Spalten überprüfen...

[Simo]

Hey Leute

Ich bin ein Anfänger in Delphi und brauche Ihre Unterstützung..

Ich muss die 15-Spalten einer XML-Tabelle überprüfen : Doppelter Eintrag, Integer, Float..usw
Wenn ich z.B die Spalte 1 auf doppelter Eintrag überprüfe, muss die Zeile, in der der Eintrag zwei mal vorkommt markiert werden (Oder Cursor muss hin...).

Delphi-Quellcode:

function TMyChek.MyChekGleich(StringGrid:TggStringGrid):Integer ;
var
  a , b ,c   : integer;
  Inhalt_Check : string;
  iDoppeltcounter:integer;
begin

  iDoppeltcounter:=0;
  Result:=-3;
  b:= StringGrid.RowCount; // Anzahl der Zeilen...


  for a:=0 to b do begin
    Inhalt_Check:=StringGrid.Cells[0,a]; // Zeile Um 1 erhöhen...
     for c:=0 to b do begin
        if Inhalt_Check=StringGrid.Cells[0,c] then begin
           iDoppeltcounter:=iDoppeltcounter+1;
             if iDoppeltcounter>1 then begin
                Result:=c;
                StringGrid.Selection:= TGridRect(Rect(0,Inhalt_Check)); //...??
                 exit;
                 iDoppeltcounter:=0;
             end;
        end;
     end;
  end;
end;).

Es klappt nicht mit der Markierung oder (Cursor weiss ich gar nicht wie..)
Wäre sehr dankbar wenn Sie mir helfen können

[Jumpy]

Hallo und willkommen in der DP erstmal!

Da du ja zwei zusammenhängende Fragen hast, richtigerweise in verschiedenen Threads gestellt, wäre es aber trotzdem schön die beiden Threads zu verlinken, damit man den Zusammenhang sieht.
Ausserdem ist es immer besser Quellcode in die Delphi-Tags (Symbol mit dem Helm) einzuschließen, damit man den besser lesen kann.

Zu deiner Frage/Funktion für dieses spezielle Problem:

- Halte die Funktion allgemeiner, d.h. übergib nicht nur das TStringGrid sondern auch die Nummer der zu durchsuchnden Spalte.
- Dann hast du ja eine Funktion schreiben wollen, die dir die Reihennummer zurückliefert, wenn ein Eintrag doppelt vorkommt. Wäre es nicht sinnvoller da es ja nicht nur Doppelte, sondern auch Drillinge, Vierlinge usw. geben könnte und es ja auch zudem mehrere Doppelte, Drillinge,... geben könnte entweder alle Gleichen jeweils gleich Einzufärben, oder eine ganze Liste (wie auch immer) von der Funktion zurückgeben oder anzeigen zu lassen, mit dem Wert und den Zeilen in denen dieser Wert vorkommt, wenn er denn mehrfach vorkommt?
- Daher mein Rat: Überleg nochmal genau, was die Funktion/Prozedur machen soll und dann können wir gemeinsam überlegen, wie man deinen Ansatzt si umbiegt, dass er das macht.

[Simo]

Vielen Dank für die schnelle Antwort,

Diese Funktion überprüft nur die erste Spalte der über den Editor geöffnete Tabelle auf doppelter Eintrag.
Aber die Aufgabe lautet : Ich habe eine neue Formular aufzurufen, drauf sind 15 ComboBoxen. In jeder ComboBox sind 3 gleiche Items/Funktionen drin (MyChekGleich, MyChekInteger, MyChekFloat). (ComboBox1 für Spalte 1.. ComboBox2 für Spalte 2... )

Wenn ich in ComboBox1 z.B 'MyChekGleich' ausgewählt habe dann soll die erste Spalte auf Doppelter Eintrag überprüft werden. Da habe ich Schwierigkeiten..

Dann muss ich meine Funktion in der Unit unit1 (wo alles implementiert ist) aufrufen Und wenn ich die XML-Datei geöffnet habe und über Extras die Formular aufrufe und in der ComboBox1 'MyChekGleich' auswähle und diese Einstellung speichere, dann soll beim Speichern eine Fehlermeldung ausgegeben (z.B Zeile markieren) werden wenn ein Doppelter Eintrag vorkommt..

1. Zuerst habe ich wie gesagt dem Projekt ein Unit hinzugefügt, wo ich meine Funktion/Funktionen geschrieben habe.

