virtualstringtree in excel exportieren

[youuu]

Danke, werde ich so machen

[madas]

Delphi-Quellcode:

  exportText := vst.ContentToText(tstVisible, ';');
  with TFileStream.Create('D:\ExportOrdner\ExportTest.csv', fmCreate or fmShareDenyWrite) do 
  begin
    Write(exportText[1], length(exportText));
    Free;
  end;

[David Martens]

Da muß ich ein wenig wiedersprechen.

Fakt ist man muß eine Konvertierung machen, ob StringGrid, VST oder sonstwas.

Da unser Export mit unterschiedlichen "Grids" arbeiten können soll, habe ich eine "Wrapper"-Klasse geschrieben, damit die eingentliche Exportklasse übersichtlich bleibt.

Hier ein paar Ansätze:

Delphi-Quellcode:

procedure TExcelServer.WriteRange(Row, Col, RowCount, ColCount: integer; Values: OleVariant);
begin
  ExcelWorksheet.Range[
    TranslateCell(Row + 1, Col + 1),
    TranslateCell(Row + RowCount, Col + ColCount)].Value := Values;
end;

Das ist die schnellste Variante GROSSE Datenmengen an Excel zu senden. (TranslateCell macht aus Integer die Excel Spalten/Zeilen-bezeichnungen)

Der OleVariant wird in der "Wrapper"-Klasse erzeugt:

Delphi-Quellcode:

function TDataWrapper.GetDataOle : OleVariant;
var
  i, iRow, iCol : Longint;
  bm            : TBookmark;
  FNodeData     : PGridTreeData;
  FNode         : PVirtualNode;
begin
  Result := VarArrayCreate([0, RowCount - 1,
                            0, ColCount - 1], varVariant);

  {$REGION 'FAdvStringGridLink'}
  if Assigned(FAdvStringGridLink) then
  begin
    for iCol := 0 to ColCount - 1 do
    begin
      for iRow := 0 to RowCount - 1 do
      begin
        Result[iRow, iCol] := FAdvStringGridLink.Cells[iRow, iCol];
      end;
    end;
  end;
  {$ENDREGION}

  {$REGION 'FVirtualStringTreeLink'}
  if Assigned(FVirtualStringTreeLink) then
  begin
    with FVirtualStringTreeLink do
    begin
      FNode := GetFirst;

      for iRow := 0 to RowCount - 1 do
      begin
        FNodeData := GetNodeData(FNode);
        for iCol := 0 to ColCount - 1 do
        begin
          Result[iRow, iCol] := FNodeData^.Columns[iCol];
        end;

        FNode := GetNext(FNode);
      end;
    end;
  end;
  {$ENDREGION}

  {$REGION 'FDataSourceLink'}
  if Assigned(FDataSourceLink) then
  begin
    with FDataSourceLink.DataSet do
    begin
      DisableControls;
      bm := GetBookmark;
      First;
      iRow := 0;

      while (not Eof) do
      begin
        i := 0;
        for iCol := 0 to FieldCount - 1 do
        begin
          if Fields[iCol].Visible then
          begin
            Result[iRow, i] := Fields.Fields[iCol].AsString;
            inc(i);
          end;
        end;

        Next;
        inc(iRow);
      end;

      GotoBookmark(bm);
      FreeBookmark(bm);
      EnableControls;
    end;
  end;
  {$ENDREGION}
end;

RowCount und ColCount wird auch so ermittelt.
Der OleVariant aus GetDataOle kann wie ein Stringgrid benutzt werden, was ich für zusätzliche Formatierungen ausnutze. z.B.:

Delphi-Quellcode:

...
          {$REGION 'Werte ggf. formatieren und dann einfügen —————————————————————————————'}
          if iMonat > -1 then
          begin
            for iRow := 0 to AData.RowCount - 1 do
              OleGrid[iRow, iMonat] := '01.' + OleGrid[iRow, iMonat];
          end;

          if (FExcelServer.Version.Major >= 11) then
          begin
            if iDatum > -1 then
            begin
              OleGrid[iRow, iDatum] := StrToDateTime(OleGrid[iRow, iDatum]);
            end;
          end;
