Access Blog

Kürzlich hatte ich ein Projekt bei dem XML-Dateien importiert wurden. Zur Auswahl der Dateien mussten diese zuvor aus einem Verzeichnis in ein Listenfeld ausgelesen werden.
Um das zu bewerkstelligen bedienen wir uns wieder einmal der “Microsoft Scripting Runtime” Bibliothek. Diese wird seit Office 2000 mit dem Office-Paket ausgeliefert und beinhaltet verschiedene Objekte die Dateizugriff möglich machen, u.a. auch das aus einem anderen Artikel bekannte FileSystemObject, kurz FSO genannt. Des weiteren werden die Objekte Files() und Folder() im Beispiel verwendet.

Das FileSystemObject hat verschiedene Methoden zum Datei- und Verzeichniszugriff. Wir verwenden im unteren Beispiel die Methoden GetFolder() und FolderExists(). Die Methode Files des Folder-Objektes liefert eine Collection von Dateiobjekten zurück. Diese Objekte kann man über die “Name” Eigenschaft überprüfen, ob es sich auch um den gewünschten Dateityp handelt, also z.B. “XML”.

Soweit erst mal die graue Theorie, kommen wir zum VBA-Code.
Zuerst die Deklaration der benötigten Objektvariablen. Benötigt wird dazu der Verweis auf Microsoft Scripting Runtime.

    Dim oFSO As Scripting.FileSystemObject
    Dim oFolder As Scripting.Folder
    Dim oFile As Scripting.FILE
    Dim cFile As String

Dann die Zuweisung von oFSO und oFolder:

Set oFSO = New Scripting.FileSystemObject
    If oFSO.FolderExists(Me!Folder) Then
        Set oFolder = oFSO.GetFolder(Me!Folder)

In einer Schleife über oFolder.Files, welches eine Collection aller Dateiobjekte ist, erfolgt das Auslesen der Dateinamen im Verzeichnis:

        For Each oFile In oFolder.Files
            DoEvents
            cFile = oFile.NAME
            If Right(cFile, 3) = "xml" Then
                ReDim Preserve aFiles(i)
                aFiles(i) = cFile
                i = i + 1
            End If
        Next

Zuletzt noch die Zuweisung der Dateinamen an das Listenfeld:

Me!Listenfeld1.RowSource = Join(aFiles, ";")

Den ganzen Beitrag lesen »

Hallo,
ich hab mich in letzter Zeit ein wenig mit den Möglichkeiten der GDI32.dll API Bibliothek befasst. Die GDI (Graphik Device Interface) beinhaltet Funktionen um z.B. das Aussehen eines Formulares zu verändern. Ob dreieckig, rund, abgerundet etc ist alles möglich. Auch Kombinationen von Formen sind zulässig.
OK, zugegeben, braucht eigentlich niemand. Aber man darf auch schon mal beim Design der Formulare etwas mehr an Kreativität zeigen als sonst.

Ich möchte euch jetzt zeigen wie ihr Coole runde Formulare erstellt.
Zuerst braucht ihr einen Hintergrund. Benützt dazu euer Grafikprogramm wie z.B. Photoshop etc. und erstellt eine Grafik. macht diese gleich etwas größer als das spätere Formular. Eine Verlaufsebene einfügen, darauf mit einem coolen Stil ein Kreis malen, in den Kreis ein weiterer Kreis mit weissem Hintergrund malen. Dies gibt der Rand eures Formulars.

Dann erstellt ein leeres Formular.
Plaziert darauf eure Steuerelemente wie gewohnt, denkt aber an die spätere Formular form.

Dann kommt der Code-Teil dran. Wir benötigen 3 API Funktionen, SetWindowRgn(), DeleteObject() und CreateEllipticRgn().

Hier der Deklarationsteil:

Private Declare Function SetWindowRgn _
                          Lib "user32" (ByVal hWnd As Long, _
                                        ByVal hRgn As Long, _
                                        ByVal bRedraw As Boolean) As Long

Private Declare Function DeleteObject Lib "gdi32" ( _
                                      ByVal hObject As Long) As Long

Private Declare Function CreateEllipticRgn Lib "gdi32.dll" ( _
                                           ByVal X1 As Long, _
                                           ByVal Y1 As Long, _
                                           ByVal X2 As Long, _
                                           ByVal Y2 As Long) As Long

Dim Region1 As Long

