Farbe von mit OnDrawcell gefärbter StringGridZelle abfragen

[Stecky2000]

Ich hoffe, der Tietel sagt schon genug.

Ich habe ine einem StringGrid, mittels OnDrawCell, bestimmte Zellen nach bestimmten Bedingungen mit verschiedenen Farben eingefärbt.

In einem StringGrid von 7x24 zellen sind z. B. 12 versch. Zellne mit clLime, 4 versch. mit clRed und 4 mit clBlue eingefärbt.

Nun habe ich die Inhalte des stringGrids nach Excel exportiert, was auch gut klappt.
Nur möchte ich nun auch die Färbung der Zelle mit senden.

Wie ich die Färbung in Excel erzeuge ist kein Prob, nur muss ich vorher abfragen, welche Zelle im StringGrid eine farbe x besitzt.

Ich habe es so versucht, hatte aber null Erfolg:

Delphi-Quellcode:

 if StringGrid1.Canvas.Brush.Color = clLime then

Da fehlt aber die Bestimmung der Zelle.

Damit ging aber gar nichts:

Delphi-Quellcode:

 if StringGrid1Cells[x, y].Canvas.Brush.Color = clLime then

Weis jemand einen rat?

[Bernhard Geyer]

Wie wäre es die gleichen Auswertungscode auch beim Excel-Export zu verwenden?

[Helmi]

Hallo,

wie wäre es wenn du dir die Farbe als Object in der Zelle speicherst?
Dies müsste meines Erachtens möglich sein - kanns momentan aber nicht
testen, weil ich kein Delphi auf dem Firmenrechner habe.

[Stecky2000]

Sorry, aber ich verstehe nur Bahnhof.

Bin nur ein Hobby-Programmierer und steck da nicht so tief drin.

Also noch mal zur Verdeutlichung:

In eine StringGrid1 mit 7x24, ist für einen Dienstplan mit 7 Tagen und 24 Wochen,

stehen Zahlen drin so z.B. 1,1,1,2,2,0,0, das wären die 7 Zellen in einer Zeile.

Nun hab ich Bedingungen, z.B.
wenn in StringGrid2[Spalte1,Wertx] das Zeichen "x" drin steht, dann zeichne in StringGrid1 die entsprechende Zelle clLime.

Beim export nach excel will ich diese Abfrage nicht machen, sondern gleich sagen,

Delphi-Quellcode:

For i := 1 to 24 do
  For j := 1 to 7 do
     begin
        Excel.Cells[i, j] := StringGrid1.Cells[j, i];
        If StringGrid1.Cells[j, i].Canvas.Brush.Color = clLime then
           Excel.Selection.Interior.ColorIndex := 4;
     end;

So was in der Art. Die Zellen des StringGrid1 müssen mir doch irgendwie Auskunft darüber geben können, ob sie
clLime, clRed, oder clBlue sind?

[taaktaak]

Moin, Moin.
Diese Information ist im StandardGrid nicht verfügbar. Im Post#3 wurde dir ja eine mögliche Lösung vorgeschlagen:

In OnDrawCell() übergibts du die Information, mit welcher Farbe du den Zellhintergrund füllst, an die Objektvariable die für jede Zelle des Grids verfügbar ist: Stringgrid.Objects[aCol,aRow]. Da diese Variable vom Typ TObject ist muss dies über ein Typecasting von TColor nach TObject erfolgen.
Zum Zeitpunkt des Exports nach Excel gehst du den umgekehrten Weg. Der Inhalt der korrespondierenden Objektvariable wird von TObject nach TColor gewandelt.

So müsste es eigentlich funktionieren.

[Stecky2000]

Hallo TaakTaak,

Danke für die Antwort, aber ich verstehe es nicht.

In meinen OnDrawCell wird wie folgt vorgegeangen:

Delphi-Quellcode:

procedure TDPLForm.StringGrid1DrawCell(Sender: TObject; ACol, ARow: Integer;
  Rect: TRect; State: TGridDrawState);

