Observer pattern eingebaut. Zahlreiche Attribute protected gemacht. Logik in caditem verschoben. config aus der gui entfernt

lib/CreoMigrateGui.py

@@ -2,8 +2,8 @@ import tkinter as tk
 #import ttkbootstrap as ttk
 #from ttkbootstrap.constants import *
 from gui import App
-from caditem import CadItem
-from controller import Controller, GuiLogic
+from caditem import CadItem, GuiLogic
+from controller import Controller
 from manage_configs import Configs, SivasAssemblyData
 import argparse
 import os
@@ -83,13 +83,13 @@ class Environment:
 def build_gui(model, configs):
     root = tk.Tk()
     #root = ttk.Window()
-    app = App(root, configs)
+    app = App(root)
 
     controller = Controller(model, app)
     controller.set_env(configs.get_env())
 
     logic = GuiLogic(model, configs)
-    controller.add_logic(logic)
+    model.add_logic(logic)
 
     # um ohne Observer pattern auch Rückmeldungen geben zu können
     app.set_controller(controller)   

lib/caditem.py

@@ -2,7 +2,27 @@ import json
 import pandas as pd
 import os
 
-class CadItem():
+class DataModel:
+    def __init__(self):
+        self._observers = {}
+        self._counter = 0
+        # self._data_controller = DataController()  # Externer hypothetischer Datencontroller
+        # self._data_controller.subscribe(self)
+
+    def subscribe(self, observer):
+        self._counter += 1
+        self._observers[self._counter] = observer
+        return self._counter
+
+    def unsubscribe(self, observer_id):
+        self._observers.pop(observer_id)
+
+    def notify(self, data):
+        for observer in self._observers.values():
+            observer.notify(data)
+
+
+class CadItem(DataModel):
     """
     This item contains all data for writing all necessary data to the solid edg cad file
 
@@ -138,15 +158,20 @@ class CadItem():
 
     def __init__(self):
         """ is initalized with its unique id"""
-        self.red_ids = {}
-        self.parent_children_mapping = {}
-        self.data = {}
-        self.gui_data = {}
-        self.read_only_items = {}
-        self.controller = None
+        super().__init__()
+        self._red_ids = {}
+        self._parent_children_mapping = {}
+        self._data = {}
+        self._gui_data = {}
+        self._read_only_items = {}
+        self._controller = None
+        self._logic = None
+
+    def add_logic(self, logic):
+        self._logic = logic
 
     def set_controller(self, controller):
-        self.controller = controller
+        self._controller = controller
 
     def set_asm_id(self, asm_id):
         self.set_gui_data("asm_id", asm_id)
@@ -161,47 +186,47 @@ class CadItem():
         """ contains all id relations below, data of subassemblies etc. in
             a dict of the kind parent-children
         """
-        self.parent_children_mapping = parent_children_mapping
+        self._parent_children_mapping = parent_children_mapping
     def get_parent_children(self):
-        return self.parent_children_mapping
+        return self._parent_children_mapping
 
     def set_red_ids(self, red_ids):
         """ these ids are not yet known by the PDM"""
-        self.red_ids = red_ids
+        self._red_ids = red_ids
 
     def get_red_ids(self):
-        return self.red_ids
+        return self._red_ids
 
     # Methoden um die Verwendbarkeit einzelner Schalter auszugrauen
     def set_read_only_dict(self, data:dict):
         for k,v in data:
             self.set_read_only(k,v)
     def set_read_only(self, key, val):
-        if key not in self.gui_data:
+        if key not in self._gui_data:
             raise Exception("this data can not be set "+ key)
         else:
-            self.read_only_items[key] = val
+            self._read_only_items[key] = val
     def get_read_only(self, key):
-        return self.read_only_items[key]
+        return self._read_only_items[key]
     def get_all_read_only_data(self):
-        return self.read_only_items
+        return self._read_only_items
 
     # Daten zum Impfen merken
     def set_data_dict(self, data:dict):
         for k,v in data:
             self.set_data(k,v)
     def set_data(self, key, val):
-        if key not in self.data_keys:
+        if key not in self._data_keys:
             raise Exception("this data can not be set "+ key)
         else:
-            self.data[key] = val
+            self._data[key] = val
 
     def get_data(self, key):
         """ gibt ein Datenstück zurück """
-        return self.data[key]
+        return self._data[key]
     def get_all_data(self):
         """ gibt alle enthaltenen Daten zurück """
-        return self.data
+        return self._data
 
     # Daten die in der GUI gespeichert werden sollen
     def set_gui_dict(self, data:dict):
@@ -213,15 +238,15 @@ class CadItem():
         if key not in self.gui_data_keys:
             raise Exception("this data can not be set "+ key)
         else:
-            self.gui_data[key] = val
+            self._gui_data[key] = val
 
     def get_gui_data(self, key):
-        if key in self.gui_data:
-            return self.gui_data[key]
+        if key in self._gui_data:
+            return self._gui_data[key]
         else:
             return None
     def get_all_gui_data(self):
-        return self.gui_data
+        return self._gui_data
 
     def csv2guidata(self, data):
         translated_data = dict()
@@ -238,7 +263,7 @@ class CadItem():
 
 
     def sivas_data_from_csv(self, cid):
-        path = os.path.join(self.controller.get_env("data"), cid + '.csv')
+        path = os.path.join(self._controller.get_env("data"), cid + '.csv')
         if os.path.exists(path):
             data = self._load_csv(path)
             return data
@@ -321,6 +346,14 @@ class CadItem():
         with open(path, 'w') as f:
            json.dump(self.to_dict(tree), f)
 
+    def callback(self, key, value):
+        if self._logic == None:
+            raise Exception("no logic set")
+        else:
+            self._logic.callback(key, value)
+
+    def set_gui_defaults(self):
+        self._logic.set_gui_defaults()
 class CadItemRepository:
     """
     container class for all CadItems in the local folder
@@ -352,6 +385,293 @@ class CadItemRepository:
                 return
         raise Exception("CadItem not found")
 
