Sekunden, Minuten, Stunden Rechner

[FG53]

Hallo,

ich bin ein ziemlicher Anfänger und das schon seit langem :lol:.

In einem Programm das ich aktuelle versuche zu Schreiben, spreche ich mit shellexecute cmd an und brauche dafür eine sekundenangabe.
Allerdings möchte ich dem nutzer die möglichkeit geben in Sekunden, Minuten oder Stunden die Eingabe zu tätigen.
Ich habe drei edit felder in dem der Nutzer jeweils Sekunden Minuten oder Stunden eingeben kann welches dann das Programm umrechnet.

Beispiel: Nutzer gibt in edit1 '1' Stunde ein, edit2 '60' Minuten wird automatisch gerechnet und edit3 '3600' sekunden wird automatisch gerechnet.
(Was aber auch sein muss ist das wenn der nutzer '3600' Sekunden eingibt das der rechner dann die anderen 2 edit felder befüllt.)

Daraufhin möchte ich die Sekunden auslesen und in meinen anderen befehl übernehmen. (Das sollte kein Problem sein, hoffentlich :lol:)

Ich danke schomal im voraus für eure Hilfe.

LG - FG

[Rollo62]

Dafür gäbe es sowas oder das, zusätzliche Rechenlogik muss man aber noch drumbauen, mit 3600 und so.

Jedenfalls könntest Du man in den DateUtils stöbern, was da für Dich dabei ist.

[FG53]

Danke für eure Antworten, aber um die Wahrheit zu sagen habe ich habe ich bei den Links nicht richtig durchgeblickt. Währe es möglich das mir jemand bisschen unter die Arme greift mit einem Beispiel Code, denn wie gesagt ich bin nicht sehr gut. :lol:

[himitsu]

Oder ganz bling im OnExit der 3 Edits,
erstmal alles zusammenrechnen,
dann wieder "korrekt" die Stungen/Minuten/Sekunden trennen,
und das Ergebnis in die 3 Edits zurückschreiben.

OnExit statt OnChange, da bei Eingabe "falsche" Werte auftreten dürfen, damit es nicht immer sofort bei jedem Tastendruck knallt.

[jobo]

Zitat:

Zitat von Frühlingsrolle (Beitrag 1459249)

Noch besser wäre, du sorgst dafür, dass die Eingabefelder für Minuten und Sekunden den Wert 59 niemals überschreiten.

Wieso, genau das will er doch nicht! Ich glaube es geht um Anwenderkomfort, statt um Programmiererkomfort. Und selbst wenn er es wollte: Ist Software nicht dafür da, lästige Denkarbeit zu vermeiden?

Zur Aufgabe:
Sollen auch Dezimalzahlen eintragbar sein?
Eine Zahl durch 60 teilen oder mit 60 zu multiplizieren, ist aber nicht das Problem oder?
Ich meine, was würdest Du selbst machen, wenn Du eines der Felder befüllen müsstest, nachdem ein Anwender dort eine Zahl eingetragen hat.

[FG53]

Ich habe das Programmieren weder schulisch noch systematisch gelernt. Delphi war auf meinem Pc drauf und ich habe code für code gelernt wie ich es gebraucht habe. Deswegen fehlen mir viele grundliegende Sachen. Meine Wege sind meistens viel länger als sie benötigt sind. Aber was soll ich sagen meistens funktionieren sie. :lol:

Das mit dem onexit ist auch meine idee gewesen aber die brauchen ja gar nicht erst addiert und wieder getrennt zu werden. Denn es soll kein wert sein der sich aus den 3 feldern summiert sondern ein wert der in verschiedenen angeben in den 3 feldern ausgegeben wird.

[FG53]

Zitat:

Zitat von jobo (Beitrag 1459256)

Zur Aufgabe:
Sollen auch Dezimalzahlen eintragbar sein?
Eine Zahl durch 60 teilen oder mit 60 zu multiplizieren, ist aber nicht das Problem oder?
Ich meine, was würdest Du selbst machen, wenn Du eines der Felder befüllen müsstest, nachdem ein Anwender dort eine Zahl eingetragen hat.

