1946 lines
94 KiB
Python
1946 lines
94 KiB
Python
import tkinter as tk
|
|
from tkinter import ttk
|
|
from tkinter import filedialog
|
|
import os
|
|
import re
|
|
|
|
#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
|
|
self.tree = ttk.Treeview(frame, height=65) # 'height' steuert Anzahl der sichtbaren Zeilen im Baum
|
|
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:
|
|
|
|
self.trid2sivasId = dict()
|
|
|
|
def set_heading_text(self, parent_children_mapping, red_ids):
|
|
done_items = set()
|
|
undone_items = set()
|
|
for parent,children in parent_children_mapping.items():
|
|
if parent is None:
|
|
pass
|
|
elif parent in red_ids:
|
|
undone_items.add(parent)
|
|
else:
|
|
done_items.add(parent)
|
|
for c in children:
|
|
if c in red_ids:
|
|
undone_items.add(c)
|
|
else:
|
|
done_items.add(c)
|
|
num_done = len(done_items)
|
|
num_undone = len(undone_items)
|
|
if num_done + num_undone == 0:
|
|
percentage = 0
|
|
else:
|
|
percentage = round(num_done / (num_done + num_undone) * 100, 1)
|
|
|
|
heading = "{percent}% ({done} ✔, {undone} ☐)".format(percent=percentage, done=num_done, undone=num_undone)
|
|
self.tree.heading('#0', text=heading, anchor=tk.W)
|
|
|
|
|
|
def set_controller(self, controller):
|
|
self._controller = controller
|
|
|
|
def refresh(self, parent_children_mapping, red_ids, orange_ids):
|
|
self.clear()
|
|
self.set_heading_text(parent_children_mapping, red_ids)
|
|
self.create(parent_children_mapping, red_ids, orange_ids)
|
|
|
|
def clear(self):
|
|
for c in self.tree.get_children():
|
|
self.tree.delete(c)
|
|
|
|
def _has_childs(self, sid, parent_children_mapping):
|
|
'''gibt zurück ob sivas-id ein Zwischenknoten eines Baume ist, also kein Blatt hat'''
|
|
return True if sid in parent_children_mapping else False
|
|
|
|
def create(self, parent_children_mapping, red_ids, orange_ids):
|
|
pool = dict()
|
|
for parent, children in parent_children_mapping.items():
|
|
# parent erzeugen, falls es diese nicht schon gibt (check der pool ids)
|
|
if parent is None:
|
|
parent_id = None
|
|
elif parent not in pool:
|
|
if parent not in red_ids: rowtags = ('good')
|
|
elif parent in orange_ids: rowtags = ('orange')
|
|
else: rowtags = ('missing')
|
|
|
|
parent_id = self.tree.insert('', tk.END, text=parent, tags=rowtags, open=True)
|
|
self.trid2sivasId[parent_id] = parent # merken für Doppelklick
|
|
pool[parent] = parent_id
|
|
else:
|
|
parent_id = pool[parent]
|
|
|
|
for child in children:
|
|
if child not in red_ids: rowtags = ('good')
|
|
elif child in orange_ids: rowtags = ('orange')
|
|
else: rowtags = ('missing')
|
|
|
|
if self._has_childs(child, parent_children_mapping) == True:
|
|
# wenn das Objekt ein Kind hat, könnte es bereits erzeugt worden sein
|
|
if child not in pool:
|
|
child_id = self.tree.insert('', tk.END, text=child, tags=rowtags, open=True)
|
|
pool[child] = child_id
|
|
self.trid2sivasId[child_id] = child # merken für Doppelklick
|
|
else:
|
|
child_id = pool[child]
|
|
else:
|
|
# die Blätter des Baumes kann man bedenkenlos immer bauen. Diese können redundante Texte haben.
|
|
child_id = self.tree.insert('', tk.END, text=child, tags=rowtags, open=True)
|
|
pool[child] = child_id # hier werden die keys - sivas Nummern auch überschrieben
|
|
self.trid2sivasId[child_id] = child # merken der eindeutigen Zuordnung für den späteren Doppelklick
|
|
|
|
if parent_id is not None:
|
|
self.tree.move(child_id, parent_id, 'end')
|
|
|
|
# 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('yellow', background='yellow')
|
|
self.tree.tag_configure('orange', background='orange')
|
|
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()
|
|
orange_ids = self._controller.get_orange_ids(red_ids)
|
|
self.refresh(parent_children_mapping, red_ids, orange_ids)
|
|
|
|
def item_selected(self, event):
|
|
"""callback of TK if an item in the tree has been selected
|
|
"""
|
|
trid = self.tree.selection()[0]
|
|
# trage die neue ID ins Modell ein
|
|
cid = self.trid2sivasId[trid]
|
|
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
|
|
self.asm_label = ttk.Label(frame, text="Baugruppennummer:" )
|
|
self.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, 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):
|
|
self.clear()
|
|
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
|
|
|
|
def highlight_labels(self, labels):
|
|
# not yet implemented. Not used
|
|
pass
|
|
def reset_labels(self):
|
|
# not yet implemented. Not used
|
|
pass
|
|
|
|
def clear(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
|
|
self.teilenummer_label = ttk.Label(frame, text="Teilenummer:", foreground='blue')
|
|
self.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, 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):
|
|
self.clear()
|
|
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']
|
|
|
|
def highlight_labels(self, labels):
|
|
if "Teilenummer" in labels:
|
|
self.teilenummer_label.configure(foreground='red')
|
|
def reset_labels(self):
|
|
self.teilenummer_label.configure(foreground='blue')
|
|
|
|
def clear(self):
|
|
self.teilenummer_text.set("")
|
|
|
|
|
|
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
|
|
self.datenbank_label = ttk.Label(frame, text="Datenbank:", foreground='blue' )
|
|
self.datenbank_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.datenbank = tk.StringVar()
|
|
self.datenbank_prod = ttk.Radiobutton(frame,
|
|
text="Produktiv",
|
|
variable=self.datenbank,
|
|
value="Produktiv",
|
|
command=lambda: self.callback('cb_datenbank_neu', self.datenbank.get()))
|
|
self.datenbank_prod .grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
self.datenbank_schul = ttk.Radiobutton(frame,
|
|
text="Schulung",
|
|
variable=self.datenbank,
|
|
value="Schulung",
|
|
command=lambda: self.callback('cb_datenbank_neu', self.datenbank.get()))
|
|
self.datenbank_schul .grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# pdmkategorie
|
|
self.pdmkategorie_label = ttk.Label(frame, text="PDM-Kategorie:", foreground='blue' )
|
|
self.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['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
|
|
self.neuaufbau_label = ttk.Label(frame, text="Neuaufbau:")
|
|
self.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
|
|
self.halbzeug_label = ttk.Label(frame, text="aus Halbzeug:")
|
|
self.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
|
|
self.halbzeugnummer_label = ttk.Label(frame, text="Halbzeugnummer:" )
|
|
self.halbzeugnummer_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.halbzeugnummer_neu = tk.StringVar()
|
|
self.halbzeugnummer_neu_entry = ttk.Entry(frame, textvariable=self.halbzeugnummer_neu, width=AllFrames.get_entry_text_width(self))
|
|
self.halbzeugnummer_neu_entry.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# Halbzeuglänge
|
|
self.halbzeuglaenge_label = ttk.Label(frame, text="Halbzeuglänge:" )
|
|
self.halbzeuglaenge_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.halbzeuglaenge_neu = tk.StringVar()
|
|
self.halbzeuglaenge_neu_entry = ttk.Entry(frame, textvariable=self.halbzeuglaenge_neu, width=AllFrames.get_entry_text_width(self))
|
|
self.halbzeuglaenge_neu_entry.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# HalbzeugOberfläche
|
|
self.halbzeugoberflaeche_label = ttk.Label(frame, text="Halbzeugoberfläche:")
|
|
self.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
|
|
self.halbzeugfarbe_label = ttk.Label(frame, text="Halbzeugfarbe:", foreground='steel blue' )
|
|
self.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
|
|
self.lebenszyklusstatus_label = ttk.Label(frame, text="Lebenszyklusstatus:", foreground='blue' )
|
|
self.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
|
|
self.model3d_label = ttk.Label(frame, text="3D-Modell:", foreground='blue')
|
|
self.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)
|
|
self.suche3d_button = ttk.Button(frame, text="Durchsuchen..", command=lambda: self.callback("cb_3dsuchen", None))
|
|
self.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):
|
|
self.clear()
|
|
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()
|
|
# if 'datenbank' in data:
|
|
# self.datenbank['state'] = data["datenbank"]
|
|
if 'neuaufbau' in data:
|
|
self.neuaufbau_checkbutton['state'] = data["neuaufbau"]
|
|
if 'halbzeugnummer_neu' in data:
|
|
self.halbzeugnummer_neu_entry['state'] = data["halbzeugnummer_neu"]
|
|
if 'halbzeuglaenge_neu' in data:
|
|
self.halbzeuglaenge_neu_entry['state'] = data["halbzeuglaenge_neu"]
|
|
if 'aus_halbzeug_neu' in data:
|
|
self.aushalbzeug_checkbutton['state'] = data["aus_halbzeug_neu"]
|
|
# ab hier die Dropdowns der Oberfläche
|
|
if 'cb_pdm_kategorie_neu' in data:
|
|
self.pdmkategorie_combo['state'] = data["cb_pdm_kategorie_neu"]
|
|
if 'cb_lebenszyklus_status_neu' in data:
|
|
self.lebenszyklusstatus_combo['state'] = data["cb_lebenszyklus_status_neu"]
|
|
if 'cb_halbzeugoberflaeche' in data:
|
|
self.halbzeugoberflaeche_combo['state'] = data["cb_halbzeugoberflaeche"]
|
|
if 'cb_halbzeugfarbe' in data:
|
|
self.halbzeugfarbe_combo['state'] = data["cb_halbzeugfarbe"]
|
|
if 'cb_3Dmodel_neu' in data:
|
|
self.model3d_combo['state'] = data["cb_3Dmodel_neu"]
|
|
# buttons
|
|
if 'cb_3dsuchen' in data:
|
|
self.suche3d_button['state'] =data["cb_3dsuchen"]
|
|
|
|
def highlight_labels(self, labels):
|
|
if "Datenbank" in labels:
|
|
self.datenbank_label.configure(foreground='red' )
|
|
if "PDM-Kategorie" in labels:
|
|
self.pdmkategorie_label.configure(foreground='red' )
|
|
if "Neuaufbau" in labels:
|
|
self.neuaufbau_label.configure(foreground='red' )
|
|
if "Halbzeugnummer" in labels:
|
|
self.halbzeugnummer_label.configure(foreground='red' )
|
|
if "Halbzeugoberfläche" in labels:
|
|
self.halbzeugoberflaeche_label.configure(foreground='red' )
|
|
if "Halbzeugfarbe" in labels:
|
|
self.halbzeugfarbe_label.configure(foreground='red' )
|
|
if "Lebenszyklusstatus" in labels:
|
|
self.lebenszyklusstatus_label.configure(foreground='red' )
|
|
if "3D-Modell" in labels:
|
|
self.model3d_label.configure(foreground='red')
|
|
|
|
def reset_labels(self):
|
|
self.datenbank_label.configure(foreground='blue' )
|
|
self.pdmkategorie_label.configure(foreground='blue' )
|
|
self.neuaufbau_label.configure(foreground='black')
|
|
self.halbzeugnummer_label.configure(foreground='black')
|
|
self.halbzeugoberflaeche_label.configure(foreground='black')
|
|
self.halbzeugfarbe_label.configure(foreground='steel blue' )
|
|
self.lebenszyklusstatus_label.configure(foreground='blue' )
|
|
self.model3d_label.configure(foreground='blue')
|
|
|
|
def clear(self):
|
|
self.datenbank.set('')
|
|
self.pdm_category.set('')
|
|
self.neuaufbau.set(False)
|
|
self.aus_halbzeug_neu.set(False)
|
|
self.halbzeugnummer_neu.set('')
|
|
self.halbzeuglaenge_neu.set('')
|
|
self.halbzeugoberflaeche_neu.set('')
|
|
self.halbzeugfarbe_neu.set('')
|
|
self.lebenszyklus_status_neu.set('')
|
|
self.model3d_neu.set('')
|
|
self.pdmkategorie_combo['values'] = ''
|
|
self.halbzeugoberflaeche_combo['values'] = ''
|
|
self.halbzeugfarbe_combo['values'] = ''
|
|
self.lebenszyklusstatus_combo['values'] = ''
|
|
self.model3d_combo['values'] = ''
|
|
|
|
|
|
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
|
|
self.bezeichnung1_label = ttk.Label(frame, text="Bezeichnung 1:", foreground='blue' )
|
|
self.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), font=("Calibri",10), 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), font=("Calibri",10))
|
|
self.bezeichnung1_neu_entry.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
|
|
self.rownum += 1
|
|
|
|
# Bezeichnung 2
|
|
self.bezeichnung2_label = ttk.Label(frame, text="Bezeichnung 2:" )
|
|
self.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) < 51:
|
|
self.bezeichnung1_neu_entry.configure(foreground='black')
|
|
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):
|
|
self.clear()
|
|
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()
|
|
if 'bezeichnung1_sivas' in data:
|
|
self.bezeichnung1_sivas['state'] = data["bezeichnung1_sivas"]
|
|
if 'bezeichnung1_neu' in data:
|
|
self.bezeichnung1_neu['state'] = data["bezeichnung1_neu"]
|
|
if 'bezeichnung2_sivas' in data:
|
|
self.bezeichnung2_sivas['state'] = data["bezeichnung2_sivas"]
|
|
|
|
def highlight_labels(self, labels):
|
|
if "Bezeichnung 1" in labels:
|
|
self.bezeichnung1_label.configure(foreground='blue')
|
|
if "Bezeichnung 2" in labels:
|
|
self.bezeichnung2_label.configure(foreground='red')
|
|
def reset_labels(self):
|
|
self.bezeichnung1_label.configure(foreground='blue')
|
|
self.bezeichnung2_label.configure(foreground='black')
|
|
|
|
def clear(self):
|
|
self.bezeichnung1_sivas.set('')
|
|
self.bezeichnung1_neu.set('')
|
|
self.bezeichnung2_sivas.set('')
|
|
|
|
|
|
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
|
|
self.halbzeugOhneSaege_label = ttk.Label(frame, text="Halbzeug ohne Sägeliste:", foreground='blue' )
|
|
self.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
|
|
self.ruestcode_label = ttk.Label(frame, text="Rüstcode:", foreground='blue' )
|
|
self.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
|
|
self.fertigungsart_label = ttk.Label(frame, text="Fertigungsart:", foreground='steel blue' )
|
|
self.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
|
|
self.allgemeintoleranz_label = ttk.Label(frame, text="Allgemeintoleranz:", foreground='steel blue' )
|
|
self.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
|
|
self.fosGruppe_label = ttk.Label(frame, text="FOS-Gruppe:", foreground='blue' )
|
|
self.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
|
|
self.kalkulationsart_label = ttk.Label(frame, text="Kalkulationsart:", foreground='blue' )
|
|
self.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):
|
|
self.clear()
|
|
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()
|
|
if 'halbzeugOhneSaege_sivas' in data:
|
|
self.halbzeugOhneSaege_sivas['state'] = data["halbzeugOhneSaege_sivas"]
|
|
if 'halbzeugOhneSaege_neu' in data:
|
|
self.halbzeugOhneSaege_neu['state'] = data["halbzeugOhneSaege_neu"]
|
|
if 'ruestcode_sivas' in data:
|
|
self.ruestcode_sivas['state'] = data["ruestcode_sivas"]
|
|
if 'ruestcode_neu' in data:
|
|
self.ruestcode_neu['state'] = data["ruestcode_neu"]
|
|
if 'fertigungsart_sivas' in data:
|
|
self.fertigungsart_sivas['state'] = data["fertigungsart_sivas"]
|
|
if 'fertigungsart_neu' in data:
|
|
self.fertigungsart_neu['state'] = data["fertigungsart_neu"]
|
|
if 'allgemeintoleranz_sivas' in data:
|
|
self.allgemeintoleranz_sivas['state'] = data["allgemeintoleranz_sivas"]
|
|
if 'allgemeintoleranz_neu' in data:
|
|
self.allgemeintoleranz_neu['state'] = data["allgemeintoleranz_neu"]
|
|
if 'fosGruppe_sivas' in data:
|
|
self.fosGruppe_sivas['state'] = data["fosGruppe_sivas"]
|
|
if 'fosGruppe_neu' in data:
|
|
self.fosGruppe_neu['state'] = data["fosGruppe_neu"]
|
|
if 'kalkulationsart_sivas' in data:
|
|
self.kalkulationsart_sivas['state'] = data["kalkulationsart_sivas"]
|
|
if 'kalkulationsart_neu' in data:
|
|
self.kalkulationsart_neu['state'] = data["kalkulationsart_neu"]
|
|
# ab hier die Dropdowns der Oberfläche befüllen.
|
|
if 'cb_halbzeugOhneSaege_neu' in data:
|
|
self.halbzeugOhneSaege_neu_combo['state'] = data['cb_halbzeugOhneSaege_neu']
|
|
if 'cb_ruestcode_neu' in data:
|
|
self.ruestcode_neu_combo['state'] = data['cb_ruestcode_neu']
|
|
if 'cb_fertigungsart_neu' in data:
|
|
self.fertigungsart_neu_combo['state'] = data['cb_fertigungsart_neu']
|
|
if 'cb_allgemeintoleranz_neu' in data:
|
|
self.allgemeintoleranz_neu_combo['state'] = data['cb_allgemeintoleranz_neu']
|
|
if 'cb_fosGruppe_neu' in data:
|
|
self.fosGruppe_neu_combo['state'] = data['cb_fosGruppe_neu']
|
|
if 'cb_kalkulationsart_neu' in data:
|
|
self.kalkulationsart_neu_combo['state'] = data['cb_kalkulationsart_neu']
|
|
|
|
def highlight_labels(self, labels):
|
|
if "Halbzeug ohne Sägeliste" in labels:
|
|
self.halbzeugOhneSaege_label.configure(foreground='red')
|
|
if "Rüstcode" in labels:
|
|
self.ruestcode_label.configure(foreground='red')
|
|
if "Fertigungsart" in labels:
|
|
self.fertigungsart_label.configure(foreground='red')
|
|
if "Allgemeintoleranz" in labels:
|
|
self.allgemeintoleranz_label.configure(foreground='red')
|
|
if "FOS-Gruppe" in labels:
|
|
self.fosGruppe_label.configure(foreground='red')
|
|
if "Kalkulationsart" in labels:
|
|
self.kalkulationsart_label.configure(foreground='red')
|
|
|
|
def reset_labels(self):
|
|
self.halbzeugOhneSaege_label.configure(foreground='blue')
|
|
self.ruestcode_label.configure(foreground='blue' )
|
|
self.fertigungsart_label.configure(foreground='steel blue')
|
|
self.allgemeintoleranz_label.configure(foreground='steel blue')
|
|
self.fosGruppe_label.configure(foreground='blue')
|
|
self.kalkulationsart_label.configure(foreground='blue')
|
|
|
|
def clear(self):
|
|
self.halbzeugOhneSaege_sivas.set('')
|
|
self.halbzeugOhneSaege_neu.set('')
|
|
self.ruestcode_sivas.set('')
|
|
self.ruestcode_neu.set('')
|
|
self.fertigungsart_sivas.set('')
|
|
self.fertigungsart_neu.set('')
|
|
self.allgemeintoleranz_sivas.set('')
|
|
self.allgemeintoleranz_neu.set('')
|
|
self.fosGruppe_sivas.set('')
|
|
self.fosGruppe_neu.set('')
|
|
self.kalkulationsart_sivas.set('')
|
|
self.kalkulationsart_neu.set('')
|
|
self.halbzeugOhneSaege_neu_combo['values'] = ''
|
|
self.ruestcode_neu_combo['values'] = ''
|
|
self.fertigungsart_neu_combo['values'] = ''
|
|
self.allgemeintoleranz_neu_combo['values'] = ''
|
|
self.fosGruppe_neu_combo['values'] = ''
|
|
self.kalkulationsart_neu_combo['values'] = ''
|
|
|
|
|
|
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
|
|
self.beschaffungsart_label = ttk.Label(frame, text="Beschaffungsart:", foreground='blue' )
|
|
self.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
|
|
self.mengeneinheit_label = ttk.Label(frame, text="Mengeneinheit:", foreground='blue' )
|
|
self.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
|
|
self.halbzeug_label = ttk.Label(frame, text="Halbzeug:", foreground='blue' )
|
|
self.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):
|
|
self.clear()
|
|
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()
|
|
if "beschaffungsart_sivas" in data:
|
|
self.beschaffungsart_sivas['state'] = data["beschaffungsart_sivas"]
|
|
if "beschaffungsart_neu" in data:
|
|
self.beschaffungsart_neu['state'] = data["beschaffungsart_neu"]
|
|
if "mengeneinheit_sivas" in data:
|
|
self.mengeneinheit_sivas['state'] = data["mengeneinheit_sivas"]
|
|
if "mengeneinheit_neu" in data:
|
|
self.mengeneinheit_neu['state'] = data["mengeneinheit_neu"]
|
|
if "halbzeug_sivas" in data:
|
|
self.halbzeug_sivas['state'] = data["halbzeug_sivas"]
|
|
if "halbzeug_neu" in data:
|
|
self.halbzeug_neu['state'] = data["halbzeug_neu"]
|
|
# ab hier die Dropdowns der Oberfläche befüllen.
|
|
if "cb_beschaffungsart_neu" in data:
|
|
self.beschaffungsart_combo['state'] = data["cb_beschaffungsart_neu"]
|
|
if "cb_mengeneinheit_neu" in data:
|
|
self.mengeneinheit_combo['state'] = data["cb_mengeneinheit_neu"]
|
|
if "cb_halbzeug_neu" in data:
|
|
self.halbzeug_combo['state'] = data["cb_halbzeug_neu"]
|
|
|
|
def highlight_labels(self, labels):
|
|
if "Beschaffungsart" in labels:
|
|
self.beschaffungsart_label.configure(foreground='red' )
|
|
if "Mengeneinheit" in labels:
|
|
self.mengeneinheit_label.configure(foreground='red' )
|
|
if "Halbzeug" in labels:
|
|
self.halbzeug_label.configure(foreground='red' )
|
|
def reset_labels(self):
|
|
self.beschaffungsart_label.configure(foreground='blue' )
|
|
self.mengeneinheit_label.configure(foreground='blue' )
|
|
self.halbzeug_label.configure(foreground='blue' )
|
|
|
|
def clear(self):
|
|
self.beschaffungsart_sivas.set('')
|
|
self.beschaffungsart_neu.set('')
|
|
self.mengeneinheit_sivas.set('')
|
|
self.mengeneinheit_neu.set('')
|
|
self.halbzeug_sivas.set('')
|
|
self.halbzeug_neu.set('')
|
|
self.beschaffungsart_combo['values'] = ''
|
|
self.mengeneinheit_combo['values'] = ''
|
|
self.halbzeug_combo['values'] = ''
|
|
|
|
|
|
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
|
|
self.tosgruppe_label = ttk.Label(frame, text="TOS-Gruppe:", foreground='blue' )
|
|
self.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
|
|
self.dispogruppe_label = ttk.Label(frame, text="Dispogruppe:", foreground='blue' )
|
|
self.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
|
|
self.dispolaufgruppe_label = ttk.Label(frame, text="Dispolaufgruppe:", foreground='blue' )
|
|
self.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
|
|
self.ersatzfuer_label = ttk.Label(frame, text="Ersatz für:" )
|
|
self.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
|
|
self.ersetztdurch_label = ttk.Label(frame, text="Ersetzt durch:" )
|
|
self.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
|
|
self.hersteller_label = ttk.Label(frame, text="Hersteller:" )
|
|
self.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()
|
|
a = self.hersteller_neu.get()
|
|
self.hersteller_neu_combo = ttk.Combobox(frame, textvariable=self.hersteller_neu, width=AllFrames.get_combo_width(self))
|
|
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
|
|
self.herstteilenr_label = ttk.Label(frame, text="Hersteller Teilenummer:" )
|
|
self.herstteilenr_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.herstteilenr_sivas = tk.StringVar()
|
|
self.herstteilenr_sivas_entry = ttk.Entry(frame, textvariable=self.herstteilenr_sivas, state="readonly", width=AllFrames.get_entry_text_width(self))
|
|
self.herstteilenr_sivas_entry.grid(column=col_left+1, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.herstteilenr_neu = tk.StringVar()
|
|
self.herstteilenr_neu_entry = ttk.Entry(frame, textvariable=self.herstteilenr_neu, width=AllFrames.get_entry_text_width(self))
|
|
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):
|
|
self.clear()
|
|
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()
|
|
if 'tosgruppe_sivas' in data:
|
|
self.tosgruppe_sivas['state'] = data["tosgruppe_sivas"]
|
|
if 'tosgruppe_neu' in data:
|
|
self.tosgruppe_neu['state'] = data["tosgruppe_neu"]
|
|
if 'dispogruppe_sivas' in data:
|
|
self.dispogruppe_sivas['state'] = data["dispogruppe_sivas"]
|
|
if 'dispogruppe_neu' in data:
|
|
self.dispogruppe_neu['state'] = data["dispogruppe_neu"]
|
|
if 'dispolaufgruppe_sivas' in data:
|
|
self.dispolaufgruppe_sivas['state'] = data["dispolaufgruppe_sivas"]
|
|
if 'dispolaufgruppe_neu' in data:
|
|
self.dispolaufgruppe_neu['state'] = data["dispolaufgruppe_neu"]
|
|
if 'ersatzfuer_sivas' in data:
|
|
self.ersatzfuer_sivas['state'] = data["ersatzfuer_sivas"]
|
|
if 'ersatzfuer_neu' in data:
|
|
self.ersatzfuer_neu['state'] = data["ersatzfuer_neu"]
|
|
if 'ersetztdurch_sivas' in data:
|
|
self.ersetztdurch_sivas['state'] = data["ersetztdurch_sivas"]
|
|
if 'ersetztdurch_neu' in data:
|
|
self.ersetztdurch_neu['state'] = data["ersetztdurch_neu"]
|
|
if 'hersteller_sivas' in data:
|
|
self.hersteller_sivas['state'] = data["hersteller_sivas"]
|
|
if 'hersteller_neu' in data:
|
|
self.hersteller_neu['state'] = data["hersteller_neu"]
|
|
if 'herstteilenr_sivas' in data:
|
|
self.herstteilenr_sivas_entry['state'] = data["herstteilenr_sivas"]
|
|
if 'herstteilenr_neu' in data:
|
|
self.herstteilenr_neu_entry['state'] = data["herstteilenr_neu"]
|
|
# ab hier die Dropdowns der Oberfläche befüllen.
|
|
if "cb_dispogruppe_neu" in data:
|
|
self.dispogruppe_neu_combo['state'] = data["cb_dispogruppe_neu"]
|
|
if "cb_dispolaufgruppe_neu" in data:
|
|
self.dispolaufgruppe_neu_combo['state'] = data["cb_dispolaufgruppe_neu"]
|
|
if "cb_hersteller_neu" in data:
|
|
self.hersteller_neu_combo['state'] = data["cb_hersteller_neu"]
|
|
|
|
def highlight_labels(self, labels):
|
|
if "TOS-Gruppe" in labels:
|
|
self.tosgruppe_label.configure(foreground='red' )
|
|
if "Dispogruppe" in labels:
|
|
self.dispogruppe_label.configure(foreground='red' )
|
|
if "Dispolaufgruppe" in labels:
|
|
self.dispolaufgruppe_label.configure(foreground='red' )
|
|
if "Ersatz für" in labels:
|
|
self.ersatzfuer_label.configure(foreground='red')
|
|
if "Ersetzt durch" in labels:
|
|
self.ersetztdurch_label.configure(foreground='red')
|
|
if "Hersteller" in labels:
|
|
self.hersteller_label.configure(foreground='red')
|
|
if "Hersteller Teilenummer" in labels:
|
|
self.herstteilenr_label.configure(foreground='red')
|
|
def reset_labels(self):
|
|
self.tosgruppe_label.configure(foreground='blue' )
|
|
self.dispogruppe_label.configure(foreground='blue' )
|
|
self.dispolaufgruppe_label.configure(foreground='blue' )
|
|
self.ersatzfuer_label.configure(foreground='black')
|
|
self.ersetztdurch_label.configure(foreground='black')
|
|
self.hersteller_label.configure(foreground='black')
|
|
self.herstteilenr_label.configure(foreground='black')
|
|
|
|
def clear(self):
|
|
self.tosgruppe_sivas.set('')
|
|
self.tosgruppe_neu.set('')
|
|
self.dispogruppe_sivas.set('')
|
|
self.dispogruppe_neu.set('')
|
|
self.dispolaufgruppe_sivas.set('')
|
|
self.dispolaufgruppe_neu.set('')
|
|
self.ersatzfuer_sivas.set('')
|
|
self.ersatzfuer_neu.set('')
|
|
self.ersetztdurch_sivas.set('')
|
|
self.ersetztdurch_neu.set('')
|
|
self.hersteller_sivas.set('')
|
|
self.hersteller_neu.set('')
|
|
self.herstteilenr_sivas.set('')
|
|
self.herstteilenr_neu.set('')
|
|
self.dispogruppe_neu_combo['values'] = ''
|
|
self.dispolaufgruppe_neu_combo['values'] = ''
|
|
self.hersteller_neu_combo['values'] = ''
|
|
|
|
|
|
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
|
|
self.werkstoffdiskr_label = ttk.Label(frame, text="Werkstoffdiskrepanz:")
|
|
self.werkstoffdiskr_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
|
|
self.werkstoffdiskr_neu= tk.BooleanVar()
|
|
self.werkstoffdiskr_checkbutton = ttk.Checkbutton(frame,
|
|
#text='ja',
|
|
variable=self.werkstoffdiskr_neu,
|
|
command=lambda: self.callback("cb_werkstoffdiskrepanz", self.werkstoffdiskr_neu.get()),
|
|
onvalue=True,
|
|
offvalue=False)
|
|
self.werkstoffdiskr_checkbutton.grid(column=col_left+2, row=self.rownum, sticky=tk.W, padx=3, pady=3)
|
|
self.rownum += 1
|
|
|
|
# Werkstofftyp
|
|
self.werkstofftyp_label = ttk.Label(frame, text="Werkstofftyp:", foreground='steel blue' )
|
|
self.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
|
|
self.material_label = ttk.Label(frame, text="Material:", foreground='steel blue' )
|
|
self.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
|
|
self.oberflaeche_label = ttk.Label(frame, text="Oberfläche:", foreground='steel blue' )
|
|
self.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
|
|
self.farbe_label = ttk.Label(frame, text="Farbe:", foreground='steel blue' )
|
|
self.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_neu": self.werkstoffdiskr_neu.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):
|
|
self.clear()
|
|
data = self.get_controller().get_all_gui_data()
|
|
if 'werkstoffdiskr_neu' in data:
|
|
self.werkstoffdiskr_neu.set(data["werkstoffdiskr_neu"])
|
|
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()
|
|
if 'werkstoffdiskr_neu' in data:
|
|
self.werkstoffdiskr_checkbutton['state'] = data["werkstoffdiskr_neu"]
|
|
if 'werkstofftyp_neu' in data:
|
|
self.werkstofftyp_neu['state'] = data["werkstofftyp_neu"]
|
|
if 'material_sivas' in data:
|
|
self.material_sivas['state'] = data["material_sivas"]
|
|
if 'material_neu' in data:
|
|
self.material_neu['state'] = data["material_neu"]
|
|
if 'oberflaeche_neu' in data:
|
|
self.oberflaeche_neu['state'] = data["oberflaeche_neu"]
|
|
if 'farbe_neu' in data:
|
|
self.farbe_neu['state'] = data["farbe_neu"]
|
|
# ab hier die Dropdowns der Oberfläche befüllen.
|
|
if 'cb_werkstofftyp_neu' in data:
|
|
self.werkstofftyp_neu_combo['state'] = data["cb_werkstofftyp_neu"]
|
|
if 'cb_material_neu' in data:
|
|
self.material_neu_combo['state'] = data["cb_material_neu"]
|
|
if 'cb_oberflaeche_neu' in data:
|
|
self.oberflaeche_neu_combo['state'] = data["cb_oberflaeche_neu"]
|
|
if 'cb_farbe_neu' in data:
|
|
self.farbe_neu_combo['state'] = data["cb_farbe_neu"]
|
|
|
|
def highlight_labels(self, labels):
|
|
if "Werkstoffdiskrepanz" in labels:
|
|
self.werkstoffdiskr_label.configure(foreground='red')
|
|
if "Werkstofftyp" in labels:
|
|
self.werkstofftyp_label.configure(foreground='red')
|
|
if "Material" in labels:
|
|
self.material_label.configure(foreground='red')
|
|
if "Oberfläche" in labels:
|
|
self.oberflaeche_label.configure(foreground='red')
|
|
if "Farbe" in labels:
|
|
self.farbe_label.configure(foreground='red')
|
|
def reset_labels(self):
|
|
self.werkstoffdiskr_label.configure(foreground='black')
|
|
self.werkstofftyp_label.configure(foreground='steel blue' )
|
|
self.material_label.configure(foreground='steel blue' )
|
|
self.oberflaeche_label.configure(foreground='steel blue' )
|
|
self.farbe_label.configure(foreground='steel blue' )
|
|
|
|
def clear(self):
|
|
self.werkstoffdiskr_neu.set(False)
|
|
self.werkstofftyp_neu.set('')
|
|
self.material_sivas.set('')
|
|
self.material_neu.set('')
|
|
self.oberflaeche_neu.set('')
|
|
self.farbe_neu.set('')
|
|
self.werkstofftyp_neu_combo['values'] = ''
|
|
self.material_neu_combo['values'] = ''
|
|
self.oberflaeche_neu_combo['values'] = ''
|
|
self.farbe_neu_combo['values'] = ''
|
|
|
|
|
|
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
|
|
self.version_label = ttk.Label(frame, text="Version:" )
|
|
self.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.rownum += 1
|
|
|
|
|
|
# Änderungsindex
|
|
self.aenderungsindex_label = ttk.Label(frame, text="Änderungsindex:", foreground='blue' )
|
|
self.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
|
|
self.aenderungstext_label = ttk.Label(frame, text="Änderungstext:", foreground='blue' )
|
|
self.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
|
|
self.freigabevermerk_label = ttk.Label(frame, text="Freigabevermerk:", foreground='blue' )
|
|
self.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):
|
|
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')
|
|
|
|
aenderungstext_sivas = re.sub(r"\n", "", aenderungstext_sivas, flags=re.I)
|
|
aenderungstext_neu = re.sub(r"\n", "", aenderungstext_neu, flags=re.I)
|
|
freigabevermerk_sivas = re.sub(r"\n", "", freigabevermerk_sivas, flags=re.I)
|
|
freigabevermerk_neu = re.sub(r"\n", "", freigabevermerk_neu, flags=re.I)
|
|
|
|
ret = {
|
|
"version_sivas": self.version_sivas.get(),
|
|
"aenderungsindex_sivas": self.aenderungsindex_sivas.get(),
|
|
"aenderungsindex_neu": self.aenderungsindex_neu.get(),
|
|
"aenderungstext_sivas": aenderungstext_sivas,
|
|
"aenderungstext_neu": aenderungstext_neu,
|
|
"freigabevermerk_sivas": freigabevermerk_sivas,
|
|
"freigabevermerk_neu": freigabevermerk_neu
|
|
}
|
|
return ret
|
|
|
|
def data_from_model(self):
|
|
self.clear()
|
|
data = self.get_controller().get_all_gui_data()
|
|
if 'version_sivas' in data:
|
|
self.version_sivas.set(data["version_sivas"])
|
|
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["aenderungstext_neu"]
|
|
if text:
|
|
self.aenderungstext_neu.insert('1.0', text)
|
|
if 'freigabevermerk_sivas' in data:
|
|
text = data["freigabevermerk_sivas"]
|
|
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()
|
|
if 'version_sivas' in data:
|
|
self.version_sivas['state'] = data["version_sivas"]
|
|
if 'aenderungsindex_sivas' in data:
|
|
self.aenderungsindex_sivas['state'] = data["aenderungsindex_sivas"]
|
|
if 'aenderungsindex_neu' in data:
|
|
self.aenderungsindex_neu['state'] = data["aenderungsindex_neu"]
|
|
if 'aenderungstext_sivas' in data:
|
|
self.aenderungstext_sivas['state'] = data["aenderungstext_sivas"]
|
|
if 'aenderungstext_neu' in data:
|
|
self.aenderungstext_neu['state'] = data["freigabevermerk_neu"]
|
|
if 'freigabevermerk_sivas' in data:
|
|
self.freigabevermerk_sivas['state'] = data["freigabevermerk_neu"]
|
|
if 'freigabevermerk_neu' in data:
|
|
self.freigabevermerk_neu['state'] = data["freigabevermerk_neu"]
|
|
|
|
def highlight_labels(self, labels):
|
|
if "Version" in labels:
|
|
self.version_label.configure(foreground='red')
|
|
if "Änderungsindex" in labels:
|
|
self.aenderungsindex_label.configure(foreground='red')
|
|
if "Änderungstext" in labels:
|
|
self.aenderungstext_label.configure(foreground='red')
|
|
if "Freigabevermerk" in labels:
|
|
self.freigabevermerk_label.configure(foreground='red')
|
|
def reset_labels(self):
|
|
self.version_label.configure(foreground='black')
|
|
self.aenderungsindex_label.configure(foreground='blue' )
|
|
self.aenderungstext_label.configure(foreground='blue' )
|
|
self.freigabevermerk_label.configure(foreground='blue' )
|
|
|
|
def clear(self):
|
|
self.version_sivas.set('')
|
|
self.aenderungsindex_sivas.set('')
|
|
self.aenderungsindex_neu.set('')
|
|
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
|
|
self.zusatzinfos_auto_label = ttk.Label(frame, text="Zusatzinformationen\nautomatisch:")
|
|
self.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
|
|
self.zusatzinfos_bendef_label = ttk.Label(frame, text="Zusatzinformationen\nBenutzerdefiniert:")
|
|
self.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):
|
|
|
|
zusatzinfos_auto_text = self.zusatzinfos_auto_text.get('1.0', 'end')
|
|
zusatzinfos_bendef_text = self.zusatzinfos_bendef_text.get('1.0', 'end')
|
|
|
|
zusatzinfos_auto_text = re.sub(r"\n", "", zusatzinfos_auto_text, flags=re.I)
|
|
zusatzinfos_bendef_text = re.sub(r"\n", "", zusatzinfos_bendef_text, flags=re.I)
|
|
|
|
ret = {
|
|
"zusatzinfos_auto_text": zusatzinfos_auto_text,
|
|
"zusatzinfos_bendef_text": zusatzinfos_bendef_text
|
|
}
|
|
|
|
return ret
|
|
|
|
def data_from_model(self):
|
|
self.clear()
|
|
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()
|
|
if 'zusatzinfos_auto_text' in data:
|
|
self.zusatzinfos_auto_text['state'] = data["zusatzinfos_auto_text"]
|
|
if 'zusatzinfos_bendef_text' in data:
|
|
self.zusatzinfos_bendef_text['state'] = data["zusatzinfos_bendef_text"]
|
|
|
|
def highlight_labels(self, labels):
|
|
if "Zusatzinformationen automatisch" in labels:
|
|
self.zusatzinfos_auto_label.configure(foreground='red')
|
|
if "Zusatzinformationen Benutzerdefiniert" in labels:
|
|
self.zusatzinfos_bendef_label.configure(foreground='red')
|
|
def reset_labels(self):
|
|
self.zusatzinfos_auto_label.configure(foreground='black')
|
|
self.zusatzinfos_bendef_label.configure(foreground='black')
|
|
|
|
|
|
def clear(self):
|
|
self.zusatzinfos_auto_text.delete('1.0', 'end')
|
|
self.zusatzinfos_bendef_text.delete('1.0', 'end')
|
|
|
|
class App():
|
|
def __init__(self, root, config):
|
|
"""Standardgui mit Baum zur Anwahl der Teile des Assemblies"""
|
|
|
|
self._root = root
|
|
self._config = config
|
|
self.build_widgets()
|
|
|
|
def build_widgets(self):
|
|
""" baue alle Frames der Gui auf
|
|
"""
|
|
# Defaultgrösse des Fensters
|
|
Dimension = self._config.Gui.get('Fenster', 'Dimension')
|
|
self._root.geometry(Dimension)
|
|
|
|
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)
|
|
container.pack()
|
|
|
|
# hier im Canvas ist der linke und Rechte Frame drin
|
|
|
|
# CanvasBreite gesteuert durch gui.cfg
|
|
width = self._config.Gui.get('Fenster', 'CanvasBreite')
|
|
height = self._config.Gui.get('Fenster', 'CanvasHoehe')
|
|
self._canvas = tk.Canvas(container, width=width, height=height)
|
|
self._canvas.pack(side="left", fill="both", expand=True)
|
|
|
|
# zum Verschieben des Canvas: Eine globale Scrollbar ganz rechts
|
|
vscrollbar = ttk.Scrollbar(container, orient='vertical', command=self._canvas.yview)
|
|
vscrollbar.pack(side="left", fill="y", expand=False)
|
|
|
|
# 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)
|
|
# Canvas-Größe anpassen
|
|
self._canvas.update_idletasks()
|
|
self._canvas.config(scrollregion=self._canvas.bbox("all"))
|
|
|
|
|
|
inner_frame = ttk.Frame(self._canvas)
|
|
self._canvas.create_window((0, 0), window=inner_frame, anchor="nw")
|
|
|
|
|
|
|
|
|
|
# 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.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_leftframes(self):
|
|
self.lf1.clear()
|
|
self.lf2.clear()
|
|
|
|
def clear_rightframes(self):
|
|
self.rf1.clear()
|
|
self.rf2.clear()
|
|
self.rf3.clear()
|
|
self.rf4.clear()
|
|
self.rf5.clear()
|
|
self.rf6.clear()
|
|
self.rf7.clear()
|
|
self.rf8.clear()
|
|
self.rf9.clear()
|
|
|
|
def clear(self):
|
|
self.clear_rightframes()
|
|
self.clear_leftframes()
|
|
|
|
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 highlight_labels(self, labels):
|
|
self.rf1.highlight_labels(labels)
|
|
self.rf2.highlight_labels(labels)
|
|
self.rf3.highlight_labels(labels)
|
|
self.rf4.highlight_labels(labels)
|
|
self.rf5.highlight_labels(labels)
|
|
self.rf6.highlight_labels(labels)
|
|
self.rf7.highlight_labels(labels)
|
|
self.rf8.highlight_labels(labels)
|
|
self.rf9.highlight_labels(labels)
|
|
|
|
def reset_labels(self):
|
|
self.rf1.reset_labels()
|
|
self.rf2.reset_labels()
|
|
self.rf3.reset_labels()
|
|
self.rf4.reset_labels()
|
|
self.rf5.reset_labels()
|
|
self.rf6.reset_labels()
|
|
self.rf7.reset_labels()
|
|
self.rf8.reset_labels()
|
|
self.rf9.reset_labels()
|
|
|
|
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>
|
|
|
|
"""
|