+
+
+class GuiLogic():
+    """
+    Class for business logic. implementing the dependencies between different user inputs
+    """
+    def __init__(self, model, configs):
+        # das Modell soll hier nur verwendet werden um aktuell Zustände abzufragen!
+        # alles weitere zum Setzen von Daten etc. muss über den Controller laufen, also zurück gegeben werden. 
+        self.model = model 
+        # hier holt man die Daten der Configs
+        self.config = configs
+        # hier sind alle Callbacks bzw. deren Comboboxen 
+
+    def set_gui_defaults(self):
+        # set defaults from given logic
+        self.call_and_set_data('cb_pdm_kategorie_neu')
+        self.call_and_set_data('cb_neuaufbau')
+        self.call_and_set_data('cb_aus_halbzeug_neu')
+        self.call_and_set_data('cb_halbzeugoberflaeche')
+
+    def call_and_set_data(self, callbackfunc):
+        eval('self.model.set_gui_dict(self.'+callbackfunc+'(None))')
+
+    def callback(self, key, value):
+        """gibt ein dict zurück, welches neu im Modell gesetzt wird"""
+
+        ret = dict()
+        if key == 'cb_pdm_kategorie_neu':
+            ret = self.cb_pdm_kategorie_neu(value)
+        elif key == 'cb_neuaufbau':
+            ret = self.cb_neuaufbau(value)
+        elif key == 'cb_aus_halbzeug_neu':
+            ret = self.cb_aus_halbzeug_neu(value)
+        elif key == "cb_halbzeugoberflaeche":
+            ret = self.cb_halbzeugoberflaeche(value)
+        elif key == "cb_halbzeugfarbe":
+            ret = self.cb_halbzeugfarbe(value)
+        elif key == 'cb_lebenszyklus_status_neu':
+            ret = self.cb_lebenszyklus_status_neu(value)
+        elif key == 'cb_3Dmodel_neu':
+            ret = self.cb_3Dmodel_neu(value)
+        elif key == 'cb_halbzeugOhneSaege_neu':
+            pass
+        elif key == 'cb_ruestcode_neu':
+            pass
+        elif key == 'cb_fertigungsart_neu':
+            pass
+        elif key == 'cb_allgemeintoleranz_neu':
+            pass
+        elif key == 'cb_fosGruppe_neu':
+            pass
+        elif key == 'cb_kalkulationsart_neu':
+            pass
+        elif key == 'cb_beschaffungsart_neu':
+            pass
+        elif key == 'cb_mengeneinheit_neu':
+            pass
+        elif key == 'cb_halbzeug_neu':
+            pass
+        elif key == 'cb_dispogruppe_neu':
+            pass
+        elif key == 'cb_dispolaufgruppe_neu':
+            pass
+        elif key == 'cb_hersteller_neu':
+            pass
+        elif key == 'cb_werkstoffdiskrepanz':
+            pass
+        elif key == 'cb_werkstofftyp_neu':
+            pass
+            # ret = self.cb_werkstofftyp_neu(value)
+        elif key == 'cb_material_neu':
+            pass
+        elif key == 'cb_oberflaeche_neu':
+            pass
+        elif key == 'cb_farbe_neu':
+            ret = self.cb_farbe_neu(value)
+        elif key == 'cb_speichern':
+            pass
+        elif key == 'cb_migrieren':
+            pass
+        elif key == 'cb_zurücksetzen':
+            pass
+        elif key == 'cb_suche_asm':
+            pass
+        else:
+            raise Exception("this callback does not exist "+key)
+        return ret
+        
+    def cb_pdm_kategorie_neu(self, selected):
+        """setzt die Dropdownliste mit
+            <undefiniert>, Baugruppe, Einzelteil, Kaufteil, Schweissbaugruppe
+        """
+        ret = dict()
+        categories = self.config.Allgemein.get_options("Kategorien")
+        if selected is None:
+            ret['pdm_kategorie_neu'] = categories[0] 
+            ret['cb_pdm_kategorie_neu'] = categories
+        else:
+            ret['pdm_kategorie_neu'] = selected 
+        return ret
+
+    def cb_neuaufbau(self, trueOrfalse):
+        ret = dict()
+        pdm_kat = self.model.get_gui_data("pdm_kategorie_neu")
+        if pdm_kat != "Einzelteil" or pdm_kat != "Kaufteil":
+            ret["neuaufbau"] = False
+        return ret
+    
+    def cb_aus_halbzeug_neu(self, trueOrfalse):
+        ret = dict()
+        pdm_kat = self.model.get_gui_data("pdm_kategorie_neu")
+        if pdm_kat == "Einzelteil":
+            pass
+        else:
+            ret["aus_halbzeug_neu"] = False
+        return ret
+    
+
+    def cb_halbzeugoberflaeche(self, selected):
+        ret = dict()
+        aus_halbzeug = self.model.get_gui_data("aus_halbzeug_neu")
+        if aus_halbzeug == "True":
+            oarten = self.config.Oberfläche.get_oberflächen_behandlungen()
+            if selected is None:
+                ret['halbzeugoberflaeche_neu'] = oarten[0] 
+                ret['cb_halbzeugoberflaeche'] = oarten
+            else:
+                ret['halbzeugoberflaeche_neu'] = selected 
+        else:
+            ret = { 
+                'halbzeugoberflaeche_neu': "",
+                'cb_halbzeugoberflaeche': "",
+            }
+        return ret
+
+    def cb_lebenszyklus_status_neu(self, selected):
+        ret = dict()
+        lstatus = self.config.Allgemein.get_options("Lebenszyklus") # Serie, Prototyp
+        if selected is None:
+            ret['lebenszyklus_status_neu'] = lstatus[0]
+            ret['cb_lebenszyklus_status_neu'] = lstatus
+        else:
+            ret['cb_lebenszyklus_status_neu'] = selected 
+        return ret
+    
+    def cb_halbzeugfarbe(self, selected):
+        ret = dict()
+        halbzeugoberflaeche = self.model.get_gui_data("halbzeugoberflaeche_neu")
+        aus_halbzeug = self.model.get_gui_data("aus_halbzeug_neu")
+
+        # setze die Inhalte der abhängigen Comboboxen neu 
+        ret = { 
+            'halbzeugfarbe_neu': '', 
+            'cb_halbzeugfarbe': '',
+        }
+        if aus_halbzeug == "True":
+            if halbzeugoberflaeche == "eloxieren":
+                farben_elox = self.config.Farben.get_farben_eloxieren()
+                if selected is None:
+                    ret['halbzeugfarbe_neu'] = farben_elox[0]     # Default, falls nichts gewählt ist
+                    ret['cb_halbzeugfarbe'] = farben_elox         # Liste in der Combobox
+                else:
+                    ret['halbzeugfarbe_neu'] = selected           # vom Nutzer ausgewählter Wert
+            elif halbzeugoberflaeche == "lackieren" or halbzeugoberflaeche == "pulverbeschichten":
+                farbauswahl = self.config.Farben.get_farbauswahl()
+                if selected is None:
+                    ret['halbzeugfarbe_neu'] = farbauswahl[0]
+                    ret['cb_halbzeugfarbe'] = farbauswahl
+                else:
+                    ret['halbzeugfarbe_neu'] = selected
+        else:
+            pass
+        return ret
+
+    def cb_3Dmodel_neu(self, selected):
+        ret = dict()
+        pdm_kategorie_neu = self.model.get_gui_data("pdm_kategorie_neu")
+        if pdm_kategorie_neu == "Baugruppe" or pdm_kategorie_neu == "Schweissbaugruppe":
+            # Defaultwert = \\ssg.local\freigaben\Abteilungen\Entwicklung\CAD\Standards\SolidEdge\Template\DIN Metric\baugruppe.asm
+            # Dropdownwerte = keine
+            # state_ComboBox = disabled
+            # state_Button = disabled
+            # ret = { 
+                # '': '', 
+                # '': '',
+            # }
+            pass
+        elif pdm_kategorie_neu == "Kaufteil":
+            # Defaultwert = \\ssg.local\freigaben\SIVAS_CAD_EDM\Migration\06_3D_Vorlagen\ET_mit_Volumen.par
+            # Dropdownwerte = keine
+            # state_ComboBox = disabled
+            # state_Button = disabled
+            pass
+        elif pdm_kategorie_neu == "Einzelteil":
+            aus_halbzeug = self.model.get_gui_data("aus_halbzeug_neu")
+            neuaufbau = self.model.get_gui_data("neuaufbau")
+            if aus_halbzeug == "True" or neuaufbau == "True":
+                # Defaultwert = \\ssg.local\freigaben\SIVAS_CAD_EDM\Migration\06_3D_Vorlagen\ET_mit_Volumen.par
+                # Dropdownwerte = keine
+                # state_ComboBox = disabled
+                # state_Button = disabled
+                pass
+            else:
+                # Defaultwert = ""
+                # Dropdownwerte = Dateipfade von allen .par-Dateien, die die aktuelle Teilenummer im Dateinamen aufweisen und sich gleichzeitig in einem der rekursiv durchsuchten Pfade aus der Sektion "3D-Modelle" in "Zielpfade.cfg" befinden.
+                # state_ComboBox = readonly
+                # state_Button = keiner
+
+                # IF Button "Durchsuchen" geklickt und benutzerdefinierte Solid Edge-Datei gewählt:
+                    # Defaultwert = Dateipfad der gewählten Solid Edge-Datei
+                pass
+        return ret
+
+
+
+    # def cb_werkstofftyp_neu(self, selected_werkstoff):
+        # """bekommt Aluminium, Stahl etc. und setzt dann die anderen Felder der Oberfläche"""
+
+        # # Logik, die steuert, welcher Defaultwert gilt:
+
+        # #    In den nachfolgenden Fällen darf kein Defaultwert eingetragen
+        # #    werden (selbst wenn in from_siv.csv ein Wert in der Spalte
+        # #    "Werkstoff" eingetragen sein sollte):
+        # #        PDM-Kategorie == "Baugruppe"
+        # #        PDM-Kategorie == "Schweissbaugruppe"
+        # #        PDM-Kategorie == "Einzelteil" und Aus Halbzeug == True (Haken gesetzt)
+
+        # #    Gilt PDM-Kategorie == "Kaufteil" soll der Defaultwert "siehe
+        # #    Hersteller" eingetragen werden
+
+        # #    Gilt PDM-Kategorie == "Einzelteil" und Aus Halbzeug == False (kein
+        # #    Haken), dann wird der Defaultwert wie folgt bestimmt:
+        # ret = dict()
+        # # das Feld selbst mit dem Selektierten beschreiben
+        # ret['werkstofftyp_neu']= selected_werkstoff
+
+        # pdm_kat = self.model.get_gui_data("pdm_kategorie_neu")
+        # aus_halbzeug = self.model.get_gui_data("aus_halbzeug_neu")
+
+        # if pdm_kat == 'Einzelteil' and aus_halbzeug is False:
+            # wnamen = self.config.Werkstoffe.get_werkstoffe_of_name(selected_werkstoff)
+            # # setze die Inhalte der abhängigen Comboboxen neu und den Wert im Modell
+            # ret = { 
+                    # # das Feld selbst mit dem Selektierten beschreiben
+                   # 'werkstofftyp_neu': selected_werkstoff,  
+                    # # die neuen Inhalte der comboboxen setzen
+                   # 'cb_material_neu': wnamen, 
+                    # # der angezeigte Wert der Combos sollte anfangs dem ersten der Liste entsprechen
+                   # 'material_neu': wnamen[0],  
+            # }
+        # return ret
+
+    # def oberfläche(self, selected):
+
+        # ret = dict()
+        # # das Feld selbst mit dem Selektierten beschreiben
+        # ret['oberflaeche_neu']= selected
+
+        # pdm_kat = self.model.get_gui_data("pdm_kategorie_neu")
+        # aus_halbzeug = self.model.get_gui_data("aus_halbzeug_neu")
+
+        # if pdm_kat == 'Einzelteil' and aus_halbzeug is False:
+            # onamen = self.config.Oberfläche.get_oberfläche_of_type(selected)
+            # # setze die Inhalte der abhängigen Comboboxen neu und den Wert im Modell
+            # ret = { 
+                    # # die neuen Inhalte der comboboxen setzen
+                   # 'cb_oberflaeche_neu': onamen, 
+                    # # der angezeigte Wert der Combos sollte anfangs dem ersten der Liste entsprechen
+                   # 'oberflaeche_neu': onamen[0],  
+            # }
+        # return ret
+
+    def cb_farbe_neu(self, selected):
+        farben_alle = self.config.Farben.get_farbauswahl()
+        farben_elox = self.config.Farben.get_farben_eloxieren()
+        # setze die Inhalte der abhängigen Comboboxen neu und den Wert im Modell
+        ret = { 
+                # das Feld selbst mit dem Selektierten beschreiben
+               'farbe_neu': selected,  
+                # die neuen Inhalte der comboboxen setzen
+               'cb_farben': farben_alle, 
+                # der angezeigte Wert der Combos sollte anfangs dem ersten der Liste entsprechen
+               'farbe_neu': farben_alle[0],  
+        }
+        return ret
+
 if __name__ == "__main__":
     pass
 

