Einfärben des Grids

[Flash68]

Hallo zusammen,

ich versuche mit folgender Procedure mein Grid abwechselnd einzufärben:

Delphi-Quellcode:

procedure TFRM_Main.DBG_RechnerDrawColumnCell(Sender: TObject;
  const Rect: TRect; DataCol: Integer; Column: TColumn; State: TGridDrawState);
  var
  test1: real;
  RowNo: Integer;
  farbe: Integer;
begin
  with (Sender as TDBGrid) do
  begin
    if (gdSelected in State) then
    begin
      Canvas.Brush.Color := clskyblue;
    end
    else
    begin
      rowno := DM_Rechner.ADO_DS_Rechner.RecNo;
      test1 := (Rowno / 2) - trunc(Rowno / 2);
      If test1 = 0 then
        begin
          farbe := Clwhite;
        end
        else
        Begin
          farbe := clsilver;
        end;
      canvas.brush.Color := farbe;
      canvas.Font.Color := ClBlack;
    end;
    canvas.FillRect(rect);
    canvas.TextOut(Rect.Left + 2, rect.Top + 1, column.Field.AsString);
 end
end;

bei meinen anderen Projekten funkioniert das auch, aber bei dem aktuellen Projekt ist alles clsilver und nicht abwechselnd silber und weiss.

Kann mir jemand helfen woran das liegt und wie ich das ändere?

Gruß

Flash

[DeddyH]

Benutze doch bitte Delphi-Tags, dann ist der Code auch besser zu lesen. Und Deine Ermittlung gerader/ungerader Zeilen erscheint mir doch sehr kompliziert, wieso nicht einfach Odd() oder mod 2 benutzen. Durch den Vergleich einer Fließkommazahl mit 0 kann es sein, dass das so nicht eintritt, da etwas wie 0,00000001 herauskommt.

[Flash68]

Wie benutze ich die Tags?

Wie gesagt bei meinen anderen Projekten funktioniert das ohne Probleme, habe den Code selbst im Internet gefunden.

[DeddyH]

Entweder über die "Helm"-Schaltfläche im Beitragseditor oder händisch mit [ delphi]Code[ /delphi] (ohne Leerzeichen). Und wie gesagt, das geht auch anders:

Delphi-Quellcode:

if Odd(DM_Rechner.ADO_DS_Rechner.RecNo) then
  farbe := clSilver
else
  farbe := clWhite;

//oder auch
if (DM_Rechner.ADO_DS_Rechner.RecNo and 1) = 0 then
  farbe := clWhite
else
  farbe := clSilver;

[Flash68]

OK hab es oben mal geändert, danke für den Tip.

Wegen des codes meinst du so:

Delphi-Quellcode:

procedure TFRM_Main.DBG_RechnerDrawColumnCell(Sender: TObject;
  const Rect: TRect; DataCol: Integer; Column: TColumn; State: TGridDrawState);
  var
  farbe: Integer;
begin
  with (Sender as TDBGrid) do
  begin
    if (gdSelected in State) then
    begin
      Canvas.Brush.Color := clskyblue;
    end
    else
    begin
      if Odd(DM_Rechner.ADO_DS_Rechner.RecNo) then
        farbe := clSilver
      else
        farbe := clWhite;
      {end; ist zu viel}
      canvas.brush.Color := farbe;
      canvas.Font.Color := ClBlack;
    end;
    canvas.FillRect(rect);
    canvas.TextOut(Rect.Left + 2, rect.Top + 1, column.Field.AsString);
 end
end;

[DeddyH]

Das sollte so richtig sein, zumindest ist mir nichts Negatives aufgefallen.

[Flash68]

Es war ein end zuviel, aber das hat leider nichts geändert, es wird noch immer alles in silber angezeigt(außer dem Cursor der ist blau).

[DeddyH]

Hast Du DefaultDrawing auf false gesetzt?

[Flash68]

Ne das steht auf True so wie bei meinen anderen Projekten auch.

[DeddyH]

Komisch. Wie ist es so?

Delphi-Quellcode:

procedure TFRM_Main.DBG_RechnerDrawColumnCell(Sender: TObject;
  const Rect: TRect; DataCol: Integer; Column: TColumn; State: TGridDrawState);
  var
  farbe: Integer;
