MultiView Mascot Support

How to: Use SDE

Overview

This bulletin contains a description of MultiView Mascot’s Static Data Exchange (SDE)and how it can be configured to run with applications.

Contents

* Introduction to Static Data Exchange

* Configuring Accelerator Keys

* Configuring SDE and Applications

* Configuring the Daemon

References

The SDE process is referred to in the Release Notes for MultiView Mascot, this also refers to several sections in the Configuration Guide.

Static Data Exchange

Static Data Exchange (SDE) provides the capability to enable data to be transferred from specified fields in a source window, formatted and then output to a target window. SDE is made up of three different stages:

CUT  The selected data is copied from the current window and passed to the clipboard for transferring.

PROCESS  The data is passed through a PIPE into a daemon, where it is formatted for the output.

PASTE  The data is pasted onto the receiving application.

When the CUT process is executed, MultiView Mascot copies the data from the specified fields into the cut pipe, ( this pipe can be configured by the user). The data goes through the pipe and into a SDE Daemon,(which is a user written script) this is where the data is formatted into its output form. The formatted data is then placed in the pipe "mvpipe.$$" (this pipe is created in the /tmp directory by MultiView Mascot, the $$ refers to the individual Process ID). The data will remain in this pipe ("pipe.$$") until a PASTE is executed, (from MultiView Mascot) and then the information is copied into the application.

To be able to use the SDE Cut and Paste, several configuration stages must be completed first.

* Configuring the accelerator keys and menu functions

* Configuring Applications

* Configuring the Daemon and the Pipe

Each one of these will be looked at in the following sections.

Configuring Accelerator Keys

MultiView Mascot allows the configuring of accelerator keys, to speed up the process of SDE cut and Paste. They can be added to the mvw_termcap file under the relevant terminal description.

Mnemonic KCT=string
Description :SDE cut. The default value is ESC -

Mnemonic KCT1=string
Description :Alternative SDE cut. The default value is ESC -

Mnemonic KPS=string
Description :SDE paste. The default value is ESC +

Mnemonic KPS1=string
Description :Alternative SDE paste. The default value is ESC +

Example:

To enable the following keys for SDE

SDE Cut Escape + 'C' or 'a' + '1'
SDE paste Escape + 'P' or 'a' + '2'

The mvw_termcap file entry