begin
  with (Sender as TStringGrid) do
  begin
    // Don't change color for first Column, first row
    if (ACol = 0) or (ARow = 0) then
      Canvas.Brush.Color := clBtnFace
    else
    begin
         if (cells[ACol, ARow] <> '') and (cells[ACol, ARow] <> ' ') then
           if cells[ACol, ARow] = StringGrid3.Cells[0, StrToInt(cells[ACol, ARow])] then
               begin
                    if (StringGrid3.Cells[1, StrToInt(cells[ACol, ARow])] = 'x') or (StringGrid3.Cells[1, StrToInt(cells[ACol, ARow])] = 'X') then
                       begin
                            Canvas.Brush.Color := clLime;
                            Canvas.TextRect(Rect, Rect.Left + 2, Rect.Top + 2, cells[acol, arow]);
                            Canvas.FrameRect(Rect);
                       end;
                    if (StringGrid3.Cells[1, StrToInt(cells[ACol, ARow])] = 'd') or (StringGrid3.Cells[1, StrToInt(cells[ACol, ARow])] = 'D') then
                       begin
                            Canvas.Brush.Color := clRed;
                            Canvas.Font.Color := clWhite;
                            Canvas.Font.Style := [fsbold];
                            Canvas.TextRect(Rect, Rect.Left + 2, Rect.Top + 2, cells[acol, arow]);
                            Canvas.FrameRect(Rect);
                       end;
                    if (StringGrid3.Cells[1, StrToInt(cells[ACol, ARow])] = 'g') or (StringGrid3.Cells[1, StrToInt(cells[ACol, ARow])] = 'G') then
                       begin
                            Canvas.Brush.Color := clBlue;
                            Canvas.Font.Color := clWhite;
                            Canvas.Font.Style := [fsbold];
                            Canvas.TextRect(Rect, Rect.Left + 2, Rect.Top + 2, cells[acol, arow]);
                            Canvas.FrameRect(Rect);
                       end;
                    if (StringGrid3.Cells[2, StrToInt(cells[ACol, ARow])] = '') then
                       begin
                            Canvas.Brush.Color := clBlack;
                            Canvas.Font.Color := clWhite;
                            Canvas.Font.Style := [fsbold];
                            Canvas.TextRect(Rect, Rect.Left + 2, Rect.Top + 2, cells[acol, arow]);
                            Canvas.FrameRect(Rect);
                       end;
               end;
    end;
  end;
end;

Ich schreibe die Farbe also nur mit

Delphi-Quellcode:

Canvas.Brush.Color := clLime;

rein.

Ich habe darauf hin und nach deiner Antwort folgendes versucht, aber ohne Erfolg:

Delphi-Quellcode:

Color := Integer(StringGrid1.Objects[j, i]);

Das geht aber auch nicht, da steht in der Variablen Color immer nur 0 drin;

[taaktaak]

hihihi, genau anders 'rum!

Die Farbe muss ins Objekt! Deine Zuweisung läuft ja genau in die falsche Richtung. So wie es dort steht, musst du es machen, wenn du die Daten exportierst.

[Stecky2000]

Ich glaube wir reden an einander vorbei.

Ich will doch gerade exportieren.

Dazu will ich doch wissen ob in StrinGrid1 eine Zelle eingefärbt ist, damit ich dann in Excel ebenfalls die Zelle färbe.

Das Abfragen ob die Zelle im StringGrid gefäbt ist wollte ich nun damit machen:

Delphi-Quellcode:

Color := Integer(StringGrid1.Objects[j, i]);

Ich habe dazu speziell eine Version von meinem Prg/Dienstplan gemacht, in der gleich in Zeile 1 des StringGrids,
die Spalte 1 grün ist, die Spalte 2 rot ist und die Spalte 3 blau ist.

Wenn nun oben beschriebene Schleifen in Spalte1/Zeile1 läuft zeigt die Variable Color immer 0.

Bitte sage mir, ob ich dich komplett missverstehe und hilf mir bitte auf die Sprünge.

[taaktaak]

Ahhh, verstehe,
wir reden aber nur zum Teil aneinander vorbei:

Bevor du die Farbe aus Objects (beim Export) lesen kannst, muss der Wert ja erst einmal dort abgelegt werden. Das muss im OnDrawCell() geschehen. Da sehe ich in deinem Code nix, wo das passiert: Überall dort, wo du den Hintergrund färbst, musst du zusätzlich die verwendete Farbe ins Object speichern, also z.B.

Delphi-Quellcode:

 ...then begin 
  Canvas.Brush.Color := clLime; 
  Canvas.TextRect(Rect, Rect.Left + 2, Rect.Top + 2, cells[acol, arow]); 
  Canvas.FrameRect(Rect); 
  TStringGrid(Sender).Objects[aCol,aRow]:=Integer(Canvas.Brush.Color) // <<< !!!!!
  end;

// edit: Ich glaub, das "TStringGrid(Sender)." ist überflüssig?!

[Stecky2000]

Also an dieser Stelle im OnDrawCell erscheint die Farbe im StringGrid in Grün (Hintergrund der zelle):

Delphi-Quellcode:

Canvas.FrameRect(Rect);

Bedeutet das, das ich die Zelle zwar färbe aber dne Farbwert nicht in die Zelle schreibe/speichere und ihn deshalb auch nicht wieder auslesenkann?

Ich dachte, wenn die Zelle grün ist, dann ist sie eben grün und weis das auch.

Edit:
Nun hab ich damit

Delphi-Quellcode:

StringGrid1.Objects[aCol,aRow] := Integer(Canvas.Brush.Color);

versucht den Wert zu speichern, aber da sagt er immer, "inkompatible Typen TObject und Integer;

