Datenhaltung Python GUI

[Karl (Gast)]

Hallo,

ich möchte ein Programm mit einer GUI mit wxPython schreiben. Ich habe 
verschiedenen Klassen definiert, in denen die Daten gespeichert werden 
sollen (diese werden dann an andere Funktionsklassen übergeben und 
berechnen das Ergebnis. Das Backend ist fertig.). Die GUI habe ich als 
wx.Notebook konzipiert. Nun frage ich mich, wie bzw. wo ich sie Daten 
der Klassen speichern soll. Die Daten sollen z.b. mit einem wx.TextCtrl 
auf einem Panel eingegeben werden und bei einem Event (Button, Change 
...) kann ich die Eingabe des TextCtrl dann einer Instanz der Klasse 
übergeben. Die Frage ist, wo "deklariere" ich diese? Quick und Dirty 
wäre natürlich das global zu machen. Alternativ könnte ich mir 
vorstellen das z.B. an den Frame oder das Panel anzuhängen. Dann muss 
man aber z.B. über GetParent() darauf zugreifen und wenn man später an 
der Struktur der GUI was ändert, dann muss man auch alles überarbeiten. 
Gibt es bessere Möglichkeiten?

[MaWin (Gast)]

Code zeigen

[Heiner (Gast)]

MVC ist bekannt? Die Klassendeklaration gehören ins model, der 
controller zieht die Daten aus der view, sobald das entsprechende 
Ereignis eingetreten ist, und setzt sie zu einer Instanz deiner 
Datenklasse zusammen. Dann wird sie dort entweder weiterverarbeitet oder 
geht zwecks Persistenz ins model.

Da die Geschichte nun leider schon halb fertig gestrickt ist, könnte es 
etwas fummelig werden, diese Struktur nachträglich herzustellen. Das ist 
die Folge davon, sich über solche Dinge nicht Gedanken zu machen, bevor 
auch nur eine einzige Zeile Code geschrieben ist. Keine Panik, nächstes 
mal machst du es besser.

MaWin schrieb:
> Code zeigen

Hör auf, die Leute zu nerven. Wozu soll das auf diesem 
Abstraktionsniveau gut sein?

