Result := AnsiCompareStr(FDateTimeFormat, DefaultDateTimeFormat) <> 0;
end;

function TQExportFormats.IsCurrencyFormatStored: boolean;
begin
  Result := AnsiCompareStr(FCurrencyFormat, DefaultCurrencyFormat) <> 0;
end;

function TQExportFormats.IsBooleanTrueStored: boolean;
begin
  Result := AnsiCompareStr(FBooleanTrue, S_BOOLEAN_TRUE) <> 0;
end;

function TQExportFormats.IsBooleanFalseStored: boolean;
begin
  Result := AnsiCompareStr(FBooleanFalse, S_BOOLEAN_FALSE) <> 0;
end;

{ TQExportColumn }

constructor TQExportColumn.Create(Collection: TCollection);
begin
  inherited;
  FTag := 0;
  if Collection is TQExportColumns then
    FColumns := Collection as TQExportColumns;
end;

function TQExportColumn.GetIsDefaultFormat: boolean;
begin
  Result := false;
  if FAllowFormat then
    case FColType of
      ectInteger, ectBigint: Result := FFormat = FColumns.FOwnerFormats.IntegerFormat;
      ectFloat: Result := FFormat = FColumns.FOwnerFormats.FloatFormat;
      ectDate: Result := FFormat = FColumns.FOwnerFormats.DateFormat;
      ectTime: Result := FFormat = FColumns.FOwnerFormats.TimeFormat;
      ectDateTime: Result := FFormat = FColumns.FOwnerFormats.DateTimeFormat;
      ectCurrency: Result := FFormat = FColumns.FOwnerFormats.CurrencyFormat;
    end;
end;

function TQExportColumn.GetDefaultFormat: string;
begin
  Result := EmptyStr;
  if FAllowFormat then
    case FColType of
      ectInteger, ectBigint: Result := FColumns.FOwnerFormats.IntegerFormat;
      ectFloat: Result := FColumns.FOwnerFormats.FloatFormat;
      ectDate: Result := FColumns.FOwnerFormats.DateFormat;
      ectTime: Result := FColumns.FOwnerFormats.TimeFormat;
      ectDateTime: Result := FColumns.FOwnerFormats.DateTimeFormat;
      ectCurrency: Result := FColumns.FOwnerFormats.CurrencyFormat;
    end;
end;

procedure TQExportColumn.SetDefaultFormat;
begin
  FFormat := GetDefaultFormat;
end;

{ TQExportColumns }

constructor TQExportColumns.Create(Holder: TPersistent; NormalFunc: TNormalFunc);
begin
  inherited Create(TQExportColumn);
  FHolder := Holder;
  FNormalFunc := NormalFunc;
end;

function TQExportColumns.Add: TQExportColumn;
begin
  Result := TQExportColumn(inherited Add);
end;

function TQExportColumns.GetColumn(Index: integer): TQExportColumn;
begin
  Result := TQExportColumn(inherited Items[Index]);
end;

procedure TQExportColumns.SetColumn(Index: integer; Value: TQExportColumn);
begin
  Items[Index].Assign(Value);
end;

procedure TQExportColumns.LoadOwnerProperties;
var
  PropInfo: PPropInfo;
