Property "Objects" im Stringgrid

[Hansa]

Hi,

in diesem Thread hier :

http://www.delphipraxis.net/internal...a75c5f6fdb8c12

kam das Thema Ojects zur Sprache. Leider gibt das Thema in der Hilfe kaum was her. Was genau kann man damit jetzt machen ? Wenn ich das richtig sehe, dann kann man jeder einzelnen Zelle irgendwas zuordnen als TObject. Das ist mir aber etwas suspekt, weil zu abstrakt. 8) Ich bräuchte ein Fallbeispiel, möglichst einfach. :mrgreen:

Angenommen ich will gezielt einzelne Zellen nicht editierbar machen, in Abhängigkeit von einer Bedingung. Ginge das ? In diesem Falle bräuchte ich nur von jeder Zelle true oder false und müßte das irgendwie auswerten, aber wie ? Wer weiß mehr ? Mein Gespür sagt mir, daß damit wohl schon einiges möglich ist, wo man zuerst gar nicht dran denkt. Oder ich täusche mich, da in der Hilfe darüber tatsächlich nur ein Satz steht.

[Nightshade]

Du kannst einfach ganze Objecte in einer Zelle speichern.

Delphi-Quellcode:

Type TMyObject = class(TObject)
  private
    Editable : boolean;
end;


procedure AddObjectToGrid(ACol, ARow : integer; Editable : boolean);
var
  MyObject : TMyObject;
begin
  MyObject := TMyObject.Create;
  MyObject.EditAble := EditAble;
  Stringgrid1.Objects[ACol, ARow] := MyObject;
end;

function TestForEdit(ACol, ARow):boolean;
var
  MyObject : TMyObject;
begin
  MyObject := TMyObject(Stringgrid1.Objects[ACol, ARow]);
  result := MyObject.EditAble;
end;

Nur mal so als Beispiel.....

PS : Nicht vergesen die Objekte wieder Freizugeben !

[Jens Schumann]

Hallo Hansa,
das was ich jetzt sage gilt für TStringGrid und alle TStrings-Nachfahren.
Die Objects Eigenschaft eigent sich hervorragend, um dem Text noch Zusatzinfo's
in Form eines Objektes mitzugeben. Es könnte ja sein, dass der Text im Grid
eine Eigenschaft eines Objektes ist. Wenn Du die Zelle anwählst hast Du sofort
das ganze Objekt zur Hand. Das kann manchmal ziemlich praktisch sein.

[Hansa]

Zitat:

Zitat von Jens Schumann

...Das kann manchmal ziemlich praktisch sein.

Kann man das so sehen, wie ein zu den einzelnen Zellen mitgeschlepptes 2. Array, in dem irgendwas drin ist, also auch nur ein boolean, wie in meinem Beispiel ? Oder eine Farbe oder was weiß denn ich ? :mrgreen:

Wenn das tatsächlich so ist, dann frage ich mich, warum nirgendwo, zumindest hier nicht, was darüber zu lesen steht. Das wäre dann wirklich eine praktische Sache, die man unbedingt nutzen sollte.

P.S.: ich meine damit ein Array wie Cells [x,y], nur eben kein Text.

[Christian Seehase]

Moin Jens,

Zitat:

...und alle TStrings-Nachfahren.

leider nicht für alle :?

Bei TMemo.Lines und TRichEdit.Lines wird zwar kein Fehler produziert, wenn man AddObject verwendet, aber hier enthält das Objekt nichts. Der Wert bleibt immer 0.

@Hansa:

Zitat:

Zitat von Hansa

Wenn das tatsächlich so ist, dann frage ich mich, warum nirgendwo, zumindest hier nicht, was darüber zu lesen steht.

Was meinst Du mit "hier"?

Die Verwendung von Stringlist-Objekten für verschiedene Zwecke kam hier durchaus schon öfter mal zur Sprache.
Sozusagen als Tag Eigenschaft der Stringlisten ;-)

[Hansa]

In dem Beispiel gehts nicht recht weiter. 8) Es waren einige Schreibfehler drin und hiermit gehts auch nicht. Wo muß ich "editable" besetzen ? AddObjectToGrid, wo muß das hin ? Im Moment erhalte ich nur Zugriffsverletzungen.

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, Grids;

type TMyObject = class(TObject)
  private
    Editable : boolean;