begin
  with (Sender as TDBGrid) do
  begin
    if (gdSelected in State) then
    begin
      farbe := clskyblue;
    end
    else
    begin
      if Odd(DM_Rechner.ADO_DS_Rechner.RecNo) then
        farbe := clSilver
      else
        farbe := clWhite;
      end;
    end;
    canvas.brush.Color := farbe;
    DefaultDrawColumnCell(Rect, DataCol, Column, State) ;
  end;
end;

[edit] Oder mal ohne with:

Delphi-Quellcode:

procedure TFRM_Main.DBG_RechnerDrawColumnCell(Sender: TObject;
  const Rect: TRect; DataCol: Integer; Column: TColumn; State: TGridDrawState);
var
  grid: TDBGrid;
  farbe: TColor;
begin
  grid := Sender as TDBGrid;
  if (gdSelected in State) then
  begin
    farbe := clskyblue;
  end
  else
  begin
    if Odd(DM_Rechner.ADO_DS_Rechner.RecNo) then
      farbe := clSilver
    else
      farbe := clWhite;
    end;
  end;
  grid.canvas.brush.Color := farbe;
  grid.DefaultDrawColumnCell(Rect, DataCol, Column, State) ;
end;

[/edit]

[Flash68]

Da kennt er das DefaultDrawColumnCell nicht.

[DeddyH]

Das verstehe ich nicht, da das eine Methode von TCustomDBGrid ist.

[Flash68]

sagt es wäre ein undeklarierter Bezeichner.

[DeddyH]

Die Unit DBGrids ist aber eingebunden?

[Flash68]

ja die hab ich eingebunden.

[DeddyH]

Ist das jetzt eine Meldung von ErrorInsight, oder lässt sich das Projekt faktisch nicht kompilieren?

[Flash68]

Es wird in der Struktur angezeigt und das Projekt lässt sich nicht kompilieren.

[DeddyH]

OK, in meinem 2. Codebeispiel war ein end zuviel, nachdem ich das rausgelöscht habe, lässt sich das Projekt unter XE kompilieren. Ich habe keine Ahnung, was das sein könnte.

[Flash68]

Ich hab den Fehler gefunden:

Delphi-Quellcode:

procedure TFRM_Main.DBG_RechnerDrawColumnCell(Sender: TObject;
  const Rect: TRect; DataCol: Integer; Column: TColumn; State: TGridDrawState);
  var
  test1: real;
  RowNo: Integer;
  farbe: Integer;
begin
  with (Sender as TDBGrid) do
  begin
    if (gdSelected in State) then
    begin
      farbe := clskyblue;
    end
    else
    begin
      if Odd(DM_Rechner.ADO_DS_Rechner.RecNo) then
        farbe := clSilver
      else
        farbe := clWhite;
      end;
    canvas.brush.Color := farbe;
    DefaultDrawColumnCell(Rect, DataCol, Column, State) ;
  end;
end;

die letzten 2 Zeilen waren außerhalb des ends und deshalb wußte die procedure nicht das es zum dbgrid gehört.

Aber das hat auch nicht geholfen, es sind immer noch alle Zeilen silber.

[DeddyH]

Tja, ich weiß es auch nicht. Bei mir klappt es so wunderbar:

Delphi-Quellcode:

procedure TFRM_Main.DBG_RechnerDrawColumnCell(Sender: TObject; const Rect: TRect;
  DataCol: Integer; Column: TColumn; State: TGridDrawState);
var
  grid: TDBGrid;
  farbe: TColor;
begin
  grid := Sender as TDBGrid;
  if (gdSelected in State) then
  begin
    farbe := clSkyBlue;
  end
  else
  begin
    if Assigned(grid.Datasource) and Assigned(grid.Datasource.Dataset) and 
       Odd(grid.DataSource.DataSet.RecNo) then
      farbe := clSilver
    else
      farbe := clWhite;
  end;
  grid.Canvas.Brush.Color := farbe;
  grid.DefaultDrawColumnCell(Rect, DataCol, Column, State) ;
end;

[Flash68]

Bei mir funktioniert es mit beiden möglichkeiten nicht. Wie gesagt bei meinen anderen Projekten funktioniert meine alte Möglichkeit, nur hier halt nicht. Vielleicht hab ich ja woanders noch was nicht richtig eingestellt. Es ist bei allen Grids das gleiche.

