SAPERION EventScript - docs.kofax.com · 1 SAPERION EventScript 1 Einführung SAPERION lässt sich dank seiner umfangreichen Programmiermöglichkeiten schnell und flexibel an projektspezifische

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.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".


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:


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".


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.


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.


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.


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


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.

Drucken

pre = 1, note = " " Nach Klicken der Schaltfläche [OK] im Dialogfenster "Drucken"


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>


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>


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?"


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


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


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...].


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].



Function OnSetFocusEvent (controlld As Long) As Boolean

' Anweisungen

...

' ggf.Rückgabewert=True setzen, um fortzufahren

If ... Then OnSaveDialogEvent = True

End Function


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.



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...].


27






[Auswählen].


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.


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.


29



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...].






[Auswählen].


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.


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.


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



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...].






[Auswählen].

Das zugeordnete Makro ist eine Prozedur (Sub oder Function) ohne Parameter. Der Name

ist frei wählbar:

Sub MyMacroButton()

' Anweisungen

...

End Sub



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"



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...].






[Auswählen].



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".



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.



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...].






[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