{"id":55001433,"date":"2023-06-01T00:00:00","date_gmt":"2023-06-17T09:26:55","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=1433"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Bilder_per_COMAddIn_hinzufuegen","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/Bilder_per_COMAddIn_hinzufuegen\/","title":{"rendered":"Bilder per COM-Add-In hinzufügen"},"content":{"rendered":"

\"\"<\/p>\n

Im Beitrag „Bilder für Buttons und Co. schnell hinzufügen“ haben wir eine Prozedur und eine Funktion vorgestellt, mit der Sie mehrere Bilder für die Anzeige in Schaltflächen et cetera gleichzeitig zu einer Access-Datenbank hinzufügen können. Allerdings ist es unpraktisch, eine solche Funktion in jede Datenbank kopieren zu müssen, in der wir sie sehen wollen. Also bauen wir uns ein COM-Add-In, mit dem wir nicht eine weitere Schaltfläche mit der neuen Funktion zum Ribbon hinzufügen – sondern gleich die vorhandene Schaltfläche mit der neuen Funktion belegen! Der Benutzer braucht sich also gar nicht umzugewöhnen und kann wie gewohnt Bilder zur Anwendung hinzufügen.<\/b><\/p>\n

Hinweis<\/h2>\n

Die hier verwendete Entwicklungsumgebung twinBASIC <\/b>ist für die Erstellung von DLLs für 32-Bit-Office kostenlos, bei der 64-Bit-Version wird ein Splash-Screen eingeblendet.<\/p>\n

Die 64-Bit-Version kann unter folgendem Link erworben werden (in einer Zeile):<\/p>\n

https:\/\/shop.minhorst.com\/access-tools\/364\/twinbasic-professional-edition-jahreslizenz?c=78<\/pre>\n
Der Download enthält jedoch die 64-Bit-DLL zum Einsatz auf Ihrem System inklusive Setup.<\/p>\n
Ausgangssituation<\/h2>\n
Wenn wir wie in Bild 1 auf den Ribbonbefehl Durchsuchen…<\/b> klicken, erscheint ein Dateiauswahldialog, mit dem allerdings nur eine Bilddatei gleichzeitig ausgewählt werden kann. Im Beitrag Bilder für Buttons und Co. schnell hinzufügen <\/b>(www.access-im-unternehmen.de\/1436<\/b>) haben wir eine Funktion vorgestellt, mit der wir auf die gleiche Weise mehrere Bilddateien zur Datenbank und somit zur Tabelle MSysResources <\/b>hinzufügen können.<\/p>\n
\"Hinzufügen<\/p>\n
Bild 1: Hinzufügen eines Bildes als Inhalt eines Bildsteuerelements oder für andere Belange<\/span><\/b><\/p>\n
Funktion per Ribbonanpassung „überschreiben“<\/h2>\n
Diese Funktion wollen wir nun so in Access integrieren, dass sie durch Anklicken der Schaltfläche Durchsuchen… <\/b>statt der eingebauten Funktion ausgelöst wird. Das können wir durch eine entsprechende Ribbon-Definition erreichen, in der wir in einem command<\/b>-Element einen Verweis auf das entsprechende Steuerelement und einen Aufruf einer alternativen Prozedur angeben.<\/p>\n
Die Ribbon-Definition sieht wie folgt aus:<\/p>\n
<customUI xmlns=\"http:\/\/schemas.microsoft.com\/ office\/2006\/01\/customui\">\r\n   <commands>\r\n     <command onAction=\"onAction\" idMso=\"SharedImageBrowse\"\/>\r\n   <\/commands>\r\n<\/customUI><\/pre>\n
Die hier angegebene Prozedur für das Attribut onAction<\/b> können wir wie folgt definieren:<\/p>\n
Public Sub <\/span>OnAction(control As <\/span>IRibbonControl, _\r\n         ByRef CancelDefault)\r\n     BilderImportieren True<\/span>\r\nEnd Sub<\/span><\/pre>\n
Diese ruft die Prozedur BilderImportieren <\/b>auf, die wir im oben genannten Beitrag beschrieben haben.<\/p>\n
Wenn wir diese Ribbondefinition in der Anwendung unterbringen, zum Beispiel für ein Formular oder als Anwendungsribbon, steht die Funktion zwar zur Verfügung und überschreibt auch die eingebaute Funktion des Ribbon-Steuerelements, aber diese hilft uns dann auch nur in der aktuellen Anwendung weiter. Und wer sucht schon in den eingebauten Steuerelementen des Ribbons nach benutzerdefinierten Funktionen? Deshalb machen wir es einen Schritt professioneller und bauen die Funktion in ein COM-Add-In ein, das die Funktion fortan in jeder Access-Instanz zur Verfügung stellt – egal, welche Anwendung wir darin geöffnet haben.<\/p>\n
Einbau in ein COM-Add-In<\/h2>\n
Den Einbau der beiden Routinen aus dem oben genannten Artikel in ein COM-Add-In beziehungsweise dessen Erstellung erfolgt mit dem Tool twinBASIC<\/b>, das wir schon in einigen Beiträgen erwähnt haben. Interessant als Zusatzinformation zu dem, was Sie im vorliegenden Beitrag lesen, dürfte der Beitrag twinBASIC – COM-Add-Ins für Access <\/b>(www.access-im-unternehmen.de\/1306<\/b>) sein.<\/p>\n
Download und Installation von twinBASIC<\/h2>\n
Da twinBASIC mittlerweile eine andere Plattform als Entwicklungsumgebung verwendet, weisen wir nochmal auf den Download und die Installation hin.<\/p>\n
Der Download der jeweils neuesten Version erfolgt über diesen Link:<\/p>\n
https:\/\/github.com\/twinbasic\/twinbasic\/releases<\/pre>\n
Hier erweitern Sie für die gewünschte Version den Bereich Assets (siehe Bild 2) und laden die Datei herunter, beispielsweise twinBASIC_IDE_BETA_277.zip<\/b>.<\/p>\n
\"Download<\/p>\n
Bild 2: Download der twinBASIC-Entwicklungsumgebung<\/span><\/b><\/p>\n
Anschließend stellen Sie die Option Zulassen <\/b>für die heruntergeladene Datei auf Ja <\/b>ein (siehe Bild 3). Die Eigenschaft finden Sie im Eigenschaften<\/b>-Dialog der Datei, den Sie mit dem entsprechenden Kontextmenü-Befehl öffnen.<\/p>\n
\"Aktivieren<\/p>\n
Bild 3: Aktivieren der Sicherheit der Zip-Datei<\/span><\/b><\/p>\n
Danach extrahieren Sie die in der Zip-Datei enthaltenen Dateien in ein Verzeichnis Ihrer Wahl.<\/p>\n
Anschließend können Sie durch einen Doppelklick auf die Datei twinBASIC.exe<\/b> direkt mit der Anwendung arbeiten – es ist keine Installation nötig.<\/p>\n
Neues COM-Add-In anlegen<\/h2>\n
Wir legen nach dem Start von twinBASIC dort ein neues Projekt auf Basis der Vorlage Sample 5. MyCOMAddin <\/b>an, das auf der Seite Samples <\/b>der Startseite von twinBASIC <\/b>angezeigt wird.<\/p>\n
Dieses Projekt enthält alles, was man für das Erstellen eines eigenen COM-Add-Ins braucht – angefangen von einer Ribbon-Anpassung mit einem individuellen tab<\/b>-Element plus Button, der die ebenfalls integrierte Prozedur auslöst.<\/p>\n
Wir wollen unser Projekt amvAddPictures <\/b>benennen und auch die einzige Klasse des Projekts erhält diesen Namen. Der eindeutige Klassen-Identifizierer wurde von twinBASIC automatisch vergeben. Die Klasse implementiert zwei Schnittstellen, nämlich IDTExtensibility2 <\/b>und IRibbonExtensibility<\/b>:<\/p>\n
[ ClassId (\"061EF79E-7E28-4BF7-870F-01AF336670CD\") ]\r\nClass<\/span> amvAddPictures\r\n     Implements IDTExtensibility2\r\n     [ WithDispatchForwarding ]\r\n     Implements IRibbonExtensibility\r\n     ... mehr Code\r\nEnd Class<\/span><\/pre>\n
Implementieren der Schnittstelle IDTExtensibility2<\/h2>\n
Die Schnittstelle IDTExtensibility2 <\/b>gibt die Methoden vor, die zu verschiedenen Ereignissen beim Öffnen, Schließen et cetera der Access-Anwendung ausgeführt werden. Uns interessiert nur eine davon, nämlich OnConnection<\/b>. Diese wird nämlich genau dann ausgelöst, wenn der Benutzer eine Access-Instanz öffnet und liefert einige interessante Parameter. Auch hier interessiert uns nur einer, nämlich Application<\/b>. Dieser liefert einen Verweis auf die aufrufende Anwendung, in diesem Fall Access.Application<\/b>. Da die Funktionen eines COM-Add-Ins meist auf die aktuelle Access-Instanz zugreifen sollen, speichern wir den Verweis auf diese Instanz in einer Objektvariablen, die wir wie folgt deklarieren:<\/p>\n
Private <\/span>objAccess As <\/span>Access.Application<\/pre>\n
Für die Verwendung dieser Klasse benötigen wir, ähnlich wie im VBA-Editor beim Zugriff auf die Objekte anderer Bibliotheken, einen Verweis.<\/p>\n
Diesen fügen wir über die Projekteigenschaften hinzu, die wir über den Eintrag Settings <\/b>im Projektexplorer öffnen können. Hier scrollen wir zum Bereich COM Type Library \/ ActiveX References<\/b>, wo wir im unteren Feld nach Access <\/b>suchen und den gewünschten Eintrag anhaken (siehe Bild 4). Damit diese Änderung wirksam wird, müssen wir das Projekt speichern, schließen und erneut öffnen.<\/p>\n
\"Verweis<\/p>\n
Bild 4: Verweis auf die Access-Bibliothek hinzufügen<\/span><\/b><\/p>\n
Schnittstellen implementieren<\/h2>\n
Die Methoden der Schnittstelle implementieren wir darunter wie in Listing 1. Wir bilden hier auch die weiteren, nicht mit Anweisungen gefüllten Methoden ab, da diese auf jeden Fall im Projekt implementiert werden müssen.<\/p>\n
Sub <\/span>OnConnection(ByVal Application As Object<\/span>, ByVal ConnectMode As <\/span>ext_ConnectMode, ByVal AddInInst As Object<\/span>, _\r\n         ByRef custom As Variant<\/span>()) Implements IDTExtensibility2.OnConnection\r\n     Set<\/span> objAccess = Application\r\nEnd Sub<\/span>\r\n     \r\nSub <\/span>OnDisconnection(ByVal RemoveMode As <\/span>ext_DisconnectMode, ByRef custom As Variant<\/span>()) _\r\n         Implements IDTExtensibility2.OnDisconnection\r\nEnd Sub<\/span>\r\n     \r\nSub <\/span>OnAddInsUpdate(ByRef custom As Variant<\/span>()) Implements IDTExtensibility2.OnAddInsUpdate\r\nEnd Sub<\/span>\r\n     \r\nSub <\/span>OnStartupComplete(ByRef custom As Variant<\/span>()) Implements IDTExtensibility2.OnStartupComplete\r\nEnd Sub<\/span>\r\n     \r\nSub <\/span>OnBeginShutdown(ByRef custom As Variant<\/span>()) Implements IDTExtensibility2.OnBeginShutdown\r\nEnd Sub<\/span><\/pre>\n
[<\/p>\n
Listing 1: Implementierung der Methoden der Schnittstelle IDTExtensibility2<\/span><\/b><\/p>\n
Implementierung der Schnittstelle IRibbonExtensibility<\/h2>\n
Die zweite Schnittstelle erlaubt das Implementieren einer Funktion, die ebenfalls beim Start von Access ausgelöst wird und die es uns ermöglicht, eine Ribbon-Definition zurückzugeben, die dann von Access angewendet wird. Das einzige Element dieser Schnittstelle haben wir in Listing 2 abgebildet. Hier stellen wir die oben beschriebene Anpassung des Ribbons in der Variablen strXML <\/b>zusammen und geben diese als Funktionsergebnis zurück.<\/p>\n
Private Function <\/span>GetCustomUI(ByVal RibbonID As String<\/span>) As String<\/span> Implements IRibbonExtensibility.GetCustomUI\r\n     Dim <\/span>strXML As String<\/span>\r\n     strXML &= \"<customUI xmlns=\"\"http:\/\/schemas.microsoft.com\/office\/2006\/01\/customui\"\">\" & vbCrLf<\/span>\r\n     strXML &= \"  <commands><command onAction=\"\"onAction\"\" idMso=\"\"SharedImageBrowse\"\"\/><\/commands>\"\r\n     strXML &= \"<\/customUI>\" & vbCrLf<\/span>\r\n     Return strXML\r\nEnd Function<\/span>        <\/pre>\n
Listing 2: Die Funktion, die eine Ribbondefinition entgegennimmt<\/span><\/b><\/p>\n
Diese sorgt, wie bereits beschrieben, nicht für das Hinzufügen eines neuen Elements zum Ribbon, sondern sie legt fest, dass beim Anklicken der Schaltfläche Bild einfügen <\/b>die mit dem Attribut onAction <\/b>angegebene Prozedur ausgeführt wird.<\/p>\n
Diese Prozedur hinterlegen wir in der Klasse wie folgt:<\/p>\n
Public Sub <\/span>OnAction(control As <\/span>IRibbonControl, _\r\n         ByRef CancelDefault)\r\n     BilderImportieren True<\/span>\r\nEnd Sub<\/span><\/pre>\n
Hier rufen wir vor allem die Prozedur BilderImportieren<\/b> auf, der wir den Wert True <\/b>für den Parameter bolBeiVorhandenNummerieren <\/b>zuweisen. Diesen Parameter kann man auch auf False einstellen, aber in diesem Fall haben wir uns dafür entschieden, die von Access standardmäßig vorgegebene Verhaltensweise nachzubauen.<\/p>\n
Die Prozedur onAction <\/b>enthält zwei Parameter. Der erste namens control liefert einen Verweis auf das auslösende Steuerelement. Da das COM-Add-In nur ein Steuerelement im Ribbon abbilden soll, werten wir diesen Parameter nicht aus. Der zweite Parameter heißt CancelDefault <\/b>und nimmt einen Boolean<\/b>-Wert entgegen, der angibt, ob die eingebaute Funktion des Steuerelements ebenfalls ausgeführt werden soll. Das ist hier nicht der Fall – sonst würden zwei Dateiauswahl-Dialoge nacheinander angezeigt werden. Da der Standardwert dieses Parameters True <\/b>lautet, brauchen wir diesen nicht zu ändern.<\/p>\n
Wichtig bei der Definition des Parameters CancelDefault <\/b>ist, dass wir diesen nicht mit einem Datentyp versehen – beispielsweise Boolean<\/b> -, auch wenn er ohne Datentyp im Editor markiert wird. Damit würde das COM-Add-In nicht funktionieren.<\/p>\n
Das Importieren der Bilder<\/h2>\n
Die Prozedur BilderImportieren<\/b>, die wir bereits im Beitrag Bilder für Buttons und Co. schnell hinzufügen <\/b>(www.access-im-unternehmen.de\/1436<\/b>) vorgestellt haben, müssen wir an einer Stelle anpassen. Dazu stellen wir der in der Zeile, in der wir die Variable objFiledialog <\/b>füllen, der FileDialog<\/b>-Klasse die Objektvariable objAccess<\/b> voran (siehe Zeile 04 in Listing 3).<\/p>\n
01  Public Sub BilderImportieren(Optional<\/span> bolBeiVorhandenNummerieren As Boolean<\/span>)\r\n02      Dim objFiledialog As <\/span>Office.FileDialog\r\n03      Dim varBildpfad As Variant<\/span>\r\n04      Set<\/span> objFiledialog = <b>objAccess.<\/b>FileDialog(msoFileDialogFilePicker)\r\n05      With<\/span> objFiledialog\r\n06          .AllowMultiSelect = True<\/span>\r\n07          .Filters.Clear\r\n08          .Filters.Add \"Bilddatei (*.png)\", \"*.png\"\r\n09          .Filters.Add \"Alle Dateien (*.*)\", \"*.*\"\r\n10          If .Show = True<\/span> Then\r\n11            For Each varBildpfad In .SelectedItems\r\n12                  BildImportieren CStr(varBildpfad), bolBeiVorhandenNummerieren\r\n13              Next<\/span> varBildpfad\r\n14          Else\r\n15              Debug.Print<\/span> \"Keine Datei ausgewählt\"\r\n16         End If\r\n17      End With<\/span>\r\n18  End Sub        <\/pre>\n
Listing 3: Prozedur zum Importieren von Bildern<\/span><\/b><\/p>\n
Das ist notwendig, damit wir die FileDialog<\/b>-Klasse im Kontext der aktuellen Access-Anwendung öffnen und das Ergebnis auch von dieser verarbeitet wird.<\/p>\n
In der Funktion BildImportieren<\/b>, die eines der gewählten Bilder in die Datenbank importiert, sind ein paar weitere Änderungen nötig (siehe Listing 4). In Zeile 07 verwenden wir die Klasse DLookup <\/b>des Objekts objAccess<\/b>, um auf die Daten dieser Datenbank zuzugreifen. Auch die folgende Zeile 08 verwendet das CurrentProject<\/b>-Objekt von objAccess<\/b>. Gleiches gilt wieder für Zeile 14 und 18 bei der DLookup<\/b>-Funktion.<\/p>\n
01  Public Function BildImportieren(strBildpfad As String<\/span>, Optional<\/span> bolBeiVorhandenNummerieren As Boolean<\/span>) As Boolean<\/span>\r\n02      Dim strBildname As String<\/span>\r\n03      Dim strBildnameNummeriert As String<\/span>\r\n04      Dim intNummer As Integer<\/span>\r\n05      strBildname = Mid<\/span>(strBildpfad, InStrRev<\/span>(strBildpfad, \"\\\") + 1)\r\n06      strBildname = Left<\/span>(strBildname, InStrRev<\/span>(strBildname, \".\") - 1)\r\n07      If IsNull(objAccess.DLookup(\"id\", \"MSysResources\", \"name = ''\" & strBildname & \"''\")) Then\r\n08          objAccess.CurrentProject.AddSharedImage strBildname, strBildpfad\r\n09          BildImportieren = True<\/span>\r\n10      Else\r\n11          If bolBeiVorhandenNummerieren Then\r\n12              intNummer = 1\r\n13              strBildnameNummeriert = intNummer & \"_\" & strBildname\r\n14              Do While Not<\/span> IsNull(objAccess.DLookup(\"id\", \"MSysResources\", \"name = ''\" & strBildnameNummeriert & \"''\"))\r\n15                  intNummer = intNummer + 1\r\n16                  strBildnameNummeriert = intNummer & \"_\" & strBildname\r\n17              Loop<\/span>\r\n18              objAccess.CurrentProject.AddSharedImage strBildnameNummeriert, strBildpfad\r\n19              BildImportieren = True<\/span>\r\n20          Else\r\n21              MsgBox<\/span> \"Das Bild ''\" & strBildname & \"'' wurde nicht importiert.\"\r\n22          End If\r\n23      End If\r\n24  End Function<\/pre>\n
Listing 4: Funktion zum Importieren eines einzelnen Bildes<\/span><\/b><\/p>\n
Damit ist der Code der Klasse amvAddPictures <\/b>vollständig.<\/p>\n
Registrierungscode anpassen<\/h2>\n
Wir nehmen nun noch einige weitere Änderungen am Projekt vor, damit die COM-DLL zum Testen vernünftig registriert werden kann. Das betrifft zuerst die Datei DLLRegistration.twin<\/b>.<\/p>\n
Hier entfernen wir gegenüber der Version, die wir durch das Beispielprojekt erstellt haben, die Zeilen, die für das Registrieren als DLL von Excel nötig sind. Außerdem stellen wir den Namen in der Konstanten AddinClassName <\/b>in amvAddPictures <\/b>um (siehe Listing 5).<\/p>\n
Module DllRegistration\r\n     \r\n     Const AddinProjectName As String<\/span> = VBA.Compilation.CurrentProjectName\r\n     Const AddinClassName As String<\/span> = \"amvAddPictures\"\r\n     Const AddinQualifiedClassName As String<\/span> = AddinProjectName & \".\" & AddinClassName\r\n     Const RootRegistryFolder_ACCESS As String<\/span> = \"HKCU\\SOFTWARE\\Microsoft\\Office\\Access\\Addins\\\" _\r\n         & AddinQualifiedClassName & \"\\\"\r\n     Public <\/span>Function DllRegisterServer() As Boolean<\/span>\r\n         On Error GoTo<\/span> RegError\r\n         Dim <\/span>wscript As Object<\/span> = CreateObject(\"wscript.shell\")\r\n         wscript.RegWrite RootRegistryFolder_ACCESS & \"FriendlyName\", AddinProjectName, \"REG_SZ\"\r\n         wscript.RegWrite RootRegistryFolder_ACCESS & \"Description\", AddinProjectName, \"REG_SZ\"\r\n         wscript.RegWrite RootRegistryFolder_ACCESS & \"LoadBehavior\", 3, \"REG_DWORD\"\r\n         Return True<\/span>\r\n     RegError:\r\n         MsgBox<\/span> \"DllRegisterServer -- An error occured trying to write to the system registry:\" & vbCrLf<\/span> & _\r\n                 Err.Description & \" (\" & Hex(Err.Number) & \")\"\r\n         Return False<\/span>\r\n     End Function\r\n  \r\n     Public <\/span>Function DllUnregisterServer() As Boolean<\/span>\r\n         On Error GoTo<\/span> RegError\r\n         Dim <\/span>wscript As Object<\/span> = CreateObject(\"wscript.shell\")\r\n         wscript.RegDelete RootRegistryFolder_ACCESS & \"FriendlyName\"\r\n         wscript.RegDelete RootRegistryFolder_ACCESS & \"Description\"\r\n         wscript.RegDelete RootRegistryFolder_ACCESS & \"LoadBehavior\"\r\n         wscript.RegDelete RootRegistryFolder_ACCESS\r\n         Return True<\/span>\r\n     RegError:\r\n         MsgBox<\/span> \"DllUnregisterServer -- An error occured trying to delete from the system registry:\" & vbCrLf<\/span> & _\r\n                 Err.Description & \" (\" & Hex(Err.Number) & \")\"\r\n         Return False<\/span>\r\n     End Function\r\nEnd Module     <\/pre>\n
Listing 5: Das Modul DLLRegistration<\/span><\/b><\/p>\n
Projekteinstellungen anpassen<\/h2>\n
Schließlich nehmen wir noch einige Einstellungen an den Projekteigenschaften vor. Dabei stellen wir den Projektnamen und den Anwendungstitel auf amvAddPictures<\/b> ein und fügen einen Beschreibungstext hinzu (siehe Bild 5). Nach den Änderungen muss das Projekt gespeichert und der Compiler neu gestartet werden, was im Screenshot auch als Kommentar zu erkennen ist.<\/p>\n
\"Einstellungen<\/p>\n
Bild 5: Einstellungen für das Projekt<\/span><\/b><\/p>\n
Testen des COM-Add-Ins<\/h2>\n
Nun können wir das COM-Add-In einmal kompilieren und registrieren. Das können wir alles von der twinBASIC-Entwicklungsumgebung aus erledigen, indem wir oben rechts auf die Schaltfläche Build <\/b>klicken. Dies kompiliert das Projekt in eine DLL-Datei und registriert diese gleich im Anschluss anhand der Vorgaben im Modul DllRegistration<\/b>.<\/p>\n
Wenn dies fehlerfrei durchläuft, können wir danach eine neue Access-Instanz öffnen und darin ein Formular in der Entwurfsansicht öffnen.<\/p>\n
Klicken wir nun im Bereich Steuerelemente auf den Befehl Bild einfügen <\/b>und dann unten auf Durchsuchen<\/b>, erscheint ein Dateiauswahl-Dialog, mit dem Sie nun mehrere statt nur eine Datei öffnen können.<\/p>\n
Die einzige Abweichung von der Originalfunktion ist, dass wir hiermit das ausgewählte Bild oder die ausgewählten Bilder nicht direkt in das Formular oder ein aktuell markiertes Steuerelement wie beispielsweise eine Schaltfläche einfügen.<\/p>\n
Dazu müssen wir diese noch aus der nun um die hinzugefügten Bilder erweiterten Liste der Bilder auswählen.<\/p>\n
Setup für das COM-Add-In erstellen<\/h2>\n
In weiteren Beiträgen wie beispielsweise Setup für Access: Umsetzung mit InnoSetup <\/b>(www.access-im-unternehmen.de\/1326<\/b>) haben wir bereits das kostenlose Tool Inno Setup <\/b>vorgestellt.<\/p>\n
Für die Erstellung eines Setups für ein COM-Add-In benötigen wir nur ein recht kleines Skript. Dieses finden Sie in Listing 6.<\/p>\n
#define MyAppName \"amvAddPictures\"\r\n#define MyAppVersion \"1.0.0.1\"\r\n#define MyAppPublisher \"André Minhorst\"\r\n#define MyAppURL \"http:\/\/shop.minhorst.com\"\r\n[Setup]\r\nAppId={#MyAppName}\r\nAppName={#MyAppName}\r\nAppVersion={#MyAppVersion}\r\nAppVerName={#MyAppName} v{#MyAppVersion}\r\nAppPublisher={#MyAppPublisher}\r\nAppPublisherURL={#MyAppURL}\r\nAppSupportURL={#MyAppURL}\r\nAppUpdatesURL={#MyAppURL}\r\nOutputDir=Setup\r\nOutputBaseFilename={#MyAppName}-Setup\r\nCompression=lzma\r\nSolidCompression=yes\r\nShowLanguageDialog=no\r\nLanguageDetectionMethod=none\r\nUsePreviousGroup=False<\/span>\r\nDisableProgramGroupPage=yes\r\nAppendDefaultGroupName=False<\/span>\r\nWizardStyle=modern\r\nVersionInfoVersion={#MyAppVersion}\r\nVersionInfoTextVersion={#MyAppVersion}\r\nVersionInfoProductVersion={#MyAppVersion}\r\nVersionInfoProductTextVersion={#MyAppVersion}\r\nVersionInfoCompany={#MyAppPublisher}\r\nVersionInfoProductName={#MyAppName}\r\nPrivilegesRequired=lowest\r\nDefaultDirName={localappdata}\\amvAddPictures\r\n[Languages]\r\nName: \"german\"; MessagesFile: \"compiler:Languages\\German.isl\"\r\n[Files]\r\nSource: \"Build\\amvAddPictures_win32.dll\"; DestDir: \"{app}\"; Flags: regserver  <\/pre>\n
Listing 6: Das Skript zum Erstellen eines Setups für die COM-Dll<\/span><\/b><\/p>\n
Das Skript enthält einige Standardeinstellungen, die wir in einem weiteren Beitrag in einer der kommenden Ausgaben erläutern. Die wichtigsten sind die Einstellungen für die Konstanten im oberen Bereich, von denen wir in den folgenden Zeilen regen Gebrauch machen.<\/p>\n
Wichtig ist die Angabe des Parameters OutputDir<\/b>, wo wir das Verzeichnis relativ zum Verzeichnis der .iss<\/b>-Datei angeben, in dem die Setup-Datei erstellt werden soll.<\/p>\n
Weiter unten für den Parameter DefaultDirName <\/b>geben wir das Verzeichnis an, in dem das Setup die zu installierenden Daten speichern soll. Der Platzhalter {localappdata} <\/b>steht beispielsweise für den Ordner c:\\Users\\[Benutzername]\\AppData\\Local\\<\/b>, diesem fügen wir noch das Verzeichnis amvAddPictures<\/b> hinzu.<\/p>\n
Schließlich ist der einzige Eintrag im Bereich Files <\/b>wichtig. Dieser gibt an, welche Datei zum Setup hinzugefügt werden soll, wo diese landen soll und welche zusätzlichen Optionen es gibt. Mit DestDir <\/b>und dem Wert {app} <\/b>geben wir an, dass die Datei in dem vom Benutzer im Setup ausgewählten Verzeichnis gespeichert werden soll. Der Parameter Flags <\/b>legt mit dem Wert regserver <\/b>fest, dass die Datei mit der Anwendung RegSvr32.exe <\/b>registriert werden soll.<\/p>\n
Haben wir alle Daten für das Setup in dem Skript zusammengetragen, bieten sich zwei interessante Optionen:<\/p>\n