beremiz: comparison svgui/pyjs/lib/pyjslib.py

equal deleted inserted replaced

-:c02818d7e29f
+:7e61baa047f0
 from __pyjamas__ import JS
 # must declare import _before_ importing sys
 def import_module(path, parent_module, module_name, dynamic=1, async=False):
 """
 """
 JS("""
 wait();
 }
 """)
 class Object:
 pass
 object = Object
 class Modload:
 def __init__(self, path, app_modlist, app_imported_fn, dynamic,
 parent_mod):
 if self.idx >= len(self.app_modlist):
 import_wait(self.app_imported_fn, self.parent_mod, self.dynamic)
 else:
 import_wait(getattr(self, "next"), self.parent_mod, self.dynamic)
 def get_module(module_name):
 ev = "__mod = %s;" % module_name
 JS("pyjs_eval(ev);")
 return __mod
 def preload_app_modules(path, app_modnames, app_imported_fn, dynamic,
 parent_mod=None):
 loader = Modload(path, app_modnames, app_imported_fn, dynamic, parent_mod)
 loader.next()
 import sys
 class BaseException:
 name = "BaseException"
 return repr(self.args)
 def toString(self):
 return str(self)
 class Exception(BaseException):
 name = "Exception"
 class TypeError(BaseException):
 name = "TypeError"
 class StandardError(Exception):
 name = "StandardError"
 class LookupError(StandardError):
 name = "LookupError"
 def toString(self):
 return self.name + ": " + self.args[0]
 class KeyError(LookupError):
 name = "KeyError"
 class AttributeError(StandardError):
 name = "AttributeError"
 def toString(self):
 return "AttributeError: %s of %s" % (self.args[1], self.args[0])
 pyjslib.abs = Math.abs;
 """)
 class Class:
 def __init__(self, name):
 self.name = name
 def __str___(self):
 return self.name
 def eq(a,b):
 JS("""
 if (pyjslib.hasattr(a, "__cmp__")) {
 return a.__cmp__(b) == 0;
 } else if (pyjslib.hasattr(b, "__cmp__")) {
 return b.__cmp__(a) == 0;
 }
 return a == b;
 """)
 def cmp(a,b):
 if hasattr(a, "__cmp__"):
 return a.__cmp__(b)
 elif hasattr(b, "__cmp__"):
 elif b > a:
 return -1
 else:
 return 0
 def bool(v):
 # this needs to stay in native code without any dependencies here,
 # because this is used by if and while, we need to prevent
 # recursion
 JS("""
 }
 return true;
 }
 return Boolean(v);
 """)
 class List:
 def __init__(self, data=None):
 JS("""
 this.l = [];
 def __str__(self):
 return repr(self)
 list = List
 class Tuple:
 def __init__(self, data=None):
 JS("""
 this.l = [];
 this.extend(data);
 return repr(self)
 dict = Dict
 # taken from mochikit: range( [start,] stop[, step] )
 def range():
 JS("""
 var start = 0;
 var stop = 0;
 var step = 1;
 return this;
 }
 }
 """)
 def slice(object, lower, upper):
 JS("""
 if (pyjslib.isString(object)) {
 if (lower < 0) {
 lower = object.length + lower;
 return object.slice(lower, upper);
 return null;
 """)
 def str(text):
 JS("""
 if (pyjslib.hasattr(text,"__str__")) {
 return text.__str__();
 }
 return String(text);
 """)
 def ord(x):
 if(isString(x) and len(x) is 1):
 JS("""
 return x.charCodeAt(0);
 """)
 JS("""
 throw pyjslib.TypeError();
 """)
 return None
 def chr(x):
 JS("""
 return String.fromCharCode(x)
 """)
 def is_basetype(x):
 JS("""
 var t = typeof(x);
 return t == 'boolean' ||
 t == 'string' ||
 t == 'undefined'
 ;
 """)
 def get_pyjs_classtype(x):
 JS("""
 if (pyjslib.hasattr(x, "__class__"))
 if (pyjslib.hasattr(x.__class__, "__new__"))
 var src = x.__class__.__name__;
 return src;
 return null;
 """)
 def repr(x):
 """ Return the string representation of 'x'.
 """
 JS("""
 //var s = constructor.replace(new RegExp('_', "g"), '.');
 return "<" + constructor + " object>";
 """)
 def float(text):
 JS("""
 return parseFloat(text);
 """)
 def int(text, radix=0):
 JS("""
 return parseInt(text, radix);
 """)
 def len(object):
 JS("""
 if (object==null) return 0;
 if (pyjslib.isObject(object) && object.__len__) return object.__len__();
 return object.length;
 """)
 def isinstance(object_, classinfo):
 if pyjslib.isUndefined(object_):
 return False
 if not pyjslib.isObject(object_):
 return True
 return False
 else:
 return _isinstance(object_, classinfo)
 def _isinstance(object_, classinfo):
 if not pyjslib.isObject(object_):
 return False
 JS("""
 if (object_.__class__){
 var res =  object_ instanceof classinfo.constructor;
 return res;
 }
 return false;
 """)
 def getattr(obj, name, default_):
 JS("""
 if ((!pyjslib.isObject(obj))||(pyjslib.isUndefined(obj[name]))){
 if (pyjslib.isUndefined(default_)){
 }
 fnwrap.__name__ = name;
 return fnwrap;
 """)
 def setattr(obj, name, value):
 JS("""
 if (!pyjslib.isObject(obj)) return null;
 obj[name] = value;
 """)
 def hasattr(obj, name):
 JS("""
 if (!pyjslib.isObject(obj)) return false;
 if (pyjslib.isUndefined(obj[name])) return false;
 return true;
 """)
 def dir(obj):
 JS("""
 var properties=new pyjslib.List();
 for (property in obj) properties.append(property);
 return properties;
 """)
 def filter(obj, method, sequence=None):
 # object context is LOST when a method is passed, hence object must be passed separately
 # to emulate python behaviour, should generate this code inline rather than as a function call
 items = []
 return maxValue
 next_hash_id = 0
 def hash(obj):
 JS("""
 if (obj == null) return null;
 if (obj.$H) return obj.$H;
 def isObject(a):
 JS("""
 return (a != null && (typeof a == 'object')) || pyjslib.isFunction(a);
 """)
 def isFunction(a):
 JS("""
 return typeof a == 'function';
 """)
 def isString(a):
 JS("""
 return typeof a == 'string';
 """)
 def isNull(a):
 JS("""
 return typeof a == 'object' && !a;
 """)
 def isArray(a):
 JS("""
 return pyjslib.isObject(a) && a.constructor == Array;
 """)
 def isUndefined(a):
 JS("""
 return typeof a == 'undefined';
 """)
 def isIteratable(a):
 JS("""
 return pyjslib.isString(a) || (pyjslib.isObject(a) && a.__iter__);
 """)
 def isNumber(a):
 JS("""
 return typeof a == 'number' && isFinite(a);
 """)
 def toJSObjects(x):
 """
 Convert the pyjs pythonic List and Dict objects into javascript Object and Array
 objects, recursively.
 }
 return result;
 """)
 return x
 def printFunc(objs):
 JS("""
 if ($wnd.console==undefined)  return;
 var s = "";
 for(var i=0; i < objs.length; i++) {
 s += objs[i];
 }
 console.debug(s)
 """)
 def type(clsname, bases=None, methods=None):
 """ creates a class, derived from bases, with methods and variables
 """
 JS(" var mths = {}; ")

changeset 1736	7e61baa047f0
parent 1730	64d8f52bc8c8
child 1740	b789b695b5c6