Checkbox aktivieren bei bestimmten buchstaben in TEdit

[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 von Sir Rufo:

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

schönen abend

[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 TForm1.Edit1Change Methode bleibt dabei immer gleich

[rhodan]

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

bin überfordert - ich bleibe beim einzeiler..lach!
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.