qexport4.pas

Advanced.Export.Component.v4.01.rar,delphi 第三方控件

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;

  {//mp - get width for numeric formats}
  function GetWidth(DS: Integer; const CFormat: string): Integer;
  var
    MaxRes: Extended;
    j: Integer;
    TestFlag: Boolean;
  begin
    MaxRes := Exp(DS * 8 * Ln(2));
    Result := 0;
    while MaxRes > 1 do
    begin
      Result := Result + 1;
      MaxRes := MaxRes / 10;
    end;
    TestFlag := false;
    if Pos(',', CFormat) <> 0 then
      Result := Result + (Result div 3);
    for j := 1 to System.Length(CFormat) do
    begin
      if CFormat = '.' then
      begin
        Result := Result + 1;
        TestFlag := true;
      end;
      if (CFormat <> '.')
        and (CFormat <> ',') and TestFlag then
          Result := Result + 1;
    end;
  end;
  {//mp}

begin
  if Assigned(FOwnerColumnsWidth) then
    with FOwnerColumnsWidth, Items[Index] do
    begin
      i := IndexOfName(Name);
      if i > -1 then begin
        {Need to correct column width}
        Width := StrToIntDef(Values[Names[i]], 0);
        Exit;
      end;
    end;
  // Items[Index].Number must be defined
  with Items[Index] do
    case FOwnerExportSource of
      esDataSet:
      begin
        Width := FOwnerDataSet.Fields[Number].DisplayWidth;
        if FOwnerDataSet.Fields[Number].DataType in [ftSmallint, ftInteger, ftFloat, ftLargeint] then
        begin
          //if float/integer value is represented in epsilon form
          //then it can contain five symbols {E+-xxx}
          if assigned(FOwnerFormats) then
            if FOwnerDataSet.Fields[Number].DataType in [ftSmallint, ftInteger, ftLargeint] then
              Width := GetWidth(FOwnerDataSet.Fields[Number].DataSize, FOwnerFormats.FIntegerFormat)
            else
              Width := GetWidth(FOwnerDataSet.Fields[Number].DataSize, FOwnerFormats.FFloatFormat);
        end;
        if Width > 100 then Width := 100;
      end;
      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
            'L': ColAlign := ecaLeft;
            'C': COlAlign := ecaCenter;
            'R': ColAlign := ecaRight;
            else ColAlign := ecaLeft;
          end
        else ColAlign := ecaLeft;
        Exit;
      end;
      case ColType of
        ectInteger,
        ectBigint,
        ectFloat,
        ectCurrency: ColAlign := ecaRight;
        ectBoolean: ColAlign := ecaCenter;
        else ColAlign := ecaLeft;
      end;
    end;
end;

procedure TQExportColumns.AutoCalcColWidth;
var
  i, w: integer;
  Bookmark: TBookmark;
  Str: QEstring;
  Data: Variant;
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
        QExportGetColData(FOwnerExportSource, FOwnerDataSet,
          FOwnerCustomSource, {$IFNDEF NOGUI}FOwnerDBGrid, FOwnerListView,
          FOwnerStringGrid,{$ENDIF} Self, FOwnerFormats, i,
          FRecordCounter, FOwnerSkipRecCount, Str, Data);
        Str := FNormalFunc(Str);
        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 := FOwnerDataSet.Fields[Number].Size;
      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;

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