lib/controller.py

@@ -30,53 +30,59 @@ messages = {
           }
 
 
+# Der Beobachter
+class Observer:
+    def __init__(self, observable):
+        observable.subscribe(self)
+
+    def notify(self, observable, *args, **kwargs):
+        print(f"Got {args} {kwargs} from {observable}")
+
+
 class Controller():
     """
     Class for manipulating the model and returning data for the view
     """
     def __init__(self, model, view):
+        self._environment = None
+        self._observer = None
         self.set_model(model)
         self.set_view(view)
-        self.logic = None
-        self.env = None
 
     def set_env(self, env):
-        self.environment = env
+        self._environment = env
 
     def get_env(self, env_path):
-        if self.environment == None:
+        if self._environment == None:
             raise Exception("No environment set")
         if env_path == "lib":
-            ret = self.environment.lib_dir
+            ret = self._environment.lib_dir
         elif env_path == "data":
-            ret = self.environment.data_dir
+            ret = self._environment.data_dir
         elif env_path == "out":
-            ret = self.environment.out_dir
+            ret = self._environment.out_dir
         elif env_path == "cfg":
-            ret = self.environment.cfg_dir
+            ret = self._environment.cfg_dir
         else:
             raise Exception("this path is not defined  "+env_path)
         return ret
 