2. Dann eine VCL-Formular (die über Extras aufzurufen ist), wo ich 15 ComboBoxen platziert habe, da wird ausgewählt, welche Überprüfung für welche Spalte durchzuführen ist. Einstellungen müssen in einem File gespeichert werden.

3. Ich habe in der Unit unit1, beim Prozedur SpeichernClick, meine Funktion aufgerufen und meine Abfrage gemacht...Showmessage('Reaktion..')

So siehst das ganze aus :

Code zu 1 :

Delphi-Quellcode:

function TMyChek.MyChekGleich(StringGrid:TggStringGrid):Integer ;
var
  a , b ,c   : integer;
  Inhalt_Check : string;
  iDoppeltcounter:integer;
begin

  iDoppeltcounter:=0;
  Result:=-3;
  b:= StringGrid.RowCount; // Anzahl der Zeilen...


  for a:=0 to b do begin
    Inhalt_Check:=StringGrid.Cells[0,a]; //Zeile Um 1 erhöhen...
     for c:=0 to b do begin
        if Inhalt_Check=StringGrid.Cells[0,c] then begin
           iDoppeltcounter:=iDoppeltcounter+1;
             if iDoppeltcounter>1 then begin
                 Result:=c;
                 StringGrid.Selection:=...??
                 exit;
                 iDoppeltcounter:=0;
             end;
        end;
     end;
  end;
end;

Code zu 2 :

Delphi-Quellcode:

...
type
    Regel = record
      Spalte : Array [1..15] of string ;
      Kriterium : string ;
    end;

    const MaxAnzahlRegeln=9;
    const SpaltenAnzahl=15;

    var
    MyRegeln : Array [1..MaxAnzahlRegeln] of Regel;

...
procedure TFMRegeln.ComboBoxChangeAlg(Sender: TObject);

begin
  MyRegeln[STrToInt(ComboBox1.Text)].Spalte[(Sender as TComboBox).Tag]:=(Sender as TComboBox).Text;
end;



////////////////// Wird aufgerufen, wenn SaveBtn gedrückt ist../////////////////
procedure TFMRegeln.SaveBtnClick(Sender: TObject);
var
  i:integer;
  sAktDir:string;
 begin
  sAktDir:=GetCurrentDir;
  fileData:= TStringList.Create;
  fileData.add('Regeln');
  fileData.add('Regel :'+ComboBox1.Text);
  fileData.add('Kriterium für die Anwendung der Regel:'+Edit1.Text);
  for i := 1 to SpaltenAnzahl do
  fileData.add('Spalte:'+MyRegeln[StrToInt(ComboBox1.Text)].Spalte[i]);
  fileName:= sAktDir +'\Test.txt';
  //fileName:= ExtractFilePath(Paramstr(0))+'Test.txt';

  if fileName <> '' then begin
    fileData.SaveToFile(fileName);
      fileData.free;
        SaveBtn.Enabled := true;// Savebutton deaktivieren..
          close;
    end;

Code zum Punkt 3 :

Delphi-Quellcode:

////////////////////////// XML File speichern
procedure TForm1.Speichern1Click(Sender: TObject);
var
  MyXML:TBATM4XMLClass;
  i,r,S:integer;
  MyCheck:TMyChek;
  iResult:integer;
  //b : Boolean;

begin


  MyCheck:=TMyChek.Create;
  iResult:=MyCheck.MyChekGleich(MainGrid);

  //b:=MyCheck.MyChekFloat('10');

  if iResult<>-3 then begin
     Showmessage(' Doppelter Eintrag : ' + IntTostr(iResult));
  end;
       //if b then begin
          //Showmessage(' Das ist ein Integer...');

  Freeandnil(MyCheck);



  if UPPERCASE(copy(Filename,length(Filename)-2,3)) = 'TXT' then begin
    SavetextFile();
.
.
.

Ich find's selbst ein bisschen zu viel..als Frage!
Aber ich brauche Ihre Hilfe und bin sehr dankbar..
-)

[Perlsau]

@Simo:

Jumpy meinte oben aus gutem Grund:

Zitat von Jumpy:

Ausserdem ist es immer besser Quellcode in die Delphi-Tags (Symbol mit dem Helm) einzuschließen, damit man den besser lesen kann.