Dezimalzahlen sind kein muss. Die meisten entragungen werden wahrscheinlich nur ganze Zahlen sein.

[Sherlock]

Die Links schießen mMn über das Ziel hinaus. Ein Beispiel aus der Realität sagt, daß ein Spielfilm 100 Minuten dauern kann. Was du brauchst ist zweierlei: ein Ereignis, daß Dir sagt, wenn die Eingabe in einem der Felder getätigt wurde, und eine Formel, die von einem der Werte in die jeweils anderen beiden umrechnet.
Ersteres macht Delphi von Haus aus und Du könntest dazu zB das TEdit.OnChange Ereignis der TEdit Felder nehmen. Beachte bitte, daß Die gleich folgende Rechnerei in die Hose geht, wenn Dein Anwender etwas anderes als Zahlen eingibt!! VCL.StdCtrls.TEdit.NumbersOnly hilft bei VCL-Anwendungen.
Die Rechnerei ist simpel, wenn Du weißt, wieviele Minuten eine Stunde hat, und wieviele Sekunden in einer Minute stecken (Spoiler: es ist beides mal die gleiche Zahl).
Lies also nach wie man einem TEdit ein OnChange Ereignis zuweist, und lies nach, wie man einem TEdit.Text einen neuen Inhalt gibt. Dann hast Du vermutlich nach etwas Denkarbeit drei Methoden und irgendwas läuft mächtig schief, weil *Trommelwirbel* OnChange ständig befeuert wird.:-D
Du mußt also wissen, welches Feld tatsächlich vom Anwender verändert wurde, und welches aus der Berechnung heraus "automatisch". Dazu kannst Du zB erkennen, in welches Feld der Anwender zur Eingabe gegangen ist, und zwar mit TEdit.OnEnter. Dann darfst Du die Felder, die nicht gerade bearbeitet werden nicht auf das OnChange reagieren lassen, und fertig.

Sherlock

[FG53]

Sherlock, ich danke dir für deine Antwort. Das hilft mir sehr weiter. Ich versuche das mal und gebe später wieder bescheid, danke nochmal.

[Rollo62]

Also ich würde schon empfehlen direkt TDateTime als Basis-Zielspeicher zu nehmen,
und dann wie himitsu vorgeschlagen hat
- die drei Edits extrahieren und mit EncodeDateTime und z.B. in MilliSeconds umrechnen,
- daraus den Zielspeicher zusammenrechnen, http://www.delphibasics.co.uk/RTL.as...IncMillisecond
- danach wieder aus dem TDateTime die berechneten Daten extrahieren mit DecodeDateTime
- die OnChange Events kurz abzuschalten,
- und die Edits mit den Ergebnissen restaurieren,
- dann die OnChange Events wieder einschalten

Der Vorteil von TDateTime wäre, das es dann auch mit Tagen, Monaten usw. klarkommen könnte,
und die ganzen Utils drumherum ziemlich robust und getestet sind.

[HolgerX]

Hmm..

Dir geht es darum, dass in den jeweiligen Edits ein beliebiger Wert für z.B. Minuten eingegeben werden kann und daraus dann ein gültiger Zeitwert errechnet wird..

Dann würde es doch so gehen:

Delphi-Quellcode:

uses
  DateUtils,...

procedure TForm1.EditHourChange(Sender: TObject);
var
  DT : TDateTime;
begin
  DT := 0;  // 00:00:00
  DT := IncHour(DT, StrToIntDef(EditHour.Text,0));
  DT := IncMinute(DT, StrToIntDef(EditMinute.Text,0));
  DT := IncSecond(DT, StrToIntDef(EditSekunde.Text,0));

  // Mach was mit dem DT
  EditTime.Text := DateTimeToStr(DT);
end;

Es können somit 3 Stunden, 157 Minuten und 2003 Sekunden eingegeben werden und Du würdest dafür den richtige Uhrzeit im TDateTime Format erhalten.

(Dazu natürlich dieses Event in jedem OnChange der 3 Edits zuweisen)

[himitsu]

Zitat:

Zitat von Sherlock (Beitrag 1459259)

und irgendwas läuft mächtig schief, weil *Trommelwirbel* OnChange ständig befeuert wird.:-D

