Core/DBDExcelFpc.pas - master - YakuninAV/Convertors

Core/DBDExcelFpc.pas
701 строка25 KB
YakuninAV
begin with gitflick
31 июл 2026, 15:21
31 июл 2026, 15:211dc0fc6
unit DBDExcelFPC;
  {$I mormot.defines.inc}

interface

uses
  Classes, SysUtils,
//  laz_fpspreadsheet,
  fpstypes, fpspreadsheet, fpsallformats, fpsUtils,
    mormot.core.base, mormot.core.os, mormot.core.unicode,
  DBDIntfs,
  DBDExcelInfs, DBDExcelBaseClassess;

type

  { TDBDExcelReaderFPC }

  TDBDExcelReaderFPC = class(TDBDExcelReaderbase)
  private
    WS: TsWorkSheet;
  public
    function AsBoolean(const aRow, aCol: Word; out B: Boolean): Boolean; overload; override;
    function AsCurrency(const aRow, aCol: Word; out C: Currency): Boolean; overload; override;
    function AsDateTime(const aRow, aCol: Word; out D: TDateTime): Boolean; overload; override;
    function AsDouble(const aRow, aCol: Word; out D: Double): Boolean; overload; override;
    function AsExtended(const aRow, aCol: Word; out D: Extended): Boolean; overload; override;
    function AsInteger(const aRow, aCol: Word; out I: Integer): Boolean; overload; override;
    function AsInt64(const aRow, aCol: Word; out I: Int64): Boolean; overload; override;
    function AsString(const aRow, aCol: Word; out S: String): Boolean; overload; override;
    function AsVariant(const aRow, aCol: Word; out V: Variant): Boolean; overload; override;
    constructor Create(Owner: IDBDExcelV2; Worksheet: TsWorkSheet);
    destructor Destroy; override;
  end;

  { TDBDExcelWriterOle }

  { TDBDExcelWriterFPC }

  TDBDExcelWriterFPC = class(TDBDExcelWriterBase)
  private
    WS: TsWorkSheet;
    FWSName: string;
  public
    /// Функция рисует границы ячейки
    function CellBorders(const aRow, aCol: Word; const Borders: Byte;
                         const LineStyle: Integer = xlContinuous; const LineWeight: Integer = xlThin): boolean; override;
    /// Функция вставляет строку в указанное место
    //  если флаг DoCopy установлен, то содержимое текущей строки копируется в новую
    function InsertRow(const aRow: Word; const DoCopy: Boolean=True): Boolean; override;
    /// Объединить ячейки, заданные координатами (Top, Left, Rows, Cols)
    function MergeCells(const aRange: TRect): Boolean; override;
    /// Функция производит выравнивание содержимого ячейки
    // если aRow=0, то выравнивание производится для всех ячеек столбца
    // если aCol=0, то выравнивание производится для всех ячеек строки
    function RangeAlign(const aRow, aCol: Word; const VAligment, HAligment: Integer): Boolean; overload; override; deprecated;
    function RangeAlign(const aRow, aCol: Word; const VAlignment: TDBDVertAlignment=dbdvaDefault;
                        const HAligment: TDBDHorAlignment=dbdhaDefault): Boolean; overload; override;
    /// Функция производит выравнивание содержимого ячеек заданного региона
    function RangeAlign(const aRange: TRect; const VAligment: Integer = xlVAlignTop; const HAligment: Integer = xlHAlignGeneral): Boolean; overload; override;
    /// Функция вставляет строку в указанное место
    //  если флаг DoCopy установлен, то содержимое текущей строки копируется в новую
    function WriteBoolean(const aCell: string; const B: Boolean): Boolean; overload; override;
    function WriteBoolean(const aRow, aCol: Word; const B: Boolean): Boolean; overload; override;
    function WriteCurrency(const aCell: string; const C: Currency): Boolean; overload; override;
    function WriteCurrency(const aRow, aCol: Word; const C: Currency): Boolean; overload; override;
    function WriteDateTime(const aCell: string; const D: TDateTime): Boolean; overload; override;
    function WriteDateTime(const aRow, aCol: Word; const D: TDateTime): Boolean; overload; override;
    function WriteDouble(const aCell: string; const D: Double): Boolean; overload; override;
    function WriteDouble(const aRow, aCol: Word; const D: Double): Boolean; overload; override;
    function WriteInteger(const aCell: string; const I: Integer): Boolean; overload; override;
    function WriteInteger(const aRow, aCol: Word; const I: Integer): Boolean; overload; override;
    function WriteInt64(const aCell: string; const I: Int64): Boolean; overload; override;
    function WriteInt64(const aRow, aCol: Word; const I: Int64): Boolean; overload; override;
    function WriteString(const aCell: string; const S: String): Boolean; overload; override;
    function WriteString(const aRow, aCol: Word; const S: String): Boolean; overload; override;
    function WriteVariant(const aCell: string; const V: Variant): Boolean; overload; override;
    function WriteVariant(const aRow, aCol: Word; const V: Variant): Boolean; overload; override;
    constructor Create(Owner: IDBDExcelV2; var Worksheet: TsWorkSheet);
    destructor Destroy; override;
    class function DbdToFpcVertAlignment(const VAlignment: TDbdVertAlignment): TsVertAlignment; static;
  end;


  { TDBDExcelFPC }

  /// Класс реализующий работу с таблицами в FPC
  TDBDExcelFPC = class(TDBDExcelBase)
  private
    FStop: Boolean;
    FCountWB,FCountWS,FCurrIdx: integer;
    FNameWS: string;
    WB: TsWorkBook;
    WS: TsWorkSheet;
    ReadyWB: Boolean;
    IsChanged: Boolean;
    procedure GetUsedRange;
    function GetReader: IDBDExcelReaderV2; override;
    function GetWriter: IDBDExcelWriterV2; override;
    procedure OnChangeWS(Sender: TObject; ASheet: TsWorkSheet);
  public
    /// констркутор
    constructor Create(FileName: TFileName; const WBOptions: TDBDOpenWBOprions = []; const aNotifier: IDBDNotifierV1 = nil);
    /// Деструктор
    destructor Destroy; override;
    /// Добавить пустой лист в книгу
    function AddWorkSheet(const aName: string; const Index: Word=0): Integer; override;
    /// Функция ищет строку подшапочник вида | 1 | 2 | .... | n |
    // LastRow  - последняя просматриваемая строка листа Excel
    // LefCol   - номер колонки Excel с которой начинается тело таблицы
    // RigthCol - номер колноки Excel на которой заканчивается тело таблицы
    // SkipEmpty - флаг разрешающий пропускать "пустые" колонки. Колонка считается пустой если
    //             ширина колонки > миниальной ширины колонки
    //             колонка скрыта
    //             значение в ячейке подшапочника пусто
    function CheckEnumRow(const LastRow: Integer=-1; const LeftCol: Integer=1; const RightCol: Integer=0;
                          const SkipEmpty: Boolean=true): TDBDTable; override;
    /// Закрыть Excel-файл
    procedure Close; override;
    /// Функция копирует область
    //  Src, Dst - строки представляющие адреса источника и назначения
    //  адресные строки имеют вид: "Лист!Ячейка1:Ячейка2"
    function CopyRange(const Src, Dst: string): Boolean; overload; override;
    /// Функция копирует область, заданную с помощью SrcRng, с листа Src на Лист Dst, начиная с ячейки DstCell
    function CopyRange(const Src: string; const SrcRng: TRect; const Dst: string; const DstCell: TPoint): Boolean; overload; override;
    /// Функция копирует область, заданную с помощью SrcRng, с листа Src на Лист Dst, начиная с ячейки (Row,Col)
    function CopyRange(const Src,SrcRng,Dst: string; const Row, Col: Word): Boolean; overload; override;
    /// Создать копию листа
    function CopyWorkSheet(const Src, Dst: string): Boolean; overload; override;
    /// Создать копию листа
    function CopyWorkSheet(SrcIdx: Word; const Dst: string): Boolean; overload; override;
    /// Получить список листов в книге
    function GetOpenedWorksheetNames: string; override;
    /// Получить список названий открытых книг
    function GetOpenedWorkbookNames: string; override;
    /// Полчить индекс листа с заданныи именем
    function GetWorkSheetIdx(const aWorkSheetName: string): Integer; override;
    /// Функция вставляет строку в указанное место
    //  если флаг DoCopy установлен, то содержимое текущей строки копируется в новую
    function InsertRow(const aRow: Word; const DoCopy: Boolean=True): Boolean; override;
    /// Перейти к следующему листу, если текущий лист последний возвращает false
    function NextWorkSheet: Boolean; override;
    /// Открыть Excel файл
    function OpenWorkBook(const aFileName: TFilename; const WBOptions: TDBDOpenWBOprions = []): Integer; override;
    /// Открыть (сделать текущим) лист по индексу. Функция возвращает имя листа или пусто
    function OpenWorkSheet(const aIndex: Integer): string; overload; override;
    /// Найти и открыть (сделать текущим) лист по названию. Функция возваращает индекс листа или <=0
    function OpenWorkSheet(const aWorkSheetName: string): Integer; overload; override;
    /// Функция производит выравнивание содержимого ячейки
    // если aRow=0, то выравнивание производится для всех ячеек столбца
    // если aCol=0, то выравнивание производится для всех ячеек строки
    function RangeAlign(const aRow, aCol: Word; const VAligment: Integer = xlVAlignTop;
                        const HAligment: Integer = xlHAlignGeneral): Boolean; overload; override;
    /// Функция производит выравнивание содержимого ячеек заданного региона
    function RangeAlign(const aRange: TRect; const VAligment: Integer = xlVAlignTop;
                        const HAligment: Integer = xlHAlignGeneral): Boolean; overload; override;
    /// Функция рисует границы области
    //  Borders - число, установленные биты которого указываю стороны ячейки
    function RangeBorders(const aRange: string; const Borders: Byte; const LineStyle: Integer = xlContinuous;
                          const LineWeight: Integer = xlThin): Boolean; override;
    /// Функция переводит название региона в его координаты (Top, Left, Rows, Cols);
    function Range2Rect(const aRange: string; out Rect: TRect): Boolean; override;
  end;

