mirror of
https://github.com/shlomif/PySolFC.git
synced 2025-04-05 00:02:29 -04:00
1691 lines
52 KiB
Python
1691 lines
52 KiB
Python
#!/usr/bin/python
|
|
# -*- mode: python; coding: utf-8; -*-
|
|
# ---------------------------------------------------------------------------#
|
|
#
|
|
# Copyright (C) 2017 LB
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
#
|
|
# ---------------------------------------------------------------------------#
|
|
|
|
from __future__ import division
|
|
|
|
import logging
|
|
import math
|
|
import traceback
|
|
|
|
from kivy.graphics import Color
|
|
from kivy.graphics import Rectangle
|
|
from kivy.graphics import Line
|
|
from kivy.graphics import Triangle
|
|
|
|
from kivy.utils import platform
|
|
from kivy.properties import StringProperty
|
|
|
|
from kivy.base import EventLoop
|
|
from kivy.base import stopTouchApp
|
|
from kivy.app import App
|
|
from kivy.animation import Animation
|
|
from kivy.core.audio import SoundLoader
|
|
from kivy.clock import Clock
|
|
|
|
from kivy.uix.image import Image as KivyImage
|
|
from kivy.uix.boxlayout import BoxLayout
|
|
from kivy.uix.widget import Widget
|
|
from kivy.uix.button import Button
|
|
from kivy.uix.behaviors import ButtonBehavior
|
|
from kivy.uix.label import Label
|
|
from kivy.uix.scrollview import ScrollView
|
|
|
|
from kivy.uix.actionbar import ActionView
|
|
from kivy.uix.actionbar import ActionPrevious
|
|
from kivy.uix.actionbar import ActionButton
|
|
|
|
from kivy.uix.treeview import TreeView
|
|
from kivy.uix.treeview import TreeViewLabel
|
|
|
|
from kivy.core.window import Window
|
|
from kivy.cache import Cache
|
|
|
|
|
|
# =============================================================================
|
|
|
|
|
|
def get_platform():
|
|
return platform
|
|
|
|
# =============================================================================
|
|
|
|
|
|
class LAnimationMgr(object):
|
|
def __init__(self, **kw):
|
|
super(LAnimationMgr, self).__init__()
|
|
self.animations = []
|
|
self.widgets = {}
|
|
|
|
def animEnd(self, anim, widget):
|
|
# print('LAnimationMgr: animEnd = %s.%s' % (anim, widget))
|
|
|
|
self.widgets[widget] = self.widgets[widget][1:]
|
|
self.animations.remove(anim)
|
|
if len(self.widgets[widget]) > 0:
|
|
# start next animation on widget
|
|
nanim = self.widgets[widget][0]
|
|
self.animations.append(nanim)
|
|
print('LAnimationMgr: animEnd, append = %s' % (nanim))
|
|
nanim.start(widget)
|
|
else:
|
|
# no further animations for widget so stop
|
|
del self.widgets[widget]
|
|
|
|
def makeAnimStart(self, anim, spos, widget):
|
|
def animStart(dt):
|
|
widget.pos = spos
|
|
# print('LAnimationMgr: animStart = %s ... %s' % (anim, dt))
|
|
anim.start(widget)
|
|
return animStart
|
|
|
|
def checkRunning(self):
|
|
return len(self.animations) > 0
|
|
|
|
def create(self, spos, widget, **kw):
|
|
x = 0.0
|
|
y = 0.0
|
|
duration = 0.2
|
|
transition = 'in_out_quad'
|
|
if 'x' in kw:
|
|
x = kw['x']
|
|
if 'y' in kw:
|
|
y = kw['y']
|
|
if 'duration' in kw:
|
|
duration = kw['duration']
|
|
if 'transition' in kw:
|
|
transition = kw['transition']
|
|
|
|
anim = Animation(x=x, y=y, duration=duration, transition=transition)
|
|
anim.bind(on_complete=self.animEnd)
|
|
if 'bindE' in kw:
|
|
anim.bind(on_complete=kw['bindE'])
|
|
if 'bindS' in kw:
|
|
anim.bind(on_start=kw['bindS'])
|
|
|
|
offset = duration / 3.0
|
|
# offset = duration*1.2
|
|
timedelay = offset * len(self.animations)
|
|
# print('offset = %s'% offset)
|
|
print('LAnimationMgr: timedelay = %s' % timedelay)
|
|
|
|
if widget in self.widgets:
|
|
# append additional animation to widget
|
|
self.widgets[widget].append(anim)
|
|
else:
|
|
# setup first animation for widget
|
|
self.animations.append(anim)
|
|
self.widgets[widget] = [anim]
|
|
Clock.schedule_once(self.makeAnimStart(
|
|
anim, spos, widget), timedelay)
|
|
|
|
|
|
LAnimationManager = LAnimationMgr()
|
|
|
|
# =============================================================================
|
|
|
|
LSoundLoader = SoundLoader
|
|
|
|
# =============================================================================
|
|
|
|
|
|
class LBoxLayout(BoxLayout):
|
|
def __init__(self, **kw):
|
|
super(LBoxLayout, self).__init__(**kw)
|
|
|
|
def winfo_screenwidth(self):
|
|
return self.size[0]
|
|
|
|
def winfo_screenheight(self):
|
|
return self.size[1]
|
|
|
|
# =============================================================================
|
|
|
|
|
|
class LImage(KivyImage):
|
|
|
|
def __init__(self, **kwargs):
|
|
super(LImage, self).__init__(**kwargs)
|
|
self.size = self.texture.size
|
|
self.silent = False
|
|
self.allow_stretch = True
|
|
# self.keep_ratio = 0
|
|
# self.size_hint = (1.0/9.0, 1.0/4.0)
|
|
self.size_hint = (1.0, 1.0)
|
|
# self.mipmap = True # funktioniert nicht.
|
|
|
|
self.corePos = None
|
|
self.coreSize = None
|
|
|
|
# logging.info('LImage: __init__() %s' % kwargs)
|
|
|
|
def getHeight(self):
|
|
return self.size[1]
|
|
|
|
def getWidth(self):
|
|
return self.size[0]
|
|
|
|
def subsample(self, r):
|
|
''
|
|
return LImage(texture=self.texture)
|
|
'''
|
|
if (self.source!=None):
|
|
# logging.info("LImage: subsample, %d, %s " % (r , self.source))
|
|
return LImage(source=self.source)
|
|
elif (self.texture!=None):
|
|
# logging.info("LImage: subsample, %d (texture) " % r)
|
|
return LImage(texture=self.texture)
|
|
'''
|
|
return self
|
|
|
|
def on_touch_down(self, touch):
|
|
if self.silent:
|
|
return False
|
|
|
|
# print('LImage: touch_down on %s' % str(touch.pos))
|
|
if self.collide_point(*touch.pos):
|
|
if (self.source is not None):
|
|
print('LImage match %s' % self.source)
|
|
else:
|
|
print('LImage match with texture')
|
|
return True
|
|
return False
|
|
|
|
def on_touch_up(self, touch):
|
|
if self.silent:
|
|
return False
|
|
|
|
# print('LImage: touch_up on %s' % str(touch.pos))
|
|
if self.collide_point(*touch.pos):
|
|
if (self.source is not None):
|
|
print('LImage match %s' % self.source)
|
|
else:
|
|
print('LImage match with texture')
|
|
return True
|
|
return False
|
|
|
|
# =============================================================================
|
|
|
|
|
|
def addAnchorOffset(pos, size, anchor):
|
|
# print ('MfxCanvas: anchor=%s' % (anchor))
|
|
x = pos[0]
|
|
y = pos[1]
|
|
xa = 0
|
|
ya = 0
|
|
if anchor == "n":
|
|
ya = -1
|
|
elif anchor == "w":
|
|
xa = -1
|
|
elif anchor == "s":
|
|
ya = 1
|
|
elif anchor == "e":
|
|
xa = 1
|
|
elif anchor == "ne":
|
|
ya = -1
|
|
xa = 1
|
|
elif anchor == "nw":
|
|
ya = -1
|
|
xa = -1
|
|
elif anchor == "se":
|
|
ya = 1
|
|
xa = 1
|
|
elif anchor == "sw":
|
|
ya = 1
|
|
xa = -1
|
|
|
|
if xa == 0:
|
|
x = x - size[0] / 2.0
|
|
elif xa == 1:
|
|
x = x - size[0]
|
|
if ya == 0:
|
|
y = y - size[1] / 2.0
|
|
elif ya == 1:
|
|
y = y - size[1]
|
|
return (x, y)
|
|
|
|
# =============================================================================
|
|
|
|
|
|
def LColorToKivy(outline):
|
|
if (outline[0] == '#'):
|
|
outline = outline[1:]
|
|
ou0 = float(int(outline[0:2], 16)) / 256.0
|
|
ou1 = float(int(outline[2:4], 16)) / 256.0
|
|
ou2 = float(int(outline[4:6], 16)) / 256.0
|
|
ou3 = 1.0
|
|
if len(outline) >= 8:
|
|
ou3 = float(int(outline[6:8], 16)) / 256.0
|
|
return ou0, ou1, ou2, ou3
|
|
|
|
# =============================================================================
|
|
|
|
|
|
class LText(Widget):
|
|
text = StringProperty('')
|
|
|
|
def __init__(self, canvas, x, y, **kwargs):
|
|
super(LText, self).__init__(**kwargs)
|
|
# super(LText, self).__init__()
|
|
|
|
if 'text' not in kwargs:
|
|
kwargs['text'] = 'X'
|
|
|
|
font = 'helvetica'
|
|
fontsize = 18.0
|
|
if 'font' in kwargs:
|
|
font = kwargs['font'][0]
|
|
fontsize = kwargs['font'][1]
|
|
del kwargs['font']
|
|
|
|
self.anchor = 'nw'
|
|
if 'anchor' in kwargs:
|
|
self.anchor = kwargs['anchor']
|
|
|
|
self.text = kwargs['text']
|
|
self.coreFontSize = fontsize
|
|
self.coreFont = font
|
|
|
|
# print('LText: font = %s, font_size = %s' % (font, fontsize))
|
|
# print('LText: text = %s' % (self.text))
|
|
|
|
self.label = Label(font=font, font_size=fontsize, **kwargs)
|
|
# self.label = Label(font=font, font_size=fontsize)
|
|
self.label.texture_update()
|
|
self.coreSize = self.label.texture_size
|
|
self.corePos = (x, y)
|
|
self.prnt = canvas
|
|
|
|
# print('LText: corePos = %s, coreSize = %s'
|
|
# % (self.corePos, self.coreSize))
|
|
|
|
self.size = self.label.texture_size
|
|
|
|
self.bind(size=self.updateCanvas)
|
|
self.bind(pos=self.updateCanvas)
|
|
self.bind(text=self.updateCanvas)
|
|
|
|
def updateCanvas(self, inst, val):
|
|
self.label.text = self.text
|
|
self.label.texture_update()
|
|
|
|
self.coreSize = self.label.texture_size
|
|
cp = addAnchorOffset(self.corePos, self.coreSize, self.anchor)
|
|
cs = self.coreSize
|
|
|
|
pos, size = self.prnt.CoreToKivy(cp, cs)
|
|
# print('LText: pos = %s, size = %s' % (pos, size))
|
|
|
|
color = LColorToKivy(self.prnt._text_color)
|
|
# print('LText: color = %s' % str(color))
|
|
self.canvas.clear()
|
|
with self.canvas:
|
|
Color(color[0], color[1], color[2], color[3])
|
|
Rectangle(texture=self.label.texture, pos=pos, size=size)
|
|
|
|
# =============================================================================
|
|
|
|
|
|
class LEvent(object):
|
|
def __init__(self):
|
|
self.x = 0
|
|
self.y = 0
|
|
self.cardid = -1
|
|
self.char = False
|
|
pass
|
|
|
|
# =============================================================================
|
|
|
|
|
|
class LLine(Widget):
|
|
def __init__(self, canvas, args, **kw):
|
|
super(LLine, self).__init__(**kw)
|
|
|
|
print('kw = %s%s' % (args, kw))
|
|
|
|
lwidth = 10
|
|
fill = '#ee3344'
|
|
ashape = ()
|
|
arrow = 'none'
|
|
|
|
self.prnt = canvas
|
|
xmin = 100000
|
|
ymin = 100000
|
|
xmax = -100000
|
|
ymax = -100000
|
|
self.corePoly = []
|
|
if isinstance(args[0], list):
|
|
kww = args[1]
|
|
if ('width' in kww):
|
|
lwidth = kww['width']
|
|
self.lwidth = lwidth
|
|
if ('fill' in kww):
|
|
fill = kww['fill']
|
|
self.fill = fill
|
|
if ('arrowshape' in kw):
|
|
ashape = kw['arrowshape']
|
|
self.ashape = ashape
|
|
if ('arrow' in kw):
|
|
arrow = kw['arrow']
|
|
self.arrow = arrow
|
|
|
|
pts = args[0]
|
|
ipts = iter(pts)
|
|
for x, y in zip(ipts, ipts):
|
|
print('%s.%s' % (x, y))
|
|
self.corePoly.append(x)
|
|
self.corePoly.append(y)
|
|
if x < xmin:
|
|
xmin = x
|
|
if x > xmax:
|
|
xmax = x
|
|
if y < ymin:
|
|
ymin = y
|
|
if y > ymax:
|
|
ymax = y
|
|
else:
|
|
if ('width' in kw):
|
|
lwidth = kw['width']
|
|
self.lwidth = lwidth
|
|
if ('fill' in kw):
|
|
fill = kw['fill']
|
|
self.fill = fill
|
|
if ('arrowshape' in kw):
|
|
ashape = kw['arrowshape']
|
|
self.ashape = ashape
|
|
if ('arrow' in kw):
|
|
arrow = kw['arrow']
|
|
self.arrow = arrow
|
|
|
|
for i in range(0, 2):
|
|
x = args[2 * i]
|
|
y = args[2 * i + 1]
|
|
self.corePoly.append(x)
|
|
self.corePoly.append(y)
|
|
if x < xmin:
|
|
xmin = x
|
|
if x > xmax:
|
|
xmax = x
|
|
if y < ymin:
|
|
ymin = y
|
|
if y > ymax:
|
|
ymax = y
|
|
|
|
print('width = %s' % self.lwidth)
|
|
print('color = %s' % self.fill)
|
|
print('arrow = %s' % self.arrow)
|
|
print('ashape = %s' % str(self.ashape))
|
|
|
|
self.alist = []
|
|
if self.arrow == 'last':
|
|
self.alist.append(self.corePoly[-2])
|
|
self.alist.append(self.corePoly[-1])
|
|
self.alist.append(self.corePoly[-4])
|
|
self.alist.append(self.corePoly[-3])
|
|
elif self.arrow != 'none':
|
|
self.alist.append(self.corePoly[0])
|
|
self.alist.append(self.corePoly[1])
|
|
self.alist.append(self.corePoly[2])
|
|
self.alist.append(self.corePoly[3])
|
|
|
|
self.corePos = (xmin, ymin)
|
|
self.coreSize = (xmax - xmin, ymax - ymin)
|
|
self.pos = self.corePos
|
|
self.size = self.coreSize
|
|
|
|
self.bcolor = LColorToKivy(self.fill)
|
|
|
|
self.bind(size=self.updateCanvas)
|
|
self.bind(pos=self.updateCanvas)
|
|
|
|
def updateCanvas(self, instance, value):
|
|
# size = self.size
|
|
# pos = self.pos
|
|
|
|
# Linie:
|
|
poly = None
|
|
poly = []
|
|
dmy, sxy = self.prnt.CoreToKivy(
|
|
(0.0, 0.0), (self.lwidth, self.lwidth))
|
|
wpoly = sxy[1]
|
|
ipts = iter(self.corePoly)
|
|
for x, y in zip(ipts, ipts):
|
|
print('%s.%s' % (x, y))
|
|
xy, dmy = self.prnt.CoreToKivy((x, y))
|
|
poly.append(xy[0])
|
|
poly.append(xy[1])
|
|
|
|
def rot(x, y, a):
|
|
x1 = x * math.cos(a) + y * math.sin(a)
|
|
y1 = y * math.cos(a) - x * math.sin(a)
|
|
return (x1, y1)
|
|
|
|
# Pfeil:
|
|
PI = 3.1415926
|
|
atrio = None
|
|
atrio = []
|
|
if (len(self.ashape) > 2):
|
|
dx = (self.alist[0] - self.alist[2])
|
|
dy = (self.alist[1] - self.alist[3])
|
|
if (dx == 0.0):
|
|
if (dy > 0.0):
|
|
ang = -PI / 2.0
|
|
else:
|
|
ang = PI / 2.0
|
|
else:
|
|
ang = math.atan(dy / dx)
|
|
if (dx > 0.0):
|
|
ang = ang + PI
|
|
|
|
# (kante, winkel?)
|
|
x = self.ashape[0] * math.cos(self.ashape[1] * PI / 360.0)
|
|
y = 2.0 * self.ashape[0] * math.sin(self.ashape[1] * PI / 360.0)
|
|
# (länge, breite?)
|
|
# x = self.ashape[0]
|
|
# y = self.ashape[1]
|
|
o = self.ashape[2]
|
|
axy, dmy = self.prnt.CoreToKivy((self.alist[0], self.alist[1]))
|
|
dmy, asxy = self.prnt.CoreToKivy((0, 0), (x, y))
|
|
dmy, aoff = self.prnt.CoreToKivy((0, 0), (o, o))
|
|
print('asxy=%s' % str(asxy))
|
|
|
|
x1, y1 = rot(-aoff[0], 0.0, ang)
|
|
atrio.append(x1 + axy[0])
|
|
atrio.append(y1 + axy[1])
|
|
x1, y1 = rot(asxy[0] - aoff[0], asxy[1], ang)
|
|
atrio.append(x1 + axy[0])
|
|
atrio.append(y1 + axy[1])
|
|
x1, y1 = rot(asxy[0] - aoff[0], -asxy[1], ang)
|
|
atrio.append(x1 + axy[0])
|
|
atrio.append(y1 + axy[1])
|
|
|
|
self.canvas.clear()
|
|
with self.canvas:
|
|
Color(self.bcolor[0], self.bcolor[1],
|
|
self.bcolor[2], self.bcolor[3])
|
|
Line(points=poly, width=wpoly, cap='none', joint='bevel')
|
|
if (len(atrio) > 2):
|
|
Triangle(points=atrio)
|
|
|
|
# =============================================================================
|
|
|
|
|
|
class LRectangle(Widget):
|
|
def __init__(self, prnt, args, **kw):
|
|
super(LRectangle, self).__init__(**kw)
|
|
self.prnt = prnt
|
|
|
|
# print('width %s' % kw['width'])
|
|
# print('outline %s' % kw['outline'])
|
|
# print('fill %s' % kw['fill'])
|
|
|
|
width = 10.0
|
|
if ('width' in kw):
|
|
width = float(kw['width'])
|
|
|
|
bcolor = '#ffa000a0'
|
|
if ('outline') in kw:
|
|
bcolor = kw['outline']
|
|
if (not bcolor or len(bcolor) < 7):
|
|
bcolor = '#ffa000a0'
|
|
|
|
fcolor = '#00aaff20'
|
|
if ('fill') in kw:
|
|
fcolor = kw['fill']
|
|
if (not fcolor or len(fcolor) < 7):
|
|
fcolor = '#00aaff20'
|
|
|
|
self.group = None
|
|
if 'group' in kw:
|
|
self.group = kw['group']
|
|
|
|
xmin = float(args[0])
|
|
ymin = float(args[1])
|
|
xmax = float(args[2])
|
|
ymax = float(args[3])
|
|
|
|
# print ('LRectangle: min = %s.%s' % (xmin, ymin))
|
|
# print ('LRectangle: max = %s.%s' % (xmax, ymax))
|
|
# print ('LRectangle: border = %s' % (width))
|
|
|
|
self.border = width
|
|
self.fcolor = LColorToKivy(fcolor)
|
|
self.bcolor = LColorToKivy(bcolor)
|
|
|
|
self.corePos = (xmin, ymin)
|
|
self.coreSize = (xmax - xmin, ymax - ymin)
|
|
self.pos = self.corePos
|
|
self.size = self.coreSize
|
|
self.topleft = (xmin + width / 2.0, ymin + width / 2.0)
|
|
self.bottomright = (xmax - width / 2.0, ymax - width / 2.0)
|
|
self.poly = None
|
|
|
|
self.bind(size=self.updateCanvas)
|
|
self.bind(pos=self.updateCanvas)
|
|
|
|
def updateCanvas(self, instance, value):
|
|
# print('LRectangle: updateCanvas')
|
|
|
|
pos, size = self.prnt.CoreToKivy(self.corePos, self.coreSize)
|
|
bpos, dmy = self.prnt.CoreToKivy(self.topleft)
|
|
tpos, dmy = self.prnt.CoreToKivy(self.bottomright)
|
|
|
|
poly = [bpos[0], bpos[1],
|
|
tpos[0], bpos[1],
|
|
tpos[0], tpos[1],
|
|
bpos[0], tpos[1],
|
|
bpos[0], bpos[1]]
|
|
|
|
dmy, brd = self.prnt.CoreToKivy(
|
|
(0.0, 0.0), (self.border, self.border))
|
|
border = brd[1]
|
|
|
|
self.canvas.clear()
|
|
with self.canvas:
|
|
Color(self.fcolor[0], self.fcolor[1],
|
|
self.fcolor[2], self.fcolor[3])
|
|
Rectangle(pos=pos, size=size)
|
|
Color(self.bcolor[0], self.bcolor[1],
|
|
self.bcolor[2], self.bcolor[3])
|
|
Line(points=poly, width=border)
|
|
|
|
def on_touch_down(self, touch):
|
|
if self.collide_point(*touch.pos):
|
|
if self.group is not None:
|
|
logging.info('LRectangle: self=%s group=%s' %
|
|
(self, self.group))
|
|
if '<1>' in self.group.bindings:
|
|
# logging.info('LRectangle: size=%s' % (self.size))
|
|
ppos, psize = self.group.canvas.KivyToCore(touch.pos)
|
|
event = LEvent()
|
|
event.x = ppos[0]
|
|
event.y = ppos[1]
|
|
self.group.bindings['<1>'](event)
|
|
return True
|
|
return False
|
|
|
|
def on_touch_up(self, touch):
|
|
if self.collide_point(*touch.pos):
|
|
if self.group is not None:
|
|
logging.info('LRectangle: self=%s group=%s' %
|
|
(self, self.group))
|
|
if '<ButtonRelease-1>' in self.group.bindings:
|
|
ppos, psize = self.group.canvas.KivyToCore(touch.pos)
|
|
event = LEvent()
|
|
event.x = ppos[0]
|
|
event.y = ppos[1]
|
|
self.group.bindings['<ButtonRelease-1>'](event)
|
|
return True
|
|
return False
|
|
|
|
# =============================================================================
|
|
|
|
|
|
class LImageItem(BoxLayout):
|
|
def __init__(self, **kw):
|
|
super(LImageItem, self).__init__(**kw)
|
|
self.game = None
|
|
self.card = None
|
|
self.group = None
|
|
if 'game' in kw:
|
|
self.game = kw['game']
|
|
if 'card' in kw:
|
|
self.card = kw['card']
|
|
if 'group' in kw:
|
|
self.group = kw['group']
|
|
self.dragstart = None
|
|
# ev. noch globales cache für stacks->game und cards->stack
|
|
# einrichten. Aber: stacks hängt vom jeweiligen spiel ab.
|
|
|
|
def send_event_pressed_1(self, event):
|
|
if self.group and '<1>' in self.group.bindings:
|
|
self.group.bindings['<1>'](event)
|
|
|
|
def on_touch_down(self, touch):
|
|
|
|
if self.collide_point(*touch.pos):
|
|
|
|
for c in self.children:
|
|
# print('child at %s' % c)
|
|
if (c.on_touch_down(touch) and self.game):
|
|
for stack in self.game.allstacks:
|
|
for i in range(len(stack.cards)):
|
|
if stack.cards[i] == self.card:
|
|
print('LCardImage: stack = %s' % stack)
|
|
print('LCardImage: touch = %s' % str(touch))
|
|
print('grab')
|
|
# grab the touch!
|
|
touch.grab(self)
|
|
ppos, psize = self.game.canvas.KivyToCore(
|
|
touch.pos, self.size)
|
|
event = LEvent()
|
|
event.x = ppos[0]
|
|
event.y = ppos[1]
|
|
self.dragstart = touch.pos
|
|
event.cardid = i
|
|
self.send_event_pressed_1(event)
|
|
return True
|
|
|
|
if self.group is not None:
|
|
print('LCardImage: self=%s group=%s' % (self, self.group))
|
|
if '<1>' in self.group.bindings:
|
|
ppos, psize = self.group.canvas.KivyToCore(
|
|
touch.pos, self.size)
|
|
event = LEvent()
|
|
event.x = ppos[0]
|
|
event.y = ppos[1]
|
|
self.group.bindings['<1>'](event)
|
|
return True
|
|
|
|
if self.card is None:
|
|
return False
|
|
if self.game is None:
|
|
return False
|
|
|
|
# print('LCardImage: touch_down on %s' % str(touch.pos))
|
|
return False
|
|
|
|
def send_event_released_1(self, event):
|
|
if self.group and '<ButtonRelease-1>' in self.group.bindings:
|
|
self.group.bindings['<ButtonRelease-1>'](event)
|
|
|
|
def on_touch_up(self, touch):
|
|
if touch.grab_current is self:
|
|
# release my grabbed touch!
|
|
print('ungrab')
|
|
touch.ungrab(self)
|
|
return True
|
|
|
|
if self.collide_point(*touch.pos):
|
|
|
|
for c in self.children:
|
|
# print('child at %s' % c)
|
|
|
|
if (c.on_touch_up(touch) and self.game):
|
|
for stack in self.game.allstacks:
|
|
for i in range(len(stack.cards)):
|
|
if stack.cards[i] == self.card:
|
|
print('LCardImage: stack = %s' % stack)
|
|
ppos, psize = self.game.canvas.KivyToCore(
|
|
touch.pos, self.size)
|
|
event = LEvent()
|
|
event.x = ppos[0]
|
|
event.y = ppos[1]
|
|
event.cardid = i
|
|
self.send_event_released_1(event)
|
|
return True
|
|
|
|
if self.group is not None:
|
|
print('LCardImage: self=%s group=%s' % (self, self.group))
|
|
if '<ButtonRelease-1>' in self.group.bindings:
|
|
ppos, psize = self.group.canvas.KivyToCore(
|
|
touch.pos, self.size)
|
|
event = LEvent()
|
|
event.x = ppos[0]
|
|
event.y = ppos[1]
|
|
self.group.bindings['<ButtonRelease-1>'](event)
|
|
return True
|
|
|
|
if self.card is None:
|
|
return False
|
|
if self.game is None:
|
|
return False
|
|
|
|
# print('LCardImage: touch_up on %s' % str(touch.pos))
|
|
return False
|
|
|
|
def on_touch_move(self, touch):
|
|
# behandeln nur wenn grabbed
|
|
if touch.grab_current is not self:
|
|
return False
|
|
if 'pos' not in touch.profile:
|
|
return False
|
|
|
|
print('LCardImage: touch_move on %s' % str(touch.pos))
|
|
|
|
for stack in self.game.allstacks:
|
|
for i in range(len(stack.cards)):
|
|
if stack.cards[i] == self.card:
|
|
print('LCardImage: stack = %s/%s' % (stack, touch))
|
|
ppos, psize = self.game.canvas.KivyToCore(
|
|
touch.pos, self.size)
|
|
event = LEvent()
|
|
event.x = ppos[0]
|
|
event.y = ppos[1]
|
|
event.cardid = i
|
|
stack._motionEventHandler(event)
|
|
return True
|
|
|
|
# print('LCardImage: touch_move on %s' % str(touch.pos))
|
|
return False
|
|
|
|
# =============================================================================
|
|
# Treeview
|
|
|
|
|
|
class LTreeRoot(TreeView):
|
|
def __init__(self, **kw):
|
|
super(LTreeRoot, self).__init__(**kw)
|
|
self.kw = kw
|
|
|
|
|
|
class LTreeNode(ButtonBehavior, TreeViewLabel):
|
|
|
|
# def __init__(self, gameview, **kw):
|
|
def __init__(self, **kw):
|
|
self.command = None
|
|
if 'command' in kw:
|
|
self.command = kw['command']
|
|
self.variable = None
|
|
if 'variable' in kw:
|
|
self.variable = kw['variable']
|
|
if 'value' in kw:
|
|
self.value = kw['value']
|
|
if ('text' in kw):
|
|
self.title = kw['text']
|
|
|
|
super(LTreeNode, self).__init__(markup=True, **kw)
|
|
|
|
if self.variable:
|
|
self.variable.bind(value=self.onVarChange)
|
|
self.onVarChange(self.variable, self.variable.get())
|
|
|
|
# self.gameview = gameview
|
|
self.coreFont = self.font_size
|
|
# self.scaleFont(self.gameview.size[1])
|
|
# self.gameview.bind(size=self.scaleFontCB)
|
|
# nicht skalieren!
|
|
|
|
self.bind(on_release=self.on_released)
|
|
self.bind(is_selected=self.onSelect)
|
|
self.bind(is_open=self.onOpen)
|
|
|
|
def onVarChange(self, instance, value):
|
|
# print('LTreeNode: onVarChange(%s, %s, %s)'
|
|
# % (instance, value, type(value)))
|
|
if type(value) is bool:
|
|
self.setCheck(value)
|
|
if type(value) is int:
|
|
self.setVal(value)
|
|
if type(value) is str:
|
|
self.setVal(value)
|
|
# if type(value) is unicode:
|
|
# self.setVal(value)
|
|
|
|
def setCheck(self, value):
|
|
# print('LTreeNode: setCheck(%s)' % value)
|
|
if value:
|
|
# self.text = '+ '+self.title
|
|
self.text = '[b]+[/b] ' + self.title
|
|
else:
|
|
self.text = '- ' + self.title
|
|
self.texture_update()
|
|
|
|
def setVal(self, value):
|
|
# print('LTreeNode: setVal(%s)' % value)
|
|
if value == self.value:
|
|
# fs = str(int(self.font_size+2))
|
|
# print ('%s.%s' % (self.font_size, fs))
|
|
# self.text = '[size='+fs+'][b]'+self.title+'[/b][/size]'
|
|
# self.text = 'o '+self.title
|
|
self.text = '[b]o[/b] ' + self.title
|
|
# self.text = u'\u25cf '+self.title # unicode filled circle
|
|
else:
|
|
self.text = self.title
|
|
self.text = u' ' + self.title
|
|
# self.text = u'\u25cb '+self.title # unicode open circle
|
|
self.texture_update()
|
|
|
|
# font skalierung.
|
|
|
|
def scaleFont(self, value):
|
|
self.font_size = int(self.coreFont * value / 550.0)
|
|
|
|
def scaleFontCB(self, instance, value):
|
|
self.scaleFont(value[1])
|
|
|
|
# benutzer interaktion.
|
|
|
|
def onSelect(self, instance, val):
|
|
if val:
|
|
print('select %s' % self.title)
|
|
else:
|
|
print('deselect %s' % self.title)
|
|
pass
|
|
|
|
def collapseChildren(self, deep=False):
|
|
|
|
def cc(p, n):
|
|
for c in n.nodes:
|
|
if c.is_open:
|
|
cc(p, c)
|
|
p.toggle_node(c)
|
|
|
|
p = self.parent
|
|
if p and isinstance(p, LTreeRoot):
|
|
for n in self.nodes:
|
|
if n.is_open:
|
|
# n.collapseChildren() # ginge nur mit LTreeNode!
|
|
if deep:
|
|
cc(p, n) # geht mit allen TreeViewNode
|
|
p.toggle_node(n)
|
|
|
|
def collapseSiblings(self, deep=True):
|
|
|
|
def cc(p, n):
|
|
for c in n.nodes:
|
|
if c.is_open:
|
|
cc(p, c)
|
|
p.toggle_node(c)
|
|
|
|
p = self.parent
|
|
if p and isinstance(p, LTreeRoot):
|
|
# print('expand: LTreeRoot')
|
|
for n in p.root.nodes:
|
|
# print('expand: -> check %s' % n.title)
|
|
if n != self and n.is_open and n.level >= self.level:
|
|
# print('expand: -> close %s' % n.title)
|
|
if deep:
|
|
cc(p, n)
|
|
p.toggle_node(n)
|
|
|
|
pn = self.parent_node
|
|
if pn and isinstance(pn, LTreeNode):
|
|
# print('expand: LTreeNode')
|
|
for n in pn.nodes:
|
|
# print('expand: -> check %s' % n.title)
|
|
if n != self and n.is_open and n.level >= self.level:
|
|
# print('expand: -> close %s' % n.title)
|
|
if deep:
|
|
cc(p, n)
|
|
p.toggle_node(n)
|
|
|
|
def onOpen(self, instance, val):
|
|
if val:
|
|
# print('expand %s, %s' % (self.level, self.title))
|
|
self.collapseSiblings(deep=False)
|
|
else:
|
|
# print('collapse %s, %s' % (self.level, self.title))
|
|
pass
|
|
|
|
def on_released(self, v):
|
|
if self.command:
|
|
Clock.schedule_once(self.commandCB, 0.1)
|
|
else:
|
|
Clock.schedule_once(self.toggleCB, 0.1)
|
|
|
|
def commandCB(self, d):
|
|
self.command()
|
|
|
|
def toggleCB(self, d):
|
|
# hier könnte der knoten ev. auch neu aufgebaut werden ?!
|
|
self.parent.toggle_node(self)
|
|
|
|
# =============================================================================
|
|
|
|
|
|
class LTopLevelContent(BoxLayout):
|
|
def __init__(self, **kw):
|
|
super(LTopLevelContent, self).__init__(**kw)
|
|
|
|
# beispiel zu canvas (hintergrund)
|
|
with self.canvas.before:
|
|
Color(0.45, 0.5, 0.5, 1.0)
|
|
self.rect = Rectangle(pos=self.pos, size=self.size)
|
|
self.bind(pos=self.update_rect)
|
|
self.bind(size=self.update_rect)
|
|
|
|
def update_rect(self, *args):
|
|
self.rect.pos = self.pos
|
|
self.rect.size = self.size
|
|
|
|
def wm_minsize(self, w, h):
|
|
pass
|
|
|
|
# =============================================================================
|
|
|
|
|
|
class LTopLine(ButtonBehavior, Label):
|
|
|
|
def __init__(self, **kw):
|
|
super(LTopLine, self).__init__(**kw)
|
|
with self.canvas.before:
|
|
Color(0.45, 0.3, 0.3, 1.0)
|
|
self.rect = Rectangle(pos=self.pos, size=self.size)
|
|
self.bind(pos=self.update_rect)
|
|
self.bind(size=self.update_rect)
|
|
|
|
def update_rect(self, *args):
|
|
self.rect.pos = self.pos
|
|
self.rect.size = self.size
|
|
|
|
def on_press(self):
|
|
print('press')
|
|
|
|
def on_release(self):
|
|
print('release')
|
|
|
|
# =============================================================================
|
|
|
|
|
|
class LTopLevel0(BoxLayout):
|
|
def __init__(self, top, title=None, **kw):
|
|
self.main = top
|
|
super(LTopLevel0, self).__init__(orientation="vertical", **kw)
|
|
|
|
# self.canvas.add(Color(0, 1, 0, 0.4))
|
|
# self.canvas.add(Rectangle(pos=(100, 100), size=(100, 100)))
|
|
|
|
self.size_hint = (0.5, 1.0)
|
|
'''
|
|
self.titleline = BoxLayout(
|
|
orientation="horizontal", size_hint=[1.0, 0.15], **kw)
|
|
self.button = Button(text="X", size_hint=[0.15, 1.0], **kw)
|
|
if not title:
|
|
title = '<>'
|
|
self.title = Label(text=title, **kw)
|
|
self.titleline.add_widget(self.title)
|
|
self.titleline.add_widget(self.button)
|
|
'''
|
|
self.titleline = LTopLine(text=title, size_hint=[1.0, 0.15])
|
|
self.title = title
|
|
|
|
# self.content = BoxLayout(orientation="vertical", **kw)
|
|
self.content = LTopLevelContent(orientation="vertical", **kw)
|
|
self.add_widget(self.titleline)
|
|
self.add_widget(self.content)
|
|
'''
|
|
self.button.bind(on_press=self.onClick)
|
|
'''
|
|
self.titleline.bind(on_press=self.onClick)
|
|
self.main.pushWork(self.title, self)
|
|
|
|
def onClick(self, event):
|
|
print('LTopLevel: onClick')
|
|
self.main.popWork(self.title)
|
|
|
|
# =============================================================================
|
|
|
|
|
|
class LTopLevel(BoxLayout):
|
|
def __init__(self, parent, title=None, **kw):
|
|
self.mainwindow = parent
|
|
super(LTopLevel, self).__init__(orientation="vertical", **kw)
|
|
|
|
if ('size_hint' not in kw):
|
|
self.size_hint = (0.5, 1.0)
|
|
else:
|
|
del kw['size_hint']
|
|
self.titleline = LTopLine(text=title, size_hint=(1.0, 0.10))
|
|
|
|
self.content = LTopLevelContent(orientation="vertical", **kw)
|
|
self.add_widget(self.titleline)
|
|
self.add_widget(self.content)
|
|
|
|
# =============================================================================
|
|
|
|
# class LMenuBar(ActionBar):
|
|
|
|
|
|
class LMenuBar(BoxLayout):
|
|
def __init__(self, **kw):
|
|
super(LMenuBar, self).__init__(**kw)
|
|
self.menu = None
|
|
self.size_hint = (1.0, 0.08)
|
|
|
|
def setMenu(self, menu):
|
|
print('LMenuBar: setMenu %s, %s' % (self, menu))
|
|
|
|
# Letztes Menu entfernen
|
|
last = self.menu
|
|
if (last is not None):
|
|
self.remove_widget(last)
|
|
self.menu = None
|
|
|
|
# Neues Menu einfügen
|
|
if (menu is not None):
|
|
self.add_widget(menu)
|
|
self.menu = menu
|
|
menu.setBar(self)
|
|
|
|
def getMenu(self):
|
|
return self.menu
|
|
|
|
# =============================================================================
|
|
|
|
|
|
class LMenu(ActionView):
|
|
def __init__(self, prev, **kw):
|
|
print('prev = %s, kw = %s' % (prev, kw))
|
|
super(LMenu, self).__init__(**kw)
|
|
self.ap = ap = ActionPrevious(
|
|
with_previous=prev, size_hint=(.01, 1), **kw)
|
|
ap.app_icon = 'data/images/misc/pysol01.png'
|
|
self.add_widget(ap)
|
|
self.bar = None
|
|
self.uppermenu = None
|
|
|
|
def addItem(self, mi):
|
|
# print ('LMenu: addItem '+str(mi)+' '+str(self.bar))
|
|
mi.setBar(self.bar)
|
|
self.add_widget(mi)
|
|
|
|
def setBar(self, bar):
|
|
# print ('LMenu: setBar %s, %s' % (self, bar))
|
|
self.bar = bar
|
|
|
|
def prev(self, menu):
|
|
# print ('LMenu: prev = %s' % menu)
|
|
self.uppermenu = menu
|
|
self.ap.bind(on_release=self.upper)
|
|
pass
|
|
|
|
def upper(self, event):
|
|
print('upper')
|
|
self.bar.setMenu(self.uppermenu)
|
|
|
|
def delete(self, pos, mode):
|
|
# print ('LMenu(%s): delete(%s, %s)' % (self, pos, mode))
|
|
|
|
items = []
|
|
menues = []
|
|
for c in self.children:
|
|
if (type(c) is LMenuItem):
|
|
# print ('LMenu: to delete child %s' % c)
|
|
items.append(c)
|
|
elif (type(c) is LMenu):
|
|
# print ('LMenu: to delete child %s' % c)
|
|
menues.append(c)
|
|
else:
|
|
# print ('LMenu: unknown child %s' % c)
|
|
pass
|
|
|
|
for c in items:
|
|
# print ('LMenu: delete child %s' % c)
|
|
self.clear_widgets([c])
|
|
for c in menues:
|
|
# print ('LMenu: delete child %s' % c)
|
|
self.clear_widgets([c])
|
|
c.delete(pos, mode)
|
|
|
|
# def __str__(self):
|
|
# return hex(id(self))
|
|
|
|
# =============================================================================
|
|
|
|
|
|
class LMenuItem(ActionButton):
|
|
|
|
def __init__(self, menu, **kw):
|
|
super(LMenuItem, self).__init__(**kw)
|
|
# super(LMenuItem, self).__init__()
|
|
self.bar = None
|
|
self.submenu = None
|
|
self.menu = menu
|
|
self.menu.addItem(self)
|
|
self.minimum_width = '200sp'
|
|
if 'command' in kw:
|
|
self.setCommand(kw['command'])
|
|
if 'submenu' in kw:
|
|
self.setSubMenu(kw['submenu'])
|
|
|
|
def setBar(self, bar):
|
|
# print ('LMenuItem: setBar %s, %s' % (self, bar))
|
|
self.bar = bar
|
|
|
|
def onClick(self, event):
|
|
# print('LMenuItem: onClick')
|
|
# print('LMenuItem: submenu vorh: '+str(self.submenu))
|
|
self.bar.setMenu(self.submenu)
|
|
return True
|
|
|
|
def setSubMenu(self, submenu):
|
|
# print('LMenuItem: setSubMenu')
|
|
self.submenu = submenu
|
|
# print('LMenuItem: setSubMenu: '+str(self.submenu))
|
|
self.submenu.prev(self.menu)
|
|
self.submenu.setBar(self.bar)
|
|
self.bind(on_release=self.onClick)
|
|
pass
|
|
|
|
def setCommand(self, cmd):
|
|
# print('LMenuItem: setCommand')
|
|
self.bind(on_release=cmd)
|
|
|
|
# def __str__(self):
|
|
# return hex(id(self))
|
|
|
|
# =============================================================================
|
|
|
|
|
|
class LScrollView(ScrollView):
|
|
def __init__(self, **kw):
|
|
super(LScrollView, self).__init__(**kw)
|
|
self.delayDown = False
|
|
self.touch = None
|
|
|
|
def delayReset(self, dt):
|
|
if not self.delayDown:
|
|
return
|
|
self.delayDown = False
|
|
ScrollView.on_touch_down(self, self.touch)
|
|
|
|
# Scroll ist original viel zu flink auf den Touchgeräten.
|
|
# Wir versuchen das hier etwas abzuschwächen.
|
|
|
|
def on_touch_down(self, touch):
|
|
self.delayDown = True
|
|
self.touch = touch
|
|
Clock.schedule_once(self.delayReset, 0.15)
|
|
|
|
def on_touch_up(self, touch):
|
|
if self.delayDown:
|
|
ScrollView.on_touch_down(self, self.touch)
|
|
self.delayDown = False
|
|
return ScrollView.on_touch_up(self, touch)
|
|
|
|
def on_touch_move(self, touch):
|
|
return ScrollView.on_touch_move(self, touch)
|
|
|
|
# =============================================================================
|
|
|
|
|
|
class LWorkWindow(Widget):
|
|
def __init__(self):
|
|
super(LWorkWindow, self).__init__()
|
|
|
|
# beispiel zu canvas (hintergrund)
|
|
with self.canvas.before:
|
|
Color(0, 1, 1, 0.4)
|
|
self.rect = Rectangle(pos=self.pos, size=self.size)
|
|
self.bind(pos=self.update_rect)
|
|
self.bind(size=self.update_rect)
|
|
|
|
def update_rect(self, *args):
|
|
self.rect.pos = self.pos
|
|
self.rect.size = self.size
|
|
|
|
def on_touch_down(self, touch):
|
|
print('LWorkWindow: touch_down on %s' % str(touch.pos))
|
|
# return True
|
|
|
|
# =============================================================================
|
|
|
|
|
|
class LTkBase:
|
|
# Tk Emulation needs.
|
|
def __init__(self):
|
|
self.title = "default title"
|
|
self.icontitle = "default title"
|
|
logging.info("LTkBase: __init__()")
|
|
self.sleeping = False
|
|
self.in_loop = False
|
|
|
|
def cget(self, strg):
|
|
return False
|
|
|
|
def wm_title(self, strg):
|
|
self.title = strg
|
|
logging.info("LTkBase: wm_title %s" % strg)
|
|
if (self.app):
|
|
# self.app.top.topLine.text = strg
|
|
self.app.top.getMenu().ap.title = strg
|
|
|
|
def wm_iconname(self, strg):
|
|
self.icontitle = strg
|
|
logging.info("LTkBase: wm_iconname %s" % strg)
|
|
|
|
def winfo_screenwidth(self):
|
|
logging.info("LTkBase: winfo_screenwidth %s" % str(self.size[0]))
|
|
return self.size[0]
|
|
|
|
def winfo_screenheight(self):
|
|
logging.info("LTkBase: winfo_screenheight %s" % str(self.size[1]))
|
|
return self.size[1]
|
|
|
|
def winfo_screendepth(self):
|
|
return 32
|
|
|
|
def wm_minsize(self, x, y):
|
|
pass
|
|
|
|
def option_add(self, a, b, c):
|
|
pass
|
|
|
|
def option_get(self, a, b):
|
|
return 0
|
|
|
|
def wm_withdraw(self):
|
|
logging.info("LTkBase: wm_withdraw")
|
|
pass
|
|
|
|
def busyUpdate(self):
|
|
print('LTkBase: busyUpdate()')
|
|
pass
|
|
|
|
def grid_columnconfigure(self, a, weight):
|
|
pass
|
|
|
|
def grid_rowconfigure(self, a, weight):
|
|
pass
|
|
|
|
def connectApp(self, app):
|
|
logging.info("LTkBase: connectApp %s" % str(app))
|
|
self.app = app
|
|
pass
|
|
|
|
def wm_geometry(self, val):
|
|
logging.info("LTkBase: wm_geometry %s" % str(val))
|
|
pass
|
|
|
|
def update_idletasks(self):
|
|
logging.info("LTkBase: update_idletasks")
|
|
try:
|
|
if len(EventLoop.event_listeners) > 0:
|
|
self.in_loop = True
|
|
EventLoop.idle()
|
|
self.in_loop = False
|
|
else:
|
|
logging.info("LTkBase: update_idletasks: terminating")
|
|
except Exception:
|
|
self.in_loop = False
|
|
logging.info("LTkBase: update_idletasks: exception")
|
|
|
|
def wm_state(self):
|
|
return ""
|
|
|
|
def wm_deiconify(self):
|
|
pass
|
|
|
|
def mainloop(self):
|
|
logging.info("LTkBase: mainloop")
|
|
pass
|
|
|
|
def quit(self):
|
|
logging.info("LTkBase: quit")
|
|
stopTouchApp()
|
|
|
|
def interruptSleep(self):
|
|
logging.info('LTkBase: interruptSleep')
|
|
self.update_idletasks()
|
|
# self.sleep_var = 1
|
|
return
|
|
|
|
def mainquit(self):
|
|
logging.info('LTkBase: mainquit')
|
|
lapp = App.get_running_app()
|
|
lapp.mainloop.send(None) # Spielprozess verlassen
|
|
return
|
|
|
|
def onWakeUp(self, dt):
|
|
self.sleeping = False
|
|
|
|
def sleep(self, seconds):
|
|
logging.info('LTkBase: sleep %s seconds' % seconds)
|
|
self.sleeping = True
|
|
Clock.schedule_once(self.onWakeUp, seconds)
|
|
while self.sleeping:
|
|
# time.sleep(0.05)
|
|
self.in_loop = True
|
|
EventLoop.idle()
|
|
self.in_loop = False
|
|
|
|
def waitCondition(self, condition):
|
|
logging.info('LTkBase: wait condition start')
|
|
while condition():
|
|
self.in_loop = True
|
|
EventLoop.idle()
|
|
self.in_loop = False
|
|
logging.info('LTkBase: wait condition end')
|
|
|
|
def waitAnimation(self):
|
|
self.waitCondition(LAnimationManager.checkRunning)
|
|
|
|
def tkraise(self):
|
|
pass
|
|
|
|
def winfo_ismapped(self):
|
|
return True
|
|
# ???
|
|
|
|
# =============================================================================
|
|
|
|
|
|
class LStack:
|
|
def __init__(self):
|
|
self.items = []
|
|
|
|
def isEmpty(self):
|
|
return self.items == []
|
|
|
|
def push(self, key, item):
|
|
self.items.append((key, item))
|
|
|
|
def pop(self, key):
|
|
for i in range(len(self.items)):
|
|
t = self.items[i]
|
|
if (t[0] == key):
|
|
self.items.pop(i)
|
|
return t[1]
|
|
return None
|
|
|
|
def peek(self, key):
|
|
for i in range(len(self.items)):
|
|
t = self.items[i]
|
|
if (t[0] == key):
|
|
return t
|
|
return None
|
|
|
|
def size(self):
|
|
return len(self.items)
|
|
|
|
# =============================================================================
|
|
|
|
|
|
class LMainWindow(BoxLayout, LTkBase):
|
|
def __init__(self, **kw):
|
|
super(LMainWindow, self).__init__(orientation='vertical')
|
|
LTkBase.__init__(self)
|
|
self.menuArea = LMenuBar()
|
|
self.workContainer = LBoxLayout(orientation='horizontal')
|
|
self.workContainerO = LBoxLayout(orientation='horizontal')
|
|
self.workArea = None
|
|
self.toolBar = None
|
|
self.toolBarPos = 0
|
|
self.bindings = {}
|
|
self._w = '.'
|
|
self.topLine = Button(
|
|
size_hint=(1.0, 0.01),
|
|
background_down='atlas:'
|
|
'//data/images/defaulttheme/action_item_down',
|
|
background_normal='atlas:'
|
|
'//data/images/defaulttheme/action_item',
|
|
border=(0, 0, 0, 0))
|
|
self.topLine1 = Label(size_hint=(1.0, 0.01))
|
|
|
|
self.add_widget(self.topLine)
|
|
self.add_widget(self.menuArea)
|
|
self.add_widget(self.topLine1)
|
|
self.add_widget(self.workContainerO)
|
|
self.workContainerO.add_widget(self.workContainer)
|
|
# self.add_widget(Button(size_hint = (1.0, 0.01)))
|
|
|
|
self.workStack = LStack()
|
|
self.app = None
|
|
|
|
# beispiel zu canvas (hintergrund)
|
|
# with self.canvas.before:
|
|
# Color(0, 1, 0.7, 0.5)
|
|
# self.rect = Rectangle(pos=self.pos, size=self.size)
|
|
# self.bind(pos=self.update_rect)
|
|
# self.bind(size=self.update_rect)
|
|
|
|
# def update_rect(self, *args):
|
|
# self.rect.pos = self.pos
|
|
# self.rect.size = self.size
|
|
|
|
# Events.
|
|
|
|
def on_touch_down(self, touch):
|
|
ret = False
|
|
|
|
# (Eventloop reentrancy check)
|
|
if self.in_loop:
|
|
return ret
|
|
|
|
# (demo mode stop - nur auf spielfläche)
|
|
if '<KeyPress>' in self.bindings:
|
|
pgs = self.workStack.peek('playground')
|
|
if pgs:
|
|
pg = pgs[1]
|
|
if pg.collide_point(*touch.pos):
|
|
event = LEvent()
|
|
event.char = True
|
|
self.bindings['<KeyPress>'](event)
|
|
|
|
# standard notifikation:
|
|
for c in self.children:
|
|
ret = c.on_touch_down(touch)
|
|
if ret:
|
|
break
|
|
return ret
|
|
|
|
def on_touch_up(self, touch):
|
|
ret = False
|
|
# standard notifikation:
|
|
for c in self.children:
|
|
ret = c.on_touch_up(touch)
|
|
if ret:
|
|
break
|
|
return ret
|
|
|
|
# Menubar:
|
|
|
|
def setMenu(self, menu):
|
|
self.menuArea.setMenu(menu)
|
|
|
|
def getMenu(self):
|
|
return self.menuArea.getMenu()
|
|
|
|
# Toolbar:
|
|
|
|
def setTool(self, toolbar, pos=0):
|
|
if (toolbar is not None):
|
|
self.toolBar = toolbar
|
|
self.toolBarPos = pos
|
|
self.rebuildContainer()
|
|
|
|
# Workarea:
|
|
|
|
def rebuildContainer(self):
|
|
self.workContainer.clear_widgets()
|
|
self.workContainerO.clear_widgets()
|
|
|
|
if self.toolBar is not None and self.toolBarPos == 3:
|
|
self.workContainerO.add_widget(self.toolBar)
|
|
self.workContainerO.add_widget(self.workContainer)
|
|
if self.toolBar is not None and self.toolBarPos == 4:
|
|
self.workContainerO.add_widget(self.toolBar)
|
|
|
|
for w in self.workStack.items:
|
|
self.workContainer.add_widget(w[1])
|
|
|
|
def pushWork(self, key, widget):
|
|
if (widget):
|
|
self.workStack.push(key, widget)
|
|
self.rebuildContainer()
|
|
|
|
def popWork(self, key):
|
|
w = None
|
|
if self.workStack.size() > 0:
|
|
w = self.workStack.pop(key)
|
|
self.rebuildContainer()
|
|
return w
|
|
|
|
def setWork(self, key, widget):
|
|
self.pushWork(key, widget)
|
|
|
|
def getWork(self, key):
|
|
return self.workStack.peek(key)
|
|
|
|
# =============================================================================
|
|
|
|
|
|
class LApp(App):
|
|
|
|
# Handling of android return key
|
|
def key_input(self, window, key, scancode, codepoint, modifier):
|
|
if key == 27:
|
|
# Back key of Android.
|
|
lapp = App.get_running_app()
|
|
app = lapp.app
|
|
if app is None:
|
|
return False # delegate
|
|
|
|
# redirect to game undo last step
|
|
app.menubar.mUndo()
|
|
return True # consumed
|
|
else:
|
|
return False # delegate
|
|
|
|
def __init__(self):
|
|
super(LApp, self).__init__()
|
|
self.mainWindow = LMainWindow()
|
|
logging.info('top = %s' % str(self.mainWindow))
|
|
Cache.register('LAppCache', limit=10)
|
|
Cache.append('LAppCache', 'mainWindow', self.mainWindow, timeout=0)
|
|
Cache.append('LAppCache', 'mainApp', self, timeout=0)
|
|
self.startCode = 0
|
|
|
|
# Es gibt hier offensichtlich nur einen Bilschirm mit Höhe und Breite.
|
|
# Alles andere stellt das Betriebssystem zur Verfügung. Wir wissen auch
|
|
# nicht, wie das Gerät gerade orientiert ist, ist nicht unsere Sache.
|
|
# Alles was wir tun können ist Höhe und Breite zu verfolgen, sobald wir
|
|
# dazu informiert werden. (Android informiert leider nicht immer, wenn
|
|
# es nötig wäre).
|
|
# Update:
|
|
# Nachdem im Manifest nun steht 'configChange=...|screenSize' bekommen
|
|
# wir auch nach dem on_resume ein Signal. Zum Update rufen wir
|
|
# rebuildContainer verzögert auf. Aus unerfindlichen Gründen ist es
|
|
# jedoch notwendig die Verzögerung 2-stufig zu organisieren. Der erste
|
|
# Delay wird offensichtlich unter gegebenen Umständen ignoriert.
|
|
# LB170517.
|
|
|
|
def delayedRebuild(self, dt):
|
|
logging.info("LApp: delayedRebuild")
|
|
self.mainWindow.rebuildContainer()
|
|
|
|
def makeDelayedRebuild(self):
|
|
def delayedRebuild(dt):
|
|
Clock.schedule_once(self.delayedRebuild, 0.01)
|
|
return delayedRebuild
|
|
|
|
def doSize(self, obj, val):
|
|
mval = self.mainWindow.size
|
|
logging.info("LApp: size changed %s - %s (%s)" % (obj, val, mval))
|
|
# Clock.schedule_once(self.delayedRebuild, 0.01)
|
|
Clock.schedule_once(self.makeDelayedRebuild(), 0.01)
|
|
pass
|
|
|
|
def on_start(self):
|
|
logging.info('mw = %s, w = %s' % (self.mainWindow, Window))
|
|
|
|
Window.bind(on_keyboard=self.key_input)
|
|
Window.bind(size=self.doSize)
|
|
|
|
if self.startCode > 0:
|
|
logging.info("LApp: on_start fails")
|
|
return
|
|
|
|
logging.info("LApp: on_start")
|
|
self.mainloop = self.app.mainproc() # Einrichten
|
|
self.mainloop.send(None) # Spielprozess starten
|
|
logging.info("LApp: on_start processed")
|
|
|
|
def on_stop(self):
|
|
# Achtung wird u.U. 2 mal aufgerufen !!!
|
|
logging.info("LApp: on_stop")
|
|
if self.startCode > 0:
|
|
return
|
|
# lapp: erweiterte klasse dieser (mit pysolfc app members).
|
|
lapp = App.get_running_app()
|
|
lapp.app.menubar.mHoldAndQuit()
|
|
|
|
def on_pause(self):
|
|
logging.info("LApp: on_pause")
|
|
# return True: wenn wir wirklich in pause gehen. Dann wird auch
|
|
# resume aufgerufen falls die app wieder aktiviert wird.
|
|
# return False: app wird gestoppt (on_stop wird aufgerufen)
|
|
if self.startCode > 0:
|
|
return False
|
|
|
|
pauseSupport = True
|
|
# True ist die bessere Variante.
|
|
|
|
lapp = App.get_running_app()
|
|
app = lapp.app
|
|
if app is None:
|
|
return
|
|
|
|
logging.info("LApp: on_pause - pause on")
|
|
# set pause
|
|
if not app.game.pause:
|
|
app.game.doPause()
|
|
|
|
logging.info("LApp: on_pause - savegame")
|
|
# save game
|
|
try:
|
|
app.game.gstats.holded = 1
|
|
app.game._saveGame(app.fn.holdgame)
|
|
app.opt.game_holded = app.game.id
|
|
app.opt.last_gameid = app.game.id
|
|
except Exception:
|
|
traceback.print_exc()
|
|
pass
|
|
# save options
|
|
try:
|
|
app.saveOptions()
|
|
except Exception:
|
|
traceback.print_exc()
|
|
pass
|
|
# save statistics
|
|
try:
|
|
app.saveStatistics()
|
|
except Exception:
|
|
traceback.print_exc()
|
|
pass
|
|
# save comments
|
|
try:
|
|
app.saveComments()
|
|
except Exception:
|
|
traceback.print_exc()
|
|
pass
|
|
logging.info("LApp: on_pause - gamesaved")
|
|
|
|
logging.info("LApp: on_pause, Window.size=%s" % str(Window.size))
|
|
|
|
return pauseSupport
|
|
|
|
def on_resume(self):
|
|
logging.info("LApp: on_resume")
|
|
|
|
lapp = App.get_running_app()
|
|
app = lapp.app
|
|
if app is None:
|
|
return
|
|
|
|
logging.info("LApp: on_resume, Window.size=%s" % str(Window.size))
|
|
# ANM:
|
|
# Nicht einmal das Basiswindow wird hier über eine
|
|
# Orientierungsänderung informiert, die während der Pause eintrat.
|
|
# Eine korrekte Darstellung kann daher nicht garantiert werden.
|
|
# Wenn die sensoren ev. später für eine korrektur sorgen, erfolgt
|
|
# ebenfalls kein update, weil sich die parameter am Basiswindow ja
|
|
# zum alten bekannten Wert hin ändern (also gar nicht).
|
|
|
|
if app.game.pause:
|
|
Clock.schedule_once(self.makeEndPauseCmd(app), 3.0)
|
|
|
|
def makeEndPauseCmd(self, app):
|
|
def endPauseCmd(dt):
|
|
if app.game.pause:
|
|
logging.info("LApp: on_resume - pause off")
|
|
app.game.doPause()
|
|
return endPauseCmd
|