{"id":55000344,"date":"2022-12-01T00:00:00","date_gmt":"2023-03-02T16:57:12","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=344"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"ExcelDatei_per_COMAddIn_als_xlsm_speichern","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/ExcelDatei_per_COMAddIn_als_xlsm_speichern\/","title":{"rendered":"Excel-Datei per COM-Add-In als .xlsm speichern"},"content":{"rendered":"

Wer viel mit Excel-Worksheets arbeitet und diesen regelmäßig VBA-Code hinzufügt, muss diese als .xlsm-Datei speichern, damit die Änderungen am VBA-Projekt beim Schließen nicht verlorengehen. Dazu muss man immer den Backstage-Bereich von Excel öffnen und einige Mausklicks durchführen. Wie wäre es, wenn man diese Aktion direkt im Backstage-Bereich finden würde – und nur noch einen Mausklick tätigen müsste, damit das aktuelle Excel-Worksheet nicht nur unter dem gleichen Namen und der Dateiendung .xlsm gespeichert wird, sondern auch noch die ursprüngliche .xlsx-Datei gelöscht wird? Wie das geht, zeigen wir in diesem Artikel.<\/b><\/p>\n

Vorbereitung: twinBASIC<\/h2>\n

Wie Du twinBASIC herunterlädst und installierst, haben wir im Artikel twinBASIC: Visual Basic für die Zukunft <\/b>(www.vbentwickler.de\/310<\/b>) beschrieben.<\/p>\n

COM-Add-In erstellen<\/h2>\n

Um das COM-Add-In zu erstellen, startest Du twinBASIC <\/b>und wählst im Startbildschirm unter Samples <\/b>den Eintrag Sample 5. MyCOMAddin <\/b>aus (siehe Bild 1). Danach speichern wir das neu angelegte Projekt erst einmal unter dem gewünschten Namen, in diesem Fall MakeXLSM<\/b>.<\/p>\n

\"Projekt<\/p>\n

Bild 1: Projekt auf Basis der Vorlage MyCOMAddin erstellen<\/span><\/b><\/p>\n

Verweis auf die Excel-Bibliothek hinzufügen<\/h2>\n

Damit wir direkt per IntelliSense auf die Elemente der Excel-Bibliothek zugreifen können, fügen wir dem Projekt einen entsprechenden Verweis hinzu. Dazu wechseln wir in twinBASIC zum Bereich Settings. Hier scrollen wir nach unten zum Bereich COM Type Library \/ ActiveX References<\/b>.<\/p>\n

Unter All Available COM References <\/b>aktivieren wir mit einem Klick auf das Lupe-Symbol ein Suchfeld und geben Excel <\/b>ein.<\/p>\n

Der Eintrag Microsoft Excel 16.0 Object Library <\/b>erscheint und wir fügen einen Verweis auf diese Bibliothek hinzu, indem wir das Kästchen vor diesem Eintrag anhaken (siehe Bild 2).<\/p>\n

\"Hinzufügen<\/p>\n

Bild 2: Hinzufügen eines Verweises auf die Excel-Bibliothek<\/span><\/b><\/p>\n

Name und Beschreibung des Projekts anpassen<\/h2>\n

Wenn wir schon die Einstellungen anpassen, können wir auch gleich den Namen und die Beschreibung des Projekts ändern. Dazu passen wir die beiden Eigenschaften Project: Name <\/b>und Project: Description <\/b>im oberen Bereich der Einstellungen an (siehe Bild 3).<\/p>\n

\"Einstellen<\/p>\n

Bild 3: Einstellen von Projektname und -beschreibung<\/span><\/b><\/p>\n

Einstellungen speichern<\/h2>\n

Diese Änderungen speichern wir mit der Tastenkombination Strg + S<\/b>, was in der Regel einen Neustart von twinBASIC auslöst.<\/p>\n

Projektdateien anpassen<\/h2>\n

Schließlich ändern wir auch noch den Dateinamen von der Vorgabe COMAddIn.twin <\/b>in MakeXLSM.twin <\/b>und den Klassennamen von COMAddIn <\/b>in MakeXLSM <\/b>(siehe Bild 4).<\/p>\n

\"Einstellen<\/p>\n

Bild 4: Einstellen des Klassennamens und des Dateinamens<\/span><\/b><\/p>\n

Die Klasse MakeXLSM anpassen<\/h2>\n

In der Klasse MakeXLSM<\/b>, die beispielsweise die Implementierung der Schnittstellen IDTExtensibility2 <\/b>und IRibbonExtensibility <\/b>übernimmt, nehmen wir einige Änderungen vor. Die wichtigsten fassen wir nachfolgend zusammen.<\/p>\n

Wir deklarieren eine Variable namens objExcel <\/b>mit dem Datentyp Excel.Application<\/b>, der wir in der Ereignismethode OnConnection <\/b>den Verweis auf die Excel-Instanz zuweisen, durch die das COM-Add-In aufgerufen wird:<\/p>\n

Private <\/span>objExcel As <\/span>Excel.Application<\/pre>\n
Außerdem deklarieren wir eine Variable, mit der wir später die Ribbondefinition referenzieren wollen. Dies hat den Nutzen, dass wir dann die Methode Invalidate <\/b>aufrufen können, um unsere Ribbon-Steuerelemente per Code zu aktualisieren. Die Deklaration sieht wie folgt aus:<\/p>\n
Public <\/span>objRibbon As <\/span>IRibbonUI<\/pre>\n
Referenz zur Excel-Anwendung herstellen<\/h2>\n
Die Variable objExcel <\/b>füllen wir wie folgt in der Prozedur OnConnection<\/b>:<\/p>\n
Sub <\/span>OnConnection(ByVal Application As Object<\/span>, _\r\n         ByVal ConnectMode As <\/span>ext_ConnectMode, _\r\n         ByVal AddInInst As Object<\/span>, _\r\n         ByRef custom As Variant<\/span>()) _\r\n         Implements IDTExtensibility2.OnConnection\r\n     Set<\/span> objExcel = Application\r\nEnd Sub<\/span><\/pre>\n
Befehl zum Backstagebereich hinzufügen<\/h2>\n
Bevor wir uns um die eigentliche Funktion kümmern, wollen wir uns erst einmal in die Benutzeroberfläche von Excel einnisten, und zwar in den Backstage-Bereich. Hier wollen wir den Befehl In .xlsm umwandeln <\/b>direkt links in der Liste der übrigen Befehle zum Öffnen der verschiedenen Bereiche oder zum Aufrufen von Funktionen integrieren.<\/p>\n
Dazu definieren wir in der Funktion GetCustomUI<\/b> die benötigte Ribbon-Anpassung. Die Funktion sieht anschließend wie in Listing 1 aus.<\/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 &= \"<?xml version=\"\"1.0\"\"?>\" & vbCrLf<\/span>\r\n     strXML &= \"<customUI xmlns=\"\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\"\" loadImage=\"\"loadImage\"\" \" _\r\n         & \"onLoad=\"\"onLoad\"\">\" & vbCrLf<\/span>\r\n     strXML &= \"  <backstage>\" & vbCrLf<\/span>\r\n     strXML &= \"    <button id=\"\"btnMakeXLSM\"\" onAction=\"\"onAction\"\" insertAfterMso=\"\"TabInfo\"\" \" _\r\n         & \"getEnabled=\"\"getEnabled\"\" label=\"\"In .xlsm umwandeln\"\" image=\"\"console.ico\"\"\/>\" & vbCrLf<\/span>\r\n     strXML &= \"  <\/backstage>\" & vbCrLf<\/span>\r\n     strXML &= \"<\/customUI>\" & vbCrLf<\/span>\r\n     Return strXML\r\nEnd Function<\/span><\/pre>\n
Listing 1: Die Funktion LoadCustomUI lädt die in strXML zusammengestellte Ribbondefinition.<\/span><\/b><\/p>\n
Die Anpassung fügt im Wesentlichen einen Eintrag zum Backstage<\/b>-Bereich von Excel hinzu. Dieser erhält die Beschriftung In .xlsm umwandeln <\/b>und soll das Icon console.ico <\/b>anzeigen, welches wir gleich zum Projekt hinzufügen. Außerdem soll das neue Backstage-Element bei mir relativ weit oben angezeigt werden, weil ich es oft benötige. Wenn Du es lieber an einer anderen Position ablegen möchtest, kannst Du den Wert des Attributs insertAfterMso <\/b>nutzen und die idMso <\/b>des jeweiligen Elements dort eintragen. Wie findest Du die idMso<\/b>? Indem Du in den Excel-Optionen zum Bereich Menüband anpassen <\/b>wechselst, unter Befehle auswählen <\/b>den Eintrag Registerkarte “Datei” <\/b>selektierst und mit der Maus über den Befehl fährst, vor oder hinter dem Du das neue Steuerelement einfügen möchtest (siehe Bild 5). Aber Achtung: Es funktioniert leider nicht für alle Elemente. Zumindest FileSave <\/b>haben wir aber noch erfolgreich ausprobiert.<\/p>\n
\"Ermitteln<\/p>\n
Bild 5: Ermitteln der idMso für ein Backstage-Element<\/span><\/b><\/p>\n
Ein weiteres wichtiges Element in der Ribbondefinition des button<\/b>-Elements ist das Attribut onAction<\/b>, für das wir den Namen der VBA-Prozedur angeben, die dadurch aufgerufen werden soll und die wir weiter unten beschreiben.<\/p>\n
Das Attribut getEnabled <\/b>benötigen wir, weil wir das button<\/b>-Element dynamisch aktivieren oder deaktivieren wollen. Die für dieses Attribut hinterlegte Funktion liefert den Wert True <\/b>oder False <\/b>und aktiviert oder deaktiviert so die Schaltfläche. Warum sollten wir den Button deaktivieren? Weil es passieren kann, dass das geladene Excel-Workbook bereits das Format .xlsm <\/b>aufweist. Dann benötigen wir den Befehl natürlich nicht mehr.<\/p>\n
Auch im Element customUI <\/b>haben wir noch zwei Attribute definiert. Für das Attribut loadImages <\/b>hinterlegen wir den Namen der Funktion, die für jedes Element, welches das Attribut image <\/b>aufweist, das jeweilige Icon zurückliefert. Und für onLoad <\/b>legen wir die die Funktion fest, die beim Laden der Ribbondefinition ausgelöst wird und mit der wir eine Objektvariable mit einem Verweis auf die Ribbondefinition füllen können. Die Variable namens objRibbon<\/b> haben wir weiter oben bereits deklariert. Nun fehlt noch die Definition der Funktion onLoad<\/b>, die wie folgt aussieht:<\/p>\n
Function <\/span>OnLoad(ribbon As <\/span>IRibbonUI)\r\n     Set<\/span> objRibbon = ribbon\r\nEnd Function<\/span><\/pre>\n
Icon hinzufügen<\/h2>\n
Damit wir mit unserem Befehl ein Icon anzeigen können (siehe Bild 6), fügen wir dieses zuerst zum Ordner Resources|ICON <\/b>hinzu.<\/p>\n
\"Unser<\/p>\n
Bild 6: Unser Befehl im Backstage-Bereich<\/span><\/b><\/p>\n
Dazu wählen wir per Rechtsklick den Kontextmenübefehl Add|Import File… <\/b>dieses Ordners aus und selektieren dann die gewünschte .ico<\/b>-Datei.<\/p>\n
Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Visual Basic Entwickler<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 200 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span>
\nOder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t
\n\n\t\t\n\t\t