Falls du noch immer nicht weißt, wie das geht:

1. Klicke in der Forenansicht innerhalb deines bereits erstellten Beitrags auf den Button Bearbeiten.
   
2. Klicke im daraufhin erscheinenden Einfachst-Editor auf den Button Erweitert.
   
3. Markiere deinen hineinkopierten Code mit der linken Maustaste.
   
4. Klicke oberhalb des Editors auf das Helmsymbol (hellbrauner Helm mit rotem Federbusch)
   
5. Klicke auf den Button Vorschau.
   
6. Wenn du mit dem Ergebnis zufrieden bist, klicke auf den Button Änderungen speichern.

Das durchaus wünschenswerte Ergebnis dieser Bemühungen besteht darin, daß nun viel mehr Leute bereit sind, deinen Code zu lesen, weil sie nun nicht mehr befürchten müssen, an Augenkrebs zu erkranken

[Bjoerk]

Mit dem Code wird wohl keiner richtig was anfangen können? Die Typen TMyChek, TggStringGrid, TFMRegeln, TBATM4XMLClass sind nicht allgemein bekannt (oder ist TggStringGrid nur ein Tippfehler?).

Ansonsten kann man ein TStringGrid so durchsuchen:

Delphi-Quellcode:

var
  Col, Row: integer;
begin
  for Col := AStringGrid.FixedCols to AStringGrid.ColCount - 1 do // Spalten;
    for Row := AStringGrid.FixedRows to AStringGrid.RowCount - 1 do // Zeilen;
      if AStringGrid.Cells[Col, Row] = 'Delphi' then
        ShowMessage(Format('%s gefunden in Zelle (%d %d)',
          [AStringGrid.Cells[Col, Row], Col, Row]));

Ist aber eigentlich Basiswissen und solltest du in deinem Delphi Tutorial deines Vertäuens oder in der Delphi Hilfe nachschauen können?

[Simo]

So Leute... Zuerst vielen Dank für Ihre Anweisungen, Hilfe -)

Ein XML-Editor ist schon programmiert! Hat ein Menu wie jedes anderes Programm : Datei Offnen, speichern, speichern unter, schließen) Extras..usw.
Mit dem Editor werden Dateien bearbeitet,editiert. Mit Hilfe vom Editor lassen sich große Dateien als XML-Tabellen öffnen. Diese Tabellen enthalten mehrere Spalten(15) mit unterschiedlichen Inhalten. Die Elementnamen werden als Spaltenüberschriften verwendet (Name, Nummer, Einheit...).

Die Aufgabe :
Es soll eine Möglichkeit vorgesehen werden, den Inhalt der einzelnen Spalten auf zulässige Werte/Inhalte zu überprüfen ( Auf doppelter Eintrag, Integer..usw.). Es gibt aber 5 XML-Tabellen. die Elementnamen ändern sich.

Dem schon vorhandenen Projekt wird eine neue Unit hinzugefügt, wo die Funktionen, die überprüfen, programmiert werden. Dann soll dem Projekt eine VCL-Formular hinzugefügt werden. Auf dieser Formular wird folgendes platziert : die Erste ComboBox1 für die Auswahl der Regel, die angewendet werden muss (einfach Regel1..Regel2..) . Dann in einer GroupBox 15-ComboBoxen mit 15 Labeln (LabelN(SpalteN) ---> ComboBoxN , N=1,2,3..) untereinander. In diesen 15-ComboBoxen sind bisher 3 gleiche Items = also meine Funktionen 'MyChekGleich' 'MyChekInteger' 'MyChekFloat' (MyChekGleich = heisst die überprüft auf doppelter Eintrag). so habe ich sie einfach genannt.
Und unten einfach ein Button zum speichern dieser Einstellungen am Ende.(in einem File)

Da es verschieden Tabellen gibt, ändern sich diese Einstellungen : D.h bei einer Tabelle wird die erste Spalte auf Integer überprüft und die zweite Spalte auf doppelter Eintrag..usw. Bei der anderen Tabelle wird die erste Spalte auf Float und die zweite auf doppelter Eintrag..usw. Deswegen gibt's diese 15-ComboBoxen, wo man beliebig auswählen/einstellen kann, welche Funktion für welche Spalte... Es kann auch sein dass ich zum Beispiel die Spalte 5 gar nicht überprüfen möchte, dann gehe ich zu ComboBox5 und wähle da items 'leer'.
Also ich muss gar nicht den Inhalt der Tabelle abfragen sondern überprüfen, weil sie schon mit Daten gefüllt sind.