end;

  TForm1 = class(TForm)
    StringGrid1: TStringGrid;
    procedure StringGrid1SelectCell(Sender: TObject; ACol, ARow: Integer;
      var CanSelect: Boolean);
  private
    { Private-Deklarationen }
    Editable : boolean;
    MyObject : TMyObject;
  public
    { Public-Deklarationen }
    procedure AddObjectToGrid(ACol, ARow : integer; Editable : boolean);
    function TestForEdit(ACol, ARow : integer):boolean;
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.AddObjectToGrid(ACol, ARow : integer; Editable : boolean);
var
  MyObject : TMyObject;
begin
  MyObject := TMyObject.Create;
  MyObject.EditAble := EditAble;
  Form1.StringGrid1.Objects[ACol, ARow] := MyObject;
end;

function TForm1.TestForEdit(ACol, ARow : integer):boolean;
begin
  MyObject := TMyObject(Stringgrid1.Objects[ACol, ARow]);
  result := MyObject.EditAble;
end;

procedure TForm1.StringGrid1SelectCell(Sender: TObject; ACol,
  ARow: Integer; var CanSelect: Boolean);
begin
  if TestForEdit (ACol,ARow) = true then
    showmessage ('zulässig')
  else
    showmessage ('nicht zulässig');
end;

end.

[Muetze1]

Moin!

Finde ich auch verständlich, weil wenn du nirgendwo mal AddObjectToGrid() aufrufst, dann steht nirgendwo ein Objekt drinne und daher stürzt TestForEdit() ab, weil er auf ein Objekt zugreift was nicht vorhanden ist. TestForEdit() ist leider nicht so geschrieben das er vorher prüft, ob ein Objekt vorhanden ist. Grundlegend ist der Code so funktionsfähig, wenn du denn auch überall mit AddObjectToGrid() mal das Flag setzen würdest...

MfG
Muetze1

[Hansa]

Ja, wenn man das so sieht. :mrgreen: Wo soll ich die Objekte denn erzeugen ? Zu Anfang hat das Grid nur eine leere Zeile. Wo setze ich da die Objects ?

[Hansa]

Benutzt diese Dinger also auch kaum einer ? Es sieht doch so aus, daß man jeder Zelle noch einiges an weiteren Infos mitgeben kann, egal was. Deshalb einmal die Zwischenfrage, wer das ganze bei sich einsetzt und wofür.

[kiar]

hallo hansa,

ich stze die Objekte in einem Stringgrid ein, um mehrere Farben in einer Zelle darzustellen.
aber das ist dir ja bekannt. :mrgreen:

wollte nur den anfang machen.

feine Sache----- die Objecte im Stringgrid------


raik

[Nightshade]

Sobald du Text in die Zellen schreibst (muss ja irgendwo passieren :) ), musst du dann auch das Object anhängen.


Und In TestForEdit sollte man dann wirklich abfragen ob ein Object angehängt ist....

Delphi-Quellcode:

function TForm1.TestForEdit(ACol, ARow : integer):boolean;
begin
  if Stringgrid1.Objects[ACol, ARow] <> nil then begin
    MyObject := TMyObject(Stringgrid1.Objects[ACol, ARow]);
    result := MyObject.EditAble;
  end
  else
    result := false;
end;

[SirThornberry]

beim Stringrid setzt ich das nicht ein (weil ich das nie nutze). Aber bei Listviews zum Beispiel. Ich zeige in der Listview einfach nur einen Titel an und in dem Object was ich da dem Item zuweise werden Bilder, Pfade etc. hinterlegt, je nach dem was das programm macht.

[Hansa]

Hi,

ich habe das jetzt, zumindest ungefähr geschnallt, aber es tauchen Randeffekte auf :

1. Problem :
das editable Beispiel scheint zu gehen, aber nicht beim erzeugen neuer Grid-Zeilen. Ich konnte das nur realisieren durch Einführen einer neuen Form-globalen Variable. Und zwar so :

Delphi-Quellcode:

procedure TfrmArtNrEin.ErzeugeNeueZeile(Sender: TObject);
begin
  with Sender as TStringgrid do begin
    WertSpeichern;
    NeueZeile := true;    // besetzen von Col und Row ruft SelectCell auf !!
    Col := 1;             // das sgArtNr.Objects darf hier nicht verändert werden
    RowCount := RowCount + 1;
    Row := RowCount - 1;
    NeueZeile := false;   // hier wieder SelectCell einschalten
  end;
