uStringGridHelper.pas

unit uStringGridHelper;

interface

uses
  Vcl.Grids, System.Classes, Vcl.Dialogs, System.SysUtils, Winapi.Windows, Vcl.ExtCtrls,
  Vcl.Controls, Vcl.Forms, ComObj, Vcl.Printers, System.Variants, Vcl.Graphics,
  System.Generics.Collections, ClipBrd, uProgressHelper, uSmartComparer;

type
  TGridHack = class(TStringGrid);

type
  TExportType = (etExcel, etPDF, etCSV); //Export Tipleri

type //Hücrelerin stilleri
  TCellStyle = record
    BackColor: TColor;
    FontColor: TColor;
    FontBold: Boolean;
    FontItalic: Boolean;
    FontSize: Integer;
  end;

type //Kýsayol Tuþlarý
  TKeyConfig = record
    Key: Word;
    UseCtrl: Boolean;
    UseShift: Boolean;
    UseAlt: Boolean;
  end;

//Klavye kýsayollarýný aktarma
function MakeKeyConfig(AKey: Word; ACtrl: Boolean = False; AShift: Boolean = False; AAlt: Boolean = False): TKeyConfig;

type //Grid silindiðinde haber alacak olan takipçi sýnýf
  TGridObserver = class(TComponent)
  protected
    procedure Notification(AComponent: TComponent; Operation: TOperation); override;
  end;

type
  TStringGridHelperData = class
  private
    FCellStyles: array of array of TCellStyle;
    FLastSearchText: string;
    FLastSearchCol: Integer;
    FLastSearchRow: Integer;
    FCaseSensitive: Boolean;
    FOriginalKeyDown: TKeyEvent;
    FOriginalDrawCell: TDrawCellEvent;
    FOriginalSelectCell: TSelectCellEvent;
    FOriginalMouseDown: TMouseEvent;
    FSearching: Boolean;
    FCancelled: Boolean;
    FExporting: Boolean;
    FProgress: TProgressHelper;
    FSearchKey: TKeyConfig;
    FExcelKey: TKeyConfig;
    FPDFKey: TKeyConfig;
    FCSVKey: TKeyConfig;
    FCancelKey: TKeyConfig;
    FDeleteRowKey: TKeyConfig;
    FAutoFitKey: TKeyConfig;
    FGrid: TStringGrid;
    FObserver: TGridObserver;
    FHighlightCol: Integer;
    FHighlightRow: Integer;
    FOriginalHighlightColor: TColor;
    FIsHighlighted: Boolean;
    FSearchHighlightColor: TColor;
    FSortColumn: Integer;
    FSortAscending: Boolean;
    FHeaderCount: Integer;
    FOriginalFixedRows: Integer;
  public
    constructor Create(AGrid: TStringGrid);
    destructor Destroy; override;
  end;

  TStringGridHelper = class helper for TStringGrid
  private
    function GetHelperData: TStringGridHelperData;
    procedure GridKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
    procedure GridMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
    function CompareText(const S1, S2: string): Boolean;
    procedure ExportToCSVFile(const FileName, FileTypeText: string);
    procedure ExportToFile(ExportType: TExportType);
    function CheckKeyMatch(Key: Word; Shift: TShiftState; Config: TKeyConfig): Boolean;
    procedure HandleNavigationKeys(var Key: Word; Shift: TShiftState);
    function GetNextVisibleCol(CurrentCol: Integer; Direction: Integer): Integer;
    function GetNextVisibleRow(CurrentRow: Integer; Direction: Integer): Integer;
    procedure DeleteCurrentRow;
    procedure AutoFitColumns;
    procedure SortColumn(ACol: Integer; Ascending: Boolean = True);
    function GetCellStyle(ACol, ARow: Integer): TCellStyle;
    procedure InternalDrawCell(Sender: TObject; ACol, ARow: Integer; Rect: TRect; State: TGridDrawState);
    procedure ShiftStyles(StartRow: Integer; Up: Boolean);
    function GetCaseSensitive: Boolean;
    procedure SetCaseSensitive(const Value: Boolean);
    function GetIsSearching: Boolean;
    function GetIsExporting: Boolean;
    procedure GridSelectCell(Sender: TObject; ACol, ARow: Integer; var CanSelect: Boolean);
    procedure ClearHighlight;
    procedure HighlightCell(ACol, ARow: Integer);
    function GetSearchHighlightColor: TColor;
    procedure SetSearchHighlightColor(const Value: TColor);
    procedure SortByColumn(ACol: Integer; Ascending: Boolean);
    function GetHeaderCount: Integer;
    function GetHeaderRowIndex(HeaderIndex: Integer): Integer;
    procedure SwapRows(const Data: TStringGridHelperData; Idx1, Idx2: Integer);
  public
    property CaseSensitive: Boolean read GetCaseSensitive write SetCaseSensitive;
    property IsSearching: Boolean read GetIsSearching;
    property IsExporting: Boolean read GetIsExporting;
    property HeaderCount: Integer read GetHeaderCount;
    procedure InitHelper;
    procedure FreeHelper;
    procedure Search(const ASearchText: string = '');
    procedure Reset;
    procedure CancelSearch;
    procedure ExportToExcel;
    procedure ExportToPDF;
    procedure ExportToCSV;
    procedure DeleteRow;
    procedure CloneRow(CurrentRow: Integer);
    procedure AutoFit;
    procedure SetSearchKey(AKey: Word; ACtrl: Boolean = True; AShift: Boolean = False; AAlt: Boolean = False);
    procedure SetExcelKey(AKey: Word; ACtrl: Boolean = True; AShift: Boolean = False; AAlt: Boolean = False);
    procedure SetPDFKey(AKey: Word; ACtrl: Boolean = True; AShift: Boolean = False; AAlt: Boolean = False);
    procedure SetCSVKey(AKey: Word; ACtrl: Boolean = True; AShift: Boolean = False; AAlt: Boolean = False);
    procedure SetCancelKey(AKey: Word; ACtrl: Boolean = False; AShift: Boolean = False; AAlt: Boolean = False);
    procedure SetDeleteRowKey(AKey: Word; ACtrl: Boolean = True; AShift: Boolean = False; AAlt: Boolean = False);
    procedure SetAutoFitKey(AKey: Word; ACtrl: Boolean = True; AShift: Boolean = False; AAlt: Boolean = False);
    procedure SetCellStyle(ACol, ARow: Integer; ABackColor, AFontColor: TColor; ABold: Boolean = False; AItalic: Boolean = False; AFontSize: Integer = 8);
    procedure ClearAllStyles;
    procedure PrepareStyleArray;
    function AddHeader: Integer;
    procedure RemoveHeader(HeaderIndex: Integer);
    procedure RemoveAllHeaders;
    procedure SetHeaderText(HeaderIndex, ACol: Integer; const AText: string); overload;
    function GetHeaderText(HeaderIndex, ACol: Integer): string;
    procedure SetHeaderStyle(HeaderIndex: Integer; ABackColor, AFontColor: TColor; ABold: Boolean = True; AItalic: Boolean = False; AFontSize: Integer = 9);
    function IsHeaderRow(ARow: Integer): Boolean; overload;
    function GetHeaderIndex(ARow: Integer): Integer;
  end;

implementation

const
  //Grid sütun geniþlik ayarlarý
  MIN_COL_WIDTH = 30;
  MAX_COL_WIDTH = 500;
  CELL_PADDING = 20;

  //Progress bar güncelleme sýklýðý
  PROGRESS_UPDATE_INTERVAL_COL = 10; //Her 10 sütunda bir
  PROGRESS_UPDATE_INTERVAL_ROW = 50; //Her 50 satýrda bir
  PROGRESS_UPDATE_INTERVAL_SEARCH = 100; //Her 100 satýrda bir (arama için)

  //Highlight rengi (default)
  DEFAULT_HIGHLIGHT_COLOR = $66B2FF; //Turuncu