begin
  PropInfo := GetPropInfo(FHolder.ClassInfo, 'ExportedFields');
  if Assigned(PropInfo) then
    FOwnerExportedFields := TStrings(GetOrdProp(FHolder, PropInfo));

  PropInfo := GetPropInfo(FHolder.ClassInfo, 'ExportSource');
  if Assigned(PropInfo) then
    FOwnerExportSource := TQExportSource(GetOrdProp(FHolder, PropInfo));

  PropInfo := GetPropInfo(FHolder.ClassInfo, 'DataSet');
  if Assigned(PropInfo) then
    FOwnerDataSet := TDataSet(GetOrdProp(FHolder, PropInfo));

  PropInfo := GetPropInfo(FHolder.ClassInfo, 'CustomSource');
  if Assigned(PropInfo) then
    FOwnerCustomSource := TqeCustomSource(GetOrdProp(FHolder, PropInfo));

  {$IFNDEF NOGUI}
  PropInfo := GetPropInfo(FHolder.ClassInfo, 'ListView');
  if Assigned(PropInfo) then
    FOwnerListView := TListView(GetOrdProp(FHolder, PropInfo));

  PropInfo := GetPropInfo(FHolder.ClassInfo, 'DBGrid');
  if Assigned(PropInfo) then
    FOwnerDBGrid := TDBGrid(GetOrdProp(FHolder, PropInfo));

  PropInfo := GetPropInfo(FHolder.ClassInfo, 'StringGrid');
  if Assigned(PropInfo) then
    FOwnerStringGrid := TStringGrid(GetOrdProp(FHolder, PropInfo));
  {$ENDIF}

  PropInfo := GetPropInfo(FHolder.ClassInfo, 'OnlyVisibleFields');
  if Assigned(PropInfo) then
    FOwnerOnlyVisibleFields := Boolean(GetOrdProp(FHolder, PropInfo));

  PropInfo := GetPropInfo(FHolder.ClassInfo, 'Formats');
  if Assigned(PropInfo) then
    FOwnerFormats := TQExportFormats(GetOrdProp(FHolder, PropInfo));

  PropInfo := GetPropInfo(FHolder.ClassInfo, 'AutoCalcStrType');
  if Assigned(PropInfo) then
    FOwnerAutoCalcStrType := Boolean(GetOrdProp(FHolder, PropInfo));

  PropInfo := GetPropInfo(FHolder.ClassInfo, 'CaptionRow');
  if Assigned(PropInfo) then
    FOwnerCaptionRow := Integer(GetOrdProp(FHolder, PropInfo))
  else FOwnerCaptionRow := -1;

  PropInfo := GetPropInfo(FHolder.ClassInfo, 'UserFormats');
  if Assigned(PropInfo) then
    FOwnerUserFormats := TStrings(GetOrdProp(FHolder, PropInfo));

  PropInfo := GetPropInfo(FHolder.ClassInfo, 'ColumnsWidth');
  if Assigned(PropInfo) then
    FOwnerColumnsWidth := TStrings(GetOrdProp(FHolder, PropInfo));

  PropInfo := GetPropInfo(FHolder.ClassInfo, 'Captions');
  if Assigned(PropInfo) then
    FOwnerCaptions := TStrings(GetOrdProp(FHolder, PropInfo));

  PropInfo := GetPropInfo(FHolder.ClassInfo, 'ColumnsAlign');
  if Assigned(PropInfo) then
    FOwnerColumnsAlign := TStrings(GetOrdProp(FHolder, PropInfo));

  PropInfo := GetPropInfo(FHolder.ClassInfo, 'SkipRecCount');
  if Assigned(PropInfo) then
    FOwnerSkipRecCount := Integer(GetOrdProp(FHolder, PropInfo));

  PropInfo := GetPropInfo(FHolder.ClassInfo, 'ExportRecCount');
  if Assigned(PropInfo) then
    FOwnerExportRecCount := Integer(GetOrdProp(FHolder, PropInfo));

  PropInfo := GetPropInfo(FHolder.ClassInfo, 'ColumnsLength');
  if Assigned(PropInfo) then
    FOwnerColumnsLength := TStrings(GetOrdProp(FHolder, PropInfo));

  PropInfo := GetPropInfo(FHolder.ClassInfo, 'OnFetchedRecord');
  if Assigned(PropInfo) then
    FOwnerOnFetchedRecord := TExportedRecordEvent(GetMethodProp(FHolder, PropInfo));
end;

procedure TQExportColumns.Fill(BLOB: boolean);
var
  i, j: integer;
  FColCount: integer;
  FColumn: TQExportColumn;
begin
  LoadOwnerProperties;
  FColCount := 0;
  if FOwnerExportedFields.Count = 0 then begin
    case FOwnerExportSource of
      esDataSet:
        if Assigned(FOwnerDataSet) then
          FColCount := FOwnerDataSet.FieldCount;
      esCustom:
        if Assigned(FOwnerCustomSource) then
          FColCount := FOwnerCustomSource.ColCount;
      {$IFNDEF NOGUI}
      esListView:
        if Assigned(FOwnerListView) then
          FColCount := FOwnerListView.Columns.Count;
      esDBGrid:
        if Assigned(FOwnerDBGrid) then
          FColCount := FOwnerDBGrid.Columns.Count;
      esStringGrid:
        if Assigned(FOwnerStringGrid) then
          FColCount := FOwnerStringGrid.ColCount;
      {$ENDIF}
    end
  end
  else FColCount := FOwnerExportedFields.Count;
  for i := 0 to FColCount - 1 do  begin
    j := SetColumnNumber(i, BLOB);
    if  j = -1 then Continue;
    FColumn := Add;
    FColumn.Number := j;
  end;
  for i := 0 to Count - 1 do begin
    SetColumnName(i);
    SetColumnType(i);
    SetColumnCaption(i);
    SetColumnWidth(i);
    SetColumnFormat(i);
    SetColumnAlign(i);
    SetColumnSQLType(i);
    SetColumnIsString(i);
    SetColumnLength(i);
    SetColumnSize(i);
    SetColumnAllowFormat(i);
    SetColumnIsNumeric(i);
    SetColumnIsBlob(i);
    SetColumnIsMemo(i);
    SetColumnIsVisible(i);
  end;