Eigentlich nicht nötig.
Es kann an alle Edits die selbe Ereignismethode dran.
Zusammenrechnen und zerlegen ist ja überal gleicht.
(gut, wenn man was bei Minuten einträgt, dann werden die Sekunden sich nicht ändern, aber ist ja egal ob man deren Text auch nochmal zuweist)

Aber wie schon gesagt, am Besten OnExit statt OnChange.
Dann die richtigen Werte ausrechen
und einfach überall den aktuellen Wert zuweisen.

Im Setter von TEdit.Text ist bereits ein passender Code einebaut.

Delphi-Quellcode:

if Text = NewText then
  Exit;

Also wenn sich nichts ändert, dann wird nichts zugewiesen und auch kein OnChange ausgelöst.

oder wenn du es doch selber machen willst (doppelt, nochmal zur Sicherheit), dann

Delphi-Quellcode:

if Edit.Text <> NewText then
  Edit.Text := NewText;

[p80286]

Die Exe ist nett, aber er möchte wohl auch Programmieren lernen,da wären die Sourcen wohl sinnvoller.

Gruß
K-H

[Sherlock]

So unterschiedlich kann man Anforderungen interpretieren - fast wie "drei Anwälte=fünf Meinungen". :-D

Ich verstand es so, daß es ein Programm gibt, dem man eine Dauer/ein Intervall in Sekunden mitgeben kann - ich sah keine Uhrzeit im Ursprungsposting. Der Anwender soll die Wahl haben, wie er diese Zeitspanne eingeben will, dieser geplante Launcher erledigt die Umrechnung für ihn. Gibt er also 2 Stunden ein, werden die anderen Felder mit 120 Minuten bzw 7200 Sekunden befüllt. An die Anwendung wird als Parameter dann eben "7200" übergeben oder so...

@Himitsu: Oh Mann, sag mir bitte, das es das erst seit sehr kurzer Zeit gibt - meinetwegen auch nach geologischen Maßstab. :oops:

Sherlock

[Moombas]

Naja was gibts bei der Beschreibung des TE's noch groß zu interpretieren:

Zitat:

Beispiel: Nutzer gibt in edit1 '1' Stunde ein, edit2 '60' Minuten wird automatisch gerechnet und edit3 '3600' sekunden wird automatisch gerechnet.
(Was aber auch sein muss ist das wenn der nutzer '3600' Sekunden eingibt das der rechner dann die anderen 2 edit felder befüllt.)

Das dies nun nicht Sinnvoll ist (da im Prinzip der Wert von Edit1 = Edit2 = Edit3), ist eine andere Sache.

Ich gehe davon aus:
Edit1 umbenennen in StundenE , ggf. einstellen, das nur Zahlen eingegeben werden können (NumbersOnly = True)
Edit2 umbenennen in MinutenE , ggf. einstellen, das nur Zahlen eingegeben werden können (NumbersOnly = True)
Edit3 umbenennen in SekundenE, ggf. einstellen, das nur Zahlen eingegeben werden können (NumbersOnly = True)
Die Summe aller Editfelder ergibt die GESAMTZEIT, nicht wie der TE angegeben hat überall die Gleiche Zeit.
Also bei Eingabe 3600 Sekunden Stünde nur eine "1" bei Stunde, der Rest wäre 0.

Für alle die Gleiche Funktion beim OnExit hinterlegen (geht sicher auch kürzer/einfacher ist aber evtl. für einen Anfänger am leichtesten zu verstehen):

Delphi-Quellcode:

var
  iSekunden, iMinuten, iStunden : Integer;