Dann im Ereignis “Beim Laden” wird die Form geändert. Die Koordinaten müsst ihr entsprechend anpassen, damit es bei euch passt.

Private Sub Form_Load()
    X1 = 29
    Y1 = 50
    X2 = 533
    Y2 = 552
    Me.Picture = CurrentProject.Path & "\hintergrund.gif"
    Region1 = CreateEllipticRgn(X1, Y1, X2, Y2)
    SetWindowRgn Me.hWnd, Region1, True
End Sub

Wenn das Formular entladen wird sollte auch die Form zurückgesetzt werden:

Private Sub Form_Unload(Cancel As Integer)
    DeleteObject Region1
End Sub

Hier noch ein Beispiel wie das ganze aussehen könnte:

Auf www.vbAchiv.net findet ihr zu den API-Funktinonen und zu weiteren Funktionen der GDI Erklärungen.
Ein komplexeres Beispiel als Download findet ihr auf access-o-mania

AV 2010

Wenn Sie in Ihrer Anwendung ISO Passmaße nach ISO 286 benötigen, so findet man im Internet zahlreiche Excel-Tabellen die sämtliche Abmaße für Bohrung und Welle enthalten.
Ich bin für mein Projekt auf der Seite www.siritec.com fündig geworden. Siritec stellt das Programm “PMTabelle V4.0.1″ für Solid Edge kostenlos zur verfügung, dieser Download enthält u.a. die Excel-Datei PassMassTabelle.xls, auf deren Struktur der folgende Programmcode aufbaut. Die Excel Arbeitsmappe enthält über 60 Arbeitsblätter, für jede Toleranzlage und Bohrung/Welle je eine Seite bei einem Nennmaß bis 500mm.

Der Aufbau im Einzelnen ist folgender:

• Spalte 1: Nennmassbereich untere Grenze (ausschließend)
• Spalte 2: Nennmassbereich obere Grenze (einschließend)
• Spalte 3 bis 38: Toleranzgrade 1 bis 18, wobei jedes Toleranzfeld 2 Spalten umfasst, für die untere und für die obere Abmaße.
• Zeile 2: Toleranzgrade
• Zeile 3: Kennung untere Grenze/obere Grenze
• Zeile 4-28 Toleranzen in µm

Was jetzt folgt ist die Excel Automation als late Binding, die ich nur in Ausschnitten zeigen und erleutern möchte.

Public UTG AS Double
Public OTG AS Double
...
Sub getPassMasse(istmass, Toleranzlage, Toleranzgrad)
    Dim ExcelApp AS Object
    Dim ws AS Long 'Worksheet - Zähler
    Dim tol AS long  'Toleranzen - Zähler
    Set ExcelApp = CreateObject("Excel.Application")
    ExcelApp.Workbooks.Open FileName:="c:\PassMassTabelle.xls", ReadOnly:=True
    With ExcelApp
        For ws = 1 To .Sheets.Count    'alle Arbeitsblätter durchsuchen
            If ExcelApp.Sheets(ws).Name = Toleranzlage Then
                For tol = 4 To 28
                    If istmass <= CDbl(ExcelApp.Sheets(ws).Cells(tol, 2)) And istmass > CDbl(ExcelApp.Sheets(ws).Cells(tol, 1)) Then
                        UTG = ExcelApp.Sheets(ws).Cells(tol, 2 * Val(Toleranzgrad) + 1)
                        OTG = ExcelApp.Sheets(ws).Cells(tol, 2 * Val(Toleranzgrad) + 2)
                        GoTo Ausstieg
                    End If
                Next tol
            End If
        Next ws
    End With

Ausstieg:
    Excel_Terminate
End Sub

Zuerst wird das Excel Objekt instanziert und die Arbeitsmappe PassMassTabelle.xls geöffnet.
In der äußeren Schleife werden alle 69 Arbeitsblätter durchsucht nach dem, welches der entsprechenden Toleranzlage entspricht. Ist das Abeitsblatt gefunden werden in einer inneren Schleife die Zeilen 4 bis 28 durchlaufen, und nach dem Nennmassbereich gesucht, in diesen das Istmass gehört. Ist der richtige Bereich gefunden werden die Toleranzen ausgelesen. die richtigen Zellen findet man über den Toleranzgrad. Beispielsweise ergibt Toleranzgrad 7 die Zellen 15 und 16 der entsprechenden Zeile. So wird auf eine zusätzliche Schleife verzichtet. Sind die Toleranzen gefunden erfolgt der Ausstieg über eine Sprungmarke.
Was man bei der Excel Automation immer machen sollte ist eine Prüfung ob Excel schon geöffnet ist oder nicht, damit die Instanzierung des Excel Objektes auch funktioniert.
Die Funktion Excel_Terminate dient dazu, Excel zu schließen oder nur die Arbeitsmappe zu schließen, je nach dem ob beim Start Excel schon geöffent war.
Zu beidem gibts in den Newsgroups bzw. einschlägige Foren genug Beispiele.