implementation

{ TDBDExcelWriterFPC }

function TDBDExcelWriterFPC.CellBorders(const aRow, aCol: Word; const Borders: Byte; const LineStyle: Integer;
  const LineWeight: Integer): boolean;
begin

end;

class function TDBDExcelWriterFPC.DbdToFpcVertAlignment(const VAlignment: TDbdVertAlignment): TsVertAlignment;
begin
  case Valignment of
    dbdvaDefault: Result:=TsVertAlignment.vaDefault;
    dbdvaTop:     Result:=TsVertAlignment.vaTop;
    dbdvaBottom:  Result:=TsVertAlignment.vaBottom;
    dbdvaCenter:  Result:=TsVertAlignment.vaCenter;
  end;
end;

function TDBDExcelWriterFPC.InsertRow(const aRow: Word; const DoCopy: Boolean): Boolean;
begin
  Result := True;
  WS.InsertRow(aRow);
  if DoCopy then begin
    //TODO: реализовать копирование
  end;
end;

function TDBDExcelWriterFPC.MergeCells(const aRange: TRect): Boolean;
begin
  Result:=(aRange.Top>=0) and (aRange.Left>=0) and (aRange.Height>=0) and (aRange.Width>=0); if not Result Then Exit;
  try
    WS.MergeCells(aRange.Top, aRange.Left, aRange.Top+aRange.Height, aRange.Left+aRange.Width);
  except
    Result:=False;
  end;
