<\/p>\n
Die Klasse clsFlexSearch lässt sich einfach in Formulare integrieren und fügt einem einfachen Textfeld umfassende Suchmöglichkeiten hinzu. Wie Sie diese Suche implementieren, erfahren Sie im Beitrag Flexible Suche in Formularen (www.access-im-unternehmen.de\/965). Der vorliegende Beitrag erläutert die Klasse clsFlexSearch und stellt den Code vor, damit Sie diesen nachvollziehen und ihn gegebenenfalls an Ihre eigenen Bedürfnisse anpassen können.<\/b><\/p>\n
Alles in einer Klasse<\/b><\/p>\n
Die Klasse clsFlexSearch <\/b>bietet nicht nur eine praktische Suchfunktion, sondern Sie ist außerdem auch noch ganz leicht zu implementieren.<\/p>\n
Der Grund ist, dass der komplette Code in einer einzigen Klasse gekapselt ist und Sie dem Formular, das Sie mit der Funktion ausstatten möchten, lediglich einige Zeilen VBA-Code hinzufügen müssen.<\/p>\n
Die Klasse hat die Aufgabe, ein Textfeld mit einer Suchfunktion zu versehen (s. Bild 1). Der Benutzer gibt dort das Suchkriterium ein und die in der Klasse enthaltenen Ereignisprozeduren liefern die Funktionen dazu:<\/p>\n
![\"Die](\"..\/fileadmin\/_temp_\/2014_06\/pic_964_001.png\")
<\/p>\n
Bild 1: Die Klasse clsFlexSearch in Aktion<\/span><\/b><\/p>\n Die Klasse clsFlexSearch<\/b><\/p>\n Um die Klasse anzulegen, erstellen Sie im VBA-Editor über Einfügen|Klassenmodul <\/b>ein neues Klassenmodul und speichern es unter dem Namen clsFlexSearch<\/b>.<\/p>\n Die Klasse verwendet insgesamt vier Member-Variablen, denen der Benutzer vom Klassenmodul des Formulars aus die entsprechenden Eigenschaftswerte zuweist. Diese Member-Variablen werden wie folgt im Kopf des Klassenmoduls clsFlexSearch <\/b>deklariert:<\/p>\n Eigenschaften zuweisen<\/b><\/p>\n Die in diesen vier Variablen gespeicherten Werte sollen über öffentliche Eigenschaften der Implementierung der Klasse clsFlexSearch <\/b>zugewiesen werden, also etwa so:<\/p>\n Diese Eigenschaften zum Entgegennehmen der Werte für die Member-Variablen programmieren wir in der Klasse clsFlexSearch <\/b>als Public Property Let<\/b>– beziehungsweise Public Property Set<\/b>-Prozeduren. Die erste sieht wie in Listing 1 aus und nimmt als Parameter einen Wert entgegen, der nach dem Zuweisen in die Variable m_Suchabfrage <\/b>eingetragen wird.<\/p>\n Listing 1: öffentliche Eigenschaft für die Angabe der Suchabfrage<\/span><\/b><\/p>\n Für Wert-Variablen etwa vom Datentyp String <\/b>verwenden wir das Schlüsselwort Let<\/b>, später für Objektvariablen das Schlüsselwort Set<\/b>.<\/p>\n Die Public Property Let<\/b>-Prozedur PKFeld <\/b>aus Listing 2 erwartet den Namen des Primärschlüsselfeldes und weist diesen der Membervariablen m_PKFeld <\/b>zu.<\/p>\n Listing 2: öffentliche Eigenschaft für die Angabe des Primärschlüsselfeldes<\/span><\/b><\/p>\n ähnlich arbeitet die Public Property Let<\/b>-Prozedur PKFeldEinschliessen<\/b>. Die an diese Eigenschaft übergebene Variable legt fest, ob der Name des Primärschlüsselfelds im Such-Textfeld automatisch ergänzt und ob es bei der Suche über alle Felder berücksichtigt werden soll (s. Listing 3).<\/p>\n Listing 3: Hiermit legen Sie fest, ob der Primärschlüssel für die Suche berücksichtigt wird.<\/span><\/b><\/p>\n Interessant wird es bei der Public Property Set<\/b>-Prozedur Suchfeld<\/b>. Diese nimmt einen Verweis auf das Textfeld entgegen, das zur Eingabe der Suchbegriffe verwendet werden soll.<\/p>\n Die Prozedur speichert diesen Verweis in der Membervariablen m_Suchfeld<\/b>, welches den Datentyp Textbox <\/b>aufweist und mit dem Schlüsselwort WithEvents <\/b>deklariert wurde.<\/p>\n Auf diese Weise können Sie, auch wenn das Textfeld gar kein Objekt der aktuellen Klasse ist, in dieser Klasse auf seine Ereignisse reagieren. Dazu tragen wir für die den relevanten Ereignissen entsprechenden Eigenschaften jeweils den Wert [Event Procedure] <\/b>ein – hier für die Eigenschaften OnKeyUp <\/b>und OnKeyDown<\/b> (s. Listing 4).<\/p>\n Listing 4: Zuweisen des Such-Textfeldes<\/span><\/b><\/p>\n Auf die entsprechenden Ereignisse Bei Taste ab <\/b>und Bei Taste auf <\/b>reagieren wir, um bei der Eingabe von Zeichen erstens zu prüfen, ob hier eine automatische Vervollständigung angewendet werden muss, und zweitens, um auf die Tab-Taste und das Zeichen Doppelpunkt (:) zu reagieren.<\/p>\n Beides soll den als Autovervollständigungs-Wert angegebenen Ausdruck bestätigen und einen Doppelpunkt hinten anfügen, damit der Benutzer hier den Vergleichsausdruck eintragen kann.<\/p>\n Beim Herunterdrücken einer Taste<\/b><\/p>\n Nun müssen wir die Ereignisprozedur programmieren, die beim Herunterdrücken einer Taste im Suchen-Textfeld ausgelöst wird. Die Prozedur sieht wie in Listing 5 aus und liefert mit KeyCode <\/b>einen der gedrückten Taste entsprechenden Integer-Wert sowie mit Shift <\/b>einen Wert, der angibt, ob gleichzeitig die Umschalt<\/b>-, die Alt<\/b>– oder die Strg<\/b>-Taste gedrückt wurde.<\/p>\n Listing 5: Ereignisprozedur, die bei Herunterdrücken einer Taste im Suchen-Textfeld ausgelöst wird<\/span><\/b><\/p>\n Die Prozedur speichert zunächst den KeyCode <\/b>in der Variablen intKeyCode<\/b>, die wir im Kopf des Klassenmoduls wie folgt deklarieren:<\/p>\n Dies ist nötig, weil wir den KeyCode <\/b>in einigen Fällen auch noch in der später aufgerufenen Ereignisprozedur m_Suchfeld_KeyUp <\/b>benötigen, diese aber in m_Suchfeld_KeyDown <\/b>auf den Wert 0 <\/b>setzen, damit die eigentliche Wirkung dieses Tastendrucks unterdrückt wird.<\/p>\n Die folgende Select Case<\/b>-Bedingung prüft einige Werte für intKeyCode<\/b>. Der erste Zweig reagiert auf die Werte 9 <\/b>und 190<\/b>. 9 <\/b>entspricht der Tab<\/b>-Taste, 190 <\/b>dem Doppelpunkt.<\/p>\n Eigentlich entspricht 190 der Taste, auf der sich der Punkt und der Doppelpunkt befinden, aber auf den Punkt wollen wir nicht reagieren. Also verlassen wir die Prozedur, wenn der zweite Parameter, Shift<\/b>, nicht den Wert 1 (oder acShiftMask<\/b>) enthält.<\/p>\n In diesem Fall stellen wir KeyCode <\/b>auf den Wert 0 <\/b>ein, da etwa das Betätigen der Tab<\/b>-Taste sonst zum Verlassen des Textfeldes führen würde. Die Prozedur speichert den aktuellen Inhalt des mit m_Suchfeld <\/b>referenzierten Such-Textfeldes in der Variablen strSuche<\/b>. Die Variable intSelStart <\/b>nimmt die aktuelle Position der Einfügemarke auf, die Variable intSelLength<\/b> die Länge des aktuell markierten Textes.<\/p>\n Nun benötigen wir eine Liste aller Suchfelder, also derjenigen Felder, die in der für die Eigenschaft Suchabfrage <\/b>angegebenen Abfrage enthalten sind.<\/p>\n Der Performance halber wollen wir diese nicht jedes Mal neu aus der Definition der Abfrage abrufen, deshalb speichern wir diese einmalig in einem Array namens strSuchfelder<\/b>.<\/p>\n Um dieses nur einmal zu füllen, prüfen wir zunächst mithilfe der Funktion ArrayGefuellt<\/b>, ob das Array strSuchfelder <\/b>bereits gefüllt ist. Diese Funktion erläutern wir im Detail im Beitrag Mit Arrays arbeiten <\/b>(www.access-im-unternehmen.de\/963<\/b>).<\/p>\n Die Variable strSuchfelder <\/b>deklarieren wir übrigens wie folgt im Kopf des Klassenmoduls clsFlexSearch<\/b>:<\/p>\n Wenn das Array noch nicht gefüllt ist, liest die Prozedur SuchfelderEinlesen <\/b>die Felder der unter m_Suchabfrage <\/b>angegebenen Abfrage in das Array strSuchfelder <\/b>ein (s. Listing 6). Die Prozedur öffnet ein QueryDef<\/b>-Objekt auf Basis der angegebenen Abfrage und durchläuft in einer For Each<\/b>-Schleife alle Felder dieser Abfrage. Dabei prüft die Prozedur, ob es sich bei dem aktuellen Feld um das als Primärschlüssel angegebene Feld handelt und dieses gleichzeitig für die Suche berücksichtigt werden soll.<\/p>\n <\/p>\n Listing 6: Einlesen von Suchfeldern in ein Array<\/span><\/b><\/p>\n Ist dies der Fall oder handelt es sich um eines der übrigen Felder, fügt die Prozedur den Namen des Feldes zum Array hinzu, wobei zuvor die Anzahl der zulässigen Elemente angepasst wird.<\/p>\n Die Prozedur ermittelt dann ausgehend von der aktuellen Position der Einfügemarke die Position des ersten Leerzeichens links von der Einfügemarke und speichert diese in der Variablen intStartTemp<\/b>. Sollte hierbei kein Leerzeichen gefunden werden, liefert die InStrRev<\/b>-Funktion den Wert 0<\/b>. In jedem Fall addiert diese Zeile den Wert 1 <\/b>zum Ergebnis.<\/p>\n In strFeldTemp <\/b>landet dann die Zeichenkette, die sich zwischen dieser Position und der aktuellen Position der Einfügemarke befindet (inklusive Markierung, falls vorhanden).<\/p>\n Enthält strFeldTemp <\/b>nun einen Wert (Len(strFeldTemp) > 0<\/b>), beginnt die weitere Verarbeitung. Die Variable intLen-Temp <\/b>wird nun mit der Länge des in strFeldTemp <\/b>gespeicherten Ausdrucks gefüllt.<\/p>\n In einer For…Next<\/b>-Schleife durchläuft die Prozedur alle Einträge des Arrays strSuchfelder<\/b>, also alle Feldnamen der Suchabfrage. Darin prüft die Prozedur, ob der in strFeldTemp <\/b>gespeicherte Ausdruck mit den ersten intLenTemp <\/b>Zeichen des Feldnamens übereinstimmt.<\/p>\n Wenn strFeldTemp <\/b>also nun den Aus-druck Art <\/b>enthält, weil der Benutzer gerade das Feld Artikelname <\/b>eintippen möchte, vergleicht die Prozedur diesen Ausdruck jeweils mit den ersten drei Zeichen der in der Variablen strSuchfelder <\/b>gespeicherten Feldnamen. Stößt die Prozedur so auf das Feld Artikelname<\/b>, wird der Teil innerhalb der If…Then<\/b>-Bedingung ausgeführt. Hier trägt die Prozedur einen Ausdruck in die Eigenschaft Text<\/b> des Suchen-Textfeldes ein, der aus den folgenden Elementen besteht:<\/p>\n Außerdem positioniert die Prozedur die Einfügemarke hinter den Doppelpunkt.<\/p>\n Da die Prozedur nun ein passendes Feld für die Autoergänzung gefunden hat, können wir die For…Next<\/b>-Schleife verlassen.<\/p>\n Der folgende Zweig der Select Case<\/b>-Bedingung prüft noch, ob der Benutzer die Eingabetaste gedrückt hat (KeyCode <\/b>hat dann den Wert 13<\/b>). Dies soll die Suche auslösen.<\/p>\n Ist dies der Fall, wird KeyCode <\/b>auf den Wert 0 <\/b>eingestellt, damit die Eingabe nicht wie üblich verarbeitet wird. Außerdem ruft die Prozedur die Routine Suchen <\/b>mit dem aktuellen Inhalt des Textfeldes als Parameter auf.<\/p>\n Bevor wir uns diese Routine ansehen, werfen wir noch einen Blick auf die Prozedur, die durch das Ereignis Bei Taste auf <\/b>ausgelöst wird.<\/p>\n Taste im Suchfeld loslassen<\/b><\/p>\n Die Prozedur liefert die gleichen Parameter wie die zuvor beschriebene Ereignisprozedur, also KeyCode <\/b>und Shift<\/b> (s. Listing 7). Da wir hier und da aber den Wert von KeyCode <\/b>auf 0 <\/b>gesetzt haben, damit die eigentliche Wirkung dieses Tastendrucks nicht zustande kommt, verwenden wir diese nicht. Stattdessen verwenden wir den in der vorher aufgerufenen Ereignisprozedur m_Suchfeld_KeyDown <\/b>in der modulweit deklarierten Variable intKeyCode <\/b>gespeicherten Wert. <\/p>\n Listing 7: Ereignisprozedur, die bei Loslassen einer Taste im Suchen-Textfeld ausgelöst wird<\/span><\/b><\/p>\n Die Prozedur soll nichts tun, wenn der Benutzer die Tasten Löschen<\/b>, Nach links <\/b>und Nach rechts <\/b>betätigt hat – hier sollen die herkömmlichen Funktionen verwendet werden.<\/p>\n Für die übrigen Tasten speichert die Prozedur zunächst den aktuellen Inhalt des mit m_Suchfeld <\/b>referenzierten Textfeldes in der Variablen strSuche<\/b>. Dann trägt sie die Position der Einfügemarke und die Länge der Markierung in die Variablen intSelStart <\/b>und intSelLength <\/b>ein.<\/p>\n Wenn sich die Einfügemarke plus Markierung an einer Position rechts von der ganz linken Position befindet, wird der Inhalt der folgenden If…Then<\/b>-Bedingung ausgeführt.<\/p>\n intStartTemp <\/b>erhält dort zunächst die Position des ersten Leerzeichens links von der aktuellen Markierung plus eins, sollte sich dort kein Leerzeichen finden erhält die Variable den Wert 1<\/b>.<\/p>\n Die Variable strFeldTemp <\/b>wird mit dem Ausdruck von dieser Position bis zur Position hinter der aktuellen Markierung gefüllt. intLenTemp <\/b>nimmt wiederum die Länge des so erfassten Ausdrucks aus strFeldTemp <\/b>auf. Ist nun ein Ausdruck in strFeldTemp <\/b>vorhanden, folgt eine weitere If…Then<\/b>-Bedingung. Diese prüft wieder, ob das Array strSuchfelder <\/b>gefüllt ist, und füllt dieses gegebenenfalls anhand der Felder der als Suchabfrage festgelegten Abfrage.<\/p>\n In einer For…Next<\/b>-Schleife durchläuft die Prozedur wiederum die in strSuchfelder <\/b>gespeicherten Einträge. Entspricht der Anfang eines dieser Einträge dem aktuell in strFeldTemp <\/b>gespeicherten Wert (das wäre beispielsweise bei dem Feldnamen Artikelname <\/b>der Fall, wenn sich im Textfeld der Ausdruck Art <\/b>befindet).<\/p>\n Die folgende Aktion erfolgt nur, wenn sich die Einfügemarke aktuell am Ende des im Suchen-Textfeld eingegebenen Ausdrucks befindet: Dann trägt die Prozedur nämlich den fehlenden Teil des Feldnamens hinter dem aktuellen Text ein und markiert den neu hinzugefügten Teil des Textes – also in diesem Fall wie in Bild 2.<\/p>\n Bild 2: Automatische Ergänzung eines Feldnamens<\/span><\/b><\/p>\n Parsen des Suchausdrucks<\/b><\/p>\n Irgendwann wird der Benutzer die Eingabetaste betätigen und somit einen Prozess anstoßen, der zunächst die Prozedur Suchen <\/b>mit dem Parameter strSuche <\/b>aufruft und von dort das gleichnamige Ereignis Suchen <\/b>auslöst.<\/p>\n Den ersten Teil der Prozedur Suchen<\/b> finden Sie in Listing 8. Die Prozedur erhält den aktuell im Suchen-Textfeld befindlichen Ausdruck als Parameter. Sie erstellt dann zunächst ein QueryDef<\/b>-Objekt auf Basis der in m_Suchabfrage <\/b>gespeicherten Abfrage und speichert dieses in der Variablen \n
Private <\/span>m_Suchabfrage As String<\/span>\r\nPrivate <\/span>m_PKFeld As String<\/span>\r\nPrivate <\/span>m_PKFeldEinschliessen As Boolean<\/span>\r\nPrivate <\/span>WithEvents m_Suchfeld As <\/span>TextBox<\/pre>\nWith<\/span> objFlexSearch\r\n .Suchabfrage = \"qryArtikelsuche\"\r\n .PKFeld = \"ArtikelID\"\r\n .PKFeldEinschliessen = False<\/span>\r\n Set<\/span> .Suchfeld = Me!txtSucheNach\r\nEnd With<\/span><\/pre>\nPublic Property Let <\/span>Suchabfrage(strSuchabfrage As String<\/span>)\r\n m_Suchabfrage = strSuchabfrage\r\nEnd Property<\/span><\/pre>\nPublic Property Let <\/span>PKFeld(strPKFeld As String<\/span>)\r\n m_PKFeld = strPKFeld\r\nEnd Property<\/span><\/pre>\nPublic Property Let <\/span>PKFeldEinschliessen(bolPKFeldEinschliessen As Boolean<\/span>)\r\n m_PKFeldEinschliessen = bolPKFeldEinschliessen\r\nEnd Property<\/span><\/pre>\nPublic Property Set<\/span> <\/span>Suchfeld(txtSuchfeld As <\/span>TextBox)\r\n Set<\/span> m_Suchfeld = txtSuchfeld\r\n With<\/span> m_Suchfeld\r\n .OnKeyDown = \"[Event Procedure]\"\r\n .OnKeyUp = \"[Event Procedure]\"\r\n End With<\/span>\r\nEnd Property<\/span><\/pre>\nPrivate Sub <\/span>m_Suchfeld_KeyDown(KeyCode As Integer<\/span>, Shift As Integer<\/span>)\r\n Dim <\/span>intSelStart As Integer<\/span>\r\n Dim <\/span>intSelLength As Integer<\/span>\r\n Dim <\/span>intStarttemp As Integer<\/span>\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>intLenTemp As Integer<\/span>\r\n Dim <\/span>strFeldTemp As String<\/span>\r\n Dim <\/span>strSuche As String<\/span>\r\n intKeycode = KeyCode\r\n Select Case intKeycode\r\n Case <\/span>9, 190\r\n If <\/span>intKeycode = 190 And Not<\/span> Shift = acShiftMask Then<\/span>\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n KeyCode = 0\r\n strSuche = m_Suchfeld.Text\r\n intSelStart = m_Suchfeld.SelStart\r\n intSelLength = m_Suchfeld.SelLength\r\n If <\/span>Not<\/span> ArrayGefuellt(strSuchfelder) Then<\/span>\r\n SuchfelderEinlesen\r\n End If<\/span>\r\n intStarttemp = InStrRev<\/span>(strSuche, \" \", intSelStart + intSelLength) + 1\r\n strFeldTemp = Mid<\/span>(strSuche, intStarttemp, intSelStart + intSelLength)\r\n If <\/span>Len<\/span>(strFeldTemp) > 0 Then<\/span>\r\n intLenTemp = Len<\/span>(strFeldTemp)\r\n For i = LBound<\/span>(strSuchfelder) To UBound<\/span>(strSuchfelder)\r\n If <\/span>strFeldTemp = Left<\/span>(strSuchfelder(i), intLenTemp) Then<\/span>\r\n m_Suchfeld.Text = Left<\/span>(m_Suchfeld.Text, intSelStart + intSelLength - 1) _\r\n & Mid<\/span>(strSuchfelder(i), intLenTemp) & \":\" _\r\n & Mid<\/span>(m_Suchfeld.Text, intSelStart + intSelLength + 1)\r\n m_Suchfeld.SelStart = _\r\n intSelStart + intSelLength + Len<\/span>(strSuchfelder(i)) - intLenTemp + 1\r\n Exit For<\/span>\r\n End If<\/span>\r\n Next<\/span> i\r\n End If<\/span>\r\n Case <\/span>13\r\n Suchen m_Suchfeld.Text\r\n KeyCode = 0\r\n Case Else<\/span>\r\n Debug.Print<\/span> intKeycode\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nDim <\/span>intKeycode As Integer<\/span><\/pre>\nDim <\/span>strSuchfelder() As String<\/span><\/pre>\nPrivate Sub <\/span>SuchfelderEinlesen()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>qdf As <\/span>DAO.QueryDef\r\n Dim <\/span>fld As <\/span>DAO.Field\r\n Dim <\/span>i As Integer<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> qdf = db.QueryDefs(m_Suchabfrage)\r\n For Each fld In qdf.Fields\r\n If <\/span>Not<\/span> (fld.Name = m_PKFeld And m_PKFeldEinschliessen = False<\/span>) Then<\/span>\r\n ReDim Preserve strSuchfelder(qdf.Fields.Count) As String<\/span>\r\n strSuchfelder(i) = fld.Name\r\n i = i + 1\r\n End If<\/span>\r\n Next<\/span> fld\r\nEnd Sub<\/span><\/pre>\n\n
Private Sub <\/span>m_Suchfeld_KeyUp(KeyCode As Integer<\/span>, Shift As Integer<\/span>)\r\n Dim <\/span>strSuche As String<\/span>\r\n Dim <\/span>intSelStart As Integer<\/span>\r\n Dim <\/span>intSelLength As Integer<\/span>\r\n Dim <\/span>strFeldTemp As String<\/span>\r\n Dim <\/span>intStarttemp As String<\/span>\r\n Dim <\/span>intLenTemp As Integer<\/span>\r\n Dim <\/span>i As Integer<\/span>\r\n Select Case intKeycode\r\n Case <\/span>8, 37, 39 ''Löschen, nach links, nach rechts\r\n Exit Sub<\/span>\r\n End Select<\/span>\r\n strSuche = m_Suchfeld.Text\r\n intSelStart = m_Suchfeld.SelStart\r\n intSelLength = m_Suchfeld.SelLength\r\n If <\/span>intSelStart + intSelLength > 0 Then<\/span>\r\n intStarttemp = InStrRev<\/span>(strSuche, \" \", intSelStart + intSelLength) + 1\r\n strFeldTemp = Mid<\/span>(strSuche, intStarttemp, intSelStart + intSelLength)\r\n intLenTemp = Len<\/span>(strFeldTemp)\r\n If <\/span>intLenTemp > 0 Then<\/span>\r\n If <\/span>Not<\/span> ArrayGefuellt(strSuchfelder) Then<\/span>\r\n SuchfelderEinlesen\r\n End If<\/span>\r\n For i = LBound<\/span>(strSuchfelder) To UBound<\/span>(strSuchfelder)\r\n If <\/span>strFeldTemp = Left<\/span>(strSuchfelder(i), intLenTemp) Then<\/span>\r\n If <\/span>intSelStart = Len<\/span>(strSuche) Then<\/span>\r\n m_Suchfeld.Text = m_Suchfeld.Text & Mid<\/span>(strSuchfelder(i), intLenTemp + 1)\r\n m_Suchfeld.SelStart = intSelStart\r\n m_Suchfeld.SelLength = Len<\/span>(strSuchfelder(i)) + intStarttemp - intSelStart\r\n End If<\/span>\r\n Exit For<\/span>\r\n End If<\/span>\r\n Next<\/span> i\r\n End If<\/span>\r\n Else<\/span>\r\n strFeldTemp = \"\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Automatische](\"..\/fileadmin\/_temp_\/2014_06\/pic_964_002.png\")
<\/p>\n