Announcement

**Andreas Kosch** · 05.08.2002, 07:32

Hallo,

ja - das geht.

>..wenn ja wie..

Es gibt mindestens 3 Alternativen. Am einfachsten ist der Weg �ber eine tempor�re Datei, da das Worddokument oder die Excel-Tabelle als Dateiinhalt eingelesen und als BLOb in der Datenbank gespeichert werden kann.

Ansonsten steht das IDataObject-Interface zur Verf�gung, um den Inhalt des aktuellen Word-Dokuments im RTF-Formular abzurufen und in der Datenbank zu speichern.

Die dritte Alternative greift auf einen OleContainer zu, um dort �ber LoadFromStream und SaveToStream das angezeigten OLE-Objekt (Word oder Excel) direkt aus der Datenbank zu laden.

Auf der CDROM zu meinem Buch COM/DCOM/COM+ mit Delphi sind Beispielprojekte f�r alle 3 Alternativen zu finden: 
1. Kapitel 11\RedSys\RedSys.dpr (OLE Component Document-Fassung) 
2. Kapitel 11\IDataObject\Doc2Rtf\IDataObjectTest2.dpr 
3. Kapitel 11\TOLEContainer\WordOLETest.dpr<br&gt

**BlueBit** · 18.06.2003, 15:10

Hallo,

w�rde gern mal ein Codebeispiel sehen.

Gru�
Mathia

**Andreas Kosch** · 19.06.2003, 07:57

Hallo,

das folgende Beispiel demonstriert den TOleContainer-Weg:

<pre>

{ ************************************************** **************
Source File Name : WordOLETestFrm
Typ : Formular-Unit
Autor : Andreas Kosch
Erstellt am : 28.12.1997
Compiler : Delphi 4.02 UpdatePack#3
Betriebssystem : Windows 98
Beschreibung : Word-Dokument ueber OLEContainer in der
Datenbanktabelle speichern.
Die komplette Funktionalitaet ist im
Datenmodul der Anwendung gekapselt.
Revisionen : 12.09.1999 Delphi 4.02 + Word2000
************************************************** ************** }

unit WordOLETestFrm;

interface

uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms,
Dialogs, DBCtrls, Db, Grids, DBGrids, DBTables, StdCtrls,
Buttons, OleCtnrs, ExtCtrls, ComCtrls, Menus;