var
  GridHelperList: TObjectDictionary<TStringGrid, TStringGridHelperData>;

function MakeKeyConfig(AKey: Word; ACtrl: Boolean; AShift: Boolean; AAlt: Boolean): TKeyConfig;
begin
  Result.Key := AKey;
  Result.UseCtrl := ACtrl;
  Result.UseShift := AShift;
  Result.UseAlt := AAlt;
end;

{ TStringGridHelperData }

constructor TStringGridHelperData.Create(AGrid: TStringGrid);
begin
  inherited Create;
  FGrid := AGrid;
  FObserver := TGridObserver.Create(nil);
  FGrid.FreeNotification(FObserver);
  FLastSearchText := '';
  FLastSearchCol := -1;
  FLastSearchRow := -1;
  FCaseSensitive := False;
  FSearching := False;
  FCancelled := False;
  FExporting := False;
  FProgress := TProgressHelper.Create;

  //Default tuþ atamalarý
  FSearchKey := MakeKeyConfig(VK_F3, True); //Ctrl+F3
  FExcelKey := MakeKeyConfig(VK_F8, True); //Ctrl+F8
  FCSVKey := MakeKeyConfig(VK_F9, True); //Ctrl+F9
  FPDFKey := MakeKeyConfig(VK_F10, True); //Ctrl+F10
  FCancelKey := MakeKeyConfig(VK_ESCAPE, False); //ESC
  FDeleteRowKey := MakeKeyConfig(VK_DELETE, True); //Ctrl+Delete
  FAutoFitKey := MakeKeyConfig(VK_F1, True); //Ctrl+F1

  //Mevcut event'leri saklýyoruz
  FOriginalKeyDown := FGrid.OnKeyDown;
  FOriginalDrawCell := FGrid.OnDrawCell;

  //Highlight için default bilgiler
  FHighlightCol := -1;
  FHighlightRow := -1;
  FIsHighlighted := False;
  FSearchHighlightColor := DEFAULT_HIGHLIGHT_COLOR;

  //Sýralama için default bilgiler
  FSortColumn := -1;
  FSortAscending := True;

  //Baþlýklar dýþýnda header için default bilgiler
  FHeaderCount := 0;
  FOriginalFixedRows := FGrid.FixedRows;
end;

destructor TStringGridHelperData.Destroy;
var
  i: Integer;
begin
  for i := 0 to High(FCellStyles) do begin
    SetLength(FCellStyles[i], 0);
  end;
  SetLength(FCellStyles, 0);
  FObserver.Free;
  FProgress.Free;
  inherited;
end;

{ TStringGridHelper }

function TStringGridHelper.GetHelperData: TStringGridHelperData;
begin
  if not Assigned(GridHelperList) then begin
    GridHelperList := TObjectDictionary<TStringGrid, TStringGridHelperData>.Create([doOwnsValues]);
  end;

  if not GridHelperList.ContainsKey(Self) then begin
    GridHelperList.Add(Self, TStringGridHelperData.Create(Self));
  end;

  Result := GridHelperList[Self];
end;

procedure TStringGridHelper.InitHelper;
var
  Data: TStringGridHelperData;
begin
  FreeHelper;
  if Self = nil then Exit;
  try
    Data := GetHelperData;

    if not Assigned(Self) then
      raise Exception.Create('StringGrid nesnesi nil!');

    Self.OnKeyDown := GridKeyDown;
    Self.OnDrawCell := InternalDrawCell;
    Self.OnSelectCell := GridSelectCell;
    Self.OnMouseDown := GridMouseDown;
  except
    on E: Exception do
      raise Exception.CreateFmt('InitHelper hatasý: %s', [E.Message]);
  end;
end;

procedure TStringGridHelper.FreeHelper;
begin
  try
    if Assigned(GridHelperList) and GridHelperList.ContainsKey(Self) then begin
      Self.OnKeyDown := GetHelperData.FOriginalKeyDown;
      Self.OnDrawCell := GetHelperData.FOriginalDrawCell;
      Self.OnSelectCell := GetHelperData.FOriginalSelectCell;
      Self.OnMouseDown := GetHelperData.FOriginalMouseDown;
      GridHelperList.Remove(Self);
    end;
  except
    on E: Exception do begin
      OutputDebugString(PChar('FreeHelper hatasý: ' + E.Message));
    end;
  end;
end;

function TStringGridHelper.GetCaseSensitive: Boolean;
begin
  Result := GetHelperData.FCaseSensitive;
end;

procedure TStringGridHelper.SetCaseSensitive(const Value: Boolean);
begin
  GetHelperData.FCaseSensitive := Value;
end;

function TStringGridHelper.GetIsSearching: Boolean;
begin
  Result := GetHelperData.FSearching;
end;

function TStringGridHelper.GetIsExporting: Boolean;
begin
  Result := GetHelperData.FExporting;
end;

procedure TStringGridHelper.ClearHighlight;
var
  Data: TStringGridHelperData;
begin
  Data := GetHelperData;

  if Data.FIsHighlighted and (Data.FHighlightCol >= 0) and (Data.FHighlightRow >= 0) then begin
    if (Data.FHighlightCol < Length(Data.FCellStyles)) and
      (Data.FHighlightRow < Length(Data.FCellStyles[Data.FHighlightCol])) then begin
      Data.FCellStyles[Data.FHighlightCol][Data.FHighlightRow].BackColor := Data.FOriginalHighlightColor;
      TGridHack(Self).InvalidateCell(Data.FHighlightCol, Data.FHighlightRow);
    end;

    Data.FIsHighlighted := False;
    Data.FHighlightCol := -1;
    Data.FHighlightRow := -1;
  end;
end;

procedure TStringGridHelper.HighlightCell(ACol, ARow: Integer);
var
  Data: TStringGridHelperData;
begin
  try
    Data := GetHelperData;

    if (ACol < 0) or (ACol >= Self.ColCount) then
      raise Exception.CreateFmt('Geçersiz sütun: %d', [ACol]);

    if (ARow < 0) or (ARow >= Self.RowCount) then
      raise Exception.CreateFmt('Geçersiz satýr: %d', [ARow]);

    ClearHighlight;

    Data.FOriginalHighlightColor := GetCellStyle(ACol, ARow).BackColor;
    Data.FHighlightCol := ACol;
    Data.FHighlightRow := ARow;
    Data.FIsHighlighted := True;

    if (ACol < Length(Data.FCellStyles)) and
      (ARow < Length(Data.FCellStyles[ACol])) and
      (Data.FCellStyles[ACol][ARow].FontSize > 0) then begin
      Data.FCellStyles[ACol][ARow].BackColor := Data.FSearchHighlightColor;
    end
    else begin
      if ACol >= Length(Data.FCellStyles) then begin
        SetLength(Data.FCellStyles, Self.ColCount);
      end;
      if ARow >= Length(Data.FCellStyles[ACol]) then begin
        SetLength(Data.FCellStyles[ACol], Self.RowCount);
      end;

      Data.FCellStyles[ACol][ARow].BackColor := Data.FSearchHighlightColor;
      Data.FCellStyles[ACol][ARow].FontColor := Self.Font.Color;
      Data.FCellStyles[ACol][ARow].FontBold := fsBold in Self.Font.Style;
      Data.FCellStyles[ACol][ARow].FontItalic := fsItalic in Self.Font.Style;
      Data.FCellStyles[ACol][ARow].FontSize := Self.Font.Size;
    end;

    TGridHack(Self).InvalidateCell(ACol, ARow);
  except
    on E: Exception do
      raise Exception.CreateFmt('HighlightCell hatasý [Col:%d, Row:%d], mesaj: %s', [ACol, ARow, E.Message]);
  end;
