Access – Styling und Visual-Aufhübschung: Wie du Oberflächen gestaltest, die nicht nur funktionieren, sondern sich auch gut anfühlen

Von /

Viele Access-Projekte sehen nach ein paar Versionen so aus, als hätten sie mehrere Front-End-Designer ohne Abstimmung durchlaufen. Funktional läuft’s, aber visuell? Na ja. Für interne Tools ist das ok, aber für richtige Anwender-Akzeptanz und eine professionelle Ausstrahlung lohnt es sich, Zeit ins UI/Styling zu investieren.

Im Folgenden zeige ich dir pragmatische Techniken, wie du Access-Formulare, Farben, Schriften und Controls so gestaltest, dass sie konsistent, wartbar und visuell moderner wirken. Mit konkretem VBA-Code zum Mitnehmen.

1) Grundprinzipien: Design in Access denken

Bevor wir Code sehen: ein paar Prinzipien, die du dir merken kannst.

Farben mit System
Nutze ein konsistentes Farbschema über die gesamte Datenbank. Wildes Mixen von Farben signalisiert „heiß/kalt durcheinander“. Office-Themes helfen, weil sie harmonische Farbsets liefern.

Weniger ist mehr
Zu viele Farbakzente, zu viele verschiedene Schriftgrößen = visuell lauter. Zwei Schriftgrößen reichen meist: Überschrift und Inhalt.

Controls sinnvoll einsetzen
Ein Button mit 10 Farben wirkt nicht besser als ein Button mit 1 Farbe. Einheitliche Buttons, Labels und Abstände steigern die Lesbarkeit.

Raster & Abstände
Gleiche Abstände zwischen Controls wirken ruhiger. Schreibe Hilfs-Subs, die Controls einrasten lassen.

2) Farben zentral definieren

Statt überall harte Farbwerte zu verwenden, definiere sie zentral in einem Modul:

' Modul mdlStyleConstants
Option Compare Database
Option Explicit

' Farbkonstanten
Public Const clrPrimary      As Long = &H00C0504E  ' dunkles Petrol
Public Const clrAccent       As Long = &H00FF9900  ' dezentes Orange
Public Const clrBackground   As Long = &H00FFFFFF  ' weiß
Public Const clrText         As Long = &H00000000  ' schwarz
Public Const clrDisabled     As Long = &H00C0C0C0  ' grau

Wenn du später das Farbschema änderst, änderst du nur die Konstanten und nicht 100 Formulare.

3) Ein Style-Helper: Controls formatieren

Ein Helper-Modul, das Controls nach Typ formatiert:

' Modul mdlStyleHelper
Option Compare Database
Option Explicit

Public Sub StyleForm(frm As Access.Form)
    Dim ctl As Control
    
    ' Grundfarbe des Formulars
    frm.Detail.BackColor = clrBackground
    
    For Each ctl In frm.Controls
        Select Case ctl.ControlType
        Case acTextBox, acComboBox, acListBox
            ctl.BackColor = clrBackground
            ctl.ForeColor = clrText
            ctl.FontBold = False
        Case acCommandButton
            With ctl
                .BackColor = clrPrimary
                .ForeColor = clrBackground
                .FontBold = True
                ApplyButtonStyle ctl
            End With
        Case acLabel
            With ctl
                .ForeColor = clrText
                .FontBold = False
            End With
        End Select
    Next ctl
End Sub

Private Sub ApplyButtonStyle(btn As Control)
    ' Optional: ein bisschen Polsterung
    btn.PaddingTop = 4
    btn.PaddingBottom = 4
    btn.PaddingLeft = 8
    btn.PaddingRight = 8
End Sub

Anwendung:
Rufe StyleForm Me z. B. im Form_Load auf jedem Formular auf.

4) Einheitliche Kopf- und Fußleisten

Viele Access-Formulare wirken „abgehackt“. Eine einfache Kopfzeile gibt visuelle Struktur:

Public Sub ApplyHeader(frm As Access.Form, title As String)
    Dim lbl As Label
    On Error Resume Next
    Set lbl = frm.Controls("hdrTitle")
    If lbl Is Nothing Then
        Set lbl = CreateControl(frm.Name, acLabel, , , , 0, 0)
        lbl.Name = "hdrTitle"
        lbl.Width = frm.InsideWidth
    End If
    lbl.Caption = title
    lbl.BackColor = clrPrimary
    lbl.ForeColor = clrBackground
    lbl.FontSize = 14
    lbl.FontBold = True
    lbl.Top = 0
End Sub

Rufe das im Form_Open auf:

Private Sub Form_Open(Cancel As Integer)
    ApplyHeader Me, Me.Caption
End Sub

Das sorgt für ein einheitliches Look & Feel.

5) Theme-Like Farben mit Office Themes

Access unterstützt seit 2010 Office-Themes. Das bedeutet, jedes Formular kann sich an einem Farbset orientieren, das zu Word/Excel passt. Im VBA-Code sind das die ThemeColorIndex, Tint und Shade.

Beispiel: Setze den Hintergrund eines Buttons auf ein Theme-Accent:

With Me.btnSave
    .ThemeColor = acAccentColor1
    .Tint = 0
    .Shade = 0
End With