[DeddyH]

Das kann ich Dir leider nicht sagen. Ich selbst habe am Grid überhaupt nichts geändert, sondern nur das Ereignis behandelt.

[Flash68]

Ich hab auch mal ein neues Projekt eröffnet mit der gleichen DB und habe dort den gleichen Fehler.

[DeddyH]

Da hilft dann leider nur Durchsteppen. Ich habe da rein gefühlsmäßig RecNo in Verdacht, die solltest Du einmal überprüfen.

[Sir Rufo]

Also meine Empfehlung wäre hierbei (das wird ja wohl andauernd benötigt, und müllt einem ja nur den Form-Quelltext zu) eine kleine Ableitung vorzunehmen, die auch gar nicht wehtut :mrgreen:

Vorneweg, wie man das benutzt:

Ganz, wichtig, diese Unit muss nach der Unit DBGrids eingebunden werden!

Delphi-Quellcode:

unit view.Main;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, Grids, DBGrids, StdCtrls, ExtCtrls,
  // Customizers at the end
  DBGrids.Customize;  // <<<--- Das macht die ganze Magie

type
  TForm1 = class( TForm )
    DBGrid1 : TDBGrid;
    procedure FormCreate( Sender : TObject );
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1 : TForm1;

implementation

{$R *.dfm}

procedure TForm1.FormCreate( Sender : TObject );
begin
  DBGrid1.OddColor := clMoneyGreen;
  DBGrid1.OddColorize := True;
end;

end.

fettich, nur noch die Datenquelle dranhauen und schon wird alles bunt.

Delphi-Quellcode:

unit DBGrids.Customize;

interface

uses
  Classes, Windows, Graphics, Grids, DBGrids;

type
  TDBGrid = class( DBGrids.TDBGrid )
  private
    fIsOdd :                 Boolean;
    fIsHighlight :           Boolean;
    fOddColor :              TColor;
    fOddFont :               TFont;
    fOddColorize :           Boolean;
    fOddFontColorAutomatic : Boolean;
    procedure SetOddColor( const Value : TColor );
    procedure SetOddColorize( const Value : Boolean );
    procedure SetOddFont( const Value : TFont );
    procedure SetOddFontColorAutomatic( const Value : Boolean );
  protected
    procedure DrawColumnCell( const Rect : TRect; DataCol : Integer; Column : TColumn; State : TGridDrawState ); override;
    procedure DrawCellHighlight( const ARect : TRect; AState : TGridDrawState; ACol : Integer; ARow : Integer ); override;
  public
    constructor Create( AOwner : TComponent ); override;
  published
    property  OddColor : TColor
      read    fOddColor
      write   SetOddColor
      default clWhite;
    property  OddFont : TFont
      read    fOddFont
      write   SetOddFont;
    property  OddColorize : Boolean
      read    fOddColorize
      write   SetOddColorize
      default False;
    property  OddFontColorAutomatic : Boolean
      read    fOddFontColorAutomatic
      write   SetOddFontColorAutomatic
      default False;
  end;

implementation

function GetAutomaticFontColor( AColor : TColor ) : TColor;
var
  lColor :  TColor;
  r, g, b : Byte;
begin
  lColor := ColorToRGB( AColor );
  r      := ( lColor shr 0 ) and $FF;
  g      := ( lColor shr 8 ) and $FF;
  b      := ( lColor shr 16 ) and $FF;
  if ( r * 2 + g * 4 + b >= ( $FF ) * 4 )
  then
    Result := clBlack
  else
    Result := clWhite;
end;

{ TDBGrid }

constructor TDBGrid.Create( AOwner : TComponent );
begin
  inherited;
  fOddColor    := clWhite;
  fOddColorize := False;
  fOddFont     := TFont.Create;
  fOddFont.Assign( Font );
end;

procedure TDBGrid.DrawCellHighlight( const ARect : TRect; AState : TGridDrawState; ACol, ARow : Integer );
begin
  inherited;
  fIsHighlight := True;
end;

procedure TDBGrid.DrawColumnCell( const Rect : TRect; DataCol : Integer; Column : TColumn; State : TGridDrawState );
var
  lRect : TRect;
