Delphi: Wie, um text in TEdit/TMaskEdit ohne aufrufen des onchange-Ereignis

Ich habe ein ziemlich großes setup form, die möchte ich füllen mit Daten aus einer Klasse. also mache ich eine Menge

Edt1.text := ASettings.FirstThing;

Möchte ich vermeiden

Edt1.onchange := nil;
Edt1.text := ASettings.FirstThing; 
Edt1.onchange := edt1Onchange;

Wie ändere ich den text in ein Textfeld und umgehen das onchange-Ereignis.

InformationsquelleAutor Peter Turner | 2010-01-06

delphi event-handling

11

Benutzt habe ich etwas wie die änderung der OnChange-handler, aber mehr oft, ich benutze eine Flagge.
```
updatingFromCode := true;
Edt1.Text := ASettings.FirstThing;
updatingFromCode := false;
```
dann
```
procedure TForm1.OnChange(...);
begin
  if updatingFromCode then
    Exit;
  ...
```
Auch, statt hardcoding das OnChange-die die tatsächliche OnChange-Prozedur, ich würde speichern, das Edit-Steuerelement den aktuellen Wert, dann setzen Sie es (die Arbeit, wenn es nicht gesetzt ist, oder wenn ein anderer Ort hat es geändert, etc.)
```
oldOnChange := Edt1.OnChange;
Edt1.OnChange := nil;
Edt1.Text := ASettings.FirstThing; 
Edt1.OnChange := oldOnChange;
```
Könnte man nicht auch mit der Sender-parameter? Vermutlich will er das OnChange ausgelöst, wenn jemand die Eingabe von text in das Feld selbst aber nicht, wenn das Auffüllen aus einem separaten Verfahren, wie ein auto-Auffüllen von Arten. In diesem Fall bin ich Recht in der Annahme, Sie könnten TForm1.OnChange(Sender:TObject) und dann tun, "wenn Sender as TEdit" (Zeugs) else (do nothing)"? Dann musst du nicht alle extra das setzen und löschen der Variablen in Ihrem code.
Nein. Der Absender der OnChange-Ereignis wird immer TEdit, unabhängig davon, ob der Text vom Benutzer aktualisiert oder programmably. Die VCL-nie legt die Absender-parameter auf null.

InformationsquelleAutor jasonpenny
6

Soweit ich weiß, wenn das OnChange-Ihr Objekt ist entworfen, um Feuer, wenn die Text-Eigenschaft geändert, Sie haben zu stick mit der Einstellung der Veranstaltung zu null temporär. Mir, ich mache es auf diese Weise (in einem try-finally):
```
Edt1.onchange := nil;
try
    Edt1.text := ASettings.FirstThing;
finally
    Edt1.onchange := edt1Onchange;
end;
```
Könnten Sie auch tun, einige Verfahren zu behandeln, das es für Sie:
```
procedure SetTextWithoutOnChange(anEdit: TEdit; str: String);
var
    anEvent: TNotifyEvent;
begin
    anEvent := anEdit.OnChange;
    anEdit.OnChange := nil;
    try
        anEdit.Text := str;
    finally
        anEdit.OnChange := anEvent;
    end;
end;
```
Hinzugefügt SetTextWithoutOnChange procdeure zu beantworten.
+1 für die exception-block

InformationsquelleAutor AlexV
6

Könnten Sie erwägen, ein Objekt zu verwalten, die NIL ' Ing der Veranstaltung und wiederherstellen des zuvor installierten Ereignishandler. Es ist ein wenig gefährlich, anzunehmen, dass das Ereignis wiederhergestellt werden, passiert einfach zu sein, die ihm zur design-Zeit/was haben der "name, der passt" - Sie sollten immer speichern/wiederherstellen der aktuell zugewiesenen handler, nur um sicher zu sein.

Damit würde ein noch mehr re-usable-Dienstprogramm als der SetTextWithoutOnChange () - routine:
```
  TSuspendEvent = class
  private
    fObject: TObject;
    fEvent: String;
    fHandler: TMethod;
  public
    constructor Create(const aObject: TObject; aEvent: String);
    destructor Destroy; override;
  end;

  constructor TSuspendEvent.Create(const aObject: TObject; aEvent: String);
  const
    NILEvent  : TMethod = (Code: NIL; Data: NIL);
  begin
    inherited Create;

    fObject := aObject;
    fEvent  := aEvent;

    fHandler := GetMethodProp(aObject, aEvent);

    SetMethodProp(aObject, aEvent, NILEvent);
  end;


  destructor TSuspendEvent.Destroy;
  begin
    SetMethodProp(fObject, fEvent, fHandler);

    inherited;
  end;
```
In der Nutzung, dies würde folgendermaßen Aussehen:
```
  with TSuspendEvent.Create(Edit1, 'OnChange') do
  try
    Edit1.Text := 'Reset!';
  finally
    Free;
  end;
```
Für die "Du sollst nicht verwenden 'mit' crowd" - mit allen Mitteln deklarieren sich eine weitere lokale variable, und verwenden Sie, dass, wenn es wird Ihnen helfen, besser schlafen in der Nacht. 🙂