So kann man sich das vorstellen :
Ich starte mein Editor und gehe zum Menu : Datei --> Öffnen.. dann öffne ich eine Tabelle (mit 15Spalten) und rufe meine Formular über Extras auf. Da kann ich im ComboBox1 die Regel 'zum Beispiel 'MyRegeln1' auswählen. dann gucke ich mir die Tabelle an und mache meine Einstellungen in den ComboBoxen : ich wähle z.B im ComboBox1 (für Spalte1) die Funktion 'MyChekGleich' aus und im comboBox5 'MyChekGleich' dann sollen die Spalte 1 und 5 auf doppelter Eintrag überprüft werden.und lasse die anderen leer. Am Ende speicher ich diese Einstellungen und gehe zum Menu : Speichern..dann sollen diese Überprüfungen durchgeführt und eine Fehlermeldung ausgegeben werden (Zeile markieren wo es Integer sein soll oder ein Doppelter Eintrag vorkommt..). Erst beim Speichern.



Meine Code :
1.Zuerst die 3 Funktionen
2.VCL-Formular (Code)
3.(Abfrage beim Prozedur SpeichernClick.. war schon programmiert)

Zu 1

Delphi-Quellcode:

 
unit MyChkXML;

interface
uses
SysUtils, WinTypes, WinProcs, Messages, Classes,Forms, Dialogs, ExtCtrls,
StdCtrls, Buttons,ggStringGrid,Grids ;


type
  TMyChek = class

  private

  public
    function MyChekGleich(StringGrid:TggStringGrid):Integer ;
    function MyChekInteger(s:String):Boolean;
    function MyChekFloat(S:string) :Boolean;



  end;

implementation
uses
Regeln ;


////////////////////// Prüft, ob ein doppelter Eintrag vorkommt ///////////////
function TMyChek.MyChekGleich(StringGrid:TggStringGrid):Integer ;
var
  a , b ,c   : integer;
  Inhalt_Check : string;
  iDoppeltcounter:integer;
begin

  iDoppeltcounter:=0;
  Result:=-3;
  b:= StringGrid.RowCount; // Anzahl der Zeilen...


  for a:=0 to b do begin
    Inhalt_Check:=StringGrid.Cells[0,a]; //Zeile Um 1 erhöhen...
     for c:=0 to b do begin
        if Inhalt_Check=StringGrid.Cells[0,c] then begin
           iDoppeltcounter:=iDoppeltcounter+1;
             if iDoppeltcounter>1 then begin
                 Result:=c;
                 //StringGrid.Selection:=
                 exit;
                 iDoppeltcounter:=0;
             end;
        end;
     end;
  end;
end;



/////////////////// Überprüft, ob ein String eine Float Zahl ist //////////////
function TMyChek.MyChekFloat(S: string): Boolean;

begin
  try

    StrToFloat(S); // String in Float umwandeln..
    Result := True;
  except
    Result := False;
  end;
end;



///////////////////////////////////////////////////////////////////////////////
// Überprüft ob der Inhalt aus Zahlen besteht...
function TMyChek.MyChekInteger(s:String):Boolean;

var
  h : Integer;
begin

    for h := 1 to Length(s) do  begin
      if (s[h] > '0') or (s[h] < '9') then
      exit;
      Result:=True;

   end;
end;

end.

Zu 2 :

Delphi-Quellcode:

unit Regeln;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.ComCtrls, Vcl.StdCtrls, MyChkXML,
  BATM4XML, ggStringGrid, Grids ;



  type
    Regel = record
      Spalte : Array [1..15] of string ;
      Kriterium : string ;
    end;

    const MaxAnzahlRegeln=9;
    const SpaltenAnzahl=15;

    var
    MyRegeln : Array [1..MaxAnzahlRegeln] of Regel;


 type
  TFMRegeln = class(TForm)
    Label1: TLabel;
    GroupBox1: TGroupBox;
    Spalte1: TLabel;
    Label3: TLabel;
    Label4: TLabel;
    Label5: TLabel;
    Label6: TLabel;
    Label7: TLabel;
    Label8: TLabel;
    Label9: TLabel;
    Label10: TLabel;
    Label11: TLabel;
    Label12: TLabel;
    Label13: TLabel;
    Label14: TLabel;
    Label15: TLabel;
    Label16: TLabel;
    Label17: TLabel;
    ComboBox1: TComboBox;
    ComboBox2: TComboBox;
    ComboBox3: TComboBox;
    ComboBox4: TComboBox;
    ComboBox5: TComboBox;
    ComboBox6: TComboBox;
    ComboBox7: TComboBox;
    ComboBox8: TComboBox;
    ComboBox9: TComboBox;
    ComboBox10: TComboBox;
    ComboBox11: TComboBox;
    ComboBox12: TComboBox;
    ComboBox13: TComboBox;
    ComboBox14: TComboBox;
    ComboBox15: TComboBox;
    ComboBox16: TComboBox;
    SaveBtn: TButton;
    Edit1: TEdit;
    procedure SaveBtnClick(Sender: TObject);
    procedure ComboBoxChangeAlg(Sender: TObject);

  private
    { Private-Deklarationen }

  public

  { Public-Deklarationen }
  fileName : String;
  fileData : TStringList;

  end;

  var
  FMRegeln: TFMRegeln;


implementation
uses
  unit1;

{$R *.dfm}
/////////////////////////////////////////////////////////////////////////////
procedure TFMRegeln.ComboBoxChangeAlg(Sender: TObject);

begin
  MyRegeln[STrToInt(ComboBox1.Text)].Spalte[(Sender as TComboBox).Tag]:=(Sender as TComboBox).Text;
end;



////////////////// Wird aufgerufen, wenn SaveBtn gedrückt ist../////////////////
procedure TFMRegeln.SaveBtnClick(Sender: TObject);
var
  i:integer;
  sAktDir:string;
 begin
  sAktDir:=GetCurrentDir;
  fileData:= TStringList.Create;
  fileData.add('Regeln');
  fileData.add('Regel :'+ComboBox1.Text);
  fileData.add('Kriterium für die Anwendung der Regel:'+Edit1.Text);
  for i := 1 to SpaltenAnzahl do
  fileData.add('Spalte:'+MyRegeln[StrToInt(ComboBox1.Text)].Spalte[i]);
  fileName:= sAktDir +'\Test.txt';
  //fileName:= ExtractFilePath(Paramstr(0))+'Test.txt';

  if fileName <> '' then begin
    fileData.SaveToFile(fileName);
      fileData.free;
        SaveBtn.Enabled := true;// Savebutton deaktivieren..
          close;
    end;
  end;
end.

Zu 3 :

Delphi-Quellcode:

procedure TForm1.Speichern1Click(Sender: TObject);
var
  i,r,S:integer;
  MyCheck:TMyChek;
  iResult:integer;
  b : Boolean;

begin


  MyCheck:=TMyChek.Create;
  iResult:=MyCheck.MyChekGleich(MainGrid);

  b:=MyCheck.MyChekFloat('10');
  //b:=MyCheck.MyChekInteger('10.4') ;

  if iResult<>-3 then begin
     Showmessage(' Doppelter Eintrag : ' + IntTostr(iResult));
  end;
       //if b then begin
          //Showmessage(' Das ist ein Integer...');

   //end;
  if b=true then begin
    Showmessage(' Float Zahl :');
  end;

  Freeandnil(MyCheck);



  if UPPERCASE(copy(Filename,length(Filename)-2,3)) = 'TXT' then begin
    SavetextFile();

