Checkbox aktivieren bei bestimmten buchstaben in TEdit

[rhodan]

moin.

ich habe eine reihe verschiedener checkboxen und ein TEdit.
bei eingabe des buchstaben "A" soll eine bestimmte box gecheckt werden, schreibe ich zum beispiel "AB" soll die checkbox für "B" ebenfalls gecheckt werden..etc.

Habt ihr einen tipp wie ich das realisieren kann?

vielen dank für die mühe & lieben gruß aus Hamburg

Robin

[zeras]

Lasse doch den Buchstaben mit POS('A',s) finden. Wenn der Wert > 0 ist, dann hast du den Buchstaben gefunden. Wenn du das noch geschickt in eine Schleife packst, kannst du das ganze Alphabet durchsuchen.

[Perlsau]

Zitat:

Zitat von rhodan (Beitrag 1313479)

bei eingabe des buchstaben "A" soll eine bestimmte box gecheckt werden, schreibe ich zum beispiel "AB" soll die checkbox für "B" ebenfalls gecheckt werden..etc.

TEdit verfügt über drei Ereignisse, um auf Tastatureingaben zu reagieren und gleichzeitig die gedrückte Taste zu erfahren: OnKeyPress, OnKeyDown und OnKeyUp.

OnKeyPress liefert eine Variable vom Typ Char mit der gedrückten Taste, also 'a' oder 'A', die sich unterscheiden. OnKeyDown und OnKeyUp liefern dagegen eine Variable vom Typ Word, die nicht den ASCII-Code repräsentiert, sondern den sog. virtuellen Tastencode, also den Code, den die Hardware der Tastatur liefert. Hier steht z.B. der Tastencode 65 sowohl für 'a' als auch für 'A'. Als ASCII-Code wäre 'a' ein Chr(97), 'A' dagegen ein Chr(65).

Damit solltest du nun eigentlich was anfangen können ...

[rhodan]

vielen dank Männer!

habs jetzt so gelöst

Delphi-Quellcode:

procedure TForm1.Edit2Change(Sender: TObject);
var
position: integer;
S: string;
begin
 s := edit2.Text;
 Position := Pos('A', s);

if Position > 0 then
  checkbox1.Checked:=true
  else
    checkbox1.Checked:=false;
end;

@Perlsau

ich habe onKeyPress und OnKeyDown auch probiert.

Delphi-Quellcode:

procedure TForm1.Edit2KeyPress(Sender: TObject; var Key: Char);
begin
if Key = Chr($41) then
checkbox1.Checked:=true
else
checkbox1.Checked:=false;
end;

kam hier nicht ganz zum gleichen ergebnis aber die unterschiede von onKeyPress und OnKeyDown waren mir nicht bekannt, danke dafür.

robin

[Sir Rufo]

Oder einfach ganz kurz

Delphi-Quellcode:

procedure TForm1.Edit2Change(Sender: TObject);
begin
  checkbox1.Checked := Pos('A', Edit2.Text) > 0;
end;

[JanWe]

falls Du mehrere Checkboxen (wenn ich Deinen ersten Thread richtig gelesen hab ..) setzen willst.. würd ich das so machen.
Allerdings dürfte das aus Geschwindigkeitsgründen dann nur noch nach Abschluß des Tippens funktionieren.
Per Button - ausführbar (Button.click;) z.B. wenn RETURN gedrückt wurde.

Delphi-Quellcode:

procedure TForm1.Button1click(Sender: TObject); //Edit2Change erstmal nicht
var s, ch : String:
i, j : integer;
begin
  s := Edit1.text;
  Lenst := length(s) - 1; // ausnahmsweise schon mal 1 abgezogen

  for j := 1 to 26 do begin // erstmal alle clearen
    Checkbox1.checked := false;
    Checkbox2.checked := false;
    Checkbox3.checked := false;
    ....
    Checkbox26.checked := false;
  end;

  for i := 1 to LenSt(s) do begin // 1 ist bereits abgezogen!!, s.o.
    ch := lowerchar(s[i]);

    case ch of
      'a': Checkbox1.checked := true;
      'b': Checkbox1.checked := true;
      'c': Checkbox1.checked := true;