-    def add_logic(self, logic):
-        self.logic = logic
-    def remove_logic(self):
-        self.logic = None
-
     def set_model(self, model):
-        self.model = model
+        self._model = model
+        if self._observer == None:
+            self._observer = Observer(model)
     def set_view(self, view):
-        self.view = view
+        self._view = view
 
     def refresh_gui(self):
-        self.view.data_from_model()
+        self._view.data_from_model()
     def data_from_model(self):
-        self.view.data_from_model()
+        self._view.data_from_model()
 
     def get_current_asm_id(self):
-        self.model.get_current_asm_id()
+        self._model.get_current_asm_id()
     def set_current_asm_id(self, asm_id):
-        self.model.set_current_asm_id(asm_id)
+        self._model.set_current_asm_id(asm_id)
 
     
     def set_current_item_id(self, cid):
@@ -85,7 +91,7 @@ class Controller():
         if not cid.isnumeric():
             return 
         # nur die red-id Daten können geladen werden.
-        red_ids = self.model.get_red_ids() 
+        red_ids = self._model.get_red_ids() 
         if not cid in red_ids:
             return 
 
@@ -93,16 +99,16 @@ class Controller():
         self.set_gui_data('teilenummer', cid)
 
         # falls eine .json Datei davon im Work Ordner existiert, dann diese zuerst versuchen ins Modell zu laden
-        isok = self.model.from_json_file(self.get_env("out"), cid)
+        isok = self._model.from_json_file(self.get_env("out"), cid)
         if isok == False:
             # ansonsten die .csv Datei mit den SIVAS Infos aus data holen
-            loaded = self.model.sivas_data_from_csv(cid)
+            loaded = self._model.sivas_data_from_csv(cid)
             if loaded == None:
                 print("no file found "+ cid)
             else:
                 # und diese in der Gui setzen 
-                set_data = self.model.csv2guidata(loaded) 
-                self.logic.create_gui_dependencies()         
+                set_data = self._model.csv2guidata(loaded) 
+                self._model.set_gui_defaults()         
                 self.refresh_gui()
    
     def get_current_item_id(self):
@@ -110,14 +116,14 @@ class Controller():
 
 
     def set_red_ids(self, red_ids):
-        self.model.set_red_ids(red_ids)
+        self._model.set_red_ids(red_ids)
     def get_red_ids(self):
-        return self.model.get_red_ids()
+        return self._model.get_red_ids()
 
     def set_parent_children(self, parent_children_mapping):
-        self.model.set_parent_children(parent_children_mapping)
+        self._model.set_parent_children(parent_children_mapping)
     def get_parent_children(self):
-        return self.model.get_parent_children()
+        return self._model.get_parent_children()
 
     # merkt sich die reinen Daten zum Impfen
     def set_data_dict(self, data:dict):
@@ -126,12 +132,12 @@ class Controller():
             self.set_data(k,v)
     def set_data(self, key, value):
         """merken der Daten zum Impfen"""
-        self.model.set_data(key, value)
+        self._model.set_data(key, value)
 
     def get_data(self, key):
-        return self.model.get_data(key)
+        return self._model.get_data(key)
     def get_all_data(self):
-        return self.model.get_all_data()
+        return self._model.get_all_data()
 
     # merkt sich die Nutzereingaben, bzw. Daten für die GUI
     def set_gui_dict(self, data:dict):
@@ -140,19 +146,23 @@ class Controller():
             self.set_gui_data(k,v)
     def set_gui_data(self, key, value):
         """merken der Eingaben des Nutzers der GUI """
-        self.model.set_gui_data(key, value)
+        self._model.set_gui_data(key, value)
 
     def get_gui_data(self, key):
-        return self.model.get_gui_data(key)
+        return self._model.get_gui_data(key)
     def get_all_gui_data(self):
-        return self.model.get_all_gui_data()
+        return self._model.get_all_gui_data()
 
     def callback(self, key, value):
