1431 lines
69 KiB
Python
1431 lines
69 KiB
Python
import tkinter as tk
|
|
from tkinter import ttk
|
|
from tkinter import filedialog
|
|
import os
|
|
|
|
#import logging
|
|
|
|
|
|
#logger = logging.getLogger(__name__)
|
|
|
|
def OnMouseWheel(self,event):
|
|
self.scrollbar1.yview("scroll",event.delta,"units")
|
|
return "break"
|
|
|
|
class AllFrames():
|
|
""" enthält alle gleichen Methoden für die Widgets in der rechte Spalte
|
|
"""
|
|
def __init__(self, nrow=0):
|
|
self.set_start_row(nrow)
|
|
self._controller = None
|
|
|
|
self._text_width = 40
|
|
self._entry_text_width = 45
|
|
self._combo_width = 42
|
|
|
|
def get_entry_text_width(self):
|
|
return self._entry_text_width
|
|
def get_combo_width(self):
|
|
return self._combo_width
|
|
def get_text_width(self):
|
|
return self._text_width
|
|
|
|
def get_rows(self):
|
|
"""gibt die Anzahl der von diesem Widget belegten Zeilen zurück"""
|
|
return self.rownum
|
|
|
|
def set_start_row(self, nrow):
|
|
"""setzt für diesen Frame die Anfangszeile"""
|
|
if nrow < 0:
|
|
raise Exception("this row can not be set")
|
|
self.rownum = nrow
|
|
|
|
def set_controller(self, controller):
|
|
self._controller = controller
|
|
def get_controller(self):
|
|
return self._controller
|
|
|
|
def callback(self, key, value):
|
|
"""ruft den Controller und damit die Businesslogic auf, dass dieser key gerade in die Oberfläche gesetzt wurde"""
|
|
controller = self.get_controller()
|
|
if controller:
|
|
controller.callback(key, value)
|
|
|
|
class TreeView():
|
|
def __init__(self, frame, nrow=0):
|
|
# a treeview
|
|
# hier Anzahl der sichtbaren Zeilen des Baums angeben:
|
|
self.tree = ttk.Treeview(frame, height=65)
|
|
# TODO hier anstatt root die Statistik rein schreiben.
|
|
self.tree.heading('#0', text='root', anchor=tk.W)
|
|
self.tree.grid(row=nrow, column=0, sticky=tk.NSEW)
|
|
|
|
# add a scrollbar
|
|
scrollbar = ttk.Scrollbar(frame, orient='vertical', command=self.tree.yview)
|
|
self.tree.configure(yscroll=scrollbar.set)
|
|
scrollbar.grid(row=nrow, column=1, sticky='ns')
|
|
|
|
#self.tree.bind('<<TreeviewSelect>>', self.item_selected) # Einfachklick
|
|
self.tree.bind('<Double-Button-1>', self.item_selected) # Doppelklick:
|
|
|
|
def set_controller(self, controller):
|
|
self._controller = controller
|
|
|
|
def refresh(self, parent_children_mapping, red_ids):
|
|
self.clear()
|
|
self.create(parent_children_mapping, red_ids)
|
|
|
|
def clear(self):
|
|
for c in self.tree.get_children():
|
|
self.tree.delete(c)
|
|
|
|
def create(self, parent_children_mapping, red_ids):
|
|
# adding data of first column after root
|
|
pool = set()
|
|
for parent,children in parent_children_mapping.items():
|
|
if parent not in pool:
|
|
self.tree.insert('', tk.END, text=parent, iid=parent, open=True)
|
|
pool.add(parent)
|
|
cn = children
|
|
# sortiere die Zahlen im Baum immer aufsteigend
|
|
cn.sort(reverse=True)
|
|
for child_id in cn:
|
|
if child_id not in pool:
|
|
pool.add(child_id)
|
|
if child_id not in red_ids: rowtags = ('good')
|
|
else: rowtags = ('missing')
|
|
self.tree.insert('', tk.END, text=child_id, iid=child_id, tags=rowtags, open=True)
|
|
#self.tree.move(child_id, parent, 0)
|
|
|
|
# einmal über alles gehen und alle keys an die richtige Stelle schieben
|
|
for parent,children in parent_children_mapping.items():
|
|
for child_id in children:
|
|
self.tree.move(child_id, parent, 0)
|
|
|
|
# https://www.askpython.com/python-modules/tkinter/tkinter-colors
|
|
#self.tree.tag_configure('good', background='LawnGreen')
|
|
self.tree.tag_configure('good', background='white')
|
|
self.tree.tag_configure('missing', background='red')
|
|
|
|
def data_from_model(self):
|
|
parent_children_mapping = self._controller.get_parent_children()
|
|
red_ids = self._controller.get_red_ids()
|
|
self.refresh(parent_children_mapping, red_ids)
|
|
|
|
def item_selected(self, event):
|
|
"""callback of TK if an item in the tree has been selected
|
|
"""
|
|
cid = self.tree.selection()[0]
|
|
# trage die neue ID ins Modell ein
|
|
self._controller.set_current_item_id(cid)
|
|
|
|
class LeftFrameAsm(AllFrames):
|
|
def __init__(self, frame, nrow=0):
|
|
AllFrames.__init__(self, nrow)
|
|
self.frame = frame
|
|
self.build_widgets()
|
|
|
|
def build_widgets(self):
|
|
frame = self.frame
|
|
self.rownum = AllFrames.get_rows(self)
|
|
col_left = 0
|
|
# Baugruppennummer
|
|
asm_label = ttk.Label(frame, text="Baugruppennummer:" )
|
|
asm_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
self.asm_number = tk.StringVar()
|
|
asm_entry = ttk.Entry(frame, textvariable=self.asm_number, width=9, font=("Calibri",15))
|
|
asm_entry.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
#search_iconpath = os.path.join(configs.get_cfg_path(), 'images', 'search.png')
|
|
#search_icon = tk.PhotoImage(file=search_iconpath)
|
|
# Resizing image to fit on button
|
|
#photoimage = search_icon.subsample(3, 3)
|
|
asm_search_button = ttk.Button(
|
|
frame,
|
|
text="Suche",
|
|
#image=photoimage,
|
|
compound = tk.LEFT,
|
|
command=lambda: self.callback("cb_suche_asm", self.asm_number.get())
|
|
)
|
|
asm_search_button.grid(column=col_left, row=self.rownum, sticky=tk.EW, padx=3, pady=3)
|
|
self.rownum += 1
|
|
asm_loadlocal_button = ttk.Button(
|
|
frame,
|
|
text="Lade lokal",
|
|
#image=photoimage,
|
|
compound = tk.LEFT,
|
|
command=lambda: self.callback("cb_ladelokal_asm", self.asm_number.get())
|
|
)
|
|
asm_loadlocal_button.grid(column=col_left, row=self.rownum, sticky=tk.EW, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
def get_data(self):
|
|
return {
|
|
"asm_id": self.asm_number.get(),
|
|
}
|
|
|
|
def data_from_model(self):
|
|
data = self.get_controller().get_all_gui_data()
|
|
if 'asm_id' in data:
|
|
self.asm_number.set(data["asm_id"])
|
|
|
|
def set_states(self):
|
|
# not yet implemented. Not used
|
|
pass
|
|
|
|
|
|
class RightFrameLabels(AllFrames):
|
|
def __init__(self, frame, nrow=0):
|
|
AllFrames.__init__(self, nrow)
|
|
self.frame = frame
|
|
self.build_widgets()
|
|
|
|
def build_widgets(self):
|
|
frame = self.frame
|
|
self.rownum = AllFrames.get_rows(self)
|
|
col_left = 0
|
|
|
|
# Teilenummer
|
|
teilenummer_label = ttk.Label(frame, text="Teilenummer:")
|
|
teilenummer_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.teilenummer_text = tk.StringVar()
|
|
teilenummer_entry = ttk.Entry(frame, textvariable=self.teilenummer_text, width=9, font=("Calibri",15), state="readonly")
|
|
teilenummer_entry.grid(column=col_left+1, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
teilenummer_entry.bind('<<ComboboxSelected>>', lambda event:self.callback("cb_teilenummer", self.teilenummer_text.get()))
|
|
self.rownum += 1
|
|
separator2 = ttk.Separator(frame, orient='horizontal')
|
|
separator2.grid(column=col_left, columnspan=3, row=self.rownum, sticky=tk.EW, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
|
|
def get_data(self):
|
|
return {
|
|
"teilenummer": self.teilenummer_text.get(),
|
|
}
|
|
|
|
def data_from_model(self):
|
|
data = self.get_controller().get_all_gui_data()
|
|
if 'teilenummer' in data:
|
|
self.teilenummer_text.set(data["teilenummer"])
|
|
|
|
def set_states(self):
|
|
data = self.get_controller().get_gui_states()
|
|
if 'teilenummer' in data:
|
|
self.teilenummer_text["state"] = data['teilenummer']
|
|
|
|
class RightFramePDM(AllFrames):
|
|
def __init__(self, frame, nrow=0):
|
|
AllFrames.__init__(self, nrow)
|
|
self.frame = frame
|
|
self.build_widgets()
|
|
|
|
def build_widgets(self):
|
|
frame = self.frame
|
|
self.rownum = AllFrames.get_rows(self)
|
|
col_left = 0
|
|
|
|
# Datenbank Schulung oder Produktiv
|
|
datenbank_label = ttk.Label(frame, text="Datenbank:" )
|
|
datenbank_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.datenbank = tk.StringVar()
|
|
self.datenbank.set("Schulung") # default
|
|
datenbank_prod = ttk.Radiobutton(frame, text="Produktiv", variable=self.datenbank, value="Produktiv")
|
|
datenbank_prod .grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
datenbank_schul = ttk.Radiobutton(frame, text="Schulung", variable=self.datenbank, value="Schulung")
|
|
datenbank_schul .grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# pdmkategorie
|
|
#categories = configs.Allgemein.get_options("Kategorien") #"Baugruppe", "Einzelteil", "Kaufteil", "NichtSivas", "Normteil", "Schweissbaugruppe"
|
|
pdmkategorie_label = ttk.Label(frame, text="PDM-Kategorie:" )
|
|
pdmkategorie_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.pdm_category = tk.StringVar()
|
|
self.pdmkategorie_combo = ttk.Combobox(frame, textvariable=self.pdm_category, width=AllFrames.get_combo_width(self))
|
|
#self.pdmkategorie_combo['values'] = categories
|
|
self.pdmkategorie_combo['state'] = 'readonly'
|
|
self.pdmkategorie_combo.bind('<<ComboboxSelected>>', lambda event:self.callback('cb_pdm_kategorie_neu', self.pdm_category.get()))
|
|
self.pdmkategorie_combo.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# Neuaufbau
|
|
neuaufbau_label = ttk.Label(frame, text="Neuaufbau:")
|
|
neuaufbau_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
|
|
self.neuaufbau = tk.BooleanVar()
|
|
self.neuaufbau_checkbutton = ttk.Checkbutton(frame,
|
|
#text='ja',
|
|
variable=self.neuaufbau,
|
|
command=lambda:self.callback("cb_neuaufbau", self.neuaufbau.get()),
|
|
onvalue=True,
|
|
offvalue=False)
|
|
self.neuaufbau_checkbutton.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# aus Halbzeug
|
|
halbzeug_label = ttk.Label(frame, text="aus Halbzeug:")
|
|
halbzeug_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.aus_halbzeug_neu = tk.BooleanVar()
|
|
self.aushalbzeug_checkbutton = ttk.Checkbutton(frame,
|
|
#text='neu',
|
|
variable=self.aus_halbzeug_neu,
|
|
command=lambda:self.callback("cb_aus_halbzeug_neu", self.aus_halbzeug_neu.get()),
|
|
onvalue=True,
|
|
offvalue=False)
|
|
self.aushalbzeug_checkbutton.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# Halbzeugnummer
|
|
halbzeugnummer_label = ttk.Label(frame, text="Halbzeugnummer:" )
|
|
halbzeugnummer_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.halbzeugnummer_neu = tk.StringVar()
|
|
halbzeugnummer_neu_entry = ttk.Entry(frame, textvariable=self.halbzeugnummer_neu, width=AllFrames.get_entry_text_width(self))
|
|
halbzeugnummer_neu_entry.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# Halbzeuglänge
|
|
halbzeuglaenge_label = ttk.Label(frame, text="Halbzeuglänge:" )
|
|
halbzeuglaenge_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.halbzeuglaenge_neu = tk.StringVar()
|
|
halbzeuglaenge_neu_entry = ttk.Entry(frame, textvariable=self.halbzeuglaenge_neu, width=AllFrames.get_entry_text_width(self))
|
|
halbzeuglaenge_neu_entry.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# HalbzeugOberfläche
|
|
halbzeugoberflaeche_label = ttk.Label(frame, text="Halbzeugoberfläche:" )
|
|
halbzeugoberflaeche_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.halbzeugoberflaeche_neu = tk.StringVar()
|
|
self.halbzeugoberflaeche_combo = ttk.Combobox(frame, textvariable=self.halbzeugoberflaeche_neu, width=AllFrames.get_combo_width(self))
|
|
self.halbzeugoberflaeche_combo['state'] = 'readonly'
|
|
self.halbzeugoberflaeche_combo.bind('<<ComboboxSelected>>', lambda event:self.callback('cb_halbzeugoberflaeche', self.halbzeugoberflaeche_neu.get()))
|
|
self.halbzeugoberflaeche_combo.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# HalbzeugFarbe
|
|
halbzeugfarbe_label = ttk.Label(frame, text="Halbzeugfarbe:" )
|
|
halbzeugfarbe_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.halbzeugfarbe_neu = tk.StringVar()
|
|
self.halbzeugfarbe_combo = ttk.Combobox(frame, textvariable=self.halbzeugfarbe_neu, width=AllFrames.get_combo_width(self))
|
|
self.halbzeugfarbe_combo['state'] = 'readonly'
|
|
self.halbzeugfarbe_combo.bind('<<ComboboxSelected>>', lambda event:self.callback('cb_halbzeugfarbe', self.halbzeugfarbe_neu.get()))
|
|
self.halbzeugfarbe_combo.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# Lebenszyklusstatus
|
|
#lstatus = configs.Allgemein.get_options("Lebenszyklus") # Serie, Prototyp
|
|
lebenszyklusstatus_label = ttk.Label(frame, text="Lebenszyklusstatus:")
|
|
lebenszyklusstatus_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.lebenszyklus_status_neu = tk.StringVar()
|
|
self.lebenszyklusstatus_combo = ttk.Combobox(frame, textvariable=self.lebenszyklus_status_neu, width=AllFrames.get_combo_width(self))
|
|
self.lebenszyklusstatus_combo['state'] = 'readonly'
|
|
self.lebenszyklusstatus_combo.bind('<<ComboboxSelected>>', lambda event:self.callback('cb_lebenszyklus_status_neu', self.lebenszyklus_status_neu.get()))
|
|
self.lebenszyklusstatus_combo.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# 3D Model Filesearch
|
|
model3d_label = ttk.Label(frame, text="3D-Modell:" )
|
|
model3d_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.model3d_neu = tk.StringVar()
|
|
self.model3d_combo = ttk.Combobox(frame, textvariable=self.model3d_neu, justify='right', width=AllFrames.get_combo_width(self))
|
|
self.model3d_combo['state'] = 'readonly'
|
|
self.model3d_combo.bind('<<ComboboxSelected>>', lambda event:self.callback('cb_3Dmodel_neu', self.model3d_neu.get()))
|
|
self.model3d_combo.grid(column=col_left+1, columnspan=2, row=self.rownum, sticky=tk.EW, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
#lambda: self.callback("cb_speichern", None)
|
|
suche3d_button = ttk.Button(frame, text="Durchsuchen..", command=lambda: self.callback("cb_3dsuchen", None))
|
|
suche3d_button.grid(column=col_left+2, row=self.rownum, sticky=tk.EW)
|
|
self.rownum += 1
|
|
|
|
|
|
def get_data(self):
|
|
return {
|
|
"datenbank": self.datenbank.get(),
|
|
"pdm_kategorie_neu": self.pdm_category.get(),
|
|
"neuaufbau": self.neuaufbau.get(),
|
|
"aus_halbzeug_neu": self.aus_halbzeug_neu.get(),
|
|
"halbzeugnummer_neu": self.halbzeugnummer_neu.get(),
|
|
"halbzeuglaenge_neu": self.halbzeuglaenge_neu.get(),
|
|
"halbzeugoberflaeche_neu": self.halbzeugoberflaeche_neu.get(),
|
|
"halbzeugfarbe_neu": self.halbzeugfarbe_neu.get(),
|
|
"lebenszyklus_status_neu": self.lebenszyklus_status_neu.get(),
|
|
"model3d_neu": self.model3d_neu.get(),
|
|
# ab hier die Dropdowns der Oberfläche auslesen.
|
|
"cb_pdm_kategorie_neu": self.pdmkategorie_combo['values'],
|
|
"cb_lebenszyklus_status_neu": self.lebenszyklusstatus_combo['values'],
|
|
"cb_halbzeugoberflaeche": self.halbzeugoberflaeche_combo['values'],
|
|
"cb_halbzeugfarbe": self.halbzeugfarbe_combo['values'],
|
|
"cb_3Dmodel_neu": self.model3d_combo['values'],
|
|
|
|
}
|
|
|
|
def data_from_model(self):
|
|
data = self.get_controller().get_all_gui_data()
|
|
if 'datenbank' in data:
|
|
self.datenbank.set(data["datenbank"])
|
|
if 'pdm_kategorie_neu' in data:
|
|
self.pdm_category.set(data["pdm_kategorie_neu"])
|
|
if 'neuaufbau' in data:
|
|
self.neuaufbau.set(data["neuaufbau"])
|
|
if 'halbzeugnummer_neu' in data:
|
|
self.halbzeugnummer_neu.set(data["halbzeugnummer_neu"])
|
|
if 'halbzeuglaenge_neu' in data:
|
|
self.halbzeuglaenge_neu.set(data["halbzeuglaenge_neu"])
|
|
if 'halbzeugoberflaeche_neu' in data:
|
|
self.halbzeugoberflaeche_neu.set(data["halbzeugoberflaeche_neu"])
|
|
if 'halbzeugfarbe_neu' in data:
|
|
self.halbzeugfarbe_neu.set(data["halbzeugfarbe_neu"])
|
|
if 'lebenszyklus_status_neu' in data:
|
|
self.lebenszyklus_status_neu.set(data["lebenszyklus_status_neu"])
|
|
if 'model3d_neu' in data:
|
|
self.model3d_neu.set(data["model3d_neu"])
|
|
if 'aus_halbzeug_neu' in data:
|
|
self.aus_halbzeug_neu.set(data["aus_halbzeug_neu"])
|
|
# ab hier die Dropdowns der Oberfläche befüllen.
|
|
if 'cb_pdm_kategorie_neu' in data:
|
|
self.pdmkategorie_combo['values'] = data["cb_pdm_kategorie_neu"]
|
|
if 'cb_lebenszyklus_status_neu' in data:
|
|
self.lebenszyklusstatus_combo['values'] = data["cb_lebenszyklus_status_neu"]
|
|
if 'cb_halbzeugoberflaeche' in data:
|
|
self.halbzeugoberflaeche_combo['values'] = data["cb_halbzeugoberflaeche"]
|
|
if 'cb_halbzeugfarbe' in data:
|
|
self.halbzeugfarbe_combo['values'] = data["cb_halbzeugfarbe"]
|
|
if 'cb_3Dmodel_neu' in data:
|
|
self.model3d_combo['values'] = data["cb_3Dmodel_neu"]
|
|
|
|
def set_states(self):
|
|
data = self.get_controller().get_gui_states()
|
|
pass
|
|
# if 'teilenummer' in data:
|
|
# self.teilenummer_text["state"] = data['teilenummer']
|
|
|
|
class RightFrameBezeichnung(AllFrames):
|
|
def __init__(self, frame, nrow=0):
|
|
AllFrames.__init__(self, nrow)
|
|
self.frame = frame
|
|
self.build_widgets()
|
|
|
|
def build_widgets(self):
|
|
frame = self.frame
|
|
self.rownum = AllFrames.get_rows(self)
|
|
col_left = 0
|
|
|
|
# Feld, SIVAS-Werte, Überschriebene Werte
|
|
feld_label = ttk.Label(frame, text="Feld" )
|
|
feld_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
Sivas_label = ttk.Label(frame, text="SIVAS-Werte" )
|
|
Sivas_label.grid(column=col_left+1, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
transwritten_label = ttk.Label(frame, text="Überschriebene Werte" )
|
|
transwritten_label.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
|
|
feld_label.configure(font=("Helvetica", 12))
|
|
Sivas_label.configure(font=("Helvetica",12))
|
|
transwritten_label.configure(font=("Helvetica",12))
|
|
self.rownum += 1
|
|
|
|
separator = ttk.Separator(frame, orient='horizontal')
|
|
separator.grid(column=col_left, columnspan=3, row=self.rownum, sticky=tk.EW, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# Bezeichnung 1
|
|
bezeichnung1_label = ttk.Label(frame, text="Bezeichnung 1:" )
|
|
bezeichnung1_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.bezeichnung1_sivas = tk.StringVar()
|
|
self.bezeichnung1_entry = ttk.Entry(frame, textvariable=self.bezeichnung1_sivas, width=AllFrames.get_entry_text_width(self), state="readonly")
|
|
self.bezeichnung1_entry.grid(column=col_left+1, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.bezeichnung1_neu = tk.StringVar()
|
|
self.bezeichnung1_neu.trace_add('write', callback=self.trace_bezeichnung_neu)
|
|
self.bezeichnung1_neu_entry = ttk.Entry(frame, textvariable=self.bezeichnung1_neu, width=AllFrames.get_entry_text_width(self))
|
|
self.bezeichnung1_neu_entry.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
|
|
self.rownum += 1
|
|
|
|
# Bezeichnung 2
|
|
bezeichnung2_label = ttk.Label(frame, text="Bezeichnung 2:" )
|
|
bezeichnung2_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.bezeichnung2_sivas = tk.StringVar()
|
|
bezeichnung2_entry = ttk.Entry(frame, textvariable=self.bezeichnung2_sivas, state="readonly", width=AllFrames.get_entry_text_width(self))
|
|
bezeichnung2_entry.grid(column=col_left+1, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
separator = ttk.Separator(frame, orient='horizontal')
|
|
separator.grid(column=col_left, columnspan=3, row=self.rownum, sticky=tk.EW, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
def trace_bezeichnung_neu(self, var, index, mode):
|
|
""" Spezial: Bei zu langem Eintrag die Farbe des Textes auffällig machen """
|
|
text = self.bezeichnung1_neu.get()
|
|
if len(text) < 45:
|
|
self.bezeichnung1_neu_entry.configure(foreground='black')
|
|
self._controller.set_gui_data("bezeichnung1_neu", text)
|
|
elif len(text) < 51:
|
|
self.bezeichnung1_neu_entry.configure(foreground='orange')
|
|
else:
|
|
self.bezeichnung1_neu_entry.configure(foreground='red')
|
|
|
|
def get_data(self):
|
|
return {
|
|
"bezeichnung1_sivas": self.bezeichnung1_sivas.get(),
|
|
"bezeichnung1_neu": self.bezeichnung1_neu.get(),
|
|
"bezeichnung2_sivas": self.bezeichnung2_sivas.get(),
|
|
}
|
|
|
|
def data_from_model(self):
|
|
data = self.get_controller().get_all_gui_data()
|
|
if 'bezeichnung1_sivas' in data:
|
|
self.bezeichnung1_sivas.set(data["bezeichnung1_sivas"])
|
|
if 'bezeichnung1_neu' in data:
|
|
self.bezeichnung1_neu.set(data["bezeichnung1_neu"])
|
|
if 'bezeichnung2_sivas' in data:
|
|
self.bezeichnung2_sivas.set(data["bezeichnung2_sivas"])
|
|
|
|
def set_states(self):
|
|
data = self.get_controller().get_gui_states()
|
|
pass
|
|
|
|
class RightFrameHalbzeugOhneS(AllFrames):
|
|
def __init__(self, frame, nrow=0):
|
|
AllFrames.__init__(self, nrow)
|
|
self.frame = frame
|
|
self.build_widgets()
|
|
|
|
def build_widgets(self):
|
|
frame = self.frame
|
|
self.rownum = AllFrames.get_rows(self)
|
|
col_left = 0
|
|
|
|
# categories = configs.Allgemein.get_options("Kategorien")
|
|
# ruestcodes = configs.Allgemein.get_options("Ruestcode")
|
|
|
|
# Halbzeug ohne Sägeliste
|
|
halbzeugOhneSaege_label = ttk.Label(frame, text="Halbzeug ohne Sägeliste:" )
|
|
halbzeugOhneSaege_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.halbzeugOhneSaege_sivas = tk.StringVar()
|
|
halbzeugOhneSaege_entry = ttk.Entry(frame, textvariable=self.halbzeugOhneSaege_sivas, state="readonly", width=AllFrames.get_entry_text_width(self))
|
|
halbzeugOhneSaege_entry.grid(column=col_left+1, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
|
|
self.halbzeugOhneSaege_neu = tk.StringVar()
|
|
self.halbzeugOhneSaege_neu_combo = ttk.Combobox(frame, textvariable=self.halbzeugOhneSaege_neu, width=AllFrames.get_combo_width(self))
|
|
self.halbzeugOhneSaege_neu_combo['values'] = ['ja','nein']
|
|
self.halbzeugOhneSaege_neu_combo['state'] = 'readonly'
|
|
self.halbzeugOhneSaege_neu_combo.bind('<<ComboboxSelected>>', lambda event:self.callback('cb_halbzeugOhneSaege_neu', self.halbzeugOhneSaege_neu.get()))
|
|
self.halbzeugOhneSaege_neu_combo.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# Rüstcode
|
|
ruestcode_label = ttk.Label(frame, text="Rüstcode:" )
|
|
ruestcode_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.ruestcode_sivas = tk.StringVar()
|
|
ruestcode_entry = ttk.Entry(frame, textvariable=self.ruestcode_sivas, state="readonly", width=AllFrames.get_entry_text_width(self))
|
|
ruestcode_entry.grid(column=col_left+1, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
|
|
self.ruestcode_neu = tk.StringVar()
|
|
self.ruestcode_neu_combo = ttk.Combobox(frame, textvariable=self.ruestcode_neu, width=AllFrames.get_combo_width(self))
|
|
#self.ruestcode_neu_combo['values'] = ruestcodes
|
|
self.ruestcode_neu_combo['state'] = 'readonly'
|
|
self.ruestcode_neu_combo.bind('<<ComboboxSelected>>', lambda event:self.callback('cb_ruestcode_neu', self.ruestcode_neu.get()))
|
|
self.ruestcode_neu_combo.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# Fertigungsart
|
|
fertigungsart_label = ttk.Label(frame, text="Fertigungsart:" )
|
|
fertigungsart_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.fertigungsart_sivas = tk.StringVar()
|
|
fertigungsart_entry = ttk.Entry(frame, textvariable=self.fertigungsart_sivas, state="readonly", width=AllFrames.get_entry_text_width(self))
|
|
fertigungsart_entry.grid(column=col_left+1, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
|
|
self.fertigungsart_neu = tk.StringVar()
|
|
self.fertigungsart_neu_combo = ttk.Combobox(frame, textvariable=self.fertigungsart_neu, width=AllFrames.get_combo_width(self))
|
|
#self.fertigungsart_neu_combo['values'] = categories
|
|
self.fertigungsart_neu_combo['state'] = 'readonly'
|
|
self.fertigungsart_neu_combo.bind('<<ComboboxSelected>>', lambda event:self.callback('cb_fertigungsart_neu', self.fertigungsart_neu.get()))
|
|
self.fertigungsart_neu_combo.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# Allgmeintoleranz
|
|
allgemeintoleranz_label = ttk.Label(frame, text="Allgemeintoleranz:" )
|
|
allgemeintoleranz_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.allgemeintoleranz_sivas = tk.StringVar()
|
|
allgemeintoleranz_entry = ttk.Entry(frame, textvariable=self.allgemeintoleranz_sivas, state="readonly", width=AllFrames.get_entry_text_width(self))
|
|
allgemeintoleranz_entry.grid(column=col_left+1, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
|
|
self.allgemeintoleranz_neu = tk.StringVar()
|
|
self.allgemeintoleranz_neu_combo = ttk.Combobox(frame, textvariable=self.allgemeintoleranz_neu, width=AllFrames.get_combo_width(self))
|
|
#self.allgemeintoleranz_neu_combo['values'] = categories
|
|
self.allgemeintoleranz_neu_combo['state'] = 'readonly'
|
|
self.allgemeintoleranz_neu_combo.bind('<<ComboboxSelected>>', lambda event:self.callback('cb_allgemeintoleranz_neu', self.allgemeintoleranz_neu.get()))
|
|
self.allgemeintoleranz_neu_combo.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# FOS-Gruppe
|
|
fosGruppe_label = ttk.Label(frame, text="FOS-Gruppe:" )
|
|
fosGruppe_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.fosGruppe_sivas = tk.StringVar()
|
|
fosGruppe_entry = ttk.Entry(frame, textvariable=self.fosGruppe_sivas, state="readonly", width=AllFrames.get_entry_text_width(self))
|
|
fosGruppe_entry.grid(column=col_left+1, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
|
|
self.fosGruppe_neu = tk.StringVar()
|
|
self.fosGruppe_neu_combo = ttk.Combobox(frame, textvariable=self.fosGruppe_neu, width=AllFrames.get_combo_width(self))
|
|
#self.fosGruppe_neu_combo['values'] = categories
|
|
self.fosGruppe_neu_combo['state'] = 'readonly'
|
|
self.fosGruppe_neu_combo.bind('<<ComboboxSelected>>', lambda event:self.callback('cb_fosGruppe_neu', self.fosGruppe_neu.get()))
|
|
self.fosGruppe_neu_combo.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# Kalulationsart
|
|
kalkulationsart_label = ttk.Label(frame, text="Kalkulationsart:" )
|
|
kalkulationsart_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.kalkulationsart_sivas = tk.StringVar()
|
|
kalkulationsart_entry = ttk.Entry(frame, textvariable=self.kalkulationsart_sivas, state="readonly", width=AllFrames.get_entry_text_width(self))
|
|
kalkulationsart_entry.grid(column=col_left+1, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
|
|
self.kalkulationsart_neu = tk.StringVar()
|
|
self.kalkulationsart_neu_combo = ttk.Combobox(frame, textvariable=self.kalkulationsart_neu, width=AllFrames.get_combo_width(self))
|
|
#self.kalkulationsart_neu_combo['values'] = categories
|
|
self.kalkulationsart_neu_combo['state'] = 'readonly'
|
|
self.kalkulationsart_neu_combo.bind('<<ComboboxSelected>>', lambda event:self.callback('cb_kalkulationsart_neu', self.kalkulationsart_neu.get()))
|
|
self.kalkulationsart_neu_combo.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
separator = ttk.Separator(frame, orient='horizontal')
|
|
separator.grid(column=col_left, columnspan=3, row=self.rownum, sticky=tk.EW, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
def get_data(self):
|
|
return {
|
|
"halbzeugOhneSaege_sivas": self.halbzeugOhneSaege_sivas.get(),
|
|
"halbzeugOhneSaege_neu": self.halbzeugOhneSaege_neu.get(),
|
|
"ruestcode_sivas": self.ruestcode_sivas.get(),
|
|
"ruestcode_neu": self.ruestcode_neu.get(),
|
|
"fertigungsart_sivas": self.fertigungsart_sivas.get(),
|
|
"fertigungsart_neu": self.fertigungsart_neu.get(),
|
|
"allgemeintoleranz_sivas": self.allgemeintoleranz_sivas.get(),
|
|
"allgemeintoleranz_neu": self.allgemeintoleranz_neu.get(),
|
|
"fosGruppe_sivas": self.fosGruppe_sivas.get(),
|
|
"fosGruppe_neu": self.fosGruppe_neu.get(),
|
|
"kalkulationsart_sivas": self.kalkulationsart_sivas.get(),
|
|
"kalkulationsart_neu": self.kalkulationsart_neu.get(),
|
|
# ab hier die Dropdowns der Oberfläche auslesen
|
|
"cb_halbzeugOhneSaege_neu" :self.halbzeugOhneSaege_neu_combo['values'],
|
|
"cb_ruestcode_neu" :self.ruestcode_neu_combo['values'],
|
|
"cb_fertigungsart_neu" :self.fertigungsart_neu_combo['values'],
|
|
"cb_allgemeintoleranz_neu" :self.allgemeintoleranz_neu_combo['values'],
|
|
"cb_fosGruppe_neu" :self.fosGruppe_neu_combo['values'],
|
|
"cb_kalkulationsart_neu" :self.kalkulationsart_neu_combo['values']
|
|
}
|
|
|
|
def data_from_model(self):
|
|
data = self.get_controller().get_all_gui_data()
|
|
|
|
if 'halbzeugOhneSaege_sivas' in data:
|
|
self.halbzeugOhneSaege_sivas.set(data["halbzeugOhneSaege_sivas"])
|
|
if 'halbzeugOhneSaege_neu' in data:
|
|
self.halbzeugOhneSaege_neu.set(data["halbzeugOhneSaege_neu"])
|
|
if 'ruestcode_sivas' in data:
|
|
self.ruestcode_sivas.set(data["ruestcode_sivas"])
|
|
if 'ruestcode_neu' in data:
|
|
self.ruestcode_neu.set(data["ruestcode_neu"])
|
|
if 'fertigungsart_sivas' in data:
|
|
self.fertigungsart_sivas.set(data["fertigungsart_sivas"])
|
|
if 'fertigungsart_neu' in data:
|
|
self.fertigungsart_neu.set(data["fertigungsart_neu"])
|
|
if 'allgemeintoleranz_sivas' in data:
|
|
self.allgemeintoleranz_sivas.set(data["allgemeintoleranz_sivas"])
|
|
if 'allgemeintoleranz_neu' in data:
|
|
self.allgemeintoleranz_neu.set(data["allgemeintoleranz_neu"])
|
|
if 'fosGruppe_sivas' in data:
|
|
self.fosGruppe_sivas.set(data["fosGruppe_sivas"])
|
|
if 'fosGruppe_neu' in data:
|
|
self.fosGruppe_neu.set(data["fosGruppe_neu"])
|
|
if 'kalkulationsart_sivas' in data:
|
|
self.kalkulationsart_sivas.set(data["kalkulationsart_sivas"])
|
|
if 'kalkulationsart_neu' in data:
|
|
self.kalkulationsart_neu.set(data["kalkulationsart_neu"])
|
|
# ab hier die Dropdowns der Oberfläche befüllen.
|
|
if 'cb_halbzeugOhneSaege_neu' in data:
|
|
self.halbzeugOhneSaege_neu_combo['values'] = data['cb_halbzeugOhneSaege_neu']
|
|
if 'cb_ruestcode_neu' in data:
|
|
self.ruestcode_neu_combo['values'] = data['cb_ruestcode_neu']
|
|
if 'cb_fertigungsart_neu' in data:
|
|
self.fertigungsart_neu_combo['values'] = data['cb_fertigungsart_neu']
|
|
if 'cb_allgemeintoleranz_neu' in data:
|
|
self.allgemeintoleranz_neu_combo['values'] = data['cb_allgemeintoleranz_neu']
|
|
if 'cb_fosGruppe_neu' in data:
|
|
self.fosGruppe_neu_combo['values'] = data['cb_fosGruppe_neu']
|
|
if 'cb_kalkulationsart_neu' in data:
|
|
self.kalkulationsart_neu_combo['values'] = data['cb_kalkulationsart_neu']
|
|
|
|
def set_states(self):
|
|
data = self.get_controller().get_gui_states()
|
|
pass
|
|
|
|
class RightFrameBeschaffungsart(AllFrames):
|
|
def __init__(self, frame, nrow=0):
|
|
AllFrames.__init__(self, nrow)
|
|
self.frame = frame
|
|
self.build_widgets()
|
|
|
|
def build_widgets(self):
|
|
frame = self.frame
|
|
self.rownum = AllFrames.get_rows(self)
|
|
col_left = 0
|
|
|
|
# Beschaffungsart
|
|
beschaffungsart_label = ttk.Label(frame, text="Beschaffungsart:" )
|
|
beschaffungsart_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.beschaffungsart_sivas = tk.StringVar()
|
|
beschaffungsart_entry = ttk.Entry(frame, textvariable=self.beschaffungsart_sivas, state="readonly", width=AllFrames.get_entry_text_width(self))
|
|
beschaffungsart_entry.grid(column=col_left+1, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
|
|
self.beschaffungsart_neu = tk.StringVar()
|
|
self.beschaffungsart_combo = ttk.Combobox(frame, textvariable=self.beschaffungsart_neu, width=AllFrames.get_combo_width(self))
|
|
#self.beschaffungsart_combo['values'] = categories
|
|
self.beschaffungsart_combo['state'] = 'readonly'
|
|
self.beschaffungsart_combo.bind('<<ComboboxSelected>>', lambda event:self.callback('cb_beschaffungsart_neu', self.beschaffungsart_neu.get()))
|
|
self.beschaffungsart_combo.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# Mengeneinheit
|
|
mengeneinheit_label = ttk.Label(frame, text="Mengeneinheit:" )
|
|
mengeneinheit_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.mengeneinheit_sivas = tk.StringVar()
|
|
mengeneinheit_entry = ttk.Entry(frame, textvariable=self.mengeneinheit_sivas, state="readonly", width=AllFrames.get_entry_text_width(self))
|
|
mengeneinheit_entry.grid(column=col_left+1, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
|
|
self.mengeneinheit_neu = tk.StringVar()
|
|
self.mengeneinheit_combo = ttk.Combobox(frame, textvariable=self.mengeneinheit_neu, width=AllFrames.get_combo_width(self))
|
|
#self.mengeneinheit_combo['values'] = categories
|
|
self.mengeneinheit_combo['state'] = 'readonly'
|
|
self.mengeneinheit_combo.bind('<<ComboboxSelected>>', lambda event:self.callback('cb_mengeneinheit_neu', self.mengeneinheit_neu.get()))
|
|
self.mengeneinheit_combo.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# Halbzeug
|
|
halbzeug_label = ttk.Label(frame, text="Halbzeug:" )
|
|
halbzeug_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.halbzeug_sivas = tk.StringVar()
|
|
halbzeug_entry = ttk.Entry(frame, textvariable=self.halbzeug_sivas, state="readonly", width=AllFrames.get_entry_text_width(self))
|
|
halbzeug_entry.grid(column=col_left+1, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
|
|
self.halbzeug_neu = tk.StringVar()
|
|
self.halbzeug_combo = ttk.Combobox(frame, textvariable=self.halbzeug_neu, width=AllFrames.get_combo_width(self))
|
|
self.halbzeug_combo['values'] = ['ja','nein']
|
|
self.halbzeug_combo['state'] = 'readonly'
|
|
self.halbzeug_combo.bind('<<ComboboxSelected>>', lambda event:self.callback('cb_halbzeug_neu', self.halbzeug_neu.get()))
|
|
self.halbzeug_combo.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
separator = ttk.Separator(frame, orient='horizontal')
|
|
separator.grid(column=col_left, columnspan=3, row=self.rownum, sticky=tk.EW, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
|
|
def get_data(self):
|
|
return {
|
|
"beschaffungsart_sivas": self.beschaffungsart_sivas.get(),
|
|
"beschaffungsart_neu": self.beschaffungsart_neu.get(),
|
|
"mengeneinheit_sivas": self.mengeneinheit_sivas.get(),
|
|
"mengeneinheit_neu": self.mengeneinheit_neu.get(),
|
|
"halbzeug_sivas": self.halbzeug_sivas.get(),
|
|
"halbzeug_neu": self.halbzeug_neu.get(),
|
|
# ab hier die Dropdowns der Oberfläche auslesen.
|
|
"cb_beschaffungsart_neu": self.beschaffungsart_combo['values'],
|
|
"cb_mengeneinheit_neu": self.mengeneinheit_combo['values'],
|
|
"cb_halbzeug_neu": self.halbzeug_combo['values'],
|
|
}
|
|
|
|
def data_from_model(self):
|
|
data = self.get_controller().get_all_gui_data()
|
|
if "beschaffungsart_sivas" in data:
|
|
self.beschaffungsart_sivas.set(data["beschaffungsart_sivas"])
|
|
if "beschaffungsart_neu" in data:
|
|
self.beschaffungsart_neu.set(data["beschaffungsart_neu"])
|
|
if "mengeneinheit_sivas" in data:
|
|
self.mengeneinheit_sivas.set(data["mengeneinheit_sivas"])
|
|
if "mengeneinheit_neu" in data:
|
|
self.mengeneinheit_neu.set(data["mengeneinheit_neu"])
|
|
if "halbzeug_sivas" in data:
|
|
self.halbzeug_sivas.set(data["halbzeug_sivas"])
|
|
if "halbzeug_neu" in data:
|
|
self.halbzeug_neu.set(data["halbzeug_neu"])
|
|
# ab hier die Dropdowns der Oberfläche befüllen.
|
|
if "cb_beschaffungsart_neu" in data:
|
|
self.beschaffungsart_combo['values'] = data["cb_beschaffungsart_neu"]
|
|
if "cb_mengeneinheit_neu" in data:
|
|
self.mengeneinheit_combo['values'] = data["cb_mengeneinheit_neu"]
|
|
if "cb_halbzeug_neu" in data:
|
|
self.halbzeug_combo['values'] = data["cb_halbzeug_neu"]
|
|
|
|
def set_states(self):
|
|
data = self.get_controller().get_gui_states()
|
|
pass
|
|
|
|
class RightFrameTOSGruppe(AllFrames):
|
|
def __init__(self, frame, nrow=0):
|
|
AllFrames.__init__(self, nrow)
|
|
self.frame = frame
|
|
self.build_widgets()
|
|
|
|
def build_widgets(self):
|
|
frame = self.frame
|
|
self.rownum = AllFrames.get_rows(self)
|
|
col_left = 0
|
|
|
|
# TOS-Gruppe
|
|
tosgruppe_label = ttk.Label(frame, text="TOS-Gruppe:" )
|
|
tosgruppe_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.tosgruppe_sivas = tk.StringVar()
|
|
tosgruppe_entry = ttk.Entry(frame, textvariable=self.tosgruppe_sivas, state="readonly", width=AllFrames.get_entry_text_width(self))
|
|
tosgruppe_entry.grid(column=col_left+1, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.tosgruppe_neu = tk.StringVar()
|
|
tosgruppe_neu_entry = ttk.Entry(frame, textvariable=self.tosgruppe_neu, width=AllFrames.get_entry_text_width(self))
|
|
tosgruppe_neu_entry.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# Dispogruppe
|
|
dispogruppe_label = ttk.Label(frame, text="Dispogruppe:" )
|
|
dispogruppe_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.dispogruppe_sivas = tk.StringVar()
|
|
dispogruppe_entry = ttk.Entry(frame, textvariable=self.dispogruppe_sivas, state="readonly", width=AllFrames.get_entry_text_width(self))
|
|
dispogruppe_entry.grid(column=col_left+1, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
|
|
self.dispogruppe_neu = tk.StringVar()
|
|
self.dispogruppe_neu_combo = ttk.Combobox(frame, textvariable=self.dispogruppe_neu, width=AllFrames.get_combo_width(self))
|
|
#self.dispogruppe_neu_combo['values'] = categories
|
|
self.dispogruppe_neu_combo['state'] = 'readonly'
|
|
self.dispogruppe_neu_combo.bind('<<ComboboxSelected>>', lambda event:self.callback('cb_dispogruppe_neu', self.dispogruppe_neu.get()))
|
|
self.dispogruppe_neu_combo.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# Dispolaufgruppe
|
|
dispolaufgruppe_label = ttk.Label(frame, text="Dispolaufgruppe:" )
|
|
dispolaufgruppe_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.dispolaufgruppe_sivas = tk.StringVar()
|
|
dispolaufgruppe_entry = ttk.Entry(frame, textvariable=self.dispolaufgruppe_sivas, state="readonly", width=AllFrames.get_entry_text_width(self))
|
|
dispolaufgruppe_entry.grid(column=col_left+1, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
|
|
self.dispolaufgruppe_neu = tk.StringVar()
|
|
self.dispolaufgruppe_neu_combo = ttk.Combobox(frame, textvariable=self.dispolaufgruppe_neu, width=AllFrames.get_combo_width(self))
|
|
#self.dispolaufgruppe_neu_combo['values'] = categories
|
|
self.dispolaufgruppe_neu_combo['state'] = 'readonly'
|
|
self.dispolaufgruppe_neu_combo.bind('<<ComboboxSelected>>', lambda event:self.callback('cb_dispolaufgruppe_neu', self.dispolaufgruppe_neu.get()))
|
|
self.dispolaufgruppe_neu_combo.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# Ersatz für
|
|
ersatzfuer_label = ttk.Label(frame, text="Ersatz für:" )
|
|
ersatzfuer_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.ersatzfuer_sivas = tk.StringVar()
|
|
ersatzfuer_entry = ttk.Entry(frame, textvariable=self.ersatzfuer_sivas, state="readonly", width=AllFrames.get_entry_text_width(self))
|
|
ersatzfuer_entry.grid(column=col_left+1, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.ersatzfuer_neu = tk.StringVar()
|
|
ersatzfuer_neu_entry = ttk.Entry(frame, textvariable=self.ersatzfuer_neu, width=AllFrames.get_entry_text_width(self))
|
|
ersatzfuer_neu_entry.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# Ersetzt durch
|
|
ersetztdurch_label = ttk.Label(frame, text="Ersetzt durch:" )
|
|
ersetztdurch_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.ersetztdurch_sivas = tk.StringVar()
|
|
ersetztdurch_entry = ttk.Entry(frame, textvariable=self.ersetztdurch_sivas, state="readonly", width=AllFrames.get_entry_text_width(self))
|
|
ersetztdurch_entry.grid(column=col_left+1, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.ersetztdurch_neu = tk.StringVar()
|
|
ersetztdurch_neu_entry = ttk.Entry(frame, textvariable=self.ersetztdurch_neu, width=AllFrames.get_entry_text_width(self))
|
|
ersetztdurch_neu_entry.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
# Ersetzt durch
|
|
|
|
# Hersteller
|
|
hersteller_label = ttk.Label(frame, text="Hersteller:" )
|
|
hersteller_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.hersteller_sivas = tk.StringVar()
|
|
hersteller_entry = ttk.Entry(frame, textvariable=self.hersteller_sivas, state="readonly", width=AllFrames.get_entry_text_width(self))
|
|
hersteller_entry.grid(column=col_left+1, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
|
|
self.hersteller_neu = tk.StringVar()
|
|
self.hersteller_neu_combo = ttk.Combobox(frame, textvariable=self.hersteller_neu, width=AllFrames.get_combo_width(self))
|
|
#self.hersteller_neu_combo['values'] = categories
|
|
self.hersteller_neu_combo['state'] = 'readonly'
|
|
self.hersteller_neu_combo.bind('<<ComboboxSelected>>', lambda event:self.callback('cb_hersteller_neu', self.hersteller_neu.get()))
|
|
self.hersteller_neu_combo.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# Hersteller Teilenummer
|
|
herstteilenr_label = ttk.Label(frame, text="Hersteller Teilenummer:" )
|
|
herstteilenr_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.herstteilenr_sivas = tk.StringVar()
|
|
herstteilenr_entry = ttk.Entry(frame, textvariable=self.herstteilenr_sivas, state="readonly", width=AllFrames.get_entry_text_width(self))
|
|
herstteilenr_entry.grid(column=col_left+1, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.herstteilenr_neu = tk.StringVar()
|
|
herstteilenr_neu_entry = ttk.Entry(frame, textvariable=self.herstteilenr_neu, width=AllFrames.get_entry_text_width(self))
|
|
herstteilenr_neu_entry.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
# Ersetzt durch
|
|
|
|
separator = ttk.Separator(frame, orient='horizontal')
|
|
separator.grid(column=col_left, columnspan=3, row=self.rownum, sticky=tk.EW, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
|
|
def get_data(self):
|
|
return {
|
|
"tosgruppe_neu": self.tosgruppe_neu.get(),
|
|
"tosgruppe_sivas": self.tosgruppe_sivas.get(),
|
|
"dispogruppe_neu": self.dispogruppe_neu.get(),
|
|
"dispogruppe_sivas": self.dispogruppe_sivas.get(),
|
|
"dispolaufgruppe_neu": self.dispolaufgruppe_neu.get(),
|
|
"dispolaufgruppe_sivas": self.dispolaufgruppe_sivas.get(),
|
|
"hersteller_neu": self.hersteller_neu.get(),
|
|
"hersteller_sivas": self.hersteller_sivas.get(),
|
|
"ersatzfuer_neu": self.ersatzfuer_neu.get(),
|
|
"ersatzfuer_sivas": self.ersatzfuer_sivas.get(),
|
|
"ersetztdurch_neu": self.ersetztdurch_neu.get(),
|
|
"ersetztdurch_sivas": self.ersetztdurch_sivas.get(),
|
|
"herstteilenr_sivas": self.herstteilenr_sivas.get(),
|
|
"herstteilenr_neu": self.herstteilenr_neu.get(),
|
|
# ab hier die Dropdowns der Oberfläche auslesen.
|
|
"cb_dispogruppe_neu": self.dispogruppe_neu_combo['values'],
|
|
"cb_dispolaufgruppe_neu": self.dispolaufgruppe_neu_combo['values'],
|
|
"cb_hersteller_neu": self.hersteller_neu_combo['values'],
|
|
}
|
|
|
|
def data_from_model(self):
|
|
data = self.get_controller().get_all_gui_data()
|
|
if 'tosgruppe_sivas' in data:
|
|
self.tosgruppe_sivas.set(data["tosgruppe_sivas"])
|
|
if 'tosgruppe_neu' in data:
|
|
self.tosgruppe_neu.set(data["tosgruppe_neu"])
|
|
if 'dispogruppe_sivas' in data:
|
|
self.dispogruppe_sivas.set(data["dispogruppe_sivas"])
|
|
if 'dispogruppe_neu' in data:
|
|
self.dispogruppe_neu.set(data["dispogruppe_neu"])
|
|
if 'dispolaufgruppe_sivas' in data:
|
|
self.dispolaufgruppe_sivas.set(data["dispolaufgruppe_sivas"])
|
|
if 'dispolaufgruppe_neu' in data:
|
|
self.dispolaufgruppe_neu.set(data["dispolaufgruppe_neu"])
|
|
if 'ersatzfuer_sivas' in data:
|
|
self.ersatzfuer_sivas.set(data["ersatzfuer_sivas"])
|
|
if 'ersatzfuer_neu' in data:
|
|
self.ersatzfuer_neu.set(data["ersatzfuer_neu"])
|
|
if 'ersetztdurch_sivas' in data:
|
|
self.ersetztdurch_sivas.set(data["ersetztdurch_sivas"])
|
|
if 'ersetztdurch_neu' in data:
|
|
self.ersetztdurch_neu.set(data["ersetztdurch_neu"])
|
|
if 'hersteller_sivas' in data:
|
|
self.hersteller_sivas.set(data["hersteller_sivas"])
|
|
if 'hersteller_neu' in data:
|
|
self.hersteller_neu.set(data["hersteller_neu"])
|
|
if 'herstteilenr_sivas' in data:
|
|
self.herstteilenr_sivas.set(data["herstteilenr_sivas"])
|
|
if 'herstteilenr_neu' in data:
|
|
self.herstteilenr_neu.set(data["herstteilenr_neu"])
|
|
# ab hier die Dropdowns der Oberfläche befüllen.
|
|
if "cb_dispogruppe_neu" in data:
|
|
self.dispogruppe_neu_combo['values'] = data["cb_dispogruppe_neu"]
|
|
if "cb_dispolaufgruppe_neu" in data:
|
|
self.dispolaufgruppe_neu_combo['values'] = data["cb_dispolaufgruppe_neu"]
|
|
if "cb_hersteller_neu" in data:
|
|
self.hersteller_neu_combo['values'] = data["cb_hersteller_neu"]
|
|
|
|
def set_states(self):
|
|
data = self.get_controller().get_gui_states()
|
|
pass
|
|
|
|
class RightFrameWerkstoffdiskrepanz(AllFrames):
|
|
def __init__(self, frame, nrow=0):
|
|
AllFrames.__init__(self, nrow)
|
|
self.frame = frame
|
|
self.build_widgets()
|
|
|
|
def build_widgets(self):
|
|
frame = self.frame
|
|
self.rownum = AllFrames.get_rows(self)
|
|
col_left = 0
|
|
|
|
# wnamen = configs.Werkstoffe.get_werkstoff_namen()
|
|
|
|
# Werkstoffdiskrepanz
|
|
werkstoffdiskr_label = ttk.Label(frame, text="Werkstoffdiskrepanz:")
|
|
werkstoffdiskr_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
|
|
self.werkstoffdiskr_sivas= tk.BooleanVar()
|
|
werkstoffdiskr_checkbutton = ttk.Checkbutton(frame,
|
|
#text='ja',
|
|
variable=self.werkstoffdiskr_sivas,
|
|
command=lambda: self.callback("cb_werkstoffdiskrepanz", self.werkstoffdiskr_sivas.get()),
|
|
onvalue=True,
|
|
offvalue=False)
|
|
werkstoffdiskr_checkbutton.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# Werkstofftyp
|
|
werkstofftyp_label = ttk.Label(frame, text="Werkstofftyp:" )
|
|
werkstofftyp_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.werkstofftyp_neu = tk.StringVar()
|
|
self.werkstofftyp_neu_combo = ttk.Combobox(frame, textvariable=self.werkstofftyp_neu, width=AllFrames.get_combo_width(self))
|
|
# self.werkstofftyp_neu_combo['values'] = wnamen
|
|
self.werkstofftyp_neu_combo['state'] = 'readonly'
|
|
self.werkstofftyp_neu_combo.bind('<<ComboboxSelected>>', lambda event:self.callback('cb_werkstofftyp_neu', self.werkstofftyp_neu.get()))
|
|
self.werkstofftyp_neu_combo.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# Material
|
|
material_label = ttk.Label(frame, text="Material:" )
|
|
material_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.material_sivas = tk.StringVar()
|
|
material_entry = ttk.Entry(frame, textvariable=self.material_sivas, state="readonly", width=AllFrames.get_entry_text_width(self))
|
|
material_entry.grid(column=col_left+1, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
|
|
self.material_neu = tk.StringVar()
|
|
self.material_neu_combo = ttk.Combobox(frame, textvariable=self.material_neu, width=AllFrames.get_combo_width(self))
|
|
self.material_neu_combo['state'] = 'readonly'
|
|
self.material_neu_combo.bind('<<ComboboxSelected>>', lambda event:self.callback('cb_material_neu', self.material_neu.get()))
|
|
self.material_neu_combo.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
|
|
# Oberfläche
|
|
oberflaeche_label = ttk.Label(frame, text="Oberfläche:" )
|
|
oberflaeche_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
|
|
self.oberflaeche_neu = tk.StringVar()
|
|
self.oberflaeche_neu_combo = ttk.Combobox(frame, textvariable=self.oberflaeche_neu, width=AllFrames.get_combo_width(self))
|
|
self.oberflaeche_neu_combo['state'] = 'readonly'
|
|
self.oberflaeche_neu_combo.bind('<<ComboboxSelected>>', lambda event:self.callback('cb_oberflaeche_neu', self.oberflaeche_neu.get()))
|
|
self.oberflaeche_neu_combo.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# Farbe
|
|
farbe_label = ttk.Label(frame, text="Farbe:" )
|
|
farbe_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
|
|
self.farbe_neu = tk.StringVar()
|
|
self.farbe_neu_combo = ttk.Combobox(frame, textvariable=self.farbe_neu, width=AllFrames.get_combo_width(self))
|
|
self.farbe_neu_combo['state'] = 'readonly'
|
|
self.farbe_neu_combo.bind('<<ComboboxSelected>>', lambda event:self.callback('cb_farbe_neu', self.farbe_neu.get()))
|
|
self.farbe_neu_combo.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
separator = ttk.Separator(frame, orient='horizontal')
|
|
separator.grid(column=col_left, columnspan=3, row=self.rownum, sticky=tk.EW, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
def get_data(self):
|
|
return {
|
|
"werkstoffdiskr_sivas": self.werkstoffdiskr_sivas.get(),
|
|
"werkstofftyp_neu": self.werkstofftyp_neu.get(),
|
|
"material_sivas": self.material_sivas.get(),
|
|
"material_neu": self.material_neu.get(),
|
|
"oberflaeche_neu": self.oberflaeche_neu.get(),
|
|
"farbe_neu": self.farbe_neu.get(),
|
|
# ab hier die Dropdowns der Oberfläche
|
|
"cb_werkstofftyp_neu": self.werkstofftyp_neu_combo['values'],
|
|
"cb_material_neu": self.material_neu_combo['values'],
|
|
"cb_oberflaeche_neu": self.oberflaeche_neu_combo['values'],
|
|
"cb_farbe_neu": self.farbe_neu_combo['values'],
|
|
}
|
|
|
|
def data_from_model(self):
|
|
data = self.get_controller().get_all_gui_data()
|
|
if 'werkstoffdiskr_sivas' in data:
|
|
self.werkstoffdiskr_sivas.set((data["werkstoffdiskr_sivas"]))
|
|
if 'werkstofftyp_neu' in data:
|
|
self.werkstofftyp_neu.set(data["werkstofftyp_neu"])
|
|
if 'material_sivas' in data:
|
|
self.material_sivas.set(data["material_sivas"])
|
|
if 'material_neu' in data:
|
|
self.material_neu.set(data["material_neu"])
|
|
if 'oberflaeche_neu' in data:
|
|
self.oberflaeche_neu.set(data["oberflaeche_neu"])
|
|
if 'farbe_neu' in data:
|
|
self.farbe_neu.set(data["farbe_neu"])
|
|
# ab hier die Dropdowns der Oberfläche befüllen.
|
|
if 'cb_werkstofftyp_neu' in data:
|
|
self.werkstofftyp_neu_combo['values'] = data["cb_werkstofftyp_neu"]
|
|
if 'cb_material_neu' in data:
|
|
self.material_neu_combo['values'] = data["cb_material_neu"]
|
|
if 'cb_oberflaeche_neu' in data:
|
|
self.oberflaeche_neu_combo['values'] = data["cb_oberflaeche_neu"]
|
|
if 'cb_farbe_neu' in data:
|
|
self.farbe_neu_combo['values'] = data["cb_farbe_neu"]
|
|
|
|
def set_states(self):
|
|
data = self.get_controller().get_gui_states()
|
|
pass
|
|
|
|
class RightFrameVersion(AllFrames):
|
|
def __init__(self, frame, nrow=0):
|
|
AllFrames.__init__(self, nrow)
|
|
self.frame = frame
|
|
self.build_widgets()
|
|
|
|
def build_widgets(self):
|
|
frame = self.frame
|
|
self.rownum = AllFrames.get_rows(self)
|
|
col_left = 0
|
|
|
|
# Version
|
|
version_label = ttk.Label(frame, text="Version:" )
|
|
version_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.version_sivas = tk.StringVar()
|
|
version_entry = ttk.Entry(frame, textvariable=self.version_sivas, state="readonly", width=AllFrames.get_entry_text_width(self))
|
|
version_entry.grid(column=col_left+1, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.version_neu = tk.StringVar()
|
|
version_neu_entry = ttk.Entry(frame, textvariable=self.version_neu, width=AllFrames.get_entry_text_width(self))
|
|
version_neu_entry.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
|
|
# Änderungsindex
|
|
aenderungsindex_label = ttk.Label(frame, text="Änderungsindex:" )
|
|
aenderungsindex_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.aenderungsindex_sivas = tk.StringVar()
|
|
aenderungsindex_entry = ttk.Entry(frame, textvariable=self.aenderungsindex_sivas, state="readonly", width=AllFrames.get_entry_text_width(self))
|
|
aenderungsindex_entry.grid(column=col_left+1, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.aenderungsindex_neu = tk.StringVar()
|
|
aenderungsindex_neu_entry = ttk.Entry(frame, textvariable=self.aenderungsindex_neu, width=AllFrames.get_entry_text_width(self))
|
|
aenderungsindex_neu_entry.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# Änderungstext
|
|
aenderungstext_label = ttk.Label(frame, text="Änderungstext:" )
|
|
aenderungstext_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
|
|
self.aenderungstext_sivas = tk.Text(frame, height=3, width=AllFrames.get_text_width(self), font=("Calibri",10))
|
|
self.aenderungstext_sivas.grid(column=col_left+1, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
|
|
self.aenderungstext_neu = tk.Text(frame, height=3, width=AllFrames.get_text_width(self), font=("Calibri",10))
|
|
self.aenderungstext_neu.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# Freigabevermerk
|
|
freigabevermerk_label = ttk.Label(frame, text="Freigabevermerk:" )
|
|
freigabevermerk_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
|
|
self.freigabevermerk_sivas = tk.Text(frame, height=3, width=AllFrames.get_text_width(self), font=("Calibri",10))
|
|
self.freigabevermerk_sivas.grid(column=col_left+1, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
|
|
self.freigabevermerk_neu = tk.Text(frame,height=3, width=AllFrames.get_text_width(self), font=("Calibri",10) )
|
|
self.freigabevermerk_neu.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
separator = ttk.Separator(frame, orient='horizontal')
|
|
separator.grid(column=col_left, columnspan=3, row=self.rownum, sticky=tk.EW, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
|
|
def get_data(self):
|
|
return {
|
|
"version_sivas": self.version_sivas.get(),
|
|
"version_neu": self.version_neu.get(),
|
|
"aenderungsindex_sivas": self.aenderungsindex_sivas.get(),
|
|
"aenderungsindex_neu": self.aenderungsindex_neu.get(),
|
|
"aenderungstext_sivas": self.aenderungstext_sivas.get('1.0', 'end'),
|
|
"aenderungstext_neu": self.aenderungstext_neu.get('1.0', 'end'),
|
|
"freigabevermerk_sivas": self.freigabevermerk_sivas.get('1.0', 'end'),
|
|
"freigabevermerk_neu": self.freigabevermerk_neu.get('1.0', 'end'),
|
|
}
|
|
|
|
def data_from_model(self):
|
|
data = self.get_controller().get_all_gui_data()
|
|
if 'version_sivas' in data:
|
|
self.version_sivas.set(data["version_sivas"])
|
|
if 'version_neu' in data:
|
|
self.version_neu.set(data["version_neu"])
|
|
if 'aenderungsindex_sivas' in data:
|
|
self.aenderungsindex_sivas.set(data["aenderungsindex_sivas"])
|
|
if 'aenderungsindex_neu' in data:
|
|
self.aenderungsindex_neu.set(data["aenderungsindex_neu"])
|
|
if 'aenderungstext_sivas' in data:
|
|
text = data["aenderungstext_sivas"]
|
|
if text:
|
|
self.aenderungstext_sivas.insert('1.0', text)
|
|
if 'aenderungstext_neu' in data:
|
|
text = data["freigabevermerk_neu"]
|
|
if text:
|
|
self.aenderungstext_neu.insert('1.0', text)
|
|
if 'freigabevermerk_sivas' in data:
|
|
text = data["freigabevermerk_neu"]
|
|
if text:
|
|
self.freigabevermerk_sivas.insert('1.0', text)
|
|
if 'freigabevermerk_neu' in data:
|
|
text = data["freigabevermerk_neu"]
|
|
if text:
|
|
self.freigabevermerk_neu.insert('1.0', text)
|
|
|
|
def set_states(self):
|
|
data = self.get_controller().get_gui_states()
|
|
pass
|
|
|
|
def clear_texts(self):
|
|
self.aenderungstext_sivas.delete('1.0', 'end')
|
|
self.aenderungstext_neu.delete('1.0', 'end')
|
|
self.freigabevermerk_sivas.delete('1.0', 'end')
|
|
self.freigabevermerk_neu.delete('1.0', 'end')
|
|
|
|
class RightFrameZusatzinfos(AllFrames):
|
|
def __init__(self, frame, nrow=0):
|
|
AllFrames.__init__(self, nrow)
|
|
self.frame = frame
|
|
self.build_widgets()
|
|
|
|
def build_widgets(self):
|
|
frame = self.frame
|
|
self.rownum = AllFrames.get_rows(self)
|
|
col_left = 0
|
|
|
|
# Zusatzinformationen automatisch
|
|
zusatzinfos_auto_label = ttk.Label(frame, text="Zusatzinformationen\nautomatisch:")
|
|
zusatzinfos_auto_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
|
|
self.zusatzinfos_auto_text = tk.Text(frame, height=3, width=AllFrames.get_text_width(self), font=("Calibri",10))
|
|
self.zusatzinfos_auto_text.grid(column=col_left+1, columnspan=2, row=self.rownum, sticky=tk.EW+tk.NS, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# Zusatzinformationen Benutzerdefiniert
|
|
zusatzinfos_bendef_label = ttk.Label(frame, text="Zusatzinformationen\nBenutzerdefiniert:")
|
|
zusatzinfos_bendef_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
|
|
self.zusatzinfos_bendef_text = tk.Text(frame, height=3, width=AllFrames.get_text_width(self), font=("Calibri",10))
|
|
self.zusatzinfos_bendef_text.grid(column=col_left+1, columnspan=2, row=self.rownum, sticky=tk.EW+tk.NS, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
separator = ttk.Separator(frame, orient='horizontal')
|
|
separator.grid(column=col_left, columnspan=3, row=self.rownum, sticky=tk.EW, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
speichern_button = ttk.Button(frame, text="Speichern", command=lambda: self.callback("cb_speichern", None))
|
|
speichern_button.grid(column=col_left, row=self.rownum, sticky=tk.EW, padx=3, pady=3)
|
|
migrieren_button = ttk.Button(frame, text="migrieren", command=lambda: self.callback("cb_migrieren", None))
|
|
migrieren_button.grid(column=col_left+1, row=self.rownum, sticky=tk.EW, padx=3, pady=3)
|
|
zuruecksetzen_button = ttk.Button(frame, text="zurücksetzen", command=lambda: self.callback("cb_zurücksetzen", None))
|
|
zuruecksetzen_button.grid(column=col_left+2, row=self.rownum, sticky=tk.EW, padx=3, pady=3)
|
|
|
|
def get_data(self):
|
|
return {
|
|
"zusatzinfos_auto_text": self.zusatzinfos_auto_text.get('1.0', 'end'),
|
|
"zusatzinfos_bendef_text": self.zusatzinfos_bendef_text.get('1.0', 'end'),
|
|
}
|
|
|
|
def data_from_model(self):
|
|
data = self.get_controller().get_all_gui_data()
|
|
if 'zusatzinfos_auto_text' in data:
|
|
text = data["zusatzinfos_auto_text"]
|
|
if text:
|
|
self.zusatzinfos_auto_text.insert('1.0', text)
|
|
if 'zusatzinfos_bendef_text' in data:
|
|
text = data["zusatzinfos_bendef_text"]
|
|
if text:
|
|
self.zusatzinfos_bendef_text.insert('1.0', text)
|
|
|
|
def set_states(self):
|
|
data = self.get_controller().get_gui_states()
|
|
pass
|
|
|
|
def clear_texts(self):
|
|
self.zusatzinfos_auto_text.delete('1.0', 'end')
|
|
self.zusatzinfos_bendef_text.delete('1.0', 'end')
|
|
|
|
class App():
|
|
def __init__(self, root):
|
|
"""Standardgui mit Baum zur Anwahl der Teile des Assemblies"""
|
|
|
|
self._root = root
|
|
self.build_widgets()
|
|
|
|
def build_widgets(self):
|
|
""" baue alle Frames der Gui auf
|
|
"""
|
|
|
|
# configure the grid
|
|
# die erste Spalte mit Baum sollte unbeweglich bleiben bei Vergrößerung des Fensters.
|
|
# self._root.columnconfigure(0, weight=2)
|
|
#self._root.columnconfigure(1, weight=1)
|
|
#self._root.geometry('800x800')
|
|
|
|
style = ttk.Style(self._root)
|
|
style.theme_use('clam')
|
|
|
|
# gesamtes Fenster durch Scrollbar, aber auch mit Mausrad verschieben
|
|
self._root.bind('<MouseWheel>', self.OnMouseWheel)
|
|
|
|
container = ttk.Frame(self._root)
|
|
self._canvas = tk.Canvas(container, width=950, height=900)
|
|
# canvas = tk.Canvas(container)
|
|
|
|
# baue eine globale Scrollbar ganz rechts
|
|
vscrollbar = ttk.Scrollbar(container, orient='vertical', command=self._canvas.yview)
|
|
|
|
# verknüpfe Scrollbar und Canvas
|
|
self._canvas.bind(
|
|
'<Configure>',
|
|
lambda e: self._canvas.configure(
|
|
scrollregion=self._canvas.bbox("all")
|
|
)
|
|
)
|
|
self._canvas.configure(yscrollcommand=vscrollbar.set)
|
|
#self._root.grid_columnconfigure(0, weight=0)
|
|
|
|
inner_frame = ttk.Frame(self._canvas)
|
|
self._canvas.create_window((0, 0), window=inner_frame, anchor="nw")
|
|
|
|
# Canvas-Größe anpassen
|
|
self._canvas.update_idletasks()
|
|
self._canvas.config(scrollregion=self._canvas.bbox("all"))
|
|
|
|
container.pack()
|
|
self._canvas.pack(side="left", fill="both", expand=True)
|
|
vscrollbar.pack(side="right", fill="y", expand=False)
|
|
|
|
# einen linken und rechten Rahmen darin
|
|
# left_frame = ttk.Frame(inner_frame, width=200, height=800)
|
|
left_frame = ttk.Frame(inner_frame)
|
|
#left_frame.grid(row=0, column=0, padx=10, pady=3)
|
|
left_frame.pack(side='left', expand=False)
|
|
|
|
# right_frame = ttk.Frame(inner_frame, width=650, height=800)
|
|
right_frame = ttk.Frame(inner_frame)
|
|
#right_frame.grid(row=0, column=1, padx=10, pady=3)
|
|
right_frame.pack(side='left', expand=True)
|
|
|
|
# self._canvas.columnconfigure(0, weight=1)
|
|
# self._canvas.columnconfigure(1, weight=6)
|
|
# left_frame.columnconfigure(0, weight=1)
|
|
# right_frame.columnconfigure(0, weight=6)
|
|
|
|
|
|
self.lf1 = LeftFrameAsm(left_frame, 0)
|
|
nrows = self.lf1.get_rows()
|
|
self.lf2 = TreeView(left_frame, nrows)
|
|
|
|
self.rf1 = RightFrameLabels(right_frame, 0)
|
|
nrows = self.rf1.get_rows()
|
|
self.rf2 = RightFramePDM(right_frame, nrows)
|
|
nrows = self.rf2.get_rows()
|
|
self.rf3 = RightFrameBezeichnung(right_frame, nrows)
|
|
nrows = self.rf3.get_rows()
|
|
self.rf4 = RightFrameHalbzeugOhneS(right_frame, nrows)
|
|
nrows = self.rf4.get_rows()
|
|
self.rf5 = RightFrameBeschaffungsart(right_frame, nrows)
|
|
nrows = self.rf5.get_rows()
|
|
self.rf6 = RightFrameTOSGruppe(right_frame, nrows)
|
|
nrows = self.rf6.get_rows()
|
|
self.rf7 = RightFrameWerkstoffdiskrepanz(right_frame, nrows)
|
|
nrows = self.rf7.get_rows()
|
|
self.rf8 = RightFrameVersion(right_frame, nrows)
|
|
nrows = self.rf8.get_rows()
|
|
self.rf9 = RightFrameZusatzinfos(right_frame, nrows)
|
|
nrows = self.rf9.get_rows()
|
|
|
|
def data_from_model(self):
|
|
""" methode zum Auslesen aller Daten der Oberfläche aus dem Modell
|
|
"""
|
|
self.clear_texts()
|
|
self.lf1.data_from_model()
|
|
self.lf2.data_from_model()
|
|
|
|
self.rf1.data_from_model()
|
|
self.rf2.data_from_model()
|
|
self.rf3.data_from_model()
|
|
self.rf4.data_from_model()
|
|
self.rf5.data_from_model()
|
|
self.rf6.data_from_model()
|
|
self.rf7.data_from_model()
|
|
self.rf8.data_from_model()
|
|
self.rf9.data_from_model()
|
|
|
|
def clear_texts(self):
|
|
self.rf8.clear_texts()
|
|
self.rf9.clear_texts()
|
|
|
|
def set_states(self):
|
|
# not used. So not implemented:
|
|
#self.lf1.set_states()
|
|
#self.lf2.set_states()
|
|
|
|
self.rf1.set_states()
|
|
self.rf2.set_states()
|
|
self.rf3.set_states()
|
|
self.rf4.set_states()
|
|
self.rf5.set_states()
|
|
self.rf6.set_states()
|
|
self.rf7.set_states()
|
|
self.rf8.set_states()
|
|
self.rf9.set_states()
|
|
|
|
|
|
def data_from_view(self, key=None):
|
|
ret = dict()
|
|
ret.update(self.lf1.get_data())
|
|
#self.lf2.get_data() tree hat kein get_data
|
|
|
|
ret.update(self.rf1.get_data())
|
|
ret.update(self.rf2.get_data())
|
|
ret.update(self.rf3.get_data())
|
|
ret.update(self.rf4.get_data())
|
|
ret.update(self.rf5.get_data())
|
|
ret.update(self.rf6.get_data())
|
|
ret.update(self.rf7.get_data())
|
|
ret.update(self.rf8.get_data())
|
|
ret.update(self.rf9.get_data())
|
|
|
|
if key:
|
|
return ret[key]
|
|
else:
|
|
return ret
|
|
|
|
def set_controller(self, controller):
|
|
""" merken des Handels auf den Controller in jedem Widget"""
|
|
self._controller = controller
|
|
|
|
self.lf1.set_controller(controller)
|
|
self.lf2.set_controller(controller)
|
|
|
|
self.rf1.set_controller(controller)
|
|
self.rf2.set_controller(controller)
|
|
self.rf3.set_controller(controller)
|
|
self.rf4.set_controller(controller)
|
|
self.rf5.set_controller(controller)
|
|
self.rf6.set_controller(controller)
|
|
self.rf7.set_controller(controller)
|
|
self.rf8.set_controller(controller)
|
|
self.rf9.set_controller(controller)
|
|
|
|
def mainloop(self):
|
|
self._root.mainloop()
|
|
|
|
def OnMouseWheel(self,event):
|
|
self._canvas.yview("scroll", event.delta, "units")
|
|
return "break"
|
|
|
|
def suche_3d(self):
|
|
"""create a new window with the file search dialog"""
|
|
toplevel = tk.Toplevel()
|
|
toplevel.title("search Window")
|
|
selected = filename = filedialog.askopenfilename(
|
|
parent=toplevel,
|
|
initialdir= os.getcwd(),
|
|
title="please select .par or .asm file",
|
|
filetypes=[("Part-Dokumente", ".par"), ("Assembly-Dokumente", ".asm")]
|
|
)
|
|
toplevel.destroy()
|
|
return selected
|
|
|
|
if __name__ == "__main__":
|
|
|
|
""" using the Model-View-Controller (MVC) Pattern
|
|
- The MODEL is responsible for managing the data of the application. It
|
|
receives user input from the CONTROLLER
|
|
- The VIEW renders presentation of the model in a particular format.
|
|
- The CONTROLLER responds to the user input and performs interactions on the
|
|
data model objects. The CONTROLLER receives the input, optionally validates
|
|
it and then passes the input to the model.
|
|
|
|
<CONTROLLER>
|
|
<--fills gui -- --manipulates-->
|
|
--user input-> <--give model data--
|
|
<VIEW> <MODEL>
|
|
|
|
"""
|