qexport4common.pas

delphi中把数据输出为html excel等形式的控件

    case Format.Alignment.Vertical of
      valTop: Y := 5;
      valCenter: Y := (PaintBox.Height - PaintBox.Canvas.TextHeight(TXT)) div 2;
      valBottom: Y := PaintBox.Height - 5 - PaintBox.Canvas.TextHeight(TXT);
      else Y := 0;
    end;}

    PaintBox.Canvas.TextOut(X, Y, TXT);

    //otm.otmSize := SizeOf(otm);
    //GetOutlineTextMetrics(PaintBox.Canvas.Handle, otm.otmSize, @otm);
  end;

begin
  FillBackground;
  OutText;
end;

procedure DrawPDFSample(PaintBox: TPaintBox; PDFFont: TFont);
  procedure FillBackground;
  begin
    PaintBox.Canvas.Brush.Color := clWhite;
    PaintBox.Canvas.FillRect(Rect(0, 0, PaintBox.Width, PaintBox.Height));
  end;

  procedure OutText;
  const
    TXT = 'Aa Zz';
  var
    X, Y: integer;
  begin
    with PaintBox.Canvas.Font do begin
      Name := PDFFont.Name;
      Size := PDFFont.Size;
      Charset := PDFFont.Charset;
      Color := PDFFont.Color;
      Style := PDFFont.Style - [fsStrikeOut, fsUnderline];
    end;

    X := (PaintBox.Width - PaintBox.Canvas.TextWidth(TXT)) div 2;
    Y := (PaintBox.Height - PaintBox.Canvas.TextHeight(TXT)) div 2;

    PaintBox.Canvas.TextOut(X, Y, TXT);

  end;

begin
  FillBackground;
  OutText;
end;
{$ENDIF}

procedure QExportCheckSource(ExportSource: TQExportSource;
  DataSet: TDataSet; CustomSource: TqeCustomSource4
  {$IFNDEF NOGUI}; DBGrid: TDBGrid; ListView: TListView;
  StringGrid: TStringGrid{$ENDIF});
begin
  if ((ExportSource = esDataSet) and not Assigned(DataSet)) or
     ((ExportSource = esCustom) and not Assigned(CustomSource)){$IFNDEF NOGUI}or
     ((ExportSource = esDBGrid) and
      (not Assigned(DBGrid) or
       not Assigned(DBGrid.DataSource) or
       not Assigned(DBGrid.DataSource.DataSet))) or
     ((ExportSource = esListView) and not Assigned(ListView)) or
     ((ExportSource = esStringGrid) and not Assigned(StringGrid)){$ENDIF} then
    raise Exception.CreateFmt({$IFDEF WIN32}QExportLoadStr(QEM_ExportSourceNotAssigned){$ENDIF}
                              {$IFDEF LINUX}QEM_ExportSourceNotAssigned{$ENDIF},
                              [QExportSourceAsString(ExportSource)]);
end;

function QExportSource(ExportSource: TQExportSource;
  DataSet: TDataSet; CustomSource: TqeCustomSource4
  {$IFNDEF NOGUI}; DBGrid: TDBGrid; ListView: TListView;
  StringGrid: TStringGrid{$ENDIF}): TComponent;
begin
  Result := nil;
  if ExportSource = esDataSet then
    Result := DataSet
  else if ExportSource = esCustom then
    Result := CustomSource
  {$IFNDEF NOGUI}
  else if ExportSource = esDBGrid then
    Result := DBGrid
  else if ExportSource = esListView then
    Result := ListView
  else if ExportSource = esStringGrid then
    Result := StringGrid;
  {$ENDIF}
end;

procedure QExportGetColumns(ExportSource: TQExportSource;
  DataSet: TDataSet; CustomSource: TqeCustomSource4; 
  {$IFNDEF NOGUI}DBGrid: TDBGrid; ListView: TListView;
  StringGrid: TStringGrid;{$ENDIF} ExportedFields, AvailableCols,
  ExportedCols: TStrings);
var
  i: integer;
  WA: boolean;
  FDS: TDataSet;
