Das deutsche Python-Forum

Code: Alles auswählen

# -*- coding: utf-8 -*-
from tkinter import *
from Kalender import *

def clicked(arg):
    print("geklickt (Tag): " + str(arg))

root = Tk()
root.title("Kalender-Demonstration")
kalender = Kalender(clicked, root)
root.mainloop()

Code: Alles auswählen

# -*- coding: utf-8 -*-
from tkinter import *
from KalenderLogik import *
from TagKachel import *
from HeaderKachel import *
from Arrow import *

class Kalender(Frame):
    def __init__(self, listener, master = None):
        Frame.__init__(self, master)
        self.pack()
        self.KalenderLogik = KalenderLogik()
        self.setToToday()
        self.listener = listener
        
    def rightArrowClicked(self, event):
        print("rechter Pfeil")
        self.KalenderLogik.increaseMonth()
        self.updateIt()
        
    def leftArrowClicked(self, event):
        print("linker Pfeil")
        self.KalenderLogik.decreaseMonth()
        self.updateIt()
        
    def createRightArrow(self):
        self.rightArrow = Arrow("right", self.rightArrowClicked, self)
        self.rightArrow.grid(row = 0, column = 6)
        
    def createLeftArrow(self):
        self.leftArrow = Arrow("left", self.leftArrowClicked, self)
        self.leftArrow.grid(row = 0, column = 0)
        
    def updateIt(self):
        print(self.KalenderLogik.getMonth())
        self.createKacheln()
        self.createHeaderKacheln()
        self.createMonthLabel()
        self.createRightArrow()
        self.createLeftArrow()
        
    def setBackgroundColor(self, day, color):
        self.TagKachelList[day-1].setBackgroundColor(color)
        
    def createMonthLabel(self):
        monthLabel = Canvas(self, width = 5*32, heigh = 30)
        monthLabel.create_rectangle(2, 2, (5*32)-2, 28, fill = "white")
        monthLabel.create_text((((5*32)-2)/2), 15, text = self.KalenderLogik.months[self.KalenderLogik.getMonth()-1] + " " + str(self.KalenderLogik.getYear()), font = 15)
        monthLabel.grid(row = 0, column = 1, columnspan = 5)
        
    def createHeaderKacheln(self):
        self.HeaderKachelList = []
        for i in range(0, 7):
            day = self.KalenderLogik.days[i]
            self.HeaderKachelList.append(HeaderKachel(day, self))
            self.HeaderKachelList[i].grid(row = 1, column = i)

    def createKacheln(self):
        spacer = 6
        self.TagKachelList = []
        for iDay in range(0, self.KalenderLogik.getNumberOfDaysInMonth(self.KalenderLogik.getMonth(), self.KalenderLogik.getYear())):
            self.TagKachelList.append(TagKachel(iDay+1, self))
            self.TagKachelList[iDay].grid(row = int((iDay+spacer) / 7) + 2, column = (iDay+spacer) % 7)

    def getDay(self):
        return self.KalenderLogik.getDay()
    def getMonth(self):
        return self.KalenderLogik.getMonth()
    def getYear(self):
        return self.KalenderLogik.getYear()

    def setDay(self, day):
        self.KalenderLogik.setDay(day)
        self.updateIt()
    def setMonth(self, month):
        self.KalenderLogik.setMonth(month)
        self.updateIt()
    def setYear(self, year):
        self.KalenderLogik.setYear(year)
        self.updateIt()

    def setToToday(self):
        self.KalenderLogik.setToToday()
        self.updateIt()
        
    def notify(self, message):
        self.listener(message)
        
    def setListener(self, listener):
        self.listener = listener

Code: Alles auswählen

# -*- coding: utf-8 -*-
from time import *