...
          {$REGION 'Daten schreiben ——————————————————————————————————————————————————————'}
          FExcelServer.WriteRange(FStartRow,
                                  FStartCol,
                                  AData.RowCount,
                                  AData.ColCount,
                                  OleGrid);
          {$ENDREGION}
...

Ich benutzt übrigens Early-binding um wenigstens ein bisschen Kontrolle zu behalten. (Sollte man bei solchen Problemen immer dazu sagen, erleichter das Verständnis ungemein)

Um jetzt auf das Wiedersprechen zu kommen:
man kann natürlich die Werte einzeln nach Excel schreibe:

Delphi-Quellcode:

  {$REGION 'FVirtualStringTreeLink'}
  if Assigned(FVirtualStringTreeLink) then
  begin
    with FVirtualStringTreeLink do
    begin
      FNode := GetFirst;

      for iRow := 0 to RowCount - 1 do
      begin
        FNodeData := GetNodeData(FNode);
        for iCol := 0 to ColCount - 1 do
        begin
          Result[iRow, iCol] := FNodeData^.Columns[iCol];  // Hier kann man statt den Variant zu füllen auch gleich Excel füttern
        end;

        FNode := GetNext(FNode);
      end;
    end;
  end;
  {$ENDREGION}

Diese Variante ist aber um mehrere Größenordnungen langsamer!

Gruß David

[David Martens]

Und weil wir gerade dabei sind. Ich würde gerne mein Wissen, was Excel angeht, mit anderen teilen und ein Projekt ins Leben rufen was zum Ziel hat einen funktionierenden Excel(Word, Office)-Server für Delphi bereitzustellen.

Hier u.a. was ich bisher kann:
- Prüfung ob Excel installiert
- Excel: starten, anzeigen, verstecken, schließen, Version anfragen, Sprache (des Systems)
- Dokument: öffnen, speichern, neu anlegen
- Tabellen: anlegen, umbenennen, kopieren, aktivieren
- PivotTable: anlegen, formatieren
- PivotField: umbenennen, Orientierung/Position ändern, Funktion/Berechnung bestimmen, Zwischensummen, Sortierung
- Diagramme: anlegen, Typ setzen, installierte Typen finden (nur bis 2007), Titel/Achsen ändern, neue Datenserie hinzufügen
- Diagrammobjekt: Name/Fehlerbalken ändern, Datenlabel anzeigen
- Hyperlink: in Zelle einfügen
- Zellen/Spalten/Reihen/"Ranges": einfügen, löschen, ändern, lesen, (Zahlen)-Format ändern, Schrift ändern (nicht alles), Pagebreak anlegen
- Spalten: autofit
- Makros: existiert ein Makro (nicht für 2007), ausführen
- diverse Listen: offene Dokumente, Tabellen, PivotTables, PivotFields, Diagramme, Diagrammobjekte

Leider ist alles in EINER Klasse zusammengefasst. Wenn ich Zeit hätte (hust), würde ich für die einzelnen Objekte Klassen anlegen, ähnlich wie es in Excel selber ist.

Hat jemand Lust und Zeit dabei mitzumachen? Alleine kann ich das nicht stemmen.

nachmal Gruß David

[youuu]

David Martens, das ist grad zuviel input auf einmal, da blick ich noch garniht durch.

Bei "ExcelWorksheet" erhalte ich schon die Fehlermeldung "undeklarierter Bezeichner"

Wenn ich das mal "doof" kopiere

[David Martens]

In TExcelServer stecken ja auch Variablen die den Zugriff auf Excel managen. Zeig doch mal wie du in die Zellen von Excel schreibst?

Ich wollte nicht die ganzen 4000 Zeilen Quelltext meines ExcelServers hier einstellen.

Ich hatte übrigens vergessen das intensives Exception handling auch im Server stecken.

[youuu]