// ...
      'y': Checkbox1.checked := true;
      'z': Checkbox1.checked := true;
    end;

  end;

end;

[mkinzler]

Warum eine Schleife, wenn Du dann jede einzeln setzt?
Immerhin sind diese nach 26 Schleifendurchläufen dann auf jedenfall nicht mehr gescheckt. ;)

Ich würde diese in einem Array verwalten und dann mit Schleife über den Index ansprechen.

Delphi-Quellcode:

for i := 0 to 25 do
  checkbox[i].Checked := Pos( chr(i+65), Uppercase(Edit2.Text)) > 0;

[rhodan]

Zitat:

Zitat von Sir Rufo (Beitrag 1313483)

Oder einfach ganz kurz

Delphi-Quellcode:

procedure TForm1.Edit2Change(Sender: TObject);
begin
  checkbox1.Checked := Pos('A', Edit2.Text) > 0;
end;

ich danke dir...! hab meinen code geändert dahingehend...mächtiger einzeiler :lol::shock:

schönen abend

[SMO]

Zitat:

Zitat von Perlsau (Beitrag 1313481)

liefern dagegen eine Variable vom Typ Word, die nicht den ASCII-Code repräsentiert, sondern den sog. virtuellen Tastencode, also den Code, den die Hardware der Tastatur liefert.

Stimmt so nicht ganz. Die Hardware der Tastatur liefert geräteabhhängige Scancodes, die vom Treiber in geräteunabhängige virtuelle Key-Codes übersetzt werden.

[Sir Rufo]

Wenn du so richtig frei und losgelöst von allem programmieren möchtest, dann definierst du dir einfach ein Interface

Delphi-Quellcode:

type
  IStringConsumer = interface
    [ '{349D7AB4-F90B-416B-B31E-3E41AD5E5195}' ]
    procedure Consume( const AString: string );
  end;

und die Form hat dann

Delphi-Quellcode:

type
  TForm1 = class( TForm )
    Edit1 : TEdit;
    procedure Edit1Change( Sender: TObject );
  private
    FStringConsumer : IStringConsumer;
  end;

procedure TForm1.Edit1Change( Sender: TObject );
begin
  if Assigned( FStringConsumer ) then
    FStringConsumer.Consume( Edit1.Text );
end;

Jetzt kannst du ganz simpel irgendeinen StringConsumer dort unterjubeln, z.B. einen

Delphi-Quellcode:

type
  TCheckBoxContainsStringConsumer = class( TInterfacedObject, IStringConsumer )
  private
    FCheckBox      : TCheckBox;
    FContainsString: string;
  public
    constructor Create( ACheckBox: TCheckBox; const AContainsString: string );
    procedure Consume( const AString: string );
  end;

{ TCheckBoxContainsStringConsumer }

procedure TCheckBoxContainsStringConsumer.Consume( const AString: string );
begin
  FCheckBox.Checked := Pos( FContainsString, AString ) > 0;
end;

constructor TCheckBoxContainsStringConsumer.Create(
  ACheckBox            : TCheckBox;
  const AContainsString: string );
begin
  inherited Create;
  FCheckBox       := ACheckBox;
  FContainsString := AContainsString;
end;

und irgendwo in einer Form-Methode erzeugst du eine Instanz

Delphi-Quellcode:

procedure TForm1.AfterConstruction;
begin
  inherited;
  FStringConsumer := TCheckBoxContainsStringConsumer.Create( CheckBox1, 'A' );
end;

und schon wird die Checkbox gesetzt ...

Möchtest du mehrere Consumer (z.B. CheckBoxen) ansteuern, dann erstellt man sich ganz einfach ein Aggregat:

Delphi-Quellcode:

  TStringConsumerArray = array of IStringConsumer;

  TAggregateStringConsumer = class( TInterfacedObject, IStringConsumer )
  private
    FConsumers: TInterfaceList;
  public
    constructor Create( AConsumers: TStringConsumerArray );
    destructor Destroy; override;

    procedure Consume( const AString: string );
  end;

