Python __pyjamas__.JS类代码示例

 def __init__(self, options):
     if options:
         self.renderer = \
             JS("""new $wnd.google.maps.DirectionsRenderer(@{{options}})""")
     else:
         self.renderer = \
             JS("""new $wnd.google.maps.DirectionsRenderer()""")

 def __init__(self, year, month, day, d=None):
     if d is None:
         d = JS("""new Date(@{{year}}, @{{month}} - 1, @{{day}}, 0, 0, 0, 0)""")
     self._d = d
     self.year = d.getFullYear()
     self.month = d.getMonth() + 1.0
     self.day = d.getDate()

 def __init__(self, options):
     if options:
         self.renderer = \
             JS("""new $wnd['google']['maps']['DirectionsRenderer'](@{{options}})""")
     else:
         self.renderer = \
             JS("""new $wnd['google']['maps']['DirectionsRenderer']()""")

 def time(self):
     """
     **pyjsdl.time.time**
     
     Return current computer time (in ms).
     """
     ctime = JS("new Date()")
     return ctime.getTime()

class DirectionsService:

    def __init__(self):
        self.ds = JS("""new $wnd.google.maps.DirectionsService()""")

    def route(self, request, callback):
        self.ds.route(request,
           lambda jsResults, status:
               callback(translateDirectionsResults(jsResults), status))

class Geocoder:

    def __init__(self):
        self.geocoder = JS("new $wnd.google.maps.Geocoder()")

    def geocode(self, request, callback):

        self.geocoder.geocode(request,
            lambda jsResults, status:
            callback(translateGeocoderResults(jsResults), status))

class DirectionsRenderer:
    def __init__(self, options):
        if options:
            self.renderer = JS("""new $wnd.google.maps.DirectionsRenderer(options);""")
        else:
            self.renderer = JS("""new $wnd.google.maps.DirectionsRenderer();""")

    def setDirections(self, results):
        self.renderer.setDirections(translateDirectionsResults(results, True))

    def setMap(self, map):
        self.renderer.setMap(map)

 def __init__(self, data=None, offset=None, length=None, typedarray=None):
     """
     The PyTypedArray is instantiated with either the array size, an array of the TypedArray or Python type, or an existing ArrayBuffer to view, which creates a new TypedArray of size and included data as the specified type. Optional arguments include offset index at which ArrayBuffer data is inserted and length of an ArrayBuffer.
     """
     if data:
         if isinstance(data, int):
             if pyjs_mode.optimized:
                 self.__data = JS("""new @{{typedarray}}(@{{data}})""")
             else:
                 self.__data = JS("""new @{{typedarray}}(@{{data}}['valueOf']())""")
         elif isinstance(data, (list,tuple)):
             if pyjs_mode.optimized:
                 self.__data = JS("""new @{{typedarray}}(@{{data}}['getArray']())""")
             else:
                 data = [dat.valueOf() for dat in data]
                 self.__data = JS("""new @{{typedarray}}(@{{data}}['getArray']())""")
         elif isinstance(data, PyTypedArray):
             self.__data = JS("""new @{{typedarray}}(@{{data}}['__data'])""")
         else:   #TypedArray or ArrayBuffer
             if offset is None and length is None:
                 self.__data = JS("""new @{{typedarray}}(@{{data}})""")
             else:
                 if offset is None:
                     offset = 0
                 if length is None:
                     self.__data = JS("""new @{{typedarray}}(@{{data}}, @{{offset}})""")
                 else:
                     self.__data = JS("""new @{{typedarray}}(@{{data}}, @{{offset}}, @{{length}})""")
     else:
         self.__data = None

def gmtime(t=None):
    if t is None:
        t = time()
    date = JS("new Date(@{{t}}*1000)")
    tm = struct_time()
    tm_year = tm.tm_year = int(date.getUTCFullYear())
    tm.tm_mon = int(date.getUTCMonth()) + 1
    tm.tm_mday = int(date.getUTCDate())
    tm.tm_hour = int(date.getUTCHours())
    tm.tm_min = int(date.getUTCMinutes())
    tm.tm_sec = int(date.getUTCSeconds())
    tm.tm_wday = (int(date.getUTCDay()) + 6) % 7
    tm.tm_isdst = 0
    startOfYear = JS("new Date('Jan 1 '+ @{{tm_year}} +' GMT+0000')")
    tm.tm_yday = 1 + int((t - startOfYear.getTime()/1000)/86400)
    return tm