end;

procedure TStringGridHelper.GridSelectCell(Sender: TObject; ACol, ARow: Integer; var CanSelect: Boolean);
var
  Data: TStringGridHelperData;
begin
  Data := GetHelperData;
  if Assigned(Data.FOriginalSelectCell) then begin
    Data.FOriginalSelectCell(Sender, ACol, ARow, CanSelect);
  end;
  if CanSelect and ((ACol <> Data.FHighlightCol) or (ARow <> Data.FHighlightRow)) then begin
    ClearHighlight;
  end;
end;

function TStringGridHelper.GetSearchHighlightColor: TColor;
begin
  Result := GetHelperData.FSearchHighlightColor;
end;

procedure TStringGridHelper.SetSearchHighlightColor(const Value: TColor);
begin
  GetHelperData.FSearchHighlightColor := Value;
end;

procedure TStringGridHelper.DeleteCurrentRow;
var
  i: Integer;
  CurrentRow, MinRow: Integer;
  Data: TStringGridHelperData;
begin
  try
    Data := GetHelperData;
    CurrentRow := Self.Row;
    MinRow := Self.FixedRows;

    if CurrentRow < MinRow then
      raise Exception.Create('Sabit satýrlar silinemez!');

    if Self.RowCount <= MinRow + 1 then
      raise Exception.Create('Son veri satýrý silinemez!');

    if MessageDlg('Seçili satýrý silmek istediðinizden emin misiniz?', mtConfirmation, [mbYes, mbNo], 0) <> mrYes then Exit;

    ShiftStyles(CurrentRow, True);
    for i := CurrentRow to Self.RowCount - 2 do begin
      Self.Rows[i].Assign(Self.Rows[i + 1]);
    end;
    Self.RowCount := Self.RowCount - 1;
    if CurrentRow >= Self.RowCount then begin
      Self.Row := Self.RowCount - 1;
    end;
    Reset;
  except
    on E: Exception do
      raise Exception.CreateFmt('Satýr silme hatasý [Row:%d], mesaj: %s', [Self.Row, E.Message]);
  end;
end;

procedure TStringGridHelper.DeleteRow;
begin
  if IsSearching then
    raise Exception.Create('Arama devam ederken satýr silinemez!');

  if IsExporting then
    raise Exception.Create('Export devam ederken satýr silinemez!');

  DeleteCurrentRow;
end;

procedure TStringGridHelper.PrepareStyleArray;
var
  i: Integer;
  Data: TStringGridHelperData;
begin
  Data := GetHelperData;
  SetLength(Data.FCellStyles, Self.ColCount);
  for i := 0 to Self.ColCount - 1 do begin
    SetLength(Data.FCellStyles[i], Self.RowCount);
  end;
end;

function TStringGridHelper.CheckKeyMatch(Key: Word; Shift: TShiftState; Config: TKeyConfig): Boolean;
var
  CtrlPressed, ShiftPressed, AltPressed: Boolean;
begin
  CtrlPressed := ssCtrl in Shift;
  ShiftPressed := ssShift in Shift;
  AltPressed := ssAlt in Shift;
  Result := (Key = Config.Key) and
    (CtrlPressed = Config.UseCtrl) and
    (ShiftPressed = Config.UseShift) and
    (AltPressed = Config.UseAlt);
end;

procedure TStringGridHelper.ClearAllStyles;
var
  i: Integer;
  Data: TStringGridHelperData;
begin
  Data := GetHelperData;
  for i := 0 to High(Data.FCellStyles) do begin
    SetLength(Data.FCellStyles[i], 0);
  end;
  SetLength(Data.FCellStyles, 0);
  Self.Invalidate;
end;

procedure TStringGridHelper.SetSearchKey(AKey: Word; ACtrl: Boolean; AShift: Boolean; AAlt: Boolean);
var
  Data: TStringGridHelperData;
begin
  Data := GetHelperData;
  Data.FSearchKey := MakeKeyConfig(AKey, ACtrl, AShift, AAlt);
end;

procedure TStringGridHelper.ShiftStyles(StartRow: Integer; Up: Boolean);
var
  i, j: Integer;
  Data: TStringGridHelperData;
begin
  Data := GetHelperData;
  if Length(Data.FCellStyles) = 0 then Exit;

  if Up then begin
    for i := StartRow to Self.RowCount - 2 do begin
      for j := 0 to Self.ColCount - 1 do begin
        if (j < Length(Data.FCellStyles)) and (Length(Data.FCellStyles[j]) > i + 1) then begin
          Data.FCellStyles[j][i] := Data.FCellStyles[j][i + 1]
        end
        else if (j < Length(Data.FCellStyles)) and (Length(Data.FCellStyles[j]) > i) then begin
          Data.FCellStyles[j][i].FontSize := 0;
        end;
      end;
    end;

    for j := 0 to High(Data.FCellStyles) do begin
      if Length(Data.FCellStyles[j]) >= Self.RowCount then begin
        SetLength(Data.FCellStyles[j], Self.RowCount - 1);
      end;
    end;
  end
  else begin
    for j := 0 to High(Data.FCellStyles) do begin
      SetLength(Data.FCellStyles[j], Self.RowCount);
    end;

    for i := Self.RowCount - 1 downto StartRow + 1 do begin
      for j := 0 to Self.ColCount - 1 do begin
        Data.FCellStyles[j][i] := Data.FCellStyles[j][i - 1];
      end;
    end;
  end;
end;

procedure TStringGridHelper.GridMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
var
  ACol, ARow: Integer;
  Data: TStringGridHelperData;
  HeaderRowIndex: Integer;
begin
  Data := GetHelperData;

  if Assigned(Data.FOriginalMouseDown) then begin
    Data.FOriginalMouseDown(Sender, Button, Shift, X, Y);
  end;

  if (Button = mbLeft) and (ssCtrl in Shift) then begin
    Self.MouseToCell(X, Y, ACol, ARow);
    if IsHeaderRow(ARow) then Exit;
    HeaderRowIndex := Data.FHeaderCount;
    if (ARow >= HeaderRowIndex) and (ARow < Self.FixedRows) and (ACol >= Self.FixedCols) then begin
      if Data.FSortColumn = ACol then begin
        Data.FSortAscending := not Data.FSortAscending;
      end
      else begin
        Data.FSortColumn := ACol;
        Data.FSortAscending := True;
      end;
      SortByColumn(ACol, Data.FSortAscending);
    end;
  end;
end;

procedure TStringGridHelper.SetExcelKey(AKey: Word; ACtrl: Boolean; AShift: Boolean; AAlt: Boolean);
var
  Data: TStringGridHelperData;
begin
  Data := GetHelperData;
  Data.FExcelKey := MakeKeyConfig(AKey, ACtrl, AShift, AAlt);
end;

procedure TStringGridHelper.SetPDFKey(AKey: Word; ACtrl: Boolean; AShift: Boolean; AAlt: Boolean);
var
  Data: TStringGridHelperData;
begin
  Data := GetHelperData;
  Data.FPDFKey := MakeKeyConfig(AKey, ACtrl, AShift, AAlt);
end;

procedure TStringGridHelper.SetAutoFitKey(AKey: Word; ACtrl, AShift, AAlt: Boolean);
var
  Data: TStringGridHelperData;
begin
  Data := GetHelperData;
  Data.FAutoFitKey := MakeKeyConfig(AKey, ACtrl, AShift, AAlt);
end;

procedure TStringGridHelper.SetCancelKey(AKey: Word; ACtrl: Boolean; AShift: Boolean; AAlt: Boolean);
var
  Data: TStringGridHelperData;