end;

function TQExportColumns.SetColumnNumber(Index: integer; BLOB: boolean): integer;
var
  Field: TField;
  Column: TqeCustomColumn;
  {$IFNDEF NOGUI}j: integer;{$ENDIF}
begin
  Result := -1;
  if FOwnerExportedFields.Count = 0 then begin
    case FOwnerExportSource of
      esDataSet: begin
        Field := FOwnerDataSet.Fields[Index];
        if Assigned(Field) and
           (((BLOB) or (not Field.IsBlob)) and
            ((not FOwnerOnlyVisibleFields) or Field.Visible)) then
          Result := Index;
      end;
      {$IFNDEF NOGUI}
      esDBGrid: begin
        Field := FOwnerDBGrid.Columns[Index].Field;
        if Assigned(Field)  and
           (((BLOB) or (not Field.IsBlob)) and
            ((not FOwnerOnlyVisibleFields) or Field.Visible)) then
          Result := Index
      end;
      else Result := Index;
      {$ENDIF}
    end;
    Exit;
  end;

  case FOwnerExportSource of
    esDataSet: begin
      Field := FOwnerDataSet.FieldByName(FOwnerExportedFields[Index]);
      if Assigned(Field) and
         ((not FOwnerOnlyVisibleFields) or Field.Visible) then
        Result := Field.Index;
    end;
    esCustom: begin
      Column := FOwnerCustomSource.ColumnByName(FOwnerExportedFields[Index]);
      if Assigned(Column) then
        Result := Column.Index;
    end;
    {$IFNDEF NOGUI}
    esDBGrid:
      for j := 0 to FOwnerDBGrid.Columns.Count - 1 do begin
        Field := FOwnerDBGrid.Columns[j].Field;
        if Assigned(Field) and
           ((AnsiCompareText(Field.FieldName, FOwnerExportedFields[Index]) = 0) and
            (not FOwnerOnlyVisibleFields or Field.Visible)) then
          Result := j;
      end;
    esListView:
      for j := 0 to FOwnerListView.Columns.Count - 1 do begin
        if AnsiCompareText(FOwnerListView.Columns[j].Caption,
                           FOwnerExportedFields[Index]) = 0 then
          Result := j;
      end;
    esStringGrid: begin
      Result := StrToIntDef(FOwnerExportedFields[Index], -1);
      if not ((Result >= 0) and (Result <= FOwnerStringGrid.ColCount)) then
        Result := -1;
    end;
    {$ENDIF}
  end;
end;

procedure TQExportColumns.SetColumnName(Index: integer);
begin
  // Items[Index].Number must be defined
  with Items[Index] do
    case FOwnerExportSource of
      esDataSet: Name := FOwnerDataSet.Fields[Number].FieldName;
      esCustom: Name := FOwnerCustomSource.Columns[Number].ColumnName;
      {$IFNDEF NOGUI}
      esDBGrid: Name := FOwnerDBGrid.Columns[Number].Field.FieldName;
      esListView: Name := FOwnerListView.Columns[Number].Caption;
      esStringGrid: Name := IntToStr(Number);
      {$ENDIF}
    end;
end;