end;

Kommentare im Source sind im Zusammenhang wichtig !!

Das SelectCell habe ich dann damit auch noch etwas vergewaltigt : :mrgreen:

Delphi-Quellcode:

procedure TfrmArtNrEin.sgArtNrSelectCell(Sender: TObject; ACol,
  ARow: Integer; var CanSelect: Boolean);
begin
  EditObject := TEditObject (sgArtNr.Objects [ACol,ARow]);

  CanSelect := EditObject.Editable or NeueZeile;  // vorerst Form-global definiert

//showmessage (BoolToStr (CanSelect,true)+IntToStr (ACol)+'   '+IntToStr (ARow));
(*
canselect := true;
*)
end;

Gut, das ganze geht schon so. Diese Variable "NeueZeile" gefällt mir allerdings nicht. Ich finde sie überflüssig. Die Editable Zellen im Grid werden solange richtig behandelt, bis RowCount erhöht werden muß, auch ohne "NeueZeile". Sieht da jemand vielleicht einen Denkfehler ?

2. Problem :

Es geht um das Create dieses Objects. Wenn ich einmal zuviel folgendes aufrufe :

Delphi-Quellcode:

procedure TfrmArtNrEin.AddEditObjectToGrid(ACol, ARow : integer; Editable : boolean);
var
  EditObject : TEditObject;
begin
  EditObject := TEditObject.Create;
  EditObject.EditAble := EditAble;
  sgArtNr.Objects[ACol, ARow] := EditObject;
end;

Was ist dann damit ? Es ist doch created und eventuell doppelt vorhanden. Also laufen in so einem Fall die Stringgrid-Zellen nicht mehr synchron zu den Edit Objects. 8) Also kann ich mich auch nicht darauf verlassen, eine for-Schleife zu verwenden, die Stringgrid-Zellen durchzugehen und zu löschen, hi Kiar :hi: .

Was auch noch den Speicher / das Laufzeitverhalten angeht : spricht etwas dagegen, pro Zelle ein Object mit 5 Bool-Werten anzulegen und wie wirkt sich so was aus ? Denn es ist ein doppelt 2-dimensionales Problem. Muß für jede Zelle im Fall der Fälle das Objects-Array auch wieder sozusagen Zelle um Zelle überprüft werden ?

[Christian Seehase]

Moin Hansa,

bis zu 32 boolsche Werte kannst Du auch direkt dort speichern, ohne ein Objekt haben zu müssen, es handelt sich ja schliesslich nur um einen 32 Bit grossen Wert, der einen Pointer zu einem Objekt darstellen kann, aber nicht muss.

[Nightshade]

Warum erstellst du in der Neuen Zeile nicht direkt die Objekte ?

Delphi-Quellcode:

procedure TfrmArtNrEin.ErzeugeNeueZeile(Sender: TObject); 
var
  t : integer;
begin 
  with Sender as TStringgrid do begin 
    WertSpeichern; 
    NeueZeile := true;    // besetzen von Col und Row ruft SelectCell auf !! 
    Col := 1;             // das sgArtNr.Objects darf hier nicht verändert werden 
    RowCount := RowCount + 1; 
    Row := RowCount - 1; 
    for t := 0 to pred(rows.Count) do       // Direkt für jede Zelle ein Objekt erstellen.
       AddEditObjectToGrid(t, Row, true);
    NeueZeile := false;   // hier wieder SelectCell einschalten 
  end; 
end;

[Hansa]

Zitat:

Zitat von Christian Seehase

...bis zu 32 boolsche Werte kannst Du auch direkt dort speichern, ohne ein Objekt haben zu müssen...

Wo ? Was meinst Du damit ? :shock:

Delphi-Quellcode:

procedure TfrmEin.ChangeEditObjectEditable (ACol, ARow : integer;
                                                    Editable : boolean);
begin
  if sgNr.Objects[ACol, ARow] <> nil then begin
    EditObject := TEditObject (sgNr.Objects[ACol, ARow]);
    EditObject.Editable := Editable;
    sgNr.Objects[ACol, ARow] := EditObject;
  end;
end;