end;

function TDBDExcelWriterFPC.RangeAlign(const aRow, aCol: Word; const VAligment, HAligment: Integer): Boolean;
begin
//  WS.WriteVertAlignment(aRow,aCol, )
end;

function TDBDExcelWriterFPC.RangeAlign(const aRow, aCol: Word; const VAlignment: TDBDVertAlignment;
                                       const HAligment: TDBDHorAlignment): Boolean;
begin
  WS.WriteVertAlignment(aRow,aCol, DbdToFpcVertAlignment(VAlignment));
end;

function TDBDExcelWriterFPC.RangeAlign(const aRange: TRect; const VAligment: Integer; const HAligment: Integer): Boolean;
begin

end;

function TDBDExcelWriterFPC.WriteBoolean(const aCell: string; const B: Boolean): Boolean;
var R,C: Cardinal; f: TsRelFlags;
begin
  Result := ParseCellString(aCell, R, C, f);
  if Result then WS.WriteBoolValue(R,C,B);
end;

function TDBDExcelWriterFPC.WriteBoolean(const aRow, aCol: Word; const B: Boolean): Boolean;
begin
  Result := WS.WriteBoolValue(aRow,aCol,B)<>nil;
end;

function TDBDExcelWriterFPC.WriteCurrency(const aCell: string; const C: Currency): Boolean;
var Rw,Cl: Cardinal; f: TsRelFlags;
begin
  Result := ParseCellString(aCell, Rw, Cl, f);
  if Result then Result := WriteCurrency(Rw,Cl,C);
