ZOOM für tkinter-GUI bei verschiedenen Displaygrößen?

Fragen zu Tkinter.
Nobuddy
User
Beiträge: 994
Registriert: Montag 30. Januar 2012, 16:38

Ich habe das mit Sirius3ś Kritik, verbessert und unnötige Einträge vereinfacht.

Code: Alles auswählen

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# For Python3.x


import os
import csv
import codecs
from functools import partial

"""Private Module"""
import data_load as Data


## Schreiben Daten in Datei
# Schreibe die Daten von datenpool in filename
def write_csv(filename, datenpool):
    with codecs.open(filename, "w") as zielfile:
        writer = csv.writer(zielfile, delimiter="\t", quotechar="^")
        writer.writerows(datenpool)

my_reader = partial(csv.reader, delimiter='\t', quotechar='^')

class ScreenConf(object):
    """
    Gebe für die Displaygröße, das entsprechende Layout aus.
    Rüchgabewert:
    - Text normal, für Textausgabe
    - Text ca. 16 % größer als normal, für Buttons und Texteingabe
    - wie oben, Schrift fett
    - Höhe von unterem Frame
    - Breite Distanz
    - Breite Distanz2
    - Breite Distanz3
    - Breite Distanz4
    - Breite Eingabe Textfeld
    - Breite Eingabe2 Textfeld
    - Schriftfarbe schwarz
    - Schriftfarbe weiß
    - Schriftfarbe dunkelgrau, Buttons
    - Schriftfarbe dunkelrot, Buttons
    - Hintergrundfarbe grau, für Texteingabe, Textfenster, Buttons
    """

    def __init__(self, screenx, screeny):

        self.screenx = screenx
        self.screeny = screeny
        self.base_xy = 1680, 1050
        self.font = 'NimbusSansL'   # Schriftart
        self.col1 = 'black'
        self.col2 = 'white'
        self.col3 = 'darkgrey'
        self.col4 = 'darkred'
        self.col5 = 'grey'

        self.filelist = 'screendefinition'
        self.screen = Data.ListDef(self.filelist, 'screen')
        with codecs.open(Data.Path(self.filelist), 'r') as infile:
            for row in my_reader(infile):
                if row[self.screen] == '{} x {}'.format(self.screenx,
                        self.screeny):
                    self.screenline = row


    def myscreen(self):
        """
        Berechne die neue Displaygröße anhand der Basiswerte.
        Erstelle Datensatz für neues Display in 'gui_screendefinition'.
        """

        mylist = list()
        try:
            # Erstelle das Displaylayout.
            for i, row in enumerate(self.screenline):
                if i != 0 and i < 3:
                    mylist.append((self.font, row))
                if i == 2:
                    mylist.append((self.font, row, 'bold'))
                if i > 2:
                    mylist.append(row)
        except AttributeError:
            # Verhältnis zwischen der Basis-Displaygröße
            # und der neuen Displaygröße definieren.
            self.x_diff = round((self.screenx / self.base_xy[0]), 2)
            self.y_diff = round((self.screeny / self.base_xy[1]), 2)
            self.diff = self.x_diff * self.y_diff
            # Lade die Werte der Basis-Displaygröße
            # Erstelle Liste aus self.filelist
            data = list()
            with codecs.open(Data.Path(self.filelist), 'r') as infile:
                for row in my_reader(infile):
                    if row[self.screen] == '{} x {}'.format(self.base_xy[0],
                            self.base_xy[1]):
                        self.baseline = row
                    data.append(row)
            # Erstelle die Werte für die neue Displaygröße
            mynewlist = list()
            for i, row in enumerate(self.baseline):
                if i == 0:
                    mynewlist.append('{} x {}'.format(self.screenx,
                        self.screeny))
                else:
                    mynewlist.append(round(float(row) * self.diff))
            # Aktualisiere self.filelist mit den neuen Werten.
            newdata = list()
            newdata.append(mynewlist)
            [newdata.append(row) for row in data]
            write_csv(Data.Path(self.filelist), sorted(newdata))
            # Erstelle das neue Displaylayout.
            for i, row in enumerate(self.mynewlist):
                if i != 0 and i < 3:
                    mylist.append((self.font, row))
                if i == 2:
                    mylist.append((self.font, row, 'bold'))
                if i > 2:
                    mylist.append(row)
        mylist.append(self.col1)
        mylist.append(self.col2)
        mylist.append(self.col3)
        mylist.append(self.col4)
        mylist.append(self.col5)
        return mylist


if __name__ == '__main__':
    # Test
    ScreenConf(1600, 900).myscreen()

Code: Alles auswählen

"""Private Module"""
from gui_screenconf import ScreenConf

class View(object):

    def __init__(self, controller):
        self.port = prog_check(PROGRAMMNAME)
        print('Port: %s, PID: %s' % (self.port, os.getpid()))
 
        self.root = tk.Tk()
        self.title = "EDV-Work"
        self.root.title(self.title)
        self.controller = controller
        xpos = 0
        ypos = 0
        self.screenx = self.root.winfo_screenwidth()
        self.screeny =  self.root.winfo_screenheight()
        self.root.geometry("%dx%d+%d+%d" % (self.screenx,
            self.screeny, xpos, ypos))

        # Layout Definition
        self.mylayout = ScreenConf(self.screenx, self.screeny).myscreen()
        self.txt = self.mylayout[0]
        self.txt2 = self.mylayout[1]
        self.txt2b = self.mylayout[2]
        self.fluy = self.mylayout[3]
        self.distanzx = self.mylayout[4]
        self.distanzx2 = self.mylayout[5]
        self.distanzx3 = self.mylayout[6]
        self.distanzx4 = self.mylayout[7]
        self.eingabex = self.mylayout[8]
        self.eingabex2 = self.mylayout[9]
        self.fc = self.mylayout[10]
        self.fcw = self.mylayout[11]
        self.fcdg = self.mylayout[12]
        self.fcdr = self.mylayout[13]
        self.bg = self.mylayout[14]
Antworten