begin
  iSekunden := 0;
  iMinuten  := 0;
  iStunden  := 0;
  case Sender.Name of
    SekundenE : iSekunden := strtoint(SekundenE.Text); //Hilfsvariable aus Editfeld füllen 
    MinutenE  : iMinuten  := strtoint(MinutenE.Text);  //Hilfsvariable aus Editfeld füllen 
    StundenE  : iStunden  := strtoint(StundenE.Text);  //Hilfsvariable aus Editfeld füllen
    else      : Exit;
  end;

  if iSekunden > 59 then //Da 60 Sekunden = 1 Minute, dies umrechnen
  begin
    iMinuten  := iMinuten + (iSekunden DIV 60); //die Minuten, die sich aus den Sekunden ergeben hinzuaddieren
    iSekunden := iSekunden MOD 60;              //die korrekten Sekunden berechnen
  end;

  if iMinuten > 59 then
  begin
    iStunden := iStunden + (iMinuten DIV 60); //die Stunden, die sich aus den Minuten ergeben hinzuaddieren
    iMinuten := iMinuten MOD 60;              //die korrekten Minuten berechnen
  end;

  SekundenE.Text := inttostr(iSekunden); //Hilfsvariablen ins Editfeld zurückspielen
  MinutenE.Text  := inttostr(iMinuten);  //Hilfsvariablen ins Editfeld zurückspielen
  StundenE.Text  := inttostr(iStunden);  //Hilfsvariablen ins Editfeld zurückspielen
  iSecGes := (strtoint(StundenE.Text) * 60 + strtoint(MinutenE.Text)) * 60 + strtoint(SekundenE.Text); //Gesamtsekunden (Globale Variable)
end;

Achtung ungetestet. Programmiert in der Theorie^^

[Sherlock]

:lol:
"Summe" ist jetzt aber neu, und eine weitere Interpretation der Anforderungsspezifikation.

Sherlock

[Moombas]

Zitat:

Zitat von Sherlock (Beitrag 1459356)

:lol:
"Summe" ist jetzt aber neu, und eine weitere Interpretation der Anforderungsspezifikation.

Sherlock

Jaein^^

Er möchte z.B. 3600 Sekunden eingeben und das entsprechend in die Editfelder umgesetzt haben.
Ein Anzeige, die quasi 3mal das Gleiche aussagt (3600 Sec. = 60 Min. = 1 Std.), macht in Anbetracht dessen, da er es in Sekunden "weitergeben" will nicht viel Sinn.

Besser ist, das der Benutzer eingibt er möchte (um beim Beispiel zu bleiben) 3600 Sekunden haben.
Diese werden dann korrekt umgerechnet und angezeigt, so das der Benutzer dann weiß, das seine 3600 Sekunden einer Stunde entsprechen.
Die Sekunden lassen sich ja dann weiterhin problemlos berechnen (s.o.).

Fraglich ist für mich nur, ob die alten Werte beibehalten werden sollen (von den nicht geänderten Feldern) oder jedesmal eine komplette neu Berechnung erfolgen soll.
Ich werde meinen Post dahingehend mal ändern, denn seine Beschreibung sagt eher eine komplette neu Berechnung aus.

[FG53]

Danke nochmal euch allen für dir Antworten. Das ding ist es soll weder eine bestimmte Uhrzeit ausgerechnet werden. Noch soll eine Zeitangabe auf 3 Edit Felder aufgeteilt werden. Die Frühlingrolle hat recht es soll für Runterfahren des Pc benutzt werden. Im CMD braucht man eine Sekunden angabe. Allerdings soll der Benutzer die Freiheit haben statt Sekunden '12' Stunden angeben zu können und ich brauche dann die Zahl in Sekunden für CMD.

Aktuell bin ich nach einer langen Programmier Pause wieder am Start und scheitere teilweise an den kleinsten dingen. Ich kriege es nicht mal mehr hin das ich ein editfeld mit 60 multipliziere und in einem anderen editfeld ausgebe. Tipps?? :lol:

[Moombas]

Zitat:

Zitat von FG53 (Beitrag 1459362)

Danke nochmal euch allen für dir Antworten. Das ding ist es soll weder eine bestimmte Uhrzeit ausgerechnet werden. Noch soll eine Zeitangabe auf 3 Edit Felder aufgeteilt werden. Die Frühlingrolle hat recht es soll für Runterfahren des Pc benutzt werden. Im CMD braucht man eine Sekunden angabe. Allerdings soll der Benutzer die Freiheit haben statt Sekunden '12' Stunden angeben zu können und ich brauche dann die Zahl in Sekunden für CMD.

Aktuell bin ich nach einer langen Programmier Pause wieder am Start und scheitere teilweise an den kleinsten dingen. Ich kriege es nicht mal mehr hin das ich ein editfeld mit 60 multipliziere und in einem anderen editfeld ausgebe. Tipps?? :lol:

Zum Editfeld rechnen:
Edit2.text := inttostr(strtoint(Edit1.text) * 60);

Zu deiner "Anforderung": Es kann dem Benutzer doch egal sein, wieviele Sekunden das nachher tatsächlich sind.
Lass ihn eine (sinnvolle) Zeitangabe machen (z.B. 12 Stunden) und es wird im Hintergrund umgerechnet und umgesetzt.

[FG53]

Daran habe ich auch gedacht Moombas allerdings wollte ich ihn auch die Freiheit geben in Minuten oder in Sekunden zu schreiben.
Mittlerweile bin ich dazu gekommen. Ich wollte zuerst mit integer arbeiten allerdings beim hochrechnen hat er dann logischerweise
immer einen Fehler gegeben. Jetzt ist der Code mit float. Allerdings gibt er mit jetzt einen Fehler wenn ich was eingebe und dann
das Feld wieder Lösche jemand ne idee. Und nebenbei ich weiß das ist nicht die eleganteste lösung aber sie macht das was ich brauche.
Nebenbei habe ich das mit der Zahl nicht hinbekommen deswegen habe ich einfach ein Label erstellt dem ich die Caption 60 gegeben habe;
Das werde ich wahrscheinlich im nachhinein einfach visible fals stellen.

Code:

procedure TForm1.Edit1Change(Sender: TObject);
begin
edit2.Text := floattostr (strtofloat(edit1.Text) * strtofloat(label7.caption));


end;

procedure TForm1.Edit2Change(Sender: TObject);
begin
edit3.Text := floattostr (strtofloat(edit2.Text) * strtofloat(label7.caption));
edit1.Text := floattostr (strtofloat(edit2.Text) / strtofloat(label7.caption));
end;

procedure TForm1.Edit3Change(Sender: TObject);
begin
edit2.Text := floattostr (strtofloat(edit3.Text) / strtofloat(label7.caption));
end;

Noch eine zusätzliche kleine Frage weiß einer wie ich das hinbekomme denn auf diese weiße funktioniert es nicht.
Der inhalt des edit Feldes wird nicht ausgelesen.

Code:

ShellExecute(0, nil, 'cmd.exe', '/k shutdown -s -f -t (edit3.text) & exit', nil, SW_SHOWNORMAL);

[Moombas]

Zitat:

Zitat von FG53 (Beitrag 1459364)

Daran habe ich auch gedacht Moombas allerdings wollte ich ihn auch die Freiheit geben in Minuten oder in Sekunden zu schreiben.

Kann er doch, es wird nur beim Verlassen des Feldes entsprechend umgerechnet.



Mach es wirklich im Onexit oder prüfe auf ein leeres Feld (dann nichts machen).

Wenn beim Onchange das Feld leer ist, kann er nichts umwandeln und läuft auf einen Fehler ('' <> 0).

Zitat:

ShellExecute(0, nil, 'cmd.exe', '/k shutdown -s -f -t ' + edit3.text + ' & exit', nil, SW_SHOWNORMAL);

[FG53]

Moombas danke wieder für deine schnelle Antwort. Allerdings kriege ich einen fehler bei deinem verbesserten Code.

Incompatible types: 'String' and 'PAnsiChar'

[himitsu]

mal ein kleiner Exkurs

Delphi-Quellcode:

// nur auftrennen
// es muß überall am Ende mindestens eine Ziffer drinstehen
// MaskEdit.EditMask = '09:009:009;1; '
i := StrToInt(Copy(MaskEdit.Text, 1, 2)) * 60 * 60
   + StrToInt(Copy(MaskEdit.Text, 4, 3)) * 60
   + StrToInt(Copy(MaskEdit.Text, 8, 3));

// und nun inkl. Fehl-/Leereingaben
// Felder können leer bleiben und Zahlen müssen nicht am Ende stehen (hier mit '0'+Trim)
// MaskEdit.EditMask = '##:###:###;1; '
i := StrToInt('0' + Trim(Copy(MaskEdit.Text, 1, 2))) * 60 * 60
   + StrToInt('0' + Trim(Copy(MaskEdit.Text, 4, 3))) * 60
   + StrToInt('0' + Trim(Copy(MaskEdit.Text, 8, 3)));