begin
  if Assigned( DataLink.DataSet )
  then
    fIsOdd := Odd( DataLink.DataSet.RecNo );

  if OddColorize and not fIsHighlight and fIsOdd and ( ( State - [gdHotTrack] = [] ) or not ( Focused or ( dgAlwaysShowSelection in Options ) ) )
  then
    begin
      lRect      := Rect;
      lRect.Left := lRect.Left + 1;

      Canvas.Brush.Color := OddColor;
      Canvas.FillRect( Rect );
      Canvas.Font := fOddFont;

      DefaultDrawColumnCell( lRect, DataCol, Column, State );
    end;
  fIsHighlight := False;
  inherited;
end;

procedure TDBGrid.SetOddColor( const Value : TColor );
begin
  if fOddColor <> Value
  then
    begin
      fOddColor := Value;

      if fOddFontColorAutomatic
      then
        fOddFont.Color := GetAutomaticFontColor( fOddColor );

      if fOddColorize
      then
        Invalidate;
    end;
end;

procedure TDBGrid.SetOddColorize( const Value : Boolean );
begin
  if fOddColorize <> Value
  then
    begin
      fOddColorize := Value;
      Invalidate;
    end;
end;

procedure TDBGrid.SetOddFont( const Value : TFont );
begin
  fOddFont.Assign( Value );

  if fOddFontColorAutomatic
  then
    fOddFont.Color := GetAutomaticFontColor( fOddColor );

  if fOddColorize
  then
    Invalidate;
end;

procedure TDBGrid.SetOddFontColorAutomatic( const Value : Boolean );
begin
  if fOddFontColorAutomatic <> Value
  then
    begin
      fOddFontColorAutomatic := Value;

      if fOddFontColorAutomatic
      then
        fOddFont.Color := GetAutomaticFontColor( fOddColor );

      if fOddColorize
      then
        Invalidate;
    end;
end;

end.

EDIT: Da gab es ein paar Situationen (MultiSelect, etc.) wo das noch nicht ganz funktioniert hat, jetzt ist aber alles schick ;)
EDIT2: So, jetzt sollte das wirklich schick sein :mrgreen:

[Flash68]

das klappt gut. jetzt fehlt mir nur noch etwas um den aktuellen Cursor des Grids einzufärben.

[Sir Rufo]

Zitat:

Zitat von Flash68 (Beitrag 1128490)

das klappt gut. jetzt fehlt mir nur noch etwas um den aktuellen Cursor des Grids einzufärben.

Mit ein wenig Transferleistung kannst du das da selber rein basteln ;)

Schau dir an, an welcher Stelle und warum wann da was gemalt wird (und vor allem warum da manchmal doch nicht gemalt wird) ;)

[Sir Rufo]

Sodele, ich habe das doch nochmal umgerissen :)

Unter der Eigenschaft GridCustomizer sind dann die Steuermöglichkeiten für Even/Odd (mit/ohne HighLight) einfärben.
Mit OddCount kann man jetzt auch die Anzahl der Zeilen, nach denen die Farbe gewechselt wird, angeben.

Ich glaube ich habe jetzt auch die letzten Darstellungsfehler wegbekommen :)

Delphi-Quellcode:

unit DBGrids.Customize;

interface

uses
  Classes, Windows, Controls, Graphics, Grids, DBGrids;