end;

function TDBDExcelWriterFPC.WriteCurrency(const aRow, aCol: Word; const C: Currency): Boolean;
var D: Double;
begin
  D:=C;
  Result := (WS.WriteCurrency(ARow, ACol, D)<>nil);
end;

function TDBDExcelWriterFPC.WriteDateTime(const aCell: string; const D: TDateTime): Boolean;
var Rw,Cl: Cardinal; f: TsRelFlags;
begin
  Result := ParseCellString(aCell, Rw, Cl, f);
  if Result then WS.WriteDateTime(Rw,Cl, D);
end;

function TDBDExcelWriterFPC.WriteDateTime(const aRow, aCol: Word; const D: TDateTime): Boolean;
begin
  Result := (WS.WriteDateTime(ARow, ACol, D)<>nil);
end;

function TDBDExcelWriterFPC.WriteDouble(const aCell: string; const D: Double): Boolean;
var Rw,Cl: Cardinal; f: TsRelFlags;
begin
  Result := ParseCellString(aCell, Rw, Cl, f);
  if Result then WS.WriteNumber(Rw,Cl, D);
end;

function TDBDExcelWriterFPC.WriteDouble(const aRow, aCol: Word; const D: Double): Boolean;
begin
  Result := (WS.WriteNumber(aRow,aCol, D)<>nil);
end;

function TDBDExcelWriterFPC.WriteInteger(const aCell: string; const I: Integer): Boolean;
var Rw,Cl: Cardinal; f: TsRelFlags;
begin
  Result := ParseCellString(aCell, Rw, Cl, f);
  if Result then WS.WriteCellValueAsString(Rw,Cl, IntToStr(i));
end;

function TDBDExcelWriterFPC.WriteInteger(const aRow, aCol: Word; const I: Integer): Boolean;
begin
  Result := (WS.WriteCellValueAsString(aRow,aCol, IntToStr(i))<>nil);
end;

function TDBDExcelWriterFPC.WriteInt64(const aCell: string; const I: Int64): Boolean;
var Rw,Cl: Cardinal; f: TsRelFlags;
begin
  Result := ParseCellString(aCell, Rw, Cl, f);
  if Result then WS.WriteCellValueAsString(Rw,Cl, IntToStr(i));
end;

function TDBDExcelWriterFPC.WriteInt64(const aRow, aCol: Word; const I: Int64): Boolean;
begin
  Result := (WS.WriteCellValueAsString(aRow,aCol, IntToStr(i))<>nil);
end;

function TDBDExcelWriterFPC.WriteString(const aCell: string; const S: String): Boolean;
var Rw,Cl: Cardinal; f: TsRelFlags;
begin
  Result := ParseCellString(aCell, Rw, Cl, f);
  if Result then WS.WriteText(Rw, Cl, S);
end;

function TDBDExcelWriterFPC.WriteString(const aRow, aCol: Word; const S: String): Boolean;
begin
  Result := (WS.WriteText(aRow, aCol, S)<>nil);
end;

function TDBDExcelWriterFPC.WriteVariant(const aCell: string; const V: Variant): Boolean;
var Rw,Cl: Cardinal; f: TsRelFlags;
begin
  Result := ParseCellString(aCell, Rw, Cl, f);
  if Result then Result := WriteVariant(Rw, Cl, V);
end;

