CreateOleObject('Word.Application') - Dotx öffnen aber docx bekommen, wie?

[Piro]

Moin zusammen,

ich habe ein Datei vorlage.dotx, welche ich öffne und mit Daten fülle.
Diese Vorlage ist schreibgeschützt. Der Schreibschutz wird deaktiviert, beim Füllen der Daten.

Das klappt auch alles super. Hier der Code

Delphi-Quellcode:

const
 wdAllowOnlyFormFields = $00000002; // http://www.delphigroups.info/2/d4/455196.html
..
try
   {Verbindung aufbauen}
   Word:=CreateOleObject('Word.Application');
 except
   {Schlägt sie fehl (Word nicht installiert), gibt es eine Fehlermeldung}
   ShowMessage('Microsoft Word kann nicht starten.');
   Screen.Cursor:=crDefault;
   Exit;
 end;

 word.visible:=true;
 word.Documents.Open(doc); // doc = vorlagen.dotx

try
   word.ActiveDocument.Unprotect;

   if word.ActiveDocument.Bookmarks.Exists('Titel') then
   begin
     r := word.ActiveDocument.Bookmarks.Item('Titel').Range;
     r.InsertAfter(lbl_titel.Caption);
   end;

   if word.ActiveDocument.Bookmarks.Exists('Beschreibung') then
   begin
     r := word.ActiveDocument.Bookmarks.Item('Beschreibung').Range;
     r.InsertAfter(edt_beschreibung.Text);
   end;

   word.ActiveDocument.Protect(wdAllowOnlyFormFields);
 finally
   word:=unassigned;
 end;

Leider wird nicht ein docx Dokument geöffnet sondern, dass dotx Dokument und wenn man nicht aufpasst und speichert, werden die Änderungen übernommen.

Starte ich aber das dotx Dokument, macht Word ein docx Dokument auf.

Welcher Schalter fehlt mir, damit das Öffnen aus Delphi mit meinem Code aus der vorlagen.dotx ein document.docx macht?

Danke im Voraus.
Sven

[Jumpy]

Müsste das nicht Documents.Add sein, mit dem Namen der Vorlage als Paramter?
Denn du willst ja nicht die Vorlage öffnen sondern ein neues Dokument auf Basis der Vorlage erstellen.

[Piro]

Vielen vielen Dank.

Das war es. :-D:thumb:

Einen habe ich dann doch noch. Mit folgendem Code, öffnet Word sich mit dem dotx Dokument.

Delphi-Quellcode:

var
 doc : String;
begin
 doc := frm_main.AppPath + 'data\formulare\vorlage.dotx';
 if FileExists(doc) then
 begin
   ShellExecute(0, 'open', PChar(doc), nil, nil, SW_NORMAL );
 end;

Gibt es hier auch eine Möglichkeit, dass ein docx Dokument geöfnnet wird?

[Jumpy]

C:\Programme\Microsoft Office\OFFICE11\winword.exe Word-Datei

[Piro]

Ah ok, damit würde ich aber die Office Version vorgeben.

Das schöne mit meiner Lösung ist, dass ich das das verlinkte Office nehme zum Dateityp. Bei einem Office Wechsel,
muss ich nicht den Pfad zum Office angeben.

Oder ich mache das auch mit CreateOleObject('Word.Application') wenn es keine einfache Lösung gibt.

Aus der Registry, dass Word auslesen, wollte ich eigentlich nicht.

[Delphi.Narium]

Delphi-Quellcode:

var
 doc : String;
begin
 doc := frm_main.AppPath + 'data\formulare\dokumentenname.docx';
 if FileExists(doc) then
 begin
   ShellExecute(0, 'open', PChar(doc), nil, nil, SW_NORMAL );
 end;

[Piro]

es gibt doch nur die vorlagen.dotx Datei.

Ich möchte das diese als Vorlage geöffnet wird und Word dann ein normale docx Datei öffnet, wie in meinem vorherigen Code.

[Delphi.Narium]

Du willst also weder eine Vorlage öffnen, noch ein Dokument, sondern ein neues Dokument (anhand einer Vorlage) erstellen.

Das solltest Du auch so schreiben und Dir auch darüber klar werden, dass Du genau das möchtest.

Also ungefähr sowas:

Delphi-Quellcode:

function NeuesDokument(aWordApp : TWordApplication; aWordDoc : TWordDocument; aDot : String; aVisible : Boolean = false) : Boolean;
var
  vDOT         : OleVariant;
  vNewDOT      : OleVariant;
  vDocType     : OleVariant;
  vVisible     : OleVariant;
begin
  vDOT     := aDot; // Das ist die Vorlage, anhand der ein neues Doukment erstellt werden soll.
  vNewDOT  := False; // Wir wollen keine neue Vorlage erstellen, deshalb False.
  vVisible := aVisible; // Word soll das Ganze sichtbar machen.
  vDocType := EmptyParam; // Der Parameter muss angegeben werden, soll aber leer sein.
  try
    aWordApp.Documents.Add(vDOT, vNewDOT, vDocType, vVisible);
    aWordDoc.ConnectTo(aWordApp.ActiveDocument);
    aWordApp.ActiveWindow.ActivePane.View.type_ := wdOutlineView;
    Result := True;
  except
    on e : Exception do begin
      Result := False;
      MessageDlg(e.Message,mtError,[mbOk],0);
    end;
  end;
end;

Wenn es unbedingt ShellExcecute sein muss, schau Dir mal die Kommandozeilenparameter an: https://support.office.com/en-us/art...5-441737deb3a6

Und dann hoffe darauf, dass sie bei anderen Officeversionen (OpenOffice ...) entsprechend implementiert sind.