[Karl (Gast)]

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
@author: 
"""

import wx
import wx.dataview as dv
import os
import sys
from scr.entry import *


_ = wx.GetTranslation


def getNextImageID(count):
    imID = 0
    while True:
        yield imID
        imID += 1
        if imID == count:
            imID = 0
class MyDisplaySettings():
    def __init__(self):
        '''Settings for various Displays
        
        ToolSize - Symboly of ToolBar
        FrameSize - Main Window
        BookSize - Symbols of Toolbook
        '''

        #get horizontal resulution of smalest Display
        MinHorSize = 10000 
        Displays = (wx.Display(i) for i in range(wx.Display.GetCount()))
        Sizes = [Display.GetGeometry().GetSize() for Display in Displays]
        for size in Sizes:
            if size[0] < MinHorSize:
                MinHorSize = size[0]
        #MinHorSize = 1000
        if MinHorSize < 1024:
            self.ToolSize = (24,24)
            self.FrameSize = (800,600)
            self.BookSize = (36,36)
        else:
            self.ToolSize = (48,48)
            self.FrameSize = (1440,900)
            self.BookSize = (72,72)
        self.ProjectParameterColumn = int((self.FrameSize[0]-self.BookSize[0])/4)

class MyApp(wx.App):
    locale = None

    def OnInit(self):
        print('Running wxPython ' + wx.version())
        # Set Current directory to the one containing this file
        os.chdir(os.path.dirname(os.path.abspath(__file__)))
        self.SetAppName('Helical_pile_GUI')
        self.InitLanguage()
        # Create the main window
        myFrame = MyFrame()
        self.SetTopWindow(myFrame)
        myFrame.Show()
        return True


    def InitLanguage(self):
        '''Load language settings'''
        #https://wiki.wxpython.org/How%20to%20use%20the%20Internationalization%20-%20i18n%20%28Phoenix%29?action=AttachFile&do=view&target=source.zip
        langsAvail = {
            "System default" : wx.LANGUAGE_DEFAULT,
            "English"        : wx.LANGUAGE_ENGLISH,
            "German"         : wx.LANGUAGE_GERMAN,
        }
        lang = wx.LANGUAGE_DEFAULT
        wx.Locale.AddCatalogLookupPathPrefix("locale")
        self.locale = wx.Locale()
        if not self.locale.Init(lang):
            wx.LogWarning("This language is not supported by the system.")
        if not self.locale.AddCatalog("GUI"):
            wx.LogError("Couldn't find/load the 'GUI' catalog for locale '" + self.locale.GetCanonicalName() + "'.")
            
class MyFrame(wx.Frame):
    def __init__(self):
        '''Main Frame with Toolbar, Statusbar and Toolbook''' 
        DS = MyDisplaySettings() 
        super().__init__(None, title=_('GUI'), size = DS.FrameSize)
        self.CreateStatusBar()
        self.MakeToolBar()
        panel = wx.Panel(self)
        notebook = MyToolbook(panel)
        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(notebook, 1, wx.ALL|wx.EXPAND, 5)
        panel.SetSizer(sizer)
        self.Layout()      
        self.Show()
    def MakeToolBar(self):
        '''Init Toolbar with Buttons'''
        DS = MyDisplaySettings()
        myToolBar = self.CreateToolBar(wx.TB_TEXT)
        # New Button to start new Project
        new_bmp =  wx.ArtProvider.GetBitmap(wx.ART_NEW, wx.ART_TOOLBAR, DS.ToolSize)
        self.ButtonNew = myToolBar.AddTool(10, "New", new_bmp, wx.NullBitmap, wx.ITEM_NORMAL, "New", "Long help for 'New'", None)
        self.Bind(wx.EVT_TOOL, self.OnToolClick, id=10)
        self.Bind(wx.EVT_TOOL_RCLICKED, self.OnToolClick, id=10)
        #print(self.ButtonNew.GetId())
        #Open Button
        open_bmp = wx.ArtProvider.GetBitmap(wx.ART_FILE_OPEN, wx.ART_TOOLBAR, DS.ToolSize)
        
    def OnToolClick(self,event):
        print('Click')
        
class MyMainPanel(wx.Panel):
    def __init__(self, parent):
        super().__init__(parent)
        myToolbook = MyToolbook(self)
        
class MyToolbook(wx.Toolbook):
    def __init__(self, parent):
        super().__init__(parent, style = wx.BK_LEFT)
        self.DS = MyDisplaySettings()
        
        # make an image list using ./img folder
        il = wx.ImageList(self.DS.BookSize[0], self.DS.BookSize[1])
        bmp = self.scale_bitmap(wx.Bitmap('./img/prj.png', wx.BITMAP_TYPE_PNG))
        il.Add(bmp)
        bmp = self.scale_bitmap(wx.Bitmap('./img/soil.png', wx.BITMAP_TYPE_PNG))
        il.Add(bmp)
        bmp = self.scale_bitmap(wx.Bitmap('./img/strat.png', wx.BITMAP_TYPE_PNG))
        il.Add(bmp)
        bmp = self.scale_bitmap(wx.Bitmap('./img/geom.png', wx.BITMAP_TYPE_PNG))
        il.Add(bmp)
        self.AssignImageList(il)
        
        panel = MyToolbookPanelMaster(self)
        PanelProject = MyToolbookProject(self)
        self.AddPage(PanelProject,_('Project'), imageId=0)
        self.AddPage(panel,_('Soil'), imageId=1)
        self.AddPage(panel,_('Layering'), imageId=2)
        self.AddPage(panel,_('Geometry'), imageId=3)
        
    
    def scale_bitmap(self, bitmap):
        image = bitmap.ConvertToImage()
        image = image.Scale(self.DS.BookSize[0], self.DS.BookSize[1], wx.IMAGE_QUALITY_HIGH)
        result = wx.Bitmap(image)
        return result
        
class MyToolbookPanelMaster(wx.Panel):
    def __init__(self, parent):
        super().__init__(parent)
        self.SetBackgroundColour(wx.WHITE)
        
class MyToolbookProject(MyToolbookPanelMaster):
    def __init__(self, parent):
        super().__init__(parent)
        DS = MyDisplaySettings()
        BS = wx.BoxSizer(wx.VERTICAL)
        
        
        self.listctrl = listctrl = dv.DataViewListCtrl(self, style = dv.DV_ROW_LINES | dv.DV_VERT_RULES | dv.DV_MULTIPLE | dv.DV_HORIZ_RULES | dv.DV_VARIABLE_LINE_HEIGHT)
        

        listctrl.AppendTextColumn(_("Parameter"), width =  DS.ProjectParameterColumn) #flags=dv.DATAVIEW_COL_RESIZABLE
        listctrl.AppendTextColumn(_("Value"), width =  DS.ProjectParameterColumn*2, mode=dv.DATAVIEW_CELL_EDITABLE)
        
        self.data = data = Project()
        data.Name = "Spannendes Projekt"
        data.Location = "an einem geheimen Ort"
        data.Description = "Eine spannende Konstruktion zur zur Ausführung toller Sachen"
        
        self.datalist = [[_('Name'), data.Name],
                         [_('Location'), data.Location],
                         [_('Description'), data.Description]]
        
        for Item in self.datalist:
            listctrl.AppendItem(Item)
        
        self.Bind(dv.EVT_DATAVIEW_ITEM_EDITING_DONE, self.edit_done, listctrl)
        BS.Add(listctrl, 1, wx.EXPAND, 20) #wx.EXPAND wx.ALL wx.SHAPED
        self.SetSizer(BS)
        
    def edit_done(self,event):
        print(self.listctrl.GetSelectedRow()][1])
        #Hier die Daten aus der listctrl und an Project übergeben
        #aber wo soll man Project speichern um es später z.b. auf 
        #Toolbook-Page Geometry zu verwenden?
        
if __name__ == '__main__':
    app = MyApp()
    app.MainLoop()

[Karl (Gast)]

Ich hänge bei

class MyToolbookProject

 bzw. dort bei

def edit_done(self,event):

Die Klasse Project ist dabei das Trivialste und hat nur die 3 Member. 
Aber andere Klassen sind da etwas komplizierter gestrickt.

[Karl (Gast)]

Später soll natürlich auch ein Speicher-Button in die Toolbar, womit 
dann die ganzen Daten der Objekte (also Project, Soil ...) auf der 
Festplatte gespeichert werden können.

[MaWin (Gast)]

Karl schrieb:
> Alternativ könnte ich mir
> vorstellen das z.B. an den Frame oder das Panel anzuhängen. Dann muss
> man aber z.B. über GetParent() darauf zugreifen

Nicht unbedingt.

Klassen, die Zugriff auf die Datenhaltung benötigen können dies auf 
mehrere Arten bekommen:
- Wie du schon sagtest indirekt über die GUI-Hierarchie.
- Man kann bei der Erstellung der Klassen bereits eine Referenz auf die 
Datenhaltung mitgeben.
- Jede Klasse kann ihren Parent fragen, ob dieser eine Referenz auf die 
Daten hat. Wenn nicht, wird die Anfrage an den Parent weitergereicht. 
Bis man irgendwann oben angekommen ist, bei einer Klasse, die die 
Anfrage befriedigen kann. Das ist im Prinzip das umgekehrte Design des 
vorherigen Punkts. Bei Änderung der Daten oder Ablagestruktur ändert 
sich nichts an den weiterreichenden Schichten.
- Global. Ja, kann man machen. Wenn man absolut ausschließen kann, dass 
man die Hierarchie mehrfach instanziieren können muss. Aber wäre jetzt 
auch nicht meine erste Lösung.

[Karl (Gast)]

Heiner schrieb:
> MVC ist bekannt?

War mir nicht bekannt, ich kannte nur Entity-control-boundary.

Heiner schrieb:
> Da die Geschichte nun leider schon halb fertig gestrickt ist, könnte es
> etwas fummelig werden, diese Struktur nachträglich herzustellen.

Ist noch weit weg von halb fertig. Ich denke es lässt sich relativ 
einfach noch ergänzen.

Heiner schrieb:
> MaWin schrieb:
>> Code zeigen
>
> Hör auf, die Leute zu nerven. Wozu soll das auf diesem
> Abstraktionsniveau gut sein?

Ich hatte beim erstellen schon überlegt, den Code mitzugeben, dann aber 
mich restmal für die "Abstraktion" entschieden. Ich kann MaWins wünsch 
nachvollziehen.
Ich werde eine Controllerklasse schreiben und die als Referenz mitgeben. 
Auf das implementieren eines "Beobachter" werde ich aber wohl 
verzichten. Prinzipiell wäre es sicher Toll, die Software am Reißbrett 
zu entwerfen und dann umzusetzen, abe ich bin kein Informatiker und das 
Gesamtprojekt ist doch ehr überschaubar.