-        if not self.logic:
-            return 
+        if not self._model:
+            raise Exception("no model yet added")
+
+        # gib dem observer Bescheid, was aufgerufen wurde
+        if self._observer:
+            self._observer.notify(key,value)
 
         # Logik um neue Werte in Oberfläche oder Modell zu füllen
-        model_values = self.logic.callback(key, value)
+        model_values = self._model.callback(key, value)
         if model_values:
             self.set_gui_dict(model_values)
             self.refresh_gui()
@@ -171,307 +181,8 @@ class Controller():
         """speichert die bisherigen Eingaben beider Spalten in eine json Datei"""
         path = os.path.join(self.get_env("out"), str(self.get_current_item_id()) + '.json')
         # die Bauminfos und RedIds dazu werden standardmässig nicht mit gemerkt. 
-        self.model.save(path, False)
+        self._model.save(path, False)
 
-class GuiLogic():
-    """
-    Class for business logic. implementing the dependencies between different user inputs
-    """
-    def __init__(self, model, configs):
-        # das Modell soll hier nur verwendet werden um aktuell Zustände abzufragen!
-        # alles weitere zum Setzen von Daten etc. muss über den Controller laufen, also zurück gegeben werden. 
-        self.model = model 
-        # hier holt man die Daten der Configs
-        self.config = configs
-        # hier sind alle Callbacks bzw. deren Comboboxen 
-
-    def create_gui_dependencies(self):
-        # set defaults from given logic
-
-        value = None
-        # r = self.cb_pdm_kategorie_neu(value)
-        # self.model.set_gui_dict(r)
-        # r= self.cb_neuaufbau(value)
-        # self.model.set_gui_dict(r)
-        # r= self.cb_aus_halbzeug_neu(value)
-        # self.model.set_gui_dict(r)
-        # # r= self.cb_lebenszyklus_status_neu(value)
-        # # self.model.set_gui_dict(r)
-        # r= self.cb_halbzeugoberflaeche(value)
-        # self.model.set_gui_dict(r)
-        # r= self.cb_halbzeugfarbe(value)
-        # self.model.set_gui_dict(r)
-        # # r= self.cb_3Dmodel_neu(value)
-        # # self.model.set_gui_dict(r)
-
-        self.call_and_set_data('cb_pdm_kategorie_neu')
-        self.call_and_set_data('cb_neuaufbau')
-        self.call_and_set_data('cb_aus_halbzeug_neu')
-        self.call_and_set_data('cb_halbzeugoberflaeche')
-
-    def call_and_set_data(self, callbackfunc):
-        eval('self.model.set_gui_dict(self.'+callbackfunc+'(None))')
-
-    def callback(self, key, value):
-        """gibt ein dict zurück, welches neu im Modell gesetzt wird"""
-
-        if key == 'cb_pdm_kategorie_neu':
-            return self.cb_pdm_kategorie_neu(value)
-        elif key == 'cb_neuaufbau':
-            return self.cb_neuaufbau(value)
-        elif key == 'cb_aus_halbzeug_neu':
-            return self.cb_aus_halbzeug_neu(value)
-        elif key == "cb_halbzeugoberflaeche":
-            return self.cb_halbzeugoberflaeche(value)
-        elif key == "cb_halbzeugfarbe":
-            return self.cb_halbzeugfarbe(value)
-        elif key == 'cb_lebenszyklus_status_neu':
-            return self.cb_lebenszyklus_status_neu(value)
-        elif key == 'cb_3Dmodel_neu':
-            return self.cb_3Dmodel_neu(value)
-        elif key == 'cb_halbzeugOhneSaege_neu':
-            pass
-        elif key == 'cb_ruestcode_neu':
-            pass
-        elif key == 'cb_fertigungsart_neu':
-            pass
-        elif key == 'cb_allgemeintoleranz_neu':
-            pass
-        elif key == 'cb_fosGruppe_neu':
-            pass
-        elif key == 'cb_kalkulationsart_neu':
-            pass
-        elif key == 'cb_beschaffungsart_neu':
-            pass
-        elif key == 'cb_mengeneinheit_neu':
-            pass
-        elif key == 'cb_halbzeug_neu':
-            pass
-        elif key == 'cb_dispogruppe_neu':
-            pass
-        elif key == 'cb_dispolaufgruppe_neu':
-            pass
-        elif key == 'cb_hersteller_neu':
-            pass
-        elif key == 'cb_werkstoffdiskrepanz':
-            pass
-        elif key == 'cb_werkstofftyp_neu':
-            pass
-            # return self.werkstofftyp(value)
-        elif key == 'cb_material_neu':
-            pass
-        elif key == 'cb_oberflaeche_neu':
-            pass
-        elif key == 'cb_farbe_neu':
-            return self.cb_farbe_neu(value)
-        elif key == 'cb_speichern':
-            pass
-        elif key == 'cb_migrieren':
-            pass
-        elif key == 'cb_zurücksetzen':
-            pass
-        elif key == 'cb_suche_asm':
-            pass
-        else:
-            raise Exception("this callback does not exist "+key)
-        
-    def cb_pdm_kategorie_neu(self, selected):
-        """setzt die Dropdownliste mit
-            <undefiniert>, Baugruppe, Einzelteil, Kaufteil, Schweissbaugruppe
-        """
-        ret = dict()
-        categories = self.config.Allgemein.get_options("Kategorien")
-        if selected is None:
-            ret['pdm_kategorie_neu'] = categories[0] 
-            ret['cb_pdm_kategorie_neu'] = categories
-        else:
-            ret['pdm_kategorie_neu'] = selected 
-        return ret
-
-    def cb_neuaufbau(self, trueOrfalse):
-        ret = dict()
-        pdm_kat = self.model.get_gui_data("pdm_kategorie_neu")
-        if pdm_kat != "Einzelteil" or pdm_kat != "Kaufteil":
-            ret["neuaufbau"] = False
-        return ret
-    
-    def cb_aus_halbzeug_neu(self, trueOrfalse):
-        ret = dict()
-        pdm_kat = self.model.get_gui_data("pdm_kategorie_neu")
-        if pdm_kat == "Einzelteil":
-            pass
-        else:
-            ret["aus_halbzeug_neu"] = False
-        return ret
-    
-
-    def cb_halbzeugoberflaeche(self, selected):
-        ret = dict()
-        aus_halbzeug = self.model.get_gui_data("aus_halbzeug_neu")
-        if aus_halbzeug == "True":
-            oarten = self.config.Oberfläche.get_oberflächen_behandlungen()
-            if selected is None:
-                ret['halbzeugoberflaeche_neu'] = oarten[0] 
-                ret['cb_halbzeugoberflaeche'] = oarten
-            else:
-                ret['halbzeugoberflaeche_neu'] = selected 
-        else:
-            ret = { 
-                'halbzeugoberflaeche_neu': "",
-                'cb_halbzeugoberflaeche': "",
-            }
-        return ret
-
-    def cb_lebenszyklus_status_neu(self, selected):
-        ret = dict()
-        lstatus = self.config.Allgemein.get_options("Lebenszyklus") # Serie, Prototyp
-        if selected is None:
-            ret['lebenszyklus_status_neu'] = lstatus[0]
-            ret['cb_lebenszyklus_status_neu'] = lstatus
-        else:
-            ret['cb_lebenszyklus_status_neu'] = selected 
-        return ret
-    
-    def cb_halbzeugfarbe(self, selected):
-        ret = dict()
-        halbzeugoberflaeche = self.model.get_gui_data("halbzeugoberflaeche_neu")
-        aus_halbzeug = self.model.get_gui_data("aus_halbzeug_neu")
-
-        # setze die Inhalte der abhängigen Comboboxen neu 
-        ret = { 
-            'halbzeugfarbe_neu': '', 
-            'cb_halbzeugfarbe': '',
-        }
-        if aus_halbzeug == "True":
-            if halbzeugoberflaeche == "eloxieren":
-                farben_elox = self.config.Farben.get_farben_eloxieren()
-                if selected is None:
-                    ret['halbzeugfarbe_neu'] = farben_elox[0]     # Default, falls nichts gewählt ist
-                    ret['cb_halbzeugfarbe'] = farben_elox         # Liste in der Combobox
-                else:
-                    ret['halbzeugfarbe_neu'] = selected           # vom Nutzer ausgewählter Wert
-            elif halbzeugoberflaeche == "lackieren" or halbzeugoberflaeche == "pulverbeschichten":
-                farbauswahl = self.config.Farben.get_farbauswahl()
-                if selected is None:
-                    ret['halbzeugfarbe_neu'] = farbauswahl[0]
-                    ret['cb_halbzeugfarbe'] = farbauswahl
-                else:
-                    ret['halbzeugfarbe_neu'] = selected
-        else:
-            pass
-        return ret
-
-    def cb_3Dmodel_neu(self, selected):
-        ret = dict()
-        pdm_kategorie_neu = self.model.get_gui_data("pdm_kategorie_neu")
-        if pdm_kategorie_neu == "Baugruppe" or pdm_kategorie_neu == "Schweissbaugruppe":
-            # Defaultwert = \\ssg.local\freigaben\Abteilungen\Entwicklung\CAD\Standards\SolidEdge\Template\DIN Metric\baugruppe.asm
-            # Dropdownwerte = keine
-            # state_ComboBox = disabled
-            # state_Button = disabled
-            # ret = { 
-                # '': '', 
-                # '': '',
-            # }
-            pass
-        elif pdm_kategorie_neu == "Kaufteil":
-            # Defaultwert = \\ssg.local\freigaben\SIVAS_CAD_EDM\Migration\06_3D_Vorlagen\ET_mit_Volumen.par
-            # Dropdownwerte = keine
-            # state_ComboBox = disabled
-            # state_Button = disabled
-            pass
-        elif pdm_kategorie_neu == "Einzelteil":
-            aus_halbzeug = self.model.get_gui_data("aus_halbzeug_neu")
-            neuaufbau = self.model.get_gui_data("neuaufbau")
-            if aus_halbzeug == "True" or neuaufbau == "True":
-                # Defaultwert = \\ssg.local\freigaben\SIVAS_CAD_EDM\Migration\06_3D_Vorlagen\ET_mit_Volumen.par
-                # Dropdownwerte = keine
-                # state_ComboBox = disabled
-                # state_Button = disabled
-                pass
-            else:
-                # Defaultwert = ""
-                # Dropdownwerte = Dateipfade von allen .par-Dateien, die die aktuelle Teilenummer im Dateinamen aufweisen und sich gleichzeitig in einem der rekursiv durchsuchten Pfade aus der Sektion "3D-Modelle" in "Zielpfade.cfg" befinden.
-                # state_ComboBox = readonly
-                # state_Button = keiner
-
-                # IF Button "Durchsuchen" geklickt und benutzerdefinierte Solid Edge-Datei gewählt:
-                    # Defaultwert = Dateipfad der gewählten Solid Edge-Datei
-                pass
-        return ret
-
-
-
-    # def werkstofftyp(self, selected_werkstoff):
-        # """bekommt Aluminium, Stahl etc. und setzt dann die anderen Felder der Oberfläche"""
-
-        # # Logik, die steuert, welcher Defaultwert gilt:
-
-        # #    In den nachfolgenden Fällen darf kein Defaultwert eingetragen
-        # #    werden (selbst wenn in from_siv.csv ein Wert in der Spalte
-        # #    "Werkstoff" eingetragen sein sollte):
-        # #        PDM-Kategorie == "Baugruppe"
-        # #        PDM-Kategorie == "Schweissbaugruppe"
-        # #        PDM-Kategorie == "Einzelteil" und Aus Halbzeug == True (Haken gesetzt)
-
-        # #    Gilt PDM-Kategorie == "Kaufteil" soll der Defaultwert "siehe
-        # #    Hersteller" eingetragen werden
-
-        # #    Gilt PDM-Kategorie == "Einzelteil" und Aus Halbzeug == False (kein
-        # #    Haken), dann wird der Defaultwert wie folgt bestimmt:
-        # ret = dict()
-        # # das Feld selbst mit dem Selektierten beschreiben
-        # ret['werkstofftyp_neu']= selected_werkstoff
-
-        # pdm_kat = self.model.get_gui_data("pdm_kategorie_neu")
-        # aus_halbzeug = self.model.get_gui_data("aus_halbzeug_neu")
-
-        # if pdm_kat == 'Einzelteil' and aus_halbzeug is False:
-            # wnamen = self.config.Werkstoffe.get_werkstoffe_of_name(selected_werkstoff)
-            # # setze die Inhalte der abhängigen Comboboxen neu und den Wert im Modell
-            # ret = { 
-                    # # das Feld selbst mit dem Selektierten beschreiben
-                   # 'werkstofftyp_neu': selected_werkstoff,  
-                    # # die neuen Inhalte der comboboxen setzen
-                   # 'cb_material_neu': wnamen, 
-                    # # der angezeigte Wert der Combos sollte anfangs dem ersten der Liste entsprechen
-                   # 'material_neu': wnamen[0],  
-            # }
-        # return ret
-
-    # def oberfläche(self, selected):
-
-        # ret = dict()
-        # # das Feld selbst mit dem Selektierten beschreiben
-        # ret['oberflaeche_neu']= selected
-
-        # pdm_kat = self.model.get_gui_data("pdm_kategorie_neu")
-        # aus_halbzeug = self.model.get_gui_data("aus_halbzeug_neu")
-
-        # if pdm_kat == 'Einzelteil' and aus_halbzeug is False:
-            # onamen = self.config.Oberfläche.get_oberfläche_of_type(selected)
-            # # setze die Inhalte der abhängigen Comboboxen neu und den Wert im Modell
-            # ret = { 
-                    # # die neuen Inhalte der comboboxen setzen
-                   # 'cb_oberflaeche_neu': onamen, 
-                    # # der angezeigte Wert der Combos sollte anfangs dem ersten der Liste entsprechen
-                   # 'oberflaeche_neu': onamen[0],  
-            # }
-        # return ret
-
-    def cb_farbe_neu(self, selected):
-        farben_alle = self.config.Farben.get_farbauswahl()
-        farben_elox = self.config.Farben.get_farben_eloxieren()
-        # setze die Inhalte der abhängigen Comboboxen neu und den Wert im Modell
-        ret = { 
-                # das Feld selbst mit dem Selektierten beschreiben
-               'farbe_neu': selected,  
-                # die neuen Inhalte der comboboxen setzen
-               'cb_farben': farben_alle, 
-                # der angezeigte Wert der Combos sollte anfangs dem ersten der Liste entsprechen
-               'farbe_neu': farben_alle[0],  
-        }
-        return ret
 
 
 

