class CardFormat(EventDispatcher):
width = NumericProperty(cm(CP.getfloat('Card', 'width')))
height = NumericProperty(cm(CP.getfloat('Card', 'height')))
size = ReferenceListProperty(width, height)
keep_ratio = BooleanProperty(True)
ratio = NumericProperty(6.5 / 8.8)
def updateW(self, W, unit):
if unit == 'px':
self.width = float(W)
else:
self.width = float(W) * cm(1)
if self.keep_ratio:
self.height = self.width / self.ratio
def updateH(self, H, unit):
if unit == 'px':
self.height = float(H)
else:
self.height = float(H) * cm(1)
if self.keep_ratio:
self.width = self.height * self.ratio
def on_keep_ratio(self, instance, keep_ratio):
if keep_ratio:
self.ratio = self.width / self.height
def build(self):
scroll = ScrollView()
grid = GridLayout(cols=1, spacing=1, size_hint_y=None)
grid.bind(minimum_height=grid.setter('height'))
scroll.add_widget(grid)
for r in range(0, 50):
bt = Button(text='Slow start ' + str(r),
size_hint_y=None,
height=cm(2))
grid.add_widget(bt)
scroll2 = ScrollView()
grid2 = GridLayout(cols=1, spacing=1, size_hint_y=None)
grid2.bind(minimum_height=grid2.setter('height'))
scroll2.add_widget(grid2)
for r in range(50, 100):
bt = Button(text="Fast scrolling doesn't work " + str(r),
size_hint_y=None,
height=cm(2))
grid2.add_widget(bt)
carousel = Carousel()
carousel.add_widget(scroll)
carousel.add_widget(scroll2)
return carousel
def build(self):
self.root = NotificationDemo(self)
if platform == 'android':
try:
self.service = autoclass(
'org.test.npexample.ServiceMyservice')
mActivity = autoclass(
'org.kivy.android.PythonActivity').mActivity
argument = ''
self.service.start(mActivity, argument)
except:
self.service = AndroidService(
'Sevice example', 'service is running')
self.service.start('Hello From Service')
else:
Window.system_size = cm(7), cm(12)
self.client.on_connect = self.on_connect
self.client.on_disconnect = self.on_disconnect
Clock.schedule_once(self.try_connecting, 0)
Clock.schedule_interval(self.handle_msg, 0.1)
# def skipp(*a):
# self.root.ids.sm.current = 'main'
# Clock.schedule_once(skipp, 0.5)
return self.root
def apply_ph_dim(self):
from kivy.metrics import cm
if self.selected_ph:
self.selected_ph.width = int(float(self.ids.ph_w.text) * cm(1))
self.selected_ph.angle = int(self.ids.ph_angle.text)
self.selected_ph.height = int(float(self.ids.ph_h.text) * cm(1))
self.selected_ph.y = int(float(self.ids.ph_y.text) * cm(1))
self.selected_ph.x = int(float(self.ids.ph_x.text) * cm(1))
def apply_ph_dim(self):
from kivy.metrics import cm
if self.selected_ph:
self.selected_ph.width = int(float(self.ids.ph_w.text) * cm(1))
self.selected_ph.angle = int(self.ids.ph_angle.text)
self.selected_ph.height = int(float(self.ids.ph_h.text) * cm(1))
self.selected_ph.y = int(float(self.ids.ph_y.text) * cm(1))
self.selected_ph.x = int(float(self.ids.ph_x.text) * cm(1))
def _inner(*args):
w,h = float(p.ids.width.text), float(p.ids.height.text)
if p.ids.w_metric.text == "cm":
from kivy.metrics import cm
w *= cm(1)
if p.ids.h_metric.text == "cm":
from kivy.metrics import cm
h *= cm(1)
self.setImageSize((w, h))
def _inner(*args):
w, h = float(p.ids.width.text), float(
p.ids.height.text)
if p.ids.w_metric.text == "cm":
from kivy.metrics import cm
w *= cm(1)
if p.ids.h_metric.text == "cm":
from kivy.metrics import cm
h *= cm(1)
self.setImageSize((w, h))
def AddLines(self, x, y, w, h):
from kivy.metrics import cm
step = 10.0/cm(1)
pagging = 1.0/cm(1)
self.pdf.lines([
((x-step)*r_cm, (y-pagging)*r_cm, (x+w+step)*r_cm, (y-pagging)*r_cm),
((x-pagging)*r_cm, (y-step)*r_cm, (x-pagging)*r_cm, (y+h+step)*r_cm),
((x-step)*r_cm, (y+h+pagging)*r_cm, (x+w+step)*r_cm, (y+h+pagging)*r_cm),
((x+w-pagging)*r_cm, (y-step)*r_cm, (x+w-pagging)*r_cm, (y+h+step)*r_cm)
])
def AddLines(self, x, y, w, h):
from kivy.metrics import cm
step = 10.0 / cm(1)
pagging = 1.0 / cm(1)
self.pdf.lines([((x - step) * r_cm, (y - pagging) * r_cm,
(x + w + step) * r_cm, (y - pagging) * r_cm),
((x - pagging) * r_cm, (y - step) * r_cm,
(x - pagging) * r_cm, (y + h + step) * r_cm),
((x - step) * r_cm, (y + h + pagging) * r_cm,
(x + w + step) * r_cm, (y + h + pagging) * r_cm),
((x + w - pagging) * r_cm, (y - step) * r_cm,
(x + w - pagging) * r_cm, (y + h + step) * r_cm)])
def __init__(self,*args,**kwargs):
BGTemplate.__init__(self)
self.template_name = "EmptyKlass"
from fields import ImageField
img = ImageField()
#img.x = img.y = 0
img.id = "default"
#img.width = self.width
#img.height = self.height
img.keep_ratio = True
img.scale = True
self.add_widget(img)
from kivy.metrics import cm
self.size = (cm(6.35), cm(8.8))
def __init__(self, *args, **kwargs):
BGTemplate.__init__(self, *args, **kwargs)
self.template_name = "RedSkinKlass"
from fields import ColorField
color = ColorField()
#color.id = "deffault"
color.width = self.width
color.height = self.height
color.opacity= .5
color.rgba = (1,0,0,1)
self.add_widget(color)
from kivy.metrics import cm
self.size = color.size = (cm(6.5),cm(8.8))
from kivy.clock import Clock
def menu(self, text, count, price):
layout = BoxLayout(orientation='horizontal')
lbl1 = Label(text=text,
color=[.17, .17, .17, 1],
size_hint=[.6, 1],
text_size=[cm(9), cm(0)])
lbl2 = Label(text=count, color=[.17, .17, .17, 1], size_hint=[.2, 1])
lbl3 = Label(text=price, color=[.17, .17, .17, 1], size_hint=[.2, 1])
layout.add_widget(lbl1)
layout.add_widget(lbl2)
layout.add_widget(lbl3)
self.ids.addLabel.add_widget(layout)
def addDialogRow(self, bl, title, val):
bh = self.getDialogRow()
bh.add_widget(MyLabel(text="%s:" % title))
ti = TextInput(text=str(val), height=cm(1))
bh.add_widget(ti)
bl.add_widget(bh)
return bl, ti
def updateW(self, W, unit):
if unit == 'px':
self.width = float(W)
else:
self.width = float(W) * cm(1)
if self.keep_ratio:
self.height = self.width / self.ratio
def updateW(self, W, unit):
if unit == 'px':
self.width = float(W)
else:
self.width = float(W) * cm(1)
if self.keep_ratio:
self.height = self.width/self.ratio
def update_dialog(self, cur_build, upd_build):
popup = Popup(title='Update', content=ScrollView(), size_hint=(0.8,None), height=cm(5))
grid = GridLayout(cols=1, spacing=0, size_hint_y=None)
grid.bind(minimum_height= grid.setter('height'))
con = StackLayout()
grid.add_widget(con)
popup.content.add_widget(grid)
lbl1 = Label(text='Current build is %s' % (cur_build), size_hint_y=None, height=cm(1))
lbl2 = Label(text='Build %s available' % (upd_build), size_hint_y=None, height=cm(1))
btn1 = Button(text='Cancel', size_hint=(0.5, None), height=cm(1))
btn2 = Button(text='Update', size_hint=(0.5, None), height=cm(1))
btn1.bind(on_release=popup.dismiss)
btn2.bind(on_release=lambda x: {self.update(), popup.dismiss()})
for x in (lbl1, lbl2, btn1, btn2):
con.add_widget(x)
popup.open()
def updateH(self, H, unit):
if unit == 'px':
self.height = float(H)
else:
self.height = float(H) * cm(1)
if self.keep_ratio:
self.width = self.height * self.ratio
def updateH(self, H, unit):
if unit == 'px':
self.height = float(H)
else:
self.height = float(H) * cm(1)
if self.keep_ratio:
self.width = self.height * self.ratio
def buildGuiForAction(self):
print("build gui for action ", self.actionType)
if self.actionType == 'start':
bl = BoxLayout(orientation='vertical')
bl.add_widget(MSLabel(text="Widgets wizard"))
#bl.add_widget(Button(
# text="rebuild!",
# on_release=self.sw.rebuildWs
# ))
bl.add_widget(
Label(text="Awalable widgets to add to screen:",
size_hint_y=None,
height=cm(1)))
wl = self.sw.getWidgetsTypeList()
for w in wl:
print("w", w)
bv = BoxLayout(orientation="horizontal",
height=self.gui.btH,
width=bl.width,
size_hint=[None, None])
bl.add_widget(bv)
b = Button(
text=w['name'],
#height = self.gui.btH,
size_hint=[None, None],
on_release=self.on_start_addW,
size=[cm(3.0), cm(1.0)])
bv.add_widget(b)
ki = uixImage(source=("icons/%s" % w['thumb']),
size_hint=[None, None],
size=[cm(3.0), cm(1.0)])
bv.add_widget(ki)
#bv.add_widget(ki)
print("3")
for c in self.gui.rl.ids.bl_selWidToAdd.children:
self.gui.rl.ids.bl_selWidToAdd.remove_widget(c)
self.gui.rl.ids.bl_selWidToAdd.clear_widgets()
self.gui.rl.ids.bl_selWidToAdd.add_widget(bl)
self.gui.screenChange("SelectWidgetToAdd")
self.gui.rl.ids.bl_selWidToAdd.size = self.sw.solveScrolSize(
self.gui.rl.ids.bl_selWidToAdd)
def toggle_find_bar(self, *args):
fbar = self.ids.find_bar
if fbar.height:
anim = Animation(height=0.0, d=0.5)
anim.start(fbar)
else:
anim = Animation(height=cm(2.0), d=0.5)
anim.start(fbar)
def _inner(*args):
prev = p.ids['preview']
tmpl = prev.children[0]
TS = tmpl.size
PS = prev.parent.size
W_ratio = float(.9 * PS[0]) / TS[0]
H_ratio = float(.9 * PS[1]) / TS[1]
ratio = min(W_ratio, H_ratio)
x, y = p.ids['FL'].center
prev.center = ratio * x, ratio * y
#p.ids['preview'].scale = ratio
#forcing x to 0
prev.x = 5
prev.center_y = y
from kivy.metrics import cm
p.tsize = options.current_selection[0].size[0] / cm(
1), options.current_selection[0].size[1] / cm(1)
class PageFormat(EventDispatcher):
width = NumericProperty(cm(CP.getfloat('Page', 'width')))
height = NumericProperty(cm(CP.getfloat('Page', 'height')))
left = NumericProperty(cm(CP.getfloat('Page', 'left')))
right = NumericProperty(cm(CP.getfloat('Page', 'right')))
bottom = NumericProperty(cm(CP.getfloat('Page', 'bottom')))
top = NumericProperty(cm(CP.getfloat('Page', 'top')))
def build(self):
scroll = ScrollView()
grid = GridLayout(cols=1, spacing=1, size_hint_y=None)
grid.bind(minimum_height=grid.setter('height'))
scroll.add_widget(grid)
for r in range(0,50):
bt = Button(text='Smooth '+str(r), size_hint_y=None, height=cm(2))
grid.add_widget(bt)
scroll2 = ScrollView()
grid2 = GridLayout(cols=1, spacing=1, size_hint_y=None)
grid2.bind(minimum_height=grid2.setter('height'))
scroll2.add_widget(grid2)
for r in range(50,100):
bt = Button(text="Fast scrolling works"+str(r), size_hint_y=None, height=cm(2))
grid2.add_widget(bt)
carousel = Carousel(do_scroll_y=False)
carousel.add_widget(scroll)
carousel.add_widget(scroll2)
return carousel
def update_done_dialog(self, cur_build, upd_build):
popup = Popup(title='Update done', content=ScrollView(), size_hint=(0.8,None), height=cm(5))
grid = GridLayout(cols=1, spacing=0, size_hint_y=None)
grid.bind(minimum_height= grid.setter('height'))
con = StackLayout()
grid.add_widget(con)
popup.content.add_widget(grid)
lbl1 = Label(text='Done updating from %s to %s' % (cur_build, upd_build), size_hint_y=None, height=cm(1))
btn1 = Button(text='Close', size_hint=(1, None), height=cm(1))
btn1.bind(on_release=popup.dismiss)
for x in (lbl1, btn1):
con.add_widget(x)
popup.open()
def after_init(self):
for x in range(1, 10):
lbl = Label(size_hint=(1, None),
height=(cm(1)),
text='X ' + str(x))
self.add_widget(lbl)
self.bind(
size=lambda obj, val: setattr(self.background, 'size', self.size))
self.bind(
size=lambda obj, val: setattr(self.background, 'pos', self.pos))
blue = InstructionGroup()
color = from_rgb(144, 175, 197)
blue.add(Color(*color))
blue.add(self.background)
self.canvas.before.add(blue)
def build(self):
self.root = NotificationDemo(self)
if platform == 'android':
try:
self.service = autoclass('org.test.npexample.ServiceMyservice')
mActivity = autoclass(
'org.kivy.android.PythonActivity').mActivity
argument = ''
self.service.start(mActivity, argument)
except:
self.service = AndroidService('Sevice example',
'service is running')
self.service.start('Hello From Service')
else:
Window.system_size = cm(7), cm(12)
self.client.on_connect = self.on_connect
self.client.on_disconnect = self.on_disconnect
Clock.schedule_once(self.try_connecting, 0)
Clock.schedule_interval(self.handle_msg, 0.1)
# def skipp(*a):
# self.root.ids.sm.current = 'main'
# Clock.schedule_once(skipp, 0.5)
return self.root
def _inner(*args):
prev = p.ids['preview']
tmpl = prev.children[0]
TS = tmpl.size
PS = prev.parent.size
W_ratio = float(.9*PS[0])/TS[0]
H_ratio = float(.9*PS[1])/TS[1]
ratio = min(W_ratio, H_ratio)
x, y = p.ids['FL'].center
prev.center = ratio * x, ratio * y
#p.ids['preview'].scale = ratio
#forcing x to 0
prev.x = 5
prev.center_y = y
from kivy.metrics import cm
p.tsize = options.current_selection[0].size[0]/cm(1), options.current_selection[0].size[1]/cm(1)
def addSettingsDialogPart(self, bl, inWConf=None):
presetVals = []
for s in self.defSettings:
presetVals.append(s['name'])
presetDef = presetVals[0]
#bl = BoxLayout(orientation="vertical")
bh = self.getDialogRow()
bh.add_widget(MyLabel(text="Preset:"))
self.spPreset = Spinner(text=presetDef,
values=presetVals,
height=cm(1))
bh.add_widget(self.spPreset)
bl.add_widget(bh)
self.spPreset.bind(text=self.on_presetChange)
if inWConf:
self.spPreset.text = inWConf['atr']['name']
bl, self.ti_title = self.addDialogRow(
bl, "Title", "" if inWConf == None else inWConf['atr']['title'])
bl, self.ti_min = self.addDialogRow(
bl, "Min value",
-175 if inWConf == None else str(inWConf['atr']['min']))
bl, self.ti_max = self.addDialogRow(
bl, "Max value",
175 if inWConf == None else str(inWConf['atr']['max']))
bl, self.ti_tick = self.addDialogRow(
bl, "Tick", 25 if inWConf == None else str(inWConf['atr']['tick']))
bl, self.ti_subtick = self.addDialogRow(
bl, "Sub ticks",
6 if inWConf == None else str(inWConf['atr']['subtick']))
bl, self.ti_start_angle = self.addDialogRow(
bl, "Start angle",
-170 if inWConf == None else str(inWConf['atr']['start_angle']))
bl, self.ti_end_angle = self.addDialogRow(
bl, "End angle",
170 if inWConf == None else str(inWConf['atr']['end_angle']))
bl, self.ti_value_font_size = self.addDialogRow(
bl, "Value size",
23 if inWConf == None else str(inWConf['atr']['value_font_size']))
bl, self.ti_label_font_size = self.addDialogRow(
bl, "Labels size",
50 if inWConf == None else str(inWConf['atr']['label_font_size']))
return bl
def run(self, a='', b=''):
try:
hs = 0.0
for c in self.queryWidget.children:
hs += c.height
self.queryWidget.size = [self.queryWidget.size[0], hs + cm(1)]
print("it will have ", hs, " height")
print("parnte is size ", self.queryWidget.parent.size)
print("parnte2 is size ", self.queryWidget.parent.parent.size)
print("parnte3 is size ",
self.queryWidget.parent.parent.parnet.size)
except:
print("queryPopup - no need to resize scroll view")
print("preopen")
self.open()
print("postopen")
def rescale_interface(self, *_, force=False):
"""Called when the window changes resolution, calculates variables dependent on screen size"""
self.store_window_size()
if Window.width != self.last_width:
self.last_width = Window.width
self.popup_x = min(Window.width, 640)
if (Window.height != self.last_height) or force:
self.last_height = Window.height
self.button_scale = int(
float(cm(0.85)) *
(int(self.config.get("Settings", "buttonsize")) / 100))
self.text_scale = int(
(self.button_scale / 3) *
int(self.config.get("Settings", "textsize")) / 100)
self.display_border = self.button_scale / 3
self.display_padding = self.button_scale / 4
def draw_rules(self, *args):
self.rules.points = [
-5, -5, self.width * self.FACTOR_LINE - 5, -5, -5, -5, -5,
self.height * self.FACTOR_LINE - 5
]
with self.canvas:
self.htick = [
Line(points=(x * cm(1), -10, x * cm(1), +5))
for x in range(2 + int(self.width / cm(1)))
]
self.vtick = [
Line(points=(-10, y * cm(1), +5, y * cm(1)))
for y in range(2 + int(self.height / cm(1)))
]
def build(self):
main_scroll = ScrollView(do_scroll_x=False)
main_grid = GridLayout(cols=1,
spacing=100,
padding=[0, 50, 0, 50],
size_hint_y=None)
main_grid.bind(minimum_height=main_grid.setter('height'))
main_scroll.add_widget(main_grid)
scroll_count = 4
for _ in range(scroll_count):
scroll = ScrollView(size_hint_y=None,
height=300,
do_scroll_y=False)
grid = GridLayout(rows=1, spacing=1, size_hint=(None, 1))
grid.bind(minimum_width=grid.setter('width'))
scroll.add_widget(grid)
for r in range(0, 50):
bt = Button(text='Button ' + str(r),
size_hint_x=None,
width=cm(2))
bt.bind(on_press=self.print_btn)
grid.add_widget(bt)
main_grid.add_widget(scroll)
return main_scroll
def yf(row, col, index):
from kivy.metrics import cm
return cm(1) * eval(dyf)
def custom_layout(self, w, h, a, dxf, dyf, clean_book_first=False):
if clean_book_first:
self.new_book()
from conf import FORCE_FIT_FORMAT
#alas, I have to linezarise in order to save layout for each widget
from kivy.app import App
App.get_running_app().root.ids.deck.linearize()
fg, bg, dual_dict = self.get_duals()
fg = list(reversed(fg))
from kivy.metrics import cm
from conf import page_format
w = 0 if not (w) else float(w)
w *= cm(1)
h = 0 if not (h) else float(h)
h *= cm(1)
a = 0 if not (a) else float(a)
if not dxf:
xf = lambda r, c, ind: 0
else:
def xf(row, col, index):
from kivy.metrics import cm
return cm(1) * eval(dxf)
if not dyf:
yf = lambda r, c, ind: 0
else:
def yf(row, col, index):
from kivy.metrics import cm
return cm(1) * eval(dyf)
vars = dict(row_index=0,
col_index=0,
former_angle=0,
added_ones=list(),
cindex=-1)
from kivy.clock import Clock
self.ids.progress.max = len(fg)
def inner(*args):
if not fg:
Clock.unschedule(inner)
self.export_phs()
return
self.ids.progress.value += 1
cs, _ = fg.pop()
vars['cindex'] += 1
ph = self.add_ph()
#print 'force fit', FORCE_FIT_FORMAT
self.set_ph_img(ph, cs, not (FORCE_FIT_FORMAT))
ph.x = w * vars['col_index'] + page_format.left
ph.top = page_format.height - page_format.top - h * vars[
'row_index']
ph.angle = (vars['former_angle'] + a) % 360
vars['former_angle'] = ph.angle
vars['col_index'] += 1
ph.x += xf(vars['row_index'], vars['col_index'], vars['cindex'])
ph.y += yf(vars['row_index'], vars['col_index'], vars['cindex'])
if ph.right > page_format.width - page_format.right:
vars['row_index'] += 1
vars['col_index'] = 1
ph.x = page_format.left
ph.top = page_format.height - page_format.top - h * vars[
'row_index']
ph.x += xf(vars['row_index'], vars['col_index'],
vars['cindex'])
ph.y += yf(vars['row_index'], vars['col_index'],
vars['cindex'])
if ph.y < page_format.bottom:
self.remove_ph(ph)
vars['row_index'] = 0
vars['col_index'] = 0
if dual_dict:
#First page is done, create dual
mp = self.add_mirror_page()
for ph, b in zip(
reversed(mp.children),
[dual_dict[f] for f in vars['added_ones']]):
self.set_ph_img(ph, b, use_img_size=False)
#Once completed, add a new page
self.add_page()
vars['added_ones'] = list()
#Now, put back into the fg the needed cs. Also link dual if exists
ncs = self.ids.pictures.children[0]
if dual_dict:
dual_dict[ncs] = dual_dict[cs]
fg.append((ncs, _))
elif not (
fg
) and dual_dict: #layout is done. proceed with last uncompleted mirror page
vars['added_ones'].append(cs)
mp = self.add_mirror_page()
for ph, b in zip(reversed(mp.children),
[dual_dict[f] for f in vars['added_ones']]):
self.set_ph_img(ph, b, use_img_size=False)
else:
vars['added_ones'].append(cs)
Clock.schedule_interval(inner, .05)
"""This module handle generation of formatted page, through several renderer: PIL, WX & Reportlab/PDF"""
#For Py2exe towork
from kivy.metrics import cm
from kivy.vector import Vector
from kivy.factory import Factory
from kivy.logger import Logger
from reportlab.pdfgen.canvas import Canvas
from reportlab.lib.units import cm as r_cm
from reportlab.lib.utils import ImageReader
from PIL.Image import frombuffer, open as PILOpen
from conf import page_format
#Page Format - to be stuck into a .ini file
width = page_format.width/cm(1)
height = page_format.height/cm(1)
left = page_format.left/cm(1)
right = page_format.right/cm(1)
bottom = page_format.bottom/cm(1)
top = page_format.top/cm(1)
def center(x,y,w,h):
return x+w/2, y+h/2
class PDFBook:
def save(self):
try:
self.pdf.save()
except IOError:
def calculate_size(self):
from utils import alert
Logger.info('Printing with mode %s'%str(self.mode))
alert('Calculating Size for mode %s'%str(self.mode))
#Create all the necessary steps for while loop in printing
#populate self.index with line made of i, row, col, face & item
from datetime import date
from os.path import split, relpath
from conf import gamepath
if self.dst.startswith(gamepath):
title = relpath(self.dst, gamepath)
else:
title = split(self.dst)[-1]
self.banner = "File: %s - Date : %s - Print Mode: %s"%(title, date.today(), self.mode)
if self.mode not in ('LAYOUT', 'BINCAN'):
if self.mode == 'FORCED':
from conf import card_format
_w,_h = card_format.size
else:
_w,_h = self.mode
ft = "%.2fcmx%.2fcm"%(_w/cm(1),_h/cm(1))
self.banner += ' - Format : %s'%ft
self.pdf.drawString(20,20, self.banner)
fps, bps = self.stack
#Swtich on Print Mode
if self.mode == 'LAYOUT':
dst = [(obj.layout[-1], 0, 0, 'F', obj) for obj in fps]
dst.extend([(obj.layout[-1], 0, 0, 'F', obj) for obj in bps])
self.index = sorted(dst, key=lambda x:x[0])
self.index.reverse()
elif self.mode == 'BINCAN':
#######################################################
from conf import page_format
from layout import BinCanNode
SIZE = page_format.width-page_format.left-page_format.right, page_format.height-page_format.top-page_format.bottom
INDEX_PAGE = 0
dual_dict = dict()
fg = [(f,i) for (i,f) in enumerate(fps)]
for f,b in zip(fps,bps):
dual_dict[f]=b
#fill current page with what you can
def skey(item):
w,h = item[0].getSize()
return w*h, -item[1]
fg = sorted(fg, key=skey, reverse=True)
while fg:
sorted_phs = fg[:]
added_ones = list()
PAGE_LAYOUT = BinCanNode(0, 0, SIZE[0], SIZE[1])
for f, i in sorted_phs:
w,h = f.getSize()
layout = PAGE_LAYOUT.find(f, w,h)
if not layout:
continue
del fg[fg.index((f, i))]
X, Y = layout.x, layout.y
#Rebase properly
x = X + page_format.left
y = page_format.height-page_format.top-Y -h
angle = layout.retry.get(f, 0) * 90
self.index.append((INDEX_PAGE, 0, 0, 'F',(x, y, w, h, angle, f)))
added_ones.append((f, (x, y, w, h, angle)))
if not added_ones: #We could NOT feet any of the pictures: raise error:
Logger.error( 'Error: not all pictures could be fit inside one page')
break
if dual_dict:
#First page is done, create dual
INDEX_PAGE += 1
for f,_layout in added_ones:
b = dual_dict[f]
x, y, w, h, angle = _layout
x = page_format.width - page_format.right -x - w
angle = -angle
self.index.append((INDEX_PAGE, 0, 0, 'F', (x, y, w, h, angle, b)))
#Add a new page, only if necessay:
if fg:
INDEX_PAGE+=1
self.index.reverse()
######################################################
else:
if self.mode == 'FORCED':
fitting_size = card_format.size
else:
fitting_size = self.mode
#First determinez the number of item per page, acconirding to the dimensions
x,y= self.x, self.y = Vector(fitting_size)/cm(1)
NUM_COL = int((width-left)/(x+5/cm(1)))
NUM_ROW = int((height-top)/(y+5/cm(1)))
PICT_BY_SHEET=NUM_COL*NUM_ROW
if not(fps) and not(bps):
print 'Warning: nothing to print: cancelling PDF generation'
return
if not NUM_COL or not NUM_ROW:
PICT_BY_SHEET = 1
if not NUM_ROW:
NUM_ROW = 1
if not NUM_COL:
NUM_COL = 1
x = self.x = width-left-right
y = self.y = height-top-bottom
if 0:
print 'fitting size', fitting_size
print "x,y", x,y
print 'Num row', NUM_ROW
print 'Num Col', NUM_COL
print PICT_BY_SHEET , 'pictures by sheet'
#Now prepare the whole list of index that will be used for the while loop
index = self.index
for i in range((len(fps)/PICT_BY_SHEET)+1):
for row in range(NUM_ROW):
for col in range(NUM_COL):
try:
obj = fps.pop()
index.append((i,row,col,'F', obj))
except IndexError:
break
for row in range(NUM_ROW):
for col in range(NUM_COL):
try:
obj = bps.pop()
index.append((i,row,col,'B', obj))
except IndexError:
break
self.index.reverse()
def generation_step(self, with_realize = False):
"Will be called in order to show some advancement"
i, row, col, face, item = self.index.pop()
#Determine wheter a new page should be appended
face_index = 0 if self.current_face == 'F' else 1
if self.current_face != face:
self.current_face = face
self.current_page_num[1-face_index] = i
self.AddPage()
elif self.current_page_num[face_index] != i:
self.current_page_num[face_index] = i
self.AddPage()
#Determine Image X/Y/W/H depending on print mode
if self.mode == 'LAYOUT':
x, y, self.x, self.y, angle, pageindex = item.layout
x /= cm(1)
y /= cm(1)
self.x /= cm(1)
self.y /= cm(1)
elif self.mode == 'BINCAN':
x, y, self.x, self.y, angle, item = item #hackick: replace item in place !
x /= cm(1)
y /= cm(1)
self.x /= cm(1)
self.y /= cm(1)
else:
if face == 'F':
x, y = col * self.x + left, height-(1+row)*self.y - top
else:
x, y = width - (1+col)*self.x - left - right, height-(1+row)*self.y - top
#x, y = width - (1+col)*self.x - right, height-(1+row)*self.y - top
#self.x & slef.y has already been setp by calculate_size
#Check is there is a layout that could be used, just for the angle
if getattr(item, 'layout',0):
angle = item.layout[4]
else:
angle = 0
#Now that in item lies the Stack Item, before rendering it, inject special print vairables
item.print_index = {
'pagenum' : i,
'stackrow': row,
'stackcol': col,
'pageface': face
}
# Now, define source for image: we either get the source or convert to image
if item.image:#speicla case for complex image manip
src = ImageReader(item.image.rotate(angle))
elif item.template:
if with_realize:
item.realise(True,True)
tmplWidget = item.tmplWidget
elif item.tmplWidget:#it has been modified
tmplWidget = item.tmplWidget
else:
from template import BGTemplate
Logger.info( '[Printer] Generation Step without tmplWidget')
tmplWidget = BGTemplate.FromFile(item.template)
if tmplWidget:
#only taking the last one
tmplWidget = tmplWidget[-1]
else:
raise NameError('No such template: '+ item.template)
if item.values:
tmplWidget.apply_values(item.values)
from kivy.base import EventLoop
EventLoop.idle()
cim = tmplWidget.toImage(for_print=True)
pim = frombuffer('RGBA', cim.size, cim._texture.pixels, 'raw', 'RGBA',0,1)
src = ImageReader(pim.rotate(angle))
else:
src = item.source
from utils import find_path
src = find_path(src)
if angle:
src = ImageReader(PILOpen(src).rotate(angle))
#print "Adding Image to pdf", i, row, col, face, item, src, x, y, self.x, self.y, angle
self.pdf.drawImage(src, x*r_cm, y*r_cm, self.x*r_cm, self.y*r_cm, mask='auto')
from conf import CP
if CP.getboolean('Print','draw_cut_rect'):
#add line after image: they ll be above
self.AddLines(x,y,self.x,self.y)
def getDialogRow(self):
return BoxLayout(orientation="horizontal",
height=cm(1),
size_hint_y=None)
def yf(row, col, index):
from kivy.metrics import cm
return cm(1) * eval(dyf)
def generation_step(self, with_realize=False):
"Will be called in order to show some advancement"
i, row, col, face, item = self.index.pop()
#Determine wheter a new page should be appended
face_index = 0 if self.current_face == 'F' else 1
if self.current_face != face:
self.current_face = face
self.current_page_num[1 - face_index] = i
self.AddPage()
elif self.current_page_num[face_index] != i:
self.current_page_num[face_index] = i
self.AddPage()
#Determine Image X/Y/W/H depending on print mode
if self.mode == 'LAYOUT':
x, y, self.x, self.y, angle, pageindex = item.layout
x /= cm(1)
y /= cm(1)
self.x /= cm(1)
self.y /= cm(1)
elif self.mode == 'BINCAN':
x, y, self.x, self.y, angle, item = item #hackick: replace item in place !
x /= cm(1)
y /= cm(1)
self.x /= cm(1)
self.y /= cm(1)
else:
if face == 'F':
x, y = col * self.x + left, height - (1 + row) * self.y - top
else:
x, y = width - (1 + col) * self.x - left - right, height - (
1 + row) * self.y - top
#x, y = width - (1+col)*self.x - right, height-(1+row)*self.y - top
#self.x & slef.y has already been setp by calculate_size
#Check is there is a layout that could be used, just for the angle
if getattr(item, 'layout', 0):
angle = item.layout[4]
else:
angle = 0
#Now that in item lies the Stack Item, before rendering it, inject special print vairables
item.print_index = {
'pagenum': i,
'stackrow': row,
'stackcol': col,
'pageface': face
}
# Now, define source for image: we either get the source or convert to image
if item.image: #speicla case for complex image manip
src = ImageReader(item.image.rotate(angle))
elif item.template:
if with_realize:
item.realise(True, True)
tmplWidget = item.tmplWidget
elif item.tmplWidget: #it has been modified
tmplWidget = item.tmplWidget
else:
from template import BGTemplate
Logger.info('[Printer] Generation Step without tmplWidget')
tmplWidget = BGTemplate.FromFile(item.template)
if tmplWidget:
#only taking the last one
tmplWidget = tmplWidget[-1]
else:
raise NameError('No such template: ' + item.template)
if item.values:
tmplWidget.apply_values(item.values)
from kivy.base import EventLoop
EventLoop.idle()
cim = tmplWidget.toImage(for_print=True)
pim = frombuffer('RGBA', cim.size, cim._texture.pixels, 'raw',
'RGBA', 0, 1)
src = ImageReader(pim.rotate(angle))
else:
src = item.source
from utils import find_path
src = find_path(src)
if angle:
src = ImageReader(PILOpen(src).rotate(angle))
#print "Adding Image to pdf", i, row, col, face, item, src, x, y, self.x, self.y, angle
self.pdf.drawImage(src,
x * r_cm,
y * r_cm,
self.x * r_cm,
self.y * r_cm,
mask='auto')
from conf import CP
if CP.getboolean('Print', 'draw_cut_rect'):
#add line after image: they ll be above
self.AddLines(x, y, self.x, self.y)
def calculate_size(self):
from utils import alert
Logger.info('Printing with mode %s' % str(self.mode))
alert('Calculating Size for mode %s' % str(self.mode))
#Create all the necessary steps for while loop in printing
#populate self.index with line made of i, row, col, face & item
from datetime import date
from os.path import split, relpath
from conf import gamepath
if self.dst.startswith(gamepath):
title = relpath(self.dst, gamepath)
else:
title = split(self.dst)[-1]
self.banner = "File: %s - Date : %s - Print Mode: %s" % (
title, date.today(), self.mode)
if self.mode not in ('LAYOUT', 'BINCAN'):
if self.mode == 'FORCED':
from conf import card_format
_w, _h = card_format.size
else:
_w, _h = self.mode
ft = "%.2fcmx%.2fcm" % (_w / cm(1), _h / cm(1))
self.banner += ' - Format : %s' % ft
self.pdf.drawString(20, 20, self.banner)
fps, bps = self.stack
#Swtich on Print Mode
if self.mode == 'LAYOUT':
dst = [(obj.layout[-1], 0, 0, 'F', obj) for obj in fps]
dst.extend([(obj.layout[-1], 0, 0, 'F', obj) for obj in bps])
self.index = sorted(dst, key=lambda x: x[0])
self.index.reverse()
elif self.mode == 'BINCAN':
#######################################################
from conf import page_format
from layout import BinCanNode
SIZE = page_format.width - page_format.left - page_format.right, page_format.height - page_format.top - page_format.bottom
INDEX_PAGE = 0
dual_dict = dict()
fg = [(f, i) for (i, f) in enumerate(fps)]
for f, b in zip(fps, bps):
dual_dict[f] = b
#fill current page with what you can
def skey(item):
w, h = item[0].getSize()
return w * h, -item[1]
fg = sorted(fg, key=skey, reverse=True)
while fg:
sorted_phs = fg[:]
added_ones = list()
PAGE_LAYOUT = BinCanNode(0, 0, SIZE[0], SIZE[1])
for f, i in sorted_phs:
w, h = f.getSize()
layout = PAGE_LAYOUT.find(f, w, h)
if not layout:
continue
del fg[fg.index((f, i))]
X, Y = layout.x, layout.y
#Rebase properly
x = X + page_format.left
y = page_format.height - page_format.top - Y - h
angle = layout.retry.get(f, 0) * 90
self.index.append(
(INDEX_PAGE, 0, 0, 'F', (x, y, w, h, angle, f)))
added_ones.append((f, (x, y, w, h, angle)))
if not added_ones: #We could NOT feet any of the pictures: raise error:
Logger.error(
'Error: not all pictures could be fit inside one page')
break
if dual_dict:
#First page is done, create dual
INDEX_PAGE += 1
for f, _layout in added_ones:
b = dual_dict[f]
x, y, w, h, angle = _layout
x = page_format.width - page_format.right - x - w
angle = -angle
self.index.append(
(INDEX_PAGE, 0, 0, 'F', (x, y, w, h, angle, b)))
#Add a new page, only if necessay:
if fg:
INDEX_PAGE += 1
self.index.reverse()
######################################################
else:
if self.mode == 'FORCED':
fitting_size = card_format.size
else:
fitting_size = self.mode
#First determinez the number of item per page, acconirding to the dimensions
x, y = self.x, self.y = Vector(fitting_size) / cm(1)
NUM_COL = int((width - left) / (x + 5 / cm(1)))
NUM_ROW = int((height - top) / (y + 5 / cm(1)))
PICT_BY_SHEET = NUM_COL * NUM_ROW
if not (fps) and not (bps):
print 'Warning: nothing to print: cancelling PDF generation'
return
if not NUM_COL or not NUM_ROW:
PICT_BY_SHEET = 1
if not NUM_ROW:
NUM_ROW = 1
if not NUM_COL:
NUM_COL = 1
x = self.x = width - left - right
y = self.y = height - top - bottom
if 0:
print 'fitting size', fitting_size
print "x,y", x, y
print 'Num row', NUM_ROW
print 'Num Col', NUM_COL
print PICT_BY_SHEET, 'pictures by sheet'
#Now prepare the whole list of index that will be used for the while loop
index = self.index
for i in range((len(fps) / PICT_BY_SHEET) + 1):
for row in range(NUM_ROW):
for col in range(NUM_COL):
try:
obj = fps.pop()
index.append((i, row, col, 'F', obj))
except IndexError:
break
for row in range(NUM_ROW):
for col in range(NUM_COL):
try:
obj = bps.pop()
index.append((i, row, col, 'B', obj))
except IndexError:
break
self.index.reverse()
"""This module handle generation of formatted page, through several renderer: PIL, WX & Reportlab/PDF"""
#For Py2exe towork
from kivy.metrics import cm
from kivy.vector import Vector
from kivy.factory import Factory
from kivy.logger import Logger
from reportlab.pdfgen.canvas import Canvas
from reportlab.lib.units import cm as r_cm
from reportlab.lib.utils import ImageReader
from PIL.Image import frombuffer, open as PILOpen
from conf import page_format
#Page Format - to be stuck into a .ini file
width = page_format.width / cm(1)
height = page_format.height / cm(1)
left = page_format.left / cm(1)
right = page_format.right / cm(1)
bottom = page_format.bottom / cm(1)
top = page_format.top / cm(1)
def center(x, y, w, h):
return x + w / 2, y + h / 2
class PDFBook:
def save(self):
try:
self.pdf.save()
except IOError:
class gui(App):
testHDG = 10
remotePythonPid = None
#npTest = NumericProperty(1)
btH = kmetrics.cm(1)
lineH = kmetrics.cm(0.7)
lDynamicLable = ObjectProperty(1)
wifiTcpStatusOpts = {
'on': "icons/ico_armG_256_256.png",
'off': "icons/ico_armR_256_256.png"
}
wifiTcpStatus = StringProperty("icons/ico_manZle_256_256.png")
def __init__(self, *a, **kw):
super(gui, self).__init__(*a, **kw)
Builder.load_file('layoutPresets.kv')
if kplatform == 'android':
self.sensorsRemoteTcp = "host:port"
else:
#self.sensorsRemoteTcp = "192.168.43.208:11223"
#self.sensorsRemoteTcp = "192.168.43.208:11223"
self.sensorsRemoteTcp = "192.168.49.199:11223"
self.windowSize = Window.size
self.isReady = False
self.plt = None
self.ips = []
def doLocalIp(self):
print("- do local ips")
import subprocess
r = subprocess.Popen(['ip','address'], stdout=subprocess.PIPE)
so,se = r.communicate()
self.ips = []
l = so.split()
print(" got elements",len(l))
for ii,i in enumerate(l):
i = str(i)[2:-1]
#print("i:[",i,']')
if len(i)>2:
#if i[-1] == ":":
# print(" interface: ",i)
if str(l[ii-1])[2:-1] == 'inet':
ip = i
ip = ip.split("/")
ip = ip[0]
print(" ip:",ip)
if ip == "127.0.0.1":
print(" skip it's local")
else:
self.ips.append(ip)
self.rl.ids.l_phoLocIps.text = "{}".format(", ".join(self.ips))
#sys.exit(0)
def build(self):
print("layoutMyWidgets...")
Builder.load_file('layoutMyWidgets.kv')
print("layoutLoader...")
Builder.load_file('layoutLoader.kv')
Window.bind(on_key_down=self.on_key_down)
Window.bind(on_key_up=self.on_key_up)
self.ll = LoaderLayout()
#sys.exit(9)
self.loaderStep = 0
Clock.schedule_once( self.loaderNextStep, 0.1 )
self.colorTheme = "day"
self.theme_cls.theme_style = "Dark"
return self.ll
def makeIFT(self,a=1):
self.ift = ImageFromTexture()
self.iftii = 0
self.iftI = [
'/home/yoyo/Pictures/IMG_20200927_084635.jpg',
'/home/yoyo/Pictures/filamentChopt.jpg',
#'/tmp/fig.png'
]
self.rl.ids.l_forMfd.add_widget(self.ift)
self.iftIter()
def iftIter(self,a=0):
if self.iftii >= 2:
self.iftii = 0
print("iftIter", self.iftii)
data = BytesIO(open(self.iftI[self.iftii], "rb").read())
im = CoreImage(data, ext="jpg", filename="image.jpg")
#self.ift.canvas.clear()
self.ift.imgTexture = CoreImage( im, ext='jpg', filename='yy.jpg' )
self.iftii+=1
Clock.schedule_once(self.iftIter, 1.0)
def loaderNextStep(self,a=0,b=0):
self.loaderStep+=1
print("loaderNextStep step now",self.loaderStep)
if self.loaderStep == 1:
if kplatform == 'android':
self.platform = 'android'
else:
self.platform = 'pc'
self.ll.ids.l_loaMaiWin.text = "DONE"
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 2:
from TimeHelper import TimeHelper
from FileActions import FileActions
self.th = TimeHelper()
self.fa = FileActions()
self.homeDirPath = self.fa.getHomeDirectoryForApp(
'ykpilot',
kplatform
)
print("homeDir",self.homeDirPath)
#sys.exit(0)
self.timeAppStart = self.th.getTimestamp()
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 3:
self.ll.ids.l_loaHel.text = "DONE"
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 4:
bS = self.th.benStart()
Builder.load_file('layoutMain.kv')
self.rl = RootLayout()
self.bE = self.th.benDone(bS,'')
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 5:
self.ll.ids.l_appRooLay.text = "DONE in %s sec."%self.bE
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 6:
bS = self.th.benStart()
Builder.load_file('layoutActionBar.kv')
self.ab = ykpActionBar()
self.bE = self.th.benDone(bS,'')
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 7:
self.ll.ids.l_actBarLay.text = "DONE in %s sec."%self.bE
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 8:
bS = self.th.benStart()
self.config = DataSR_restore(
self.fa.join( self.homeDirPath,'ykpilot.conf')
)
if self.config == None:
self.config = {}
self.doLocalIp()
self.bE = self.th.benDone(bS, "")
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 9:
self.ll.ids.l_loaCon.text = "DONE in %s sec."%self.bE
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 10:
bS = self.th.benStart()
if kplatform == 'android':
self.platform = 'android'
self.animation = False
ipSens = '192.168.43.56'
if len(self.ips)>0:
ipSens = self.ips[0]
ip = ipSens
self.senderIp = ip
self.senderPort = 11223
makeRender = True
print("- setting up a sensor server at ",ipSens,":",self.senderPort)
# android service
if mkservice:
from android import AndroidService
service = AndroidService("ykpilot background","running ....")
service.start("service started")
self.service = service
# android service
self.workingFolderAdress = '/storage/emulated/0/ykpilot/'
self.virtualButtons = False
else:
self.platform = 'pc'
self.animation = True
ipSens = '192.168.43.56'
if len(self.ips)>0:
ipSens = self.ips[0]
ip = ipSens
self.senderIp = ip
self.senderPort = 11225
makeRender = True
self.workingFolderAdress = './ykpilot/'
self.virtualButtons = False
self.bE = self.th.benDone(bS, "")
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 11:
self.ll.ids.l_loaPlaChk.text = "DONE in %s sec."%self.bE
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 12:
bS = self.th.benStart()
print("preloaderStep0")
self.loaderStep0()
print("postloaderStep0")
self.bE = self.th.benDone(bS, "")
#Clock.schedule_once(
self.loaderNextStep()#, 0.1 )
elif self.loaderStep == 13:
self.ll.ids.l_loaRest.text = "DONE in %s sec."%self.bE
Clock.schedule_once( self.loaderNextStep, 0.5 )
elif self.loaderStep == 14:
bS = self.th.benStart()
from sensors import sensors
self.sen = sensors(self)
print("pre ask for permissions")
self.sen.askForPermissions()
print("post ask for permissions")
self.bE = self.th.benDone(bS, "")
Clock.schedule_once( self.loaderNextStep, 0.5 )
elif self.loaderStep == 15:
if self.platform == 'android' and self.sen.permissonsStatus == False:
self.loaderStep-=1
else:
self.ll.ids.l_permissions.text = "DONE in %s sec."%self.bE
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 16:
bS = self.th.benStart()
self.sen.makeSensors()
p = self.rl.parent
p.remove_widget(self.rl)
rl = self.sen.buidPlayer(self.rl)
p.add_widget(rl)
#self.sen.run()
#try:
# self.sen.gps_start(1000, 0)
#except:
# print("EE - can't start sen.gps")
# print(sys.exc_info())
# pass
self.bE = self.th.benDone(bS, "")
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 17:
self.ll.ids.l_sensors.text = "DONE in %s sec."%self.bE
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 18:
bS = self.th.benStart()
from ScreenWidgets import ScreenWidgets
self.sWidgets = ScreenWidgets(self)
self.sWidgets.setGui()
self.bE = self.th.benDone(bS, "")
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 19:
self.ll.ids.l_loaSWid.text = "DONE in %s sec."%self.bE
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 20:
bS = self.th.benStart()
from ScreenAutopilot import ScreenAutopilot
self.ap = ScreenAutopilot(self)
self.bE = self.th.benDone(bS, "")
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 21:
self.ll.ids.l_loaSAut.text = "DONE in %s sec."%self.bE
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 22:
bS = self.th.benStart()
from ScreenRace import ScreenRace
self.sRace = ScreenRace(self)
self.sRace.setupGui()
self.bE = self.th.benDone(bS, "")
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 23:
self.ll.ids.l_loaSRac.text = "DONE in %s sec."%self.bE
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 24:
bS = self.th.benStart()
from ScreenCompass import ScreenCompass
self.sCompass = ScreenCompass()
self.sCompass.setGui(self)
self.rl.ids.blCompass.add_widget( self.sCompass )
self.bE = self.th.benDone(bS, "")
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 25:
self.ll.ids.l_loaSCom.text = "DONE in %s sec."%self.bE
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 26:
bS = self.th.benStart()
from ScreenNMEAMultiplexer import ScreenNMEAMultiplexer
self.sNMEAMul = ScreenNMEAMultiplexer()
self.sNMEAMul.setGui(self)
self.bE = self.th.benDone(bS, "")
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 27:
self.ll.ids.l_loaSMul.text = "DONE in %s sec."%self.bE
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 28:
bS = self.th.benStart()
from boatRender import Renderer
self.senBoat = Renderer()
self.senBoat.setGui(self)
self.rl.ids.blModelScreen.add_widget( self.senBoat )
self.bE = self.th.benDone(bS, "")
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 29:
self.ll.ids.l_loaMScr.text = "DONE in %s sec."%self.bE
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 30:
bS = self.th.benStart()
from simRender import simRender
from simEngine import simEngine
from driver1 import driver1
from driver2 import driver2
from driver3 import driver3
from driver4 import driver4
from driver5 import driver5
from driver6 import driver6
from driver7 import driver7
from driver8 import driver8
from driver9 import driver9
from driver10 import driver10
self.simRen = simRender()
self.simEng = simEngine(self,self.simRen)
self.simRen.setSim(self.simEng)
self.simRen.setGui(self)
self.simEng.renderFrame()
self.rl.ids.blSimulator.add_widget( self.simRen )
self.driver1 = driver1(self.simEng)
self.driver2 = driver2(self.simEng)
self.driver3 = driver3(self.simEng)
self.driver4 = driver4(self.simEng)
self.driver5 = driver5(self.simEng)
self.driver6 = driver6(self.simEng)
self.driver7 = driver7(self.simEng)
self.driver8 = driver8(self.simEng)
self.driver9 = driver9(self.simEng)
self.driver10 = driver10(self.simEng)
self.bE = self.th.benDone(bS, "")
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 31:
self.ll.ids.l_loaSSim.text = "DONE in %s sec."%self.bE
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 32:
bS = self.th.benStart()
print("Sender Server is on port[%s]"%self.senderPort)
self.sf = MyServerFactory(self)
reactor.listenTCP(self.senderPort, self.sf )
self.bE = self.th.benDone(bS, "")
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 33:
self.ll.ids.l_loaTcpSer.text = "DONE in %s sec."%self.bE
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 34:
bS = self.th.benStart()
self.tcp4ap = ttc(self)
self.bE = self.th.benDone(bS, "")
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 35:
self.ll.ids.l_AutoWifiArmTCP.text = "DONE in %s sec."%self.bE
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 36:
bS = self.th.benStart()
from ScreenTriangulacja import Triangulacja, TrianAddDialog
self.triangulacja = Triangulacja(self)
self.bE = self.th.benDone(bS, "")
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 37:
self.ll.ids.l_Tri.text = "DONE in %s sec."%self.bE
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 38:
bS = self.th.benStart()
from ScreenTakePhoto import ScreenTakePhoto
self.stp = ScreenTakePhoto(self)
self.bE = self.th.benDone(bS, "")
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 39:
self.ll.ids.l_takPho.text = "DONE in %s sec."%self.bE
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 40:
bS = self.th.benStart()
from ScreenSensors import ScreenSensors
self.sSensors = ScreenSensors()
self.sSensors.setGui(self)
self.bE = self.th.benDone(bS, "")
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 41:
self.ll.ids.l_screSen.text = "DONE in %s sec."%self.bE
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 999:
bS = self.th.benStart()
self.bE = self.th.benDone(bS, "")
Clock.schedule_once( self.loaderNextStep, 0.1 )
elif self.loaderStep == 1000:
#self.ll.ids.l_loaSWid.text = "DONE in %s sec."%self.bE
Clock.schedule_once( self.loaderNextStep, 0.1 )
else:
print(" loader finished ?")
print(" starting main loop for sensors ")
self.sen.run()
if self.sen.gpsD.androidServiceStatus == False:
try:
self.sen.gps_start(1000, 0)
except:
print("EE - can't gps_start :(")
self.sen.gpsD.addCallBack( self.sCompass,'Compass' )
self.sen.comCal.addCallBack( self.sCompass,'Compass' )
self.sen.comCalAccelGyro.addCallBack( self.sCompass,'Compass' )
self.sen.gpsD.addCallBack( self.sRace )
self.sen.comCal.addCallBack( self.ap )
self.sen.comCal.addCallBack( self.sen )
self.sen.comCal.addCallBack( self.senBoat )
#self.gui.senBoat.setRoseta( self.hdg )
#Clock.schedule_once(self.sen.on_PlayFromFile_play, 1.0)
#Clock.schedule_once(self.sWidgets.on_addEditDelButton, 1.0)
#Clock.schedule_once(self.sWidgets.rebuildWs, 5.0)
print("starting listener for sensors :) if pc")
if self.platform == 'pc':
Clock.schedule_once(self.connectToSensorsRemoteTcp, 1 )
#if 1:
# self.plt = PCPlot(self)
print('flip layouts....')
par = self.ll.parent
par.remove_widget(self.ll)
par.add_widget(self.rootLayout)
self.ll = None
print(" DONE")
if self.config['apCommunicationMode'] == 'wifi tcp':
self.ap.startTcp()
print("config",self.config)
defScreen = 'ykpilot'
goToScreen = defScreen
dontStartAt = ['Loader','EditWidget', 'SettingUpWidget', 'SelectWidgetToAdd']
try:
goToScreen = self.config['screenCurrent']
except:
print("EE - no def config['screenCurrent'] :/")
if goToScreen in dontStartAt:
print("goToScreen is in dont start list")
goToScreen = defScreen
print("go to screen is ",goToScreen)
try:
self.screenChange(goToScreen)
except:
print("EE - no screen [",goToScreen,"] in screenmanager")
self.screenChange(defScreen)
#multiplexer screen
self.rl.ids.cb_nmeBSensors.active = True if self.config['nmeBSensors'] else False
self.rl.ids.cb_nmeBAutopilot.active = True if self.config['nmeBAutopilot'] else False
self.rl.ids.cb_nmeBNmea.active = True if self.config['nmeBNmea'] else False
self.triangulacja.isReady()
#self.makeIFT()
self.isReady = True
def on_gotECPUStr(self,buf):
print("on_gotECPUStr",buf)
def loaderStep0(self):
#self.s3dtextures = Screen3dtextures()
#self.s3dtextures.setGui(self)
#self.rl.ids.bl3dtextures.add_widget( self.s3dtextures.l )
self.cDefVals = {
'screenCurrent': 'Sensors',
'totalUptime' : 0,
'totalMiles': 0.0,
'apDirectionReverse': 0,
'apDriver': 'driver9',
'apCommunicationMode': "audio jack",
'apWifiIp': '192.168.4.1',
'nmeBSensors': 0,
'nmeBAutopilot': 0,
'nmeBNmea': 1
}
for k in self.cDefVals.keys():
try:
print("config ",k," -- > ",self.config[k] )
except:
print("config default - > no value [",k,"] setting [",self.cDefVals[k],"]")
self.config[k] = self.cDefVals[k]
print(1)
#if self.virtualButtons:
# self.vBut = ScreenVirtualButtons(self)
#
print(2)
'''
wfa = self.workingFolderAdress.split("/")
dirName = wfa[-2]
try:
print("working folder adres ",
self.fa.mkDir(self.workingFolderAdress[:-1])
)
except:
pass
'''
#self.tcp = helperTCP(ip)
self.rl.passGuiApp(self)
print(4)
#self.sen.run()
"""
self.graph = Graph(xlabel='time', ylabel="angle", x_ticks_minor=1,
ymax=1.0,ymin=0.0
)
self.pPitch = MeshLinePlot(color=[1,1,0,1])
self.pHeel = MeshLinePlot(color=[1,0,1,1])
self.graph.add_plot(self.pPitch)
self.graph.add_plot(self.pHeel)
self.rl.ids.blModSimGra.add_widget(self.graph)
self.graphGyro = Graph(xlabel='time', ylabel="gyro", x_ticks_minor=1,
ymax=1.0,ymin=0.0
)
self.pgx = MeshLinePlot(color=[1,1,0,1])
self.pgy = MeshLinePlot(color=[1,0,1,1])
self.pgz = MeshLinePlot(color=[1,0,0,1])
self.graphGyro.add_plot(self.pgx)
self.graphGyro.add_plot(self.pgy)
self.graphGyro.add_plot(self.pgz)
self.rl.ids.blModSimGra.add_widget(self.graphGyro)
self.graphFFT = Graph(xlabel="Hz Heel", ylabel="Db Heel", ymax=1.0, ymin=0.0)
self.pFFTHeel = MeshLinePlot(color=[1,0,0,1])
self.pFFTPitch = MeshLinePlot(color=[0,1,0,1])
self.pFFTUD = MeshLinePlot(color=[0,0,1,1])
self.graphFFT.add_plot(self.pFFTHeel)
self.graphFFT.add_plot(self.pFFTPitch)
self.graphFFT.add_plot(self.pFFTUD)
self.rl.ids.blModSimFFT.add_widget( self.graphFFT )
self.compasGyro = Graph(xlabel='time', ylabel="compas", x_ticks_minor=1,
ymax=1.0,ymin=0.0
)
self.pc = MeshLinePlot(color=[1,1,0,1])
self.compasGyro.add_plot(self.pc)
self.rl.ids.blModSimGra.add_widget(self.compasGyro)
self.graphMic = Graph(xlabel="Hz mic", ylabel="Db mic", ymax=1.0, ymin=0.0)
self.pMic = MeshLinePlot(color=[1,0,0,1])
self.pMic1 = MeshLinePlot(color=[0,1,0,1])
self.pMic2 = MeshLinePlot(color=[0,0,1,1])
self.graphMic.add_plot(self.pMic)
self.graphMic.add_plot(self.pMic1)
self.graphMic.add_plot(self.pMic2)
self.rl.ids.blMicScre.add_widget(self.graphMic)
"""
#self.d3tex2 = d3tex2()
#self.d3tex2.setGui(self)
#self.rl.ids.bl3dtextures2.add_widget( self.d3tex2 )
print(5)
#action bar
if True:
self.mw = BoxLayout(orientation="vertical")
print(7)
self.mw.add_widget(self.ab)
self.mw.add_widget(self.rl)
print(8)
self.rootLayout = self.mw
else:
self.rootLayout = self.rl
# actionbar
print(9)
#self.sWidgets.setUpGui()
#self.ap.setupDriver()
#Window.set_title("ykpilot")
#self.ode = odeRTB(self)
#self.sen.accel.addCallBack(self.ode)
def hide_widget(self, wid, dohide=True):
if hasattr(wid, 'saved_attrs'):
if not dohide:
wid.height, wid.size_hint_y, wid.opacity, wid.disabled = wid.saved_attrs
del wid.saved_attrs
elif dohide:
wid.saved_attrs = wid.height, wid.size_hint_y, wid.opacity, wid.disabled
wid.height, wid.size_hint_y, wid.opacity, wid.disabled = 0, None, 0, True
def on_start(self):
print( "-------- on_start" )
try:
dont_go_sleep()
except:
pass
def on_pause(self):
if self.isReady:
print( "--------- on pause")
try:
self.sen.gps_stop()
except:
pass
self.on_configSave()
return True
def on_resume(self):
print( "------- on resume")
try:
abcaa = self.sen
self.sen.gps_start(1000, 0)
except:
print("EE - no self.sen or other gps error")
def on_configSave(self):
if self.rl.current not in ['TriangulateDialogs']:
self.config['screenCurrent'] = self.rl.current
self.config['totalUptime']+= self.th.getTimestamp()-self.timeAppStart
print("save config res", DataSR_save(
self.config,
self.fa.join( self.homeDirPath,'ykpilot.conf')
)
)
print("odometer....")
try:
abcue = self.sen
self.sen.odometer.saveData()
except:
pass
print("save widgets config")
try:
print(" res",self.sWidgets.saveConfig())
except:
print("EE - trying to save sWidget but it is not there yet !")
def on_makeToast(self, msg):
mdtoast(msg)
def on_takePhotoTest(self):
print("on_takePhotoTest")
d = DLabel(text="abc")
self.stp.takePhoto(
self.on_takePhotoTestDone,
d
)
def on_takePhotoTestDone(self, status, fileName):
print("on_takePhotoTestDone<",status)
def on_fullScreen(self, status):
print("on_fullScreen status",status)
if status:
self.gui_ab_height = self.ab.height
self.ab.height = 0.0
else:
self.ab.height = self.gui_ab_height
def on_toggleFullScreen(self):
print("on_toggleFullScreen",self.ab.height)
if self.ab.height > 0.0:
self.on_fullScreen(True)
else:
self.on_fullScreen(False)
# Screen: "Welcome"
def on_push_udp_msg(self):
udp = helperUdp()
udp.setAsSender()
self.testHDG+=1
udp.send("$AAHDG,%s,0,W,0,E"%self.testHDG)
def on_triAddPress(self, a=0,b=0):
print("on_triAddPress")
def on_push_tcp_msg(self):
self.testHDG+=1
self.tcp.sendToAll("$AAHDG,%s,0,W,0,E"%self.testHDG)
def doBranch(self,widget,level,search):
p = ""
for i in range(level):
p+= " "
for i,c in enumerate(widget.walk(restrict=True)):
if i >= 1:
print(p,level,"i",i," - id:",c.id," ",c)
parent = None
#while True:
# try:
# if parent == None:
# parent = c
#print(p,"parent",parent)
#print(p,"id:",parent.id)
#print(p,"pos",parent.pos)
#print(p,"size:",parent.size)
# parent = parent.parent
# except:
# break
try:
abc = str(c).index(search)
print(p,"got IT!")
return None
except:
self.doBranch(c, level+1, search)
''''p = ""
for i in range(level):
p+= " "
print(p,"doBranch children",len(widget.content.children))
for c in widget.content.chirdren:
print(p,"-",c)
try:
abc = c.index(search)
print(p," got it !")
return None
except:
if len(c.content.chirdren) > 0:
self.doBranch(c, level+1, search)
'''
def on_findWidgetByAdres(self, text):
print("on_findWidgetByAdres",text)
print("search for [",text,"]")
self.doBranch(self.rootLayout, 0, text)
def on_cb_nmeB(self, what, obj):
status = 1 if obj.active else 0
print("on_cb_nmeB",what," - >",status)
if what == 'sensors':
self.config['nmeBSensors'] = status
elif what == 'autopilot':
self.config['nmeBAutopilot'] = status
elif what == 'nmea':
self.config['nmeBNmea'] = status
self.on_configSave()
def on_cb_remotePython(self,checkbox):
print( checkbox.active )
if checkbox.active:
rp = remotePython()
_thread.start_new(rp.run,())
def on_cb_twistedTcp(self,checkobx):
pass
def on_push_sensorsInit(self):
print("android host ------------------")
self.sen.gps_start(1000,0)
print("sensors object !")
print("sensors running :)")
# actionbar
def screenChange(self, screenName = '',b=''):
print("screenChange",screenName,' b:',b)
if type(screenName) == str:
sn = screenName
else:
try:
sn = screenName.text
except:
sn = screenName.title
if self.rl.current == "Model Screen":
self.senBoat.on_noMoreDisplayd()
if self.virtualButtons and self.rl.current == "Virtual Buttons":
self.vBut.on_noMoreDisplayd()
self.rl.current = sn
print("screenChange to [%s]"%sn)
if sn == "Model Screen" :
self.senBoat.on_displayNow()
if sn[:7] in ['Compass','Widgets']:
print("make updateIt on sn change")
if sn == 'Compass':
self.sCompass.updateIt()
elif sn[:7] == 'Widgets':
self.sWidgets.updateIt()
if self.virtualButtons and sn == "Virtual Buttons":
self.vBut.on_displayNow()
if sn == "Autopilot":
self.ap.updateGui()
if self.rl.current == "3dtextures2":
self.d3tex2.on_displayNow()
def screenNight(self, a=0):
print("screenNight")
self.corolTheme = "night"
self.rl.fs = shader_red
def screenDay(self, a=0):
print("screenDay")
self.colorTheme = "day"
self.rl.fs = shader_day
def screenNightDay(self, a=0):
if self.colorTheme == "day":
self.corolTheme = "night"
elif self.colorTheme == "night":
self.colorTheme = "day"
print("screenNightDay!",self.colorTheme)
def on_touch_down(self, touch):
print('down',touch.x, touch.y)
if 0:#collide_point:
return True
return False
def on_touch_up(self, touch):
print('up',touch.x, touch.y)
if 0:#collide_point:
return True
return False
def on_key_down(self, *args):
print("on_key_down",list(args))
if self.isReady:
if self.rl.current == '3dtextures':
self.s3dtextures.on_key_down(list(args))
def on_key_up(self, *args):
print("on_key_up",list(args))
if self.isReady:
if self.rl.current == 'Simulator':
self.simEng.on_key_up(list(args))
elif self.rl.current == '3dtextures':
self.s3dtextures.on_key_up(list(args))
# screen: "Model Screen"
def on_touchSail(self, slider):
self.senBoat.setSail(slider.value)
def on_touchHeel(self, slider):
self.senBoat.setHeel(slider.value)
# screen: "Sensors"
def on_cb_sensorsRemoteTcp(self, checkbox):
if checkbox.active:
self.connectToSensorsRemoteTcp(0)
def connectToSensorsRemoteTcp(self,a):
self.rl.ids.cb_sensorsRemoteTcp.active = True
self.cf = MyClientFactory(self)
ip,port = str(self.rl.ids.ti_sensorsRemoteTcp.text).split(":")
reactor.connectTCP(str(ip),int(port),self.cf)
def __init__(self, **kwargs):
super(StackLayout, self).__init__( **kwargs)
for x in range(0, 100):
self.ids.rv.data.append({'text': 'TEXT '+str(x), 'gui': self, 'selected': False})
for x in range(0, 100):
self.ids.rv2.data.append({'text': 'TEXT '+str(x), 'gui': self, 'selected': False})
for x in range(0, 100):
self.ids.gridr.add_widget(Button(text='TEXT '+str(x),size_hint=(1,None), height=cm(1)))
for x in range(0, 100):
self.ids.gridr2.add_widget(Button(text='TEXT '+str(x),size_hint=(1,None), height=cm(1)))
class ContextMenu(GridLayout, AbstractMenu):
visible = kp.BooleanProperty(False)
spacer = kp.ObjectProperty(None)
min_y = cm(1.2)
def __init__(self, *args, **kwargs):
super(ContextMenu, self).__init__(*args, **kwargs)
self.orig_parent = None
def on_pos(self, _, value):
if self.y < self.min_y:
self.y = self.min_y
def on_size(self, _, value):
if self.y < self.min_y:
self.y = self.min_y
def arrow_up(self):
self.kb_force_hover(1)
def arrow_down(self):
self.kb_force_hover(-1)
def kb_force_hover(self, index):
global force_mouse_pos
found = False
for i, x in enumerate(self.children):
if not hasattr(x, 'hovered'):
continue
if x.hovered:
if i is 0 and index == -1:
index = 0
force_mouse_pos = self.children[i+index].pos
found = True
break
if not found:
force_mouse_pos = self.children[-1].pos
def select_hovered(self):
for x in self.children:
if not hasattr(x, 'hovered'):
continue
if x.hovered:
x.dispatch('on_release')
def hide(self):
self.visible = False
def show(self, x=None, y=None):
self.visible = True
self._add_to_parent()
self.hide_submenus()
root_parent = self.bounding_box_widget if self.bounding_box_widget is not None else self.get_context_menu_root_parent()
if root_parent is None:
return
point_relative_to_root = root_parent.to_local(*self.to_window(x, y))
# Choose the best position to open the menu
if x is not None and y is not None:
if point_relative_to_root[0] + self.width < root_parent.width:
pos_x = x
else:
pos_x = x - self.width
if issubclass(self.parent.__class__, AbstractMenuItem):
pos_x -= self.parent.width
if point_relative_to_root[1] - self.height < 0:
pos_y = y
if issubclass(self.parent.__class__, AbstractMenuItem):
pos_y -= self.parent.height + self.spacer.height
else:
pos_y = y - self.height
self.pos = pos_x, pos_y
def self_or_submenu_collide_with_point(self, x, y):
queue = self.menu_item_widgets
collide_widget = None
# Iterate all siblings and all children
while len(queue) > 0:
widget = queue.pop(0)
submenu = widget.get_submenu()
if submenu is not None and widget.hovered:
queue += submenu.menu_item_widgets
widget_pos = widget.to_window(0, 0)
if widget.collide_point(x - widget_pos[0], y - widget_pos[1]) and not widget.disabled:
widget.hovered = True
collide_widget = widget
for sib in widget.siblings:
sib.hovered = False
elif submenu and submenu.visible:
widget.hovered = True
else:
widget.hovered = False
return collide_widget
def _on_visible(self, new_visibility):
if new_visibility:
self.size = self.get_max_width(), self.get_height()
self._add_to_parent()
# @todo: Do we need to remove self from self.parent.__context_menus? Probably not.
elif self.parent and not new_visibility:
self.orig_parent = self.parent
'''
We create a set that holds references to all context menus in the parent widget.
It's necessary to keep at least one reference to this context menu. Otherwise when
removed from parent it might get de-allocated by GC.
'''
if not hasattr(self.parent, '_ContextMenu__context_menus'):
self.parent.__context_menus = set()
self.parent.__context_menus.add(self)
self.parent.remove_widget(self)
self.hide_submenus()
self._cancel_hover_timer()
def _add_to_parent(self):
if not self.parent:
self.orig_parent.add_widget(self)
self.orig_parent = None
# Create the timer on the outer most menu object
if self._get_root_context_menu() == self:
self._setup_hover_timer()
def get_max_width(self):
max_width = 0
for widget in self.menu_item_widgets:
width = widget.content_width if widget.content_width is not None else widget.width
if width is not None and width > max_width:
max_width = width
return max_width
def get_context_menu_root_parent(self):
"""
Return the bounding box widget for positioning sub menus. By default it's root context menu's parent.
"""
if self.bounding_box_widget is not None:
return self.bounding_box_widget
root_context_menu = self._get_root_context_menu()
return root_context_menu.bounding_box_widget if root_context_menu.bounding_box_widget else root_context_menu.parent
def _get_root_context_menu(self):
"""
Return the outer most context menu object
"""
root = self
while issubclass(root.parent.__class__, ContextMenuItem) \
or issubclass(root.parent.__class__, ContextMenu):
root = root.parent
return root
def hide_app_menus(self, obj, pos):
return self.self_or_submenu_collide_with_point(pos.x, pos.y) is None and self.hide()
def custom_layout(self, w, h, a, dxf, dyf, clean_book_first=False):
if clean_book_first:
self.new_book()
from conf import FORCE_FIT_FORMAT
#alas, I have to linezarise in order to save layout for each widget
from kivy.app import App
App.get_running_app().root.ids.deck.linearize()
fg,bg,dual_dict = self.get_duals()
fg = list(reversed(fg))
from kivy.metrics import cm
from conf import page_format
w = 0 if not(w) else float(w)
w *= cm(1)
h = 0 if not(h) else float(h)
h *= cm(1)
a = 0 if not(a) else float(a)
if not dxf:
xf = lambda r, c, ind: 0
else:
def xf(row, col, index):
from kivy.metrics import cm
return cm(1) * eval(dxf)
if not dyf:
yf = lambda r, c, ind: 0
else:
def yf(row, col, index):
from kivy.metrics import cm
return cm(1) * eval(dyf)
vars = dict(row_index=0, col_index = 0, former_angle=0, added_ones=list(),cindex=-1)
from kivy.clock import Clock
self.ids.progress.max = len(fg)
def inner(*args):
if not fg:
Clock.unschedule(inner)
self.export_phs()
return
self.ids.progress.value += 1
cs, _ = fg.pop()
vars['cindex'] +=1
ph = self.add_ph()
#print 'force fit', FORCE_FIT_FORMAT
self.set_ph_img(ph, cs, not(FORCE_FIT_FORMAT))
ph.x = w * vars['col_index'] + page_format.left
ph.top = page_format.height - page_format.top - h * vars['row_index']
ph.angle = (vars['former_angle']+a)%360
vars['former_angle'] = ph.angle
vars['col_index'] += 1
ph.x += xf(vars['row_index'],vars['col_index'], vars['cindex'])
ph.y += yf(vars['row_index'], vars['col_index'], vars['cindex'])
if ph.right > page_format.width-page_format.right:
vars['row_index'] += 1
vars['col_index'] = 1
ph.x = page_format.left
ph.top = page_format.height - page_format.top - h * vars['row_index']
ph.x += xf(vars['row_index'],vars['col_index'], vars['cindex'])
ph.y += yf(vars['row_index'],vars['col_index'], vars['cindex'])
if ph.y < page_format.bottom:
self.remove_ph(ph)
vars['row_index'] = 0
vars['col_index'] = 0
if dual_dict:
#First page is done, create dual
mp = self.add_mirror_page()
for ph, b in zip (reversed(mp.children), [dual_dict[f] for f in vars['added_ones']]):
self.set_ph_img(ph,b, use_img_size= False)
#Once completed, add a new page
self.add_page()
vars['added_ones'] = list()
#Now, put back into the fg the needed cs. Also link dual if exists
ncs = self.ids.pictures.children[0]
if dual_dict:
dual_dict[ncs] = dual_dict[cs]
fg.append((ncs,_))
elif not(fg) and dual_dict: #layout is done. proceed with last uncompleted mirror page
vars['added_ones'].append(cs)
mp = self.add_mirror_page()
for ph, b in zip (reversed(mp.children), [dual_dict[f] for f in vars['added_ones']]):
self.set_ph_img(ph,b, use_img_size= False)
else:
vars['added_ones'].append(cs)
Clock.schedule_interval(inner,.05)
def draw_rules(self, *args):
self.rules.points = [-5, -5, self.width*self.FACTOR_LINE-5,-5, -5, -5, -5, self.height*self.FACTOR_LINE-5]
with self.canvas:
self.htick = [Line(points=(x*cm(1),-10, x*cm(1),+5)) for x in range(2+int(self.width/cm(1)))]
self.vtick = [Line(points=(-10, y*cm(1),+5, y*cm(1))) for y in range(2+int(self.height/cm(1)))]