Vorteil: Wenn der Anwender ein anderes Office-Theme nutzt, passen sich die Farben an.

6) Icons zentral verwalten

Viele Datenbanken haben Buttons mit individuellen Bildern – schnell inkonsistent. Besser: gemeinsames Bild-Repository.

  1. Lege eine Tabelle tblIcons an mit Feldern: IconName, ImageData (OLE/Attachment).
  2. Lade alle benötigten Icons dort.
  3. Schreibe einen Helper, der Bilder auf Buttons setzt:
Public Sub ApplyIcon(btn As Access.Control, iconName As String)
    Dim rs As DAO.Recordset
    Set rs = CurrentDb.OpenRecordset("SELECT ImageData FROM tblIcons WHERE IconName='" & iconName & "'")
    If Not rs.EOF Then
        btn.PictureData = rs!ImageData
        btn.PictureType = acPictureTypeEmbedded
    End If
    rs.Close
End Sub

Nutze ApplyIcon Me.btnSave, "save" statt manuell Bilder zu setzen.

7) Lebendige Forms: Hover & Fokus-Effekte

Kleiner visueller Boost: Farbe bei Fokus/MouseOver.

Private Sub ctl_MouseMove(Index As Integer)
    Me.ActiveControl.BackColor = clrAccent
End Sub

Private Sub ctl_MouseLeave(Index As Integer)
    Me.ActiveControl.BackColor = clrBackground
End Sub

Tipp: Das funktioniert am besten mit ActiveX oder modernen Controls, nicht allen nativen Access-Controls.

8) Automatische Layout-Makros

Damit Abstände stimmen, kannst du ein kleines Layout-Makro schreiben:

Public Sub SnapToGrid(frm As Access.Form, Optional gridSize As Integer = 8)
    Dim ctl As Control
    For Each ctl In frm.Controls
        ctl.Left = Round(ctl.Left / gridSize) * gridSize
        ctl.Top  = Round(ctl.Top  / gridSize) * gridSize
    Next ctl
End Sub

Rufe das bei Bedarf aus dem VBA-Editor; das bringt Ordnung ins Layout.

9) Fehlerfarben & Validierung

Wenn ein Feld einen Fehler hat, sichtbar machen:

Public Sub MarkError(ctl As Control)
    ctl.BackColor = vbRed
    ctl.ForeColor = vbWhite
End Sub

Public Sub ClearError(ctl As Control)
    ctl.BackColor = clrBackground
    ctl.ForeColor = clrText
End Sub

Nutze das z. B. im BeforeUpdate von TextBoxen für Pflichtfelder.

10) Performance-Hinweise

Viele UI-Änderungen zur Laufzeit können Access bremsen:

Tipps:

  • Gruppiere Styling-Aufrufe statt einzeln.
  • Setze Me.TimerInterval = 0 während großer Loops.
  • Bei vielen Formularen lieber zentrale Routine als viele lokale Kopien.

11) Automatisierte Theme-Erzeugung

Willst du mehrere Farbvarianten? Schreibe ein kleines Tool, das aus einer Hauptfarbe ein komplettes Set ableitet:

Public Function GenerateTintedColors(baseColor As Long) As Collection
    Dim cols As New Collection
    Dim i As Integer
    For i = -30 To 30 Step 10
        cols.Add ChangeColorBrightness(baseColor, i)
    Next i
    Set GenerateTintedColors = cols
End Function

Private Function ChangeColorBrightness(c As Long, percent As Integer) As Long
    Dim r As Long, g As Long, b As Long
    r = (c And &HFF) * (100 + percent) / 100
    g = ((c \ &H100) And &HFF) * (100 + percent) / 100
    b = ((c \ &H10000) And &HFF) * (100 + percent) / 100
    ChangeColorBrightness = RGB(r, g, b)
End Function

So generierst du Farbabstufungen dynamisch.

Schlusswort: Styling hilft – aber nur, wenn es System hat

Ein hübsches Formular allein macht noch kein gutes Access-Projekt. Ein konsistentes, wartbares und durchdachtes UI-Styling reduziert Fehler, macht Anwender glücklich und vermittelt Kompetenz. Die Code-Helfer oben geben dir ein Gerüst, um Styling systematisch in deinen Projekten zu etablieren.

Thema „Visual-Aufhübschung als fertige Lösung“: thememydatabase.co.uk

Wenn du keine Zeit für eigene Styling-Tools hast, gibt es mit thememydatabase.co.uk eine fertige Lösung für Access-Styling. Dort findest du Add-Ins wie ApplyStyle und TMDThemeMaker, die Office-artige Themes, Farben und Icon-Sets auf deine Datenbank anwenden. Technisch laufen die Tools über VBA, indem sie Formulare/Controls iterieren und Eigenschaften wie Theme-Farben, Tint/Shade und Shared Images setzen. Das Ergebnis: visuell modernere Access-Oberflächen, ohne dass du alle Details selbst coden musst. Für Entwickler ein gutes Sprungbrett, um vorhandene Front-Ends schnell ansprechender zu machen – aber immer noch besser verstehen, was unter der Haube passiert, als nur Klick-für-Klick anzuwenden.

Ähnliche Beiträge

Nach oben scrollen