So geht das ganze offensichtlich. Es geht hier darum, eine Eigenschaft des StringGrid-Objektes nur zu verändern unter der Vorrausetzung, daß es schon da ist. 8) Allerdings habe ich andere Aussagen gelesen, daß die Zeile :

Delphi-Quellcode:

EditObject := TEditObject (sgNr.Objects[ACol, ARow]);

Besser gesagt, eine Zuweisung an das Objekt nicht nötig sei, da es ohnehin an die Zelle gebunden ist. Das Object sieht so aus :

Delphi-Quellcode:

  TEditObject = class(TObject)
    public    
      Editable : boolean; 
...
  end;

Der Typecast hier :

Delphi-Quellcode:

EditObject := TEditObject (sgNr.Objects[ACol, ARow]);

ist mir im Zusammenhang auch noch nicht vollständig klar.

Wer weiß mehr ? Das Ding ist schon wichtig, aber ich denke schon daran, daß nicht mehr rauskommt als hier :

http://www.delphipraxis.net/internal...ect.php?t=4012

http://www.delphipraxis.net/internal...t=objektablage

Ist zwar schon länger her, aber mittlerweile alles voll im produktiven Einsatz. Dem Thema hier droht wohl dasselbe Schicksal.

[Christian Seehase]

Moin Hansa,

die Zeile

Delphi-Quellcode:

EditObject := TEditObject (sgNr.Objects[ACol, ARow]);

ist nicht notwendig, da Du das Objekt auch direkt so ansprechen kannst:

Delphi-Quellcode:

procedure TfrmEin.ChangeEditObjectEditable (ACol, ARow : integer;
                                                    Editable : boolean);
begin
  if sgNr.Objects[ACol, ARow] <> nil then begin
    (sgNr.Objects[ACol, ARow] as TEditObject).Editable := Editable;
  end;
end;

Wie sieht eigentlich die vollständige Deklaration Deines EditObjects aus?

[kiar]

@chris,

moin, das würde mich mal interessieren, wie du das mit den 32 bool werten meinst.

rak

[Christian Seehase]

Moin Raik,

meine Aussage bezog sich hierauf:

Zitat:

Zitat von Hansa

...spricht etwas dagegen, pro Zelle ein Object mit 5 Bool-Werten anzulegen...

wenn es sich ausschliesslich um boolsche Werte handelt, so lassen sich diese ja in fünf Bits darstellen.
Der Pointer den ein TObject darstellt ist 32-Bit gross, kann also sogar 32 derartige Werte enthalten.
Man muss ja nicht zwingend ein Objekt erzeugen, um den Pointer mit einem Wert zu füllen.

Beispiel (ein wenig auf Hansas Postings bezogen)

Delphi-Quellcode:

const
  _iEditable = $00000001; // Zelle ist editierbar
  _iScanned  = $00000020; // Zelleninhalt wurde gescannt
  _iColorRed = $00000040; // Zelle soll rot sein
//...

// Den Pointer mit den beiden Bits belegen
sgNr.Objects[ACol, ARow] := TObject(_iEditable or _iScanned);

Jetzt enthält das Objekt der Zelle die zwei boolschen Werte (gesetzt), ohne dass ein Objekt erzeugt wurde.
Im Beispiel ist jetzt für die Zelle hinterlegt, dass sie editierbar ist, und das ihr derzeitiger Wert durch Scannen erzeugt wurde.
Sie soll nicht rot eingefärbt werden.

[kiar]

hallo chris,

das ist ja cool ,

danke wieder etwas gelernt. :thumb:

raik

[Robert_G]

Zitat:

Zitat von kiar

@chris,

moin, das würde mich mal interessieren, wie du das mit den 32 bool werten meinst.

rak

Ein Objekt ist ja nur ein Pointer -> 4 Byte -> 32 Werte in einem set. (wie Christian bereits schrieb)
Wobei ich kein Profi für solches Low-Level-Gefriemel bin.
Ich würde das ganze als das abtun was es ist. Ein simpler oller 2-dimenionaler Array, der dir eigentlich nix bringt, was nicht schon eine Variable eines 2d-TObject-arrays bringen würde. -> TypCasting bis zum Umfallen :?
Es wäre vielleicht sinnvoller von dem Grid abzuleiten und die Items gleich von der Klasse zu nehmen, die deinen Daten entspricht.
Oder besser: Eine Collection dieser Klasse, die du an das Grid packen kannst,...
Was auch immer du machst, es wäre sicher lesbarer und flexibler wenn du nicht diesen komischen Array nutzt. (So wie es bis jetzt aussieht hast du ja dein Formular mit einer Menge Code zugestopft, der da nicht hingehört. ;) )