type
  TDBGridCustomizeOptionBase = class( TControl )
  private
    fCustomized : Boolean;
    fCustomize :  Boolean;
    procedure SetCustomize( const Value : Boolean );
  protected
    procedure AssignTo( Dest : TPersistent ); override;
  public
    procedure Invalidate; override;
    constructor Create( AOwner : TComponent ); override;
  published
    property Customize : Boolean
      read   fCustomize
      write  SetCustomize;
  end;

  TDBGridCustomizeOption = class( TDBGridCustomizeOptionBase )
  private
    fRowColor :           TColor;
    fFontColorAutomatic : Boolean;
    fFontColor :          TColor;
    fFontColorAuto :      TColor;
    procedure SetFontColor( const Value : TColor );
    procedure SetFontColorAutomatic( const Value : Boolean );
    procedure SetRowColor( const Value : TColor );
    function GetFontColor : TColor;
  protected
    procedure AssignTo( Dest : TPersistent ); override;
  public
    constructor Create( AOwner : TComponent ); override;
  published
    property RowColor : TColor
      read   fRowColor
      write  SetRowColor;
    property FontColor : TColor
      read   GetFontColor
      write  SetFontColor;
    property FontColorAutomatic : Boolean
      read   fFontColorAutomatic
      write  SetFontColorAutomatic;
  end;

  TDBGridCustomizeOptions = class( TDBGridCustomizeOptionBase )
  private
    fEvenRow :        TDBGridCustomizeOption;
    fOddRow :         TDBGridCustomizeOption;
    fOddHilightRow :  TDBGridCustomizeOption;
    fEvenHilightRow : TDBGridCustomizeOption;
    fOddCount :       integer;
    function GetOddCount : integer;
    procedure SetOddCount( const Value : integer );
  protected
    procedure AssignTo( Dest : TPersistent ); override;
  public
    constructor Create( AOwner : TComponent ); override;
    function GetCustomizedColors( RowNr : integer; RowHighLight : Boolean; var ARowColor, AFontColor : TColor ) : Boolean;
  published
    property OddRow : TDBGridCustomizeOption
      read   fOddRow;
    property EvenRow : TDBGridCustomizeOption
      read   fEvenRow;
    property OddHilightRow : TDBGridCustomizeOption
      read   fOddHilightRow;
    property EvenHilightRow : TDBGridCustomizeOption
      read   fEvenHilightRow;
    property OddCount : integer
      read   GetOddCount
      write  SetOddCount;
  end;

  TDBGrid = class( DBGrids.TDBGrid )
  private
    fIsHighlight :    Boolean;
    fGridCustomizer : TDBGridCustomizeOptions;
  protected
    procedure DrawColumnCell( const Rect : TRect; DataCol : integer; Column : TColumn; State : TGridDrawState ); override;
    procedure DrawCellHighlight( const ARect : TRect; AState : TGridDrawState; ACol : integer; ARow : integer ); override;
  public
    constructor Create( AOwner : TComponent ); override;
  published
    property GridCustomizer : TDBGridCustomizeOptions
      read   fGridCustomizer;
  end;

function GetAutomaticFontColor( AColor : TColor ) : TColor;

implementation

function GetAutomaticFontColor( AColor : TColor ) : TColor;
var
  lColor :  TColor;
  r, g, b : Byte;
begin
  lColor := ColorToRGB( AColor );
  r      := ( lColor shr 0 ) and $FF;
  g      := ( lColor shr 8 ) and $FF;
  b      := ( lColor shr 16 ) and $FF;
  if ( r * 2 + g * 4 + b >= ( $FF ) * 4 )
  then
    Result := clBlack
  else
    Result := clWhite;
end;

{ TDBGrid }

constructor TDBGrid.Create( AOwner : TComponent );
begin
  inherited;
  fGridCustomizer := TDBGridCustomizeOptions.Create( Self );
end;

procedure TDBGrid.DrawCellHighlight( const ARect : TRect; AState : TGridDrawState; ACol, ARow : integer );
begin
  inherited;
  fIsHighlight := True;
end;

procedure TDBGrid.DrawColumnCell( const Rect : TRect; DataCol : integer; Column : TColumn; State : TGridDrawState );
var
  lRect :      TRect;
  lRowNr :     integer;
  lRowColor :  TColor;
  lFontColor : TColor;

  lSaveColor :     TColor;
  lSaveFontColor : TColor;
begin
  if Assigned( DataLink.DataSet )
  then
    begin
      lRowColor  := Canvas.Brush.Color;
      lFontColor := Canvas.Font.Color;

      if GridCustomizer.GetCustomizedColors( DataLink.DataSet.RecNo, fIsHighlight, lRowColor, lFontColor )
      then
        begin

          lSaveColor     := Canvas.Brush.Color;
          lSaveFontColor := Canvas.Font.Color;

          lRect      := Rect;
          lRect.Left := lRect.Left + 1;

          Canvas.Brush.Color := lRowColor;
          Canvas.FillRect( Rect );
          Canvas.Font.Color := lFontColor;

          DefaultDrawColumnCell( lRect, DataCol, Column, State );

          Canvas.Brush.Color := lSaveColor;
          Canvas.Font.Color  := lSaveFontColor;

        end;
    end;
  fIsHighlight := False;
  inherited;
