Example #1
0
    def test_trenneEvent(self):
        EM.events = []

        event1 = Event(Zeit(11, 30), Zeit(15, 00))
        event2 = Event(Zeit(16, 30), Zeit(22, 00))
        event3 = Event(Zeit(14, 45), Zeit(17, 00))

        lsg1 = Event(Zeit(11, 30), Zeit(14, 30))
        lsg2 = Event(Zeit(14, 30), Zeit(15, 0))
        lsg3 = Event(Zeit(14, 45), Zeit(15, 00))
        EM.addEvent(event1)
        EM.addEvent(event2)
        EM.addEvent(event3)

        EM.trenneEvent(event1, Zeit(14, 30))
        self.assertEqual(str(EM.findeEvent(Zeit(12, 0))), str(lsg1))
        self.assertEqual(str(EM.findeEvent(Zeit(14, 30))), str(lsg2))
        EM.trenneEvent(EM.findeEvent(Zeit(14, 55)),
                       Zeit(14, 45))  #trenne ein getrenntes Event
        self.assertEqual(str(EM.findeEvent(Zeit(14, 55))), str(lsg3))

        EM.events = []
        event1 = Event(Zeit(11, 30), Zeit(15, 00))
        event2 = Event(Zeit(16, 30), Zeit(22, 00))
        event3 = Event(Zeit(14, 45), Zeit(17, 00))
        EM.addEvent(event1)
        EM.addEvent(event2)
        EM.addEvent(event3)

        EM.trenneEvent(event3, Zeit(
            17, 0))  # event3 endet bei 16:30, dh trennung bei 17 tut nichts
        self.assertEqual(str(EM.findeEvent(Zeit(16, 55))), str(event2))
Example #2
0
    def test_findeEvent(self):
        EM.events = []
        event1 = Event(Zeit(14, 30), Zeit(15, 00))
        event2 = Event(Zeit(16, 30), Zeit(17, 00))
        event3 = Event(Zeit(14, 45), Zeit(17, 00))

        EM.addEvent(event1)
        EM.addEvent(event2)
        EM.addEvent(event3)

        lsg1 = EM.findeEvent(Zeit(14, 45))
        lsg2 = EM.findeEvent(Zeit(15, 00))
        lsg3 = EM.findeEvent(Zeit(16, 30))

        self.assertEqual(event1, lsg1)
        self.assertEqual(event3, lsg2)
        self.assertEqual(event2, lsg3)
Example #3
0
 def test_removeElement(self):
     EM.events = []
     event1 = Event(Zeit(11, 30), Zeit(15, 00))
     event2 = Event(Zeit(16, 30), Zeit(22, 00))
     event3 = Event(Zeit(14, 45), Zeit(17, 00))
     EM.addEvent(event1)
     EM.addEvent(event2)
     EM.addEvent(event3)
     EM.removeEvent(event1)
     self.assertIsNone(EM.findeEvent(Zeit(12, 0)))
     self.assertEqual(len(EM.events), 2)
Example #4
0
    def test_verschiebeEventUm(self):
        EM.events = []
        TM.schlafenszeit = Zeit(23, 0)
        EM.mittagspause = Event(Zeit(0, 0), Zeit(0, 0))
        event1 = Event(Zeit(11, 30), Zeit(15, 00))
        event2 = Event(Zeit(16, 30), Zeit(22, 00))
        event3 = Event(Zeit(15, 00), Zeit(16, 30))

        lsg1 = Event(Zeit(17, 30), Zeit(23, 00))
        lsg2 = Event(Zeit(18, 30), Zeit(23, 00))

        lsg3 = Event(Zeit(12, 30), Zeit(16, 00))  #event1 3. Verschiebung
        lsg4 = Event(Zeit(16, 0), Zeit(17, 30))  #event3 3.V
        lsg5 = Event(Zeit(18, 30), Zeit(23, 00))  #event2 3.V
        EM.addEvent(event1)
        EM.addEvent(event2)
        EM.addEvent(event3)
        EM.verschiebeEventUm(event2, Zeit(1, 0))
        self.assertEqual(str(EM.findeEvent(Zeit(18, 00))), str(lsg1))
        self.assertEqual(lsg1, event2)

        EM.verschiebeEventUm(event2,
                             Zeit(1,
                                  0))  #verschiebe in die Schlafenszeit hinein
        self.assertEqual(str(EM.findeEvent(Zeit(19, 00))), str(lsg2))
        self.assertEqual(lsg2, event2)

        EM.verschiebeEventUm(event1,
                             Zeit(1, 0))  #verschiebe mit anhängenden Events

        self.assertEqual(str(EM.findeEvent(Zeit(13, 0))),
                         str(lsg3))  #event1 verschoben
        self.assertEqual(str(event1), str(lsg3))

        self.assertEqual(str(EM.findeEvent(Zeit(17, 0))),
                         str(lsg4))  # event3 verschoben
        self.assertEqual(str(event3), str(lsg4))

        self.assertEqual(str(EM.findeEvent(Zeit(20, 0))),
                         str(lsg5))  # event2 verschoben
        self.assertEqual(event2, lsg5)