type
TFormMain = class(TForm)
StatBar: TStatusBar;
Panel1: TPanel;
OleContainerWord: TOleContainer;
DBGrid1: TDBGrid;
DBNavigator1: TDBNavigator;
MainMenu1: TMainMenu;
Datei1: TMenuItem;
Exit1: TMenuItem;
MHelp: TMenuItem;
MHAbout: TMenuItem;
MemoVerb: TMemo;
MWActivate: TMenuItem;
N1: TMenuItem;
MWExportRTF: TMenuItem;
SaveDialog1: TSaveDialog;
MWExportDOC: TMenuItem;
procedure Exit1Click(Sender: TObject);
procedure MHAboutClick(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure MWActivateClick(Sender: TObject);
procedure MWExportRTFClick(Sender: TObject);
procedure MWExportDOCClick(Sender: TObject);
private
{ Private-Deklarationen }
procedure ActivateWordDocInContainer(Sender: TObject);
public
{ Public-Deklarationen }
end;

var
FormMain: TFormMain;

implementation

{$R *.DFM}

uses ComObj, ActiveX, WordOLETestDM;

// Neu: OLEContainer beim Aktivieren der Anwendung neu initialisieren

procedure TFormMain.FormCreate(Sender: TObject);
begin
Application.OnActivate := ActivateWordDocInContainer;
end;

// Datenmodul-Methode aufrufen: Im Edit-Modus wird DoVerb(1) aufgerufen

procedure TFormMain.ActivateWordDocInContainer(Sender: TObject);
begin
DM.ActivateContainer
end;

// Manuelle Aktivierung via Menuepunkt

procedure TFormMain.MWActivateClick(Sender: TObject);
begin
OleContainerWord.DoVerb(1);
end;

procedure TFormMain.Exit1Click(Sender: TObject);
begin
Close
end;

procedure TFormMain.MHAboutClick(Sender: TObject);
begin
MessageDlg('Word-Dokument ueber TOLEContainer direkt aus ' + #13 +
'der Datenbank einlesen bzw. dort speichern. ' + #13 +
'Das Dokument wird ueber ZLib in komprimierter ' + #13 +
'Form in der Datenbanktabelle gespeichert.' + #13#13 +
'&#169 Andreas Kosch 1998-1999' , mtInformation, [mbOK], 0);
end;

{ Fuer den Fall, dass ein eingebettetes OLE-Objekt nicht im speziellen
Format des OleContainers gespeichert werden soll, sondern im
urspruenglichen Dateiformat, kann der Automation-Zugriff bemueht
werden. }

procedure TFormMain.MWExportDOCClick(Sender: TObject);
begin
with SaveDialog1 do
if Execute then
OleContainerWord.OLEObject.SaveAs(FileName:= FileName,
FileFormat:= 0);
end;

{ Fuer den Fall, dass ein eingebettetes OLE-Objekt nicht im speziellen
Format des OleContainers gespeichert werden soll, sondern im
urspruenglichen Dateiformat, kann das universelle IDataObject-Interface
bemueht werden.
In diesem Fall wird das gesuchte Format ueber seine Bezeichnung als
Zeichenkette gesucht. }

procedure TFormMain.MWExportRTFClick(Sender: TObject);
const
RTF_NAME = 'Rich Text Format';
RTF_NAME_MAX = 254;
var
aDataObject : IDataObject;
aEnumFmt : IEnumFORMATETC;
aFormatEtc : TFormatEtc;
aMedium : TStgMedium;
pFmtName : PChar;
bFmtFound : Boolean;
pRTFData : PChar;
OutputFile : TextFile;
begin
// Zieldateiname definiert ?
if not SaveDialog1.Execute then
Abort;
bFmtFound := False;
OleContainerWord.DoVerb(1);
OleContainerWord.OLEObjectInterface.QueryInterface (IDataObject, aDataObject);
// IDataObject der Quelle ok ?
if aDataObject = nil then
Abort;
// cfFormat-Wert fuer den RTF-Inhalt des Word-Dokuments ermitteln
OleCheck(aDataObject.EnumFormatEtc(DATADIR_GET, aEnumFmt));
while (not bFmtFound) and
(aEnumFmt.Next(1, aFormatEtc, nil) = S_OK) do
begin
pFmtName := AllocMem(RTF_NAME_MAX + 1);
GetClipBoardFormatName(aFormatEtc.cfFormat, pFmtName, RTF_NAME_MAX);
if (String(pFmtName) = RTF_NAME) then
bFmtFound := True;
FreeMem(pFmtName);
end;
if not bFmtFound then
Abort;
OleCheck(aDataObject.GetData(aFormatEtc, aMedium));
// RTF-Format wird ueber einen globalen Puffer uebergeben
pRTFData := GlobalLock(aMedium.hglobal);
try
AssignFile(OutputFile, SaveDialog1.Filename);
// Datei neu erstellen oder ueberschreiben
ReWrite(OutputFile);
try
WriteLn(OutputFile, pRTFData);
finally
CloseFile(OutputFile);
end;
finally
GlobalUnlock(aMedium.hglobal);
end;
end;

end.

</pre>
Das Datenmodul:

<pre>

{ ************************************************** **************
Source File Name : WordOLETestDM.pas
Typ : Datenmodul
Autor : Andreas Kosch
Erstellt am : 31.01.1998
Compiler : Delphi 3.02 / Delphi 4.02
Betriebssystem : Windows 95
Revisionen : 12.09.1999 Delphi 4 UpdatePack#3 + Word2000
************************************************** ************** }

unit WordOLETestDM;

interface

uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms,
Dialogs, DB, DBTables;

type
TDM = class(TDataModule)
TableWordOLE: TTable;
TableWordOLERecNr: TAutoIncField;
TableWordOLEDocName: TStringField;
TableWordOLEDocData: TBlobField;
DataSourceWordOLE: TDataSource;
procedure DataSourceWordOLEDataChange(Sender: TObject; Field: TField);
procedure TableWordOLEBeforePost(DataSet: TDataSet);
procedure TableWordOLENewRecord(DataSet: TDataSet);
private
{ Private-Deklarationen }
procedure ReadDocData;
procedure WriteDocData;
procedure WriteRTFDataFile;
public
{ Public-Deklarationen }
procedure ActivateContainer;
end;

var
DM: TDM;

implementation

{$R *.DFM}

uses WordOLETestFrm, COMObj, ZLib;

const
ZLibBufferSize = 4096; // ZLib
wdGoToBookmark = -1;
wdGoToLine = 3;
wdGoToRelative = 2;

var
ZLibBuffer: array[0..ZLibBufferSize - 1] of Byte;

resourcestring
cDocPath = 'C:\temp\test.doc';
cRTFPath = 'C:\temp\test.rtf';
cMsgStatus = '%d Bytes zu %d Bytes komprimiert.' + #13 +
'Komprimierte Daten: %d %% der Originalgroesse';

(* Ereignisbehandlungsmethode fuer OnDateChange reagiert auf
3 Bedingungen:
a) Tabelle noch nicht aktiv -> Exit
b) Benutzer waehlt einen anderen Datensatz aus -> ReadDocData
c) Benutzer editiert einen Datensatz -> Word aktivieren *)

