Das deutsche Python-Forum

Code: Alles auswählen

#!/usr/bin/env python
# -*- coding: iso-8859-1 -*-
"""
******************************************************************************
* Description:  Zeigt eine Dialogbox an, in der man Von- und Biszeitpunkte
*               auswählen kann. Von- und Biszeitpunkte können auch über
*               die Kommandozeile übergeben werden. Wird nichts übergeben,
*               dann wird der heutige Tag angezeigt.
* Created:      2005-08-11 by http://halvar.at/
******************************************************************************
"""

import pygtk
pygtk.require("2.0")
import gtk
import time
import datetime
import os.path


#----------------------------------------------------------------------
class Datetimeselect2(object):


    #----------------------------------------------------------------------
    def get_cancel(self):
        """
        Gibt zurück, ob die Dialogbox abgebrochen wurde
        """
        return not(self.normal_closed)


    #----------------------------------------------------------------------
    def show_from_datetime(self):
        """
        Zeigt den Von-Zeitpunkt an
        """
        
        s = "%s. %s %s %02.i:%02.i:%02.i" % (
            self.from_datetime.day,
            self.monate[self.from_datetime.month - 1],
            self.from_datetime.year,
            self.from_datetime.hour,
            self.from_datetime.minute,
            self.from_datetime.second
        )
        self.from_label.set_text(s)


    #----------------------------------------------------------------------
    def show_to_datetime(self):
        """
        Zeigt den Bis-Zeitpunkt an
        """

        s = "%s. %s %s %02.i:%02.i:%02.i" % (
            self.to_datetime.day,
            self.monate[self.to_datetime.month - 1],
            self.to_datetime.year,
            self.to_datetime.hour,
            self.to_datetime.minute,
            self.to_datetime.second
        )
        self.to_label.set_text(s)


    #----------------------------------------------------------------------
    def update_from_datetime(self, widget = None, data = None):
        """
        Aktualisiert das from_datetime-Objekt
        """
        
        # Wenn beim Füllen --> Abbruch
        if self.data_filling:
            return

        # Daten übernehmen
        d = self.from_cal.get_date()
        self.from_datetime = datetime.datetime(
            d[0],
            d[1] + 1,
            d[2],
            int(self.from_hour.get_value()),
            int(self.from_minute.get_value()),
            int(self.from_second.get_value())
        )
        
        # Anzeigen
        self.show_from_datetime()


    #----------------------------------------------------------------------
    def update_to_datetime(self, widget = None, data = None):
        """
        Aktualisiert das to_datetime-Objekt
        """

        # Wenn beim Füllen --> Abbruch
        if self.data_filling:
            return

        # Daten übernehmen
        d = self.to_cal.get_date()
        self.to_datetime = datetime.datetime(
            d[0],
            d[1] + 1,
            d[2],
            int(self.to_hour.get_value()),
            int(self.to_minute.get_value()),
            int(self.to_second.get_value())
        )
        
        # Anzeigen
        self.show_to_datetime()


    #----------------------------------------------------------------------
    def ok_event(self, widget, data = None):
        self.normal_closed = True
        gtk.main_quit()


    #----------------------------------------------------------------------
    def cancel_event(self, widget, data = None):
        self.normal_closed = False
        gtk.main_quit()


    #----------------------------------------------------------------------
    def __init__(self, from_datetime = None, to_datetime = None):
        """
        Initialisiert und zeigt das Dialogfenster an
        """
        
        # Variablen vorbereiten
        self.normal_closed = False
        self.data_filling = False
        self.monate = [
            u"Jänner",
            "Februar",
            u"März",
            "April",
            "Mai",
            "Juni",
            "Juli",
            "August",
            "September",
            "Oktober",
            "November",
            "Dezember"
        ]

        # Daten übernehmen
        if from_datetime:
            self.from_datetime = from_datetime
        else:
            loct = time.localtime()
            self.from_datetime = datetime.datetime(
                loct[0], loct[1], loct[2], 0, 0, 0
            )

        if to_datetime:
            self.to_datetime = to_datetime
        else:
            loct = time.localtime()
            self.to_datetime = datetime.datetime(
                loct[0], loct[1], loct[2], 23, 59, 59
            )

        # Fenster
        w = gtk.Window(gtk.WINDOW_TOPLEVEL)
        w.set_title("Von/Bis Auswahl")
        w.set_modal(True)
        w.set_position(gtk.WIN_POS_CENTER)
        w.set_resizable(False)
        w.connect("destroy", gtk.main_quit)

        # Box
        box1 = gtk.VBox(False, False)
        w.add(box1)
        box1.show()

        # Menü - Menüleiste
        menu_bar = gtk.MenuBar()
        box1.pack_start(menu_bar, False, False)
        menu_bar.show()

        # Menü - Datei-Item
        file_item = gtk.MenuItem("_Datei")
        menu_bar.append(file_item)
        file_item.mnemonic_activate(True)
        file_item.show()

        # Menü - Datei-Menü
        file_menu = gtk.Menu()
        file_item.set_submenu(file_menu)

        # Menü - OK
        ok_item = gtk.ImageMenuItem(gtk.STOCK_OK)
        ok_item.connect("activate", self.ok_event)
        file_menu.append(ok_item)
        ok_item.show()

        # Label
        box2 = gtk.HBox(False, 0)
        box1.pack_start(box2, True, True)
        box2.set_border_width(10)
        box2.show()
        labeltext = \
            u"Wählen Sie links den Beginnzeitpunkt und rechts " + \
            u"den Endzeitpunkt aus. Klicken Sie auf die " + \
            u"<i>OK-Schaltfläche</i> um die Eingabe zu bestätigen."
        label = gtk.Label(labeltext)
        label.set_line_wrap(True)
        label.set_use_markup(True)
        box2.pack_start(label, True, False)
        label.show()

        # Box mit den zwei Seiten
        box2 = gtk.HBox(True, 4)
        box1.pack_start(box2, False, False)
        box2.show()

        # Linke Seite
        #------------------------------------
        box3 = gtk.VBox(False, 4)
        box2.pack_start(box3, False, False, 6)
        box3.show()

        # Label
        label = gtk.Label("Von:")
        label.set_alignment(0.02, 0.0)
        box3.pack_start(label, False, False, 0)
        label.show()

        # Calender - Von
        self.from_cal = gtk.Calendar()
        self.from_cal.set_size_request(200, -1)
        self.from_cal.connect("day-selected", self.update_from_datetime)
        box3.pack_start(self.from_cal, False, False, 0)
        self.from_cal.show()

        # Zeit - Von - Box
        box4 = gtk.HBox(True, 4)
        box3.pack_start(box4, False, False, 0)
        box4.show()

        # Zeit - Von - Stunde
        self.from_hour = gtk.SpinButton()
        self.from_hour.connect("value-changed", self.update_from_datetime)
        adj = self.from_hour.get_adjustment()
        self.data_filling = True
        adj.set_all(0, 0, 23, 1, 1, 1)
        self.data_filling = False
        box4.pack_start(self.from_hour, True, True, 0)
        self.from_hour.show()

        # Zeit - Von - Minute
        self.from_minute = gtk.SpinButton()
        self.from_minute.connect("value-changed", self.update_from_datetime)
        adj = self.from_minute.get_adjustment()
        self.data_filling = True
        adj.set_all(0, 0, 59, 1, 1, 1)
        self.data_filling = False
        box4.pack_start(self.from_minute, True, True, 0)
        self.from_minute.show()

        # Zeit - Von - Sekunde
        self.from_second = gtk.SpinButton()
        self.from_second.connect("value-changed", self.update_from_datetime)
        adj = self.from_second.get_adjustment()
        self.data_filling = True
        adj.set_all(0, 0, 59, 1, 1, 1)
        self.data_filling = False
        box4.pack_start(self.from_second, True, True, 0)
        self.from_second.show()

        # Anzeige - Von
        box4 = gtk.HBox(False, 0)
        box3.pack_start(box4, False, False, 4)
        box4.show()
        self.from_label = gtk.Label()
        box4.pack_start(self.from_label, True, True)
        self.from_label.show()

        # Rechte Seite
        #------------------------------------
        box3 = gtk.VBox(False, 4)
        box2.pack_start(box3, False, False, 6)
        box3.show()

        # Label
        label = gtk.Label("Bis:")
        label.set_alignment(0.02, 0.0)
        box3.pack_start(label, False, False, 0)
        label.show()

        # Calender - Bis
        self.to_cal = gtk.Calendar()
        self.to_cal.set_size_request(200, -1)
        self.to_cal.connect("day-selected", self.update_to_datetime)
        box3.pack_start(self.to_cal, False, False, 0)
        self.to_cal.show()

        # Zeit - Bis - Box
        box4 = gtk.HBox(True, 4)
        box3.pack_start(box4, False, False, 0)
        box4.show()

        # Zeit - Bis - Stunde
        self.to_hour = gtk.SpinButton()
        self.to_hour.connect("value-changed", self.update_to_datetime)
        adj = self.to_hour.get_adjustment()
        self.data_filling = True
        adj.set_all(23, 0, 23, 1, 1, 1)
        self.data_filling = False
        box4.pack_start(self.to_hour, True, True, 0)
        self.to_hour.show()

        # Zeit - Bis - Minute
        self.to_minute = gtk.SpinButton()
        self.to_minute.connect("value-changed", self.update_to_datetime)
        adj = self.to_minute.get_adjustment()
        self.data_filling = True
        adj.set_all(59, 0, 59, 1, 1, 1)
        self.data_filling = False
        box4.pack_start(self.to_minute, True, True, 0)
        self.to_minute.show()

        # Zeit - Bis - Sekunde
        self.to_second = gtk.SpinButton()
        self.to_second.connect("value-changed", self.update_to_datetime)
        adj = self.to_second.get_adjustment()
        self.data_filling = True
        adj.set_all(59, 0, 59, 1, 1, 1)
        self.data_filling = False
        box4.pack_start(self.to_second, True, True, 0)
        self.to_second.show()

        # Anzeige - Bis
        box4 = gtk.HBox(False, 0)
        box3.pack_start(box4, False, False, 4)
        box4.show()
        self.to_label = gtk.Label()
        box4.pack_start(self.to_label, True, True)
        self.to_label.show()

        # HSeparator
        #------------------------------------
        box2 = gtk.HBox(False, 0)
        box1.pack_start(box2, False, False, 4)
        box2.show()
        sep = gtk.HSeparator()
        box2.pack_start(sep, True, True)
        sep.show()

        # Abbrechen und OK
        box2 = gtk.HBox(True, 6)
        box1.pack_start(box2, False, False, 6)
        box2.show()
        cancel = gtk.Button(stock = gtk.STOCK_CANCEL)
        cancel.connect("clicked", self.cancel_event)
        box2.pack_start(cancel, True, True, 6)
        cancel.show()
        ok = gtk.Button(stock = gtk.STOCK_OK)
        ok.connect("clicked", self.ok_event)
        box2.pack_start(ok, True, True, 6)
        ok.show()
        ok.set_flags(gtk.CAN_DEFAULT)
        ok.grab_default()
        
        # Datum und Zeit an die Widgets übergeben
        # Flag
        self.data_filling = True
        # From:
        self.from_cal.select_month( 
            self.from_datetime.month - 1, self.from_datetime.year
        )
        self.from_cal.select_day(self.from_datetime.day)
        self.from_hour.set_value(self.from_datetime.hour)
        self.from_minute.set_value(self.from_datetime.minute)
        self.from_second.set_value(self.from_datetime.second)
        # To:
        self.to_cal.select_month(
            self.to_datetime.month - 1, self.to_datetime.year
        )
        self.to_cal.select_day(self.to_datetime.day)
        self.to_hour.set_value(self.to_datetime.hour)
        self.to_minute.set_value(self.to_datetime.minute)
        self.to_second.set_value(self.to_datetime.second)
        # Flag
        self.data_filling = False
        
        # Daten anzeigen
        self.show_from_datetime()
        self.show_to_datetime()
        
        # Fenster anzeigen
        w.show()


