saperion eventscript - docs.kofax.com · 1 saperion eventscript 1 einführung saperion lässt sich...
TRANSCRIPT
SAPERION EventScript
Copyright © 2016 Lexmark. All rights reserved.
Lexmark is a trademark of Lexmark International, Inc., registered in the U.S. and/or other countries. All other trademarksare the property of their respective owners. No part of this publication may be reproduced, stored, or transmitted in anyform without the prior written permission of Lexmark.
Inhaltsverzeichnis
1 Einführung ........................................................................................................... 1
2 Installation der Option "EventScript" ................................................................ 2
2.1 Lizenzierung ........................................................................................................ 2
2.2 Freischalten durch Feature-Key ........................................................................... 2
2.3 Festlegen des Makro-Ordners ............................................................................ 2
3 Programmierrichtlinien in SAPERION ............................................................... 2
3.1 Deklarationen ....................................................................................................... 2
3.1.1 Geltungsbereich ............................................................................................... 2
3.1.2 Benennungen ................................................................................................... 3
3.1.3 Variablepräfix ................................................................................................... 3
3.1.4 Spezielle Typen ................................................................................................ 3
3.1.5 Konstanten ....................................................................................................... 4
3.1.6 Funktionen ....................................................................................................... 4
3.1.7 Parameter ......................................................................................................... 4
3.2 Einrücken ............................................................................................................. 4
3.2.1 Deklarationen ................................................................................................... 5
3.2.2 Blöcke ............................................................................................................... 5
3.2.3 Zeilenfortsetzung ............................................................................................. 5
3.3 Kommentare ........................................................................................................ 5
3.4 Hinweise .............................................................................................................. 6
4 Erstellen von Makros .......................................................................................... 6
4.1 Der Makro-Editor ................................................................................................. 6
4.2 Erstellen von Makros im SAPERION Makro-Editor ........................................... 7
4.3 Erstellen von Dialogen mit dem Dialog-Editor .................................................. 9
4.4 Testen der Makros und Aufspüren von Fehlern ............................................... 9
4.4.1 Aktivieren des Debug-Modus ......................................................................... 10
4.4.2 Verwenden des Debug-Fensters ..................................................................... 11
4.5 Festlegen eines Benutzers .................................................................................. 11
4.6 Tipps für Programmierung und Fehlersuche ..................................................... 12
4.6.1 Checkliste Fehlersuche .................................................................................... 12
4.6.2 Zugreifen auf Funktionen in anderen BAS-Dateien ....................................... 12
4.6.3 Fehlerbehandlung über "On Error"-Anweisung ............................................. 13
5 Zuordnen der Makros zu Ereignissen ................................................................ 15
5.1 Makro einem Ereignis zuordnen ........................................................................ 15
5.2 Allgemeine Systemereignisse ............................................................................. 16
5.2.1 Syntax der Makros ........................................................................................... 17
5.2.2 Ereignis "Archivierung" ................................................................................... 17
5.2.3 Ereignis "Revision" .......................................................................................... 18
5.2.4 Ereignis "Löschen" .......................................................................................... 18
5.2.5 Ereignis "Bearbeiten" ...................................................................................... 18
5.2.6 Ereignis "Drucken" .......................................................................................... 18
5.2.7 Ereignis "Fehler" .............................................................................................. 19
5.2.8 Ereignis "Benutzerverwaltung" ....................................................................... 19
5.2.9 Ereignis "Beleg-Übernahme" .......................................................................... 20
5.2.10 Ereignis "System" ............................................................................................ 21
5.2.11 Ereignis "Eingang in Korb" ............................................................................. 21
5.2.12 Ereignis "Programmstart" ............................................................................... 21
5.2.13 Ereignis "Programmende" .............................................................................. 21
5.2.14 Periodisches Ereignis ...................................................................................... 22
5.2.15 Ereignis "Menü geladen" ................................................................................ 22
5.3 Ereignisse in Abfrage- und Indexmasken ........................................................... 23
5.3.1 Maskenereignisse (Dialog Events) ................................................................. 23
OnInitDialog - Ereignis ................................................................................. 23
OnSaveDialog - Ereignis ............................................................................... 23
OnSetFocus - Ereignis .................................................................................. 24
OnKillFocus - Ereignis ................................................................................... 24
OnItemAccept ................................................................................................ 24
OnItemDrop .................................................................................................. 24
5.3.2 Ereignisse in Maskenfeldern (Control-Events) .............................................. 24
OnEditChanged - Ereignis ............................................................................ 26
OnSetFocus - Ereignis .................................................................................. 26
OnKillFocus - Ereignis ................................................................................... 26
OnEditSetText - Ereignis ............................................................................... 26
OnSelChange – Ereignis ............................................................................... 26
5.3.3 Ereignisse in Ergebnislisten ............................................................................ 26
OnSelChange - Ereignis ................................................................................ 28
OnItemDrag - Ereignis .................................................................................. 28
OnItemAccept - Ereignis ............................................................................... 28
OnItemDrop - Ereignis ................................................................................. 28
OnTooltip - Ereignis ...................................................................................... 28
OnDragCancel - Ereignis .............................................................................. 28
OnEdit - Ereignis ........................................................................................... 28
OnView - Ereignis .......................................................................................... 28
OnPrint - Ereignis ......................................................................................... 28
OnDelete - Ereignis ....................................................................................... 28
OnIndex - Ereignis ........................................................................................ 28
OnSave - Ereignis .......................................................................................... 28
OnNew - Ereignis .......................................................................................... 28
OnSecurity - Ereignis .................................................................................... 28
5.3.4 Ereignisse in Outlinern ................................................................................... 28
OnSelChange ................................................................................................. 30
OnExpand ...................................................................................................... 30
OnItemDrag ................................................................................................... 30
OnItemAccept ................................................................................................ 30
OnItemDrop .................................................................................................. 30
OnItemNew ................................................................................................... 30
OnItemEdit .................................................................................................... 30
OnItemDelete ................................................................................................ 30
OnDragCancel ............................................................................................... 30
5.3.5 Ereignisse durch Schaltflächen in Masken .................................................... 30
Definieren einer Schaltfläche, die ein Makro ausführt ................................ 31
Zuordnung des Makros über das Ereignis "OnButtonClick" ...................... 32
OnButtonClick-Ereignis ................................................................................. 33
5.3.6 Ereignisse durch ActiveX-Objekte in Masken ................................................ 33
6 Beispiele ............................................................................................................... 33
6.1 Einfache SAPERION Funktionen ........................................................................ 34
6.1.1 Programmierung Ribbons ............................................................................... 34
6.2 Komplexere SAPERION Funktionen ................................................................... 34
6.2.1 Löschen aus der Nachschlagetabelle bei der Archivierung ........................... 34
Anwendungsfall ............................................................................................. 34
Code-Beispiel ................................................................................................. 34
6.3 Makros in Masken .............................................................................................. 35
6.3.1 Auswahl einer Applikation .............................................................................. 35
Anwendungsfall ............................................................................................. 35
Code-Beispiel ................................................................................................. 35
6.4 Benutzung der COM-Objekte anderer Applikationen ....................................... 36
6.4.1 Benutzung der COM Objekte von Microsoft Word ....................................... 36
1
SAPERION EventScript
1 Einführung
SAPERION lässt sich dank seiner umfangreichen Programmiermöglichkeiten schnell und flexibel an
projektspezifische Vorgaben anpassen. Mit EventScript, der COM-Schnittstelle und UBI stehen Ihnen
hierfür verschiedene Möglichkeiten zur Verfügung.
EventScript ermöglicht die interne Programmierung von SAPERION in Form von BASIC Makros. Es steht
hierfür ein Makro-Editor zur Verfügung, der durch seine farbliche Hervorhebung der Syntax ein leichtes
Programmieren ermöglicht und zur Fehlersuche umfangreiche Testmöglichkeiten bietet. Bei Bedarf kann
auch ein externer Editor zur Erstellung der Makros verwendet werden.
Die BASIC-Befehle des Makro-Editors sind weitestgehend kompatibel zum Standardumfang von VBA
(Visual BASIC for Applications, eingetragenes Markenzeichen der Microsoft Corporation). Darüber
hinaus können Objekte der COM-Schnittstelle (SAPERION-API) in den Makros verwendet werden. Über
diese Objekte werden die wesentlichen Funktionen von SAPERION zur Verfügung gestellt. Auf weitere
Objekte kann über die Windows COM-Schnittstelle zugegriffen werden.
Zudem ermöglicht es die Option "EventScript" bei der Benutzung von SAPERION auf bestimmte
Ereignisse (Events) in bestimmter Weise (durch Ausführen eines Makros) zu reagieren. Die
hiermit entstehenden Möglichkeiten sind nahezu unbegrenzt. So können unter anderem spezifische
Workflow-Mechanismen, komplexe Dokumentenübernahmen oder komfortable Schnittstellen zu
anderen Anwendungen erstellt werden.
Ereignisse treten während der Benutzung von SAPERION in unterschiedlichster Weise auf. So ist
das Klicken einer Schaltfläche in einer Abfragemaske genauso ein Ereignis wie die Archivierung eines
Dokumentes durch den Dokumentenserver. Zudem können periodische Ereignisse definiert werden, die
sich in definierbaren Zeitintervallen wiederholen. Jedem Ereignis kann ein Makro zugeordnet werden,
dass bei Eintreffen des Ereignisses ausgeführt wird. Viele dieser Ereignisse rufen das Makro sogar
zweimal auf (vor und nach der tatsächlichen Ausführung). Bei "vor" kann in den Makros gegebenenfalls
die weitere Ausführung der mit dem Ereignis verbundenen Prozesse abgebrochen werden.
Eine weitere Nutzungsmöglichkeit ist die Vorbelegung von Maskenfeldern mit Hilfe von Makros und
BASIC-Funktionen.
! Für die Benutzung der Option "EventScript" sind grundlegende Kenntnisse in BASIC erforderlich.
2 Installation der Option "EventScript"
2
2 Installation der Option "EventScript"
2.1 Lizenzierung
Die Option "EventScript" ist nicht benutzerlimitiert und wird nur einmalig systemweit lizenziert. Es
können alle Benutzer der SAPERION Version damit arbeiten. Die SAPERION COM-Schnittstelle ist
bereits im Standardpaket von SAPERION enthalten und braucht nicht explizit lizenziert werden.
2.2 Freischalten durch Feature-Key
Die Option "EventScript" wird bei einer Systeminstallation oder einem Update durch Aktivierung der
entsprechenden Checkbox innerhalb der Optionenauswahl installiert.
2.3 Festlegen des Makro-Ordners
Bei einer Neuinstallation werden die Makros im Ordner MACROS des SAPERION Verzeichnisses
abgespeichert. Durch einen zusätzlichen Eintrag in der PROGRAM.INI kann aber auch ein beliebiger
Makro-Ordner festgelegt werden.
[Setup]
...
PathVBAModules=<Speicherort> Pfad zum Makro-Ordner. Ist dies ein Unterordner des SAPERION Verzeichnisses, reicht
der Name des Unterordners. Fehlt
dieser Eintrag, wird das SAPERION Verzeichnis verwendet.
...
! Vor dem Editieren der PROGRAM.INI müssen Sie SAPERION auf allen Arbeitsstationen beenden.
3 Programmierrichtlinien in SAPERION
Die folgenden Richtlinien enthalten Vorgaben, die die Kooperation, Wartbarkeit und
Wiederverwendbarkeit bei Programmierprojekten verbessern sollen. Es handelt sich um Empfehlungen,
deren Einhaltung sich positiv auf die Arbeit mit Makros auswirkt.
3.1 Deklarationen
3.1.1 Geltungsbereich
Globale Variablen sollten nur in Ausnahmefällen eingesetzt werden. Besser ist es, den Geltungsbereich
von Deklarationen immer soweit als möglich einzuschränken, da hierdurch ungewollte Seiteneffekte
vermieden werden können.
3.1 Deklarationen
3
Bei Funktionsparametern sollte darauf geachtet werden, dass sie bei "Val" definiert werden, wenn nur
lesend auf sie zugegriffen wird. So kann verhindert werden, dass eine versehentliche Zuweisung zu
einem Parameter zu Auswirkungen außerhalb der Funktion führt.
3.1.2 Benennungen
Um die Möglichkeit einer internationalen Verwendung zu gewährleisten, ist die Verwendung von
englischsprachigen Namen zu bevorzugen. Die Namen sollten hierbei so gewählt werden, dass sie den
Zweck so gut wie möglich wiedergeben. Bei zusammengesetzten Begriffen wird jeder neue Teil mit einem
Großbuchstaben begonnen. Unterstriche sollten nur bei Konstanten verwendet werden. Die Verwendung
von Sonderzeichen (z.B. Umlaute) ist verboten.
Abkürzungen sind nur erlaubt, wenn diese auch für Außenstehende intuitiv verständlich sind.
Gegebenenfalls sollten verwendete Abkürzungen im Header erklärt werden.
Namen, die auch von SAPERION verwendet werden, beispielsweise Mask, Document, Cursor, müssen
mit einem Präfix versehen werden.
3.1.3 Variablepräfix
Variable beginnen immer mit einem Kleinbuchstaben. Häufig verwendete Begriffsteile können
allgemeinverständlich abgekürzt werden. Im Zweifelsfall ist die ausgeschriebene Version bei der
Deklaration als Kommentar anzugeben.
Sollten Schleifenvariablen verwendet werden, für die kein sinnvoller Name gefunden werden kann,
sollten die Variablen entsprechend mit i oder j bezeichnet werden.
Bei geschickter Benennung kann in der Regel auf ein Datentyp-Präfix verzichtet werden. Sollte auf Präfixe
zurückgegriffen werden müssen, gilt:
+ Das Präfix besteht aus einem Buchstaben
+ Das Präfix wird klein geschrieben.
+ Der nächste Buchstabe wird groß geschrieben.
Folgende Buchstaben werden verwendet:
+ b: Boolean
+ s: String
+ l: Long
+ o: Object
3.1.4 Spezielle Typen
Fließkommavariablen sollten nur verwendet werden, wenn es sich nicht vermeiden lässt. Ansonsten
läuft man Gefahr, einen Rundungsfehler zu erzeugen.
3 Programmierrichtlinien in SAPERION
4
Damit kein Überlauf provoziert wird, sollten Datentypen ausreichend dimensioniert werden.
3.1.5 Konstanten
Konstanten sollten nur mit Bedacht und aussagekräftig benannt verwendet werden. Ansonsten kann die
Verwendung von Konstanten zu einer schlechten Lesbarkeit führen.
Konstanten sollten immer unabhängig vom Wert benannt werden, damit eine Änderung des Wertes ohne
Probleme möglich ist.
Konstanten werden immer mit Großbuchstaben bezeichnet. Zur besseren Lesbarkeit können
Unterstriche "_" verwendet werden. Gleiches gilt für Sprungmarken.
Beispiel
Const DOCTYPE_SCANPAGE=1
3.1.6 Funktionen
So weit möglich, sollte der Verwendungszweck der Funktion aus dem Namen hervorgehen. Damit
Funktionen leichter von Variablen unterschieden werden können, beginnen sie mit Großbuchstaben.
Beispiel
newDir=MakeDir(newDirName)
Public Function MakeDir(byVal DirName) as long
3.1.7 Parameter
Falls es sich anbietet, sollten Parameter adäquat zu den Variablen im Aufruf benannt werden. Ansonsten
gelten für die Benennung die gleichen Regeln wie für Variable.
Beispiel
CheckAdmin (SaperionApp)
Public Function CheckAdmin (byVal SaperionApp as Object) as Boolean
...
End Function
3.2 Einrücken
Durch geeignetes Einrücken kann der Programmtext übersichtlicher gestaltet und so ein besserer
Überblick über den Programmfluss geschaffen werden. Jede Einrückung sollte mit jeweils zwei
Leerstellen realisiert werden, da Tabulatoren zu unleserlichen Ausgaben in externen Editoren und auf
Druckern führen kann.
3.3 Kommentare
5
In der MS-IDE von VB sollte das Einrücken auf zwei Stellen gesetzt werden. Damit wird der Quelltext
bei längeren Zeilen besser lesbar.
3.2.1 Deklarationen
Deklarationen beginnen grundsätzlich linksbündig. Programmtext wird immer eingerückt.
Beispiel
Public Function GetFileExtension (ByVal FileName as String) as String
Dim FilePart as String
On Error Goto ERRORHANDLER
3.2.2 Blöcke
Der Anweisungsteil von "If"-Abfragen wird immer in eine neue Zeile geschrieben und eingerückt.
Beispiel
If Bedingung then
...Anweisungen
else
...Anweisungen
End If
Ebenso wird mit Anweisungsteilen von Schleifen und mit Select Statements verfahren.
3.2.3 Zeilenfortsetzung
Bei einer Anweisung über mehrere Zeilen wird durch Einrücken markiert, dass es sich um keine
eigenständige Zeile handelt.
Beispiel
MsgBox "Dies ist der erste Teil." &_
"Jetzt kommt der dritte Teil," &_
"der eingerückt wird."
3.3 Kommentare
Kommentare sind ein wichtiges Hilfsmittel für das spätere Verständnis des Programms. Um die
internationale Verwendbarkeit zu gewährleisten, sollten alle Kommentare in Englisch verfasst werden.
4 Erstellen von Makros
6
Bei jedem Programm sollte ein Kommentar-Header existieren, in dem Erstellungs-, Modifikations- und
Funktionskommentare enthalten sind. Codestellen die nicht ohne weiteres verständlich sind, sollten
ausführlich, sinnvoll und aussagekräftig kommentiert werden.
Bei jeder Änderung an einem Programm sollte darauf geachtet werden, dass die entsprechenden
Kommentare aktuell gehalten werden.
3.4 Hinweise
Verwendung von "Document.SaveChanges"
Damit ein Dokument bei der Verwendung von "Document.SaveChanges" komplett revisioniert wird,
muss vorher der Befehl "Document.Load" ausgeführt werden.
"SaveChanges" darf nicht in einem Archivierungs-Event verwendet werden.
4 Erstellen von Makros
4.1 Der Makro-Editor
In der Regel werden Sie Makros mit dem in SAPERION integrierten Makro-Editor erstellen (Cypress
Enable von Cypress Software). Hierbei handelt es sich um einen weitestgehend mit VBA kompatiblen
Basic-Editor mit einer Vielzahl nützlicher Funktionen (Syntaxhervorhebung, Tracing/Debugging, etc.).
Sie können die Makros aber im Prinzip auch mit einem beliebigen anderen hierfür geeigneten Editor
erstellen (z.B. VBA-Editor von Microsoft Office). Um die Makros in SAPERION benutzen zu können,
müssen Sie diese jedoch an die ENABLE-Syntax und deren Eigenheiten anpassen und dann im
Makro-Ordner von SAPERION speichern.
Die exakte Sprachbeschreibung des BASIC-Dialektes befindet sich in der Hilfedatei WBA.HLP innerhalb
des SAPERION Verzeichnisses.
Die BASIC-Befehle des Makro-Editors sind kompatibel zum Standardumfang von VBA (Visual BASIC for
Applications, eingetragenes Markenzeichen der Microsoft Corporation). Darüber hinaus können Objekte
der COM-Schnittstelle in den Makros verwendet werden. Über diese Objekte werden die wesentlichen
Funktionen von SAPERION zur Verfügung gestellt.
Eine englischsprachige Hilfe zu den Standardbefehlen in BASIC können sie erhalten, indem Sie mit dem
Mauscursor auf die Stelle im Code gehen und <F1> drücken. Die dazugehörige Hilfedatei WBA.HLP
befindet sich innerhalb des SAPERION Verzeichnisses und enthält zudem allgemeine Beschreibungen
des BASIC-Dialektes im Makro-Editor.
Für Objekte aus der COM-Schnittstelle ist diese kontextsensitive Hilfe mit <F1> nicht vorhanden.
Informationen zu den einzelnen Objekten müssen daher in den Hilfedateien der Anwendung
nachgelesen werden.
4.2 Erstellen von Makros im SAPERION Makro-Editor
7
Abb. 4–1: SAPERION Makro-Editor
Der im Makro-Editor angezeigte Code wird für eine bessere Übersichtlichkeit automatisch farbig
hervorgehoben. Die Farbgebung erfolgt nach folgender Regel:
+ Rot: Einleitung bzw. Ende einer Prozedur
+ Violett: Objekte
+ Hellblau: BASIC-Anweisungen
+ Dunkelblau: BASIC-Anweisungen (Syntax zudem in einer Quickinfo anzeigbar)
+ Grün: Objekte in Dialogen
Am unteren linken Rand des Editors werden Ihnen sowohl die Zeilen- als auch die Spaltennummer
angezeigt. Hierdurch ist das Auffinden einer Programmzeile, beispielsweise Aufgrund einer
Fehlermeldung vereinfacht.
4.2 Erstellen von Makros im SAPERION Makro-Editor
1. Rufen Sie den Makro-Editor durch Klick auf Ribbon DESIGN > Gruppe MODELLIEREN >
Befehl SCRIPTE auf. Es öffnet sich der Dialog "EventScript".
4 Erstellen von Makros
8
Hier sind alle im Makro-Ordner von SAPERION vorhandenen BAS-Dateien als Module
aufgelistet. In der Spalte "Codezeilen" wird Ihnen die Anzahl der Codezeilen innerhalb des
Moduls angezeigt.
2. Durch Klicken auf das [+]-Symbol am Anfang jedes Eintrags können zudem die in der
BAS-Datei vorhandenen Prozeduren (Subs und Functions) angezeigt werden.
! Ein Modul kann maximal 99 Subs enthalten, wird die Maximalanzahl
überschritten, kann das Modul nicht gespeichert werden. Bei
großen Modulen empfiehlt es sich aus Performancegründen das
Syntaxhighlighting über den Eintrag PrettyLayout=FALSE in der
Sektion [Macro] auszuschalten.
3. Markieren Sie den gewünschten Eintrag und klicken auf die Schaltfläche [Ausführen], so
wird das Makro ausgeführt.
4. Über [Neu] können Sie eine neue BAS-Datei anlegen oder über [Bearbeiten] die unter
Module selektierte BAS-Datei öffnen. In beiden Fällen öffnet sich der Makro-Editor von
SAPERION. Bei vorheriger Selektion einer Prozedur springt der Mauszeiger direkt zur
entsprechenden Stelle in der BAS-Datei.
5. Im Makro-Editor können Sie ein oder mehrere BASIC-Makros erstellen, bearbeiten und
testen.
6. Über Ribbon VBA > SPEICHERN können Sie die gerade im Makro-Editor angezeigten
Makros in einer BAS-Datei speichern. Wenn noch kein Dateiname vergeben wurde, öffnet
sich automatisch ein Fenster zur Eingabe des Dateinamens. Der voreingestellte Dateityp
ist Makro. Die Datei wird immer im Makro-Ordner von SAPERION gespeichert.
! Innerhalb eines Makros können maximal 100 Prozeduren in einem
Modul definiert werden. Wird die Maximalanzahl überschritten, kann
das Modul nicht gespeichert werden.
4.3 Erstellen von Dialogen mit dem Dialog-Editor
9
7. Alternativ können Sie über Ribbon VBA > SPEICHERN ALS die angezeigten Makros auch
in codierter Form als SES-Datei (Makro-Code) abspeichern.
i Ein in codierter Form abgespeichertes Makro kann im Nachhinein
nicht mehr decodiert und bearbeitet werden. Es ist daher
empfehlenswert, eine Kopie der Originaldatei aufzubewahren.
Die vollständige Codierung des Makros tritt erst nach Beendigung des Clients auf dem
es erstellt wurde in Kraft. Vorher kann die Datei von diesem Client aus noch von jedem
Benutzer geöffnet werden. Als Makro-Code gespeicherte Makros werden im Dialogfenster
"EventScript" ausgegraut dargestellt und können nicht mehr bearbeitet werden. Liegt
ein Makro sowohl als BAS-Datei als auch als SES-Datei vor, wird hier nur die BAS-Datei
angezeigt.
4.3 Erstellen von Dialogen mit dem Dialog-Editor
Neben dem Makro-Editor existiert auch ein Dialog-Editor für benutzerdefinierte Dialoge. Diesen öffen
Sie über Ribbon START > Gruppe OPTIONEN > Befehl DIALOG-EDITOR:
Die meisten der im Windows Standard enthaltenen Dialog-Controls werden von Enable BASIC
unterstützt. Die Syntax ist der von Microsoft Word BASIC sehr ähnlich. Die Syntax für Dialoge ist nicht
in Microsoft Visual BASIC oder Microsoft Visual BASIC for Applications enthalten.
Falls Sie SAPERION auf Window Vista oder später installiert haben, kann es vorkommen, dass
beim Aufrufen des Dialog Editors eine Fehlermeldung erscheint. Um dies zu vermeiden, starten Sie
SAPERION mit der Windows Option "Als Administrator ausführen".
i Hilfe zum Dialog-Editor und zur Erstellung von Dialogen entnehmen Sie bitte den
englischsprachigen Hilfedateien ENADLG.HLP und WBA.HLP. Beide Dateien befinden sich im
SAPERION Verzeichnis.
4.4 Testen der Makros und Aufspüren von Fehlern
Zum Testen der Makros und zum Aufspüren von Fehlern (Tracing, Debugging) stehen folgende
Funktionen zur Verfügung:
4 Erstellen von Makros
10
+ Starten eines Makros <F5>
Ribbon START > Gruppe AUSFÜHREN > Befehl START
+ Beenden eines Makros
Ribbon START > Gruppe AUSFÜHREN > Befehl STOP
+ Ausführen des nächsten Einzelschritts im Makro <F8>
Ribbon START > Gruppe AUSFÜHREN > Befehl EINZELSCHRITT
+ Abarbeiten der einzelnen ProzedureN <F10>
Ribbon START > Gruppe AUSFÜHREN > Befehl PROZEDURSCHRITT
+ Definieren und Entfernen eines Haltepunkts <F9>
Ribbon START > Gruppe AUSFÜHREN > Befehl HALTEPUNKT
+ Anzeigen einzelner Werte in Variablen
Ribbon START > Gruppe AUSFÜHREN > Befehl QUICK WATCH
Haltepunkte
Über Ribbon START > Gruppe AUSFÜHREN > Befehl HALTEPUNKT können Sie einen Haltepunkt
in einer beliebigen Programmzeile des Programmcodes setzen oder einen bestehenden Haltepunkt
wieder entfernen. Es können mehrere Haltepunkte innerhalb des vorliegenden Makros definiert werden,
die entsprechenden Programmzeilen sind rot markiert. Bei Beenden des Makro-Editors werden alle
Haltepunkte wieder entfernt.
i Das Starten im Haltemodus ist nur für Prozeduren (Subs oder Functions) ohne Parameter
möglich. Enthält die Prozedur Parameter, wird eine Fehlermeldung "Runtime Error on line: -1
- Wrong number of arguments" ausgegeben.
Quick Watch
Über Ribbon START > Gruppe AUSFÜHREN > Befehl QUICK WATCH können Sie sich den Wert einer
Variablen in einem Meldungsfenster ausgeben lassen. Sie müssen vorher den Haltepunkt an diese Stelle
im Programmcode positionieren.
4.4.1 Aktivieren des Debug-Modus
Nicht selten treten in einem Makros schwer zu lokalisierende Fehler auf. Der Programmcode enthält
zwar syntaktisch gültigen Code, aber das Makro reagiert trotzdem nicht so wie gewünscht.
Um solche Fehler zu finden, müssen Sie das Makro in einer möglichst realistischen Umgebung testen.
Am besten ist es dabei, jeden einzelnen Programmschritt genau verfolgen zu können. Hierfür dient der
so genannte Debug-Modus. Sie können diesen für einzelne Prozeduren über die Checkbox "Debug" im
Fenster "EventScript" aktivieren. Die Prozedur wird daraufhin mit einem [Stopp]-Symbol gekennzeichnet.
Bei Verlassen des Fensters über der [OK]-Schaltfläche werden die hier vorgenommenen Änderungen
gespeichert, bei [Abbrechen] bleibt alles unverändert.
4.5 Festlegen eines Benutzers
11
Abb. 4–2: Auswahl des Debug-Modus
Wenn zur Laufzeit von SAPERION diese Prozedur aufgerufen wird, wird automatisch der Makro-Editor
geladen und die Prozedur hierin als Einzelschritt gestartet. Die Prozedur befindet sich jetzt im
Haltemodus. Sie können nun beliebig Haltepunkte setzen oder die Prozedur schrittweise weiter
durchlaufen und so eventuelle Fehler besser erkennen. Im Unterschied zum manuell gestarteten
Haltemodus stehen jedoch keine Menübefehle oder Tastenkürzel zur Verfügung, so dass die Befehle
über die Icons in der Symbolleiste des Makro-Editors ausgeführt werden müssen.
! Sie sollten den Debug-Modus nicht für die Ereignisse "OnSetFocus" und "OnKillFocus"
verwenden, da der Fokus beim Eintreffen dieser Ereignisse in den Makro-Editor wechselt und die
normale Wirkungsweise dieser Ereignisse somit verfälscht.
4.4.2 Verwenden des Debug-Fensters
Nach dem Start eines Makros im Einzel- oder Prozedurschritt erscheint zusätzlich ein Debug-Fenster.
Hierin können Sie über den Befehl "Print" entsprechende Texte zeilenweise ausgeben. Auf diese Weise
haben sie die Möglichkeit, umfangreiche Zwischenergebnisse ausgeben zu lassen.
Abb. 4–3: "Debug Fenster"
4.5 Festlegen eines Benutzers
Für ein einzelnes Modul oder die gesamten COM-API kann ein Benutzer festgelegt werden. Wird das
entsprechende Modul oder die gesamte COM-API anschließend aufgerufen, erfolgt dieser Aufruf unter
dem Namen des angegebenen Benutzers mit dessen Rechten und der angegebenen Rolle.
1. Rufen Sie den Makro-Editor durch Klick auf Ribbon DESIGN > Gruppe MODELLIEREN >
Befehl SCRIPTE auf. Es öffnet sich der Dialog "EventScript".
4 Erstellen von Makros
12
2. Über die Schaltfläche [COM-API..] bzw. bei einem markierten Modul über die Schaltfläche
[Modul...] öffnet sich das Anmeldefenster, in dem der Benutzer mit Passwort und Rolle
eingegeben werden kann.
Neben den herkömmlichen Clientarten können hier auch explizit die API-Clients
ausgewählt werden.
4.6 Tipps für Programmierung und Fehlersuche
4.6.1 Checkliste Fehlersuche
+ Wird ein Modul-User benutzt? Siehe dazu auch die Sektion PROGRAM.INI [Macro]. Wenn ja, sollte
dieser deaktiviert bzw. neu gesetzt werden.
+ Hat das Makro den richtigen Typ für das Ereignis (Sub/ Function/ Parameter)?
+ Soll das Makro am Client oder am Core Server (z.B. bei Tasks) ausgeführt werden? Bei Makros am
Server sind folgende Hinweise zu beachten:
Er wird empfohlen, für das vom Task verwendete BAS-Modul einen Modul-User zu definieren.
Der Befehl CreateObject darf nicht in den vom Task aufgerufenen Makros verwendet werden. Das
Erzeugen von Dokumenten muss in den Makros über Application.CreateDoc erfolgen.
Der Task übergeht Benutzermeldungen ("Msgbox" oder "Application.MsgBox"). Der Inhalt einer
"Msgbox2 wird allerdings in das Eventlog geschrieben. Programmcode für einen Task sollte speziell
unter Berücksichtigung dieser Begebenheiten erstellt bzw. getestet werden.
COM-User und Modul-User sind nicht parallel einsetzbar.
4.6.2 Zugreifen auf Funktionen in anderen BAS-Dateien
Um Funktionen aus anderen Modulen (BAS-Dateien) benutzen zu können, kann die Funktion
RunScript() verwendet werden.
RetValue = Application.RunScript ("MyModule!MyFunction", Param1, Param2)
4.6 Tipps für Programmierung und Fehlersuche
13
In diesem Fall wird die Funktion "MyFunction" im Modul "MyModule.bas" mit den Parametern "Param1"
und "Param2" aufgerufen und der Wert "RetValue" zurückgegeben. Weitere Informationen hierzu finden
Sie in der Beschreibung der COM-Schnittstelle.
4.6.3 Fehlerbehandlung über "On Error"-Anweisung
Unter bestimmten Voraussetzungen können Fehler auftreten, die nicht mit dem eigentlichen
Programmcode zusammenhängen. Diese so genannten Laufzeitfehler, die zum Beispiel auftreten
können, wenn ein Dokument nicht archiviert werden kann, weil der Dokumenten Server nicht zur
Verfügung steht, können zu einer Unterbrechung, schlimmstenfalls zum Abbruch Ihres Makros führen.
Um dies zu verhindern, sollten Sie in allen Prozeduren, die solche Fehler möglicherweise verursachen
können, eine so genannte Fehlerbehandlungsroutine (Error Handler) in die Makros integrieren. Eine
solche Fehlerbehandlung erfolgt über "OnError"-Anweisung und ist typischerweise nach folgendem
Prinzip programmiert:
Sub MyProzedur()
' Gehe im Fehlerfall zur Sprungmarke MyErrorHandler
On Error GoTo MyErrorHandler
' Befehle der eigentlichen Prozedur...
...
' Beende Subroutine ohne MyErrorHandler noch zu durchlaufen
Exit Sub
' Sprungmarke: Ab hier beginnt die Fehlerbehandlung
MyErrorHandler:
' Befehle des ErrorHandlers...
...
' Die eigentliche Prozedur wird fortgesetzt’
Resume
End Sub
Wenn ein Fehler auftritt, wird die Prozedur an der angegebenen Sprungmarke fortgesetzt und die
nachfolgenden Anweisungen ausgeführt. Hierbei handelt es sich um eine Auswertung des auftretenden
Fehlers und der Auslösung einer entsprechenden Reaktion.
Unmittelbar vor der Sprungmarke, welche die Fehlerbehandlungsroutine kennzeichnet, muss eine "Exit
Sub"-Anweisung vermerkt werden, damit die Routine zur Fehlerbehandlung nicht immer sondern nur
bei einem Sprung zur Sprungmarke – also dem Auftreten eines Fehlers – durchlaufen wird.
i Die Sprungmarke muss sich in derselben Prozedur wie die "OnError"-Anweisung befinden.
Bei der Verwendung von "OnError" kann es zu einer Störung kommen, wenn die Methode zusammen
mit der Funktion "Val ( )" verwendet wird.
Beispiel 1
Im folgenden Makro entsteht ein Fehler, wenn in der Ergebnisliste kein Dokument selektiert ist. Der
Benutzer wird durch eine entsprechende Meldung darauf hingewiesen.
4 Erstellen von Makros
14
Sub GetSelectedDoc ()
Dim crs As Object
Dim doc As Object
On Error GoTo GetSelectedDocERR
Set crs = Mask.Cursor
Set doc = crs.Document
doc.load
doc.EditImage
Exit Sub
GetSelectedDocERR:
MsgBox "Bitte selektieren Sie zunächst ein Dokument in der Ergebnisliste !"
End Sub
Beispiel 2
Im folgenden Beispiel wird auch auf eventuelle Tücken bei der Verwendung von
Fehlerbehandlungsroutinen hingewiesen. Nach Auftreten des Fehlers springt das Programm nicht
in seine eigene Fehlerbehandlungsroutine, sondern in die der Prozedur "DoNothing", da die letzte
Fehlerbehandlung beim Durchlaufen der Prozedur "DoNothing" definiert war.
Sub MyProcedure()
On Error GoTo ErrorHandlerMain
DoNothing
' Ein Fehler wird erzeugt!!!
err.raise = 91
Exit Sub
ErrorHandlerMain:
MsgBox "Fehler in Error_Handle"
End Sub
' Diese Function tut gar nichts (besitzt aber ein Error-Handling)
Sub DoNothing ()
On Error GoTo DoNothingERR
Exit Sub
DoNothingERR:
MsgBox "Fehler in Prozedur Do_Nothing"
End Sub
Lösungsmöglichkeit
Sub MyProcedure()
On Error GoTo ErrorHandlerMain
DoNothing
On Error GoTo ErrorHandlerMainLösung: Wiederholen der Anweisung "On
Error..."
err.raise = 91
Exit Sub
ErrorHandlerMain:
MsgBox "Fehler in Error_Handle"
5.1 Makro einem Ereignis zuordnen
15
End Sub
5 Zuordnen der Makros zu Ereignissen
Damit Makros zur Laufzeit von SAPERION ausgeführt werden können, müssen sie einem Ereignis
zugeordnet werden. Ereignisse treten während der Benutzung von SAPERION in unterschiedlichster
Weise auf. So ist das Klicken auf eine Schaltfläche in einer Abfragemaske genauso ein Ereignis wie die
Archivierung eines Dokumentes durch den Dokumentenserver.
Ereignisse können oft auf mehrfache Weise erzeugt werden. So wird beispielsweise das Ereignis "Anzeige
eines Dokumentes in der Ergebnisliste" durch Klicken der Schaltflächen [Anzeigen] oder [Bearbeiten],
durch Benutzung der entsprechenden Kontextmenüs oder durch Drag&Drop eines Dokuments auf das
[Anzeigen]-Piktogramm ausgelöst. Sie müssen die Zuordnung zu einem Makro jedoch nur einmal für
das Ereignis vornehmen.
! Ereignisse werden immer am Client ausgelöst, nicht am Server.
SAPERION unterstützt die Zuordnung von Makros für folgende Ereignisse:
+ Allgemeine Systemereignisse (z.B. Archivierung oder Anzeige eines Dokuments, periodisches
Ereignis, etc.)
+ Ereignisse, die durch die Benutzung der Abfrage- und Indexmasken entstehen (Öffnen, Schließen,
Fokuserhalt, Fokusverlust, Feldeingabe, Klicken von Schaltflächen, etc.)
+ Ereignisse, die durch Klicken auf benutzerdefinierte Symbole in der Symbolleiste ausgelöst werden.
Die Zuordnung erfolgt kontextabhängig auf unterschiedlichem Wege und wird in den nachfolgenden
Kapiteln näher beschrieben.
5.1 Makro einem Ereignis zuordnen
1. Klicken Sie auf Ribbon DESIGN > Gruppe MODELLIEREN > Befehl EREIGNISSE. Der
Dialog "Ereignisse öffnet sich.
5 Zuordnen der Makros zu Ereignissen
16
2. Über die Schaltflächen [Neu] oder [Bearbeiten] öffnet sich das Dialogfenster "Ereignis-
Parameter" zur Definition bzw. Bearbeitung der entsprechenden Parameter.
3. Nehmen Sie nun folgende Einstellungen vor:
+ Wählen Sie in der Auswahlliste "Typ" den gewünschten Ereignistyp.
+ Tragen Sie eine Beschreibung des Ereignisses im Feld "Beschreibung" ein.
+ Im Dialogbereich "Periodisches Ereignis" können für den Ereignistyp "Periodisch"
weitere Einzelheiten definiert werden, z.B. wie häufig und in welchem Zeitraum ein
Ereignis ausgelöst werden soll.
4. Über die Schaltfläche [Makros] können Sie das dazugehörige Makro im Dialogfenster
"EventScript" auswählen.
5. Über die Schaltfläche [Löschen] können Sie einen markierten Eintrag aus der Liste
entfernen.
5.2 Allgemeine Systemereignisse
SAPERION bietet die Möglichkeit, beim Auftreten wichtiger Systemereignisse automatisch ein
bestimmtes Makro auszuführen. Sie können auf diese Weise gezielt in die Abläufe von
SAPERION mit geeigneten Makrofunktionen eingreifen und beispielsweise zusätzliche Sicherheits- und
Plausibilitätsprüfungen bei Ereignissen wie Archivieren, Revision, Löschen durchführen.
In den folgenden Unterkapiteln werden die Systemereignisse detailliert beschrieben.
5.2 Allgemeine Systemereignisse
17
5.2.1 Syntax der Makros
Function MyArchivingEvent ( pre As Long, note As String ) As Boolean
' vor dem Ereignis...
If pre = 1 Then
' ... Anweisungen
' Rückgabewert=True setzen, um Ereignis weiter auszuführen
If ... Then MyArchivingEvent = True
Else
' nach dem Ereignis ...
' ... Anweisungen
...
End If
End Function
Sie müssen der Funktion explizit einen Rückgabewert TRUE geben, damit die normalerweise mit
dem Ereignis im Zusammenhang stehenden Aktionen ausgeführt werden. Standardmäßig ist der
Rückgabewert FALSE, das Ereignis wird also abgebrochen. Der Rückgabewert wird nur bei pre = 1 (vor
dem Ereignis) ausgewertet.
Das periodische Ereignis wird in SAPERION anders behandelt. Das Makro hierzu hat keine Parameter
und wird nicht als Function sondern als Sub definiert:
Sub MyPeriodicEvent()
' ... Anweisungen
...
End Sub
! Ohne genaue Kenntnis der Abläufe im System sollten Sie in Makros nie die normalerweise mit
dem Ereignis im Zusammenhang stehenden Aktionen nachbilden. Insbesondere die Methoden
Store und SaveChanges sollten Sie nie verwenden. Eine Änderung von Indexwerten über
SetProperty oder ACL ist hingegen unkritisch.
Mit Ausnahme des periodischen Ereignisses müssen alle Makros als Funktionen mit zwei Parametern
(standardmäßig "pre" und "note") definiert werden. Das Makro wird bei den meisten Systemereignissen
zweimal aufgerufen. Der Parameter "pre" ist vor dem Ereignis 1 und nach dem Ereignis 0. Der Parameter
"note" enthält kontextabhängig weitere Informationen. Das Makro hat typischerweise folgenden Aufbau:
5.2.2 Ereignis "Archivierung"
Das Ereignis tritt beim Archivieren eines Dokuments auf.
Archivierung
pre = 1, note = "" Nach Klicken auf [OK] in der Indexmaske
pre = 0, note = "" Wenn Archivierung ohne Fehler vorgenommen wurde
5 Zuordnen der Makros zu Ereignissen
18
pre = 0, note = "Dokument konnte nicht erzeugt werden." Wenn die weitere Ausführung des Events abgebrochen wurde (Rückga-
bewert der Funktion FALSE)
5.2.3 Ereignis "Revision"
Das Ereignis tritt beim Erzeugen einer Revision auf.
Revision
pre = 1, note = " " Nach Bestätigung mit [OK] im Dialogfenster "Neue Revision erzeugen"
pre = 0, note = "Set ACL: A" Wenn ACL erstellt oder verändert wurde
pre = 0, note = "Removed ACL" Wenn ACL entfernt wurde
pre = 0, note = " " Bei sonstigen Revisionen (Indexierung, Annotationen, etc.)
Wird das Ereignis "Revision" im Makro durch einen Rückgabewert = FALSE beendet, wird ein
Fehler-Ereignis erzeugt mit pre = 0 und note = "Revision konnte nicht erzeugt werden".
5.2.4 Ereignis "Löschen"
Das Ereignis tritt auf, bevor der Benutzer das Löschen von Dokumenten oder Einträgen aus der
Benutzerverwaltung (Benutzer, Gruppe, Profil, Zugriffsliste) bestätigt hat.
Löschen
pre = 1, note = " " Bei der Nachfrage, bevor der Benutzer das Löschen bestätigt
pre = 0, note = " " Nach dem Löschen
5.2.5 Ereignis "Bearbeiten"
Das Ereignis tritt beim Öffnen eines Dokuments aus einer Ergebnisliste ein (Befehle [Bearbeiten] oder
[Anzeigen]). Es tritt ebenfalls ein, wenn der Befehl mit gedrückter <Strg>-Taste ausgeführt wurde und
lediglich die Dokumentenstruktur angezeigt wird. Es tritt nicht beim Öffnen von Dokumenten aus den
Inhaltsfenstern der Körbe (Eingang, Dokumente oder Offen) ein.
Bearbeiten
pre = 1, note = " " Nach Ausführen der Befehle [Bearbeiten] oder [Anzeigen]
pre = 0, note = " " Nachdem das Dokument angezeigt ist.
5.2.6 Ereignis "Drucken"
Das Ereignis tritt beim Drucken von Dokumenten ein. Wird der Druckbefehl aus dem SAPERION Viewer
über [Dokument][Drucken] ausgeführt, wird kein Ereignis erzeugt.
pre = 1, note = " " Nach Klicken der Schaltfläche [OK] im Dialogfenster "Drucken"
5.2 Allgemeine Systemereignisse
19
pre = 0, note = " " Nach Abschluss des Druckvorganges
5.2.7 Ereignis "Fehler"
Das Ereignis tritt in Fehlersituationen auf. Anschließend wird die dazugehörige SAPERION
Fehlermeldung in einem Meldungsfenster ausgegeben.
+ pre = 0, note = <Fehlermeldung>
5.2.8 Ereignis "Benutzerverwaltung"
Das Ereignis tritt bei verschiedenen Aktionen im Zusammenhang mit der Benutzerverwaltung ein.
Dies sind neben der An- und Abmeldung ein Erstellen, Ändern oder Löschen der Benutzer, Gruppen,
Profile und Zugriffslisten und deren Verknüpfungen untereinander. Beim Löschen wird zudem ein
"Löschen"-Ereignis erzeugt.
Benutzerverwaltung
pre = 1, note = "LOGOFF" Das Ereignis tritt nach dem Befehl zum Beenden von SAPERION ein,
aber noch vor der SAPERION Nachfrage "Soll SAPERION wirklich been-
det werden?"
pre = 0, note = "LOGON" Das Ereignis tritt ein, nachdem sich der Benutzer im Logon-Dialog an-
gemeldet hat.
+ pre =0, note = "User <UserFullName> : New name: <UserName>"
+ pre =0, note = "User <UserFullName> : New description: <UserDescription>"
+ pre =0, note = "User <UserFullName> : New sync OS: <Boolean>"
+ pre =0, note = "User <UserFullName> : New Password"
+ pre =0, note = "User <UserFullName> : Added: Group <GroupFullName>
+ pre =0, note = "User <UserFullName> : Removed: Group <GroupFullName>
+ pre =0, note = "User <UserFullName> : Copied profile from: <UserFullName>"
+ pre =0, note = "User <UserFullName> : Deleted"
+ pre =0, note = "User <UserFullName> : Changed description: <old> -> <new>"
+ pre =0, note = "User <UserFullName> : Changed Password"
+ etc.
+ pre =0, note = "Group <GroupFullName> : New name: <GroupName>"
+ pre =0, note = "Group <GroupFullName> : New description: <GroupDescription>"
+ pre =0, note = "Group <GroupFullName> : New sync OS: <Boolean>"
+ pre =0, note = "Group <GroupFullName> : New role: Role <RoleFullName>"
+ pre =0, note = "Group <GroupFullName> : Added: Group <GroupFullName>
+ pre =0, note = "Group <GroupFullName> : Removed: Group <GroupFullName>
5 Zuordnen der Makros zu Ereignissen
20
+ pre =0, note = "Group <GroupFullName> : Deleted"
+ pre =0, note = "Group <GroupFullName> : Changed description: <old> -> <new>"
+ pre =0, note = "Group <GroupFullName> : Changed role: <old> -> <new>"
+ etc.
+ pre =0 note = "Role <RoleName> : New name"
+ pre =0 note = "Role <RoleName> : New description: "RoleDescription>"
+ pre =0 note = "Role <RoleName> : New sync OS: <Boolean>"
+ pre =0 note = "Role <RoleName> : New access formula: <AccessFormula>"
+ pre =0 note = "Role <RoleName> : New work dir: <WorkDir>
+ pre =0 note = "Role <RoleName> : New excl Baskets: <Boolean>"
+ pre =0 note = "Role <RoleName> : New local config: <Boolean>"
+ pre =0 note = "Role <RoleName> : New command group mask: 111011001"
+ pre =0 note = "Role <RoleName> : New commands: <Commands>"
+ pre =0 note = "Role <RoleName> : Changed description: <old> -> <new>"
+ pre =0 note = "Role <RoleName> : Changed excl baskets: <old> -> <new>"
+ pre =0 note = "Role <RoleName> : Changed commands: <old> > <new>
+ pre =0 note = "Role <RoleName> : Deleted"
+ etc.
+ pre =0 note = "ACL <ACLName> : New name"
+ pre =0 note = "ACL <ACLName> : New description: <ACLDescription>"
+ pre =0 note = "ACL <ACLName> : New sync OS: <Boolean>"
+ pre =0 note = "ACL <ACLName> : New member: Group <GroupFullName>(RWDPV)"
+ pre =0 note = "ACL <ACLName> : Added member: User <UserFullName>(RDPV)"
+ pre =0 note = "ACL <ACLName> : Removed member: User <UserFullName>(RDPV)"
+ pre =0 note = "ACL <ACLName> : Deleted"
+ pre =0 note = "ACL <ACLName> : Changed description: <old> -> <new>"
+ etc.
5.2.9 Ereignis "Beleg-Übernahme"
Das Ereignis tritt bei der COLD-Übernahme auf.
+ pre = 1, note = <Dateiname>
5.2 Allgemeine Systemereignisse
21
+ pre = 0, note = <Zeit>
5.2.10 Ereignis "System"
Das Ereignis tritt bei bestimmten Aktionen der Server (Core Server) auf.
System
pre = 0, note = "Server started successfully." Nach erfolgreichem Start des Servers
pre = 0, note = "Server stopped." Nach Beenden des Server in der MMC
pre = 0, note = "IMPORT: WInfo.CSF, LINES: 3, OK: 2, ERROR: 1, TIME:
00:00:00"
Nach einem CSF-Import
5.2.11 Ereignis "Eingang in Korb"
Das Ereignis tritt nach dem Eingang eines Dokumentes in einem der Körbe auf. Der Parameter "pre"
ist immer 0. Der Parameter "note" enthält eine Zeichenkette, die sich aus einer Nummer für den
Korbtyp (0=Eingangskorb, 1=Dokumentenkorb, 2=Offenkorb, 4=Strukturfenster) und den Namen des
SAPERION Benutzers zusammengesetzt.
Eingang in Korb
pre = 0, note = "0 <Username>" Nach Eingang eines Dokuments im Eingangskorb eines Benutzers
pre = 0, note = "1 <Username>" Nach Eingang eines Dokuments im Dokumentenkorb eines Benutzers
pre = 0, note = "2 <Username>" Nach Eingang eines Dokuments im Offenkorb eines Benutzers
pre = 0, note = "4 <Username>" Nach Eingang eines Dokuments im Strukturfenster, auch bei Verschie-
ben von Dokumenten innerhalb des Strukturfensters.
5.2.12 Ereignis "Programmstart"
Das Ereignis tritt beim Starten von SAPERION ein.
Programmstart
pre = 1, note = "" Vor Erscheinen des Logon-Dialogs. Wenn der Rückgabewert des Ma-
kros FALSE ist, wird der Start von SAPERION abgebrochen.
pre = 0, note = "" Nach Aufbau der Oberfläche, unmittelbar bevor SAPERION benutzt
werden kann.
5.2.13 Ereignis "Programmende"
Das Ereignis tritt beim Beenden von SAPERION ein.
Programmende
pre = 1, note = "" Nach Ausführen des Befehls zur Beendigung von SAPERION, aber
noch vor der SAPERION Nachfrage "Soll SAPERION wirklich beendet
werden?"
5 Zuordnen der Makros zu Ereignissen
22
pre = 0, note = "" Nach der SAPERION Nachfrage "Soll SAPERION wirklich beendet wer-
den?"
5.2.14 Periodisches Ereignis
Ein periodisches Ereignis führt in definierbaren Zeitabständen (z.B. jede Minute) und zu definierbaren
Zeiten (z.B. zwischen 8:00 und 18:00 Uhr) ein entsprechend zugeordnetes Makro aus.
5.2.15 Ereignis "Menü geladen"
Das Ereignis tritt auf, wenn das Hauptmenü, das Viewer-Menü, das Kontextmenü vom Viewer oder das
Kontextmenü der Ergebnisliste geladen wird. Damit können eigene Menüs in die entsprechenden Menüs
eingehängt werden.
Welches Menü erzeugt wird, wird über den Parameter "note" bestimmt:
+ note="Main": Hauptmenü
+ note="Viewer": Menü des Viewers
+ note="ResultListContext": Kontextmenü der Ergebnisliste
+ note="ViewerContext": Kontextmenü des Viewers
+ note="StructureWindowContext": Kontextmenü des Strukturfensters
+ note="TrayWindowContext" Kontextmenü der Körbe
+ note="FreeResultList" : Ergebnisliste
+ note="FreeQueryForm: <form name>": Nicht eingebettete Masken
Zusätzlich wird das erzeugte Menü als "Menu" an das IMenu-Objekt übergeben und kann dort bearbeitet
werden.
Beispiel
Function CommandHandler( cmdId As Long, cmdString As String ) As Boolean
MsgBox "Command called: " + cmdString
CommandHandler = False
End Function
Function menuLoad( pre As Long, note As String ) As Boolean
Dim customMenu As Object
If note = "ResultListContext" Then
MsgBox "installed own handler for menu " & note
Menu.handler = "menutest!CommandHandler"
Menu.InsertItem "", 0, 2048
Set customMenu = Application.CreateMenu( "MenuTest", "CommandHandler" )
customMenu.InsertItem "Test", 101
Menu.InsertMenu "New!", customMenu
End If
menuLoad = True
5.3 Ereignisse in Abfrage- und Indexmasken
23
End Function
5.3 Ereignisse in Abfrage- und Indexmasken
SAPERION bietet die Möglichkeit, beim Auftreten bestimmter Ereignisse während der Benutzung von
Index- und Abfragemasken automatisch ein bestimmtes Makro auszuführen. Sie können auf diese
Weise gezielt die Benutzung der Masken kontrollieren und den Benutzer vor Fehlbedienungen schützen.
Zudem können Plausibilitätsüberprüfungen der vorgenommenen Einträge durchgeführt werden.
Die Zuordnung der Makros erfolgt an unterschiedlichen Stellen innerhalb des Masken-Designers von
SAPERION.
5.3.1 Maskenereignisse (Dialog Events)
Die unmittelbar mit der Maske im Zusammenhang stehenden Ereignisse werden über den Menübefehl
Ribbon START > Gruppe MODELLIEREN > Befehl EREIGNISSE im Dialogfenster "Ereignisse definieren"
angezeigt.
1. Markieren Sie die gewünschte Zeile und klicken auf die Schaltfläche [Makro...]. Der Dialog
"EventScript" öffnet sich.
2. Wählen Sie hier das gewünschte Makro aus.
Ein zugeordnetes Makro hat typischerweise folgenden Aufbau (Name der Funktion und
des Parameters ist frei wählbar):
Function OnSaveDialogEvent (controlld As Long) As Boolean
' ... Anweisungen
...
If ... Then OnSaveDialogEvent = True' ggf.Rückgabewert=True setzen, um fortzufahren
End Function
3. Über die Schaltfläche [Löschen] können Sie die Zuordnung zu einem Makro wieder
entfernen.
Die existierenden Maskenereignisse werden im Folgenden aufgelistet.
5.3.1.1 OnInitDialog - Ereignis
Das Ereignis tritt ein, wenn eine Maske geöffnet wird (mit ControlID=0). Der Rückgabewert des Makros
wird ignoriert, d.h. das Öffnen der Maske kann nicht über das Makro verhindert werden, es dient nur
der Initialisierung.
5.3.1.2 OnSaveDialog - Ereignis
Das Ereignis tritt ein, wenn in der Maske die Schaltfläche [OK] geklickt wird (mit ControlID=1). In
Abfragemasken tritt es zudem nach dem Klicken der Schaltfläche [Ergebnis] ein (mit ControlID=18). Der
5 Zuordnen der Makros zu Ereignissen
24
Rückgabewert des Makros muss TRUE sein, damit SAPERION seinen durch das Makro unterbrochenen
Ablauf weiter fortsetzt.
5.3.1.3 OnSetFocus - Ereignis
Das Ereignis tritt ein, wenn die Maske den Fokus erhält. Bitte beachten Sie, dass im dazugehörigen
Makro der Fokus nicht verändert werden darf, da sonst eine Endlosschleife auftreten kann. Der
Rückgabewert des Makros wird ignoriert.
5.3.1.4 OnKillFocus - Ereignis
Das Ereignis tritt ein, wenn die Maske den Fokus verliert. Bitte beachten Sie, dass im dazugehörigen
Makro der Fokus nicht verändert werden darf, da sonst eine Endlosschleife auftreten kann. Der
Rückgabewert des Makros wird ignoriert.
5.3.1.5 OnItemAccept
Das Ereignis wird ausgelöst, wenn eine Datei auf eine Maske gezogen wird. Wird als Ergebnis FALSE
zurückgegeben, ändert sich der Cursor entsprechend. Mit Hilfe von "OnItemDrop" kann dann zum
Beispiel die Archivierung eines Dokumentes durch Fallenlassen des Dokumentes auf die Maske realisiert
werden.
5.3.1.6 OnItemDrop
Das Ereignis tritt ein, wenn ein Dokument auf eine Maske fallengelassen wird.
5.3.2 Ereignisse in Maskenfeldern (Control-Events)
Bei der Benutzung der Masken treten in den einzelnen Maskenfeldern Ereignisse auf, denen gezielt
Makros zugeordnet werden können.
1. Öffnen Sie den SAPERION Masken-Designer beispielsweise über Ribbon DESIGN >
Gruppe ANWENDUNGEN > INDEXMASKE ERSTELLEN.
2. Durch Hinzufügen des Maskenelements "Feld" öffnet sich der Dialog "Masken-Feld", in
welchem Sie die entsprechenden Parameter definieren können.
3. Öffnen Sie die Registerkarte "Ablauf" und klicken auf die Schaltfläche [Ereignisse...].
5.3 Ereignisse in Abfrage- und Indexmasken
25
4. Der Dialog "Ereignisse definieren" öffnet sich. Hier werden die zur Verfügung stehenden
Ereignisse aufgelistet.
5. Wählen Sie den gewünschten Eintrag und klicken auf die Schaltfläche [Makro...]. Der
Dialog "EventScript" öffnet sich.
6. Wählen Sie im Dialog "EventScript" das dazugehörige Makro aus und klicken auf
[Auswählen].
Ein zugeordnetes Makro hat typischerweise folgenden Aufbau (Name der Funktion und
des Parameters ist frei wählbar):
Function OnSetFocusEvent (controlld As Long) As Boolean
' Anweisungen
...
' ggf.Rückgabewert=True setzen, um fortzufahren
If ... Then OnSaveDialogEvent = True
End Function
5 Zuordnen der Makros zu Ereignissen
26
Als Parameter wird eine eindeutige Kennung des Feldes in der Maske übergeben. Auslesen
kann man diese ID auch mit Hilfe der Funktion "FieldID" des Objektes IMask (COM-
Schnittstelle).
7. Über [Löschen] können Sie die Zuordnung zu einem Makro wieder entfernen.
8. Klicken Sie abschließend im Dialog "Masken-Feld" auf [OK], um Ihre Einstellungen zu
speichern.
Die existierenden Maskenfeldereignisse werden im Folgenden aufgelistet.
5.3.2.1 OnEditChanged - Ereignis
Das Ereignis tritt bei jeder Änderung im Feld ein (Eintippen eines Zeichens, Einfügen von Text aus
Zwischenablage, Ersetzen von selektiertem Text, Löschen einzelner Zeichen oder von selektiertem Text).
Der Rückgabewert des Makros wird ignoriert.
5.3.2.2 OnSetFocus - Ereignis
Das Ereignis tritt ein, wenn das Feld den Fokus erhält. Der Rückgabewert des Makros wird ignoriert.
5.3.2.3 OnKillFocus - Ereignis
Das Ereignis tritt ein, wenn das Feld den Fokus verliert. Der Rückgabewert des Makros wird ignoriert.
5.3.2.4 OnEditSetText - Ereignis
Das Ereignis tritt ein, wenn beim Öffnen der Maske die Vorbelegung eines Feldes ausgewertet und in
das Feld übertragen wird. Der Rückgabewert des Makros wird ignoriert.
5.3.2.5 OnSelChange – Ereignis
Das Ereignis tritt ein, wenn auf Nachschlagetabellen oder Outliner zugegriffen werden soll.
5.3.3 Ereignisse in Ergebnislisten
In einer Ergebnisliste treten Ereignisse auf, denen gezielt Makros zugeordnet werden können.
1. Öffnen Sie den SAPERION Masken-Designer beispielsweise über Ribbon DESIGN >
Gruppe ANWENDUNGEN > INDEXMASKE ERSTELLEN.
2. Durch Hinzufügen des Maskenelements "Suche" öffnet sich der Dialog "Masken-
Ergebnisliste", in welchem Sie die entsprechenden Parameter definieren können.
3. Öffnen Sie die Registerkarte "Eigenschaften" und klicken auf die Schaltfläche
[Ereignisse...].
5.3 Ereignisse in Abfrage- und Indexmasken
27
4. Der Dialog "Ereignisse definieren" öffnet sich. Hier werden die zur Verfügung stehenden
Ereignisse aufgelistet.
5. Wählen Sie den gewünschten Eintrag und klicken auf die Schaltfläche [Makro...]. Der
Dialog "EventScript" öffnet sich.
6. Wählen Sie im Dialog "EventScript" das dazugehörige Makro aus und klicken auf
[Auswählen].
7. Über [Löschen] können Sie die Zuordnung zu einem Makro wieder entfernen.
8. Klicken Sie abschließend im Dialog "Masken-Ergebnisliste" auf [OK], um Ihre
Einstellungen zu speichern.
Die existierenden Masken-Ergebnisliste Ereignisse werden im Folgenden aufgelistet.
5 Zuordnen der Makros zu Ereignissen
28
5.3.3.1 OnSelChange - Ereignis
Das Ereignis tritt ein, wenn ein Zugriff erfolgen soll.
5.3.3.2 OnItemDrag - Ereignis
Das Ereignis tritt ein, wenn ein Drag ausgeführt wird.
5.3.3.3 OnItemAccept - Ereignis
Das Ereignis tritt ein, wenn an dieser Stelle ein Drop möglich wäre.
5.3.3.4 OnItemDrop - Ereignis
Das Ereignis tritt ein, wenn ein Drop ausgeführt wird.
5.3.3.5 OnTooltip - Ereignis
Das Ereignis tritt ein, wenn der Tooltip angezeigt wird.
5.3.3.6 OnDragCancel - Ereignis
Das Ereignis tritt ein, wenn ein Drag&Drop Vorgang abgebrochen wird, d.h. wenn ein Drag ohne Drop
ausgeführt wird.
5.3.3.7 OnEdit - Ereignis
Das Ereignis tritt ein, wenn ein Dokument aus der Ergebnisliste bearbeitet werden soll.
5.3.3.8 OnView - Ereignis
Das Ereignis tritt ein, wenn ein Dokument aus der Ergebnisliste angezeigt werden soll.
5.3.3.9 OnPrint - Ereignis
Das Ereignis tritt ein, wenn ein Dokument aus der Ergebnisliste gedruckt werden soll. Sind mehrere
Dokumente markiert, tritt das Ereignis beim letzten selektierten Dokument ein.
5.3.3.10 OnDelete - Ereignis
Das Ereignis tritt ein, wenn ein Dokument aus der Ergebnisliste gelöscht werden soll.
5.3.3.11 OnIndex - Ereignis
Das Ereignis tritt ein, wenn der Index eines Dokuments aus der Ergebnisliste geöffnet werden soll.
5.3.3.12 OnSave - Ereignis
Das Ereignis tritt ein, wenn ein Dokument aus der Ergebnisliste gespeichert werden soll.
5.3.3.13 OnNew - Ereignis
Das Ereignis tritt ein, wenn in der Ergebnisliste einer Abfragemaske zur Pflege einer Nachschlagetabelle
ein neuer Datensatz eingegeben werden soll.
5.3.3.14 OnSecurity - Ereignis
Das Ereignis tritt ein, wenn einem Dokument aus der Ergebnisliste eine ACL zugewiesen werden soll.
5.3.4 Ereignisse in Outlinern
In Outlinern auftretenden Ereignissen können gezielt Makros zugeordnet werden. Dies erfolgt
im Dialogfenster "Masken-Outliner" durch Klicken der Schaltfläche [Ereignisse...]. Im Dialogfenster
"Ereignisse definieren" werden daraufhin die zur Verfügung stehenden Ereignisse aufgelistet.
5.3 Ereignisse in Abfrage- und Indexmasken
29
1. Öffnen Sie den SAPERION Masken-Designer beispielsweise über Ribbon DESIGN >
Gruppe ANWENDUNGEN > INDEXMASKE ERSTELLEN.
2. Durch Hinzufügen des Maskenelements "Suche" öffnet sich der Dialog "Masken-
Outliner", in welchem Sie die entsprechenden Parameter definieren können.
3. Öffnen Sie die Registerkarte "Parameter" und klicken auf die Schaltfläche [Ereignisse...].
4. Der Dialog "Ereignisse definieren" öffnet sich. Hier werden die zur Verfügung stehenden
Ereignisse aufgelistet.
5. Wählen Sie den gewünschten Eintrag und klicken auf die Schaltfläche [Makro...]. Der
Dialog "EventScript" öffnet sich.
6. Wählen Sie im Dialog "EventScript" das dazugehörige Makro aus und klicken auf
[Auswählen].
7. Über [Löschen] können Sie die Zuordnung zu einem Makro wieder entfernen.
8. Klicken Sie abschließend im Dialog "Masken-Outliner" auf [OK], um Ihre Einstellungen
zu speichern.
Die existierenden Masken-Outliner Ereignisse werden im Folgenden aufgelistet.
5 Zuordnen der Makros zu Ereignissen
30
5.3.4.1 OnSelChange
Das Ereignis tritt ein, wenn auf den Outliner zugegriffen werden soll.
5.3.4.2 OnExpand
Das Ereignis tritt ein, wenn eine weitere Outlinerebene geöffnet wird.
5.3.4.3 OnItemDrag
Das Ereignis tritt ein, wenn ein Drag ausgeführt wird.
5.3.4.4 OnItemAccept
Das Ereignis tritt ein, wenn an dieser Stelle ein Drop möglich wäre.
5.3.4.5 OnItemDrop
Das Ereignis tritt ein, wenn ein Drop ausgeführt wird.
5.3.4.6 OnItemNew
Das Ereignis tritt ein, wenn eine neue Outlinerebene angelegt wird.
5.3.4.7 OnItemEdit
Das Ereignis tritt ein, wenn eine Outlinerebene bearbeitet wird.
5.3.4.8 OnItemDelete
Das Ereignis tritt ein, wenn eine Outlinerebene gelöscht wird.
5.3.4.9 OnDragCancel
Das Ereignis tritt ein, wenn ein Drag&Drop Vorgang abgebrochen wird, d.h. wenn ein Drag ohne Drop
ausgeführt wird.
5.3.5 Ereignisse durch Schaltflächen in Masken
Über Schaltflächen können in zweierlei Weise Makros ausgeführt werden. Zum einem können
zusätzliche Schaltflächen definiert werden, deren alleinige Funktion die Ausführung eines Makros ist.
5.3 Ereignisse in Abfrage- und Indexmasken
31
Zum anderen kann jeder Schaltfläche über das Ereignis "OnButtonClicked" ein Makro zugeordnet
werden.
In der ersten Variante kann eine beliebige Subprozedur verwendet werden, in der zweiten Variante
müssen die Makros in einer bestimmten Syntax vorliegen. In beiden Varianten werden die Makros
ausgehend vom Dialogfenster "Masken-Schalter" zugeordnet.
5.3.5.1 Definieren einer Schaltfläche, die ein Makro ausführt
1. Öffnen Sie den SAPERION Masken-Designer beispielsweise über Ribbon DESIGN >
Gruppe ANWENDUNGEN > INDEXMASKE ERSTELLEN.
2. Durch Hinzufügen des Maskenelements "Button" öffnet sich der Dialog "Masken-
Schalter", in welchem Sie die entsprechenden Parameter definieren können.
3. Öffnen Sie die Registerkarte "Funktion" und klicken auf die Schaltfläche [Ereignisse...].
4. Der Dialog "Ereignisse definieren" öffnet sich. Hier werden die zur Verfügung stehenden
Ereignisse aufgelistet.
5. Wählen Sie den gewünschten Eintrag und klicken auf die Schaltfläche [Makro...]. Der
Dialog "EventScript" öffnet sich.
6. Wählen Sie im Dialog "EventScript" das dazugehörige Makro aus und klicken auf
[Auswählen].
Das zugeordnete Makro ist eine Prozedur (Sub oder Function) ohne Parameter. Der Name
ist frei wählbar:
Sub MyMacroButton()
' Anweisungen
...
End Sub
7. Über [Löschen] können Sie die Zuordnung zu einem Makro wieder entfernen.
5 Zuordnen der Makros zu Ereignissen
32
8. Klicken Sie abschließend im Dialog "Masken-Schalter" auf [OK], um Ihre Einstellungen
zu speichern.
5.3.5.2 Zuordnung des Makros über das Ereignis "OnButtonClick"
1. Öffnen Sie den SAPERION Masken-Designer beispielsweise über Ribbon DESIGN >
Gruppe ANWENDUNGEN > INDEXMASKE ERSTELLEN.
2. Durch Hinzufügen des Maskenelements "Button" öffnet sich der Dialog "Masken-
Schalter", in welchem Sie die entsprechenden Parameter definieren können.
3. Öffnen Sie die Registerkarte "Funktion" und klicken auf die Schaltfläche [Ereignisse...].
4. Der Dialog "Ereignisse definieren" öffnet sich. Hier werden die zur Verfügung stehenden
Ereignisse aufgelistet.
5. Wählen Sie den gewünschten Eintrag und klicken auf die Schaltfläche [Makro...]. Der
Dialog "EventScript" öffnet sich.
6. Wählen Sie im Dialog "EventScript" das dazugehörige Makro aus und klicken auf
[Auswählen].
Ein zugeordnetes Makro hat typischerweise folgenden Aufbau (Name der Funktion und
des Parameters ist frei wählbar):
Function OnButtonClickEvent (controlld As Long) As Boolean
' Anweisungen
...
' ggf. Rückgabewert=True setzen, um fortzufahren
If ... Then OnButtonClickEvent = True
End Function
Als Parameter wird eine eindeutige Kennung des Feldes in der Maske übergeben. Auslesen
kann man diese ID auch mit Hilfe der Funktion "FieldID" des Objektes "IMask".
7. Über [Löschen] können Sie die Zuordnung zu einem Makro wieder entfernen.
5.3 Ereignisse in Abfrage- und Indexmasken
33
8. Klicken Sie abschließend im Dialog "Masken-Schalter" auf [OK], um Ihre Einstellungen
zu speichern.
5.3.5.3 OnButtonClick-Ereignis
Das Ereignis tritt ein, wenn eine Schaltfläche in einer Maske gedrückt wurde. Der Rückgabewert des
Makros muss TRUE sein, damit SAPERION seinen durch das Makro unterbrochenen Ablauf weiter
fortsetzt.
5.3.6 Ereignisse durch ActiveX-Objekte in Masken
Bei Verwendung von ActiveX-Objekten in einer Maske stehen Ihnen in der Regel mehrere Ereignisse zur
Verfügung. Welche dies sind, ist vom jeweiligen ActiveX-Objekt abhängig.
1. Öffnen Sie den SAPERION Masken-Designer beispielsweise über Ribbon DESIGN >
Gruppe ANWENDUNGEN > INDEXMASKE ERSTELLEN.
2. Durch Hinzufügen des Maskenelements "ActiveX-Objekt" öffnet sich der Dialog "ActiveX-
Objekt erzeugen".
3. Öffnen Sie die Registerkarte "Ereignisse" und klicken auf die Schaltfläche [Makro...].
4. Der Dialog "Ereignisse definieren" öffnet sich. Hier werden die zur Verfügung stehenden
Ereignisse aufgelistet.
5. Wählen Sie den gewünschten Eintrag und klicken auf die Schaltfläche [Makro...]. Der
Dialog "EventScript" öffnet sich.
6. Wählen Sie im Dialog "EventScript" das dazugehörige Makro aus und klicken auf
[Auswählen].
Das zugeordnete Makro ist eine Prozedur (Sub oder Function) ohne Parameter. Der Name
ist frei wählbar:
Sub MyActiveXEvent()
' Anweisungen
...
End Sub
7. Klicken Sie abschließend im Dialog "ActiveX-Objekt erzeugen" auf [OK], um Ihre
Einstellungen zu speichern.
6 Beispiele
In den folgenden Beispielen wird erläutert, wie die verschiedenen Funktionsgruppen in "EventScript"
benutzt werden. Die dabei verwendeten Beispiele stammen aus reellen Anwendungsfällen von
SAPERION.
6 Beispiele
34
6.1 Einfache SAPERION Funktionen
6.1.1 Programmierung Ribbons
Die mit SAPERION 7 eingeführten Ribbons basieren auf Drittprogrammen der Firma Codejock Software.
Sie werden in Form von ActiveX-Objekten (Codejack.*.ocx; im SAPERION Verzeichnis) zur Verfügung
gestellt. Über die API-Schnittstelle haben Sie die Möglichkeit eigene Ribbons zu erzeugen und anzeigen
zulassen.
Zu diesem Zweck stehen Ihnen die "Best Practices Programmierung Ribbons" zur Verfügung.
6.2 Komplexere SAPERION Funktionen
6.2.1 Löschen aus der Nachschlagetabelle bei der Archivierung
6.2.1.1 Anwendungsfall
Dokumente, die mit einem Barcode versehen sind, sollen während der Archivierung automatisch mit
Indexinformationen aus einer Nachschlagetabelle versehen werden. Um zu überprüfen, ob alle Barcodes
korrekt abgearbeitet werden, soll bei der Archivierung der zum Barcode gehörende Datensatz aus der
Nachschlagetabelle gelöscht werden.
6.2.1.2 Code-Beispiel
Es wird in der Workflow-Komponente eine Verknüpfung des Ereignisses "Archivierung" mit dem
entsprechenden Makro hergestellt.
' Sub Delete ( ) im Haltemodus
Sub Delete ( event As Long, s As String )
Dim vLabel As String
Dim DeleteCursor As Object
If Len( s ) = 0 Then
vLabel = document.Label
Set DeleteCursor = Application.SelectQuery ( "NKBel", "NLabel='" & vLabel & "'" )
If DeleteCursor.First Then
DeleteCursor.DeleteCurrent
End If
Else
MsgBox "Fehler: " & s
End If
End Sub
6.3 Makros in Masken
35
i Im Haltemodus müssen die Funktionen ohne Parameter definiert werden, da in diesem Modus
keine Aufrufparameter unterstützt werden.
6.3 Makros in Masken
6.3.1 Auswahl einer Applikation
6.3.1.1 Anwendungsfall
In manchen Fällen ist es notwendig, in Indexierungs- oder Ergebnismasken spezielle Funktionen zur
Verfügung zu stellen, die nicht zum Standardumfang von SAPERION gehören. In Windows sind die
Dateiendungen bekanntermaßen nicht eindeutig. Eine Dateiendung kann als Repräsentant für mehrere
Anwendungen benutzt werden. So können z. B. TXT-Dateien sowohl mit NOTEPAD als auch mit WRITE
geöffnet werden. Es ist also anhand der Dateiendung nicht immer erkennbar, welches Programm zur
Bearbeitung herangezogen werden soll.
6.3.1.2 Code-Beispiel
Im Masken-Editor von SAPERION kann in einer Maske ein Makro-Knopf definiert werden, mit dem ein
Makro verknüpft werden kann. Je nach Maskentyp steht der Fokus auf bestimmten Objekten. In der
Indexierungsmaske ist zum Beispiel der Fokus auf das aktuelle Dokument gesetzt, so dass direkt mit
dem Dokument gearbeitet werden kann. Nun ist es möglich, aus einer vorher definierten Auswahlliste
eine Applikation auszuwählen, das Dokument zu speichern und die Applikation mit dem gespeicherten
Dokument aufzurufen.
Sub StoreFile()
Dim FileName As String
Dim ID As Long
FileName = Document.FileName
FileName = "C:\TEMP\" & FileName
Document.SaveAs(0,FileName,0)
MsgBox "Datei unter " & FileName & " gespeichert."
End Sub
Sub Apps()
Dim AppNames$(2)
Begin Dialog SelectAppDlg 20, 20, 150, 50, "SelectApp"
OKButton 80, 10, 50, 13
CancelButton 80, 30, 50, 13
DropListBox 10, 10, 60, 50, AppNames$(), .DrpList
TextBox 10, 30, 60, 13, .Parameter
End Dialog
Dim Button As Long
Dim FileName As String
Dim ID As Long
Dim SelectApp As SelectAppDlg
6 Beispiele
36
Dim ExecString As String
AppNames(1)="PBrush"
AppNames(2)="Notepad"
FileName = Document.FileName
FileName = "C:\TEMP\" & FileName
'MsgBox FileName
Document.SaveAs(0,FileName,0)
Button = Dialog (SelectApp)
If Button = -1 Then
'MsgBox AppNames(SelectApp.DrpList+1)
ExecString = AppNames(SelectApp.DrpList+1) & " " & FileName & " " & SelectApp.Parameter
'MsgBox ExecString
ID = Shell (ExecString)
End If
End Sub
6.4 Benutzung der COM-Objekte anderer Applikationen
6.4.1 Benutzung der COM Objekte von Microsoft Word
Das folgende Beispiel lädt eine Datei Word.Doc, fügt am Anfang einen Text ein und speichert das
Dokument anschließend.
Sub COMWord()
Dim WordObj As Object
Dim myData As String
' Demonstrates Automatic type conversion
myData = 4 * Atn(1)
Set WordObj = CreateObject("Word.Application")
WordObj.Documents.Open Filename:="C:\Saperion\Word.doc"
WordObj.Visible = True
WordObj.Selection.TypeText "The following was computed in Cypress Enable: "
WordObj.Selection.TypeText MyData
WordObj.ActiveDocument.Close
Set WordObj = Nothing
End Sub