qexport3.pas

DELPHI开发VCL

  i, w: integer;
  Bookmark: TBookmark;
  Str: string;
begin
  for i := 0 to Count - 1 do
    if Length(Items[i].Caption) > Items[i].Width
      then Items[i].Width := Length(Items[i].Caption);

  Bookmark := QExportGetBookmark(FOwnerExportSource, FOwnerDataSet,
    FOwnerCustomSource{$IFNDEF NOGUI}, FOwnerDBGrid, FOwnerListView,
    FOwnerStringGrid{$ENDIF});
  try
    QExportFirst(FOwnerExportSource, FOwnerDataSet, FOwnerCustomSource
      {$IFNDEF NOGUI}, FOwnerDBGrid, FOwnerListView, FOwnerStringGrid{$ENDIF});
    for i := 0 to FOwnerSkipRecCount - 1 do
      QExportNext(FOwnerExportSource, FOwnerDataSet, FOwnerCustomSource,
        {$IFNDEF NOGUI}FOwnerDBGrid, FOwnerListView, FOwnerStringGrid,{$ENDIF} FRecordCounter);

    FRecordCounter := 0;
    while not QExportEOF(FOwnerExportSource, FOwnerDataSet, FOwnerCustomSource,
      {$IFNDEF NOGUI}FOwnerDBGrid, FOwnerListView, FOwnerStringGrid,{$ENDIF}
      FRecordCounter, FOwnerExportRecCount, FOwnerSkipRecCount) and
      ((FOwnerExportRecCount = 0) or
       (FRecordCounter < FOwnerExportRecCount)) do
    begin
      //if Aborted and not CanContinue then Break;
      for i := 0 to Count - 1 do
      begin
        Str := QExportGetColData(FOwnerExportSource, FOwnerDataSet,
          FOwnerCustomSource, {$IFNDEF NOGUI}FOwnerDBGrid, FOwnerListView,
          FOwnerStringGrid,{$ENDIF} Self, FOwnerFormats, FNormalFunc, i,
          FRecordCounter, FOwnerSkipRecCount, true);
        w := Length(Str);
        if w > Items[i].Width then
          Items[i].Width := w;
      end;
      QExportNext(FOwnerExportSource, FOwnerDataSet, FOwnerCustomSource,
      {$IFNDEF NOGUI}FOwnerDBGrid, FOwnerListView, FOwnerStringGrid,{$ENDIF}
      FRecordCounter);
      if Assigned(FOwnerOnFetchedRecord) then
        FOwnerOnFetchedRecord(Holder, FRecordCounter);
{$IFDEF WIN32}
      Sleep(0);
{$ENDIF}
    end;
    QExportGoToBookmark(FOwnerExportSource, FOwnerDataSet, FOwnerCustomSource,
      {$IFNDEF NOGUI}FOwnerDBGrid, FOwnerListView, FOwnerStringGrid,{$ENDIF}
      Bookmark);
  finally
    QExportFreeBookmark(FOwnerExportSource, FOwnerDataSet,
      {$IFNDEF NOGUI}FOwnerDBGrid, FOwnerListView, FOwnerStringGrid, {$ENDIF}
      Bookmark);
  end;
end;

procedure TQExportColumns.SetColumnSQLType(Index: integer);
begin
  with Items[Index] do begin
    case FOwnerExportSource of
      esDataSet: SQLType := DataType2SQLType(FOwnerDataSet.Fields[Number]);
      esCustom: SQLType := QExportType2SQLType(Items[Index]);
      {$IFNDEF NOGUI}
      esDBGrid: SQLType := DataType2SQLType(FOwnerDBGrid.Columns[Number].Field);
      esListView,
      esStringGrid: QExportType2SQLType(Items[Index]);
      {$ENDIF}
    end;
  end;
end;

procedure TQExportColumns.SetColumnLength(Index: integer);
var
  i: integer;
begin
  if not Items[Index].IsString then Exit;
  if Assigned(FOwnerColumnsLength) then
    if FOwnerExportSource in [esListView, esStringGrid] then
      with FOwnerColumnsLength, Items[Index] do begin
        i := IndexOfName(Name);
        if i > -1 then begin
          Length := StrToIntDef(Values[Names[i]], 255);
          Exit;
        end;
      end;
  /// Items[Index].Number must be defined
  with Items[Index] do
    case FOwnerExportSource of
      esDataSet: Length := MinimumInt(FOwnerDataSet.Fields[Number].Size, 255);
      esCustom: Length := MinimumInt(FOwnerCustomSource.Columns[Number].Size, 255);
      {$IFNDEF NOGUI}
      esDBGrid: Length := MinimumInt(FOwnerDBGrid.Columns[Number].Field.Size, 255);
      esListView: Length := 255;
      esStringGrid: Length := 255;
      {$ENDIF}
    end;