function TDBDExcelWriterFPC.WriteVariant(const aRow, aCol: Word; const V: Variant): Boolean;
var r: RawByteString; s: string;
begin
  VariantToRawByteString(V,r);
  s:=r;
  Result := (WS.WriteCellValueAsString(aRow,aCol,s)<>nil);
end;

constructor TDBDExcelWriterFPC.Create(Owner: IDBDExcelV2; var Worksheet: TsWorkSheet);
begin
  inherited Create(Owner);
  WS:=Worksheet;
  FWSName:=WS.Name;
end;

destructor TDBDExcelWriterFPC.Destroy;
begin
  inherited Destroy;
end;

{ TDBDExcelReaderFPC }

function TDBDExcelReaderFPC.AsBoolean(const aRow, aCol: Word; out B: Boolean): Boolean;
var p: PCell;
begin
  try
    p := WS.GetCell(aRow-1,ARow-1);
    if p<>nil then begin B:=p^.BoolValue; Result:=True; end
              else Result:=False;
  except
    Result:=False;
  end;
end;

function TDBDExcelReaderFPC.AsCurrency(const aRow, aCol: Word; out C: Currency): Boolean;
begin
  try
    C:=AsDouble(aRow,aCol);
    Result:=True;
  except
    Result:=False;
  end;
end;

function TDBDExcelReaderFPC.AsDateTime(const aRow, aCol: Word; out D: TDateTime): Boolean;
begin
  try
    Result:=WS.ReadAsDateTime(aRow-1,ACol-1, D);
  except
    Result:=False;
  end;
end;

function TDBDExcelReaderFPC.AsDouble(const aRow, aCol: Word; out D: Double): Boolean;
var s: string;
begin
  if AsString(aRow,aCol,S) and (s<>'') then D:=xlStringToFloat(s);
Exit;
  try
    D:=WS.ReadAsNumber(aRow-1,ACol-1);
    Result:=True;
  except
    on E: Exception do begin
      Result:=False;
    end;
  end;
end;

function TDBDExcelReaderFPC.AsExtended(const aRow, aCol: Word; out D: Extended): Boolean;
begin
  try
    D:=WS.ReadAsNumber(aRow-1,ACol-1);
    Result:=True;
  except
    Result:=False;
  end;
end;

function TDBDExcelReaderFPC.AsInteger(const aRow, aCol: Word; out I: Integer): Boolean;
var p: PCell; d:Double;
begin
  try
    D:=WS.ReadAsNumber(aRow-1,ACol-1);
    I:=Round(d);
    Result:=True;
  except
    Result:=False;
  end;
end;

function TDBDExcelReaderFPC.AsInt64(const aRow, aCol: Word; out I: Int64): Boolean;
var d: Double;
begin
  try
    D:=WS.ReadAsNumber(aRow-1,ACol-1);
    I:=Round(d);
    Result:=True;
  except
    Result:=False;
  end;
end;

function TDBDExcelReaderFPC.AsString(const aRow, aCol: Word; out S: String): Boolean;
begin
  try
    S:=WS.ReadAsText(aRow-1,aCol-1);
    Result:=True;
  except
    Result:=False;
  end;
end;

function TDBDExcelReaderFPC.AsVariant(const aRow, aCol: Word; out V: Variant): Boolean;
var p: PCell;
begin
  p := WS.GetCell(aRow-1,ACol-1);
  if p<>nil then
    try
      V:=p^.UTF8StringValue;
      Result:=True;
    except
      Result:=False;
    end;
end;

constructor TDBDExcelReaderFPC.Create(Owner: IDBDExcelV2; Worksheet: TsWorkSheet);
begin
  inherited Create(Owner);
  WS:=Worksheet;
  FWSName:=WS.Name;
end;

destructor TDBDExcelReaderFPC.Destroy;
begin
  inherited Destroy;
end;

{ TDBDExcelFPC }

procedure TDBDExcelFPC.GetUsedRange;
begin
  FLastRow:=WS.GetLastRowIndex;
  FLastCol:=WS.GetLastColIndex;
  if FLastCol <=1 then
    FLastCol:=WS.Cells.GetLastCell.Col;
end;

