Das deutsche Python-Forum

Code: Alles auswählen

#!/usr/bin/env python

'''
	Description:    a calendar-widget for Tkinter
	Version:        0.2
	Copyright:      2004 by Markus Weihs (ehm_dot_weihs_at_utanet_dot_at)
	Created:        2004-07-17
	Last modified:  2004-07-18
	Licence:        free
	Requirements:   Python,Tkinter 
'''

import Tkinter as tk
from calendar import setfirstweekday, monthcalendar

class TkCalendar(tk.Frame):


	def __init__(self,y,m,us=0):
		tk.Frame.__init__(self,bd=2,relief=tk.GROOVE)
		self.year = y
		self.month = m
		self.date = tk.StringVar()

		if us:
			self.dayArray = ["Su","Mo","Tu","We","Th","Fr","Sa"]
			self.col = 0
			setfirstweekday(6)
		else:
			self.dayArray = ["Mo","Di","Mi","Do","Fr","Sa","So"]
			self.col = 6

		f = tk.Frame(self)
		f.pack(fill=tk.X)
		tk.Button(f,
			text='<',
			command=self.__decrease,
			relief=tk.FLAT).pack(side=tk.LEFT)
		self.l = tk.Label(f,text="%.2i.%i" % (self.month,self.year))
		self.l.pack(side=tk.LEFT,padx=12)
		tk.Button(f,
			text='>',
			command=self.__increase,
			relief=tk.FLAT).pack(side=tk.RIGHT)

		self.c = tk.Canvas(self,
			width=140,height=135,
			bg='white',bd=2,relief=tk.GROOVE)
		self.c.bind('<1>', self.__click)
		self.c.pack()
		
		self.__fill_canvas()

	def __fill_canvas(self):
		m = monthcalendar(self.year,self.month)
	
		for col in range(len(m[0])):
			for row in range(len(m)):
				if m[row][col]==0:
					pass
				else:
					if col==self.col:
						self.c.create_text(
							col*20+12,row*20+30,
							text="%2i" % m[row][col],fill='red',tags='day')
					else:
						self.c.create_text(
							col*20+12,row*20+30,
							text="%2i" % m[row][col],tags='day')
		x=12; y=10
		for i in self.dayArray:
			self.c.create_text(x,y,text=i,fill='blue', tags='day')
			x+=20

	def __decrease(self):
		self.c.delete('day')
		if self.month == 1:
			self.year -= 1
			self.month = 12
		else:
			self.month -= 1
		self.l.configure(text="%.2i.%i" % (self.month, self.year))
		self.__fill_canvas()
	

	def __increase(self):
		self.c.delete('day')
		if self.month == 12:
			self.year += 1
			self.month = 1
		else:
			self.month += 1
		self.l.configure(text="%.2i.%i" % (self.month, self.year))
		self.__fill_canvas()
	
	def __click(self,event):
		x = self.c.find_closest(event.x,event.y)[0]
		try:
			day = self.c.itemcget(x,'text')
			self.date.set("%.2i.%.2i.%i" % (int(day),self.month,self.year))
			print self.date.get()
		except: pass


if __name__ == '__main__':
	from time import localtime
	year,month = localtime()[0:2]
	root = tk.Tk()
	c = TkCalendar(year, month)		       # european version
	#c = TkCalendar(year, month, us=1)   # us version
	c.pack()
	root.mainloop()

Code: Alles auswählen

class HolidayInput(tkSimpleDialog.Dialog):
    def __init__(self, parent, year, title=None, start=None):
        self.y=year
        self.s=start
        tkSimpleDialog.Dialog.__init__(self, parent, title)
    def body(self, master):
        self.sel=YearSelect(master, self.y, self.s)
    def apply(self):
        self.result=self.sel.result

Code: Alles auswählen

#!/usr/local/bin/python
# -*- coding: cp1252 -*-
# File: DaySelect.py
# Routinen zur Auswahl eines Datums
# oder mehrerer Tage in einem bestimmten Monat oder Jahr
# Geschrieben von Hans-Werner Krause, 03/2006 in Python
# Anleihen von Markus Weihs TkCalendar

from calendar import monthcalendar, isleap
from datetime import date, timedelta
from Tkinter import *

HolidayYear=0
HolidayList=[]
DayName=('Mo', 'Di', 'Mi', 'Do', 'Fr', 'Sa', 'So')
MonthName=('Januar', 'Februar', 'März', 'April', 'Mai', 'Juni', 'Juli', \
                  'August', 'September', 'Oktober', 'November', 'Dezember')