begin
  QExportCheckSource(ExportSource, DataSet, CustomSource
    {$IFNDEF NOGUI}, DBGrid, ListView, StringGrid{$ENDIF});

  AvailableCols.Clear;
  ExportedCols.Clear;
  {$IFDEF NOGUI}FDS := nil;{$ENDIF}
  case ExportSource of
    esDataSet,
    esDbGrid: begin
      case ExportSource of
        esDataSet: FDS := DataSet;
        {$IFNDEF NOGUI}
        esDBGrid: FDS := DBGrid.DataSource.DataSet;
        else FDS := nil;
        {$ENDIF}
      end;
      WA := FDS.Active;
      if not FDS.Active and (FDS.FieldCount = 0) then
        try FDS.Open; except Exit; end;
      for i := 0 to FDS.FieldCount - 1 do
        if FDS.Fields[i].IsBlob
          then AvailableCols.AddObject(FDS.Fields[i].FieldName, TObject(1))
          else AvailableCols.AddObject(FDS.Fields[i].FieldName, TObject(0));
      if not WA and FDS.Active then
        try FDS.Close; except end;
    end;
    esCustom:
      for i := 0 to CustomSource.ColCount - 1 do
        AvailableCols.AddObject(CustomSource.Columns[i].ColumnName, TObject(0));
    {$IFNDEF NOGUI}
    esListView:
      for i := 0 to ListView.Columns.Count - 1 do
        AvailableCols.AddObject(ListView.Columns[i].Caption, TObject(0));
    esStringGrid:
      for i := 0 to StringGrid.ColCount - 1 do
        AvailableCols.AddObject(IntToStr(i), TObject(0));
    {$ENDIF}
  end; { case }

  for i := 0 to ExportedFields.Count - 1 do
    if AvailableCols.IndexOf(ExportedFields[i]) <> -1 then
      ExportedCols.Add(ExportedFields[i]);
  for i := AvailableCols.Count - 1 downto 0 do
    if ExportedFields.IndexOf(AvailableCols[i]) <> -1 then
      AvailableCols.Delete(i);
end;

function QExportIsActive(ExportSource: TQExportSource;
  DataSet: TDataSet; CustomSource: TqeCustomSource4
  {$IFNDEF NOGUI}; DBGrid: TDBGrid; ListView: TListView;
  StringGrid: TStringGrid{$ENDIF}): boolean;
begin
  Result := true;
  case ExportSource of
    esDataSet: Result := DataSet.Active;
    {$IFNDEF NOGUI}
    esDBGrid: Result := DBGrid.DataSource.DataSet.Active;
    {$ENDIF}
  end;
end;

function QExportIsEmpty(ExportSource: TQExportSource;
  DataSet: TDataSet; CustomSource: TqeCustomSource4
  {$IFNDEF NOGUI}; DBGrid: TDBGrid; ListView: TListView;
  StringGrid: TStringGrid{$ENDIF}): boolean;
begin
  Result := true;
  case ExportSource of
    esDataSet: Result := DataSet.IsEmpty;
    {$IFNDEF NOGUI}
    esDBGrid: Result := DBGrid.DataSource.DataSet.IsEmpty;
    esListView: Result := ListView.Items.Count = 0;
    esStringGrid: Result := StringGrid.RowCount = StringGrid.FixedRows;
    {$ENDIF}
  end;
end;

function QExportGetBookmark(ExportSource: TQExportSource; DataSet: TDataSet;
  CustomSource: TqeCustomSource4{$IFNDEF NOGUI}; DBGrid: TDBGrid;
  ListView: TListView; StringGrid: TStringGrid{$ENDIF}): TBookmark;
  {$IFDEF VCL12}
var
  bmk: TBookmark;
  {$ENDIF}
begin
  Result := nil;
  case ExportSource of
    esDataSet: Result := DataSet.GetBookmark;
    esCustom:
    {$IFDEF VCL12}
    Result := TBookmark(CustomSource.RecNo);
    {$ELSE}
    Result := Pointer(CustomSource.RecNo);
    {$ENDIF}
    {$IFNDEF NOGUI}
    esDBGrid: Result := DbGrid.DataSource.DataSet.GetBookmark;
    esListView: begin
      if Assigned(ListView.Selected)
        then Result := Pointer(ListView.Selected.Index)
        else Result := Pointer(0);
    end;
    esStringGrid:
    {$IFDEF VCL12}
    begin
    SetLength(bmk, SizeOf( StringGrid.Row ));
    PInteger(bmk)^ := StringGrid.Row;
    Result := bmk;
    end
    {$ELSE}
    Result := Pointer(StringGrid.Row);
    {$ENDIF}
    {$ENDIF}
  end;