Oder, um es noch bequemer zu bedienen und zu beseitigen "mit", würde ich das machen TSuspendEvent Klasse ein Objekt mit Referenzzählung und wickeln Ihre Verwendung in einer Funktion, ergab eine Referenz zur Benutzeroberfläche Referenz zur es konnte zugelassen werden, um "Leben in scope", wie am Beispiel von meinem AutoFree () - Implementierung. In der Tat könnte man nutzen, AutoFree () - zu verwalten, dies bereits:
```
  AutoFree(TSuspendEvent.Create(Edit1, 'OnChange'));
  Edit1.Text := 'Reset!';
```
Dsabling Ereignisse für eine Periode erstreckt sich über den Rahmen eines einzigen Verfahrens erfordert jedoch mehr Verwaltungsaufwand, als alle Helfer die Dienstprogramme sind wahrscheinlich in der Lage sein werden in einer generischen Mode, die ich denke, zumindest nicht ohne spezifische Mittel für die Wiederherstellung der Ereignisse explizit, anstatt automatisch.

Wenn Sie einfach gewickelt TSuspendEvent innen eigene Schnittstelle nachgeben Funktion, nach dem gleichen Muster wie AutoFree() könnte man vereinfachen, dieses weiter zu:
```
  SuspendEvent(Edit1, 'OnChange');
  Edit1.Text := 'Reset!';
```
Als ein letzter Hinweis, ich denke, es sollte ziemlich einfach sein, zu sehen, wie diese können Recht einfach erweitert um Unterstützung für die Aussetzung mehrerer Ereignisse auf einem Objekt in einem einzigen Aufruf, wenn erforderlich, zum Beispiel:
```
  SuspendEvent(Edit1, ['OnChange', 'OnEnter']);
```
wow, das scheint wie eine Menge Arbeit, aber wahrscheinlich lohnt es. Ich werde daran erinnern und wahrscheinlich implementieren Sie einige Tag, danke!
Es ist nicht viel Arbeit, wirklich (es dauerte etwa 3 Minuten, und "AutoFree" dauerte etwa 10 Minuten). Und das Ergebnis ist eine ersparnis, die auch in Zukunft anfallen, über die Lebensdauer der Projekte, in denen Sie dann die Ergebnisse verwenden (der code ist vollständig generisch - kleine 'g').

InformationsquelleAutor Deltics
1

Ich weiß, das ist eine alte Frage, aber ich dachte, ich möchte hinzufügen, meine Lösung ist nicht mit der komplizierten Verfahren, die in den vorherigen Antworten wenn es hoch kommt, einen anderen suchen.

Das problem ist das onChange-Ereignis selbst. Ich benutze es nicht für text-Felder.

entfernen Sie alle OnChange und verwenden Sie die OnExit statt und binden Sie es an die OnKeyUp.

Alle Änderungen haben einen gemeinsamen Vorfahren TCustomEdit.

Ich in der Regel verwenden Sie eine Methode namens CustomEditKeyUp und zeigen alle änderungen in einem Formular zu diesem einzigen Methode (TEdit, TLabeledEdit usw. usw.)
```
type THack = class(TCustomEdit);

procedure TForm1.CustomeEditKeyUP(Sender: TObject; var Key: Word;
  Shift: TShiftState);
begin
  if (Key=VK_RETURN) and (Sender is TCustomEdit) then
    {This is just to isolate the one occasion when they press the
    enter but don't exit immediately}
    if Assigned(THack(Sender).OnExit) then THack(Sender).OnExit(Sender);
end;
```
Aus irgendeinem Grund, das OnExit-ist privat in einem TCustomEdit so der Hack benötigt wird. Wenn Sie wissen, dass die Bearbeitungen sind von einer anderen Strecke, wo die OnExit-ist die öffentlichkeit, die-cast, wenn anders und der Hack ist nicht notwendig.

Dann Für jede Edit-Steuerelement, die Verwendung einer bestimmten OnExit
```
procedure TForm1.MyEditExit(Sender: TObject);
begin
  if MyEdit.Modified then
  begin
    {Do Something here}
    MyEdit.Modified := false;
  end;
end;
```
Wenn Sie möchten, um den Wert zu ändern programmgesteuert, ohne es brennen 'OnExit'
```
....
MyEdit.Text :='I've changed it'
MyEdit.Modified := false;
....
```
Der große Vorteil für mich ist, dass, wenn ich mich auf die Analyse der Eingaben für sagen eine gültige Zahl ich nur einmal gemacht werden, wenn die Bearbeitung abgeschlossen ist und nicht für jede einzelne backspace, löschen, einfügen etc umgeben von versuchen, sofern es die verschiedene Formatierung-Funktionen Fehler heraus, da Sie nicht verstehen, Leerzeichen etc.. Für die Datenbank etc, die Anzahl der calls deutlich reduziert werden.

Dass ' s meine zwei penneth.

InformationsquelleAutor PhilipO

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.