procedure TQExportColumns.SetColumnType(Index: integer);
begin
  // Items[Index].Number must be defined
  with Items[Index] do
    case FOwnerExportSource of
      esDataSet: ColType := DataType2QExportColType(FOwnerDataSet.Fields[Number]);
      esCustom: ColType := FOwnerCustomSource.Columns[Number].ColumnType;
      {$IFNDEF NOGUI}
      esDBGrid: ColType := DataType2QExportColType(FOwnerDBGrid.Columns[Number].Field);
      esListView:
        if not FOwnerAutoCalcStrType
          then ColType := ectString
          else if FOwnerListView.Items.Count > 0 then begin
            if Number = 0
              then ColType := CalcStringType(FOwnerListView.Items[0].Caption,
                FOwnerFormats.BooleanTrue, FOwnerFormats.BooleanFalse)
              else ColType := CalcStringType(FOwnerListView.Items[0].SubItems[Number - 1],
                FOwnerFormats.BooleanTrue, FOwnerFormats.BooleanFalse);
          end;
      esStringGrid:
        if not FOwnerAutoCalcStrType
          then ColType := ectString
          else ColType := CalcStringType(FOwnerStringGrid.Cells[Number,
            FOwnerStringGrid.Row], FOwnerFormats.BooleanTrue,
            FOwnerFormats.BooleanFalse);
      {$ENDIF}
    end;
end;

procedure TQExportColumns.SetColumnFormat(Index: integer);
var
  i: integer;
begin
  // Items[Index].ColType must be defined
  if Assigned(FOwnerFormats) then
    with FOwnerFormats, Items[Index] do
      case ColType of
        ectInteger, ectBigint: Format := IntegerFormat;
        ectFloat: Format := FloatFormat;
        ectDate: Format := DateFormat;
        ectTime: Format := TimeFormat;
        ectDateTime: Format := DateTimeFormat;
        ectCurrency: Format := CurrencyFormat;
      end;

  if Assigned(FOwnerUserFormats) then
    with FOwnerUserFormats, Items[Index] do begin
      i := IndexOfName(Name);
      if i > -1 then Format := Values[Names[i]];
    end;
end;

procedure TQExportColumns.SetColumnWidth(Index: integer);
var
  i: integer;
begin
  if Assigned(FOwnerColumnsWidth) then
    with FOwnerColumnsWidth, Items[Index] do begin
      i := IndexOfName(Name);
      if i > -1 then begin
        Width := StrToIntDef(Values[Names[i]], 0);
        Exit;
      end;
    end;
  // Items[Index].Number must be defined
  with Items[Index] do
    case FOwnerExportSource of
      esDataSet: Width := FOwnerDataSet.Fields[Number].DisplayWidth;
      esCustom: Width := FOwnerCustomSource.Columns[Number].Width;
      {$IFNDEF NOGUI}
      esDBGrid: Width := FOwnerDBGrid.Columns[Number].Width div
        FOwnerDBGrid.Canvas.TextWidth('X');
      esListView: begin
        Width := FOwnerListView.Columns[Number].Width div
          GetTextWidth(FOwnerListView, 'X');
      end;
      esStringGrid: Width := FOwnerStringGrid.ColWidths[Number] div
        FOwnerStringGrid.Canvas.TextWidth('X');
      {$ENDIF}
    end;
end;

procedure TQExportColumns.SetColumnCaption(Index: integer);
var
  i: integer;
begin
  if Assigned(FOwnerCaptions) then
    with FOwnerCaptions, Items[Index] do begin
      i := IndexOfName(Name);
      if i > -1 then begin
        Caption := Values[Names[i]];
        Exit;
      end;
    end;
  // Items[Index].Number must be defined
  with Items[Index] do
    case FOwnerExportSource of
      esDataSet: Caption := FOwnerDataSet.Fields[Number].DisplayLabel;
      esCustom: Caption := FOwnerCustomSource.Columns[Number].Caption;
      {$IFNDEF NOGUI}
      esDBGrid: Caption := FOwnerDBGrid.Columns[Number].Title.Caption;
      esListView: Caption := FOwnerListView.Columns[Number].Caption;
      esStringGrid:
        if FOwnerCaptionRow > -1
          then Caption := FOwnerStringGrid.Cells[Number, FOwnerCaptionRow]
          else Caption := 'ColNo_' + IntToStr(Number);
      {$ENDIF}
    end;
end;

procedure TQExportColumns.SetColumnAlign(Index: integer);
var
  i: integer;
  s: String;
begin
  // Items[Index].ColType must be defined
  if Assigned(FOwnerColumnsAlign) then
    with FOwnerColumnsAlign, Items[Index] do begin
      i := IndexOfName(Name);
      if i > -1 then begin
        s := AnsiUpperCase(Values[Names[i]]);
        if s <> '' then
          case s[1] of