ddi_private/velamentumRS
3
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Compare commits

merge into: ddi_private:master
Branches Tags
ddi_private:master
ddi_private:velamentumJAVA
...
pull from: ddi_private:velamentumJAVA
Branches Tags
ddi_private:master
ddi_private:velamentumJAVA

No commits in common. "master" and "velamentumJAVA" have entirely different histories.
master ... velamentum

135 changed files with 69 additions and 5794 deletions
Show Stats Expand all files Collapse all files

158
.gitignore vendored
View File

@ -1,158 +0,0 @@
# ---> Java
# Compiled class file
*.class
src/java/velamentum
# Log file
*.log
# BlueJ files
*.ctxt
# Mobile Tools for Java (J2ME)
.mtj.tmp/
# Package Files #
*.jar
*.war
*.nar
*.ear
*.zip
!src/java/velamentumJava.zip
*.tar.gz
*.rar
# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
hs_err_pid*
# ---> Python
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class
# C extensions
*.so
# Distribution / packaging
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
pip-wheel-metadata/
share/python-wheels/
*.egg-info/
.installed.cfg
*.egg
MANIFEST
# PyInstaller
# Usually these files are written by a python script from a template
# before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest
*.spec
# Installer logs
pip-log.txt
pip-delete-this-directory.txt
# Unit test / coverage reports
htmlcov/
.tox/
.nox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*.cover
*.py,cover
.hypothesis/
.pytest_cache/
# Translations
*.mo
*.pot
# Django stuff:
*.log
local_settings.py
db.sqlite3
db.sqlite3-journal
# Flask stuff:
instance/
.webassets-cache
# Scrapy stuff:
.scrapy
# Sphinx documentation
docs/_build/
# PyBuilder
target/
# Jupyter Notebook
.ipynb_checkpoints
# IPython
profile_default/
ipython_config.py
# pyenv
.python-version
# pipenv
# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
# However, in case of collaboration, if having platform-specific dependencies or dependencies
# having no cross-platform support, pipenv may install dependencies that don't work, or not
# install all needed dependencies.
#Pipfile.lock
# PEP 582; used by e.g. github.com/David-OConnor/pyflow
__pypackages__/
# Celery stuff
celerybeat-schedule
celerybeat.pid
# SageMath parsed files
*.sage.py
# Environments
.env
.venv
env/
venv/
ENV/
env.bak/
venv.bak/
# Spyder project settings
.spyderproject
.spyproject
# Rope project settings
.ropeproject
# mkdocs documentation
/site
# mypy
.mypy_cache/
.dmypy.json
dmypy.json
# Pyre type checker
.pyre/

362
LICENSE
View File