Denn ShellExecute und Open startet das Officepaket, dass in der Registry (für den übergebenen Dateityp) eingetragen ist (und das muss nicht das Office von MS sein).
Bei unterschiedlichen Officeversionen von MS mag das problemlos gehen, bei der Unterstützung unterschiedlicher Officepakete unterschiedlicher Hersteller, könnte es sportlich werden.

Delphi-Quellcode:

CreateOleObject('Word.Application')

nimmt das MS-Officepaket, das installiert ist. Das ist beim Wechsel der Officeversion für Dein Programm transparent. Solange an der Schnittstelle (MS-seitig) nix geändert wird, kann Dir die Officeversion auf dem "Zielrechner" (beim Kunden ...) egal sein.

[Piro]

Vielen vielen Dank.

Super Erklärung.

Ich werde auf ShellExecute verzichten.

@ Delphi.Narium
Mein Code funktioniert auch. Bin mir nur nicht sicher, ob ich lieber
deinen nehmen soll. Die Parameter beim Starten von Word sind eindeutiger.

Danke für einen kurzen Hinweis

[Jumpy]

Ich würde an deiner Stelle dann auch auf ShellExecute verzichten, denn das (Neues Dokument basierend auf Template) geht nur so, wie ich es eben gezeigt habe und dazu müsstest du immer die Office-Version wissen, wie du das ja auch angemerkt hast.

Also ist der Weg über Ole wohl der bessere, wenn wir mal davon ausgehen, dass du nur MS-Word benutzt, kein OpenOffice o.ä.

Dann kannst du es so machen, wie Delphi.Narium, wobei ich immer nie weiß, wie diese Early-Binding Varianten funktionieren, wenn ich mal eine neue oder ältere Office-Version ansprechen will, als die, womit ich das kompiliert habe. Da kann vllt. jemand anders mehr zu sagen.

Daher nehm ich da meist Late-Binding (so wie in deinem Beispiel), auch wenn das ggf. etwas lansamer ist.

[Delphi.Narium]

Du willst doch zur Laufzeit des Programmes per Wordfernsteuerung ein Dokument erstellen und mit Inhalt befüllen.

Meiner Meinung nach ist es in diesem Zusammenhang unsinnig, für die Erstellung des Dokumentes nicht die Wordfernsteuerung zu nehmen, sondern über einen anderen Weg zu versuchen (hier ShellExecute) Word zu starten und dann "irgendwie" eine Verbindung zu Word zu bekommen, mit der dann weitergearbeitet wird.

Mit Shellexecute wird nicht Word gestartet, sondern das mit dem Dateityp verbundene Programm. Das mag meist Word sein, muss es aber nicht. Wenn Du für Deine Aufgabe zwingend Word benötigst, dann starte Wort über die Schnittstelle, also

Delphi-Quellcode:

Word := CreateOleObject('Word.Application');

. Vorteil, wenn das nicht funktioniert, weißt Du sofort, dass kein Word zur Verfügung steht und musst dann nicht per ShellExecute hoffen, dass Du zufällig das "richtige" Word startest und nicht eventuell was anderes, auf das Du dann sowieso keinerlei Einfluß hast. Fände es als Anwender jedenfalls befremdlich, wenn "mein" Programm ein Dokument erstellen soll, aber irgendwie bei jedem Versuch 'ne neue Instanz von OpenOffice mit 'nem leeren Dokument startet und dann nix mehr passiert.

Die Parameter von Word sind nicht eindeutiger, es sind halt unterschiedliche Wege zum gleichen Ziel. Man muss sich für die Wordfernsteuerung halt schon mit der Schnittstelle befassen und da gehört das Erstellen eines neuen Dokumentes schon eher zu den einfachen Aufgaben.

[p80286]

Zitat:

Zitat von Piro (Beitrag 1419361)

ich habe ein Datei vorlage.dotx, welche ich öffne und mit Daten fülle.

Erstelle ein neues Dokument mit Hilfe der Vorlage und speichere es im gewünschten Format ab.
Deine Vorgehensweise wird zwar oft angewandt ist aber schlicht falsch.

Gruß
K-H

[Schokohase]

Falls sich noch jemand dafür interessiert, wie das per ShellExecute funktioniert

Delphi-Quellcode:

var
 doc : String;
begin
 doc := frm_main.AppPath + 'data\formulare\vorlage.dotx';
 if FileExists(doc) then
 begin
   ShellExecute(0, 'new', PChar(doc), nil, nil, SW_NORMAL );
 end; 
end;

• open - öffnet die Vorlage zum Bearbeiten
• new - erstellt ein Dokument auf Basis der Vorlage und öffnet dieses zum Bearbeiten

[Jumpy]

Das "new" kannte ich noch nicht, als mögliches Command für ShellExecute. Funzt das nur bei Word?

[Rollo62]

Das "new" wäre mir auch neu, wo ist das denn beschrieben ?

Hier gibts noch ein paar mehr Optionen.

Edit:
Ok, der Trick könnte sein das man es in der Registry vorher abfragen muss was geht.

[Schokohase]

Rechte Maustaste auf so eine .dotx Datei zeigt mir im Kontext-Menü Neu, Öffnen und Drucken an.
Also auf Englisch New, Open und Print.

Neugierig wie ich nun mal bin ...

[Piro]

Sorry, dass ich mich jetzt erst melde. Hatte viel um die Ohren.


Super Antworten und tolle Ansätze.

In unserer Firma haben alle Office und daher Word.

CreateOleObject ist schon der richtiger Weg und funktioniert wie gewünscht.

Das mit dem Parameter new werde ich mal versuchen.

Vielen Dank an alle. Mein Problem ist gelöst