begin
  Data := GetHelperData;
  Data.FCancelKey := MakeKeyConfig(AKey, ACtrl, AShift, AAlt);
end;

procedure TStringGridHelper.SetCellStyle(ACol, ARow: Integer; ABackColor, AFontColor: TColor; ABold, AItalic: Boolean; AFontSize: Integer);
var
  Data: TStringGridHelperData;
begin
  try
    Data := GetHelperData;
    if (ACol < 0) or (ACol >= Self.ColCount) then
      raise Exception.CreateFmt('Geçersiz sütun indexi: %d (0-%d arasý olmalý)', [ACol, Self.ColCount - 1]);

    if (ARow < 0) or (ARow >= Self.RowCount) then
      raise Exception.CreateFmt('Geçersiz satýr indexi: %d (0-%d arasý olmalý)', [ARow, Self.RowCount - 1]);

    if AFontSize <= 0 then
      raise Exception.CreateFmt('Geçersiz font boyutu: %d (pozitif olmalý)', [AFontSize]);

    if ACol >= Length(Data.FCellStyles) then begin
      SetLength(Data.FCellStyles, Self.ColCount);
    end;
    if ARow >= Length(Data.FCellStyles[ACol]) then begin
      SetLength(Data.FCellStyles[ACol], Self.RowCount);
    end;

    try
      Data.FCellStyles[ACol][ARow].BackColor := ABackColor;
      Data.FCellStyles[ACol][ARow].FontColor := AFontColor;
      Data.FCellStyles[ACol][ARow].FontBold := ABold;
      Data.FCellStyles[ACol][ARow].FontItalic := AItalic;
      Data.FCellStyles[ACol][ARow].FontSize := AFontSize;
    finally
      TGridHack(Self).InvalidateCell(ACol, ARow);
    end;
  except
    on E: Exception do
      raise Exception.CreateFmt('SetCellStyle hatasý [Col:%d, Row:%d], mesaj: %s', [ACol, ARow, E.Message]);
  end;
end;

procedure TStringGridHelper.SetCSVKey(AKey: Word; ACtrl, AShift, AAlt: Boolean);
var
  Data: TStringGridHelperData;
begin
  Data := GetHelperData;
  Data.FCSVKey := MakeKeyConfig(AKey, ACtrl, AShift, AAlt);
end;

procedure TStringGridHelper.SetDeleteRowKey(AKey: Word; ACtrl, AShift, AAlt: Boolean);
var
  Data: TStringGridHelperData;
begin
  Data := GetHelperData;
  Data.FDeleteRowKey := MakeKeyConfig(AKey, ACtrl, AShift, AAlt);
end;

function TStringGridHelper.CompareText(const S1, S2: string): Boolean;
begin
  if CaseSensitive then begin
    Result := Pos(S1, S2) > 0;
  end
  else begin
    Result := Pos(AnsiUpperCase(S1), AnsiUpperCase(S2)) > 0;
  end;
end;


procedure TStringGridHelper.SwapRows(const Data: TStringGridHelperData; Idx1, Idx2: Integer);
var
  TempRow: TStringList;
  TempStyles: array of TCellStyle;
  k: Integer;
begin
  if Idx1 = Idx2 then Exit;

  TempRow := TStringList.Create;
  try
    TempRow.Assign(Self.Rows[Idx1]);
    Self.Rows[Idx1].Assign(Self.Rows[Idx2]);
    Self.Rows[Idx2].Assign(TempRow);
  finally
    TempRow.Free;
  end;

  if Length(Data.FCellStyles) > 0 then begin
    SetLength(TempStyles, Self.ColCount);

    for k := 0 to Self.ColCount - 1 do begin
      if (k < Length(Data.FCellStyles)) and (Idx1 < Length(Data.FCellStyles[k])) then begin
        TempStyles[k] := Data.FCellStyles[k][Idx1];
      end;
    end;

    for k := 0 to Self.ColCount - 1 do begin
      if (k < Length(Data.FCellStyles)) and (Idx2 < Length(Data.FCellStyles[k])) then begin
        Data.FCellStyles[k][Idx1] := Data.FCellStyles[k][Idx2];
      end;
    end;

    for k := 0 to Self.ColCount - 1 do begin
      if (k < Length(Data.FCellStyles)) and (Idx2 < Length(Data.FCellStyles[k])) then begin
        Data.FCellStyles[k][Idx2] := TempStyles[k];
      end;
    end;
  end;
end;


procedure TStringGridHelper.SortByColumn(ACol: Integer; Ascending: Boolean);
var
  Data: TStringGridHelperData;

  procedure QuickSort(L, R: Integer);
  var
    I, J: Integer;
    Pivot: string;
  begin
    I := L;
    J := R;
    Pivot := Self.Cells[ACol, (L + R) div 2];

    repeat
      if Ascending then begin
        while TSmartComparer.Compare(Self.Cells[ACol, I], Pivot) < 0 do Inc(I);
        while TSmartComparer.Compare(Self.Cells[ACol, J], Pivot) > 0 do Dec(J);
      end
      else begin
        while TSmartComparer.Compare(Self.Cells[ACol, I], Pivot) > 0 do Inc(I);
        while TSmartComparer.Compare(Self.Cells[ACol, J], Pivot) < 0 do Dec(J);
      end;

      if I <= J then begin
        SwapRows(Data, I, J);
        Inc(I);
        Dec(J);
      end;
    until I > J;

    if L < J then QuickSort(L, J);
    if I < R then QuickSort(I, R);
  end;

begin
  Data := GetHelperData;
  if (ACol < 0) or (ACol >= Self.ColCount) then Exit;
  if Self.RowCount <= Self.FixedRows + 1 then Exit;

  Screen.Cursor := crHourGlass;
  try
    QuickSort(Self.FixedRows, Self.RowCount - 1);
    Self.Invalidate;
  finally
    Screen.Cursor := crDefault;
  end;
end;

procedure TStringGridHelper.SortColumn(ACol: Integer; Ascending: Boolean);
var
  Data: TStringGridHelperData;
begin
  Data := GetHelperData;
  Data.FSortColumn := ACol;
  Data.FSortAscending := Ascending;
  SortByColumn(ACol, Ascending);
end;

procedure TStringGridHelper.CloneRow(CurrentRow: Integer);
var
  i: Integer;
  NewRow: Integer;
  Data: TStringGridHelperData;
begin
  Data := GetHelperData;
  if (CurrentRow < 0) or (CurrentRow >= Self.RowCount) then Exit;

  Self.RowCount := Self.RowCount + 1;
  NewRow := CurrentRow + 1;
  ShiftStyles(CurrentRow, False);

  for i := 0 to Self.ColCount - 1 do begin
    Self.Cells[i, NewRow] := Self.Cells[i, CurrentRow];
    if (i < Length(Data.FCellStyles)) and (CurrentRow < Length(Data.FCellStyles[i])) then begin
      Data.FCellStyles[i][NewRow] := Data.FCellStyles[i][CurrentRow];
    end;
  end;

  Self.Invalidate;
end;

function TStringGridHelper.GetCellStyle(ACol, ARow: Integer): TCellStyle;
var
  Data: TStringGridHelperData;
