In meinem Programm habe ich einige edittext Felder. Die Eingaben sollen auf ihre Gültigkeit geprüft (Länge, Typ 'String' oder Typ 'numerisch', Eingabe schon vorhanden, ....) werden.
Ich habe die Eingabenprüfung bis jetzt in den edittext_callbacks untergebracht. Das bedeutet, sobald ich das jeweilige edittext Feld verlasse, wird die Callbackfunktion ausgelöst und eine etwaig ungültige Eingabe gemeldet.
Wenn ich jedoch direkt nach der Eingabe in ein edittext Feld auf den "Weiter" Button klicke, wird zusätzlich zu der jeweiligen edittext_callback Funktion die buttondownfcn ausgelöst. Das möchte ich verhindern, da die buttondownfcn nun mit einer ungültigen Eingabe weitermacht.
Eine Möglichkeit wäre, die Gültigkeitsprüfung aller edittext Felder in die buttondownfcn zu verschieben. Das Problem dabei ist jedoch, dass ich dann die ungültige Eingabe erst beim Verlassen des Fensters gemeldet bekomme.
Man könnte die Gültigkeitsprüfung auch in beiden Funtionen (edittext_callback & buttondownfcn) vorsehen; Da dadurch daber die Prüfung doppelt vorhanden wäre, möchte ich dies vermeiden.
Danke für Deinen Vorschlag.
Wenn ich einen flag benutzen würde, müsste ich diesen in der button_callback setzen. Also nach den Eingaben in den edittext Feldern und dem Drücken des Buttons, prüfen ob die Eingaben stimmen.
Somit erfahre ich erst beim Verlassen des Fensters ob die Eingaben ok sind.
Oder: Ich erweitere die edittext_callback Funktionen derart, dass sie mir den besagten flag setzen und führe diese in der button_callback aus.
Code:
function flag = stpktname_edit_Callback(hObject, eventdata, handles) if "ungültig"
flag = 0;
end ....
function Weiter_button_Callback(hObject, eventdata, handles) if ~stpktname_edit_Callback(handles.stpktname_edit, eventdata, handles) return end ....
.....
Die Lösung mit den erweiterten edittext_callbacks ist auch nicht ideal.
Wann immer der button gedrückt wird, löst der jeweilige edittext_callback zweimal aus (einmal als echter edittext_callback und ein zweites mal durch den Aufruf im button_callback).
das Betätigen des Weiter_Buttons verhindern
- im stpktname_edit_Callback die aktuelle Eingabe prüfen
- und wenn die gültig ist, eine allgemeine "sind alle Eingaben da"-Abfrage starten
- die dann im positiven Fall ein
Ich versuche mein Problem etwas genauer zu beschreiben:
Anm.: Es existieren mehrere edittext Felder, von denen aber nicht alle editiert werden müssen. Bei den Feldern die optional sind, erfolgt nur eine Längenprüfung des eingegeben String´s (z.B. max 30 Zeichen).
Beispiel für ein Pflichtfeld:
Code:
function Projektname_edit_Callback( hObject, eventdata, handles)
ifisempty(strtrim(get( hObject, 'String')))% Projektname muss editiert werden!! errordlg( 'Bitte vergeben Sie einen Projektnamen','kein Projektname') return elseifsum(strcmpi( Projekte(:,5), strtrim(get( hObject, 'String')))) ~= 0% Projektname bereits vorhanden? errordlg({'Der Projektname ist bereits vergeben.'; 'Bitte geben Sie einen anderen Namen an.'} , 'Projektname bereits vorhanden') set( hObject, 'String' , '');
return elseif ~checkinput( hObject, 'string', 30, 'Projektname')% Eingabe zu lang? set( hObject, 'String' , '');
return end
Wenn hier eine Eingabe erfolgt, wird geprüft ob diese nicht größer 35 Zeichen ist. Wenn nichts drin steht, macht das nichts.
Das Problem ist dabei ist, dass, wenn ich direkt nach dem Editieren eines edittext Feldes auf den Weiter_button drücke, zwar die jeweilige edittext_callback Funktionen ausgeführt wird, aber leider auch die Weiter_button_callback Funktion, die das aktuelle Fenster schließt und das nächste öffnet. Ich habe somit keine Möglichkeit die fehlerhafte oder fehlende Eingabe zu korrigieren.
die Pflichtfelder beherrschen, aber wenn ich ein Nicht- Pflichtfeld erst gar nicht "berühre" und damit auch den Callback nicht auslöse wird der Button nicht mehr auf 'on' gestellt.
Wenn man jetzt die Nicht- Pflichtfelder aus der set 'off'/ 'on'- Geschichte raushält, und man editiert sie doch, stehe ich wieder am Beginn meines Dilemmas.
Ich das Problem jetzt so gelöst:
Code:
function flag = Projektname_edit_Callback( hObject, eventdata, handles)
ifisempty(strtrim(get( hObject, 'String')))% Projektname muss editiert werden!! errordlg( 'Bitte vergeben Sie einen Projektnamen','kein Projektname','on')
flag1 = 0;
else
flag1 = 1;
end
ifsum(strcmpi( Projekte(:,5), strtrim(get( hObject, 'String')))) ~= 0% Projektname bereits vorhanden? errordlg({'Der Projektname ist bereits vergeben.'; 'Bitte geben Sie einen anderen Namen an.'} , 'Projektname bereits vorhanden', 'on') set( hObject, 'String' , '');
flag2 = 0;
else
flag2 = 1;
end
if ~checkinput( hObject, 'string', 30, 'Projektname')% Eingabe zu lang? set( hObject, 'String' , '');
flag3 = 0;
else
flag3 = 1;
end
if flag1 == 0|| flag2 == 0 || flag3 == 0
flag = 0;
else
flag = 1;
end
function flag = Kommentar_edit_Callback( hObject, eventdata, handles)
if ~checkinput( hObject, 'string', 35, 'Kommentar')% Eingabe zu lang? set( hObject, 'String' , '');
flag = 0;
else
flag = 1;
end
function Weiter_button_Callback( hObject, eventdata, handles)
100%ig schön ist das zwar auch noch nicht, da beim Klick auf den Weiter_button zweimal dasselbe geprüft wird (einmal klassisch durch den edittext_callback und einmal durch den nochmaligen Aufruf im Weiter_button_Callback).
Durch
dann mach es so, dass du in der Button-Callback die Eingaben prüfst, und im Errordlg angibst welches EditFeld fehlerhaft ist und danach springst du mit einem RETURN (im Fall das eine fehlerhafte Eingabe vorliegt) aus der Callback wieder raus und kannst editieren ohne das die Callback vollständig ausgeführt wird.
Gruß
Alex
PS: Generell werden Fehlerüberprüfungen im positiven Fall mit RETURN abgeschlossen, um das Ausführen der Funktion im Fehlerfall zu verhindern _________________
Ich weiß schon; Die Sache ist schon etwas spitzfindig.
Mir ist schon bewusst, dass sich diese Gültigkeitsprüfung leicht umsetzen lässt. Die Frage ist nur wie, und ich hätte es gerne elegant.
+ Wenn man die Prüfung so umsetzt wie Du in Deinem letztem Beitrag gemeint hast, wird ERST NACH dem Drücken des Weiter_button geprüft und nicht wie gewünscht AUCH SOFORT nach Verlassen des edittext Feldes.
+ Wird im edittext_callback geprüft, erfolgt KEINE Prüfung beim Button_callback.
+ Prüft man im edittext_callback UND im Button_callback habe ich redundanten Codeteile.
Meine Lösung ist nun:
- Prüfe in Button_callback und in den edittext_callback´s
- Um Redundanzen zu vermeiden ändere ich die edittext_callback´s derart, so dass sie im Button_callback nochmalig aufrufen werden können. Im Button_callback wird dann je nach Prüfungsergebnis ( 0 oder 1) mit
Ich komme da dann nochmal auf meinen Vorschlag mit den flags zurück:
In den optionalen Feldern ist der Flag standardmäßig auf eins gesetzt und wird in der Callback auf je nach dem ob ordnungsgemäß editiert wurde auf 0 gestetzt und eine Fehlermeldung ausgegeben oder nicht.
In den Pflichtfeldern ist der Flag by default 0 und wird erst nach erfolgreichem Schreiben auf 1 gesetzt.
In der Button-Callback wird dann der Flag-Status überprüft und bei 0 wird mit RETURN abgebrochen.
Vorteil: Wenn du aus einem Edit-Feld heraus gleich auf den Button klickst wird erst die Edit-Callback ausgeführt (sollte zumindest so sein) und danach dann die Button-Callback. Wenn jetzt in der Edit-Callback ein Fehler festgestellt wird, dann wird der Flag auf 0 gesetzt. Anschließend überprüft die ButtonCallback den Flag, stellt fest das der 0 ist und bricht ab.
Ich hoffe das ist verständlich (und funktioniert auch so).
Du kannst Beiträge in dieses Forum schreiben. Du kannst auf Beiträge in diesem Forum antworten. Du kannst deine Beiträge in diesem Forum nicht bearbeiten. Du kannst deine Beiträge in diesem Forum nicht löschen. Du kannst an Umfragen in diesem Forum nicht mitmachen. Du kannst Dateien in diesem Forum posten Du kannst Dateien in diesem Forum herunterladen
MATLAB, Simulink, Stateflow, Handle Graphics, Real-Time Workshop, SimBiology, SimHydraulics, SimEvents, and xPC TargetBox are registered trademarks and The MathWorks, the L-shaped membrane logo, and Embedded MATLAB are trademarks of The MathWorks, Inc.
RSS