end;

procedure QExportGotoBookmark(ExportSource: TQExportSource; DataSet: TDataSet;
  CustomSource: TqeCustomSource4;{$IFNDEF NOGUI}DBGrid: TDBGrid;
  ListView: TListView; StringGrid: TStringGrid;{$ENDIF} Bookmark: TBookmark);
begin
  case ExportSource of
    esDataSet: DataSet.GotoBookmark(Bookmark);
    esCustom:
      begin
        CustomSource.RecNo := Integer(Bookmark);
        CustomSource.Eof := False;
      end;
    {$IFNDEF NOGUI}
    esDBGrid: DbGrid.DataSource.DataSet.GotoBookmark(Bookmark);
    esListView: ListView.Items[Integer(Bookmark)].Selected := true;
    esStringGrid:
    {$IFDEF VCL12}
    StringGrid.Row :=  Integer(PInteger(Bookmark)^);
    {$ELSE}
    StringGrid.Row := Integer(Bookmark);
    {$ENDIF}
    {$ENDIF}
  end;
end;

procedure QExportFreeBookmark(ExportSource: TQExportSource; DataSet: TDataSet;
  {$IFNDEF NOGUI}DBGrid: TDBGrid; ListView: TListView;
  StringGrid: TStringGrid;{$ENDIF} Bookmark: TBookmark);
begin
  case ExportSource of
    esDataSet: DataSet.FreeBookmark(Bookmark);
    {$IFNDEF NOGUI}
    esDBGrid: DbGrid.DataSource.DataSet.FreeBookmark(Bookmark);
    {$ENDIF}
  end;
end;

procedure QExportFirst(ExportSource: TQExportSource;
  DataSet: TDataSet; CustomSource: TqeCustomSource4
  {$IFNDEF NOGUI};DBGrid: TDBGrid; ListView: TListView;
  StringGrid: TStringGrid{$ENDIF});
begin
  case ExportSource of
    esDataSet: DataSet.First;
    esCustom: CustomSource.First;
    {$IFNDEF NOGUI}
    esDBGrid:
      if Assigned(DBGrid) and Assigned(DBGrid.DataSource) and
         Assigned(DBGrid.DataSource.DataSet) and
         DBGrid.DataSource.DataSet.Active then
           DBGrid.DataSource.DataSet.First;
    esListView: ListView.Items[0].Selected := true;
    esStringGrid: StringGrid.Row := StringGrid.FixedRows;
    {$ENDIF}
  end;
end;

procedure QExportNext(ExportSource: TQExportSource;
  DataSet: TDataSet; CustomSource: TqeCustomSource4;
  {$IFNDEF NOGUI}DBGrid: TDBGrid; ListView: TListView;
  StringGrid: TStringGrid;{$ENDIF} var RecordCounter: integer);
begin
  Inc(RecordCounter);
  case ExportSource of
    esDataSet: DataSet.Next;
    esCustom: CustomSource.Next;
    {$IFNDEF NOGUI}
    esDBGrid: DBGrid.DataSource.DataSet.Next;
    esStringGrid: begin
      if StringGrid.Row < StringGrid.RowCount - 1 then
        StringGrid.Row := StringGrid.Row + 1;
    end;
    {$ENDIF}
  end;
end;

procedure QExportSkip(ExportSource: TQExportSource;
  DataSet: TDataSet; CustomSource: TqeCustomSource4;
  {$IFNDEF NOGUI}DBGrid: TDBGrid; ListView: TListView;
  StringGrid: TStringGrid;{$ENDIF} SkipRecCount: integer;
  SkipEvent: TExportedRecordEvent; Sender: TObject; var RecordCounter: integer);
var
  i: integer;