begin
  try
    Data := GetHelperData;

    if (ACol < 0) or (ACol >= Self.ColCount) then
      raise Exception.CreateFmt('Geçersiz sütun indexi: %d', [ACol]);

    if (ARow < 0) or (ARow >= Self.RowCount) then
      raise Exception.CreateFmt('Geçersiz satýr indexi: %d', [ARow]);

    if (ACol < Length(Data.FCellStyles))
      and (ARow < Length(Data.FCellStyles[ACol]))
      and (Data.FCellStyles[ACol][ARow].FontSize > 0) then begin
      Result := Data.FCellStyles[ACol][ARow];
    end
    else begin
      if (ACol < Self.FixedCols) or (ARow < Self.FixedRows) then begin
        Result.BackColor := Self.FixedColor;
        Result.FontColor := Self.Font.Color;
      end
      else begin
        Result.BackColor := Self.Color;
        Result.FontColor := Self.Font.Color;
      end;
      Result.FontBold := fsBold in Self.Font.Style;
      Result.FontItalic := fsItalic in Self.Font.Style;
      Result.FontSize := Self.Font.Size;
    end;
  except
    on E: Exception do
    begin
      Result.BackColor := clWhite;
      Result.FontColor := clBlack;
      Result.FontBold := False;
      Result.FontItalic := False;
      Result.FontSize := 8;
      OutputDebugString(PChar(Format('GetCellStyle hatasý [Col:%d, Row:%d], mesaj: %s', [ACol, ARow, E.Message])));
    end;
  end;
end;

function TStringGridHelper.GetNextVisibleCol(CurrentCol, Direction: Integer): Integer;
var
  NewCol, CheckCount, MinCol: Integer;
begin
  NewCol := CurrentCol;
  CheckCount := 0;
  MinCol := Self.FixedCols;
  repeat
    NewCol := NewCol + Direction;
    if NewCol >= Self.ColCount then begin
      NewCol := MinCol
    end
    else if NewCol < MinCol then begin
      NewCol := Self.ColCount - 1;
    end;

    Inc(CheckCount);
    if CheckCount > Self.ColCount then begin
      Result := CurrentCol;
      Exit;
    end;
  until Self.ColWidths[NewCol] >= 1;
  Result := NewCol;
end;

function TStringGridHelper.GetNextVisibleRow(CurrentRow, Direction: Integer): Integer;
var
  NewRow, CheckCount, MinRow: Integer;
begin
  NewRow := CurrentRow;
  CheckCount := 0;
  MinRow := Self.FixedRows;
  repeat
    NewRow := NewRow + Direction;
    if NewRow >= Self.RowCount then begin
      NewRow := MinRow
    end
    else if NewRow < MinRow then begin
      NewRow := Self.RowCount - 1;
    end;

    Inc(CheckCount);
    if CheckCount > Self.RowCount then begin
      Result := CurrentRow;
      Exit;
    end;
  until Self.RowHeights[NewRow] >= 1;
  Result := NewRow;
end;

procedure TStringGridHelper.GridKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
var
  Data: TStringGridHelperData;
begin
  Data := GetHelperData;
  HandleNavigationKeys(Key, Shift);
  if Key = 0 then Exit;

  if Assigned(Data.FOriginalKeyDown) then begin
    Data.FOriginalKeyDown(Sender, Key, Shift);
  end;

  if CheckKeyMatch(Key, Shift, Data.FSearchKey) then begin
    if not Data.FSearching then begin
      Search;
    end;
    Key := 0;
  end
  else if CheckKeyMatch(Key, Shift, Data.FDeleteRowKey) then begin
    if not Data.FExporting and not Data.FSearching then begin
      DeleteRow;
    end;
    Key := 0;
  end
  else if CheckKeyMatch(Key, Shift, Data.FCancelKey) then begin
    if Data.FSearching or Data.FExporting then begin
      CancelSearch
    end
    else begin
      Reset;
    end;
    Key := 0;
  end
  else if CheckKeyMatch(Key, Shift, Data.FAutoFitKey) then begin
    if not Data.FExporting and not Data.FSearching then begin
      AutoFit;
    end;
    Key := 0;
  end
  else if CheckKeyMatch(Key, Shift, Data.FExcelKey) then begin
    if not Data.FExporting and not Data.FSearching then begin
      ExportToExcel;
    end;
    Key := 0;
  end
  else if CheckKeyMatch(Key, Shift, Data.FPDFKey) then begin
    if not Data.FExporting and not Data.FSearching then begin
      ExportToPDF;
    end;
    Key := 0;
  end
  else if CheckKeyMatch(Key, Shift, Data.FCSVKey) then begin
    if not Data.FExporting and not Data.FSearching then begin
      ExportToCSV;
    end;
    Key := 0;
  end
  else if (Key = Ord('C')) and (ssCtrl in Shift) then begin
    if (Row < FixedRows) or (Col < FixedCols) then Exit;
    Clipboard.AsText := Cells[Col, Row];
    Key := 0;
  end;
end;

procedure TStringGridHelper.HandleNavigationKeys(var Key: Word; Shift: TShiftState);
var
  NewCol, NewRow: Integer;
begin
  if (ssCtrl in Shift) or (ssShift in Shift) or (ssAlt in Shift) then Exit;

  case Key of
    VK_LEFT:
      begin
        NewCol := GetNextVisibleCol(Self.Col, -1);
        if NewCol <> Self.Col then begin
          Self.Col := NewCol;
          Key := 0;
        end;
      end;
    VK_RIGHT:
      begin
        NewCol := GetNextVisibleCol(Self.Col, 1);
        if NewCol <> Self.Col then begin
          Self.Col := NewCol;
          Key := 0;
        end;
      end;
    VK_UP:
      begin
        NewRow := GetNextVisibleRow(Self.Row, -1);
        if NewRow <> Self.Row then begin
          Self.Row := NewRow;
          Key := 0;
        end;
      end;
    VK_DOWN:
      begin
        NewRow := GetNextVisibleRow(Self.Row, 1);
        if NewRow <> Self.Row then begin
          Self.Row := NewRow;
          Key := 0;
        end;
      end;
  end;
end;

procedure TStringGridHelper.InternalDrawCell(Sender: TObject; ACol, ARow: Integer; Rect: TRect; State: TGridDrawState);
var
  Style: TCellStyle;
  CellValue: string;
  TextRect: TRect;
  IntValue: Int64;
  FloatValue, PercentageValue: Double;
  DateValue, TimeValue: TDateTime;
  CurrencyValue: Currency;
  TextWidth, TextHeight: Integer;
  TextX, TextY: Integer;
  Alignment: TAlignment;
begin
  Style := GetCellStyle(ACol, ARow);

  Self.Canvas.Brush.Color := Style.BackColor;
  Self.Canvas.FillRect(Rect);
  Self.Canvas.Font.Color := Style.FontColor;
  Self.Canvas.Font.Size := Style.FontSize;

  if Style.FontBold then begin
    Self.Canvas.Font.Style := Self.Canvas.Font.Style + [fsBold];
  end
  else begin
    Self.Canvas.Font.Style := Self.Canvas.Font.Style - [fsBold];
  end;

  CellValue := Trim(Self.Cells[ACol, ARow]);
  TextRect := Rect;
  InflateRect(TextRect, -2, -2);
  Alignment := taLeftJustify;

  if Trim(CellValue) <> '' then begin
    if TSmartParser.TryParseInteger(CellValue, IntValue) then begin
      Alignment := taRightJustify;
    end
    else if TSmartParser.TryParseFloat(CellValue, FloatValue) then begin
      Alignment := taRightJustify;
    end
    else if TSmartParser.TryParseCurrency(CellValue, CurrencyValue) then begin
      Alignment := taRightJustify;
    end
    else if TSmartParser.TryParsePercentage(CellValue, PercentageValue) then begin
      Alignment := taRightJustify;
    end
    else if TSmartParser.TryParseDate(CellValue, DateValue) then begin
      Alignment := taCenter;
    end
    else if TSmartParser.TryParseTime(CellValue, TimeValue) then begin
      Alignment := taCenter;
    end
    else begin
      Alignment := taLeftJustify;
    end;
  end;

  TextWidth := Self.Canvas.TextWidth(CellValue);
  TextHeight := Self.Canvas.TextHeight(CellValue);

  case Alignment of
    taLeftJustify: TextX := TextRect.Left;
    taCenter: TextX := TextRect.Left + (TextRect.Width - TextWidth) div 2;
    taRightJustify: TextX := TextRect.Right - TextWidth;
  end;

  TextY := TextRect.Top + (TextRect.Height - TextHeight) div 2;
  Self.Canvas.TextRect(TextRect, TextX, TextY, CellValue);

  if (gdSelected in State) and (ACol = Self.Col) and (ARow = Self.Row) then begin
    Self.Canvas.DrawFocusRect(Rect);
  end;