#----------------------------------------------------------------------
def parse_options():
    """
    Wertet die Argumente aus und gibt diese zurück
    """

    from optparse import OptionParser
    from sys import exit

    # Usage-Text angeben und Parser-Objekt erzeugen
    usage = \
        "%prog [--from=YYYYMMDD[hhmmss]] [--to=YYYYMMDD[hhmmss]] [-d]\n\n" + \
        "    Zeigt eine Dialogbox an, in der man Von- und Biszeitpunkte\n" + \
        "    auswaehlen kann. Von- und Biszeitpunkte koennen auch ueber\n" + \
        "    die Kommandozeile uebergeben werden. Wird nichts uebergeben,\n" + \
        "    dann wird der heutige Tag angezeigt.\n" + \
        "    By Gerold Penz 2005 -- http://halvar.at/\n\n" + \
        "Beispiel: %prog --from=20050809 --to=20050809"
    parser = OptionParser(usage = usage)

    # Optionen hinzufuegen
    parser.add_option(
        "--from",
        dest = "from_string",
        action = "store",
        metavar = "YYYYMMDDhhmmss",
        default = "",
        help = \
            "YYYYMMDDhhmmss gibt die Schreibweise des Von-Zeitpunkts an"
    )
    parser.add_option(
        "--to",
        dest = "to_string",
        action = "store",
        metavar = "YYYYMMDDhhmmss",
        default = "",
        help = \
            "YYYYMMDDhhmmss gibt die Schreibweise des Bis-Zeitpunkts an"
    )
    parser.add_option(
        "-d", "--debug",
        dest = "debug",
        action = "store_true",
        default = False,
        help = "show debug messages"
    )

    # Optionen parsen
    (options, args) = parser.parse_args()

    # Optionen und Argumente anzeigen
    if options.debug:
        print "Options:"
        print options
        print "-"*70
        print "Arguments:"
        for item in args:
            print item
            print "-"*70

    # Rueckgabe
    return (options, args)