UTG und OTG sind unteres und oberes Abmass in µm. das bedeutet, dass das Istmass du beiden hinzuzuaddieren ist, um die Toleranzgrenzen zu erhalten.

Zur Auswahl einer Passung kann man sich z.B. ein kleines Popup-Formular erstellen, das beim schließen die gefundenen Toleranzgrenzen in das Eingabeformular eintragen. Nachfolgend noch ein paar Screenshots wie das aussehen könnte.

AV 2010

Bei der manuellen Messwerterfassung hat man immer die Unsicherheit des Faktors “Mensch” zu berücksichtigen. Zahlendreher oder zuviele Nullen sind da schnell mal eingegeben, und im Nachhinein schwer zu finden. Da ist es besser man macht eine Plausibilitätsprüfung indem man das Formular ungebunden macht und bei klick auf den Speicherbutton die Eingabewerte überprüft.

Z.B. auf die Anzahl der Stellen, ob positiv oder negativ, ob größer oder kleiner von einem bestimmten Wert, oder ob in einem bestimmten Zahlenbereich liegend.

Das Problem daran ist, dass sich diese Begrenzungen ständig ändern können. Dann muss man den VBA-Code durchsuchen wo man diese Plausibilitätsprüfung gemacht hat. Besser wäre das doch wenn man in einer Tabelle alle Plausibilitäten einfach ablegen könnte von wo aus sie einfach zu administrieren sind. Und genau das wollen wir jetzt machen.

Zuerst die Tabelle.
Jeder Messwert hat eine bestimmte Nummer oder Namen. Außerdem benötigen wird ein Vergleichsmuster, und eine Werteliste mit den einzelnen Werten gegen den der Messwert abgeprüft wird.

Ein Datensatz in dieser Tabelle sieht z.B. so aus:

Im Muster sieht man Platzhalter in geschweiften Klammern stehen, diese werden dann mit den Werten aus der Werteliste ergänzt.
Den ganzen Beitrag lesen »

XML Dokumente sind hirachisch strukturierte Dokumente die aus einzelnen Knoten bestehen, in denen sich Informationen und weitere Unterknoten befinden können. Um dies zu verdeutlichen habe ich eine einfache Struktur erstellt, eine Bücherliste mit 3 Einträgen:

Um Informationen aus XML Dokumenten per VBA einzulesen bietet sich das DOM-XML an. Genaue Informationen zum DOM-XML findet man z.B. auf dieser MSDN-Seite: http://msdn.microsoft.com/de-de/library/aa468547.aspx

Um die benötigten Objekte zu erstellen benötigt man bei early-Binding einen Verweiss auf die XML Bibliothek. Dazu den Verweis Microsoft XML, v3.0 einbinden. Es gibt auch neuere Versionen dieser Bibliothek, doch die 3.0 genügt vollkommen für diese Zwecke und hat sich bewährt.

Danach kann man das benötigte Objekt deklarieren:
Dim objDomDoc As New DOMDocument

Um auf die Knoten zugreifen zu können benötigt man ein weiteres Objekt:
Dim objNode As IXMLDOMNode

Zuerst wird die XML-Datei geöffnet:

Dim FileName As String
Filename = "c:\test\myXMLFile.xml"
objDomDoc.async = False
objDomDoc.Load Filename

Dann das Objekt für den Wurzel-Knoten gesetzt:
Set objNode = objDomDoc.documentElement
Den ganzen Beitrag lesen »

Mal angenommen Sie wollen Eingaben in einem ungebundenem Formular auf ihre Richtigkeit prüfen. Eine geläufige Vorgehensweise wäre z.B. den Feldinhalt gegen Null zu prüfen, oder die Länge auf eine bestimmte Mindestanzahl an Zeichen. Das ist alles aber ziemlich ungenau und lässt meist großen Spielraum bei der Falscheingabe.