end;

procedure TStringGridHelper.AutoFit;
begin
  if IsSearching or IsExporting then begin
    MessageDlg('Ýþlem devam ederken sütun geniþliði ayarlanamaz!', mtWarning, [mbOK], 0);
    Exit;
  end;
  AutoFitColumns;
end;

procedure TStringGridHelper.AutoFitColumns;
var
  i, j: Integer;
  MaxWidth, CellWidth: Integer;
  Canvas: TCanvas;
  Style: TCellStyle;
  Data: TStringGridHelperData;
  DC: HDC;
begin
  Data := GetHelperData;
  Canvas := nil;
  DC := 0;

  try
    Canvas := TCanvas.Create;
    try
      DC := GetDC(Self.Handle);
      if DC = 0 then
        raise Exception.Create('Device Context alýnamadý!');

      Canvas.Handle := DC;
      Canvas.Font.Assign(Self.Font);

      Data.FProgress.Show('Sütunlar ayarlanýyor...', Self.ColCount);
      try
        for i := 0 to Self.ColCount - 1 do begin
          if Self.ColWidths[i] > 0 then begin
            MaxWidth := MIN_COL_WIDTH;

            if i mod PROGRESS_UPDATE_INTERVAL_COL = 0 then begin
              Data.FProgress.Update(i, Format('Sütun ayarlanýyor: %d / %d', [i + 1, Self.ColCount]));
              Application.ProcessMessages;
              if Data.FProgress.IsCancelled then begin
                MessageDlg('Sütun ayarlama iptal edildi.', mtInformation, [mbOK], 0);
                Exit;
              end;
            end;

            for j := 0 to Self.RowCount - 1 do begin
              if Self.RowHeights[j] > 0 then begin
                try
                  Style := GetCellStyle(i, j);
                  Canvas.Font.Size := Style.FontSize;
                  if Style.FontBold then begin
                    Canvas.Font.Style := [fsBold];
                  end
                  else begin
                    Canvas.Font.Style := [];
                  end;

                  CellWidth := Canvas.TextWidth(Self.Cells[i, j]) + CELL_PADDING;
                  if CellWidth > MaxWidth then begin
                    MaxWidth := CellWidth;
                  end;
                except
                  Continue;
                end;
              end;
            end;

            if MaxWidth > MAX_COL_WIDTH then begin
              MaxWidth := MAX_COL_WIDTH;
            end;
            Self.ColWidths[i] := MaxWidth;
          end;
        end;
      finally
        Data.FProgress.Hide;
      end;
    finally
      if DC <> 0 then begin
        ReleaseDC(Self.Handle, DC);
      end;
      Canvas.Free;
    end;
  except
    on E: Exception do begin
      Data.FProgress.Hide;
      raise Exception.CreateFmt('AutoFit hatasý: %s', [E.Message]);
    end;
  end;
end;

procedure TStringGridHelper.CancelSearch;
var
  Data: TStringGridHelperData;
begin
  Data := GetHelperData;
  Data.FCancelled := True;
  Data.FProgress.Hide;
end;

procedure TStringGridHelper.Search(const ASearchText: string);
var
  SearchText: string;
  i, j: Integer;
  StartRow, StartCol: Integer;
  Found: Boolean;
  ProcessCount: Integer;
  Data: TStringGridHelperData;
  FoundCol, FoundRow, SearchStartRow: Integer;
begin
  Data := GetHelperData;
  try
    if Data.FSearching then
      raise Exception.Create('Arama zaten devam ediyor!');

    if ASearchText = '' then begin
      if InputQuery('Arama', 'Aramak istediðiniz metni girin (ESC ile iptal):', Data.FLastSearchText) then begin
        SearchText := Data.FLastSearchText
      end
      else Exit;
    end
    else begin
      SearchText := ASearchText;
    end;

    if SearchText = '' then Exit;

    Data.FLastSearchText := SearchText;
    Found := False;
    Data.FSearching := True;
    Data.FCancelled := False;
    ProcessCount := 0;
    SearchStartRow := Self.FixedRows;
    Data.FProgress.Show('Arama yapýlýyor...', Self.RowCount);
    try
      if (Data.FLastSearchCol >= 0) and (Data.FLastSearchRow >= 0) then begin
        StartRow := Data.FLastSearchRow;
        StartCol := Data.FLastSearchCol + 1;
      end
      else begin
        StartRow := Self.Row;
        if StartRow < SearchStartRow then begin
          StartRow := SearchStartRow;
        end;
        StartCol := 0;
      end;

      for j := StartCol to Self.ColCount - 1 do begin
        if (Self.ColWidths[j] > 0) and (Self.RowHeights[StartRow] > 0) then begin //Kolon geniþliði ve Satýr yüksekliði 0'dan büyük ise arama yap
          if CompareText(SearchText, Self.Cells[j, StartRow]) then begin
            FoundCol := j;
            FoundRow := StartRow;
            Data.FLastSearchCol := j;
            Data.FLastSearchRow := StartRow;
            Found := True;
            Break;
          end;
        end;
      end;

      if not Found then begin
        for i := StartRow + 1 to Self.RowCount - 1 do begin
          if Self.RowHeights[i] > 0 then begin
            Inc(ProcessCount);
            if ProcessCount mod PROGRESS_UPDATE_INTERVAL_SEARCH = 0 then begin
              Data.FProgress.Update(i, Format('Aranýyor: %d / %d satýr', [i, Self.RowCount]));
              Application.ProcessMessages;
              if Data.FProgress.IsCancelled then begin
                MessageDlg('Arama iptal edildi.', mtInformation, [mbOK], 0);
                Exit;
              end;
            end;

            for j := 0 to Self.ColCount - 1 do begin
              if Self.ColWidths[j] > 0 then begin
                if CompareText(SearchText, Self.Cells[j, i]) then begin
                  FoundCol := j;
                  FoundRow := i;
                  Data.FLastSearchCol := j;
                  Data.FLastSearchRow := i;
                  Found := True;
                  Break;
                end;
              end;
            end;

            if Found then Break;
          end;
        end;
      end;

      if not Found then begin
        for i := Self.FixedRows to StartRow do begin
          if Self.RowHeights[i] > 0 then begin
            Inc(ProcessCount);
            if ProcessCount mod PROGRESS_UPDATE_INTERVAL_SEARCH = 0 then begin
              Data.FProgress.Update(i, Format('Aranýyor: %d / %d satýr', [i, Self.RowCount]));
              Application.ProcessMessages;
              if Data.FProgress.IsCancelled then begin
                MessageDlg('Arama iptal edildi.', mtInformation, [mbOK], 0);
                Exit;
              end;
            end;

            for j := 0 to Self.ColCount - 1 do begin
              if (i = StartRow) and (j >= StartCol) then Break;
              if Self.ColWidths[j] > 0 then begin
                if CompareText(SearchText, Self.Cells[j, i]) then begin
                  FoundCol := j;
                  FoundRow := i;
                  Data.FLastSearchCol := j;
                  Data.FLastSearchRow := i;
                  Found := True;
                  Break;
                end;
              end;
            end;

            if Found then Break;
          end;
        end;
      end;

      if Found then begin
        Self.Col := FoundCol;
        Self.Row := FoundRow;
        HighlightCell(FoundCol, FoundRow);
      end
      else begin
        MessageDlg('Aradýðýnýz metin bulunamadý!', mtError, [mbOK], 0);
        Reset;
      end;
    finally
      Data.FSearching := False;
      Data.FCancelled := False;
      Data.FProgress.Hide;
    end;
  except
    on E: Exception do begin
      Data.FSearching := False;
      Data.FCancelled := False;
      Data.FProgress.Hide;
      raise Exception.CreateFmt('Arama hatasý: %s', [E.Message]);
    end;
  end;
