commit 1d272caebed5e9f6f459ace77410313b45be7080 Author: Daniel Spittank Date: Sat Feb 4 16:58:47 2017 +0100 Erste Version für iOS unter iOS nicht unterstützt sind AudioRecorder, VideoRecorder, SprachEingabe, VibrationsSignal. Der BildRecorder kann nur interaktiv aufnehmen. diff --git a/source/Examples/Sprachtest/Sprachtest.py b/source/Examples/Sprachtest/Sprachtest.py new file mode 100644 index 0000000..bd76e92 --- /dev/null +++ b/source/Examples/Sprachtest/Sprachtest.py @@ -0,0 +1,18 @@ +from velamentum.ui.dialoge.Dialog import * +from velamentum.ui.dialoge.EingabeDialog import * +from velamentum.sprache.Sprachausgabe import * + +dialog = Dialog("Sprachausgabe", "Willkommen zum Sprachtest.") +dialog.zeige() + +eDialog = EingabeDialog("Sprachausgabe", "Bitte geben Sie einen Text ein.") +eDialog.zeige() + +sprachausgabe = Sprachausgabe(eDialog.nenneErgebnis()) +sprachausgabe.sprechen() + +while sprachausgabe.sprichtNoch(): + pass + +dialog.setzeNachricht("Ich habe gesprochen!") +dialog.zeige() diff --git a/source/Examples/SteinScherePapier/SteinScherePapier.py b/source/Examples/SteinScherePapier/SteinScherePapier.py new file mode 100644 index 0000000..c8e6506 --- /dev/null +++ b/source/Examples/SteinScherePapier/SteinScherePapier.py @@ -0,0 +1,50 @@ +# -*- coding: utf-8 -*- +from velamentum.ui.dialoge.Dialog import * +from velamentum.ui.dialoge.EntscheidungsDialog import * +from velamentum.werkzeuge.Zufallsgenerator import * + +# Dialog vorbereiten und Begrüßung anzeigen +dialog = Dialog("Stein, Papier, Schere", "Willkommen zum Spiel!") +dialog.zeige() + +# EntscheidungDialog vorbereiten +eDialog = EntscheidungsDialog("Stein, Papier, Schere", "Bitte wählen Sie" \ + "Ihren Gegenstand.") + +eDialog.setzeText1("🌑 Stein") +eDialog.setzeText2("✂️ Schere") +eDialog.setzeText3("📃 Papier") +eDialog.setzeDreiTasten(True) + +# Entscheidung einfordern +while eDialog.nenneErgebnis() == 0: + eDialog.zeige() + +# Zufallsgenerator vorbereiten +zufall = Zufallsgenerator(1,3) + +# Sieger ermitteln +if zufall.nenneErgebnis() == 1: + dialog.zeigeNachricht("Ich habe 'Stein' gewählt.") + if eDialog.nenneErgebnis() == 1: + dialog.zeigeNachricht("Unentschieden!") + elif eDialog.nenneErgebnis() == 2: + dialog.zeigeNachricht("Ich habe gewonnen!") + else: + dialog.zeigeNachricht("Sie haben gewonnen!") +elif zufall.nenneErgebnis() == 2: + dialog.zeigeNachricht("Ich habe 'Schere' gewählt.") + if eDialog.nenneErgebnis() == 1: + dialog.zeigeNachricht("Sie haben gewonnen!") + elif eDialog.nenneErgebnis() == 2: + dialog.zeigeNachricht("Unentschieden!") + else: + dialog.zeigeNachricht("Ich habe gewonnen!") +else: + dialog.zeigeNachricht("Ich habe 'Papier' gewählt.") + if eDialog.nenneErgebnis() == 1: + dialog.zeigeNachricht("Ich habe gewonnen!") + elif eDialog.nenneErgebnis() == 2: + dialog.zeigeNachricht("Sie haben gewonnen!") + else: + dialog.zeigeNachricht("Unentschieden!") diff --git a/source/Examples/SuS/Schlauheitstest/Schlauheitstest.py b/source/Examples/SuS/Schlauheitstest/Schlauheitstest.py new file mode 100644 index 0000000..30588c7 --- /dev/null +++ b/source/Examples/SuS/Schlauheitstest/Schlauheitstest.py @@ -0,0 +1,80 @@ +from velamentum.alle import* +punkte=0 +d=Dialog("Schlauheits-Test","Teste, wie schlau du bist!") +d.zeige() +ed=EntscheidungsDialog("Laender-Frage","Wie viele Laender gehoeren zu Der EU?") +ed.text1="28" +ed.text2="17" +ed.zweiTasten=True +ed.zeige() +if(ed.ergebnis==1): + d.nachricht="Richtig! Es gehoeren 28 Laender zu der EU."; punkte+=2 +elif(ed.ergebnis==2): + d.nachricht="Leider Falsch!" +d.zeige() +ed=EntscheidungsDialog("Personen-Frage","Wieviele Leute lebten 2012 in Deutschland?") +ed.text1="40000000" +ed.text2="80000000" +ed.text3="81000000" +ed.dreiTasten=True +ed.zeige() +if(ed.ergebnis==1): + d.nachricht="Leider Falsch!" +elif(ed.ergebnis==2): + d.nachricht="Fast Richtig!" +elif(ed.ergebnis==3): + d.nachricht="Richtig! 2012 lebten 81000000 Menschen in Deutschland." +d.zeige() +ed=EntscheidungsDialog("Einwohner-Frage","Welche Stadt hat Die meisten Einwohner?") +ed.text1="Peking" +ed.text2="New York" +ed.text3="Mexico-City" +ed.dreiTasten=True +ed.zeige() +if (ed.ergebnis==1): + d.nachricht="Leider Falsch, Peking hat 15800000 Einwohner Und damit 4.300.000 Einwohner weniger, Als Die Stadt Mit Den meisten Einwohnern." +elif (ed.ergebnis==2): + d.nachricht="Leider Falsch, New York hat 8200000 Einwohner Und damit Ca. 11.800.000 Einwohner weniger, Als Die Stadt Mit Den meisten Einwohnern." +elif (ed.ergebnis==3): + d.nachricht="Richtig, Mexico-City hat 20100000 Einwohner Und Ist damit Die Stadt Mit Den meisten Einwohnern Der Welt."; punkte+=3 +d.zeige() +ed=EntscheidungsDialog("Film-Frage","Welcher Film hat Das meiste geld eingebracht?") +ed.text1="Avatar" +ed.text2="Skyfall" +ed.text3="Iron Man 3" +ed.dreiTasten=True +ed.zeige() +if (ed.ergebnis==1): + d.nachricht="Richtig, Der Film Avatar hat 2800000000 Dollar eingespielt Und Ist damit Auf Platz 1!"; punkte+=3 +elif (ed.ergebnis==2): + d.nachricht="Leider Falsch, Der Film Skyfall hat 1100000000 Dollar eingespielt Und liegt damit auf Platz 9." +elif (ed.ergebnis==3): + d.nachricht="Leider Falsch, Der Film Iron Man 3 hat 1200000000 Dollar eingespielt Und liegt damit Auf Platz 6." +d.zeige() +ed=EntscheidungsDialog("Koerperteil-Frage","Wie viele Knochen hat der menschliche Koerper Im Durchschnitt?") +ed.text1="150" +ed.text2="206" +ed.text4="403" +ed.dreiTasten=True +ed.zeige() +if (ed.ergebnis==1): + d.nachricht="Leider Falsch, er hat mehr, Als Nur 150 Knochen." +elif (ed.ergebnis==2): + d.nachricht="Richtig, allerdings Ist dies Nur Der Durchschnitt. Kleine Kinder Haben beispielsweise Noch mehr Knochen, Als erwachsene Menschen, Weil Die Knochen Mit dem Alter zusammenwachsen!"; punkte+=3 +elif (ed.ergebnis==3): + d.nachricht="Ganz Falsch" +d.zeige() +ed=EntscheidungsDialog("Fertig!","Willst du wissen, Wie viele Punkte Du erreicht hast") +ed.text1="Ja" +ed.text2="Nein" +ed.zweiTasten=True +ed.zeige() +if (ed.ergebnis==1): + d.nachricht="Du hast %d Punkte erreicht!" % (punkte) +elif (ed.ergebnis==2): + d.nachricht="Danke fuers spielen!" +if(ed.ergebnis == 1 and punkte>=8): + d.nachricht="Du hast %d Punkte erreicht Und bist damit schlau!" % (punkte) +elif(ed.ergebnis == 1 and punkte<=8): + d.nachricht="Du hast %d Punkte erreicht Und bist damit dumm!" % (punkte) +d.zeige() diff --git a/source/Examples/Zahlenraten/Zahlenraten.py b/source/Examples/Zahlenraten/Zahlenraten.py new file mode 100644 index 0000000..3723742 --- /dev/null +++ b/source/Examples/Zahlenraten/Zahlenraten.py @@ -0,0 +1,36 @@ +# -*- coding: utf-8 -*- +from velamentum.alle import * + +# Zufallsgenerator vorbereiten +zufall = Zufallsgenerator(1,1000) + +# Dialog vorbereiten und Begrüßung anzeigen +dialog = Dialog("Zahlenraten", "Willkommen zum Spiel!") +dialog.zeige() + +dialog.zeigeNachricht("Ich habe eine Zahl zwischen 1 und 1000 gewählt." \ + "Raten Sie welche es ist!") + +# EingabeDialog vorbereiten +eDialog = EingabeDialog("Zahlenraten", "Bitte geben Sie eine Zahl zwischen 1 " \ + "und 1000 ein:", True) + +# Zähler für die Versuche initialisieren +versuche = 0 + +# Entscheidung einfordern +while eDialog.nenneErgebnis() != zufall.nenneErgebnis(): + # Anzahl der Versuche um eins erhöhen + versuche += 1 + + # EingabeDialog anzeigen + eDialog.zeige() + + # Eingabe überprüfen + if eDialog.nenneErgebnis() > zufall.nenneErgebnis(): + dialog.zeigeNachricht("Ihre Zahl war zu groß!") + elif eDialog.nenneErgebnis() < zufall.nenneErgebnis(): + dialog.zeigeNachricht("Ihre Zahl war zu klein!") + +dialog.zeigeNachricht("Herzlichen Glückwunsch! Sie haben die Zahl nach {0} " \ + "Versuchen erraten.".format(versuche)) diff --git a/source/iOS/__init__.py b/source/iOS/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/source/iOS/alle.py b/source/iOS/alle.py new file mode 100644 index 0000000..5742269 --- /dev/null +++ b/source/iOS/alle.py @@ -0,0 +1,22 @@ +from velamentum.dateien.DateiSystemElement import DateiSystemElement +from velamentum.dateien.Datei import Datei +from velamentum.dateien.Verzeichnis import Verzeichnis +from velamentum.multimedia.Recorder import Recorder +from velamentum.multimedia.AudioRecorder import AudioRecorder +from velamentum.multimedia.BildRecorder import BildRecorder +from velamentum.multimedia.VideoRecorder import VideoRecorder +from velamentum.multimedia.Player import Player +from velamentum.multimedia.AudioPlayer import AudioPlayer +from velamentum.signale.Signal import Signal +from velamentum.signale.AudioSignal import AudioSignal +from velamentum.signale.TextSignal import TextSignal +from velamentum.signale.VibrationsSignal import VibrationsSignal +from velamentum.sprache.Spracheingabe import Spracheingabe +from velamentum.sprache.Sprachausgabe import Sprachausgabe +from velamentum.ui.dialoge.Dialog import Dialog +from velamentum.ui.dialoge.EingabeDialog import EingabeDialog +from velamentum.ui.dialoge.EntscheidungsDialog import EntscheidungsDialog +from velamentum.ui.dialoge.PasswortDialog import PasswortDialog +from velamentum.werkzeuge.System import System +from velamentum.werkzeuge.Zufallsgenerator import Zufallsgenerator +from velamentum.werkzeuge.Zwischenablage import Zwischenablage diff --git a/source/iOS/dateien/Datei.py b/source/iOS/dateien/Datei.py new file mode 100644 index 0000000..f37b02b --- /dev/null +++ b/source/iOS/dateien/Datei.py @@ -0,0 +1,71 @@ +# -*- coding: utf-8 -*- +from velamentum.dateien.DateiSystemElement import DateiSystemElement + +class Datei(DateiSystemElement): + """Die Klasse Datei dient dem Umgang mit Dateien. + + Attribute: + --- von 'DateiSystemElement' geerbte --- + groesse (Zahl): Die Größe der Datei in Byte. + inhalt (Zeichenkette): Der Inhalt der Datei. + """ + + def __init__(self, pPfad, pSofortEinlesen=False): + """Konstruktor. Initialisiert die Datei. + + Parameter: + pPfad (Zeichenkette): Der Pfad der Datei. + [optional] pSofortEinlesen: Gibt an, ob die Datei direkt bei der + Initialisierung eingelesen werden soll. [Standardwert: False] + """ + DateiSystemElement.__init__(self, pPfad) + if(pSofortEinlesen): + self.einlesen() + + def nenneGroesse(self): + """Anfrage. Gibt die Größe der Datei in Byte zurück. + + Parameter: + --- keine --- + + Rückgabe (Zahl): Die Größe der Datei in Byte. + """ + tSize = 0 + if self.istVorhanden(): + try: + tSize = os.path.getsize(self.pfad) + except: + print("Fehler. Auf '%s' kann nicht zugegriffen werden." + % self._pfad) + + def einlesen(self): + """Auftrag. Liest die Datei in das Attribut 'inhalt' ein. + + Parameter: + --- keine --- + """ + if self.istVorhanden(): + try: + tDatei = open(self._pfad, "r") + self.inhalt = tDatei.read() + tDatei.close() + except: + print("Fehler. Einlesen von '%s' nicht möglich." % self._pfad) + else: + self.inhalt = "" + + def speichern(self): + """Auftrag. Schreibt den Wert des Attributs 'inhalt' in die Datei. + + Parameter: + --- keine --- + """ + try: + tDatei = open(self._pfad, "w") + tDatei.write(self.inhalt) + tDatei.close() + except: + print("Fehler. Speichern von '%s' nicht möglich." % self._pfad) + + # Attribute (verdeckte Getter und Setter) + groesse = property(nenneGroesse, doc="Die Größe der Datei in Byte.") diff --git a/source/iOS/dateien/DateiSystemElement.py b/source/iOS/dateien/DateiSystemElement.py new file mode 100644 index 0000000..03ac758 --- /dev/null +++ b/source/iOS/dateien/DateiSystemElement.py @@ -0,0 +1,104 @@ +# -*- coding: utf-8 -*- +# Modul zur Erkennung des MIME-Types des Elements. +import mimetypes, shutil, os.path + +class DateiSystemElement(object): + """Die Klasse DateiSystemElement stellt die Basisklasse für Elemente + im Dateisystem (z.B. Dateien und Verzeichnisse) dar. + + Anmerkungen: + - Eigentlich sollte ein DateiSystemElement seinen eigenen Pfad nicht + kennen. Auch das Umbenennen und weitere Verwaltungsfunktionen gehören + eher zum übergeordneten Dateisystem. Aus praktikabilitätsgründen + wurde allerdings diese Implementierung gewählt. + - Für die Erkennung des MIME-Types wird derzeit lediglich die + Erweiterung des Elements berücksichtigt. + + Attribute: + name (Zeichenkette): Der Name des Elements im Dateisystem. + pfad (Zeichenkette): Der Pfad des Elements im Dateisystem. + typ (Zeichenkette): Gibt den MIME-Type des Elements an. + verzeichnis (Zeichenkette): Der Pfad des übergeordneten Verzeichnisses + der Datei. + """ + + def __init__(self, pPfad): + """Konstruktor. Initialisiert das DateiSystemElement. + + Parameter: + pPfad (Zeichenkette): Der Pfad des DateiSystemElements. + """ + # Slash am Ende entfernen + if pPfad.endswith('/'): + pPfad = pPfad[:-1] + + self._pfad = pPfad + self._erkenneTyp() + + def _erkenneTyp(self): + """Hilfsmethode. Erkennt den Typ des DateiSystemElements und speichert. + diesen im Attribut 'typ'. + """ + if os.path.isfile(self._pfad): + # Erkennung des MIME-Types. Es wird lediglich die Erweiterung + # der Datei geprüft. + self.typ = mimetypes.guess_type(self._pfad, False) + elif os.path.isdir(self._pfad): + self.typ = "inode/directory" + elif os.path.islink(self._pfad): + self.typ = "inode/symlink" + elif os.path.ismount(self._pfad): + self.typ = "inode/mount-point" + else: + self.typ = "application/octet-stream" + + def istVorhanden(self): + """Anfrage. Prüft, ob das Element im Dateisystem bereits existiert. + + Parameter: + --- keine --- + + Rückgabe (Wahrheitswert): True falls das Element im Dateisystem bereits + existiert, sonst False. + """ + return os.path.exists(self._pfad) + + def nennePfad(self): + """Anfrage. Gibt den Pfad des Elements im Dateisystem zurück.""" + return self._pfad + + def nenneVerzeichnis(self): + """Anfrage. Gibt das übergeordnete Verzeichnis des Elements zurück.""" + return os.path.dirname(self._pfad) + + def nenneName(self): + """Anfrage. Gibt den Namen des Elements im Dateisystem zurück.""" + return os.path.basename(self._pfad) + + def nenneTyp(self): + """Anfrage. Gibt den Typ des Elements zurück (als MIME-Type).""" + return self.typ + + def verschieben(pPfad): + """Auftrag. Hängt das Element im Dateisystem um. + + Parameter: + pPfad (Zeichenkette): Gibt den neuen Pfad im Dateisystem an. + """ + # Verschieben, falls Element bereits existiert. + if os.path.exists(pPfad): + try: + shutil.move(self._pfad, pPfad) + self._pfad = pPfad + except: + print("Fehler. Verschieben von '%s' nicht möglich." % self._pfad) + + # Attribute (verdeckte Getter und Setter) + pfad = property(nennePfad, verschieben, doc="Der Pfad des " \ + "DateiSystemElements im Dateisystem.") + name = property(nenneName, doc="Der Name des DateiSystemElements im" \ + "Dateisystem.") + verzeichnis = property(nenneVerzeichnis, doc="Der Pfad des übergeordneten" \ + " Verzeichnisses des DateiSystemElements im Dateisystem.") + + diff --git a/source/iOS/dateien/Verzeichnis.py b/source/iOS/dateien/Verzeichnis.py new file mode 100644 index 0000000..3569b9c --- /dev/null +++ b/source/iOS/dateien/Verzeichnis.py @@ -0,0 +1,29 @@ +# -*- coding: utf-8 -*- +from velamentum.dateien.DateiSystemElement import DateiSystemElement +import os + +class Verzeichnis(DateiSystemElement): + """Die Klasse Verzeichnis dient dem Umgang mit Verzeichnissen. + + Attribute: + --- von 'DateiSystemElement' geerbte --- + """ + + def __init__(self, pPfad): + """Konstruktor. Initialisiert das Verzeichnis. + + Parameter: + pPfad (Zeichenkette): Der Pfad des Verzeichnisses. + """ + DateiSystemElement.__init__(self, pPfad) + + def nenneKinder(self): + """Anfrage. Gibt eine Liste der Kinder des Verzeichnisses zurück.""" + tListe = [] + + try: + tListe = os.listdir(self._pfad) + except: + print("Fehler. Einlesen von '%s' nicht möglich." % self._pfad) + + return tListe diff --git a/source/iOS/dateien/__init__.py b/source/iOS/dateien/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/source/iOS/multimedia/AudioPlayer.py b/source/iOS/multimedia/AudioPlayer.py new file mode 100644 index 0000000..15de0fc --- /dev/null +++ b/source/iOS/multimedia/AudioPlayer.py @@ -0,0 +1,166 @@ +# -*- coding: utf-8 -*- +import time +import random +import velamentum.dateien.Datei +from velamentum.multimedia.Player import Player +import sound + +class AudioPlayer(Player): + """Die Klasse Player dient der Wiedergabe von Multimediadaten aus einer + Datei. + + Attribute: + --- von 'Player' geerbte --- + datei (Datei): Die Datei, deren Inhalt wiedergegeben werden soll. + dauer (Zahl): Gesamtdauer der Datei in Millisekunden. + position (Zahl): Die aktuelle Position der Wiedergabe in Millisekunden. + wiederholen (Wahrheitswert): Gibt an, ob die Wiedergabe am Ende von + vorne beginnen soll. + """ + + def __init__(self, pDatei, pSofortWiedergeben=False): + """Konstruktor. Initialisiert den Player. + + Parameter: + pDatei (Datei): Datei, die wiedergegeben werden soll. + [optional] pSofortWiedergeben (Wahrheitswert): Soll die Datei direkt + nach der Initialisierung wiedergegeben werden? + """ + self.datei = pDatei + # Eindeutige ID festlegen zur Verwaltung verschiedener gleichzeitig + # wiederzugebender Streams. + self._id = "%s%04d" % (pDatei.nenneName(), random.randint(0,8191)) + + if self.datei.istVorhanden(): + self.player = sound.Player(self.datei.nennePfad()) + else: + print("Fehler. Datei %s nicht gefunden." % pDatei.nennePfad()) + + def __del__(self): + """Destruktor. Stellt sicher, dass die Wiedergabe beim Löschen des + Objekts beendet wird. + + Parameter: + --- keine --- + """ + pass + + def nenneDauer(self): + """Anfrage. Gibt die Gesamtdauer der Datei zurück. + + Parameter: + --- keine --- + + Rückgabe (Zahl): Gesamtdauer der Datei in Millisekunden. + """ + return self.player.duration * 1000 + + def nennePosition(self): + """Anfrage. Gibt die aktuelle Position der Wiedergabe zurück. + + Parameter: + --- keine --- + + Rückgabe (Zahl): Aktuelle Position der Wiedergabe in Millisekunden. + """ + return self.player.current_time * 1000 + + def setzePosition(self, pPosition): + """Auftrag. Legt die aktuelle Position der Wiedergabe fest. + + Parameter: + pPosition (Zahl): Neue Position in Millisekunden. + """ + # Position auf gültigen Bereich (0 - dauer) beschränken. + if pPosition > self.dauer: + pPosition = self.dauer + elif pPosition < 0: + pPosition = 0 + + self.player.current_time = pPosition/1000 + + + def nenneDatei(self): + """Anfrage. Gibt die Datei zurück, die wiedergegeben werden soll. + + Parameter: + --- keine --- + + Rückgabe (Datei): Datei, die wiedergegeben werden soll. + """ + return self.datei + + def setzeDatei(self, pDatei): + """Auftrag. Legt die Datei fest, die wiedergegeben werden soll. + + Parameter: + pDatei (Datei): Datei, die wiedergegeben werden soll. + """ + + if pDatei.istVorhanden(): + self.player = sound.Player(pDatei.nennePfad()) + Player.setzeDatei(self, pDatei) + else: + print("Fehler. Datei %s nicht gefunden." % pDatei.nennePfad()) + + def nenneWiederholen(self): + """Anfrage. Gibt zurück, ob die Wiedergabe am Ende wieder von vorne + beginnen soll. + + Parameter: + --- keine --- + + Rückgabe (Wahrheitswert): Soll die Datei wiederholt + wiedergegeben werden? + """ + return True if self.player.number_of_loops == -1 else False + + def setzeWiederholen(self, pWiederholen): + """Auftrag. Legt fest, ob die Wiedergabe am Ende wieder von vorne + beginnen soll. + + Parameter: + pWiederholen (Wahrheitswert): Soll die Datei wiederholt + wiedergegeben werden? + """ + if pWiederholen: + self.player.number_of_loops = -1 + else: + self.player.number_of_loops = 0 + + def wiedergeben(self): + """Auftrag. Startet die Wiedergabe der Multimediadaten. + + Parameter + --- keine --- + """ + self.player.play() + + def pausieren(self): + """Auftrag. Pausiert die Wiedergabe der Multimediadaten. Die Wiedergabe + kann mit 'wiedergeben' fortgesetzt werden. + + Parameter + --- keine --- + """ + self.player.pause() + + def stoppen(self): + """Auftrag. Stoppt die Wiedergabe der Multimediadaten. (Wie 'pausieren', + Wiedergabe kann jedoch nicht fortgesetzt werden, sondern beginnt dann + von vorne. + + Parameter + --- keine --- + """ + self.player.stop() + + # Attribute (verdeckte Getter und Setter) + datei = property(nenneDatei, setzeDatei, doc="Die Datei, deren Inhalt " \ + "wiedergegeben werden soll.") + dauer = property(nenneDauer, doc="Die Gesamtdauer der Datei in Millisekunden.") + position = property(nennePosition, setzePosition, doc = "Die aktuelle "\ + "Position der Wiedergabe.") + wiederholen = property(nenneWiederholen, setzeWiederholen, doc="Gibt an, "\ + "ob die Wiedergabe am Ende wieder von vorne beginnen soll.") + diff --git a/source/iOS/multimedia/AudioRecorder.py b/source/iOS/multimedia/AudioRecorder.py new file mode 100644 index 0000000..7bff545 --- /dev/null +++ b/source/iOS/multimedia/AudioRecorder.py @@ -0,0 +1,21 @@ +# -*- coding: utf-8 -*- +import velamentum.dateien.Datei +from velamentum.multimedia.Recorder import Recorder +import dialogs + +class AudioRecorder(Recorder): + """Die Klasse AudioRecorder dient der Aufnahme von Audiodaten in eine Datei. + + Attribute: + --- von 'Recorder' geerbte --- + """ + + def __init__(self, pDatei=velamentum.dateien.Datei.Datei("~/aufnahme.m4a")): + """Konstruktor. Initialisiert den AudioRecorder. + + Parameter: + [optional] pDatei (Datei): Datei, in der die Aufnahme gespeichert + werden soll [Standardwert: Datei mit Pfad '~/aufnahme.m4a']. + """ + Recorder.__init__(self, pDatei) + dialogs.alert('Fehler', 'AudioRecorder auf iOS nicht implementiert.') diff --git a/source/iOS/multimedia/BildRecorder.py b/source/iOS/multimedia/BildRecorder.py new file mode 100644 index 0000000..d38b2b7 --- /dev/null +++ b/source/iOS/multimedia/BildRecorder.py @@ -0,0 +1,52 @@ +# -*- coding: utf-8 -*- +import velamentum.dateien.Datei +from velamentum.multimedia.Recorder import Recorder +import photos + +class BildRecorder(Recorder): + """Die Klasse BildRecorder dient der Aufnahme von Bilddaten in eine Datei. + + Attribute: + --- von 'Recorder' geerbte --- + """ + + def __init__(self, pDatei=velamentum.dateien.Datei.Datei("/sdcard/aufnahme.jpg")): + """Konstruktor. Initialisiert den BildRecorder. + + Parameter: + [optional] pDatei (Datei): Datei, in der die Aufnahme gespeichert + werden soll [Standardwert: Datei mit Pfad '/scard/aufnahme.jpg']. + """ + Recorder.__init__(self, pDatei) + + def aufnehmen(self): + """Auftrag. Macht ein Foto und speichert es in der angegebenen Datei. + + HINWEIS: Die angegebene Datei wird überschrieben. + + Parameter + --- keine --- + """ + self.aufnehmenInteraktiv() + + def stoppen(self): + """Auftrag. Dummy. Für Fotos nutzlos. + + Parameter + --- keine --- + """ + pass + + def aufnehmenInteraktiv(self): + """Auftrag. Startet eine interaktive Aufnahme. Der Benutzer erhält die + Möglichkeit die Aufnahme interaktiv zu starten und zu stoppen. Dazu wird + auf die Standard-Kamera-App zurückgegriffen. + + HINWEIS: Die angegebene Datei wird überschrieben. + + Parameter: + --- keine --- + """ + imgTmp = photos.capture_image() + imgTmp.save(self.datei.nennePfad(), quality=90) + diff --git a/source/iOS/multimedia/Player.py b/source/iOS/multimedia/Player.py new file mode 100644 index 0000000..305b368 --- /dev/null +++ b/source/iOS/multimedia/Player.py @@ -0,0 +1,132 @@ +# -*- coding: utf-8 -*- +import time +import velamentum.dateien.Datei + +class Player(object): + """Die Klasse Player dient der Wiedergabe von Multimediadaten aus einer + Datei. + + Attribute: + datei (Datei): Die Datei, deren Inhalt wiedergegeben werden soll. + dauer (Zahl): Gesamtdauer der Datei in Millisekunden. + position (Zahl): Die aktuelle Position der Wiedergabe in Millisekunden. + wiederholen (Wahrheitswert): Gibt an, ob die Wiedergabe am Ende von + vorne beginnen soll. + """ + + def __init__(self, pDatei): + """Konstruktor. Initialisiert den Player. + + Parameter: + pDatei (Datei): Datei, die wiedergegeben werden soll. + """ + self.datei = pDatei + # Eindeutige ID festlegen zur Verwaltung verschiedener gleichzeitig + # wiederzugebender Streams. + self._id = "%s%04d" % (pDatei.nenneName(), randint(0,4095)) + + def nenneDatei(self): + """Anfrage. Gibt die Datei zurück, die wiedergegeben werden soll. + + Parameter: + --- keine --- + + Rückgabe (Datei): Datei, die wiedergegeben werden soll. + """ + return self.datei + + def setzeDatei(self): + """Anfrage. Gibt die Datei zurück, die wiedergegeben werden soll. + + Parameter: + --- keine --- + + Rückgabe (Datei): Datei, die wiedergegeben werden soll. + """ + return self.datei + + def nenneWiederholen(self): + """Anfrage. Gibt zurück, ob die Wiedergabe am Ende wieder von vorne + beginnen soll. + + Parameter: + --- keine --- + + Rückgabe (Wahrheitswert): Soll die Datei wiederholt + wiedergegeben werden? + """ + return False + + def setzeWiederholen(self, pWiederholen): + """Auftrag. Legt fest, ob die Wiedergabe am Ende wieder von vorne + beginnen soll. + + Parameter: + pWiederholen (Wahrheitswert): Soll die Datei wiederholt + wiedergegeben werden? + """ + pass + + def nenneDauer(self): + """Anfrage. Gibt die Gesamtdauer der Datei zurück. + + Parameter: + --- keine --- + + Rückgabe (Zahl): Gesamtdauer der Datei in Millisekunden. + """ + return 0 + + def nennePosition(self): + """Anfrage. Gibt die aktuelle Position der Wiedergabe zurück. + + Parameter: + --- keine --- + + Rückgabe (Zahl): Gesamtdauer der Datei in Millisekunden. + """ + return 0 + + def setzePosition(self, pPosition): + """Auftrag. Legt die aktuelle Position der Wiedergabe fest. + + Parameter: + pPosition (Zahl): Neue Position in Millisekunden. + """ + pass + + def wiedergeben(self): + """Auftrag. Startet die Wiedergabe der Multimediadaten. + + Parameter + --- keine --- + """ + pass + + def pausieren(self): + """Auftrag. Pausiert die Wiedergabe der Multimediadaten. Die Wiedergabe + kann mit 'wiedergeben' fortgesetzt werden. + + Parameter + --- keine --- + """ + pass + + def stoppen(self): + """Auftrag. Stoppt die Wiedergabe der Multimediadaten. + + Parameter + --- keine --- + """ + pass + + # Attribute (verdeckte Getter und Setter) + datei = property(nenneDatei, setzeDatei, doc="Die Datei, deren Inhalt " \ + "wiedergegeben werden soll.") + dauer = property(nenneDauer, doc="Die Gesamtdauer der Datei in Millisekunden.") + position = property(nennePosition, setzePosition, doc = "Die aktuelle "\ + "Position der Wiedergabe.") + wiederholen = property(nenneWiederholen, setzeWiederholen, doc="Gibt an, "\ + "ob die Wiedergabe am Ende wieder von vorne beginnen soll.") + + diff --git a/source/iOS/multimedia/Recorder.py b/source/iOS/multimedia/Recorder.py new file mode 100644 index 0000000..4774d92 --- /dev/null +++ b/source/iOS/multimedia/Recorder.py @@ -0,0 +1,95 @@ +# -*- coding: utf-8 -*- +import time +import velamentum.dateien.Datei + +class Recorder(object): + """Die Klasse Recorder dient der Aufnahme von Multimediadaten in eine Datei. + + Attribute: + aufnahmeLaeuft (Wahrheitswert): Gibt an, ob gerade eine Aufnahme läuft. + datei (Datei): Die Datei, in der die Aufnahme gespeichert werden soll. + """ + + def __init__(self, pDatei=velamentum.dateien.Datei.Datei("~/aufnahme")): + """Konstruktor. Initialisiert den Recorder. + + Parameter: + [optional] datei (Datei): Datei, in der die Aufnahme gespeichert + werden soll [Standardwert: Datei mit Pfad '/scard/aufnahme']. + """ + self.aufnahmeLaeuft = False + self.datei = pDatei + + def nimmtAuf(self): + """Anfrage. Gibt an, ob gerade eine Aufgabe läuft. + + Parameter: + --- keine --- + + Rückgabe (Wahrheitswert): True falls eine Aufnahme läuft, False sonst. + """ + return self.aufnahmeLaeuft + + def nenneDatei(self): + """Anfrage. Gibt die Datei zurück, in der die Aufnahme gespeichert + werden soll. + + Parameter + --- keine --- + + Rückgabe (Datei): Datei, in der die Aufnahme gespeichert werden soll. + """ + return self.datei + + def setzeDatei(self, pDatei): + """Auftrag. Legt die Datei fest, in der die Aufnahme gespeichert + werden soll. + + Parameter + pDatei (Datei): Datei, in der die Aufnahme gespeichert werden soll. + """ + self.datei = pDatei + + def aufnehmen(self): + """Auftrag. Startet die Aufnahme der Multimediadaten. + + HINWEIS: Die angegebene Datei wird überschrieben. + + Parameter + --- keine --- + """ + self.aufnahmeLaeuft = True + + def stoppen(self): + """Auftrag. Stoppt die Aufnahme der Multimediadaten. + + Parameter + --- keine --- + """ + self.aufnahmeLaeuft = False + + def aufnehmenAuto(self, pDauer): + """Auftrag. Startet eine Aufnahme mit der in 'pDauer' angegebenen Dauer + und beendet die Aufnahme danach automatisch. + + HINWEIS: Die angegebene Datei wird überschrieben. + + Parameter + pDauer (Zahl): Dauer der Aufnahme. + """ + self.aufnehmen() + time.sleep(pDauer) + self.stoppen() + + def aufnehmenInteraktiv(self): + """Auftrag. Startet eine interaktive Aufnahme. Der Benutzer erhält die + Möglichkeit die Aufnahme interaktiv zu starten und zu stoppen. Dazu wird + in der Regel auf die jeweilige Recorder-Applikation zurückgegriffen. + + HINWEIS: Die angegebene Datei wird überschrieben. + + Parameter: + --- keine --- + """ + pass + diff --git a/source/iOS/multimedia/VideoRecorder.py b/source/iOS/multimedia/VideoRecorder.py new file mode 100644 index 0000000..d438748 --- /dev/null +++ b/source/iOS/multimedia/VideoRecorder.py @@ -0,0 +1,21 @@ +# -*- coding: utf-8 -*- +import velamentum.dateien.Datei +from velamentum.multimedia.Recorder import Recorder +import dialogs + +class VideoRecorder(Recorder): + """Die Klasse VideoRecorder dient der Aufnahme von Videodaten in eine Datei. + + Attribute: + --- von 'Recorder' geerbte --- + """ + + def __init__(self, pDatei=velamentum.dateien.Datei.Datei("~/aufnahme.mp4")): + """Konstruktor. Initialisiert den VideoRecorder. + + Parameter: + [optional] pDatei (Datei): Datei, in der die Aufnahme gespeichert + werden soll [Standardwert: Datei mit Pfad '/scard/aufnahme.m4a']. + """ + Recorder.__init__(self, pDatei) + dialogs.alert('Fehler', 'VideoRecorder auf iOS nicht implementiert.') diff --git a/source/iOS/multimedia/__init__.py b/source/iOS/multimedia/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/source/iOS/sensoren/__init__.py b/source/iOS/sensoren/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/source/iOS/signale/AudioSignal.mp3 b/source/iOS/signale/AudioSignal.mp3 new file mode 100644 index 0000000..f18ee79 Binary files /dev/null and b/source/iOS/signale/AudioSignal.mp3 differ diff --git a/source/iOS/signale/AudioSignal.py b/source/iOS/signale/AudioSignal.py new file mode 100644 index 0000000..c33354b --- /dev/null +++ b/source/iOS/signale/AudioSignal.py @@ -0,0 +1,60 @@ +# -*- coding: utf-8 -*- +from velamentum.signale.Signal import Signal +from velamentum.multimedia.AudioPlayer import AudioPlayer +from velamentum.dateien.Datei import Datei +import os.path + +class AudioSignal(Signal): + """Die Klasse AudioSignal dient der Übermittlung von Audiosignalen + an den Benutzer. + + Attribute: + datei (Datei): Audiodatei, die für das Signal verwendet werden soll. + """ + + def __init__(self, pDatei=None): + """Konstruktor. Initialisiert das AudioSignal. + + Parameter: + [optional] pDatei (Zeichenkette): Audiodatei, die für das Signal + verwendet werden soll. [Standardwert: None] + """ + Signal.__init__(self) + self.setzeDatei(pDatei) + self.__audioPlayer = AudioPlayer(self.nenneDatei()) + + def nenneDatei(self): + """Anfrage. Gibt die Audiodatei des Signals zurück. + + Parameter: + --- keine --- + + Rückgabe (Zeichenkette): Audiodatei des Signals. + """ + return self.__datei + + def setzeDatei(self, pDatei): + """Auftrag. Ändert die Audiodatei des Signals. + + Parameter: + pDatei (Zeichenkette): Audiodatei des Signals. + """ + # Falls keine Datei angegeben wurde, verwende Standarddatei aus dem + # Modulpfad. + if pDatei==None: + tDatei = os.path.join(os.path.dirname(__file__),"AudioSignal.mp3") + pDatei = Datei(tDatei) + + self.__datei = pDatei + + def signalisiere(self): + """Auftrag. Übermittelt das Signal an den Benutzer. + + Parameter + --- keine --- + """ + self.__audioPlayer.wiedergeben() + + # Attribute (verdeckte Getter und Setter) + datei = property(nenneDatei, setzeDatei, doc="Die Audiodatei, die für das "\ + "Signal verwendet werden soll.") diff --git a/source/iOS/signale/Signal.py b/source/iOS/signale/Signal.py new file mode 100644 index 0000000..d9e9efa --- /dev/null +++ b/source/iOS/signale/Signal.py @@ -0,0 +1,21 @@ +# -*- coding: utf-8 -*- + +class Signal(object): + """Die Klasse Signal dient der Übermittlung von Signalen an den Benutzer.""" + + def __init__(self): + """Konstruktor. Initialisiert das Signal. + + Parameter: + --- keine --- + """ + pass + + def signalisiere(self): + """Auftrag. Übermittelt das Signal an den Benutzer. + + Parameter + --- keine --- + """ + pass + diff --git a/source/iOS/signale/TextSignal.py b/source/iOS/signale/TextSignal.py new file mode 100644 index 0000000..2756cbc --- /dev/null +++ b/source/iOS/signale/TextSignal.py @@ -0,0 +1,46 @@ +# -*- coding: utf-8 -*- +from velamentum.signale.Signal import Signal +import dialogs + +class TextSignal(Signal): + """Die Klasse TextSignal dient der Übermittlung von Textsignalen + an den Benutzer. + + Attribute: + text (Zeichenkette): Text des Signals. + """ + + def __init__(self, pText="TextSignal"): + """Konstruktor. Initialisiert das Signal. + + Parameter: + [optional] pText (Zeichenkette): Text des Signals. + """ + Signal.__init__(self) + self.text = pText + + def nenneText(self): + """Anfrage. Gibt den Text des Signals zurück. + + Parameter: + --- keine --- + + Rückgabe (Zeichenkette): Text des Signals. + """ + return self.text + + def setzeText(self, pText): + """Auftrag. Ändert den Text des Signals. + + Parameter: + pText (Zeichenkette): Text des Signals. + """ + self.text = pText + + def signalisiere(self): + """Auftrag. Übermittelt das Signal an den Benutzer. + + Parameter + --- keine --- + """ + dialogs.hud_alert(self.text) diff --git a/source/iOS/signale/VibrationsSignal.py b/source/iOS/signale/VibrationsSignal.py new file mode 100644 index 0000000..fead766 --- /dev/null +++ b/source/iOS/signale/VibrationsSignal.py @@ -0,0 +1,46 @@ +# -*- coding: utf-8 -*- +from velamentum.signale.Signal import Signal +import dialogs + +class VibrationsSignal(Signal): + """Die Klasse Signal dient der Übermittlung von Vibrationssignalen + an den Benutzer. + + Attribute + dauer (Zahl): Dauer der Vibration in Millisekunden.""" + + def __init__(self, pDauer=300): + """Konstruktor. Initialisiert das Vibrationssignal. + + Parameter: + [optional] pDauer (Zahl): Dauer der Vibration in Millisekunden. + [Standardwert: 300] + """ + Signal.__init__(self) + self.dauer = pDauer + + def nenneDauer(self): + """Anfrage. Gibt die Dauer der Vibration zurück. + + Parameter: + --- keine --- + + Rückgabe (Zahl): Dauer der Vibration in Millisekunden. + """ + return self.dauer + + def setzeDauer(self, pDauer): + """Auftrag. Ändert die Dauer der Vibration. + + Parameter: + pDauer: Dauer der Vibration in Millisekunden. + """ + self.dauer = pDauer + + def signalisiere(self): + """Auftrag. Übermittelt das Signal an den Benutzer. + + Parameter: + --- keine --- + """ + dialogs.alert('Fehler', 'Für iOS nicht implementiert.') diff --git a/source/iOS/signale/__init__.py b/source/iOS/signale/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/source/iOS/sprache/Sprachausgabe.py b/source/iOS/sprache/Sprachausgabe.py new file mode 100644 index 0000000..0d3a935 --- /dev/null +++ b/source/iOS/sprache/Sprachausgabe.py @@ -0,0 +1,55 @@ +# -*- coding: utf-8 -*- +import speech + +class Sprachausgabe(object): + """Die Klasse Sprachausgabe ermöglicht die Umwandlung von Text in Sprache. + Dieser wird dann als gesprochene Sprache über die Lautsprecher ausgegeben. + + Attribute: + text (Zeichenkette): Der umzuwandelnde Text.""" + + def __init__(self, pText="Text"): + """Auftrag. Initialisiert die Sprachausgabe. + + Parameter: + [optional] pText (Zeichenkette): Der umzuwandelnde Text. + """ + self.text = pText + + def setzeText(self, pText): + """Auftrag. Ändert den umzuwandelnden Text. + + Parameter: + pText (Zeichenkette): + """ + self.text = pText + + def nenneText(self): + """Anfrage. Gibt den umzuwandelnden Text zurück. + + Parameter: + --- keine --- + + Rückgabe (Zeichenkette): Der umzuwandelnde Text. + """ + return self.text + + def sprichtNoch(self): + """Anfrage. Überprüft, ob noch eine Sprachausgabe läuft. + + Parameter: + --- keine --- + + Rückgabe (Wahrheitswert): Liefert True, wenn die Sprachausgabe noch + läuft, sonst False. + """ + return speech.is_speaking() + + def sprechen(self): + """Auftrag. Wandelt den Text in Sprache um und gibt ihn über die + Lautsprecher aus. + + Parameter: + --- keine --- + """ + speech.say(self.text) diff --git a/source/iOS/sprache/Spracheingabe.py b/source/iOS/sprache/Spracheingabe.py new file mode 100644 index 0000000..7249f41 --- /dev/null +++ b/source/iOS/sprache/Spracheingabe.py @@ -0,0 +1,37 @@ +# -*- coding: utf-8 -*- + +class Spracheingabe(object): + """Die Klasse Spracheingabe ermöglicht die Umwandlung von Sprache in Text. + Gesprochener Text wird aufgenommen und mittels einer Spracherkennung in + Text umgewandelt. + + Attribute: + text (Zeichenkette): Der erkannte Text.""" + + def __init__(self): + """Konstruktor: Initialisiert die Spracheingabe. + + Parameter: + --- keine --- + """ + self.text = "" + + def nenneText(self): + """Anfrage. Gibt den erkannten Text zurück. + + Parameter: + --- keine --- + + Rückgabe (Zeichenkette): Der erkannte Text. + """ + return self.text + + def erkenneSprache(self): + """Auftrag. Der gesprochene Text wird erkannt und im Attribut 'text' + gespeichert. + + Parameter: + --- keine --- + """ + self.text = "In iOS nicht verfügbar" + diff --git a/source/iOS/sprache/__init__.py b/source/iOS/sprache/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/source/iOS/ui/__init__.py b/source/iOS/ui/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/source/iOS/ui/dialoge/Dialog.py b/source/iOS/ui/dialoge/Dialog.py new file mode 100644 index 0000000..a378602 --- /dev/null +++ b/source/iOS/ui/dialoge/Dialog.py @@ -0,0 +1,76 @@ +# -*- coding: utf-8 -*- +import dialogs + +class Dialog(object): + """Die Klasse Dialog stellt einen einfachen Dialog zur Verfuegung, der eine + Nachricht anzeigen kann und nach Bestätigung durch den Benutzer wieder + verschwindet. + + Attribute: + titel (Zeichenkette): Der Titel des Dialogs. + nachricht (Zeichenkette): Die Nachricht des Dialogs. + """ + + def __init__(self, pTitel="Titel", pNachricht="Nachricht"): + """Auftrag. Initialisiert den Dialog. + + Parameter: + [optional] pTitel (Zeichenkette): Der Titel des Dialogs. + [optional] pNachricht (Zeichenkette): Die Nachricht des Dialogs. + """ + self.titel = pTitel + self.nachricht = pNachricht + + def setzeNachricht(self, pNachricht): + """Auftrag. Ändert die Nachricht des Dialogs. + + Parameter: + pNachricht (Zeichenkette): Die Nachricht des Dialogs. + """ + self.nachricht = pNachricht + + def setzeTitel(self, pTitel): + """Auftrag. Ändert den Titel des Dialogs. + + Parameter: + pTitel (Zeichenkette): Der Titel des Dialogs. + """ + self.titel = pTitel + + def nenneNachricht(self): + """Anfrage. Gibt die Nachricht des Dialogs zurück. + + Parameter: + --- keine --- + + Rückgabe (Zeichenkette): Die Nachricht des Dialogs. + """ + return self.titel + + def nenneTitel(self): + """Anfrage. Gibt den Titel des Dialogs zurück. + + Parameter: + --- keine --- + + Rückgabe (Zeichenkette): Der Titel des Dialogs. + """ + return self.titel + + def zeigeNachricht(self,pNachricht): + """Auftrag. Kurzform für das Anzeigen eines Dialogs. Setzt die neue + Nachricht und zeigt den Dialog sofort an. + + Parameter: + pNachricht (Zeichenkette): Die Nachricht des Dialogs. + """ + self.nachricht = pNachricht + self.zeige() + + def zeige(self): + """Auftrag. Zeigt den Dialog an. + + Parameter: + --- keine --- + """ + dialogs.alert(self.titel, self.nachricht, 'Ok', '', '', True) diff --git a/source/iOS/ui/dialoge/EingabeDialog.py b/source/iOS/ui/dialoge/EingabeDialog.py new file mode 100644 index 0000000..d487e56 --- /dev/null +++ b/source/iOS/ui/dialoge/EingabeDialog.py @@ -0,0 +1,98 @@ +# -*- coding: utf-8 -*- +from velamentum.ui.dialoge.Dialog import Dialog +import dialogs + +class EingabeDialog(Dialog): + """Die Klasse EingabeDialog (erbt Attribute und Methoden von der Klasse + Dialog) stellt einen einfachen Dialog zur Eingabe von Zeichenketten zur + Verfügung. + + Attribute: + titel (Zeichenkette): Der Titel des Dialogs. + nachricht (Zeichenkette): Die Nachricht des Dialogs. + ergebnis (Zeichenkette): Der eingegebene Text. + nurZahlen (Wahrheitswert): Nur Zahlen als Eingabe erlauben. + wertAnzeigen (Wahrheitswert): Den aktuellen Wert im Eingabefeld + anzeigen. + """ + + def __init__(self, pTitel="EingabeDialog", pNachricht="Nachricht", pNurZahlen=False, + pWertAnzeigen=False): + """Konstruktor. Initialisiert den EingabeDialog. + + Parameter: + [optional] pTitel (Zeichenkette): Der Titel des Dialogs. + [optional] pNachricht (Zeichenkette): Die Nachricht des Dialogs. + [optional] pNurZahlen (Wahrheitswert): Nur Zahlen als Eingabe + erlauben (Standardwert: False). + [optional] pWertAnzeigen (Wahrheitswert): Den aktuellen Wert im + Eingabefeld anzeigen (Standardwert: False). + """ + Dialog.__init__(self, pTitel, pNachricht) + self.__ergebnis = '' + self.nurZahlen = pNurZahlen + self.wertAnzeigen = pWertAnzeigen + + def nenneErgebnis(self): + """Anfrage. Gibt die eingegebene Zeichenkette zurück. + + Parameter: + --- keine --- + + Rückgabe (Zeichenkette): Die eingegebene Zeichenkette. + """ + if self.__ergebnis == '' and self.nurZahlen: + self.__ergebnis = 0 + return int(self.__ergebnis) if self.nurZahlen else self.__ergebnis + + def nenneNurZahlen(self): + """Anfrage. Gibt zurück, ob nur Zahlen als Eingabe zugelassen sind. + + Parameter: + --- keine --- + + Rückgabe (Wahrheitswert): Sollen nur Zahlen als Eingabe zugelassen sein? + """ + return self.nurZahlen + + def nenneWertAnzeigen(self): + """Anfrage. Gibt zurück, ob der aktuelle Wert im Eingabefeld angezeigt + werden soll. + + Parameter: + --- keine --- + + Rückgabe (Wahrheitswert): Soll der aktuelle Wert bei der Eingabe + angezeigt werden? + """ + return self.wertAnzeigen + + def setzeNurZahlen(self, pNurZahlen): + """Auftrag. Legt fest, ob nur Zahlen als Eingabe zugelassen sind. + + Parameter: + pNurZahlen (Wahrheitswert): Sollen nur Zahlen als Eingabe zugelassen + sein? + """ + self.nurZahlen = pNurZahlen + + def setzeWertAnzeigen(self, pWertAnzeigen): + """Auftrag. Legt fest, ob der aktuelle Wert bei der Eingabe angezeigt + werden soll. + + Parameter: + pWertAnzeigen (Wahrheitswert): Soll der aktuelle Wert bei der + Eingabe angezeigt werden? + """ + self.nurZahlen = pWertAnzeigen + + def zeige(self): + """Auftrag. Zeigt den EingabeDialog an und speichert die eingegebene + Zeichenkette im Attribut 'ergebnis'. + + Parameter: + --- keine --- + """ + self.__ergebnis = dialogs.input_alert(self.titel, self.nachricht, self.__ergebnis if self.wertAnzeigen else '', 'Ok', True) + + ergebnis = property(nenneErgebnis, doc="Die Eingabe des Benutzers.") diff --git a/source/iOS/ui/dialoge/EntscheidungsDialog.py b/source/iOS/ui/dialoge/EntscheidungsDialog.py new file mode 100644 index 0000000..ba05c5c --- /dev/null +++ b/source/iOS/ui/dialoge/EntscheidungsDialog.py @@ -0,0 +1,131 @@ +# -*- coding: utf-8 -*- +from velamentum.ui.dialoge.Dialog import Dialog +import dialogs + +class EntscheidungsDialog(Dialog): + """Die Klasse Dialog stellt einen einfachen Dialog mit zwei oder drei + Tasten als Antwortmöglichkeiten zur Verfuegung. Der Text der Tasten ist + frei wählbar. + + Attribute: + titel (Zeichenkette): Der Titel des Dialogs. + nachricht (Zeichenkette): Die Nachricht des Dialogs. + ergebnis (Zahl): Die Nummer der ausgewählten Taste (1-3), 0 bei Abbruch + oder Fehler. + text1 (Zeichenkette): Der Text der ersten Taste. + text2 (Zeichenkette): Der Text der zweiten Taste. + text3 (Zeichenkette): Der Text der dritten Taste. + dreiTasten (Wahrheitswert): Anzahl der anzuzeigenden Tasten. True für + drei Tasten, False für zwei Tasten. + """ + + def __init__(self, pTitel="Titel", pNachricht="Nachricht"): + """Konstruktor. Initialisiert den EntscheidungsDialog. + + Parameter: + [optional] pTitel (Zeichenkette): Der Titel des Dialogs. + [optional] pNachricht (Zeichenkette): Die Nachricht des Dialogs. + """ + Dialog.__init__(self, pTitel, pNachricht) + self.ergebnis = 0 + self.text1 = "Ja" + self.text2 = "Nein" + self.text3 = "Vielleicht" + self.dreiTasten = False + + def setzeText1(self, pText): + """Auftrag. Ändert den Text der ersten Taste. + + Parameter: + pText (Zeichenkette): Text der Taste. + """ + self.text1 = pText + + def setzeText2(self, pText): + """Auftrag. Ändert den Text der zweiten Taste. + + Parameter: + pText (Zeichenkette): Text der Taste. + """ + self.text2 = pText + + def setzeText3(self, pText): + """Auftrag. Ändert den Text der dritten Taste. + + Parameter: + pText (Zeichenkette): Text der Taste. + """ + self.text3 = pText + + def setzeDreiTasten(self, pDreiTasten): + """Auftrag. Legt fest, ob zwei oder drei Tasten angezeigt werden sollen. + + Parameter: + dreiTasten (Wahrheitswert): Anzahl der anzuzeigenden Tasten. + True für drei Tasten, False für zwei Tasten. + """ + self.dreiTasten = pDreiTasten + + def nenneErgebnis(self): + """Anfrage. Gibt die Nummer der gewählten Taste (1-3) oder 0 bei einem + Abbruch oder Fehler aus. + + Parameter: + --- keine --- + + Rückgabe (Zahl): Fehler oder Abbruch durch den Benutzer => 0, + Taste gedrückt => Nummer der Taste (1-3). + """ + return self.ergebnis + + def nenneText1(self): + """Anfrage. Gibt den Text der ersten Taste zurück. + + Parameter: + --- keine --- + + Rückgabe (Zeichenkette): Der Text der ersten Taste. + """ + return self.text1 + + def nenneText2(self): + """Anfrage. Gibt den Text der zweiten Taste zurück. + + Parameter: + --- keine --- + + Rückgabe (Zeichenkette): Der Text der zweiten Taste. + """ + return self.text2 + + def nenneText3(self): + """Anfrage. Gibt den Text der dritten Taste zurück. + + Parameter: + --- keine --- + + Rückgabe (Zeichenkette): Der Text der dritten Taste. + """ + return self.text3 + + def nenneDreiTasten(self): + """Anfrage. Gibt zurück ob zwei (False) oder drei (True) Tasten + angezeigt werden sollen. + + Parameter: + --- keine --- + + Rückgabe (Wahrheitswert): True, falls drei Tasten angezeigt werden + sollen, False sonst. + """ + return self.dreiTasten + + def zeige(self): + """Auftrag. Zeigt den EntscheidungsDialog an und speichert die Auswahl + im Attribut 'ergebnis'. + + Parameter: + --- keine --- + """ + + self.ergebnis = dialogs.alert(self.titel, self.nachricht, self.text1, self.text2, self.text3 if self.dreiTasten else '',True) diff --git a/source/iOS/ui/dialoge/PasswortDialog.py b/source/iOS/ui/dialoge/PasswortDialog.py new file mode 100644 index 0000000..a6ec157 --- /dev/null +++ b/source/iOS/ui/dialoge/PasswortDialog.py @@ -0,0 +1,36 @@ +# -*- coding: utf-8 -*- +from velamentum.ui.dialoge.EingabeDialog import EingabeDialog +import dialogs + +class PasswortDialog(EingabeDialog): + """Die Klasse EingabeDialog (erbt Attribute und Methoden von der Klasse + EingabeDialog) stellt einen einfachen Dialog zur Eingabe von Passwörtern zur + Verfügung. Im Unterschied zum Eingabedialog wird die Zeichenkette während + der Eingabe nicht angezeigt. + + Attribute: + titel (Zeichenkette): Der Titel des Dialogs. + nachricht (Zeichenkette): Die Nachricht des Dialogs. + ergebnis (Zeichenkette): Der eingegebene Text. + """ + + def __init__(self, pTitel="Titel", pNachricht="Nachricht", pNurZahlen=False): + """Konstruktor. Initialisiert den PasswortDialog. + + Parameter: + [optional] pTitel (Zeichenkette): Der Titel des Dialogs. + [optional] pNachricht (Zeichenkette): Die Nachricht des Dialogs. + [optional] pNurZahlen (Wahrheitswert): Nur Zahlen als Eingabe + erlauben (Standardwert: False). + """ + EingabeDialog.__init__(self, pTitel, pNachricht, pNurZahlen=False) + + def zeige(self): + """Auftrag. Zeigt den PasswortDialog an und speichert die eingegebene + Zeichenkette im Attribut 'ergebnis'. + + Parameter: + --- keine --- + """ + + self.ergebnis = dialogs.password_alert(self.titel, self.nachricht,'','Ok',True) diff --git a/source/iOS/ui/dialoge/__init__.py b/source/iOS/ui/dialoge/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/source/iOS/werkzeuge/System.py b/source/iOS/werkzeuge/System.py new file mode 100644 index 0000000..d60517b --- /dev/null +++ b/source/iOS/werkzeuge/System.py @@ -0,0 +1,14 @@ +# -*- coding: utf-8 -*- +import velamentum.dateien.Datei +import console + +class System(object): + """Die Klasse System dient dem Zugriff auf bestimmte Funktionen des Systems. + + Attribute: + --- keine --- + """ + @staticmethod + def oeffneDatei(pDatei): + console.open_in(pDatei.nennePfad()) + diff --git a/source/iOS/werkzeuge/Zufallsgenerator.py b/source/iOS/werkzeuge/Zufallsgenerator.py new file mode 100644 index 0000000..8f05d24 --- /dev/null +++ b/source/iOS/werkzeuge/Zufallsgenerator.py @@ -0,0 +1,86 @@ +# -*- coding: utf-8 -*- + +import random +import os + +class Zufallsgenerator(object): + """Die Klasse Zufallsgenerator bietet die Möglichkeit einfach Zuffallszahlen + zu generieren. + + Attribute: + min (Zahl): Untere Grenze für die generierten Zufallszahlen. + max (Zahl): Obere Grenze für die generierten Zufallszahlen. + ergebnis (Zahl): Die zuletzt generierte Zufallszahl. + """ + + def __init__(self, pMin=1, pMax=6): + """Konstruktor. Initialisiert den Zufallsgenerator, generiert eine erste + Zufallszahl und speichert sie im Attribut ergebnis. + + Parameter: + [optional] min (Zahl): Kleinste mögliche Zufallszahl. + [optional] max (Zahl): Größte mögliche Zufallszahl. + """ + random.seed(os.urandom(8)); + self.min = pMin + self.max = pMax + self.ergebnis = random.randrange(self.min, self.max+1) + + def setzeMinimum(self, pMin): + """Auftrag. Ändert das Minimum (kleinste mögliche Zufallszahl). + + Parameter: + pMin (Zahl): Kleinste mögliche Zufallszahl. + """ + self.min = pMin + + def setzeMaximum(self, pMax): + """Auftrag. Ändert das Maximum (größte mögliche Zufallszahl). + + Parameter: + pMax (Zahl): Größte mögliche Zufallszahl. + """ + self.max = pMax + + def nenneErgebnis(self): + """Anfrage. Gibt die zuletzt generierte Zufallszahl zurück. + + Parameter: + --- keine --- + + Rückgabe (Zahl): Die zuletzt generierte Zufallszahl. + """ + return self.ergebnis + + def nenneMinimum(self): + """Anfrage. Gibt das eingestellte Minimum (kleinste mögliche + Zufallszahl) zurück. + + Parameter: + --- keine --- + + Rückgabe (Zahl): Kleinste mögliche Zufallszahl. + """ + return self.min + + def nenneMaximum(self): + """Anfrage. Gibt das eingestellte Maximum (größte mögliche Zufallszahl) + zurück. + + Parameter: + --- keine --- + + Rückgabe (Zahl): Größte mögliche Zufallszahl. + """ + return self.max + + def generiere(self): + """Auftrag. Generiert eine neue Zufallszahl und speichert sie im + Attribut 'ergebnis'. + + Parameter: + --- keine --- + """ + self.ergebnis = random.randrange(self.min, self.max+1) + + diff --git a/source/iOS/werkzeuge/Zwischenablage.py b/source/iOS/werkzeuge/Zwischenablage.py new file mode 100644 index 0000000..a2ef710 --- /dev/null +++ b/source/iOS/werkzeuge/Zwischenablage.py @@ -0,0 +1,43 @@ +# -*- coding: utf-8 -*- +import clipboard + +class Zwischenablage(object): + """Die Klasse dient dem Zugriff auf die Zwischenablage des Systems. + + Attribute: + text (Zeichenkette): Der Text in der Zwischenablage des Systems. + """ + + def __init__(self): + """Konstruktor. Initialisiert die Zwischenablage. + + Parameter: + --- keine --- + """ + pass + + @staticmethod + def nenneText(self): + """Anfrage. Gibt den Text aus der Zwischenablage zurück. + + Parameter + --- keine --- + + Rückgabe (Zeichenkette): Der Inhalt der Zwischenablage. + """ + return clipboard.get() + + @staticmethod + def setzeText(self, pText): + """Auftrag. Schreibt den Text in die Zwischenablage. + + Parameter + pText (Zeichenkette): Der Text, der in die Zwischenablage + geschrieben werden soll. + """ + clipboard.set(pText) + + # Attribute (verdeckte Getter und Setter) + text = property (nenneText, setzeText, doc="Der Text in der" \ + "Zwischenablage des Systems.") + diff --git a/source/iOS/werkzeuge/__init__.py b/source/iOS/werkzeuge/__init__.py new file mode 100644 index 0000000..e69de29