class YearSelect:
    def __init__(self, master, y, start=[]):
        c=[]
        Label(master, text=y).pack()
        for i in range(4):
            f1=(Frame(master))
            f1.pack()
            for j in range(3):
                f2=Frame(f1)
                f2.pack(side=LEFT)
                m=3*i+j
                try:
                    s=start[m]
                except:
                    s=[]
                c.append(MonthSelect(f2, m+1, y, s))
        self.result=[x.result for x in c]
                
class MonthSelect:
    def __init__(self, master, m, y, start=[]):
        smonth=[31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
        if isleap(y):
            smonth[1]=29
        if m<1:
            m=1
        if m>12:
            m=12
        self.result=[]
        for i in start:
            try:
                d=int(i)
            except:
                continue
            if d>0 and d<=smonth[m-1]:
                self.result.append(d)
        Label(master, text=MonthName[m-1]).pack()
        self.c=Canvas(master, width=140, height=135, bg='white', \
                      bd=2, relief=GROOVE)
        self.c.bind('<Button-1>', self.click)
        self.c.pack()
        mc=monthcalendar(y, m)
        for col in range(len(mc[0])):
            for row in range(len(mc)):
                d=mc[row][col]
                if d==0:
                    pass
                else:
                    if d in self.result:
                        if isHoliday(d, m, y):
                            self.c.create_text(col*20+12, row*20+30, \
                                text='%2i' % d, fill='green', tags='holiday')
                        else:
                            self.c.create_text(col*20+12, row*20+30, \
                                text='%2i' % d, fill='green')
                    else:
                        if isHoliday(d, m, y):
                            self.c.create_text(col*20+12, row*20+30, \
                                text='%2i' % d, fill='red', tags='holiday')
                        else:
                            self.c.create_text(col*20+12, row*20+30, \
                                text='%2i' % d, fill='black')
        x=12
        for i in DayName:
            self.c.create_text(x, 10, text=i, fill='blue')
            x+=20

    def click(self, event):
        x=self.c.find_closest(event.x, event.y)[0] 
        dd=self.c.itemcget(x, 'text')
        if dd.isalpha():
            return
        d=int(dd)
        if d in self.result:
            self.result.remove(d)
            if 'holiday' in self.c.itemcget(x, 'tags'):
                self.c.itemconfig(x, fill='red')
            else:
                self.c.itemconfig(x, fill='black')
        else:
            self.result.append(d)
            self.result.sort()
            self.c.itemconfig(x, fill='green')

class DaySelect:
    def __init__(self, master, m=None, y=None):
        if m is None:
            m=date.today().month
        else:
            if m<1:
                m=1
            if m>12:
                m=12
        if y is None:
            y=date.today().year
        self.m=m
        self.y=y
        self.l=Label(master)
        self.l.pack()
        self.c=Canvas(master, width=140, height=135, bg='white', \
                      bd=2, relief=GROOVE)
        self.c.bind('<Button-1>', self.click)
        self.c.pack()
        Button(master, text='<', width=2, command=self.mDecrease).\
                  pack(side=LEFT, padx=10)
        Button(master, text='<<', width=2, command=self.yDecrease).\
                  pack(side=LEFT)
        Button(master, text='>', width=2, command=self.mIncrease).\
                  pack(side=RIGHT, padx=10)
        Button(master, text='>>', width=2, command=self.yIncrease).\
                  pack(side=RIGHT)
        x=12
        for i in DayName:
            self.c.create_text(x, 10, text=i, fill='blue') 
            x+=20
        self.draw()

    def click(self, event):
        x=self.c.find_closest(event.x, event.y)[0] 
        dd=self.c.itemcget(x, 'text')
        if dd.isalpha():
            return
        d=int(dd)
        if self.xOld is not None:
            if 'holiday' in self.c.itemcget(self.xOld, 'tags'):
                self.c.itemconfig(self.xOld, fill='red')
            else:
                self.c.itemconfig(self.xOld, fill='black')
        self.c.itemconfig(x, fill='green')
        self.result=d, self.m, self.y
        self.xOld=x

    def mDecrease(self):
        if self.m==1:
            self.m=12
            self.y-=1
        else:
            self.m-=1
        self.c.delete('day')
        self.draw()

    def yDecrease(self):
        self.y-=1
        self.c.delete('day')
        self.draw()

    def mIncrease(self):
        if self.m==12:
            self.m=1
            self.y+=1
        else:
            self.m+=1
        self.c.delete('day')
        self.draw()

    def yIncrease(self):
        self.y+=1
        self.c.delete('day')
        self.draw()

    def draw(self):
        self.result=None
        self.xOld=None
        self.l.config(text=MonthName[self.m-1]+' '+str(self.y))
        mc=monthcalendar(self.y, self.m)
        for col in range(len(mc[0])):
            for row in range(len(mc)):
                d=mc[row][col]
                if d==0:
                    pass
                else:
                    if isHoliday(d, self.m, self.y):
                        self.c.create_text(col*20+12, row*20+30, \
                            text='%2i' % d, fill='red', tags=('holiday', 'day'))
                    else:
                        self.c.create_text(col*20+12, row*20+30, \
                            text='%2i' % d, fill='black', tags='day')

def GetDay(dd, m, y):
    global HolidayList, HolidayYear
    if y!=HolidayYear:
        HolidayYear=y
        a=y%19
        b=y//100
        c=b//4
        d=(19*a+(15-(13+8*b)//25+b-c)%30)%30
        e=(2*(y%4)+4*(y%7)+6*d+(4+b-c)%7)%7
        mon=4
        if d==29 and e==6:
            day=19
        elif d==28 and e==6 and a>10:
            day=18
        elif d+e<=9:
            day=22+d+e
            mon=3
        else:
            day=d+e-9
        HolidayList=[]
        HolidayList.append(date(y, mon, day)) #Ostersonntag
        HolidayList.insert(0,HolidayList[0]-timedelta(2)) #Karfreitag
        HolidayList.append(HolidayList[1]+timedelta(1)) #Ostermontag
        HolidayList.append(HolidayList[2]+timedelta(38)) #Himmelfahrt
        HolidayList.append(HolidayList[3]+timedelta(10)) #Pfingstsonntag
        HolidayList.append(HolidayList[4]+timedelta(1)) #Pfingstmontag
        HolidayList.append(date(y, 1, 1)) #Neujahr
        HolidayList.append(date(y, 5, 1)) #1. Mai
        HolidayList.append(date(y, 10, 3)) #Tag der deutschen Einheit
        HolidayList.append(date(y, 12, 24)) #Heiligabend
        HolidayList.append(date(y, 12, 25)) #1. Weihnachtsfeiertag
        HolidayList.append(date(y, 12, 26)) #2. Weihnachtsfeiertag
        HolidayList.append(date(y, 12, 31)) #Sylvester
    if date(y, m, dd) in HolidayList:
        return HolidayList.index(date(y, m, dd))+7
    return date(y, m, dd).weekday()

def isHoliday(d, m, y):
    if GetDay(d, m, y)>=6:
        return True
    return False

def GetLenHolidayList():
    GetDay(1, 1, date.today().year)
    return len(HolidayList)

if __name__=='__main__':
    root=Tk()
    root.title('Wählen Sie bitte Tage aus!')
    #sel=DaySelect(root)
    #sel=MonthSelect(root, 11, 2006)
    sel=YearSelect(root, 2006)
    root.mainloop()
    print sel.result

Code: Alles auswählen

import Tkinter as tk

class KalFrame(tk.Frame):

    # Funktionen:
    #
    # _color_set
    # _color_reset
    # _zurueck
    # _vor
    # _markiere
    # istSchaltjahr
    # anz_tage
    # JACOBSTHAL
    # set_monat
    # _auswahl
    # get

    from time import localtime
    def __init__(self,master,fkt1=None,fkt2=None,*cnf,**opts):
        tk.Frame.__init__(self,master,*cnf,**opts)
        # vars:
        self.farben={"bg1":"gray100",
                     "bg2":"gray88",
                     "bg3":"gray100",
                     "bg4":"darkblue",
                     "bg5":"lightblue",
                     "bgactive":"#05044A",
                     "bgbuttons":"gray88",
                     "bglabel":"gray88",
                     "bgweekend":"gray66",
                     "fg1":"gray88",        # Markierung premonth (angeschnitten)
                     "fg2":"black",         # Markierung Hauptmonat
                     "fg3":"gray88",        # Markierung newmonth (angeschnitten)
                     "fg4":"white",         # Markierung Termin/Event im Hauptmonat
                     "fg5":"black",         # Markierung Termin/Event im Nebenmonat
                     "fgactive":"#ffA518",  # Markierung wenn geklickt
                     "fgbuttons":"black",   # Flaechenfarbe: Buttons (vor/zurueck)
                     "fglabel":"black",     # Flaechenfarbe: Label   (anz akt monat)
                     "fgweekend":"white"}   # Markierung von Sa und So
        self.fkt1 = fkt1
        self.fkt2 = fkt2
        self.bulist = []
        self.m = 1      # aktueller monat
        self.j = 2006   # aktuelles jahr
        self.last_choosen_widget = -1
        # start:
        for i in range(6*7):
            obj = tk.Label(self,relief="groove",width=2,height=1,font=("Arial",8,"bold"))
            self.bulist.append( obj )
            obj.grid(column=i%7,row=i/7)
            obj.bind("<1>",self._auswahl)
            obj.marked = False
            obj.var = tk.StringVar()
            obj.configure( textvariable = obj.var )
            
            
        self.li = tk.Button(self, text = "<", relief = "groove",
                            bg = self.farben["bgbuttons"],
                            fg = self.farben["fgbuttons"],
                            command = self._zurueck)
        self.re = tk.Button(self, text = ">", relief = "groove",
                            bg = self.farben["bgbuttons"],
                            fg = self.farben["fgbuttons"],
                            command = self._vor)
        self.mi = tk.Label(self, text="2006/01",relief="groove",
                           bg =  self.farben["bglabel"],
                           fg =  self.farben["fglabel"])
        self.li.grid(column=0,row=7)
        self.re.grid(column=6,row=7)
        self.mi.grid(column=1,row=7,columnspan=5,sticky="nsew")

        self.set_monat(self.localtime()[1],self.localtime()[0])

    def _color_set(self,objlist,farbname,forever=False):
        BG = self.farben["bg"+farbname]
        FG = self.farben["fg"+farbname]
        for w in objlist:
            w.configure(bg = BG, fg = FG)
            if forever: w.last_color = (BG,FG)
    def _color_reset(self,objlist):
        for w in objlist:
            w.configure( bg = w.last_color[0], fg = w.last_color[1] )
            
    def _zurueck(self):
        m, j = self.m-1, self.j
        if m ==  0: m = 12; j -= 1
        self.set_monat(m, j)
    def _vor(self):
        m, j = self.m+1, self.j
        if m == 13: m =  1; j += 1
        self.set_monat(m, j)
    def _markiere(self):
        print "_markiere()"
        if self.fkt1 == None: return
        print " -> ok!"
        li_tage1 = []
        li_tage2 = []
        li_tage3 = []
        j2, m2 = self.j, self.m
        j1, m1 = j2,m2-1
        if m1 == -1: m1=11; j1-=1
        j3, m3 = j2,m2+1
        if m3 == 12: m3= 0; j3+=1
        l1, l2, l3 = self.li_aufteilung1[:], self.li_aufteilung2[:], self.li_aufteilung3[:]

        if len(l1)>1:
            eins, zwei = l1[0], l1[-1]
            for i in range(int(eins.var.get()),int(zwei.var.get())+1):
                li_tage1.append(((j1,m1,i),l1[i-int( eins.var.get() )]) )
        elif len(l1)==1:
            li_tage1.append( ((j1, m1, int(l1[0].var.get())), l1[0]) )

        eins, zwei = l2[0], l2[-1]
        for i in range( int(eins.var.get()), int(zwei.var.get() ) +1):
            li_tage2.append( ((j2, m2, i), l2[i-1]) )

        eins, zwei = l3[0], l3[-1]
        for i in range( int(eins.var.get()), int(zwei.var.get() ) +1):
            li_tage3.append( ((j3, m3, i), l3[i-1]) )

        l1 = self.fkt1( li_tage1 )
        l2 = self.fkt1( li_tage2 )
        l3 = self.fkt1( li_tage3 )
        for liste,farbe in ((l1,"5"), (l2,"4"), (l3,"5")):
            self._color_set(objlist = liste,
                            farbname= farbe,
                            forever = True)
            for obj in liste:
                obj.marked = True
        
    def istSchaltjahr(self,jahr):
        "1=istschaltjahr; 0=keinschaltjahr"
        if (jahr%400==0)or(jahr%4==0 and jahr%100!=0):
            return 1
        else:
            return 0

    def anz_tage(self,monat,jahr):
        "maximalanzahl der tage, die ein m haben kann (ohne schaltjahr!)"
        if monat in (1,3,5,7,8,10,12):
            return 31
        elif monat in (4,6,9,11):
            return 30
        else:
            return 28+self.istSchaltjahr(jahr)

    def JACOBSTHAL(self,a):
        "0=mo,1=di,...,6=so"
        liD = [ i for i in range( self.anz_tage(self.m,self.j) + 1 ) ] # tag 1=1; tag 31=31
        dict_k = {1:6+5*self.istSchaltjahr(self.j),
                  2:2+self.istSchaltjahr(self.j),
                  3:2,
                  4:5,5:0,
                  6:3,7:5,
                  8:1,9:4,
                  10:6,11:2,12:4}
        
        k = dict_k[ self.m ]
        c,j = divmod( self.j, 100 )
        
        d = liD[a] + k + j + j/4 - 2*( c%4 )

        wochentag = (d%7)-1
        if wochentag == -1: wochentag = 6 # So
        return wochentag
        
    def set_monat(self,m,j=-1):
        self.m = m
        if j <> -1: self.j = j

        self.mi.configure(text="%i/%0.2i"%(self.j,self.m))

        startday = self.JACOBSTHAL(1) # der erste tag des aktuellen monats
        endday = startday+self.anz_tage(self.m,self.j)-1
        self.startday, self.endday = startday, endday # "globalisierung" fuer das event
        
        premonth = self.m - 1; j1=self.j
        if premonth ==  0: premonth = 12; j1-=1
        newmonth = self.m + 1; j2=self.j
        if newmonth == 13: newmonth = 1; j2+=1
        
        self.li_aufteilung1 = []
        self.li_aufteilung2 = []
        self.li_aufteilung3 = []
        self.li_aufteilung4 = []
        
        for i, obj in enumerate(self.bulist):
            if i<startday: # alter monat
                lab = (self.anz_tage(premonth,j1)-(startday-1)+i)
                obj.var.set( "%0.2i" % lab)
                self.li_aufteilung1.append(obj)
                
            elif i>endday: # neuer monat
                lab = (i-endday)
                obj.var.set( "%0.2i" % lab)
                self.li_aufteilung3.append(obj)
                
            else: #      aktueller monat
                lab = ( i-(startday-1) )
                obj.var.set( "%0.2i" % lab)
                self.li_aufteilung2.append(obj)
            if i%7 in (5,6): # wochenende
                self.li_aufteilung4.append(obj)
            obj.marked = False
        # farbe:
        self._color_set(self.li_aufteilung2,"2",forever=True)
        self._color_set(self.li_aufteilung4,"weekend",forever=True)
        self._color_set(self.li_aufteilung1,"1",forever=True)
        self._color_set(self.li_aufteilung3,"3",forever=True)
        self._color_set((self.li,self.re),"buttons",forever=False)
        self._color_set((self.mi,),"label",forever=False)
        self.configure(bg=self.farben["bglabel"])
        self._markiere()

    def _auswahl(self, event=None):
        "wenn auf ein tag geklickt worden ist"
        wid = event.widget
        label = wid["text"]
        # neusuche falls falscher monat
        if wid in self.li_aufteilung1:
            self._zurueck()
            for w in self.li_aufteilung2:
                if w["text"]==label:
                    wid = w; break
        elif wid in self.li_aufteilung3:
            self._vor()
            for w in self.li_aufteilung2:
                if w["text"]==label:
                    wid = w; break
        # farbe setzen
        self._color_set((wid,),"active")
        # wurde doppelt geklickt?
        if wid == self.last_choosen_widget:
            return
        # farbe des alten zuruecksetzen
        if self.last_choosen_widget != -1:
            self._color_reset( (self.last_choosen_widget,) )
        # neues zum alten machen und auf neues warten
        self.last_choosen_widget = wid
        # datumstupel zB: (2006,05,21)
        print self.get()
        # externe funktion aufrufen.. die ZWEITE, die, die dann irgendwas macht...
        if self.fkt2:
            if wid.marked: self.fkt2(self.get())
        
    def get(self):
        "gibt aktuellen 'klick' aus zB: (2006,05,21)"
        tu = (self.j,self.m,int(self.last_choosen_widget["text"]))
        return tu



if __name__ == "__main__":

    li = {(2006,06,03):"datum nr. eins",(2006,06,04):"datum nummer zwei",(2006,05,31):"drittes eingetragenes datum..."}
    
    def externfkt1(doppeltupel):
        objekte = []
        global li
        li_keys = li.keys()
        for item,obj in doppeltupel:
            if item in li_keys:
                objekte.append(obj)
        return objekte
    
    def externfkt2(tripel):
        global li
        print li[tripel]

    root = tk.Tk()
    ka = KalFrame(root,fkt1 = externfkt1, fkt2 = externfkt2)
    ka.pack()
    root.mainloop()