end;

procedure TStringGridHelper.Reset;
var
  Data: TStringGridHelperData;
begin
  Data := GetHelperData;
  Data.FLastSearchText := '';
  Data.FLastSearchCol := -1;
  Data.FLastSearchRow := -1;
end;

procedure TStringGridHelper.ExportToCSV;
begin
  ExportToFile(etCSV);
end;

procedure TStringGridHelper.ExportToCSVFile(const FileName, FileTypeText: string);
var
  CSVFile: TextFile;
  Line, CellValue: string;
  i, j: Integer;
  ProcessCount: Integer;
  Data: TStringGridHelperData;
begin
  Data := GetHelperData;
  ProcessCount := 0;
  Data.FProgress.Show(FileTypeText + ' Export', Self.RowCount);
  try
    AssignFile(CSVFile, FileName);
    try
      Rewrite(CSVFile);
      for i := 0 to Self.RowCount - 1 do begin
        if Self.RowHeights[i] > 0 then begin
          Inc(ProcessCount);
          if ProcessCount mod PROGRESS_UPDATE_INTERVAL_ROW = 0 then begin
            Data.FProgress.Update(i, Format('%s: %d / %d satýr', [FileTypeText, i, Self.RowCount]));
            Application.ProcessMessages;
            if Data.FProgress.IsCancelled then begin
              CloseFile(CSVFile);
              DeleteFile(pChar(FileName));
              MessageDlg(FileTypeText + ' export iptal edildi.', mtError, [mbOK], 0);
              Exit;
            end;
          end;
          Line := '';
          for j := 0 to Self.ColCount - 1 do begin
            if Self.ColWidths[j] > 0 then begin
              CellValue := Self.Cells[j, i];
              if (Pos(',', CellValue) > 0) or (Pos('"', CellValue) > 0) then begin
                CellValue := StringReplace(CellValue, '"', '""', [rfReplaceAll]);
                CellValue := '"' + CellValue + '"';
              end;
              if j > 0 then Line := Line + ',';
              Line := Line + CellValue;
            end;
          end;
          WriteLn(CSVFile, Line);
        end;
      end;
      CloseFile(CSVFile);
      MessageDlg(FileTypeText + ' dosyasý baþarýyla kaydedildi: ' + FileName, mtInformation, [mbOK], 0);
    except
      on E: Exception do begin
        CloseFile(CSVFile);
        MessageDlg(FileTypeText + ' export hatasý: ' + E.Message, mtError, [mbOK], 0);
      end;
    end;
  finally
    Data.FExporting := False;
    Data.FCancelled := False;
    Data.FProgress.Hide;
  end;
end;

procedure TStringGridHelper.ExportToExcel;
begin
  ExportToFile(etExcel);
end;

procedure TStringGridHelper.ExportToPDF;
begin
  ExportToFile(etPDF);
end;

procedure TStringGridHelper.ExportToFile(ExportType: TExportType);
var
  SaveDialog: TSaveDialog;
  FileName: string;
  ExcelApp, WorkBook, WorkSheet: OleVariant;
  i, j: Integer;
  ProcessCount, ExcelCol, ExcelRow: Integer;
  FileTypeText: string;
  CellStyle: TCellStyle;
  Cell: OleVariant;
  Data: TStringGridHelperData;
begin
  Data := GetHelperData;

  try
    if Data.FExporting then
      raise Exception.Create('Export zaten devam ediyor!');

    case ExportType of
      etExcel: FileTypeText := 'Excel';
      etPDF: FileTypeText := 'PDF';
      etCSV: FileTypeText := 'CSV';
    end;

    SaveDialog := TSaveDialog.Create(nil);
    try
      SaveDialog.Title := FileTypeText + ' Dosyasý Olarak Kaydet';
      case ExportType of
        etExcel:
          begin
            SaveDialog.Filter := 'Excel Dosyasý (*.xlsx)|*.xlsx|Eski Excel Dosyasý (*.xls)|*.xls';
            SaveDialog.DefaultExt := 'xlsx';
          end;
        etPDF:
          begin
            SaveDialog.Filter := 'PDF Dosyasý (*.pdf)|*.pdf';
            SaveDialog.DefaultExt := 'pdf';
          end;
        etCSV:
          begin
            SaveDialog.Filter := 'CSV Dosyasý (*.csv)|*.csv';
            SaveDialog.DefaultExt := 'csv';
          end;
      end;
      SaveDialog.FileName := 'GridExport_' + FormatDateTime('yyyymmdd_hhnnss', Now);
      if not SaveDialog.Execute then Exit;
      FileName := SaveDialog.FileName;
    finally
      SaveDialog.Free;
    end;

    Data.FExporting := True;
    Data.FCancelled := False;
    ProcessCount := 0;

    if ExportType = etCSV then begin
      ExportToCSVFile(FileName, FileTypeText);
      Exit;
    end;

    Data.FProgress.Show(FileTypeText + ' Export', Self.RowCount);
    try
      try
        try
          ExcelApp := CreateOleObject('Excel.Application');
        except
          on E: Exception do
            raise Exception.Create('Excel yüklü deðil veya baþlatýlamadý: ' + E.Message);
        end;

        ExcelApp.Visible := False;
        ExcelApp.DisplayAlerts := False;

        WorkBook := ExcelApp.Workbooks.Add;
        WorkSheet := WorkBook.WorkSheets[1];

        ExcelRow := 0;
        for i := 0 to Self.RowCount - 1 do begin
          if Self.RowHeights[i] > 0 then begin
            Inc(ProcessCount);
            if ProcessCount mod PROGRESS_UPDATE_INTERVAL_ROW = 0 then begin
              Data.FProgress.Update(i, Format('%s: %d / %d satýr', [FileTypeText, i, Self.RowCount]));
              Application.ProcessMessages;
              if Data.FProgress.IsCancelled then begin
                raise Exception.Create('Export kullanýcý tarafýndan iptal edildi');
              end;
            end;
            Inc(ExcelRow);
            ExcelCol := 0;
            for j := 0 to Self.ColCount - 1 do begin
              if Self.ColWidths[j] > 0 then begin
                Inc(ExcelCol);
                try
                  Cell := WorkSheet.Cells[ExcelRow, ExcelCol];
                  CellStyle := GetCellStyle(j, i);
                  Cell.Value := Self.Cells[j, i];
                  Cell.Interior.Color := ColorToRGB(CellStyle.BackColor);
                  Cell.Font.Color := ColorToRGB(CellStyle.FontColor);
                  Cell.Font.Bold := CellStyle.FontBold;
                  Cell.Font.Italic := CellStyle.FontItalic;
                  Cell.Font.Size := CellStyle.FontSize;
                  Cell.HorizontalAlignment := 3;
                  Cell.VerticalAlignment := 2;
                  Cell.WrapText := True;
                except
                  Continue;
                end;
              end;
            end;
          end;
        end;

        WorkSheet.Columns.AutoFit;

        case ExportType of
          etExcel:
            begin
              WorkBook.SaveAs(FileName);
              WorkBook.Close;
            end;
          etPDF:
            begin
              WorkSheet.UsedRange.Borders.LineStyle := 1;
              WorkSheet.PageSetup.Orientation := 2;
              WorkSheet.PageSetup.Zoom := False;
              WorkSheet.PageSetup.FitToPagesWide := 1;
              WorkSheet.PageSetup.FitToPagesTall := False;

              try
                WorkSheet.ExportAsFixedFormat(0, FileName);
              except
                on E: Exception do
                  raise Exception.Create('PDF export hatasý. Excel 2007 veya üzeri gereklidir: ' + E.Message);
              end;

              WorkBook.Close(False);
            end;
        end;

        ExcelApp.Quit;
        VarClear(ExcelApp);
        VarClear(WorkBook);
        VarClear(WorkSheet);

        MessageDlg(FileTypeText + ' dosyasý baþarýyla kaydedildi: ' + FileName, mtInformation, [mbOK], 0);
      except
        on E: Exception do
        begin
          try
            if not VarIsNull(WorkBook) and not VarIsClear(WorkBook) then begin
              WorkBook.Close(False);
            end;
            if not VarIsNull(ExcelApp) and not VarIsClear(ExcelApp) then begin
              ExcelApp.Quit;
            end;
          except
          end;
          VarClear(ExcelApp);
          VarClear(WorkBook);
          VarClear(WorkSheet);
          raise;
        end;
      end;
    finally
      Data.FExporting := False;
      Data.FCancelled := False;
      Data.FProgress.Hide;
    end;
  except
    on E: Exception do begin
      Data.FExporting := False;
      MessageDlg(FileTypeText + ' export hatasý: ' + E.Message, mtError, [mbOK], 0);
    end;
  end;