def mktime(t):
    """mktime(tuple) -> floating point number
    Convert a time tuple in local time to seconds since the Epoch."""
    tm_year = t[0]
    tm_mon = t[1] - 1
    tm_mday = t[2]
    tm_hour = t[3]
    tm_min = t[4]
    tm_sec = t[5]
    date = JS("new Date(@{{tm_year}}, @{{tm_mon}}, @{{tm_mday}}, @{{tm_hour}}, @{{tm_min}}, @{{tm_sec}})") # local time
    utc = JS("Date.UTC(@{{tm_year}}, @{{tm_mon}}, @{{tm_mday}}, @{{tm_hour}}, @{{tm_min}}, @{{tm_sec}})")/1000
    ts = date.getTime() / 1000
    if t[8] == 0:
        if ts - utc == timezone:
            return ts
        return ts + _dst
    return ts

def localtime(t=None):
    if t == None:
        t = time()
    date = JS("new Date(t*1000)")
    tm = struct_time()
    tm.tm_year = date.getFullYear()
    tm.tm_mon = date.getMonth() + 1
    tm.tm_mday = date.getDate()
    tm.tm_hour = date.getHours()
    tm.tm_min = date.getMinutes()
    tm.tm_sec = date.getSeconds()
    tm.tm_wday = (date.getDay() + 6) % 7
    startOfYear = int((JS("new Date(tm.tm_year,0,1)").getTime()) / 1000)
    tm.tm_yday = 1 + int((t - startOfYear) / 86400)
    tm.tm_isdst = date.getTimezoneOffset()
    return tm

def gmtime(t=None):
    if t == None:
        t = time()
    date = JS("new Date(t*1000)")
    tm = struct_time()
    tm.tm_year = date.getUTCFullYear()
    tm.tm_mon = date.getUTCMonth() + 1
    tm.tm_mday = date.getUTCDate()
    tm.tm_hour = date.getUTCHours()
    tm.tm_min = date.getUTCMinutes()
    tm.tm_sec = date.getUTCSeconds()
    tm.tm_wday = (date.getUTCDay() + 6) % 7
    startOfYear = int((JS("new Date(tm.tm_year,0,1)").getTime()) / 1000)
    tm.tm_yday = 1 + int((t - startOfYear) / 86400)
    tm.tm_isdst = 0
    return tm

class md5:
    def __init__(self, s=''):
        self.finished = False
        self.md5 = JS("new @{{!_md5}}()")
        self.md5.init()
        self.update(s)

    def update(self, s):
        for c in str(s):
            b = ord(c)
            self.md5.update(b)

    def hexdigest(self):
        if not self.finished:
            self.finished = True
            self.md5.finish()
        res = self.md5.getdigestBits()
        return hexstr(res)

    def digest(self):
        if not self.finished:
            self.finished = True
            self.md5.finish()
        return self.md5.getdigestBits()

 def fromtimestamp(self, timestamp, tz=None):
     if tz != None:
         raise NotImplementedError("tz")
     d = JS("""new Date()""")
     d.setTime(timestamp * 1000.0)
     return datetime(0, 0, 0, d=d)

def localtime(t=None):
    if t is None:
        t = time()
    date = JS("new Date(@{{t}}*1000)")
    dateOffset = date.getTimezoneOffset()
    tm = struct_time()
    tm_year = tm.tm_year = int(date.getFullYear())
    tm_mon = tm.tm_mon = int(date.getMonth()) + 1
    tm_mday = tm.tm_mday = int(date.getDate())
    tm.tm_hour = int(date.getHours())
    tm.tm_min = int(date.getMinutes())
    tm.tm_sec = int(date.getSeconds())
    tm.tm_wday = (int(date.getDay()) + 6) % 7
    tm.tm_isdst = 0 if timezone == 60*date.getTimezoneOffset() else 1
    startOfYear = JS("new Date(@{{tm_year}},0,1)") # local time
    startOfYearOffset = startOfYear.getTimezoneOffset()
    startOfDay = JS("new Date(@{{tm_year}},@{{tm_mon}}-1,@{{tm_mday}})")
    dt = float(startOfDay.getTime() - startOfYear.getTime())/1000
    dt = dt + 60 * (startOfYearOffset - dateOffset)
    tm.tm_yday = 1 + int(dt/86400.0)
    return tm