end;

{ TDBGridCustomizeOptions }

procedure TDBGridCustomizeOptions.AssignTo( Dest : TPersistent );
begin
  if Dest is TDBGridCustomizeOptions
  then
    with TDBGridCustomizeOptions( Dest ) do
      begin
        EvenRow.Assign( Self.EvenRow );
        EvenHilightRow.Assign( Self.EvenHilightRow );
        OddRow.Assign( Self.OddRow );
        OddHilightRow.Assign( Self.OddRow );
        OddCount := Self.OddCount;
      end;
  inherited;
end;

constructor TDBGridCustomizeOptions.Create( AOwner : TComponent );
begin
  inherited;
  fEvenRow        := TDBGridCustomizeOption.Create( Self );
  fOddRow         := TDBGridCustomizeOption.Create( Self );
  fEvenHilightRow := TDBGridCustomizeOption.Create( Self );
  fOddHilightRow  := TDBGridCustomizeOption.Create( Self );
end;

function TDBGridCustomizeOptions.GetCustomizedColors( RowNr : integer; RowHighLight : Boolean; var ARowColor, AFontColor : TColor ) : Boolean;
var
  lCustomizer : TDBGridCustomizeOption;
begin

  Result := False;

  if not Customize
  then
    Exit;

  if ( OddCount = 0 ) or ( ( RowNr + OddCount - 1 ) mod ( OddCount * 2 ) >= OddCount )
  then
    begin

      if RowHighLight
      then
        lCustomizer := EvenHilightRow
      else
        lCustomizer := EvenRow;
    end
  else
    begin
      if RowHighLight
      then
        lCustomizer := OddHilightRow
      else
        lCustomizer := OddRow;
    end;

  if not lCustomizer.Customize
  then
    Exit;

  ARowColor  := lCustomizer.RowColor;
  AFontColor := lCustomizer.FontColor;

  Result := True;

end;

function TDBGridCustomizeOptions.GetOddCount : integer;
begin
  if fOddCount < 0
  then
    fOddCount := 0;
  Result      := fOddCount;
end;

procedure TDBGridCustomizeOptions.SetOddCount( const Value : integer );
begin
  if fOddCount <> Value
  then
    begin
      fOddCount := Value;
      Invalidate;
    end;
end;

{ TDBGridCustomizeOption }

procedure TDBGridCustomizeOption.AssignTo( Dest : TPersistent );
begin
  if Dest is TDBGridCustomizeOption
  then
    with TDBGridCustomizeOption( Dest ) do
      begin
        FontColor          := Self.fFontColor;
        FontColorAutomatic := Self.FontColorAutomatic;
        RowColor           := Self.fRowColor;
      end;
  inherited;
end;

constructor TDBGridCustomizeOption.Create( AOwner : TComponent );
begin
  inherited;
  fRowColor           := clWindow;
  fFontColor          := clWindowText;
  fFontColorAuto      := GetAutomaticFontColor( fRowColor );
  fFontColorAutomatic := True;
end;

function TDBGridCustomizeOption.GetFontColor : TColor;
begin
  if fFontColorAutomatic
  then
    Result := fFontColorAuto
  else
    Result := fFontColor;
end;

procedure TDBGridCustomizeOption.SetFontColor( const Value : TColor );
begin
  if ( fFontColor <> Value ) and not fFontColorAutomatic
  then
    begin
      fFontColor := Value;
      Invalidate;
    end;
end;

procedure TDBGridCustomizeOption.SetFontColorAutomatic( const Value : Boolean );
begin
  if fFontColorAutomatic <> Value
  then
    begin
      fFontColorAutomatic := Value;
      Invalidate;
    end;
end;

procedure TDBGridCustomizeOption.SetRowColor( const Value : TColor );
begin
  if fRowColor <> Value
  then
    begin
      fRowColor      := Value;
      fFontColorAuto := GetAutomaticFontColor( fRowColor );
      Invalidate;
    end;
end;

{ TDBGridCustomizeOptionBase }

