virtualstringtree in excel exportieren

[youuu]

Hi, wie der Titel schon sagt, wie exportiere ich am besten virtualstringtree in excel?

[s.h.a.r.k]

Nun ja, nachdem die eigentlichen Daten nicht in dem VST stecken hat es ja damit eigentlich nichts direkt zu tun. Du könntest z.B. eine CSV-Darei schreiben.

[hoika]

Hallo,

zuerst in ein TStringGrid, und von dort per Google-Suche nach Excel.


Heiko

[youuu]

Vom String in Excel ist kein Problem, dachte nur ich kann es umgehen ein Stringgrid noch auf die Form zuschmieren

[DataCool]

Hi,

wie S.h.a.r.k. schon sagte es ist ganz egal in welcher optischen Komponente die Daten stehen,
Du must einfach eine ".csv" Datei erstellen.
So schwer ist das ja nicht, da arbeitest Du mit TFileStream oder Textfile oder TStringList
und schreibst Deine Daten zeilenweise(am Ende der Zeile CRLF)und die Felder trennst Du dann mit ";"
fertig.

Greetz Data

[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 :thumb: 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:

Zitat von youuu (Beitrag 1035523)

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

[himitsu]

Delphi-Quellcode:

function StringToVariant(const SourceString : string) : Variant;
var
  FloatValue : Double;

Grund: Variant kennt kein Extended und er würde es demnach vesuchen runterzurunden, welches bei zu großen Werten Fehler/Exceptions verursachen würde.

das ganze Try-Funally, inklusife der :=UnAssigned; kannst du weglassen, das macht Delphi automatisch, beim Verlassen der Funktionen.


Bei RefToCell ist das Col immer größer als 0?
Wenn nicht, dann wäre eine Fehlerprüfung/-behandlung angebracht.


Und statt dem wenig aussagenden Result würde ich eine etwas aussagekräftigere Fehlerbehandlung verwenden:

Delphi-Quellcode:

procedure ExportStringGridToExcel(StringGrid : TStringGrid);
var
  Col       : Integer;
  Data      : OleVariant;
  ExcelApp  : OleVariant;
  MaxCol    : Integer;
  MaxRow    : Integer;
  Range     : OleVariant;
  Row       : Integer;
  Workbook  : OleVariant;
  Worksheet : OleVariant;
begin
  //Verbindung zu Excel herstellen
  ExcelApp := CreateOleObject('Excel.Application');
  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
            for Col := 0 to Pred(MaxCol) do
              Data[Succ(Row), Succ(Col)] := StringToVariant(StringGrid.Cells[Col, Row])
          //Daten dem Excelsheet übergeben
          Range.Value := Data;
          Range.Columns.AutoFit;
          //Excel anzeigen
          Workbook.Activate;
          ExcelApp.Visible := True;
        end;
      end;
    end else
      raise Exception.Create('neues Workbook konnte nicht angelegt werden');
  end else
    raise Exception.Create('Excel.Application konnte nicht geladen werden');
end;

oder

Delphi-Quellcode:

procedure ExportStringGridToExcel(StringGrid : TStringGrid);
var
  Col       : Integer;
  Data      : OleVariant;
  ExcelApp  : OleVariant;
  MaxCol    : Integer;
  MaxRow    : Integer;
  Range     : OleVariant;
  Row       : Integer;
  Workbook  : OleVariant;
  Worksheet : OleVariant;
begin
  //Verbindung zu Excel herstellen
  ExcelApp := CreateOleObject('Excel.Application');
  if VarIsNull(ExcelApp) then
    raise Exception.Create('Excel.Application konnte nicht geladen werden');
  //Neues Workbook öffnen
  Workbook := ExcelApp.Workbooks.Add;
  if VarIsNull(Workbook) then
    raise Exception.Create('neues Workbook konnte nicht angelegt werden');
  //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
        for Col := 0 to Pred(MaxCol) do
          Data[Succ(Row), Succ(Col)] := StringToVariant(StringGrid.Cells[Col, Row])
      //Daten dem Excelsheet übergeben
      Range.Value := Data;
      Range.Columns.AutoFit;
      //Excel anzeigen
      Workbook.Activate;
      ExcelApp.Visible := True;
    end;
  end;
end;

[youuu]

Danke Himitsu, für die Erklärungen, das wusste ich nicht.
Aber das hauptptoblem ist, das ich das Stringgrid nicht mehr verwenden möchte, lieber das VST und da blick ich ga nicht durch mit dem Export.

Muss auch zugeben, das ich mich das erste mal damit beschäftige (VST Exports).

[himitsu]

Es kommt auch erstmal darauf an, wie du die Daten im VST ablegst/anzeigst/verwaltest.

dieses ließt z.B. alle Hauptknoten/Zeilen aus (wenn man den VST als Tabelle nutzt:

Delphi-Quellcode:

var
  RowCount: Integer;
  Row: PVirtualNode;
begin
  RowCount := VirtualStringTree1.RootNodeCount;
  Row := VirtualStringTree1.RootNode;
  while Assigned(Row) do begin

    // die Spalten der jeweiligen Zeile aus Row.Data auslesen,
    // irgendwie wirst du dort ja die Daten verwalten

    Row := Row.NextSibling;
  end;
end;

Aber ich würde nicht den Export aus dem VST erzeugen.
- im Hintergrund liegen alle Daten in einer eigenen Struktur/Liste rum
- der VST wird, für die Anzeige mit dieser Struktur/Liste verknüpft
- auch der Export wird aus der internen Liste erstellt

Der VST ist ja gerade dafür entworfen wurden, daß er selber keine Daten vorhalten/verwalten muß, sondern z.B. nur Zeiger auf die Daten bekommt und diese dann "virtuell" anzeigt, aber aus externen Quellen holt.

[youuu]

Ah, gut das versteh ich.
Auch wenn es sich jetzt dumm anhört, wie spicht man die Liste an in der diese Daten liegen?

[David Martens]

@himitsu: dazu muß der Export aber die Struktur kennen. Wenn das nicht der Fall ist, dann muß man direkt aufs VST gehen. Hat den Vorteil das der Export dann universell bleibt.

Hier noch mein Vorschlag (ein wenig Umgebaut von himitsus post):

Delphi-Quellcode:

procedure ExportVirtualStringTreeToExcel(VirtualStringTree : TVirtualStringTree);
var
  ExcelApp,
  Workbook,
  Worksheet,
  Range,
  Data      : OleVariant;
  iCol,
  iRow,
  ColCount,
  RowCount  : Integer;
  FNodeData : PGridTreeData;
  FNode     : PVirtualNode;
begin
  //Verbindung zu Excel herstellen
  ExcelApp := CreateOleObject('Excel.Application');
  if not VarIsNull(ExcelApp) then
  begin
    //Neues Workbook öffnen
    Workbook := ExcelApp.Workbooks.Add;
    //Worksheet auswählen
    Worksheet := Workbook.ActiveSheet;
    if not VarIsNull(Workbook) then
    begin
      RowCount := VirtualStringTree.TotalCount;
      ColCount := VirtualStringTree.Header.Columns.Count;

      if (RowCount > 0) and (ColCount > 0) then
      begin
        //Bereich auswählen
        Range := Worksheet.Range[RefToCell(1, 1), RefToCell(ColCount, RowCount)];
        if not VarIsNull(Range) then
        begin
          Data := VarArrayCreate([0, RowCount - 1,
                                  0, ColCount - 1], varVariant);

          with VirtualStringTree do
          begin
            FNode := GetFirst;

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

              FNode := GetNext(FNode);
            end;
          end;

          Range.Value := Data;
          Range.Columns.AutoFit;
          //Excel anzeigen
          Workbook.Activate;
          ExcelApp.Visible := True;
        end;
      end;
    end
    else
      raise Exception.Create('neues Workbook konnte nicht angelegt werden');
  end
  else
    raise Exception.Create('Excel.Application konnte nicht geladen werden');
end;

Das ist übrigens Late-binding.

Gruß David

[youuu]

Schönen guten Morgen,

danke David, allerdings funktioniert diese Stelle bei mir nicht

Delphi-Quellcode:

FNodeData : PGridTreeData;

undeklarierter Bezeichner wird mir da zurück gegeben.

[David Martens]

:oops: ich sehe gerade das der Export so doch nicht unabhänig von den Daten ist.

Hier was noch fehlt:

Delphi-Quellcode:

type
  TGridTreeData = record
    Columns : TStringList;
  end;
  PGridTreeData = ^TGridTreeData;

Das sind quasi die Daten einer Reihe. Entweder übernimmst du das so, oder du nimmst deine eigene Struktur.

David

[youuu]

Hm da erhalt ich eine Zugriffsverletzung bei.

[David Martens]

Wie sieht denn bei dir die Datenstruktur aus, in die du die Daten schreibst?

Hier noch wie wir das machen:

Delphi-Quellcode:

procedure TfraGLOB_VSTAnalyseGrid.LoadVST;
var
  GridNodeData : PGridTreeData;
  newGridNode  : PVirtualNode;
  i            : integer;
begin
  FDataSource.DataSet.Open;
  FDataSource.DataSet.First;

  vstAnalyse.Clear;
  vstAnalyse.BeginUpdate;

  while not FDataSource.DataSet.Eof do
  begin
    newGridNode := vstAnalyse.AddChild(nil);
    GridNodeData := vstAnalyse.GetNodeData(newGridNode);
    vstAnalyse.ValidateNode(newGridNode, false);
    GridNodeData^.Columns := TStringList.Create;

    for i := 0 to FDataSource.DataSet.Fields.Count - 1 do
      GridNodeData^.Columns.Add(FDataSource.DataSet.Fields[i].AsString);

    FDataSource.DataSet.Next;
  end;

  vstAnalyse.EndUpdate;
  SetHeaders;
  SetColumnWidth;

  newGridNode := vstAnalyse.GetFirst;

  if newGridNode <> nil then
  begin
    vstAnalyse.Selected[newGridNode] := true;
  end;
  
  SetControls;
end;

[youuu]

Delphi-Quellcode:

type
  Tdata = class
    name: WideString;
    url: WideString;
    date: WideString;
end;

So ist meine Struktur

Delphi-Quellcode:

with data do
  Begin
    data.name := NameExport(RKundenSource.Lines.Text); 
    data.date := DateExport(RKundenSource.Lines.Text);   
    data.url := sl[i];                 
  end;

  VstScan.update;
  VstScan.addchild(nil, data);
  VstScan.endupdate;

[David Martens]

Als Klasse? Das geht doch bei VST garnicht.

[youuu]

Also bislang funktionierte es super, bzw. hatte keine Probleme damit.

[David Martens]

Wie greifst du denn später auf "data" aus VstScan.addchild(nil, data); zu?

Moment ich sehe gerade:

Zitat:

Zitat von youuu (Beitrag 1036188)

Code:

type
  Tdata = class
    name: WideString;
    url: WideString;
    date: WideString;
end;

So ist meine Struktur

Code:

with data do
  Begin
    Kunde.name := NameExport(RKundenSource.Lines.Text); 
    Kunde.date := DateExport(RKundenSource.Lines.Text);   
    Kunde.url := sl[i];                 
  end;

  VstScan.update;
  VstScan.addchild(nil, data);
  VstScan.endupdate;

Da haut was nicht hin. Was ist denn Kunde, das ist in der Klasse doch garnicht definiert. Damit speicherst du nicht ab.

Versuchs mal hiermit

Delphi-Quellcode:

  TGridTreeData = record
    name: WideString;
    url: WideString;
    date: WideString;
  end;
  PGridTreeData = ^TGridTreeData;

...
var
  GridNodeData : PGridTreeData;
  newGridNode : PVirtualNode;
begin
    newGridNode := vstAnalyse.AddChild(nil);
    GridNodeData := vstAnalyse.GetNodeData(newGridNode);
    vstAnalyse.ValidateNode(newGridNode, false);

    GridNodeData^.name := NameExport(RKundenSource.Lines.Text); 
    GridNodeData^.date := DateExport(RKundenSource.Lines.Text);   
    GridNodeData^.url := sl[i];

[youuu]

Also, wenn ich eine Zeile anklick(Doppelklick)

lass les ich so all die Daten ein.

Delphi-Quellcode:

  Node:= VstScan.FocusedNode;

  data:= TData(VstScan.GetNodeData(node)^ );

Edit: oben nochmal Editiert, das mit Kunde war ein Kopie Fehler.
Probiere dein nachher aus, wenn ich zurück bin.

[David Martens]

Na dann ist es doch einfach:
(Dann steht auch ColCount fest)

Delphi-Quellcode:

procedure ExportVirtualStringTreeToExcel(VirtualStringTree : TVirtualStringTree);
var
  ExcelApp,
  Workbook,
  Worksheet,
  Range,
  Data      : OleVariant;
  iCol,
  iRow,
  ColCount,
  RowCount  : Integer;
  FData     : TData;
  FNode     : PVirtualNode;
begin
  //Verbindung zu Excel herstellen
  ExcelApp := CreateOleObject('Excel.Application');
  if not VarIsNull(ExcelApp) then
  begin
    //Neues Workbook öffnen
    Workbook := ExcelApp.Workbooks.Add;
    //Worksheet auswählen
    Worksheet := Workbook.ActiveSheet;
    if not VarIsNull(Workbook) then
    begin
      RowCount := VirtualStringTree.TotalCount;
      ColCount := VirtualStringTree.Header.Columns.Count;

      if (RowCount > 0) and (ColCount > 0) then
      begin
        //Bereich auswählen
        Range := Worksheet.Range[RefToCell(1, 1), RefToCell(ColCount, RowCount)];
        if not VarIsNull(Range) then
        begin
          Data := VarArrayCreate([0, RowCount - 1,
                                  0, ColCount - 1], varVariant);

          with VirtualStringTree do
          begin
            FNode := GetFirst;

            for iRow := 0 to RowCount - 1 do
            begin
              // hier steht jetzt deine Datenstruktur
              FData := TData(VstScan.GetNodeData(node)^);
              Data[iRow, 0] := FData.name;
              Data[iRow, 1] := FData.url;
              Data[iRow, 2] := FData.date;

              // oder so, dann brauchst du FData nicht:
              Data[iRow, 0] := TData(VstScan.GetNodeData(node)^).name;
              Data[iRow, 1] := TData(VstScan.GetNodeData(node)^).url;
              Data[iRow, 2] := TData(VstScan.GetNodeData(node)^).date;

              FNode := GetNext(FNode);
            end;
          end;

          Range.Value := Data;
          Range.Columns.AutoFit;
          //Excel anzeigen
          Workbook.Activate;
          ExcelApp.Visible := True;
        end;
      end;
    end
    else
      raise Exception.Create('neues Workbook konnte nicht angelegt werden');
  end
  else
    raise Exception.Create('Excel.Application konnte nicht geladen werden');
end;

Das ist übrigens Late-binding.

Gruß David[/QUOTE]

[youuu]

Hmmmm Wieder Exception mit Lesen von Adresse 0000000 als wenn es nicht existiert.


Bei:

Delphi-Quellcode:

FData := TKundendata(VirtualStringTree.GetNodeData(node)^);

Edit: Ok habs gefunde.

Bei:

Delphi-Quellcode:

FData := TKundendata(VirtualStringTree.GetNodeData(FNode)^);

muss es heißen, das "F" leder vergessen gehabt.

Super nun klappt es, Danke David

[David Martens]

Bitte :-D