Und bei

Delphi-Quellcode:

TStringGrid(Sender).Objects[aCol,aRow] := Integer(Canvas.Brush.Color);

das gleiche.

[taaktaak]

Sorry, sorry, sorry :pale:

Das war ein wenig schusselig von mir. Die Typecasts sind falsch. Richtig ist:

Delphi-Quellcode:

StringGrid1.Objects[ACol,ARow]:=Pointer(Canvas.Brush.Color); // in OnDrawCell()

Color:=TColor(StringGrid1.Objects[aCol,ARow]); // in ExportProzedur

übrige Fragen: Nein, die Zelle hat keine Information, welche Farbe sie einnehmen soll - aus diesem Grund färbst DU die Zelle im OnDrawCell(). Und weil die Zelle diese Information nicht besitzt, legst du die Farbinformation in Objects[] ab, um später in der Exportprozedur darauf zugreifen zu können.

[Stecky2000]

Danke, bin vor einer Minute selbst auf DEINE Lösung gekommen,...... fast.

Ich habe es so gemacht:

Delphi-Quellcode:

  begin  
    Canvas.Brush.Color := clLime;
    TStringGrid(Sender).Objects[aCol,aRow] := Pointer(clLime);
    Canvas.Font.Color := clBlack;
    Canvas.Font.Style := [fsbold];
    Canvas.TextRect(Rect, Rect.Left + 2, Rect.Top + 2, cells[acol, arow]);
    Canvas.FrameRect(Rect);
  end;

Das geht wohl auch mit StringGrid1.Objects statt TStringGrid(Sender).Objects und
beim Pointer mit (clLime) oder eben mit (Canvas.Brush.Color) aber,

die gefärbte Zelle flimmert dann extrem, in allen Fällen.
Das war vorher nicht.

Wie bekomme ich das weg?

[taaktaak]

