Seit Jahren gibt es im Web einige Module, die das Handling von Bilddateien als Icons in Ribbons, Kontextmenüs, TreeViews oder als Formular-Icon erlauben. Diese sind meist umfangreich und für Laien kaum verständlich. Wir haben die verwendeten Techniken einmal ein wenig einfacher gestaltet, sodass man nicht mehr so viel Code benötigt – und vor allem weniger API-Funktionen. In diesem Artikel lernen Sie, wie Sie Ribbon-Einträge und Kontextmenü-Befehle mit Icons versehen. Als Bonus gibt es eine hilfreiche Funktion, mit der wir schnell viele Icons in die Access-Datenbank übertragen können, statt diese Schritt-für-Schritt einzulesen.<\/b><\/p>\n
Theorie zu Bilddateien für Icons und Ribbons<\/h2>\n
Seit der Version 2010 speichert Microsoft Access Bilder, die aus dem Dateisystem ausgewählt und Steuerelementen wie dem Bildsteuerelement oder der Schaltfläche zugeordnet werden, in einer Systemtabelle der Datenbank namens MSysResources<\/b>.<\/p>\n
Nachdem wir einem Formular im Entwurf über den Ribbonbefehl Bild einfügen <\/b>ein Bild hinzugefügt haben, ist dieses anschließend ständig verfügbar (siehe Bild 1).<\/p>\n
![\"Bilder](\"..\/fileadmin\/_temp_\/2025_04\/pic_1557_001.png\")
<\/p>\n
Bild 1: Bilder sind nach dem Hinzufügen ständig in der aktuellen Datenbank verfügbar.<\/span><\/b><\/p>\n Die Bilddateien werden intern versteckt gespeichert, nämlich in der bereits erwähnten Tabelle MSysResources<\/b>.<\/p>\n Diese sieht nach dem Hinzufügen einiger Bilder wie in Bild 2 aus.<\/p>\n Bild 2: Tabelle zum Speichern der Bilder in der aktuellen Datenbank<\/span><\/b><\/p>\n All diese Bilder können wir allerdings auch anderweitig nutzen, wenn sie sich einmal in der Datenbank befinden – zum Beispiel, indem wir sie per VBA auslesen und in Ribbons oder Kontextmenüs anzeigen.<\/p>\n Der Dialog zum Hinzufügen von Bildern zur Datenbank über den Befehl Bild einfügen <\/b>hat einen Nachteil, der bereits aus der Beschriftung dieses Befehls ersichtlich wird – man kann immer nur ein Bild pro Vorgang hinzufügen. Wenn man einen Satz von Bildern hat, die man immer wieder benötigt, wird das schnell aufwendig.<\/p>\n Wir stellen also in diesem Beitrag eine Funktion vor, mit der wir gleich mehrere Bilder im Dateidialog auswählen und zur Datenbank hinzufügen können.<\/p>\n Während wir die Bilder aus der Tabelle MSysResources <\/b>zu Bildsteuerelementen oder Schaltflächen hinzufügen können, indem wir diese einfach für die Eigenschaft Bild<\/b> auswählen (siehe Bild 3), ist das bei den Schaltflächen und anderen Elementen in Schaltflächen im Kontextmenüs nicht so einfach möglich. Diese erwarten ein per VBA zugewiesenes Element des Typs StdPicture<\/b>.<\/p>\n Bild 3: Die Bilder stehen in der Bild-Eigenschaft zur Verfügung<\/span><\/b><\/p>\n Ein Bild aus der Tabelle MSysResources <\/b>auszuwählen und in ein StdPicture<\/b>-Element umzuwandeln, ist kein Hexenwerk, aber dazu sind einige Codezeilen nötig und eine Reihe API-Funktionen. Im zweiten Abschnitt dieses Beitrags werden wir eine Vorgehensweise vorstellen, die wesentlich kompakter als die üblicherweise verwendeten und auch in diesem Magazin eingeführten Techniken sind.<\/p>\n Außerdem zeigen wir, wie diese Elemente dann den entsprechenden Steuerelementen zugewiesen werden.<\/p>\n Zuerst schauen wir uns die Funktion zum schnellen Einlesen von mehreren Bilddateien an.<\/p>\n Diese erfordert zunächst eine Funktion, mit der wir die einzulesenden Dateien per Dateidialog auswählen können. Außerdem benötigen wir eine Routine, welche die ausgewählten Dateien in das Anlagefeld der Tabelle MSysResources <\/b>schreibt. Diese beiden Routinen führen wir in einer aufrufenden Prozedur namens amvFileToResources <\/b>zusammen.<\/p>\n Die Funktion zum Anzeigen des Dateidialogs basiert auf der FileDialog<\/b>-Klasse der Office-Bibliothek, auf die wir noch einen Verweis setzen müssen (siehe Bild 4).<\/p>\n Bild 4: Hinzufügen des Verweises auf die Office-Bibliothek<\/span><\/b><\/p>\n Diese benötigen wir auch später noch, wenn wir ein Kontextmenü mit Icons erstellen wollen.<\/p>\n Die Prozedur amvFileToResources <\/b>steuert unseren Vorgang:<\/p>\n Sie ruft zunächst die Funktion amvChooseFiles <\/b>auf, die eine Zeichenkette mit den durch das Pipe-Zeichen (|) getrennten einzelnen Pfaden der einzulesenden Dateien zurückgibt.<\/p>\n Diese Liste speichern wir in der Variablen strPathlist<\/b>. Den Inhalt dieser Variablen teilen wir mit der Split<\/b>-Funktion in ein Array auf, das wir in der Variablen strPaths() <\/b>speichern.<\/p>\n Die Elemente dieses Arrays durchlaufen wir nachfolgend in einer For…Next<\/b>-Schleife. In dieser Schleife rufen wir für jedes Element einmal die Funktion amvAddImageToMSysResources <\/b>auf, um die jeweilige Datei in einen neuen Datensatz der Tabelle MSysResources <\/b>zu schreiben.<\/p>\n Die Funktion zum Auswählen der Dateien nutzt den Dateiauswahldialog der Office-Bibliothek, um dem Benutzer eine flexible Mehrfachauswahl von Dateien zu ermöglichen, und gibt die Pfade der ausgewählten Dateien als durch das Pipe-Zeichen getrennte Zeichenkette zurück (siehe Listing 1). Gleichzeitig merkt sich die Funktion den beim letzten Vorgang verwendeten Ordnerpfad und schlägt diesen beim nächsten Aufruf erneut vor, was eine erhebliche Erleichterung bei wiederholter Arbeit mit denselben Ordnern darstellt.Zu Beginn der Funktion werden die nötigen Variablen deklariert. Eine dieser Variablen speichert das Initialverzeichnis für den Dateiauswahldialog. Dieser Pfad wird mithilfe der Funktion amvGetAppSetting <\/b>(siehe Modul MDL_AMV_Registry<\/b>) aus dem Bereich der Registry für Anwendungseinstellungen ausgelesen. Ist dort kein Pfad hinterlegt, etwa weil die Funktion zum ersten Mal verwendet wird oder die Einstellung gelöscht wurde, verwendet die Funktion standardmäßig das Verzeichnis der aktuellen Datenbankdatei. Das bedeutet, dass der Benutzer beim ersten Aufruf im Ordner der Datenbank zu arbeiten beginnt, bei weiteren Aufrufen jedoch direkt im zuletzt verwendeten Verzeichnis landet.<\/p>\n Listing 1: Ermitteln der einzulesenden Bilddateien per Dateidialog<\/span><\/b><\/p>\n Anschließend wird ein Dialogobjekt vom Typ FileDialog <\/b>mit dem Typ msoFileDialogOpen<\/b> zum Auswählen von Dateien erzeugt. Der Dialog wird so konfiguriert, dass mehrere Dateien auf einmal ausgewählt werden können. Er erhält einen beschreibenden Titel, einen angepassten Beschriftungstext für die Auswahlschaltfläche sowie zwei Filtereinträge: einen für PNG-Dateien und einen für ICO-Dateien.<\/p>\n Zeigt der Benutzer nun den Dialog an und bestätigt die Auswahl, wird überprüft, ob überhaupt Dateien ausgewählt wurden. Ist dies der Fall, wird aus dem Pfad der ersten Datei der zugehörige Ordner extrahiert. Dieser Ordner wird später als neue Anwendungseinstellung gespeichert, damit er beim nächsten Aufruf der Funktion wieder als Ausgangspunkt dient. Danach werden alle ausgewählten Dateipfade nacheinander in einer Zeichenkette gesammelt. Zwischen den einzelnen Dateipfaden wird das Pipe-Zeichen als Trenner eingefügt. Abschließend wird der führende Trenner entfernt, sodass die Rückgabe sauber formatiert ist.<\/p>\n Die Funktion speichert dann den aktualisierten Startordner mithilfe der Prozedur amvSaveAppSetting<\/b>, ebenfalls im Modul MDL_AMV_Registry <\/b>zu finden, und gibt schließlich die Zeichenkette mit den Pfaden der ausgewählten Dateien zurück.<\/p>\n Nach der Auswahl folgt die Prozedur amvAddImageToMSysResources<\/b>. Diese deklariert ein Database<\/b>-Objekt, zwei Recordsets für die Tabelle MSysResources <\/b>und die darin enthaltene interne Tabelle zum Speichern der Attachments und ein Field2<\/b>-Objekt zum Laden der Dateien in das Zielfeld (siehe Listing 2).<\/p>\n Listing 2: Die Prozedur amvAddImageToMSysResources<\/span><\/b><\/p>\n Die Prozedur erwartet den Pfad der einzulesenden Datei als Parameter. Sie ermittelt zunächst die Dateiendung und den Dateinamen sowie den Dateinamen ohne Dateiendung und trägt diese Daten in die Variablen strExtension<\/b>, strFilename <\/b>und strFilenameWithoutExtensions <\/b>ein.<\/p>\n Dann erstellt sie eine Referenz zum aktuellen Database<\/b>-Objekt und öffnet darüber die Tabelle MSysResources<\/b> als Recordset.<\/p>\n Hier fügt sie mit AddNew <\/b>einen neuen Datensatz hinzu und trägt die Dateiendung in das Feld Extension <\/b>sowie den Dateinamen ohne Dateiendung in das Feld Name <\/b>ein. Als Type wird immer img <\/b>eingetragen.<\/p>\n Nun folgt der spannende Teil. Das zweite Recordset wird mit dem Wert Value <\/b>des Feldes Data <\/b>der Tabelle MSysResources <\/b>gefüllt, also mit der internen Tabelle zum Speichern der Attachments.<\/p>\n Auch hier fügen wir mit AddNew <\/b>einen neuen Datensatz ein und referenzieren dann das Feld FileData <\/b>mit der Variablen fldFileData<\/b>. Die hier verwendete Field2<\/b>-Klasse liefert gegenüber der herkömmlichen Field-Klasse noch die Methode LoadFromFile<\/b>, die das Einlesen einer Datei in das Feld ermöglicht. Diese nutzen wir, um die angegebene Datei in das Anlagefeld zu laden. Zusätzlich stellen wir die Eigenschaft Filename <\/b>auf den Dateinamen ein, diesmal mit Dateierweiterung, und speichern den neu hinzugefügten Datensatz der internen Tabelle mit der Update<\/b>-Methode.<\/p>\n Die gleiche Methode rufen wir auch noch für das übergeordnete Recordset auf und schließen dann die geöffneten Objekte und geben die Objektvariablen frei.<\/p>\n Rufen wir die Prozedur amvFileToResources <\/b>nun auf, erscheint der Dateidialog, mit dem wir die gewünschten Bilddateien auswählen können. Die ausgewählten Dateien werden ohne Rücksicht auf eventuelle Dubletten in die Tabelle MSysResources <\/b>geschrieben.<\/p>\n Nachdem wir dies erledigt haben, sind einige Dateien in dieser Tabelle gelandet, die wir für die folgenden Techniken als Icons für das Ribbon und für Kontextmenüs nutzen können.<\/p>\n Wenn wir Bilder im Ribbon anzeigen wollen, benötigen wir zweierlei:<\/p>\n Eine der einfachsten möglichen Ribbondefinitionen für diesen Zweck haben wir bereits in die für diesen Fall vorbereitete Tabelle USysRibbons <\/b>eingetragen (siehe Bild 5). Das Attribut des button<\/b>-Elements enthält den Wert apple<\/b>, was dazu führt, dass ein Bild namens apple <\/b>angezeigt werden soll. Das Attribut loadImage <\/b>ist mit dem Wert loadImage <\/b>ausgestattet, was bedeutet, dass wir eine gleichnamige Funktion zum Einlesen der Bilder hinterlegen müssen.<\/p>\n Bild 5: Einfachste mögliche Ribbondefinition zum Anzeigen eines benutzerdefinierten Bildes<\/span><\/b><\/p>\n Funktionen für die Automation von Ribbons hinterlegen wir traditionell in einem Modul namens mdlRibbons<\/b>. In diesem Fall fügen wir dort die folgende Funktion ein:<\/p>\n Sie ruft lediglich eine weitere Funktion namens amvGetImageFromResourcesByName <\/b>auf, die den Wert des Parameters control <\/b>übergeben bekommt. Diese Funktion liefert das Bild in Form einer Variable des Typs StdPicture <\/b>zurück, die schließlich an die Ribbondefinition zurückgegeben werden kann.<\/p>\n Im Gegensatz zu Prozeduren, die zum Beispiel beim Anklicken eines Ribbonbuttons ausgelöst werden, liefert control <\/b>hier kein Objekt des Typs IRibbonControl<\/b>, sondern lediglich den Wert des Attributs image <\/b>des jeweils mit einer Bilddatei zu füllenden Steuerelements.<\/p>\n Die Funktion amvGetImageFromResourcesByName <\/b>ist eine Wrapperfunktion, die zu dem übergebenen Bildnamen die ID des entsprechenden Datensatzes aus der Tabelle MSysResources <\/b>ermittelt (siehe Listing 3).<\/p>\n Listing 3: Die Funktion amvGetImageFromResourcesByName<\/span><\/b><\/p>\n Sie ermittelt per Recordset alle Datensätze, deren Bild den entsprechenden Namen hat.<\/p>\n Die weitere Vorgehensweise hängt davon ab, wie viele Datensätze mit diesem Bildnamen gefunden wurden:<\/p>\n Listing 4: Die Funktion amvGetImageFromResources<\/span><\/b><\/p>\n Die Funktion zum Einlesen einer Ressource in eine Objektvariable des Typs StdPicture <\/b>nimmt die ID des zu verwendenden Datensatzes der Tabelle MSysResources <\/b>entgegen und soll schließlich das StdPicture<\/b>-Objekt zurückliefern.<\/p>\n Dies geschieht in zwei Schritten. Der erste ruft die Funktion amvAttachmentToByteArray <\/b>auf, die das Attachment zunächst in ein Byte-Array einliest. Das Ergebnis dieser Funktion, das zwischenzeitlich in der Variablen bytData <\/b>landet, wird dann in der Funktion amvArrayToStdPicture <\/b>weiterverarbeitet. Diese liefert schließlich das StdPicture<\/b>-Objekt zurück.<\/p>\n Die Funktion amvAttachmentToByteArray <\/b>aus Listing 5 nimmt den Primärschlüsselwert der Ressource aus der Tabelle MSysResources <\/b>entgegen und liefert ein Byte-Array mit dem Inhalt des Anlagefeldes zurück.<\/p>\n Listing 5: Die Funktion amvAttachmentToByteArray<\/span><\/b><\/p>\n Die Funktion soll aus dem Eintrag der Tabelle MSysResources<\/b> den tatsächlichen Inhalt des gespeicherten Bildes als reines Byte-Array extrahieren. Der besondere Fokus liegt dabei auf der Tatsache, dass Access Anlagen intern mit einem zusätzlichen Datenkopf versieht.<\/p>\n Dieser Kopf enthält Verwaltungsinformationen, die beim späteren Verwenden der Daten (zum Beispiel in einem Bildobjekt oder beim Speichern in eine Datei) nicht benötigt und daher entfernt werden müssen. Die Funktion befreit die gespeicherte Datei also von diesem Overhead und liefert nur den reinen, nutzbaren Inhalt zurück.<\/p>\n Ziel der Funktion ist es, für einen übergebenen Primärschlüsselwert – also einen Verweis auf einen Datensatz in MSysResources <\/b>– den enthaltenen Anlagendatensatz zu lesen, den tatsächlichen Startpunkt der eigentlichen Binärdaten zu ermitteln, diese dann isoliert in ein neues Byte-Array zu kopieren und schließlich zurückzugeben. Sie eignet sich somit hervorragend als Bindeglied zwischen der internen Speicherung von Ressourcen in Access und einer externen Weiterverwendung, beispielsweise zur Übergabe an Windows-APIs oder wie hier an benutzerdefinierte Ribbon-Schaltflächen, die ein StdPicture<\/b>-Objekt erwarten.<\/p>\n Zunächst werden zwei Byte-Arrays deklariert: bytAttachData<\/b>, welches den vollständigen Inhalt aus dem Anlagenfeld übernimmt, und bytAttach<\/b>, das später den bereinigten, reinen Datenanteil aufnehmen soll.<\/p>\n Eine dritte Variable, lngOffset<\/b>, speichert die Position im Array, ab der der tatsächliche Inhalt beginnt. Dieser Offset wird durch den Wert des ersten Bytes des Arrays bestimmt – bytAttachData(0) <\/b>-, welches laut interner Speicherstruktur von Access die Länge des Headers angibt. Dieser Trick ist elementar, da er vermeidet, das genaue Format des Anlagendatentyps analysieren zu müssen. Stattdessen wird das erste Byte als Startmarke interpretiert und als Versatz für das Kopieren der Daten genutzt.<\/p>\n Die Abfrage selbst erfolgt über ein Recordset im Snapshot-Modus, um eine möglichst performante und schreibgeschützte Lesung zu gewährleisten. Das SQL-Statement greift auf die Spalte FileData <\/b>des eingebetteten Anlagenfelds Data zu. Dies ist möglich, da das Anlagenfeld, wie oben bereits erwähnt, intern als komplexer Datentyp mit Unterfeldern gespeichert wird, wobei FileData <\/b>die eigentlichen Binärdaten enthält.<\/p>\n Nach dem Lesen des vollständigen Datensatzes und dem Ermitteln des Offsets wird das Zielarray bytAttach <\/b>mit der Größe des verbleibenden Datenblocks dimensioniert. Der Copy-Vorgang erfolgt über die API-Funktion amvCopyMemory<\/b>, die wie in Listing 6 neben zwei weiteren, später noch benötigten API-Funktionen im Kopf des Moduls MDL_AMV_API <\/b>deklariert wird.<\/p>\n Listing 6: Die für die vorliegende Lösung benötigten API-Funktionen<\/span><\/b><\/p>\n Die API-Deklarationen haben wir bewusst jeweils mit dem Präfix amv… <\/b>versehen. Dazu ist es erforderlich, die ursprüngliche API-Funktion mit dem Parameter ALIAS <\/b>zu versehen. Der Sinn dieser Aktion ist, dass diese Funktionen gegebenenfalls in VBA-Projekte eingefügt werden, die bereits über die eine oder andere dieser API-Funktionen verfügt. Damit diese nicht mühsam abgeglichen werden müssen, haben wir einfach unseren eigenen Satz von API-Funktionen bereitgestellt.<\/p>\n Mit amvCopyMemory<\/b> werden die reinen Daten ab der Offset-Position aus dem ursprünglichen Array in das neue Array geschrieben – bytegenau und ohne den Headeranteil.<\/p>\n Nach dem erfolgreichen Kopieren wird das bereinigte Array als Ergebnis der Funktion zurückgegeben. Zusätzlich werden die beiden internen Arrays am Ende der Funktion mit Erase <\/b>freigegeben, um den Arbeitsspeicher zu entlasten.<\/p>\n Tritt während des Prozesses ein Fehler auf, springt der Code in die Fehlerbehandlung, die hier nur aus einem Err.Clear <\/b>besteht. Damit wird ein eventueller Fehlerzustand gelöscht, ohne dass eine Meldung angezeigt wird. Dies ist in Situationen nützlich, in denen bewusst fehlertolerant gearbeitet werden soll – etwa, wenn der Aufrufer entscheidet, was im Fehlerfall zu tun ist.<\/p>\n Die Funktion amvArrayToStdPicture <\/b>aus Listing 7 dient der Umwandlung eines Byte<\/b>-Arrays in ein Objekt des Typs StdPicture<\/b>.<\/p>\n Listing 7: Funktion zum Umwandeln des Byte-Arrays in ein StdPicture-Objekt<\/span><\/b><\/p>\n Die Funktion nutzt dafür auf elegante Weise die Windows Image Acquisition<\/b>-Bibliothek (kurz: WIA<\/b>), die seit Windows XP Bestandteil des Betriebssystems ist und über COM bereitgestellt wird.<\/p>\n Das zentrale Ziel der Funktion ist es, das Bild aus dem Byte<\/b>-Array direkt in ein StdPicture<\/b>-Objekt zu überführen.<\/p>\n Die Funktion erstellt ein neues Objekt auf Basis der WIA-Bibliothek, konkret ein sogenanntes Vector-Objekt. Dieses Objekt dient der Aufnahme von binären Daten und verfügt über eine Eigenschaft BinaryData<\/b>, der das Byte-Array direkt zugewiesen wird. Intern analysiert die WIA-Bibliothek das Format der Binärdaten – typischerweise PNG, JPG oder BMP – und wandelt diese automatisch in eine Bilddarstellung um, sofern das Format gültig ist.<\/p>\n Sobald das Byte-Array zugewiesen wurde, steht das resultierende Bild über die Eigenschaft Picture <\/b>als COM-Objekt vom Typ StdPicture <\/b>zur Verfügung. Dieses Objekt wird dann über Set <\/b>an die Funktion zurückgegeben.<\/p>\n Die Eleganz dieser Lösung liegt vor allem in der Kombination von Einfachheit und Effektivität: In nur wenigen Codezeilen wird ein häufig komplexer Vorgang – das Interpretieren von Bilddaten und deren Konvertierung in eine COM-kompatible Darstellung – vollständig gelöst. Besonders hervorzuheben ist, dass keinerlei temporäre Dateien oder externe Bibliotheken notwendig sind. Die WIA-Bibliothek ist in der Regel bereits auf jedem Windows-System vorhanden und erfordert lediglich den passenden Verweis, wobei CreateObject<\/b> in diesem Fall sogar ohne expliziten Verweis in den VBA-Verweiseinstellungen funktioniert.<\/p>\n Damit haben wir fast alles zusammen. Wir müssen dies nur noch testen, was wir der Einfachheit halber ohne aufwendiges Öffnen und Schließen erledigen wollen.<\/p>\n Dazu erstellen wir ein Testformular, für dessen Beim Laden<\/b>-Ereignis wir die Prozedur aus Listing 8 hinterlegen.<\/p>\n![\"Tabelle](\"..\/fileadmin\/_temp_\/2025_04\/pic_1557_002.png\")
<\/p>\nVorbereitung: Icons in der Datenbank speichern<\/h2>\n
Bilder in Ribbon und Kontextmenü<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2025_04\/pic_1557_003.png\")
<\/p>\nSchnelles Einlesen von vielen Icons<\/h2>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2025_04\/pic_1557_006.png\")
<\/p>\nSteuerung des Einlesevorgangs der Bilddateien<\/h2>\n
Public Sub <\/span>amvFilesToResources()\r\n Dim <\/span>strPaths() As String<\/span>\r\n Dim <\/span>strPathlist As String<\/span>\r\n Dim <\/span>i As Integer<\/span>\r\n \r\n strPathlist = ChooseFiles\r\n strPaths() = Split<\/span>(strPathlist, \"|\")\r\n For i = LBound<\/span>(strPaths) To UBound<\/span>(strPaths)\r\n Debug.Print<\/span> strPaths(i)\r\n amvAddImageToMSysResources strPaths(i)\r\n Next<\/span> i\r\nEnd Sub<\/span><\/pre>\nDie Funktion amvChooseFiles<\/h2>\n
Public Function <\/span>amvChooseFiles()\r\n Dim <\/span>objFileDialog As <\/span>Office.FileDialog\r\n Dim <\/span>strTemp As String<\/span>\r\n Dim <\/span>varFilename As Variant<\/span>\r\n Dim <\/span>strInitialFilename As String<\/span>\r\n strInitialFilename = amvGetAppSetting(\"InitialFilename\")\r\n If <\/span>Len<\/span>(strInitialFilename) = 0 Then<\/span>\r\n strInitialFilename = CurrentProject.Path & \"\\\"\r\n End If<\/span>\r\n Set<\/span> objFileDialog = Application.FileDialog(msoFileDialogOpen)\r\n With<\/span> objFileDialog\r\n .Title = \"Bilddateien auswählen\"\r\n .ButtonName = \"Auswählen\"\r\n .AllowMultiSelect = True<\/span>\r\n .InitialFileName = strInitialFilename\r\n .Filters.Clear\r\n .Filters.Add \"PNG-Dateien\", \"*.png\"\r\n .Filters.Add \"ICO-Dateien (.ico)\", \"*.ico\"\r\n If <\/span>.Show = True<\/span> Then<\/span>\r\n If <\/span>Not<\/span> .SelectedItems.Count = 0 Then<\/span>\r\n strInitialFilename = .SelectedItems(1)\r\n strInitialFilename = Left<\/span>(strInitialFilename, InStrRev<\/span>(strInitialFilename, \"\\\"))\r\n For Each varFilename In .SelectedItems\r\n strTemp = strTemp & \"|\" & varFilename\r\n Next<\/span> varFilename\r\n If <\/span>Not<\/span> Len<\/span>(strTemp) = 0 Then<\/span>\r\n strTemp = Mid<\/span>(strTemp, 2)\r\n End If<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n End With<\/span>\r\n amvSaveAppSetting \"InitialFilename\", strInitialFilename\r\n amvChooseFiles = strTemp\r\nEnd Function<\/span><\/pre>\nProzedur zum Speichern der Bilder in der Tabelle MSysResources<\/h2>\n
Public Sub <\/span>amvAddImageToMSysResources(ByVal strPath As String<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rstResources As <\/span>DAO.Recordset\r\n Dim <\/span>rstAttachments As <\/span>DAO.Recordset2\r\n Dim <\/span>fldFileData As <\/span>DAO.Field2\r\n Dim <\/span>strExtension As String<\/span>\r\n Dim <\/span>strFilename As String<\/span>\r\n Dim <\/span>strFilenameWithoutExtension As String<\/span>\r\n strExtension = Mid<\/span>(strPath, InStrRev<\/span>(strPath, \".\") + 1)\r\n strFilename = Mid<\/span>(strPath, InStrRev<\/span>(strPath, \"\\\") + 1)\r\n strFilenameWithoutExtension = Left<\/span>(strFilename, InStrRev<\/span>(strFilename, \".\") - 1)\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rstResources = db.OpenRecordset(\"SELECT * FROM MSysResources\", dbOpenDynaset)\r\n rstResources.AddNew<\/span>\r\n \r\n rstResources!Extension = strExtension\r\n rstResources!Name = strFilenameWithoutExtension\r\n rstResources!Type = \"img\"\r\n \r\n Set<\/span> rstAttachments = rstResources.Fields(\"Data\").Value\r\n rstAttachments.AddNew<\/span>\r\n Set<\/span> fldFileData = rstAttachments.Fields(\"FileData\")\r\n fldFileData.LoadFromFile strPath\r\n rstAttachments.FileName = strFilename\r\n rstAttachments.Update\r\n rstAttachments.Close\r\n Set<\/span> rstAttachments = Nothing\r\n \r\n rstResources.Update\r\n rstResources.Close\r\n Set<\/span> rstResources = Nothing\r\n Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\nVorbereiten der Tabelle MSysResources mit einigen Bilddateien<\/h2>\n
Bilder im Ribbon anzeigen<\/h2>\n
\n
![\"Einfachste](\"..\/fileadmin\/_temp_\/2025_04\/pic_1557_004.png\")
<\/p>\nPublic Sub <\/span>loadImage(control, ByRef image)\r\n Set<\/span> image = amvGetImageFromResourcesByName(control)\r\nEnd Sub<\/span><\/pre>\nID der einzufügenden Bilddatei ermitteln<\/h2>\n
Public Function <\/span>amvGetImageFromResourcesByName(strName As Variant<\/span>) As <\/span>StdPicture\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>lngID As Long<\/span>\r\n \r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT ID FROM MSysResources WHERE Name = ''\" & strName & \"''\", dbOpenSnapshot)\r\n \r\n Select Case rst.RecordCount\r\n Case <\/span>1\r\n lngID = rst.Fields(0)\r\n Set<\/span> amvGetImageFromResourcesByName = amvGetImageFromResources(lngID)\r\n Case <\/span>0\r\n MsgBox<\/span> \"Bild ''\" & strName & \"'' nicht in der Tabelle MSysResources gefunden.\"\r\n Case Else<\/span>\r\n MsgBox<\/span> \"Mehr als ein Bild namens ''\" & strName & \"'' in der Tabelle MSysResources vorhanden.\"\r\n End Select<\/span>\r\nEnd Function<\/span><\/pre>\n\n
Public Function <\/span>amvGetImageFromResources(lngID As Long<\/span>) As <\/span>StdPicture\r\n Dim <\/span>bytData() As Byte<\/span>\r\n \r\n On Error GoTo<\/span> hErr\r\n \r\n bytData() = amvAttachmentToByteArray(lngID)\r\n Set<\/span> amvGetImageFromResources = amvArrayToStdPicture(bytData)\r\nExit Function<\/span>\r\nhErr:\r\n Err.Clear\r\nEnd Function<\/span><\/pre>\nErmitteln des StdPicture-Objekts für die angegebene Ressource<\/h2>\n
Funktion zum Erzeugen eines Byte-Arrays aus einem Attachment<\/h2>\n
Public Function <\/span>amvAttachmentToByteArray(lngID As Long<\/span>) As Byte<\/span>()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>bytAttach() As Byte<\/span>\r\n Dim <\/span>bytAttachData() As Byte<\/span>\r\n Dim <\/span>lngOffset As Long<\/span>\r\nOn Error GoTo<\/span> hErr\r\n \r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT Data.FileData FROM MSysResources WHERE id = \" & lngID, dbOpenSnapshot)\r\n If <\/span>Not<\/span> rst.EOF Then<\/span>\r\n bytAttachData = rst.Fields(0)\r\n lngOffset = bytAttachData(0)\r\n ReDim bytAttach(UBound<\/span>(bytAttachData) - lngOffset)\r\n amvCopyMemory bytAttach(0), bytAttachData(lngOffset), UBound<\/span>(bytAttach)\r\n amvAttachmentToByteArray = bytAttach\r\n \r\n Erase bytAttachData\r\n Erase bytAttach\r\n Else<\/span>\r\n MsgBox<\/span> \"Attachment mit der ID ''\" & lngID & \"'' konnte nicht in MSysResources gefunden werden.\"\r\n End If<\/span>\r\n \r\n Exit Function<\/span>\r\nhErr:\r\n Err.Clear\r\nEnd Function<\/span><\/pre>\nPublic <\/span>Declare PtrSafe Sub amvCopyMemory Lib \"Kernel32.dll\" Alias \"RtlMoveMemory\" (Destination As <\/span>Any, _\r\n Source As <\/span>Any, ByVal Length As Long<\/span>Ptr)\r\nPublic <\/span>Declare PtrSafe Function amvCreateIconFromResourceEx Lib \"user32.dll\" Alias \"CreateIconFromResourceEx\" _\r\n (presbits As <\/span>Any, dwResSize As <\/span>Any, ByVal fIcon As Long<\/span>, ByVal dwVer As Long<\/span>, ByVal cxDesired As Long<\/span>, _\r\n ByVal cyDesired As Long<\/span>, ByVal flags As Long<\/span>) As Long<\/span>Ptr\r\nPublic <\/span>Declare PtrSafe Function amvSendMessage Lib \"user32\" Alias \"SendMessageA\" (ByVal hwnd As Long<\/span>Ptr, _\r\n ByVal wMsg As Long<\/span>, ByVal wParam As Long<\/span>Ptr, lParam As <\/span>Any) As Long<\/span>Ptr<\/pre>\nFunktion zum Überführen des Byte-Arrays in ein StdPicture-Objekt<\/h2>\n
Public Function <\/span>amvArrayToStdPicture(bytArray() As Byte<\/span>) As <\/span>StdPicture\r\n On Error GoTo<\/span> hErr\r\n With<\/span> CreateObject(\"WIA.Vector\")\r\n .BinaryData = bytArray\r\n Set<\/span> amvArrayToStdPicture = .Picture\r\n End With<\/span>\r\n Exit Function<\/span>\r\nhErr:\r\n Err.Clear\r\nEnd Function<\/span><\/pre>\nTesten der Funktionen zum Anzeigen eines Bildes aus MSysResources im Ribbon<\/h2>\n
Private Sub <\/span>Form_Load()\r\n Dim <\/span>strRibbonName As String<\/span>\r\n strRibbonName = \"Ribbon_\" & Format(Now, \"yyyymmdd_hhnnss\")\r\n Application.LoadCustomUI strRibbonName, DLookup(\"RibbonXML\", \"USysRibbons\", \"RibbonName = ''Einfache Buttons''\")\r\n Me.RibbonName = strRibbonName\r\nEnd Sub<\/span><\/pre>\n