Eine alternative Möglichkeit ist es sogenannte Reguläre Ausdrücke (Regexp, regular expressions) zu verwenden, welche in vielen Entwicklungssprachen und vorallem in Scriptsprachen wie PHP bekannt sind.

Reguläre Ausdrücke bestehen aus einem Muster, das in Begrenzer eingeschlossen wird, sowie aus verschiedenen Schaltern, den Modifizierern. In VB/VBA wurde allerdings auf die Begrenzer verzichtet, und die Modifizierer sind aus der Zeichenkette – welche dem regulären Ausdruck entspricht – ausgegliedert als Eigenschaft des entsprechenden Objektes.

Wagen wir mal einen Blick über den Tellerand hinüber zur Scriptsprache PHP und definieren wir mal einen regulären Ausdruck:

In diesem Muster sind so gut wie alle Techniken von regulären Ausdrücken enthalten, dass nicht kundige schon ins grübeln kommen. Mir ging das nicht anderst. Im obigen Beispiel wollen eine Eingabe einer Postleitzahl auf Ihre Richtigkeit überprüfen. Die Postleitzahl könnte z.B. so aussehen: D-80807 oder D80807 oder nur 80807.
Den ganzen Beitrag lesen »

Angenommen sie arbeiten in einer Personalabteilung. Bei Ihnen landen fast täglich Urlaubsanträge mit den Angaben Urlaubsbeginn, Urlaubsende, AnzahlTage. Soweit ja easy, aber leider sind über 10% der Anträge ohne die Angabe der Anzahl Urlaubstage. Sie holen den großen Kalender raus, zählen die Werktage, dann den zweiten Kalender mit den Feiertagen raus holen und prüfen ob ein Feiertag dazwischen liegt usw.

Die Lösung: Der Urlaubstage-Rechner.

Man sehe sich erst mal nachfolgenden VBA-Code an, der in einem Modul steht:

Public Function urlaubstage(Startdatum As Date, Enddatum As Date) As Long
    Dim i As Integer
    Dim tempDate As Date

    If Not IsDate(Startdatum) Or Not IsDate(Enddatum) Then
        MsgBox "Bitte gültiges Startdatum und Enddatum eingeben", vbExclamation + vbOKOnly
        Exit Function
    End If

    If DateDiff("d", Startdatum, Enddatum) < 0 Then
        MsgBox "Das Enddatum muss nach dem Startdatum liegen!", vbExclamation + vbOKOnly
        Exit Function
    End If

    For i = 0 To DateDiff("d", Startdatum, Enddatum)
        tempDate = DateAdd("d", i, Startdatum)
        If Weekday(tempDate) <> 1 And Weekday(tempDate) <> 7 Then
            'tempDate ist kein Wochenende
            If Not istFeiertag(tempDate) Then
                'tempDate ist kein Feiertag
                urlaubstage = urlaubstage + 1
            End If
        End If
    Next i
End Function

Den ganzen Beitrag lesen »

Ein Startbildschirm kann verschiedenste Aufgaben erfüllen. Z.B. den Anwender begrüßen oder über Neuigkeiten informieren. Ein weiterer Aspekt ist den Start der eigentlichen Anwendung bewusst zu verzögern um eine Art Barriere aufzubauen. Dies könnte man z.B. dafür Nutzen eine eingeschränkte Anwendung zu erstellen, um die Anwender zu drängen eine entsprechende Lizenz zu kaufen.

Dies zu realisieren ist sogar ziemlich einfach. Man erstelle ein Formular mit einer deaktivierten Befehlsschaltfläche die im Klick-Ereignis das Anwendungs-Formular öffnet. Im Formularmodul dann dieser Code:

Option Compare Database
Option Explicit

Dim Startintervall As Integer

Private Sub cmdApp_Click()
    DoCmd.Close acForm, Me.Name
    DoCmd.OpenForm "Anwendungsform"
End Sub

Private Sub Form_Timer()
    If Startintervall <= 10 Then
        Me.TimerInterval = 1000
        Me!cmdApp.Caption = 10 - Startintervall
        Startintervall = Startintervall + 1
    Else
        Me.TimerInterval = 0
        Me!cmdApp.Caption = "Anwendung starten"
        Me!cmdApp.Enabled = True
    End If
End Sub

Den ganzen Beitrag lesen »