:KCT=\E[c:KPS=\E[p:\
:KCT1=a1:KPS1=a2:

SDE cut and Paste can also be called from a menu by using the following functions on a command line within the MultiView Mascot.rc file.

Menu Command: f.sdecut
Description: implements an SDE cut

Menu Command: f.sdepaste
Description: implements a SDE paste

Configuring SDE and Applications

SDE can also be configured to run with a specific applications from the menu. The following syntax must be used.

"MenuOption" "co-ordinates" "Parameters" "f.exec" "application-Name"

The following is a list of the SDE parameters that can be configured on a menu command line.

Parameter:   -C X Y length
Description:   This specifies an area of the application window to cut. Where X and Y are the co-ordinates of the mark to start the cut from. The length refers to the number of characters to cut. The flag must always be followed by three numeric parameters. Up to 24 areas can be specified.

Parameter :   -P[pipe name]
Description:   This is used to specify the pipe name that the cut operation will place the text in.

Example

The following is an example of a Rootmenu command line to open up a vi session for cut and paste;

"Vi with SDE" 01 01 24 39 -C 2 1 20 -C 4 1 20 -P sde_pipe f.exec vi

The following is an example of a Rootmenu in MultiView Mascot, that has an applications set up to use the SDE cut and paste.

Example Rootmenu.

#RootMenu
" Root Menu " f.title
" &Clients -> " f.menu ClientsMenu
" &Shell " 06 10 18 55 f.exec /bin/sh
" &Refresh " f.refresh
no-label f.separator
" SDE Cut " f.sdecut
" SDE Paste " f.sdepaste
no-label f.separator
" Vi Cut session " 01 01 24 39 -C 2 1 20 -C 4 1 20 -C 6 1 20 -C 8 1 20@0E@@0E@ @07@-P sde_pipe f.exec
" Vi Paste session" 01 41 24 79 f.exec vi
" &End Session" f.quit_mwm
##

The above example has an application set up for SDE Cut and Paste, the Vi session will cut four different parts of the screen, when SDE is executed. The co-ordinates of where it will cut are issued on the command line with the -C flag. The -P flag specifies the pipe that the SDE Cut should use. The f.exec is the application that will be run, in this case a vi session editing the file sde_source.

Configuring the Daemon

The Daemon is a script program that formats the data it receives and then places it into a pipe waiting for the Paste function to be called. The script file will create a pipe and Daemon and give the Daemon information on how to format the data. Before you can write a Daemon, you need to know how information is passed from the cut process into the pipe.

When a cut is processed, it copies the data into a pipe. It will write the information as one long line of data. It splits up the data by sending an escape, between each field it receives, (a field is each separate -C parameter used). The pipename (mvpipe.$$) is sent first so the Daemon knows where to send its output to.

Pipename<esc>field1<esc>field2<esc>field3<esc>field4....

The Daemon must split this information up, it does this by looking for the <esc> sequence and then storing the information into a variable.

pipename='echo $DATA|awk ' { FS="\033" } { print $1 } ' '
field1=`echo $DATA|awk '{ FS="\033"} { print $2 } ' '

The variable 'pipename' is created by echoing the $DATA (data in the pipe) until it reaches the first <ESC>, the { FS="\033" } tell the Daemon that the field separator is an <esc>. It then prints out the data before the escape into the variable.

When the data has been divided into the variables, it must be echoed into the pipe (mvpipe.$$), to await a paste. This is done by using an echo.

echo "i\n$field4\n\n$field3\n\n$field2\n\n"| tr "[a-z]" "[A-Z]" >$pipename

Any text you require can be inserted in the echo statement, as shown above the 'i' is inserted to ensure that when the data is pasted into VI is will be in insert mode. The '\n' is a sequence to start a new line. The variable names must be prefixed by a $ e.g. $field1.

The '|tr "[a-z]" "[A-Z]" changes the case of the text it echo's to upper case.

###

## SDE Example daemon. sde_daemon sde_pipe &

###

:
if [ "$#" -ne 1 ]
then
echo "Usage: $0 pipe_name"
exit 1
fi
#Informs user of command Syntax if
#incorrect
if [ ! -f "$1" ]
then
mknod $1 p > /dev/null 2>&1
if [ $? -ne 0 ]
then
echo "$0: can't make $1"
exit 1
fi
chmod 666 $1 >/dev/null 2>&1
if [ $? -ne 0 ]
then
rm $1 >/dev/null 2>&1
echo "$0: can't chmod $1"
exit 1
fi
fi
#Checks to enure that pipe can be
#written, and then creates the pipe files.
trap "rm $1;exit 1 > /dev/null 2>&1" 1 2 4 9 15
while :
do
read DATA < $1
if [ -n "$DATA" ]
then
pipename=`echo $DATA|awk '{ FS="\033"} { print $1 } '`
field1=`echo $DATA|awk '{ FS="\033"} { print $2 } '`
field2=`echo $DATA|awk '{ FS="\033"} { print $3 } '`
field3=`echo $DATA|awk '{ FS="\033"} { print $4 } '`
field4=`echo $DATA|awk '{ FS="\033"} { print $5 } '`
#This is where the data is split
#into fields and then echoed
#to the pipe.
echo "i\n$field4\n\n$field3\n\n$field2\n\n"| tr "[a-z]" "[A-Z]" >$pipename
fi
done

The example script above is called SDE_Daemon and it must be executed with the pipe name that it will create. This should be the same as the pipename used with the -p on the menu command line.