lib/gui.py

@@ -121,12 +121,12 @@ class TreeView():
         self.controller.set_current_item_id(cid)
 
 class LeftFrameAsm(AllFrames):
-    def __init__(self, frame, nrow=0, configs=None):
+    def __init__(self, frame, nrow=0):
         AllFrames.__init__(self, nrow)
         self.frame = frame
-        self.build_widgets(configs)
+        self.build_widgets()
 
-    def build_widgets(self, configs):
+    def build_widgets(self):
         frame = self.frame
         self.rownum = AllFrames.get_rows(self)
         col_left = 0
@@ -163,12 +163,12 @@ class LeftFrameAsm(AllFrames):
             self.asm_number.set(data["asm_id"])
 
 class RightFrameLabels(AllFrames):
-    def __init__(self, frame, nrow=0, configs=None):
+    def __init__(self, frame, nrow=0):
         AllFrames.__init__(self, nrow)
         self.frame = frame
-        self.build_widgets(configs)
+        self.build_widgets()
 
-    def build_widgets(self, configs):
+    def build_widgets(self):
         frame = self.frame
         self.rownum = AllFrames.get_rows(self)
         col_left = 0
@@ -213,12 +213,12 @@ class RightFrameLabels(AllFrames):
             self.teilenummer_text.set(data["teilenummer"])
 
 class RightFramePDM(AllFrames):
