441 lines
12 KiB
Python
441 lines
12 KiB
Python
from math import floor
|
|
from kivy.factory import Factory
|
|
from kivy.properties import NumericProperty, StringProperty, \
|
|
DictProperty, ListProperty, OptionProperty, BooleanProperty
|
|
from kivy.logger import Logger
|
|
from kivy.uix.textinput import TextInput
|
|
from kivy.uix.boxlayout import BoxLayout
|
|
from kivy.uix.stacklayout import StackLayout
|
|
from kivy.core.window import Window
|
|
from kivy.graphics import Color
|
|
from .responsivelayout import VResponsiveLayout
|
|
from .baseWidget import *
|
|
from .utils import *
|
|
from .i18n import I18n
|
|
from .toolbar import Toolbar
|
|
from .color_definitions import getColors
|
|
from .dataloader import DataGraber
|
|
from .ready import WidgetReady
|
|
from .widget_css import WidgetCSS
|
|
from .dateinput import DateInput
|
|
from .uitype.factory import UiFactory # import get_input_builder
|
|
|
|
"""
|
|
form options
|
|
{
|
|
"toolbar":
|
|
"dataloader":{
|
|
"dataurl":"first"
|
|
"datatargment":"second",
|
|
"datarfname":"third"
|
|
"params":
|
|
"method"
|
|
}
|
|
"cols":"1"
|
|
"labelwidth":
|
|
"textsize":
|
|
"inputheight":
|
|
"inline":True,False
|
|
"fields":[
|
|
{
|
|
"name":
|
|
"label":
|
|
"datatype",
|
|
"uitype",
|
|
"uiparams",
|
|
"default",
|
|
"readonly",
|
|
"required"
|
|
},
|
|
]
|
|
"binds":[
|
|
]
|
|
}
|
|
"""
|
|
|
|
class InputBox(BoxLayout):
|
|
def __init__(self, form, **options):
|
|
self.input_widget = None
|
|
self.form = form
|
|
self.options = options
|
|
self.uitype = options.get('uitype',options.get('datatype','str'))
|
|
self.size_hint = (None, None)
|
|
height = self.form.inputheight
|
|
if self.uitype == 'text':
|
|
if not options.get('height'):
|
|
self.options['height'] = 4
|
|
height = self.options.get('height',4)
|
|
|
|
self.labelwidth = self.form.labelwidth
|
|
kwargs = {
|
|
"orientation":'horizontal',
|
|
}
|
|
if height<=1:
|
|
kwargs['size_hint_y'] = height
|
|
else:
|
|
kwargs['size_hint_y'] = None
|
|
kwargs['height'] = CSize(height)
|
|
if self.form.input_width <= 1:
|
|
kwargs['size_hint_x'] = self.form.input_width
|
|
else:
|
|
kwargs['size_hint_x'] = None
|
|
kwargs['width'] = self.form.input_width
|
|
super().__init__(**kwargs)
|
|
self.initflag = False
|
|
self.register_event_type("on_datainput")
|
|
self.init()
|
|
|
|
def focus_act(self, *args):
|
|
pass
|
|
|
|
|
|
def on_size(self, *args):
|
|
if self.input_widget is None:
|
|
return
|
|
self.labeltext.size_hint_x = None
|
|
if self.form.labelwidth < 1:
|
|
self.labeltext.width = self.width * self.form.labelwidth - \
|
|
CSize(1)
|
|
else:
|
|
self.labeltext.width = CSize(self.form.labelwidth)
|
|
|
|
self.input_widget.size_hint_x = None
|
|
self.input_widget.width = self.width - self.labeltext.width - CSize(1)
|
|
|
|
def on_datainput(self,o,v=None):
|
|
pass
|
|
#print('on_datainput fired ...',o,v)
|
|
|
|
def init(self):
|
|
if self.initflag:
|
|
return
|
|
i18n = I18n()
|
|
label = self.options.get('label',self.options.get('name'))
|
|
kwargs = {
|
|
"i18n":True,
|
|
"otext":label,
|
|
"font_size":CSize(1),
|
|
}
|
|
if self.form.labelwidth <= 1:
|
|
kwargs['size_hint_x'] = self.form.labelwidth
|
|
else:
|
|
kwargs['size_hint_x'] = None
|
|
kwargs['width'] = CSize(self.form.labelwidth)
|
|
|
|
self.labeltext = Text(**kwargs)
|
|
self.add_widget(self.labeltext)
|
|
if self.options.get('required',False):
|
|
star = Label(text='*',
|
|
color=(1,0,0,1),
|
|
size_hint_x=None,
|
|
width=CSize(1))
|
|
self.add_widget(star)
|
|
|
|
options = self.options.copy()
|
|
options['hint_text'] = i18n(self.options.get('hint_text'))
|
|
options['size_hint_y'] = None
|
|
options['height'] = self.height
|
|
self.input_widget = UiFactory.build_input_widget(options)
|
|
try:
|
|
self.input_widget.bind(focus=self.focus_act)
|
|
except:
|
|
pass
|
|
self.input_widget.height = self.height
|
|
self.input_widget.size_hint_y = None
|
|
|
|
if self.form.labelwidth < 1:
|
|
self.input_widget.size_hint_x = 1 - self.form.labelwidth
|
|
else:
|
|
self.input_widget.size_hint_x = None
|
|
self.input_widget.width = self.width - self.labeltext.width - CSize(1)
|
|
if self.options.get('readonly'):
|
|
self.input_widget.disabled = True
|
|
if self.options.get('value'):
|
|
self.input_widget.setValue(self.options.get('value'))
|
|
elif self.options.get('default_value'):
|
|
self.input_widget.setValue(self.options.get('default_value'))
|
|
|
|
self.input_widget.widget_id = self.options['name']
|
|
self.add_widget(self.input_widget)
|
|
if self.labelwidth<=1:
|
|
self.labeltext.size_hint_x = self.labelwidth
|
|
self.input_widget.size_hint_x = 1 - self.labelwidth
|
|
else:
|
|
self.labeltext.size_hint_x = None
|
|
self.labeltext.width = CSize(self.labelwidth)
|
|
self.initflag = True
|
|
self.input_widget.bind(on_focus=self.on_focus)
|
|
|
|
def check(self):
|
|
d = self.getValue()
|
|
v = d.get(self.options.get('name'))
|
|
Logger.info('InputWidget() getValue=%s, name=%s',
|
|
v,self.options.get('name'))
|
|
if self.options.get('required',False) and \
|
|
(v == '' or v is None):
|
|
return False
|
|
|
|
return True
|
|
|
|
def clear(self):
|
|
self.input_widget.setValue('')
|
|
|
|
def on_focus(self,o,v):
|
|
if v:
|
|
self.old_value = o.text
|
|
else:
|
|
if self.old_value != o.text:
|
|
self.dispatch('on_datainput',o.text)
|
|
|
|
def setValue(self,v):
|
|
self.input_widget.setValue(v)
|
|
|
|
def getValue(self):
|
|
return {self.options.get('name'):self.input_widget.getValue()}
|
|
|
|
def disable(self,*args,**kwargs):
|
|
self.input_widget.disabled = True
|
|
|
|
def enable(self,*args,**kwargs):
|
|
self.input_widget.disabled = False
|
|
|
|
def defaultToolbar():
|
|
return {
|
|
"img_size_c":1,
|
|
"text_size_c":1,
|
|
"toolbar_orient":"H",
|
|
"tool_orient":"horizontal",
|
|
"tools":[
|
|
{
|
|
"name":"__submit",
|
|
"source_on":blockImage("save.png"),
|
|
"source_off":blockImage("save.png"),
|
|
"label":"submit"
|
|
},
|
|
{
|
|
"name":"__clear",
|
|
"source_on":blockImage("clear.png"),
|
|
"source_off":blockImage("clear.png"),
|
|
"label":"clear"
|
|
}
|
|
]
|
|
|
|
}
|
|
|
|
class Form(WidgetCSS, WidgetReady, BoxLayout):
|
|
cols = NumericProperty(None)
|
|
csscls=StringProperty('formcss')
|
|
input_css=StringProperty('formfieldcss')
|
|
inputwidth=NumericProperty(1)
|
|
inputheight=NumericProperty(3)
|
|
labelwidth=NumericProperty(0.3)
|
|
toolbar_at=OptionProperty('top', \
|
|
options=['top','bottom','left','right'])
|
|
dataloader=DictProperty(None)
|
|
fields = ListProperty([])
|
|
toolbar=DictProperty(None)
|
|
submit=DictProperty(None)
|
|
clear=DictProperty(None)
|
|
notoolbar=BooleanProperty(False)
|
|
def __init__(self, **options):
|
|
self.cols = 1
|
|
self.toolbar_w = None
|
|
if self.toolbar_at in ['top','bottom']:
|
|
options['orientation'] = 'vertical'
|
|
else:
|
|
options['orientation'] = 'horizontal'
|
|
SUPER(Form, self, options)
|
|
self.setup_cols_and_inputwidth()
|
|
self.init()
|
|
self.register_event_type('on_submit')
|
|
|
|
def setup_cols_and_inputwidth(self):
|
|
if isHandHold() and Window.width < Window.height:
|
|
self._cols = 1
|
|
self.input_width = 1
|
|
return
|
|
if self.cols is None and self.inputwidth is None:
|
|
self.input_width = 1
|
|
self._cols = 1
|
|
return
|
|
if self.inputwidth > 1:
|
|
self.input_width = CSize(self.inputwidth)
|
|
self._cols = -1 # auto calculate
|
|
return
|
|
self.input_width = self.inputwidth
|
|
self._cols = 1
|
|
|
|
def set_grid_attrs(self):
|
|
if self._cols == 1 and self.input_width <= 1:
|
|
self.input_width = self.width
|
|
self.fsc.box_width = self.input_width
|
|
|
|
def on_size(self, *args):
|
|
if not hasattr(self,'fsc'):
|
|
return
|
|
|
|
if not self.notoolbar:
|
|
if self.toolbar_at in ['top', 'bottom']:
|
|
self.fsc.height = self.height - self.toolbar_w.height
|
|
else:
|
|
self.fsc.width = self.width - self.toolbar_w.width
|
|
else:
|
|
if self.toolbar_at in ['top', 'bottom']:
|
|
self.fsc.height = self.height
|
|
else:
|
|
self.fsc.width = self.width
|
|
self.set_grid_attrs()
|
|
|
|
def init(self):
|
|
if not self.notoolbar:
|
|
desc = defaultToolbar()
|
|
desc1 = self.toolbar
|
|
tools = desc['tools'].copy()
|
|
if desc1:
|
|
desc.update(desc1)
|
|
tools = tools + desc1['tools']
|
|
if self.submit:
|
|
kw = self.submit.copy()
|
|
if kw.get('name'):
|
|
del kw['name']
|
|
for t in tools:
|
|
if t['name'] == '__submit':
|
|
t.update(kw)
|
|
if self.clear:
|
|
kw = self.clear.copy()
|
|
if kw.get('name'):
|
|
del kw['name']
|
|
for t in tools:
|
|
if t['name'] == '__clear':
|
|
t.update(kw)
|
|
|
|
desc['tools'] = tools
|
|
if self.toolbar_at in ['top', 'bottom']:
|
|
desc['toolbar_orient'] = 'H'
|
|
else:
|
|
desc['toolbar_orient'] = 'V'
|
|
desc['tool_orient'] = 'veritcal'
|
|
|
|
self.toolbar_w = Factory.Toolbar(**desc)
|
|
self.fsc = VResponsiveLayout(
|
|
box_width = self.input_width,
|
|
size_hint=(1,1)
|
|
)
|
|
|
|
if self.toolbar_at in ['top', 'left'] and self.toolbar_w:
|
|
self.add_widget(self.toolbar_w)
|
|
self.add_widget(self.fsc)
|
|
if self.toolbar_at in ['bottom', 'right'] and self.toolbar_w:
|
|
self.add_widget(self.toolbar_w)
|
|
|
|
self.fieldWidgets=[]
|
|
for f in self.fields:
|
|
w = InputBox(self, **f)
|
|
self.fsc.add_widget(w)
|
|
self.fieldWidgets.append(w)
|
|
w.bind(on_ready=self.makeInputLink)
|
|
wid = Factory.Blocks.getWidgetById('__submit',from_widget=self)
|
|
if wid:
|
|
wid.bind(on_press=self.on_submit_button)
|
|
wid = Factory.Blocks.getWidgetById('__clear',from_widget=self)
|
|
if wid:
|
|
wid.bind(on_press=self.on_clear_button)
|
|
if self.dataloader:
|
|
self.loader = DataGraber(**self.dataloader)
|
|
d = self.loader.load()
|
|
if d:
|
|
self.setValue(d)
|
|
self.on_size()
|
|
|
|
def makeInputLink(self,o,v=None):
|
|
self.readiedInput += 1
|
|
if self.readiedInput >= len(self.fields):
|
|
p = self.fieldWidgets[0]
|
|
for w in self.fieldWidgets[1:]:
|
|
p.input_widget.focus_next = w.input_widget
|
|
w.input_widget.focus_previous = p.input_widget
|
|
p = w
|
|
|
|
def setValue(self,d):
|
|
for f in self.fieldWidgets:
|
|
v = f.getValue()
|
|
for k in v.keys():
|
|
f.setValue({k:d[k]})
|
|
|
|
def getValue(self):
|
|
d = {}
|
|
for f in self.fieldWidgets:
|
|
v = f.getValue()
|
|
d.update(v)
|
|
return d
|
|
|
|
def checkData(self):
|
|
for w in self.fieldWidgets:
|
|
if not w.check():
|
|
w.input_widget.focus = True
|
|
Logger.info('kivyblcks: input check false')
|
|
return False
|
|
Logger.info('kivyblcks: input check success')
|
|
return True
|
|
|
|
def on_submit(self,o, v=None):
|
|
return False
|
|
|
|
def on_submit_button(self,o,v=None):
|
|
Logger.info('kivyblcks: submit button press')
|
|
if not self.checkData():
|
|
Logger.info('kivyblocks: CheckData False')
|
|
return
|
|
d = self.getValue()
|
|
Logger.info('kivyblocks: fire on_submit')
|
|
self.dispatch('on_submit',d)
|
|
|
|
def on_clear_button(self,o,v=None):
|
|
for fw in self.fieldWidgets:
|
|
fw.clear()
|
|
|
|
class StrSearchForm(BoxLayout):
|
|
def __init__(self,img_url=None,**options):
|
|
self.name = options.get('name','search_string')
|
|
BoxLayout.__init__(self,orientation='horizontal',size_hint_y=None,height=CSize(3))
|
|
self.input_css = options.get('input_css', 'input')
|
|
i18n = I18n()
|
|
self.input_widget = StrInput(
|
|
text='',
|
|
multiline=False,
|
|
csscls=self.input_css,
|
|
hint_text=i18n(options.get('tip',options.get('hint_text',''))),
|
|
allow_copy=True,
|
|
font_size=CSize(1),
|
|
size_hint_y=None,
|
|
size_hint_x=1,
|
|
height=3)
|
|
self.add_widget(self.input_widget)
|
|
self.register_event_type('on_submit')
|
|
v = options.get('value',options.get('default_value',''))
|
|
self.input_widget.setValue(v)
|
|
self.input_widget.bind(on_text_validate=self.submit_input)
|
|
|
|
def getValue(self):
|
|
d = {
|
|
self.name:self.input_widget.text
|
|
}
|
|
return d
|
|
|
|
def setValue(self, d):
|
|
if isinstance(d,str):
|
|
self.input_widget.text = d
|
|
if isinstance(d,{}):
|
|
self.input_widget.text = d.get(self.name,'')
|
|
|
|
def submit_input(self,o,v=None):
|
|
text = self.input_widget.text
|
|
if text != '':
|
|
d = {
|
|
self.name:text
|
|
}
|
|
self.dispatch('on_submit',d)
|
|
|
|
def on_submit(self,v=None):
|
|
pass
|