@ -1,362 +0,0 @@
Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Creative
Commons Corporation ("Creative Commons") is not a law firm and does not provide
legal services or legal advice. Distribution of Creative Commons public licenses
does not create a lawyer-client or other relationship. Creative Commons makes
its licenses and related information available on an "as-is" basis. Creative
Commons gives no warranties regarding its licenses, any material licensed
under their terms and conditions, or any related information. Creative Commons
disclaims all liability for damages resulting from their use to the fullest
extent possible.
Using Creative Commons Public Licenses
Creative Commons public licenses provide a standard set of terms and conditions
that creators and other rights holders may use to share original works of
authorship and other material subject to copyright and certain other rights
specified in the public license below. The following considerations are for
informational purposes only, are not exhaustive, and do not form part of our
licenses.
Considerations for licensors: Our public licenses are intended for use by
those authorized to give the public permission to use material in ways otherwise
restricted by copyright and certain other rights. Our licenses are irrevocable.
Licensors should read and understand the terms and conditions of the license
they choose before applying it. Licensors should also secure all rights necessary
before applying our licenses so that the public can reuse the material as
expected. Licensors should clearly mark any material not subject to the license.
This includes other CC-licensed material, or material used under an exception
or limitation to copyright. More considerations for licensors : wiki.creativecommons.org/Considerations_for_licensors
Considerations for the public: By using one of our public licenses, a licensor
grants the public permission to use the licensed material under specified
terms and conditions. If the licensor's permission is not necessary for any
reason–for example, because of any applicable exception or limitation to copyright–then
that use is not regulated by the license. Our licenses grant only permissions
under copyright and certain other rights that a licensor has authority to
grant. Use of the licensed material may still be restricted for other reasons,
including because others have copyright or other rights in the material. A
licensor may make special requests, such as asking that all changes be marked
or described. Although not required by our licenses, you are encouraged to
respect those requests where reasonable. More considerations for the public
: wiki.creativecommons.org/Considerations_for_licensees
Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Public
License
By exercising the Licensed Rights (defined below), You accept and agree to
be bound by the terms and conditions of this Creative Commons Attribution-NonCommercial-ShareAlike
4.0 International Public License ("Public License"). To the extent this Public
License may be interpreted as a contract, You are granted the Licensed Rights
in consideration of Your acceptance of these terms and conditions, and the
Licensor grants You such rights in consideration of benefits the Licensor
receives from making the Licensed Material available under these terms and
conditions.
Section 1 – Definitions.
a. Adapted Material means material subject to Copyright and Similar Rights
that is derived from or based upon the Licensed Material and in which the
Licensed Material is translated, altered, arranged, transformed, or otherwise
modified in a manner requiring permission under the Copyright and Similar
Rights held by the Licensor. For purposes of this Public License, where the
Licensed Material is a musical work, performance, or sound recording, Adapted
Material is always produced where the Licensed Material is synched in timed
relation with a moving image.
b. Adapter's License means the license You apply to Your Copyright and Similar
Rights in Your contributions to Adapted Material in accordance with the terms
and conditions of this Public License.
c. BY-NC-SA Compatible License means a license listed at creativecommons.org/compatiblelicenses,
approved by Creative Commons as essentially the equivalent of this Public
License.
d. Copyright and Similar Rights means copyright and/or similar rights closely
related to copyright including, without limitation, performance, broadcast,
sound recording, and Sui Generis Database Rights, without regard to how the
rights are labeled or categorized. For purposes of this Public License, the
rights specified in Section 2(b)(1)-(2) are not Copyright and Similar Rights.
e. Effective Technological Measures means those measures that, in the absence
of proper authority, may not be circumvented under laws fulfilling obligations
under Article 11 of the WIPO Copyright Treaty adopted on December 20, 1996,
and/or similar international agreements.
f. Exceptions and Limitations means fair use, fair dealing, and/or any other
exception or limitation to Copyright and Similar Rights that applies to Your
use of the Licensed Material.
g. License Elements means the license attributes listed in the name of a Creative
Commons Public License. The License Elements of this Public License are Attribution,
NonCommercial, and ShareAlike.
h. Licensed Material means the artistic or literary work, database, or other
material to which the Licensor applied this Public License.
i. Licensed Rights means the rights granted to You subject to the terms and
conditions of this Public License, which are limited to all Copyright and
Similar Rights that apply to Your use of the Licensed Material and that the
Licensor has authority to license.
j. Licensor means the individual(s) or entity(ies) granting rights under this
Public License.
k. NonCommercial means not primarily intended for or directed towards commercial
advantage or monetary compensation. For purposes of this Public License, the
exchange of the Licensed Material for other material subject to Copyright
and Similar Rights by digital file-sharing or similar means is NonCommercial
provided there is no payment of monetary compensation in connection with the
exchange.
l. Share means to provide material to the public by any means or process that
requires permission under the Licensed Rights, such as reproduction, public
display, public performance, distribution, dissemination, communication, or
importation, and to make material available to the public including in ways
that members of the public may access the material from a place and at a time
individually chosen by them.
m. Sui Generis Database Rights means rights other than copyright resulting
from Directive 96/9/EC of the European Parliament and of the Council of 11
March 1996 on the legal protection of databases, as amended and/or succeeded,
as well as other essentially equivalent rights anywhere in the world.
n. You means the individual or entity exercising the Licensed Rights under
this Public License. Your has a corresponding meaning.
Section 2 – Scope.
a. License grant.
1. Subject to the terms and conditions of this Public License, the Licensor
hereby grants You a worldwide, royalty-free, non-sublicensable, non-exclusive,
irrevocable license to exercise the Licensed Rights in the Licensed Material
to:
A. reproduce and Share the Licensed Material, in whole or in part, for NonCommercial
purposes only; and
B. produce, reproduce, and Share Adapted Material for NonCommercial purposes
only.
2. Exceptions and Limitations. For the avoidance of doubt, where Exceptions
and Limitations apply to Your use, this Public License does not apply, and
You do not need to comply with its terms and conditions.
3. Term. The term of this Public License is specified in Section 6(a).
4. Media and formats; technical modifications allowed. The Licensor authorizes
You to exercise the Licensed Rights in all media and formats whether now known
or hereafter created, and to make technical modifications necessary to do
so. The Licensor waives and/or agrees not to assert any right or authority
to forbid You from making technical modifications necessary to exercise the
Licensed Rights, including technical modifications necessary to circumvent
Effective Technological Measures. For purposes of this Public License, simply
making modifications authorized by this Section 2(a)(4) never produces Adapted
Material.
5. Downstream recipients.
A. Offer from the Licensor – Licensed Material. Every recipient of the Licensed
Material automatically receives an offer from the Licensor to exercise the
Licensed Rights under the terms and conditions of this Public License.
B. Additional offer from the Licensor – Adapted Material. Every recipient
of Adapted Material from You automatically receives an offer from the Licensor
to exercise the Licensed Rights in the Adapted Material under the conditions
of the Adapter's License You apply.
C. No downstream restrictions. You may not offer or impose any additional
or different terms or conditions on, or apply any Effective Technological
Measures to, the Licensed Material if doing so restricts exercise of the Licensed
Rights by any recipient of the Licensed Material.
6. No endorsement. Nothing in this Public License constitutes or may be construed
as permission to assert or imply that You are, or that Your use of the Licensed
Material is, connected with, or sponsored, endorsed, or granted official status
by, the Licensor or others designated to receive attribution as provided in
Section 3(a)(1)(A)(i).
b. Other rights.
1. Moral rights, such as the right of integrity, are not licensed under this
Public License, nor are publicity, privacy, and/or other similar personality
rights; however, to the extent possible, the Licensor waives and/or agrees
not to assert any such rights held by the Licensor to the limited extent necessary
to allow You to exercise the Licensed Rights, but not otherwise.
2. Patent and trademark rights are not licensed under this Public License.
3. To the extent possible, the Licensor waives any right to collect royalties
from You for the exercise of the Licensed Rights, whether directly or through
a collecting society under any voluntary or waivable statutory or compulsory
licensing scheme. In all other cases the Licensor expressly reserves any right
to collect such royalties, including when the Licensed Material is used other
than for NonCommercial purposes.
Section 3 – License Conditions.
Your exercise of the Licensed Rights is expressly made subject to the following
conditions.
a. Attribution.
1. If You Share the Licensed Material (including in modified form), You must:
A. retain the following if it is supplied by the Licensor with the Licensed
Material:
i. identification of the creator(s) of the Licensed Material and any others
designated to receive attribution, in any reasonable manner requested by the
Licensor (including by pseudonym if designated);
ii. a copyright notice;
iii. a notice that refers to this Public License;
iv. a notice that refers to the disclaimer of warranties;
v. a URI or hyperlink to the Licensed Material to the extent reasonably practicable;
B. indicate if You modified the Licensed Material and retain an indication
of any previous modifications; and
C. indicate the Licensed Material is licensed under this Public License, and
include the text of, or the URI or hyperlink to, this Public License.
2. You may satisfy the conditions in Section 3(a)(1) in any reasonable manner
based on the medium, means, and context in which You Share the Licensed Material.
For example, it may be reasonable to satisfy the conditions by providing a
URI or hyperlink to a resource that includes the required information.
3. If requested by the Licensor, You must remove any of the information required
by Section 3(a)(1)(A) to the extent reasonably practicable.
b. ShareAlike.In addition to the conditions in Section 3(a), if You Share
Adapted Material You produce, the following conditions also apply.
1. The Adapter's License You apply must be a Creative Commons license with
the same License Elements, this version or later, or a BY-NC-SA Compatible
License.
2. You must include the text of, or the URI or hyperlink to, the Adapter's
License You apply. You may satisfy this condition in any reasonable manner
based on the medium, means, and context in which You Share Adapted Material.
3. You may not offer or impose any additional or different terms or conditions
on, or apply any Effective Technological Measures to, Adapted Material that
restrict exercise of the rights granted under the Adapter's License You apply.
Section 4 – Sui Generis Database Rights.
Where the Licensed Rights include Sui Generis Database Rights that apply to
Your use of the Licensed Material:
a. for the avoidance of doubt, Section 2(a)(1) grants You the right to extract,
reuse, reproduce, and Share all or a substantial portion of the contents of
the database for NonCommercial purposes only;
b. if You include all or a substantial portion of the database contents in
a database in which You have Sui Generis Database Rights, then the database
in which You have Sui Generis Database Rights (but not its individual contents)
is Adapted Material, including for purposes of Section 3(b); and
c. You must comply with the conditions in Section 3(a) if You Share all or
a substantial portion of the contents of the database.
For the avoidance of doubt, this Section 4 supplements and does not replace
Your obligations under this Public License where the Licensed Rights include
other Copyright and Similar Rights.
Section 5 – Disclaimer of Warranties and Limitation of Liability.
a. Unless otherwise separately undertaken by the Licensor, to the extent possible,
the Licensor offers the Licensed Material as-is and as-available, and makes
no representations or warranties of any kind concerning the Licensed Material,
whether express, implied, statutory, or other. This includes, without limitation,
warranties of title, merchantability, fitness for a particular purpose, non-infringement,
absence of latent or other defects, accuracy, or the presence or absence of
errors, whether or not known or discoverable. Where disclaimers of warranties
are not allowed in full or in part, this disclaimer may not apply to You.
b. To the extent possible, in no event will the Licensor be liable to You
on any legal theory (including, without limitation, negligence) or otherwise
for any direct, special, indirect, incidental, consequential, punitive, exemplary,
or other losses, costs, expenses, or damages arising out of this Public License
or use of the Licensed Material, even if the Licensor has been advised of
the possibility of such losses, costs, expenses, or damages. Where a limitation
of liability is not allowed in full or in part, this limitation may not apply
to You.
c. The disclaimer of warranties and limitation of liability provided above
shall be interpreted in a manner that, to the extent possible, most closely
approximates an absolute disclaimer and waiver of all liability.
Section 6 – Term and Termination.
a. This Public License applies for the term of the Copyright and Similar Rights
licensed here. However, if You fail to comply with this Public License, then
Your rights under this Public License terminate automatically.
b. Where Your right to use the Licensed Material has terminated under Section
6(a), it reinstates:
1. automatically as of the date the violation is cured, provided it is cured
within 30 days of Your discovery of the violation; or
2. upon express reinstatement by the Licensor.
For the avoidance of doubt, this Section 6(b) does not affect any right the
Licensor may have to seek remedies for Your violations of this Public License.
c. For the avoidance of doubt, the Licensor may also offer the Licensed Material
under separate terms or conditions or stop distributing the Licensed Material
at any time; however, doing so will not terminate this Public License.
d. Sections 1, 5, 6, 7, and 8 survive termination of this Public License.
Section 7 – Other Terms and Conditions.
a. The Licensor shall not be bound by any additional or different terms or
conditions communicated by You unless expressly agreed.
b. Any arrangements, understandings, or agreements regarding the Licensed
Material not stated herein are separate from and independent of the terms
and conditions of this Public License.
Section 8 – Interpretation.
a. For the avoidance of doubt, this Public License does not, and shall not
be interpreted to, reduce, limit, restrict, or impose conditions on any use
of the Licensed Material that could lawfully be made without permission under
this Public License.
b. To the extent possible, if any provision of this Public License is deemed
unenforceable, it shall be automatically reformed to the minimum extent necessary
to make it enforceable. If the provision cannot be reformed, it shall be severed
from this Public License without affecting the enforceability of the remaining
terms and conditions.
c. No term or condition of this Public License will be waived and no failure
to comply consented to unless expressly agreed to by the Licensor.
d. Nothing in this Public License constitutes or may be interpreted as a limitation
upon, or waiver of, any privileges and immunities that apply to the Licensor
or You, including from the legal processes of any jurisdiction or authority.
Creative Commons is not a party to its public licenses. Notwithstanding, Creative
Commons may elect to apply one of its public licenses to material it publishes
and in those instances will be considered the "Licensor." The text of the
Creative Commons public licenses is dedicated to the public domain under the
CC0 Public Domain Dedication. Except for the limited purpose of indicating
that material is shared under a Creative Commons public license or as otherwise
permitted by the Creative Commons policies published at creativecommons.org/policies,
Creative Commons does not authorize the use of the trademark "Creative Commons"
or any other trademark or logo of Creative Commons without its prior written
consent including, without limitation, in connection with any unauthorized
modifications to any of its public licenses or any other arrangements, understandings,
or agreements concerning use of licensed material. For the avoidance of doubt,
this paragraph does not form part of the public licenses.
Creative Commons may be contacted at creativecommons.org.