Hmmm :shock: :shock:
Habe keine Idee warum es flackert.
Spontane Idee: Den Farbwert nur dem Objekt zuweisen, wenn etwas anderes (also nix oder 'ne andere Farbe) enthalten ist. Das reduziert den schreibenden Zugriff - ob das was bringt?
Probiere es mal aus.

[Stecky2000]

Hab schon alles probiert, Reihenfolge, Dinge weglassen, bringt nichts.
Es flackert sobald ich in Objects reinschreibe.

[taaktaak]

Mir ist aufgefallen, dass du mit

Delphi-Quellcode:

Canvas.Brush.Color := clBlue; 
Canvas.Font.Color := clWhite; 
Canvas.Font.Style := [fsbold]; 
Canvas.TextRect(Rect, Rect.Left + 2, Rect.Top + 2, cells[acol, arow]); 
Canvas.FrameRect(Rect);

eine mir ungewohnt erscheinende Art der Ausgabe verwendest. Offensichtlich funktioniert sie, aber üblicherweise schaut das eher so aus..

Delphi-Quellcode:

Canvas.Brush.Color := clBlue;
Canvas.FillRect(Rect);
Canvas.Font.Color := clWhite; 
Canvas.Font.Style := [fsbold]; 
Canvas.Textout(Canvas.Handle,Rect.Left+2,Rect.Top+2,PChar(Cells[acol,arow]),length(cells[acol,arow]));

Flackert es auch mit dieser Ausgabeversion?

[Helmi]

Hallo,

ich mach in meiner Software in OnDrawCell das gleiche

Delphi-Quellcode:

      Brush.Color := Integer(Objects[aCol, ARow]);
      FillRect(Rect);

Aber bei mir flattert nichts

[Stecky2000]

Die ungewöhnliche Ausgabeform habe ich hier aus dem Forum.

Deine Form funktioniert bei mir nicht, da bekomme ich den Fehler: Inkompatible Typen String und Integer.

[taaktaak]

Oh Mann! Oh Mann!
Muss natürlich

Delphi-Quellcode:

Textout(Canvas.Handle,Rect.Left+2,Rect.Top+2,PChar(Cells[aCol,aRow]),length(Cells[aCol,aRow]));

sein, dass Canvas muss weg.
Ach, ich mach besser Schluß für heute ...

[Lannes]

Hallo,

Zitat:

Zitat von Stecky2000

Hab schon alles probiert, Reihenfolge, Dinge weglassen, bringt nichts.
Es flackert sobald ich in Objects reinschreibe.

das muss flackern, denn durch das setzen von Objects wird das Neuzeichnen der Zelle = Ereignis OnDrawCell, ausgelöst. In OnDrawCell wird dann wieder Objects gesetzt = Neuzeichnen der Zelle = Ereignis OnDrawCell usw. usw. :arrow: das Ereignis löst sich quasi selbst immer wieder aus.
Merksatz: Innerhalb solcher Ereignisbehandlungs-Routinen wie, OnDrawCell, OnDrawItem etc. nie Code ausführen der ein Neuzeichnen auslöst.

Die Lösung Deines Problems steht in Beitrag #2

Zitat:

Zitat von Stecky2000

... Beim export nach excel will ich diese Abfrage nicht machen, sondern gleich sagen,

Delphi-Quellcode:

For i := 1 to 24 do
  For j := 1 to 7 do
     begin
        Excel.Cells[i, j] := StringGrid1.Cells[j, i];
        If StringGrid1.Cells[j, i].Canvas.Brush.Color = clLime then
           Excel.Selection.Interior.ColorIndex := 4;
     end;

So was in der Art. Die Zellen des StringGrid1 müssen mir doch irgendwie Auskunft darüber geben können, ob sie
clLime, clRed, oder clBlue sind?

Die Zellen können Dir die Auskunft geben.
Mal im groben:
Steht in der Zelle ein X dann wird sie in OnDrawCell in ClLime gezeichnet, also setz in ColorIndex eine 4.
Dein Code abgewandelt:

Delphi-Quellcode:

var s : String;
//...
For i := 1 to 24 do
  For j := 1 to 7 do
     begin
     s := StringGrid1.Cells[j, i];
     Excel.Cells[i, j] := s;
     If s = 'X' then
       Excel.Selection.Interior.ColorIndex := 4;
     end;

[Stecky2000]

Lannes, Du hast Recht und ich danke dir, auch wenn ich genau diese Lösung bereits vor deinem Post selbst eingebaut habe.

Wie Du in einem meiner ersten Post bereits zitiert hast,

"... Beim export nach excel will ich diese Abfrage nicht machen, sondern gleich sagen, "

wollte ich genau diese Lösung nicht, letztendlich, da sich das mit dem Flackern nicht lösen lies, habe ich es genau so eingebaut, mit abgewmdeltem Code da ich das ganze mit dem "X" in einem anderen StringGrid checke.

Es freut mich, dass ich doch langsam begreife warum was nicht geht, denn ich hatte bereits das gleiche vermutet, wie Du jetzt sagst:

"das muss flackern, denn durch das setzen von Objects wird das Neuzeichnen der Zelle = Ereignis OnDrawCell, ausgelöst."

Genau das habe ich schon bei anderer Gelegenheit festgestellt und sehe die Lösung für sowas genauso, keinen Code innerhalb der OnDrawCell der sozusagen OnDrawCell selbst immer wieder provoziert.

Mein Code sieht jetzt so aus:

Delphi-Quellcode:

Excel.Cells[i+6, j+1] := StringGrid1.Cells[j, i];
Excel.Cells[i+6, j+1].Select;
if (StringGrid1.Cells[j, i] <> '') and (StringGrid1.Cells[j, i] <> ' ') then
  if StringGrid1.Cells[j, i] = StringGrid3.Cells[0, StrToInt(StringGrid1.Cells[j, i])] then
    begin
      if (StringGrid3.Cells[1, StrToInt(StringGrid1.Cells[j, i])] = 'x') or 
         (StringGrid3.Cells[1, StrToInt(StringGrid1.Cells [j, i])] = 'X') then
             Excel.Selection.Interior.ColorIndex := 4;  //grün machen
             Excel.Selection.Interior.Pattern := xlSolid;
    end;

[taaktaak]

Das muss man natürlich erst mal wissen, das die Zuweisung selbst ein erneutes Draw auslöst - na, wieder was dazugelernt!

[Hobby-Programmierer]

Nabend ...,
das nenne ich ja jetzt mal 'die Kuh am Schwanz von der Weide ziehen'!
Warum zum Geier so einen Aufwand? Du machst dir selber ein Problem wo eigentlich keines sein dürfte, oder habe ich da was falsch verstanden?

- Du hebst anhand irgendwelcher Bedingungen die Zellen eines SG farblich hervor
- Exportierst nach Excel
- liest die Zellfarbe ein um die ebenfalls mitzuschicken
:wiejetzt:

Ein SG sollte eigentlich nur zur Darstellung und nicht zur Datenhaltung gebraucht werden! Für die Daten nimm lieber einen Record oder ein Array, dann hast du diese Sorgen nicht.

PS. Aber selbst wenn du deinen alten Gedanken verwenden möchtest, da flackert nix - siehe Demo
Zellfarbe abfragen geht mit

Delphi-Quellcode:

procedure TForm1.Panel1Click(Sender: TObject);
var cRow, cCol: Integer;
    farbe: TColor;
begin
  cCol:= StrToInt(Edit1.Text) +1;
  cRow:= ComboBox2.ItemIndex +1;
  farbe:= TColor(Grid_Plan.Objects[cCol, cRow]);

  if farbe = 0 then
    ... // dein Code
   else
    ... ; // dein Code
end;