def __init__(self, retour_selection, titre, parent_scm,
dict_eleves_par_groupe, **kwargs):
self.titre = titre
self.retour_selection = retour_selection
self.parent_scm = parent_scm
self.dict_eleves = dict_eleves_par_groupe
self.dict_panneau_groupe = dict()
super(Formation, self).__init__(**kwargs)
for nom_groupe in self.dict_eleves.keys():
tb = TabbedPanelItem(text=nom_groupe)
panneaugr = PanneauGroupe(self.dict_eleves[nom_groupe],
nom_cours=titre)
self.dict_panneau_groupe[nom_groupe] = panneaugr
tb.add_widget(panneaugr)
self.nb.add_widget(tb)
fin = TabbedPanelItem(text='Terminer')
self.panfin = PanneauFinFormation(self.terminaison, self.recapitulatif)
fin.add_widget(self.panfin)
fin.bind(on_release=self.panfin.update)
self.nb.add_widget(fin)
self.panneau_fin = fin
retour = TabbedPanelHeader(text='Retour')
retour.bind(on_release=self.retour)
self.nb.add_widget(retour)
self.panneau_retour = retour
def _manip_sort(task, sort_type, *args):
sort_type = 'Asc' not in sort_type.text
from_address = task.from_address(task.tablenum, ':all', extended=True)
values, cols, rows, labels = from_address
# get separated cols to sort
chunks = []
for x in range(0, len(values), rows):
chunks.append(values[x:x + rows])
values = []
for val in chunks:
values.append(sorted(val, reverse=sort_type))
# add Table
table = task.ids.tablesel.text
table += ' (desc)' if sort_type else ' (asc)'
tabletab = TabbedPanelItem(text=table)
task.app.root.ids.tabpanel.add_widget(tabletab)
values = zip(*values)
values = [v for vals in values for v in vals]
task.app.root.tables.append((
table, task.tablecls(max_cols=cols, max_rows=rows,
pos=task.app.root.pos,
size=task.app.root.size,
values=values, labels=labels)
))
tabletab.content = task.app.root.tables[-1][1]
def addTab(self, name, obj):
th = TabbedPanelItem(text=name)
self.add_widget(th)
th.add_widget(obj)
th.background_down = "blue.jpeg"
print dir(th)
return th
def populate(self):
app = MDApp.get_running_app()
sub_panel = self.children[0]
for name, store in app.db.stores.items():
if name == 'default': # Duplicated store
default_store = store.name
continue
store_panel = TabbedPanelItem(text=name.capitalize())
sub_panel.add_widget(store_panel)
container = app.container_factory.get('map_locations', store)
container.store = store
items = set()
for location in store.locations.values():
for item in location.items:
if item:
item = app.db.items[item]
items.add((store, location, item))
# print(len(items))
container.generate_data(items)
container.to_layout()
store_panel.content = BoxLayout(orientation='vertical')
store_panel.content.add_widget(LocationMapHeader(container=container))
store_panel.content.add_widget(container.container_display)
for panel in sub_panel.tab_list:
# noinspection PyUnboundLocalVariable
if panel.text == default_store:
sub_panel.default_tab = panel
sub_panel.tab_width = MDApp.get_running_app().root.width / (len(app.db.stores) - 1)
def __init__(self):
App.__init__(self)
self.data = HymnData()
self.title = "Old-Line Primitive Baptist Hymn and Tune Book"
self.panel = TabbedPanel()
self.number_tab = TabbedPanelItem(text="By number")
self.panel.add_widget(self.number_tab)
self.set_up_number_tab()
self.panel.default_tab = self.number_tab
self.first_line_tab = TabbedPanelItem(text="By first line")
self.panel.add_widget(self.first_line_tab)
self.set_up_first_line_tab()
self.search_tab = TabbedPanelItem(text="Search")
self.panel.add_widget(self.search_tab)
self.set_up_search_tab()
self.about_tab = TabbedPanelItem(text="About")
self.panel.add_widget(self.about_tab)
self.set_up_about_tab()
def __init__(self, **kwargs):
super(PythonConsole, self).__init__(**kwargs)
self.console = ConsoleWidget(self)
tab1 = TabbedPanelItem(text="Console")
tab1.add_widget(self.console)
self.add_widget(tab1)
def __init__(self, **kwargs):
super(PythonConsole, self).__init__(**kwargs)
self.console = ConsoleWidget(self)
tab1 = TabbedPanelItem(text="Console")
tab1.add_widget(self.console)
self.add_widget(tab1)
def tabProbabilityTesting(self):
'''
tab containing plot of probability distributions from various user-specificed pools of dice
'''
self.plotColorMap = [
[1,0,0,1],
[0,1,0,1],
[0,0,1,1],
[1,1,0,1],
[1,0,1,1],
[0,1,1,1],
[1,1,1,1],
[0.75,0.75,0.75,1]]
tabProb = TabbedPanelItem(text = 'Prob. Plots')
self.statsMainLayout = BoxLayout(orientation = 'vertical')
self.entryLayout = BoxLayout(orientation = 'vertical',size_hint = (1,0.45))
buttonLayout = BoxLayout(size_hint = (1,0.05))
self.graphLayout = BoxLayout(size_hint = (1,0.5))
self.graph = Graph(xlabel='Value', ylabel='Counts',
x_ticks_minor=1,x_ticks_major=2, y_ticks_minor = 100, y_ticks_major=500,
y_grid_label=True, x_grid_label=True, padding=5,
x_grid=True, y_grid=True, xmin=-0, xmax=15, ymin=0,ymax = 5000)
self.graphLayout.add_widget(self.graph)
self.plotList = []
self.statsMainLayout.add_widget(self.entryLayout)
self.statsMainLayout.add_widget(buttonLayout)
self.statsMainLayout.add_widget(self.graphLayout)
self.testList = []
self.appendNewTest(self.entryLayout,readOnly = True)
self.testList.append(self.appendNewTest(self.entryLayout))
buttonList = [['Add New Test','Plot Results','Reset']]
buttonFunctionList = [[self.fireNewTestButton,self.firePlotButton,self.fireResetTestsButton]]
self.addButtons(buttonList,buttonFunctionList,buttonLayout)
tabProb.add_widget(self.statsMainLayout)
return tabProb
def finalize(self, *args):
assert not hasattr(self, '_finalized')
if not (
self.engine and self.toggle and self.character
):
Clock.schedule_once(self.finalize, 0)
return
self._tabs = TabbedPanel(do_default_tab=False)
for rb, txt in (
('character', 'character'),
('avatar', 'avatar'),
('character_thing', 'thing'),
('character_place', 'place'),
('character_portal', 'portal')
):
tab = TabbedPanelItem(text=txt)
setattr(self, '_{}_tab'.format(rb), tab)
box = RulesBox(
engine=self.engine,
rulebook=self._get_rulebook(rb),
entity=self.character,
toggle=self.toggle
)
tab.add_widget(box)
self._tabs.add_widget(tab)
self.add_widget(self._tabs)
self._finalized = True
def _manip_sort(task, sort_type, *args):
sort_type = 'Asc' not in sort_type.text
from_address = task.from_address(task.tablenum, ':all', extended=True)
values, cols, rows, labels = from_address
# get separated cols to sort
chunks = []
for x in range(0, len(values), rows):
chunks.append(values[x:x + rows])
values = []
for val in chunks:
values.append(sorted(val, reverse=sort_type))
# add Table
table = task.ids.tablesel.text
table += ' (desc)' if sort_type else ' (asc)'
tabletab = TabbedPanelItem(text=table)
task.app.root.ids.tabpanel.add_widget(tabletab)
values = list(zip(*values))
values = [v for vals in values for v in vals]
task.app.root.tables.append((table,
task.tablecls(max_cols=cols,
max_rows=rows,
pos=task.app.root.pos,
size=task.app.root.size,
values=values,
labels=labels)))
tabletab.content = task.app.root.tables[-1][1]
def change_data_set(self, new_dic):
liste_groupe = [{'text': nom_groupe} for nom_groupe in new_dic.keys()]
print('tododo:', liste_groupe)
current_groupes = self.dict_panneau_groupe.keys()
self.deja_enregistre = False
print('tadada:', new_dic.keys())
print(current_groupes)
for nom_groupe in current_groupes:
# Si le groupe n'est plus dans la liste
# il faut retirer le panneau
if nom_groupe not in new_dic:
# Mais d'abord il faut le retrouver !
tabbed = [
tb for tb in self.nb.get_tab_list()
if tb.text == nom_groupe
]
try:
del self.dict_panneau_groupe[nom_groupe]
except KeyError:
pass
if tabbed:
self.nb.remove_widget(tabbed[0])
for groupe in liste_groupe:
nom_groupe = groupe['text']
if not new_dic[nom_groupe]:
# Si c'est vide
continue
# Si le groupe n'existe pas, on crée le panneau et le rajoute
if not nom_groupe in current_groupes:
tb = TabbedPanelItem(text=nom_groupe)
panneaugr = PanneauGroupe(new_dic[nom_groupe],
nom_cours=self.titre)
self.dict_panneau_groupe[nom_groupe] = panneaugr
tb.add_widget(panneaugr)
# Parce qu'à la SNSM, on aime quand c'est bien fait!
self.nb.remove_widget(self.panneau_fin)
self.nb.remove_widget(self.panneau_retour)
self.nb.add_widget(tb)
self.nb.add_widget(self.panneau_fin)
self.nb.add_widget(self.panneau_retour)
else:
# Maintenant on gère les nouveaux élèves
nouveaux_eleves = [
eleve for eleve in new_dic[nom_groupe]
if not eleve in self.dict_eleves[nom_groupe]
]
rejetes = [
eleve for eleve in self.dict_eleves[nom_groupe]
if not eleve in new_dic[nom_groupe]
]
self.dict_eleves = dict(new_dic)
panneaugr = self.dict_panneau_groupe[nom_groupe]
for ne in nouveaux_eleves:
panneaugr.ajoute_nouvel_eleve(ne)
# Et on vire les autres
for mm in rejetes:
panneaugr.supprime_eleve(mm)
def getTabLayout(self, command):
tabItem = None
for child in self.root.tab_list:
if child.text == command.tabName:
return child.content
tabItem = TabbedPanelItem(text=command.tabName)
self.root.add_widget(tabItem)
tabItem.add_widget(BoxLayout(orientation='vertical', size_hint=(1, 1)))
return tabItem.content
def populate_tabs(self):
new_manager_tab = TabbedPanelItem(text='Tasks')
new_manager_tab.add_widget(self.new_manager)
# self.ids.tp.add_widget(events_tab)
self.ids.tp.add_widget(new_manager_tab)
# self.ids.tp.add_widget(stats_tab)
self.ids.tp.default_tab = new_manager_tab
def __init__(self, prjMaterials, *args, **kwargs): print(f"creating materials sliders...") super(AllMatPropTabbedPanel, self).__init__(*args, **kwargs) self._prjMaterials = prjMaterials for mat in prjMaterials.materials: tmp = TabbedPanelItem() tmp2 = MatPropPanel(mat) self.add_widget(tmp) tmp.text = mat.name tmp.add_widget(tmp2)
def button_options(self):
print("options pressed")
app = App.get_running_app()
cont = GridLayout(cols=1)
# retrieve audio outputs / soundcards from audioengine class
out_list = app.root.ae.get_outputs()
print(out_list)
# combine out_list, add to output selector
for x, y in zip(*out_list):
# intentional error to remember where left off
b = Button(id="{}".format(y), text="{} {}".format(x, y))
b.bind(on_press=self.audio_opts_button_callback)
cont.add_widget(b)
for x in self.children:
print(x)
tp = TabbedPanel(do_default_tab=False)
# audio tab
th_audio = TabbedPanelItem(text="Audio")
th_audio.content = GridLayout()
th_audio.add_widget(cont)
# files tab
th_files = TabbedPanelItem(text="Files")
th_files.add_widget(Button(text="files tab content"))
tp.add_widget(th_audio)
tp.add_widget(th_files)
popup = Popup(title='Options',
content=tp,
size_hint=(None, None),
size=(800, 800))
popup.open()
def _import_data(self, selection, *args):
'''Imports :ref:`sqlite` from path selected in ``Dialog`` and puts it
to :mod:`main.Table`.
.. versionadded:: 0.1.0
'''
# limit table name and column name to [a-zA-Z]
# CREATE TABLE test(
# Column INTEGER NOT NULL CHECK(
# typeof(Column) = 'integer'))
if not selection:
return
else:
selection = selection[0]
if '.sqlite' not in selection:
return
conn = sqlite3.connect(op.join(selection))
c = conn.cursor()
# get tables first!
c.execute("SELECT name FROM sqlite_master WHERE type='table'")
tables = [tab[0] for tab in c.fetchall()]
for table in tables:
c.execute("pragma table_info({0})".format(table))
table_info = c.fetchall()
labels = [lbl[1] for lbl in table_info]
# allow only: INTEGER, REAL, TEXT
try:
types = [type[2][0] for type in table_info]
except IndexError:
error = ErrorPop(msg='Bad file: No defined types in columns!')
error.open()
return
tabletab = TabbedPanelItem(text=table)
self.ids.tabpanel.add_widget(tabletab)
c.execute('select * from {0}'.format(table))
values = [item for item in c.fetchone()]
max_cols = len(values)
values += [item for sublist in c.fetchall() for item in sublist]
max_rows = int(math.ceil(len(values) / float(max_cols)))
self.tables.append((table,
Table(max_cols=max_cols,
max_rows=max_rows,
pos=self.pos,
size=self.size,
values=values,
labels=labels)))
tabletab.content = self.tables[-1][1]
self.opendlg.dismiss()
conn.close()
def open_file(self, document):
"""
:type document: doxing.client.data_model.document.DocumentDTO
"""
# TODO: prevent double openning same file
opened_file = TabbedPanelItem()
opened_file.text = document.name
opened_file.add_widget(
TextFileEditor(ctxt=self._ctxt, document=document))
self.add_widget(opened_file)
self.switch_to(opened_file)
def build(self):
root = BoxLayout()
root = TabbedPanel(do_default_tab=False)
root.tab_width = 200
self.load("default.xml")
self.wips_container = WipContainer(self,
self.wips,
orientation="vertical",
size_hint_y=None,
height=1200,
minimum_height=200)
queue_scroll = ScrollView(bar_width=20)
queue_scroll.add_widget(self.wips_container)
tab = TabbedPanelItem(text="queue")
tab.add_widget(queue_scroll)
root.add_widget(tab)
tab = TabbedPanelItem(text="settings")
self.setting_container = SettingContainer(self)
tab.add_widget(self.setting_container)
self.setting_container.update_widgets()
root.add_widget(tab)
self.check_for_projects()
self.load_xml_files()
Clock.schedule_interval(lambda x: self.check_for_projects(), 10)
return root
def __init__(self, screenmanager, **kwargs):
super(GraphScreen, self).__init__(**kwargs)
#Set screenmanager
sm = screenmanager
#Set master layout
layout = BoxLayout(spacing=10)
#Create tabpanel
tabs = TabbedPanel()
#Add tabs
speedTab = TabbedPanelItem(text='Speed')
speedTab.content = Label(text='Speed')
backTab = TabbedPanelItem(text='Back')
tabs.add_widget(speedTab)
tabs.add_widget(backTab)
layout.add_widget(tabs)
self.add_widget(layout)
def build(self):
self.availablePorts = listSerialPorts()
if len(self.availablePorts) == 0:
self.availablePorts.append("----")
tabbedPannel = TabbedPanel(do_default_tab=False)
# Connection Tab
self.connectionTab = TabbedPanelItem(text="Connection")
self.layout1 = BoxLayout(orientation='vertical', spacing=10, padding=(200, 200))
self.connectionTab.add_widget(self.layout1)
self.lblSerialSettings = Label(text="Connection settings")
self.layout1.add_widget(self.lblSerialSettings)
self.dlBaudrate = Spinner(values = ["57600", "115200", "230400", "460800", "921600"],
text = "115200")
self.layout1.add_widget(self.dlBaudrate)
self.dlPort = Spinner(values = self.availablePorts,
text = self.availablePorts[0])
self.layout1.add_widget(self.dlPort)
self.btnConnect = Switch()
self.btnConnect.bind(active = self.connect)
self.layout1.add_widget(self.btnConnect)
# Graph tab
self.graphTab = TabbedPanelItem(text = "Graph")
# self.layout2 = BoxLayout(orientation='vertical', spacing=10, padding=(200, 200))
# self.graphTab.add_widget(self.layout2)
graph = Graph(xlabel='X', ylabel='Y', x_ticks_minor=5,
x_ticks_major=25, y_ticks_major=1,
y_grid_label=True, x_grid_label=True, padding=5,
x_grid=True, y_grid=True, xmin=-0, xmax=100, ymin=-1, ymax=1)
plot = MeshLinePlot(color=[1, 1, 0, 1])
plot.points = [(x, sin(x / 10.)) for x in range(0, 101)]
graph.add_plot(plot)
self.graphTab.add_widget(graph)
tabbedPannel.add_widget(self.connectionTab)
tabbedPannel.add_widget(self.graphTab)
return tabbedPannel
class ListaCheltuieliPanel(TabbedPanelItem):
updateState = ''
lista = TabbedPanelItem(text='Lista cheltuieli')
bigView = StackLayout(orientation='rl-tb')
top_buttons = GridLayout(cols=2,
row_default_height=40,
size_hint=(1, None),
height=40)
db_entries = DBEntries(cols=2)
scroll = ScrollView(size_hint=(1, None),
size=(Window.width, Window.height - 126))
def updateByButton(self, button):
if (self.updateState != button[0].lower() + button[1:] + "_ASC"):
self.updateState = button[0].lower() + button[1:] + "_ASC"
else:
self.updateState = button[0].lower() + button[1:] + "_DESC"
self.updateView()
def updateView(self):
self.db_entries.clear_widgets()
db = getConnection()
cur = db.cursor()
if (self.updateState == ''):
cur.execute("SELECT * FROM cheltuieli;")
for row in cur.fetchall():
for col in row[1:]:
self.db_entries.add_widget(SpendingsLabel(text=str(col)))
else:
cur.execute("SELECT * FROM cheltuieli ORDER BY " +
self.updateState[0:4] + " " + self.updateState[5:] +
";")
for row in cur.fetchall():
for col in row[1:]:
self.db_entries.add_widget(SpendingsLabel(text=str(col)))
self.db_entries.add_widget(TotalLabel(text='Total'))
cur.execute("SELECT SUM(suma) FROM cheltuieli;")
self.db_entries.add_widget(TotalLabel(text=str(cur.fetchall()[0][0])))
def __init__(self):
self.top_buttons.add_widget(
Button(on_press=lambda btn: self.updateByButton(btn.text),
text='Suma'))
self.top_buttons.add_widget(
Button(on_press=lambda btn: self.updateByButton(btn.text),
text='Data'))
self.updateView()
self.bigView.add_widget(
RefreshButton(on_press=lambda btn: self.updateView(),
text='',
size_hint=(None, None),
height=40,
width=40))
self.bigView.add_widget(self.top_buttons)
self.bigView.add_widget(self.db_entries)
self.lista.add_widget(self.bigView)
def prod_menu(build_place):
scatter = ScatterLayout()
menu = MenuLayout()
inside_menu = InsideMenuLayout()
main_box = BoxLayout(orientation='horizontal')
left_box = BoxLayout(orientation='vertical', size_hint_x=.35)
right_box = BoxLayout(size_hint_x=.65)
icon_bottom_box = BoxLayout(size_hint=(.9, .8))
icon_layout = BoxLayout(size_hint_y=.4) # pos_hint=({'top': 1})
statistic_grid = GridLayout(cols=1,
size_hint_y=None,
pos_hint=({
'top': .9
}),
spacing=10,
padding=5)
for r in config.resources:
res = config.resources[r]
stat_box = BoxLayout(orientation='horizontal',
height=40,
size_hint_y=None)
stat_box.add_widget(Image(source=res[2], size_hint_x=.2))
stat_box.add_widget(Label(text=f'{res[0]}', size_hint_x=.8))
statistic_grid.add_widget(stat_box)
tb = TabbedPanel(do_default_tab=False, tab_width=130)
ti = TabbedPanelItem(text='Улучшения')
ti.content = prod_upgrade_content()
tb.add_widget(ti)
tb.add_widget(TabbedPanelItem(text='Автоматизация'))
tb.add_widget(TabbedPanelItem(text='Статистика'))
icon_bottom_box.add_widget(statistic_grid)
icon_layout.add_widget(Image(source='data/images/buildings/buildings.zip'))
left_box.add_widget(icon_layout)
left_box.add_widget(icon_bottom_box)
right_box.add_widget(tb)
main_box.add_widget(left_box)
main_box.add_widget(right_box)
inside_menu.add_widget(main_box)
close_b = CloseMenuButton(build_place, scatter)
menu.add_widget(inside_menu)
menu.add_widget(close_b)
scatter.add_widget(menu)
return scatter
def buildTab(self):
self.background_image = "images/gui_elements/tab_darkblue.png"
with open("config/blocks.json") as json_data:
blocks_config = json.load(json_data)
for tab in blocks_config["tabs"]:
#newTab = TabbedPanelItem(text = str(tab["id"]))
block_type = str(tab["id"])[0]
newTab = TabbedPanelItem()
color_tab = []
for color in tab["rgba"]:
color_tab.append(color)
newTab.background_color = color_tab
newLayout = StackLayout(spacing=10)
for block in tab["blocks"]:
newBlock = Block(block_type, str(block["id"]),
str(block["source"]))
newLayout.add_widget(newBlock)
newTab.content = newLayout
self.add_widget(newTab)
def build(self):
self.GabrielPage = FloatLayout()
self.EditPage = FloatLayout()
self.SettingsPage = FloatLayout()
self.MainMenu = TabbedPanel(background_color=(1, 1, 1, 1),
default_tab_text='Габриэль',
default_tab_content=self.GabrielPage)
self.EditMenu = TabbedPanelItem(text='Edit')
self.SettingsMenu = TabbedPanelItem(text='Settings')
self.MainMenu.add_widget(self.EditMenu)
self.MainMenu.add_widget(self.SettingsMenu)
self.In_GabrielPage()
self.In_EditPage()
self.In_SettingsPage()
return self.MainMenu
def createInfoTab(stringDict, tabName):
tab = TabbedPanelItem()
tab.name = tabName
tab.text = stringDict[tabName]["Title"]
titleText = Label(text=stringDict[tabName]["Title"])
bodyText = Label(text=stringDict[tabName]["Body"])
tab.add_widget(titleText)
tab.add_widget(bodyText)
return tab
def __init__(self, **kwargs):
super(BandLay, self).__init__(**kwargs)
self.tab_item = TabbedPanel()
self.tab_item.do_default_tab = False
self.tab_item.tab_height = 20
list_bands = []
if site.equipment == 'ADU06':
list_bands = ['A', 'B', 'F', 'C', 'D']
elif site.equipment == 'ADU07':
list_bands = ['65536H', '4096H', '128H', '4H']
for band in list_bands:
tab_item = TabbedPanelItem()
tab_item.text = band
self.tab_item.add_widget(tab_item)
list_file_pplt = self.search_pplt_file(band)
site.files_plot[band] = list_file_pplt
self.grid_lay = ScrollBox()
i = 0
for file_pplt_select in site.files_plot[band]:
self.grid_lay.ids.grid.add_widget(file_pplt_select)
print(file_pplt_select.obj_pplt.name)
i += 1
if band == '65536H' or band == '4096H':
self.grid_lay.ids.grid.size_hint_x = None
self.grid_lay.ids.grid.width = int(i / 3 * 300)
else:
self.grid_lay.ids.grid.size_hint_x = None
self.grid_lay.ids.grid.width = int(i/3 * 250)
tab_item.add_widget(self.grid_lay)
self.add_widget(self.tab_item)
print(project.path_file_ppmt)
def __init__(self, publicationsView, friendsView, aboutView,
activityFeedView, **kwargs):
"""
Panneau d'onglets contenant (dans chaque onglet):
- L'espace de publication
- Les amis/demandes d'ami
- Les informations personnelles de l'utilisateur
- Le fil d'actualité
:param publicationsView: Les publications
:type publicationsView: PublicationsWidget
:param friendsView: Les amis
:type friendsView: FriendsWidget
:param aboutView: Les information personnelles
:type aboutView: AboutWidget
:param activityFeedView: Le fil d'actualité
:type activityFeedView: ActivityFeedWidget
:param kwargs: Arguments clé/valeur de la classe parente
"""
super(ProfileTabbedPanel, self).__init__(**kwargs)
# La taille des onglets s'adapte à la taille disponible
self._tab_layout.padding = [0, 0, 0, '-2dp']
self.bind(size=self.resizeTabs)
# L'onglet des publications (il faut utiliser l'onglet par défaut)
self.default_tab_text = "Wall"
self.default_tab_content = publicationsView
# L'onglet des amis/demandes d'ami
self.friendsViewTab = TabbedPanelItem(text="Friends",
content=friendsView)
# L'onglet des informations personnelles
self.aboutViewTab = TabbedPanelItem(text="About", content=aboutView)
# L'onglet du fil d'actualité
self.activityFeedViewTab = TabbedPanelItem(text="Feed",
content=activityFeedView)
self.add_widget(self.friendsViewTab)
self.add_widget(self.aboutViewTab)
def build(self):
container = super().build()
panel = TabbedPanelItem(text="Starcraft 2 Launcher")
self.mission_panel = panel.content = MissionLayout()
self.tabs.add_widget(panel)
Clock.schedule_interval(self.build_mission_table, 0.5)
return container
def finalize(self, *args):
assert not hasattr(self, '_finalized')
if not (self.engine and self.toggle and self.character):
Clock.schedule_once(self.finalize, 0)
return
self._tabs = TabbedPanel(do_default_tab=False)
for rb, txt in (('character', 'character'), ('avatar', 'avatar'),
('character_thing',
'thing'), ('character_place',
'place'), ('character_portal', 'portal')):
tab = TabbedPanelItem(text=txt)
setattr(self, '_{}_tab'.format(rb), tab)
box = RulesBox(engine=self.engine,
rulebook=self._get_rulebook(rb),
entity=self.character,
toggle=self.toggle)
tab.add_widget(box)
self._tabs.add_widget(tab)
self.add_widget(self._tabs)
self._finalized = True
def test_tabbed_panel():
app = App.get_running_app()
app.step_1 = False
container = default_container()
instructions = Label(text='Press the button on the next tab, then press Submit.')
tab_btn = FocusButton(text='Press me first')
submit_btn = FocusButton(text='Submit', size_hint_y=0.1)
inner_container = default_container()
ignore_btn = FocusButton(text='Ignore me')
inner_container.add_widget(instructions)
inner_container.add_widget(ignore_btn)
tp = FocusTabbedPanel()
tp.default_tab_content = inner_container
item = TabbedPanelItem(text='Go here')
item.add_widget(tab_btn)
tp.add_widget(item)
def press_ignore(*args): # Auto fail
app.stop()
def press_step_1(*args):
app.step_1 = True
def submit(*args):
if app.step_1:
app.did_action = True
app.stop()
ignore_btn.bind(on_press=press_ignore)
tab_btn.bind(on_press=press_step_1)
submit_btn.bind(on_press=submit)
container.add_widget(tp)
container.add_widget(submit_btn)
app.root.add_widget(container)
return True
def __init__(self, **kwargs):
super(BandLay, self).__init__(**kwargs)
self.tab_item = TabbedPanel()
self.tab_item.do_default_tab = False
self.tab_item.tab_height = 20
list_bands = []
if site.equipment == 'ADU06':
list_bands = ['A', 'B', 'F', 'C', 'D']
elif site.equipment == 'ADU07':
list_bands = ['65536H', '4096H', '128H', '4H']
for band in list_bands:
tab_item = TabbedPanelItem()
tab_item.text = band
self.tab_item.add_widget(tab_item)
list_file_pplt = self.search_pplt_file(band)
site.files_plot[band] = list_file_pplt
self.grid_lay = ScrollBox()
i = 0
for file_pplt_select in site.files_plot[band]:
self.grid_lay.ids.grid.add_widget(file_pplt_select)
print(file_pplt_select.obj_pplt.name)
i += 1
if band == '65536H' or band == '4096H':
self.grid_lay.ids.grid.size_hint_x = None
self.grid_lay.ids.grid.width = int(i / 3 * 300)
else:
self.grid_lay.ids.grid.size_hint_x = None
self.grid_lay.ids.grid.width = int(i / 3 * 250)
tab_item.add_widget(self.grid_lay)
self.add_widget(self.tab_item)
print(project.path_file_ppmt)
def buildTab(self, size):
self.background_image = "images/gui_elements/tab.png"
with open("config/blocks.json") as json_data:
blocks_config = json.load(json_data)
for tab in blocks_config["tabs"]:
block_id = tab["id"][0]
newTab = TabbedPanelItem()
newTab.background_normal = str(tab["tab_unpress"])
newTab.background_down = str(tab["tab_press"])
newLayout = BoxLayout(spacing=10)
space = size * 0.80 / self.size[0]
newLayout.size_hint = [len(tab["blocks"]) * space, 1]
for block in tab["blocks"]:
if '0' not in block["type"]:
newBlock = Block(block_id, str(block["id"]),
str(block["type"]),
str(block["source"]),
int(size * 0.80))
newLayout.add_widget(newBlock)
newTab.content = newLayout
self.add_widget(newTab)
def build_play_screen(self):
play_screen = Screen(name='play')
self.sm.add_widget(play_screen)
tab_names = self.layout_names
self.layouts = {}
tb_panel = TabbedPanel(do_default_tab=False,
tab_width=Window.width / len(tab_names))
play_screen.add_widget(tb_panel)
for layout_name in self.layout_names:
layout = BoxLayout(orientation='vertical')
self.layouts[layout_name] = layout
self.add_audio_to_layout(layout_name)
tabitem = TabbedPanelItem(text=layout_name)
tabitem.add_widget(layout)
tb_panel.add_widget(tabitem)
return
def __init__(self, **kwargs):
super(MainBody, self).__init__(**kwargs)
self.do_default_tab = False
self.tab_height = 50
self.tab_width = 125
self.tab1 = TabbedPanelItem(text="Cutting Speed")
self.tab2 = TabbedPanelItem(text="Toolpath Angle")
self.tab3 = TabbedPanelItem(text="Material Removal")
self.tab4 = TabbedPanelItem(text="RA")
self.tab5 = TabbedPanelItem(text="R Edge Feed")
self.tab6 = TabbedPanelItem(text="Tolerance")
self.cuttingdata()
self.helix_angle()
self.material_removal()
self.surface_roughness()
self.round_edge()
self.midpoint()
self.add_widget(self.tab1)
self.add_widget(self.tab2)
self.add_widget(self.tab3)
self.add_widget(self.tab4)
self.add_widget(self.tab5)
self.add_widget(self.tab6)
self.default_tab = self.tab1
def main_base_menu(build_place):
scatter = ScatterLayout()
menu = building.MenuLayout()
inside_menu = building.InsideMenuLayout()
main_box = BoxLayout(orientation='horizontal')
left_box = BoxLayout(orientation='vertical', size_hint_x=.35)
right_box = BoxLayout(size_hint_x=.65)
icon_bottom_box = BoxLayout(size_hint=(.9, .8))
icon_layout = BoxLayout(size_hint_y=.4) # pos_hint=({'top': 1})
# Вывод производства ресурсов
stat_res = res_generation('main_base')
# Добавление вкладок Здания
tb = TabbedPanel(do_default_tab=False, tab_width=130)
base_e = TabbedPanelItem(text='Энергия')
base_e.content = base_energy()
base_f = TabbedPanelItem(text='Пища')
base_f.content = base_food()
tb.add_widget(base_e)
tb.add_widget(base_f)
icon_bottom_box.add_widget(stat_res)
icon_layout.add_widget(Image(source='data/images/buildings/main-base.png'))
left_box.add_widget(icon_layout)
left_box.add_widget(icon_bottom_box)
right_box.add_widget(tb)
main_box.add_widget(left_box)
main_box.add_widget(right_box)
inside_menu.add_widget(main_box)
close_b = building.CloseMenuButton(build_place, scatter)
menu.add_widget(inside_menu)
menu.add_widget(close_b)
scatter.add_widget(menu)
return scatter
def __init__(self, nr, table, **kwargs):
TabbedPanelItem.__init__(self, **kwargs)
self.text = "Poziom {n}".format(n=nr)
# Layout
box = BoxLayout(orientation="vertical")
self.add_widget(box)
# Elementy
box.add_widget(InfoLabel(text="Najlepszy wynik:", size_hint_y=0.1, font_name=DEFAULT_FONT))
box.add_widget(BestScoreLabel(best=DataBase.get_best_score(table, nr), size_hint_y=0.3))
box.add_widget(InfoLabel(text="Ostatnich {c}:".format(c=RECENT_COUNT), size_hint_y=0.1, font_name=DEFAULT_FONT))
th = BoxLayout(orientation="horizontal", size_hint_y=0.15, spacing=1)
th.add_widget(HeaderLabel(text="Data", size_hint_x=0.3))
th.add_widget(HeaderLabel(text="Godzina", size_hint_x=0.3))
th.add_widget(HeaderLabel(text="Uzyskany wynik"))
box.add_widget(th)
converter = lambda row_index, row: {
'size_hint_y': None,
'height': 40,
'cls_dicts': [
{'cls': RowLabel, 'kwargs': {'i': row_index, 'text': row.date, 'size_hint_x': 0.3} },
{'cls': RowLabel, 'kwargs': {'i': row_index, 'text': row.time, 'size_hint_x': 0.3} },
{'cls': RowLabel, 'kwargs': {'i': row_index, 'text': row.score, 'font_size': 20} },
]
}
adapter = DictAdapter(
sorted_keys=range(RECENT_COUNT + 1),
args_converter=converter,
data={i: r for i, r in enumerate(DataBase.get_recent_scores(table, nr, RECENT_COUNT))},
cls=CompositeListItem
)
box.add_widget(ListView(adapter=adapter))
def __init__(self, **kwargs):
super(Tab_panel, self).__init__(**kwargs)
self.pirveli_tab = TabbedPanelItem(text="შესავსები ბლანკი",
font_name="bpg_arial_2009",
font_size=20)
Window.bind(on_resize=self.window_size_changed)
self.tab_width = Window.width / 2.27
self.tab_height = Window.height / 11.76
self.tab_pos = "top_right"
self.default_tab_text = "Registration"
self.background_image = 'background1.png'
self.add_widget(self.pirveli_tab)
self.mama = Mama_lay()
self.pirovneba = pirovneba_box()
self.default_tab_content = self.pirovneba
self.pirveli_tab.add_widget(self.mama)
self.switch_button = Button(text="შემდეგი",
font_name="bpg_arial_2009",
font_size=20)
self.switch_button.bind(on_release=self.next_tab_func)
self.pirovneba.person_box.add_widget(self.switch_button)
class MainBox(BoxLayout):
'''
Mainbox class
'''
def __init__(self, **kwargs):
'''
Init main class ui
'''
super(MainBox, self).__init__(**kwargs)
self.f_size = '15sp'
# Shape Widget
self.shape = Shape(size_hint=(0.7, 1))
self.add_widget(self.shape)
# Right Menu
self.panel = TabbedPanel(size_hint=(0.3, 1), do_default_tab=False)
self.tab_param = TabbedPanelItem(text='Parameters')
self.tab_color = TabbedPanelItem(text='Shape')
self.tab_color_bg = TabbedPanelItem(text='Background')
self.tab_export = TabbedPanelItem(text='Export')
self.panel.add_widget(self.tab_param)
self.panel.add_widget(self.tab_color)
self.panel.add_widget(self.tab_color_bg)
self.panel.add_widget(self.tab_export)
self.menu_right = RightMenu(
padding=15,
orientation="vertical")
# Switch mode line
self.box_switch = BoxLayout(orientation='horizontal')
self.mode_label = Label(
text="Line mode",
font_size=self.f_size,
markup=True)
self.box_switch.add_widget(self.mode_label)
self.switch_mode = Switch(active=False)
self.switch_mode.bind(active=self.on_switch)
self.box_switch.add_widget(self.switch_mode)
self.menu_right.add_widget(self.box_switch)
# Size value
self.box_size = BoxLayout(orientation='horizontal')
self.size_label = Label(
text="Shape size",
font_size=self.f_size,
markup=True)
self.size_label_value = Label(
text=str(self.shape.shape_size),
font_size=self.f_size,
markup=True)
self.box_size.add_widget(self.size_label)
self.box_size.add_widget(self.size_label_value)
self.slider_shape_size = Slider(
min=self.shape.property('shape_size').get_min(self.shape),
max=self.shape.property('shape_size').get_max(self.shape),
value=self.shape.shape_size, step=1)
self.slider_shape_size.bind(value=self.change_shape_size)
self.menu_right.add_widget(self.box_size)
self.menu_right.add_widget(self.slider_shape_size)
# Width point or line
self.box_stroke = BoxLayout(orientation='horizontal')
self.wdth_label = Label(
text="Stroke width",
font_size=self.f_size,
markup=True)
self.wdth_label_value = Label(
text=str(self.shape.wdth),
font_size=self.f_size,
markup=True)
self.box_stroke.add_widget(self.wdth_label)
self.box_stroke.add_widget(self.wdth_label_value)
self.slider_wdth = Slider(
min=self.shape.property('wdth').get_min(self.shape),
max=self.shape.property('wdth').get_max(self.shape),
value=self.shape.wdth, step=1)
self.slider_wdth.bind(value=self.change_wdth)
self.menu_right.add_widget(self.box_stroke)
self.menu_right.add_widget(self.slider_wdth)
# a value
self.box_a = BoxLayout(orientation='horizontal')
self.a_label = Label(
text="Param a ",
font_size=self.f_size,
markup=True)
self.a_label_value = Label(
text=str(self.shape.a),
font_size=self.f_size,
markup=True)
self.box_a.add_widget(self.a_label)
self.box_a.add_widget(self.a_label_value)
self.slider_a = Slider(
min=self.shape.property('a').get_min(self.shape),
max=self.shape.property('a').get_max(self.shape),
value=self.shape.a)
self.slider_a.bind(value=self.change_a)
self.menu_right.add_widget(self.box_a)
self.menu_right.add_widget(self.slider_a)
# b value
self.box_b = BoxLayout(orientation='horizontal')
self.b_label = Label(
text="Param b ",
font_size=self.f_size,
markup=True)
self.b_label_value = Label(
text=str(self.shape.b),
font_size=self.f_size,
markup=True)
self.box_b.add_widget(self.b_label)
self.box_b.add_widget(self.b_label_value)
self.slider_b = Slider(
min=self.shape.property('b').get_min(self.shape),
max=self.shape.property('b').get_max(self.shape),
value=self.shape.b)
self.slider_b.bind(value=self.change_b)
self.menu_right.add_widget(self.box_b)
self.menu_right.add_widget(self.slider_b)
# m value
self.box_m = BoxLayout(orientation='horizontal')
self.m_label = Label(
text="Param m ",
font_size=self.f_size,
markup=True)
self.m_label_value = Label(
text=str(self.shape.m),
font_size=self.f_size,
markup=True)
self.box_m.add_widget(self.m_label)
self.box_m.add_widget(self.m_label_value)
self.slider_m = Slider(
min=self.shape.property('m').get_min(self.shape),
max=self.shape.property('m').get_max(self.shape),
value=self.shape.m)
self.slider_m.bind(value=self.change_m)
self.menu_right.add_widget(self.box_m)
self.menu_right.add_widget(self.slider_m)
# n1 value
self.box_n1 = BoxLayout(orientation='horizontal')
self.n1_label = Label(
text="Param n1 ",
font_size=self.f_size,
markup=True)
self.n1_label_value = Label(
text=str(self.shape.n1),
font_size=self.f_size,
markup=True)
self.box_n1.add_widget(self.n1_label)
self.box_n1.add_widget(self.n1_label_value)
self.slider_n1 = Slider(
min=self.shape.property('n1').get_min(self.shape),
max=self.shape.property('n1').get_max(self.shape),
value=self.shape.n1)
self.slider_n1.bind(value=self.change_n1)
self.menu_right.add_widget(self.box_n1)
self.menu_right.add_widget(self.slider_n1)
# n2 value
self.box_n2 = BoxLayout(orientation='horizontal')
self.n2_label = Label(
text="Param n2 ",
font_size=self.f_size,
markup=True)
self.n2_label_value = Label(
text=str(self.shape.n2),
font_size=self.f_size,
markup=True)
self.box_n2.add_widget(self.n2_label)
self.box_n2.add_widget(self.n2_label_value)
self.slider_n2 = Slider(
min=self.shape.property('n2').get_min(self.shape),
max=self.shape.property('n2').get_max(self.shape),
value=self.shape.n2)
self.slider_n2.bind(value=self.change_n2)
self.menu_right.add_widget(self.box_n2)
self.menu_right.add_widget(self.slider_n2)
# n3 value
self.box_n3 = BoxLayout(orientation='horizontal')
self.n3_label = Label(
text="Param n3 ",
font_size=self.f_size,
markup=True)
self.n3_label_value = Label(
text=str(self.shape.n3),
font_size=self.f_size,
markup=True)
self.box_n3.add_widget(self.n3_label)
self.box_n3.add_widget(self.n3_label_value)
self.slider_n3 = Slider(
min=self.shape.property('n3').get_min(self.shape),
max=self.shape.property('n3').get_max(self.shape),
value=self.shape.n3)
self.slider_n3.bind(value=self.change_n3)
self.menu_right.add_widget(self.box_n3)
self.menu_right.add_widget(self.slider_n3)
# Nb points
self.box_nbp = BoxLayout(orientation='horizontal')
self.nbp_label = Label(
text="Points number ",
font_size=self.f_size,
markup=True)
self.nbp_label_value = Label(
text=str(self.shape.nbp),
font_size=self.f_size,
markup=True)
self.box_nbp.add_widget(self.nbp_label)
self.box_nbp.add_widget(self.nbp_label_value)
self.slider_nbp = Slider(
min=self.shape.property('nbp').get_min(self.shape),
max=self.shape.property('nbp').get_max(self.shape),
value=self.shape.nbp, step=2)
self.slider_nbp.bind(value=self.change_nbp)
self.menu_right.add_widget(self.box_nbp)
self.menu_right.add_widget(self.slider_nbp)
# Percent
self.box_percent = BoxLayout(orientation='horizontal')
self.percent_label = Label(
text="Percent ",
font_size=self.f_size,
markup=True)
self.percent_label_value = Label(
text=str(self.shape.percent),
font_size=self.f_size,
markup=True)
self.box_percent.add_widget(self.percent_label)
self.box_percent.add_widget(self.percent_label_value)
self.slider_percent = Slider(
min=self.shape.property('percent').get_min(self.shape),
max=self.shape.property('percent').get_max(self.shape),
value=self.shape.percent, step=1)
self.slider_percent.bind(value=self.change_percent)
self.menu_right.add_widget(self.box_percent)
self.menu_right.add_widget(self.slider_percent)
# Travel
self.box_travel = BoxLayout(orientation='horizontal')
self.travel_label = Label(
text="Travel ",
font_size=self.f_size,
markup=True)
self.travel_label_value = Label(
text=str(self.shape.travel),
font_size=self.f_size,
markup=True)
self.box_travel.add_widget(self.travel_label)
self.box_travel.add_widget(self.travel_label_value)
self.slider_travel = Slider(
min=self.shape.property('travel').get_min(self.shape),
max=self.shape.property('travel').get_max(self.shape),
value=self.shape.travel, step=2)
self.slider_travel.bind(value=self.change_travel)
self.menu_right.add_widget(self.box_travel)
self.menu_right.add_widget(self.slider_travel)
# ColorPicker for Shape
self.picker = ColorPicker()
self.picker.bind(color=self.on_color)
# ColorPicker for background
self.picker_bg = ColorPicker()
self.picker_bg.bind(color=self.on_color_bg)
# Export svg button
self.export_button = Button(text='Export', size_hint=(1, 0.15))
self.export_button.bind(on_press=self.export)
# Tab packs
self.tab_param.add_widget(self.menu_right)
self.tab_color.add_widget(self.picker)
self.tab_color_bg.add_widget(self.picker_bg)
self.tab_export.add_widget(self.export_button)
self.add_widget(self.panel)
# Popups
self.pop_export = Popup(
title="Export file",
content=Label(text="File exported"),
size_hint=(None, None),
size=(640, 240))
def change_wdth(self, *args):
'''
Change stroke width
'''
self.shape.wdth = self.slider_wdth.value
self.wdth_label_value.text = str(self.slider_wdth.value)
def on_switch(self, *args):
'''
Switch mode line or point
'''
self.shape.line = self.switch_mode.active
def on_color(self, *args):
'''
Shape color
'''
self.shape.color = self.picker.hex_color
def on_color_bg(self, *args):
'''
Shape background color
'''
self.shape.bg_color = self.picker_bg.hex_color
def change_shape_size(self, *args):
'''
Shape size
'''
self.shape.shape_size = self.slider_shape_size.value
self.size_label_value.text = str(self.slider_shape_size.value)
def change_a(self, *args):
'''
a value
'''
self.shape.a = self.slider_a.value
self.a_label_value.text = str(self.slider_a.value)
def change_b(self, *args):
'''
b value
'''
self.shape.b = self.slider_b.value
self.b_label_value.text = str(self.slider_b.value)
def change_m(self, *args):
'''
m value
'''
self.shape.m = self.slider_m.value
self.m_label_value.text = str(self.slider_m.value)
def change_n1(self, *args):
'''
n1 value
'''
self.shape.n1 = self.slider_n1.value
self.n1_label_value.text = str(self.slider_n1.value)
def change_n2(self, *args):
'''
n2 value
'''
self.shape.n2 = self.slider_n2.value
self.n2_label_value.text = str(self.slider_n2.value)
def change_n3(self, *args):
'''
n3 value
'''
self.shape.n3 = self.slider_n3.value
self.n3_label_value.text = str(self.slider_n3.value)
def change_nbp(self, *args):
'''
point number
'''
self.shape.nbp = self.slider_nbp.value
self.nbp_label_value.text = str(self.slider_nbp.value)
def change_percent(self, *args):
'''
Percent value
'''
self.shape.percent = self.slider_percent.value
self.percent_label_value.text = str(self.slider_percent.value)
def change_travel(self, *args):
'''
Travel number
'''
self.shape.travel = self.slider_travel.value
self.travel_label_value.text = str(self.slider_travel.value)
def export(self, *args):
'''
Export to svg file
'''
document = svgwrite.Drawing(filename='export.svg', debug=True)
tmp = [(float("%.4g" % e)) for e in self.shape.path]
# Export polygon
if self.shape.line:
svg_path = coupled(tmp)
document.add(document.polygon(points=svg_path))
else: # Export points
svg_path = coupled(coupled(tmp))
for elem in svg_path:
document.add(document.line(
start=elem[0],
end=elem[1]
))
document.save()
self.shape.export_to_png('export.png')
self.pop_export.open()
def __init__(self, **kwargs):
'''
Init main class ui
'''
super(MainBox, self).__init__(**kwargs)
self.f_size = '15sp'
# Shape Widget
self.shape = Shape(size_hint=(0.7, 1))
self.add_widget(self.shape)
# Right Menu
self.panel = TabbedPanel(size_hint=(0.3, 1), do_default_tab=False)
self.tab_param = TabbedPanelItem(text='Parameters')
self.tab_color = TabbedPanelItem(text='Shape')
self.tab_color_bg = TabbedPanelItem(text='Background')
self.tab_export = TabbedPanelItem(text='Export')
self.panel.add_widget(self.tab_param)
self.panel.add_widget(self.tab_color)
self.panel.add_widget(self.tab_color_bg)
self.panel.add_widget(self.tab_export)
self.menu_right = RightMenu(
padding=15,
orientation="vertical")
# Switch mode line
self.box_switch = BoxLayout(orientation='horizontal')
self.mode_label = Label(
text="Line mode",
font_size=self.f_size,
markup=True)
self.box_switch.add_widget(self.mode_label)
self.switch_mode = Switch(active=False)
self.switch_mode.bind(active=self.on_switch)
self.box_switch.add_widget(self.switch_mode)
self.menu_right.add_widget(self.box_switch)
# Size value
self.box_size = BoxLayout(orientation='horizontal')
self.size_label = Label(
text="Shape size",
font_size=self.f_size,
markup=True)
self.size_label_value = Label(
text=str(self.shape.shape_size),
font_size=self.f_size,
markup=True)
self.box_size.add_widget(self.size_label)
self.box_size.add_widget(self.size_label_value)
self.slider_shape_size = Slider(
min=self.shape.property('shape_size').get_min(self.shape),
max=self.shape.property('shape_size').get_max(self.shape),
value=self.shape.shape_size, step=1)
self.slider_shape_size.bind(value=self.change_shape_size)
self.menu_right.add_widget(self.box_size)
self.menu_right.add_widget(self.slider_shape_size)
# Width point or line
self.box_stroke = BoxLayout(orientation='horizontal')
self.wdth_label = Label(
text="Stroke width",
font_size=self.f_size,
markup=True)
self.wdth_label_value = Label(
text=str(self.shape.wdth),
font_size=self.f_size,
markup=True)
self.box_stroke.add_widget(self.wdth_label)
self.box_stroke.add_widget(self.wdth_label_value)
self.slider_wdth = Slider(
min=self.shape.property('wdth').get_min(self.shape),
max=self.shape.property('wdth').get_max(self.shape),
value=self.shape.wdth, step=1)
self.slider_wdth.bind(value=self.change_wdth)
self.menu_right.add_widget(self.box_stroke)
self.menu_right.add_widget(self.slider_wdth)
# a value
self.box_a = BoxLayout(orientation='horizontal')
self.a_label = Label(
text="Param a ",
font_size=self.f_size,
markup=True)
self.a_label_value = Label(
text=str(self.shape.a),
font_size=self.f_size,
markup=True)
self.box_a.add_widget(self.a_label)
self.box_a.add_widget(self.a_label_value)
self.slider_a = Slider(
min=self.shape.property('a').get_min(self.shape),
max=self.shape.property('a').get_max(self.shape),
value=self.shape.a)
self.slider_a.bind(value=self.change_a)
self.menu_right.add_widget(self.box_a)
self.menu_right.add_widget(self.slider_a)
# b value
self.box_b = BoxLayout(orientation='horizontal')
self.b_label = Label(
text="Param b ",
font_size=self.f_size,
markup=True)
self.b_label_value = Label(
text=str(self.shape.b),
font_size=self.f_size,
markup=True)
self.box_b.add_widget(self.b_label)
self.box_b.add_widget(self.b_label_value)
self.slider_b = Slider(
min=self.shape.property('b').get_min(self.shape),
max=self.shape.property('b').get_max(self.shape),
value=self.shape.b)
self.slider_b.bind(value=self.change_b)
self.menu_right.add_widget(self.box_b)
self.menu_right.add_widget(self.slider_b)
# m value
self.box_m = BoxLayout(orientation='horizontal')
self.m_label = Label(
text="Param m ",
font_size=self.f_size,
markup=True)
self.m_label_value = Label(
text=str(self.shape.m),
font_size=self.f_size,
markup=True)
self.box_m.add_widget(self.m_label)
self.box_m.add_widget(self.m_label_value)
self.slider_m = Slider(
min=self.shape.property('m').get_min(self.shape),
max=self.shape.property('m').get_max(self.shape),
value=self.shape.m)
self.slider_m.bind(value=self.change_m)
self.menu_right.add_widget(self.box_m)
self.menu_right.add_widget(self.slider_m)
# n1 value
self.box_n1 = BoxLayout(orientation='horizontal')
self.n1_label = Label(
text="Param n1 ",
font_size=self.f_size,
markup=True)
self.n1_label_value = Label(
text=str(self.shape.n1),
font_size=self.f_size,
markup=True)
self.box_n1.add_widget(self.n1_label)
self.box_n1.add_widget(self.n1_label_value)
self.slider_n1 = Slider(
min=self.shape.property('n1').get_min(self.shape),
max=self.shape.property('n1').get_max(self.shape),
value=self.shape.n1)
self.slider_n1.bind(value=self.change_n1)
self.menu_right.add_widget(self.box_n1)
self.menu_right.add_widget(self.slider_n1)
# n2 value
self.box_n2 = BoxLayout(orientation='horizontal')
self.n2_label = Label(
text="Param n2 ",
font_size=self.f_size,
markup=True)
self.n2_label_value = Label(
text=str(self.shape.n2),
font_size=self.f_size,
markup=True)
self.box_n2.add_widget(self.n2_label)
self.box_n2.add_widget(self.n2_label_value)
self.slider_n2 = Slider(
min=self.shape.property('n2').get_min(self.shape),
max=self.shape.property('n2').get_max(self.shape),
value=self.shape.n2)
self.slider_n2.bind(value=self.change_n2)
self.menu_right.add_widget(self.box_n2)
self.menu_right.add_widget(self.slider_n2)
# n3 value
self.box_n3 = BoxLayout(orientation='horizontal')
self.n3_label = Label(
text="Param n3 ",
font_size=self.f_size,
markup=True)
self.n3_label_value = Label(
text=str(self.shape.n3),
font_size=self.f_size,
markup=True)
self.box_n3.add_widget(self.n3_label)
self.box_n3.add_widget(self.n3_label_value)
self.slider_n3 = Slider(
min=self.shape.property('n3').get_min(self.shape),
max=self.shape.property('n3').get_max(self.shape),
value=self.shape.n3)
self.slider_n3.bind(value=self.change_n3)
self.menu_right.add_widget(self.box_n3)
self.menu_right.add_widget(self.slider_n3)
# Nb points
self.box_nbp = BoxLayout(orientation='horizontal')
self.nbp_label = Label(
text="Points number ",
font_size=self.f_size,
markup=True)
self.nbp_label_value = Label(
text=str(self.shape.nbp),
font_size=self.f_size,
markup=True)
self.box_nbp.add_widget(self.nbp_label)
self.box_nbp.add_widget(self.nbp_label_value)
self.slider_nbp = Slider(
min=self.shape.property('nbp').get_min(self.shape),
max=self.shape.property('nbp').get_max(self.shape),
value=self.shape.nbp, step=2)
self.slider_nbp.bind(value=self.change_nbp)
self.menu_right.add_widget(self.box_nbp)
self.menu_right.add_widget(self.slider_nbp)
# Percent
self.box_percent = BoxLayout(orientation='horizontal')
self.percent_label = Label(
text="Percent ",
font_size=self.f_size,
markup=True)
self.percent_label_value = Label(
text=str(self.shape.percent),
font_size=self.f_size,
markup=True)
self.box_percent.add_widget(self.percent_label)
self.box_percent.add_widget(self.percent_label_value)
self.slider_percent = Slider(
min=self.shape.property('percent').get_min(self.shape),
max=self.shape.property('percent').get_max(self.shape),
value=self.shape.percent, step=1)
self.slider_percent.bind(value=self.change_percent)
self.menu_right.add_widget(self.box_percent)
self.menu_right.add_widget(self.slider_percent)
# Travel
self.box_travel = BoxLayout(orientation='horizontal')
self.travel_label = Label(
text="Travel ",
font_size=self.f_size,
markup=True)
self.travel_label_value = Label(
text=str(self.shape.travel),
font_size=self.f_size,
markup=True)
self.box_travel.add_widget(self.travel_label)
self.box_travel.add_widget(self.travel_label_value)
self.slider_travel = Slider(
min=self.shape.property('travel').get_min(self.shape),
max=self.shape.property('travel').get_max(self.shape),
value=self.shape.travel, step=2)
self.slider_travel.bind(value=self.change_travel)
self.menu_right.add_widget(self.box_travel)
self.menu_right.add_widget(self.slider_travel)
# ColorPicker for Shape
self.picker = ColorPicker()
self.picker.bind(color=self.on_color)
# ColorPicker for background
self.picker_bg = ColorPicker()
self.picker_bg.bind(color=self.on_color_bg)
# Export svg button
self.export_button = Button(text='Export', size_hint=(1, 0.15))
self.export_button.bind(on_press=self.export)
# Tab packs
self.tab_param.add_widget(self.menu_right)
self.tab_color.add_widget(self.picker)
self.tab_color_bg.add_widget(self.picker_bg)
self.tab_export.add_widget(self.export_button)
self.add_widget(self.panel)
# Popups
self.pop_export = Popup(
title="Export file",
content=Label(text="File exported"),
size_hint=(None, None),
size=(640, 240))
def finalize(self, *args):
"""Add my tabs"""
if not self.canvas:
Clock.schedule_once(self.finalize, 0)
return
deck_builder_kwargs = {
'pos_hint': {'x': 0, 'y': 0},
'starting_pos_hint': {'x': 0.05, 'top': 0.95},
'card_size_hint': (0.3, 0.4),
'card_hint_step': (0, -0.1),
'deck_x_hint_step': 0.4
}
self._tabs = TabbedPanel(
size=self.size,
pos=self.pos,
do_default_tab=False
)
self.bind(
size=self._tabs.setter('size'),
pos=self._tabs.setter('pos')
)
self.add_widget(self._tabs)
for functyp in 'trigger', 'prereq', 'action':
tab = TabbedPanelItem(text=functyp.capitalize())
setattr(self, '_{}_tab'.format(functyp), tab)
self._tabs.add_widget(getattr(self, '_{}_tab'.format(functyp)))
builder = DeckBuilderView(**deck_builder_kwargs)
setattr(self, '_{}_builder'.format(functyp), builder)
builder.bind(decks=getattr(self, '_trigger_push_{}s'.format(functyp)))
scroll_left = DeckBuilderScrollBar(
size_hint_x=0.01,
pos_hint={'x': 0, 'y': 0},
deckbuilder=builder,
deckidx=0,
scroll_min=0
)
setattr(self, '_scroll_left_' + functyp, scroll_left)
scroll_right = DeckBuilderScrollBar(
size_hint_x=0.01,
pos_hint={'right': 1, 'y': 0},
deckbuilder=builder,
deckidx=1,
scroll_min=0
)
setattr(self, '_scroll_right_' + functyp, scroll_right)
layout = FloatLayout()
setattr(self, '_{}_layout'.format(functyp), layout)
tab.add_widget(layout)
layout.add_widget(builder)
layout.add_widget(scroll_left)
layout.add_widget(scroll_right)
layout.add_widget(
Label(
text='Used',
pos_hint={'center_x': 0.1, 'center_y': 0.98},
size_hint=(None, None)
)
)
layout.add_widget(
Label(
text='Unused',
pos_hint={'center_x': 0.5, 'center_y': 0.98},
size_hint=(None, None)
)
)
self.bind(rule=getattr(self, '_trigger_pull_{}s'.format(functyp)))
def build_layout(self):
box_base = BoxLayout(orientation="vertical", padding=0)
ctrl_box_haut = BoxLayout(orientation="horizontal", padding=10, size_hint_y=None)
# Nom de l'individu
ctrl_label = Label(text="[color=000000][size=28][b]%s[/b][/size][/color]" % self.dictIndividu["nomComplet"], markup=True, size_hint_y=None)
ctrl_box_haut.add_widget(ctrl_label)
# Photo
photo = self.dictIndividu["photo"]
if photo == None :
if self.dictIndividu["IDcivilite"] == 1 : photo = UTILS_Images.GetTextureFromFichier("images/homme.png")
if self.dictIndividu["IDcivilite"] in (2, 3) : photo = UTILS_Images.GetTextureFromFichier("images/femme.png")
if self.dictIndividu["IDcivilite"] == 4 : photo = UTILS_Images.GetTextureFromFichier("images/garcon.png")
if self.dictIndividu["IDcivilite"] == 5 : photo = UTILS_Images.GetTextureFromFichier("images/fille.png")
if photo != None :
ctrl_image = Image(texture=photo, size_hint_x=None)
ctrl_box_haut.add_widget(ctrl_image)
box_base.add_widget(ctrl_box_haut)
# Onglets
ctrl_onglets = TabbedPanel(do_default_tab=False, padding=10, tab_pos='top_left') # Vertical=left_bottom
box_base.add_widget(ctrl_onglets)
liste_onglets = [
{"code":"messages", "titre":u"Messages"},
{"code":"identite", "titre":u"Identité"},
{"code":"liens", "titre":u"Liens"},
{"code":"coordonnees", "titre":u"Coordonnées"},
{"code":"scolarite", "titre":u"Scolarité"},
{"code":"activites", "titre":u"Activités"},
{"code":"medical", "titre":u"Médical"},
]
for dictOnglet in liste_onglets :
onglet = TabbedPanelItem(id=dictOnglet["code"], text=dictOnglet["titre"])
doc = RstDocument(text=self.GetTexteOnglet(dictOnglet["code"]))
onglet.add_widget(doc)
ctrl_onglets.add_widget(onglet)
# Barre d'état
grid = GridLayout(cols=3, row=1, row_force_default=True, row_default_height=30, spacing=(5, 5), padding=10, size_hint=(1, None), height=50)
grid.canvas.before.add(Color(0.128, 0.128, 0.128))
def redraw(self, args):
grid.bg_rect.size = self.size
grid.bg_rect.pos = self.pos
with grid.canvas.before:
grid.bg_rect = Rectangle(pos=grid.pos, size=grid.size)
grid.bind(pos=redraw, size=redraw)
#ctrl_bouton = Button(id="consommations", text="Consommations", width=200, size_hint=(None, None))
#grid.add_widget(ctrl_bouton)
box_base.add_widget(grid)
# Finalisation du layout
self.add_widget(box_base)
def generate_panel_tab(self, txt):
tpi = TabbedPanelItem(text=txt)
tpi.content = TextInput(text='Waiting data...', readonly=True)
self.panel.add_widget(tpi)
def _manip_append(task, append_type, amount, container, overwrite, *args):
append_type = append_type.text
overwrite = overwrite.active
amount = int(amount.text) if amount.text else 0
if append_type == 'Append type':
raise Exception('No append type was chosen!')
# Stop the task if no amount (or =0) is specified
# or if no column is available
if not amount and not container.children:
raise Exception('No amount was specified!')
from_address = task.from_address(task.tablenum, ':all',
extended=True)
values, cols, rows, labels = from_address
rows = int(rows)
# get columns
chunks = []
for x in range(0, len(values), rows):
chunks.append(values[x:x + rows])
if append_type == 'Columns':
_cols = container.children[0].ids.columns.children
for c in reversed(_cols):
labels.append(c.ids.colname.text)
_type = c.ids.coltype.text
if _type == 'INTEGER':
chunks.extend([[0 for _ in range(rows)]])
elif _type == 'REAL':
chunks.extend([[0.0 for _ in range(rows)]])
else:
chunks.extend([[u'' for _ in range(rows)]])
amount += 1
cols += 1
elif append_type == 'Rows':
# append to columns a zero value according
# to their type int(amount)-times
for r in range(amount):
for chunk in chunks:
if isinstance(chunk[0], int):
chunk.append(0)
elif isinstance(chunk[0], float):
chunk.append(0.0)
else:
chunk.append(u'')
# increase row count by new rows
rows += amount
# zip chunks to values, flatten values
values = zip(*chunks)
values = [v for vals in values for v in vals]
# add Table
tab_pos = 0
table = task.ids.tablesel.text
tabpanel = task.app.root.ids.tabpanel
tabpanel_len = len(tabpanel.tab_list)
if overwrite:
tab_pos = task.tablenum
# list of available tabs in Task is 0 -> n (from tables),
# but tab_list order is reversed in Kivy, therefore
# reverse the index by going backwards with -1
# and increase tab_pos, which is only index of
# value order in spinner
old_tab = tabpanel.tab_list[-1 - (tab_pos + 1)]
tabpanel.remove_widget(old_tab)
tabletab = TabbedPanelItem(text=table)
tabpanel.add_widget(tabletab, tabpanel_len - 1 - (tab_pos + 1))
else:
# if space in name, sql save boom
if append_type == 'Columns':
table += u'_append_{}_cols'.format(str(amount))
elif append_type == 'Rows':
table += u'_append_{}_rows'.format(str(amount))
tabletab = TabbedPanelItem(text=table)
tabpanel.add_widget(tabletab, 0)
# make new table
new_table = (
table, task.tablecls(max_cols=cols, max_rows=rows,
pos=task.app.root.pos,
size=task.app.root.size,
values=values, labels=labels)
)
# place newly created table into tab's content
if overwrite:
task.app.root.tables[tab_pos] = new_table
tabletab.content = task.app.root.tables[tab_pos][1]
else:
task.app.root.tables.append(new_table)
tabletab.content = task.app.root.tables[-1][1]
def create_editor_tab(self, filename = None):
tab2 = TabbedPanelItem(text="Editor")
editor = EditorWidget(self, tab2, filename)
tab2.add_widget(editor)
self.add_widget(tab2)
self.activate_newest_tab()