-    def __init__(self, frame, nrow=0, configs=None):
+    def __init__(self, frame, nrow=0):
         AllFrames.__init__(self, nrow)
         self.frame = frame
-        self.build_widgets(configs)
+        self.build_widgets()
 
-    def build_widgets(self, configs):
+    def build_widgets(self):
         frame = self.frame
         self.rownum = AllFrames.get_rows(self)
         col_left = 0
@@ -409,18 +409,16 @@ class RightFramePDM(AllFrames):
             self.model3d_combo['values'] = data["cb_3Dmodel_neu"]
 
 class RightFrameBezeichnung(AllFrames):
-    def __init__(self, frame, nrow=0, configs=None):
+    def __init__(self, frame, nrow=0):
         AllFrames.__init__(self, nrow)
         self.frame = frame
-        self.build_widgets(configs)
+        self.build_widgets()
 
-    def build_widgets(self, configs):
+    def build_widgets(self):
         frame = self.frame
         self.rownum = AllFrames.get_rows(self)
         col_left = 0
 
-        #categories = configs.Allgemein.get_options("Kategorien")
-
         # 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)
@@ -465,12 +463,12 @@ class RightFrameBezeichnung(AllFrames):
             self.bezeichnung2_neu.set(data["bezeichnung2_neu"])
 
 class RightFrameHalbzeugOhneS(AllFrames):
-    def __init__(self, frame, nrow=0, configs=None):
+    def __init__(self, frame, nrow=0):
         AllFrames.__init__(self, nrow)
         self.frame = frame
-        self.build_widgets(configs)
+        self.build_widgets()
 
-    def build_widgets(self, configs):
+    def build_widgets(self):
         frame = self.frame
         self.rownum = AllFrames.get_rows(self)
         col_left = 0
@@ -639,18 +637,16 @@ class RightFrameHalbzeugOhneS(AllFrames):
 
 
 class RightFrameBeschaffungsart(AllFrames):
-    def __init__(self, frame, nrow=0, configs=None):
+    def __init__(self, frame, nrow=0):
         AllFrames.__init__(self, nrow)
         self.frame = frame