#----------------------------------------------------------------------
if __name__ == "__main__":

    # Optionen und Argumente parsen
    (options, args) = parse_options()

    # Datum parsen
    if options.from_string:
        try:
            from_datetime = datetime.datetime(
                *time.strptime(options.from_string, "%Y%m%d%H%M%S")[:6]
            )
        except:
            from_datetime = datetime.datetime(
                *time.strptime(options.from_string, "%Y%m%d")[:6]
            )
    else:
        loct = time.localtime()
        from_datetime = datetime.datetime(
            loct[0], loct[1], loct[2], 0, 0, 0
        )

    if options.to_string:
        try:
            to_datetime = datetime.datetime(
                *time.strptime(options.to_string, "%Y%m%d%H%M%S")[:6]
            )
        except:
            loct = time.strptime(options.to_string, "%Y%m%d")[:6]
            to_datetime = datetime.datetime(
                loct[0], loct[1], loct[2], 23, 59, 59
            )
    else:
        loct = time.localtime()
        to_datetime = datetime.datetime(
            loct[0], loct[1], loct[2], 23, 59, 59
        )

    # Aufrufen
    diag = Datetimeselect2(from_datetime, to_datetime)
    gtk.main()

    # Zurück geben
    if diag.get_cancel():
        print "cancel"
    else:
        print diag.from_datetime, diag.to_datetime