##########################################################################
# UMWANDLUNG #
##########################################################################
# Wandelt Zahlenwerte (Integer) in das Format tt:hh:mm:ss um #
# tt=Tage, hh=Stunden, mm=Minuten und ss=Sekunden #
# #
# Aufruf = Umwandlung Zeit%,Typ%,Ausgabe% #
# #
# Dabei kann man dieser Prozedur verschiedene Zeitformate übergeben #
# Typ 1 = Sekunden #
# Typ 2 = Minuten #
# Typ 3 = Stunden #
# Typ 4 = Tage #
# Beispiel: Umwandlung 187458,1,1 gibt 02:04:04:18 zurück (tt:hh:mm:ss) #
# Umwandlung 2844,2,1 gibt 01:23:24:00 zurück (tt:hh:mm:ss) #
# #
# #
# Auch das Ausgabeformat kann bestimmt werden #
# Ausgabe 1 = tt:hh:mm:ss #
# Ausgabe 2 = hh:mm:ss #
# Ausgabe 3 = mm:ss #
# Ausgabe 4 = ss #
# Beispiel: Umwandlung 187458,1,2 gibt 52:04:18 zurück (hh:mm:ss) #
# Umwandlung 187458,1,3 gibt 3124:18 zurück (mm:ss) #
##########################################################################
Proc Umwandlung
Parameters Zeit%,Typ%,Ausgabe%
Declare Sek%,Std%,Min%,Tag%,Sek$,Std$,Min$,Tag$,ToSub%,Return$
Case equ(Zeit%,0):Return 00:00:00:00
Case equ(Typ%,0):Return 00:00:00:00
Case gt(Typ%,4):Return 00:00:00:00
Case equ(Ausgabe%,0):Let Ausgabe%=1
Case gt(Ausgabe%,4):Let Ausgabe%=1
if equ(Typ%,1)
Let Sek%=Zeit%
elseif equ(Typ%,2)
Let Sek%=mul(Zeit%,60)
elseif equ(Typ%,3)
Let Sek%=mul(Zeit%,3600)
elseif equ(Typ%,4)
Let Sek%=mul(Zeit%,86400)
endif
Case equ(Ausgabe%,4):Return Str$(Sek%)
Let Tag%=Div(Sek%,86400)
Let Tag$=@Str$(Tag%)
Case lt(@Len(Tag$),2):Let Tag$=add$(0,Tag$)
Let ToSub%=mul(Tag%,86400)
Let Sek%=Sub(Sek%,ToSub%)
Let Std%=Div(Sek%,3600)
Let Std$=@Str$(Std%)
Case lt(@len(Std$),2):Let Std$=add$(0,Std$)
Let ToSub%=mul(Std%,3600)
Let Sek%=Sub(Sek%,ToSub%)
Let Min%=Div(Sek%,60)
Let Min$=@Str$(Min%)
Case lt(@len(Min$),2):Let Min$=add$(0,Min$)
Let ToSub%=mul(Min%,60)
Let Sek%=Sub(Sek%,ToSub%)
Let Sek$=@Str$(Sek%)
Case lt(@len(Sek$),2):Let Sek$=add$(0,Sek$)
if equ(Ausgabe%,1)
Return add$(add$(add$(add$(add$(add$(tag$,:),std$),:),min$),:),sek$)
elseif equ(Ausgabe%,2)
Let Std%=add(mul(Tag%,24),Std%)
Let Std$=Str$(Std%)
Case lt(@len(Std$),2):Let Std$=add$(0,Std$)
Return add$(add$(add$(add$(std$,:),min$),:),sek$)
elseif equ(Ausgabe%,3)
Let Std%=add(mul(Tag%,24),Std%)
Let Min%=add(mul(Std%,60),Min%)
Let Min$=str$(Min%)
Case lt(@len(min$),2):Let min$=add$(0,Min$)
Return add$(add$(Min$,:),Sek$)
endif
EndProc
################################################################
# ZeitToDec #
################################################################
# Wandelt Strings im Format XX:YY in Dezimalwerte um #
# #
# Aufruf = ZeitToDec Zeit$,Typ% #
# Beispiel: ZeitToDec 16:45,1 gibt 16,75 zurück #
# #
# Auch das Ausgabeformat kann bestimmt werden #
# Typ 1 = String #
# Typ 2 = Float #
# Beispiel: ZeitToDec 16:45,1 gibt den String 16,75 zurück #
# ZeitToDec 16:45,2 gibt den Float 16.75 zurück #
# #
################## ! ! ! A C H T U N G ! ! ! #################
# #
# Beachte, dass man beim Aufruf dieser Prozedur, je nach Typ #
# einen anderen Return-Wert zurück bekommt. #
# Bei Typ 1 = @$(0) bei Typ 2 = @!(0) #
################################################################
Proc ZeitToDec
Parameters Zeit$,Typ%
Case lt(len(Zeit$),5):Return 00:00
Case gt(len(Zeit$),5):Return 00:00
Case lt(Typ%,1):Let Typ%=1
Case gt(Typ%,2):Let Typ%=1
Declare xx%,yy%,Zentel!,Return$,Zentel$,Return!,xx$
Let xx%=@Val(left$(Zeit$,2))
Let yy%=@Val(right$(Zeit$,2))
Let Zentel!=div(yy%,0.6)
Decimals 0
Let xx$=Str$(xx%)
Let Zentel$=Str$(Zentel!)
Case lt(@len(xx$),2):Let xx$=add$(0,xx$)
Case lt(@len(Zentel$),2):Let Zentel$=add$(0,Zentel$)
Let Return$=add$(add$(xx$,,),Zentel$)
if equ(Typ%,1)
Return Return$
elseif equ(Typ%,2)
Decimals 2
Let Return$=@Translate$(Return$,,,.)
Let Return!=val(Return$)
Return Return!
endif
Decimals 6
EndProc
################################################################
# DecToZeit #
################################################################
# Wandelt Dezimalwerte (Float) in das String-Format XX:YY um. #
# #
# Aufruf = DecToZeit Zeit! #
# Beispiel: DecToZeit 16.75 gibt 16:45 zurück #
# #
################################################################
Proc DecToZeit
Parameters Zeit!
Declare GanzZahl%,Zentel!,Zentel%,GanzZahl$,Zentel$
Let GanzZahl%=Zeit!
Let Zentel!=sub(Zeit!,GanzZahl%)
Let Zentel!=mul(Zentel!,60)
Let Zentel%=Zentel!
Let GanzZahl$=@Str$(GanzZahl%)
Let Zentel$=@Str$(Zentel%)
Case lt(@len(GanzZahl$),2):Let GanzZahl$=add$(0,GanzZahl$)
Case lt(@len(Zentel$),2):Let Zentel$=add$(0,Zentel$)
Return add$(add$(GanzZahl$,:),Zentel$)
EndProc
################################################################
# AddSubZeit #
################################################################
# Berechnet die Addition oder Subtraktion von zwei Zeitwerten #
# im Format hh:mm #
# #
# Aufruf = AddSubZeit Summand1$,Summand2$,Typ% #
# Beispiel: AddSubZeit 16:45,03:30,1 gibt 20:15 zurück #
# Beispiel: AddSubZeit 16:45,03:30,2 gibt 13:15 zurück #
# #
# Typ 1 = Addition ( Grundschuldeutsch: Plus nehmen ) #
# Typ 2 = Subtraktion ( Grundschuldeutsch: Minus nehmen ) #
################################################################
# Achtung: Es können auch Werte über 24:00 herauskommen #
# Siehe dazu die Prozedur AddSubUhrzeit #
################################################################
Proc AddSubZeit
Parameters Summand1$,Summand2$,Typ%
Declare Summand1!,Summand2!,Summe!
ZeitToDec Summand1$,2
Let Summand1!=@!(0)
ZeitToDec Summand2$,2
Let Summand2!=@!(0)
if equ(Typ%,1)
Let Summe!=add(Summand1!,Summand2!)
elseif equ(Typ%,2)
Let Summe!=sub(Summand1!,Summand2!)
endif
DecToZeit Summe!
Return @$(0) Cool -> Returnt den letzten Returnwert <- Wollte ich immer schon mal machen... absolut Sinnlos... ;-)
EndProc
#################################################################
# AddSubUhrzeit #
#################################################################
# Berechnet die Addition oder Subtraktion von zwei Uhrzeiten #
# im Format hh:mm #
# #
# Aufruf = AddSubUhrzeit Summand1$,Summand2$,Typ% #
# Beispiel: AddSubUhrzeit 17:30,07:45,1 gibt 01:15 zurück #
# Beispiel: AddSubUhrzeit 17:30,07:45,2 gibt 09:45 zurück #
# #
# Typ 1 = Addition ( Grundschuldeutsch: Plus nehmen ) #
# Typ 2 = Subtraktion ( Grundschuldeutsch: Minus nehmen ) #
#################################################################
Proc AddSubUhrzeit
Parameters Summand1$,Summand2$,Typ%
Declare Zeit$,Zeit!,Teiler%
AddSubZeit Summand1$,Summand2$,Typ%
Let Zeit$=@$(0)
ZeitToDec Zeit$,2
Let Zeit!=@!(0)
Let Teiler%=Div(Zeit!,24)
Let Zeit!=sub(Zeit!,mul(Teiler%,24))
DecToZeit Zeit!
EndProc
(309)
Deutsch
English
Français
Español
Italia