[kiar]

hallo robert,

das ist mir schon klar. ich wäre nur nie auf die Idee gekommen, es so zu realisieren.


raik

[Hansa]

Hi,

habe das ganze mal durchexerziert. 8) Das geht so weit schon und ist wohl auch für solche Fälle gedacht. Aber : Ich kann ein neues Object erzeugen, mit row = row + 300 !! Für diese Dinger dann wieder wegzukriegen genügt es also nicht die Zellen eines Stringrids mit Rowcount, Free usw. durchzugehen.

Was ist jetzt ? Wer setzt das konkret ein ?

[Hansa]

Ja, die Frage ist zumindest teilweise noch offen. Wer setzt das in der Praxis ein ?

[Sharky]

Zitat:

Zitat von Hansa

Ja, die Frage ist zumindest teilweise noch offen. Wer setzt das in der Praxis ein ?

Ich :stupid:
Z.b. "Missbrauche" ich via TypCasting die Eigenschaft Object (bzw. Data bei einem TListView) dafür um die IDs von Datensätzen einer Tabelle zu speichern.
In einem anderen Probjekt (Auftragserfassung) habe ich in einem eigenen Objekt, das im prinzip nur ein Record war, Informationen zu jeder Zeile gespeichert die dort nicht angezeigt werden sollten da diese Werte in Editfeldern gezeigt wurden.
Ich finde das eine ganz tolle Sache. Man muss nur daran denken das man die erzeugten Objekte beim Löschen einer Zelle/Zeile selber wieder freigeben muss. Auch beim schliessen der Form muss man sich um die Freigabe der Objekte selber kümmern.

[plautzer]

Hi,

ich habe ähnliche Fragen wie Hansi. Mir wurde schonmal nahe gelegt, TObject zu benutzen, aber bis jetzt sehe ich keinen wirklichen Sinn darin.

Ich habe ebenfalls ein Beispiel, bei dem ich gern wissen würde, ob das mit einen TObject besser umzusetzen wäre.

Ich will einfach alle Zeilen im Grid in Arrays gespeichert haben, damit ich diese per Speicherklick dann alle abarbeiten bzw speichern kann.

Meine Variante ist eine bissl umständlicher, aber funktioniert auch:

Delphi-Quellcode:

procedure TFmain.StringGridSetEditText(Sender: TObject; ACol, ARow: Integer; const Value: String);
begin   //Sobald ein feld editiert wird, wird die RowNummer im array a[x] gespeichert und die Änderungen im Label festgehalten 
if posproof(strtoint(lgrid_change.Caption),stringgrid.Row) = false then
begin
setlength(a,stringgrid.RowCount);
zahl:=strtoint(lgrid_change.Caption);
a[zahl]:=stringgrid.Row;
lgrid_change.Caption:=inttostr(zahl+1);
end;
end;

//Die Funktion um die Position der reihe zu ermitteln

function TFmain.posproof(label_zahl,reihe:integer):boolean;
begin
if label_zahl > 0 then
  begin
    zahl:=1;
    while zahl < label_zahl do
      begin
      if reihe= a[zahl] then
      begin
      result:=true;
      exit;
      end
      else zahl:=zahl+1;
   end;
   result:=false;
end
else result:=false;
end;

//Das Speichern... 

   zahl:=1;
   while zahl < strtoint(lgrid_change.Caption) do
   begin
   DM.SP_abrechnung_update.Params[0].AsString:= stringgrid.Cells[0,a[zahl]];
   DM.SP_abrechnung_update.Params[1].AsString:= stringgrid.Cells[1,a[zahl]];
   ...
   DM.SP_abrechnung_update.ExecProc;
   Dm.IBTrans.Commit;
   DM.IBTrans.Active := True;
   DM.Abrechnung.Open;
   zahl:=zahl+1;
   end;