Auf die Schnelle die aktuellen Datensätze nach Excel rüberschieben wäre doch nicht schlecht, und beeindruckt doch sicher euren Chef – der von der Materie wieder keine Ahnung hat
Und wenn der wüsste wie einfach das geht…

Hier mal der ganze Code der dazu notwendig ist:

Dim oExcel As Object, i As Integer
Dim db As Database
Dim rs As Recordset
Set db = CurrentDb

On Error Resume Next
Err.Clear
Set oExcel = CreateObject("Excel.Application")
If Err.Number <> 0 Then Set oExcel = CreateObject("Excel.Application")
On Error GoTo 0
With oExcel
    .Visible = True
    .Workbooks.Add
    .ActiveSheet.Name = "Arbeitsblatt1"
    Set rs = db.OpenRecordset(Me.RecordSource, dbOpenSnapshot)
    For i = 0 To rs.Fields.Count - 1
        .Cells(1, i + 1) = rs.Fields(i).Name
    Next i
    .Range("A2").SELECT
    .Selection.CopyFromRecordset rs
End With
rs.close
set rs = Nothing
set db = Nothing
Set oExcel = Nothing

Da obige Methode late Binding ist, benötigt man keinen Verweiss auf Excel.
Mittels .Cells(zeile,spalte) wird die Spaltenüberschriften eingetragen, die aus dem Namen der Datenfelder kommen. .Range(“A2″).SELECT setzt den Cursor auf das Feld A2 in Excel, und mittels .Selection.CopyFromRecordset rs werden alle Daten im aktuellen Recordset auf einen Rutsch nach Excel kopiert.

AV 2009

Popup-Formular, d.h. Formulare mit der Eigenschaft Popup = ja, lassen sich mittig ausrichten indem man die Eigenschaft “Automatisch zentrieren” auf ja stellt. Will man aber z.B. mehrere Popup-Formular an definierter Stelle positionieren, dann muss man dafür schon ein Stückchen VBA-Code einsetzen.

Die entsprechende Anweisung dazu lautet:
Forms("Formularname").Move Links, Oben, Breite, Höhe
Die Angaben Links, Oben, Breite und Höhe sind in Twips anzugeben. Die Angabe des Wertes Links ist erforderlich, die restlichen Angaben sind Optional.

Die Maßeinheit Twip bedeutet 1/20 eines Inch-Punktes, was 1/1440 Inch (Zoll) entspricht.
Demnach ist 1mm gerundete 56,7 Twips.

Probiert es einfach mal aus. Wenn ihr aber zu große Werte eingebt, wird euer Formular nicht mehr zu sehen sein da es außerhalb dem sichtbaren Bereich “liegt”.

Ein anderer Anwendungsfall ist, dass ein Popup-Formular relativ zu einem anderen Formular oder einem Steuerelement auf einem anderen Fomular plaziert sein soll. Dies ist z.B. bei dem DatePicker der Fall, den ich in einem anderen Beitrag beschrieben habe.

Nachfolgend eine Prozedur die ein Popup-Formular öffnet und direkt unter einer Befehlsschaltfläche plaziert:
Den ganzen Beitrag lesen »

Bekannter Weise gibt es für Formular-Objekte keine Zeichen-Befehler wie line() oder Circle(), dies ist den Berichts-Objekten vorbehalten. Das kann man ärgerlich finden oder nicht, ändern kann man das eh nicht. “Man” sucht also nach Alternativen – der Kunde will das schließlich.

Fündig wird man wie so oft bei Stephen Lebans, einem Access Enthusiast der sein Wissen bereitwillig teilt. Auf http://www.lebans.com/imageclass.htm findet man für Access 97 und 2000+ 2 Downloads namens PictureBoxA97.zip und PictureBoxA2K.zip.

Der Download besteht aus einer Beispieldatenbank die die Funktionsweise demonstriert. Für eigene Projekte sind die beiden Klassenmodele clsPictureBox und clsVertices relevant, die man am besten gleich in eine leere Access-Datei kopiert.

Meine Aufgabenstellung war, anhand von Konstruktionsangaben offene und geschlossene Grundrisszeichnungen darzustellen. Die Angaben waren Kundenspezifisch und bestehen aus Innenwinkel und Länge von Linien, also eine relative Polarkoordinaten. Ein Quadratischer Grundriss der Länge 1000 hat daher die folgenden Angaben:
(90/1000), (90/1000), (90/1000), (90/1000)
Gibt man noch eine Tiefe von 200mm vor, dann sieht die generierte Zeichnung so aus:

Den ganzen Beitrag lesen »

Im Beitrag “Bilder in Access” hatte ich es ja kurz angesprochen wie man einen echten Bilderzoom realisieren kann. Ich hab mir heute mal 1,5 Stunden Zeit genommen und das mal ausprobiert was für mich in der Theorie schon klar war.

Also, man suche ein freies JavaScript für einen Bilderzoom das einem gefällt, und “bastelt” damit per Output-Stream eine HTML-Datei, die man per Webbrowser-Control anzeigen lassen kann.
Siehe dazu der Beitrag über das Webbrowser-Control.

Hier mal ein kurzer Blick in den VBA-Code:

Open CurrentProject.Path & "\index.html" For Output As #1
Print #1, "<!DOCTYPE HTML PUBLIC " & Chr(34) & "-//W3C//DTD HTML 4.0 Transitional//EN" & Chr(34) & ">"
Print #1, "<!-- saved from url=(0013)about:internet -->"
Print #1, "<html>"
Print #1, "<head>"
Print #1, "<script language=" & Chr(34) & "JavaScript1.2" & Chr(34) & ">"
Print #1, "var zoomfactor=0.05; //Enter factor (0.05=5%)"
Print #1, "function zoomhelper(){"
Print #1, "    if (parseInt(whatcache.style.width)>10&&parseInt(whatcache.style.height)>10){"
Print #1, "        whatcache.style.width = parseInt(whatcache.style.width) + parseInt(whatcache.style.width) * zoomfactor * prefix"
Print #1, "        whatcache.style.height = parseInt(whatcache.style.height) + parseInt(whatcache.style.height) * zoomfactor * prefix"
Print #1, "    }"
Print #1, "}"

Bei JavaScript ist peinlich genau auf die korrekte Schreibweise zu achten, kein Fehler wird einem dabei verziehen. Vorallem bei der Groß-/Kleinschreibung – JavaScript erfordert immer Kleinschreibung der Schlüsselwörter. Also ein style.Width funktioniert schon nicht mehr, richtig wäre hier style.width.

Für meinen Bilderzoom habe ich das Script von javascriptkit.com verwendet, welches man hier bekommt: http://www.javascriptkit.com/script/script2/imagezoom.shtml

Weiterhin wichtig ist die Ermittlung der Bildgröße Breite/Höhe in Pixeln.
Dazu dieser Code, der breite und höhe in globale Variablen schreibt:

Private Sub getPictureProperties(bild As String)
    Dim H As Double
    Dim W As Double
    Dim verhaeltnis As Double
    W = LoadPicture(CurrentProject.Path & "\" & bild).Width
    H = LoadPicture(CurrentProject.Path & "\" & bild).Height
    W = (W * 96) / 2540
    H = (H * 96) / 2540
    breite = Round(W, 0)
    hoehe = Round(H, 0)
End Sub

Obiger Code geht aber nur mit jpg, gif und bmp Bildern.
Jetzt fehlt noch ein bisschen Drum herum, eine Tabelle mit den Bild-Informationen und ein Formular mit dem Webbrowser-Steuerelement.

Wer jetzt aber an der Umsetzung scheitert, der kann von mir meine Test-Anwendung mit ein Paar Bildern kostenlos bekommen. Einfach per Email anfragen.

AV 2008

Die bisherige Vorgehensweise eine Fehlerbehandlung zu realisieren war, einen Error Handler in einer Prozedur einzufügen und dann entweder per MsgBox eine Meldung ausgeben oder eine Funktion aufrufen die den Fehler entsprechend behandelt. Das könnte z.B. so aussehen:

Sub MeineProzedur()
    On Error goto Fehlerbehandlung
    'Programmcode...

Exit_Here:
    Exit sub

Fehlerbehandlung:
    Msgbox Err.description
    Resume Exit_Here
End sub

Der Entwickler wünscht sich natürlich, dass diese Routine automatisch und an zentraler Stelle implementiert wäre, und er nicht in jede Prozedur eine Fehlerbehandlung einbauen müsste. Das war bislang leider nicht möglich – jetzt bietet die Firma iTech Masters (www.everyaccess.com) eine entsprechende Software an, die ich hier vorstelle. Das Produkt steht nach der Installation als AddIn in der VBA IDE zur Verfügung. Das AddIn Menü sieht wie folgt aus:

Den ganzen Beitrag lesen »

Man stelle sich folgendes Szenario vor:
Sie möchten einen Wareneingang verbuchen und danach einen neuen Einkaufs- und Verkaufspreis berechnen. Dazu müssen Sie 2 Datenbankoperationen durchführen. Sie verbuchen die Ware ins Lager und wollen den Einkaufs- und Verkaufspreis in der Artikeltabelle aktualisieren. Wenn bei der zweiten Operation ein Fehler auftaucht, wird zwar der Wareneingang verbucht, aber Einkaufs- und Verkaufspreis werden nicht in die Tabelle geschrieben. Durch solche Vorgänge ist es leicht möglich dass Tabellen inkonsistent werden.

Tritt also nun bei der zweiten Operation ein Fehler auf und eine Fehlerbehandlung greift, so sind Änderungen der ersten Operation bereits geschrieben. Jetzt müssten Sie eine Methode zur Hand haben, mit der sie alle vorherigen und zusammenhängenden Operationen einfach rückgängig machen könnten. In der Fachsprache wird dieser Vorgang ein Rollback genannt. Und diese Methode bietet uns Access in der Form von Transaktionen.

Microsoft Access bzw. die Jet-Engine stellt dafür zumindest schon seit Access 97 ein leistungsstarkes Transaktionenmodel mit entsprechenden Methoden zur Verfügung. Eine Transaktion hat folgende Methoden:

• BeginTrans
• CommitTrans
• Rollback

Den ganzen Beitrag lesen »

Importieren Sie regelmäßig Daten, z.B. von externen Mitarbeitern, so müssen Sie diese i.d.R. zuerst aufbereiten, d.h. mit dem vorhandenem Datenstamm abgleichen. Dazu empfiehlt sich die Daten in eine separate Hilfstabelle zu importieren, diese dann zu bearbeiten und dann erst zu den Stammdaten hinzuzufügen. Sie werden aber bald feststellen, dass dieses ständige importieren und wieder leeren der Hilfstabelle die Anwendung bzw. das Backend schnell anwachsen lässt.

D.H. der Administrator oder sonstig Verantwortliche muss regelmäßig das Backend anfassen und Komprimieren. Dabei muss er peinlich genau darauf achten, dass alle Mitarbeiter ihre Anwendung geschlossen halten. Eigentlich ein Unding, und bei einem 7×24 Stunden Betrieb sogut wie unmöglich.

Die Lösung aus der Misere ist, das Importieren und Aufbereiten außerhalb des Backends zu tätigen und dann erst die aufbereiteten Daten in das Backend einfügen, und das ganze soll natürlich auch automatisiert ablaufen. Dazu ist folgender Ablauf sinnvoll:

• temporäre Datenbank im Ordner des Backends erstellen
• Tabelle in temporärer Datenbank erstellen
• Daten in Tabelle schreiben
• Daten aufbereiten
• Daten in das Arbeits-Backend übernehmen

Den ganzen Beitrag lesen »

Will man z.B. einen Artikeltext in einem Formular oder bei einer Word-Ausgabe ausgeben, weiss man oft nicht wie lang der Text ist, und man ist genötigt den String zu kürzen.
Man kann aber auch den Text in einzelne Zeilen aufsplitten, die man in ein Array schreibt. Daraus kann man z.B. Strings zusammensetzen und ein vbcrlf zwischen die einzelnen Zeilen schreiben. Oder bei der zeilenweisen Ausgabe in ein Worddokument, z.B. ein Angebot, direkt aus dem Array schreiben.

Der Algorithmus für diesen Ablauf ist im Groben:
- Prüfen ob String größer als x-Zeichen
- Schleife über alle Zeichen setzen
- Teilstringe der größe x bilden
- Teilstringe untersuchen und Trennzeichen finden (Leerzeichen, Punkt, Komma)
- Wörter die länger als x sind mit Bindestrich aufteilen
- Bearbeitung des letzten Teilstrings
- Ende Schleife
- einzelne Teilstrings säubern (Leerzeichen am Anfang, vbcrlf)
Den ganzen Beitrag lesen »

Im Laufe des Entwicklungsprozesses einer Access-Anwendung, hat der Entwickler eine Fülle an kleinen, funktionell abgegrenzbaren Aufgabenstellungen zu bewältigen. Der Kunde gibt vor, welche Funktionalitäten bzw. Abläufe die Anwendung abbilden muss. Im besten Falle hat er das noch schriftlich und sogar mit einem dezidierten Ablaufplan. Dem Entwickler seine Aufgabe ist es dabei, aus mündlichen Angaben, E-Mails, Telefax, eigenen Aufzeichnungen, Pflichtenhefte oder aus eigener Erfahrung Code-Algorithmen zu entwerfen und in VBA-Codezeilen niederzuschreiben. Dieser Artikel gibt Auskunft über die notwendigen Techniken und Methoden die ein Entwickler kennen muss um dabei effektiv vorzugehen.

Man unterscheidet zwischen Entwurfsprinzipien und Entwurfstechniken. Erstere sind als allgemeingültig und anerkannt zu betrachten. Entwurfsprinzipien sind universell anwendbar. Hingegen Entwurfstechniken im speziellen anwendbare Techniken und Vorgehensweisen darstellen.

Die 3 wichtigsten Entwurfsprinzipien:

• schrittweise Verfeinerung
• Modularisierung
• Strukturierung

Das erstere Entwurfsprinzip halte ich für Entwickeln von Access-Anwendung als das brauchbarste, da die beiden anderen beiden auf große bis sehr große Softwareprojekte abzielen. Im nachfolgenden werde ich auf die schrittweise Verfeinerung eingehen und die beiden anderen Prinzipien außer acht lassen.
Den ganzen Beitrag lesen »

Um z.B. Rechnungen oder Lieferscheine zu erstellen und an den Kunden Weiterzugeben eignet sich nicht immer ein Access Bericht, vorallem dann nicht wenn die Weitergabe elektronisch in Form von einer E-Mail erfolgt.
Aus meiner Praxis hat sich als beste Methode herausgestellt, eine seprarate Word-Vorlage zu erstellen. Darin fügt man Textmarken ein, z.B. eine für den Kopf und in der Zeile darunter eine für die Angebotspositionen. Nur 2 Textmarkten? Genau, denn der Trick an der Sache ist, dass ich in der Zeile mit der Textmarke für die Angebotspositionen feste Tabulatoren einsetze:

Man benötigt die Tabulatoren z.B. für lfd.Nr, Artikelnummer, Menge + Einheit, Artikeltext, Euro-Zeichen und Preis. Beachtet wie rum die Tabulatoren gerichtet sind. Um z.B. bei den Preisen Komma und Tausender-Punkt untereinander zu haben muss man den Preis rechts ausrichten.
Den ganzen Beitrag lesen »

Im letzten Teil der Serie geht es nun darum wie man in der Praxis die Mehrsprachigkeit realisiert. In der Regel ist es so, dass man zuerst die Formulare und Berichte ganz normal in Deutscher Sprache erstellt.
Um nun die Sprachcodes zu handhaben kann man mit einem Blatt Papier anfangen und Code mit Sprache als Liste aufschreiben. Oder man macht das z.B. in Excel. Wichtig bei dieser Sache ist, dass der Sprachcode fortlaufend ist und dass keine doppelten Codes vorhanden sind.
Hat man alle Deutschen Texte und Sprachcodes erfasst, ändert man nun im Formular/Bericht die Beschriftungen bzw. ControlTipText ab.
OK, das ist mir persönlich zu mühselig, und ich habe daher kurzerhand eine Funktion erstellt, die das automatisch für mich macht.
Den ganzen Beitrag lesen »

Im 2. Teil des Artikels befasse ich mich mit Wertelisten in Kombinationsfeldern und Listenfeldern. Außerdem gibt es bei diesem Thema noch ein paar Fallen, die es zu entschärfern gilt.

Wertelisten sind 1 bis n-Spaltig, wobei man nicht zuviel Spalten verwenden sollte. Der Aufbau einer 2-Spaltigen Werteliste mit Spaltenüberschriften ist wie folgt:
‘Überschrift1′;’Überschrift2′;’Wert1_Spalte1′;’Wert1_Spalte2′;’Wert2_Spalte2′; usw.

Der Ablauf ist wie folgt. Man erstellt ein Kombinationsfeld bzw. Listenfeld und gibt im Dialog an selbst Werte einzutragen (Werteliste). Dann trägt man die codierten Textnummern in das Eingabefeld ein. In den Eigenschaften betrachtet sieht das z.B. wie folgt aus:

Den ganzen Beitrag lesen »