procedure TDBGridCustomizeOptionBase.AssignTo( Dest : TPersistent );
begin
  if Dest is TDBGridCustomizeOptionBase
  then
    begin
      with TDBGridCustomizeOptionBase( Dest ) do
        begin

          Customize := Self.Customize;

        end;

    end
  else
    inherited;
end;

constructor TDBGridCustomizeOptionBase.Create( AOwner : TComponent );
begin
  inherited;
  fCustomized := False;
  fCustomize  := False;
end;

procedure TDBGridCustomizeOptionBase.Invalidate;
begin
  if ( fCustomize or fCustomized )
  then
    begin
      if Assigned( Owner ) and ( Owner is TControl )
      then
        TControl( Owner ).Invalidate;
      fCustomized := fCustomize;
    end;
end;

procedure TDBGridCustomizeOptionBase.SetCustomize( const Value : Boolean );
begin
  if fCustomize <> Value
  then
    begin
      fCustomize := Value;
      Invalidate;
    end;
end;

end.

[Flash68]

Wie setzte ich denn jetzt die Unit ein?

[Sir Rufo]

Zitat:

Zitat von Flash68 (Beitrag 1128787)

Wie setzte ich denn jetzt die Unit ein?

öhhm, genau wie die alte, daran hat sich nichts geändert, nur dass du die Eigenschaften jetzt zusammengefasst unter der Eigenschaft GridCustomizer findest.

Delphi-Quellcode:

uses
  DBGrids, DBGrids.Customizer;

...

DBGrid1.GridCustomizer.OddRow.RowColor := clRed;
DBGrid1.GridCustomizer.OddRow.Customize := True;
DBGrid1.GridCustomizer.Customize := True;

[Flash68]

aber du hast doch geschrieben das man die anzahl der Zeilen varieren kann und was ist mit der highlightfarbe?

[Sir Rufo]

Zitat:

Zitat von Flash68 (Beitrag 1128793)

aber du hast doch geschrieben das man die anzahl der Zeilen varieren kann und was ist mit der highlightfarbe?

Tipp doch mal in der IDE ein

Delphi-Quellcode:

DBGrid1.GridCustomizer.

und dann abwarten, was der dir da so in der Liste anbietet.

[Jumpy]

Zitat:

Zitat von Sir Rufo (Beitrag 1128804)

Zitat:

Zitat von Flash68 (Beitrag 1128793)

aber du hast doch geschrieben das man die anzahl der Zeilen varieren kann und was ist mit der highlightfarbe?

Tipp doch mal in der IDE ein

Delphi-Quellcode:

DBGrid1.GridCustomizer.

und dann abwarten, was der dir da so in der Liste anbietet.

[Nichtganzernst]
Wie da muss man was eintippen? Geht das nicht im Objektinspektor?
[/Nichtganzernst]

[Flash68]

ich habe das jetzt folgendermaßen eingearbeitet:

Delphi-Quellcode:

  DBG_Rechner.gridcustomizer.oddrow.RowColor:= clsilver;
  DBG_Rechner.gridcustomizer.oddrow.customize:=true;
  DBG_Rechner.gridcustomizer.Customize:= true;
  DBG_Rechner.gridcustomizer.OddHilightRow.RowColor:= clskyblue;
  DBG_Rechner.gridcustomizer.OddHilightRow.customize:= true;

aber mein grid ist ganz weiß

[Sir Rufo]

Zitat:

Zitat von Flash68 (Beitrag 1128838)

ich habe das jetzt folgendermaßen eingearbeitet:

Delphi-Quellcode:

  DBG_Rechner.gridcustomizer.oddrow.RowColor:= clsilver;
  DBG_Rechner.gridcustomizer.oddrow.customize:=true;
  DBG_Rechner.gridcustomizer.Customize:= true;
  DBG_Rechner.gridcustomizer.OddHilightRow.RowColor:= clskyblue;
  DBG_Rechner.gridcustomizer.OddHilightRow.customize:= true;

aber mein grid ist ganz weiß

Es fehlt noch das

Delphi-Quellcode:

  DBG_Rechner.GridCustomizer.OddCount := 1;

Im Anhang ein Testprogramm, wo alle Customize-Attribute klick- und auswählbar sind.

[Flash68]

Danke nochmal für die Hilfe, jetzt funktioniert alles.

Gruß

Flash