Wie ihr sehen könnt fehlt mir noch die Prüfung ob ünberhaupt etwas geändert wurde. Kann man das über ein TObject lösen, sodass man den alten Zelleninhalt im TObject speichert und ihm beim Verlassen der Zelle mit dem neuen Zelleninhalt vergleicht?

Und könnte ich gleich die geänderten in den Arrays speichern und dann abarbeiten, ohne das ich die Anzahl der Veränderungen im Label speichere?


Schön Abend noch,

Plautzer

[Hansa]

Zitat:

Zitat von plautzer

Ich will einfach alle Zeilen im Grid in Arrays gespeichert haben, damit ich diese per Speicherklick dann alle abarbeiten bzw speichern kann...

Irgendwie bist du auf dem Holzweg. Warum noch ein Array für ein Stringgrid ? :shock: Auf meiner Glaskugel steht allerdings, du willst für einzelne Zellen festhalten, ob sie geändert worden sind ?

Und dafür die Stringgrid-Objects benutzen ? Das würde schon so gehen. Allerdings würde ich alles von Anfang an lesen. Da muß schon noch einiges bedacht werden.

[plautzer]

Zitat:

Zitat von Hansa

Irgendwie bist du auf dem Holzweg. Warum noch ein Array für ein Stringgrid ? ..

Kannst du das nochmal näher erläutern?
Ich wüsste mir sonst nicht weiter zu helfen.

Ich möchte ermöglichen, dass man verschiedene Zellen bzw. Zeilen im Stringgrid editieren kann und dann nur die geänderten Zeilen auch geupdatet werden.

Ich könnte es zwar so machen, das ich immer alles speichere, aber geht bei mir nicht, das ich jede Änderung(Zeitpunkt) festhalte und die sich dann ändern würde, auch wenn garnichts editiert wurde.

Ich habe jetzt noch folgendes Problem, und zwar habe ich nun die Daten aus der Tabelle auf X Tabellen verteilt.Ich muss nun realisieren, dass wenn man in den verschiedene Tabellen editiert und dann speichert, auch alle Daten geupdadet werden. Das kann ich nicht wie oben lösen.

Ich müsste an jeder Zelle eine Objekt,dranhängen, das den Tabellenname, die Zeile und wenns noch geht die ID beinhält.

Wie gesagt, muss ich das ganze wieder in Variablen (Arrays) speichern um dann alle auf einmal zu speichern.

Nochmal zur Änderung im Zelleinhalt:

Zitat:

Und dafür die Stringgrid-Objects benutzen ?

Gibt es noch andere möglichkeiten, außer zwei EDITS (vorher,nachher) zu vergleichen?


THx,

Plautzer

[Hansa]

Du brauchst das Array nicht, weil du sowieso für jede Zelle ein Object mit Row und Col hast.

Dein Object würde dann so aussehen :

Delphi-Quellcode:

  TPlautzerObject = class(TObject)
    editierbar : boolean;  
    ID         : integer;
    TableName  : string;
  end;

[plautzer]

Mahlzeit,

wenn ich das jetzt richtig verstehe, dann setze ich den Wert editiert der Zelle auf true. Wenn ich dann alles speichern will, dann lese ich alle zelle die aud true gesetz sind aus und kann mit den angehängten Informationen(reihe und ID), den ganzen Spaß auslesen, oder?

Bin ich damit wieder auf den Holzweg? Wenn nicht, dann würde ich gern wissen wie man die Objekte wieder ausliest.

Thx,

Plautzer

[Hansa]

Wenn das alles ist was du wissen willst, dann bist du nicht auf dem Holzweg. Aber leider "no time". Prüfe einfach auf NIL. :mrgreen:

[plautzer]

HI,

ich bin mal euer beispiel nachgegangen und es hat bei mir auch einwandfrei funktionieren, doch in diesem spezielleren fall wiederrum nicht:

Und zwar werden per buttonklick, die daten aus der tabelle nach ihre Ablesejahr auf x Stinggrids verteilt. Es werden die Stringgrids erstellt und anschließend gefüllt.

Delphi-Quellcode:

Tgrid = class(Tstringgrid)
    public
    name:tgrid;
    editiert : boolean;
    ID         : integer;
    TableName  : string;
  end;
Treihe = class(tobject)
   private
   nr: integer;
   end;