end;


function TStringGridHelper.GetHeaderCount: Integer;
begin
  Result := GetHelperData.FHeaderCount;
end;

function TStringGridHelper.GetHeaderRowIndex(HeaderIndex: Integer): Integer;
var
  Data: TStringGridHelperData;
begin
  Data := GetHelperData;

  if (HeaderIndex < 0) or (HeaderIndex >= Data.FHeaderCount) then
    raise Exception.CreateFmt('Geçersiz Header index: %d (0-%d arasý olmalý)', [HeaderIndex, Data.FHeaderCount - 1]);

  Result := HeaderIndex;
end;

function TStringGridHelper.GetHeaderIndex(ARow: Integer): Integer;
var
  Data: TStringGridHelperData;
begin
  Data := GetHelperData;

  if (ARow >= 0) and (ARow < Data.FHeaderCount) then begin
    Result := ARow;
  end
  else begin
    Result := -1;
  end;
end;

function TStringGridHelper.IsHeaderRow(ARow: Integer): Boolean;
begin
  Result := GetHeaderIndex(ARow) >= 0;
end;

function TStringGridHelper.AddHeader: Integer;
var
  Data: TStringGridHelperData;
  i, NewHeaderRow: Integer;
begin
  Data := GetHelperData;

  try
    Self.RowCount := Self.RowCount + 1;

    for i := Self.RowCount - 1 downto Data.FHeaderCount + 1 do begin
      Self.Rows[i].Assign(Self.Rows[i - 1]);
    end;

    NewHeaderRow := Data.FHeaderCount;
    Self.Rows[NewHeaderRow].Clear;
    Self.FixedRows := Self.FixedRows + 1;
    ShiftStyles(NewHeaderRow, False);
    Inc(Data.FHeaderCount);

    for i := 0 to Self.ColCount - 1 do begin
      SetCellStyle(i, NewHeaderRow,
        Self.FixedColor,
        Self.Font.Color,
        fsBold in Self.Font.Style,
        fsItalic in Self.Font.Style,
        Self.Font.Size);
    end;

    Self.Invalidate;
    Result := NewHeaderRow;
  except
    on E: Exception do
      raise Exception.CreateFmt('Header ekleme hatasý: %s', [E.Message]);
  end;
end;

procedure TStringGridHelper.RemoveHeader(HeaderIndex: Integer);
var
  Data: TStringGridHelperData;
  i, HeaderRow: Integer;
begin
  Data := GetHelperData;

  if Data.FHeaderCount = 0 then
    raise Exception.Create('Silinecek Header yok!');

  try
    HeaderRow := GetHeaderRowIndex(HeaderIndex);
    ShiftStyles(HeaderRow, True);

    for i := HeaderRow to Self.RowCount - 2 do begin
      Self.Rows[i].Assign(Self.Rows[i + 1]);
    end;

    Self.RowCount := Self.RowCount - 1;

    if Self.FixedRows > Data.FOriginalFixedRows then begin
      Self.FixedRows := Self.FixedRows - 1;
    end;

    Dec(Data.FHeaderCount);
    Self.Invalidate;
  except
    on E: Exception do
      raise Exception.CreateFmt('Header silme hatasý [Index:%d]: %s', [HeaderIndex, E.Message]);
  end;
end;

procedure TStringGridHelper.RemoveAllHeaders;
var
  Data: TStringGridHelperData;
  i: Integer;
begin
  Data := GetHelperData;

  if Data.FHeaderCount = 0 then Exit;

  try
    for i := Data.FHeaderCount - 1 downto 0 do begin
      RemoveHeader(i);
    end;

    Data.FHeaderCount := 0;
    Self.Invalidate;
  except
    on E: Exception do
      raise Exception.CreateFmt('Tüm Header silme hatasý: %s', [E.Message]);
  end;
end;

procedure TStringGridHelper.SetHeaderText(HeaderIndex, ACol: Integer; const AText: string);
var
  HeaderRow: Integer;
begin
  if GetHelperData.FHeaderCount = 0 then
    raise Exception.Create('Header oluþturulmamýþ! Önce AddHeader çaðýrýn.');

  if (ACol < 0) or (ACol >= Self.ColCount) then
    raise Exception.CreateFmt('Geçersiz sütun indexi: %d', [ACol]);

  HeaderRow := GetHeaderRowIndex(HeaderIndex);
  Self.Cells[ACol, HeaderRow] := AText;
end;

function TStringGridHelper.GetHeaderText(HeaderIndex, ACol: Integer): string;
var
  HeaderRow: Integer;
begin
  if GetHelperData.FHeaderCount = 0 then
    raise Exception.Create('Header yok!');

  if (ACol < 0) or (ACol >= Self.ColCount) then
    raise Exception.CreateFmt('Geçersiz sütun indexi: %d', [ACol]);

  HeaderRow := GetHeaderRowIndex(HeaderIndex);
  Result := Self.Cells[ACol, HeaderRow];
end;

procedure TStringGridHelper.SetHeaderStyle(HeaderIndex: Integer; ABackColor, AFontColor: TColor;
  ABold, AItalic: Boolean; AFontSize: Integer);
var
  HeaderRow, i: Integer;
begin
  HeaderRow := GetHeaderRowIndex(HeaderIndex);

  for i := 0 to Self.ColCount - 1 do begin
    SetCellStyle(i, HeaderRow, ABackColor, AFontColor, ABold, AItalic, AFontSize);
  end;
end;


procedure CleanupGridHelpers;
begin
  if Assigned(GridHelperList) then begin
    FreeAndNil(GridHelperList);
  end;
end;

{ TGridObserver }

procedure TGridObserver.Notification(AComponent: TComponent; Operation: TOperation);
begin
  inherited;
  if (Operation = opRemove) and (AComponent is TStringGrid) then begin
    if Assigned(GridHelperList) then begin
      GridHelperList.Remove(TStringGrid(AComponent));
    end;
  end;
end;

initialization
  GridHelperList := nil;

finalization
  CleanupGridHelpers;

end.