BIN
MyVTest.class Normal file
View File

Binary file not shown.

0
src/Examples/MyVTest.java → MyVTest.java
View File

20
README.md
View File

@ -1,20 +0,0 @@
# velamentumRS
Fork von velamentum mit dem Ziel sowohl python am Desktop als auch eine Java Unterstützung herzustellen.
## Java
**Unterstützte Bibliotheken:**
- velamentum.ui.dialoge.Dialog
- velamentum.ui.dialoge.EingabeDialog
- velamentum.ui.dialoge.EingabeDialog_alt
- velamentum.ui.dialoge.EntscheidungsDialog
- velamentum.ui.dialoge.PasswortDialog
### Buildprozess
Im Verzeichnis `src/java` befindet sich ein Makefile.
`make` erstellt aus den Quellen alle benötigten Klassen-Dateien in das Verzeichnis
`src/java/velamentum`. Diese sollten dann im Java-Classpath mit `javac -cp pfad/zu/java/velamentum`
oder in der Umgebungsvariable `export CLASSPATH=$CLASSPATH:pfad/zu/java/velamentum` angegeben
werden.

BIN
SchereSteinPapier.class Normal file
View File

Binary file not shown.

64
SchereSteinPapier.java Normal file
View File

@ -0,0 +1,64 @@
import velamentum.Dialog;
import velamentum.EntscheidungsDialog;
import velamentum.werkzeuge.Zufallsgenerator;
public class SchereSteinPapier {
public static void main(String[] args) {
Dialog dialog = new Dialog("Schere, Stein, Papier", "Willkommen zum Spiel!");
dialog.zeige();
EntscheidungsDialog eDialog = new EntscheidungsDialog("Schere, Stein, Papier", "Bitte wählen Sie ihren Gegenstand");
eDialog.setzeText1("Schere");
eDialog.setzeText2("Stein");
eDialog.setzeText3("Papier");
eDialog.setzeDreiTasten(true);
eDialog.zeige();
System.out.println(eDialog.nenneErgebnis());
Zufallsgenerator zufall = new Zufallsgenerator(1, 3);
System.out.println(zufall.nenneErgebnis());
if(zufall.nenneErgebnis() == 1) {
dialog.zeigeNachricht("Ich habe Schere gewählt.");
if(eDialog.nenneErgebnis() == 1) {
dialog.zeigeNachricht("Unentschieden!");
}
else if(eDialog.nenneErgebnis() == 2) {
dialog.zeigeNachricht("Du hast gewonnen!");
}
else {
dialog.zeigeNachricht("Ich habe gewonnen!");
}
}
else if(zufall.nenneErgebnis() == 2) {
dialog.zeigeNachricht("Ich habe Stein gewählt.");
if(eDialog.nenneErgebnis() == 2) {
dialog.zeigeNachricht("Unentschieden!");
}
else if(eDialog.nenneErgebnis() == 1) {
dialog.zeigeNachricht("Ich habe gewonnen!");
}
else {
dialog.zeigeNachricht("Du hast gewonnen!");
}
}
else{
dialog.zeigeNachricht("Ich habe Papier gewählt.");
if(eDialog.nenneErgebnis() == 3) {
dialog.zeigeNachricht("Unentschieden!");
}
else if(eDialog.nenneErgebnis() == 2) {
dialog.zeigeNachricht("Ich habe gewonnen!");
}
else {
dialog.zeigeNachricht("Du hast gewonnen!");
}
}
}
}

BIN
Zahlenraten.class Normal file
View File

Binary file not shown.

0
src/Examples/Zahlenraten/Zahlenraten.java → Zahlenraten.java
View File

0
src/Android/__init__.py
View File

22
src/Android/alle.py
View File

@ -1,22 +0,0 @@
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

2
src/Android/android.py
View File

@ -1,2 +0,0 @@
import androidhelper
androide = androidhelper.Android()

71
src/Android/dateien/Datei.py
View File

@ -1,71 +0,0 @@
# -*- 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.")

104
src/Android/dateien/DateiSystemElement.py
View File

@ -1,104 +0,0 @@
# -*- 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.")

29
src/Android/dateien/Verzeichnis.py
View File

@ -1,29 +0,0 @@
# -*- 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

0
src/Android/dateien/__init__.py
View File

178
src/Android/multimedia/AudioPlayer.py
View File