procedure TForm1.AddObjectToGrid(ACol, ARow : integer; nr : integer);
begin
  reihe := Treihe.Create;
  reihe.nr := nr;
  Form1.st_grid.Objects[ACol, ARow] := reihe;
end;

function TForm1.TestForEdit(ACol, ARow : integer):integer;
begin
  reihe := Treihe(sT_grid.Objects[ACol, ARow]);
  result := reihe.nr;
end;

procedure TForm1.Button10Click(Sender: TObject);
var datum:tdatetime;
    i,s,k,x,y, datum1:integer;
    a:string;
begin
ibdataset1.Close;
ibdataset1.SelectSQL.Clear;
ibdataset1.SelectSQL.Text := 'select distinct EXTRACT(YEAR FROM ABLESEDATUM) as ablesejahr from ABRECHNUNG';
ibdataset1.Open;
i:=0;
while i < ibdataset1.RecordCount do
begin
datum1:=ibdataset1.fieldbyname('ablesejahr').AsInteger;
NewTabSheet := TTabSheet.Create(PageControl1);
NewTabSheet.PageControl := PageControl1;
newtabsheet.Caption:= inttostr(datum1);

st_grid:=tgrid.Create(newtabsheet);
st_grid.Parent := newtabsheet;
st_grid.TableName:='grid' + inttostr(datum1);

with st_grid do
begin
Left := 0;
Top := 0;
Width := newtabsheet.Height-5;
Height := newtabsheet.Width-5;
SetBounds(4,4,newtabsheet.Width-5,newtabsheet.Height-5);
ColCount := 12;
DefaultColWidth := 17;
DefaultRowHeight := 17;
RowCount := 2;
Options := [goFixedVertLine, goFixedHorzLine, goVertLine, goHorzLine, goRangeSelect, goEditing];
TabOrder := 0;

ColWidths[1]:=17;
ColWidths[2]:=53;
ColWidths[3]:=50;
{ColWidths[4]:=54;
ColWidths[5]:=55;
ColWidths[6]:=54;
ColWidths[7]:=71;
ColWidths[8]:=71;
ColWidths[9]:=67;
ColWidths[10]:=45;
ColWidths[11]:=57;
ColWidths[12]:=23;}
RowHeights[1] := 17;
OnSelectCell := stringgrid1SelectCell;   //Objekt nr der Zelle wd
end;
ibdataset2.Close;
ibdataset2.SelectSQL.Clear;
ibdataset2.SelectSQL.Text := 'select ABLESEDATUM, ablese_nr from ABRECHNUNG where EXTRACT(YEAR FROM ABLESEDATUM) = :a';
ibdataset2.ParamByName('a').AsInteger:=datum1;
ibdataset2.Open;

  k:=0;
  While K < ibDataset2.RecordCount do
  Begin
   st_grid.RowCount := st_grid.RowCount +1;
   st_grid.Cells[1,k+1]:=ibdataset2.fieldbyname('ablese_nr').AsString;
   st_grid.Cells[2,k+1]:=ibdataset2.fieldbyname('ablesedatum').AsString;
   AddObjectToGrid(1, k+1, ibdataset2.fieldbyname('ablese_nr').AsInteger);
   AddObjectToGrid(2, k+1, ibdataset2.fieldbyname('ablese_nr').AsInteger);
   ibdataset2.Next;
   k:=k+1
  end;
  st_grid.RowCount := st_grid.RowCount -1;

ibdataset1.Next;
i:=i+1;
end;

Mein problem:

Es wird zwar jeder Zelle ein Objekt(Nr) zugeordnet, jedoch erscheint beim Zellenklick immer die letzte NR aus der letzten Tabelle!!!

Ich denke, das problem liegt daran dass alle stringgrid gleich heißen, nämlich "st_grid" und dann immer der Wert aus dem letzten Grid genommen.

Wie kann ich jedem grid einen eigenen Namen geben, den ich dann bei späteren Prozeduren leicht auslesen kann?

Ich glaube mit arrays brauche ich nicht mehr ankommen, oder?

Thx,

Plautzer

[Khabarakh]

str_grid und newtabsheet solltest du nur lokal in der ButtonClick-Prozedur deklarieren. Ändere dann TestForEdit in

Delphi-Quellcode:

function TForm1.TestForEdit(ACol, ARow : integer; grid: TStringgrid):integer;

