Source Code for Module fife.fife

    1  # This file was automatically generated by SWIG (http://www.swig.org). 
    2  # Version 1.3.40 
    3  # 
    4  # Do not make changes to this file unless you know what you are doing--modify 
    5  # the SWIG interface file instead. 
    6  # This file is compatible with both classic and new-style classes. 
    7   
    8  from sys import version_info 
    9  if version_info >= (2,6,0): 
   10 -    def swig_import_helper(): 
   11          from os.path import dirname 
   12          import imp 
   13          fp = None 
   14          try: 
   15              fp, pathname, description = imp.find_module('_fife', [dirname(__file__)]) 
   16          except ImportError: 
   17              import _fife 
   18              return _fife 
   19          if fp is not None: 
   20              try: 
   21                  _mod = imp.load_module('_fife', fp, pathname, description) 
   22              finally: 
   23                  fp.close() 
   24              return _mod 
   25      _fife = swig_import_helper() 
   26      del swig_import_helper 
   27  else: 
   28      import _fife 
   29  del version_info 
   30  try: 
   31      _swig_property = property 
   32  except NameError: 
   33      pass # Python < 2.2 doesn't have 'property'. 
   34 -def _swig_setattr_nondynamic(self,class_type,name,value,static=1): 
   35      if (name == "thisown"): return self.this.own(value) 
   36      if (name == "this"): 
   37          if type(value).__name__ == 'SwigPyObject': 
   38              self.__dict__[name] = value 
   39              return 
   40      method = class_type.__swig_setmethods__.get(name,None) 
   41      if method: return method(self,value) 
   42      if (not static) or hasattr(self,name): 
   43          self.__dict__[name] = value 
   44      else: 
   45          raise AttributeError("You cannot add attributes to %s" % self) 
   46   
   47 -def _swig_setattr(self,class_type,name,value): 
   48      return _swig_setattr_nondynamic(self,class_type,name,value,0) 
   49   
   50 -def _swig_getattr(self,class_type,name): 
   51      if (name == "thisown"): return self.this.own() 
   52      method = class_type.__swig_getmethods__.get(name,None) 
   53      if method: return method(self) 
   54      raise AttributeError(name) 
   55   
   56 -def _swig_repr(self): 
   57      try: strthis = "proxy of " + self.this.__repr__() 
   58      except: strthis = "" 
   59      return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) 
   60   
   61  try: 
   62      _object = object 
   63      _newclass = 1 
   64  except AttributeError: 
   65 -    class _object : pass 
   66      _newclass = 0 
   67   
   68   
   69  try: 
   70      import weakref 
   71      weakref_proxy = weakref.proxy 
   72  except: 
   73      weakref_proxy = lambda x: x 
   74   
   75   
   76 -class SwigPyIterator(_object): 
   77      __swig_setmethods__ = {} 
   78      __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value) 
   79      __swig_getmethods__ = {} 
   80      __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name) 
   81 -    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") 
   82      __repr__ = _swig_repr 
   83      __swig_destroy__ = _fife.delete_SwigPyIterator 
   84      __del__ = lambda self : None; 
   85 -    def value(self): return _fife.SwigPyIterator_value(self) 
   86 -    def incr(self, n = 1): return _fife.SwigPyIterator_incr(self, n) 
   87 -    def decr(self, n = 1): return _fife.SwigPyIterator_decr(self, n) 
   88 -    def distance(self, *args): return _fife.SwigPyIterator_distance(self, *args) 
   89 -    def equal(self, *args): return _fife.SwigPyIterator_equal(self, *args) 
   90 -    def copy(self): return _fife.SwigPyIterator_copy(self) 
   91 -    def next(self): return _fife.SwigPyIterator_next(self) 
   92 -    def __next__(self): return _fife.SwigPyIterator___next__(self) 
   93 -    def previous(self): return _fife.SwigPyIterator_previous(self) 
   94 -    def advance(self, *args): return _fife.SwigPyIterator_advance(self, *args) 
   95 -    def __eq__(self, *args): return _fife.SwigPyIterator___eq__(self, *args) 
   96 -    def __ne__(self, *args): return _fife.SwigPyIterator___ne__(self, *args) 
   97 -    def __iadd__(self, *args): return _fife.SwigPyIterator___iadd__(self, *args) 
   98 -    def __isub__(self, *args): return _fife.SwigPyIterator___isub__(self, *args) 
   99 -    def __add__(self, *args): return _fife.SwigPyIterator___add__(self, *args) 
  100 -    def __sub__(self, *args): return _fife.SwigPyIterator___sub__(self, *args) 
  101 -    def __iter__(self): return self 
  102  SwigPyIterator_swigregister = _fife.SwigPyIterator_swigregister 
  103  SwigPyIterator_swigregister(SwigPyIterator) 
  104   
  105 -class StringVector(_object): 
  106      """Proxy of C++ std::vector<(std::string)> class""" 
  107      __swig_setmethods__ = {} 
  108      __setattr__ = lambda self, name, value: _swig_setattr(self, StringVector, name, value) 
  109      __swig_getmethods__ = {} 
  110      __getattr__ = lambda self, name: _swig_getattr(self, StringVector, name) 
  111      __repr__ = _swig_repr 
  112 -    def iterator(self): 
  113          """iterator(self) -> SwigPyIterator""" 
  114          return _fife.StringVector_iterator(self) 
  115   
  116 -    def __iter__(self): return self.iterator() 
  117 -    def __nonzero__(self): 
  118          """__nonzero__(self) -> bool""" 
  119          return _fife.StringVector___nonzero__(self) 
  120   
  121 -    def __bool__(self): 
  122          """__bool__(self) -> bool""" 
  123          return _fife.StringVector___bool__(self) 
  124   
  125 -    def __len__(self): 
  126          """__len__(self) -> size_type""" 
  127          return _fife.StringVector___len__(self) 
  128   
  129 -    def pop(self): 
  130          """pop(self) -> value_type""" 
  131          return _fife.StringVector_pop(self) 
  132   
  133 -    def __getslice__(self, *args): 
  134          """__getslice__(self, difference_type i, difference_type j) -> StringVector""" 
  135          return _fife.StringVector___getslice__(self, *args) 
  136   
  137 -    def __setslice__(self, *args): 
  138          """__setslice__(self, difference_type i, difference_type j, StringVector v)""" 
  139          return _fife.StringVector___setslice__(self, *args) 
  140   
  141 -    def __delslice__(self, *args): 
  142          """__delslice__(self, difference_type i, difference_type j)""" 
  143          return _fife.StringVector___delslice__(self, *args) 
  144   
  145 -    def __delitem__(self, *args): 
  146          """ 
  147          __delitem__(self, difference_type i) 
  148          __delitem__(self, PySliceObject slice) 
  149          """ 
  150          return _fife.StringVector___delitem__(self, *args) 
  151   
  152 -    def __getitem__(self, *args): 
  153          """ 
  154          __getitem__(self, PySliceObject slice) -> StringVector 
  155          __getitem__(self, difference_type i) -> value_type 
  156          """ 
  157          return _fife.StringVector___getitem__(self, *args) 
  158   
  159 -    def __setitem__(self, *args): 
  160          """ 
  161          __setitem__(self, PySliceObject slice, StringVector v) 
  162          __setitem__(self, difference_type i, value_type x) 
  163          """ 
  164          return _fife.StringVector___setitem__(self, *args) 
  165   
  166 -    def append(self, *args): 
  167          """append(self, value_type x)""" 
  168          return _fife.StringVector_append(self, *args) 
  169   
  170 -    def empty(self): 
  171          """empty(self) -> bool""" 
  172          return _fife.StringVector_empty(self) 
  173   
  174 -    def size(self): 
  175          """size(self) -> size_type""" 
  176          return _fife.StringVector_size(self) 
  177   
  178 -    def clear(self): 
  179          """clear(self)""" 
  180          return _fife.StringVector_clear(self) 
  181   
  182 -    def swap(self, *args): 
  183          """swap(self, StringVector v)""" 
  184          return _fife.StringVector_swap(self, *args) 
  185   
  186 -    def get_allocator(self): 
  187          """get_allocator(self) -> allocator_type""" 
  188          return _fife.StringVector_get_allocator(self) 
  189   
  190 -    def begin(self): 
  191          """begin(self) -> const_iterator""" 
  192          return _fife.StringVector_begin(self) 
  193   
  194 -    def end(self): 
  195          """end(self) -> const_iterator""" 
  196          return _fife.StringVector_end(self) 
  197   
  198 -    def rbegin(self): 
  199          """rbegin(self) -> const_reverse_iterator""" 
  200          return _fife.StringVector_rbegin(self) 
  201   
  202 -    def rend(self): 
  203          """rend(self) -> const_reverse_iterator""" 
  204          return _fife.StringVector_rend(self) 
  205   
  206 -    def pop_back(self): 
  207          """pop_back(self)""" 
  208          return _fife.StringVector_pop_back(self) 
  209   
  210 -    def erase(self, *args): 
  211          """ 
  212          erase(self, iterator pos) -> iterator 
  213          erase(self, iterator first, iterator last) -> iterator 
  214          """ 
  215          return _fife.StringVector_erase(self, *args) 
  216   
  217 -    def __init__(self, *args):  
  218          """ 
  219          __init__(self) -> StringVector 
  220          __init__(self, StringVector arg0) -> StringVector 
  221          __init__(self, size_type size) -> StringVector 
  222          __init__(self, size_type size, value_type value) -> StringVector 
  223          """ 
  224          this = _fife.new_StringVector(*args) 
  225          try: self.this.append(this) 
  226          except: self.this = this 
  227 -    def push_back(self, *args): 
  228          """push_back(self, value_type x)""" 
  229          return _fife.StringVector_push_back(self, *args) 
  230   
  231 -    def front(self): 
  232          """front(self) -> value_type""" 
  233          return _fife.StringVector_front(self) 
  234   
  235 -    def back(self): 
  236          """back(self) -> value_type""" 
  237          return _fife.StringVector_back(self) 
  238   
  239 -    def assign(self, *args): 
  240          """assign(self, size_type n, value_type x)""" 
  241          return _fife.StringVector_assign(self, *args) 
  242   
  243 -    def resize(self, *args): 
  244          """ 
  245          resize(self, size_type new_size) 
  246          resize(self, size_type new_size, value_type x) 
  247          """ 
  248          return _fife.StringVector_resize(self, *args) 
  249   
  250 -    def insert(self, *args): 
  251          """ 
  252          insert(self, iterator pos, value_type x) -> iterator 
  253          insert(self, iterator pos, size_type n, value_type x) 
  254          """ 
  255          return _fife.StringVector_insert(self, *args) 
  256   
  257 -    def reserve(self, *args): 
  258          """reserve(self, size_type n)""" 
  259          return _fife.StringVector_reserve(self, *args) 
  260   
  261 -    def capacity(self): 
  262          """capacity(self) -> size_type""" 
  263          return _fife.StringVector_capacity(self) 
  264   
  265      __swig_destroy__ = _fife.delete_StringVector 
  266      __del__ = lambda self : None; 
  267  StringVector_swigregister = _fife.StringVector_swigregister 
  268  StringVector_swigregister(StringVector) 
  269   
  270 -class UintVector(_object): 
  271      """Proxy of C++ std::vector<(unsigned int)> class""" 
  272      __swig_setmethods__ = {} 
  273      __setattr__ = lambda self, name, value: _swig_setattr(self, UintVector, name, value) 
  274      __swig_getmethods__ = {} 
  275      __getattr__ = lambda self, name: _swig_getattr(self, UintVector, name) 
  276      __repr__ = _swig_repr 
  277 -    def iterator(self): 
  278          """iterator(self) -> SwigPyIterator""" 
  279          return _fife.UintVector_iterator(self) 
  280   
  281 -    def __iter__(self): return self.iterator() 
  282 -    def __nonzero__(self): 
  283          """__nonzero__(self) -> bool""" 
  284          return _fife.UintVector___nonzero__(self) 
  285   
  286 -    def __bool__(self): 
  287          """__bool__(self) -> bool""" 
  288          return _fife.UintVector___bool__(self) 
  289   
  290 -    def __len__(self): 
  291          """__len__(self) -> size_type""" 
  292          return _fife.UintVector___len__(self) 
  293   
  294 -    def pop(self): 
  295          """pop(self) -> value_type""" 
  296          return _fife.UintVector_pop(self) 
  297   
  298 -    def __getslice__(self, *args): 
  299          """__getslice__(self, difference_type i, difference_type j) -> UintVector""" 
  300          return _fife.UintVector___getslice__(self, *args) 
  301   
  302 -    def __setslice__(self, *args): 
  303          """__setslice__(self, difference_type i, difference_type j, UintVector v)""" 
  304          return _fife.UintVector___setslice__(self, *args) 
  305   
  306 -    def __delslice__(self, *args): 
  307          """__delslice__(self, difference_type i, difference_type j)""" 
  308          return _fife.UintVector___delslice__(self, *args) 
  309   
  310 -    def __delitem__(self, *args): 
  311          """ 
  312          __delitem__(self, difference_type i) 
  313          __delitem__(self, PySliceObject slice) 
  314          """ 
  315          return _fife.UintVector___delitem__(self, *args) 
  316   
  317 -    def __getitem__(self, *args): 
  318          """ 
  319          __getitem__(self, PySliceObject slice) -> UintVector 
  320          __getitem__(self, difference_type i) -> value_type 
  321          """ 
  322          return _fife.UintVector___getitem__(self, *args) 
  323   
  324 -    def __setitem__(self, *args): 
  325          """ 
  326          __setitem__(self, PySliceObject slice, UintVector v) 
  327          __setitem__(self, difference_type i, value_type x) 
  328          """ 
  329          return _fife.UintVector___setitem__(self, *args) 
  330   
  331 -    def append(self, *args): 
  332          """append(self, value_type x)""" 
  333          return _fife.UintVector_append(self, *args) 
  334   
  335 -    def empty(self): 
  336          """empty(self) -> bool""" 
  337          return _fife.UintVector_empty(self) 
  338   
  339 -    def size(self): 
  340          """size(self) -> size_type""" 
  341          return _fife.UintVector_size(self) 
  342   
  343 -    def clear(self): 
  344          """clear(self)""" 
  345          return _fife.UintVector_clear(self) 
  346   
  347 -    def swap(self, *args): 
  348          """swap(self, UintVector v)""" 
  349          return _fife.UintVector_swap(self, *args) 
  350   
  351 -    def get_allocator(self): 
  352          """get_allocator(self) -> allocator_type""" 
  353          return _fife.UintVector_get_allocator(self) 
  354   
  355 -    def begin(self): 
  356          """begin(self) -> const_iterator""" 
  357          return _fife.UintVector_begin(self) 
  358   
  359 -    def end(self): 
  360          """end(self) -> const_iterator""" 
  361          return _fife.UintVector_end(self) 
  362   
  363 -    def rbegin(self): 
  364          """rbegin(self) -> const_reverse_iterator""" 
  365          return _fife.UintVector_rbegin(self) 
  366   
  367 -    def rend(self): 
  368          """rend(self) -> const_reverse_iterator""" 
  369          return _fife.UintVector_rend(self) 
  370   
  371 -    def pop_back(self): 
  372          """pop_back(self)""" 
  373          return _fife.UintVector_pop_back(self) 
  374   
  375 -    def erase(self, *args): 
  376          """ 
  377          erase(self, iterator pos) -> iterator 
  378          erase(self, iterator first, iterator last) -> iterator 
  379          """ 
  380          return _fife.UintVector_erase(self, *args) 
  381   
  382 -    def __init__(self, *args):  
  383          """ 
  384          __init__(self) -> UintVector 
  385          __init__(self, UintVector arg0) -> UintVector 
  386          __init__(self, size_type size) -> UintVector 
  387          __init__(self, size_type size, value_type value) -> UintVector 
  388          """ 
  389          this = _fife.new_UintVector(*args) 
  390          try: self.this.append(this) 
  391          except: self.this = this 
  392 -    def push_back(self, *args): 
  393          """push_back(self, value_type x)""" 
  394          return _fife.UintVector_push_back(self, *args) 
  395   
  396 -    def front(self): 
  397          """front(self) -> value_type""" 
  398          return _fife.UintVector_front(self) 
  399   
  400 -    def back(self): 
  401          """back(self) -> value_type""" 
  402          return _fife.UintVector_back(self) 
  403   
  404 -    def assign(self, *args): 
  405          """assign(self, size_type n, value_type x)""" 
  406          return _fife.UintVector_assign(self, *args) 
  407   
  408 -    def resize(self, *args): 
  409          """ 
  410          resize(self, size_type new_size) 
  411          resize(self, size_type new_size, value_type x) 
  412          """ 
  413          return _fife.UintVector_resize(self, *args) 
  414   
  415 -    def insert(self, *args): 
  416          """ 
  417          insert(self, iterator pos, value_type x) -> iterator 
  418          insert(self, iterator pos, size_type n, value_type x) 
  419          """ 
  420          return _fife.UintVector_insert(self, *args) 
  421   
  422 -    def reserve(self, *args): 
  423          """reserve(self, size_type n)""" 
  424          return _fife.UintVector_reserve(self, *args) 
  425   
  426 -    def capacity(self): 
  427          """capacity(self) -> size_type""" 
  428          return _fife.UintVector_capacity(self) 
  429   
  430      __swig_destroy__ = _fife.delete_UintVector 
  431      __del__ = lambda self : None; 
  432  UintVector_swigregister = _fife.UintVector_swigregister 
  433  UintVector_swigregister(UintVector) 
  434   
  435 -class IntVector(_object): 
  436      """Proxy of C++ std::vector<(int)> class""" 
  437      __swig_setmethods__ = {} 
  438      __setattr__ = lambda self, name, value: _swig_setattr(self, IntVector, name, value) 
  439      __swig_getmethods__ = {} 
  440      __getattr__ = lambda self, name: _swig_getattr(self, IntVector, name) 
  441      __repr__ = _swig_repr 
  442 -    def iterator(self): 
  443          """iterator(self) -> SwigPyIterator""" 
  444          return _fife.IntVector_iterator(self) 
  445   
  446 -    def __iter__(self): return self.iterator() 
  447 -    def __nonzero__(self): 
  448          """__nonzero__(self) -> bool""" 
  449          return _fife.IntVector___nonzero__(self) 
  450   
  451 -    def __bool__(self): 
  452          """__bool__(self) -> bool""" 
  453          return _fife.IntVector___bool__(self) 
  454   
  455 -    def __len__(self): 
  456          """__len__(self) -> size_type""" 
  457          return _fife.IntVector___len__(self) 
  458   
  459 -    def pop(self): 
  460          """pop(self) -> value_type""" 
  461          return _fife.IntVector_pop(self) 
  462   
  463 -    def __getslice__(self, *args): 
  464          """__getslice__(self, difference_type i, difference_type j) -> IntVector""" 
  465          return _fife.IntVector___getslice__(self, *args) 
  466   
  467 -    def __setslice__(self, *args): 
  468          """__setslice__(self, difference_type i, difference_type j, IntVector v)""" 
  469          return _fife.IntVector___setslice__(self, *args) 
  470   
  471 -    def __delslice__(self, *args): 
  472          """__delslice__(self, difference_type i, difference_type j)""" 
  473          return _fife.IntVector___delslice__(self, *args) 
  474   
  475 -    def __delitem__(self, *args): 
  476          """ 
  477          __delitem__(self, difference_type i) 
  478          __delitem__(self, PySliceObject slice) 
  479          """ 
  480          return _fife.IntVector___delitem__(self, *args) 
  481   
  482 -    def __getitem__(self, *args): 
  483          """ 
  484          __getitem__(self, PySliceObject slice) -> IntVector 
  485          __getitem__(self, difference_type i) -> value_type 
  486          """ 
  487          return _fife.IntVector___getitem__(self, *args) 
  488   
  489 -    def __setitem__(self, *args): 
  490          """ 
  491          __setitem__(self, PySliceObject slice, IntVector v) 
  492          __setitem__(self, difference_type i, value_type x) 
  493          """ 
  494          return _fife.IntVector___setitem__(self, *args) 
  495   
  496 -    def append(self, *args): 
  497          """append(self, value_type x)""" 
  498          return _fife.IntVector_append(self, *args) 
  499   
  500 -    def empty(self): 
  501          """empty(self) -> bool""" 
  502          return _fife.IntVector_empty(self) 
  503   
  504 -    def size(self): 
  505          """size(self) -> size_type""" 
  506          return _fife.IntVector_size(self) 
  507   
  508 -    def clear(self): 
  509          """clear(self)""" 
  510          return _fife.IntVector_clear(self) 
  511   
  512 -    def swap(self, *args): 
  513          """swap(self, IntVector v)""" 
  514          return _fife.IntVector_swap(self, *args) 
  515   
  516 -    def get_allocator(self): 
  517          """get_allocator(self) -> allocator_type""" 
  518          return _fife.IntVector_get_allocator(self) 
  519   
  520 -    def begin(self): 
  521          """begin(self) -> const_iterator""" 
  522          return _fife.IntVector_begin(self) 
  523   
  524 -    def end(self): 
  525          """end(self) -> const_iterator""" 
  526          return _fife.IntVector_end(self) 
  527   
  528 -    def rbegin(self): 
  529          """rbegin(self) -> const_reverse_iterator""" 
  530          return _fife.IntVector_rbegin(self) 
  531   
  532 -    def rend(self): 
  533          """rend(self) -> const_reverse_iterator""" 
  534          return _fife.IntVector_rend(self) 
  535   
  536 -    def pop_back(self): 
  537          """pop_back(self)""" 
  538          return _fife.IntVector_pop_back(self) 
  539   
  540 -    def erase(self, *args): 
  541          """ 
  542          erase(self, iterator pos) -> iterator 
  543          erase(self, iterator first, iterator last) -> iterator 
  544          """ 
  545          return _fife.IntVector_erase(self, *args) 
  546   
  547 -    def __init__(self, *args):  
  548          """ 
  549          __init__(self) -> IntVector 
  550          __init__(self, IntVector arg0) -> IntVector 
  551          __init__(self, size_type size) -> IntVector 
  552          __init__(self, size_type size, value_type value) -> IntVector 
  553          """ 
  554          this = _fife.new_IntVector(*args) 
  555          try: self.this.append(this) 
  556          except: self.this = this 
  557 -    def push_back(self, *args): 
  558          """push_back(self, value_type x)""" 
  559          return _fife.IntVector_push_back(self, *args) 
  560   
  561 -    def front(self): 
  562          """front(self) -> value_type""" 
  563          return _fife.IntVector_front(self) 
  564   
  565 -    def back(self): 
  566          """back(self) -> value_type""" 
  567          return _fife.IntVector_back(self) 
  568   
  569 -    def assign(self, *args): 
  570          """assign(self, size_type n, value_type x)""" 
  571          return _fife.IntVector_assign(self, *args) 
  572   
  573 -    def resize(self, *args): 
  574          """ 
  575          resize(self, size_type new_size) 
  576          resize(self, size_type new_size, value_type x) 
  577          """ 
  578          return _fife.IntVector_resize(self, *args) 
  579   
  580 -    def insert(self, *args): 
  581          """ 
  582          insert(self, iterator pos, value_type x) -> iterator 
  583          insert(self, iterator pos, size_type n, value_type x) 
  584          """ 
  585          return _fife.IntVector_insert(self, *args) 
  586   
  587 -    def reserve(self, *args): 
  588          """reserve(self, size_type n)""" 
  589          return _fife.IntVector_reserve(self, *args) 
  590   
  591 -    def capacity(self): 
  592          """capacity(self) -> size_type""" 
  593          return _fife.IntVector_capacity(self) 
  594   
  595      __swig_destroy__ = _fife.delete_IntVector 
  596      __del__ = lambda self : None; 
  597  IntVector_swigregister = _fife.IntVector_swigregister 
  598  IntVector_swigregister(IntVector) 
  599   
  600 -class FloatVector(_object): 
  601      """Proxy of C++ std::vector<(float)> class""" 
  602      __swig_setmethods__ = {} 
  603      __setattr__ = lambda self, name, value: _swig_setattr(self, FloatVector, name, value) 
  604      __swig_getmethods__ = {} 
  605      __getattr__ = lambda self, name: _swig_getattr(self, FloatVector, name) 
  606      __repr__ = _swig_repr 
  607 -    def iterator(self): 
  608          """iterator(self) -> SwigPyIterator""" 
  609          return _fife.FloatVector_iterator(self) 
  610   
  611 -    def __iter__(self): return self.iterator() 
  612 -    def __nonzero__(self): 
  613          """__nonzero__(self) -> bool""" 
  614          return _fife.FloatVector___nonzero__(self) 
  615   
  616 -    def __bool__(self): 
  617          """__bool__(self) -> bool""" 
  618          return _fife.FloatVector___bool__(self) 
  619   
  620 -    def __len__(self): 
  621          """__len__(self) -> size_type""" 
  622          return _fife.FloatVector___len__(self) 
  623   
  624 -    def pop(self): 
  625          """pop(self) -> value_type""" 
  626          return _fife.FloatVector_pop(self) 
  627   
  628 -    def __getslice__(self, *args): 
  629          """__getslice__(self, difference_type i, difference_type j) -> FloatVector""" 
  630          return _fife.FloatVector___getslice__(self, *args) 
  631   
  632 -    def __setslice__(self, *args): 
  633          """__setslice__(self, difference_type i, difference_type j, FloatVector v)""" 
  634          return _fife.FloatVector___setslice__(self, *args) 
  635   
  636 -    def __delslice__(self, *args): 
  637          """__delslice__(self, difference_type i, difference_type j)""" 
  638          return _fife.FloatVector___delslice__(self, *args) 
  639   
  640 -    def __delitem__(self, *args): 
  641          """ 
  642          __delitem__(self, difference_type i) 
  643          __delitem__(self, PySliceObject slice) 
  644          """ 
  645          return _fife.FloatVector___delitem__(self, *args) 
  646   
  647 -    def __getitem__(self, *args): 
  648          """ 
  649          __getitem__(self, PySliceObject slice) -> FloatVector 
  650          __getitem__(self, difference_type i) -> value_type 
  651          """ 
  652          return _fife.FloatVector___getitem__(self, *args) 
  653   
  654 -    def __setitem__(self, *args): 
  655          """ 
  656          __setitem__(self, PySliceObject slice, FloatVector v) 
  657          __setitem__(self, difference_type i, value_type x) 
  658          """ 
  659          return _fife.FloatVector___setitem__(self, *args) 
  660   
  661 -    def append(self, *args): 
  662          """append(self, value_type x)""" 
  663          return _fife.FloatVector_append(self, *args) 
  664   
  665 -    def empty(self): 
  666          """empty(self) -> bool""" 
  667          return _fife.FloatVector_empty(self) 
  668   
  669 -    def size(self): 
  670          """size(self) -> size_type""" 
  671          return _fife.FloatVector_size(self) 
  672   
  673 -    def clear(self): 
  674          """clear(self)""" 
  675          return _fife.FloatVector_clear(self) 
  676   
  677 -    def swap(self, *args): 
  678          """swap(self, FloatVector v)""" 
  679          return _fife.FloatVector_swap(self, *args) 
  680   
  681 -    def get_allocator(self): 
  682          """get_allocator(self) -> allocator_type""" 
  683          return _fife.FloatVector_get_allocator(self) 
  684   
  685 -    def begin(self): 
  686          """begin(self) -> const_iterator""" 
  687          return _fife.FloatVector_begin(self) 
  688   
  689 -    def end(self): 
  690          """end(self) -> const_iterator""" 
  691          return _fife.FloatVector_end(self) 
  692   
  693 -    def rbegin(self): 
  694          """rbegin(self) -> const_reverse_iterator""" 
  695          return _fife.FloatVector_rbegin(self) 
  696   
  697 -    def rend(self): 
  698          """rend(self) -> const_reverse_iterator""" 
  699          return _fife.FloatVector_rend(self) 
  700   
  701 -    def pop_back(self): 
  702          """pop_back(self)""" 
  703          return _fife.FloatVector_pop_back(self) 
  704   
  705 -    def erase(self, *args): 
  706          """ 
  707          erase(self, iterator pos) -> iterator 
  708          erase(self, iterator first, iterator last) -> iterator 
  709          """ 
  710          return _fife.FloatVector_erase(self, *args) 
  711   
  712 -    def __init__(self, *args):  
  713          """ 
  714          __init__(self) -> FloatVector 
  715          __init__(self, FloatVector arg0) -> FloatVector 
  716          __init__(self, size_type size) -> FloatVector 
  717          __init__(self, size_type size, value_type value) -> FloatVector 
  718          """ 
  719          this = _fife.new_FloatVector(*args) 
  720          try: self.this.append(this) 
  721          except: self.this = this 
  722 -    def push_back(self, *args): 
  723          """push_back(self, value_type x)""" 
  724          return _fife.FloatVector_push_back(self, *args) 
  725   
  726 -    def front(self): 
  727          """front(self) -> value_type""" 
  728          return _fife.FloatVector_front(self) 
  729   
  730 -    def back(self): 
  731          """back(self) -> value_type""" 
  732          return _fife.FloatVector_back(self) 
  733   
  734 -    def assign(self, *args): 
  735          """assign(self, size_type n, value_type x)""" 
  736          return _fife.FloatVector_assign(self, *args) 
  737   
  738 -    def resize(self, *args): 
  739          """ 
  740          resize(self, size_type new_size) 
  741          resize(self, size_type new_size, value_type x) 
  742          """ 
  743          return _fife.FloatVector_resize(self, *args) 
  744   
  745 -    def insert(self, *args): 
  746          """ 
  747          insert(self, iterator pos, value_type x) -> iterator 
  748          insert(self, iterator pos, size_type n, value_type x) 
  749          """ 
  750          return _fife.FloatVector_insert(self, *args) 
  751   
  752 -    def reserve(self, *args): 
  753          """reserve(self, size_type n)""" 
  754          return _fife.FloatVector_reserve(self, *args) 
  755   
  756 -    def capacity(self): 
  757          """capacity(self) -> size_type""" 
  758          return _fife.FloatVector_capacity(self) 
  759   
  760      __swig_destroy__ = _fife.delete_FloatVector 
  761      __del__ = lambda self : None; 
  762  FloatVector_swigregister = _fife.FloatVector_swigregister 
  763  FloatVector_swigregister(FloatVector) 
  764   
  765 -class DoubleVector(_object): 
  766      """Proxy of C++ std::vector<(double)> class""" 
  767      __swig_setmethods__ = {} 
  768      __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleVector, name, value) 
  769      __swig_getmethods__ = {} 
  770      __getattr__ = lambda self, name: _swig_getattr(self, DoubleVector, name) 
  771      __repr__ = _swig_repr 
  772 -    def iterator(self): 
  773          """iterator(self) -> SwigPyIterator""" 
  774          return _fife.DoubleVector_iterator(self) 
  775   
  776 -    def __iter__(self): return self.iterator() 
  777 -    def __nonzero__(self): 
  778          """__nonzero__(self) -> bool""" 
  779          return _fife.DoubleVector___nonzero__(self) 
  780   
  781 -    def __bool__(self): 
  782          """__bool__(self) -> bool""" 
  783          return _fife.DoubleVector___bool__(self) 
  784   
  785 -    def __len__(self): 
  786          """__len__(self) -> size_type""" 
  787          return _fife.DoubleVector___len__(self) 
  788   
  789 -    def pop(self): 
  790          """pop(self) -> value_type""" 
  791          return _fife.DoubleVector_pop(self) 
  792   
  793 -    def __getslice__(self, *args): 
  794          """__getslice__(self, difference_type i, difference_type j) -> DoubleVector""" 
  795          return _fife.DoubleVector___getslice__(self, *args) 
  796   
  797 -    def __setslice__(self, *args): 
  798          """__setslice__(self, difference_type i, difference_type j, DoubleVector v)""" 
  799          return _fife.DoubleVector___setslice__(self, *args) 
  800   
  801 -    def __delslice__(self, *args): 
  802          """__delslice__(self, difference_type i, difference_type j)""" 
  803          return _fife.DoubleVector___delslice__(self, *args) 
  804   
  805 -    def __delitem__(self, *args): 
  806          """ 
  807          __delitem__(self, difference_type i) 
  808          __delitem__(self, PySliceObject slice) 
  809          """ 
  810          return _fife.DoubleVector___delitem__(self, *args) 
  811   
  812 -    def __getitem__(self, *args): 
  813          """ 
  814          __getitem__(self, PySliceObject slice) -> DoubleVector 
  815          __getitem__(self, difference_type i) -> value_type 
  816          """ 
  817          return _fife.DoubleVector___getitem__(self, *args) 
  818   
  819 -    def __setitem__(self, *args): 
  820          """ 
  821          __setitem__(self, PySliceObject slice, DoubleVector v) 
  822          __setitem__(self, difference_type i, value_type x) 
  823          """ 
  824          return _fife.DoubleVector___setitem__(self, *args) 
  825   
  826 -    def append(self, *args): 
  827          """append(self, value_type x)""" 
  828          return _fife.DoubleVector_append(self, *args) 
  829   
  830 -    def empty(self): 
  831          """empty(self) -> bool""" 
  832          return _fife.DoubleVector_empty(self) 
  833   
  834 -    def size(self): 
  835          """size(self) -> size_type""" 
  836          return _fife.DoubleVector_size(self) 
  837   
  838 -    def clear(self): 
  839          """clear(self)""" 
  840          return _fife.DoubleVector_clear(self) 
  841   
  842 -    def swap(self, *args): 
  843          """swap(self, DoubleVector v)""" 
  844          return _fife.DoubleVector_swap(self, *args) 
  845   
  846 -    def get_allocator(self): 
  847          """get_allocator(self) -> allocator_type""" 
  848          return _fife.DoubleVector_get_allocator(self) 
  849   
  850 -    def begin(self): 
  851          """begin(self) -> const_iterator""" 
  852          return _fife.DoubleVector_begin(self) 
  853   
  854 -    def end(self): 
  855          """end(self) -> const_iterator""" 
  856          return _fife.DoubleVector_end(self) 
  857   
  858 -    def rbegin(self): 
  859          """rbegin(self) -> const_reverse_iterator""" 
  860          return _fife.DoubleVector_rbegin(self) 
  861   
  862 -    def rend(self): 
  863          """rend(self) -> const_reverse_iterator""" 
  864          return _fife.DoubleVector_rend(self) 
  865   
  866 -    def pop_back(self): 
  867          """pop_back(self)""" 
  868          return _fife.DoubleVector_pop_back(self) 
  869   
  870 -    def erase(self, *args): 
  871          """ 
  872          erase(self, iterator pos) -> iterator 
  873          erase(self, iterator first, iterator last) -> iterator 
  874          """ 
  875          return _fife.DoubleVector_erase(self, *args) 
  876   
  877 -    def __init__(self, *args):  
  878          """ 
  879          __init__(self) -> DoubleVector 
  880          __init__(self, DoubleVector arg0) -> DoubleVector 
  881          __init__(self, size_type size) -> DoubleVector 
  882          __init__(self, size_type size, value_type value) -> DoubleVector 
  883          """ 
  884          this = _fife.new_DoubleVector(*args) 
  885          try: self.this.append(this) 
  886          except: self.this = this 
  887 -    def push_back(self, *args): 
  888          """push_back(self, value_type x)""" 
  889          return _fife.DoubleVector_push_back(self, *args) 
  890   
  891 -    def front(self): 
  892          """front(self) -> value_type""" 
  893          return _fife.DoubleVector_front(self) 
  894   
  895 -    def back(self): 
  896          """back(self) -> value_type""" 
  897          return _fife.DoubleVector_back(self) 
  898   
  899 -    def assign(self, *args): 
  900          """assign(self, size_type n, value_type x)""" 
  901          return _fife.DoubleVector_assign(self, *args) 
  902   
  903 -    def resize(self, *args): 
  904          """ 
  905          resize(self, size_type new_size) 
  906          resize(self, size_type new_size, value_type x) 
  907          """ 
  908          return _fife.DoubleVector_resize(self, *args) 
  909   
  910 -    def insert(self, *args): 
  911          """ 
  912          insert(self, iterator pos, value_type x) -> iterator 
  913          insert(self, iterator pos, size_type n, value_type x) 
  914          """ 
  915          return _fife.DoubleVector_insert(self, *args) 
  916   
  917 -    def reserve(self, *args): 
  918          """reserve(self, size_type n)""" 
  919          return _fife.DoubleVector_reserve(self, *args) 
  920   
  921 -    def capacity(self): 
  922          """capacity(self) -> size_type""" 
  923          return _fife.DoubleVector_capacity(self) 
  924   
  925      __swig_destroy__ = _fife.delete_DoubleVector 
  926      __del__ = lambda self : None; 
  927  DoubleVector_swigregister = _fife.DoubleVector_swigregister 
  928  DoubleVector_swigregister(DoubleVector) 
  929   
  930 -class BoolVector(_object): 
  931      """Proxy of C++ std::vector<(bool)> class""" 
  932      __swig_setmethods__ = {} 
  933      __setattr__ = lambda self, name, value: _swig_setattr(self, BoolVector, name, value) 
  934      __swig_getmethods__ = {} 
  935      __getattr__ = lambda self, name: _swig_getattr(self, BoolVector, name) 
  936      __repr__ = _swig_repr 
  937 -    def iterator(self): 
  938          """iterator(self) -> SwigPyIterator""" 
  939          return _fife.BoolVector_iterator(self) 
  940   
  941 -    def __iter__(self): return self.iterator() 
  942 -    def __nonzero__(self): 
  943          """__nonzero__(self) -> bool""" 
  944          return _fife.BoolVector___nonzero__(self) 
  945   
  946 -    def __bool__(self): 
  947          """__bool__(self) -> bool""" 
  948          return _fife.BoolVector___bool__(self) 
  949   
  950 -    def __len__(self): 
  951          """__len__(self) -> size_type""" 
  952          return _fife.BoolVector___len__(self) 
  953   
  954 -    def pop(self): 
  955          """pop(self) -> value_type""" 
  956          return _fife.BoolVector_pop(self) 
  957   
  958 -    def __getslice__(self, *args): 
  959          """__getslice__(self, difference_type i, difference_type j) -> BoolVector""" 
  960          return _fife.BoolVector___getslice__(self, *args) 
  961   
  962 -    def __setslice__(self, *args): 
  963          """__setslice__(self, difference_type i, difference_type j, BoolVector v)""" 
  964          return _fife.BoolVector___setslice__(self, *args) 
  965   
  966 -    def __delslice__(self, *args): 
  967          """__delslice__(self, difference_type i, difference_type j)""" 
  968          return _fife.BoolVector___delslice__(self, *args) 
  969   
  970 -    def __delitem__(self, *args): 
  971          """ 
  972          __delitem__(self, difference_type i) 
  973          __delitem__(self, PySliceObject slice) 
  974          """ 
  975          return _fife.BoolVector___delitem__(self, *args) 
  976   
  977 -    def __getitem__(self, *args): 
  978          """ 
  979          __getitem__(self, PySliceObject slice) -> BoolVector 
  980          __getitem__(self, difference_type i) -> value_type 
  981          """ 
  982          return _fife.BoolVector___getitem__(self, *args) 
  983   
  984 -    def __setitem__(self, *args): 
  985          """ 
  986          __setitem__(self, PySliceObject slice, BoolVector v) 
  987          __setitem__(self, difference_type i, value_type x) 
  988          """ 
  989          return _fife.BoolVector___setitem__(self, *args) 
  990   
  991 -    def append(self, *args): 
  992          """append(self, value_type x)""" 
  993          return _fife.BoolVector_append(self, *args) 
  994   
  995 -    def empty(self): 
  996          """empty(self) -> bool""" 
  997          return _fife.BoolVector_empty(self) 
  998   
  999 -    def size(self): 
 1000          """size(self) -> size_type""" 
 1001          return _fife.BoolVector_size(self) 
 1002   
 1003 -    def clear(self): 
 1004          """clear(self)""" 
 1005          return _fife.BoolVector_clear(self) 
 1006   
 1007 -    def swap(self, *args): 
 1008          """swap(self, BoolVector v)""" 
 1009          return _fife.BoolVector_swap(self, *args) 
 1010   
 1011 -    def get_allocator(self): 
 1012          """get_allocator(self) -> allocator_type""" 
 1013          return _fife.BoolVector_get_allocator(self) 
 1014   
 1015 -    def begin(self): 
 1016          """begin(self) -> const_iterator""" 
 1017          return _fife.BoolVector_begin(self) 
 1018   
 1019 -    def end(self): 
 1020          """end(self) -> const_iterator""" 
 1021          return _fife.BoolVector_end(self) 
 1022   
 1023 -    def rbegin(self): 
 1024          """rbegin(self) -> const_reverse_iterator""" 
 1025          return _fife.BoolVector_rbegin(self) 
 1026   
 1027 -    def rend(self): 
 1028          """rend(self) -> const_reverse_iterator""" 
 1029          return _fife.BoolVector_rend(self) 
 1030   
 1031 -    def pop_back(self): 
 1032          """pop_back(self)""" 
 1033          return _fife.BoolVector_pop_back(self) 
 1034   
 1035 -    def erase(self, *args): 
 1036          """ 
 1037          erase(self, iterator pos) -> iterator 
 1038          erase(self, iterator first, iterator last) -> iterator 
 1039          """ 
 1040          return _fife.BoolVector_erase(self, *args) 
 1041   
 1042 -    def __init__(self, *args):  
 1043          """ 
 1044          __init__(self) -> BoolVector 
 1045          __init__(self, BoolVector arg0) -> BoolVector 
 1046          __init__(self, size_type size) -> BoolVector 
 1047          __init__(self, size_type size, value_type value) -> BoolVector 
 1048          """ 
 1049          this = _fife.new_BoolVector(*args) 
 1050          try: self.this.append(this) 
 1051          except: self.this = this 
 1052 -    def push_back(self, *args): 
 1053          """push_back(self, value_type x)""" 
 1054          return _fife.BoolVector_push_back(self, *args) 
 1055   
 1056 -    def front(self): 
 1057          """front(self) -> value_type""" 
 1058          return _fife.BoolVector_front(self) 
 1059   
 1060 -    def back(self): 
 1061          """back(self) -> value_type""" 
 1062          return _fife.BoolVector_back(self) 
 1063   
 1064 -    def assign(self, *args): 
 1065          """assign(self, size_type n, value_type x)""" 
 1066          return _fife.BoolVector_assign(self, *args) 
 1067   
 1068 -    def resize(self, *args): 
 1069          """ 
 1070          resize(self, size_type new_size) 
 1071          resize(self, size_type new_size, value_type x) 
 1072          """ 
 1073          return _fife.BoolVector_resize(self, *args) 
 1074   
 1075 -    def insert(self, *args): 
 1076          """ 
 1077          insert(self, iterator pos, value_type x) -> iterator 
 1078          insert(self, iterator pos, size_type n, value_type x) 
 1079          """ 
 1080          return _fife.BoolVector_insert(self, *args) 
 1081   
 1082 -    def reserve(self, *args): 
 1083          """reserve(self, size_type n)""" 
 1084          return _fife.BoolVector_reserve(self, *args) 
 1085   
 1086 -    def capacity(self): 
 1087          """capacity(self) -> size_type""" 
 1088          return _fife.BoolVector_capacity(self) 
 1089   
 1090      __swig_destroy__ = _fife.delete_BoolVector 
 1091      __del__ = lambda self : None; 
 1092  BoolVector_swigregister = _fife.BoolVector_swigregister 
 1093  BoolVector_swigregister(BoolVector) 
 1094   
 1095 -class Uint16Uint16Pair(_object): 
 1096      """Proxy of C++ std::pair<(uint16_t,uint16_t)> class""" 
 1097      __swig_setmethods__ = {} 
 1098      __setattr__ = lambda self, name, value: _swig_setattr(self, Uint16Uint16Pair, name, value) 
 1099      __swig_getmethods__ = {} 
 1100      __getattr__ = lambda self, name: _swig_getattr(self, Uint16Uint16Pair, name) 
 1101      __repr__ = _swig_repr 
 1102 -    def __init__(self, *args):  
 1103          """ 
 1104          __init__(self) -> Uint16Uint16Pair 
 1105          __init__(self, unsigned short first, unsigned short second) -> Uint16Uint16Pair 
 1106          __init__(self, Uint16Uint16Pair p) -> Uint16Uint16Pair 
 1107          """ 
 1108          this = _fife.new_Uint16Uint16Pair(*args) 
 1109          try: self.this.append(this) 
 1110          except: self.this = this 
 1111      __swig_setmethods__["first"] = _fife.Uint16Uint16Pair_first_set 
 1112      __swig_getmethods__["first"] = _fife.Uint16Uint16Pair_first_get 
 1113      if _newclass:first = _swig_property(_fife.Uint16Uint16Pair_first_get, _fife.Uint16Uint16Pair_first_set) 
 1114      __swig_setmethods__["second"] = _fife.Uint16Uint16Pair_second_set 
 1115      __swig_getmethods__["second"] = _fife.Uint16Uint16Pair_second_get 
 1116      if _newclass:second = _swig_property(_fife.Uint16Uint16Pair_second_get, _fife.Uint16Uint16Pair_second_set) 
 1117 -    def __len__(self): return 2 
 1118 -    def __repr__(self): return str((self.first, self.second)) 
 1119 -    def __getitem__(self, index):  
 1120        if not (index % 2):  
 1121          return self.first 
 1122        else: 
 1123          return self.second 
 1124 -    def __setitem__(self, index, val): 
 1125        if not (index % 2):  
 1126          self.first = val 
 1127        else: 
 1128          self.second = val 
 1129      __swig_destroy__ = _fife.delete_Uint16Uint16Pair 
 1130      __del__ = lambda self : None; 
 1131  Uint16Uint16Pair_swigregister = _fife.Uint16Uint16Pair_swigregister 
 1132  Uint16Uint16Pair_swigregister(Uint16Uint16Pair) 
 1133   
 1134 -class Uint16Uint16PairVector(_object): 
 1135      """Proxy of C++ std::vector<(std::pair<(uint16_t,uint16_t)>)> class""" 
 1136      __swig_setmethods__ = {} 
 1137      __setattr__ = lambda self, name, value: _swig_setattr(self, Uint16Uint16PairVector, name, value) 
 1138      __swig_getmethods__ = {} 
 1139      __getattr__ = lambda self, name: _swig_getattr(self, Uint16Uint16PairVector, name) 
 1140      __repr__ = _swig_repr 
 1141 -    def iterator(self): 
 1142          """iterator(self) -> SwigPyIterator""" 
 1143          return _fife.Uint16Uint16PairVector_iterator(self) 
 1144   
 1145 -    def __iter__(self): return self.iterator() 
 1146 -    def __nonzero__(self): 
 1147          """__nonzero__(self) -> bool""" 
 1148          return _fife.Uint16Uint16PairVector___nonzero__(self) 
 1149   
 1150 -    def __bool__(self): 
 1151          """__bool__(self) -> bool""" 
 1152          return _fife.Uint16Uint16PairVector___bool__(self) 
 1153   
 1154 -    def __len__(self): 
 1155          """__len__(self) -> std::vector<(std::pair<(unsigned short,unsigned short)>)>::size_type""" 
 1156          return _fife.Uint16Uint16PairVector___len__(self) 
 1157   
 1158 -    def pop(self): 
 1159          """pop(self) -> std::vector<(std::pair<(unsigned short,unsigned short)>)>::value_type""" 
 1160          return _fife.Uint16Uint16PairVector_pop(self) 
 1161   
 1162 -    def __getslice__(self, *args): 
 1163          """ 
 1164          __getslice__(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::difference_type i,  
 1165              std::vector<(std::pair<(unsigned short,unsigned short)>)>::difference_type j) -> Uint16Uint16PairVector 
 1166          """ 
 1167          return _fife.Uint16Uint16PairVector___getslice__(self, *args) 
 1168   
 1169 -    def __setslice__(self, *args): 
 1170          """ 
 1171          __setslice__(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::difference_type i,  
 1172              std::vector<(std::pair<(unsigned short,unsigned short)>)>::difference_type j,  
 1173              Uint16Uint16PairVector v) 
 1174          """ 
 1175          return _fife.Uint16Uint16PairVector___setslice__(self, *args) 
 1176   
 1177 -    def __delslice__(self, *args): 
 1178          """ 
 1179          __delslice__(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::difference_type i,  
 1180              std::vector<(std::pair<(unsigned short,unsigned short)>)>::difference_type j) 
 1181          """ 
 1182          return _fife.Uint16Uint16PairVector___delslice__(self, *args) 
 1183   
 1184 -    def __delitem__(self, *args): 
 1185          """ 
 1186          __delitem__(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::difference_type i) 
 1187          __delitem__(self, PySliceObject slice) 
 1188          """ 
 1189          return _fife.Uint16Uint16PairVector___delitem__(self, *args) 
 1190   
 1191 -    def __getitem__(self, *args): 
 1192          """ 
 1193          __getitem__(self, PySliceObject slice) -> Uint16Uint16PairVector 
 1194          __getitem__(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::difference_type i) -> std::vector<(std::pair<(unsigned short,unsigned short)>)>::value_type 
 1195          """ 
 1196          return _fife.Uint16Uint16PairVector___getitem__(self, *args) 
 1197   
 1198 -    def __setitem__(self, *args): 
 1199          """ 
 1200          __setitem__(self, PySliceObject slice, Uint16Uint16PairVector v) 
 1201          __setitem__(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::difference_type i,  
 1202              std::vector<(std::pair<(unsigned short,unsigned short)>)>::value_type x) 
 1203          """ 
 1204          return _fife.Uint16Uint16PairVector___setitem__(self, *args) 
 1205   
 1206 -    def append(self, *args): 
 1207          """append(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::value_type x)""" 
 1208          return _fife.Uint16Uint16PairVector_append(self, *args) 
 1209   
 1210 -    def empty(self): 
 1211          """empty(self) -> bool""" 
 1212          return _fife.Uint16Uint16PairVector_empty(self) 
 1213   
 1214 -    def size(self): 
 1215          """size(self) -> std::vector<(std::pair<(unsigned short,unsigned short)>)>::size_type""" 
 1216          return _fife.Uint16Uint16PairVector_size(self) 
 1217   
 1218 -    def clear(self): 
 1219          """clear(self)""" 
 1220          return _fife.Uint16Uint16PairVector_clear(self) 
 1221   
 1222 -    def swap(self, *args): 
 1223          """swap(self, Uint16Uint16PairVector v)""" 
 1224          return _fife.Uint16Uint16PairVector_swap(self, *args) 
 1225   
 1226 -    def get_allocator(self): 
 1227          """get_allocator(self) -> std::vector<(std::pair<(unsigned short,unsigned short)>)>::allocator_type""" 
 1228          return _fife.Uint16Uint16PairVector_get_allocator(self) 
 1229   
 1230 -    def begin(self): 
 1231          """begin(self) -> std::vector<(std::pair<(unsigned short,unsigned short)>)>::const_iterator""" 
 1232          return _fife.Uint16Uint16PairVector_begin(self) 
 1233   
 1234 -    def end(self): 
 1235          """end(self) -> std::vector<(std::pair<(unsigned short,unsigned short)>)>::const_iterator""" 
 1236          return _fife.Uint16Uint16PairVector_end(self) 
 1237   
 1238 -    def rbegin(self): 
 1239          """rbegin(self) -> std::vector<(std::pair<(unsigned short,unsigned short)>)>::const_reverse_iterator""" 
 1240          return _fife.Uint16Uint16PairVector_rbegin(self) 
 1241   
 1242 -    def rend(self): 
 1243          """rend(self) -> std::vector<(std::pair<(unsigned short,unsigned short)>)>::const_reverse_iterator""" 
 1244          return _fife.Uint16Uint16PairVector_rend(self) 
 1245   
 1246 -    def pop_back(self): 
 1247          """pop_back(self)""" 
 1248          return _fife.Uint16Uint16PairVector_pop_back(self) 
 1249   
 1250 -    def erase(self, *args): 
 1251          """ 
 1252          erase(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::iterator pos) -> std::vector<(std::pair<(unsigned short,unsigned short)>)>::iterator 
 1253          erase(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::iterator first,  
 1254              std::vector<(std::pair<(unsigned short,unsigned short)>)>::iterator last) -> std::vector<(std::pair<(unsigned short,unsigned short)>)>::iterator 
 1255          """ 
 1256          return _fife.Uint16Uint16PairVector_erase(self, *args) 
 1257   
 1258 -    def __init__(self, *args):  
 1259          """ 
 1260          __init__(self) -> Uint16Uint16PairVector 
 1261          __init__(self, Uint16Uint16PairVector arg0) -> Uint16Uint16PairVector 
 1262          __init__(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::size_type size) -> Uint16Uint16PairVector 
 1263          __init__(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::size_type size,  
 1264              std::vector<(std::pair<(unsigned short,unsigned short)>)>::value_type value) -> Uint16Uint16PairVector 
 1265          """ 
 1266          this = _fife.new_Uint16Uint16PairVector(*args) 
 1267          try: self.this.append(this) 
 1268          except: self.this = this 
 1269 -    def push_back(self, *args): 
 1270          """push_back(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::value_type x)""" 
 1271          return _fife.Uint16Uint16PairVector_push_back(self, *args) 
 1272   
 1273 -    def front(self): 
 1274          """front(self) -> std::vector<(std::pair<(unsigned short,unsigned short)>)>::value_type""" 
 1275          return _fife.Uint16Uint16PairVector_front(self) 
 1276   
 1277 -    def back(self): 
 1278          """back(self) -> std::vector<(std::pair<(unsigned short,unsigned short)>)>::value_type""" 
 1279          return _fife.Uint16Uint16PairVector_back(self) 
 1280   
 1281 -    def assign(self, *args): 
 1282          """ 
 1283          assign(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::size_type n,  
 1284              std::vector<(std::pair<(unsigned short,unsigned short)>)>::value_type x) 
 1285          """ 
 1286          return _fife.Uint16Uint16PairVector_assign(self, *args) 
 1287   
 1288 -    def resize(self, *args): 
 1289          """ 
 1290          resize(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::size_type new_size) 
 1291          resize(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::size_type new_size,  
 1292              std::vector<(std::pair<(unsigned short,unsigned short)>)>::value_type x) 
 1293          """ 
 1294          return _fife.Uint16Uint16PairVector_resize(self, *args) 
 1295   
 1296 -    def insert(self, *args): 
 1297          """ 
 1298          insert(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::iterator pos,  
 1299              std::vector<(std::pair<(unsigned short,unsigned short)>)>::value_type x) -> std::vector<(std::pair<(unsigned short,unsigned short)>)>::iterator 
 1300          insert(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::iterator pos,  
 1301              std::vector<(std::pair<(unsigned short,unsigned short)>)>::size_type n,  
 1302              std::vector<(std::pair<(unsigned short,unsigned short)>)>::value_type x) 
 1303          """ 
 1304          return _fife.Uint16Uint16PairVector_insert(self, *args) 
 1305   
 1306 -    def reserve(self, *args): 
 1307          """reserve(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::size_type n)""" 
 1308          return _fife.Uint16Uint16PairVector_reserve(self, *args) 
 1309   
 1310 -    def capacity(self): 
 1311          """capacity(self) -> std::vector<(std::pair<(unsigned short,unsigned short)>)>::size_type""" 
 1312          return _fife.Uint16Uint16PairVector_capacity(self) 
 1313   
 1314      __swig_destroy__ = _fife.delete_Uint16Uint16PairVector 
 1315      __del__ = lambda self : None; 
 1316  Uint16Uint16PairVector_swigregister = _fife.Uint16Uint16PairVector_swigregister 
 1317  Uint16Uint16PairVector_swigregister(Uint16Uint16PairVector) 
 1318   
 1319  SD_SAMPLE_POS = _fife.SD_SAMPLE_POS 
 1320  SD_TIME_POS = _fife.SD_TIME_POS 
 1321  SD_BYTE_POS = _fife.SD_BYTE_POS 
 1322 -class SoundEmitter(_object): 
 1323      """Proxy of C++ FIFE::SoundEmitter class""" 
 1324      __swig_setmethods__ = {} 
 1325      __setattr__ = lambda self, name, value: _swig_setattr(self, SoundEmitter, name, value) 
 1326      __swig_getmethods__ = {} 
 1327      __getattr__ = lambda self, name: _swig_getattr(self, SoundEmitter, name) 
 1328      __repr__ = _swig_repr 
 1329 -    def __init__(self, *args):  
 1330          """__init__(self, SoundManager manager, SoundClipPool pool, unsigned int uid) -> SoundEmitter""" 
 1331          this = _fife.new_SoundEmitter(*args) 
 1332          try: self.this.append(this) 
 1333          except: self.this = this 
 1334      __swig_destroy__ = _fife.delete_SoundEmitter 
 1335      __del__ = lambda self : None; 
 1336 -    def getId(self): 
 1337          """getId(self) -> unsigned int""" 
 1338          return _fife.SoundEmitter_getId(self) 
 1339   
 1340 -    def setSoundClip(self, *args): 
 1341          """setSoundClip(self, unsigned int sound_id)""" 
 1342          return _fife.SoundEmitter_setSoundClip(self, *args) 
 1343   
 1344 -    def reset(self, defaultall = False): 
 1345          """ 
 1346          reset(self, bool defaultall = False) 
 1347          reset(self) 
 1348          """ 
 1349          return _fife.SoundEmitter_reset(self, defaultall) 
 1350   
 1351 -    def release(self): 
 1352          """release(self)""" 
 1353          return _fife.SoundEmitter_release(self) 
 1354   
 1355 -    def play(self): 
 1356          """play(self)""" 
 1357          return _fife.SoundEmitter_play(self) 
 1358   
 1359 -    def pause(self): 
 1360          """pause(self)""" 
 1361          return _fife.SoundEmitter_pause(self) 
 1362   
 1363 -    def stop(self): 
 1364          """stop(self)""" 
 1365          return _fife.SoundEmitter_stop(self) 
 1366   
 1367 -    def setLooping(self, *args): 
 1368          """setLooping(self, bool loop)""" 
 1369          return _fife.SoundEmitter_setLooping(self, *args) 
 1370   
 1371 -    def setRolloff(self, *args): 
 1372          """setRolloff(self, float rolloff)""" 
 1373          return _fife.SoundEmitter_setRolloff(self, *args) 
 1374   
 1375 -    def setPositioning(self, *args): 
 1376          """setPositioning(self, bool relative)""" 
 1377          return _fife.SoundEmitter_setPositioning(self, *args) 
 1378   
 1379 -    def setPosition(self, *args): 
 1380          """setPosition(self, float x, float y, float z)""" 
 1381          return _fife.SoundEmitter_setPosition(self, *args) 
 1382   
 1383 -    def setVelocity(self, *args): 
 1384          """setVelocity(self, float x, float y, float z)""" 
 1385          return _fife.SoundEmitter_setVelocity(self, *args) 
 1386   
 1387 -    def setGain(self, *args): 
 1388          """setGain(self, float gain)""" 
 1389          return _fife.SoundEmitter_setGain(self, *args) 
 1390   
 1391 -    def getGain(self): 
 1392          """getGain(self) -> float""" 
 1393          return _fife.SoundEmitter_getGain(self) 
 1394   
 1395 -    def isStereo(self): 
 1396          """isStereo(self) -> bool""" 
 1397          return _fife.SoundEmitter_isStereo(self) 
 1398   
 1399 -    def getBitResolution(self): 
 1400          """getBitResolution(self) -> short""" 
 1401          return _fife.SoundEmitter_getBitResolution(self) 
 1402   
 1403 -    def getSampleRate(self): 
 1404          """getSampleRate(self) -> unsigned long""" 
 1405          return _fife.SoundEmitter_getSampleRate(self) 
 1406   
 1407 -    def getDecodedLength(self): 
 1408          """getDecodedLength(self) -> unsigned long""" 
 1409          return _fife.SoundEmitter_getDecodedLength(self) 
 1410   
 1411 -    def getDuration(self): 
 1412          """getDuration(self) -> unsigned long""" 
 1413          return _fife.SoundEmitter_getDuration(self) 
 1414   
 1415 -    def setCursor(self, *args): 
 1416          """setCursor(self, SoundPositionType type, float value)""" 
 1417          return _fife.SoundEmitter_setCursor(self, *args) 
 1418   
 1419 -    def getCursor(self, *args): 
 1420          """getCursor(self, SoundPositionType type) -> float""" 
 1421          return _fife.SoundEmitter_getCursor(self, *args) 
 1422   
 1423  SoundEmitter_swigregister = _fife.SoundEmitter_swigregister 
 1424  SoundEmitter_swigregister(SoundEmitter) 
 1425   
 1426  RES_TYPE_FILE = _fife.RES_TYPE_FILE 
 1427  RES_TYPE_IMAGE = _fife.RES_TYPE_IMAGE 
 1428 -class ResourceLocation(_object): 
 1429      """Proxy of C++ FIFE::ResourceLocation class""" 
 1430      __swig_setmethods__ = {} 
 1431      __setattr__ = lambda self, name, value: _swig_setattr(self, ResourceLocation, name, value) 
 1432      __swig_getmethods__ = {} 
 1433      __getattr__ = lambda self, name: _swig_getattr(self, ResourceLocation, name) 
 1434      __repr__ = _swig_repr 
 1435 -    def __init__(self, *args):  
 1436          """__init__(self, string filename) -> ResourceLocation""" 
 1437          this = _fife.new_ResourceLocation(*args) 
 1438          try: self.this.append(this) 
 1439          except: self.this = this 
 1440      __swig_destroy__ = _fife.delete_ResourceLocation 
 1441      __del__ = lambda self : None; 
 1442 -    def getFilename(self): 
 1443          """getFilename(self) -> string""" 
 1444          return _fife.ResourceLocation_getFilename(self) 
 1445   
 1446 -    def __eq__(self, *args): 
 1447          """__eq__(self, ResourceLocation loc) -> bool""" 
 1448          return _fife.ResourceLocation___eq__(self, *args) 
 1449   
 1450 -    def __lt__(self, *args): 
 1451          """__lt__(self, ResourceLocation loc) -> bool""" 
 1452          return _fife.ResourceLocation___lt__(self, *args) 
 1453   
 1454 -    def clone(self): 
 1455          """clone(self) -> ResourceLocation""" 
 1456          return _fife.ResourceLocation_clone(self) 
 1457   
 1458 -    def getType(self): 
 1459          """getType(self) -> ResourceLocationType""" 
 1460          return _fife.ResourceLocation_getType(self) 
 1461   
 1462  ResourceLocation_swigregister = _fife.ResourceLocation_swigregister 
 1463  ResourceLocation_swigregister(ResourceLocation) 
 1464   
 1465 -class IReferenceCounted(_object): 
 1466      """Proxy of C++ FIFE::IReferenceCounted class""" 
 1467      __swig_setmethods__ = {} 
 1468      __setattr__ = lambda self, name, value: _swig_setattr(self, IReferenceCounted, name, value) 
 1469      __swig_getmethods__ = {} 
 1470      __getattr__ = lambda self, name: _swig_getattr(self, IReferenceCounted, name) 
 1471 -    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") 
 1472      __repr__ = _swig_repr 
 1473  IReferenceCounted_swigregister = _fife.IReferenceCounted_swigregister 
 1474  IReferenceCounted_swigregister(IReferenceCounted) 
 1475   
 1476 -class IResource(IReferenceCounted): 
 1477      """Proxy of C++ FIFE::IResource class""" 
 1478      __swig_setmethods__ = {} 
 1479      for _s in [IReferenceCounted]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) 
 1480      __setattr__ = lambda self, name, value: _swig_setattr(self, IResource, name, value) 
 1481      __swig_getmethods__ = {} 
 1482      for _s in [IReferenceCounted]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) 
 1483      __getattr__ = lambda self, name: _swig_getattr(self, IResource, name) 
 1484 -    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") 
 1485      __repr__ = _swig_repr 
 1486      __swig_destroy__ = _fife.delete_IResource 
 1487      __del__ = lambda self : None; 
 1488 -    def getResourceLocation(self): 
 1489          """getResourceLocation(self) -> ResourceLocation""" 
 1490          return _fife.IResource_getResourceLocation(self) 
 1491   
 1492 -    def getResourceFile(self): 
 1493          """getResourceFile(self) -> string""" 
 1494          return _fife.IResource_getResourceFile(self) 
 1495   
 1496 -    def setResourceLocation(self, *args): 
 1497          """setResourceLocation(self, ResourceLocation location)""" 
 1498          return _fife.IResource_setResourceLocation(self, *args) 
 1499   
 1500 -    def setResourceFile(self, *args): 
 1501          """setResourceFile(self, string filename)""" 
 1502          return _fife.IResource_setResourceFile(self, *args) 
 1503   
 1504 -    def getPoolId(self): 
 1505          """getPoolId(self) -> int""" 
 1506          return _fife.IResource_getPoolId(self) 
 1507   
 1508 -    def setPoolId(self, *args): 
 1509          """setPoolId(self, int poolid)""" 
 1510          return _fife.IResource_setPoolId(self, *args) 
 1511   
 1512 -    def getRefCount(self): 
 1513          """getRefCount(self) -> unsigned int""" 
 1514          return _fife.IResource_getRefCount(self) 
 1515   
 1516  IResource_swigregister = _fife.IResource_swigregister 
 1517  IResource_swigregister(IResource) 
 1518   
 1519 -class ResourceLoader(_object): 
 1520      """Proxy of C++ FIFE::ResourceLoader class""" 
 1521      __swig_setmethods__ = {} 
 1522      __setattr__ = lambda self, name, value: _swig_setattr(self, ResourceLoader, name, value) 
 1523      __swig_getmethods__ = {} 
 1524      __getattr__ = lambda self, name: _swig_getattr(self, ResourceLoader, name) 
 1525      __repr__ = _swig_repr 
 1526      __swig_destroy__ = _fife.delete_ResourceLoader 
 1527      __del__ = lambda self : None; 
 1528 -    def loadResource(self, *args): 
 1529          """loadResource(self, ResourceLocation location) -> IResource""" 
 1530          return _fife.ResourceLoader_loadResource(self, *args) 
 1531   
 1532 -    def __init__(self):  
 1533          """__init__(self) -> ResourceLoader""" 
 1534          if self.__class__ == ResourceLoader: 
 1535              _self = None 
 1536          else: 
 1537              _self = self 
 1538          this = _fife.new_ResourceLoader(_self, ) 
 1539          try: self.this.append(this) 
 1540          except: self.this = this 
 1541 -    def __disown__(self): 
 1542          self.this.disown() 
 1543          _fife.disown_ResourceLoader(self) 
 1544          return weakref_proxy(self) 
 1545  ResourceLoader_swigregister = _fife.ResourceLoader_swigregister 
 1546  ResourceLoader_swigregister(ResourceLoader) 
 1547   
 1548 -class ResourceSaver(_object): 
 1549      """Proxy of C++ FIFE::ResourceSaver class""" 
 1550      __swig_setmethods__ = {} 
 1551      __setattr__ = lambda self, name, value: _swig_setattr(self, ResourceSaver, name, value) 
 1552      __swig_getmethods__ = {} 
 1553      __getattr__ = lambda self, name: _swig_getattr(self, ResourceSaver, name) 
 1554 -    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") 
 1555      __repr__ = _swig_repr 
 1556      __swig_destroy__ = _fife.delete_ResourceSaver 
 1557      __del__ = lambda self : None; 
 1558 -    def save(self, *args): 
 1559          """ 
 1560          save(self, ResourceLocation location, IResource resource) 
 1561          save(self, string filename, IResource resource) 
 1562          """ 
 1563          return _fife.ResourceSaver_save(self, *args) 
 1564   
 1565  ResourceSaver_swigregister = _fife.ResourceSaver_swigregister 
 1566  ResourceSaver_swigregister(ResourceSaver) 
 1567   
 1568 -class Pool(_object): 
 1569      """Proxy of C++ FIFE::Pool class""" 
 1570      __swig_setmethods__ = {} 
 1571      __setattr__ = lambda self, name, value: _swig_setattr(self, Pool, name, value) 
 1572      __swig_getmethods__ = {} 
 1573      __getattr__ = lambda self, name: _swig_getattr(self, Pool, name) 
 1574 -    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") 
 1575      __repr__ = _swig_repr 
 1576      INVALID_ID = _fife.Pool_INVALID_ID 
 1577      __swig_destroy__ = _fife.delete_Pool 
 1578      __del__ = lambda self : None; 
 1579 -    def addResourceFromFile(self, *args): 
 1580          """addResourceFromFile(self, string filename) -> int""" 
 1581          return _fife.Pool_addResourceFromFile(self, *args) 
 1582   
 1583 -    def addResourceFromLocation(self, *args): 
 1584          """addResourceFromLocation(self, ResourceLocation loc) -> int""" 
 1585          return _fife.Pool_addResourceFromLocation(self, *args) 
 1586   
 1587 -    def getResourceCount(self, *args): 
 1588          """getResourceCount(self, int status) -> int""" 
 1589          return _fife.Pool_getResourceCount(self, *args) 
 1590   
 1591 -    def purgeLoadedResources(self): 
 1592          """purgeLoadedResources(self) -> int""" 
 1593          return _fife.Pool_purgeLoadedResources(self) 
 1594   
 1595 -    def addResourceLoader(self, *args): 
 1596          """addResourceLoader(self, ResourceLoader loader)""" 
 1597          return _fife.Pool_addResourceLoader(self, *args) 
 1598   
 1599 -    def clearResourceLoaders(self): 
 1600          """clearResourceLoaders(self)""" 
 1601          return _fife.Pool_clearResourceLoaders(self) 
 1602   
 1603 -    def release(self, *args): 
 1604          """ 
 1605          release(self, unsigned int index, bool dec = False) 
 1606          release(self, unsigned int index) 
 1607          """ 
 1608          return _fife.Pool_release(self, *args) 
 1609   
 1610 -    def get(self, *args): 
 1611          """ 
 1612          get(self, unsigned int index, bool inc = False) -> IResource 
 1613          get(self, unsigned int index) -> IResource 
 1614          """ 
 1615          return _fife.Pool_get(self, *args) 
 1616   
 1617 -    def printStatistics(self): 
 1618          """printStatistics(self)""" 
 1619          return _fife.Pool_printStatistics(self) 
 1620   
 1621  Pool_swigregister = _fife.Pool_swigregister 
 1622  Pool_swigregister(Pool) 
 1623   
 1624 -class ResourcePtr(_object): 
 1625      """Proxy of C++ FIFE::ResourcePtr class""" 
 1626      __swig_setmethods__ = {} 
 1627      __setattr__ = lambda self, name, value: _swig_setattr(self, ResourcePtr, name, value) 
 1628      __swig_getmethods__ = {} 
 1629      __getattr__ = lambda self, name: _swig_getattr(self, ResourcePtr, name) 
 1630      __repr__ = _swig_repr 
 1631 -    def __init__(self, *args):  
 1632          """ 
 1633          __init__(self, IResource ptr = None) -> ResourcePtr 
 1634          __init__(self) -> ResourcePtr 
 1635          __init__(self, Pool pool, int index) -> ResourcePtr 
 1636          __init__(self, ResourcePtr r) -> ResourcePtr 
 1637          """ 
 1638          this = _fife.new_ResourcePtr(*args) 
 1639          try: self.this.append(this) 
 1640          except: self.this = this 
 1641 -    def release(self): 
 1642          """release(self)""" 
 1643          return _fife.ResourcePtr_release(self) 
 1644   
 1645 -    def load(self): 
 1646          """load(self)""" 
 1647          return _fife.ResourcePtr_load(self) 
 1648   
 1649 -    def unload(self): 
 1650          """unload(self)""" 
 1651          return _fife.ResourcePtr_unload(self) 
 1652   
 1653      __swig_destroy__ = _fife.delete_ResourcePtr 
 1654      __del__ = lambda self : None; 
 1655  ResourcePtr_swigregister = _fife.ResourcePtr_swigregister 
 1656  ResourcePtr_swigregister(ResourcePtr) 
 1657   
 1658 -class SoundClipPool(Pool): 
 1659      """Proxy of C++ FIFE::SoundClipPool class""" 
 1660      __swig_setmethods__ = {} 
 1661      for _s in [Pool]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) 
 1662      __setattr__ = lambda self, name, value: _swig_setattr(self, SoundClipPool, name, value) 
 1663      __swig_getmethods__ = {} 
 1664      for _s in [Pool]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) 
 1665      __getattr__ = lambda self, name: _swig_getattr(self, SoundClipPool, name) 
 1666 -    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") 
 1667      __repr__ = _swig_repr 
 1668      __swig_destroy__ = _fife.delete_SoundClipPool 
 1669      __del__ = lambda self : None; 
 1670 -    def getSoundClip(self, *args): 
 1671          """getSoundClip(self, unsigned int index) -> SoundClip""" 
 1672          return _fife.SoundClipPool_getSoundClip(self, *args) 
 1673   
 1674  SoundClipPool_swigregister = _fife.SoundClipPool_swigregister 
 1675  SoundClipPool_swigregister(SoundClipPool) 
 1676   
 1677 -class SoundManager(_object): 
 1678      """Proxy of C++ FIFE::SoundManager class""" 
 1679      __swig_setmethods__ = {} 
 1680      __setattr__ = lambda self, name, value: _swig_setattr(self, SoundManager, name, value) 
 1681      __swig_getmethods__ = {} 
 1682      __getattr__ = lambda self, name: _swig_getattr(self, SoundManager, name) 
 1683      __repr__ = _swig_repr 
 1684 -    def __init__(self, *args):  
 1685          """__init__(self, SoundClipPool arg0) -> SoundManager""" 
 1686          this = _fife.new_SoundManager(*args) 
 1687          try: self.this.append(this) 
 1688          except: self.this = this 
 1689      __swig_destroy__ = _fife.delete_SoundManager 
 1690      __del__ = lambda self : None; 
 1691 -    def init(self): 
 1692          """init(self)""" 
 1693          return _fife.SoundManager_init(self) 
 1694   
 1695 -    def createEmitter(self): 
 1696          """createEmitter(self) -> SoundEmitter""" 
 1697          return _fife.SoundManager_createEmitter(self) 
 1698   
 1699 -    def getEmitter(self, *args): 
 1700          """getEmitter(self, unsigned int emitterid) -> SoundEmitter""" 
 1701          return _fife.SoundManager_getEmitter(self, *args) 
 1702   
 1703 -    def releaseEmitter(self, *args): 
 1704          """releaseEmitter(self, unsigned int emitterid)""" 
 1705          return _fife.SoundManager_releaseEmitter(self, *args) 
 1706   
 1707 -    def getContext(self): 
 1708          """getContext(self) -> ALCcontext""" 
 1709          return _fife.SoundManager_getContext(self) 
 1710   
 1711 -    def setVolume(self, *args): 
 1712          """setVolume(self, float vol)""" 
 1713          return _fife.SoundManager_setVolume(self, *args) 
 1714   
 1715 -    def getVolume(self): 
 1716          """getVolume(self) -> float""" 
 1717          return _fife.SoundManager_getVolume(self) 
 1718   
 1719 -    def mute(self): 
 1720          """mute(self)""" 
 1721          return _fife.SoundManager_mute(self) 
 1722   
 1723 -    def unmute(self): 
 1724          """unmute(self)""" 
 1725          return _fife.SoundManager_unmute(self) 
 1726   
 1727 -    def setListenerPosition(self, *args): 
 1728          """setListenerPosition(self, float x, float y, float z)""" 
 1729          return _fife.SoundManager_setListenerPosition(self, *args) 
 1730   
 1731 -    def setListenerOrientation(self, *args): 
 1732          """setListenerOrientation(self, float x, float y, float z)""" 
 1733          return _fife.SoundManager_setListenerOrientation(self, *args) 
 1734   
 1735  SoundManager_swigregister = _fife.SoundManager_swigregister 
 1736  SoundManager_swigregister(SoundManager) 
 1737   
 1738 -class EngineSettings(_object): 
 1739      """Proxy of C++ FIFE::EngineSettings class""" 
 1740      __swig_setmethods__ = {} 
 1741      __setattr__ = lambda self, name, value: _swig_setattr(self, EngineSettings, name, value) 
 1742      __swig_getmethods__ = {} 
 1743      __getattr__ = lambda self, name: _swig_getattr(self, EngineSettings, name) 
 1744 -    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") 
 1745      __repr__ = _swig_repr 
 1746      __swig_destroy__ = _fife.delete_EngineSettings 
 1747      __del__ = lambda self : None; 
 1748 -    def validate(self): 
 1749          """validate(self)""" 
 1750          return _fife.EngineSettings_validate(self) 
 1751   
 1752 -    def setBitsPerPixel(self, *args): 
 1753          """setBitsPerPixel(self, uint8_t bitsperpixel)""" 
 1754          return _fife.EngineSettings_setBitsPerPixel(self, *args) 
 1755   
 1756 -    def getBitsPerPixel(self): 
 1757          """getBitsPerPixel(self) -> uint16_t""" 
 1758          return _fife.EngineSettings_getBitsPerPixel(self) 
 1759   
 1760 -    def getPossibleBitsPerPixel(self): 
 1761          """getPossibleBitsPerPixel(self) -> std::vector<(uint16_t,std::allocator<(uint16_t)>)>""" 
 1762          return _fife.EngineSettings_getPossibleBitsPerPixel(self) 
 1763   
 1764 -    def getPossibleResolutions(self): 
 1765          """getPossibleResolutions(self) -> Uint16Uint16PairVector""" 
 1766          return _fife.EngineSettings_getPossibleResolutions(self) 
 1767   
 1768 -    def setFullScreen(self, *args): 
 1769          """setFullScreen(self, bool fullscreen)""" 
 1770          return _fife.EngineSettings_setFullScreen(self, *args) 
 1771   
 1772 -    def isFullScreen(self): 
 1773          """isFullScreen(self) -> bool""" 
 1774          return _fife.EngineSettings_isFullScreen(self) 
 1775   
 1776 -    def setInitialVolume(self, *args): 
 1777          """setInitialVolume(self, float volume)""" 
 1778          return _fife.EngineSettings_setInitialVolume(self, *args) 
 1779   
 1780 -    def getInitialVolume(self): 
 1781          """getInitialVolume(self) -> float""" 
 1782          return _fife.EngineSettings_getInitialVolume(self) 
 1783   
 1784 -    def getMaxVolume(self): 
 1785          """getMaxVolume(self) -> float""" 
 1786          return _fife.EngineSettings_getMaxVolume(self) 
 1787   
 1788 -    def setRenderBackend(self, *args): 
 1789          """setRenderBackend(self, string renderbackend)""" 
 1790          return _fife.EngineSettings_setRenderBackend(self, *args) 
 1791   
 1792 -    def getRenderBackend(self): 
 1793          """getRenderBackend(self) -> string""" 
 1794          return _fife.EngineSettings_getRenderBackend(self) 
 1795   
 1796 -    def getPossibleRenderBackends(self): 
 1797          """getPossibleRenderBackends(self) -> StringVector""" 
 1798          return _fife.EngineSettings_getPossibleRenderBackends(self) 
 1799   
 1800 -    def setSDLRemoveFakeAlpha(self, *args): 
 1801          """setSDLRemoveFakeAlpha(self, bool sdlremovefakealpha)""" 
 1802          return _fife.EngineSettings_setSDLRemoveFakeAlpha(self, *args) 
 1803   
 1804 -    def isSDLRemoveFakeAlpha(self, *args): 
 1805          """isSDLRemoveFakeAlpha(self, bool sdlremovefakealpha) -> bool""" 
 1806          return _fife.EngineSettings_isSDLRemoveFakeAlpha(self, *args) 
 1807   
 1808 -    def setScreenWidth(self, *args): 
 1809          """setScreenWidth(self, uint16_t screenwidth)""" 
 1810          return _fife.EngineSettings_setScreenWidth(self, *args) 
 1811   
 1812 -    def getScreenWidth(self): 
 1813          """getScreenWidth(self) -> uint16_t""" 
 1814          return _fife.EngineSettings_getScreenWidth(self) 
 1815   
 1816 -    def setScreenHeight(self, *args): 
 1817          """setScreenHeight(self, uint16_t screenheight)""" 
 1818          return _fife.EngineSettings_setScreenHeight(self, *args) 
 1819   
 1820 -    def getScreenHeight(self): 
 1821          """getScreenHeight(self) -> uint16_t""" 
 1822          return _fife.EngineSettings_getScreenHeight(self) 
 1823   
 1824 -    def setDefaultFontPath(self, *args): 
 1825          """setDefaultFontPath(self, string defaultfontpath)""" 
 1826          return _fife.EngineSettings_setDefaultFontPath(self, *args) 
 1827   
 1828 -    def getDefaultFontPath(self): 
 1829          """getDefaultFontPath(self) -> string""" 
 1830          return _fife.EngineSettings_getDefaultFontPath(self) 
 1831   
 1832 -    def setDefaultFontSize(self, *args): 
 1833          """setDefaultFontSize(self, uint16_t defaultfontsize)""" 
 1834          return _fife.EngineSettings_setDefaultFontSize(self, *args) 
 1835   
 1836 -    def getDefaultFontSize(self): 
 1837          """getDefaultFontSize(self) -> uint16_t""" 
 1838          return _fife.EngineSettings_getDefaultFontSize(self) 
 1839   
 1840 -    def setDefaultFontGlyphs(self, *args): 
 1841          """setDefaultFontGlyphs(self, string defaultfontglyphs)""" 
 1842          return _fife.EngineSettings_setDefaultFontGlyphs(self, *args) 
 1843   
 1844 -    def getDefaultFontGlyphs(self): 
 1845          """getDefaultFontGlyphs(self) -> string""" 
 1846          return _fife.EngineSettings_getDefaultFontGlyphs(self) 
 1847   
 1848 -    def setWindowTitle(self, *args): 
 1849          """setWindowTitle(self, string title)""" 
 1850          return _fife.EngineSettings_setWindowTitle(self, *args) 
 1851   
 1852 -    def getWindowTitle(self): 
 1853          """getWindowTitle(self) -> string""" 
 1854          return _fife.EngineSettings_getWindowTitle(self) 
 1855   
 1856 -    def setWindowIcon(self, *args): 
 1857          """setWindowIcon(self, string icon)""" 
 1858          return _fife.EngineSettings_setWindowIcon(self, *args) 
 1859   
 1860 -    def getWindowIcon(self): 
 1861          """getWindowIcon(self) -> string""" 
 1862          return _fife.EngineSettings_getWindowIcon(self) 
 1863   
 1864 -    def setColorKeyEnabled(self, *args): 
 1865          """setColorKeyEnabled(self, bool colorkeyenable)""" 
 1866          return _fife.EngineSettings_setColorKeyEnabled(self, *args) 
 1867   
 1868 -    def isColorKeyEnabled(self): 
 1869          """isColorKeyEnabled(self) -> bool""" 
 1870          return _fife.EngineSettings_isColorKeyEnabled(self) 
 1871   
 1872 -    def setColorKey(self, *args): 
 1873          """setColorKey(self, uint8_t r, uint8_t g, uint8_t b)""" 
 1874          return _fife.EngineSettings_setColorKey(self, *args) 
 1875   
 1876 -    def getColorKey(self): 
 1877          """getColorKey(self) -> SDL_Color""" 
 1878          return _fife.EngineSettings_getColorKey(self) 
 1879   
 1880 -    def setVideoDriver(self, *args): 
 1881          """setVideoDriver(self, string driver)""" 
 1882          return _fife.EngineSettings_setVideoDriver(self, *args) 
 1883   
 1884 -    def getVideoDriver(self): 
 1885          """getVideoDriver(self) -> string""" 
 1886          return _fife.EngineSettings_getVideoDriver(self) 
 1887   
 1888 -    def setLightingModel(self, *args): 
 1889          """setLightingModel(self, unsigned int lighting)""" 
 1890          return _fife.EngineSettings_setLightingModel(self, *args) 
 1891   
 1892 -    def getLightingModel(self): 
 1893          """getLightingModel(self) -> unsigned int""" 
 1894          return _fife.EngineSettings_getLightingModel(self) 
 1895   
 1896  EngineSettings_swigregister = _fife.EngineSettings_swigregister 
 1897  EngineSettings_swigregister(EngineSettings) 
 1898   
 1899 -class IEngineChangeListener(_object): 
 1900      """Proxy of C++ FIFE::IEngineChangeListener class""" 
 1901      __swig_setmethods__ = {} 
 1902      __setattr__ = lambda self, name, value: _swig_setattr(self, IEngineChangeListener, name, value) 
 1903      __swig_getmethods__ = {} 
 1904      __getattr__ = lambda self, name: _swig_getattr(self, IEngineChangeListener, name) 
 1905      __repr__ = _swig_repr 
 1906      __swig_destroy__ = _fife.delete_IEngineChangeListener 
 1907      __del__ = lambda self : None; 
 1908 -    def onScreenModeChanged(self, *args): 
 1909          """onScreenModeChanged(self, ScreenMode newmode)""" 
 1910          return _fife.IEngineChangeListener_onScreenModeChanged(self, *args) 
 1911   
 1912 -    def __init__(self):  
 1913          """__init__(self) -> IEngineChangeListener""" 
 1914          if self.__class__ == IEngineChangeListener: 
 1915              _self = None 
 1916          else: 
 1917              _self = self 
 1918          this = _fife.new_IEngineChangeListener(_self, ) 
 1919          try: self.this.append(this) 
 1920          except: self.this = this 
 1921 -    def __disown__(self): 
 1922          self.this.disown() 
 1923          _fife.disown_IEngineChangeListener(self) 
 1924          return weakref_proxy(self) 
 1925  IEngineChangeListener_swigregister = _fife.IEngineChangeListener_swigregister 
 1926  IEngineChangeListener_swigregister(IEngineChangeListener) 
 1927   
 1928 -class Engine(_object): 
 1929      """Proxy of C++ FIFE::Engine class""" 
 1930      __swig_setmethods__ = {} 
 1931      __setattr__ = lambda self, name, value: _swig_setattr(self, Engine, name, value) 
 1932      __swig_getmethods__ = {} 
 1933      __getattr__ = lambda self, name: _swig_getattr(self, Engine, name) 
 1934      __repr__ = _swig_repr 
 1935 -    def __init__(self):  
 1936          """__init__(self) -> Engine""" 
 1937          this = _fife.new_Engine() 
 1938          try: self.this.append(this) 
 1939          except: self.this = this 
 1940      __swig_destroy__ = _fife.delete_Engine 
 1941      __del__ = lambda self : None; 
 1942 -    def initializePumping(self): 
 1943          """initializePumping(self)""" 
 1944          return _fife.Engine_initializePumping(self) 
 1945   
 1946 -    def finalizePumping(self): 
 1947          """finalizePumping(self)""" 
 1948          return _fife.Engine_finalizePumping(self) 
 1949   
 1950 -    def pump(self): 
 1951          """pump(self)""" 
 1952          return _fife.Engine_pump(self) 
 1953   
 1954 -    def getSettings(self): 
 1955          """getSettings(self) -> EngineSettings""" 
 1956          return _fife.Engine_getSettings(self) 
 1957   
 1958 -    def getDeviceCaps(self): 
 1959          """getDeviceCaps(self) -> DeviceCaps""" 
 1960          return _fife.Engine_getDeviceCaps(self) 
 1961   
 1962 -    def changeScreenMode(self, *args): 
 1963          """changeScreenMode(self, ScreenMode mode) -> Image""" 
 1964          return _fife.Engine_changeScreenMode(self, *args) 
 1965   
 1966 -    def init(self): 
 1967          """init(self)""" 
 1968          return _fife.Engine_init(self) 
 1969   
 1970 -    def destroy(self): 
 1971          """destroy(self)""" 
 1972          return _fife.Engine_destroy(self) 
 1973   
 1974 -    def getSoundManager(self): 
 1975          """getSoundManager(self) -> SoundManager""" 
 1976          return _fife.Engine_getSoundManager(self) 
 1977   
 1978 -    def getEventManager(self): 
 1979          """getEventManager(self) -> EventManager""" 
 1980          return _fife.Engine_getEventManager(self) 
 1981   
 1982 -    def getTimeManager(self): 
 1983          """getTimeManager(self) -> TimeManager""" 
 1984          return _fife.Engine_getTimeManager(self) 
 1985   
 1986 -    def getGuiManager(self): 
 1987          """getGuiManager(self) -> GUIManager""" 
 1988          return _fife.Engine_getGuiManager(self) 
 1989   
 1990 -    def getImagePool(self): 
 1991          """getImagePool(self) -> ImagePool""" 
 1992          return _fife.Engine_getImagePool(self) 
 1993   
 1994 -    def getAnimationPool(self): 
 1995          """getAnimationPool(self) -> AnimationPool""" 
 1996          return _fife.Engine_getAnimationPool(self) 
 1997   
 1998 -    def getSoundClipPool(self): 
 1999          """getSoundClipPool(self) -> SoundClipPool""" 
 2000          return _fife.Engine_getSoundClipPool(self) 
 2001   
 2002 -    def getRenderBackend(self): 
 2003          """getRenderBackend(self) -> RenderBackend""" 
 2004          return _fife.Engine_getRenderBackend(self) 
 2005   
 2006 -    def getModel(self): 
 2007          """getModel(self) -> Model""" 
 2008          return _fife.Engine_getModel(self) 
 2009   
 2010 -    def getLogManager(self): 
 2011          """getLogManager(self) -> LogManager""" 
 2012          return _fife.Engine_getLogManager(self) 
 2013   
 2014 -    def getDefaultFont(self): 
 2015          """getDefaultFont(self) -> GuiFont""" 
 2016          return _fife.Engine_getDefaultFont(self) 
 2017   
 2018 -    def getVFS(self): 
 2019          """getVFS(self) -> VFS""" 
 2020          return _fife.Engine_getVFS(self) 
 2021   
 2022 -    def getCursor(self): 
 2023          """getCursor(self) -> Cursor""" 
 2024          return _fife.Engine_getCursor(self) 
 2025   
 2026 -    def addChangeListener(self, *args): 
 2027          """addChangeListener(self, IEngineChangeListener listener)""" 
 2028          return _fife.Engine_addChangeListener(self, *args) 
 2029   
 2030 -    def removeChangeListener(self, *args): 
 2031          """removeChangeListener(self, IEngineChangeListener listener)""" 
 2032          return _fife.Engine_removeChangeListener(self, *args) 
 2033   
 2034  Engine_swigregister = _fife.Engine_swigregister 
 2035  Engine_swigregister(Engine) 
 2036   
 2037 -class Key(_object): 
 2038      """Proxy of C++ FIFE::Key class""" 
 2039      __swig_setmethods__ = {} 
 2040      __setattr__ = lambda self, name, value: _swig_setattr(self, Key, name, value) 
 2041      __swig_getmethods__ = {} 
 2042      __getattr__ = lambda self, name: _swig_getattr(self, Key, name) 
 2043      __repr__ = _swig_repr 
 2044      INVALID_KEY = _fife.Key_INVALID_KEY 
 2045      BACKSPACE = _fife.Key_BACKSPACE 
 2046      TAB = _fife.Key_TAB 
 2047      CLEAR = _fife.Key_CLEAR 
 2048      ENTER = _fife.Key_ENTER 
 2049      PAUSE = _fife.Key_PAUSE 
 2050      ESCAPE = _fife.Key_ESCAPE 
 2051      SPACE = _fife.Key_SPACE 
 2052      EXCLAIM = _fife.Key_EXCLAIM 
 2053      QUOTEDBL = _fife.Key_QUOTEDBL 
 2054      HASH = _fife.Key_HASH 
 2055      DOLLAR = _fife.Key_DOLLAR 
 2056      AMPERSAND = _fife.Key_AMPERSAND 
 2057      QUOTE = _fife.Key_QUOTE 
 2058      LEFTPAREN = _fife.Key_LEFTPAREN 
 2059      RIGHTPAREN = _fife.Key_RIGHTPAREN 
 2060      ASTERISK = _fife.Key_ASTERISK 
 2061      PLUS = _fife.Key_PLUS 
 2062      COMMA = _fife.Key_COMMA 
 2063      MINUS = _fife.Key_MINUS 
 2064      PERIOD = _fife.Key_PERIOD 
 2065      SLASH = _fife.Key_SLASH 
 2066      NUM_0 = _fife.Key_NUM_0 
 2067      NUM_1 = _fife.Key_NUM_1 
 2068      NUM_2 = _fife.Key_NUM_2 
 2069      NUM_3 = _fife.Key_NUM_3 
 2070      NUM_4 = _fife.Key_NUM_4 
 2071      NUM_5 = _fife.Key_NUM_5 
 2072      NUM_6 = _fife.Key_NUM_6 
 2073      NUM_7 = _fife.Key_NUM_7 
 2074      NUM_8 = _fife.Key_NUM_8 
 2075      NUM_9 = _fife.Key_NUM_9 
 2076      COLON = _fife.Key_COLON 
 2077      SEMICOLON = _fife.Key_SEMICOLON 
 2078      LESS = _fife.Key_LESS 
 2079      EQUALS = _fife.Key_EQUALS 
 2080      GREATER = _fife.Key_GREATER 
 2081      QUESTION = _fife.Key_QUESTION 
 2082      AT = _fife.Key_AT 
 2083      LEFTBRACKET = _fife.Key_LEFTBRACKET 
 2084      BACKSLASH = _fife.Key_BACKSLASH 
 2085      RIGHTBRACKET = _fife.Key_RIGHTBRACKET 
 2086      CARET = _fife.Key_CARET 
 2087      UNDERSCORE = _fife.Key_UNDERSCORE 
 2088      BACKQUOTE = _fife.Key_BACKQUOTE 
 2089      A = _fife.Key_A 
 2090      B = _fife.Key_B 
 2091      C = _fife.Key_C 
 2092      D = _fife.Key_D 
 2093      E = _fife.Key_E 
 2094      F = _fife.Key_F 
 2095      G = _fife.Key_G 
 2096      H = _fife.Key_H 
 2097      I = _fife.Key_I 
 2098      J = _fife.Key_J 
 2099      K = _fife.Key_K 
 2100      L = _fife.Key_L 
 2101      M = _fife.Key_M 
 2102      N = _fife.Key_N 
 2103      O = _fife.Key_O 
 2104      P = _fife.Key_P 
 2105      Q = _fife.Key_Q 
 2106      R = _fife.Key_R 
 2107      S = _fife.Key_S 
 2108      T = _fife.Key_T 
 2109      U = _fife.Key_U 
 2110      V = _fife.Key_V 
 2111      W = _fife.Key_W 
 2112      X = _fife.Key_X 
 2113      Y = _fife.Key_Y 
 2114      Z = _fife.Key_Z 
 2115      DELETE = _fife.Key_DELETE 
 2116      WORLD_0 = _fife.Key_WORLD_0 
 2117      WORLD_1 = _fife.Key_WORLD_1 
 2118      WORLD_2 = _fife.Key_WORLD_2 
 2119      WORLD_3 = _fife.Key_WORLD_3 
 2120      WORLD_4 = _fife.Key_WORLD_4 
 2121      WORLD_5 = _fife.Key_WORLD_5 
 2122      WORLD_6 = _fife.Key_WORLD_6 
 2123      WORLD_7 = _fife.Key_WORLD_7 
 2124      WORLD_8 = _fife.Key_WORLD_8 
 2125      WORLD_9 = _fife.Key_WORLD_9 
 2126      WORLD_10 = _fife.Key_WORLD_10 
 2127      WORLD_11 = _fife.Key_WORLD_11 
 2128      WORLD_12 = _fife.Key_WORLD_12 
 2129      WORLD_13 = _fife.Key_WORLD_13 
 2130      WORLD_14 = _fife.Key_WORLD_14 
 2131      WORLD_15 = _fife.Key_WORLD_15 
 2132      WORLD_16 = _fife.Key_WORLD_16 
 2133      WORLD_17 = _fife.Key_WORLD_17 
 2134      WORLD_18 = _fife.Key_WORLD_18 
 2135      WORLD_19 = _fife.Key_WORLD_19 
 2136      WORLD_20 = _fife.Key_WORLD_20 
 2137      WORLD_21 = _fife.Key_WORLD_21 
 2138      WORLD_22 = _fife.Key_WORLD_22 
 2139      WORLD_23 = _fife.Key_WORLD_23 
 2140      WORLD_24 = _fife.Key_WORLD_24 
 2141      WORLD_25 = _fife.Key_WORLD_25 
 2142      WORLD_26 = _fife.Key_WORLD_26 
 2143      WORLD_27 = _fife.Key_WORLD_27 
 2144      WORLD_28 = _fife.Key_WORLD_28 
 2145      WORLD_29 = _fife.Key_WORLD_29 
 2146      WORLD_30 = _fife.Key_WORLD_30 
 2147      WORLD_31 = _fife.Key_WORLD_31 
 2148      WORLD_32 = _fife.Key_WORLD_32 
 2149      WORLD_33 = _fife.Key_WORLD_33 
 2150      WORLD_34 = _fife.Key_WORLD_34 
 2151      WORLD_35 = _fife.Key_WORLD_35 
 2152      WORLD_36 = _fife.Key_WORLD_36 
 2153      WORLD_37 = _fife.Key_WORLD_37 
 2154      WORLD_38 = _fife.Key_WORLD_38 
 2155      WORLD_39 = _fife.Key_WORLD_39 
 2156      WORLD_40 = _fife.Key_WORLD_40 
 2157      WORLD_41 = _fife.Key_WORLD_41 
 2158      WORLD_42 = _fife.Key_WORLD_42 
 2159      WORLD_43 = _fife.Key_WORLD_43 
 2160      WORLD_44 = _fife.Key_WORLD_44 
 2161      WORLD_45 = _fife.Key_WORLD_45 
 2162      WORLD_46 = _fife.Key_WORLD_46 
 2163      WORLD_47 = _fife.Key_WORLD_47 
 2164      WORLD_48 = _fife.Key_WORLD_48 
 2165      WORLD_49 = _fife.Key_WORLD_49 
 2166      WORLD_50 = _fife.Key_WORLD_50 
 2167      WORLD_51 = _fife.Key_WORLD_51 
 2168      WORLD_52 = _fife.Key_WORLD_52 
 2169      WORLD_53 = _fife.Key_WORLD_53 
 2170      WORLD_54 = _fife.Key_WORLD_54 
 2171      WORLD_55 = _fife.Key_WORLD_55 
 2172      WORLD_56 = _fife.Key_WORLD_56 
 2173      WORLD_57 = _fife.Key_WORLD_57 
 2174      WORLD_58 = _fife.Key_WORLD_58 
 2175      WORLD_59 = _fife.Key_WORLD_59 
 2176      WORLD_60 = _fife.Key_WORLD_60 
 2177      WORLD_61 = _fife.Key_WORLD_61 
 2178      WORLD_62 = _fife.Key_WORLD_62 
 2179      WORLD_63 = _fife.Key_WORLD_63 
 2180      WORLD_64 = _fife.Key_WORLD_64 
 2181      WORLD_65 = _fife.Key_WORLD_65 
 2182      WORLD_66 = _fife.Key_WORLD_66 
 2183      WORLD_67 = _fife.Key_WORLD_67 
 2184      WORLD_68 = _fife.Key_WORLD_68 
 2185      WORLD_69 = _fife.Key_WORLD_69 
 2186      WORLD_70 = _fife.Key_WORLD_70 
 2187      WORLD_71 = _fife.Key_WORLD_71 
 2188      WORLD_72 = _fife.Key_WORLD_72 
 2189      WORLD_73 = _fife.Key_WORLD_73 
 2190      WORLD_74 = _fife.Key_WORLD_74 
 2191      WORLD_75 = _fife.Key_WORLD_75 
 2192      WORLD_76 = _fife.Key_WORLD_76 
 2193      WORLD_77 = _fife.Key_WORLD_77 
 2194      WORLD_78 = _fife.Key_WORLD_78 
 2195      WORLD_79 = _fife.Key_WORLD_79 
 2196      WORLD_80 = _fife.Key_WORLD_80 
 2197      WORLD_81 = _fife.Key_WORLD_81 
 2198      WORLD_82 = _fife.Key_WORLD_82 
 2199      WORLD_83 = _fife.Key_WORLD_83 
 2200      WORLD_84 = _fife.Key_WORLD_84 
 2201      WORLD_85 = _fife.Key_WORLD_85 
 2202      WORLD_86 = _fife.Key_WORLD_86 
 2203      WORLD_87 = _fife.Key_WORLD_87 
 2204      WORLD_88 = _fife.Key_WORLD_88 
 2205      WORLD_89 = _fife.Key_WORLD_89 
 2206      WORLD_90 = _fife.Key_WORLD_90 
 2207      WORLD_91 = _fife.Key_WORLD_91 
 2208      WORLD_92 = _fife.Key_WORLD_92 
 2209      WORLD_93 = _fife.Key_WORLD_93 
 2210      WORLD_94 = _fife.Key_WORLD_94 
 2211      WORLD_95 = _fife.Key_WORLD_95 
 2212      KP0 = _fife.Key_KP0 
 2213      KP1 = _fife.Key_KP1 
 2214      KP2 = _fife.Key_KP2 
 2215      KP3 = _fife.Key_KP3 
 2216      KP4 = _fife.Key_KP4 
 2217      KP5 = _fife.Key_KP5 
 2218      KP6 = _fife.Key_KP6 
 2219      KP7 = _fife.Key_KP7 
 2220      KP8 = _fife.Key_KP8 
 2221      KP9 = _fife.Key_KP9 
 2222      KP_PERIOD = _fife.Key_KP_PERIOD 
 2223      KP_DIVIDE = _fife.Key_KP_DIVIDE 
 2224      KP_MULTIPLY = _fife.Key_KP_MULTIPLY 
 2225      KP_MINUS = _fife.Key_KP_MINUS 
 2226      KP_PLUS = _fife.Key_KP_PLUS 
 2227      KP_ENTER = _fife.Key_KP_ENTER 
 2228      KP_EQUALS = _fife.Key_KP_EQUALS 
 2229      UP = _fife.Key_UP 
 2230      DOWN = _fife.Key_DOWN 
 2231      RIGHT = _fife.Key_RIGHT 
 2232      LEFT = _fife.Key_LEFT 
 2233      INSERT = _fife.Key_INSERT 
 2234      HOME = _fife.Key_HOME 
 2235      END = _fife.Key_END 
 2236      PAGE_UP = _fife.Key_PAGE_UP 
 2237      PAGE_DOWN = _fife.Key_PAGE_DOWN 
 2238      F1 = _fife.Key_F1 
 2239      F2 = _fife.Key_F2 
 2240      F3 = _fife.Key_F3 
 2241      F4 = _fife.Key_F4 
 2242      F5 = _fife.Key_F5 
 2243      F6 = _fife.Key_F6 
 2244      F7 = _fife.Key_F7 
 2245      F8 = _fife.Key_F8 
 2246      F9 = _fife.Key_F9 
 2247      F10 = _fife.Key_F10 
 2248      F11 = _fife.Key_F11 
 2249      F12 = _fife.Key_F12 
 2250      F13 = _fife.Key_F13 
 2251      F14 = _fife.Key_F14 
 2252      F15 = _fife.Key_F15 
 2253      NUM_LOCK = _fife.Key_NUM_LOCK 
 2254      CAPS_LOCK = _fife.Key_CAPS_LOCK 
 2255      SCROLL_LOCK = _fife.Key_SCROLL_LOCK 
 2256      RIGHT_SHIFT = _fife.Key_RIGHT_SHIFT 
 2257      LEFT_SHIFT = _fife.Key_LEFT_SHIFT 
 2258      RIGHT_CONTROL = _fife.Key_RIGHT_CONTROL 
 2259      LEFT_CONTROL = _fife.Key_LEFT_CONTROL 
 2260      RIGHT_ALT = _fife.Key_RIGHT_ALT 
 2261      LEFT_ALT = _fife.Key_LEFT_ALT 
 2262      RIGHT_META = _fife.Key_RIGHT_META 
 2263      LEFT_META = _fife.Key_LEFT_META 
 2264      RIGHT_SUPER = _fife.Key_RIGHT_SUPER 
 2265      LEFT_SUPER = _fife.Key_LEFT_SUPER 
 2266      ALT_GR = _fife.Key_ALT_GR 
 2267      COMPOSE = _fife.Key_COMPOSE 
 2268      HELP = _fife.Key_HELP 
 2269      PRINT_SCREEN = _fife.Key_PRINT_SCREEN 
 2270      SYSREQ = _fife.Key_SYSREQ 
 2271      BREAK = _fife.Key_BREAK 
 2272      MENU = _fife.Key_MENU 
 2273      POWER = _fife.Key_POWER 
 2274      EURO = _fife.Key_EURO 
 2275      UNDO = _fife.Key_UNDO 
 2276 -    def __init__(self, *args):  
 2277          """ 
 2278          __init__(self, KeyType key = INVALID_KEY, uint32_t codepoint = 0) -> Key 
 2279          __init__(self, KeyType key = INVALID_KEY) -> Key 
 2280          __init__(self) -> Key 
 2281          """ 
 2282          this = _fife.new_Key(*args) 
 2283          try: self.this.append(this) 
 2284          except: self.this = this 
 2285      __swig_destroy__ = _fife.delete_Key 
 2286      __del__ = lambda self : None; 
 2287 -    def isPrintable(self): 
 2288          """isPrintable(self) -> bool""" 
 2289          return _fife.Key_isPrintable(self) 
 2290   
 2291 -    def isFunctionKey(self): 
 2292          """isFunctionKey(self) -> bool""" 
 2293          return _fife.Key_isFunctionKey(self) 
 2294   
 2295 -    def getValue(self): 
 2296          """getValue(self) -> KeyType""" 
 2297          return _fife.Key_getValue(self) 
 2298   
 2299 -    def getAsString(self): 
 2300          """getAsString(self) -> string""" 
 2301          return _fife.Key_getAsString(self) 
 2302   
 2303  Key_swigregister = _fife.Key_swigregister 
 2304  Key_swigregister(Key) 
 2305   
 2306  ES_ENGINE = _fife.ES_ENGINE 
 2307  ES_GUICHAN_WIDGET = _fife.ES_GUICHAN_WIDGET 
 2308  CMD_UNKNOWN = _fife.CMD_UNKNOWN 
 2309  CMD_QUIT_GAME = _fife.CMD_QUIT_GAME 
 2310  CMD_MOUSE_FOCUS_GAINED = _fife.CMD_MOUSE_FOCUS_GAINED 
 2311  CMD_MOUSE_FOCUS_LOST = _fife.CMD_MOUSE_FOCUS_LOST 
 2312  CMD_INPUT_FOCUS_GAINED = _fife.CMD_INPUT_FOCUS_GAINED 
 2313  CMD_INPUT_FOCUS_LOST = _fife.CMD_INPUT_FOCUS_LOST 
 2314  CMD_APP_RESTORED = _fife.CMD_APP_RESTORED 
 2315  CMD_APP_ICONIFIED = _fife.CMD_APP_ICONIFIED 
 2316 -class IEventSource(_object): 
 2317      """Proxy of C++ FIFE::IEventSource class""" 
 2318      __swig_setmethods__ = {} 
 2319      __setattr__ = lambda self, name, value: _swig_setattr(self, IEventSource, name, value) 
 2320      __swig_getmethods__ = {} 
 2321      __getattr__ = lambda self, name: _swig_getattr(self, IEventSource, name) 
 2322      __repr__ = _swig_repr 
 2323 -    def getEventSourceType(self): 
 2324          """getEventSourceType(self) -> EventSourceType""" 
 2325          return _fife.IEventSource_getEventSourceType(self) 
 2326   
 2327      __swig_destroy__ = _fife.delete_IEventSource 
 2328      __del__ = lambda self : None; 
 2329 -    def __init__(self):  
 2330          """__init__(self) -> IEventSource""" 
 2331          if self.__class__ == IEventSource: 
 2332              _self = None 
 2333          else: 
 2334              _self = self 
 2335          this = _fife.new_IEventSource(_self, ) 
 2336          try: self.this.append(this) 
 2337          except: self.this = this 
 2338 -    def __disown__(self): 
 2339          self.this.disown() 
 2340          _fife.disown_IEventSource(self) 
 2341          return weakref_proxy(self) 
 2342  IEventSource_swigregister = _fife.IEventSource_swigregister 
 2343  IEventSource_swigregister(IEventSource) 
 2344   
 2345 -class Event(_object): 
 2346      """Proxy of C++ FIFE::Event class""" 
 2347      __swig_setmethods__ = {} 
 2348      __setattr__ = lambda self, name, value: _swig_setattr(self, Event, name, value) 
 2349      __swig_getmethods__ = {} 
 2350      __getattr__ = lambda self, name: _swig_getattr(self, Event, name) 
 2351 -    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") 
 2352      __repr__ = _swig_repr 
 2353 -    def consume(self): 
 2354          """consume(self)""" 
 2355          return _fife.Event_consume(self) 
 2356   
 2357 -    def isConsumed(self): 
 2358          """isConsumed(self) -> bool""" 
 2359          return _fife.Event_isConsumed(self) 
 2360   
 2361 -    def getSource(self): 
 2362          """getSource(self) -> IEventSource""" 
 2363          return _fife.Event_getSource(self) 
 2364   
 2365 -    def getTimeStamp(self): 
 2366          """getTimeStamp(self) -> int""" 
 2367          return _fife.Event_getTimeStamp(self) 
 2368   
 2369 -    def getDebugString(self): 
 2370          """getDebugString(self) -> string""" 
 2371          return _fife.Event_getDebugString(self) 
 2372   
 2373 -    def getName(self): 
 2374          """getName(self) -> string""" 
 2375          return _fife.Event_getName(self) 
 2376   
 2377      __swig_destroy__ = _fife.delete_Event 
 2378      __del__ = lambda self : None; 
 2379  Event_swigregister = _fife.Event_swigregister 
 2380  Event_swigregister(Event) 
 2381   
 2382 -class InputEvent(Event): 
 2383      """Proxy of C++ FIFE::InputEvent class""" 
 2384      __swig_setmethods__ = {} 
 2385      for _s in [Event]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) 
 2386      __setattr__ = lambda self, name, value: _swig_setattr(self, InputEvent, name, value) 
 2387      __swig_getmethods__ = {} 
 2388      for _s in [Event]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) 
 2389      __getattr__ = lambda self, name: _swig_getattr(self, InputEvent, name) 
 2390 -    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") 
 2391      __repr__ = _swig_repr 
 2392 -    def isConsumedByWidgets(self): 
 2393          """isConsumedByWidgets(self) -> bool""" 
 2394          return _fife.InputEvent_isConsumedByWidgets(self) 
 2395   
 2396 -    def isAltPressed(self): 
 2397          """isAltPressed(self) -> bool""" 
 2398          return _fife.InputEvent_isAltPressed(self) 
 2399   
 2400 -    def isControlPressed(self): 
 2401          """isControlPressed(self) -> bool""" 
 2402          return _fife.InputEvent_isControlPressed(self) 
 2403   
 2404 -    def isMetaPressed(self): 
 2405          """isMetaPressed(self) -> bool""" 
 2406          return _fife.InputEvent_isMetaPressed(self) 
 2407   
 2408 -    def isShiftPressed(self): 
 2409          """isShiftPressed(self) -> bool""" 
 2410          return _fife.InputEvent_isShiftPressed(self) 
 2411   
 2412      __swig_destroy__ = _fife.delete_InputEvent 
 2413      __del__ = lambda self : None; 
 2414  InputEvent_swigregister = _fife.InputEvent_swigregister 
 2415  InputEvent_swigregister(InputEvent) 
 2416   
 2417 -class Command(Event): 
 2418      """Proxy of C++ FIFE::Command class""" 
 2419      __swig_setmethods__ = {} 
 2420      for _s in [Event]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) 
 2421      __setattr__ = lambda self, name, value: _swig_setattr(self, Command, name, value) 
 2422      __swig_getmethods__ = {} 
 2423      for _s in [Event]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) 
 2424      __getattr__ = lambda self, name: _swig_getattr(self, Command, name) 
 2425      __repr__ = _swig_repr 
 2426 -    def __init__(self):  
 2427          """__init__(self) -> Command""" 
 2428          this = _fife.new_Command() 
 2429          try: self.this.append(this) 
 2430          except: self.this = this 
 2431      __swig_destroy__ = _fife.delete_Command 
 2432      __del__ = lambda self : None; 
 2433 -    def getCommandType(self): 
 2434          """getCommandType(self) -> CommandType""" 
 2435          return _fife.Command_getCommandType(self) 
 2436   
 2437 -    def setCommandType(self, *args): 
 2438          """setCommandType(self, CommandType type)""" 
 2439          return _fife.Command_setCommandType(self, *args) 
 2440   
 2441 -    def getCode(self): 
 2442          """getCode(self) -> int""" 
 2443          return _fife.Command_getCode(self) 
 2444   
 2445 -    def setCode(self, *args): 
 2446          """setCode(self, int code)""" 
 2447          return _fife.Command_setCode(self, *args) 
 2448   
 2449 -    def setSource(self, *args): 
 2450          """setSource(self, IEventSource source)""" 
 2451          return _fife.Command_setSource(self, *args) 
 2452   
 2453 -    def setTimeStamp(self, *args): 
 2454          """setTimeStamp(self, int timestamp)""" 
 2455          return _fife.Command_setTimeStamp(self, *args) 
 2456   
 2457  Command_swigregister = _fife.Command_swigregister 
 2458  Command_swigregister(Command) 
 2459   
 2460 -class ICommandListener(_object): 
 2461      """Proxy of C++ FIFE::ICommandListener class""" 
 2462      __swig_setmethods__ = {} 
 2463      __setattr__ = lambda self, name, value: _swig_setattr(self, ICommandListener, name, value) 
 2464      __swig_getmethods__ = {} 
 2465      __getattr__ = lambda self, name: _swig_getattr(self, ICommandListener, name) 
 2466      __repr__ = _swig_repr 
 2467 -    def onCommand(self, *args): 
 2468          """onCommand(self, Command command)""" 
 2469          return _fife.ICommandListener_onCommand(self, *args) 
 2470   
 2471      __swig_destroy__ = _fife.delete_ICommandListener 
 2472      __del__ = lambda self : None; 
 2473 -    def __init__(self):  
 2474          """__init__(self) -> ICommandListener""" 
 2475          if self.__class__ == ICommandListener: 
 2476              _self = None 
 2477          else: 
 2478              _self = self 
 2479          this = _fife.new_ICommandListener(_self, ) 
 2480          try: self.this.append(this) 
 2481          except: self.this = this 
 2482 -    def __disown__(self): 
 2483          self.this.disown() 
 2484          _fife.disown_ICommandListener(self) 
 2485          return weakref_proxy(self) 
 2486  ICommandListener_swigregister = _fife.ICommandListener_swigregister 
 2487  ICommandListener_swigregister(ICommandListener) 
 2488   
 2489 -class KeyEvent(InputEvent): 
 2490      """Proxy of C++ FIFE::KeyEvent class""" 
 2491      __swig_setmethods__ = {} 
 2492      for _s in [InputEvent]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) 
 2493      __setattr__ = lambda self, name, value: _swig_setattr(self, KeyEvent, name, value) 
 2494      __swig_getmethods__ = {} 
 2495      for _s in [InputEvent]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) 
 2496      __getattr__ = lambda self, name: _swig_getattr(self, KeyEvent, name) 
 2497 -    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") 
 2498      __repr__ = _swig_repr 
 2499      UNKNOWN = _fife.KeyEvent_UNKNOWN 
 2500      PRESSED = _fife.KeyEvent_PRESSED 
 2501      RELEASED = _fife.KeyEvent_RELEASED 
 2502 -    def getType(self): 
 2503          """getType(self) -> KeyEventType""" 
 2504          return _fife.KeyEvent_getType(self) 
 2505   
 2506 -    def isNumericPad(self): 
 2507          """isNumericPad(self) -> bool""" 
 2508          return _fife.KeyEvent_isNumericPad(self) 
 2509   
 2510 -    def getKey(self): 
 2511          """getKey(self) -> Key""" 
 2512          return _fife.KeyEvent_getKey(self) 
 2513   
 2514      __swig_destroy__ = _fife.delete_KeyEvent 
 2515      __del__ = lambda self : None; 
 2516  KeyEvent_swigregister = _fife.KeyEvent_swigregister 
 2517  KeyEvent_swigregister(KeyEvent) 
 2518   
 2519 -class IKeyListener(_object): 
 2520      """Proxy of C++ FIFE::IKeyListener class""" 
 2521      __swig_setmethods__ = {} 
 2522      __setattr__ = lambda self, name, value: _swig_setattr(self, IKeyListener, name, value) 
 2523      __swig_getmethods__ = {} 
 2524      __getattr__ = lambda self, name: _swig_getattr(self, IKeyListener, name) 
 2525      __repr__ = _swig_repr 
 2526 -    def keyPressed(self, *args): 
 2527          """keyPressed(self, KeyEvent evt)""" 
 2528          return _fife.IKeyListener_keyPressed(self, *args) 
 2529   
 2530 -    def keyReleased(self, *args): 
 2531          """keyReleased(self, KeyEvent evt)""" 
 2532          return _fife.IKeyListener_keyReleased(self, *args) 
 2533   
 2534      __swig_destroy__ = _fife.delete_IKeyListener 
 2535      __del__ = lambda self : None; 
 2536 -    def __init__(self):  
 2537          """__init__(self) -> IKeyListener""" 
 2538          if self.__class__ == IKeyListener: 
 2539              _self = None 
 2540          else: 
 2541              _self = self 
 2542          this = _fife.new_IKeyListener(_self, ) 
 2543          try: self.this.append(this) 
 2544          except: self.this = this 
 2545 -    def __disown__(self): 
 2546          self.this.disown() 
 2547          _fife.disown_IKeyListener(self) 
 2548          return weakref_proxy(self) 
 2549  IKeyListener_swigregister = _fife.IKeyListener_swigregister 
 2550  IKeyListener_swigregister(IKeyListener) 
 2551   
 2552 -class MouseEvent(InputEvent): 
 2553      """Proxy of C++ FIFE::MouseEvent class""" 
 2554      __swig_setmethods__ = {} 
 2555      for _s in [InputEvent]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) 
 2556      __setattr__ = lambda self, name, value: _swig_setattr(self, MouseEvent, name, value) 
 2557      __swig_getmethods__ = {} 
 2558      for _s in [InputEvent]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) 
 2559      __getattr__ = lambda self, name: _swig_getattr(self, MouseEvent, name) 
 2560 -    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") 
 2561      __repr__ = _swig_repr 
 2562      UNKNOWN_EVENT = _fife.MouseEvent_UNKNOWN_EVENT 
 2563      MOVED = _fife.MouseEvent_MOVED 
 2564      PRESSED = _fife.MouseEvent_PRESSED 
 2565      RELEASED = _fife.MouseEvent_RELEASED 
 2566      WHEEL_MOVED_DOWN = _fife.MouseEvent_WHEEL_MOVED_DOWN 
 2567      WHEEL_MOVED_UP = _fife.MouseEvent_WHEEL_MOVED_UP 
 2568      CLICKED = _fife.MouseEvent_CLICKED 
 2569      ENTERED = _fife.MouseEvent_ENTERED 
 2570      EXITED = _fife.MouseEvent_EXITED 
 2571      DRAGGED = _fife.MouseEvent_DRAGGED 
 2572      EMPTY = _fife.MouseEvent_EMPTY 
 2573      LEFT = _fife.MouseEvent_LEFT 
 2574      RIGHT = _fife.MouseEvent_RIGHT 
 2575      MIDDLE = _fife.MouseEvent_MIDDLE 
 2576      UNKNOWN_BUTTON = _fife.MouseEvent_UNKNOWN_BUTTON 
 2577 -    def getX(self): 
 2578          """getX(self) -> int""" 
 2579          return _fife.MouseEvent_getX(self) 
 2580   
 2581 -    def getY(self): 
 2582          """getY(self) -> int""" 
 2583          return _fife.MouseEvent_getY(self) 
 2584   
 2585 -    def getType(self): 
 2586          """getType(self) -> MouseEventType""" 
 2587          return _fife.MouseEvent_getType(self) 
 2588   
 2589 -    def getButton(self): 
 2590          """getButton(self) -> MouseButtonType""" 
 2591          return _fife.MouseEvent_getButton(self) 
 2592   
 2593      __swig_destroy__ = _fife.delete_MouseEvent 
 2594      __del__ = lambda self : None; 
 2595  MouseEvent_swigregister = _fife.MouseEvent_swigregister 
 2596  MouseEvent_swigregister(MouseEvent) 
 2597   
 2598 -class IMouseListener(_object): 
 2599      """Proxy of C++ FIFE::IMouseListener class""" 
 2600      __swig_setmethods__ = {} 
 2601      __setattr__ = lambda self, name, value: _swig_setattr(self, IMouseListener, name, value) 
 2602      __swig_getmethods__ = {} 
 2603      __getattr__ = lambda self, name: _swig_getattr(self, IMouseListener, name) 
 2604      __repr__ = _swig_repr 
 2605 -    def mouseEntered(self, *args): 
 2606          """mouseEntered(self, MouseEvent evt)""" 
 2607          return _fife.IMouseListener_mouseEntered(self, *args) 
 2608   
 2609 -    def mouseExited(self, *args): 
 2610          """mouseExited(self, MouseEvent evt)""" 
 2611          return _fife.IMouseListener_mouseExited(self, *args) 
 2612   
 2613 -    def mousePressed(self, *args): 
 2614          """mousePressed(self, MouseEvent evt)""" 
 2615          return _fife.IMouseListener_mousePressed(self, *args) 
 2616   
 2617 -    def mouseReleased(self, *args): 
 2618          """mouseReleased(self, MouseEvent evt)""" 
 2619          return _fife.IMouseListener_mouseReleased(self, *args) 
 2620   
 2621 -    def mouseClicked(self, *args): 
 2622          """mouseClicked(self, MouseEvent evt)""" 
 2623          return _fife.IMouseListener_mouseClicked(self, *args) 
 2624   
 2625 -    def mouseWheelMovedUp(self, *args): 
 2626          """mouseWheelMovedUp(self, MouseEvent evt)""" 
 2627          return _fife.IMouseListener_mouseWheelMovedUp(self, *args) 
 2628   
 2629 -    def mouseWheelMovedDown(self, *args): 
 2630          """mouseWheelMovedDown(self, MouseEvent evt)""" 
 2631          return _fife.IMouseListener_mouseWheelMovedDown(self, *args) 
 2632   
 2633 -    def mouseMoved(self, *args): 
 2634          """mouseMoved(self, MouseEvent evt)""" 
 2635          return _fife.IMouseListener_mouseMoved(self, *args) 
 2636   
 2637 -    def mouseDragged(self, *args): 
 2638          """mouseDragged(self, MouseEvent evt)""" 
 2639          return _fife.IMouseListener_mouseDragged(self, *args) 
 2640   
 2641      __swig_destroy__ = _fife.delete_IMouseListener 
 2642      __del__ = lambda self : None; 
 2643 -    def __init__(self):  
 2644          """__init__(self) -> IMouseListener""" 
 2645          if self.__class__ == IMouseListener: 
 2646              _self = None 
 2647          else: 
 2648              _self = self 
 2649          this = _fife.new_IMouseListener(_self, ) 
 2650          try: self.this.append(this) 
 2651          except: self.this = this 
 2652 -    def __disown__(self): 
 2653          self.this.disown() 
 2654          _fife.disown_IMouseListener(self) 
 2655          return weakref_proxy(self) 
 2656  IMouseListener_swigregister = _fife.IMouseListener_swigregister 
 2657  IMouseListener_swigregister(IMouseListener) 
 2658   
 2659 -class IKeyFilter(_object): 
 2660      """Proxy of C++ FIFE::IKeyFilter class""" 
 2661      __swig_setmethods__ = {} 
 2662      __setattr__ = lambda self, name, value: _swig_setattr(self, IKeyFilter, name, value) 
 2663      __swig_getmethods__ = {} 
 2664      __getattr__ = lambda self, name: _swig_getattr(self, IKeyFilter, name) 
 2665      __repr__ = _swig_repr 
 2666 -    def isFiltered(self, *args): 
 2667          """isFiltered(self, KeyEvent evt) -> bool""" 
 2668          return _fife.IKeyFilter_isFiltered(self, *args) 
 2669   
 2670      __swig_destroy__ = _fife.delete_IKeyFilter 
 2671      __del__ = lambda self : None; 
 2672 -    def __init__(self):  
 2673          """__init__(self) -> IKeyFilter""" 
 2674          if self.__class__ == IKeyFilter: 
 2675              _self = None 
 2676          else: 
 2677              _self = self 
 2678          this = _fife.new_IKeyFilter(_self, ) 
 2679          try: self.this.append(this) 
 2680          except: self.this = this 
 2681 -    def __disown__(self): 
 2682          self.this.disown() 
 2683          _fife.disown_IKeyFilter(self) 
 2684          return weakref_proxy(self) 
 2685  IKeyFilter_swigregister = _fife.IKeyFilter_swigregister 
 2686  IKeyFilter_swigregister(IKeyFilter) 
 2687   
 2688 -class EventManager(_object): 
 2689      """Proxy of C++ FIFE::EventManager class""" 
 2690      __swig_setmethods__ = {} 
 2691      __setattr__ = lambda self, name, value: _swig_setattr(self, EventManager, name, value) 
 2692      __swig_getmethods__ = {} 
 2693      __getattr__ = lambda self, name: _swig_getattr(self, EventManager, name) 
 2694      __repr__ = _swig_repr 
 2695 -    def __init__(self):  
 2696          """__init__(self) -> EventManager""" 
 2697          this = _fife.new_EventManager() 
 2698          try: self.this.append(this) 
 2699          except: self.this = this 
 2700      __swig_destroy__ = _fife.delete_EventManager 
 2701      __del__ = lambda self : None; 
 2702 -    def addCommandListener(self, *args): 
 2703          """addCommandListener(self, ICommandListener listener)""" 
 2704          return _fife.EventManager_addCommandListener(self, *args) 
 2705   
 2706 -    def addCommandListenerFront(self, *args): 
 2707          """addCommandListenerFront(self, ICommandListener listener)""" 
 2708          return _fife.EventManager_addCommandListenerFront(self, *args) 
 2709   
 2710 -    def removeCommandListener(self, *args): 
 2711          """removeCommandListener(self, ICommandListener listener)""" 
 2712          return _fife.EventManager_removeCommandListener(self, *args) 
 2713   
 2714 -    def addKeyListener(self, *args): 
 2715          """addKeyListener(self, IKeyListener listener)""" 
 2716          return _fife.EventManager_addKeyListener(self, *args) 
 2717   
 2718 -    def addKeyListenerFront(self, *args): 
 2719          """addKeyListenerFront(self, IKeyListener listener)""" 
 2720          return _fife.EventManager_addKeyListenerFront(self, *args) 
 2721   
 2722 -    def removeKeyListener(self, *args): 
 2723          """removeKeyListener(self, IKeyListener listener)""" 
 2724          return _fife.EventManager_removeKeyListener(self, *args) 
 2725   
 2726 -    def addMouseListener(self, *args): 
 2727          """addMouseListener(self, IMouseListener listener)""" 
 2728          return _fife.EventManager_addMouseListener(self, *args) 
 2729   
 2730 -    def addMouseListenerFront(self, *args): 
 2731          """addMouseListenerFront(self, IMouseListener listener)""" 
 2732          return _fife.EventManager_addMouseListenerFront(self, *args) 
 2733   
 2734 -    def removeMouseListener(self, *args): 
 2735          """removeMouseListener(self, IMouseListener listener)""" 
 2736          return _fife.EventManager_removeMouseListener(self, *args) 
 2737   
 2738 -    def getEventSourceType(self): 
 2739          """getEventSourceType(self) -> EventSourceType""" 
 2740          return _fife.EventManager_getEventSourceType(self) 
 2741   
 2742 -    def dispatchCommand(self, *args): 
 2743          """dispatchCommand(self, Command command)""" 
 2744          return _fife.EventManager_dispatchCommand(self, *args) 
 2745   
 2746 -    def setKeyFilter(self, *args): 
 2747          """setKeyFilter(self, IKeyFilter keyFilter)""" 
 2748          return _fife.EventManager_setKeyFilter(self, *args) 
 2749   
 2750  EventManager_swigregister = _fife.EventManager_swigregister 
 2751  EventManager_swigregister(EventManager) 
 2752   
 2753 -class AbstractFont(_object): 
 2754      """Proxy of C++ FIFE::AbstractFont class""" 
 2755      __swig_setmethods__ = {} 
 2756      __setattr__ = lambda self, name, value: _swig_setattr(self, AbstractFont, name, value) 
 2757      __swig_getmethods__ = {} 
 2758      __getattr__ = lambda self, name: _swig_getattr(self, AbstractFont, name) 
 2759 -    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") 
 2760      __repr__ = _swig_repr 
 2761      __swig_destroy__ = _fife.delete_AbstractFont 
 2762      __del__ = lambda self : None; 
 2763 -    def setRowSpacing(self, *args): 
 2764          """setRowSpacing(self, int spacing)""" 
 2765          return _fife.AbstractFont_setRowSpacing(self, *args) 
 2766   
 2767 -    def getRowSpacing(self): 
 2768          """getRowSpacing(self) -> int""" 
 2769          return _fife.AbstractFont_getRowSpacing(self) 
 2770   
 2771 -    def setGlyphSpacing(self, *args): 
 2772          """setGlyphSpacing(self, int spacing)""" 
 2773          return _fife.AbstractFont_setGlyphSpacing(self, *args) 
 2774   
 2775 -    def getGlyphSpacing(self): 
 2776          """getGlyphSpacing(self) -> int""" 
 2777          return _fife.AbstractFont_getGlyphSpacing(self) 
 2778   
 2779 -    def setAntiAlias(self, *args): 
 2780          """setAntiAlias(self, bool antiAlias)""" 
 2781          return _fife.AbstractFont_setAntiAlias(self, *args) 
 2782   
 2783 -    def isAntiAlias(self): 
 2784          """isAntiAlias(self) -> bool""" 
 2785          return _fife.AbstractFont_isAntiAlias(self) 
 2786   
 2787 -    def setColor(self, *args): 
 2788          """ 
 2789          setColor(self, uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255) 
 2790          setColor(self, uint8_t r, uint8_t g, uint8_t b) 
 2791          """ 
 2792          return _fife.AbstractFont_setColor(self, *args) 
 2793   
 2794 -    def getColor(self): 
 2795          """getColor(self) -> SDL_Color""" 
 2796          return _fife.AbstractFont_getColor(self) 
 2797   
 2798 -    def getWidth(self, *args): 
 2799          """getWidth(self, string text) -> int""" 
 2800          return _fife.AbstractFont_getWidth(self, *args) 
 2801   
 2802 -    def getHeight(self): 
 2803          """getHeight(self) -> int""" 
 2804          return _fife.AbstractFont_getHeight(self) 
 2805   
 2806  AbstractFont_swigregister = _fife.AbstractFont_swigregister 
 2807  AbstractFont_swigregister(AbstractFont) 
 2808   
 2809 -class FontBase(AbstractFont): 
 2810      """Proxy of C++ FIFE::FontBase class""" 
 2811      __swig_setmethods__ = {} 
 2812      for _s in [AbstractFont]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) 
 2813      __setattr__ = lambda self, name, value: _swig_setattr(self, FontBase, name, value) 
 2814      __swig_getmethods__ = {} 
 2815      for _s in [AbstractFont]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) 
 2816      __getattr__ = lambda self, name: _swig_getattr(self, FontBase, name) 
 2817 -    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") 
 2818      __repr__ = _swig_repr 
 2819      __swig_destroy__ = _fife.delete_FontBase 
 2820      __del__ = lambda self : None; 
 2821  FontBase_swigregister = _fife.FontBase_swigregister 
 2822  FontBase_swigregister(FontBase) 
 2823   
 2824 -class TTFont(FontBase): 
 2825      """Proxy of C++ FIFE::TrueTypeFont class""" 
 2826      __swig_setmethods__ = {} 
 2827      for _s in [FontBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) 
 2828      __setattr__ = lambda self, name, value: _swig_setattr(self, TTFont, name, value) 
 2829      __swig_getmethods__ = {} 
 2830      for _s in [FontBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) 
 2831      __getattr__ = lambda self, name: _swig_getattr(self, TTFont, name) 
 2832      __repr__ = _swig_repr 
 2833 -    def __init__(self, *args):  
 2834          """__init__(self, string filename, int size) -> TTFont""" 
 2835          this = _fife.new_TTFont(*args) 
 2836          try: self.this.append(this) 
 2837          except: self.this = this 
 2838      __swig_destroy__ = _fife.delete_TTFont 
 2839      __del__ = lambda self : None; 
 2840 -    def setColor(self, *args): 
 2841          """ 
 2842          setColor(self, Uint8 r, Uint8 g, Uint8 b, Uint8 a = 255) 
 2843          setColor(self, Uint8 r, Uint8 g, Uint8 b) 
 2844          """ 
 2845          return _fife.TTFont_setColor(self, *args) 
 2846   
 2847 -    def getWidth(self, *args): 
 2848          """getWidth(self, string text) -> int""" 
 2849          return _fife.TTFont_getWidth(self, *args) 
 2850   
 2851 -    def getHeight(self): 
 2852          """getHeight(self) -> int""" 
 2853          return _fife.TTFont_getHeight(self) 
 2854   
 2855  TTFont_swigregister = _fife.TTFont_swigregister 
 2856  TTFont_swigregister(TTFont) 
 2857   
 2858 -class SubImageFont(FontBase): 
 2859      """Proxy of C++ FIFE::SubImageFont class""" 
 2860      __swig_setmethods__ = {} 
 2861      for _s in [FontBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) 
 2862      __setattr__ = lambda self, name, value: _swig_setattr(self, SubImageFont, name, value) 
 2863      __swig_getmethods__ = {} 
 2864      for _s in [FontBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) 
 2865      __getattr__ = lambda self, name: _swig_getattr(self, SubImageFont, name) 
 2866      __repr__ = _swig_repr 
 2867 -    def __init__(self, *args):  
 2868          """__init__(self, string filename, string glyphs, ImagePool pool) -> SubImageFont""" 
 2869          this = _fife.new_SubImageFont(*args) 
 2870          try: self.this.append(this) 
 2871          except: self.this = this 
 2872      __swig_destroy__ = _fife.delete_SubImageFont 
 2873      __del__ = lambda self : None; 
 2874 -    def setColor(self, *args): 
 2875          """ 
 2876          setColor(self, Uint8 r, Uint8 g, Uint8 b, Uint8 a = 255) 
 2877          setColor(self, Uint8 r, Uint8 g, Uint8 b) 
 2878          """ 
 2879          return _fife.SubImageFont_setColor(self, *args) 
 2880   
 2881 -    def getWidth(self, *args): 
 2882          """getWidth(self, string text) -> int""" 
 2883          return _fife.SubImageFont_getWidth(self, *args) 
 2884   
 2885 -    def getHeight(self): 
 2886          """getHeight(self) -> int""" 
 2887          return _fife.SubImageFont_getHeight(self) 
 2888   
 2889  SubImageFont_swigregister = _fife.SubImageFont_swigregister 
 2890  SubImageFont_swigregister(SubImageFont) 
 2891   
 2892 -class Font(_object): 
 2893      """Proxy of C++ gcn::Font class""" 
 2894      __swig_setmethods__ = {} 
 2895      __setattr__ = lambda self, name, value: _swig_setattr(self, Font, name, value) 
 2896      __swig_getmethods__ = {} 
 2897      __getattr__ = lambda self, name: _swig_getattr(self, Font, name) 
 2898 -    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") 
 2899      __repr__ = _swig_repr 
 2900      __swig_destroy__ = _fife.delete_Font 
 2901      __del__ = lambda self : None; 
 2902 -    def getWidth(self, *args): 
 2903          """getWidth(self, string text) -> int""" 
 2904          return _fife.Font_getWidth(self, *args) 
 2905   
 2906 -    def getHeight(self): 
 2907          """getHeight(self) -> int""" 
 2908          return _fife.Font_getHeight(self) 
 2909   
 2910  Font_swigregister = _fife.Font_swigregister 
 2911  Font_swigregister(Font) 
 2912   
 2913 -class GuiFont(Font,AbstractFont): 
 2914      """Proxy of C++ FIFE::GuiFont class""" 
 2915      __swig_setmethods__ = {} 
 2916      for _s in [Font,AbstractFont]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) 
 2917      __setattr__ = lambda self, name, value: _swig_setattr(self, GuiFont, name, value) 
 2918      __swig_getmethods__ = {} 
 2919      for _s in [Font,AbstractFont]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) 
 2920      __getattr__ = lambda self, name: _swig_getattr(self, GuiFont, name) 
 2921      __repr__ = _swig_repr 
 2922 -    def __init__(self, *args):  
 2923          """__init__(self, AbstractFont font) -> GuiFont""" 
 2924          this = _fife.new_GuiFont(*args) 
 2925          try: self.this.append(this) 
 2926          except: self.this = this 
 2927      __swig_destroy__ = _fife.delete_GuiFont 
 2928      __del__ = lambda self : None; 
 2929 -    def getStringIndexAt(self, *args): 
 2930          """getStringIndexAt(self, string text, int x) -> int""" 
 2931          return _fife.GuiFont_getStringIndexAt(self, *args) 
 2932   
 2933 -    def drawString(self, *args): 
 2934          """drawString(self, Graphics graphics, string text, int x, int y)""" 
 2935          return _fife.GuiFont_drawString(self, *args) 
 2936   
 2937 -    def setRowSpacing(self, *args): 
 2938          """setRowSpacing(self, int spacing)""" 
 2939          return _fife.GuiFont_setRowSpacing(self, *args) 
 2940   
 2941 -    def getRowSpacing(self): 
 2942          """getRowSpacing(self) -> int""" 
 2943          return _fife.GuiFont_getRowSpacing(self) 
 2944   
 2945 -    def setGlyphSpacing(self, *args): 
 2946          """setGlyphSpacing(self, int spacing)""" 
 2947          return _fife.GuiFont_setGlyphSpacing(self, *args) 
 2948   
 2949 -    def getGlyphSpacing(self): 
 2950          """getGlyphSpacing(self) -> int""" 
 2951          return _fife.GuiFont_getGlyphSpacing(self) 
 2952   
 2953 -    def setAntiAlias(self, *args): 
 2954          """setAntiAlias(self, bool antiAlias)""" 
 2955          return _fife.GuiFont_setAntiAlias(self, *args) 
 2956   
 2957 -    def isAntiAlias(self): 
 2958          """isAntiAlias(self) -> bool""" 
 2959          return _fife.GuiFont_isAntiAlias(self) 
 2960   
 2961 -    def getAsImage(self, *args): 
 2962          """getAsImage(self, string text) -> Image""" 
 2963          return _fife.GuiFont_getAsImage(self, *args) 
 2964   
 2965 -    def setColor(self, *args): 
 2966          """ 
 2967          setColor(self, uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255) 
 2968          setColor(self, uint8_t r, uint8_t g, uint8_t b) 
 2969          """ 
 2970          return _fife.GuiFont_setColor(self, *args) 
 2971   
 2972 -    def getColor(self): 
 2973          """getColor(self) -> SDL_Color""" 
 2974          return _fife.GuiFont_getColor(self) 
 2975   
 2976 -    def getWidth(self, *args): 
 2977          """getWidth(self, string text) -> int""" 
 2978          return _fife.GuiFont_getWidth(self, *args) 
 2979   
 2980 -    def getHeight(self): 
 2981          """getHeight(self) -> int""" 
 2982          return _fife.GuiFont_getHeight(self) 
 2983   
 2984  GuiFont_swigregister = _fife.GuiFont_swigregister 
 2985  GuiFont_swigregister(GuiFont) 
 2986   
 2987 -class GcnImage(_object): 
 2988      """Proxy of C++ gcn::Image class""" 
 2989      __swig_setmethods__ = {} 
 2990      __setattr__ = lambda self, name, value: _swig_setattr(self, GcnImage, name, value) 
 2991      __swig_getmethods__ = {} 
 2992      __getattr__ = lambda self, name: _swig_getattr(self, GcnImage, name) 
 2993 -    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") 
 2994      __repr__ = _swig_repr 
 2995      __swig_destroy__ = _fife.delete_GcnImage 
 2996      __del__ = lambda self : None; 
 2997 -    def load(*args): 
 2998          """ 
 2999          load(string filename, bool convertToDisplayFormat = True) -> GcnImage 
 3000          load(string filename) -> GcnImage 
 3001          """ 
 3002          return _fife.GcnImage_load(*args) 
 3003   
 3004      if _newclass:load = staticmethod(load) 
 3005      __swig_getmethods__["load"] = lambda x: load 
 3006 -    def getWidth(self): 
 3007          """getWidth(self) -> int""" 
 3008          return _fife.GcnImage_getWidth(self) 
 3009   
 3010 -    def getHeight(self): 
 3011          """getHeight(self) -> int""" 
 3012          return _fife.GcnImage_getHeight(self) 
 3013   
 3014  GcnImage_swigregister = _fife.GcnImage_swigregister 
 3015  GcnImage_swigregister(GcnImage) 
 3016   
 3017 -def GcnImage_load(*args): 
 3018    """ 
 3019      load(string filename, bool convertToDisplayFormat = True) -> GcnImage 
 3020      GcnImage_load(string filename) -> GcnImage 
 3021      """ 
 3022    return _fife.GcnImage_load(*args) 
 3023   
 3024 -class GuiImage(GcnImage): 
 3025      """Proxy of C++ FIFE::GuiImage class""" 
 3026      __swig_setmethods__ = {} 
 3027      for _s in [GcnImage]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) 
 3028      __setattr__ = lambda self, name, value: _swig_setattr(self, GuiImage, name, value) 
 3029      __swig_getmethods__ = {} 
 3030      for _s in [GcnImage]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) 
 3031      __getattr__ = lambda self, name: _swig_getattr(self, GuiImage, name) 
 3032      __repr__ = _swig_repr 
 3033 -    def __init__(self, *args):  
 3034          """ 
 3035          __init__(self) -> GuiImage 
 3036          __init__(self, int id, ImagePool pool) -> GuiImage 
 3037          """ 
 3038          this = _fife.new_GuiImage(*args) 
 3039          try: self.this.append(this) 
 3040          except: self.this = this 
 3041 -    def getWidth(self): 
 3042          """getWidth(self) -> int""" 
 3043          return _fife.GuiImage_getWidth(self) 
 3044   
 3045 -    def getHeight(self): 
 3046          """getHeight(self) -> int""" 
 3047          return _fife.GuiImage_getHeight(self) 
 3048   
 3049      __swig_destroy__ = _fife.delete_GuiImage 
 3050      __del__ = lambda self : None; 
 3051  GuiImage_swigregister = _fife.GuiImage_swigregister 
 3052  GuiImage_swigregister(GuiImage) 
 3053   
 3054 -class ConsoleExecuter(_object): 
 3055      """Proxy of C++ FIFE::ConsoleExecuter class""" 
 3056      __swig_setmethods__ = {} 
 3057      __setattr__ = lambda self, name, value: _swig_setattr(self, ConsoleExecuter, name, value) 
 3058      __swig_getmethods__ = {} 
 3059      __getattr__ = lambda self, name: _swig_getattr(self, ConsoleExecuter, name) 
 3060      __repr__ = _swig_repr 
 3061      __swig_destroy__ = _fife.delete_ConsoleExecuter 
 3062      __del__ = lambda self : None; 
 3063 -    def onToolsClick(self): 
 3064          """onToolsClick(self)""" 
 3065          return _fife.ConsoleExecuter_onToolsClick(self) 
 3066   
 3067 -    def onConsoleCommand(self, *args): 
 3068          """onConsoleCommand(self, string command) -> string""" 
 3069          return _fife.ConsoleExecuter_onConsoleCommand(self, *args) 
 3070   
 3071 -    def __init__(self):  
 3072          """__init__(self) -> ConsoleExecuter""" 
 3073          if self.__class__ == ConsoleExecuter: 
 3074              _self = None 
 3075          else: 
 3076              _self = self 
 3077          this = _fife.new_ConsoleExecuter(_self, ) 
 3078          try: self.this.append(this) 
 3079          except: self.this = this 
 3080 -    def __disown__(self): 
 3081          self.this.disown() 
 3082          _fife.disown_ConsoleExecuter(self) 
 3083          return weakref_proxy(self) 
 3084  ConsoleExecuter_swigregister = _fife.ConsoleExecuter_swigregister 
 3085  ConsoleExecuter_swigregister(ConsoleExecuter) 
 3086   
 3087 -class Console(_object): 
 3088      """Proxy of C++ FIFE::Console class""" 
 3089      __swig_setmethods__ = {} 
 3090      __setattr__ = lambda self, name, value: _swig_setattr(self, Console, name, value) 
 3091      __swig_getmethods__ = {} 
 3092      __getattr__ = lambda self, name: _swig_getattr(self, Console, name) 
 3093      __repr__ = _swig_repr 
 3094 -    def show(self): 
 3095          """show(self)""" 
 3096          return _fife.Console_show(self) 
 3097   
 3098 -    def hide(self): 
 3099          """hide(self)""" 
 3100          return _fife.Console_hide(self) 
 3101   
 3102 -    def clear(self): 
 3103          """clear(self)""" 
 3104          return _fife.Console_clear(self) 
 3105   
 3106 -    def toggleShowHide(self): 
 3107          """toggleShowHide(self)""" 
 3108          return _fife.Console_toggleShowHide(self) 
 3109   
 3110 -    def println(self, *args): 
 3111          """println(self, string s)""" 
 3112          return _fife.Console_println(self, *args) 
 3113   
 3114 -    def setConsoleExecuter(self, *args): 
 3115          """setConsoleExecuter(self, ConsoleExecuter consoleexec)""" 
 3116          return _fife.Console_setConsoleExecuter(self, *args) 
 3117   
 3118 -    def removeConsoleExecuter(self): 
 3119          """removeConsoleExecuter(self)""" 
 3120          return _fife.Console_removeConsoleExecuter(self) 
 3121   
 3122 -    def __init__(self):  
 3123          """__init__(self) -> Console""" 
 3124          this = _fife.new_Console() 
 3125          try: self.this.append(this) 
 3126          except: self.this = this 
 3127      __swig_destroy__ = _fife.delete_Console 
 3128      __del__ = lambda self : None; 
 3129  Console_swigregister = _fife.Console_swigregister 
 3130  Console_swigregister(Console) 
 3131   
 3132 -class MouseListener(_object): 
 3133      """Proxy of C++ gcn::MouseListener class""" 
 3134      __swig_setmethods__ = {} 
 3135      __setattr__ = lambda self, name, value: _swig_setattr(self, MouseListener, name, value) 
 3136      __swig_getmethods__ = {} 
 3137      __getattr__ = lambda self, name: _swig_getattr(self, MouseListener, name) 
 3138      __repr__ = _swig_repr 
 3139      __swig_destroy__ = _fife.delete_MouseListener 
 3140      __del__ = lambda self : None; 
 3141 -    def mouseEntered(self, *args): 
 3142          """mouseEntered(self, gcn::MouseEvent mouseEvent)""" 
 3143          return _fife.MouseListener_mouseEntered(self, *args) 
 3144   
 3145 -    def mouseExited(self, *args): 
 3146          """mouseExited(self, gcn::MouseEvent mouseEvent)""" 
 3147          return _fife.MouseListener_mouseExited(self, *args) 
 3148   
 3149 -    def mousePressed(self, *args): 
 3150          """mousePressed(self, gcn::MouseEvent mouseEvent)""" 
 3151          return _fife.MouseListener_mousePressed(self, *args) 
 3152   
 3153 -    def mouseReleased(self, *args): 
 3154          """mouseReleased(self, gcn::MouseEvent mouseEvent)""" 
 3155          return _fife.MouseListener_mouseReleased(self, *args) 
 3156   
 3157 -    def mouseClicked(self, *args): 
 3158          """mouseClicked(self, gcn::MouseEvent mouseEvent)""" 
 3159          return _fife.MouseListener_mouseClicked(self, *args) 
 3160   
 3161 -    def mouseWheelMovedUp(self, *args): 
 3162          """mouseWheelMovedUp(self, gcn::MouseEvent mouseEvent)""" 
 3163          return _fife.MouseListener_mouseWheelMovedUp(self, *args) 
 3164   
 3165 -    def mouseWheelMovedDown(self, *args): 
 3166          """mouseWheelMovedDown(self, gcn::MouseEvent mouseEvent)""" 
 3167          return _fife.MouseListener_mouseWheelMovedDown(self, *args) 
 3168   
 3169 -    def mouseMoved(self, *args): 
 3170          """mouseMoved(self, gcn::MouseEvent mouseEvent)""" 
 3171          return _fife.MouseListener_mouseMoved(self, *args) 
 3172   
 3173 -    def mouseDragged(self, *args): 
 3174          """mouseDragged(self, gcn::MouseEvent mouseEvent)""" 
 3175          return _fife.MouseListener_mouseDragged(self, *args) 
 3176   
 3177 -    def __init__(self):  
 3178          """__init__(self) -> MouseListener""" 
 3179          if self.__class__ == MouseListener: 
 3180              _self = None 
 3181          else: 
 3182              _self = self 
 3183          this = _fife.new_MouseListener(_self, ) 
 3184          try: self.this.append(this) 
 3185          except: self.this = this 
 3186 -    def __disown__(self): 
 3187          self.this.disown() 
 3188          _fife.disown_MouseListener(self) 
 3189          return weakref_proxy(self) 
 3190  MouseListener_swigregister = _fife.MouseListener_swigregister 
 3191  MouseListener_swigregister(MouseListener) 
 3192   
 3193 -class KeyListener(_object): 
 3194      """Proxy of C++ gcn::KeyListener class""" 
 3195      __swig_setmethods__ = {} 
 3196      __setattr__ = lambda self, name, value: _swig_setattr(self, KeyListener, name, value) 
 3197      __swig_getmethods__ = {} 
 3198      __getattr__ = lambda self, name: _swig_getattr(self, KeyListener, name) 
 3199      __repr__ = _swig_repr 
 3200      __swig_destroy__ = _fife.delete_KeyListener 
 3201      __del__ = lambda self : None; 
 3202 -    def keyPressed(self, *args): 
 3203          """keyPressed(self, gcn::KeyEvent keyEvent)""" 
 3204          return _fife.KeyListener_keyPressed(self, *args) 
 3205   
 3206 -    def keyReleased(self, *args): 
 3207          """keyReleased(self, gcn::KeyEvent keyEvent)""" 
 3208          return _fife.KeyListener_keyReleased(self, *args) 
 3209   
 3210 -    def __init__(self):  
 3211          """__init__(self) -> KeyListener""" 
 3212          if self.__class__ == KeyListener: 
 3213              _self = None 
 3214          else: 
 3215              _self = self 
 3216          this = _fife.new_KeyListener(_self, ) 
 3217          try: self.this.append(this) 
 3218          except: self.this = this 
 3219 -    def __disown__(self): 
 3220          self.this.disown() 
 3221          _fife.disown_KeyListener(self) 
 3222          return weakref_proxy(self) 
 3223  KeyListener_swigregister = _fife.KeyListener_swigregister 
 3224  KeyListener_swigregister(KeyListener) 
 3225   
 3226 -class ActionListener(_object): 
 3227      """Proxy of C++ gcn::ActionListener class""" 
 3228      __swig_setmethods__ = {} 
 3229      __setattr__ = lambda self, name, value: _swig_setattr(self, ActionListener, name, value) 
 3230      __swig_getmethods__ = {} 
 3231      __getattr__ = lambda self, name: _swig_getattr(self, ActionListener, name) 
 3232      __repr__ = _swig_repr 
 3233      __swig_destroy__ = _fife.delete_ActionListener 
 3234      __del__ = lambda self : None; 
 3235 -    def action(self, *args): 
 3236          """action(self, gcn::ActionEvent actionEvent)""" 
 3237          return _fife.ActionListener_action(self, *args) 
 3238   
 3239 -    def __init__(self):  
 3240          """__init__(self) -> ActionListener""" 
 3241          if self.__class__ == ActionListener: 
 3242              _self = None 
 3243          else: 
 3244              _self = self 
 3245          this = _fife.new_ActionListener(_self, ) 
 3246          try: self.this.append(this) 
 3247          except: self.this = this 
 3248 -    def __disown__(self): 
 3249          self.this.disown() 
 3250          _fife.disown_ActionListener(self) 
 3251          return weakref_proxy(self) 
 3252  ActionListener_swigregister = _fife.ActionListener_swigregister 
 3253  ActionListener_swigregister(ActionListener) 
 3254   
 3255 -class GUIManager(_object): 
 3256      """Proxy of C++ FIFE::GUIManager class""" 
 3257      __swig_setmethods__ = {} 
 3258      __setattr__ = lambda self, name, value: _swig_setattr(self, GUIManager, name, value) 
 3259      __swig_getmethods__ = {} 
 3260      __getattr__ = lambda self, name: _swig_getattr(self, GUIManager, name) 
 3261 -    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") 
 3262      __repr__ = _swig_repr 
 3263 -    def getConsole(self): 
 3264          """getConsole(self) -> Console""" 
 3265          return _fife.GUIManager_getConsole(self) 
 3266   
 3267 -    def add(self, *args): 
 3268          """add(self, Widget widget)""" 
 3269          return _fife.GUIManager_add(self, *args) 
 3270   
 3271 -    def remove(self, *args): 
 3272          """remove(self, Widget widget)""" 
 3273          return _fife.GUIManager_remove(self, *args) 
 3274   
 3275 -    def createFont(self, *args): 
 3276          """createFont(self, string path, unsigned int size, string glyphs) -> GuiFont""" 
 3277          return _fife.GUIManager_createFont(self, *args) 
 3278   
 3279 -    def releaseFont(self, *args): 
 3280          """releaseFont(self, GuiFont font)""" 
 3281          return _fife.GUIManager_releaseFont(self, *args) 
 3282   
 3283 -    def translateKeyEvent(self, *args): 
 3284          """translateKeyEvent(self, gcn::KeyEvent evt) -> KeyEvent""" 
 3285          return _fife.GUIManager_translateKeyEvent(self, *args) 
 3286   
 3287 -    def translateMouseEvent(self, *args): 
 3288          """translateMouseEvent(self, gcn::MouseEvent evt) -> MouseEvent""" 
 3289          return _fife.GUIManager_translateMouseEvent(self, *args) 
 3290   
 3291      __swig_destroy__ = _fife.delete_GUIManager 
 3292      __del__ = lambda self : None; 
 3293  GUIManager_swigregister = _fife.GUIManager_swigregister 
 3294  GUIManager_swigregister(GUIManager) 
 3295   
 3296 -class Graphics(_object): 
 3297      """Proxy of C++ gcn::Graphics class""" 
 3298      __swig_setmethods__ = {} 
 3299      __setattr__ = lambda self, name, value: _swig_setattr(self, Graphics, name, value) 
 3300      __swig_getmethods__ = {} 
 3301      __getattr__ = lambda self, name: _swig_getattr(self, Graphics, name) 
 3302 -    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") 
 3303      __repr__ = _swig_repr 
 3304      LEFT = _fife.Graphics_LEFT 
 3305      CENTER = _fife.Graphics_CENTER 
 3306      RIGHT = _fife.Graphics_RIGHT 
 3307      __swig_destroy__ = _fife.delete_Graphics 
 3308      __del__ = lambda self : None; 
 3309  Graphics_swigregister = _fife.Graphics_swigregister 
 3310  Graphics_swigregister(Graphics) 
 3311   
 3312 -class Color(_object): 
 3313      """Proxy of C++ gcn::Color class""" 
 3314      __swig_setmethods__ = {} 
 3315      __setattr__ = lambda self, name, value: _swig_setattr(self, Color, name, value) 
 3316      __swig_getmethods__ = {} 
 3317      __getattr__ = lambda self, name: _swig_getattr(self, Color, name) 
 3318      __repr__ = _swig_repr 
 3319 -    def __init__(self, *args):  
 3320          """ 
 3321          __init__(self) -> Color 
 3322          __init__(self, int color) -> Color 
 3323          __init__(self, int r, int g, int b, int a = 255) -> Color 
 3324          __init__(self, int r, int g, int b) -> Color 
 3325          """ 
 3326          this = _fife.new_Color(*args) 
 3327          try: self.this.append(this) 
 3328          except: self.this = this 
 3329 -    def __add__(self, *args): 
 3330          """__add__(self, Color color) -> Color""" 
 3331          return _fife.Color___add__(self, *args) 
 3332   
 3333 -    def __sub__(self, *args): 
 3334          """__sub__(self, Color color) -> Color""" 
 3335          return _fife.Color___sub__(self, *args) 
 3336   
 3337 -    def __mul__(self, *args): 
 3338          """__mul__(self, float value) -> Color""" 
 3339          return _fife.Color___mul__(self, *args) 
 3340   
 3341 -    def __eq__(self, *args): 
 3342          """__eq__(self, Color color) -> bool""" 
 3343          return _fife.Color___eq__(self, *args) 
 3344   
 3345 -    def __ne__(self, *args): 
 3346          """__ne__(self, Color color) -> bool""" 
 3347          return _fife.Color___ne__(self, *args) 
 3348   
 3349      __swig_setmethods__["r"] = _fife.Color_r_set 
 3350      __swig_getmethods__["r"] = _fife.Color_r_get 
 3351      if _newclass:r = _swig_property(_fife.Color_r_get, _fife.Color_r_set) 
 3352      __swig_setmethods__["g"] = _fife.Color_g_set 
 3353      __swig_getmethods__["g"] = _fife.Color_g_get 
 3354      if _newclass:g = _swig_property(_fife.Color_g_get, _fife.Color_g_set) 
 3355      __swig_setmethods__["b"] = _fife.Color_b_set 
 3356      __swig_getmethods__["b"] = _fife.Color_b_get 
 3357      if _newclass:b = _swig_property(_fife.Color_b_get, _fife.Color_b_set) 
 3358      __swig_setmethods__["a"] = _fife.Color_a_set 
 3359      __swig_getmethods__["a"] = _fife.Color_a_get 
 3360      if _newclass:a = _swig_property(_fife.Color_a_get, _fife.Color_a_set) 
 3361      __swig_destroy__ = _fife.delete_Color 
 3362      __del__ = lambda self : None; 
 3363  Color_swigregister = _fife.Color_swigregister 
 3364  Color_swigregister(Color) 
 3365   
 3366 -class Widget(_object): 
 3367      """Proxy of C++ gcn::Widget class""" 
 3368      __swig_setmethods__ = {} 
 3369      __setattr__ = lambda self, name, value: _swig_setattr(self, Widget, name, value) 
 3370      __swig_getmethods__ = {} 
 3371      __getattr__ = lambda self, name: _swig_getattr(self, Widget, name) 
 3372 -    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") 
 3373      __repr__ = _swig_repr 
 3374 -    def setWidth(self, *args): 
 3375          """setWidth(self, int width)""" 
 3376          return _fife.Widget_setWidth(self, *args) 
 3377   
 3378 -    def getWidth(self): 
 3379          """getWidth(self) -> int""" 
 3380          return _fife.Widget_getWidth(self) 
 3381   
 3382 -    def setHeight(self, *args): 
 3383          """setHeight(self, int height)""" 
 3384          return _fife.Widget_setHeight(self, *args) 
 3385   
 3386 -    def getHeight(self): 
 3387          """getHeight(self) -> int""" 
 3388          return _fife.Widget_getHeight(self) 
 3389   
 3390 -    def setSize(self, *args): 
 3391          """setSize(self, int width, int height)""" 
 3392          return _fife.Widget_setSize(self, *args) 
 3393   
 3394 -    def setX(self, *args): 
 3395          """setX(self, int x)""" 
 3396          return _fife.Widget_setX(self, *args) 
 3397   
 3398 -    def getX(self): 
 3399          """getX(self) -> int""" 
 3400          return _fife.Widget_getX(self) 
 3401   
 3402 -    def setY(self, *args): 
 3403          """setY(self, int y)""" 
 3404          return _fife.Widget_setY(self, *args) 
 3405   
 3406 -    def getY(self): 
 3407          """getY(self) -> int""" 
 3408          return _fife.Widget_getY(self) 
 3409   
 3410 -    def setPosition(self, *args): 
 3411          """setPosition(self, int x, int y)""" 
 3412          return _fife.Widget_setPosition(self, *args) 
 3413   
 3414 -    def setFrameSize(self, *args): 
 3415          """setFrameSize(self, unsigned int frameSize)""" 
 3416          return _fife.Widget_setFrameSize(self, *args) 
 3417   
 3418 -    def getFrameSize(self): 
 3419          """getFrameSize(self) -> unsigned int""" 
 3420          return _fife.Widget_getFrameSize(self) 
 3421   
 3422 -    def setFocusable(self, *args): 
 3423          """setFocusable(self, bool focusable)""" 
 3424          return _fife.Widget_setFocusable(self, *args) 
 3425   
 3426 -    def isFocusable(self): 
 3427          """isFocusable(self) -> bool""" 
 3428          return _fife.Widget_isFocusable(self) 
 3429   
 3430 -    def isFocused(self): 
 3431          """isFocused(self) -> bool""" 
 3432          return _fife.Widget_isFocused(self) 
 3433   
 3434 -    def setEnabled(self, *args): 
 3435          """setEnabled(self, bool enabled)""" 
 3436          return _fife.Widget_setEnabled(self, *args) 
 3437   
 3438 -    def isEnabled(self): 
 3439          """isEnabled(self) -> bool""" 
 3440          return _fife.Widget_isEnabled(self) 
 3441   
 3442 -    def setVisible(self, *args): 
 3443          """setVisible(self, bool visible)""" 
 3444          return _fife.Widget_setVisible(self, *args) 
 3445   
 3446 -    def isVisible(self): 
 3447          """isVisible(self) -> bool""" 
 3448          return _fife.Widget_isVisible(self) 
 3449   
 3450 -    def setBaseColor(self, *args): 
 3451          """setBaseColor(self, Color color)""" 
 3452          return _fife.Widget_setBaseColor(self, *args) 
 3453   
 3454 -    def getBaseColor(self): 
 3455          """getBaseColor(self) -> Color""" 
 3456          return _fife.Widget_getBaseColor(self) 
 3457   
 3458 -    def setForegroundColor(self, *args): 
 3459          """setForegroundColor(self, Color color)""" 
 3460          return _fife.Widget_setForegroundColor(self, *args) 
 3461   
 3462 -    def getForegroundColor(self): 
 3463          """getForegroundColor(self) -> Color""" 
 3464          return _fife.Widget_getForegroundColor(self) 
 3465   
 3466 -    def setBackgroundColor(self, *args): 
 3467          """setBackgroundColor(self, Color color)""" 
 3468          return _fife.Widget_setBackgroundColor(self, *args) 
 3469   
 3470 -    def getBackgroundColor(self): 
 3471          """getBackgroundColor(self) -> Color""" 
 3472          return _fife.Widget_getBackgroundColor(self) 
 3473   
 3474 -    def setSelectionColor(self, *args): 
 3475          """setSelectionColor(self, Color color)""" 
 3476          return _fife.Widget_setSelectionColor(self, *args) 
 3477   
 3478 -    def getSelectionColor(self): 
 3479          """getSelectionColor(self) -> Color""" 
 3480          return _fife.Widget_getSelectionColor(self) 
 3481   
 3482 -    def requestFocus(self): 
 3483          """requestFocus(self)""" 
 3484          return _fife.Widget_requestFocus(self) 
 3485   
 3486 -    def requestMoveToTop(self): 
 3487          """requestMoveToTop(self)""" 
 3488          return _fife.Widget_requestMoveToTop(self) 
 3489   
 3490 -    def requestMoveToBottom(self): 
 3491          """requestMoveToBottom(self)""" 
 3492          return _fife.Widget_requestMoveToBottom(self) 
 3493   
 3494 -    def setActionEventId(self, *args): 
 3495          """setActionEventId(self, string actionEventId)""" 
 3496          return _fife.Widget_setActionEventId(self, *args) 
 3497   
 3498 -    def getActionEventId(self): 
 3499          """getActionEventId(self) -> string""" 
 3500          return _fife.Widget_getActionEventId(self) 
 3501   
 3502 -    def getAbsolutePosition(self, *args): 
 3503          """getAbsolutePosition(self, int x, int y)""" 
 3504          return _fife.Widget_getAbsolutePosition(self, *args) 
 3505   
 3506 -    def getFont(self): 
 3507          """getFont(self) -> Font""" 
 3508          return _fife.Widget_getFont(self) 
 3509   
 3510 -    def setGlobalFont(*args): 
 3511          """setGlobalFont(Font font)""" 
 3512          return _fife.Widget_setGlobalFont(*args) 
 3513   
 3514      if _newclass:setGlobalFont = staticmethod(setGlobalFont) 
 3515      __swig_getmethods__["setGlobalFont"] = lambda x: setGlobalFont 
 3516 -    def setFont(self, *args): 
 3517          """setFont(self, Font font)""" 
 3518          return _fife.Widget_setFont(self, *args) 
 3519   
 3520 -    def isTabInEnabled(self): 
 3521          """isTabInEnabled(self) -> bool""" 
 3522          return _fife.Widget_isTabInEnabled(self) 
 3523   
 3524 -    def setTabInEnabled(self, *args): 
 3525          """setTabInEnabled(self, bool enabled)""" 
 3526          return _fife.Widget_setTabInEnabled(self, *args) 
 3527   
 3528 -    def isTabOutEnabled(self): 
 3529          """isTabOutEnabled(self) -> bool""" 
 3530          return _fife.Widget_isTabOutEnabled(self) 
 3531   
 3532 -    def setTabOutEnabled(self, *args): 
 3533          """setTabOutEnabled(self, bool enabled)""" 
 3534          return _fife.Widget_setTabOutEnabled(self, *args) 
 3535   
 3536 -    def requestModalFocus(self): 
 3537          """requestModalFocus(self)""" 
 3538          return _fife.Widget_requestModalFocus(self) 
 3539   
 3540 -    def requestModalMouseInputFocus(self): 
 3541          """requestModalMouseInputFocus(self)""" 
 3542          return _fife.Widget_requestModalMouseInputFocus(self) 
 3543   
 3544 -    def releaseModalFocus(self): 
 3545          """releaseModalFocus(self)""" 
 3546          return _fife.Widget_releaseModalFocus(self) 
 3547   
 3548 -    def releaseModalMouseInputFocus(self): 
 3549          """releaseModalMouseInputFocus(self)""" 
 3550          return _fife.Widget_releaseModalMouseInputFocus(self) 
 3551   
 3552 -    def isModalFocused(self): 
 3553          """isModalFocused(self) -> bool""" 
 3554          return _fife.Widget_isModalFocused(self) 
 3555   
 3556 -    def isModalMouseInputFocused(self): 
 3557          """isModalMouseInputFocused(self) -> bool""" 
 3558          return _fife.Widget_isModalMouseInputFocused(self) 
 3559   
 3560 -    def getWidgetAt(self, *args): 
 3561          """getWidgetAt(self, int x, int y) -> Widget""" 
 3562          return _fife.Widget_getWidgetAt(self, *args) 
 3563   
 3564 -    def moveToTop(self, *args): 
 3565          """moveToTop(self, Widget widget)""" 
 3566          return _fife.Widget_moveToTop(self, *args) 
 3567   
 3568 -    def moveToBottom(self, *args): 
 3569          """moveToBottom(self, Widget widget)""" 
 3570          return _fife.Widget_moveToBottom(self, *args) 
 3571   
 3572 -    def focusNext(self): 
 3573          """focusNext(self)""" 
 3574          return _fife.Widget_focusNext(self) 
 3575   
 3576 -    def focusPrevious(self): 
 3577          """focusPrevious(self)""" 
 3578          return _fife.Widget_focusPrevious(self) 
 3579   
 3580 -    def addActionListener(self, *args): 
 3581          """addActionListener(self, ActionListener actionListener)""" 
 3582          return _fife.Widget_addActionListener(self, *args) 
 3583   
 3584 -    def removeActionListener(self, *args): 
 3585          """removeActionListener(self, ActionListener actionListener)""" 
 3586          return _fife.Widget_removeActionListener(self, *args) 
 3587   
 3588 -    def addMouseListener(self, *args): 
 3589          """addMouseListener(self, MouseListener actionListener)""" 
 3590          return _fife.Widget_addMouseListener(self, *args) 
 3591   
 3592 -    def removeMouseListener(self, *args): 
 3593          """removeMouseListener(self, MouseListener actionListener)""" 
 3594          return _fife.Widget_removeMouseListener(self, *args) 
 3595   
 3596 -    def addKeyListener(self, *args): 
 3597          """addKeyListener(self, KeyListener actionListener)""" 
 3598          return _fife.Widget_addKeyListener(self, *args) 
 3599   
 3600 -    def removeKeyListener(self, *args): 
 3601          """removeKeyListener(self, KeyListener actionListener)""" 
 3602          return _fife.Widget_removeKeyListener(self, *args) 
 3603   
 3604 -    def draw(self, *args): 
 3605          """draw(self, Graphics graphics)""" 
 3606          return _fife.Widget_draw(self, *args) 
 3607   
 3608      __swig_destroy__ = _fife.delete_Widget 
 3609      __del__ = lambda self : None; 
 3610  Widget_swigregister = _fife.Widget_swigregister 
 3611  Widget_swigregister(Widget) 
 3612   
 3613 -def Widget_setGlobalFont(*args): 
 3614    """Widget_setGlobalFont(Font font)""" 
 3615    return _fife.Widget_setGlobalFont(*args) 
 3616   
 3617 -class Container(Widget): 
 3618      """Proxy of C++ gcn::Container class""" 
 3619      __swig_setmethods__ = {} 
 3620      for _s in [Widget]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) 
 3621      __setattr__ = lambda self, name, value: _swig_setattr(self, Container, name, value) 
 3622      __swig_getmethods__ = {} 
 3623      for _s in [Widget]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) 
 3624      __getattr__ = lambda self, name: _swig_getattr(self, Container, name) 
 3625      __repr__ = _swig_repr 
 3626 -    def __init__(self):  
 3627          """__init__(self) -> Container""" 
 3628          this = _fife.new_Container() 
 3629          try: self.this.append(this) 
 3630          except: self.this = this 
 3631      __swig_destroy__ = _fife.delete_Container 
 3632      __del__ = lambda self : None; 
 3633 -    def setOpaque(self, *args): 
 3634          """setOpaque(self, bool opaque)""" 
 3635          return _fife.Container_setOpaque(self, *args) 
 3636   
 3637 -    def isOpaque(self): 
 3638          """isOpaque(self) -> bool""" 
 3639          return _fife.Container_isOpaque(self) 
 3640   
 3641 -    def add(self, *args): 
 3642          """ 
 3643          add(self, Widget widget) 
 3644          add(self, Widget widget, int x, int y) 
 3645          """ 
 3646          return _fife.Container_add(self, *args) 
 3647   
 3648 -    def remove(self, *args): 
 3649          """remove(self, Widget widget)""" 
 3650          return _fife.Container_remove(self, *args) 
 3651   
 3652 -    def clear(self): 
 3653          """clear(self)""" 
 3654          return _fife.Container_clear(self) 
 3655   
 3656  Container_swigregister = _fife.Container_swigregister 
 3657  Container_swigregister(Container) 
 3658   
 3659 -class CheckBox(Widget): 
 3660      """Proxy of C++ gcn::CheckBox class""" 
 3661      __swig_setmethods__ = {} 
 3662      for _s in [Widget]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) 
 3663      __setattr__ = lambda self, name, value: _swig_setattr(self, CheckBox, name, value) 
 3664      __swig_getmethods__ = {} 
 3665      for _s in [Widget]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) 
 3666      __getattr__ = lambda self, name: _swig_getattr(self, CheckBox, name) 
 3667      __repr__ = _swig_repr 
 3668 -    def __init__(self):  
 3669          """__init__(self) -> CheckBox""" 
 3670          this = _fife.new_CheckBox() 
 3671          try: self.this.append(this) 
 3672          except: self.this = this 
 3673      __swig_destroy__ = _fife.delete_CheckBox 
 3674      __del__ = lambda self : None; 
 3675 -    def isSelected(self): 
 3676          """isSelected(self) -> bool""" 
 3677          return _fife.CheckBox_isSelected(self) 
 3678   
 3679 -    def setSelected(self, *args): 
 3680          """setSelected(self, bool marked)""" 
 3681          return _fife.CheckBox_setSelected(self, *args) 
 3682   
 3683 -    def getCaption(self): 
 3684          """getCaption(self) -> string""" 
 3685          return _fife.CheckBox_getCaption(self) 
 3686   
 3687 -    def setCaption(self, *args): 
 3688          """setCaption(self, string caption)""" 
 3689          return _fife.CheckBox_setCaption(self, *args) 
 3690   
 3691 -    def adjustSize(self): 
 3692          """adjustSize(self)""" 
 3693          return _fife.CheckBox_adjustSize(self) 
 3694   
 3695  CheckBox_swigregister = _fife.CheckBox_swigregister 
 3696  CheckBox_swigregister(CheckBox) 
 3697   
 3698 -class TextField(Widget): 
 3699      """Proxy of C++ gcn::UTF8TextField class""" 
 3700      __swig_setmethods__ = {} 
 3701      for _s in [Widget]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) 
 3702      __setattr__ = lambda self, name, value: _swig_setattr(self, TextField, name, value) 
 3703      __swig_getmethods__ = {} 
 3704      for _s in [Widget]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) 
 3705      __getattr__ = lambda self, name: _swig_getattr(self, TextField, name) 
 3706      __repr__ = _swig_repr 
 3707 -    def __init__(self, *args):  
 3708          """ 
 3709          UTF8TextField() -> TextField 
 3710          __init__(self, string text) -> TextField 
 3711          """ 
 3712          this = _fife.new_TextField(*args) 
 3713          try: self.this.append(this) 
 3714          except: self.this = this 
 3715 -    def setText(self, *args): 
 3716          """setText(self, string text)""" 
 3717          return _fife.TextField_setText(self, *args) 
 3718   
 3719 -    def getText(self): 
 3720          """getText(self) -> string""" 
 3721          return _fife.TextField_getText(self) 
 3722   
 3723 -    def adjustSize(self): 
 3724          """adjustSize(self)""" 
 3725          return _fife.TextField_adjustSize(self) 
 3726   
 3727 -    def adjustHeight(self): 
 3728          """adjustHeight(self)""" 
 3729          return _fife.TextField_adjustHeight(self) 
 3730   
 3731 -    def setCaretPosition(self, *args): 
 3732          """setCaretPosition(self, unsigned int position)""" 
 3733          return _fife.TextField_setCaretPosition(self, *args) 
 3734   
 3735 -    def getCaretPosition(self): 
 3736          """getCaretPosition(self) -> unsigned int""" 
 3737          return _fife.TextField_getCaretPosition(self) 
 3738   
 3739      __swig_destroy__ = _fife.delete_TextField 
 3740      __del__ = lambda self : None; 
 3741  TextField_swigregister = _fife.TextField_swigregister 
 3742  TextField_swigregister(TextField) 
 3743   
 3744 -class Button(Widget): 
 3745      """Proxy of C++ gcn::Button class""" 
 3746      __swig_setmethods__ = {} 
 3747      for _s in [Widget]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) 
 3748      __setattr__ = lambda self, name, value: _swig_setattr(self, Button, name, value) 
 3749      __swig_getmethods__ = {} 
 3750      for _s in [Widget]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) 
 3751      __getattr__ = lambda self, name: _swig_getattr(self, Button, name) 
 3752      __repr__ = _swig_repr 
 3753 -    def __init__(self, *args):  
 3754          """ 
 3755          __init__(self) -> Button 
 3756          __init__(self, string caption) -> Button 
 3757          """ 
 3758          this = _fife.new_Button(*args) 
 3759          try: self.this.append(this) 
 3760          except: self.this = this 
 3761 -    def setCaption(self, *args): 
 3762          """setCaption(self, string caption)""" 
 3763          return _fife.Button_setCaption(self, *args) 
 3764   
 3765 -    def getCaption(self): 
 3766          """getCaption(self) -> string""" 
 3767          return _fife.Button_getCaption(self) 
 3768   
 3769 -    def setAlignment(self, *args): 
 3770          """setAlignment(self, Alignment alignment)""" 
 3771          return _fife.Button_setAlignment(self, *args) 
 3772   
 3773 -    def getAlignment(self): 
 3774          """getAlignment(self) -> Alignment""" 
 3775          return _fife.Button_getAlignment(self) 
 3776   
 3777 -    def adjustSize(self): 
 3778          """adjustSize(self)""" 
 3779          return _fife.Button_adjustSize(self) 
 3780   
 3781      __swig_destroy__ = _fife.delete_Button 
 3782      __del__ = lambda self : None; 
 3783  Button_swigregister = _fife.Button_swigregister 
 3784  Button_swigregister(Button) 
 3785   
 3786 -class TwoButton(Widget): 
 3787      """Proxy of C++ gcn::TwoButton class""" 
 3788      __swig_setmethods__ = {} 
 3789      for _s in [Widget]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) 
 3790      __setattr__ = lambda self, name, value: _swig_setattr(self, TwoButton, name, value) 
 3791      __swig_getmethods__ = {} 
 3792      for _s in [Widget]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) 
 3793      __getattr__ = lambda self, name: _swig_getattr(self, TwoButton, name) 
 3794      __repr__ = _swig_repr 
 3795 -    def __init__(self, up_image = None, down_image = None, hover_image = None,  
 3796      caption = ""):  
 3797          """ 
 3798          __init__(self, GcnImage up_image = None, GcnImage down_image = None,  
 3799              GcnImage hover_image = None, char caption = "") -> TwoButton 
 3800          __init__(self, GcnImage up_image = None, GcnImage down_image = None,  
 3801              GcnImage hover_image = None) -> TwoButton 
 3802          __init__(self, GcnImage up_image = None, GcnImage down_image = None) -> TwoButton 
 3803          __init__(self, GcnImage up_image = None) -> TwoButton 
 3804          __init__(self) -> TwoButton 
 3805          """ 
 3806          this = _fife.new_TwoButton(up_image, down_image, hover_image, caption) 
 3807          try: self.this.append(this) 
 3808          except: self.this = this 
 3809      __swig_destroy__ = _fife.delete_TwoButton 
 3810      __del__ = lambda self : None; 
 3811 -    def setCaption(self, *args): 
 3812          """setCaption(self, string caption)""" 
 3813          return _fife.TwoButton_setCaption(self, *args) 
 3814   
 3815 -    def getCaption(self): 
 3816          """getCaption(self) -> string""" 
 3817          return _fife.TwoButton_getCaption(self) 
 3818   
 3819 -    def setAlignment(self, *args): 
 3820          """setAlignment(self, Alignment alignment)""" 
 3821          return _fife.TwoButton_setAlignment(self, *args) 
 3822   
 3823 -    def getAlignment(self): 
 3824          """getAlignment(self) -> Alignment""" 
 3825          return _fife.TwoButton_getAlignment(self) 
 3826   
 3827 -    def setUpImage(self, *args): 
 3828          """setUpImage(self, GcnImage image)""" 
 3829          return _fife.TwoButton_setUpImage(self, *args) 
 3830   
 3831 -    def setDownImage(self, *args): 
 3832          """setDownImage(self, GcnImage image)""" 
 3833          return _fife.TwoButton_setDownImage(self, *args) 
 3834   
 3835 -    def setHoverImage(self, *args): 
 3836          """setHoverImage(self, GcnImage image)""" 
 3837          return _fife.TwoButton_setHoverImage(self, *args) 
 3838   
 3839 -    def setDownOffset(self, *args): 
 3840          """setDownOffset(self, int x, int y)""" 
 3841          return _fife.TwoButton_setDownOffset(self, *args) 
 3842   
 3843 -    def getDownXOffset(self): 
 3844          """getDownXOffset(self) -> int""" 
 3845          return _fife.TwoButton_getDownXOffset(self) 
 3846   
 3847 -    def getDownYOffset(self): 
 3848          """getDownYOffset(self) -> int""" 
 3849          return _fife.TwoButton_getDownYOffset(self) 
 3850   
 3851  TwoButton_swigregister = _fife.TwoButton_swigregister 
 3852  TwoButton_swigregister(TwoButton) 
 3853   
 3854 -class ToggleButton(Widget): 
 3855      """Proxy of C++ gcn::ToggleButton class""" 
 3856      __swig_setmethods__ = {} 
 3857      for _s in [Widget]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) 
 3858      __setattr__ = lambda self, name, value: _swig_setattr(self, ToggleButton, name, value) 
 3859      __swig_getmethods__ = {} 
 3860      for _s in [Widget]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) 
 3861      __getattr__ = lambda self, name: _swig_getattr(self, ToggleButton, name) 
 3862      __repr__ = _swig_repr 
 3863 -    def __init__(self, up_image = None, down_image = None, hover_image = None,  
 3864      caption = "", group = ""):  
 3865          """ 
 3866          __init__(self, GcnImage up_image = None, GcnImage down_image = None,  
 3867              GcnImage hover_image = None, char caption = "",  
 3868              char group = "") -> ToggleButton 
 3869          __init__(self, GcnImage up_image = None, GcnImage down_image = None,  
 3870              GcnImage hover_image = None, char caption = "") -> ToggleButton 
 3871          __init__(self, GcnImage up_image = None, GcnImage down_image = None,  
 3872              GcnImage hover_image = None) -> ToggleButton 
 3873          __init__(self, GcnImage up_image = None, GcnImage down_image = None) -> ToggleButton 
 3874          __init__(self, GcnImage up_image = None) -> ToggleButton 
 3875          __init__(self) -> ToggleButton 
 3876          """ 
 3877          this = _fife.new_ToggleButton(up_image, down_image, hover_image, caption, group) 
 3878          try: self.this.append(this) 
 3879          except: self.this = this 
 3880      __swig_destroy__ = _fife.delete_ToggleButton 
 3881      __del__ = lambda self : None; 
 3882 -    def setCaption(self, *args): 
 3883          """setCaption(self, string caption)""" 
 3884          return _fife.ToggleButton_setCaption(self, *args) 
 3885   
 3886 -    def getCaption(self): 
 3887          """getCaption(self) -> string""" 
 3888          return _fife.ToggleButton_getCaption(self) 
 3889   
 3890 -    def setAlignment(self, *args): 
 3891          """setAlignment(self, Alignment alignment)""" 
 3892          return _fife.ToggleButton_setAlignment(self, *args) 
 3893   
 3894 -    def getAlignment(self): 
 3895          """getAlignment(self) -> Alignment""" 
 3896          return _fife.ToggleButton_getAlignment(self) 
 3897   
 3898 -    def setSpacing(self, *args): 
 3899          """setSpacing(self, unsigned int spacing)""" 
 3900          return _fife.ToggleButton_setSpacing(self, *args) 
 3901   
 3902 -    def getSpacing(self): 
 3903          """getSpacing(self) -> unsigned int""" 
 3904          return _fife.ToggleButton_getSpacing(self) 
 3905   
 3906 -    def setUpImage(self, *args): 
 3907          """setUpImage(self, GcnImage image)""" 
 3908          return _fife.ToggleButton_setUpImage(self, *args) 
 3909   
 3910 -    def setDownImage(self, *args): 
 3911          """setDownImage(self, GcnImage image)""" 
 3912          return _fife.ToggleButton_setDownImage(self, *args) 
 3913   
 3914 -    def setHoverImage(self, *args): 
 3915          """setHoverImage(self, GcnImage image)""" 
 3916          return _fife.ToggleButton_setHoverImage(self, *args) 
 3917   
 3918 -    def setDownOffset(self, *args): 
 3919          """setDownOffset(self, int x, int y)""" 
 3920          return _fife.ToggleButton_setDownOffset(self, *args) 
 3921   
 3922 -    def getDownXOffset(self): 
 3923          """getDownXOffset(self) -> int""" 
 3924          return _fife.ToggleButton_getDownXOffset(self) 
 3925   
 3926 -    def getDownYOffset(self): 
 3927          """getDownYOffset(self) -> int""" 
 3928          return _fife.ToggleButton_getDownYOffset(self) 
 3929   
 3930 -    def isToggled(self): 
 3931          """isToggled(self) -> bool""" 
 3932          return _fife.ToggleButton_isToggled(self) 
 3933   
 3934 -    def setToggled(self, *args): 
 3935          """setToggled(self, bool toggled)""" 
 3936          return _fife.ToggleButton_setToggled(self, *args) 
 3937   
 3938 -    def setGroup(self, *args): 
 3939          """setGroup(self, string group)""" 
 3940          return _fife.ToggleButton_setGroup(self, *args) 
 3941   
 3942 -    def getGroup(self): 
 3943          """getGroup(self) -> string""" 
 3944          return _fife.ToggleButton_getGroup(self) 
 3945   
 3946  ToggleButton_swigregister = _fife.ToggleButton_swigregister 
 3947  ToggleButton_swigregister(ToggleButton) 
 3948   
 3949 -class ScrollArea(Widget): 
 3950      """Proxy of C++ gcn::ScrollArea class""" 
 3951      __swig_setmethods__ = {} 
 3952      for _s in [Widget]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) 
 3953      __setattr__ = lambda self, name, value: _swig_setattr(self, ScrollArea, name, value) 
 3954      __swig_getmethods__ = {} 
 3955      for _s in [Widget]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) 
 3956      __getattr__ = lambda self, name: _swig_getattr(self, ScrollArea, name) 
 3957      __repr__ = _swig_repr 
 3958 -    def __init__(self, *args):  
 3959          """ 
 3960          __init__(self) -> ScrollArea 
 3961          __init__(self, Widget content) -> ScrollArea 
 3962          __init__(self, Widget content, ScrollPolicy hPolicy, ScrollPolicy vPolicy) -> ScrollArea 
 3963          """ 
 3964          this = _fife.new_ScrollArea(*args) 
 3965          try: self.this.append(this) 
 3966          except: self.this = this 
 3967      __swig_destroy__ = _fife.delete_ScrollArea 
 3968      __del__ = lambda self : None; 
 3969 -    def setContent(self, *args): 
 3970          """setContent(self, Widget widget)""" 
 3971          return _fife.ScrollArea_setContent(self, *args) 
 3972   
 3973 -    def getContent(self): 
 3974          """getContent(self) -> Widget""" 
 3975          return _fife.ScrollArea_getContent(self) 
 3976   
 3977 -    def setHorizontalScrollPolicy(self, *args): 
 3978          """setHorizontalScrollPolicy(self, ScrollPolicy hPolicy)""" 
 3979          return _fife.ScrollArea_setHorizontalScrollPolicy(self, *args) 
 3980   
 3981 -    def getHorizontalScrollPolicy(self): 
 3982          """getHorizontalScrollPolicy(self) -> ScrollPolicy""" 
 3983          return _fife.ScrollArea_getHorizontalScrollPolicy(self) 
 3984   
 3985 -    def setVerticalScrollPolicy(self, *args): 
 3986          """setVerticalScrollPolicy(self, ScrollPolicy vPolicy)""" 
 3987          return _fife.ScrollArea_setVerticalScrollPolicy(self, *args) 
 3988   
 3989 -    def getVerticalScrollPolicy(self): 
 3990          """getVerticalScrollPolicy(self) -> ScrollPolicy""" 
 3991          return _fife.ScrollArea_getVerticalScrollPolicy(self) 
 3992   
 3993 -    def setScrollPolicy(self, *args): 
 3994          """setScrollPolicy(self, ScrollPolicy hPolicy, ScrollPolicy vPolicy)""" 
 3995          return _fife.ScrollArea_setScrollPolicy(self, *args) 
 3996   
 3997 -    def setVerticalScrollAmount(self, *args): 
 3998          """setVerticalScrollAmount(self, int vScroll)""" 
 3999          return _fife.ScrollArea_setVerticalScrollAmount(self, *args) 
 4000   
 4001 -    def getVerticalScrollAmount(self): 
 4002          """getVerticalScrollAmount(self) -> int""" 
 4003          return _fife.ScrollArea_getVerticalScrollAmount(self) 
 4004   
 4005 -    def setHorizontalScrollAmount(self, *args): 
 4006          """setHorizontalScrollAmount(self, int hScroll)""" 
 4007          return _fife.ScrollArea_setHorizontalScrollAmount(self, *args) 
 4008   
 4009 -    def getHorizontalScrollAmount(self): 
 4010          """getHorizontalScrollAmount(self) -> int""" 
 4011          return _fife.ScrollArea_getHorizontalScrollAmount(self) 
 4012   
 4013 -    def setScrollAmount(self, *args): 
 4014          """setScrollAmount(self, int hScroll, int vScroll)""" 
 4015          return _fife.ScrollArea_setScrollAmount(self, *args) 
 4016   
 4017 -    def getHorizontalMaxScroll(self): 
 4018          """getHorizontalMaxScroll(self) -> int""" 
 4019          return _fife.ScrollArea_getHorizontalMaxScroll(self) 
 4020   
 4021 -    def getVerticalMaxScroll(self): 
 4022          """getVerticalMaxScroll(self) -> int""" 
 4023          return _fife.ScrollArea_getVerticalMaxScroll(self) 
 4024   
 4025 -    def setScrollbarWidth(self, *args): 
 4026          """setScrollbarWidth(self, int width)""" 
 4027          return _fife.ScrollArea_setScrollbarWidth(self, *args) 
 4028   
 4029 -    def getScrollbarWidth(self): 
 4030          """getScrollbarWidth(self) -> int""" 
 4031          return _fife.ScrollArea_getScrollbarWidth(self) 
 4032   
 4033 -    def setLeftButtonScrollAmount(self, *args): 
 4034          """setLeftButtonScrollAmount(self, int amount)""" 
 4035          return _fife.ScrollArea_setLeftButtonScrollAmount(self, *args) 
 4036   
 4037 -    def setRightButtonScrollAmount(self, *args): 
 4038          """setRightButtonScrollAmount(self, int amount)""" 
 4039          return _fife.ScrollArea_setRightButtonScrollAmount(self, *args) 
 4040   
 4041 -    def setUpButtonScrollAmount(self, *args): 
 4042          """setUpButtonScrollAmount(self, int amount)""" 
 4043          return _fife.ScrollArea_setUpButtonScrollAmount(self, *args) 
 4044   
 4045 -    def setDownButtonScrollAmount(self, *args): 
 4046          """setDownButtonScrollAmount(self, int amount)""" 
 4047          return _fife.ScrollArea_setDownButtonScrollAmount(self, *args) 
 4048   
 4049 -    def getLeftButtonScrollAmount(self): 
 4050          """getLeftButtonScrollAmount(self) -> int""" 
 4051          return _fife.ScrollArea_getLeftButtonScrollAmount(self) 
 4052   
 4053 -    def getRightButtonScrollAmount(self): 
 4054          """getRightButtonScrollAmount(self) -> int""" 
 4055          return _fife.ScrollArea_getRightButtonScrollAmount(self) 
 4056   
 4057 -    def getUpButtonScrollAmount(self): 
 4058          """getUpButtonScrollAmount(self) -> int""" 
 4059          return _fife.ScrollArea_getUpButtonScrollAmount(self) 
 4060   
 4061 -    def getDownButtonScrollAmount(self): 
 4062          """getDownButtonScrollAmount(self) -> int""" 
 4063          return _fife.ScrollArea_getDownButtonScrollAmount(self) 
 4064   
 4065      SHOW_ALWAYS = _fife.ScrollArea_SHOW_ALWAYS 
 4066      SHOW_NEVER = _fife.ScrollArea_SHOW_NEVER 
 4067      SHOW_AUTO = _fife.ScrollArea_SHOW_AUTO 
 4068  ScrollArea_swigregister = _fife.ScrollArea_swigregister 
 4069  ScrollArea_swigregister(ScrollArea) 
 4070   
 4071 -class TextBox(Widget): 
 4072      """Proxy of C++ gcn::UTF8TextBox class""" 
 4073      __swig_setmethods__ = {} 
 4074      for _s in [Widget]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) 
 4075      __setattr__ = lambda self, name, value: _swig_setattr(self, TextBox, name, value) 
 4076      __swig_getmethods__ = {} 
 4077      for _s in [Widget]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) 
 4078      __getattr__ = lambda self, name: _swig_getattr(self, TextBox, name) 
 4079      __repr__ = _swig_repr 
 4080 -    def __init__(self, *args):  
 4081          """ 
 4082          UTF8TextBox() -> TextBox 
 4083          __init__(self, string text) -> TextBox 
 4084          """ 
 4085          this = _fife.new_TextBox(*args) 
 4086          try: self.this.append(this) 
 4087          except: self.this = this 
 4088 -    def setText(self, *args): 
 4089          """setText(self, string text)""" 
 4090          return _fife.TextBox_setText(self, *args) 
 4091   
 4092 -    def getText(self): 
 4093          """getText(self) -> string""" 
 4094          return _fife.TextBox_getText(self) 
 4095   
 4096 -    def getTextRow(self, *args): 
 4097          """getTextRow(self, int row) -> string""" 
 4098          return _fife.TextBox_getTextRow(self, *args) 
 4099   
 4100 -    def setTextRow(self, *args): 
 4101          """setTextRow(self, int row, string text)""" 
 4102          return _fife.TextBox_setTextRow(self, *args) 
 4103   
 4104 -    def getNumberOfRows(self): 
 4105          """getNumberOfRows(self) -> unsigned int""" 
 4106          return _fife.TextBox_getNumberOfRows(self) 
 4107   
 4108 -    def getCaretPosition(self): 
 4109          """getCaretPosition(self) -> unsigned int""" 
 4110          return _fife.TextBox_getCaretPosition(self) 
 4111   
 4112 -    def setCaretPosition(self, *args): 
 4113          """setCaretPosition(self, unsigned int position)""" 
 4114          return _fife.TextBox_setCaretPosition(self, *args) 
 4115   
 4116 -    def getCaretRow(self): 
 4117          """getCaretRow(self) -> unsigned int""" 
 4118          return _fife.TextBox_getCaretRow(self) 
 4119   
 4120 -    def setCaretRow(self, *args): 
 4121          """setCaretRow(self, int row)""" 
 4122          return _fife.TextBox_setCaretRow(self, *args) 
 4123   
 4124 -    def getCaretColumn(self): 
 4125          """getCaretColumn(self) -> unsigned int""" 
 4126          return _fife.TextBox_getCaretColumn(self) 
 4127   
 4128 -    def setCaretColumn(self, *args): 
 4129          """setCaretColumn(self, int column)""" 
 4130          return _fife.TextBox_setCaretColumn(self, *args) 
 4131   
 4132 -    def setCaretRowColumn(self, *args): 
 4133          """setCaretRowColumn(self, int row, int column)""" 
 4134          return _fife.TextBox_setCaretRowColumn(self, *args) 
 4135   
 4136 -    def scrollToCaret(self): 
 4137          """scrollToCaret(self)""" 
 4138          return _fife.TextBox_scrollToCaret(self) 
 4139   
 4140 -    def isEditable(self): 
 4141          """isEditable(self) -> bool""" 
 4142          return _fife.TextBox_isEditable(self) 
 4143   
 4144 -    def setEditable(self, *args): 
 4145          """setEditable(self, bool editable)""" 
 4146          return _fife.TextBox_setEditable(self, *args) 
 4147   
 4148 -    def addRow(self, *args): 
 4149          """addRow(self, string row)""" 
 4150          return _fife.TextBox_addRow(self, *args) 
 4151   
 4152 -    def isOpaque(self): 
 4153          """isOpaque(self) -> bool""" 
 4154          return _fife.TextBox_isOpaque(self) 
 4155   
 4156 -    def setOpaque(self, *args): 
 4157          """setOpaque(self, bool opaque)""" 
 4158          return _fife.TextBox_setOpaque(self, *args) 
 4159   
 4160      __swig_destroy__ = _fife.delete_TextBox 
 4161      __del__ = lambda self : None; 
 4162  TextBox_swigregister = _fife.TextBox_swigregister 
 4163  TextBox_swigregister(TextBox) 
 4164   
 4165 -class ListModel(_object): 
 4166      """Proxy of C++ gcn::ListModel class""" 
 4167      __swig_setmethods__ = {} 
 4168      __setattr__ = lambda self, name, value: _swig_setattr(self, ListModel, name, value) 
 4169      __swig_getmethods__ = {} 
 4170      __getattr__ = lambda self, name: _swig_getattr(self, ListModel, name) 
 4171      __repr__ = _swig_repr 
 4172      __swig_destroy__ = _fife.delete_ListModel 
 4173      __del__ = lambda self : None; 
 4174 -    def getNumberOfElements(self): 
 4175          """getNumberOfElements(self) -> int""" 
 4176          return _fife.ListModel_getNumberOfElements(self) 
 4177   
 4178 -    def getElementAt(self, *args): 
 4179          """getElementAt(self, int i) -> string""" 
 4180          return _fife.ListModel_getElementAt(self, *args) 
 4181   
 4182 -    def __init__(self):  
 4183          """__init__(self) -> ListModel""" 
 4184          if self.__class__ == ListModel: 
 4185              _self = None 
 4186          else: 
 4187              _self = self 
 4188          this = _fife.new_ListModel(_self, ) 
 4189          try: self.this.append(this) 
 4190          except: self.this = this 
 4191 -    def __disown__(self): 
 4192          self.this.disown() 
 4193          _fife.disown_ListModel(self) 
 4194          return weakref_proxy(self) 
 4195  ListModel_swigregister = _fife.ListModel_swigregister 
 4196  ListModel_swigregister(ListModel) 
 4197   
 4198 -class ListBox(Widget): 
 4199      """Proxy of C++ gcn::ListBox class""" 
 4200      __swig_setmethods__ = {} 
 4201      for _s in [Widget]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) 
 4202      __setattr__ = lambda self, name, value: _swig_setattr(self, ListBox, name, value) 
 4203      __swig_getmethods__ = {} 
 4204      for _s in [Widget]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) 
 4205      __getattr__ = lambda self, name: _swig_getattr(self, ListBox, name) 
 4206      __repr__ = _swig_repr 
 4207 -    def __init__(self, *args):  
 4208          """ 
 4209          __init__(self) -> ListBox 
 4210          __init__(self, ListModel listModel) -> ListBox 
 4211          """ 
 4212          this = _fife.new_ListBox(*args) 
 4213          try: self.this.append(this) 
 4214          except: self.this = this 
 4215      __swig_destroy__ = _fife.delete_ListBox 
 4216      __del__ = lambda self : None; 
 4217 -    def getSelected(self): 
 4218          """getSelected(self) -> int""" 
 4219          return _fife.ListBox_getSelected(self) 
 4220   
 4221 -    def setSelected(self, *args): 
 4222          """setSelected(self, int selected)""" 
 4223          return _fife.ListBox_setSelected(self, *args) 
 4224   
 4225 -    def setListModel(self, *args): 
 4226          """setListModel(self, ListModel listModel)""" 
 4227          return _fife.ListBox_setListModel(self, *args) 
 4228   
 4229 -    def getListModel(self): 
 4230          """getListModel(self) -> ListModel""" 
 4231          return _fife.ListBox_getListModel(self) 
 4232   
 4233 -    def adjustSize(self): 
 4234          """adjustSize(self)""" 
 4235          return _fife.ListBox_adjustSize(self) 
 4236   
 4237 -    def isWrappingEnabled(self): 
 4238          """isWrappingEnabled(self) -> bool""" 
 4239          return _fife.ListBox_isWrappingEnabled(self) 
 4240   
 4241 -    def setWrappingEnabled(self, *args): 
 4242          """setWrappingEnabled(self, bool wrapping)""" 
 4243          return _fife.ListBox_setWrappingEnabled(self, *args) 
 4244   
 4245  ListBox_swigregister = _fife.ListBox_swigregister 
 4246  ListBox_swigregister(ListBox) 
 4247   
 4248 -class DropDown(Widget): 
 4249      """Proxy of C++ gcn::DropDown class""" 
 4250      __swig_setmethods__ = {} 
 4251      for _s in [Widget]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) 
 4252      __setattr__ = lambda self, name, value: _swig_setattr(self, DropDown, name, value) 
 4253      __swig_getmethods__ = {} 
 4254      for _s in [Widget]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) 
 4255      __getattr__ = lambda self, name: _swig_getattr(self, DropDown, name) 
 4256      __repr__ = _swig_repr 
 4257 -    def __init__(self, listModel = None, scrollArea = None, listBox = None):  
 4258          """ 
 4259          __init__(self, ListModel listModel = None, ScrollArea scrollArea = None,  
 4260              ListBox listBox = None) -> DropDown 
 4261          __init__(self, ListModel listModel = None, ScrollArea scrollArea = None) -> DropDown 
 4262          __init__(self, ListModel listModel = None) -> DropDown 
 4263          __init__(self) -> DropDown 
 4264          """ 
 4265          this = _fife.new_DropDown(listModel, scrollArea, listBox) 
 4266          try: self.this.append(this) 
 4267          except: self.this = this 
 4268      __swig_destroy__ = _fife.delete_DropDown 
 4269      __del__ = lambda self : None; 
 4270 -    def getSelected(self): 
 4271          """getSelected(self) -> int""" 
 4272          return _fife.DropDown_getSelected(self) 
 4273   
 4274 -    def setSelected(self, *args): 
 4275          """setSelected(self, int selected)""" 
 4276          return _fife.DropDown_setSelected(self, *args) 
 4277   
 4278 -    def setListModel(self, *args): 
 4279          """setListModel(self, ListModel listModel)""" 
 4280          return _fife.DropDown_setListModel(self, *args) 
 4281   
 4282 -    def getListModel(self): 
 4283          """getListModel(self) -> ListModel""" 
 4284          return _fife.DropDown_getListModel(self) 
 4285   
 4286 -    def adjustHeight(self): 
 4287          """adjustHeight(self)""" 
 4288          return _fife.DropDown_adjustHeight(self) 
 4289   
 4290 -    def setBaseColor(self, *args): 
 4291          """setBaseColor(self, Color color)""" 
 4292          return _fife.DropDown_setBaseColor(self, *args) 
 4293   
 4294 -    def getBaseColor(self): 
 4295          """getBaseColor(self) -> Color""" 
 4296          return _fife.DropDown_getBaseColor(self) 
 4297   
 4298 -    def setForegroundColor(self, *args): 
 4299          """setForegroundColor(self, Color color)""" 
 4300          return _fife.DropDown_setForegroundColor(self, *args) 
 4301   
 4302 -    def getForegroundColor(self): 
 4303          """getForegroundColor(self) -> Color""" 
 4304          return _fife.DropDown_getForegroundColor(self) 
 4305   
 4306 -    def setBackgroundColor(self, *args): 
 4307          """setBackgroundColor(self, Color color)""" 
 4308          return _fife.DropDown_setBackgroundColor(self, *args) 
 4309   
 4310 -    def getBackgroundColor(self): 
 4311          """getBackgroundColor(self) -> Color""" 
 4312          return _fife.DropDown_getBackgroundColor(self) 
 4313   
 4314 -    def setSelectionColor(self, *args): 
 4315          """setSelectionColor(self, Color color)""" 
 4316          return _fife.DropDown_setSelectionColor(self, *args) 
 4317   
 4318 -    def getSelectionColor(self): 
 4319          """getSelectionColor(self) -> Color""" 
 4320          return _fife.DropDown_getSelectionColor(self) 
 4321   
 4322  DropDown_swigregister = _fife.DropDown_swigregister 
 4323  DropDown_swigregister(DropDown) 
 4324   
 4325 -class RadioButton(Widget): 
 4326      """Proxy of C++ gcn::RadioButton class""" 
 4327      __swig_setmethods__ = {} 
 4328      for _s in [Widget]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) 
 4329      __setattr__ = lambda self, name, value: _swig_setattr(self, RadioButton, name, value) 
 4330      __swig_getmethods__ = {} 
 4331      for _s in [Widget]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) 
 4332      __getattr__ = lambda self, name: _swig_getattr(self, RadioButton, name) 
 4333      __repr__ = _swig_repr 
 4334 -    def __init__(self, *args):  
 4335          """ 
 4336          __init__(self) -> RadioButton 
 4337          __init__(self, string caption, string group, bool marked = False) -> RadioButton 
 4338          __init__(self, string caption, string group) -> RadioButton 
 4339          """ 
 4340          this = _fife.new_RadioButton(*args) 
 4341          try: self.this.append(this) 
 4342          except: self.this = this 
 4343      __swig_destroy__ = _fife.delete_RadioButton 
 4344      __del__ = lambda self : None; 
 4345 -    def isSelected(self): 
 4346          """isSelected(self) -> bool""" 
 4347          return _fife.RadioButton_isSelected(self) 
 4348   
 4349 -    def setSelected(self, *args): 
 4350          """setSelected(self, bool marked)""" 
 4351          return _fife.RadioButton_setSelected(self, *args) 
 4352   
 4353 -    def getCaption(self): 
 4354          """getCaption(self) -> string""" 
 4355          return _fife.RadioButton_getCaption(self) 
 4356   
 4357 -    def setCaption(self, *args): 
 4358          """setCaption(self, string caption)""" 
 4359          return _fife.RadioButton_setCaption(self, *args) 
 4360   
 4361 -    def setGroup(self, *args): 
 4362          """setGroup(self, string group)""" 
 4363          return _fife.RadioButton_setGroup(self, *args) 
 4364   
 4365 -    def getGroup(self): 
 4366          """getGroup(self) -> string""" 
 4367          return _fife.RadioButton_getGroup(self) 
 4368   
 4369 -    def adjustSize(self): 
 4370          """adjustSize(self)""" 
 4371          return _fife.RadioButton_adjustSize(self) 
 4372   
 4373  RadioButton_swigregister = _fife.RadioButton_swigregister 
 4374  RadioButton_swigregister(RadioButton) 
 4375   
 4376 -class Slider(Widget): 
 4377      """Proxy of C++ gcn::Slider class""" 
 4378      __swig_setmethods__ = {} 
 4379      for _s in [Widget]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) 
 4380      __setattr__ = lambda self, name, value: _swig_setattr(self, Slider, name, value) 
 4381      __swig_getmethods__ = {} 
 4382      for _s in [Widget]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) 
 4383      __getattr__ = lambda self, name: _swig_getattr(self, Slider, name) 
 4384      __repr__ = _swig_repr 
 4385 -    def __init__(self, *args):  
 4386          """ 
 4387          __init__(self, double scaleEnd = 1.0) -> Slider 
 4388          __init__(self) -> Slider 
 4389          __init__(self, double scaleStart, double scaleEnd) -> Slider 
 4390          """ 
 4391          this = _fife.new_Slider(*args) 
 4392          try: self.this.append(this) 
 4393          except: self.this = this 
 4394      __swig_destroy__ = _fife.delete_Slider 
 4395      __del__ = lambda self : None; 
 4396 -    def setScale(self, *args): 
 4397          """setScale(self, double scaleStart, double scaleEnd)""" 
 4398          return _fife.Slider_setScale(self, *args) 
 4399   
 4400 -    def getScaleStart(self): 
 4401          """getScaleStart(self) -> double""" 
 4402          return _fife.Slider_getScaleStart(self) 
 4403   
 4404 -    def setScaleStart(self, *args): 
 4405          """setScaleStart(self, double scaleStart)""" 
 4406          return _fife.Slider_setScaleStart(self, *args) 
 4407   
 4408 -    def getScaleEnd(self): 
 4409          """getScaleEnd(self) -> double""" 
 4410          return _fife.Slider_getScaleEnd(self) 
 4411   
 4412 -    def setScaleEnd(self, *args): 
 4413          """setScaleEnd(self, double scaleEnd)""" 
 4414          return _fife.Slider_setScaleEnd(self, *args) 
 4415   
 4416 -    def getValue(self): 
 4417          """getValue(self) -> double""" 
 4418          return _fife.Slider_getValue(self) 
 4419   
 4420 -    def setValue(self, *args): 
 4421          """setValue(self, double value)""" 
 4422          return _fife.Slider_setValue(self, *args) 
 4423   
 4424 -    def setMarkerLength(self, *args): 
 4425          """setMarkerLength(self, int length)""" 
 4426          return _fife.Slider_setMarkerLength(self, *args) 
 4427   
 4428 -    def getMarkerLength(self): 
 4429          """getMarkerLength(self) -> int""" 
 4430          return _fife.Slider_getMarkerLength(self) 
 4431   
 4432 -    def setOrientation(self, *args): 
 4433          """setOrientation(self, Orientation orientation)""" 
 4434          return _fife.Slider_setOrientation(self, *args) 
 4435   
 4436 -    def getOrientation(self): 
 4437          """getOrientation(self) -> Orientation""" 
 4438          return _fife.Slider_getOrientation(self) 
 4439   
 4440 -    def setStepLength(self, *args): 
 4441          """setStepLength(self, double length)""" 
 4442          return _fife.Slider_setStepLength(self, *args) 
 4443   
 4444 -    def getStepLength(self): 
 4445          """getStepLength(self) -> double""" 
 4446          return _fife.Slider_getStepLength(self) 
 4447   
 4448      HORIZONTAL = _fife.Slider_HORIZONTAL 
 4449      VERTICAL = _fife.Slider_VERTICAL 
 4450  Slider_swigregister = _fife.Slider_swigregister 
 4451  Slider_swigregister(Slider) 
 4452   
 4453 -class Window(Container): 
 4454      """Proxy of C++ gcn::Window class""" 
 4455      __swig_setmethods__ = {} 
 4456      for _s in [Container]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) 
 4457      __setattr__ = lambda self, name, value: _swig_setattr(self, Window, name, value) 
 4458      __swig_getmethods__ = {} 
 4459      for _s in [Container]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) 
 4460      __getattr__ = lambda self, name: _swig_getattr(self, Window, name) 
 4461      __repr__ = _swig_repr 
 4462 -    def __init__(self, *args):  
 4463          """ 
 4464          __init__(self) -> Window 
 4465          __init__(self, string caption) -> Window 
 4466          """ 
 4467          this = _fife.new_Window(*args) 
 4468          try: self.this.append(this) 
 4469          except: self.this = this 
 4470      __swig_destroy__ = _fife.delete_Window 
 4471      __del__ = lambda self : None; 
 4472 -    def setCaption(self, *args): 
 4473          """setCaption(self, string caption)""" 
 4474          return _fife.Window_setCaption(self, *args) 
 4475   
 4476 -    def getCaption(self): 
 4477          """getCaption(self) -> string""" 
 4478          return _fife.Window_getCaption(self) 
 4479   
 4480 -    def setAlignment(self, *args): 
 4481          """setAlignment(self, Alignment alignment)""" 
 4482          return _fife.Window_setAlignment(self, *args) 
 4483   
 4484 -    def getAlignment(self): 
 4485          """getAlignment(self) -> Alignment""" 
 4486          return _fife.Window_getAlignment(self) 
 4487   
 4488 -    def setPadding(self, *args): 
 4489          """setPadding(self, unsigned int padding)""" 
 4490          return _fife.Window_setPadding(self, *args) 
 4491   
 4492 -    def getPadding(self): 
 4493          """getPadding(self) -> unsigned int""" 
 4494          return _fife.Window_getPadding(self) 
 4495   
 4496 -    def setTitleBarHeight(self, *args): 
 4497          """setTitleBarHeight(self, unsigned int height)""" 
 4498          return _fife.Window_setTitleBarHeight(self, *args) 
 4499   
 4500 -    def getTitleBarHeight(self): 
 4501          """getTitleBarHeight(self) -> unsigned int""" 
 4502          return _fife.Window_getTitleBarHeight(self) 
 4503   
 4504 -    def setMovable(self, *args): 
 4505          """setMovable(self, bool movable)""" 
 4506          return _fife.Window_setMovable(self, *args) 
 4507   
 4508 -    def isMovable(self): 
 4509          """isMovable(self) -> bool""" 
 4510          return _fife.Window_isMovable(self) 
 4511   
 4512 -    def setOpaque(self, *args): 
 4513          """setOpaque(self, bool opaque)""" 
 4514          return _fife.Window_setOpaque(self, *args) 
 4515   
 4516 -    def isOpaque(self): 
 4517          """isOpaque(self) -> bool""" 
 4518          return _fife.Window_isOpaque(self) 
 4519   
 4520 -    def resizeToContent(self): 
 4521          """resizeToContent(self)""" 
 4522          return _fife.Window_resizeToContent(self) 
 4523   
 4524  Window_swigregister = _fife.Window_swigregister 
 4525  Window_swigregister(Window) 
 4526   
 4527 -class Label(Widget): 
 4528      """Proxy of C++ gcn::ClickLabel class""" 
 4529      __swig_setmethods__ = {} 
 4530      for _s in [Widget]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) 
 4531      __setattr__ = lambda self, name, value: _swig_setattr(self, Label, name, value) 
 4532      __swig_getmethods__ = {} 
 4533      for _s in [Widget]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) 
 4534      __getattr__ = lambda self, name: _swig_getattr(self, Label, name) 
 4535      __repr__ = _swig_repr 
 4536 -    def __init__(self, *args):  
 4537          """ 
 4538          ClickLabel() -> Label 
 4539          __init__(self, string caption) -> Label 
 4540          """ 
 4541          this = _fife.new_Label(*args) 
 4542          try: self.this.append(this) 
 4543          except: self.this = this 
 4544      __swig_destroy__ = _fife.delete_Label 
 4545      __del__ = lambda self : None; 
 4546 -    def setCaption(self, *args): 
 4547          """setCaption(self, string caption)""" 
 4548          return _fife.Label_setCaption(self, *args) 
 4549   
 4550 -    def getCaption(self): 
 4551          """getCaption(self) -> string""" 
 4552          return _fife.Label_getCaption(self) 
 4553   
 4554 -    def isTextWrapping(self): 
 4555          """isTextWrapping(self) -> bool""" 
 4556          return _fife.Label_isTextWrapping(self) 
 4557   
 4558 -    def setTextWrapping(self, *args): 
 4559          """setTextWrapping(self, bool arg0)""" 
 4560          return _fife.Label_setTextWrapping(self, *args) 
 4561   
 4562 -    def setWidth(self, *args): 
 4563          """setWidth(self, int width)""" 
 4564          return _fife.Label_setWidth(self, *args) 
 4565   
 4566 -    def adjustSize(self): 
 4567          """adjustSize(self)""" 
 4568          return _fife.Label_adjustSize(self) 
 4569   
 4570  Label_swigregister = _fife.Label_swigregister 
 4571  Label_swigregister(Label) 
 4572   
 4573 -class Icon(Widget): 
 4574      """Proxy of C++ gcn::Icon2 class""" 
 4575      __swig_setmethods__ = {} 
 4576      for _s in [Widget]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) 
 4577      __setattr__ = lambda self, name, value: _swig_setattr(self, Icon, name, value) 
 4578      __swig_getmethods__ = {} 
 4579      for _s in [Widget]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) 
 4580      __getattr__ = lambda self, name: _swig_getattr(self, Icon, name) 
 4581      __repr__ = _swig_repr 
 4582 -    def __init__(self, *args):  
 4583          """__init__(self, GcnImage image) -> Icon""" 
 4584          this = _fife.new_Icon(*args) 
 4585          try: self.this.append(this) 
 4586          except: self.this = this 
 4587      __swig_destroy__ = _fife.delete_Icon 
 4588      __del__ = lambda self : None; 
 4589 -    def setImage(self, *args): 
 4590          """setImage(self, GcnImage image)""" 
 4591          return _fife.Icon_setImage(self, *args) 
 4592   
 4593  Icon_swigregister = _fife.Icon_swigregister 
 4594  Icon_swigregister(Icon) 
 4595   
 4596 -class PercentageBar(Widget): 
 4597      """Proxy of C++ gcn::PercentageBar class""" 
 4598      __swig_setmethods__ = {} 
 4599      for _s in [Widget]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) 
 4600      __setattr__ = lambda self, name, value: _swig_setattr(self, PercentageBar, name, value) 
 4601      __swig_getmethods__ = {} 
 4602      for _s in [Widget]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) 
 4603      __getattr__ = lambda self, name: _swig_getattr(self, PercentageBar, name) 
 4604      __repr__ = _swig_repr 
 4605 -    def __init__(self):  
 4606          """__init__(self) -> PercentageBar""" 
 4607          this = _fife.new_PercentageBar() 
 4608          try: self.this.append(this) 
 4609          except: self.this = this 
 4610      __swig_destroy__ = _fife.delete_PercentageBar 
 4611      __del__ = lambda self : None; 
 4612 -    def setForegroundImage(self, *args): 
 4613          """setForegroundImage(self, GcnImage image)""" 
 4614          return _fife.PercentageBar_setForegroundImage(self, *args) 
 4615   
 4616 -    def setOrientation(self, *args): 
 4617          """setOrientation(self, Orientation orientation)""" 
 4618          return _fife.PercentageBar_setOrientation(self, *args) 
 4619   
 4620 -    def getOrientation(self): 
 4621          """getOrientation(self) -> Orientation""" 
 4622          return _fife.PercentageBar_getOrientation(self) 
 4623   
 4624 -    def getValue(self): 
 4625          """getValue(self) -> int""" 
 4626          return _fife.PercentageBar_getValue(self) 
 4627   
 4628 -    def setValue(self, *args): 
 4629          """setValue(self, int value)""" 
 4630          return _fife.PercentageBar_setValue(self, *args) 
 4631   
 4632      HORIZONTAL = _fife.PercentageBar_HORIZONTAL 
 4633      VERTICAL = _fife.PercentageBar_VERTICAL 
 4634  PercentageBar_swigregister = _fife.PercentageBar_swigregister 
 4635  PercentageBar_swigregister(PercentageBar) 
 4636   
 4637 -class Point(_object): 
 4638      """Proxy of C++ FIFE::PointType2D<(int)> class""" 
 4639      __swig_setmethods__ = {} 
 4640      __setattr__ = lambda self, name, value: _swig_setattr(self, Point, name, value) 
 4641      __swig_getmethods__ = {} 
 4642      __getattr__ = lambda self, name: _swig_getattr(self, Point, name) 
 4643      __repr__ = _swig_repr 
 4644      __swig_setmethods__["x"] = _fife.Point_x_set 
 4645      __swig_getmethods__["x"] = _fife.Point_x_get 
 4646      if _newclass:x = _swig_property(_fife.Point_x_get, _fife.Point_x_set) 
 4647      __swig_setmethods__["y"] = _fife.Point_y_set 
 4648      __swig_getmethods__["y"] = _fife.Point_y_get 
 4649      if _newclass:y = _swig_property(_fife.Point_y_get, _fife.Point_y_set) 
 4650 -    def __init__(self, *args):  
 4651          """ 
 4652          __init__(self, int _x = 0, int _y = 0) -> Point 
 4653          __init__(self, int _x = 0) -> Point 
 4654          __init__(self) -> Point 
 4655          __init__(self, Point rhs) -> Point 
 4656          """ 
 4657          this = _fife.new_Point(*args) 
 4658          try: self.this.append(this) 
 4659          except: self.this = this 
 4660 -    def __add__(self, *args): 
 4661          """__add__(self, Point p) -> Point""" 
 4662          return _fife.Point___add__(self, *args) 
 4663   
 4664 -    def __sub__(self, *args): 
 4665          """__sub__(self, Point p) -> Point""" 
 4666          return _fife.Point___sub__(self, *args) 
 4667   
 4668 -    def __iadd__(self, *args): 
 4669          """__iadd__(self, Point p) -> Point""" 
 4670          return _fife.Point___iadd__(self, *args) 
 4671   
 4672 -    def __isub__(self, *args): 
 4673          """__isub__(self, Point p) -> Point""" 
 4674          return _fife.Point___isub__(self, *args) 
 4675   
 4676 -    def __mul__(self, *args): 
 4677          """__mul__(self, int i) -> Point""" 
 4678          return _fife.Point___mul__(self, *args) 
 4679   
 4680 -    def __div__(self, *args): 
 4681          """__div__(self, int i) -> Point""" 
 4682          return _fife.Point___div__(self, *args) 
 4683   
 4684 -    def __eq__(self, *args): 
 4685          """__eq__(self, Point p) -> bool""" 
 4686          return _fife.Point___eq__(self, *args) 
 4687   
 4688 -    def __ne__(self, *args): 
 4689          """__ne__(self, Point p) -> bool""" 
 4690          return _fife.Point___ne__(self, *args) 
 4691   
 4692 -    def length(self): 
 4693          """length(self) -> int""" 
 4694          return _fife.Point_length(self) 
 4695   
 4696 -    def normalize(self): 
 4697          """normalize(self)""" 
 4698          return _fife.Point_normalize(self) 
 4699   
 4700 -    def rotate(self, *args): 
 4701          """ 
 4702          rotate(self, int angle) 
 4703          rotate(self, Point origin, int angle) 
 4704          """ 
 4705          return _fife.Point_rotate(self, *args) 
 4706   
 4707 -    def getX(self): 
 4708          """getX(self) -> int""" 
 4709          return _fife.Point_getX(self) 
 4710   
 4711 -    def getY(self): 
 4712          """getY(self) -> int""" 
 4713          return _fife.Point_getY(self) 
 4714   
 4715 -    def setX(self, *args): 
 4716          """setX(self, int _x)""" 
 4717          return _fife.Point_setX(self, *args) 
 4718   
 4719 -    def setY(self, *args): 
 4720          """setY(self, int _y)""" 
 4721          return _fife.Point_setY(self, *args) 
 4722   
 4723 -    def __str__(self): 
 4724          """__str__(self) -> string""" 
 4725          return _fife.Point___str__(self) 
 4726   
 4727      __swig_destroy__ = _fife.delete_Point 
 4728      __del__ = lambda self : None; 
 4729  Point_swigregister = _fife.Point_swigregister 
 4730  Point_swigregister(Point) 
 4731   
 4732 -class DoublePoint(_object): 
 4733      """Proxy of C++ FIFE::PointType2D<(double)> class""" 
 4734      __swig_setmethods__ = {} 
 4735      __setattr__ = lambda self, name, value: _swig_setattr(self, DoublePoint, name, value) 
 4736      __swig_getmethods__ = {} 
 4737      __getattr__ = lambda self, name: _swig_getattr(self, DoublePoint, name) 
 4738      __repr__ = _swig_repr 
 4739      __swig_setmethods__["x"] = _fife.DoublePoint_x_set 
 4740      __swig_getmethods__["x"] = _fife.DoublePoint_x_get 
 4741      if _newclass:x = _swig_property(_fife.DoublePoint_x_get, _fife.DoublePoint_x_set) 
 4742      __swig_setmethods__["y"] = _fife.DoublePoint_y_set 
 4743      __swig_getmethods__["y"] = _fife.DoublePoint_y_get 
 4744      if _newclass:y = _swig_property(_fife.DoublePoint_y_get, _fife.DoublePoint_y_set) 
 4745 -    def __init__(self, *args):  
 4746          """ 
 4747          __init__(self, double _x = 0, double _y = 0) -> DoublePoint 
 4748          __init__(self, double _x = 0) -> DoublePoint 
 4749          __init__(self) -> DoublePoint 
 4750          __init__(self, DoublePoint rhs) -> DoublePoint 
 4751          """ 
 4752          this = _fife.new_DoublePoint(*args) 
 4753          try: self.this.append(this) 
 4754          except: self.this = this 
 4755 -    def __add__(self, *args): 
 4756          """__add__(self, DoublePoint p) -> DoublePoint""" 
 4757          return _fife.DoublePoint___add__(self, *args) 
 4758   
 4759 -    def __sub__(self, *args): 
 4760          """__sub__(self, DoublePoint p) -> DoublePoint""" 
 4761          return _fife.DoublePoint___sub__(self, *args) 
 4762   
 4763 -    def __iadd__(self, *args): 
 4764          """__iadd__(self, DoublePoint p) -> DoublePoint""" 
 4765          return _fife.DoublePoint___iadd__(self, *args) 
 4766   
 4767 -    def __isub__(self, *args): 
 4768          """__isub__(self, DoublePoint p) -> DoublePoint""" 
 4769          return _fife.DoublePoint___isub__(self, *args) 
 4770   
 4771 -    def __mul__(self, *args): 
 4772          """__mul__(self, double i) -> DoublePoint""" 
 4773          return _fife.DoublePoint___mul__(self, *args) 
 4774   
 4775 -    def __div__(self, *args): 
 4776          """__div__(self, double i) -> DoublePoint""" 
 4777          return _fife.DoublePoint___div__(self, *args) 
 4778   
 4779 -    def __eq__(self, *args): 
 4780          """__eq__(self, DoublePoint p) -> bool""" 
 4781          return _fife.DoublePoint___eq__(self, *args) 
 4782   
 4783 -    def __ne__(self, *args): 
 4784          """__ne__(self, DoublePoint p) -> bool""" 
 4785          return _fife.DoublePoint___ne__(self, *args) 
 4786   
 4787 -    def length(self): 
 4788          """length(self) -> double""" 
 4789          return _fife.DoublePoint_length(self) 
 4790   
 4791 -    def normalize(self): 
 4792          """normalize(self)""" 
 4793          return _fife.DoublePoint_normalize(self) 
 4794   
 4795 -    def rotate(self, *args): 
 4796          """ 
 4797          rotate(self, double angle) 
 4798          rotate(self, DoublePoint origin, double angle) 
 4799          """ 
 4800          return _fife.DoublePoint_rotate(self, *args) 
 4801   
 4802 -    def getX(self): 
 4803          """getX(self) -> double""" 
 4804          return _fife.DoublePoint_getX(self) 
 4805   
 4806 -    def getY(self): 
 4807          """getY(self) -> double""" 
 4808          return _fife.DoublePoint_getY(self) 
 4809   
 4810 -    def setX(self, *args): 
 4811          """setX(self, double _x)""" 
 4812          return _fife.DoublePoint_setX(self, *args) 
 4813   
 4814 -    def setY(self, *args): 
 4815          """setY(self, double _y)""" 
 4816          return _fife.DoublePoint_setY(self, *args) 
 4817   
 4818 -    def __str__(self): 
 4819          """__str__(self) -> string""" 
 4820          return _fife.DoublePoint___str__(self) 
 4821   
 4822      __swig_destroy__ = _fife.delete_DoublePoint 
 4823      __del__ = lambda self : None; 
 4824  DoublePoint_swigregister = _fife.DoublePoint_swigregister 
 4825  DoublePoint_swigregister(DoublePoint) 
 4826   
 4827 -class Point3D(_object): 
 4828      """Proxy of C++ FIFE::PointType3D<(int)> class""" 
 4829      __swig_setmethods__ = {} 
 4830      __setattr__ = lambda self, name, value: _swig_setattr(self, Point3D, name, value) 
 4831      __swig_getmethods__ = {} 
 4832      __getattr__ = lambda self, name: _swig_getattr(self, Point3D, name) 
 4833      __repr__ = _swig_repr 
 4834      __swig_setmethods__["x"] = _fife.Point3D_x_set 
 4835      __swig_getmethods__["x"] = _fife.Point3D_x_get 
 4836      if _newclass:x = _swig_property(_fife.Point3D_x_get, _fife.Point3D_x_set) 
 4837      __swig_setmethods__["y"] = _fife.Point3D_y_set 
 4838      __swig_getmethods__["y"] = _fife.Point3D_y_get 
 4839      if _newclass:y = _swig_property(_fife.Point3D_y_get, _fife.Point3D_y_set) 
 4840      __swig_setmethods__["z"] = _fife.Point3D_z_set 
 4841      __swig_getmethods__["z"] = _fife.Point3D_z_get 
 4842      if _newclass:z = _swig_property(_fife.Point3D_z_get, _fife.Point3D_z_set) 
 4843 -    def __init__(self, *args):  
 4844          """ 
 4845          __init__(self, int _x = 0, int _y = 0, int _z = 0) -> Point3D 
 4846          __init__(self, int _x = 0, int _y = 0) -> Point3D 
 4847          __init__(self, int _x = 0) -> Point3D 
 4848          __init__(self) -> Point3D 
 4849          __init__(self, Point3D rhs) -> Point3D 
 4850          """ 
 4851          this = _fife.new_Point3D(*args) 
 4852          try: self.this.append(this) 
 4853          except: self.this = this 
 4854 -    def __add__(self, *args): 
 4855          """__add__(self, Point3D p) -> Point3D""" 
 4856          return _fife.Point3D___add__(self, *args) 
 4857   
 4858 -    def __sub__(self, *args): 
 4859          """__sub__(self, Point3D p) -> Point3D""" 
 4860          return _fife.Point3D___sub__(self, *args) 
 4861   
 4862 -    def __iadd__(self, *args): 
 4863          """__iadd__(self, Point3D p) -> Point3D""" 
 4864          return _fife.Point3D___iadd__(self, *args) 
 4865   
 4866 -    def __isub__(self, *args): 
 4867          """__isub__(self, Point3D p) -> Point3D""" 
 4868          return _fife.Point3D___isub__(self, *args) 
 4869   
 4870 -    def __mul__(self, *args): 
 4871          """__mul__(self, int i) -> Point3D""" 
 4872          return _fife.Point3D___mul__(self, *args) 
 4873   
 4874 -    def __div__(self, *args): 
 4875          """__div__(self, int i) -> Point3D""" 
 4876          return _fife.Point3D___div__(self, *args) 
 4877   
 4878 -    def __eq__(self, *args): 
 4879          """__eq__(self, Point3D p) -> bool""" 
 4880          return _fife.Point3D___eq__(self, *args) 
 4881   
 4882 -    def __ne__(self, *args): 
 4883          """__ne__(self, Point3D p) -> bool""" 
 4884          return _fife.Point3D___ne__(self, *args) 
 4885   
 4886 -    def length(self): 
 4887          """length(self) -> int""" 
 4888          return _fife.Point3D_length(self) 
 4889   
 4890 -    def normalize(self): 
 4891          """normalize(self)""" 
 4892          return _fife.Point3D_normalize(self) 
 4893   
 4894      __swig_destroy__ = _fife.delete_Point3D 
 4895      __del__ = lambda self : None; 
 4896  Point3D_swigregister = _fife.Point3D_swigregister 
 4897  Point3D_swigregister(Point3D) 
 4898   
 4899 -class DoublePoint3D(_object): 
 4900      """Proxy of C++ FIFE::PointType3D<(double)> class""" 
 4901      __swig_setmethods__ = {} 
 4902      __setattr__ = lambda self, name, value: _swig_setattr(self, DoublePoint3D, name, value) 
 4903      __swig_getmethods__ = {} 
 4904      __getattr__ = lambda self, name: _swig_getattr(self, DoublePoint3D, name) 
 4905      __repr__ = _swig_repr 
 4906      __swig_setmethods__["x"] = _fife.DoublePoint3D_x_set 
 4907      __swig_getmethods__["x"] = _fife.DoublePoint3D_x_get 
 4908      if _newclass:x = _swig_property(_fife.DoublePoint3D_x_get, _fife.DoublePoint3D_x_set) 
 4909      __swig_setmethods__["y"] = _fife.DoublePoint3D_y_set 
 4910      __swig_getmethods__["y"] = _fife.DoublePoint3D_y_get 
 4911      if _newclass:y = _swig_property(_fife.DoublePoint3D_y_get, _fife.DoublePoint3D_y_set) 
 4912      __swig_setmethods__["z"] = _fife.DoublePoint3D_z_set 
 4913      __swig_getmethods__["z"] = _fife.DoublePoint3D_z_get 
 4914      if _newclass:z = _swig_property(_fife.DoublePoint3D_z_get, _fife.DoublePoint3D_z_set) 
 4915 -    def __init__(self, *args):  
 4916          """ 
 4917          __init__(self, double _x = 0, double _y = 0, double _z = 0) -> DoublePoint3D 
 4918          __init__(self, double _x = 0, double _y = 0) -> DoublePoint3D 
 4919          __init__(self, double _x = 0) -> DoublePoint3D 
 4920          __init__(self) -> DoublePoint3D 
 4921          __init__(self, DoublePoint3D rhs) -> DoublePoint3D 
 4922          """ 
 4923          this = _fife.new_DoublePoint3D(*args) 
 4924          try: self.this.append(this) 
 4925          except: self.this = this 
 4926 -    def __add__(self, *args): 
 4927          """__add__(self, DoublePoint3D p) -> DoublePoint3D""" 
 4928          return _fife.DoublePoint3D___add__(self, *args) 
 4929   
 4930 -    def __sub__(self, *args): 
 4931          """__sub__(self, DoublePoint3D p) -> DoublePoint3D""" 
 4932          return _fife.DoublePoint3D___sub__(self, *args) 
 4933   
 4934 -    def __iadd__(self, *args): 
 4935          """__iadd__(self, DoublePoint3D p) -> DoublePoint3D""" 
 4936          return _fife.DoublePoint3D___iadd__(self, *args) 
 4937   
 4938 -    def __isub__(self, *args): 
 4939          """__isub__(self, DoublePoint3D p) -> DoublePoint3D""" 
 4940          return _fife.DoublePoint3D___isub__(self, *args) 
 4941   
 4942 -    def __mul__(self, *args): 
 4943          """__mul__(self, double i) -> DoublePoint3D""" 
 4944          return _fife.DoublePoint3D___mul__(self, *args) 
 4945   
 4946 -    def __div__(self, *args): 
 4947          """__div__(self, double i) -> DoublePoint3D""" 
 4948          return _fife.DoublePoint3D___div__(self, *args) 
 4949   
 4950 -    def __eq__(self, *args): 
 4951          """__eq__(self, DoublePoint3D p) -> bool""" 
 4952          return _fife.DoublePoint3D___eq__(self, *args) 
 4953   
 4954 -    def __ne__(self, *args): 
 4955          """__ne__(self, DoublePoint3D p) -> bool""" 
 4956          return _fife.DoublePoint3D___ne__(self, *args) 
 4957   
 4958 -    def length(self): 
 4959          """length(self) -> double""" 
 4960          return _fife.DoublePoint3D_length(self) 
 4961   
 4962 -    def normalize(self): 
 4963          """normalize(self)""" 
 4964          return _fife.DoublePoint3D_normalize(self) 
 4965   
 4966      __swig_destroy__ = _fife.delete_DoublePoint3D 
 4967      __del__ = lambda self : None; 
 4968  DoublePoint3D_swigregister = _fife.DoublePoint3D_swigregister 
 4969  DoublePoint3D_swigregister(DoublePoint3D) 
 4970   
 4971 -class Rect(_object): 
 4972      """Proxy of C++ FIFE::RectType<(int)> class""" 
 4973      __swig_setmethods__ = {} 
 4974      __setattr__ = lambda self, name, value: _swig_setattr(self, Rect, name, value) 
 4975      __swig_getmethods__ = {} 
 4976      __getattr__ = lambda self, name: _swig_getattr(self, Rect, name) 
 4977      __repr__ = _swig_repr 
 4978      __swig_setmethods__["x"] = _fife.Rect_x_set 
 4979      __swig_getmethods__["x"] = _fife.Rect_x_get 
 4980      if _newclass:x = _swig_property(_fife.Rect_x_get, _fife.Rect_x_set) 
 4981      __swig_setmethods__["y"] = _fife.Rect_y_set 
 4982      __swig_getmethods__["y"] = _fife.Rect_y_get 
 4983      if _newclass:y = _swig_property(_fife.Rect_y_get, _fife.Rect_y_set) 
 4984      __swig_setmethods__["w"] = _fife.Rect_w_set 
 4985      __swig_getmethods__["w"] = _fife.Rect_w_get 
 4986      if _newclass:w = _swig_property(_fife.Rect_w_get, _fife.Rect_w_set) 
 4987      __swig_setmethods__["h"] = _fife.Rect_h_set 
 4988      __swig_getmethods__["h"] = _fife.Rect_h_get 
 4989      if _newclass:h = _swig_property(_fife.Rect_h_get, _fife.Rect_h_set) 
 4990 -    def __init__(self, x = 0, y = 0, width = 0, height = 0):  
 4991          """ 
 4992          __init__(self, int x = 0, int y = 0, int width = 0, int height = 0) -> Rect 
 4993          __init__(self, int x = 0, int y = 0, int width = 0) -> Rect 
 4994          __init__(self, int x = 0, int y = 0) -> Rect 
 4995          __init__(self, int x = 0) -> Rect 
 4996          __init__(self) -> Rect 
 4997          """ 
 4998          this = _fife.new_Rect(x, y, width, height) 
 4999          try: self.this.append(this) 
 5000          except: self.this = this 
 5001 -    def right(self): 
 5002          """right(self) -> int""" 
 5003          return _fife.Rect_right(self) 
 5004   
 5005 -    def bottom(self): 
 5006          """bottom(self) -> int""" 
 5007          return _fife.Rect_bottom(self) 
 5008   
 5009 -    def __eq__(self, *args): 
 5010          """__eq__(self, Rect rect) -> bool""" 
 5011          return _fife.Rect___eq__(self, *args) 
 5012   
 5013 -    def contains(self, *args): 
 5014          """contains(self, Point point) -> bool""" 
 5015          return _fife.Rect_contains(self, *args) 
 5016   
 5017 -    def intersects(self, *args): 
 5018          """intersects(self, Rect rect) -> bool""" 
 5019          return _fife.Rect_intersects(self, *args) 
 5020   
 5021 -    def intersectInplace(self, *args): 
 5022          """intersectInplace(self, Rect rect) -> bool""" 
 5023          return _fife.Rect_intersectInplace(self, *args) 
 5024   
 5025 -    def getX(self): 
 5026          """getX(self) -> int""" 
 5027          return _fife.Rect_getX(self) 
 5028   
 5029 -    def getY(self): 
 5030          """getY(self) -> int""" 
 5031          return _fife.Rect_getY(self) 
 5032   
 5033 -    def setX(self, *args): 
 5034          """setX(self, int _x)""" 
 5035          return _fife.Rect_setX(self, *args) 
 5036   
 5037 -    def setY(self, *args): 
 5038          """setY(self, int _y)""" 
 5039          return _fife.Rect_setY(self, *args) 
 5040   
 5041 -    def getW(self): 
 5042          """getW(self) -> int""" 
 5043          return _fife.Rect_getW(self) 
 5044   
 5045 -    def getH(self): 
 5046          """getH(self) -> int""" 
 5047          return _fife.Rect_getH(self) 
 5048   
 5049 -    def setW(self, *args): 
 5050          """setW(self, int _w)""" 
 5051          return _fife.Rect_setW(self, *args) 
 5052   
 5053 -    def setH(self, *args): 
 5054          """setH(self, int _h)""" 
 5055          return _fife.Rect_setH(self, *args) 
 5056   
 5057 -    def __str__(self): 
 5058          """__str__(self) -> string""" 
 5059          return _fife.Rect___str__(self) 
 5060   
 5061      __swig_destroy__ = _fife.delete_Rect 
 5062      __del__ = lambda self : None; 
 5063  Rect_swigregister = _fife.Rect_swigregister 
 5064  Rect_swigregister(Rect) 
 5065   
 5066 -class FloatRect(_object): 
 5067      """Proxy of C++ FIFE::RectType<(float)> class""" 
 5068      __swig_setmethods__ = {} 
 5069      __setattr__ = lambda self, name, value: _swig_setattr(self, FloatRect, name, value) 
 5070      __swig_getmethods__ = {} 
 5071      __getattr__ = lambda self, name: _swig_getattr(self, FloatRect, name) 
 5072      __repr__ = _swig_repr 
 5073      __swig_setmethods__["x"] = _fife.FloatRect_x_set 
 5074      __swig_getmethods__["x"] = _fife.FloatRect_x_get 
 5075      if _newclass:x = _swig_property(_fife.FloatRect_x_get, _fife.FloatRect_x_set) 
 5076      __swig_setmethods__["y"] = _fife.FloatRect_y_set 
 5077      __swig_getmethods__["y"] = _fife.FloatRect_y_get 
 5078      if _newclass:y = _swig_property(_fife.FloatRect_y_get, _fife.FloatRect_y_set) 
 5079      __swig_setmethods__["w"] = _fife.FloatRect_w_set 
 5080      __swig_getmethods__["w"] = _fife.FloatRect_w_get 
 5081      if _newclass:w = _swig_property(_fife.FloatRect_w_get, _fife.FloatRect_w_set) 
 5082      __swig_setmethods__["h"] = _fife.FloatRect_h_set 
 5083      __swig_getmethods__["h"] = _fife.FloatRect_h_get 
 5084      if _newclass:h = _swig_property(_fife.FloatRect_h_get, _fife.FloatRect_h_set) 
 5085 -    def __init__(self, x = 0, y = 0, width = 0, height = 0):  
 5086          """ 
 5087          __init__(self, float x = 0, float y = 0, float width = 0, float height = 0) -> FloatRect 
 5088          __init__(self, float x = 0, float y = 0, float width = 0) -> FloatRect 
 5089          __init__(self, float x = 0, float y = 0) -> FloatRect 
 5090          __init__(self, float x = 0) -> FloatRect 
 5091          __init__(self) -> FloatRect 
 5092          """ 
 5093          this = _fife.new_FloatRect(x, y, width, height) 
 5094          try: self.this.append(this) 
 5095          except: self.this = this 
 5096 -    def right(self): 
 5097          """right(self) -> float""" 
 5098          return _fife.FloatRect_right(self) 
 5099   
 5100 -    def bottom(self): 
 5101          """bottom(self) -> float""" 
 5102          return _fife.FloatRect_bottom(self) 
 5103   
 5104 -    def __eq__(self, *args): 
 5105          """__eq__(self, FloatRect rect) -> bool""" 
 5106          return _fife.FloatRect___eq__(self, *args) 
 5107   
 5108 -    def contains(self, *args): 
 5109          """contains(self, FIFE::PointType2D<(float)> point) -> bool""" 
 5110          return _fife.FloatRect_contains(self, *args) 
 5111   
 5112 -    def intersects(self, *args): 
 5113          """intersects(self, FloatRect rect) -> bool""" 
 5114          return _fife.FloatRect_intersects(self, *args) 
 5115   
 5116 -    def intersectInplace(self, *args): 
 5117          """intersectInplace(self, FloatRect rect) -> bool""" 
 5118          return _fife.FloatRect_intersectInplace(self, *args) 
 5119   
 5120 -    def getX(self): 
 5121          """getX(self) -> float""" 
 5122          return _fife.FloatRect_getX(self) 
 5123   
 5124 -    def getY(self): 
 5125          """getY(self) -> float""" 
 5126          return _fife.FloatRect_getY(self) 
 5127   
 5128 -    def setX(self, *args): 
 5129          """setX(self, float _x)""" 
 5130          return _fife.FloatRect_setX(self, *args) 
 5131   
 5132 -    def setY(self, *args): 
 5133          """setY(self, float _y)""" 
 5134          return _fife.FloatRect_setY(self, *args) 
 5135   
 5136 -    def getW(self): 
 5137          """getW(self) -> float""" 
 5138          return _fife.FloatRect_getW(self) 
 5139   
 5140 -    def getH(self): 
 5141          """getH(self) -> float""" 
 5142          return _fife.FloatRect_getH(self) 
 5143   
 5144 -    def setW(self, *args): 
 5145          """setW(self, float _w)""" 
 5146          return _fife.FloatRect_setW(self, *args) 
 5147   
 5148 -    def setH(self, *args): 
 5149          """setH(self, float _h)""" 
 5150          return _fife.FloatRect_setH(self, *args) 
 5151   
 5152 -    def __str__(self): 
 5153          """__str__(self) -> string""" 
 5154          return _fife.FloatRect___str__(self) 
 5155   
 5156      __swig_destroy__ = _fife.delete_FloatRect 
 5157      __del__ = lambda self : None; 
 5158  FloatRect_swigregister = _fife.FloatRect_swigregister 
 5159  FloatRect_swigregister(FloatRect) 
 5160   
 5161 -class DoubleRect(_object): 
 5162      """Proxy of C++ FIFE::RectType<(double)> class""" 
 5163      __swig_setmethods__ = {} 
 5164      __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleRect, name, value) 
 5165      __swig_getmethods__ = {} 
 5166      __getattr__ = lambda self, name: _swig_getattr(self, DoubleRect, name) 
 5167      __repr__ = _swig_repr 
 5168      __swig_setmethods__["x"] = _fife.DoubleRect_x_set 
 5169      __swig_getmethods__["x"] = _fife.DoubleRect_x_get 
 5170      if _newclass:x = _swig_property(_fife.DoubleRect_x_get, _fife.DoubleRect_x_set) 
 5171      __swig_setmethods__["y"] = _fife.DoubleRect_y_set 
 5172      __swig_getmethods__["y"] = _fife.DoubleRect_y_get 
 5173      if _newclass:y = _swig_property(_fife.DoubleRect_y_get, _fife.DoubleRect_y_set) 
 5174      __swig_setmethods__["w"] = _fife.DoubleRect_w_set 
 5175      __swig_getmethods__["w"] = _fife.DoubleRect_w_get 
 5176      if _newclass:w = _swig_property(_fife.DoubleRect_w_get, _fife.DoubleRect_w_set) 
 5177      __swig_setmethods__["h"] = _fife.DoubleRect_h_set 
 5178      __swig_getmethods__["h"] = _fife.DoubleRect_h_get 
 5179      if _newclass:h = _swig_property(_fife.DoubleRect_h_get, _fife.DoubleRect_h_set) 
 5180 -    def __init__(self, x = 0, y = 0, width = 0, height = 0):  
 5181          """ 
 5182          __init__(self, double x = 0, double y = 0, double width = 0, double height = 0) -> DoubleRect 
 5183          __init__(self, double x = 0, double y = 0, double width = 0) -> DoubleRect 
 5184          __init__(self, double x = 0, double y = 0) -> DoubleRect 
 5185          __init__(self, double x = 0) -> DoubleRect 
 5186          __init__(self) -> DoubleRect 
 5187          """ 
 5188          this = _fife.new_DoubleRect(x, y, width, height) 
 5189          try: self.this.append(this) 
 5190          except: self.this = this 
 5191 -    def right(self): 
 5192          """right(self) -> double""" 
 5193          return _fife.DoubleRect_right(self) 
 5194   
 5195 -    def bottom(self): 
 5196          """bottom(self) -> double""" 
 5197          return _fife.DoubleRect_bottom(self) 
 5198   
 5199 -    def __eq__(self, *args): 
 5200          """__eq__(self, DoubleRect rect) -> bool""" 
 5201          return _fife.DoubleRect___eq__(self, *args) 
 5202   
 5203 -    def contains(self, *args): 
 5204          """contains(self, DoublePoint point) -> bool""" 
 5205          return _fife.DoubleRect_contains(self, *args) 
 5206   
 5207 -    def intersects(self, *args): 
 5208          """intersects(self, DoubleRect rect) -> bool""" 
 5209          return _fife.DoubleRect_intersects(self, *args) 
 5210   
 5211 -    def intersectInplace(self, *args): 
 5212          """intersectInplace(self, DoubleRect rect) -> bool""" 
 5213          return _fife.DoubleRect_intersectInplace(self, *args) 
 5214   
 5215 -    def getX(self): 
 5216          """getX(self) -> double""" 
 5217          return _fife.DoubleRect_getX(self) 
 5218   
 5219 -    def getY(self): 
 5220          """getY(self) -> double""" 
 5221          return _fife.DoubleRect_getY(self) 
 5222   
 5223 -    def setX(self, *args): 
 5224          """setX(self, double _x)""" 
 5225          return _fife.DoubleRect_setX(self, *args) 
 5226   
 5227 -    def setY(self, *args): 
 5228          """setY(self, double _y)""" 
 5229          return _fife.DoubleRect_setY(self, *args) 
 5230   
 5231 -    def getW(self): 
 5232          """getW(self) -> double""" 
 5233          return _fife.DoubleRect_getW(self) 
 5234   
 5235 -    def getH(self): 
 5236          """getH(self) -> double""" 
 5237          return _fife.DoubleRect_getH(self) 
 5238   
 5239 -    def setW(self, *args): 
 5240          """setW(self, double _w)""" 
 5241          return _fife.DoubleRect_setW(self, *args) 
 5242   
 5243 -    def setH(self, *args): 
 5244          """setH(self, double _h)""" 
 5245          return _fife.DoubleRect_setH(self, *args) 
 5246   
 5247 -    def __str__(self): 
 5248          """__str__(self) -> string""" 
 5249          return _fife.DoubleRect___str__(self) 
 5250   
 5251      __swig_destroy__ = _fife.delete_DoubleRect 
 5252      __del__ = lambda self : None; 
 5253  DoubleRect_swigregister = _fife.DoubleRect_swigregister 
 5254  DoubleRect_swigregister(DoubleRect) 
 5255   
 5256 -class ModelCoordinate(_object): 
 5257      """Proxy of C++ FIFE::PointType3D<(int)> class""" 
 5258      __swig_setmethods__ = {} 
 5259      __setattr__ = lambda self, name, value: _swig_setattr(self, ModelCoordinate, name, value) 
 5260      __swig_getmethods__ = {} 
 5261      __getattr__ = lambda self, name: _swig_getattr(self, ModelCoordinate, name) 
 5262      __repr__ = _swig_repr 
 5263      __swig_setmethods__["x"] = _fife.ModelCoordinate_x_set 
 5264      __swig_getmethods__["x"] = _fife.ModelCoordinate_x_get 
 5265      if _newclass:x = _swig_property(_fife.ModelCoordinate_x_get, _fife.ModelCoordinate_x_set) 
 5266      __swig_setmethods__["y"] = _fife.ModelCoordinate_y_set 
 5267      __swig_getmethods__["y"] = _fife.ModelCoordinate_y_get 
 5268      if _newclass:y = _swig_property(_fife.ModelCoordinate_y_get, _fife.ModelCoordinate_y_set) 
 5269      __swig_setmethods__["z"] = _fife.ModelCoordinate_z_set 
 5270      __swig_getmethods__["z"] = _fife.ModelCoordinate_z_get 
 5271      if _newclass:z = _swig_property(_fife.ModelCoordinate_z_get, _fife.ModelCoordinate_z_set) 
 5272 -    def __init__(self, *args):  
 5273          """ 
 5274          __init__(self, int _x = 0, int _y = 0, int _z = 0) -> ModelCoordinate 
 5275          __init__(self, int _x = 0, int _y = 0) -> ModelCoordinate 
 5276          __init__(self, int _x = 0) -> ModelCoordinate 
 5277          __init__(self) -> ModelCoordinate 
 5278          __init__(self, Point3D rhs) -> ModelCoordinate 
 5279          """ 
 5280          this = _fife.new_ModelCoordinate(*args) 
 5281          try: self.this.append(this) 
 5282          except: self.this = this 
 5283 -    def __add__(self, *args): 
 5284          """__add__(self, Point3D p) -> Point3D""" 
 5285          return _fife.ModelCoordinate___add__(self, *args) 
 5286   
 5287 -    def __sub__(self, *args): 
 5288          """__sub__(self, Point3D p) -> Point3D""" 
 5289          return _fife.ModelCoordinate___sub__(self, *args) 
 5290   
 5291 -    def __iadd__(self, *args): 
 5292          """__iadd__(self, Point3D p) -> Point3D""" 
 5293          return _fife.ModelCoordinate___iadd__(self, *args) 
 5294   
 5295 -    def __isub__(self, *args): 
 5296          """__isub__(self, Point3D p) -> Point3D""" 
 5297          return _fife.ModelCoordinate___isub__(self, *args) 
 5298   
 5299 -    def __mul__(self, *args): 
 5300          """__mul__(self, int i) -> Point3D""" 
 5301          return _fife.ModelCoordinate___mul__(self, *args) 
 5302   
 5303 -    def __div__(self, *args): 
 5304          """__div__(self, int i) -> Point3D""" 
 5305          return _fife.ModelCoordinate___div__(self, *args) 
 5306   
 5307 -    def __eq__(self, *args): 
 5308          """__eq__(self, Point3D p) -> bool""" 
 5309          return _fife.ModelCoordinate___eq__(self, *args) 
 5310   
 5311 -    def __ne__(self, *args): 
 5312          """__ne__(self, Point3D p) -> bool""" 
 5313          return _fife.ModelCoordinate___ne__(self, *args) 
 5314   
 5315 -    def length(self): 
 5316          """length(self) -> int""" 
 5317          return _fife.ModelCoordinate_length(self) 
 5318   
 5319 -    def normalize(self): 
 5320          """normalize(self)""" 
 5321          return _fife.ModelCoordinate_normalize(self) 
 5322   
 5323      __swig_destroy__ = _fife.delete_ModelCoordinate 
 5324      __del__ = lambda self : None; 
 5325  ModelCoordinate_swigregister = _fife.ModelCoordinate_swigregister 
 5326  ModelCoordinate_swigregister(ModelCoordinate) 
 5327   
 5328 -class ExactModelCoordinate(_object): 
 5329      """Proxy of C++ FIFE::PointType3D<(double)> class""" 
 5330      __swig_setmethods__ = {} 
 5331      __setattr__ = lambda self, name, value: _swig_setattr(self, ExactModelCoordinate, name, value) 
 5332      __swig_getmethods__ = {} 
 5333      __getattr__ = lambda self, name: _swig_getattr(self, ExactModelCoordinate, name) 
 5334      __repr__ = _swig_repr 
 5335      __swig_setmethods__["x"] = _fife.ExactModelCoordinate_x_set 
 5336      __swig_getmethods__["x"] = _fife.ExactModelCoordinate_x_get 
 5337      if _newclass:x = _swig_property(_fife.ExactModelCoordinate_x_get, _fife.ExactModelCoordinate_x_set) 
 5338