def test():
app = KumReader()
from e32 import Ao_lock
lock=Ao_lock()
appuifw.app.exit_key_handler=lock.signal
lock.wait()
def __init__(self):
from e32 import Ao_lock
from key_codes import EKeyEnter
self.input_wait_lock = Ao_lock()
self.input_stopped = False
self.control = self.text = appuifw.Text()
self.text.bind(EKeyEnter, self.input_wait_lock.signal)
self.savestderr = sys.stderr
self.savestdout = sys.stdout
self.savestdin = sys.stdin
sys.stderr = self
sys.stdout = self
sys.stdin = self
self.writebuf = []
def make_flusher(text, buf):
def doflush():
text.add(unicode(''.join(buf)))
del buf[:]
if text.len() > 1500:
text.delete(0, text.len() - 500)
return doflush
self._doflush = make_flusher(self.text, self.writebuf)
self._flushgate = e32.ao_callgate(self._doflush)
def test():
app = KumReader()
from e32 import Ao_lock
lock = Ao_lock()
appuifw.app.exit_key_handler = lock.signal
lock.wait()
def __init__(self, logger = False):
self.logger = logger
from e32 import Ao_lock
from key_codes import EKeyEnter
self.input_wait_lock = Ao_lock()
self.input_stopped = False
self.control = self.text = appuifw.Text()
self.text.font = ('title', 16, None)
self.text.color = 0
self.savestderr = sys.stderr
self.savestdout = sys.stdout
self.savestdin = sys.stdin
sys.stderr = self
sys.stdout = self
sys.stdin = self
self.writebuf = []
self._doflush = self.clear()
self._flushgate = self.clear()
if self.logger :
def make_flusher(text, buf):
def doflush():
text.set_pos(text.len())
text.add(ru(''.join(buf)))
del buf[:]
return doflush
self._doflush = make_flusher(self.text, self.writebuf)
self._flushgate = e32.ao_callgate(self._doflush)
else:
self.logger = False
self.clear()
return None
def __init__(self, difficulty=3):
self.difficulty = difficulty
self.columns = range(1, 8)
self.suits = range(1, 5)
self.table = Table(initialCards=Deck(visible=False))
self.selected = None
self.deal(self.table)
self.select(('game', 1))
self.table.show()
self.registerKeys()
self.lock = Ao_lock()
self.lock.wait()
self.table.unshow()
def __init__(self):
self.columns = range(1, 9)
self.free = range(1, 5)
self.suits = range(1, 5)
self.table = Table(initialCards=Deck(visible=True))
self.selected = None
self.deal(self.table)
self.select(('game', 1))
self.table.show()
self.registerKeys()
self.lock = Ao_lock()
self.lock.wait()
self.table.unshow()
def __init__(self, sid=None):
self.commands = {}
self.events = {}
self.pluginnames = []
self.plugins = {}
try:
if sid == None:
sid = GetSid()
self.sid = sid
Property.Define(sid, EKeyCommand, Property.EInt)
Property.Define(sid, EKeyArguments, Property.EText)
Property.Define(sid, EKeyResult, Property.EInt)
self.pCommand = Property()
self.pArgs = Property()
self.pResult = Property()
self.pCommand.Attach(sid, EKeyCommand, Property.EInt)
self.pArgs.Attach(sid, EKeyArguments, Property.EText)
self.pResult.Attach(sid, EKeyResult, Property.EInt)
self.lResult = Ao_lock()
except:
DumpExceptionInfo()
def __init__(self, dtext, dialog):
self.dialog = dialog
self.filelist = []
self.filename = None
self.lastpath = None
self.winparam = []
self.body = None
self.optbody = None
self.dtext = dtext
self.outpath = 'E:\\Images'
self.quality = 75
self.bpp = 24
self.compression = 'default'
self.comprname = {'no' : self.dtext['comp_no'], 'fast' : self.dtext['comp_fast'], 'default' : self.dtext['comp_def'], 'best' : self.dtext['comp_best']}
self.conf = None
self.format = 'PNG'
self.lock = Ao_lock()
def __init__(self,sid=None):
self.commands = {}
self.events = {}
self.pluginnames = []
self.plugins = {}
try:
if sid == None:
sid = GetSid()
self.sid = sid
Property.Define(sid,EKeyCommand,Property.EInt)
Property.Define(sid,EKeyArguments,Property.EText)
Property.Define(sid,EKeyResult,Property.EInt)
self.pCommand = Property()
self.pArgs = Property()
self.pResult = Property()
self.pCommand.Attach(sid,EKeyCommand,Property.EInt)
self.pArgs.Attach(sid,EKeyArguments,Property.EText)
self.pResult.Attach(sid,EKeyResult,Property.EInt)
self.lResult = Ao_lock()
except:
DumpExceptionInfo()
class Game:
def __init__(self):
self.columns = range(1, 9)
self.free = range(1, 5)
self.suits = range(1, 5)
self.table = Table(initialCards=Deck(visible=True))
self.selected = None
self.deal(self.table)
self.select(('game', 1))
self.table.show()
self.registerKeys()
self.lock = Ao_lock()
self.lock.wait()
self.table.unshow()
def deal(self, table):
pile = table[('pile', 1)]
pile.cascadeY = 0
pile.shuffle()
pile.drawBase = False
# add free card stacks
for free in self.free:
table.addStack(id=('free', free))
table[('free', free)].x = 1 + cardWidth * free - cardWidth / 2
# add goal stacks
x = 4 * (cardWidth + 1) + cardWidth / 2 + 2
goal = 0
for suit in self.suits:
table.addStack(id=('goal', suit))
table[('goal', suit)].x = x
table[('goal', suit)].y = 1
table[('goal', suit)].cascadeX = 0
table[('goal', suit)].cascadeY = 0
x += cardWidth
x = cardWidth / 2 + 1
for col in self.columns:
table.addStack(id=('game', col))
table[('game', col)].x = x
table[('game', col)].y = 45
table[('game', col)].cascadeX = 0
table[('game', col)].cascadeY = 10
x += cardWidth + 1
while len(pile) > 0:
for col in self.columns:
table.moveCards(pile, self.table[('game', col)], 1)
# add temporary cards for held stack
table.addStack(id=('held', 1))
table[('held', 1)].x = 60
table[('held', 1)].y = 180
table[('held', 1)].cascadeX = 12
table[('held', 1)].cascadeY = 4
table[('held', 1)].drawBase = False
self.held = table[('held', 1)]
def select(self, stackName, index=-1):
sel = self.selected
if sel:
self.table[sel].selectedIndex = None
self.table[stackName].selectedIndex = index
self.selected = stackName
def registerKeys(self):
table = app.body
table.bind(EKeyDownArrow, self.keyDown)
table.bind(EKeyUpArrow, self.keyUp)
table.bind(EKeyRightArrow, self.keyRight)
table.bind(EKeyLeftArrow, self.keyLeft)
table.bind(EKeySelect, self.keySelect)
app.exit_key_handler = self.exit
def exit(self):
if query(u'Exit game', 'query'):
self.lock.signal()
def keyUp(self):
sel = self.selected
stack = self.table[sel]
# find no. of free cells
n = 0
for free in self.free:
if len(self.table[('free', free)]) == 0:
n += 1
if len(stack[:stack.selectedIndex]) > 0 and stack[
stack.selectedIndex - 1].visible and n >= len(
stack[stack.selectedIndex:]
) and sel[0] == 'game' and stack[stack.selectedIndex].colour(
) != stack[stack.selectedIndex - 1].colour() and int(
stack[stack.selectedIndex]) + 1 == int(
stack[stack.selectedIndex - 1]):
self.select(sel, stack.selectedIndex - 1)
self.table.refreshMarkers()
def keyDown(self):
sel = self.selected
stack = self.table[sel]
if len(stack[stack.selectedIndex:]) > 1:
self.select(sel, stack.selectedIndex + 1)
else:
if sel[0] == 'free':
self.select(('game', sel[1]), -1)
if sel[0] == 'goal':
self.select(('game', sel[1] + len(self.free)), -1)
self.table.refreshMarkers()
def keySelect(self):
sel = self.selected
stack = self.table[sel]
card = stack.selected()
pile = self.table[('pile', 1)]
free = self.table[('free', 1)]
if sel[0] == 'game' or sel[0] == 'goal' or sel[0] == 'free':
if len(self.held) > 0:
# drop cards if possible
if (sel[0] == 'free' and len(stack) == 0 and len(self.held)
== 1) or (sel[0] == 'game' and len(stack) == 0) or (
len(stack) == 0 and sel[0] == 'goal'
and int(self.held[0]) == 1 and len(self.held) == 1
) or (sel[0] == 'goal' and len(stack) > 0
and stack[-1].suit() == self.held[0].suit()
and int(stack[-1]) - int(self.held[0]) == -1
and len(self.held)
== 1) or (stack == self.prevStack) or (
sel[0] == 'game' and len(stack) > 0 and
int(stack[-1]) - int(self.held[0]) == 1 and
stack[-1].colour() != self.held[0].colour()):
self.table.moveCards(self.held, stack)
self.select(sel)
self.table.refresh()
# check if the game is finished
finished = True
for suit in self.suits:
finished &= len(self.table[('goal', suit)]) == 13
if finished:
note(u'Complete!', 'conf')
self.lock.signal()
return
# pick up selected cards
else:
if card and card.visible:
self.table.moveCards(stack, self.held,
len(stack[stack.selectedIndex:]))
self.prevStack = stack
self.select(sel)
self.table.refresh()
return
# return the cards if position invalid
if len(self.held) > 0:
self.table.moveCards(self.held, self.prevStack)
self.table.refresh()
def keyLeft(self):
sel = self.selected
if sel[0] == 'game':
new = sel[1] - 1
if new in self.columns:
self.select((sel[0], new))
else:
self.select(('goal', max(self.suits)))
if sel[0] == 'goal':
new = sel[1] - 1
if new in self.suits:
self.select((sel[0], new))
else:
self.select(('free', max(self.free)))
if sel[0] == 'free':
new = sel[1] - 1
if new in self.free:
self.select((sel[0], new))
else:
self.select(('game', max(self.columns)))
sel = self.selected
stack = self.table[sel]
if len(self.held) == 0 and len(stack) == 0:
self.keyLeft()
else:
self.table.refreshMarkers()
def keyRight(self):
sel = self.selected
if sel[0] == 'game':
new = sel[1] + 1
if new in self.columns:
self.select((sel[0], new))
else:
self.select(('free', min(self.free)))
if sel[0] == 'goal':
new = sel[1] + 1
if new in self.suits:
self.select((sel[0], new))
else:
self.select(('game', min(self.columns)))
if sel[0] == 'free':
new = sel[1] + 1
if new in self.free:
self.select((sel[0], new))
else:
self.select(('goal', min(self.suits)))
sel = self.selected
stack = self.table[sel]
if len(self.held) == 0 and len(stack) == 0:
self.keyRight()
else:
self.table.refreshMarkers()
class Game:
def __init__(self, difficulty=3):
self.difficulty = difficulty
self.columns = range(1, 8)
self.suits = range(1, 5)
self.table = Table(initialCards=Deck(visible=False))
self.selected = None
self.deal(self.table)
self.select(('game', 1))
self.table.show()
self.registerKeys()
self.lock = Ao_lock()
self.lock.wait()
self.table.unshow()
def deal(self, table):
pile = table[('pile', 1)]
pile.cascadeY = 0
pile.shuffle()
# add available cards stacks
table.addStack(id=('open', 1))
table[('open', 1)].x = 2 + cardWidth * 1.5
table[('open', 1)].cascadeX = 10
table[('open', 1)].cascadeY = 0
table[('open', 1)].drawBase = False
# add goal stacks
x = 3 * (cardWidth + 1) + cardWidth / 2
goal = 0
for suit in self.suits:
table.addStack(id=('goal', suit))
table[('goal', suit)].x = x
table[('goal', suit)].y = 1
table[('goal', suit)].cascadeX = 0
table[('goal', suit)].cascadeY = 0
x += cardWidth + 1
x = cardWidth / 2 + 1
for col in self.columns:
table.addStack(id=('game', col))
table[('game', col)].x = x
table[('game', col)].y = 45
table[('game', col)].cascadeX = 0
table[('game', col)].cascadeY = 10
x += cardWidth + 1
for n in range(col):
table.moveCards(pile, self.table[('game', col)], 1)
table[('game', col)][-1].visible = True
# add temporary cards for held stack
table.addStack(id=('held', 1))
table[('held', 1)].x = 40
table[('held', 1)].y = 150
table[('held', 1)].cascadeX = 12
table[('held', 1)].cascadeY = 4
table[('held', 1)].drawBase = False
self.held = table[('held', 1)]
def select(self, stackName, index=-1):
sel = self.selected
if sel:
self.table[sel].selectedIndex = None
self.table[stackName].selectedIndex = index
self.selected = stackName
def registerKeys(self):
table = app.body
table.bind(EKeyDownArrow, self.keyDown)
table.bind(EKeyUpArrow, self.keyUp)
table.bind(EKeyRightArrow, self.keyRight)
table.bind(EKeyLeftArrow, self.keyLeft)
table.bind(EKeySelect, self.keySelect)
app.exit_key_handler = self.exit
def exit(self):
if query(u'Exit game', 'query'):
self.lock.signal()
def keyUp(self):
sel = self.selected
stack = self.table[sel]
if sel[0] == 'game':
if len(stack[:stack.selectedIndex]) > 0 and stack[
stack.selectedIndex - 1].visible:
self.select(sel, stack.selectedIndex - 1)
self.table.refreshMarkers()
def keyDown(self):
sel = self.selected
stack = self.table[sel]
if len(stack[stack.selectedIndex:]) > 1:
self.select(sel, stack.selectedIndex + 1)
self.table.refreshMarkers()
def keySelect(self):
sel = self.selected
stack = self.table[sel]
card = stack.selected()
pile = self.table[('pile', 1)]
open = self.table[('open', 1)]
if sel[0] == 'game' or sel[0] == 'goal' or sel[0] == 'open':
# turn over a card if not visible
if card and not (card.visible) and card == stack[-1] and len(
self.held) == 0:
card.visible = True
self.table.refresh()
return
if len(self.held) > 0:
# drop cards if possible
if (sel[0] == 'game' and len(stack) == 0
and int(self.held[0]) == 13) or (
len(stack) == 0 and sel[0] == 'goal'
and int(self.held[0]) == 1 and len(self.held) == 1
) or (sel[0] == 'goal' and len(stack) > 0
and stack[-1].suit() == self.held[0].suit()
and int(stack[-1]) - int(self.held[0]) == -1
and len(self.held)
== 1) or (stack == self.prevStack) or (
sel[0] == 'game' and len(stack) > 0 and
int(stack[-1]) - int(self.held[0]) == 1 and
stack[-1].colour() != self.held[0].colour()):
self.table.moveCards(self.held, stack)
self.select(sel)
self.table.refresh()
# check if the game is finished
finished = True
for suit in self.suits:
finished &= len(self.table[('goal', suit)]) == 13
if finished:
note(u'Complete!', 'conf')
self.lock.signal()
return
# pick up selected cards
else:
if card and card.visible:
self.table.moveCards(stack, self.held,
len(stack[stack.selectedIndex:]))
self.prevStack = stack
self.select(sel)
self.table.refresh()
return
# open new cards from pile
if sel[0] == 'pile' and len(self.held) == 0:
# hide current open cards
if len(open) > 0:
for openCard in open:
openCard.visible = False
self.table.moveCards(open, pile, toBottom=True)
# show new cards
self.table.moveCards(pile, open, min(len(pile), self.difficulty))
for openCard in open:
openCard.visible = True
self.table.refresh()
return
# return the cards if position invalid
if len(self.held) > 0:
self.table.moveCards(self.held, self.prevStack)
self.table.refresh()
def keyLeft(self):
sel = self.selected
if sel[0] == 'game':
new = sel[1] - 1
if new in self.columns:
self.select((sel[0], new))
else:
self.select(('goal', max(self.suits)))
if sel[0] == 'goal':
new = sel[1] - 1
if new in self.suits:
self.select((sel[0], new))
else:
self.select(('open', 1))
if sel[0] == 'pile':
self.select(('game', max(self.columns)))
if sel[0] == 'open':
self.select(('pile', 1))
# if no cards open don't select it
sel = self.selected
stack = self.table[sel]
if (sel[0] == 'open' or len(self.held) == 0) and len(stack) == 0:
self.keyLeft()
else:
self.table.refreshMarkers()
def keyRight(self):
sel = self.selected
if sel[0] == 'game':
new = sel[1] + 1
if new in self.columns:
self.select((sel[0], new))
else:
self.select(('pile', 1))
if sel[0] == 'goal':
new = sel[1] + 1
if new in self.suits:
self.select((sel[0], new))
else:
self.select(('game', min(self.columns)))
if sel[0] == 'open':
self.select(('goal', min(self.suits)))
if sel[0] == 'pile':
self.select(('open', 1))
# if no cards open don't select it
sel = self.selected
stack = self.table[sel]
if (sel[0] == 'open' or len(self.held) == 0) and len(stack) == 0:
self.keyRight()
else:
self.table.refreshMarkers()
text = "simlock Status = %d" % status
app.body.add(u'%s\n' % text)
status = get_first_boot_status()
text = "first boot Status = %d" % status
app.body.add(u'%s\n' % text)
status = get_sim_owned_status()
text = "sim owned Status = %d" % status
app.body.add(u'%s\n' % text)
status = get_new_email_status()
text = "new email Status = %d" % status
app.body.add(u'%s\n' % text)
status = get_wcdma_status()
text = "wcdma Status = %d" % status
app.body.add(u'%s\n' % text)
status = get_sim_present()
text = "sim present = %d" % status
app.body.add(u'%s\n' % text)
lock = Ao_lock()
app.body = Text()
app.body.clear()
app.exit_key_handler = lock.signal
app.menu = [(u"View sysagent info", viewsysagent)]
lock.wait()
def quit():
app.exit_key_handler = None
script_lock.signal()
capturer.stop()
print "TERMINATO."
print
def inizio():
global img
img = Image.open("C:\\nokia\\images\\tasti2.JPG")
canv.blit(img)
script_lock = Ao_lock()
app.exit_key_handler = quit
appuifw.app.body = canv = appuifw.Canvas()
appuifw.app.screen = 'full'
capturer = keycapture.KeyCapturer(cb_capture)
capturer.forwarding = 0
capturer.keys = (keycapture.EKey0, keycapture.EKey1, keycapture.EKey2,
keycapture.EKey3, keycapture.EKey4, keycapture.EKey5,
keycapture.EKey6, keycapture.EKey7, keycapture.EKey8,
keycapture.EKey9, keycapture.EKeyYes, keycapture.EKeyNo,
keycapture.EKeySelect, keycapture.EKeyEdit,
keycapture.EKeyStar, keycapture.EKeyHash)
capturer.start()
inizio()
script_lock.wait()
class Client:
def __init__(self, sid=None):
self.commands = {}
self.events = {}
self.pluginnames = []
self.plugins = {}
try:
if sid == None:
sid = GetSid()
self.sid = sid
Property.Define(sid, EKeyCommand, Property.EInt)
Property.Define(sid, EKeyArguments, Property.EText)
Property.Define(sid, EKeyResult, Property.EInt)
self.pCommand = Property()
self.pArgs = Property()
self.pResult = Property()
self.pCommand.Attach(sid, EKeyCommand, Property.EInt)
self.pArgs.Attach(sid, EKeyArguments, Property.EText)
self.pResult.Attach(sid, EKeyResult, Property.EInt)
self.lResult = Ao_lock()
except:
DumpExceptionInfo()
def Done(self):
try:
for plugin in self.plugins.keys():
self.UnloadPlugin(plugin)
Property.Delete(self.sid, EKeyCommand)
Property.Delete(self.sid, EKeyArguments)
Property.Delete(self.sid, EKeyResult)
except:
DumpExceptionInfo()
def __getattr__(self, attr):
if attr in self.commands:
return self.commands[attr]
def PingServer(self):
try:
self.pResult.Set(0xff)
self.pCommand.Set(EKeyCmdServerPing)
ao_sleep(0.3)
if self.pResult.Get() == EResultOk:
return True
else:
return False
except:
DumpExceptionInfo()
return False
def ServerStart(self, script):
ping = self.PingServer()
self.pResult.Subscribe(self.OnResult)
if ping == False:
start_exe(u"c:\\sys\\bin\\custom_launcher.exe", script)
self.lResult.wait()
def ServerStop(self):
return self.ServerCall(EKeyCmdServerExit, "")
def LoadPlugin(self, name):
if name in self.pluginnames:
return
import_string = "import %s as plugin" % name
exec import_string
self.plugins[name] = plugin
self.pluginnames.append(name)
plugin.ClientInit(self)
def UnloadPlugin(self, name):
self.plugins[name].ClientDone(self)
del self.plugins[name]
def RegisterEvents(self, events):
try:
for key in events.keys():
self.events[key] = Event(key, events[key][1], self.sid,
events[key][0])
return EResultOk
except:
DumpExceptionInfo()
return EResultFailed
def RegisterCommands(self, commands):
try:
def istuple(var):
return type(var) == type(())
for cmd in commands:
if istuple(cmd):
name, key, format = cmd
self.commands[name] = Command(self, key, format).Call
else:
name = cmd.__name__
self.commands[name] = cmd
return EResultOk
except:
DumpExceptionInfo()
return EResultFailed
def OnResult(self):
try:
self.lResult.signal()
return EResultOk
except:
DumpExceptionInfo()
return EResultFailed
def ServerCall(self, key, format, *args):
try:
if format != "":
s = struct.pack(format, *args)
self.pArgs.Set(s)
self.pCommand.Set(key)
self.lResult.wait()
return self.pResult.Get()
except:
DumpExceptionInfo()
return EResultFailed
def DelCommands(self, *commands):
try:
for name in commands:
del self.commands[name]
return EResultOk
except:
DumpExceptionInfo()
return EResultFailed
def DelEvents(self, *events):
try:
for key in events:
self.events[key].Done()
del self.events[key]
return EResultOk
except:
DumpExceptionInfo()
return EResultFailed
def SendEvent(self, key, *args):
try:
if key in self.events:
self.events[key].Set(*args)
return EResultOk
except:
DumpExceptionInfo()
return EResultFailed
def GetEvent(self, key):
try:
if key in self.events:
return self.events[key].Get()
except:
DumpExceptionInfo()
if key==keycapture.EKey3:
return
def quit():
app.exit_key_handler = None
script_lock.signal()
capturer.stop()
print "TERMINATO."
print
def inizio():
global img
img=Image.open("C:\\nokia\\images\\tasti2.JPG")
canv.blit(img)
script_lock = Ao_lock()
app.exit_key_handler = quit
appuifw.app.body=canv=appuifw.Canvas()
appuifw.app.screen='full'
capturer=keycapture.KeyCapturer(cb_capture)
capturer.forwarding=0
capturer.keys=(
keycapture.EKey0,
keycapture.EKey1,
keycapture.EKey2,
keycapture.EKey3,
keycapture.EKey4,
keycapture.EKey5,
keycapture.EKey6,
keycapture.EKey7,
keycapture.EKey8,
class Console:
def __init__(self, logger = False):
self.logger = logger
from e32 import Ao_lock
from key_codes import EKeyEnter
self.input_wait_lock = Ao_lock()
self.input_stopped = False
self.control = self.text = appuifw.Text()
self.text.font = ('title', 16, None)
self.text.color = 0
self.savestderr = sys.stderr
self.savestdout = sys.stdout
self.savestdin = sys.stdin
sys.stderr = self
sys.stdout = self
sys.stdin = self
self.writebuf = []
self._doflush = self.clear()
self._flushgate = self.clear()
if self.logger :
def make_flusher(text, buf):
def doflush():
text.set_pos(text.len())
text.add(ru(''.join(buf)))
del buf[:]
return doflush
self._doflush = make_flusher(self.text, self.writebuf)
self._flushgate = e32.ao_callgate(self._doflush)
else:
self.logger = False
self.clear()
return None
def __del__(self):
sys.stderr = self.savestderr
sys.stdout = self.savestdout
sys.stdin = self.savestdin
self.control = self.text = None
return
def stop_input(self):
self.input_stopped = True
self.input_wait_lock.signal()
def clear(self):
self.text.clear()
def write(self, obj):
self.writebuf.append(obj)
self.flush()
def writelines(self, list):
self.write(''.join(list))
def flush(self):
if len(self.writebuf) > 0:
if e32.is_ui_thread():
self._doflush()
else:
self._flushgate()
def readline(self):
if not e32.is_ui_thread():
raise IOError('Cannot call readline from non-UI thread')
pos = self.text.get_pos()
len = self.text.len()
save_exit_key_handler = appuifw.app.exit_key_handler
appuifw.app.exit_key_handler = self.stop_input
self.input_wait_lock.wait()
appuifw.app.exit_key_handler = save_exit_key_handler
if self.input_stopped:
self.text.add(u'\n')
self.input_stopped = False
raise EOFError
new_pos = self.text.get_pos()
new_len = self.text.len()
if (new_pos <= pos) | (new_len - len != new_pos - pos):
new_pos = self.text.len()
self.text.set_pos(new_pos)
self.text.add(u'\n')
user_input = ''
else:
user_input = self.text.get(pos, new_pos - pos - 1)
return user_input.encode('utf8')
class Console:
def __init__(self):
from e32 import Ao_lock
from key_codes import EKeyEnter
self.input_wait_lock = Ao_lock()
self.input_stopped = False
self.control = self.text = appuifw.Text()
self.text.bind(EKeyEnter, self.input_wait_lock.signal)
self.savestderr = sys.stderr
self.savestdout = sys.stdout
self.savestdin = sys.stdin
sys.stderr = self
sys.stdout = self
sys.stdin = self
self.writebuf = []
def make_flusher(text, buf):
def doflush():
text.add(unicode(''.join(buf)))
del buf[:]
if text.len() > 1500:
text.delete(0, text.len() - 500)
return doflush
self._doflush = make_flusher(self.text, self.writebuf)
self._flushgate = e32.ao_callgate(self._doflush)
def __del__(self):
sys.stderr = self.savestderr
sys.stdout = self.savestdout
sys.stdin = self.savestdin
self.control = self.text = None
def stop_input(self):
self.input_stopped = True
self.input_wait_lock.signal()
def clear(self):
self.text.clear()
def write(self, obj):
self.writebuf.append(obj)
self.flush()
def writelines(self, list):
self.write(''.join(list))
def flush(self):
if len(self.writebuf) > 0:
if e32.is_ui_thread():
self._doflush()
else:
self._flushgate()
def readline(self):
if not e32.is_ui_thread():
raise IOError('Cannot call readline from non-UI thread')
pos = self.text.get_pos()
len = self.text.len()
save_exit_key_handler = appuifw.app.exit_key_handler
appuifw.app.exit_key_handler = self.stop_input
self.input_wait_lock.wait()
appuifw.app.exit_key_handler = save_exit_key_handler
if self.input_stopped:
self.text.add(u'\n')
self.input_stopped = False
raise EOFError
new_pos = self.text.get_pos()
new_len = self.text.len()
if ((new_pos <= pos) | ((new_len - len) != (new_pos - pos))):
new_pos = self.text.len()
self.text.set_pos(new_pos)
self.text.add(u'\n')
user_input = ''
else:
user_input = (self.text.get(pos, new_pos - pos - 1))
return (user_input)
class Client:
def __init__(self,sid=None):
self.commands = {}
self.events = {}
self.pluginnames = []
self.plugins = {}
try:
if sid == None:
sid = GetSid()
self.sid = sid
Property.Define(sid,EKeyCommand,Property.EInt)
Property.Define(sid,EKeyArguments,Property.EText)
Property.Define(sid,EKeyResult,Property.EInt)
self.pCommand = Property()
self.pArgs = Property()
self.pResult = Property()
self.pCommand.Attach(sid,EKeyCommand,Property.EInt)
self.pArgs.Attach(sid,EKeyArguments,Property.EText)
self.pResult.Attach(sid,EKeyResult,Property.EInt)
self.lResult = Ao_lock()
except:
DumpExceptionInfo()
def Done(self):
try:
for plugin in self.plugins.keys():
self.UnloadPlugin(plugin)
Property.Delete(self.sid,EKeyCommand)
Property.Delete(self.sid,EKeyArguments)
Property.Delete(self.sid,EKeyResult)
except:
DumpExceptionInfo()
def __getattr__(self,attr):
if attr in self.commands:
return self.commands[attr]
def PingServer(self):
try:
self.pResult.Set(0xff)
self.pCommand.Set(EKeyCmdServerPing)
ao_sleep(0.3)
if self.pResult.Get() == EResultOk:
return True
else:
return False
except:
DumpExceptionInfo()
return False
def ServerStart(self,script):
ping = self.PingServer()
self.pResult.Subscribe(self.OnResult)
if ping == False:
start_exe(u"c:\\sys\\bin\\custom_launcher.exe",script)
self.lResult.wait()
def ServerStop(self):
return self.ServerCall(EKeyCmdServerExit,"")
def LoadPlugin(self,name):
if name in self.pluginnames:
return
import_string = "import %s as plugin" % name
exec import_string
self.plugins[name]=plugin
self.pluginnames.append(name)
plugin.ClientInit(self)
def UnloadPlugin(self,name):
self.plugins[name].ClientDone(self)
del self.plugins[name]
def RegisterEvents(self,events):
try:
for key in events.keys():
self.events[key] = Event(key,events[key][1],self.sid,events[key][0])
return EResultOk
except:
DumpExceptionInfo()
return EResultFailed
def RegisterCommands(self,commands):
try:
def istuple(var):
return type(var) == type(())
for cmd in commands:
if istuple(cmd):
name, key, format = cmd
self.commands[name] = Command(self,key,format).Call
else:
name = cmd.__name__
self.commands[name] = cmd
return EResultOk
except:
DumpExceptionInfo()
return EResultFailed
def OnResult(self):
try:
self.lResult.signal()
return EResultOk
except:
DumpExceptionInfo()
return EResultFailed
def ServerCall(self,key,format,*args):
try:
if format != "":
s = struct.pack(format,*args)
self.pArgs.Set(s)
self.pCommand.Set(key)
self.lResult.wait()
return self.pResult.Get()
except:
DumpExceptionInfo()
return EResultFailed
def DelCommands(self,*commands):
try:
for name in commands:
del self.commands[name]
return EResultOk
except:
DumpExceptionInfo()
return EResultFailed
def DelEvents(self,*events):
try:
for key in events:
self.events[key].Done()
del self.events[key]
return EResultOk
except:
DumpExceptionInfo()
return EResultFailed
def SendEvent(self,key,*args):
try:
if key in self.events:
self.events[key].Set(*args)
return EResultOk
except:
DumpExceptionInfo()
return EResultFailed
def GetEvent(self,key):
try:
if key in self.events:
return self.events[key].Get()
except:
DumpExceptionInfo()