end;

procedure TQExportColumns.SetColumnAllowFormat(Index: integer);
begin
  Items[Index].FAllowFormat := Items[Index].ColType in [ectInteger, ectBigint,
    ectFloat, ectDate, ectTime, ectDateTime, ectCurrency];
end;

procedure TQExportColumns.SetColumnIsNumeric(Index: integer);
begin
  Items[Index].FIsNumeric := Items[Index].ColType in [ectInteger, ectBigint,
    ectFloat, ectCurrency];
end;

procedure TQExportColumns.SetColumnIsString(Index: integer);
begin
  Items[Index].FIsString := Items[Index].ColType in [ectString];
end;

function TQExportColumns.GetColumnIsNull(Index: integer): boolean;
begin
  case FOwnerExportSource of
    esDataSet: Result := FOwnerDataSet.Fields[Items[Index].Number].IsNull;
    {$IFNDEF NOGUI}
    esDBGrid: Result := FOwnerDBGrid.Columns[Items[Index].Number].Field.IsNull;
    {$ENDIF}
    else Result := false;
  end;
end;

procedure TQExportColumns.SetColumnIsBlob(Index: integer);
begin
  case FOwnerExportSource of
    esDataSet: Items[Index].FIsBlob := FOwnerDataSet.Fields[Items[Index].Number].IsBlob;
    {$IFNDEF NOGUI}
    esDBGrid: Items[Index].FIsBlob := FOwnerDBGrid.Columns[Items[Index].Number].Field.IsBlob;
    {$ENDIF}
    else Items[Index].FIsBlob := false;
  end;
end;

procedure TQExportColumns.SetColumnIsMemo(Index: integer);
begin
  case FOwnerExportSource of
    esDataSet: Items[Index].FIsMemo := FOwnerDataSet.Fields[Items[Index].Number] is TMemoField;
    {$IFNDEF NOGUI}
    esDBGrid: Items[Index].FIsMemo := FOwnerDBGrid.Columns[Items[Index].Number].Field is TMemoField;
    {$ENDIF}
    else Items[Index].FIsMemo := false;
  end;
end;

procedure TQExportColumns.SetColumnIsVisible(Index: integer);
begin
  case FOwnerExportSource of
    esDataSet: Items[Index].FIsVisible := FOwnerDataSet.Fields[Items[Index].Number].Visible;
    {$IFNDEF NOGUI}
    esDBGrid: Items[Index].FIsVisible := FOwnerDBGrid.Columns[Items[Index].Number].Field.Visible;
    {$ENDIF}
    else Items[Index].FIsVisible := true;
  end;
end;

function TQExportColumns.IndexOfName(const AName: string): integer;
var
  i: integer;
begin
  Result := -1;
  for i := 0 to Count - 1 do
    if AnsiCompareText(AName, Items[i].Name) = 0 then begin
      Result := i;
      Exit;
    end;
end;

procedure TQExportColumns.EmptyTags;
var
  i: integer;
begin
  for i := 0 to Count - 1 do
    Items[i].Tag := 0;
end;

function TQExportColumns.ContainsBLOB: boolean;
var
  i: integer;
begin
  Result := false;
  for i := 0 to Count - 1 do
    if Items[i].IsBlob then begin
      Result := true;
      Exit;
    end;
end;

function TQExportColumns.ContainsMEMO: boolean;
var
  i: integer;
begin
  Result := false;
  for i := 0 to Count - 1 do
    if Items[i].IsMemo then begin
      Result := true;
      Exit;
    end;
end;

{ TQExportWriter }

constructor TQExportWriter.Create(AOwner: TQExport3; AStream: TStream);
begin
  inherited Create;
  FStream := AStream;
  FOwner := AOwner;
end;

procedure TQExportWriter.EmptyLine;
begin
  WriteLn(EmptyStr);
end;

procedure TQExportWriter.CharLine(Chr: char; Count: integer);
var
  i: integer;
  str: string;
begin
  str := EmptyStr;
  for i := 0 to Count - 1 do str := str + Chr;
  WriteLn(str);
end;

function TQExportWriter.PadL(const S: string; Chr: char; Count: integer): string;
var
  i, j: integer;
begin
  if Length(S) >= Count then
  begin
    Result := Copy(S, 1, Count);
    Exit;
  end;
  Result := S;
  j := Count - Length(S);
  for i := 1 to j do Result := Chr + Result;
end;

function TQExportWriter.PadR(const S: string; Chr: char; Count: integer): string;
var
  i: integer;
begin
  if Length(S) >= Count then
  begin
    Result := Copy(S, 1, Count);
    Exit;
  end;
  Result := S;
  for i := Length(S) + 1 to Count do Result := Result + Chr;