Wird hier zu sehen ist überprüft meine erste Funktion nur die erste Spalte im allgemein..Cells[0,a]..[0,c]. Und die anderen auch...
Da habe ich Schwierigkeiten.. erst nach der Auswahl in den ComboBoxen muss man wissen welche Spalte..usw -( -(.

Ich bin echt sehr dankbar..

[Jumpy]

Ich wiederhole mal Teile meines Senfs aus #2:

Ich würde die Prüffunktionen allgemeiner halten, so dass man nicht nur die erste Spalte damit prüfen kann, mal anhand des Beispiels der Gleichheitsprüfun (nur so reinkopiert in deinen Text, also ohnr Gewähr):

Delphi-Quellcode:

function TMyChek.MyChekGleich(StringGrid:TggStringGrid; Spaltennummer:Integer):Integer ;
//wobei ich die Funktion umbennenen würde, in das was sie macht, nämlich die erste Zeile liefern, //in der was doppelt vorkommt also somit sowas wie:
//function TMyChek.GetFirstRepetition(StringGrid:TggStringGrid; Spaltennummer:Integer):Integer ;
var
  a , b ,c : integer;
  Inhalt_Check : string;
  iDoppeltcounter:integer;
begin
  iDoppeltcounter:=0;
  Result:=0;//Ich würde sagen, wenn 0 zurückkommt, gibt es keine Doppelten

  b:= StringGrid.RowCount; // Anzahl der Zeilen...

  for a:=0 to b do begin  //müsste meiner Meinung nach b-1 sein
    Inhalt_Check:=StringGrid.Cells[Spaltennummer,a]; //Zeile Um 1 erhöhen...
     for c:=0 to b do begin //b-1 s.o.?
        if Inhalt_Check=StringGrid.Cells[Spaltennummer,c] then begin
           //iDoppeltcounter:=iDoppeltcounter+1;
           Inc(iDoppeltcounter);
             if iDoppeltcounter>1 then begin
                 Result:=c;
                 //StringGrid.Selection:=
                 exit;
                 iDoppeltcounter:=0;
             end;
        end;
     end;
  end;
end;

Nichts desto trotz erschließt sich mir vieles in der Funktion nicht. Was soll das mit dem Doppelcounter bringen? Auch die geschachtelten Schleifen machen keinen Sinn, weil die beide immer von 0 bis b laufen und daher für Zeile scheinbar eine doppelte gefunden würde.
Müsste also daher nicht die zweite Schleife von c=a+1 bis b laufen.

Generell ist die Funktion aber auch gar nicht das, was du suchst. Es soll doch was markiert werden und zwar nicht nur die erste Doppelte sondern alle, oder?

[Simo]

Ich danke dir für deine Antwort.. nett von dir -)

Das Problem ist, Ich habe diese Funktionen 'allgemein' programmiert (natürlich auch falsch..denn die erste überprüft die erste Spalte und die anderen nur allgemein). Nachdem ich dem schon vorhandenen Projekt diese VCL-Formular (Mit dem Namen Regeln) hinzugefügt habe, sind die Spaltennummern von der Einstellung der ComboBoxen abhängig geworden. D.h ..StringGrid.Cells[welche ComboBox?,a]
wenn ich über Extras 'Regeln' aufrufe, erscheint meine Formular. Wenn ich zum Beispiel im ComboBox9 'MyChekGleich' auswähle und diese Einstellung speichere. dann muss genau die Spalte nummer 9 beim Speichern auf doppelter Eintrag überprüft werden. Es könnten ja mehr Funktionen drin sein und mehr Spalten.. muss beliebig sein.

Ich habe eigentlich so gemacht wie im Code 2 zu sehen ist :

Delphi-Quellcode:

procedure TFMRegeln.ComboBoxChangeAlg(Sender: TObject);

begin
  MyRegeln[STrToInt(ComboBox1.Text)].Spalte[(Sender as TComboBox).Tag]:=(Sender as TComboBox).Text;
end;

MyRegeln : da wird nur Regel1 ausgewählt..unwichtig!!
Ich habe alle ComboBoxen im Objektinspektor bei Eigenschaft 'Tag' nummeriert. bei ComboBox1: Tag=1.. ComboBox15..Tag=15). deswegen im Code .Spalte[(Sender as TComboBox).Tag].

Ich weiss nicht wie ich die Einstellungen (Code 2) mit meinen Funktionen verbinde (Code1) und sie voneinandere abhängig mache ? Sowas.. if Inhalt_Check=StringGrid.Cells[Spalte[(Sender as TComboBox).Tag),c] then begin ... ??

Und das für alle Spalten.. wenn ich im ComboBox 2 und 9 'MyChekGleich' auswähle dann müssen genau diese Spalten überprüft werden und die anderen nicht!!!
Die anderen zwei Funktionen muss ich auch noch um'programmieren, aber wenn es mit einer Funktion klappt dann kann ich für sie das gleiche machen.. sie von der Einstellung der ComboBoxen abhängig machen -)

