Datenfenster mit Scrollbar für X und Y

gui_window_data.py

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

import os
import csv
import codecs
import tkinter as tk


CONFIG = {'width' : 0,
        'font': ('NimbusSansL', 14),
        'font_color': 'black',
        'entry_bg' : 'grey',
        'back_ground' : 'orange',
        'select_mode': 'single'}


class DataGui(object):

    def __init__(self, controller, result, default_labels, main_title):

        self.root = tk.Toplevel()
        self.root.title(main_title)
        self.conf = CONFIG
        self.controller = controller
        self.default_labels = default_labels
        self.result = result

        # Definition Fenster-Geometrie u. -Position
        self.screenx = self.root.winfo_screenwidth()
        self.screeny =  self.root.winfo_screenheight()
        xpos = 0
        x_state = max([len(row) for row in default_labels]) * 8 + 900
        if self.screenx > x_state:
            xpos = self.screenx - (x_state + 100)
        ypos = 0
        y_state = (len(self.default_labels) * 50) + 200
        if y_state < self.screeny and xpos != 0:
            ypos = y_state - self.screeny
            self.root.geometry("%dx%d+%d+%d" % (x_state, y_state, xpos,
                ypos))
        else:
            self.root.geometry("%dx%d+%d+%d" % (x_state, self.screeny,
                xpos, ypos))

        self.frame = tk.Frame(self.root)
        self.frame.pack(side='top', fill='both', expand=True)
 
        self.frame.config()
        self.label_names = self.default_labels
        self.scr_frame = self.set_scrolled_entries(self.frame, 
            self.label_names, self.result, self.screeny)
        self.scr_frame.pack(expand=True)

        self.button_frame = tk.Label(self.root,
            bg=self.conf['back_ground'])
        self.button_frame.pack(fill='x', ipady=5)

        tk.Button(self.button_frame, text="Abbrechen",
            font=self.conf['font'], fg=self.conf['font_color'],
            highlightthickness=0, command=self.root.destroy
            ).pack(side='right', padx=4)

        tk.Button(self.button_frame, text="Übernehmen",
            font=self.conf['font'], fg=self.conf['font_color'],
            highlightthickness=0, command=self.controller.collect_entries
            ).pack(side='right', padx=4)


    def set_scrolled_entries(self, parent, label_names, result, screeny):

        self.entry_vars = [tk.StringVar() for _ in label_names]
        self.entries = list()
 
        scroll_frame = tk.Frame(parent, bg='red')
        canvas = tk.Canvas(scroll_frame, highlightthickness=0)
        canvas.grid(row=0, column=1, sticky=tk.NSEW)
 
        xscroll = tk.Scrollbar(scroll_frame, orient=tk.HORIZONTAL,
            command=canvas.xview)
        xscroll.grid(row=1, column=1, sticky=tk.EW)
 
        yscroll = tk.Scrollbar(scroll_frame, orient=tk.VERTICAL,
            command=canvas.yview)
        yscroll.grid(row=0, column=2, sticky=tk.NS)
 
        canvas.config(xscrollcommand=xscroll.set)
        scroll_frame.grid_rowconfigure(1, weight=1)
 
        canvas.config(yscrollcommand=xscroll.set)
        scroll_frame.grid_rowconfigure(0, weight=1)

        self.canvas = canvas
        self.bind_scroll(xscroll, self.x_scroll)
        self.bind_scroll(yscroll, self.y_scroll)

        label_frame = tk.Frame(canvas)
        ENTRY_IPADX = 5 # Abstand zu Text in x
        ENTRY_IPADY = 2 # Abstand zu Text in y
        for i, (var, name) in enumerate(zip(self.entry_vars,
                self.label_names)):
            label_container = tk.Frame(label_frame,)
            label_container.grid(row=i, column=0, padx=10, pady=10,
                sticky=tk.NW)
            label = tk.Label(label_container, text=name,
                font=self.conf['font'])
            label.grid(ipady=5, sticky=tk.W)
            entry_container = tk.Frame(label_frame,relief='sunken',
                bd=1, bg=self.conf['entry_bg'])
            entry_container.grid(row=i, column=1)
            entry = tk.Entry(entry_container, textvariable=var, width=70,
                font=self.conf['font'], bg=self.conf['entry_bg'], bd=0,
                highlightthickness=0)
            entry.grid(row=0, column=0, padx=ENTRY_IPADX, pady=ENTRY_IPADY)
            try:
                var.set(''.join([row[i] for row in result]))
            except IndexError:
                var.set('IndexError')
            self.entries.append(var)

        canvas.create_window(0, 0, window=label_frame, anchor=tk.NW)
        canvas.update_idletasks()
        x, y, w, h = label_frame.bbox(tk.ALL)

        h_max = h
        if h > (self.screeny - 150):
            h_max = (self.screeny - 150)

        canvas.config(scrollregion=(x, y, w, h), width=w, height=h_max)

        return scroll_frame


    def check(self, event):
        self.controller.process(self.items)


    def run(self):
        self.root.mainloop()


    def bind_scroll(self, widget, mode):
        #~~ Windows
        widget.bind("<MouseWheel>", mode)
        #~~ Linux      
        widget.bind("<Button-4>", mode)
        widget.bind("<Button-5>", mode)


    def x_scroll(self, event):
        if event.num == 5 or event.delta < 0:
            self.canvas.xview_scroll(1, "unit")
        elif event.num == 4 or event.delta > 0:
            self.canvas.xview_scroll(-1, "unit")


    def y_scroll(self, event):
        if event.num == 5 or event.delta < 0:
            self.canvas.yview_scroll(1, "unit")
        elif event.num == 4 or event.delta > 0:
            self.canvas.yview_scroll(-1, "unit")


class Controller(object):

    def __init__(self, result, default_labels, main_title):
        self.model = Model(default_labels, result)
        self.view = DataGui(self, self.model.items, self.model.items2,
            main_title)

    def process(self, result):
        print(self.view.entry_vars[0])
        print(listbox_item)

    def collect_entries(self):
        entry_data = dict()
        for index, entry_var in enumerate(self.view.entry_vars):
            print("{} : {}".format(self.model.items2[index],
                entry_var.get()))
            entry_data[self.model.items2[index]] = entry_var.get()
        print()
        print(entry_data)

    def run(self):
        self.view.run()


class Model(object):

    def __init__(self, items, items2):
        self.items = items
        self.items2 = items2


def main():
    try:
        Controller(default_labels, result, main_title).run()
    except NameError:
        line = ['TomTom', '4711', 'Hier wird erklärt, was TomTom ist.',
            'Ausführliche Beschreibung zu TomTom. Diese Beschreibung ist \
sooooooooooooooooooooo laaaaaaaaaaaaannnnnnnnnnnnnng, daß es nicht in \
eine Zeile hinein passt!', 'TomTom', '4711', 'Stück', '1', '49,90', '42,90']
        result = set()
        result.add(tuple(line))
        default_labels = ['Lieferant', 'Artikelnummer', 'Benennung',
            'Beschreibung', 'Hersteller', 'Herstellernummer',
            'VE', 'Inhalt', 'Vk', 'Ek']
        main_title = 'Produktdaten'
        Controller(default_labels, result, main_title).run()


if __name__ == '__main__':
    main()