um, da es ja in den vorigen Beispielen nur ein Grid gab. Um also das richtige Grid durch den Sender auszuwählen:

Delphi-Quellcode:

[...]
if TestForEdit(ACol, ARow, Sender as TStringgrid) then
[...]

[plautzer]

FUNZT!!!


Dank dir.

[Hansa]

Das ist gut, aber denke daran, daß das nicht alles ist. Die Objekte müssen wieder freigegeben werden.

[plautzer]

mahlzeit,

freigeben: aber erst beim schließen der Programms, oder? Was passiert wenns man's nicht macht?`

Wenn einen Zelle bearbeitet wird, bekommt sie eine Object 'editiert'.

Delphi-Quellcode:

procedure TForm1.AddeditObjectToGrid(ACol, ARow : integer);
var st_grid:tgrid;
begin
  reihe := Treihe.Create;
  reihe.editiert := editiert;
  Form1.st_grid.Objects[ACol, ARow] := reihe;
end;

wie kann ich nun aus lesen, welche zelle in welchen grid dieses object hat?
Nil ist mir schon bekannt, aber ganz bekommen ich das nicht hin.

Delphi-Quellcode:

function TForm1.TestForEditiert(ACol, ARow : integer; grid: TStringgrid):boolean;
var st_grid:tgrid;
begin
    if grid.Objects[ACol, ARow] <> nil then begin
  reihe := Treihe(grid.Objects[ACol, ARow]);
  result := reihe.editiert;
  end
  else
    result := false;
end;

Per buttonclick soll mit allen editierten zellen irgentwas passieren, z.b. das objekt nr an eine listbox abgeben werden. Könnt ihr mir da nochmal aushelfen?

Thx,

Plautzer

[Hansa]

Deine Nomenklatur ist etwas verwirrend. 8) Ist Reihe eine Zelle des Grids oder was ? :gruebel: Dann nenne sie doch Zelle. Was das freigeben betrifft :

Delphi-Quellcode:

  for i := sgNr.FixedCols to sgNr.ColCount - 1 do
    for j := sgNr.FixedRows to sgNr.RowCount - 1 do
      if sgNr.Objects [i,j] <> nil then begin
        sgNr.Objects [i,j].Free;
        sgNr.Objects [i,j] := nil;
      end;

Das steht bei mir im FormHide. FormClose ginge auch.

[plautzer]

Hmm, stimmt das mit der reihe ist ein bizzl verwirren, ich habs auch nur so genannt, weil für mich die reihe interessant ist, welche zelle davon ist egal. Aber stimmt schon, das werde ich mal ändern.

Lassen sich nun alle vorhanden Grids auf das onject editiert untersuchen?

Plautzer

[Hansa]

Das hängt von Deiner Programm-Architektur ab. Bei mir gibts ein Grid, in dem alles definiert ist. Und dieses vererbe ich weiter. In den Stringgrid-Objekten habe ich alles für die Zellen nötige hinterlegt : Color, MouseSelect (ähnlich wie dein editable) und einiges mehr. In dem Ursprungsgrid sind die Events auch hinterlegt und die Prozeduren, Werte zu ändern. z.B. so :

Delphi-Quellcode:

procedure Tfrm.ChangeEditObjectMouseSelect (ACol, ARow : integer;   // zum Ändern von
                                            MouseSelect : boolean); // Eigenschaften pro Zelle
begin
  if sgNr.Objects[ACol, ARow] <> nil then
    (sgNr.Objects[ACol, ARow] as TEditObject).MouseSelect := MouseSelect;
end;

Will ich nun eine Zelle sperren, dann rufe ich das einfach so auf :

Delphi-Quellcode:

ChangeEditObjectMouseSelect (2,2,false);

In diesem Fall käme ich an Zelle 2,2 nicht mehr dran.

[plautzer]

soviel habe ich ja verstanden. Wenn ich die geänderten Zellen speichern will, muss ich erst einaml herauskriegen welche das sind.

Am besten wäre es, wenn man alle Zeilen im grid durchgehen könnten und prüft ob, diese editiert wurde, wenn ja, dann folgt gleich die speicherung, der ganzen ZEILE etc.

Mein problem ist, das ich nicht weiss wieviel einträge jedes Grid hat und wie viele grids überhaupt vorhanden sind. Also macht sich da ne schleife nicht gut.

Plautzer