(

Vielleicht kann ich es nicht so richtig erklären..
Ich wäre sehr dankbar wenn Ihr mir helfen könnt..

[Jumpy]

Ich würde es vllt. mal so versuchen (ohne jetzt dein ganzes Konzept umzuschmeißen) und ohne jede Fehlerprüfung:

Delphi-Quellcode:

procedure TMyChek.StartePruefung;
var i:integer;
begin
  for i:=1 to 15 do
    PruefeCombobox(i);
end;

procedure TMyChek.PruefeCombobox(nr as integer);
var cb:TCombobBox;
begin
  cb:=TComboBox(FindComponent('ComboBox'+IntToStr(nr)));
  if cb.Text='CheckGleich' then
    MyChekGleich(Grid:TStringGrid,nr)
  else if cb.Text='CheckInteger' then
    MyChekInteger(Grid:TStringGrid,nr)
  else if cb.Text='CheckDouble' then
    MyChekDouble(Grid:TStringGrid,nr)
  else
    //Kein Check für Spalte nr
end;

Und die Checks dann so auslegen, dass Sie nicht irgendeinen Wert zurückliefern, sondern das StringGrid markieren oder eine Liste mit Fehlern zuückliefern.


Zu deinem Speichern Problem (Nr.2). Wäre es nicht sinnvoller, die Daten (=Regeln pro Spalte) in einer Form zu speichern, die es ermöglicht sie nachher wieder leicht auszulesen?. Mach dich doch dazu mal z.B. über Ini-Dateien schlau. Das was du unter Punkt 2 machst, kannst du als Mensch zwar nachher gut lesen, aber eine Routine zu schreiben, mit der du das wieder einlesen kannst wird unnötig schwierig.


P.S.: In der Regel dutzt man sich hier. Egal ob Anfänger oder Profi. Nur falls du dich wunderst, warum ich einfach "du" schreibe, wo du doch immer so höflich von "sie" sprichst.

P.P.S.: Nur ein Gedanke, der mir gerade kam. Wenn du Beispielsweise hingegen willst und in deinen Prüfroutinen die Gridzellen durch einfärben markieren willst, so würde ich mir eine Struktur anlegen, z.B. ein Array of Array of TColor oder sonstwas, wo in der OnDraw Funktion des Grids (also bei jedem Neuzeichnen) geguckt wird, welche Farbe eine Zelle haben soll. Und in deinen Prüfroutinen machst du dann nur noch einen entsprechenden Eintrag in dieser Struktur.

[Simo]

Vielen Dank Ralph -)
Die Idee ist eigentlich gut -)

Und wo gehört denn das Code? Wo tue ich genau die Abfragen..
Was muss ich dann in meiner Funktion ändern/umprogrammieren ?

Delphi-Quellcode:

function TMyChek.MyChekGleich(StringGrid:TggStringGrid; Spaltennummer:Integer):Integer ;
//wobei ich die Funktion umbennenen würde, in das was sie macht, nämlich die erste Zeile liefern, //in der was doppelt vorkommt also somit sowas wie:
//function TMyChek.GetFirstRepetition(StringGrid:TggStringGrid; Spaltennummer:Integer):Integer ;
var
  a , b ,c : integer;
  Inhalt_Check : string;
  iDoppeltcounter:integer;
begin
  iDoppeltcounter:=0;
  Result:=0;//Ich würde sagen, wenn 0 zurückkommt, gibt es keine Doppelten

  b:= StringGrid.RowCount; // Anzahl der Zeilen...

  for a:=0 to b do begin //müsste meiner Meinung nach b-1 sein
    Inhalt_Check:=StringGrid.Cells[Spaltennummer,a]; //Zeile Um 1 erhöhen...
     for c:=0 to b do begin //b-1 s.o.?
        if Inhalt_Check=StringGrid.Cells[Spaltennummer,c] then begin
           //iDoppeltcounter:=iDoppeltcounter+1;
           Inc(iDoppeltcounter);
             if iDoppeltcounter>1 then begin
                 Result:=c;
                 //StringGrid.Selection:=
                 exit;
                 iDoppeltcounter:=0;
             end;
        end;
     end;
  end;
end;

Das gleiche kann ich dann für die anderen Funktionen machen.
Wie siehts das ganze aus ?

Delphi-Quellcode:

procedure TFMRegeln.ComboBoxChangeAlg(Sender: TObject);

begin
  MyRegeln[STrToInt(ComboBox1.Text)].Spalte[(Sender as TComboBox).Tag]:=(Sender as TComboBox).Text;
end;

??