// und nochmal in "modern" ... k.A. warum es kein Append/Add gibtm für das '0'+
i := ('0' + MaskEdit.Text.Substring(0, 2).Trim).ToInteger * 60 * 60
   + ('0' + MaskEdit.Text.Substring(3, 3).Trim).ToInteger * 60
   + ('0' + MaskEdit.Text.Substring(7, 3).Trim).ToInteger;

// und wieder zusammen
MaskEdit.Text := Format('%2d:%3d:%3d', [i div 60 div 60, i div 60 mod 60, i mod 60]);

Delphi-Quellcode:

// und wieder zusammen, falls es Einzeledits waren, ohne vorher Copy/Substring
Edit1.Text := IntToStr(i div 60 div 60);
Edit2.Text := IntToStr(i div 60 mod 60);
Edit3.Text := IntToStr(i mod 60);

// lol
Edit1.Text := (i div 60 div 60).ToString;
Edit2.Text := (i div 60 mod 60).ToString;
Edit3.Text := (i mod 60).ToString;

[Moombas]

Müsste so gehen. Sry, hatte das mit dem Char vorhin vergessen^^

Zitat:

shellexecute(0, nil, 'cmd.exe', pchar('/k shutdown -s -f -t ' + edit3.text + ' & exit'), nil, sw_shownormal);

[FG53]

Danke Moombas :thumb:. Damit hab ich alles was ich brauchte danke an alle die mir dabei geholfen haben.

[himitsu]

Warum

Delphi-Quellcode:

cmd /K

und

Delphi-Quellcode:

exit

, anstatt dem richtigen

Delphi-Quellcode:

cmd /C

?

und die shutdown.exe kann man auch direkt aufrufen,
mit dem Vorteil, dass man auch dessen ExitCode (ErrorLevel) im Programm abfragen kann. (CreateProcess)

[FG53]

Das ist mir gar nicht aufgefallen danke dir Himitsu werde das korigieren.

[hoika]

Hallo,
ich würde 3 RadioButtons nehmen,
die kommen vor die 3 Edits.
Und der RadioButton, der ausgewählt ist, bestimmt den Eingabe-Editor.
Die jeweils anderen beiden Editoren werden Disabled oder ReadOnly gesetzt.

Schon spart man sich eine Menge Logik.

[Moombas]

Zitat:

Zitat von hoika (Beitrag 1459439)

Hallo,
ich würde 3 RadioButtons nehmen,
die kommen vor die 3 Edits.
Und der RadioButton, der ausgewählt ist, bestimmt den Eingabe-Editor.
Die jeweils anderen beiden Editoren werden Disabled oder ReadOnly gesetzt.

Schon spart man sich eine Menge Logik.

Dann brauchst du nur ein Edit!
Der Radiobutton bestimmt wie die Zahl interpretiert werden soll (H, M, S) und im Editfeld gibt man sie ein.
Und beim Verlassen dessen wird es entsprechend umgesetzt.
Aber (von der Nutzereingabe und GUI betrachtet) es wäre für den Benutzer ein (minimaler) Mehraufwand bei der Eingabe.
Auch wenn es nur 1 Klick mehr ist, versuche ich dem Benutzer jeden Arbeitsweg so gut wie möglich zu verkürzen/vereinfachen und die GUI so schlank wie möglich zu halten (Ja, 3 Radiobuttons (als Radiobuttongroup) + 1 Editfeld sind in der Summe in der GUI (je nach Dimensionierung und Anordnung) weniger als 3 Editfelder.).
Wobei ich immer folgendes als Leitfaden nehme: Funktion > Arbeitsschritte > GUI > kurze/einfache Programmierlogik

Und ob man sich dadurch wirklich so viel Logik spart, bin ich mir gerade nicht mal sicher.
Bei deiner Variante müsstest du (ggf.) 3 unterschiedliche Funktionen schreiben, bei der eben angesprochenen Variante nur 1, halt nur mit der Prüfung der Eingabefelder.