Entschuldigung, hatte gestern leider keine Zeit mehr.

Bislang schreib ich noch gar nichts in Excel, ich hab es vorher mit einen Striggrid gelöst und mit Hilfer der Schweizer.
Nun wollte ich allerdings ein VirtualStringTree benutzen, da ich mit ihm besser arbeiten kann.

Nur kenn ich mich bei dem VST nicht aus, wie man den Inhalt exportiert.

[himitsu]

Zitat von youuu:

Bei "ExcelWorksheet" erhalte ich schon die Fehlermeldung "undeklarierter Bezeichner"

Das ist eine Variable, welche du natürlich noch deklarieren
und dann auch noch mit einem passenden Objekt/Interface befüllen mußt.

schau einfach mal, was sonst so dazu geschrieben wurde ExcelWorksheet ... irgendwo wird hoffentlich das Nötige zu finden sein.

[youuu]

Delphi-Quellcode:

//Hilfsfunktionen
function StringToVariant(const SourceString : string) : Variant;
var
  FloatValue : Extended;
begin
  if TryStrToFloat(SourceString, FloatValue) then
    Result := FloatValue
  else
    Result := SourceString;
end;

function RefToCell(Col, Row : Integer) : string;
var
  Pos : Integer;
begin
  //Spalte bestimmen
  Result := '';
  while Col > 0 do
  begin
    Pos := Col mod 26;
    if Pos = 0 then
    begin
      Pos := 26;
      Dec(Col);
    end;
    Result := Chr(Ord('A') + Pos - 1) + Result;
    Col := Col div 26;
  end;
  //Spalte und Zeile zusammenführen
  Result := Result + IntToStr(Row);
end;

//Inhalt eines TStringGrid nach Excel exportieren und anzeigen
function ExportStringGridToExcel(StringGrid : TStringGrid) : Boolean;
var
  Col       : Integer;
  Data      : OleVariant;
  ExcelApp  : OleVariant;
  MaxCol    : Integer;
  MaxRow    : Integer;
  Range     : OleVariant;
  Row       : Integer;
  Workbook  : OleVariant;
  Worksheet : OleVariant;
  Value     : OleVariant;
begin
  Result := False;
  //Verbindung zu Excel herstellen
  ExcelApp := CreateOleObject('Excel.Application');
  try
    if not VarIsNull(ExcelApp) then
    begin
      //Neues Workbook öffnen
      Workbook := ExcelApp.Workbooks.Add;
      if not VarIsNull(Workbook) then
      begin
        //Maximalen Bereich bestimmen
        MaxCol := Min(StringGrid.ColCount, ExcelApp.Columns.Count);
        MaxRow := Min(StringGrid.RowCount, ExcelApp.Rows.Count);
        if (MaxRow > 0) and (MaxCol > 0) then
        begin
          //Worksheet auswählen
          Worksheet := Workbook.ActiveSheet;
          //Bereich auswählen
          Range := Worksheet.Range[RefToCell(1, 1), RefToCell(MaxCol, MaxRow)];
          if not VarIsNull(Range) then
          begin
            //Daten aus Grid holen
            Data := VarArrayCreate([1, MaxRow, 1, MaxCol], varVariant);
            for Row := 0 to Pred(MaxRow) do
            begin
              for Col := 0 to Pred(MaxCol) do
              begin
                Value := StringToVariant(StringGrid.Cells[Col, Row]);
                Data[Succ(Row), Succ(Col)] := Value
              end;
            end;
            //Daten dem Excelsheet übergeben
            Range.Value := Data;
            Range.Columns.AutoFit;
            //Excel anzeigen
            Workbook.Activate;
            ExcelApp.Visible := True;
            Result := True;
          end;
        end;
      end;
    end;
  finally
    Value    := UnAssigned;
    Data     := UnAssigned;
    Range    := UnAssigned;
    Workbook := UnAssigned;
    ExcelApp := UnAssigned;
  end;
end;

Das ist der Code den ich verwendet habe für den Export von Stringgrid zu Excel