{ TAggregateStringConsumer }

procedure TAggregateStringConsumer.Consume( const AString: string );
var
  LIdx: Integer;
begin
  for LIdx := 0 to FConsumers.Count - 1 do
    begin
      IStringConsumer( FConsumers[ LIdx ] ).Consume( AString );
    end;
end;

constructor TAggregateStringConsumer.Create( AConsumers: TStringConsumerArray );
var
  LIdx: Integer;
begin
  inherited Create;
  FConsumers := TInterfaceList.Create;
  for LIdx   := low( AConsumers ) to high( AConsumers ) do
    FConsumers.Add( AConsumers[ LIdx ] );
end;

destructor TAggregateStringConsumer.Destroy;
begin
  FConsumers.Free;
  inherited;
end;

und in der Form dann ganz einfach

Delphi-Quellcode:

procedure TForm1.AfterConstruction;
begin
  inherited;
  FStringConsumer := 
    TAggregateStringConsumer.Create( [
      TCheckBoxContainsStringConsumer.Create( CheckBox1, 'A' ),
      TCheckBoxContainsStringConsumer.Create( CheckBox2, 'B' ),
      TCheckBoxContainsStringConsumer.Create( CheckBox3, 'C' ),
      TCheckBoxContainsStringConsumer.Create( CheckBox4, 'D' ),
      TCheckBoxContainsStringConsumer.Create( CheckBox5, 'E' ),
      TCheckBoxContainsStringConsumer.Create( CheckBox6, 'F' ),
      TCheckBoxContainsStringConsumer.Create( CheckBox7, 'G' ),
      TCheckBoxContainsStringConsumer.Create( CheckBox8, 'H' ),
      // oder auf mehr Zeichen reagieren
      TCheckBoxContainsStringConsumer.Create( CheckBox9, 'Hallo' ) ] );
end;

Die

Delphi-Quellcode:

TForm1.Edit1Change

Methode bleibt dabei immer gleich ;)

[rhodan]

"Kaum macht man's richtig - schon funktioniert's"

bin überfordert - ich bleibe beim einzeiler..lach! :lol::lol::lol::lol:
schöner code.

[idefix2]

Das ganze erscheint mir wirklich unnötig aufwändig.
Eine Stringlist, die zu jedem String als Objekt die zugehörige Checkbox hat.

Delphi-Quellcode:

type
  TForm1 = class( TForm )
    Edit1 : TEdit;
    procedure Edit1Change( Sender: TObject );
  private
    MyStrings : TStringlist;
  end;

....

Procedure TForm1.Formcreate;
var ch: char;
begin
...
MyStrings:=TStringlist.Create;

MyStrings.AddObject('a', checkbox1);
MyStrings.AddObject('b', checkbox2);

// oder für jeden Buchstaben eine Checkbox:
for ch:='a' to 'z'
    Mystrings.AddObject(ch, findcomponent('checkbox'+inttostr(ord(ch)-ord('a')+1))
end;

procedure TForm1.Edit1Change( Sender: TObject );
var i: integer;
begin
for i:=0 to MyStrings.count-1 do
    TCheckbox(MyStrings.objects[i]).checked := pos(MyStrings[i],edit1.text)>0 
end;

Nebenbei: Wenn du wirklich für jeden Buchstaben eine Checkbox brauchen solltest, dann würde ich die überhaupt erst zur Laufzeit im Formcreate anlegen und bei der Gelegenheit gleich in die Stringlist hängen.

@Sir Rufo
Dein Code ist ein schönes Beispiel für das Hantieren mit Interfaces, und im Gegensatz zur StringList braucht man am Ende nichts freigeben. In diesem konkreten Fall wären es aber für eine einfache Aufgabe reichlich komplizierte Konstrukte, die das Programm nicht unbedingt lesbar machen. Wenn sich dann jemand in den Code einlesen soll, der ihn nicht geschrieben hat, braucht der sicher eine hübsche Weile, um draufzukommen, was wo wie bewerkstelligt wird.