ELO OLE Automation Interface Description UK
ELO OLE Automation Interface Description UK
ELO OLE Automation Interface Description UK
02.03.2007
The ELOoffice 2.1 DDE Interface has been replaced by a more modern and improved OLE Automation
Interface with the professional version. It is now possible to send commands to ELO from outside, make entries
or request information from ELO.
Script names can be allocated freely. They must only meet the rules for a file name. All script names starting
with ELO are reserved for ELO Digital Office. You should not use these, as otherwise name conflicts may
occur.
The OLE Automation Interface by ELO is very similar to the previous DDE interface. For this reason it cannot
be called object oriented, but command oriented.
The interface is more or less identical for ELOoffice and ELOprofessional, however, not all functions are
available under ELOoffice. When creating the objects it needs to be remembered that ELOoffice has another ID
than ELOprofessional. For ELOoffice, the object must be created with the ID ELO.office instead of
ELO.professional. If you want to use the Automation Interface under ELOprofessional 2.5, you must use the ID
LeitzElo.Elo32, ELOoffice 4.5 required the ID LeitzElo.Elo32o. The LeitzElo Ids are still valid for the program
versions ELOprofessional 3.0 or 5.0 for compatibility reasons, but will be discarded in the next program version.
Important Information:
These two main targets may result in the introduction of new Automation commands in the project within a
short period of time, that are intended to execute one particular function only. Consequently, it is not guaranteed
that each command is executable in each workview and in any combination with other commands. Due to the
compatibility requirement, new client functions cannot always be introduced to the existing commands. In this
case, either an xyz_EXT function is created or the functionality is not exported via the Automation Interface at
all.
Please note also, that this interface is a Client-Interface. It’s not conceived for executing a large amount of
actions. You should check before penetrating in border ranges, whether the OLE Interface meets your requests
at all. Since here are many components involved on which we have no influence, we’re not able to offer you a
work around at some limitations (e.g. memory leaks in the OLE Interface, in Windows Scripting Host or in the
Compiler Run-time environment as well).
Table of Contents
Appendix.............................................................................................................................................................416
Appendix A, Description of dialog elements in the main ELO view...............................................................416
The ELO object is only simply available, several CreateObject requests trigger off the same program instance to
be accessed. In order to be able to use two ELOprofessional versions per scripting at the same time (e.g. for
script-controlled transfer between two different archives), the following procedure needs to be followed:
• Apart from the ELO32D.EXE version, you can now additionally create ELO32E.EXE, ELO32F.EXE
and ELO32G.EXE.
• These programs then answer to ELO.professional2 (ELO32D.EXE), ELO.professional3
(ELO32E.EXE), ELO.professional4 (ELO32F.EXE), and ELO.professional5 (ELO32G.EXE).
You can now use separate program allocations for different script tasks. For example, if you have written a
series of extensions for a help desk function and another group of scripts for automatic e-mail storage in another
archive, you can use the two applications (up to 4) via this extension.
If you want to work with different archives from one workplace, you can do so to a certain extent with the
profiles. For this purpose, you can automatically switch the settings for AccessManager and database login
during program start. However, there are a large number of settings that are not part of the profiles, but must be
switched in practice. These are for example ScriptEvents, button allocations, and preset storage masks. This is
especially annoying if you want to work in the different areas at the same time. For this reason, from version
3.00.360 there is a possibility to operate the clients completely with their own registry branches.
First Steps
The following sections provide an overview of ELO Automation Interface programming. The examples focus on
the required steps, no error log is carried out.
From version 3.0 onwards you have the opportunity to record all automation accesses in one file. This is a
practical extension for the script creation. However, this new function is rendered special importance in case of
malfunctions or when controlling completed components, whose interior structure cannot be viewed. The report
is switched on via the Options dialog:
In general, there are two different scenarios for ELO remote control:
1. A user works with ELO and you want to carry out actions in the work area of this user via your
application. In this case no login is required, it has already been carried out by the user. You then
only need to check in your application whether ELO is already active.
2. You have an independent process (e.g. automatic fax or mail transfer). In this case the application
has to carry out a login (and a logout at the end).
}
catch (...)
{
// ELOprofessional must have been called at least once
// at the workplace - it then registers
// automatically as OLE Automation Server
return;
};
// check version
iOleResult=EloServer.OleFunction("Version");
if (iOleResult<101002)
{
// version is smaller than 1.01.002
// too old!
EloServer.OleFunction("Login","LOGOUT","","");
EloServer=NULL;
return;
};
// System login
iOleResult=EloServer.OleFunction("Login", Login name,
password, archive);
if (iOleResult<0)
{
// Unknown login name, password or archive
EloServer.OleFunction("Login","LOGOUT","","");
EloServer=NULL;
};
With the GetEntryId function, you can request the currently selected entry, GetEntry then supplies you with the
appropriate name.
ObjectId=EloServer.OleFunction("GetEntryId",-1);
ObjectShort=EloServer.OleFunction("GetEntryName",ObjectId);
List of All Documents in the Accounting Cabinet, Invoice Folder, 1998 Tab
First of all, the ObjectId of the 1998 tab in the invoices folder in the accounting cabinet is detected with
LookupIndex. After switching to the tab, all documents can be requested.
In order to add a new document, first of all an empty input must be prepared, the subject data are to be added,
and the image file must be transferred to the user postbox with AddToPostbox. This entry can then be added to
the archive.
If you want to add a document to the archive, you must first determine the document type. ELO works internally
with mask numbers in this case, the real world with descriptions. In order to convert the description into a mask
number, you have to browse through the available masks and compare with the description.
iEloMask=0;
for (iEloMask=0;iEloMask<MAX_MASKNO;iEloMask++)
{
if (EloServer.OleFunction("ReadObjMask",iEloMask)>=0)
{
sTmp=EloServer.OlePropertyGet("ObjMName");
if (sTmp.UpperCase()=="ELOMAIL")
{
return iEloMask;
};
};
};
return -1;
};
It will be simpler from version 1.01.048 with the LookupMaskName function. The function described above is
reduced to one request:
iEloMask=EloServer.LookupMaskName("ELOMAIL");
Adding a Mail with Text Body and File Attachment to the Archive
The following example shows how an e-mail is automatically added to the archive. For this purpose, the e-mail
is first checked in, the subject, sender and recipient are evaluated and the body and the file attachment
are saved. The basic information and the file names are then transferred to the InsertIntoELO function.
EloServer.OleFunction("PrepareObject",0,4,iMailMask);
EloServer.OlePropertySet("ObjShort",sSubject);
EloServer.OlePropertySet("ObjFlags",1); // version controlled
if (iMailMask>0)
{
// the EloMail mask has two
// additional entries: sender and recipient
EloServer.OleFunction("SetObjAttrib",0,sFrom);
EloServer.OleFunction("SetObjAttrib",1,sTo);
};
iOleResult=EloServer.OleFunction("AddPostboxFile",sMailText);
return iOleResult>0;
};
Editing a Mask
With the ReadObjMask and WriteObjMask commands you can read document type information and save it
again. The following values are available as document type information:
In addition there are 50 attribute lines (0..49) available. Each attribute line has the following values:
The ObjAttrib field is irrelevant for definition of an input mask, it is not stored at this point, as it will only
record the user input at a later stage when creating documents.
The differentiation of ObjAttribName and ObjAttribKey is carried out for three reasons:
• If different language versions need to cooperate, a suitable text (e.g. "Rechnungsnummer" and "Invoice
No.") can be displayed in the input masks. However, the same key is used database-internal in both cases
(e.g. "INVNO").
• A mask can contain several of the same fields. For example, a "Book" input mask can contain several lines
on the authors (author, co-author etc.). All these lines can then be added to the same key (e.g. author)
database-internally and thus they can all be considered during the search.
• Different masks can contain similar fields. An invoice contains the "Client name" field, a delivery note
contains the "Supplier name" field. Both fields can contain the internal "Name" database key and can thus be
triggered directly during the search.
Please note that the minimum and maximum input refers to the number of digits and not (not even for numerical
fields) to the input value.
Index lines 0..49 are available for the subject data fields. This is followed by 10 lines that are reserved for ELO-
internal tasks. Line 50 contains the link information at present. For this purpose, the index line is allocated the
group description ELO_XLINK in the AttribName field and a 12-digit random character string in the Field
value.
NEWMASK=9999
Set Elo=CreateObject("ELO.professional")
if Elo.ReadObjMask(NEWMASK)<0 then
MsgBox "Error while preparing mask"
else
Elo.ObjMName="ELO test mask"
Elo.MaskFlags=25
x=Elo.WriteObjMask()
if x<0 then
MsgBox "Error no. " & x & " when creating new mask."
else
MsgBox "New mask with number " & Elo.ObjMaskNo & " created."
end if
end if
For reading color values, the ReadColorInfo function and the ColorInfo and ColorName properties are available.
iOleResult=EloServer.OleFunction("ReadColorInfo",MyColorNumber);
if (iOleResult>0)
{
MyColorRGB=EloServer.OlePropertyGet("ColorInfo");
MyColorName=EloServer.OlePropertyGet("ColorName");
};
For detecting the complete color table, a special form of ReadColorInfo is available. If you set the 0x8000 bit in
the color number while reading, the function reads the desired color or if it is not available, the next highest
color number.
MyColorNumber=0;
for (;;)
{
MyColorNumber=MyColorNumber|0x8000;
iOleResult= EloServer.OleFunction("ReadColorInfo",MyColorNumber);
if (iOleResult<0) break;
MyColorNumber= EloServer.OlePropertyGet("ColorNo");
// Now edit the current color value here
MyColorNumber++;
};
For requesting or setting the current workview, the SelectView function is available. When you request this
function with the 0 parameter, you receive the number of the currently set worksheet (1..5) as return value. If
you use one of the values 1…5, the selected view is displayed.
if (ActView!=3)
{
// is not set to the postbox -> switch
EloServer.OleFunction("SelectView",3);
};
The following example illustrates how an external program or an ELO scripting macro can search the postbox
and edit the available entries.
In this example, all entries are loaded and the selected entries are appended by the term "Important" in the memo
field, the non-selected entries by the term "Unimportant".
// Read content of the memo field, add additional text and back
sText=EloServer.OlePropertyGet("ObjMemo")+sText;
EloServer.OlePropertySet("ObjMemo",sText);
Many feed scanners can only scan A4 documents in longitudinal direction. If a number of documents need to be
scanned horizontally, the user must intervene for every single document. This process can be automated with a
simple script. Create a new script with the following content:
Set Elo=CreateObject("ELO.professional")
res=Elo.RotateFile("",90)
Now log in this script for the "after scanning" event. A rotation process is actuated after each page fed.
This script can also easily be extended so that it searches the complete post list for selected entries and rotates
them accordingly. This way it can then be placed onto a user-free button and a larger group of documents can
thus be rotated at the same time.
In a company, delivery notes are printed with barcode. These delivery notes are then appended with
notes by hand and cannot be directly transferred via COLD for this reason. Instead they are scanned in
again and stored in the archive via the barcode component.
In the example, the ELO documents are then to be checked regularly from the order management (has
the delivery note been scanned in the meantime?) and additional information is to be entered.
The storage mask for the delivery notes contains a line "Delivery note number – DLNO", which is
entered via the barcode component and the lines "Customer number – CTNO" and "Delivery date –
DLDAT", which are appended from the order management.
As preparation for the subsequent lines, the application must create an EloServer object and determine the mask
with the name "Delivery notes" from the masks list (iLfMaskNo).
First of all, the order management has to browse all delivery notes that are still open – for each delivery note the
following routine is then requested (please note that a "real" routine should contain respective error checks,
which have been removed hear for reasons of clarity):
iObjId=EloServer.OleFunction("GetEntryId",0)
EloServer.OleFunction("PrepareObject",iObjId,4,iLfMaskNo);
EloServer.OleFunction("SetObjAttrib",1,sCtno);
EloServer.OlePropertySet("ObjXDate",sDldat);
EloServer.OleFunction("UpdateObject");
return true;
}
As a consequence of the function request, the order management then only has to issue an error message or
append its internal database with the information that the comparison could be carried out successfully. This
procedure has the advantage that a control is given whether all delivery notes have been scanned in again, and
the data that are available in the system anyway (customer number, date) do not need to be manually processed
further.
Set Elo=CreateObject("ELO.professional")
STemp=""
id=Elo.GetEntryId(-1)
ires=Elo.PrepareObject(id,0,0)
STemp=Elo.ObjShort
' Checks for separator and empty page at the same time
res=Elo.CheckPage(3, 970)
if res=1 or res=3 then
' is an empty page, now determine limit value
for j=970 to 999
if Elo.CheckPage(1,j)=0 then
exit for
end if
next
sTmp=sTmp & " [ IsWhite: " & j/10.0 & " % ] "
end if
The following example browses the postlist, takes each selected example and browses a defined section for the
keywords "Invoice" and "Delivery note" via the OCR software. If one of these keywords is found, it reads the
related mask definition and browses additional sections of the form for invoice number, customer number etc.
These entries are then saved with the document and added to the archive.
' The program reads all selected entries of the postbox and
' checks whether the document belongs to the "invoice" or "Delivery note"
' mask type. The respective data of the mask lines are then checked out from the
' form and saved.
' Afterwards, the document is moved to the archive.
res=Elo.UpdatePostbox()
When editing a self-adhesive note, the name and time are automatically entered into the text field. The
ScriptActionKey parameter contains values 1: before the request, 2: after the request, completed with Ok and 3:
after the request, completed with Cancel.
set Elo=CreateObject("ELO.professional")
if Elo.ScriptActionKey=1 then
note=Elo.NoteText
if note<>"" then
note=note & vbcrlf & vbcrlf & "====" & vbcrlf
end if
Elo.ReadUser(Elo.ActiveUserId)
note=note & Date & Time & ": " & Elo.UserName & vbcrlf & "----" & vbcrlf
Elo.NoteText=note
end if
The following lines contain an example for the automatic transfer of a document from WinWord to ELO using a
macro.
LOGIN:
Set ELOServer = Nothing ' release server object again
MsgBox ("Error: You must login under ELOprofessional.")
GoTo END
StartEloProgram:
MsgBox ("Error: ELOprofessional must be enabled for transfer.")
END:
End Sub
Within the process control two scripts can be allocated to each node, which are automatically processed at each
activation or termination of a node respectively. Within such a script the data of the current node can be
accessed, for this purpose, the properties
NodeAction, NodeActivateScript, NodeAlertWait, NodeAvailable, NodeComment, NodeFlowName,
NodeName, NodeTerminateScript, NodeType, NodeUser and NodeYesNoCondition are available (for
description of individual properties, see below).
Before these properties are accessed, the NodeAvailable property must be checked. For a value of 1, information
is available on a node, otherwise no information is available. If the script is requested manually for example, i.e.
not within the context of a process, there is no information available on a node. In this case the NodeAvailable
property has the value 0.
Caution: When forwarding a workflow activity, first of all the entire workflow is checked into the
document including the ELO index information. Afterwards, the required steps are executed in the
workflow including the respective scripts. if you change the index information in one of the scripts, the
new data are not yet visible within this step. This can be especially critical for branch nodes. If the
branching occurs due to the "AMOUNT" field, and this field is changed before branching in the end
script of the node, this new value will not included in the decision making process. If this should be
necessary, however, the group name of the respective field must be preceded by an exclamation mark in
the decision node. This informs the workflow that it has to check out the respective field directly from the
database and not from the internal data.
CRLF=Chr(13)&Chr(10)
Set Elo=CreateObject("ELO.professional")
If Elo.NodeAvailable=1 Then
if Elo.NodeAction=1 Then
NTxt=NTxt&" enabled."
Else
NTxt=NTxt&" terminated."
End If
NTxt="Action: "&NTxt
CommentTxt="Comment: "&Elo.NodeComment
If Elo.NodeType=4 Then
ConditionTxt="Condition: "&Elo.NodeYesNoCondition
Else
ConditionTxt=""
End If
MsgBox FlowTxt&CRLF&NTxt&CRLF&NameTxt&CRLF&KommentarTxt&CRLF_
&ConditionTxt&CRLF&ActivateTxt&CRLF&TerminateTxt
End If
If the active node is a distribution node, the script can control to which successor the document is to be
forwarded. Such a script is entered in the End Script field of a (distribution) node:
Set Elo=CreateObject("ELO.professional")
ObjID=Elo.NodeObjectID 'Access to the data...
Elo.PrepareObject ObjID,0,0 '...of the document being processed
MsgBox Elo.ObjShort
Rv=Elo.OpenChildNodes 'Open access to the subsequent nodes
If Rv=1 Then
Do
rv=Elo.GetChildNode 'Read subsequent node...
If (rv>0) Then '...available for
If Elo.NodeUser=3 Then 'Only user no. 3 receives the document...
Elo.NodeAllowActivate=1
Else '...none of the others
Elo.NodeAllowActivate=0
End If
End If
Loop Until rv<0
Elo.SelectCurrentNode 'Switch back to current node
End If
With the "When entering/moving an object reference" script event you can react when a user moves a document
or a storage structure element within the archive. Here, one could make adjustments for example within the
authorization structure or the subject data.
Set Elo=CreateObject("ELO.professional")
ObjectId=Elo.NodeAction
ParentId=Elo.ScriptActionKey
NewParent=Elo.WvNew
if Elo.ActionKey=1 then
MsgBox "AddRef ObjId=" & ObjectId & " Parent: " & ParentId
else
MsgBox "MoveRef ObjId=" & ObjectId & " OldParent: " & _
ParentId & " NewParent: " & NewParent
end if
Via the action key, you can detect if an object is inserted new (1), copied (2) or moved (3). The additional
parameters like ObjectId and Predecessor can be determined via the OLE interface. This request is only
activated if the moving/inserting is carried out directly via the client. If the operation was enabled via the OLE
interface, this ScriptEvent is not triggered.
With this script event, you receive notifications on documents to be registered in or out at various times. The
individual times are specified via the ActionKey, the following values are available for this (values 1001 …
1005 are only available from version 5.00.020 on):
Value Action
30 After checking out a document, but before activating the application for processing. The
CheckInOutFileName property contains the file name.
With the ScriptActionKey property you can be informed whether a document is created out of a
document template directly in the archive view; in this case the Bit 8 (value = 256) is set to 1.
Moreover this property contains information, if the document shall be activated afterwards by
ShellExecute. 0: don’t activate, 1: activate without demand, 2: activate with demand. You can also
change this value in the script and thus change the planed view type.
31 Immediately before checking in a document. The CheckInOutFileName property contains the name
of the file to be checked in.
32 After checking in the document. The CheckInOutFileName property contains the name of the file
to be checked in, this will be deleted immediately after the event.
33 Before checking out a document. The CheckInOutObjID property contains the ELO ObjectId of
the document to be checked out.
With the ScriptActionKey property you can determine if ELO is to continue with normal
processing after the script request. If you leave the property unchanged at 1, the procedure is
continued. If you enter the value 14, ELO assumes that you have completed the checkout procedure
via the script and no further actions are necessary. All other values also cancel the processing and
actuate a respective message box.
34 Before checking in a document. The CheckInOutFileName property contains the name of the file to
be checked in.
With the ScriptActionKey property you can determine if ELO is to continue with normal editing
after the script request. If you leave the property unchanged at 1, the procedure is continued. If you
enter the value 14, ELO assumes that you have completed the checkin procedure via the script and
no further actions are necessary. All other values also cancel the processing and actuate a
respective message box.
1001 Before the view of a file list for a register-checkout oder –checkin procedure. This event is
requested for every file, the file name is in the CheckInOutFileName property, the
CheckInOutObjId contains the ELO ObjectId. The ScriptActionKey property contains the
information, how the procedure is planed (bottom 8 bit), if a checkin (0x200) or a checkout
(0x100) procedure is active. Besides the bit 0x10000000 is set. If this bit is set to 0 by the script
event, this file is not included in the view list.
Caution: this script event is possibly requested several in one procedure – e.g. if the user changes
an option in the dialog and the view list is built up again for this reason.
1002 Before checking out a document from the register list. The further parameters are set like in event
1001. Is the ScriptActionKey Bit 0x10000000 is set back to 0 the checkout procedure for this
document is suppressed.
1003 After checking out a document from the register list.
1004 Before checking in a document from the register list. The further parameters are set like in event
1001. If the ScriptActionKey Bit 0x10000000 is set back to 0, the checkout procedure for this
document is suppressed.
1005 After checking in a document from the register list.
Example:
SET Elo=CreateObject("ELO.professional")
if Elo.ActionKey=33 then
Id=Elo.CheckInOutObjID
Ext=UCase(Elo.GetDocExt(Id, 1))
if Ext="MSG" then
MsgBox "E-mails cannot be checked out"
Elo.ScriptActionKey=14
end if
end if
if Elo.ActionKey=34 then
File=Elo.CheckInOutFileName
Ext=UCase(Right(File,3))
if Ext="TIF" then
MsgBox "Tiffs cannot be checked in anymore."
Elo.ScriptActionKey=14
end if
end if
This script event contains a collection of actions, which are differentiated by the ActionKey. While starting the
subject data dialog it is first of all questioned which index line shall get an user-defined button (24). Afterwards
the message to the start of editing the subject data follows. Every entering or leaving an index line triggers off a
notification as well, changing the document type too. When finished editing the subject data an event is
triggered off one more time.
To fade in own action buttons at the end of an index line, the event 24 has to be served. This event expects a
vector with a list of all buttons in the TextParam property as return. This vector consinsts of up to 54 ‘0’ and ‘1’
values, each entry is responsible for one index line. The first character stands for the short name, the second for
the fulltext entry in the search dialog, the following 2 are reserved for extensions and the last 50 are for the 50
index lines. So, if you need a button on the short name and the 2. and 4. index line, you have to enter the value
10000101 in TextParam (only necessary until the last 1, all zeros at the end can be left out).
If a user activates such a button, you receive in this event an ActionKey value 3xxx, the first index line 3000, the
next 3001. The short name provides a value 3999. Take care of the additional offset, which is entered when the
mask in the search view is requested.
Normally the buttons as a function of the active document mask are used in different ways. For this reason the
interrogation for the display vector comes up not only at the start of the display but additionally at every change
of the document type.
The Before the Search script event allows to change the SQL search inquiry before it is sent to the SQL server.
Thereby th SQL command is delivered in the TextParam property and changes caused by the script are taken
over by Elo from there.
Please note, that this script is activated at every search, also at intern searches (e.g. for the link list). So, you
have to check before changing an search inquiry, if the wanted inquiry is active.
With the "Viewer Export" script event you can intervene in the export process in several places. The different
times can be identified with the ActionKey properties. The target directory for the viewer can be checked out in
the ActivePostFile property. On the other hand, you can cancel the action prematurely via the ScriptActionKey
property. As long as you leave this value unchanged at 1, the process is continued, if you enter a 0 via your
script, it is cancelled.
"Time" 2 is favorable for copying keyword lists. Under ELOprofessional 3.0, here you can execute the
commands for copying the desired keyword lists. Under 4.0, this can also be manually configured by the user.
However, you can also replace the user request with your own control via respective script settings.
ActionKey Time
1 Before the copy process of the viewer data. If you cancel here, you get the same status as if the
viewer had not been selected in the first place.
2 After copying the viewer data and before starting viewer import. If you cancel at this point, you
have the general viewer files, but your export dataset is not checked in.
3 After starting the viewer. Please note that at this moment, the actual import process in the viewer is
not yet completed. Unfortunately there is no easy way to determine this time via script.
4 (From ELOprofessional 4.0) Before copying a keyword list, the file name and path can be found in
the ActivePostFile property. If you set the ScriptActionKey to 0, this file is not copied with the
others. Through this you can control (if the user has enabled copying of the keyword lists) which
lists are actually included in the copying process.
Example:
Set Elo=CreateObject("ELO.professional")
The Batch Scan script event is activated from different positions. About this you have an influence on the
clipped documents, the non-clipped documents and the actual storage process. The document for the batch
storage is defined by the postbox function “preset storage mask” (as with the barcode storage). The normal
storage target is defined here as well, so the mask must have a storage index.
This request comes off for each (already clipped) document immediately before the filing. The ActivePostFile
property points at the file to scan, MainParentId at the planed target, the other subject data referred properties
(e.g. short name, index lines) are already loaded as well. With the script you can make any changes in the
subject data at this time. Additionally the target can be changed.
The possibilities of this request also include an completely script controlled storage. In this case the script is
responsible for the actual storage process and the deleting of the data and subject data file. The client signals this
case with setting the SciptActionKey property to a value unequal to 0.
ActionKey=2: Pre-processing
After the scan process a barcode analysis is automatically performed (if a barcode is defined for the document
mask). Next a decision over start- and continuation pages of the documents is reached. Via default each page
with a barcode is a start page, all others are continuation pages. The script request is executed thereby for all
pages. By setting the DocKind property the script can make own divisions.
This request is sent before clipping. It comes off, when the user wants to transfer the documents in the archive
via “A” or “S”.
By this request the script gets a message again after clipping, before the transfer to the archive begins. At this
time actions can be performed, which concern the whole batch.
With this request it is possible to let an end action come off, e.g. writing a report.
Example:
The following example does not require a barcode component, the document analysis takes place by a OCR
procedure instead (only possible with fulltext option). Demo documents are easily created by printing the pages
100…200 of this document. With the help of the words “property” and “function” in the document head the
script recognizes the start pages, all other pages are declared as countinuation pages. For storage mask you
should select a mask, which has no barcode entry. The index with the storage target has to be entered in any
case.
Set Elo=CreateObject("ELO.professional")
Collecting the Workflows Script Event (available from version 4.00.214 on)
This script event is requested after the client created the SQL inquiry for the workflow list in the task view and
before the current database operation is executed. In the script the SQL command then can be changed, which
can be read and written by the TextParam property. Remember, that the changed request must not lead to SQL
syntax errors, otherwise the task list stays empty.
• The SELECT list can be changed, so that one column shows additional information.
Mind that the type and the amount of columns must not be changed, otherwise the output occurs
incomplete or is missing.
• The ORDER BY clause can be changed to get special sort orders.
If you need data to be entered by the user for this action, you shouldn’t question them in the script event,
because it is requested quite often. Here it offers itself instead to use cookies. Put a script onto a user-defined
button which questions the parameters and saves them into a cookie. Following “ClickOn” is executed on the
workflow collecting button, so that the list is actualized immediately. The current event script then works with
the data of the cookies area.
end if
You need access to a further table for this action: the index data. The name of this table is objkeys, it is included
in the list of the table between FROM und WHERE. The normal SQL command approximately looks like that:
With the line [wPos = Instr( Cmd, " where " )] the end of the table is searched and afterwards the further table
is included by [Cmd = Left( Cmd, wPos - 1 ) & " , objkeys keys " & Mid( Cmd, wPos, 2000 )]. The FROM
region looks like that:
Following the WHERE clause is extended by additional selections. This selection is [and keys.parentid =
obj.objid and keys.okeyname = 'CTNO' and keys.okeydata = '" & Ctno & "' "]. Please note the daisy chain
keys.parentid = obj.objid. If you forget this, the SQL server will provide a large amount of hits. The further parts
express, that on the index line CTNO with content of the variable Ctno shall be limited. Then the WHERE
region looks like that:
At last the customer number is displayed in the column of the workflow name. That happens by the command
[Cmd = Replace( Cmd, "fl.wf_flow_name", "fl.wf_flow_name + ' : " & Ctno & "'" )]. It exchanges the
column wf_flow_name with an arrangement of the flow name with a colon and the customer number.
Please note, that an additional column for the customer number is not established (that would lead to an error)
but the existing column with the workflow name is only added by further text parts.
This example script creates a report in HTML format when terminating a workflow and adds it to the document
as an attachment. If the WF is linked to a structural element, the report is created in it as new document.
The script must be registered as end script in all end nodes of the WF.
'TermFlow.VBS 03/04/2003
'--------------------------------------------
' © 2003 ELO Digital Office GmbH
' Author: M.Thiele (m.thiele@elo-digital.de)
'--------------------------------------------
' This script reads the actual workflow
' and creates a report as an
' HTML file which corresponds to the list view
' in the workflow designer.
'
' This report is then attached to
' the document or, if the source is a
' structural element, as new
' document.
'--------------------------------------------
Explicit option
Set Elo=CreateObject("ELO.professional")
set Fso = CreateObject("Scripting.FileSystemObject")
main
sub main
dim EloId, cnt, i, UserName
EloId=Elo.NodeObjectID
cnt=Elo.GetNodeList(1)
if EloId>1 and cnt>0 then
' First of all create the temp file and write HTML prefix
MakeFile
AddHeader Elo.WFFlowName, Elo.LoadUserName(Elo.ActiveUserId)
' This function copies the report from the postbox to the archive
sub AddAttachment(EloId, WFName)
if Elo.PrepareObjectEx(EloId,0,0)>0 then
' If the target is a doc., add as attachment,
' otherwise as new document
if Elo.ObjTypeEx<254 then
call MakeDocument(EloId, WFName)
else
call MakeAttachment(EloId, WFName)
end if
end if
end sub
status=Elo.ObjFlags
if (status and 3)<>1 then
Elo.ObjFlags=(status and 1073741820) or 1
Elo.UpdateObject
else
status=-1
end if
' Determines the file name of the temp file and creates it.
sub MakeFile
FName=Elo.GetPostDir & "ELO_Workflowreport.htm"
set file=Fso.CreateTextFile(FName, true)
end sub
...
<td width="80" bgcolor="#d8d8d8"><!--ELO_N_1--></td>
<td bgcolor="#d8d8d8"><!--ELO_T_1--></td>
...
The two lines listed above show the name(<!--ELO_N_1-->) and the content (<!--ELO_T_1-->) of the index
line 1 in two cells of one table. All ELO placeholders begin with a HTML comment introduction <!--, followed
by the permanent text ELO_. Afterwards follows the information , if it concerns the name (N) or the content (I).
At the end stands the number of the index line and the comment is to be closed.
The indicator for the index line can contain the numbers 1 till 50 (for the 50 index lines), furthermore following
letters are available:
Moreover you have the possibility to leave out parts of the HTML document completely, as a function of, if a
value is entered or not. At the index lines you can save a lot of space, if the empty lines are not displayed. For
this you add the complete region to a clip of the comment characters <!--ELO_B_xxx--> and
<!--ELO_E_xxx--> (xxx stands for the line number or for one of the special characters mentioned above).
...
<!--ELO_B_1--><tr>
<td width="80" bgcolor="#d8d8d8"><!--ELO_N_1--></td>
<td bgcolor="#d8d8d8"><!--ELO_T_1--></td>
</tr><!--ELO_E_1-->
...
In this example the index line 1 is included as an table line only if the text in this line is not empty. For the
numerical fields with the internal ELO object numbers the 0 (no document assigned) is classified as “empty”.
Table characters, which are marked as invisible or allow no reading access to the user, are also not displayed.
In the HTML template files are allowed in principle all permitted TML constructs (inclusive CSS and Java
Script). But keep in mind, that the scripting functions are switched of in some browsers. Furthermore you have
to mind, that the source comes from a file and not from a server, all active contents (active server pages, server
side includes) would not be worked on.
The script event is requested before the template file is loaded. At the time of the request the normal object
properties to the document to be displayed are loaded as after a PrepareObjectEx (Id…) and the ViewFileName
property contains the name of the template file to be loaded (e.g. c:\temp\templ_7.htm). Now you can redirect
the template file in the script to another file (by setting the ViewFileName property). In addition you are able to
change the values of the index lines if required (SetObjAttrib…).
Example for a view of the short name and the first 11 index lines (if they are not
empty):
<html><head>
<title>ELOprofessional default mask</title>
</head>
<body bgcolor="#f0f0f0">
<!--ELO_B_1--><tr>
<td width="80" bgcolor="#d8d8d8"><!--ELO_N_1--></td>
<td bgcolor="#d8d8d8"><!--ELO_T_1--></td>
</tr><!--ELO_E_1-->
<!--ELO_B_2--><tr>
<td width="80" bgcolor="#d8d8d8"><!--ELO_N_2--></td>
<td bgcolor="#d8d8d8"><!--ELO_T_2--></td>
</tr><!--ELO_E_2-->
<!--ELO_B_3--><tr>
<td width="80" bgcolor="#d8d8d8"><!--ELO_N_3--></td>
<td bgcolor="#d8d8d8"><!--ELO_T_3--></td>
</tr><!--ELO_E_3-->
<!--ELO_B_4--><tr>
<td width="80" bgcolor="#d8d8d8"><!--ELO_N_4--></td>
<td bgcolor="#d8d8d8"><!--ELO_T_4--></td>
</tr><!--ELO_E_4-->
<!--ELO_B_5--><tr>
<td width="80" bgcolor="#d8d8d8"><!--ELO_N_5--></td>
<td bgcolor="#d8d8d8"><!--ELO_T_5--></td>
</tr><!--ELO_E_5-->
<!--ELO_B_6--><tr>
<td width="80" bgcolor="#d8d8d8"><!--ELO_N_6--></td>
<td bgcolor="#d8d8d8"><!--ELO_T_6--></td>
</tr><!--ELO_E_6-->
<!--ELO_B_7--><tr>
<td width="80" bgcolor="#d8d8d8"><!--ELO_N_7--></td>
<td bgcolor="#d8d8d8"><!--ELO_T_7--></td>
</tr><!--ELO_E_7-->
<!--ELO_B_8--><tr>
<td width="80" bgcolor="#d8d8d8"><!--ELO_N_8--></td>
<td bgcolor="#d8d8d8"><!--ELO_T_8--></td>
</tr><!--ELO_E_8-->
<!--ELO_B_9--><tr>
<td width="80" bgcolor="#d8d8d8"><!--ELO_N_8--></td>
<td bgcolor="#d8d8d8"><!--ELO_T_9--></td>
</tr><!--ELO_E_9-->
<!--ELO_B_10--><tr>
<td width="80" bgcolor="#d8d8d8"><!--ELO_N_10--></td>
<td bgcolor="#d8d8d8"><!--ELO_T_10--></td>
</tr><!--ELO_E_10-->
</table>
</body>
</html>
ELO knows a number of special scripts that do not need to be configured, but are recognized from their name.
As soon as such a script is added to the ELOScripts directory with the respective name, all ELO clients request it
during the respective action.
Before the request, the client sets the ActivePostFile parameter to the file name of the document to be printed.
The script notifies via the ActionKey parameter if it wants to take care of printing itself. If the value is set to 0
(default setting), this means that ELO is to take care of the output. Value 1 confirms that the script has been
responsible for printing and value 2 is an error message, causing the operation to cancel.
Example:
For XLS files, only the current table is printed by Excel via ShellExecute. If the document has several tables, the
additional ones are not considered. The following example script is responsible for all tables to be printed.
Set Elo=CreateObject("ELO.professional")
FName=Elo.ActivePostFile
if UCase(Right(FName,4))=".XLS" then
Set objXL = CreateObject("Excel.Application")
call objXL.Workbooks.Open(FName)
objXL.Visible = TRUE
call objXL.ActiveWorkbook.PrintOut()
objXL.ActiveWorkbook.Close
Elo.ActionKey=1
end if
Thesaurus (ELO_Thesaurus)
ELO can not only manage one Thesaurus but any number of them. The selection, which Thesaurus is to be used
in which index line can be carried out via a script. This can then carry out the selection based on the index line
(Property ScriptActionKey), the current user, the current mask or based on the group name of the index line
(ActivePostFile property). The number of the Thesaurus to be used is returned via the ActionKey property.
Example:
Set Elo=CreateObject("ELO.professional")
Example:
'===============================================
' ELOprofessional_Outlook.VBS
'===============================================
'
' ELO reminders and workflows in Outlook
'
'-----------------------------------------------
'
' The script is requested by the ELOprofessional client
' when reminder dates or
' workflows are entered into the Outlook task list
' or Outlook mails are
' generated.
'
'-----------------------------------------------
'
' © 2001 ELO Digital Office GmbH
'
' Last changed: 24/10/2001
'
'-----------------------------------------------
Explicit option
GetOutlookObj function
GetOutlookObj=false
Set oOutlook=CreateObject("Outlook.Application")
If Err.Number=0 Then
GetOutlookObj=true
End If
End Function
'----------------------------
' Delete Outlook task entry
'----------------------------
Sub WVDeleteOutlook
Dim oMAPI, oObjRecipient, oFolder, oItems, oUserProperty, oItem
Dim i, iID
Set oMAPI=oOutlook.GetNameSpace("MAPI")
Set oObjRecipient=oMAPI.CreateRecipient(oElo.DelOutlookName)
Set oFolder=oMAPI.GetSharedDefaultFolder(oObjRecipient,13)
Set oItems=oFolder.Items
For i=1 To oItems.Count
Set oItem=oItems(i)
iID=oItem.UserProperties(1).Value
If iID=oElo.WvIdent Then
oItem.Delete
Exit For
End If
Next
End Sub
' ---------------------------------------
' Reminder date as Outlook task
' ---------------------------------------
Sub WVInOutlookTask
Dim oMAPI, oObjRecipients, oObjRecipient, oFolder, oItems
Dim oUserProperties, oUserProperty, oItem
Dim i, iID
Set oMAPI=oOutlook.GetNameSpace("MAPI")
Set oObjRecipient=oMAPI.CreateRecipient(oElo.OutlookName)
Set oFolder=oMAPI.GetSharedDefaultFolder(oObjRecipient,13)
Set oItems=oFolder.Items
If oElo.WVNew=1 Then
Set oItem=oItems.Add
oItem.Subject=oElo.WVShort
oItem.Body=oElo.WVDesc
Set oObjRecipients=oItem.Recipients
oObjRecipients.Add(oElo.OutlookName)
oItem.Importance=oElo.WVPrio
oItem.StartDate=oElo.WVDate
Set oUserProperties=oItem.UserProperties
Set oUserProperty=oUserProperties.Add("WvId",3)
oUserProperty.Value=oElo.WVIdent
oItem.Save
Else
For i=1 to oItems.Count
Set oItem=oFolder.Items(i)
Set oUserProperty=oItem.UserProperties(1)
iID=oUserProperty.Value
If iID=oElo.WvIdent Then
oItem.Subject=oElo.WVShort
oItem.Body=oElo.WVDesc
Set oObjRecipient=oItem.Recipients(1)
oObjRecipient.Delete
Set oObjRecipients=oItem.Recipients
oObjRecipients.Add(oElo.OutlookName)
oItem.Importance=oElo.WVPrio
oItem.StartDate=oElo.WVDate
oItem.Save
Exit For
End If
Next
End If
End Sub
' ------------------------------------
' Reminder date as Outlook mail
' ------------------------------------
Sub WVInOutlookMail
Dim oMail
Set oMail=oOutlook.CreateItem(0)
oMail.Recipients.Add(oElo.OutlookName)
oMail.Subject="[" & Chr(oElo.WvPrio+64) & "] -> " & oElo.WVDate & ": " &
oElo.WvShort & " / (ELOprofessional)"
oMail.Body=oElo.WvDesc
oMail.Send
End Sub
' -------------------------
Set oMAPI=oOutlook.GetNameSpace("MAPI")
Set oObjRecipient=oMAPI.CreateRecipient(oElo.WFOwner)
Set oFolder=oMAPI.GetSharedDefaultFolder(oObjRecipient,13)
Set oItems=oFolder.Items
Set oItem=oItems.Add
oItem.Subject="[W] " & oElo.WFFlowName & ": " & oElo.WFName & " /
(ELOprofessional)"
oItem.Body=oElo.WFComment
oItem.StartDate=Date
Set oObjRecipients=oItem.Recipients
oObjRecipients.Add(oElo.WFOwner)
oItem.Save
End Sub
' -------------------------
' Workflow as Outlook mail
' -------------------------
Sub WFInOutlookMail
Dim oMail
Set oMail=oOutlook.CreateItem(0)
oMail.Recipients.Add(oElo.WFOwner)
oMail.Subject="[W] " & oElo.WFFlowName & ": " & oElo.WFName & " /
(ELOprofessional)"
oMail.Body=oElo.WFComment
oMail.Send
End Sub
'-----------------------------------------------
'-----------------------------------------------
Sub Main
Set oElo=CreateObject("ELO.professional")
End Sub
Main
From Version 5.0 on the keyword lists are stored in the database. In this case the script is requested with some
other parameters. The identifier for the database request is passed on by the ScriptActionKey property, it has the
value 1000 (in the old form here the index line number was assigned). ViewFileName contains the group name
of the index line and ActionKey shows with 1 or 2, if the request comes from the subject data dialog or from the
mask dialog or the main menu. If the group name is changed , you can switch script-controlled to another
keyword list, because the collecting of the list is controlled by this entry.
Please note, that in the version 5.0 there is no differentiation between selecting and editing the list. If the user
owns the right to edit the key keyword list, then it is possible to add new keyword entries directly in the
selection.
Example 4.0:
Option Explicit
Dim Elo
'-----------------------------------------------
Sub Main
Dim iRet
Dim sGroup
Dim aGNum
Dim iNum, i
Dim sFileName
Set Elo=CreateObject("LeitzElo.Elo32")
If Elo.ViewFileName="ELOVER.SWL" then
iRet=Elo.ReadUser(Elo.ActiveUserId)
sGroup=Elo.UserGroups
If sGroup="" Then Exit Sub
aGNum=Split(sGroup,",",-1,1)
iNum=UBound(aGNum)
If iNum=0 Then
Elo.ViewFileName=aGNum(0) & "_" & Elo.ViewFileName
Exit Sub
End If
ReDim aGName(iNum+1)
iRet=Elo.CreateAutoDlg("Select group keyword list:")
For i=0 To iNum
iRet=Elo.AddAutoDlgControl(3, 1,Elo.LoadUserName(aGNum(i)),"0")
Next
iRet=Elo.ShowAutoDlg
If iRet=0 Then Exit Sub
sFileName=""
If sFileName<>"" Then
Elo.ViewFileName=sFileName
End If
End If
End Sub
'-----------------------------------------------
'-----------------------------------------------
Main
Example 5.0
Set Elo=CreateObject("ELO.Professional")
Although there are explicit events "when accessing an archive" and "when exiting an archive", we have
additionally defined a script (ELO_START.VBS) which starts automatically, which is requested during these
actions without having to be set in the client. The script can differentiate between the two states with the
ActionKey property (1: Accessing, 2: Exiting). If the explicit script event as well as the automatically starting
script have been set, both scripts are executed. Upon starting, first of all the automatic, then the explicit is
executed, and vice versa when exiting.
In many cases, when creating a new activity for a document, the subject data of the document reveal which
project this new entry belongs to. For this purpose, ELO requests the ELO_CheckProj script, which can detect
the information via the PopupObjectId and which can return the project name via the ViewFileName property.
This event will not be called if more than one activity has been selected for change (5) or by closing the item via
the "done" button (4). Setting the ScriptActionKey to 1 or 2 will suppress the dialog, in this case you can show
your own dialog instead. ScriptActionKey 1 signals a "ok", 2 signals an "abort".
When a document is added to the archive for the first time, a script can take control of the storage process. The
process becomes active as soon as the user adds a new document to the archive, either from the postbox or via
drag & drop from Windows Explorer. Immediately before ELO displays the storage mask, it is checked whether
a script named "ELO_EXT_[Extension]" is available in the system, so a specific handling can be linked to a
document type (e.g. "ELO_EXT_DWG" for handling AutoCAD drawings). If the respective script is available,
it is started. The ELO property ViewFileName contains the name of the file to be stored, the ObjMainparent
property contains the ID of the storage structure element, to which the user has added the document. The script
can now carry out the complete document storage on its own, e.g. additional documents that are linked to the
original document can be added to the archive with this process. The subject data creation must be carried out
within the script. Via the ScriptActionKey property, ELO is informed that the storage process has been taken
over by the script, so that no further actions are required by ELO itself. For this purpose, the property is set to
the value -30.
If a document is not loaded in the archive view, a dialog appears which offers the user a selection between
cancel, try again and load again from backup. By the ELO_READDOC script you can suppress this dialog and
effect the decision of the user by an own script. This behaviour is controlled by the ScriptActionKey property.
Following values are available:
Caution: This request runs in a loop until the document is either loaded or the user decided to cancel. If you
always choose “retry” or “backup” in the script and the document cannot be loaded, the program gets stuck at
this position.
Own Reports
You can select various preset activity reports from the context menu in the archive view. In addition, you can
create up to 4 of your own reports here. All reports are possible that can be triggered via a WHERE clause with
an SQL command.
The own reports are selected via a script. For this purpose, you must create an entry with the name
ELO_ACTSELECT. This contains two actions each for each of the 4 possible reports: a) issue the name in the
menu and b) compose the SQL command. For this purpose, the values 1..4 are transferred for a) and values
101..104 for b) in the "ActionKey" property. The script returns the desired value in the ViewFileName property.
Example:
Set Elo=CreateObject("ELO.professional")
case 1
Elo.ViewFileName="destination like 'm.thiele'"
case 102
Elo.ViewFileName="Back today"
case 2
ToDay=Date
IsoToDay=Right(ToDay,4)+Mid(ToDay,4,2)+Left(ToDay,2)
Elo.ViewFileName="backat like '"&IsoToDay&"'"
end select
Requesting Scripts
The scripts created within the script management can be requested in various ways:
Overview
The form detection in ELO proceeds within two or fore steps. In a first step the rectangle areas of the document
are marked, which are necessary for the classification of the document type. Typical areas here are the texts
“invoice” or “delivery note” or as well a firm name (no graphic elements). This areas then are edited, detected
and filed in a text list by the OCR software. For this there is the extended OCR API from version 2.05.104 on.
In a second step now is searched for characteristic patterns for every document type in the detected texts. If a
certain invoice has the text “invoice” followed by an invoice number at a pretended place (in the upper activated
rectangle list), thus only the appropriate invoice text has to be checked for this pattern for the detection of this
form. For this the pattern detection API (also new from version 2.05.104 on) is used.
If the form type was detected, it can be proved to be necessary to read additionally text regions. So you can
detect in addition to the invoice form the order number, customer number or the invoice amount. In principle
this step can occur directly with step 1. But thereby please note, that in this step you would have to analyze all
rectangle areas for all possible document on suspicion. Since that can be very complex (time-consuming), in
general it is more reasonable for a larger amount of types to displace this to a third step.
After all text regions are read and the document type is certain, now the indexing has to be extracted
systematically out of the text blocks. At this fourth step (which maybe was already covered by step two in easy
applications) the pattern detection API is used again.
Function OcrAddRect
Function OcrAnalyze
Function OcrClearRect
Function OcrGetPattern
Function OcrGetText
Function OcrPattern
The use of this commands is demonstrated in the following examples. The exact parameters you can extract
from the command list.
Examples
This first example emanates from a quite simple case. There are only two possible document types, an invoice
and the rest of the world. Only the invoice number shall be indexed.
In the first step the rectangle list with the region for the invoice text with the appropriate number is set by the
OCR-API and the detection starts.
x=ELO.OcrClearRect()
x=ELO.OcrAddRect("500,10,999,100")
x=ELO.OcrAnalyze(FileName,0)
In the second step now is checked, if the form is an invoice. For this it is checked, is the text “invoice” followed
by the invoice number can be detected in text block 1.
CntRechnung=ELO.OcrPattern(10,"*'Invoice'_N*", ELO.OcrGetText(0))
If the pattern was detected, the function returns the value 5 (= number of pattern parts), in case of an error you
receive a negative value. After that the text for the several pattern parts is available in a text field.
If CntRechnung=5 then
’ it is an invoice, 5 pattern blocks were detected
ELO.PrepareObjectEx(0,254,InvoiceMaskNo)
ELO.SetObjAttrib(0, ELO.OcrGetPattern(3))
…
end if
The four-step work in this simple example reduces to two steps. Step 3 escapes, since no further OCR regions
have to be read and step 4 escapes, because the indexing was already detected during the classification. By the
check, if it is an invoice, the invoice number was also immediately imported in the pattern text field and can be
used directly.
This example still emanates from a quite simple case. There are only two possible document types, an invoice
and a delivery note. Only the invoice or the delivery note number each shall be indexed.
In the first step the rectangle list with the two regions for the invoice text respectively the delivery note text,
with the appropriate number each, is set and the detection starts.
x=Elo.OcrClearRect()
x=Elo.OcrAddRect("500,250,999,390")
x=Elo.OcrAddRect("500,10,999,100")
x=Elo.OcrAnalyze(FileName,0)
Following it is checked, if the form is an invoice or a delivery note. For this it is checked, if the text ‘invoice’
can be detected in text block 1 or if the text ‘delivery note’ exists in text block 2.
CntInvoice=Elo.OcrPattern(10,“*’Invoice’*“, Elo.OcrGetText(0))
CntDeliveryNote=Elo.OcrPattern(10,“*’Delivery Note’*“, Elo.OcrGetText(1))
If CntInvoice<0 then
’ it is no invoice
If CntLieferschein<0 then
’ it is also no delivery note, so nothing is done
DocType=0
else
’ delivery note
DocType=1
End if
Else
’ it is an invoice
if CntDeliveryNote<0 then
’ it is really only an invoice
DocType=2
Else
’ it is an invoice and a delivery note, a fault is existent here
DocType=0
End if
End if
Now the entry in the indexing. Further rectangles are not read in this simple example, the invoice or delivery
note number is already detected by the OCR.
The following example is a complete script for the detection of three different forms and automatic storage in
the archive (if required the directory is created as well).
'OCRELO.VBS 24.08.2000
'------------------------------------------------------------------
' © 2000 ELO Digital Office GmbH
' Author: M.Thiele (m.thiele@elo.info)
'------------------------------------------------------------------
' This script analyzes the postbox documents for certain texts
' which are marked by invoice numbers and then files the detected
' invoices into the appropriate tab (which are automatically
' created if required)
'
' -----------------------------------------------------------------
set Elo=CreateObject("ELO.professional")
MaskNo=Elo.LookupMaskName("ELOInvoice")
end if
if Elo.ObjShort="" then
fname=Elo.ActivePostFile
if UCase(Right(fname,4))=".TIF" then
x=Elo.UpdatePostboxEx( 20,i )
x=Elo.Status(fname)
Analyze i, fname
Elo.UnselectPostboxLine(i)
end if
end if
next
' this function checks, if the target tab for a document exists
' and creates it if required
function CheckRegister( Date, Customerno )
RegId=Elo.LookupIndex( "RELO=" & Right(Date,4) & ":" & Customerno )
if RegId<1 then
' tab does not exists, will be created
DirectoryId=Elo.LookupIndex( "¿ELO Invoices¿" & Right(Date,4) )
if DirectoryId>0 then
' directory found, now creating the tab
if Elo.PrepareObjectEx( 0,253,0 ) then
Elo.ObjShort= Customerno
x=Elo.SetObjAttrib(0,Right(Date,4) & ":" & Customerno)
x=Elo.SetObjAttribKey(0,"RELO")
Elo.ObjFlags=4
Elo.ObjIndex="#" & DirectoryId
Elo.UpdateObject()
RegId=Elo.GetEntryId(-2)
end if
end if
end if
CheckRegister=RegId
end function
' this function executes an OCR analysis for the current postbox
' document and puts the invoice number into the short name if a
' known document type was found
sub Analyze( iPostLine, FileName )
x=Elo.OcrClearRect()
x=Elo.OcrAddRect("500,250,999,390")
x=Elo.OcrAddRect("500,10,999,100")
x=Elo.OcrAnalyze(FileName,0)
if x<0 then
exit sub
end if
Elo.ObjShort=""
Elo.ObjMemo=""
found=false
if not found then
x=Elo.OcrPattern(
10,"'Invoice'L'Number:'NL'Date:'*L'Orderno.:'NL'Customer-No.:'NL*",
Elo.OcrGetText(0))
if x>0 then 'ELO Invoice
Elo.ObjShort=Left(Elo.OcrGetPattern(3)&" ",10) & " "
&Elo.OcrGetPattern(6) & " " & Elo.OcrGetPattern(12)
x=Elo.SetObjAttrib(0,Elo.OcrGetPattern(12))
x=Elo.SetObjAttrib(1,Elo.OcrGetPattern(3))
x=Elo.SetObjAttrib(2,Elo.OcrGetPattern(9))
Elo.ObjXDate=Elo.OcrGetPattern(6)
found=true
end if
end if
if not found then 'ELO Credit
x=Elo.OcrPattern( 10,"*'Credit'L'Number:'NL'Date:'*L'Order-
No.:'NL'Customer-No.:'N*", Elo.OcrGetText(0))
if x>0 then
Elo.ObjShort=Left(Elo.OcrGetPattern(4)&" ",10) & " "
&Elo.OcrGetPattern(7) & " " & Elo.OcrGetPattern(13)
x=Elo.SetObjAttrib(0,Elo.OcrGetPattern(13))
x=Elo.SetObjAttrib(1,Elo.OcrGetPattern(4))
x=Elo.SetObjAttrib(2,Elo.OcrGetPattern(10))
Elo.ObjXDate=Elo.OcrGetPattern(7)
found=true
end if
end if
if found then
iRet=Elo.AddPostBoxFile("")
end if
Elo.Status "Detect line " & i & " : " & Elo.ObjShort
end sub
For the pattern detection only a format string is to be pretended. The check, if the text is enough for this pattern
and the division of the text into the pattern parts is accomplished in one step in ELO.
Please note, that a pattern may be made up of at most 32 parts (in version 104, maybe later it is changed).
Following pattern parts are available:
* Any text This partial pattern accepts any text, it can also be empty. You can specify
additionally a length in front of the star, the detected text has to be at least as
long as the presetting claims.
_ Empty character This partial pattern accepts any , also empty, string of empty characters.
Specifying a length in front of the underscore leads to a detection of a string
with the exact presetting.
L Line break This partial pattern detects a line break (exactly one). A number in front of the L
(e.g. 3L) claims exactly this amount of line breaks.
N Number It is detected any long string of numerics (but no empty string). The first
character which is no numeric closes this string (line break and empty characters
as well). If a multiplier is prefixed, a numeric string of exactly this length is
detected.
Example: ABC12345XYZ
n Number As for N (Number) – the difference is, that this form accept also letters, which
(special OCR) are similiar to certain numerics (O, o and Q are detected as a 0 (zero), I and l are
detected as 1 (one).
“...“ Text The text between the double quotes is accepted. Thereby the text has to be
existent exactly in this form, no additional empty characters or line breaks are
detected.
Annotations
Please note, that the detection algorithm searches until it reaches a “match” or until it is sure, that there is none.
It does not get stuck at partial solutions. An innocent implementation could locate the text “invoice” of the
invoice copy at the pattern “*’invoice’_N*” and the text “xxx invoice copy yyy invoice 12345 zzz” and after no
number is following, it could abandon. ELO whereas goes on with its search after this failure and detects the text
as you are expecting it.
Especially the pattern * causes a high internal efford, since in case of doubt many possibilities must be analyzed.
Anyway it often is necessary to use this operator. Particularly the patterns should be framed in general by a
*…*. By that “grungy characters” are intercepted at the beginning or the end of the text. There are often caused
by foreign characters, which rise into the detection rectangle. Anyway it should be used only where it is
justified. The unnecessary, but seeming harmless combination ** does not change the detection result, but it has
a very adverse influence on the performance. The pattern ** forces ELO to control the possibilities [][abcd],
[a][bcd], [ab][cd], [abc][d], [abcd][] of the text “abcd”.
Don’t put too much in one pattern. If you have rectangle with successive lines with invoice number , customer
number, order number and job number in an invoice, you can search singly for every number. But you can also
formulate a complex search pattern *’invoice’_N*’customer’_N*’order no.’_N*’job’_N*. In the second case all
numbers would be expected in one pass. But as soon as one of these numbers was not realized correctly by the
OCR software (e.g. cuslomer instead of customer) no more numbers will be detected. If the indexing is
interesting you only if all was detected, the second variant is adequate. If you hold the view, that as much as
possible should be detected and only the missing parts have to be supplemented, then you should let the number
be detected singly.
Even for complex patterns it can easily happen, that it is not detected although the text should allow that. Since
there are no special “pattern debugger”, here only a stepwise try and error can help. Beginning with the
“defective” pattern
*’invoice’_N*’customer’_N*’order no.’N*’job’_N*
The pattern is always extended by one (or more too) step(s). Mind, that you always finish the pattern with a *.
This * is the match for the whole rest. If it is missing, nothing will be detected.
The return values of the functions normally contain an error code. In these cases, negative values indicate a
function failure, positive values indicate correct execution.
ELO works internally with so-called ObjectIDs. These are (within an archive) unique values, which are
allocated to each entry upon creation and via which the entries can be requested again at any time. If you require
any references directly from ELO in your program and want to store them, you should use this ObjectId and not
the name. The ObjectId remains unchanged and guaranteed for the entire duration of the entry, however, the
name can be changed by the user or by other programs.
Some ELO events together trigger a script handling. In this case it can be determined via the ActionKey what
kind of event has occurred.
Dialog: Edit document Dialog opened in postbox view, document type not 19
yet defined
Mask accessed 20
Mask closed with Save 21
Event: Mask closed with Cancel 22
Document type changed 23
Request button list 24
After edit mask field Short name field accessed 10
Short name field closed 11
Memo field accessed 12
Memo field closed 13
Date field accessed 14
Date field closed 15
Index entry line n accessed 1000+n (n=0..49)
Index entry line n closed 2000+n
Pressed user-defined button 3000+n
Before importing/exporting Before importing a storage structure element 1
Before exporting a storage structure element 2
When checking in/out After checking out 30
Before checking in, after requesting version 31
After checking in 32
Before checking out 33
Before checking in, before requesting version 34
Before discarding 38
Before activating/displaying 80
Before printing 81
Register CheckIn/Out 1001…1005
Reading/saving user Immediately before saving 20000
After saving 20001
After reading 20010
Keyword list Before editing the keyword list 1
Before displaying the keyword list 2
Reminder Date as task for other user 1
Date as task for own use 2
Date as e-mail 3
ClickOn Event Selection of a button or menu option 40
Workflow Event Only display workflow date in ELO 3
Workflow date as task 4
Workflow date as e-mail 5
Freezing the document Before printing 0
These numbers are overwritten by the value 0x8000, if it is a research mask and not a data mask. This
information must be evaluated by all means, otherwise there may be undesired effects when trying to find
documents!
Example (store as AutoShortdes script and enter under "When editing the subject data" script event):
' which is to automatically enter the short name from the index lines
' one and two via the script.
DocumentMask = 2
Set Elo=CreateObject("ELO.professional")
Also see:
Function ActivateFlow
int ActivateFlow (int FlowID, int ObjectID, int FlowUser, AnsiString FlowName)
Parameters:
FlowID Internal ELO number (ID) of the process scheme (e.g. determined with
FindFlowTemplate)
ObjectID Internal ELO number (ID) of the ELO object which is allocated to the process
FlowUser ID of the user who starts the process
FlowName Name of the new process
Return values:
Example:
The property includes the access path and name of the active postbox file. This entry is made through actions
that carry out a new postbox entry (e.g. scanning or AddPostboxFile).
From version 3.00.508 this property can also be named. With this you can make a file active that is already
present in the postbox.
The ActiveUserId property supplies the internal ELO user number of the active login.
The Activity property sets or reads the current value of an activity. This value is only valid for the event routine
"When reading or writing an activity". If the value is requested at other times, there may be errors up to a
protection fault.
The value of the activity is a string that includes all fields. These are separated by the separator (i.e. ¿).
Available from:
3.00.510
Example:
if Elo.ActionKey=0 then
act=split(Elo.Activity, "¿")
act(15)="Test99"
Elo.Activity=join(act,"¿")
end if
if Elo.ActionKey=1 then
MsgBox Elo.Activity
end if
Creates elements in the dialog previously created with CreateAutoDlg. A CreateAutoDlg must be requested
beforehand!
int AddAutoDlgControl (int Type, int GridInc, AnsiString Caption, AnsiString Default)
GridInc:
Return value:
Example:
Creates a dialog with a label at top position, an Edit field below with entered
content and displays it.
Elo.CreateAutoDlg ("New dialog")
Elo.AddAutoDlgControl (1,0,"Top label","")
Elo.AddAutoDlgControl (4,1,"Your name","Smith")
Elo.ShowAutoDlg
Function AddLink
Connects two ELO objects (document or storage structure elements) through a logical link. Any entries without
hierarchical considerations can be linked. One object can also be linked to several other objects.
Parameters:
Return values:
Available from:
3.00.270
Function AddNote
Function AddNoteEx
Adds another self-adhesive note to a document. Please note that there is a maximum number of self-adhesive
notes for a document, more are not displayed, but not marked as faulty when saved.
Please note, that this function does not result in an update of the view on the actually displayed document.
Parameters:
Return values:
Available from:
4.00.138
Function AddPostboxFile
This function transfers one file to the postbox. For this purpose, a new entry must be prepared first of all with
PrepareObject, the short name and other values must be set via the various properties and the function must then
be requested. The file is then copied and stored in the postbox together with the subject data.
After requesting this function, the new entry then automatically becomes the "active postbox entry", it then is the
source for some further functions.
There is another special case for this function: when the "active postbox entry" is changed and is to be saved
again in the postbox, this function is requested with an empty string as parameter. This opportunity is for
example used by the barcode postprocessing.
Parameters:
Return values:
Example: open first postbox document, allocate mask number 2 to it and automatically enter the short name as
well as first index field. Afterwards, the document is transferred to the archive on the path prescribed:
x=Elo.PrepareObjectEx(-1, 0, MaskNo)
if x>0 or x=-5 or x=-7 then
Elo.ObjShort="Test" & Time
call Elo.SetObjAttrib(0,"Index 1")
call Elo.AddPostboxFile("")
x=Elo.MoveToArchive(RegisterId)
else
MsgBox "No document found in postbox"
end if
Function AddSignature
This function adds an extern signature file to an existing document. The script has the responsibility to
guarantee, that the signature actually belongs to the document. In case of an error an invalid signature is
displayed to the user.
Parameters:
Return values:
Example:
...
Result = Elo.MoveToArchive( DestPath )
If Result > 0 then
Id = Elo.GetEntryId(-2)
MsgBox Elo.AddSignature( Id, "d:\temp\00016882.ESG" )
End if
...
Available from:
4.00.180
See also:
Function AddSw
Adds a new entry into a keyword list. Each entry contains a unique two letter level information: AA, AB, AC ..
ZZ per level. The root level starts with a dot. „.AAABAC“ starts at the base with the first entry, within this with
the second subentry, within this selects the third subentry.
The group parameter is connected to the group entry in the keywording form.
Parameters:
Return values:
Example
...
Set Elo=CreateObject("ELO.professional")
Available from
5.00.066
Function AddThesaurus
This function creates a Thesaurus entry in the database. Every Thesaurus group has to own an explicit group
number (GroupId), if you assign a 0 to the group at the first entry, ELO acquires a new random number. The
Prio parameter defines the sort order, the ListId parameter has to be set permanently to 1 at the moment
(Thesaurus in the subject data dialog).
int AddThesaurus (int ListId, int GroupId, int Prio, AnsiString Value)
Parameters:
Return values:
Example:
Set Elo=CreateObject("ELO.professional")
Available from:
4.00.214
Function AnalyzeFile
This function sends the content of a postbox file to the OCR module and enters the detected sections into
predefined mask fields. The name of the postbox file can be transferred with SourceFile. Alternatively, in this
parameter a line number (#0, #1, #2 ...) can be transferred. The respective file from the postlist is then used as
file name. After detection, the result is saved in the keyword file for the image file.
The OcrDescriptor parameter contains the list of the rectangles to be checked and the mask fields to be filled. A
detailed description of this list can be found in the barcode documentation.
Compared to the barcode module, the rectangle must be defined as follows:
"R(left,top,right,bottom)"
Parameters:
Return values:
With this property you can determine the number of hierarchy levels of the current archive. For this the level of
the documents is included in the count, i.e. a classic ELO archive with the file structural elements Cabinet-
Folder-Tab-Document has 4 hierarchy levels.
If the archive view is not active yet, the ArchiveDepth property has the value –1.
Also see:
Function ArcListLineId
With this function the ELO ObjectId of a line from the right archive list can be detected.
Parameters:
Return values:
Available from:
5.00.036
Example:
for i = 0 to 8
res = res & Elo.ArcListLineSelected( i ) & " - " & Elo.ArcListLineId( i
) & ", "
next
for i = 0 to 3
Elo.SelectArcListLine( i )
next
for i = 4 to 7
Elo.UnselectArcListLine( i )
next
Elo.SelectArcListLine( 8 )
MsgBox res
Function ArcListLineSelected
With this function you can check, if a line is selected in the right archive list.
Parameters:
Return values:
Available from:
5.00.036
Example:
for i = 0 to 8
res = res & Elo.ArcListLineSelected( i ) & " - "
next
for i = 0 to 3
Elo.SelectArcListLine( i )
next
for i = 4 to 7
Elo.UnselectArcListLine( i )
next
Elo.SelectArcListLine( 8 )
MsgBox res
With the aid of this function workflow nodes which are addressed to a user group can be assigned to a single
user. By that the function “accept workflow” of the client can be cloned.
Parameters:
iLine Line number of the entry inside the task list (0-indexed)
-1 = use currently selected line
iUserID ID of the user, who shall receive and edit the node,
the currently logged-in ELO-user can be entered by the ActiveUserID property
iFlags reserved
Return values:
Available from:
4.00.220
The AttId property defines the working version of the file appendix of a document. This entry has to be
extracted of the list of the existing attachments, a foreign entry can lead to serious disfunctions here.
Available from:
5.00.042
Example:
This property transfers the result for all objects of the AutoDialog. The individual values are separated by a
return.
Example:
The Backup and BackupPath functions aren’t supported by current clients anymore and are only listed in the
OLE interface for compatibility reasons.
Since version 3.0 the Backup-functions are executed by the backup server and not by the client anymore.
The Backup and BackupPath functions aren’t supported by current clients anymore and are only listed in the
OLE interface for compatibility reasons.
Since version 3.0 the Backup-functions are executed by the backup server and not by the client
anymore.
Function BringToFront
With the BringToFront function you can bring ELO into the foreground on the desktop and thus make it visible
for the user if ELO has previously been hidden by other remotely controlled applications.
void BringToFront ()
Parameters:
none
Return values:
none
With this function, the access rights for the objects can be allocated and/or changed.
Z:
User number / Group number/ Key number
0 0 0 0 0
x x x x x x x x x x x x x x x x x x x x x x x x x x x
4 3 2 1 0
00 0 – Add rights
1 – Overwrite rights
01 0 – Forward non-subordinated objects
1 – Forward to subordinated objects (not implemented)
02 0 – Forward identical rights (not implemented)
1 – Only forward changes (not implemented)
03 0 – Warning dialog for own rights removal on
1 – Warning dialog for own rights removal off
04 0–
1 – Accept predecessor rights (not implemented)
x At present unused (reserved for extensions)
Return value:
Example:
Sets the system key for object 30 and removes all others
Elo.ChangeObjAcl (30,"KY0",1)
Also see:
Function CheckFile
With the CheckFile function you can request various file properties.
Parameters:
Return values:
Available from:
3.00.288
Also see:
Function CheckFileHash
With the function CheckFileHash you can check a file, whether it is already filed in ELO. A dialog is submitted
to the user in which the user can decide, if the document shall be filed anyway, a reference shall be entered
instead or the storage is to be cancelled completely.
Parameters:
HeaderMessage: Additional annotation in the dialog title (e.g. file name or description)
FileName: Name and path of the file to be checked
ModeFlag: Reserved, has to be set to 128
Return values:
Example:
Set Elo=CreateObject("ELO.professional")
MsgBox Elo.CheckFileHash( "Testdatei", "d:\temp\Scandatei.tif", 128 )
Available from:
4.00.034
Function CheckIn
Function CheckInEx
With this function you can check in a document again that you had previously received from the archive via
CheckOut. Please note that you must not change the file name, as this contains the ID for the archive used and
the object number. Under ELOprofessional 3.0, the CheckIn command leads to a request of the version number
and a comment. You can suppress this request by using the CheckInEx command, this information is sent as
parameters instead.
Parameters:
Return values:
Example:
3.00.278
With this property, you can determine the file name of the document within the "When checking a document
in/out" event. If required, the file name can be changed for the "Before checking in" event.
With this property, you can determine the object ID of the document within the "When checking a document
in/out" event.
Function CheckObjAcl
With the function CheckObjAcl you can check, which access rights you own for a certain object. If the object is
already active (e.g. inside of a subject data event or after a PrepareObjectEx), then you assign a 0 to lObjectId.
In this case the current value from the ObjAcl property is used. If the object is not active yet, you can assign the
ObjectId as parameter additionally. Then the ACL list of the object is loaded and checked. Since only one
property and not the whole object is read out of the database, this way is faster than the combination of
PrepareObjectEx (Id…) and CheckObjAcl(0). Of course that applies only then if no other spots of the script
require a PrepareObjectEx.
Example:
Parameters:
Return values:
Available from:
4.00.178
Function CheckOut
With the CheckOut function, you can remove a document from the current archive for editing. After editing was
completed, it can then be re-inserted into the archive via the CheckIn function. Please note that you must not
change the file name, as this contains the ID for the archive used and the object number.
Parameters:
Function CheckPage
With the CheckPage function you can check if a separator or empty page exists for the current postbox entry .
You can find an example for this command in the prefix.
Parameters:
Mode 1: Empty page control 2: Separator page control (combinations also permitted)
Hit ratio 0...999 required hits per thousand.
A value of 970 (default in ELO Client) requires a hit ratio of 97%.
Available from:
3.00.220
Function CheckUpdate
With this function you can decide if a change is to be immediately displayed. Especially for automatic recording
of mass data it can save a lot of time if ELO does not display each change. In this case, use an
ELO.CheckUpdate(0) before the run and an ELO.CheckUpdate(1) after the run.
Parameters:
Return values:
Old status
Function ClickOn
With this function a mouse click on a dialog component in the ELO main dialog can be simulated. Thus all
functions that are available in the menus or toolbar can be requested.
Parameters:
ComponentName: Name of the dialog component (list of all dialog items see appendix A)
Return values:
Also see:
Function CloseActivateDocDlg
With the CloseActivateDocDlg function you can check in a document again onto Elo which was activated from
Elo for editing. For this purpose you can choose from the options mode=1: Ok, accept new version and mode=2:
Cancel: Discard changes
Parameters:
Return values:
Also see:
Function CollectChildList
With the CollectChildList function you can determine all subsequent nodes for an object ID. The node list is
transferred as text string, the individual successor IDs are separated by colons.
Parameters:
Return values:
Function CollectLinks
With the CollectLinks function you can determine all links for an object ID. The Ids of the linked objects are
returned as comma list.
Parameters:
Return values:
Available from:
3.00.378
Function CollectWv
With the CollectWv function, you can collect the reminder dates, workflow tasks and activities of a user. This
list is not displayed in ELO, it can only be checked out via the GetListEntry function.
Caution: the temporary internal list is also used by DoInvisibleSearch. If you use both actions in a script, you
must check out the complete result list each before a change, otherwise the results are discarded.
int CollectWv (int UserId, AnsiString StartDate, AnsiString EndDate, int Prio)
Parameters:
UserId User number (plus 0x40000000 for groups and 0x20000000 for agents)
StartDate Start date of report to be collected
EndDate End date of collection area
Prio Priority (only for reminders and activities (1..3))
Return values:
Available from:
3.00.394
Example:
Set Elo=CreateObject("ELO.professional")
UserId=Elo.ActiveUserId ' only own dates
'UserId=Elo.ActiveUserId + 1073741824 ' with group dates
'UserId=Elo.ActiveUserId + 536870912 ' with agents
'UserId=Elo.ActiveUserId + 1610612736 ' all dates
The ColorInfo property determines the color value of a color definition. This color value is transmitted in RGB
style usual for Windows.
The ColorName property determines the color name (short name) of a color definition.
Function ConfirmWorkflow
With the ConfirmWorkflow function, workflows can be forwarded within the task view of the ELO Client. The
name of the node and message text can be set, via the iActivateAll parameter it is controlled whether all
succession nodes or only the first are to be activated.
ConfirmWorkflow (int iLine, AnsiString sCaption, AnsiString sComment, int iActivateAll, int iFlags)
Parameters:
iLine Line number of the entry within the task list (o-indexed)
-1=use currently selected line
sCaption New name of node
empty=leave current name unchanged
sComment Message text of node
empty=leave current message text unchanged
iActivateAll 1=activate all succession nodes
0=only activate first succession node
iFlags Reserved
Return values:
Available from:
3.00.350
Function ConfirmWorkflowEx
With the ConfirmWorkflow function, any workflows can be forwarded also outside the task view of the ELO
Client. The name of the node and message text can be set, via the iActivateAll parameter it is controlled whether
all successor nodes or only the first are to be activated.
ConfirmWorkflow (int FlowId, int NodeId, int EloObjId, int Department, AnsiString sCaption,
AnsiString sComment, int iActivateAll, int iFlags)
Parameters:
Return values:
Example:
set Elo=CreateObject("ELO.professional")
call Elo.SelectRootNode
fields=split(Elo.NodeComment,",")
call Elo.ConfirmWorkflowEx(fields(0), fields(1), fields(2), fields(3),
"Back","", 1,0)
Available from:
3.00.380
Caption:
Title of dialog
Return value:
Example:
Available from:
3.00.228
Function CreateCounter
The CreateCounter function creates a new counter with a start value that can be preset.
Parameters:
Return values:
-1: Error
1: Ok.
This function creates a list with cabinet, folder, registers etc. from current position, or if a separator is set at the
start, from cabinet position. Existing paths with the same name are only initialized again if there is a separator at
the end of the path.
The separator at the start of a path has precedence over the StartID. (StartID is ignored)
Return values:
List of ObjectIDs of created elements separated by separator (235¿252¿22)
-5 – No entry selected
-4 – Empty field name
-3 – No valid start position given
-2 – No work area active
-1 – Too many objects (archive depth is exceeded)
Example:
Creates a cabinet, folder and tab. Start position is the filing cabinet level.
ELO. CreateStructure ("¿My_Cabinet¿My_Folder¿My_Tab",0)
Creates tab with sub tab or folder with tab or cabinet with folder
Depending on the current position in the archive
ELO. CreateStructure ("123¿222",0)
Creates tab with sub tab or folder with tab or cabinet with folder
At same level of given object
ELO. CreateStructure ("123¿222"0.2345)
Creates tab with sub tab or folder with tab or cabinet with folder
Within the given object
ELO. CreateStructure ("123¿222",-764)
Also see:
Function CreateViewer
With this function you can create a viewer dataset from an export dataset. For this purpose the ViewerPostbox
directory must be prepared under ELOprofessional and a completed export dataset must be available. The target
path may already contain a viewer. If the target archive already exists, the datasets are added to this archive. Up
to 4 archives may be created in the target area.
Example:
Set Elo=CreateObject("ELO.professional")
call Elo.CreateViewer("D:\ExportPfad", "test1", "D:\Target path")
Parameters:
Return values:
Available from:
3.00.354
Parameters:
Return values:
Available from:
3.00.196
Parametes:
FlowId: Workflow Id
ObjId: Attached ELO Object
Return values:
Example:
FlowId = 4711
ObjId = 12345
Result = ELO.DeleteFlow( FlowId, ObjId )
Available from:
5.00.126
Function DeleteMask
Deletes an ELO subject data mask. Before the Deleting operation it will be checked, if there are still entries with
this mask in the archive or with the deleted but not yet permanently removed objects. If there are still entries, the
command is cancelled with an error an in the TextParam property a list is located with the first 16 Object-Ids
which use this mask.
Parameters:
Return values:
Example:
Available from:
4.00.210
Function DebugOut
Parameters:
Text Text to be issued, sent to the Debug window together with time.
Return values:
None
Also see:
Function DeleteObj
Deletes an Elo entry, pre-defined by the ObjectID. If a cabinet, folder or tab is concerned, all sub-entries are
deleted as well.
Parameters:
Return values:
Function DeleteProjectOptions
Deletes all option entries of a project in the defaults for the activities. Possibly existing project activities are not
deleted, however, and can still be displayed and listed.
You can also selectively delete a single entry. In this case, instead of the project name you must enter a string
containing name, major no., minor no. and value, separated by the normal delimiter (¿). The field value can be
left empty, the major and minor numbers can be set to 0 if they are not known. However, this deletes entire
groups, so be careful when using this option.
Parameters:
Return values:
Example:
set Elo=CreateObject("ELO.professional")
res = Elo.DeleteProjectOptions("TEST")
if res<0 then
select case res
case -5
MsgBox "Project is created new"
res=1
case -8
MsgBox "You have no authorization for editing the data"
case else
MsgBox "Error : " & res
end select
end if
if res>0 then
call Elo.InsertProjectOptions("ELO_SYSTEM", 1, 0, "TEST")
call Elo.InsertProjectOptions("TEST" , 10, 1, "Contact")
call Elo.InsertProjectOptions("TEST" , 10, 4, "Meier")
call Elo.InsertProjectOptions("TEST" , 10, 2, "Müller")
call Elo.InsertProjectOptions("TEST" , 10, 3, "Schulze")
end if
Available from:
3.00.360
Function DeleteSwl
Deletes a subtree of a keyword list. Each entry contains a unique two letter level information: AA, AB, AC .. ZZ
per level. The root level starts with a dot. „.AAABAC“ starts at the base with the first entry, within this with the
second subentry, within this selects the third subentry. Deleting an entry will automatically delete all subentries.
The group parameter is connected to the group entry in the keywording form.
Parameters:
Return values:
Example
...
Set Elo=CreateObject("ELO.professional")
Available from
5.00.066
Function DeleteWv
Deletes a reminder date (determined by parameter WvIdent). When deleting a date, the owner must also be
indicated, if you set a –1 here your own EloUserId is used.
Parameters:
Return values:
Function DeleteWvLine
With this function an entry can be hidden within the display of the reminder dates. The associated reminder
entry is not deleted.
Parameters:
Return values:
Available from:
This property indicates the reminder’s name of the person (group) to be deleted. It is used when the name of the
person (group) to which the reminder is addressed is changed in ELO, so that the entry can be removed.
Function DoCheckInOut
int DoCheckInOut (int hwndParent, AnsiString DlgTitle, AnsiString Short, AnsiString Desc,
AnsiString XDate, AnsiString FileName,int Ctrl, int Minimize)
Parameters:
Return values:
Function DoCheckInOut2
int DoCheckInOut 2(int hwndParent, AnsiString sDlgTitle, AnsiString sShort, AnsiString sDesc,
AnsiString sXDate, AnsiString sFilterExt, AnsiString& sFileName, int nMinimize)
Parameters:
Return values:
0 ... Cancel
1 ... New document saved
2 ... Document checked in
3 ... Document checked out of archive
4 ... Edit already checked out document
Function DoCheckInOut3
int DoCheckInOut3 (int hwndParent, AnsiString sDlgTitle, AnsiString sShort, AnsiString sDesc,
AnsiString sXDate, AnsiString sFilterExt, AnsiString& sFileName, int nMinimize, int iFlags,
AnsiString sInfo)
Parameters:
Return values:
0 ... Cancel
1 ... New document saved
2 ... Document checked in
3 ... Document checked out of the archive
4 ... Edit already checked out document
The DocId property defines the working version of a document. This entry has to be selected from the list of all
document files out of the version history of this document. A foreign entry at this place can lead to serious
disfunctions.
Available from:
5.00.042
The DocKey property determines the key of an entry. The entry can be a cabinet, folder, tab or document.
If you edit a mask definition, this entry contains the default for new documents of this type (the MaskKey
contains the key for the mask itself).
The DocKind property determines the color of an entry. The entry can be a cabinet, folder, tab or document.
If you edit a mask definition, this entry contains the default for new documents of this type.
The DocPath property determines the storage path of an entry. The entry can be a folder or document.
If the entry is a folder, with the respective system setting, this path can be the default value for documents in this
folder. However, this mode only represents a compatibility mode for old ELO office archives, for new archives
it should not be used anymore.
If you edit a mask definition, this entry contains the default for new documents of this type.
The DocTPath property determines the default storage path of an entry in a mask definition.
Function DoEditObject
Function DoEditObjectEx
With this function you can open the subject data dialog. It displays the data that have previously been initialized
via PrepareObjectEx.
Parameters:
Return values:
Also see:
Function DoExecute
With this function another application can be started, internally the Windows API function ShellExecute is
requested.
Option 1: in the FileName parameter the name of a program (EXE file) is transferred.
Option 2: in the FileName parameter the name of a file is transferred, the application associated with this file
type is started.
Parameters:
Return values:
Function DoExecuteEx
With this function another application can be started, internally the Windows API function ShellExecute is
requested.
Option 1: in the FileName parameter the name of a program (EXE file) is transferred.
Option 2: in the FileName parameter the name of a file is transferred, the application associated with this file
type is started.
int DoExecuteEx (AnsiString File, AnsiString Param, AnsiString Directory, AnsiString Action, int Mode)
Parameters:
Return values:
Function DoFullTextSearch
The DoFullTextSearch function starts a rich text search. As result of the function the number of found
references is returned, these are then available in the research list and can be displayed via SelectLine.
Parameters:
Return values:
Function DoInvisibleSearch
The DoInvisibleSearch function starts an invisible search process from the ObjShort, ObjMemo, ObjAttrib
entries. For this purpose, first of all a new object dataset is created with PrepareObject, this dataset is fed with
the terms to be found via the access operations and the DoInvisibleSearch function is requested. As result of the
function the number of found references is returned, these are then available in an invisible internal research list
and can be requested via getEntryId(). However, for this purpose a special line number must be transferred to
the getEntryId function, so that it can detect that it is not the normal list, but the invisible list to be searched. This
number consists of the line number and a constant factor of 268435456 (that is 0x10000000).
Example:
Elo.DoInvisibleSearch
MsgBox Result
int DoInvisibleSearch ()
Parameters:
None
Return values:
Available from:
3.00.188
Function DoSearch
The DoSearch function starts a search process from the ObjShort, ObjMemo, ObjAttrib entries. For this
purpose, first of all a new object dataset is created with PrepareObject, this dataset is fed with the terms to be
found via the access operations and the DoSearch function is requested. As result of the function the number of
found references is returned, these are then available in the research list and can be displayed via SelectLine.
Another special mode is available for displaying a list of Elo objects. In this case a mask content of the type
"Free entry" is entered so that only the field with the short name is entered with a string of the type
"¿Id1¿Id2¿Id3¿ ... ¿IdN¿". A list with these objects is then displayed in the research view.
You can determine via the Mode parameter if an already existing search result is to be deleted before a search
process. You can then compose multiple searches. For the first search a deletion is carried out, all subsequent
searches then supplement the list created so far.
int DoSearch ()
int DoSearchSel (AnsiString SelectObject)
int DoSearchEx (AnsiString SelectObject, int Mode)
Parameters:
SelectObject If there is an entry in the research result with the pre-defined short name,
this line is selected.
Mode Bit 0: 0 do not delete old list content 1: delete before research
Bit1..31: reserved.
Return values:
-1: No work area active
else: Number of found entries.
Available from:
DoSearchEx: 3.00.358
Example:
' carries out three searches for the terms, Test and Word
' and displays the result in a results list
Set Elo=CreateObject("ELO.professional")
call Elo.PrepareObjectEx(0,0,0)
Elo.ObjShort="elo"
call Elo.DoSearchEx("", 1)
call Elo.PrepareObjectEx(0,0,0)
Elo.ObjShort="test"
call Elo.DoSearchEx("", 0)
call Elo.PrepareObjectEx(0,0,0)
Elo.ObjShort="Word"
call Elo.DoSearchEx("", 0)
Function DoSelArcTree
int DoSelArcTree (int hwndParent, AnsiString sDlgTitle, int nCtrl, int nMinimize)
Parameters:
Return values:
This function edits an activity. You can carry out a pre-allocation via the input string, especially if you create a
new activity for a document you must initialize the EloGuid with the GUID of the document. If possible, you
should also pre-allocate the project entry.
Parameters:
ActInfo: Current field allocation, the individual texts are linked by the
separator (¿) each.
Return value:
Empty An error has occurred or the user has cancelled the dialog
with "Cancel".
Example:
Id=Elo.GetEntryId(-1)
if (Id>1) then
guid=Elo.GetGuidFromObj(Id)
res="¿" & guid
res=Elo.EditActivity(res)
MsgBox res
Elo.WriteActivity(res)
end if
Return values:
0 – No
1 – Yes
Also see:
Return value:
Example:
Function EloWindow
With this function, you can determine how the ELO work surfaces are displayed. As parameter ‚MINIMIZE‘
can be used, in this case no work surface becomes visible, ‚MAXIMIZE‘, the visible work surfaces are fully
displayed on the screen or ‚NORMAL‘, i.e. the default settings for the size of the work surface are used.
Parameters:
Return values:
Function Export
int Export (AnsiString sDestPath, int iExportType, int iParentId, int iOptions, AnsiString sDocTypes,
AnsiString sStartDate, AnsiString sEndDate, AnsiString sObjList)
Parameters:
sDestPath Target path for the export data. This directory must be empty,
if available.
iExportType reserved, to fill with 0.
iParentId 1: Archive, otherwise the ELO ObjectId of the start node
iOptions see list above
sDocTypes Empty: all document types, otherwise a text string with 0 + 1 for each
document type number ("10010111111111" – free entry (type 0)
and type 3 and type 5..13)
sStartDate Date limit – empty: no limit
sEndDate s.a.
sObjList ELO ObjectIDs of the entries to be exported (separated by : , i.e.
"124:125:126")
Return values:
Please note that the export process writes a report file in the postbox of the active user, which you should use for
evaluating possible errors.
Function FindFirstWv
This function is used if reminder dates need to be determined for a certain ELO object. The function contains the
object ID of the desired ELO object as parameter, it returns the number of the found reminder dates. With the
FindNextWv function, the IDs of the reminder dates are checked out.
Parameters:
Return values:
Function FindFlowTemplate
This function searches the internal ELO number (ID) for a process scheme name. The ID is required if a process
is to be started via the Automation interface.
Parameters:
Return values:
Function FindNextWv
With this function, the reminder dates associated with an ELO object are checked out, first of all FindFirstWv
must be requested.
int FindNextWv ()
Parameters:
None
Return values:
Function FindUser
This function searches the internal ELO user number for a name.
Parameters:
Return values:
Function FreezeDoc
With the FreezeDoc function you can convert an ELO document to a Tiff file via the Tiff printer and attach it as
new version to the logical document.
Parameters:
ObjectId Logical number of document to be converted
Return values:
-2: Error while printing
-1: No work area active
1: Ok
Example:
Set Elo=CreateObject("ELO.professional")
if Elo.SelectView(0)<>1 then
MsgBox "This script can only be executed in the archive view."
else
' browse through all documents of the current tab
for i=0 to 10000
id=Elo.GetEntryId(i)
if id<1 then exit for
Also see:
Function FromClipboard
AnsiString FromClipboard ()
Parameters:
none
Return values:
Available from:
3.00.456
Function GetArcName
AnsiString GetArcName ()
Parameters:
none
Return values:
Also see:
Function GetArchiveName
With the GetArchiveName function you can determine the archive name for a given archive number. Via the
archive number –1 you receive a list of all available archives, separated by the system separator (normal ¿).
Parameters:
Return values:
Return value:
Example:
Supplies the text of the input field and checked/unchecked of the checkbox.
Elo.CreateAutoDlg ("Person info")
Elo.AddAutoDlgControl (4,1,"Name","")
Elo.AddAutoDlgControl (2,3,"Married? Yes","0")
Elo.ShowAutoDlg
MsgBox GetAutoDlgValue (1)
MsgBox GetAutoDlgValue (2)
Function GetBarcode
With this function barcodes that have previously been determined with the ReadBarcodes function are checked
out.
Parameters:
Return values:
<>"": Barcode
"": Error (e.g. wrong index, ReadBarcodes not previously requested)
Function GetChildNode
With this function the subsequent nodes of the current node are checked out within a process in a loop.
int GetChildNode ()
Return values:
Function GetCookie
The GetCookie function reads the value of a cookie entry and returns it to the requesting program. This access is
primarily intended so that ELO scripting macros can permanently store information in ELO. The cookie memory
is deleted when ELO is closed.
Access to a cookie is carried out via the name (Ident), the allocated value is returned. If the cookie is unknown,
an empty string is returned.
Please note that the number of cookies is limited, each macro or each other external program should only use a
few and the same for each request instead of creating new ones.
Parameters:
Return values:
Function GetCounter
The GetCounter function supplies the current status of the selected counter. If the Increment parameter contains
a value other than 0, the counter automatically counts up.
Parameters:
Return values:
-1: Error
else: Counter status
Function GetCounterList
The GetCounterList function supplies a string with all AccessManager counters that are currently logged into
the system. The individual entries are separated by a ¿.
AnsiString GetCounterList ()
Parameters:
none
Return values:
Function GetDocExt
Returns the extension (Windows document type) for an object or document ID.
Parameters:
Return values:
Document extension.
Available from:
3.00.392
Example:
SET Elo=CreateObject("ELO.professional")
ID=Elo.GetEntryId(-1)
if ID>1 then
call Elo.PrepareObjectEx(ID,0,0)
if Elo.ObjTypeEx=254 then
Ext=UCase(Elo.GetDocExt(ID, 1))
MsgBox "Document type for entry '" & Elo.ObjShort & "' : " & Ext
end if
end if
Function GetDocFromObj
This function acquires the document manager Document-Id of a logical Object-Id. This Id can be used for
document referred actions (e.g. GetDocumentPathName or GetDocumentSize).
With the Flags parameter can be defined, if the current working version of the document or of the file
attachment is returned:
Parameters:
Return values:
Available from:
5.00.018
Example:
Function GetDocRefComment
With this function you can request the version entry and comment for a document version. The two fields are
returned in a string, separated by the pipe icon "|". Please note that only two fields are returned at present, this
may change in future. You must bear in mind in your scripts that any number of fields may be added.
Parameters:
Return values:
Available from:
3.00.322
Example:
set Elo=CreateObject("ELO.professional")
ObjId=Elo.GetEntryId(-1)
if ObjId>0 then
DocId=Elo.GetDocumentPathVersion(ObjId, 10, 0)
if DocId=0 then
MsgBox "This is not a document or" & vbcrlf & "the document has no
attachment"
else
DocInfos=Split(Elo.GetDocRefComment(ObjId + 1073741824, DocId),"|")
MsgBox DocInfos(1)
end if
else
MsgBox "No document is active"
end if
Function GetDocumentExt
Returns the file identification (extension) for a document file number. As DocId the Document Manager-ID
must be specified and not the logical Object-Id. You can get this number e.g. by the request GetDocFromObj.
Parameters:
Return values:
Available from:
5.00.018
Example:
Function GetDocumentOrientation
With this function you can have an image file in the postbox analyzed in order to detect a possible rotation by
90, 180 or 270 degrees. The analysis is carried out by using the OCR system. Before using the function, the
OCRInit function must be requested, after completion the OCRExit function. With the RotateFile function the
file can be rotated after analysis so that texts can be read from the bottom (only single page TIFF files).
As file name, an entry from the postbox can be transferred (without path, only the file name), or an index to the
postlist (marked by a #, e.g. #0 is the first entry in the postlist).
Parameters:
Return values:
Function GetDocumentPath
Reads the document or attachment file from a document and returns an access path to the file. Normal archive
documents are write-protected, for this reason the reader can request a free copy via the status
(AUTO_WRITEACCESS). However, the copy is only valid for a limited period and is deleted automatically
when exiting ELO.
Parameters:
The bits 1,2,3 and 4 exclude each other, they must not be combined.
Return values:
Function GetDocumentPathName
Returns the file path of a document file number. This file path is built from the view of the document manager
and generally not accessable from the client. As DocId the Document Manager-ID must be specified and not the
logical Object-Id. You can get this number e.g. by the request GetDocFromObj.
Parameters:
Return values:
Access path to the document respectively the file attachment or empty in case of an error
Available from:
5.00.018
Example:
Function GetDocumentPathVersion
Reads the document or attachment file from a document and returns an access path to the file. For version-
controlled documents previous versions can be accessed via the Version parameter. For this purpose, Version is
increased starting with 0 (=current version) by 1 until an empty string is returned.
Normal archive documents are write-protected, for this reason the reader can request a free copy via the status
(AUTO_WRITEACCESS). However, the copy is only valid for a limited period and is deleted automatically
when exiting ELO.
Parameters:
Return values:
Available from:
Example:
ObjId=Elo.GetEntryId(-1)
if ObjId>0 then
DocIds=Elo.GetDocumentPathVersion(ObjId, 10, 1)
if DocIds="" then
MsgBox "This is not a document or" & vbcrlf & "the document has no
attachment"
else
MsgBox DocIds
end if
else
MsgBox "No document is active"
end if
Function GetDocumentSize
Returns the file size of a document file number. As DocId the Document Manager-ID must be specified and not
the logical Object-Id. You can get this number e.g. by the request GetDocFromObj.
Parameters:
Return values:
Available from:
5.00.018
Example:
Function GetEntryId
This function returns the internal ELO ObjectId of a line from the archive, postbox or search view. This way you
can receive a list of all visible objects on the left side by requesting the GetEntryId function, starting with line 0
and increasing until a 0 is returned to you. If you start the request in the reminder, you receive a ReminderId
instead of an ObjectId.
Calling this function from the task item view returns a reminder Id (if the line contains a reminder item) or the
associated ELO object id (workflow item). Use IsWFLine to recognize the line type.
Parameters
Return values:
Function GetEntryName
With this function you can quickly determine the short name of an ELO object via the internal ELO object
number. If you use the value 0 as ObjectId, you receive the short name of the currently selected entry.
Parameters:
Return values:
Function GetGuidFromObj
This function determines the ELO Guid for a given ELO ObjectId.
Parameters:
Return values
Available from:
3.00.176
Function GetHistDoc
Returns the internal DocumentId for the n-th hit from LookupHistMD5.
Parameters:
Return values:
Available from:
3.00.170
Function GetHistObj
Returns the internal ELO ObjectId for the n-th hit from LookupHistMD5.
Parameters:
Return values:
Available from:
3.00.170
Function GetIndexGroups
With the GetIndexGroups function, you can determine a list of values entered for an index line, duplicates are
ignored. If you have an "Article name" index line for example, you can create a list of all available article names
via GetIndexGroups. You can then use these for selection in a combo box. Please note that this function can
only be used appropriately if the amount of hits does not exceed some dozen to some hundred entries.
This function can be used in two different ways. For the direct list (article example) only one index line is
considered. However, you can also create an "indirect" list, e.g. all article names that have been obtained by the
customer with the customer number (CTNO) 4711. This concerns two index lines, first of all one that
determines the selection and another that contains the items to be listed. However, it needs to be noted that a
considerable database load is created for a large number of hits.
Parameters:
GroupCol: Group name of index line from which the list is to be created
SelCol: Group name of index line from which the selection is to be used
SelVal: Index limit
Return values:
Example:
A list is created from index line ELOFAQBER with all the different entries that contain the string P3. in the
ELOVER index line.
set Elo=CreateObject("ELO.professional")
List=Elo.GetIndexGroups("ELOFAQBER", "ELOVER", "%P3.%")
List=Replace(List, "¿", vbcrlf)
MsgBox List
Available from:
3.00.324
Function GetLastDocId
This function determines the last physical document number in the archive.
Int GetLastDocId ()
Parameters:
none.
Return values:
Available from:
3.00.170
Parameters:
Return values:
Available from:
3.00.170
Function GetListEntry
With this function you can check out a line from the internal hit list of CollectWv and DoInvisibleSearch. The
result consists of the following parts:
Type¿ObjId¿Owner¿Id1¿Id2¿Text
• Type AC: activity, OB: object, WF: workflow task, WV: Reminder date
• ObjId ELO ObjectId
• Owner Owner of date (always 0 for OB)
• Id1 OB: Attachment Id, WF: Workflow Id, else 0
• Id2 WF: Node Id, else 0
Parameters:
Return values:
Available from:
3.00.394
Example:
Set Elo=CreateObject("ELO.professional")
UserId=Elo.ActiveUserId ' only own dates
'UserId=Elo.ActiveUserId + 1073741824 ' with group dates
'UserId=Elo.ActiveUserId + 536870912 ' with agents
'UserId=Elo.ActiveUserId + 1610612736 ' all dates
Function GetMD5Hash
With this function you can determine the MD5 hash for a file or for a data block. If you indicate a file name as
parameter, you receive the hash for the file. if you transfer a string starting with the characters "##", you receive
the hash value for this string (the ## characters are not counted for this).
Parameters:
FileName File name or input string for the MD5 hash value
Return value:
Available from:
3.00.170
Function GetNodeList
This function prepares a list of workflow nodes. The Mode parameter indicates which nodes are to be collected.
This function may only be requested from an eventscript within a workflow, the actions refer to the current flow.
Mode Action
0 Reset to standard, must always be carried out at the end.
1 Collect all nodes, equivalent to list view.
Parameters:
Return values
<0: Error
0..n: Number of available nodes
Available from:
3.00.508
Function GetObjAttrib
This function checks out the value of an input line of the current document mask.
The "visible" name, it is displayed to the user in the document masks as field name (e.g. invoice
number). It serves as name of the line for persons.
The supplementation, it is used in the database for identification of the line in the index (e.g. RENR). It
serves as name of the line for the machine.
The input value, here the user input is saved (e.g. 199807106)
Parameters:
AttribNo The lines of the input masks are numbered from 0..49.
Return values:
Function GetObjAttribFlags
Bit values:
Parameters:
Return values:
Flags
Available from:
5.00.164
Function GetObjAttribKey
This function checks out the index name of an input line of the current document mask.
The "visible" name, it is displayed to the user in the document masks as field name (e.g. invoice
number). It serves as name of the line for persons.
The supplementation, it is used in the database for identification of the line in the index (e.g. RENR). It
serves as name of the line for the machine.
The input value, here the user input is saved (e.g. 199807106)
Parameters:
AttribNo The lines of the input masks are numbered from 0..49.
Return values:
Function GetObjAttribMax
This function checks out the maximum input length of an input line of the current document mask. This field is
analyzed in the default input mask within ELO. If you carry out the entries program-controlled via OLE
Automation, you must make sure personally to keep to the minimum and maximum length of an entry.
Parameters:
AttribNo The lines of the input masks are numbered from 0..49.
Return values:
Function GetObjAttribMin
This function checks out the minimum input length of an input line of the current document mask. This field is
analyzed in the default input mask within ELO. If you carry out the entries program-controlled via OLE
Automation, you must make sure personally to keep to the minimum and maximum length of an entry.
Parameters:
AttribNo The lines of the input masks are numbered from 0..49.
Return values:
Function GetObjAttribName
This function checks out the name of an input line of the current document mask.
The "visible" name, it is displayed to the user in the document masks as field name (e.g. invoice
number). It serves as name of the line for persons.
The supplementation, it is used in the database for identification of the line in the index (e.g. RENR). It
serves as name of the line for the machine.
The input value, here the user input is saved (e.g. 199807106)
Parameters:
AttribNo The lines of the input masks are numbered from 0..49.
Return values:
Function GetObjAttribType
This function checks out the input type of an input line of the current document mask. This field is analyzed in
the default input mask within ELO. If you carry out the entries program-controlled via OLE Automation, you
must make sure personally to keep to the type of an entry.
Parameters:
AttribNo The lines of the input masks are numbered from 0..49.
Return values:
Function GetObjFromDoc
This function determines the object associated with a certain DocumentId (the DocumentId belongs to the file,
not the subject data – this Id is currently being determined here).
Parameters:
Return values:
Function GetObjFromDocEx
This function detects for an AccessManager Document-Id the appropriate Document-Id. In contrast to the
function GetObjFromDoc here not only the current working document but also the attachment as well as the
document and attachment versions is considered. The decision, which parts shall attract interest in the search, is
controlled by the flags parameter:
Parameters:
Return values:
Available from:
4.00.106
Example:
set elo=CreateObject("ELO.professional")
v1=Check(1)
v2=Check(2)
v3=Check(3)
v4=Check(4)
v5=Check(5)
Function GetObjFromGuid
This function determines the ELO ObjectId for a given ELO Guid.
Parameters:
Return values
Available from:
3.00.176
Function GetObjMaskNo
Returns the number of the current mask (document type). An equivalent SetObjMaskNo does not exist for this;
for new Elo documents, the document type is set once with the PrepareObject "for all times".
int GetObjMaskNo ()
Parameters:
None
Return values:
Apart from the hierarchical tree structure (cabinet – folder – tab – document), ELO offers the possibility to
create additional references. A document "Invoice Smith" can be filed in the "Invoices" tab and entered with an
additional reference in the "Smith" tab. Although there will only be one copy of the document in the system, it is
visible from both locations and can be edited.
With this function, the path of the reference can be determined.
Return value:
Example:
Returns the path of the second reference from object with Id 245.
Ref2 = Elo.GetObjRef (245,2)
Function GetPopupObjectId ()
With this function you can determine the object currently selected for a context menu. This entry is only valid if
it has been requested as a result of a context menu event.
int GetPopupObjectId ()
Parameters:
None
Return values:
Available from:
3.00.196
Also see:
Function GetPostDir
With this function you can quickly determine the postbox path of the current user.
AnsiString GetPostDir ()
Parameters:
None
Return values:
Also see:
Function GetRegInfo
With this function the serial number information of the Access Manager can be requested. For this purpose, the
following information is available via the Mode parameter:
All requests return a text with the number of users, user name (multiple lines) or a "TRUE" or "FALSE" for
binary requests.
Parameters:
Return values:
Example:
DIM Elo
DIM Text
DIM i
DIM Msg
for i=1 to 11
Msg=Msg & Text(i) & " : " & Elo.GetRegInfo(i) & vbcrlf
next
for i=0 to 7
Msg=Msg & Text(i+12) & " : " & Elo.GetRegInfo(i+20) & vbcrlf
next
Msg=Msg+vbcrlf
Msg=Msg & Text(0) & " : " & vbcrlf & vbcrlf & Elo.GetRegInfo(0)
MsgBox Msg
Available from:
3.00.282
Function GetScriptButton
This function can be used to return the contents of a script button within the ELO main screen. The function is
called from within installation scripts with which scripts are imported, at the same time setting the button and
menu content.
Parameters:
Return values:
Name of script
This function reads the script name or complete path of the script set in the script events.
Event: String with event identifier (see event list under SetScriptEvent)
Or position when prefixed with a # sign (these values may vary in future ELO versions)
Mode: 0 – Script name with complete path and file name extension
1 – Script name only
Return values:
-2 Unknown event
-1 Mode not implemented
0 No script available
Example:
Returns the complete path, with the filename of the script if available
CompletePath = ELO.GetScriptEvent ("sEonTimer",0)
Returns the script name, access via event position (#0 = "sEonTimer")
NameOnly = ELO. GetScriptEvent ("#0",1)
MaxLength: It the resulting path is longer than this value it will be shortend.
Return values :
-2 – unknown
-1 – invalid mode
0 – not available
other ok
Available from:
5.00.180
Example:
Function GotoId
Using this function, you can make ELO switch to a certain document (or cabinet, folder, tab). If you wish to link
your own entries to ELO documents, it is enough to save the corresponding ELO ObjectId and call up the
document via GotoId when you need to. You can use the GotoId(1) special case to return to the original archive
view in one step.
Usually, the archive view is set up in such a way that the desired object is in the list on the left and is selected.
The subentries or the image, if the object is a document, is displayed. Sometimes, it is useful to see the content
of the object, not just the object itself. In this case, a minus sign should be added to the ObjectId.
Parameters:
Return values:
Function GotoPath
Show a distinct ELO document or structure element. GotoId always uses the main parent for this access,
GotoPath contains the complete path, so references can be used. The list of object ids has to be build by ELO
object ids with the standard delimiter symbol.
Parameter:
Return values:
Function GovAddInfo
This function include a new request in the request list. Thereby you can define by the parameter Type, if an
active request (Type=1) or a version entry (Type=3) shall be created. Please not, that changes in the version
history can lead to unreproducable activities.
If you create a new request, you have to check in the script, if already other arrangements are existent for the
requested period (and in this case do without their own arrangement). This check is not accomplished by the
function GovAddInfo.
The new request must be created before by filling out all Gov… properties completely.
Parameters:
Return values:
Available from:
4.00.096
Function GovDeleteRequest
This function deletes a request of the request list and passes it on to the version history.
Parameters:
Return values:
Available from:
4.00.096
Example:
Set Elo=CreateObject("ELO.professional")
ConfirmReturn
sub ConfirmReturn
' firstly detecting the concerned object
barcode=InputBox("Please enter the barcode")
Id=Elo.LookupIndex("BARC="&barcode)
if Id<2 then
MsgBox "No record with the barcode found: " & barcode
exit sub
end if
The GovDueDate property contains the request date of the current entry.
Function GovGetRequestId
This function read the appropriate active RequestId to an ELO ObjectId. If no entry is active (i.e. the record is in
the archive and not delivered) or several are active (i.e. an error is occurred, since a paper record can only be
delivered to one person), an error is reported.
Parameters:
Return values:
-2: Error while reading the database, entry not found or equivocal
-1: No work area active
1: Ok
Available from:
4.00.096
Example:
Set Elo=CreateObject("ELO.professional")
ReturnToArchive
sub ReturnToArchive
' Firstly detecting the active object
Id=Elo.GetEntryId(-1)
if Id<0 then
exit sub
end if
Function GovMoveRequest
This function moves a record from one user to another user or back in the archive.
If a record shall be passed on from one user to another user, then the parameter NewUser must be provided with
the user number of the recipient (Caution: with that the record is not yet passed on, the recipient has to accept
the receiving).
A return request into the archive is caused by the NewUser value –2.
Parameters:
Return values:
Available from:
4.00.096
Example:
Set Elo=CreateObject("ELO.professional")
ReturnToArchive
sub ReturnToArchive
' Firstly detecting the active object
Id=Elo.GetEntryId(-1)
if Id<0 then
exit sub
end if
The GocObjId property contains the logical ELO Object-Id of the document or structure element that is assigned
to the current active entry.
The GovOwner property contains the AccessManager user number of the owner of the current active entry.
The GovReqDate property contains the creation date of the current entry.
The GovReqId property contains the request number of the current active entry. For a new entry this number has
to be set to 0, at existing entries it should not be changed.
The GovReqPrio property contains the priority of the current active entry.
The GovReqStatus property contains the delivery status of the current active entry.
#define KOM_STAT_REQUEST 10
#define KOM_STAT_PREP_DELIVERY 11
#define KOM_STAT_DELIVERED 12
#define KOM_STAT_MOVE_PENDING 13
#define KOM_STAT_REQ_RETURN 14
#define KOM_STAT_RETURN_CONFIRMED 15
#define KOM_STAT_MOVE_CONFIRMED 16
Function GovRequestList
This function reads a list of all requests for a paper record. After that the single entries can be activated by the
function GovRequestNext and read out by the Gov…properties. Please note, that the list stands IN FRONT OF
the first entry after the collecting with GovRequestList, the readout has to begin with a GovRequestNext.
You can collect the list by the current requests (Type=1) or by the request history (Type=3). A request is
assigned into the version table after occurred return of the record into the archive .
Parameters:
Type 1: Current requests, 3: Record history
ObjektId ELO Object-Id
Return values:
-2: Invalid type entry
-1: No work area active
>=0: Ok, amount of the found entries (can be 0 as well, then for this there are no entries).
Available from:
4.00.096
Example:
Set Elo=CreateObject("ELO.professional")
ShowRequestDates
sub ShowRequestDates
' Firstly detecting the active object
Id=Elo.GetEntryId(-1)
if Id<0 then
exit sub
end if
Function GovRequestNext
This function switches to the next entry of the current read request list.
int GovRequestNext ()
Parameters:
none
Return values:
Available from:
4.00.096
Example:
Set Elo=CreateObject("ELO.professional")
ShowRequestDates
sub ShowRequestDates
' Firstly detecting the active object
Id=Elo.GetEntryId(-1)
if Id<0 then
exit sub
end if
The GovRetDate property contains the (planed or actual) return date of the current entry.
Function Import
Parameters:
Returns:
-2 Error on import
-1 No workspace active
1 Ok
Please note, that the import process writes a report file in the postbox of the active user, which you should use
for evaluating possible errors.
Function ImportScript
With this function, you can import a script (*.vbs file) into the ELO script folder. The function is called from
within installation scripts with which scripts are imported, at the same time setting the button and menu content.
Parameters:
Return values:
Function ImportWorkflow
Parameters:
Return values:
Available from:
4.00.138
Function InsertDocAttachment
Using this function, you can add a file attachment to an existing ELO document. Remember that depending on
the document options set, any data link, which already exists will be moved into the history list or overwritten. If
the document has "update-proof" status, this function call will be refused.
Parameters:
ParentDoc Internal ELO ObjectId of the document to which the file should be linked.
DocumentFile Access path and name of the file that is to be linked.
Return values:
Function InsertDocAttachmentEx
Using this function, you can add a file attachment to an existing ELO document. Remember that depending on
the document options set, any data link, which already exists will be moved into the history list or overwritten. If
the document has "version-proof" status, this function call will be refused.
int InsertDocAttachmentEx (int ParentDoc, String DocumentFile, String Comment, String Version)
Parameters:
ParentDoc Internal ELO ObjectId of the document to which the file should be linked.
DocumentFile Access path and name of the file that is to be linked.
Comment Comment (e.g. original file name) for the attachment
Version Internal, freely definable version number or label
Return values:
Available from:
3.00.176
Function InsertProjectOptions
Using this function, you can add to the project options in the activities list.
For registering a new project, first create an entry under the pseudo-project "ELO_SYSTEM" with major
number 1 (you can set the minor number to 0, the next free number will then be allocated automatically) and the
entry value <projectname>. Under this project name, you can then save the lists for the sending method field,
return status, recipients and 10 user-defined fields.
A list always consists of a heading with the minor number 1, and then an arbitrary number of options for the
field value. If the heading starts with an exclamation mark, the user only can select an entry from the list. The
user can also enter a freely definable value in all other cases.
If no options list has been defined for one of the 10 user-defined fields, the field will not be shown in the editing
form. Even if you cannot make any specifications as a list of key words, you must at least enter a heading (minor
number 1).
int InsertProjectOptions (AnsiString Project, int Major, int Minor, AnsiString Value)
Parameters:
Return values:
Example:
' First, the entries already existing are removed, and the
' Script always enters a complete project data record
call Elo.DeleteProjectOptions("ELO")
' A further user-defined field, the user can select from the
' list or enter any value of choice
call Elo.InsertProjectOptions("ELO", 33, 1, "Submodule")
call Elo.InsertProjectOptions("ELO", 33, 0, "Internet gateway")
call Elo.InsertProjectOptions("ELO", 33, 0, "SAP link")
call Elo.InsertProjectOptions("ELO", 33, 0, "Backup server")
call Elo.InsertProjectOptions("ELO", 33, 0, "Mobile")
Available from:
3.00.360
Function InsertRef
Besides the hierarchical tree structure (cabinet – folder – tab – document), ELO offers the possibility to create
further references. A document "invoice Miller" can be filed in the "invoices" tab and also be listed in the
"Miller" tab with an additional reference. Although the document is only present in the system once, it is visible
and can be worked on from both places.
The parameter OldParent determines whether you want to lay out a new reference (OldParent=-1) or move an
existing reference (OldParent > 1).
If you are sure that your parameters are absolutely correct, you can switch type checking off using the
CheckTypes parameter to increase efficiency. You are then responsible for the reference being executed
correctly for the type, so a tab may not be referenced out of a cabinet or another tab, only out of a folder.
If there is already a link from "NewParent" to "ObjId", this is not reported as an error. No double link is created
either; the original situation remains.
int InsertRef (int ObjId, int OldParent, int NewParent, int CheckTypes)
Parameters:
Return values:
This function is used for creating your own text file for full-text key words.
Parameters:
Return values:
Available from:
3.00.170
See also:
Function IntToDate
This function converts an internal ELO date value into a date text.
Parameters:
Return values:
Date text
Available from:
3.00.196
Property IsWfLine(int)
Returns 1 if the with GetEntryID selected line of the task items view is a workflow item, 0 if not.
Available from:
5.00.140
Function LoadPostImg
This function loads a file into the viewer in the current postbox view. The document need not be situated in the
ELO postbox.
Parameters:
Return values:
-2 Loading error
-1 No workspace active
1 ok
Function LoadUserName
This function finds the user name for a user ID. If the user does not exist or a wrong ID has been entered, an
empty string is returned.
Parameters:
Return values:
User name
Function LockObject
If you would like to process an existing entry and want to make sure that it has not been changed by another
user, you can lock it when starting your work using this function. Once you have finished, you can release the
entry again. Anyone else who wants to work on this object in that time will receive the message that the entry is
already locked.
Parameters:
Return values:
Function Login
If your program finds an ELO instance already running, it can work within the context of the user already
logged in.
If your program has to start an ELO instance of its own, however, (e.g. a server process), you will need to log in
as the first action. In this login, submit the desired user ID, password and the archives to be worked on.
After completion of the work, you must log out (log in with the user ID "LOGOUT"), otherwise the system will
return a fault with a possible access conflict at the next start. You have two options for leaving the program, a
normal exit (by exiting the program) through the "LOGOUT" ID and an incomplete exit returning to the login
dialog using "LOGOUTNOQUIT" (e.g. to log in again under another name or work on another archive).
If you have carried out a complete logout, you must not attempt to log in again immediately. Since the program
is in the process of exiting, you will encounter an access violation. You must wait for a short time (1..5 seconds)
while the program ends completely AND then create a new ELO object with the CreateOleObject function (the
old instance is no longer valid, its attempted use will lead to an access violation).
Parameters:
Return values:
This function reads or sets the separating symbol for the LookupIndex function (and for related actions, such as
the COLD column index). This change affects the entire ELO operation, not only the activities of the OLE
automation interface.
Available from:
3.00.170
Function LookupDocType
Detects with the extension the pre-defined ELO document type to a file name. The file name can be available
with path, only as file name or also only as extension.
Parameters:
Return values:
Example:
Set Elo=CreateObject("ELO.professional")
Dim Exts
Exts=Array("x.msg", ".msg", "msg", "c:\d\x.doc", "y.xls")
MsgBox res
Available from:
4.00.034
See also:
Function LookupHistMD5Ext
Parameters:
Return values:
-1 No workspace active
0..n Number of documents with this hash value
Available from:
3.00.170
3.00.332 (Ext version)
Function LookupIndex
Finds the internal ELO Object ID from an access path. You submit an object index to this on the entry you are
looking for, and the corresponding object ID will be returned. Using this function, you can look for the object
ID for a certain index into which you wish to file a new document, for example.
The Property ObjIndex contains an empty entry (ObjIndex=""). No filing location is given, so
the document will not appear in the filing structure, and can only be displayed after a search.
ObjIndex contains an access path onto the parent node that starts with a ¿ symbol
(ObjIndex="¿Cabinet¿Folder¿Tab"). This path is composed of the short names separated by
the "¿" symbol (Alt-0191). Remember that using this approach, the same term should not be
used twice on this level; otherwise, there can be no unique assignment. For example, there
should not be two tabs for the month of March in the Invoices folder. On the other hand, the
"March" tab can be used in any other folder.
You can save up to three key terms in one tab (e.g. KDNR 123). If you save the text KDNR =
123 in ObjIndex, the tab mentioned above will be used as the parent node.
Parameters:
Return values:
Function LookupKeyName
Finds the internal ELO key ID via the key name. Remember that this information comes from a cache local to
the client system and newly created keys on other workstations may only be available after a restart.
Parameters:
Return values:
Function LookupMaskName
Looks up the internal ELO MaskId via the mask name. Remember that this information comes from a local
client cache, and newly created masks on other stations may only be available after a restart.
Parameters:
Return values:
Function LookupUserName
Detects the internal ELO User or GroupId by the user or group name. Please note, that this information comes
from a client-local cache and new created users of other stations are eventually first available after a time delay
or a reboot.
Parameters:
Return values:
Available from:
4.00.054
Example:
Set Elo=CreateObject("ELO.professional")
Name=InputBox("Please enter a user or group name")
MsgBox Elo.LookupUserName(Name)
The MaskFlags property contains information about the type of the mask and the default settings for document
flags for new documents of this type.
All other bits are reserved or are used for internal purposes; they are to contain the value 0.
Property MaxResultSet(int)
This property contains the maximum size of the search list result set. Please be aware: at some circumstances
this value will be replaced by a larger or a fixed value.
If this value has been changed for a script search it should be restored afterwards back to the normal value.
Otherwise it will be used also for standard searching.
Example:
MsgBox "Max result set: " & Elo.MaxResultSet
Elo.MaxResultSet = 5000
Function MergeImages
Function MergeImagesEx
With this function, you can copy one TIFF file into another TIFF file (e.g. in order to black out certain areas in
the image). Select the source file, the target file, the pages and the transparent colour as well as the position in
the target document.
Please note, that the transparent colour has to be declared as a 24-bit RGB value, for entire black and white
documents as well.
As base for the Merge-operation 1 bit (black and white) and 24 bit (coloured images) can be used, source and
target have to own the same colour resolution. 4, 8 and 16 bit intermediate formats are not supported.
Parameters:
Return values:
Available from:
4.00.094
Example:
Set Elo=CreateObject("ELO.professional")
Id=Elo.GetEntryId(-1)
if Id>1 then
Src=Elo.GetPostDir & "elo.tif"
Dst=Elo.GetDocumentPath( Id, 1 )
MsgBox Id & " : " & Dst & " : " & Src
Function MergePostPages
This function serves to file pages in the postbox into a cabinet. It corresponds to the "file pages into cabinet"
function in the context menu. This function affects the pages selected in each case.
Return values:
Using this property, the filing level for documents can be set or read. In this way, you can file documents on any
level depending on the setting.
Writing access on this property is only available from version 3.00.420. Remember that a change in this value
only affects the local client and is not saved.
Values:
1 Cabinet
2 Folder
3 Tab
...
253 Tab
254 Document
See also:
Function MovePostboxFile
Function MovePostboxFile2
Moves or copies a file from your own postbox into another user's postbox (iUser parameter). Mode=0 means
move, mode=1 means copy. The bit with the value 2 determines whether a MessageBox is shown if an error
occurs. The usual MovePostbox command is not included in the postbox protocol; only actions via
MovePostbox2 are recorded in the protocol.
Parameters:
sDataFile Filename
iUser UserId of the recipient
iMode 0=move
1=copy
sReportParam Additional parameter for the postbox report (short name).
Return values:
Available from:
Function MoveToArchive
Function MoveToArchiveEx
Using this function, you can transfer the active postbox entry (created via AddPostboxFile) into an archive.
The Property ObjIndex contains an empty entry (ObjIndex=""). No filing location is given, so
the document will not appear in the filing structure, and can only be shown after a search.
ObjIndex contains an access path onto the parent node that starts with a ¿ symbol
(ObjIndex="¿Cabinet¿Folder¿Tab"). This path is composed of the short names separated by
the "¿" symbol (Alt-0191). Remember that using this approach, the same term should not be
used twice on this level; otherwise, there can be no unique assignment. For example, there
should not be two tabs for the month of March in the Invoices folder. On the other hand, the
"March" tab can be used in any other folder.
You can save up to three key terms in one tab (e.g. KDNR 123). If you save the text KDNR =
123 in ObjIndex, the tab mentioned above will be used as the parent node.
Parameters:
Return values:
This function reads from a list of activity entries. In the first query, enter an SQL string with the WHERE clause
for the list. The subsequent entries are returned through further queries with empty SQL strings. As soon as no
further hits are available, an empty string is returned.
When formulating the WHERE clause, remember that the date entries are saved in ISO format. The advantage
of this format is the natural sorting so that range queries can be more sensibly executed. The column names
available can be taken from the following list. Refer to the following list for the available column names. If you
are using Oracle, remember that the server is case-sensitive. All ELO column names are in lower case.
Parameters:
Return value:
Example:
set Elo=CreateObject("ELO.professional")
MsgBox msg
Available from:
3.00.360
The NodeAction property contains information on whether a node in the script control has been activated or
ended:
Available from:
3.00.508
The NodeActivateScript contains the name of the script that is automatically called when a node is activated.
The NodeAlertWait property returns the time (in minutes) after which the workflow is to be passed on. If the
node is closed later, a timeout error is returned.
With this property, you can control whether a node within the workflow is activated. This only affects child
nodes from a distributing node that has been accessed via GetChildNode.
This property determines whether information on a node in a workflow is available. When testing a script within
the script management, there is no useful information on the node in a workflow.
This property contains the internal ELO UserId of the owner of a node.
Available from:
3.00.380
Available from:
3.00.380
This property contains the name of the workflow to which the node belongs.
This property contains the internal node number within the current workflow.
Available from:
3.00.380
This property contains the object ID of the ELO object inside the workflow control. This can be used inside
scripts that are called when activating or closing a node to access the information of the ELO object.
Return values:
Available from:
3.00.508
The NodeTerminateScript property contains the name of the script that is automatically called when a node is
terminated.
1 = Start node
2 = Person node
3 = Split node
4 = Decision node
5 = Collection node
The NodeUser property contains information on which user is entered in the node.
This property contains a query that decides the further workflow in a decision node.
Property NoteOwner(int)
This property contains the owner of the active "sticky" note in the script event call for editing a sticky note. The
script event is activated before the editing dialog and after the editing dialog. Before the dialog, the
ScriptActionKey is set to 1, and after editing, it is set to 2 for Ok and 3 for Cancel.
Available from:
3.00.330
5.00.224
This property contains the text of the active "sticky" note in the script event call for editing a sticky note. The
script event is activated before the editing dialog and after the editing dialog. Before the dialog, the
ScriptActionKey is set to 1, and after editing, it is set to 2 for Ok and 3 for Cancel.
Example:
set Elo=CreateObject("ELO.professional")
if Elo.ScriptActionKey=1 then
note=Elo.NoteText
if note<>"" then
note=note & vbcrlf & vbcrlf & "====" & vbcrlf
end if
Elo.ReadUser(Elo.ActiveUserId)
note=note & Date & Time & ": " & Elo.UserName & vbcrlf & "----" & vbcrlf
Elo.NoteText=note
end if
Available from:
3.00.330
5.00.224
Property NoteType(int)
This property contains the type of the active "sticky" note (sticky note, personal sticky note, stamp) in the script
event call for editing a sticky note. The script event is activated before the editing dialog and after the editing
dialog. Before the dialog, the ScriptActionKey is set to 1, and after editing, it is set to 2 for Ok and 3 for Cancel.
Available from:
3.00.330
5.00.224
With the ObjAcl property, you can either set or read the AccessControlList in the current entry. For a reading
query, at least one read access is necessary for the object, and one write access for writing.
When you read this property, you will be given a text in the form <entry>, <entry>,…<entry>.
Under the entry, first of all you will find the code for the type of access, and then the ID of the key, user or
group involved. The access type code is always two characters in length; the following values are available:
You are given the entry "KY2,RD3,WT4,RW5". Key 2 is set; user or group 3 has read access rights, 4 has write
access rights, and 5 has read/write access rights.
Available from:
4.00.000
Example:
Set Elo=CreateObject("LeitzElo.Elo32")
ObjectId=Elo.GetEntryId (-1)
rv=Elo.PrepareObject(ObjectID,0,0)
MsgBox Elo.ObjAcl
if Elo.ObjAcl="" then
Elo.ObjAcl="RW7"
else
Elo.ObjAcl=Elo.ObjAcl&",RW7"
end if
Elo.UpdateObject
MsgBox Elo.ObjAcl
Property ObjBarcodeInfo(AnsiString)
The ObjBarcodeInfo property can be used for querying the barcode configuration for the document type
selected. The text is entered via the BarcodeInfo field in the filing mask manager and submitted for internal
barcode analysis. However, you can also evaluate this text externally, for example if you wish to insert your own
bar code components.
Example:
Available from:
3.00.264
The ObjFlags property has various meanings depending on the type of object. If the object type is a cabinet,
folder or tab, ObjFlags contains the order in which subordinate objects are sorted.
If this object is a document, the flags will contain the version control level and full-text status.
All other bits are reserved and are only used for internal purposes. They are to be set to 0.
The ObjGuid property contains an internal globally unique ELO object GUID for the current entry. This GUID
is unique for every ELO object worldwide, and is also retained on replication. This property is read-only and is
only available when replication is switched on.
Available from:
3.00.180
The ObjIDate property contains the filing date of the document or the filing structure element. The date has to be
entered in the date format currently set on the system, for example DD-MM-YYYY or MM/DD/YYYY.
Remember that it makes no sense to set the property before filing into the archive (e.g. in the postbox or during
filing), since this value will always be overwritten by the client software with the current date on filing. If you
have to change the entry for whatever reason, you should do this after filing.
The ObjIndex property contains the filing location for the current object. This filing location must be selected
according to type, so you can only select a cabinet, but not a tab or another folder, as a filing location for a
folder.
The Property ObjIndex contains an empty entry (ObjIndex=""). No filing location is given, so
the document will not appear in the filing structure, and can only be shown after a search.
ObjIndex contains an access path onto the parent node that starts with a ¿ symbol
(ObjIndex="¿Cabinet¿Folder¿Tab"). This path is composed of the short names separated by
the "¿" symbol (Alt-0191). Remember that using this approach, the same term should not be
used twice on this level; otherwise, there can be no unique assignment. For example, there
should not be two tabs for the month of March in the Invoices folder. On the other hand, the
"March" tab can be used in any other folder.
You can save up to three key terms in one tab (e.g. KDNR 123). If you save the text KDNR =
123 in ObjIndex, the tab mentioned above will be used as the parent node.
The ObjInfo property contains a freely definable value in interface programming. In an import process, the
ObjId is stored from the old archive position, and in an automatic Office Professional archive comparison in the
office version, the ObjId from the professional central archive will be stored here.
The key of the entry is set to or read from the ObjKey property.
The ObjLock property reads the lock on the current entry. The value -1 means that there is no lock on the entry;
all other values return the UserId of the lock's owner.
Example:
id=Elo.GetEntryId(-1)
if id>1 then
Elo.PrepareObjectEx id,0,0
LockUser=Elo.ObjLock
if LockUser<0 then
MsgBox "No lock on entry"
else
MsgBox "Locked by " & Elo.LoadUserName(LockUser)
end if
end if
Available from:
3.00.188
The ObjMainParent determines the main parent of a folder, tab or document. Note: If this property is changed,
you must make sure that the new main parent of a folder is always a cabinet, the main parent of a tab is a folder,
and the main parent of a document is a tab. Errors can lead to undefined behaviour in ELO (for example, the
GotoObject function can no longer be carried out).
The ObjMaskNo property sets or reads the document type currently set.
Using this property, you can set the memo text for the current object. This memo text may contain a general
description of the entry and is available for all object and document types.
Using this property, you can set invisible text in the memo field of the current object. This MemoInfo text can
only be read or written via an automation interface and is available for all object and document types.
Reads/writes the short name of the currently active mask (document type). This field is set when reading or
creating an object (PrepareObject) from the mask definition table. Remember that by changing this entry, the
document type is not changed (this was set permanently by PrepareObject).
With the ObjOwner property, you can look up or change the owner of an object.
The ObjSDate property contains a second document date for a search using a date range. The date must be
entered in the format set in the system, for example DD-MM-YYYY or MM/DD/YYYY. Use ObjXDate to
determine the start date, ObjSDate to set the end date of the search range. ObjSDate deals with the second object
date, ObjSIDate the second filing date and ObjSVDate the second validity end date. These entries are only filled
using search masks and are undefined in archive objects.
The ObjSReg property contains the short name of a tab on the index tab. In all other objects, this value is
accepted and saved, but is not shown or editable from within ELO.
Using the ObjShort property, you can read or write into the current object's short name. This text should (must)
be entered for every object since this is the only means of orientation for the user in the filing structure view.
Using the ObjStatus property, you can find out whether an object has been deleted (status <> 0). Do not use this
property to delete entries simply by overwriting it with the value 1.
Using the ObjType property, you can find out the object type. Archives with a four-level hierarchy work with
ObjType, and archives of more than 4 hierarchy levels work with ObjTypeEx.
ObjType
1: Cabinet
2: Folder
3: Tab
4: Document
ObjTypeEx
1: Cabinet
2: Folder
3:...
.
253: Tab
254: Document
Exercise extreme caution when changing the object type. Normally, there is no reason to change anything here.
The object type is set when the entry is created according to the situation, and it therefore makes no sense to
change it later. Do not attempt to store tabs in tabs by manipulating this property; this will inevitably lead to
inconsistencies in the database.
The ObjVDate property contains the validity end date of a document. The date must be entered according to the
format set in the system for dates, e.g. DD-MM-YYYY or MM/DD/YYYY. If you want to run a search on the
validity end date, enter the range in ObjVDate (from) and ObjSVDate (to).
The ObjXDate property contains the document date (for invoices, for example, the invoice date). The date must
be entered in the format set in the system, e.g. DD-MM-YYYY or MM/DD/YYYY.
Function OcrAddRect
Adds another rectangle into the OCR identification rectangle list. For the construction of a rectangle list it
should be established a defined status with OcrClearRect, after that follows a sequence with at most 32
OcrAddRect commands. The rectangle is assigned in form of a string with the left upper coordinates and the
right lower coordinates. All values are express in per thousand (e.g. 0,0,999,999 is the whole page).
Parameters:
Return values:
The function OcrAnalyze passes on the name of the file to be evaluated and import with the pre-defined
rectangle list the text into the text list.
Parameters:
Return values:
Function OcrClearRect
Deletes the internal rectangle list of the OCR detection. This step should be accomplished as preparation before
setting a new rectangle list, so that a defined status exists.
int OcrClearRect ()
Parameters:
none
Return values:
always 1, ok
Function OcrGetPattern
Returns a detected partial text of a pattern. Note, that each part of a pattern contains a partial text, even if it is
actually permanent or empty. The pattern “*’invoice’_N*” owns as first part of the pattern a * (any character
string), after that follows as second part the permanent text ‘invoice’, the third part is a string of empty
characters (which can also be empty), the fourth part is a number und at last as the fifth part follows any text
again, the complete rest after the detected number can also be empty again. Please note, that you have to request
the first part with OcrGetPattern(0) (starting with 0, not with 1).
Parameters:
PatternNo: Number of the partial text out of the last pattern to be returned
Return values:
Function OcrGetText
After the OCR analysis the detected parts of the rectangle list are available in a text field. With the command
OcrGetText you can readout these texts, OcrGetText(0) returns the text to the first rectangle, OcrGetText(1) to
the second etc…
Parameters:
Return values:
Function OcrPattern
The function assumes a pattern and an entered text and splits them according to the default pattern in partial
texts. The structure of the pattern string you can gather from the appendix. The parameter PrepareText decides
on the pre-processing of the incoming text before the pattern detection (to delete unnecessary white spaces
(empty characters etc.)). Thereby the following combinations are available:
• 8: All WS will be deleted at the beginning and at the end of the text (approximates the TRIM()
command in BASIC)
• 16: After every change of lines the WS will be deleted at the beginning of the line.
Parameters:
Return values:
The OfficeMaskNo property contains the configuration settings of the ELO client under "System management"
– "Options" – "General" – "Standard filing masks for new entries" – "Microsoft Office documents". This
property is read-only.
With the OkEnabled property can be checked, if the Ok-button in the ELO subject data dialog is activated and if
the user is allowed to make changes at the index data. The property must be checked, when the ELO-subject
data dialog is replaced by an own dialog (e.g. a Visual Basic mask). Only if the return value is 1, an Ok-click
can be passed on to ELO by setting the property ScriptActionKey to 10. So it is advisable to make the Ok-button
of the own mask clickable only then when OkEnabled has the value 1.
This property can only be read.
Values:
Function OpenChildNodes
This function must be called before the subsequent nodes of the current node of a workflow can be accessed
using GetChildNode. The current node must be a distributor node.
int OpenChildNodes ()
Return values:
The values for the "Open" and "Save" dialog boxes are set or read using this property.
Options:
Value Meaning
AllowMultiSelect Allows users to select more than one file in the dialog.
CreatePrompt Generates a warning message if the user tries to select a nonexistent file, asking whether to
create a new file with the specified name.
ExtensionDifferent This flag is turned on at runtime whenever the selected filename has an
extension that differs from
Example:
This function creates an "Open" or "Save" dialog depending on type. The values for title, FileName etc are
accessible via the OpenSave property.
Value Function
1 Open Dialog
2 Save Dialog
Return value:
Example:
Values must be set beforehand with the OpenSave property. Otherwise, the dialog will appear with the default
values given by Windows.
Function OrientFile
This function can be used for analysing an image file in the postbox, any possible rotation through 90°, 180° or
270° is corrected. The analysis takes place using the OCR system. Before using the function, the OCRInit
function has to be called, and OCR Exit after the function is ended. The function also works with multipage
TIFF files.
As a filename, you can use the entry from the postbox (without the path, only the filename) or an index in the
post list (marked by a # sign, e.g. #0 is the first entry in the post list.)
Parameters:
Return values:
Available from:
This property returns the current name of the person or group to which the resubmission is to be sent.
Function PostBoxLineSelected
This function can be used for testing whether a line in the postbox has been selected.
Parameters:
Return values:
This function reads an ELO object (cabinet, folder, tab or document) into an internal editing buffer. From here,
various fields such as short name, colour, or memo text can be read, processed and edited. These changes can
then be transferred to the database permanently using the UpdateObject function.
If you wish to create a new object, you first have to initialise a new, empty entry with the ObjectId set to 0 using
this function. If you wish to mark an existing entry as "new" (that means all data is retained, but a new entry is
created when saved), enter -2 as the ObjectId. This function is available from Version 2.02.059 onwards.
The third possibility might be setting a postbox entry as an "active postbox entry". In this case, set ObjectId to -1
and the postbox line number (starting with 0) as the ObjectType.
Archives with a four-level hierarchy work with PrepareObject; archives with more than 4 hierarchy levels work
with PrepareObjectEx.
Remember that when reading postbox entries, the error conditions -5 and -7 are returned. These are only errors
in the sense that "the key words could not be read since they have not been created". The postbox entry still
exists without key words and can be processed.
Parameters:
Parameters:
Return values:
5: Existing, deleted but not yet permanently removed postbox entry read
Example: call the first postbox document, set the mask ID to 2 and automatically fill the short name and first
index field. After that, the document at the given path is transferred to the archive:
x=Elo.PrepareObjectEx(-1, 0, MaskNo)
if x>0 or x=-5 or x=-7 then
Elo.ObjShort="Test" & Time
call Elo.SetObjAttrib(0,"Tab 1")
call Elo.AddPostboxFile("")
x=Elo.MoveToArchive(TabId)
else
MsgBox "No document found in the postbox"
end if
Function PrepareReplSet
This function reads the replication information of a first ELO object. This can be queried via the QueryReplSet
function and altered via the SetReplSet function. The changes are then written into the database using
UpdateReplSet. Remember that the parent objects are automatically given the necessary replication set for this
alteration. Whether the child entries are also changed can be set through the parameter flags.
Remember that you cannot take up any logical references in a replication set. This will automatically be passed
back to the main parent.
Parameters:
Example:
FolderId=4859
Tab1=4867
Tab2=7890
ReplFolder=7
ReplTab1=8
Set Elo=CreateObject("ELO.professional")
Result=Elo.PrepareReplSet(Tab1)
if Result<0 then
MsgBox "Subtab 1 could not be read, error: " & Result
else
if Result=2 then
MsgBox "Subtab 1 already contains replication sets!"
end if
call Elo.SetReplSet(ReplTab1, 1)
Result=Elo.UpdateReplSet(5)
if Result<0 then
MsgBox "Error writing replication set information: " & Result
end if
end if
Result=Elo.PrepareReplSet(FolderId)
if Result<0 then
MsgBox "The folder could not be read, error: " & Result
else
call Elo.SetReplSet(ReplFolder, 1)
Result=Elo.UpdateReplSet(7)
if Result<0 then
MsgBox "Error writing replication information: " & Result
end if
end if
Result=Elo.PrepareReplSet(Tab2)
if Result<0 then
MsgBox "Subtab 2 could not be read, error: " & Result
else
call Elo.SetReplSet(ReplFolder, 0)
Result=Elo.UpdateReplSet(7)
if Result<0 then
MsgBox "Error writing replication information: " & Result
end if
end if
Result=Elo.PrepareReplSet(Tab1)
if Result<0 then
MsgBox "Subtab 1 could not be read, error: " & Result
else
if Result=1 then
MsgBox "Subtab 1 does not contain any replication sets!"
else
Msg="Active replication sets for tab 1: " & vbcrlf & vbcrlf
for i=1 to 128
if Elo.QueryReplSet(i)=1 then
Msg=Msg & "Replication set " & i & " active." & vbcrlf
end if
next
MsgBox Msg
end if
end if
Return values:
Available from:
3.00.290
Function PromoteAcl
This function can be used to alter the subentries of an object to the current ACL. The organization of the ACL
entries is described at the ObjAcl property.
int PromoteAcl (int iObjId, int iShowResult, int iExact, int UpdateVal, AnsiString mAcl, AnsiString
mAdd, AnsiString mDel)
Parameters:
Return values:
Available from:
3.00.204
DocTitle: Heading (if "" is returned, the title is the search result)
ObjIdList: List with object IDs separated by a separator. Unavailable object IDs are ignored.
0 0 0 0
X x x x x x x x x x x x x x x x x x x x x x x x x x x x
3 2 1 0
00 0 – List view
1 – Column view
01 0 – Short headings
1 – Long headings
02 0 – No separator line
1 – Separator line after each entry
03 0 – Show no dialog
1 – Show a dialog (values returned are used)
x Currently unused (reserved for extensions)
Return value:
Example:
To print a list of the given object IDs with the short name, filing date and index lines fields. The
heading is the search result.
ELO.PrintDocList ("","10¿11¿52","Short¿Date¿Tab",0)
To print a table of the given object IDs with the short name, filing date and index lines fields. The
heading is "My search".
ELO.PrintDocList ("My search", "10¿11¿52", "Short¿Date¿Tab",1)
The tabulators for the PrintDocList printout's column view can be set using this property.
No.:
0 - Default
1 - Short name column
2 - Document date column
3 - Filing date column
4 - Index column
5 - Memo column
Example:
Function PrintDocument
PrintDocument (int MitDialog, String DeviceName, String Port, int FromPage, int ToPage, int Copies)
Parameters:
Return values:
Function QueryOption
The QueryOption function can be used to query individual settings in the options dialog.
Parameters:
Return values:
Example:
Set Elo=CreateObject("ELO.professional")
MsgBox msg
Available from:
3.00.286
Function QueryReplSet
With this function, you can query the replication set. Refer to the example under PrepareReplSet.
Parameters:
Return values:
This function reads the activities entry defined via the ActGuid parameter.
Parameters:
Return value:
Available from:
3.00.360
Function ReadBarcodes
This function reads barcodes situated in a postbox TIFF document. The name of the postbox file can be returned
via SourceFile. Alternatively, a line number (#0, #1, #2…) can be returned. The corresponding file in the post
list used for the filename. The function returns the number of recognised barcodes; the barcodes can be called
using the GetBarcode function.
The BarcodeDescriptor parameter contains a list of the rectangles to be analysed. Refer to the barcode
documentation for a detailed description of this list.
int ReadBarcodes (AnsiString SourceFile, AnsiString BarcodeDescriptor, int MaskNo, int ReadMultiple)
Parameters:
SourceFile The file to be analysed or the post list line number (with #Number).
BarcodeDescriptor List of rectangles, in barcode format.
MaskNo Document type of the key word file to be created
ReadMultiple 1 = Read all barcodes in the rectangle defined
0 = Only read one barcode
Return values:
Function ReadColorInfo
With this function, you can read a colour definition of an ELO colour object. You can access the colour settings
via the ColorInfo and ColorName properties.
If you need a list of the colours available, you can call the function starting with 0 and the bit set at Ox8000. The
next corresponding colour value is then loaded.
Parameters:
Return values:
This function reads the system key entry and returns a name.
KeyNo:
Return value:
Example:
Function ReadObjMask
With this function, you can read a mask (document type) into the internal ELO object. The attribute name and
index fields, but not the entry value fields with the defined values, are preset.
Parameters:
Return values:
Function ReadSwl
Reads one level of a keyword list. Each entry contains a unique two letter level information: AA, AB, AC .. ZZ
per level. The root level starts with a dot. „.AAABAC“ starts at the base with the first entry, within this with the
second subentry, within this selects the third subentry.
The group parameter is connected to the group entry in the keywording form.
Parameters:
Return values:
Example
...
Set Elo=CreateObject("ELO.professional")
Available from
5.00.066
Function ReadUser
The ReadUser function reads a user record from the system file. Admins can read any user; subadmins can only
read their own users. Every user can read his own user data.
An empty user record can be created with the UserNo –1. With the UserNo –2 the accumulated rights of the
current user are read (i.e. the UserGroups property does not only contain the direct groups, but also all sub-
groups, the same applies to UserKeys). (available from version 3.00.546 on)
For the creation of a new user a free slot has to be searched (user entry with empty name field). Please be careful
with new user numbers, you may destroy existing users.
Parameters:
Return values:
Function ReadUserProperty
The ReadUserProperty function reads a user extension from one of 8 user data fields. Remember that the first
four fields are reserved by ELO (e.g. for NT name conversion). Fields 5..8 are freely available.
Parameters:
Return values:
Example:
Set Elo=CreateObject("ELO.professional")
Elo.ReadUser(Elo.ActiveUserId)
Param=Elo.ReadUserProperty(5)
if Param<>"" then
ArcList=Split(Param, "|")
ArcName=Elo.GetArcName & "¿"
for i=LBound(ArcList) to UBound(ArcList)
ThisEntry=ArcList(i)
if Left(ThisEntry, Len(ArcName))=ArcName then
ThisEntry=Mid(ThisEntry, Len(ArcName), 255)
ThisId=Elo.LookupIndex(ThisEntry)
if ThisId>0 then
Elo.GotoId(0-ThisId)
end if
end if
next
end if
After this call the function GetNodeList gives access to all nodes of the workflow
Parameters:
FlowId: Workflow Id, -2 selects the last accessed line of the task view
NodeId: Node number
ELOObjId: ELO Object Id of the connected document
Flags: unused, always 0
Return values:
Example:
Set Elo=CreateObject("ELO.professional")
Elo.SelectView(5)
For i=0 To 10
iID=Elo.GetEntryID(i)
If iID=0 Then Exit For
If Elo.IsWFLine=1 Then
Call Elo.ReadWFNode(-2,0,0,0)
MsgBox "Aktiver Knoten: " & Elo.NodeName & " / " & Elo.NodeFlowName
cnt=Elo.GetNodeList(1)
For j=0 To cnt-1
Call Elo.SelectNode(j)
If Elo.NodeType=2 then
MsgBox "Knoten " & Elo.NodeID & ": " & Elo.NodeName & " [" &
Elo.LoadUserName(Elo.NodeUser) & "]"
End If
Next
End If
Next
Available from:
5.00.140
Function ReadWv
Reads a to-do date (determined by the WvIdent parameter) into the internal to-do memory. This date can then be
read out with the various Property functions. If WvIdent has 0 value, the internal to-do memory is deleted; this
operation is essential before creating a new date.
Parameters:
Return values:
Function ReloadWv
This function updates the list of to-do dates in the main ELO window.
int ReadWv()
Parameters:
None
Return values:
The dialog for the removal of document files with backup can be automated by this function call. There are
parameters for the filing path, delete date and the backup control. The delete date has to be in the ISO date
format YYYYMMDD (Year – Month – Day).
The backup control decides if the backup document will be checked before the deletion. Value 1 deletes without
any further checks (only for test data recommended). Value 2 initiates a directory check for file sizes and value 3
forces a complete verify before deletion.
With the values 1, 2 or 3 the function does only a check, without deletion. You get only a report with the
expected deletion information. Add 21840 to this value for the final deletion (Values 21841, 21842 or 21843).
Parameters
Return value
-1 Cannot delete
-2 Invalid DelDate
-3 no work area active
others report
Available since:
5.00.094
Example:
Elo.RemoveDocs(1, "20050727", 3)
As well as its hierarchical tree structure (Cabinet - Folder - Tab - Document) ELO also lets you create other
references. A document called "Miller invoice" can be filed under the "Invoices" tab and entered in the "Miller"
tab with an additional reference. Although there is only one instance of that document in the system, it can be
viewed and processed in both places.
The function also lets you remove a reference already created.
Return value:
Example:
Function RotateFile
This function lets you rotate a graphics file in the postbox by 90, 180 or 270 degrees. In the current version only
single page TIFFS can be rotated; multipage documents cannot be handled.
The filename given may be an item from the postbox (no path, just the filename), an index number in the post
list (marked with #, e.g. #0 is the first item in the mail list) or an empty string. In this case the current postbox
file (ActivePostFile, e.g. from the previous scan) is used.
Parameters:
Return values:
Function RunEloScript
This function starts an ELO script. The system searches for the script file in the Postbox\EloScripts directory.
Parameters:
Return values:
Function SaveDocumentPage
This function lets you save one page of a multipage TIFF file.
Parameters:
Return values:
See also:
Function SaveDocumentZoomed
This function lets you save the document currently displayed with a zoom factor.
Parameters:
Return values:
See also:
Function SaveObject
This function lets you save and restore the internal object wrapper text data. The function may not be used
repeatedly, because there is only one Save memory. Every Save action overwrites the previous one. The Restore
function may be used repeatedly, but in that case the same data is restored each time.
Parameters:
Return values:
See also:
This property is used to return information to ELO from the script. ELO responds to it with very specific
actions.
See also:
Reads the header columns of the search result list, concatenated with a pipe symbol "|".
Available from:
5.00.174
Function SearchListLineId
With this function the ELO ObjectId of a line out of the search view can be detected.
Parameters:
Return values:
Available from:
5.00.036
Example:
for i = 0 to 8
res = res & Elo.SearchListLineSelected( i ) & " - " &
Elo.SearchListLineId( i ) & ", "
next
MsgBox res
Function SearchListLineSelected
This function lets you test whether a line in the search view is selected.
Parameters:
Return values:
Function SelectAllPostBoxLines
int SelectAllPostBoxLines ()
Parameters:
None
Return values:
Function SelectArcListLine
This function selects an entry in the search view. Thereby the line number runs from 0 till the amount of entries
minus 1.
Parameters:
Return values:
Available from:
5.00.036
Example:
for i = 0 to 8
res = res & Elo.ArcListLineSelected( i ) & " - "
next
for i = 0 to 3
Elo.SelectArcListLine( i )
next
for i = 4 to 7
Elo.UnselectArcListLine( i )
next
Elo.SelectArcListLine( 8 )
MsgBox res
Function SelectCurrentNode
If the OpenChildNodes and GetChildNode functions were used to edit the successors of the active node in
workflow control, then SelectCurrentNode must be recalled to give you access to the current node again.
int SelectCurrentNode ()
Return values:
Function SelectLine
The SelectLine function lets you select an entry in the current selection list. To do this, the left-hand page of
Archive view is used, or the Clipboard list, Post list, Search list or To-do list.
Parameters:
Return values:
Function SelectNode
This function selects an entry from the list of workflow nodes prepared with "GetNodeList".
Parameters:
Return values:
Available from:
3.00.508
Function SelectPostBoxLine
Function SelectPostBoxLineEx
This function selects an entry in the Postbox. By using SelectPostBoxLineEx you can load the document in the
viewer again.
Parameters:
Return values:
Function SelectRootNode
This selects the root node of the current workflow. This root node can be queried or edited with the
node…properties. If you need the current node again afterwards, call it up with the SelectCurrentNode function.
int SelectRootNode ()
Return values:
1: Ok
Example:
set Elo=CreateObject("ELO.professional")
call Elo.SelectRootNode
fields=split(Elo.NodeComment,",")
call Elo.ConfirmWorkflowEx(fields(0), fields(1), fields(2), fields(3),
"Back","", 1,0)
Available from:
3.00.380
Function SelectSearchListLine
This function selects an entry in Search view. The line number here runs from 0 till the amount of entries minus
1.
From version 3.00.544 on, you have the further possibility to enter a negative line number. In this case the line is
not only selected but the document view on this line is additionally actualized. Since for the first line it can’t be
distinguished between a “0” and a “minus 0”, this line begins at “-1” instead of a “-0” for the first entry.
Parameters:
Return values:
Function SelectTreePath
This command activates the tree view in the search view and seperates it according to the specified parameter
strings. The various levels are each marked by a ¶-Seperator, the last level will be selected and not seperated
further. Thereby you can declare for the last level the placeholders “*” for “select first entry” and “-“ for “select
nothing”.
Parameters:
Return values:
Examples:
The following example accomplishes a search over all emails (mask number 2), which contain anywhere in the
sender “Thiele”. Afterwards the path stock – purchase – arrivals is seperated an there the first sub-entry is
selected:
Set Elo=CreateObject("ELO.professional")
Elo.SelectView 4
Elo.PrepareObjectEx 0, 0, 2
Elo.SetObjAttrib 0, "%Thiele%"
Elo.DoSearch
Elo.SelectTreePath "stock¶purchase¶arrivals¶*"
Available from:
4.00.152
Function SelectUser
Function SelectUserEx
The SelectUser and SelectUserEx function lets you call a selection dialog to select a user. You get a list of all
users (optionally suppressing your own entry) and get returned the user ID selected (or –1 if you cancel).
Parameters:
Return values:
Parameters:
Return values:
Example:
Set Elo=CreateObject("ELO.professional")
Users = Elo.SelectUserEx(1)
UserList = split(Users, ",")
for each UserNo in UserList
MsgBox Elo.LoadUserName(UserNo)
Next
3.00.276
Function SelectView
The SelectView function lets you decide which working view you want to have on top. You can also use it to
ask which view is currently active.
Parameters:
Return values:
Function SelectWorkArea
Normally all Automation commands affecting the UserInterface (e.g. GotoId) apply to the currently active view.
If you are working with a second view, you cannot control the two windows independently of each other. The
SelectWorkArea function lets you define all subsequent commands for one of the two views. After completing
the window-based operations, you should reset to the standard setting with SelectWorkArea(0). Watch out that,
where operations extend over a period of time, a work area may have become invalid, e.g. if the user has closed
the window in the meantime. For this reason the explicit selection should always only be made at short notice
and should be reset immediately after completing the tasks.
Example:
if Elo.SelectWorkArea(2)>=0 then
‘ now come the commands for the second work area
x=Elo.SelectView(5) ‘Switch to To-do view
end if
Parameters:
Return values:
Available from:
3.00.264
Function SelList
The SelList function lets you make ELO show a hierarchical list. As input parameter you give the filename of
the list. If you only give a name without a filepath, the file is expected in the Postbox directory. As return value
you get an empty string (Cancel) or the option selected.
Return values:
See also:
Function SeparateTiffFile
With the function SeperateTiffFile you can split multipage tiff-files into single tiff files. These files can
automatically, controlled by separate pages, be combined to partial documents again.
For the single files the original name is used as file name. This name is added by an underscore and the line
number (starting with 0). From the file XYZ.TIF the single files XYZ_0.Tif, XYZ_1.TIF … becomes, they are
filed in the same directory.
Caution: ELO does not check, if a name conflict is existent for the new created files. If there exists already
an entry among one of the automatically generated file names, it will be overwritten without demand or
warning. If it is not guaranteed, that such conflicts cannot occur, the script must accomplish this check
before the request.
AnsiString SeparateTiffFile (AnsiString FileName, int ScanProfil, int Trennseite, int Leerseite)
Parameters:
Return values:
example:
Available from:
4.00.212
Function SetCookie
The SetCookie function sets the value of a cookie entry. If the cookie does not yet exist, it is automatically
generated. The Get/SetCookie functions are primarily intended so ELO scripting macros can store information
permanently in ELO. The cookie memory is only deleted when you close ELO.
To set a cookie, you give it a name and a value. You access a cookie with its name (Ident) and the value
assigned to it is returned. If the cookie is not known, an empty string is returned.
Please note the number of cookies is limited. Each macro and any other external program should only use a few
of them and each time you launch it you should use the same ones again and not keep creating new ones.
Parameters:
Return values:
Function SetObjAttrib
This function sets the value of an input line in the current document mask.
The "visible" description, shown to the user in the document masks as a field name (e.g. invoice
number). It provides a line name for the user.
The extension, used in the database to identify the line in the index (e.g. RENR). It provides a line
reference for the machine.
The input value; this saves the user input (e.g. 199807106)
Parameters:
AttribNo The lines of the input masks are numbered consecutively from 0…49.
AttribValue The new input value of this line, up to 30 characters at all
Return values:
Function SetObjAttribFlags
Bit values:
Parameters:
Return values:
Available from:
5.00.164
Function SetObjAttribKey
This function changes the index key of a line of the current document mask.
The "visible" description, shown to the user in the document masks as a field name (e.g. invoice
number). It provides a line name for the user.
The extension, used in the database to identify the line in the index (e.g. RENR). It provides a line
reference for the machine.
The input value; this saves the user input (e.g. 199807106)
Parameters:
AttribNo The lines of the input masks are numbered consecutively from 0…49.
KeyValue The new index of this line.
Return values:
Function SetObjAttribMax
This function sets the maximum length of an input line in the current document mask. The field is evaluated in
the standard input mask within ELO. If you make your inputs using the OLE Automation program, you must
make sure yourself that the minimum and maximum lengths of an input are observed.
Parameters:
AttribNo The lines of the input masks are numbered consecutively from 0…49.
AttribMax Maximum length of input, 0: No control
Return values:
Function SetObjAttribMin
This function sets the minimum length of an input line in the current document mask. The field is evaluated in
the standard input mask within ELO. If you make your inputs using the OLE Automation program, you must
make sure yourself that the minimum and maximum lengths of an input are observed.
Parameters:
AttribNo The lines of the input masks are numbered consecutively from 0…49.
AttribMin Minimum length of input, 0: No control
Return values:
Function SetObjAttribName
This function changes the name of a line the user sees in the current document mask.
The "visible" description, shown to the user in the document masks as a field name (e.g. invoice
number). It provides a line name for the user.
The extension, used in the database to identify the line in the index (e.g. RENR). It provides a line
reference for the machine.
The input value; this saves the user input (e.g. 199807106)
Parameters:
AttribNo The lines of the input masks are numbered consecutively from 0…49.
NameValue The new name of this line.
Return values:
Function SetObjAttribType
This function sets the type of input of an input line in the current document mask. The field is evaluated in the
standard input mask within ELO. If you make your inputs using the OLE Automation program, you must make
sure yourself that the input type is observed.
Parameters:
AttribNo The lines of the input masks are numbered consecutively from 0…49.
AttribMax Permitted input type
Return values:
Function SetOption
The SetOption function lets you change individual settings temporarily in the Options dialog. The call gives as
return value the value of the current setting.
Parameters:
Return values:
Example
Set Elo=CreateObject("ELO.professional")
OldVal=Elo.SetOption(0, "FALSE")
MsgBox "Old value of the option stood at :" & OldVal & ", it was changed to
False."
NewVal=Elo.QueryOption(0)
MsgBox "New value of the option stands at : " &NewVal
Available from:
3.00.286
Option No 3 and following: from 3.00.350
Function SetReplSet
This function lets you add or erase a new replication set. You will find an example of this under PrepareReplSet.
Parameters:
Return values:
Function SetScriptButton
This function lets you assign a script to a script button on the main ELO screen. The assignment is saved under
the respective user.
The function is called within installation scripts, which allow scripts to be imported and buttons and menus to be
assigned at the same time.
int SetScriptButton (int iTabSheet, int iButton, AnsiString sScriptName, int iVisible)
Parameters:
Return values:
Function SetScriptEvent
Script : String with script name without ending (if in standard script path) or
complete pathname with filename + ending (script is then automatically
copied to script directory)
If an empty string is sent, the event set is deleted. In this case
the mode has no significance.
Mode : 0 – Change script assignment only if there is free space (if the script contains a pathname,
when it is changed an existing file is not overwritten
and the script is not assigned)
1 – Always change script assignment (if script contains a pathname,
when it is changed an existing file is overwritten)
Return values:
Example:
Sets a script from the script directory in the OnTimer event if the space
is not filled.
ELO. SetScriptEvent ("sEonTimer", "My Timer Script",0)
Sets a script from drive A: in the OnTimer event whether it is filled or not.
ELO. SetScriptEvent ("sEonTimer", "a:\anyScript.VBS",1)
Event list
Function SetScriptMenu
This function lets you enter an ELO script in the context menu of the main ELO screen. Each view (Archive
view, Clipboard, Postbox, Search and To-dos) has its own context menu. The assignment is saved under the
respective user.
The function is called within installation scripts, which allow scripts to be imported and buttons and menus to be
assigned at the same time.
Parameters:
Return values:
The ShowActivities function shows a list of activities. You make the selection with the SQLString.
Parameters:
Mode: 1: If list only has one entry, go immediately
to Edit.
16: When editing, set focus to return date
256: When editing, block Version, Project and
Recipient fields.
SQLString: SQL query of data records to be selected.
Return value:
Available from:
3.00.360
Function ShowAutoDlg ()
Shows the dialog created. CreateAutoDlg must be called first. It is not possible to call ShowAutoDlg several
times in succession, because pressing OK or Cancel upsets the information needed to show the dialog. So you
then have to open CreateAutoDlg again.
int ShowAutoDlg ()
Return value:
Example:
Function ShowDocInverted
int ShowDocInverted ()
Parameters:
None
Return values:
See also:
The SigId property defines the document manager ID of the signature of a document. A wrong entry at this
place leads to the destruction of the signature.
Available from:
5.00.042
Function Sleep
This function accomplishes a break with an adjustable amount of milliseconds. Thereby you can additionally
execute a ProcessMessages before and/or after the waiting time. This request leads to the fact, that the client
stays active operated.
Parameters:
Return values:
1: ok
Available from:
4.00.054
See also:
Function SortSearchList
Sort the search result list. The option "multicolumn view" has to be activated.
Parameter:
Return values:
Available from:
5.00.174
Function SplitFileName
The SplitFileName function looks at a filepath (drive – path – filename or server – path – filename) and finds the
path element with the drive or server, the filename or the file Id.
Parameters:
Available from:
3.00.220
Function StartFlow
This function opens the user dialog for starting a workflow. Both standard workflows and ad hoc workflows can
be started (determined by setting a parameter).
Parameters:
Return values:
Function StartFlowEx
This function opens the user dialog for starting a workflow. Both standard workflows and ad hoc workflows can
be started (determined by setting a parameter). Ad hoc workflows can also be generated and automatically
started.
If you want to create an ad hoc workflow without UserInterface, you have to write a text file describing it before
calling it (for the structure, see example below). You then send this file as the WFInfo parameter (Warning:
don't forget the prefix "Template:").
int StartFlowEx (int Mode, int ObjectID, AnsiString WFName, AnsiString WFInfo)
Parameters:
Return values:
-2: Invalid objectID
-1: No active work area
1: Ok
Available from:
3.00.394
Example:
Set Elo=CreateObject("ELO.professional")
Set Fso = CreateObject("Scripting.FileSystemObject")
IniFile="c:\temp\flow.ini"
UserId=Elo.ActiveUserId
NodeName="Test 1"
Id=Elo.GetEntryId(-1)
call Elo.PrepareObjectEx(Id,0,0)
UserList=Elo.GetObjAttrib(0)
Fso.CreateTextFile IniFile
Set f2 = Fso.GetFile(IniFile)
Set ts2 = f2.OpenAsTextStream(2, 0)
msg="[Template]" & vbcrlf
msg=msg & "Name= " & Elo.ObjShort & vbcrlf
msg=msg & "TerminateUser=" & UserId & vbcrlf
msg=msg & "Type=1" & vbcrlf
msg=msg & "TerminateLabel=Finished" & vbcrlf
msg=msg & "StartLabel=Distribution" & vbcrlf
msg=msg & "UserList=" & UserList & vbcrlf
msg=msg & "NodeName= " & NodeName & vbcrlf
ts2.Write(msg)
ts2.Close
Function StartScan
The StartScan function lets you start a scan sweep in Postbox. With the ActionCode parameter you can define
whether it is to scan single pages or do a batch scan. The second parameter determines what scanner default
settings are to be used (page size etc.).
You can find the image scanned in ActivePostFile. If this entry is empty,
a scanning error has occurred or the user cancelled the procedure.
Parameters:
Return values:
See also:
Function Status
This function sets a text in the status line in the current main ELO window.
Parameters:
Return values:
Function StoreDirect
This function stores the Postbox entries selected in Archive, so it corresponds to the menu command 'Store
direct in Archive' in the Postbox context menu. Before starting it, the tab you want must be opened in Archive
view.
int StoreDirect ()
Parameters:
None
Return values:
Function StoreKeyword
This function stores the Postbox entries selected in Archive by keyword, so it corresponds to the menu command
'Store keyword in Archive' in the Postbox context menu.
int StoreKeyword ()
Parameters:
None
Return values:
Function StoreMulti
This function stores the Postbox entries selected in Archive, and it corresponds to the menu command 'Store Tab
Unnamed' in the Postbox context menu.
int StoreMulti ()
Parameters:
None
Return values:
Function ToClipboard
Parameters:
Return values:
Always o
Available from:
3.00.456
Example:
Option Explicit
Dim Elo,url,id,Guid,iObjID,iLine,Body
set Elo=CreateObject("ELO.professional")
url="http://hobbit3:8081/guid/"
if Elo.SelectView(0)=1 then
Id=Elo.GetEntryId(-1) ' Get selected entry
if Id>1 then
if Elo.PrepareObjectEx(Id,0,0)>0 then
Guid=Mid(Elo.ObjGuid,2, Len(Elo.ObjGuid)-2)
Elo.ToClipboard url & Guid
end if
end if
elseif Elo.SelectView(0)=2 or Elo.SelectView(0)=4 then
iLine=0
Body=""
Do
iObjID=Elo.GetEntryID(iZeile)
If iObjID=0 Then Exit Do
Elo.PrepareObjectEx iObjID,0,0
If Elo.ObjTypeEx=254 Then
Guid=Mid(Elo.ObjGuid,2, Len(Elo.ObjGuid)-2)
Body=Body & url & Guid & vbCrLf & vbCrLf
End If
iLine=iLine+1
Loop Until False
Elo.ToClipboard Body
end if
Function TreeWalk
This function runs from the Start node through all subnodes and requests a script for each entry. This way you
can work through whole structures with one call.
When working through subobjects, the Parameters mode lets you work on the current node before the subnode
or after the subnode. If you want to apply an attribute of a cabinet to all documents, then you should stipulate
"before" (the folder attribute must be set before the tabs are edited). If you want to gather information (e.g. how
many documents meet a certain criterion), then "after" is more appropriate (all the tabs must first be counted to
find the total number in the folder). If the "node succession" is not important (e.g. for "Print all documents"),
then you should choose the "before" method, because it puts slightly less load on the system.
The Parameters mode also lets you decide whether you want to include references or stick to the main lines of
succession.
With the MaxDepth parameter you can define the maximum depth you want to work on. For example, if you
want to edit all folders, set the start node to 1 (archive object) and maximum depth to 2 (cabinet and folder
level). Then in the callback script you only have to check whether the call refers to a cabinet object (in which
case you do nothing) or a folder object. The search starts here but does not go any deeper, so this call is
extremely efficient. If you want all the objects listed, you can simply set maximum depth to 15 or another
sufficiently high number.
This function offers a simple means of working with whole hierarchies. It is not designed for maximum
performance, because a separate script call must take place for every entry. So if you are dealing with large
volumes of data or you need the fastest possible access, you must create the TreeWalk in the script itself.
However, most of the time this version should be fast enough.
int TreeWalk (int Mode, int StartObj, int MaxDepth, AnsiString ScriptName)
Parameters:
Return values:
Example:
Script 2, containing the actual TreeWalk call and a list of all the short descriptions below the node currently
selected.
Available from:
3.00.324 (Professional)
5.00.222 (Office)
See also:
Function UnselectAllPostBoxLines
int UnselectAllPostBoxLines ()
Parameters:
None
Return values:
Function UnselectArcListLine
This function unselects an entry in the right list of the archive view.
Parameters:
Return values:
Available from:
5.00.036
Example:
for i = 0 to 8
res = res & Elo.ArcListLineSelected( i ) & " - "
next
for i = 0 to 3
Elo.SelectArcListLine( i )
next
for i = 4 to 7
Elo.UnselectArcListLine( i )
next
Elo.SelectArcListLine( 8 )
MsgBox res
Function UnselectLine
This function unselects an entry in the current view. This function may only used in views, where multiple
selection (e.g. clipboard) is allowed. In the other views (e.g. archive view), it can lead to coincidental results.
Parameters:
Return values:
Function UnselectPostBoxLine
Parameters:
Return values:
Function UnselectSearchListLine
Parameters:
Return values:
This function adds a new image file to an ELO document. Depending on the status of the document the old
image file is overwritten (freely edited), a new version is created (version controlled) or the function is rejected
(no revision allowed).
Parameters:
Return values:
Available from:
Function UpdateObject
With the UpdateObject function you add an entry to the database. The object must first be created with
PrepareObject or have been read from the database. If it is a new object, before saving it the system checks with
IndexText whether it can identify a permitted predecessor object.
int UpdateObject ()
Parameters:
None
Return values:
Function UpdatePostbox
The UpdatePostbox function triggers a repeat collection of the contents of Postbox. As well as the actual
Postbox files, TIFF printer files, network scanner files and Outlook entries are collected too.
int UpdatePostbox ()
Parameters:
None
Return values:
Function UpdatePostboxEx
The UpdatePostboxEx function triggers either a repeat collection of the Postbox contents or you can select one
specific entry from Postbox. As well as the actual Postbox files, TIFF printer files, network scanner files and
Outlook entries are collected too.
Parameters:
Return values:
Function UpdateReplSet
This function lets you start or cancel a new replication set. You will find an example of this under
PrepareReplSet.
Parameters:
Return values:
The UserFlags property contains the user's rights (as a bit mask). An administrator can assign any rights, while
subadministrators can assign only their own rights. If a subadministrator assigns more rights than he or she
actually has, there is no resulting error message; the setting is automatically adjusted.
With the UserGroup property you can check whether a user entry includes a group or one user.
The UserGroups property contains the user's groups (as a sequence of numbers separated by commas). An
administrator can assign any groups, while subadministrators can assign only their own groups. It is the
responsibility of the script programmer to make sure that in this case it is really only groups that are assigned,
not users or unused Ids.
The UserId property lets you find the number of the user data record currently active. Although this property
also allows write access, you should only change this number if you are quite certain what the result of the
action will be (in general there is no reason for the script programmer to change this entry).
The UserKeys property contains the user's keys (as number sequence separated by commas, the key number
paired with the access right). An administrator can assign any keys, while subadministrators can assign only
their own keys. It is the responsibility of the script programmer to make sure that in this case only the available
keys are assigned.
The UserName property lets you read the user name of the user data record currently loaded. This data record
may have been filled, for example, by means of an event either reading or writing it. In this case the ActionKey
property is set depending on the reason for the call (20000: immediately before restoring a user, 20001: after
saving a user, 20002: after reading a user.
The property contains the name of the user that has terminated this node. The name is saved in text form when
the node is closed. So it is also retained if the original user is deleted or renamed in ELO AccessManager.
Available from:
3.00.508
Function Version
Returns the ELO version number in the form MSSBBB. (Example 123456):
This query lets you ascertain that your current ELO version is new enough, in case you are using functions that
were only added in later versions.
int Version ()
Parameters:
None
Return values:
The ViewFileName property contains the name of the document shown in document viewer. It is usually
interpreted in scripts linked to the event "Before showing document". In a script like this, by changing this
property you can get a different document file shown.
See also:
This property lets you query the state of the ELO window.
Values:
Normal: 1
Minimized: 2
Maximized: 3
Not known: -1
Available from:
3.00.218
This function writes an activities entry. If the ActGuid field is empty, a new entry is created, and when a value is
entered in it the data record selected is updated.
Parameters:
Activity: Data record to be written
Return value:
-2 Error writing
-1 No active work area
1 Ok
Example:
Id=Elo.GetEntryId(-1)
if (Id>1) then
guid=Elo.GetGuidFromObj(Id)
res="¿" & guid
res=Elo.EditActivity(res)
MsgBox res
Elo.WriteActivity(res)
end if
Function WriteColorInfo
This function lets you write a color definition from the current ELO color object. The color settings may be set
in advance using the properties ColorInfo and ColorName.
Parameters:
Return values:
KeyNo:
KeyName:
Name of key
Return values:
Example:
Function WriteObjMask
This function lets you write a mask definition. The mask must first have been read with ReadObjMask. If you
want to create a new one, it must be initialized with ReadObjMask(9999).
int WriteObjMask ()
Parameters:
None
Return values:
if Elo.ReadObjMask(NEWMASK)<0 then
MsgBox "Error preparing mask"
else
Elo.ObjMName="ELO Test maske
Elo.MaskFlags=25 ' Version controlled, research+file
x=Elo.WriteObjMask()
if x<0 then
MsgBox "Error No. " & x & " creating new mask."
else
MsgBox "New mask with number " & Elo.ObjMaskNo & " created."
end if
end if
Function WriteUser
The WriteUser function writes the prepared user data record back to the system file. Administrators can write
any users, subadministrators can only write their own users or new users.
int WriteUser ()
Parameters:
None
Return values:
Function WriteUserProperty
The WriteUserProperty function writes a user property in one of the 8 user data fields. Please note that the first 4
fields are reserved by ELO (e.g. for NT naming functions). The fields 5..8 are freely disposable.
This function gives you the option of saving a property value immediately. This is particularly important if the
data is to be saved by a non administrator, in which case the WriteUser function is not accessible. This situation
is achieved by adding the value 1000 to the property number. If you describe the property 5, it is stored
temporarily in the client and only stored permanently with WriteUser. The same property with the value 1005
executes Save immediately. The option is only available for properties 5…8 so a user cannot change any system
settings.
Parameters:
Return values:
Example:
'ExitArchive.VBS
Set Elo=CreateObject("ELO.professional")
if Elo.SelectView(0)=1 then
Id=Elo.GetEntryId(-1)
if Id>1 then
if Elo.Version>300356 then
call Elo.WriteUserProperty(1005,Id)
else
if Elo.ReadUser(Elo.ActiveUserId)>0 then
call Elo.WriteUserProperty(5, Id)
call Elo.WriteUser
end if
end if
end if
end if
'EnterArchive.VBS
Set Elo=CreateObject("ELO.professional")
if Elo.ReadUser(Elo.ActiveUserId)>0 then
StartObj=Elo.ReadUserProperty(5)
if StartObj<>"" then
Elo.GotoId(StartObj)
end if
end if
Available from:
Function WriteWv
Writes a to-do date (set with the WvIdent parameter) from the internal to-do memory to the database. This date
can then be given default values with the various Property functions. A WvIdent with 0 value means a new to-do
date is created. Before completing a new date, the internal to-do memory must be deleted by a ReadWv call with
the parameter 0.
Parameters:
Return values:
The WvCreateDate property lets you read or write the create date of a to-do date that was created. It should say
the current day's date. If you leave this entry blank, it is automatically inserted when you save.
The WvDate property lets you read or write the date of a to-do date.
The WvDesc property lets you read or write the memo text for a to-do date.
This property gives you or sets the date of the to-do, on which the document was seen. It must comply with the
date format currently set in the system, i.e. normally in the form DD.MM.YYYY.
The WvIdent property lets you read or write the internal ELO number of the current to-do date. There is usually
no good reason for changing this entry, which is set with ReadWv or WriteWv.
Function WvListInvalidate ()
int WvListInvalidate ()
Return values:
Values:
0 – No
1 – Yes
The WvParent property lets you read or write the internal ELO number of the archive entry for the current to-do
date. The archive entry may be a cabinet, a folder, a tab or a document.
The WvParentType or WvParentTypeEx property lets you fix the type of ELO entry that is linked to the current
to-do date. With all other values this entry is obtained from the database with WvParent.
For archives with a four-level hierarchy you work with WvParentType; for those with more than 4 hierarchy
levels you use WvParentTypeEx.
WvParentType:
WvParentTypeEx:
The WvPrio property lets you read or write the priority of the current to-date date. There is a choice of 3 values,
1 (important), 2 (normal) and 3 (less important). All other values are automatically set to 2 (normal priority).
The WvShort property lets you read or write the short description of a to-date date. This input is absolutely
essential for a new date; if it is missing the Save operation is aborted with an error.
The WvUserFrom property lets you read or write the sender of a to-date date. This would normally be your own
UserId. If you leave the entry blank, your own Id is automatically entered.
The WvUserOwner property lets you read or write the owner of a to-date date.
Appendix
If you want to work with the "ClickOn" function or superimpose scripts on standard ELO functions, you need
the names of the corresponding menu commands or toolbar buttons. In the list below we distinguish between
buttons and menu commands with the codes "B:" and "M:". The abbreviations in the descriptors have the
following meanings:
"Arc...": Archive view, "Clip...": Clipboard, "Post...": Postbox, "Search...": Search view, "Wv...": To-do view,
"mm..": menu command in main menu, "Kom...": function of ELOkommunal, "...Popup...": menu command on a
context menu, "Plp...": menu command in the Postbox context menu, "...UserBtn...": script buttons
operations...
M:Close Beenden1
M:Edit Bearbeiten1
M:Document... mmDokumentBearbeiten
M:Wrapper text... mmEntryEdit
M:Mark all mmMarkAll
M:Paste to Clipboard mmClipEntry
M:Set authorizations... mmDokKey
M:Delete mmDeleteEntry
M:Create new... NeuerEintrag1
M:Set font color... mmMarkEntry
M:For to-do mmWvEntry
M:Insert MNInsert
M:Copy Kopieren1
M:Add link mmAddLink
M:Collect links mmCollectLink
M:Send documents mmSendMap
M:Receive documents mmReceiveMap
M:System administration Systemverwaltung1
M:Options... mmOptionen
M:Select scanner... SelScanner
M:Select scan profile... SelPagesize
M:As Preview PgSizePrescan
M:User ... mmEditUser
M:Storage masks ... mmEditMask
M:Document paths .. mmEditPath
M:Font color... mmEditMarker
M:Report options ... mmEditReport
M:Key ... mmEditKey
M:Records plan ... mmAZDefinieren
M:Password... mmEditPwd
M:Script... Skriptverwaltung1
M:Keyword lists mmEditBuzz
M:Index lines... mmSwlIndex
M:Version numbers mmSwlVer
M:Comment mmSwlComment
M:Templates... mmTemplate
M:Proxy rules ... mmVert
M:Encryption parameters ... mmCryptParams
M:Workflow mmWorkflow
M:Show active workflows AktuelleAblufe1
M:Notice periods exceeded ... NotifyAlert1
M:Report mmWFRep
M:Overview Report2
M:Define workflow Schemaerstellen1
M:Document Dokument1
M:Scan single pages mmScanPage
M:Scan multiple pages mmMultiScan
M:Attach page to Archive mmArcScanAdd
M:Insert file mmImportPage
M:Save file under GrafikExport1
M:Barcode detection mmBarcode
M:Insert notes ?? Notizeneinfgen1
M:OCR Clipboard mmOcrClip
M:Search Eintrag1
M:Search ... mmEntrySearch
M:search full text mmSearchVT
M:Search post-it note Haftnotizsuchen1
M:Pass to Postbox mmToPost
M:Activate / show mmActivateDoc
M:Check out/ edit mmEditActivateDoc
M:Print... Dokumentdrucken1
M:Check in CheckInMain
M:Send mmSendMail
M:View Ansicht1
M:Another view WeitereAnsicht1
M:Close view mmCloseView
M:Free arrangement mmArrangeFree
M:Arrange side by side mmArrangeSide
M:Arrange one on top of the other mmArrangeTop
M:Zoom Zoom1
M:Zoom 25% Zoom025
M:Zoom 50% Zoom050
M:Zoom 100% Zoom100
M:Maximum width ZoomWidth
M:Fit ZoomUser
M:User defined ZoomUsr
M:Rotate Drehen1
M:90° mmDrehen090
M:180° mmDrehen180
M:270° mmDrehen270
M:Maximize VollBild1
M:View Ansicht2
M:Archive mmGotoArc
M:Clipboard mmGotoClip
M:Postbox mmGotoPost
M:Search mmGotoSearch
M:Tasks mmGotoWv
M:Messages mmGotoMsg
M:Paper records administration mmGotoAkten
M:In preparation mmGotoCI
M:Previous page PagePrev
M:Next page PageNext
M:First page PageFirst
M:Last page PageLast
M:Update mmRefresh
M:Improve quality mmScaleToGray
M:Sort list mmSortList
M:Manual SortUser
M:Alphabetical SortAlpha
M:Inverse alphabetical SortAlphaI
M:Store date SortADate
M:Store date (inverse) SortADateI
M:Document date SortDDate
M:Doc. date (inverse) SortDDateI
M:Adjust toolbar... Toolbarskonfigurieren1
M:Help Hilfe1
M:Use Help ... HelpOnHelp
M:Contents... HelpContent
M:About the program... HelpAbout
M:Go to SlpGoto
M:Remove from list SlpRemove
M:Other references slpRefs
M:Start ad hoc workflow ... srAdHocFlow
M:Document data SlpDokumentendaten
M:Edit ... SlpEditDoc
M:Check out/ edit ... mmSlpCheckOutExec
M:Activate/ view ... SlpViewDoc
M:Print SlpPrintDoc
M:Check out document mmSlpCheckOut
M:Version history ... SlpDocHistory
M:Save file under ... SlpExport