end;

function TQExportWriter.PadC(const S: string; Chr: char; Count: integer): string;
var
  l, r: integer;
begin
  if Length(S) >= Count then
  begin
    Result := Copy(S, 1, Count);
    Exit;
  end;
  Result := S;
  l := (Count - Length(Result)) div 2;
  r := Count - Length(Result) - l;
  Result := PadL(Result, Chr, Length(Result) + l);
  Result := PadR(Result, Chr, Length(Result) + r);
end;

procedure TQExportWriter.Write(const S: string);
begin
  FStream.WriteBuffer(S[1], Length(S));
end;

procedure TQExportWriter.WriteLn(const S: string);
begin
  Write(S + CRLF);
end;

function TQExportWriter.AlignToStr(Value: TQExportColAlign): string;
begin
  case Value of
    ecaLeft: Result := 'Left alignment';
    ecaCenter: Result := 'Center alignment';
    ecaRight: Result := 'Right alignment';
    else Result := 'Unknown alignment';
  end
end;

{ TQExportCol }

constructor TQExportCol.Create(Row: TQExportRow);
begin
  inherited Create;
  FColumnIndex := -1;
  FName := EmptyStr;
  FValue := EmptyStr;
  FRow := Row;
end;

function TQExportCol.GetExportedValue(ANeedFormat: boolean): string;
begin
  if Row.Columns.GetColumnIsNull(FColumnIndex) then
    FValue := Row.Columns.FNormalFunc(Row.Formats.NullString)
  else if ANeedFormat and FNeedFormat then
    FValue := QExportFormatData(FValue, Row.Columns[FColumnIndex].Format,
      Row.Columns[FColumnIndex].ColType, Row.Columns.FNormalFunc);

  Result := FValue;

  if Assigned(Row.GetColData) then
    Result := Row.GetColData(Self);
end;

{ TQExportRow }

constructor TQExportRow.Create(Columns: TQExportColumns;
  Formats: TQExportFormats; GetColdata: TQExportGetColData);
begin
  inherited Create;
  FIndex := TStringList.Create;
  FColumns := Columns;
  FFormats := Formats;
  FGetColData := GetColData;
end;

destructor TQExportRow.Destroy;
begin
  Clear;
  FIndex.Free;
  inherited;
end;

function TQExportRow.Add(const AName: string; AColumnIndex: integer): TQExportCol;
begin
  Result := TQExportCol.Create(Self);
  Result.FName := Trim(AName);
  Result.FColumnIndex := AColumnIndex;
  inherited Add(Result);
end;

procedure TQExportRow.Clear;
var
  i: integer;
begin
  for i := Count - 1 downto 0 do Delete(i);
  inherited;
end;

procedure TQExportRow.Delete(Index: integer);
begin
  TQExportCol(Items[Index]).Free;
  inherited Delete(Index);
end;

function TQExportRow.First: TQExportCol;
begin
  Result := TQExportCol(inherited First);
end;

procedure TQExportRow.Insert(Index: Integer; Item: TQExportCol);
begin
  inherited Insert(Index, Item);
end;

procedure TQExportRow.SetValue(const AName, AValue: string; ANeedFormat:
    Boolean = True);
var
  i: integer;
begin
  FIndex.Find(AName, i);
  if i > -1 then begin
    i := Integer(FIndex.Objects[i]);
    Items[i].Value := Trim(AValue);
    Items[i].NeedFormat := ANeedFormat;
  end;
end;

procedure TQExportRow.ClearValues;
var
  i: integer;
begin
  for i := 0 to Count - 1 do
    Items[i].Value := EmptyStr
end;

function TQExportRow.Last: TQExportCol;
begin
  Result := TQExportCol(inherited Last);
end;

function TQExportRow.IndexOf(Item: TQExportCol): Integer;
begin
  Result := inherited IndexOf(Item);
end;

function TQExportRow.Remove(Item: TQExportCol): Integer;
begin
  Result := inherited Remove(Item);
end;

function TQExportRow.ColByName(const AName: string): TQExportCol;
var
  i: integer;
begin
  Result := nil;
  for i := 0 to Count - 1 do
    if AnsiCompareText(AName, Items[i].Name) = 0 then begin
      Result := Items[i];
      Exit;
    end;
end;

function TQExportRow.Get(Index: Integer): TQExportCol;
begin
  Result := TQExportCol(inherited Get(Index));
end;

procedure TQExportRow.Put(Index: Integer; const Value: TQExportCol);
begin
  inherited Put(Index, Value);
end;

{ TQExport3 }

constructor TQExport3.Create(AOwner: TComponent);
begin
  inherited;
  FRecordCounter := 0;
  FColumns := TQExportColumns.Create(Self, NormalString);

  FExportSource := esDataSet;