-        self.build_widgets(configs)
+        self.build_widgets()
 
-    def build_widgets(self, configs):
+    def build_widgets(self):
         frame = self.frame
         self.rownum = AllFrames.get_rows(self)
         col_left = 0
 
-        #categories = configs.Allgemein.get_options("Kategorien")
-
         # Beschaffungsart
         beschaffungsart_label = ttk.Label(frame, text="Beschaffungsart:" )
         beschaffungsart_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
@@ -738,18 +734,16 @@ class RightFrameBeschaffungsart(AllFrames):
             self.halbzeug_combo['values'] = data["cb_halbzeug_neu"]
 
 class RightFrameTOSGruppe(AllFrames):
-    def __init__(self, frame, nrow=0, configs=None):
+    def __init__(self, frame, nrow=0):
         AllFrames.__init__(self, nrow)
         self.frame = frame
-        self.build_widgets(configs)
+        self.build_widgets()
 
-    def build_widgets(self, configs):
+    def build_widgets(self):
         frame = self.frame
         self.rownum = AllFrames.get_rows(self)
         col_left = 0
 
-        #categories = configs.Allgemein.get_options("Kategorien")
-
         # 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)
@@ -907,12 +901,12 @@ class RightFrameTOSGruppe(AllFrames):
             self.hersteller_neu_combo['values'] = data["cb_hersteller_neu"]
 
 class RightFrameWerkstoffdiskrepanz(AllFrames):
-    def __init__(self, frame, nrow=0, configs=None):
+    def __init__(self, frame, nrow=0):
         AllFrames.__init__(self, nrow)
         self.frame = frame
-        self.build_widgets(configs)
+        self.build_widgets()
 
-    def build_widgets(self, configs):
+    def build_widgets(self):
         frame = self.frame
         self.rownum = AllFrames.get_rows(self)
         col_left = 0
@@ -1026,18 +1020,16 @@ class RightFrameWerkstoffdiskrepanz(AllFrames):
 
 
 class RightFrameVersion(AllFrames):
-    def __init__(self, frame, nrow=0, configs=None):
+    def __init__(self, frame, nrow=0):
         AllFrames.__init__(self, nrow)
         self.frame = frame
-        self.build_widgets(configs)
+        self.build_widgets()
 
-    def build_widgets(self, configs):
+    def build_widgets(self):
         frame = self.frame
         self.rownum = AllFrames.get_rows(self)
         col_left = 0
 
-        #categories = configs.Allgemein.get_options("Kategorien")
-
         # Version
         version_label = ttk.Label(frame, text="Version:" )
         version_label.grid(column=col_left, row=self.rownum, sticky=tk.W, padx=3, pady=3)
@@ -1120,12 +1112,12 @@ class RightFrameVersion(AllFrames):
             self.freigabevermerk_neu.set(data["freigabevermerk_neu"])
 
 class RightFrameZusatzinfos(AllFrames):
-    def __init__(self, frame, nrow=0, configs=None):
+    def __init__(self, frame, nrow=0):
         AllFrames.__init__(self, nrow)
         self.frame = frame
-        self.build_widgets(configs)
+        self.build_widgets()
 
-    def build_widgets(self, configs):
+    def build_widgets(self):
         frame = self.frame
         self.rownum = AllFrames.get_rows(self)
         col_left = 0
@@ -1171,13 +1163,13 @@ class RightFrameZusatzinfos(AllFrames):
             self.zusatzinfos_bendef_text.set(data["zusatzinfos_bendef_text"])
 
 class App():
-    def __init__(self, root, configs=None):
+    def __init__(self, root):
         """Standardgui mit Baum zur Anwahl der Teile des Assemblies"""
 
         self.root = root
-        self.build_widgets(root, configs)
+        self.build_widgets(root)
 
-    def build_widgets(self, root, configs):
+    def build_widgets(self, root):
         """ baue alle Frames der Gui auf
         """
 
@@ -1227,27 +1219,27 @@ class App():
         right_frame.grid(row=0,  column=1,  padx=10,  pady=3)
 
 
-        self.lf1 = LeftFrameAsm(left_frame, 0, configs)
+        self.lf1 = LeftFrameAsm(left_frame, 0)
         nrows = self.lf1.get_rows()
         self.lf2 = TreeView(left_frame, nrows)
 
-        self.rf1 = RightFrameLabels(right_frame, 0, configs)
+        self.rf1 = RightFrameLabels(right_frame, 0)
         nrows = self.rf1.get_rows()
-        self.rf2 = RightFramePDM(right_frame, nrows, configs)
+        self.rf2 = RightFramePDM(right_frame, nrows)
         nrows = self.rf2.get_rows()
-        self.rf3 = RightFrameBezeichnung(right_frame, nrows, configs)
+        self.rf3 = RightFrameBezeichnung(right_frame, nrows)
         nrows = self.rf3.get_rows()
-        self.rf4 = RightFrameHalbzeugOhneS(right_frame, nrows, configs)
+        self.rf4 = RightFrameHalbzeugOhneS(right_frame, nrows)
         nrows = self.rf4.get_rows()
-        self.rf5 = RightFrameBeschaffungsart(right_frame, nrows, configs)
+        self.rf5 = RightFrameBeschaffungsart(right_frame, nrows)
         nrows = self.rf5.get_rows()
-        self.rf6 = RightFrameTOSGruppe(right_frame, nrows, configs)
+        self.rf6 = RightFrameTOSGruppe(right_frame, nrows)
         nrows = self.rf6.get_rows()
-        self.rf7 = RightFrameWerkstoffdiskrepanz(right_frame, nrows, configs)
+        self.rf7 = RightFrameWerkstoffdiskrepanz(right_frame, nrows)
         nrows = self.rf7.get_rows()
-        self.rf8 = RightFrameVersion(right_frame, nrows, configs)
+        self.rf8 = RightFrameVersion(right_frame, nrows)
         nrows = self.rf8.get_rows()
-        self.rf9 = RightFrameZusatzinfos(right_frame, nrows, configs)
+        self.rf9 = RightFrameZusatzinfos(right_frame, nrows)
         nrows = self.rf9.get_rows()
 
     def data_from_model(self):