class KalenderLogik:
    def __init__(self, master = None):
        self.days = ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"]
        self.months = ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember"]
        self.setToToday()
        
    def increaseMonth(self):
        if self.month in range(1, 12):
            self.month = self.month + 1
        
    def decreaseMonth(self):
        if self.month in range(2, 13):
            self.month = self.month - 1

    def setToToday(self):
        lt = localtime()
        self.year, self.month, self.day = lt[0:3]

    def getYear(self):
        return self.year
    def getMonth(self):
        return self.month
    def getDay(self):
        return self.day

    def setYear(self, year):
        self.year = year
    def setMonth(self, month):
        self.month = month
    def setDay(self, day):
        self.day = day
        
    def getNumberOfDaysInMonth(self, month, year):
        if month <= 7:
            if month == 2:
                if self.schaltjahr(year) == True:
                    return 29
                else:
                    return 28
            else:
                if month % 2 == 0:
                    return 30
                else:
                    return 31
        else:
            if month % 2 == 0:
                return 31
            else:
                return 30

    def schaltjahr(self, year):
        if year % 4 == 0:
            if year % 100 != 0:
                return True
            else:
                if year % 400 == 0:
                    return True
                else:
                    return False

Code: Alles auswählen

# -*- coding: utf-8 -*-
from tkinter import *

class Kachel(Frame):
    def __init__(self, data, backgroundColor, textColor, master = None):
        Frame.__init__(self, master)
        self.data = data
        self.master = master
        self.backgroundColor = backgroundColor
        self.textColor = textColor
        self.Data = Canvas(self, width = 30, heigh = 30)
        self.drawStuff()
        self.Data.pack()
        
    def drawStuff(self):
        self.Data.create_rectangle(2, 2, 28, 28, fill = self.backgroundColor)
        self.Data.create_text(15, 15, text = self.data, fill = self.textColor, font = 15)

    def setBackgroundColor(self, color):
        self.backgroundColor = color
        self.drawStuff()

Code: Alles auswählen

# -*- coding: utf-8 -*-
from Kachel import *

class HeaderKachel(Kachel):
    def __init__(self, day, master = None):
        Kachel.__init__(self, day, "green", "red", master)

Code: Alles auswählen

# -*- coding: utf-8 *-*
from Kachel import *

class TagKachel(Kachel):
    def __init__(self, day, master = None):
        Kachel.__init__(self, day, "blue", "red", master)
        self.Data.bind("<Button-1>", self.callback)
    
    def callback(self, event):
        self.master.notify(self.data)

Code: Alles auswählen

# -*- coding: utf-8 -*-
from tkinter import *

class Arrow(Frame):
    def __init__(self, direction, listener, master = None):
        Frame.__init__(self, master)
        self.Data = Canvas(self, width = 30, heigh = 30)
        self.Data.create_rectangle(2, 2, 28, 28, fill = "white")
        self.drawArrow(direction)
        self.Data.bind("<Button-1>", listener)
        self.Data.pack()
        
    def drawArrow(self, direction):
        if direction == "right":
            self.Data.create_text(15, 15, text = "->")
        if direction == "left":
            self.Data.create_text(15, 15, text = "<-")

Code: Alles auswählen

In [9]: root = tk.Tk()

In [10]: root.children
Out[10]: {}

In [11]: label = tk.Label(root, text='Hallo')

In [12]: root.children
Out[12]: {'157766380': <Tkinter.Label instance at 0x96752ec>}

In [13]: label = tk.Label(root, text='Welt')

In [14]: root.children
Out[14]: 
{'157766380': <Tkinter.Label instance at 0x96752ec>,
 '157766732': <Tkinter.Label instance at 0x967544c>}

In [15]: label.destroy()

In [16]: root.children
Out[16]: {'157766380': <Tkinter.Label instance at 0x96752ec>}

Code: Alles auswählen

    def getYear(self):
        return self.year
    def getMonth(self):
        return self.month
    def getDay(self):
        return self.day
 
    def setYear(self, year):
        self.year = year
    def setMonth(self, month):
        self.month = month
    def setDay(self, day):
        self.day = day

Code: Alles auswählen