function TDBDExcelFPC.GetReader: IDBDExcelReaderV2;
begin
  if (not Assigned(rdr)) or (rdr.WSName<>WS.Name) then begin
    rdr := nil;
    rdr := TDBDExcelReaderFPC.Create(Self, WS);
  end;
  Result := inherited GetReader;
end;

function TDBDExcelFPC.GetWriter: IDBDExcelWriterV2;
begin
  if (not Assigned(wrt)) or (wrt.WSName<>WS.Name) then begin
    wrt := nil;
    wrt := TDBDExcelWriterFPC.Create(Self, WS);
  end;
  Result := inherited GetWriter;
end;

procedure TDBDExcelFPC.OnChangeWS(Sender: TObject; ASheet: TsWorkSheet);
begin
  IsChanged:=True;
end;

constructor TDBDExcelFPC.Create(FileName: TFileName; const WBOptions: TDBDOpenWBOprions; const aNotifier: IDBDNotifierV1);
begin
  inherited Create(WBOptions, aNotifier);
  ReadyWB:=false;
  WB:=TsWorkBook.Create;
end;

destructor TDBDExcelFPC.Destroy;
begin
  Close;
  inherited Destroy;
end;

function TDBDExcelFPC.AddWorkSheet(const aName: string; const Index: Word): Integer;
begin
  try
    WS:=WB.AddWorksheet(aName);
    Result := WS.Index+1;
    FCountWS:=Result;
  except
    on E: Exception do begin
      Result :=0; Log(dmkErrorInfo, E.HelpContext, String('Исключение при добавлении листа. ') + E.Message);
    end;
  end;
end;

function TDBDExcelFPC.CheckEnumRow(const LastRow: Integer; const LeftCol: Integer; const RightCol: Integer;
                                   const SkipEmpty: Boolean): TDBDTable;
  function ColNumber(const R,C: Integer): Integer;
  var s: string; n: Integer;
  begin
    s := rdr.AsString(R,C);
    if (s='') then Result:=0
    else if TryStrToInt(s,n) then Result:=n
    else Result:=-1;
  end;
var lCol,rCol,lRow,i,j,n, nCol, Row: Integer;
begin
  Result.Clear; Row:=-1;
  GetUsedRange;
  if LastRow>0 then lRow:=LastRow else lRow:=FLastRow-1;
  if LeftCol>0 then lCol:=LeftCol else lCol:=1;
  if RightCol>lCol then rCol:=RightCol else rCol:=FLastCol;
  if (rCol>0) and (rCol<lCol) then begin Result.Row:=-2; Exit; end;
  if rCol=0 then rCol:=200;
  GetReader;
  for i := 1 to lRow do begin
    nCol:= ColNumber(i,lCol);
    if nCol=1 then begin
      Result.AddColumn(TDBDColumn.Create(nCol,lCol)); Inc(nCol);
      Row:=i;
      for j := lCol+1 to rCol do begin
        n:=ColNumber(i,j);
        if n<0 then begin Row:=-1; Result.Clear; Break; end
        else if n=nCol then begin
          Result.AddColumn(TDBDColumn.Create(nCol,j)); Inc(nCol);
        end;
      end;
    end;
    if Row>0 then Break;
  end;
  Result.Row:=Row;
end;

procedure TDBDExcelFPC.Close;
begin
  ReadyWB:=False;
  IsChanged := IsChanged and (not (owbReadOnly in FOptions));
  if IsChanged then WB.WriteToFile(WB.Filename, true);
  if Assigned(WB) then FreeAndNil(WB);
  rdr:=nil; wrt:=nil;
end;

function TDBDExcelFPC.CopyRange(const Src, Dst: string): Boolean;
begin
  Result:=False;
end;

function TDBDExcelFPC.CopyRange(const Src: string; const SrcRng: TRect; const Dst: string; const DstCell: TPoint): Boolean;
begin
  Result:=False;
end;

function TDBDExcelFPC.CopyRange(const Src, SrcRng, Dst: string; const Row, Col: Word): Boolean;
begin
  Result:=False;
end;

function TDBDExcelFPC.CopyWorkSheet(const Src, Dst: string): Boolean;
begin
  Result:=False;
end;