Example #5
0
    def test_addPause2(self):
        EM.events = []
        TM.schlafenszeit = Zeit(23, 0)
        EM.mittagspause = Event(Zeit(0, 0), Zeit(0, 0))

        event1 = Event(Zeit(11, 30), Zeit(15, 00))
        event2 = Event(Zeit(16, 30), Zeit(22, 00))

        EM.addEvent(event1)
        EM.addEvent(event2)

        lsg1 = Event(Zeit(11, 30), Zeit(13, 00))
        pause = Event(Zeit(13, 0), Zeit(15, 0))
        lsg2 = Event(Zeit(15, 0), Zeit(17, 00))
        lsg3 = Event(Zeit(17, 00), Zeit(22, 30))
        EM.addPause(Zeit(13, 00), Zeit(2, 0))

        self.assertEqual(str(event1), str(lsg1))
        self.assertEqual(str(EM.findeEvent(Zeit(13, 5))), str(pause))
        self.assertTrue(EM.findeEvent(Zeit(13, 5)).istPause)
        self.assertEqual(str(EM.findeEvent(Zeit(15, 20))), str(lsg2))
        self.assertEqual(str(event2), str(lsg3))
    def callbackRightClick(clickEvent):
        from EventManager import EventManager
        from TimeManager import TimeManager
        from Event import Event

        if ScreenManager.ausgewaehlt is not None:  # auswahl für altes Element aufheben
            ScreenManager.ausgewaehlt.zeichne()
            ScreenManager.ausgewaehlt.unfokusiere()

        pixel = (clickEvent.x, clickEvent.y)
        # x_root ist realtiv zum canvas

        zeit = ScreenManager.pixelZuZeit(pixel[1]).runde(
            TimeManager.genauigkeit)  # ausgewählte Zeit, gerundet
        event = EventManager.findeEvent(zeit)
        if event is not None:
            pause = EventManager.addPause(zeit, EventManager.pausenLaenge)
            pause.zeichne()
            ScreenManager.ausgewaehlt = pause.endzeit
            ScreenManager.ausgewaehlt.zeichneMarkiert()
            ScreenManager.ausgewaehlt.fokusiere()
    def select(zeit, exakt=False):
        from TimeManager import TimeManager
        from EventManager import EventManager
        from Event import Event
        from Zeit import Zeit

        if exakt:
            genauigkeit = Zeit(0, 0, None)
        else:
            genauigkeit = TimeManager.genauigkeit
        gefundeneZeit = TimeManager.findeZeit(zeit, genauigkeit)
        if gefundeneZeit is not None:
            gefundeneZeit.zeichneMarkiert()
            ScreenManager.ausgewaehlt = gefundeneZeit
            ScreenManager.ausgewaehlt.fokusiere()
            return
        event = EventManager.findeEvent(zeit, genauigkeit)
        if event is None:
            zeit = zeit.runde()
            # ändere das Datum des neuen Events auf das Datum von akutellesDatum im TimeManager
            #zeit.datum = TimeManager.aktuellesDatum.datum
            if TimeManager.aufstehzeit <= zeit < TimeManager.schlafenszeit:
                neuesEvent = EventManager.addEvent(
                    Event(zeit, zeit + EventManager.eventLaenge))
                ScreenManager.ausgewaehlt = neuesEvent
            else:
                return
        else:
            if zeit.circa(event.startzeit, genauigkeit):
                ScreenManager.ausgewaehlt = event.startzeit
            elif zeit.circa(event.endzeit, genauigkeit):
                ScreenManager.ausgewaehlt = event.endzeit
            else:
                ScreenManager.ausgewaehlt = event
        ScreenManager.ausgewaehlt.zeichneMarkiert()
        ScreenManager.ausgewaehlt.fokusiere()