def updateIt(self):
        tmpBuffer = self.createKacheln()
        self.buffer.destroy()
        self.buffer = tmpBuffer
        self.buffer.grid(row = 2, column = 0, columnspan = 7)

Code: Alles auswählen

def updateIt(self):
        tmpBufferAlt = self.buffer
        tmpBufferNeu = self.createKacheln()
        tmpBufferNeu.grid(row = 2, column = 0, columnspan = 7)
        
        self.buffer = tmpBufferNeu
        tmpBufferAlt.destroy()

Code: Alles auswählen

def createKacheln(self):
        tmp = BufferClass.BufferClass(self)
        spacer = 6
        for iDay in range(0, self.kalenderLogik.getNumberOfDaysInMonth(self.kalenderLogik.getMonth(), self.kalenderLogik.getYear())):
            tmp.addWidget(Kachel.TagKachel(iDay+1, tmp))
            tmp.widgets[iDay].grid(row = int((iDay+spacer) / 7), column = (iDay+spacer) % 7)
        return tmp

Code: Alles auswählen

# -*- coding: utf-8 -*-
from tkinter import *

class BufferClass(Frame):
    def __init__(self, master = None):
        Frame.__init__(self, master)
        self.widgets = []

    def addWidget(self, widget):
        self.widgets.append(widget)

    def notify(self, data):
        self.master.notify(data)

Code: Alles auswählen

def schaltjahr(year):
    if year % 4 == 0:
        if year % 100 != 0:
            return True
        else:
            if year % 400 == 0:
                return True
            else:
                return False
    else:
        return False

# =>

def schaltjahr(year):
    if year % 4 == 0:
        if year % 100 != 0:
            return True
        else:
            return year % 400 == 0
    else:
        return False

Code: Alles auswählen

def schaltjahr(year):
    if year % 4 == 0:
        return year % 100 != 0 or year % 400 == 0
    else:
        return False

Code: Alles auswählen

def schaltjahr(year):
    return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)

Code: Alles auswählen

def get_number_of_days_in_month2(year, month):
    return 30 + ((month % 2) ^ (month > 7)) - (month == 2) * (2 - isleap(year))

Code: Alles auswählen

from calendar import monthrange
from time import localtime


def get_number_of_days_in_month(year, month):
    return monthrange(year, month)[1]


class Calendar(object):

    SHORT_DAY_NAMES = ['Mo', 'Di', 'Mi', 'Do', 'Fr', 'Sa', 'So']
    MONTH_NAMES = [
        'Januar', 'Februar', 'März', 'April', 'Mai', 'Juni', 'Juli',
        'August', 'September', 'Oktober', 'November', 'Dezember'
    ]

    def __init__(self):
        self.year, self.month, self.day = None, None, None
        self.set_to_today()

    def increase_month(self):
        if self.month < 12:
            self.month += 1

    def decrease_month(self):
        if self.month > 1:
            self.month -= 1

    def set_to_today(self):
        self.year, self.month, self.day = localtime()[0:3]

Code: Alles auswählen

import calendar
from datetime import date as Date


class Calendar(object):

    SHORT_DAY_NAMES = ['Mo', 'Di', 'Mi', 'Do', 'Fr', 'Sa', 'So']
    MONTH_NAMES = [
        'Januar', 'Februar', 'März', 'April', 'Mai', 'Juni', 'Juli',
        'August', 'September', 'Oktober', 'November', 'Dezember'
    ]

    def __init__(self):
        self.year = None
        self.month = None
        self.set_to_current_month()
        self.calendar = calendar.Calendar()

    def increase_month(self):
        if self.month == 12:
            self.month = 1
            self.year += 1
        else:
            self.month += 1

    def decrease_month(self):
        if self.month == 1:
            self.month = 12
            self.year -= 1
        else:
            self.month -= 1

    def set_to_current_month(self):
        today = Date.today()
        self.year = today.year
        self.month = today.month

    def monthdays(self):
        return self.calendar.monthdayscalendar(self.year, self.month)