procedure TDM.DataSourceWordOLEDataChange(Sender: TObject; Field: TField);
begin
with TableWordOLE do begin
// Sicherheitsabfrage
if not Active then exit;
// Datensatz wird eingelesen
if State = dsBrowse
// Dokumentinhalt aus der Datenbank einlesen
then ReadDocData;
// Datensatz wird editiert
if State = dsEdit
// Word (Menuepunkt/Toolbar) aktivieren
then FormMain.OleContainerWord.DoVerb(1);
end;
end;

(* Immer dann, wenn ein neuer Datensatz eingefuegt werden soll,
oeffnet der OLEContainer die Dokument-Vorlage, in der die
Rohfassung des Dokuments steht. Anschliessend kann das
Programm einige Server-Befehle ueber &#187DoVerb&#171 ausfuehren,
wobei zur Information die gerade verfuegbaren Befehle in die
TMemo-Instanz im Programmfenster geschrieben werden. *)

procedure TDM.TableWordOLENewRecord(DataSet: TDataSet);
var
aDoc : OLEVariant;
iCnt : Integer;
begin
TableWordOLEDocName.Value := 'Neu (unbenannt)';
// OLEContainer fuellen
FormMain.OLEContainerWord.CreateObjectFromFile(cDo cPath,False);
// Befehl "Bearbeiten" ausfuehren
FormMain.OLEContainerWord.DoVerb(1);
// zur Demonstration alle Befehle auflisten
with FormMain, MemoVerb.Lines do begin
Clear;
AddStrings(OLEContainerWord.ObjectVerbs);
end;
// im Dokument koennen via VBA-Objekt Daten eingesetzt werden
aDoc := FormMain.OLEContainerWord.OLEObject;
try
// fiktive Daten in formatierter Form schreiben
WriteRTFDataFile;
// Inhalt der RTF-Datei an die Cursorposition einfuegen
aDoc.Range.InsertFile(cRTFPath);
aDoc.Paragraphs.Add;
aDoc.Range.InsertAfter(Format('Daten vom %s.',[DateTimeToStr(Now)]));
for iCnt := 1 to 4 do
aDoc.Paragraphs.Add;
aDoc.Range.InsertAfter('Unterschrift');
except
MessageBeep($FFFFFFFF);
end;
end;