function TDBDExcelFPC.CopyWorkSheet(SrcIdx: Word; const Dst: string): Boolean;
begin
  Result:=False;
end;

function TDBDExcelFPC.GetOpenedWorksheetNames: string;
begin
  Result:='';
end;

function TDBDExcelFPC.GetOpenedWorkbookNames: string;
begin
  Result:='';
end;

function TDBDExcelFPC.GetWorkSheetIdx(const aWorkSheetName: string): Integer;
begin
  Result:=-1;
end;

function TDBDExcelFPC.InsertRow(const aRow: Word; const DoCopy: Boolean): Boolean;
begin
  Result:=False;
end;

function TDBDExcelFPC.NextWorkSheet: Boolean;
begin
  WS:=WB.GetNextWorksheet(WS);
  Result:=WS<>nil;
end;

function TDBDExcelFPC.OpenWorkBook(const aFileName: TFilename; const WBOptions: TDBDOpenWBOprions): Integer;
begin
  if ReadyWB then Close;
  if aFileName='' then begin
    Result:=-1;
    Log(dmkErrorInfo, -1, rsEInvaidFileName);
  end else if not FileExists(aFileName) then begin
    result:=-2;
    Log(dmkErrorInfo, -2, String('Файл "') + aFileName + String('" не найден'));
  end else begin
    FOptions := WBOptions;
    WB:=TsWorkBook.Create;
    try
      WB.ReadFromFile(aFileName);
      Result:=0;
      FCountWS:=WB.GetWorksheetCount;
      ReadyWB:=FCountWS>0;
      if ReadyWB then begin
        Result:=0;
        FCurrIdx:=0;
        OpenWorkSheet(1);
      end;
    except
      Result:=-3;
      Log(dmkErrorInfo, -3, String('Исключение при открытии файла "') + aFileName + String('"'));
    end;
  end;
end;

function TDBDExcelFPC.OpenWorkSheet(const aIndex: Integer): string;
begin
  Result := '';
  if not ReadyWB then begin
    Log(dmkErrorInfo, -1, rsEInvalidBookNotOpen);
  end else if aIndex<=0 then begin
    Log(dmkErrorInfo, -1, 'Индекс не может быть меньше 1)');
  end else if WB.GetWorksheetCount<aIndex then begin
    Log(dmkErrorInfo, -1, 'Индекс не может быть больше количества листов');
  end else if aIndex <> FCurrIdx then
    try
      WS:=WB.GetWorkSheetByIndex(aIndex-1);
      if WS=nil then begin
        Log(dmkErrorInfo, -1, 'Не удалось открыть лист');
      end else begin
      Result:=WS.Name;
      GetUsedRange;
      FCurrIdx := aIndex;
      FNameWS:=WS.Name;
      end;
    except
      on E: Exception do begin
        Result :='';
        Log(dmkErrorInfo, -2, rsInvalidWorkSheetName);
      end;
    end
  else Result := WS.Name;
end;

function TDBDExcelFPC.OpenWorkSheet(const aWorkSheetName: string): Integer;
begin
  if not ReadyWB then begin
    Result := -1;
    Log(dmkErrorInfo, -1, rsEInvalidBookNotOpen);
  end else if aWorkSheetName='' then begin
    Result := -2;
    Log(dmkErrorInfo, -2, rsInvalidWorkSheetName);
  end else begin
    WS:=WB.GetWorkSheetByName(aWorkSheetName);
    FCurrIdx:=WS.Index+1;
    GetUsedRange;
    Result:=FCurrIdx;
  end;
end;

function TDBDExcelFPC.RangeAlign(const aRow, aCol: Word; const VAligment: Integer; const HAligment: Integer): Boolean;
begin
  Result:=False;
end;

function TDBDExcelFPC.RangeAlign(const aRange: TRect; const VAligment: Integer; const HAligment: Integer): Boolean;
begin
  Result:=False;
end;

function TDBDExcelFPC.RangeBorders(const aRange: string; const Borders: Byte; const LineStyle: Integer;
  const LineWeight: Integer): Boolean;
begin
  Result:=False;
end;

function TDBDExcelFPC.Range2Rect(const aRange: string; out Rect: TRect): Boolean;
begin
  Result:=False;
end;

end.