Code: Alles auswählen

    def create_tiles(self):
        frame = tk.Frame(self)
        for row, week in enumerate(self.calendar.monthdays()):
            for column, day in enumerate(week):
                if day:
                    tile = DayTile(frame, day)
                    tile.grid(row=row, column=column)
        frame.grid(row=42, column=23)  # Cell of the old Frame.
        self.month_frame.destroy()
        self.month_frame = frame

Code: Alles auswählen

frame.grid(row=42, column=23)  # Cell of the old Frame.

Code: Alles auswählen

self.month_frame.destroy()

Code: Alles auswählen

if self.month_frame:
    self.month_frame.destroy()

Code: Alles auswählen

from __future__ import print_function
try:
    import Tkinter as tk
except ImportError:
    import tkinter as tk
from calendar import Calendar, day_abbr, month_name
from datetime import date as Date
from functools import partial
try:
    from future_builtins import zip
except ImportError:
    pass
from itertools import chain, repeat
from locale import LC_ALL, setlocale
try:
    range = xrange
except NameError:
    pass


class Day(tk.Canvas, object):
    def __init__(
        self,
        master,
        day=0,
        active_color='white',
        disabled_color='grey',
        size='2c'
    ):
        self.active_color = active_color
        self.disabled_color = disabled_color
        tk.Canvas.__init__(
            self,
            master,
            width=size,
            height=size,
            bg=self.disabled_color,
            highlightbackground=self.disabled_color
        )
        self.create_text((1, 1), anchor='nw', tags='day_number')
        self._day = None
        self.day = day

    @property
    def day(self):
        return self._day

    @day.setter
    def day(self, day):
        self._day = day
        self.itemconfig('day_number', text=day if day else '')
        self['bg'] = self.active_color if day else self.disabled_color


class CalendarFrame(tk.Frame):

    def __init__(
        self, master, day_clicked_callback=lambda date: None, background='white'
    ):
        tk.Frame.__init__(self, master)
        self.day_clicked_callback = day_clicked_callback
        today = Date.today()
        self.year = today.year
        self.month = today.month
        self.calendar = Calendar()

        self.header_label = tk.Label(self, font=20)
        self.header_label.grid(row=0, column=1, columnspan=5)
        
        tk.Button(
            self, text='<-', command=self.goto_previous_month
        ).grid(row=0, column=0, sticky='news')
        tk.Button(
            self, text='->', command=self.goto_next_month
        ).grid(row=0, column=6, sticky='news')

        for day in self.calendar.iterweekdays():
            label = tk.Label(self, text=day_abbr[day], bg=background)
            label.grid(row=1, column=day, sticky='we', padx=1)

        self.cells = list()
        for row_number in range(6):
            row = list()
            for column_number in range(7):
                cell = Day(self, active_color=background)
                cell.grid(row=row_number + 2, column=column_number)
                cell.bind('<Button-1>', self._day_clicked)
                row.append(cell)
            self.cells.append(row)

        self.update()

    def _day_clicked(self, event):
        day = event.widget.day
        if day:
            self.day_clicked_callback(Date(self.year, self.month, day))

    def update(self):
        self.header_label['text'] = '{0} - {1}'.format(
            month_name[self.month], self.year
        )
        weeks = self.calendar.monthdayscalendar(self.year, self.month)
        for cells, week in zip(self.cells, chain(weeks, repeat([0] * 7))):
            for cell, day in zip(cells, week):
                cell.day = day

    def goto_previous_month(self):
        if self.month == 1:
            self.month = 12
            self.year -= 1
        else:
            self.month -= 1
        self.update()

    def goto_next_month(self):
        if self.month == 12:
            self.month = 1
            self.year += 1
        else:
            self.month += 1
        self.update()


def main():
    setlocale(LC_ALL, '')
    root = tk.Tk()
    calendar = CalendarFrame(root, partial(print, 'Tag:'))
    calendar.pack()
    root.mainloop()


if __name__ == '__main__':
    main()