(* Immer dann, wenn die Tabelle in den Editier-Modus geschaltet
wurde, aktiviert das Programm Word im OLEContainer. Der Anwender
kann somit AEnderungen im Dokument vornehmen. Aus diesem Grund
schreibt das Programm den Dokumentinhalt in der Ereignis-
behandlungsmethode &#187BeforePost&#171 in die Datenbank zurueck. *)

procedure TDM.TableWordOLEBeforePost(DataSet: TDataSet);
begin
WriteDocData;
end;

{-----------------------------------------------------------}
{ Private Methoden }
{-----------------------------------------------------------}

(* Der Dokumentinhalt soll aus der Datenbank eingelesen werden.
Dazu wird eine temp. Stream-Instanz angelegt und mit dem
Inhalt aus der Datenbank gefuellt. Anschliessend laedt der
OLEContainer den Dokumentinhalt aus diesem Stream aus.

TableWordOLEDocData = persistentes TField-Objekt fuer die
Tabellenspalte "DocData" *)

procedure TDM.ReadDocData;
var
//aBS : TBlobStream;
InData : TBlobStream; // TFileStream fuer Dateiinhalt
OutData : TStream; // Ziel fuer die Komprimierung
ZStream : TCustomZLibStream; // Kompressor
iCount : Integer;
begin
InData := TBlobStream.Create(TableWordOLEDocData, bmRead);
// wurden Daten aus dem Blob-Feld gelesen ?
if InData.Size = 0 then begin
InData.Free;
Assert(InData.Size = 0, 'InData-Stream ist leer');
Exit;
end;
// Blob-Daten sind vorhanden -> los geht's
try
// UEbergabepuffer anlegen
OutData := TMemoryStream.Create;
try
// komprimierte Blob-Daten entkomprimieren
ZStream := TDecompressionStream.Create(InData);
try
// in 4096-Byte Haeppchen in die Datei schreiben
while True do begin
iCount := ZStream.Read(ZLibBuffer, ZLibBufferSize);
if iCount <> 0
then OutData.WriteBuffer(ZLibBuffer,iCount)
else Break;
end;
finally
// Free -> Buffer wird geleert
ZStream.Free;
// es sind Daten im Stream -> in den Container uebernehmen
OutData.Position := 0;
FormMain.OleContainerWord.LoadFromStream(OutData);
end;
finally
OutData.Free;
end;
finally
InData.Free;
end;
end;

(* Der Dokumentinhalt soll in die Datenbank geschrieben werden.
Dazu wird eine temp. Stream-Instanz angelegt und mit dem
Inhalt aus dem OLEContainer gefuellt. Anschliessend laedt der
OLEContainer den Dokumentinhalt aus diesem Stream aus.

TableWordOLEDocData = persistentes TField-Objekt fuer die
Tabellenspalte "DocData" *)

procedure TDM.WriteDocData;
var
InData : TStream; // TFileStream fuer Dateiinhalt
OutData : TBlobStream; // Ziel fuer die Komprimierung
ZStream : TCustomZLibStream; // Kompressor
iReadByte, // Hilfsvariable Statistik
iWriteByte: Integer; // Hilfsvariable Statistik
begin
iReadByte := 0;
iWriteByte := 0;
with TableWordOLE do begin
// Zwischenpuffer fuer die originalen (unkomprimierten) Daten
InData := TMemoryStream.Create;
try
// Ziel fuer die komprimierten Daten
OutData := TBlobStream.Create(TableWordOLEDocData, bmWrite);
try
// ZLIB-Komprimierer verwendet die schnellste Methode
ZStream := TCompressionStream.Create(clFastest, OutData);
try
// originale Daten in den Zwischenpuffer ablegen
FormMain.OLEContainerWord.SaveToStream(InData);
// originale Datengroesse sichern
Inc(iReadByte, InData.Size);
// Daten komprimieren -> stehen danach in OutData
ZStream.CopyFrom(InData, 0);
// Container deaktivieren
FormMain.OLEContainerWord.Close;
TableWordOLEDocName.Value := 'Gespeichert';
finally
// erst nach Free wird der Buffer geleert !
ZStream.Free;
// Daten sind in OutData -> Groesse sichern
Inc(iWriteByte, OutData.Size);
end;
finally
OutData.Free;
end;
finally
InData.Free;
end;
end;
// Komprimierungsergebnis in der Statuszeile anzeigen
FormMain.StatBar.SimpleText := Format(cMsgStatus,
[iReadByte,iWriteByte,
(iWriteByte * 100) div iReadByte]);
end;

(* Diese RTF-Sequenzen wurden visuell (via WordPad) zusammengestellt
und als RTF-Datei gespeichert. Wird die RTF-Datei anschliessend
mit NotePad geoeffnet, liegen die RTF-Steuerzeichen als normaler
ASCII-Text vor und koennen via Zwischenablage in das eigene
Programm uebernommen werden. *)

resourcestring
cRTF_1 = '{\rtf1\ansi\deff0\deftab720{\font tbl{\f0\fswiss\fprq2 Arial;}}';
cRTF_2 = '{\colortbl\red0\green0\blue0;}';
cRTF_3 = '\deflang1031\pard\tx284\tx4260\tx 6532\tx7668\' +
'tx8804\plain\f0\fs18';
cRTF_4 = '\par }';
cData = '\par\plain\f4\fs18\b %d.\tab %s\plain\f4\fs18\tab %s';

procedure TDM.WriteRTFDataFile;
var
iCnt : Integer;
OutputFile : TextFile;
begin
AssignFile(OutputFile, cRTFPath);
// Datei neu erstellen oder ueberschreiben
ReWrite(OutputFile);
try
WriteLn(OutputFile, cRTF_1);
WriteLn(OutputFile, cRTF_2);
WriteLn(OutputFile, cRTF_3);
// irgendwelche fiktive Daten schreiben
for iCnt := 1 to 10 do begin
WriteLn(OutputFile, Format(cData,[iCnt,'Thema:','Referent:']));
end;
WriteLn(OutputFile, cRTF_4);
finally
CloseFile(OutputFile);
end;
end;

procedure TDM.ActivateContainer;
begin
if TableWordOLE.State = dsEdit then
FormMain.OleContainerWord.DoVerb(1);
end;

end.

</pre&gt

**Bernd Schulz** · 24.06.2003, 13:24

Hallo! 
Ich wei� Andreas ist immer sehr uneigenn�tzig, aber das angegebene Buch sollte man definitiv im Schrank stehen haben! 
 
Bei Excel ist im Unterschied zu Word folgendes zu beachten: 
Nicht das RTF Format verwenden, da dabei nur die "sichtbaren" Inhalte, aber nicht Formeln etc. gelesen werden. Stattdessen "Native" als Format verwenden. Die Gr��e des Buffers l��t sich dann NUR mit GlobalSize(aMedium.hglobal) bestimmen. 
BYE BERN

Announcement

Word/Excel Dokumente/Sheets in Datenbank speichern

Word/Excel Dokumente/Sheets in Datenbank speichern

Comment

Comment

Comment

Comment