begin
  for i := 0 to SkipRecCount - 1 do begin
    QExportNext(ExportSource, DataSet, CustomSource,
     {$IFNDEF NOGUI}DBGrid, ListView, StringGrid,{$ENDIF} RecordCounter);
    if Assigned(SkipEvent) then SkipEvent(Sender, RecordCounter);
  end;
end;

function QExportEof(ExportSource: TQExportSource;
  DataSet: TDataSet; CustomSource: TqeCustomSource4;
  {$IFNDEF NOGUI}DBGrid: TDBGrid; ListView: TListView;
  StringGrid: TStringGrid;{$ENDIF} RecordCounter, ExportRecCount,
  SkipRecCount: integer): boolean;
begin
  Result := true;
  case ExportSource of
    esDataSet: Result := DataSet.Eof;
    esCustom: Result := CustomSource.Eof or not Assigned(CustomSource.OnGetNextRecord);
    {$IFNDEF NOGUI}
    esDBGrid: Result := DBGrid.DataSource.DataSet.Eof;
    esListView:
      if ExportRecCount > 0 then
        Result := RecordCounter = MaximumInt(MinimumInt(ExportRecCount,
          ListView.Items.Count - SkipRecCount), 0)
      else
        Result := RecordCounter = MaximumInt(ListView.Items.Count -
          SkipRecCount, 0);
    esStringGrid:
      if ExportRecCount > 0 then
        Result := RecordCounter = MaximumInt(MinimumInt(ExportRecCount,
          StringGrid.RowCount - StringGrid.FixedRows - SkipRecCount), 0)
      else
        Result := RecordCounter = MaximumInt(StringGrid.RowCount -
          StringGrid.FixedRows - SkipRecCount, 0);
    {$ENDIF}
  end;
end;

procedure QExportGetColData(ExportSource: TQExportSource;
  DataSet: TDataSet; CustomSource: TqeCustomSource4;
  {$IFNDEF NOGUI}DBGrid: TDBGrid; ListView: TListView;
  StringGrid: TStringGrid;{$ENDIF} Columns: TQExportColumns;
  Formats: TQExportFormats; Index, RecordCounter,
  SkipRecCount: integer; var Value: QEString; var Data: Variant);
var
  DSField: TField;
  {$IFDEF VCL6}
  i: integer;
  {$ENDIF}
begin
  DSField := nil;
  case ExportSource of
    esDataSet:
      DSField := DataSet.Fields[Columns[Index].Number];
    esCustom:
      Value := CustomSource.Columns[Columns[Index].Number].AsString;
    {$IFNDEF NOGUI}
    esDBGrid:
      DSField := DBGrid.Columns[Columns[Index].Number].Field;
    esListView:
      if Columns[Index].Number = 0 then
        Value := ListView.Items[RecordCounter + SkipRecCount].Caption
      else
        Value := ListView.Items[RecordCounter + SkipRecCount].SubItems[Columns[Index].Number - 1];
    esStringGrid:
      Value := StringGrid.Cells[Columns[Index].Number, StringGrid.Row];
    {$ENDIF}
  else
    Value := EmptyStr;
  end;
  if DSField <> nil then
  begin
    VarClear(Data);
    Data := DSField.AsVariant;
    if DSField.IsNull then
      Value := Formats.NullString
    else
    if Formats.KeepOriginalFormat then
      Value := {$IFDEF QE_UNICODE}DSField.AsVariant{$ELSE}DSField.AsString{$ENDIF}
    else begin
      Formats.ApplyParams;
      try
        case DSField.DataType of
          ftSmallint, ftInteger, ftWord, ftAutoInc, ftLargeint:
            Value := FormatFloat(Columns[Index].Format, DSField.AsInteger);
          ftFloat:
            Value := FormatFloat(Columns[Index].Format, DSField.AsFloat);
          ftBCD:
            Value := DSField.AsVariant;
          ftCurrency:
            if Columns[Index].Format <> EmptyStr then
              Value := FormatFloat(Columns[Index].Format, DSField.AsFloat)
            else
              Value := FloatToStrF(DSField.AsFloat, ffCurrency, 15, CurrencyDecimals);
          ftDate, ftTime, ftDateTime {$IFDEF VCL6}, ftTimeStamp{$ENDIF}:
            Value := FormatDateTime(Columns[Index].Format, DSField.AsDateTime)