@ -1,178 +0,0 @@
# -*- coding: utf-8 -*-
import time
import random
import velamentum.dateien.Datei
from velamentum.multimedia.Player import Player
from velamentum.android import *
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():
androide.mediaPlay(self.datei.nennePfad(), self._id,
pSofortWiedergeben)
self.dauer = int(androide.mediaPlayInfo(self._id)[1]["duration"])
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 ---
"""
androide.mediaPlayClose(self._id)
def nenneDauer(self):
"""Anfrage. Gibt die Gesamtdauer der Datei zurück.
Parameter:
--- keine ---
Rückgabe (Zahl): Gesamtdauer der Datei in Millisekunden.
"""
return self.dauer
def nennePosition(self):
"""Anfrage. Gibt die aktuelle Position der Wiedergabe zurück.
Parameter:
--- keine ---
Rückgabe (Zahl): Aktuelle Position der Wiedergabe in Millisekunden.
"""
return int(androide.mediaPlayInfo(self._id)[1]["position"])
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
androide.mediaPlaySeek(pPosition, self._id)
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.
"""
Player.setzeDatei(self, pDatei)
if pDatei.istVorhanden():
androide.mediaPlay(self.datei.nennePfad(), self._id, False)
self.dauer = int(androide.mediaPlayInfo(self._id)[1]["duration"])
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 androide.mediaPlayInfo(self._id)[1]["looping"]
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?
"""
return androide.mediaPlaySetLooping(self._id, pWiederholen)
def gibtWieder(self):
"""Anfrage. Gibt an, ob die Datei gerade wiedergegeben wird.
Parameter:
--- keine ---
Rückgabe (Wahrheitswert): True falls gerade eine Wiedergabe läuft,
False sonst.
"""
return androide.mediaIsPlaying(self._id)["result"]
def wiedergeben(self):
"""Auftrag. Startet die Wiedergabe der Multimediadaten.
Parameter
--- keine ---
"""
androide.mediaPlayStart(self._id)
def pausieren(self):
"""Auftrag. Pausiert die Wiedergabe der Multimediadaten. Die Wiedergabe
kann mit 'wiedergeben' fortgesetzt werden.
Parameter
--- keine ---
"""
androide.mediaPlayPause(self._id)
def stoppen(self):
"""Auftrag. Stoppt die Wiedergabe der Multimediadaten. (Wie 'pausieren',
Wiedergabe kann jedoch nicht fortgesetzt werden, sondern beginnt dann
von vorne.
Parameter
--- keine ---
"""
androide.mediaPlayPause(self._id)
self.setzePosition(0)
# 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.")

58
src/Android/multimedia/AudioRecorder.py
View File

@ -1,58 +0,0 @@
# -*- coding: utf-8 -*-
import velamentum.dateien.Datei
from velamentum.multimedia.Recorder import Recorder
from velamentum.ui.dialoge.Dialog import Dialog
from velamentum.android import *
class AudioRecorder(Recorder):
"""Die Klasse AudioRecorder dient der Aufnahme von Tondaten in eine Datei.
Attribute:
--- von 'Recorder' geerbte ---
"""
def __init__(self, pDatei=velamentum.dateien.Datei.Datei("/sdcard/aufnahme.m4a")):
"""Konstruktor. Initialisiert den AudioRecorder.
Parameter:
[optional] datei (Datei): Datei, in der die Aufnahme gespeichert
werden soll [Standardwert: Datei mit Pfad '/scard/aufnahme.m4a'].
"""
Recorder.__init__(self, pDatei)
def aufnehmen(self):
"""Auftrag. Startet die Aufnahme der Multimediadaten.
HINWEIS: Die angegebene Datei wird überschrieben.
Parameter
--- keine ---
"""
Recorder.aufnehmen(self)
androide.recorderStartMicrophone(self.datei.nennePfad())
def stoppen(self):
"""Auftrag. Stoppt die Aufnahme der Multimediadaten.
Parameter
--- keine ---
"""
Recorder.stoppen(self)
androide.recorderStop()
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 ---
"""
self.aufnehmen()
dialog = Dialog("Audioaufnahme", "Aufnahme gestartet. Zum Beenden" \
"'Ok' drücken.")
dialog.zeige()
self.stoppen()

51
src/Android/multimedia/BildRecorder.py
View File

@ -1,51 +0,0 @@
# -*- coding: utf-8 -*-
import velamentum.dateien.Datei
from velamentum.multimedia.Recorder import Recorder
from velamentum.android import *
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 ---
"""
androide.cameraCapturePicture(self.datei.nennePfad())
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 ---
"""
androide.cameraInteractiveCapturePicture(self.datei.nennePfad())

91
src/Android/multimedia/JNIAudioRecorder.py
View File

@ -1,91 +0,0 @@
# -*- coding: utf-8 -*-
import velamentum.dateien.Datei
from velamentum.multimedia.Recorder import Recorder
from velamentum.ui.dialoge.Dialog import Dialog
from jnius import autoclass
from velamentum.android import *
class JNIAudioRecorder(Recorder):
"""Die Klasse AudioRecorder dient der Aufnahme von Tondaten in eine Datei.
BUG: Die Nutzung aus der QPython-Konsole funktioniert derzeit nicht.
Der Aufruf aus einer Skriptdatei funktioniert hingegen problemlos.
Attribute:
--- von 'Recorder' geerbte ---
"""
def __init__(self, pDatei=velamentum.dateien.Datei.Datei("/sdcard/aufnahme.m4a")):
"""Konstruktor. Initialisiert den JNIAudioRecorder.
Parameter:
[optional] pDatei (Datei): Datei, in der die Aufnahme gespeichert
werden soll [Standardwert: Datei mit Pfad
'/sdcard/aufnahme.m4a'].
"""
Recorder.__init__(self, pDatei)
# Recorder initialisieren
MediaRecorder = autoclass('android.media.MediaRecorder')
AudioSource = autoclass('android.media.MediaRecorder$AudioSource')
OutputFormat = autoclass('android.media.MediaRecorder$OutputFormat')
AudioEncoder = autoclass('android.media.MediaRecorder$AudioEncoder')
self.__mRecorder = MediaRecorder()
self.__mRecorder.setOutputFile(pDatei.nennePfad()) # Pfad der Datei
self.__mRecorder.setAudioSource(AudioSource.MIC) # Aufnahme vom Mikrofon
self.__mRecorder.setAudioChannels(1) # Mono
self.__mRecorder.setAudioEncodingBitRate(131072) # 128 kbps
self.__mRecorder.setAudioSamplingRate(48000) # 48 kHz
# ACHTUNG: Reihenfolge ist relevant! Erst Format, dann Encoder!
self.__mRecorder.setOutputFormat(OutputFormat.MPEG_4) # MP4-Container
self.__mRecorder.setAudioEncoder(AudioEncoder.AAC) # AAC-Format
def __del__(self):
"""Destruktor. Notwendig zur Freigabe des MediaRecorders beim Löschen
des Python-Objekts.
Parameter:
--- keine ---
"""
self.__mRecorder.release()
def aufnehmen(self):
"""Auftrag. Startet die Aufnahme der Multimediadaten.
HINWEIS: Die angegebene Datei wird überschrieben.
Parameter
--- keine ---
"""
Recorder.aufnehmen(self)
self.__mRecorder.setOutputFile(self.datei.nennePfad())
self.__mRecorder.prepare()
self.__mRecorder.start()
def stoppen(self):
"""Auftrag. Stoppt die Aufnahme der Multimediadaten.
Parameter
--- keine ---
"""
Recorder.stoppen(self)
self.__mRecorder.stop()
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 ---
"""
self.aufnehmen()
dialog = Dialog("Audioaufnahme", "Aufnahme gestartet. Zum Beenden" \
"'Ok' drücken.")
dialog.zeige()
self.stoppen()

144
src/Android/multimedia/Player.py
View File

@ -1,144 +0,0 @@
# -*- coding: utf-8 -*-
import time
import velamentum.dateien.Datei
from velamentum.android import *
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 gibtWieder(self):
"""Anfrage. Gibt an, ob die Datei gerade wiedergegeben wird.
Parameter:
--- keine ---
Rückgabe (Wahrheitswert): True falls gerade eine Wiedergabe läuft,
False sonst.
"""
return False
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.")

96
src/Android/multimedia/Recorder.py
View File

@ -1,96 +0,0 @@
# -*- coding: utf-8 -*-
import time
import velamentum.dateien.Datei
from velamentum.android import *
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("/sdcard/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

53
src/Android/multimedia/VideoRecorder.py
View File

@ -1,53 +0,0 @@
# -*- coding: utf-8 -*-
import velamentum.dateien.Datei
from velamentum.multimedia.Recorder import Recorder
from velamentum.android import *
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("/sdcard/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)
def aufnehmen(self):
"""Auftrag. Startet die Aufnahme der Multimediadaten.
HINWEIS: Die angegebene Datei wird überschrieben.
Parameter
--- keine ---
"""
Recorder.aufnehmen(self)
androide.recorderCaptureVideo(self.datei.nennePfad())
def stoppen(self):
"""Auftrag. Stoppt die Aufnahme der Multimediadaten.
Parameter
--- keine ---
"""
Recorder.stoppen(self)
androide.recorderStop()
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 ---
"""
androide.startInteractiveVideoRecording(self.datei.nennePfad())

0
src/Android/multimedia/__init__.py
View File

0
src/Android/sensoren/__init__.py
View File

BIN
src/Android/signale/AudioSignal.mp3
View File

Binary file not shown.

60
src/Android/signale/AudioSignal.py
View File

@ -1,60 +0,0 @@
# -*- 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.")

22
src/Android/signale/Signal.py
View File

@ -1,22 +0,0 @@
# -*- coding: utf-8 -*-
from velamentum.android import *
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

45
src/Android/signale/TextSignal.py
View File

@ -1,45 +0,0 @@
# -*- coding: utf-8 -*-
from velamentum.signale.Signal import Signal
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 ---
"""
androide.makeToast(self.text)

45
src/Android/signale/VibrationsSignal.py
View File

@ -1,45 +0,0 @@
# -*- coding: utf-8 -*-
from velamentum.signale.Signal import Signal
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 ---
"""
androide.vibrate(self.dauer)

0
src/Android/signale/__init__.py
View File

55
src/Android/sprache/Sprachausgabe.py
View File

@ -1,55 +0,0 @@
# -*- coding: utf-8 -*-
from velamentum.android import *
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 androide.ttsIsSpeaking().result
def sprechen(self):
"""Auftrag. Wandelt den Text in Sprache um und gibt ihn über die
Lautsprecher aus.
Parameter:
--- keine ---
"""
androide.ttsSpeak(self.text)

39
src/Android/sprache/Spracheingabe.py
View File

@ -1,39 +0,0 @@
# -*- coding: utf-8 -*-
from velamentum.android import *
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 = androide.recognizeSpeech("Bitte sprechen!","de-DE",
"free_form").result

0
src/Android/sprache/__init__.py
View File

0
src/Android/ui/__init__.py
View File

79
src/Android/ui/dialoge/Dialog.py
View File

@ -1,79 +0,0 @@
# -*- coding: utf-8 -*-
from velamentum.android import *
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 ---
"""
androide.dialogCreateAlert(self.titel, self.nachricht)
androide.dialogSetPositiveButtonText('Ok')
androide.dialogShow()
androide.dialogGetResponse()

103
src/Android/ui/dialoge/EingabeDialog.py
View File

@ -1,103 +0,0 @@
# -*- coding: utf-8 -*-
from velamentum.ui.dialoge.Dialog import Dialog
from velamentum.android import *
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 ---
"""
androide.dialogCreateInput(self.titel, self.nachricht,
self.__ergebnis if self.wertAnzeigen else '',
'number' if self.nurZahlen else 'text')
androide.dialogSetPositiveButtonText('Ok')
androide.dialogShow()
self.__ergebnis = androide.dialogGetResponse().result['value']
ergebnis = property(nenneErgebnis, doc="Die Eingabe des Benutzers.")

152
src/Android/ui/dialoge/EntscheidungsDialog.py
View File

@ -1,152 +0,0 @@
# -*- coding: utf-8 -*-
from velamentum.ui.dialoge.Dialog import Dialog
from velamentum.android import *
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 ---
"""
androide.dialogCreateAlert(self.titel, self.nachricht)
androide.dialogSetPositiveButtonText(self.text1)
if self.dreiTasten:
androide.dialogSetNegativeButtonText(self.text3)
androide.dialogSetNeutralButtonText(self.text2)
else:
androide.dialogSetNegativeButtonText(self.text2)
androide.dialogShow()
tmpErg = androide.dialogGetResponse().result
if 'which' in tmpErg:
if tmpErg['which'] == 'positive':
self.ergebnis=1
elif tmpErg['which'] == 'negative':
if self.dreiTasten:
self.ergebnis=3
else:
self.ergebnis=2
elif tmpErg['which'] == 'neutral':
self.ergebnis=2
else:
self.ergebnis = 0

39
src/Android/ui/dialoge/PasswortDialog.py
View File

@ -1,39 +0,0 @@
# -*- coding: utf-8 -*-
from velamentum.ui.dialoge.EingabeDialog import EingabeDialog
from velamentum.android import *
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 ---
"""
androide.dialogCreateInput(self.titel, self.nachricht, None,
'numberPassword' if self.nurZahlen else 'textPassword')
androide.dialogSetPositiveButtonText('Ok')
androide.dialogShow()
self.ergebnis = androide.dialogGetResponse().result['value']

0
src/Android/ui/dialoge/__init__.py
View File

14
src/Android/werkzeuge/System.py
View File

@ -1,14 +0,0 @@
# -*- coding: utf-8 -*-
import velamentum.dateien.Datei
from velamentum.android import *
class System(object):
"""Die Klasse System dient dem Zugriff auf bestimmte Funktionen des Systems.
Attribute:
--- keine ---
"""
@staticmethod
def oeffneDatei(pDatei):
androide.view("file://" + pDatei.nennePfad())

86
src/Android/werkzeuge/Zufallsgenerator.py
View File

@ -1,86 +0,0 @@
# -*- 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)

43
src/Android/werkzeuge/Zwischenablage.py
View File

@ -1,43 +0,0 @@
# -*- coding: utf-8 -*-
from velamentum.android import *
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 androide.getClipboard()
@staticmethod
def setzeText(self, pText):
"""Auftrag. Schreibt den Text in die Zwischenablage.
Parameter
pText (Zeichenkette): Der Text, der in die Zwischenablage
geschrieben werden soll.
"""
androide.setClipboard(pText)
# Attribute (verdeckte Getter und Setter)
text = property (nenneText, setzeText, doc="Der Text in der" \
"Zwischenablage des Systems.")

0
src/Android/werkzeuge/__init__.py
View File

18
src/Examples/Desktop/Quiz.py
View File

@ -1,18 +0,0 @@
# -*- coding: utf-8 -*-
from velamentum.alle import *
# Dialog vorbereiten und Begrüßung anzeigen
dialog = Dialog("Quiz", "Willkommen zum Quiz!")
dialog.zeige()
frage = EntscheidungsDialog("Frage 1", "Wie viel ist 5+3?")
frage.setzeText1("7")
frage.setzeText2("8")
frage.zeige()
feedback = Dialog("Feedback", "")
if frage.nenneErgebnis() == 2:
feedback.zeigeNachricht("Richtig!")
else:
feedback.zeigeNachricht("Falsch!")

50
src/Examples/Desktop/SteinScherePapier.py
View File

@ -1,50 +0,0 @@
# -*- 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)
eDialog.zeige()
print(eDialog.nenneErgebnis())
# 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!")

40
src/Examples/Desktop/Zahlenraten.py
View File

@ -1,40 +0,0 @@
# -*- coding: utf-8 -*-
from velamentum.alle import *
#from velamentum.ui.dialoge.Dialog import *
#from velamentum.ui.dialoge.EntscheidungsDialog import *
#from velamentum.ui.dialoge.EingabeDialog import *
#from velamentum.werkzeuge.Zufallsgenerator 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 = PasswortDialog("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))

18
src/Examples/Sprachtest/Sprachtest.py
View File

@ -1,18 +0,0 @@
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()

64
src/Examples/SteinScherePapier/SchereSteinPapier.java
View File

@ -1,64 +0,0 @@
import velamentum.ui.dialoge.Dialog;
import velamentum.ui.dialoge.EntscheidungsDialog;
import velamentum.werkzeuge.Zufallsgenerator;
public class SchereSteinPapier {
public static void main(String[] args) {
Dialog dialog = new Dialog("Schere, Stein, Papier", "Willkommen zum Spiel!");
dialog.zeige();
EntscheidungsDialog eDialog = new EntscheidungsDialog("Schere, Stein, Papier", "Bitte wählen Sie ihren Gegenstand");
eDialog.setzeText1("Schere");
eDialog.setzeText2("Stein");
eDialog.setzeText3("Papier");
eDialog.setzeDreiTasten(true);
eDialog.zeige();
System.out.println(eDialog.nenneErgebnis());
Zufallsgenerator zufall = new Zufallsgenerator(1, 3);
System.out.println(zufall.nenneErgebnis());
if(zufall.nenneErgebnis() == 1) {
dialog.zeigeNachricht("Ich habe Schere gewählt.");
if(eDialog.nenneErgebnis() == 1) {
dialog.zeigeNachricht("Unentschieden!");
}
else if(eDialog.nenneErgebnis() == 2) {
dialog.zeigeNachricht("Du hast gewonnen!");
}
else {
dialog.zeigeNachricht("Ich habe gewonnen!");
}
}
else if(zufall.nenneErgebnis() == 2) {
dialog.zeigeNachricht("Ich habe Stein gewählt.");
if(eDialog.nenneErgebnis() == 2) {
dialog.zeigeNachricht("Unentschieden!");
}
else if(eDialog.nenneErgebnis() == 1) {
dialog.zeigeNachricht("Ich habe gewonnen!");
}
else {
dialog.zeigeNachricht("Du hast gewonnen!");
}
}
else{
dialog.zeigeNachricht("Ich habe Papier gewählt.");
if(eDialog.nenneErgebnis() == 3) {
dialog.zeigeNachricht("Unentschieden!");
}
else if(eDialog.nenneErgebnis() == 2) {
dialog.zeigeNachricht("Ich habe gewonnen!");
}
else {
dialog.zeigeNachricht("Du hast gewonnen!");
}
}
}
}

49
src/Examples/SteinScherePapier/SteinScherePapier.py
View File

@ -1,49 +0,0 @@
# -*- 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!")

80
src/Examples/SuS/Schlauheitstest/Schlauheitstest.py
View File

@ -1,80 +0,0 @@
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()

36
src/Examples/Zahlenraten/Zahlenraten.py
View File

@ -1,36 +0,0 @@
# -*- 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))

0
src/desktop/__init__.py
View File

22
src/desktop/alle.py
View File

@ -1,22 +0,0 @@
#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

71
src/desktop/dateien/Datei.py
View File

@ -1,71 +0,0 @@
# -*- 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.")

104
src/desktop/dateien/DateiSystemElement.py
View File

@ -1,104 +0,0 @@
# -*- 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.")

29
src/desktop/dateien/Verzeichnis.py
View File

@ -1,29 +0,0 @@
# -*- 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

0
src/desktop/dateien/__init__.py
View File

1
src/desktop/desktop.py
View File

@ -1 +0,0 @@
from tkinter import *

178
src/desktop/multimedia/AudioPlayer.py
View File

@ -1,178 +0,0 @@
# -*- coding: utf-8 -*-
import time
import random
import velamentum.dateien.Datei
from velamentum.multimedia.Player import Player
from velamentum.android import *
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():
androide.mediaPlay(self.datei.nennePfad(), self._id,
pSofortWiedergeben)
self.dauer = int(androide.mediaPlayInfo(self._id)[1]["duration"])
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 ---
"""
androide.mediaPlayClose(self._id)
def nenneDauer(self):
"""Anfrage. Gibt die Gesamtdauer der Datei zurück.
Parameter:
--- keine ---
Rückgabe (Zahl): Gesamtdauer der Datei in Millisekunden.
"""
return self.dauer
def nennePosition(self):
"""Anfrage. Gibt die aktuelle Position der Wiedergabe zurück.
Parameter:
--- keine ---
Rückgabe (Zahl): Aktuelle Position der Wiedergabe in Millisekunden.
"""
return int(androide.mediaPlayInfo(self._id)[1]["position"])
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
androide.mediaPlaySeek(pPosition, self._id)
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.
"""
Player.setzeDatei(self, pDatei)
if pDatei.istVorhanden():
androide.mediaPlay(self.datei.nennePfad(), self._id, False)
self.dauer = int(androide.mediaPlayInfo(self._id)[1]["duration"])
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 androide.mediaPlayInfo(self._id)[1]["looping"]
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?
"""
return androide.mediaPlaySetLooping(self._id, pWiederholen)
def gibtWieder(self):
"""Anfrage. Gibt an, ob die Datei gerade wiedergegeben wird.
Parameter:
--- keine ---
Rückgabe (Wahrheitswert): True falls gerade eine Wiedergabe läuft,
False sonst.
"""
return androide.mediaIsPlaying(self._id)["result"]
def wiedergeben(self):
"""Auftrag. Startet die Wiedergabe der Multimediadaten.
Parameter
--- keine ---
"""
androide.mediaPlayStart(self._id)
def pausieren(self):
"""Auftrag. Pausiert die Wiedergabe der Multimediadaten. Die Wiedergabe
kann mit 'wiedergeben' fortgesetzt werden.
Parameter
--- keine ---
"""
androide.mediaPlayPause(self._id)
def stoppen(self):
"""Auftrag. Stoppt die Wiedergabe der Multimediadaten. (Wie 'pausieren',
Wiedergabe kann jedoch nicht fortgesetzt werden, sondern beginnt dann
von vorne.
Parameter
--- keine ---
"""
androide.mediaPlayPause(self._id)
self.setzePosition(0)
# 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.")

58
src/desktop/multimedia/AudioRecorder.py
View File

@ -1,58 +0,0 @@
# -*- coding: utf-8 -*-
import velamentum.dateien.Datei
from velamentum.multimedia.Recorder import Recorder
from velamentum.ui.dialoge.Dialog import Dialog
from velamentum.android import *
class AudioRecorder(Recorder):
"""Die Klasse AudioRecorder dient der Aufnahme von Tondaten in eine Datei.
Attribute:
--- von 'Recorder' geerbte ---
"""
def __init__(self, pDatei=velamentum.dateien.Datei.Datei("/sdcard/aufnahme.m4a")):
"""Konstruktor. Initialisiert den AudioRecorder.
Parameter:
[optional] datei (Datei): Datei, in der die Aufnahme gespeichert
werden soll [Standardwert: Datei mit Pfad '/scard/aufnahme.m4a'].
"""
Recorder.__init__(self, pDatei)
def aufnehmen(self):
"""Auftrag. Startet die Aufnahme der Multimediadaten.
HINWEIS: Die angegebene Datei wird überschrieben.
Parameter
--- keine ---
"""
Recorder.aufnehmen(self)
androide.recorderStartMicrophone(self.datei.nennePfad())
def stoppen(self):
"""Auftrag. Stoppt die Aufnahme der Multimediadaten.
Parameter
--- keine ---
"""
Recorder.stoppen(self)
androide.recorderStop()
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 ---
"""
self.aufnehmen()
dialog = Dialog("Audioaufnahme", "Aufnahme gestartet. Zum Beenden" \
"'Ok' drücken.")
dialog.zeige()
self.stoppen()

51
src/desktop/multimedia/BildRecorder.py
View File

@ -1,51 +0,0 @@
# -*- coding: utf-8 -*-
import velamentum.dateien.Datei
from velamentum.multimedia.Recorder import Recorder
from velamentum.android import *
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 ---
"""
androide.cameraCapturePicture(self.datei.nennePfad())
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 ---
"""
androide.cameraInteractiveCapturePicture(self.datei.nennePfad())

91
src/desktop/multimedia/JNIAudioRecorder.py
View File

@ -1,91 +0,0 @@
# -*- coding: utf-8 -*-
import velamentum.dateien.Datei
from velamentum.multimedia.Recorder import Recorder
from velamentum.ui.dialoge.Dialog import Dialog
from jnius import autoclass
from velamentum.android import *
class JNIAudioRecorder(Recorder):
"""Die Klasse AudioRecorder dient der Aufnahme von Tondaten in eine Datei.
BUG: Die Nutzung aus der QPython-Konsole funktioniert derzeit nicht.
Der Aufruf aus einer Skriptdatei funktioniert hingegen problemlos.
Attribute:
--- von 'Recorder' geerbte ---
"""
def __init__(self, pDatei=velamentum.dateien.Datei.Datei("/sdcard/aufnahme.m4a")):
"""Konstruktor. Initialisiert den JNIAudioRecorder.
Parameter:
[optional] pDatei (Datei): Datei, in der die Aufnahme gespeichert
werden soll [Standardwert: Datei mit Pfad
'/sdcard/aufnahme.m4a'].
"""
Recorder.__init__(self, pDatei)
# Recorder initialisieren
MediaRecorder = autoclass('android.media.MediaRecorder')
AudioSource = autoclass('android.media.MediaRecorder$AudioSource')
OutputFormat = autoclass('android.media.MediaRecorder$OutputFormat')
AudioEncoder = autoclass('android.media.MediaRecorder$AudioEncoder')
self.__mRecorder = MediaRecorder()
self.__mRecorder.setOutputFile(pDatei.nennePfad()) # Pfad der Datei
self.__mRecorder.setAudioSource(AudioSource.MIC) # Aufnahme vom Mikrofon
self.__mRecorder.setAudioChannels(1) # Mono
self.__mRecorder.setAudioEncodingBitRate(131072) # 128 kbps
self.__mRecorder.setAudioSamplingRate(48000) # 48 kHz
# ACHTUNG: Reihenfolge ist relevant! Erst Format, dann Encoder!
self.__mRecorder.setOutputFormat(OutputFormat.MPEG_4) # MP4-Container
self.__mRecorder.setAudioEncoder(AudioEncoder.AAC) # AAC-Format
def __del__(self):
"""Destruktor. Notwendig zur Freigabe des MediaRecorders beim Löschen
des Python-Objekts.
Parameter:
--- keine ---
"""
self.__mRecorder.release()
def aufnehmen(self):
"""Auftrag. Startet die Aufnahme der Multimediadaten.
HINWEIS: Die angegebene Datei wird überschrieben.
Parameter
--- keine ---
"""
Recorder.aufnehmen(self)
self.__mRecorder.setOutputFile(self.datei.nennePfad())
self.__mRecorder.prepare()
self.__mRecorder.start()
def stoppen(self):
"""Auftrag. Stoppt die Aufnahme der Multimediadaten.
Parameter
--- keine ---
"""
Recorder.stoppen(self)
self.__mRecorder.stop()
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 ---
"""
self.aufnehmen()
dialog = Dialog("Audioaufnahme", "Aufnahme gestartet. Zum Beenden" \
"'Ok' drücken.")
dialog.zeige()
self.stoppen()

144
src/desktop/multimedia/Player.py
View File

@ -1,144 +0,0 @@
# -*- coding: utf-8 -*-
import time
import velamentum.dateien.Datei
from velamentum.android import *
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 gibtWieder(self):
"""Anfrage. Gibt an, ob die Datei gerade wiedergegeben wird.
Parameter:
--- keine ---
Rückgabe (Wahrheitswert): True falls gerade eine Wiedergabe läuft,
False sonst.
"""
return False
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.")

96
src/desktop/multimedia/Recorder.py
View File

@ -1,96 +0,0 @@
# -*- coding: utf-8 -*-
import time
import velamentum.dateien.Datei
from velamentum.android import *
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("/sdcard/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

53
src/desktop/multimedia/VideoRecorder.py
View File

@ -1,53 +0,0 @@
# -*- coding: utf-8 -*-
import velamentum.dateien.Datei
from velamentum.multimedia.Recorder import Recorder
from velamentum.android import *
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("/sdcard/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)
def aufnehmen(self):
"""Auftrag. Startet die Aufnahme der Multimediadaten.
HINWEIS: Die angegebene Datei wird überschrieben.
Parameter
--- keine ---
"""
Recorder.aufnehmen(self)
androide.recorderCaptureVideo(self.datei.nennePfad())
def stoppen(self):
"""Auftrag. Stoppt die Aufnahme der Multimediadaten.
Parameter
--- keine ---
"""
Recorder.stoppen(self)
androide.recorderStop()
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 ---
"""
androide.startInteractiveVideoRecording(self.datei.nennePfad())

0
src/desktop/multimedia/__init__.py
View File

0
src/desktop/sensoren/__init__.py
View File

BIN
src/desktop/signale/AudioSignal.mp3
View File

Binary file not shown.

60
src/desktop/signale/AudioSignal.py
View File

@ -1,60 +0,0 @@
# -*- 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.")

22
src/desktop/signale/Signal.py
View File

@ -1,22 +0,0 @@
# -*- coding: utf-8 -*-
from velamentum.android import *
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

45
src/desktop/signale/TextSignal.py
View File

@ -1,45 +0,0 @@
# -*- coding: utf-8 -*-
from velamentum.signale.Signal import Signal
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 ---
"""
androide.makeToast(self.text)

45
src/desktop/signale/VibrationsSignal.py
View File

@ -1,45 +0,0 @@
# -*- coding: utf-8 -*-
from velamentum.signale.Signal import Signal
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 ---
"""
androide.vibrate(self.dauer)

0
src/desktop/signale/__init__.py
View File

55
src/desktop/sprache/Sprachausgabe.py
View File

@ -1,55 +0,0 @@
# -*- coding: utf-8 -*-
from velamentum.android import *
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 androide.ttsIsSpeaking().result
def sprechen(self):
"""Auftrag. Wandelt den Text in Sprache um und gibt ihn über die
Lautsprecher aus.
Parameter:
--- keine ---
"""
androide.ttsSpeak(self.text)

39
src/desktop/sprache/Spracheingabe.py
View File

@ -1,39 +0,0 @@
# -*- coding: utf-8 -*-
from velamentum.android import *
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 = androide.recognizeSpeech("Bitte sprechen!","de-DE",
"free_form").result

0
src/desktop/sprache/__init__.py
View File

0
src/desktop/ui/__init__.py
View File

90
src/desktop/ui/dialoge/Dialog.py
View File

@ -1,90 +0,0 @@
# -*- coding: utf-8 -*-
from velamentum.desktop import *
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 ---
"""
desk = Tk()
#desk.geometry("400x200")
desk.title(self.titel)
txtLable = Label(desk, text=self.nachricht)
okBtn = Button(desk, text='Ok', command=desk.quit)
txtLable.pack()
okBtn.pack()
desk.mainloop()
desk.destroy()
#androide.dialogCreateAlert(self.titel, self.nachricht)
#androide.dialogSetPositiveButtonText('Ok')
#androide.dialogShow()
#androide.dialogGetResponse()

115
src/desktop/ui/dialoge/EingabeDialog.py
View File

@ -1,115 +0,0 @@
# -*- coding: utf-8 -*-
from velamentum.ui.dialoge.Dialog import Dialog
from velamentum.desktop import *
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 setzeErgebnis(self,feld):
self.__ergebnis = feld.get()
def zeige(self):
"""Auftrag. Zeigt den EingabeDialog an und speichert die eingegebene
Zeichenkette im Attribut 'ergebnis'.
Parameter:
--- keine ---
"""
desk = Tk()
#desk.geometry("400x200")
desk.title(self.titel)
txtLable = Label(desk, text=self.nachricht)
eingabefeld = Entry(desk, bd=5, width=40)
okBtn = Button(desk, text='Ok', command=lambda:[self.setzeErgebnis(eingabefeld),desk.quit()])
txtLable.pack()
eingabefeld.pack()
okBtn.pack()
desk.mainloop()
desk.destroy()
ergebnis = property(nenneErgebnis, doc="Die Eingabe des Benutzers.")

164
src/desktop/ui/dialoge/EntscheidungsDialog.py
View File

@ -1,164 +0,0 @@
# -*- coding: utf-8 -*-
from velamentum.ui.dialoge.Dialog import Dialog
from velamentum.desktop import *
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 setzeErgebnisA(self):
"""Auftrag. Ändert das Ergebnis für entsprechenden Button
"""
self.ergebnis = 1
def setzeErgebnisB(self):
"""Auftrag. Ändert das Ergebnis für entsprechenden Button
"""
self.ergebnis = 2
def setzeErgebnisC(self):
"""Auftrag. Ändert das Ergebnis für entsprechenden Button
"""
self.ergebnis = 3
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 ---
"""
desk = Tk()
#desk.geometry("400x200")
desk.title(self.titel)
txtLable = Label(desk, text=self.nachricht)
btn1 = Button(desk, text=self.text1, command=lambda:[self.setzeErgebnisA(),desk.quit()])
btn2 = Button(desk, text=self.text2, command=lambda:[self.setzeErgebnisB(),desk.quit()])
txtLable.grid(row=0,column=0,columnspan=3,pady=5)
btn1.grid(row=1,column=0,padx=4)
btn2.grid(row=1,column=1,padx=4)
if self.dreiTasten:
btn3 = Button(desk, text=self.text3, command=lambda:[self.setzeErgebnisC(),desk.quit()])
btn3.grid(row=1,column=2,padx=4)
desk.mainloop()
desk.destroy()

52
src/desktop/ui/dialoge/PasswortDialog.py
View File

@ -1,52 +0,0 @@
# -*- coding: utf-8 -*-
from velamentum.ui.dialoge.EingabeDialog import EingabeDialog
from velamentum.desktop import *
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 setzeErgebnis(self,feld):
self.__ergebnis = feld.get()
def zeige(self):
"""Auftrag. Zeigt den PasswortDialog an und speichert die eingegebene
Zeichenkette im Attribut 'ergebnis'.
Parameter:
--- keine ---
"""
desk = Tk()
#desk.geometry("400x200")
desk.title(self.titel)
txtLable = Label(desk, text=self.nachricht)
eingabefeld = Entry(desk, bd=5, width=40, show='*')
okBtn = Button(desk, text='Ok', command=lambda:[self.setzeErgebnis(eingabefeld),desk.quit()])
txtLable.pack()
eingabefeld.pack()
okBtn.pack()
desk.mainloop()
desk.destroy()

0
src/desktop/ui/dialoge/__init__.py
View File

14
src/desktop/werkzeuge/System.py
View File

@ -1,14 +0,0 @@
# -*- coding: utf-8 -*-
import velamentum.dateien.Datei
from velamentum.android import *
class System(object):
"""Die Klasse System dient dem Zugriff auf bestimmte Funktionen des Systems.
Attribute:
--- keine ---
"""
@staticmethod
def oeffneDatei(pDatei):
androide.view("file://" + pDatei.nennePfad())

86
src/desktop/werkzeuge/Zufallsgenerator.py
View File

@ -1,86 +0,0 @@
# -*- 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)

43
src/desktop/werkzeuge/Zwischenablage.py
View File

@ -1,43 +0,0 @@
# -*- coding: utf-8 -*-
from velamentum.android import *
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 androide.getClipboard()
@staticmethod
def setzeText(self, pText):
"""Auftrag. Schreibt den Text in die Zwischenablage.
Parameter
pText (Zeichenkette): Der Text, der in die Zwischenablage
geschrieben werden soll.
"""
androide.setClipboard(pText)
# Attribute (verdeckte Getter und Setter)
text = property (nenneText, setzeText, doc="Der Text in der" \
"Zwischenablage des Systems.")

0
src/desktop/werkzeuge/__init__.py
View File

0
src/iOS/__init__.py
View File

22
src/iOS/alle.py
View File

@ -1,22 +0,0 @@
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

71
src/iOS/dateien/Datei.py
View File

@ -1,71 +0,0 @@
# -*- 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.")

104
src/iOS/dateien/DateiSystemElement.py
View File

@ -1,104 +0,0 @@
# -*- 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.")

29
src/iOS/dateien/Verzeichnis.py
View File

@ -1,29 +0,0 @@
# -*- 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

0
src/iOS/dateien/__init__.py
View File

166
src/iOS/multimedia/AudioPlayer.py
View File

@ -1,166 +0,0 @@
# -*- 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.")

21
src/iOS/multimedia/AudioRecorder.py
View File

@ -1,21 +0,0 @@
# -*- 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.')

52
src/iOS/multimedia/BildRecorder.py
View File

@ -1,52 +0,0 @@
# -*- 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)

132
src/iOS/multimedia/Player.py
View File

@ -1,132 +0,0 @@
# -*- 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.")

95
src/iOS/multimedia/Recorder.py
View File

@ -1,95 +0,0 @@
# -*- 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

21
src/iOS/multimedia/VideoRecorder.py
View File

@ -1,21 +0,0 @@
# -*- 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.')

0
src/iOS/multimedia/__init__.py
View File

Some files were not shown because too many files have changed in this diff Show More