Documentation for vtwidget
API Documentation for the vtwidget system
Written by Bruce M. Corwin
A. Description
This system is a new widget called Vt it emulates a VTXXX
DEC style terminal plus many other special GUI type
functions that can make a text based application look like
a full fledged Motif application.
B. Functions List
This routine is the accept_focus method for the VT widget. It always accepts
focus. This routine is called from the widget code in several places.
This function is used to change the appearance of a
hyperlink section of the screen. This section is
any section that has the same attributes as the
HyperAttributes resource. This change in appearance
is meant to represent that at the lifting of the
left mouse button the hyperlink will execute.
This action begins either a selection or a hyperlink
transaction. This depends on what events follow.
This function is called whenever a change is made to
one of several colors defined in resources. Several
of the Graphics Contexts have related colors. For
instance, the inverse_GC has the background pixel
color set to the same value as the normal_GC has
for its foreground pixel color.
This function is called when a change to the VT font
has been made. This requires that all Graphics
Contexts that use the font are changed accordingly.
This function is specificaly used to change the
colors of the special font.
This function is called when a change to the special VT font
has been made. This requires that the special Graphics
Context that uses the font is changed accordingly.
This routine is called as an action to Copy to the X11 clipboard.
This function is used to create a cascade button on a popup menu.
This function is used to create a basic button option on a popup menu.
This function is used to create a separator on a popup menu.
Destroy is used to free up the screen data and
also perform any other clean up activity.
DrawHighlight draws the highlight for the current
XmVtWidget.
DrawShadow redraws the shadow for the current
XmVtWidget.
This routine performs several functions. It is used
to end a Hyperlink type transaction, and it also is
used to finalize a selection. A selection can be one
of two types: a select on an area or a select on a
word. The hyperlink transaction is executed by the
ExecHyper function.
This function is used to change the appearance of a
hyperlink section of the screen as well as execute
the link. This section is any section that has the
same attributes as the HyperAttributes resource.
This event is called any time that a change in focus is made concerning the
widget. If focus is leaving unhigelight if entering highlight, and set the
has_focus flag appropriately.
FontListToFirstFontStruct
This routine obtains the first font structure from the provided XmFontList
data. It does not provide any other font data besides the first font
structure.
This routine does the proper calculations to
convert an X coordinate pixel to a character
screen column value.
GetColumnsFromWidth is used to obtain the number of
appropriate columns for the widget derived from the
pixel width.
GetHeightFromRows is used to obtain an equivilent
pixel height of the widget from the number of rows.
This is usualy used to try to reset this height.
This routine does the proper calculations to
convert a Y coordinate pixel to a character
screen row value.
GetRowsFromHeight is used to obtain the number of
appropriate rows for the widget derived from the
pixel height.
GetWidthFromColumns is used to obtain an equivilent
pixel width of the widget from the number of columns.
This is usualy used to try to reset this width.
This routine does the proper calculations to
convert a column value to an X pixel coordinate.
This routine does the proper calculations to
convert a row value to an Y pixel coordinate.
Initialize is used to intialize the screen
data structures and other XmVtWidget data
structures.
This routine is called as the mouse moves over the
Vt widget. It is used to change the cursor if the
cursor is over a hyper-link attribute character
area.
This function is used to find all the needed Graphics
Contexts for the widget.
This routine creates one GC for future use. This is called for each GC used
in the widget.
This routine is used to perform a paste operation
for the X window system.
This routine is called as an action to Paste from the X11 clipboard.
This function is the callback for all of the basic and cascading menu buttons
for a popup menu in the Vt widget.
This function displays a dynamic menu.
QueryGeometry is used to respond to the X server when
it asks about various geometry arrangements.
Redisplay is used to redisplay the XmVtWidget after
being covered.
Resize is used to reallocate the screen geometry to
the new arrangement. It will clear any new area and
retain old area.
This routine performs an Atomic selection on an area
that is a rectangle formed by dragging the first
mouse button.
This routine performs an Atomic selection on one word
on the screen. This word is identified by having
separating spaces around it.
This routine is called when a send mouse event is requested. It sends the
mouse cursor information to the character based application (such as elvis).
This routine is used to set up the initial menu 'stub'. It prepares the base
menu shells and menu widgets and performs various initialization tasks.
SevValues is called whenever the user application
needs to change any resources.
SpecialCharEvent is used to capture three special
key events that seem to never get to the tranlation
table. These are Escape, Return and tab I try to
keep this routine as quick as possible to prevent
wasting time. This routine is unavoidably called
every time a key is pressed.
This routine is used to store the main menu shells for a complete heirarchial
menu structure. These menu shells are then used to destroy the completed menu
when the XmVtUnloadPopup function is called.
This routine is used to add an option onto the current menu. It can add a
regular option, a separator or a cascading button. This can be done for either
a popup or a pulldown menu.
StringInput is similar to SpecialCharEvent except
it is meant to be called as an action and it handles
all the other keystrokes besides what
SpecialCharEvent handles. Please note that String
input specificaly ignores those keystrokes that
SpecialCharEvent handles.
UnDrawHighlight removes the highlight for the current XmVtWidget.
UnDrawShadow removes the shadow for the current XmVtWidget. This is useful
for prototyping gui user interfaces using the escape sequences. It removes
a distracting border if one is not desired.
This routine looks alot like the XDrawRectangle basic XLib function except that
it uses an upper left and a lower right GC to create a shadow effect on the
area bounded.
This function appends a line of text to a child list widget of the Vt widget.
This line of text is appended to the bottom of the data.
This function appends a line of text to a child text widget of the Vt widget.
This line of text is appended to the bottom of the data.
This routine unmanages all Vt child widgets. This is similar to a clear screen
except it is for the special case of widgets.
This routine is used to resize a child widget using the normal rows and columns
type values of the screen coordinates.
This routine receives the vtwidget name, a child identity character, a
resource and a value for the resource that will be set. With this information
it properly sets the given resource for the child widget.
This routine copies selected data to the Clipboard from the Vt Widget.
This callback is called whenever a drag/drop operation deposits data on the Vt widget.
This routine sends all the data from a text widget to the keyboard input queue
of the parent Vt widget. The child text widget is identified by the character
identity code provided as argument 2.
XmVtFlush is an externaly callable routine that
is used to clear the keyboard buffer of all
characters. This can be used if a user would
like to utilize the data in an Activate
callback structure instead of using XmVtRead.
This routine is the normal method for programers to load a section of text to
be fed back to the keyboard at the activation of a PushButton.
This routine is the normal method for programers to load a section of text to
be fed back to the keyboard at the activation of a hyper text link.
This routine is the normal method for programers to load an icon file into a Pixmap. The identity
is a single character that when printed with an attribute of graphics will output an entire
icon image. An icon can be either a XBM file or XPM (On Motif 2.0 or greater).
This routine will create all of the menus provided in the referenced menu
file and will make the referenced root menu the base popup menu.
This routine is used to prepare a particular widget for plotting on the
screen. It does not begin managing the widget however. That is done when
it is actualy plotted.
XmVtMonitor is an externaly callable routine that
is used to monitor a file descriptor that is
connected to an open pseudo terminal, socket or
even a serial line device.
It properly sets up the periodic checks on the file
descriptor and sets up a handler for the death of
children. A pid of XmCR_VT_NOPID can be sent in
to the input pid and this will prevent any signal
handling.
This routine is called from all Pushbutton widgets when they are pressed. It
is a callback routine.
This routine pastes data from the Clipboard into the Vt Widget.
XmVtRead is an externaly callable routine that
is used like the read system call except it
accesses a XmVtWidget instead of a file
descriptor.
This function is used as the Decrement callback to the internal scrollbar.
This function is used as the Drag callback to the internal scrollbar.
This function is used as the Increment callback to the internal scrollbar.
This function is used as the Page Decrement callback to the internal scrollbar.
This function is used as the Page Increment callback to the internal scrollbar.
This function is used to set the scroll value of the VT
widget.
XmVtSend is an externaly callable routine that
is used to send characters to the keyboard
buffer manually. When this is done the Activate
callback is called.
This function is used before the main application is
realized to coordinate its width and height with the
VT widgets columns and rows. This is very useful in
cases where the VT widget is the main widget in the
application and should have a specified number of
columns and rows for any given font.
This routine is called from all Togglebutton widgets when they are pressed. It
is a callback routine related to any change in value for a toggle button.
This routine is called from all TextField widgets when they are pressed. It
is a callback routine.
This routine performs the actual transfer of data from the drop to the keyboard
input.
This routine will remove a previously created Vt Popup menu created with the
XmVtLoadPopup routine. It frees memory and destroys menu widgets. This routine
is used when either of the resources RootMenu or MenuFile are changed. This
should be called before a new XmVtLoadPopup is called.
XmVtUnmonitor is an externaly callable routine that is used to end a monitoring
activity on a Vt widget. If a process is presently being monitored that
process is first sent a SIGTERM signal as a friendly request for ending.
If the process is still present (as in the case of a shell like /bin/ksh) a
SIGKILL is then sent. Next the descriptor that is being monitored is closed and
set to the value of 0. Also the monitoring flag is set to False and the pid
internal resource is set to XmCR_VT_NOPID. At that point the monitor callback
list is called for any other clean up the application might wish to perform.
XmVtWrite is an externaly callable routine that
is used like the write system call except it
accesses a XmVtWidget instead of a file
descriptor.
This function is called when the SetValues or Initialize find that the scrolled
flag is set to true. It creates a scroll bar on the right side of the Vt
widget. It also sets up all of the internal callbacks.
This routine is used to allocate the memory used for the VTLINE array used
to store the screen information.
This function sends the answerback message to the input keyboard queue. This
routine is called when a character 5 (answer back) is interpreted.
Produce an audible tone. This is a routine called by
the screen system, and is located in the graphics
subsystem.
Check to see if the cursor is at the bottom edge if
true scroll up one line.
This routine calculates the main internal translation
weighting facter for determining RGB values.
This function is called right before a control sequence that will change the
cursor position. It cancels a preparation for autowrap that might be in
progress.
This routine is one of several routines called by
the screen subsystem. It is used to change the
colors of the VT terminal. It changes the
appropriate resources to emulate the changes a
VT240 might make.
This function is used to resize the screen from escape sequences. This is
used by standard ANSI escape sequences.
This function is called whenever a free chunk of
processing time is available from the Xt event
processing subsystem and when a file descipter is
being monitored as a call to XmVtMonitor. It
checks the file descriptor to see if output needs
to be printed on the VT widget.
This function is used to chop an input buffer up into as large of blocks as
possible that can be digested for output into the widget screen data. The
bigger the chunks the better the performance because these routines are called
often because of the fact that this is the main data stream.
Clear from begining of line to the cursor.
Clear downward from cursor.
This routine clears the screen up from the cursor
position to the first character position of the
screen.
This function clears the appropriate bit in an attribute.
This routine is used to collect preprocessed lines that have already had
comments and blank lines removed.
This routine is used to convert strings that have internal escaped characters.
These include the escape, return and null characters.
This routine is used to respond to queries about what
kind of data does the widget support for selection
conversions. It also actual sends data to other X
clients that have requested a converted section
of selection. TARGETS is the atom that is used to
respond to queries about what kind of target this
widget can convert to.
This function moves the cursor backwards.
This function moves the cursor down.
This function moves the cursor forward.
This function moves the cursor to a specified location.
This function moves the cursor up.
This routine is used to clean up a section of the screen that is blank
area but that might get clutterd with extrainious graphics. This is caused
by the sizing process of the widget. Sometimes the widget just does not get
exactly the height that it needs, it gets more. This causes dead space at
the bottom of the widget just below the last row.
Delete any number of characters from the cursor forward.
Delete any number of blank lines starting at the current
cursor.
This function is called every 400 milliseconds or so (as long as there is some
processing time available) to toggle the blink on blink type attribute
characters on the screen. It toggles the switch and then sets the modified
switch on all such characters on the screen. The routine plot will see these
characters the next screen update and toggle their images.
This function works similar to tmpnam (on which it relies) except for two
differences. First, it does not take any parameters like tmpnam. It returns
the value directly. Secondly, it returns a dynamic value that must be freed
after use. This allows saving the value for future use such as deleting the
file.
This routine is used to intiate eight bit emulation.
Normaly this includes at least a load of the default
color maps. Since this 'terminal' ceases to exist at
the end of its usage there is no default set of
colors. Therefore at this time this routine does
nothing.
This routine is used to equalize rgb values that are
out of range. This occurs when large values of
luminance are specified. The color is basicaly made
more white by spreading this extra intensity to the
other normal ranged colors.
Execute the commands associated with an escape sequence.
This routine determines what token should represent the current command. It
returns a -1 if the command is not a supported command. It returns the index
number for a supported command.
This routine is used to fix up an escape sequence that
has a 'alternative' format for the numeric parameters.
Anyway, this alternative format involves no values in
the area where you would expect them such as:
ESC[;7H which means go to column 7 in the first row.
free_data frees all allocated dynamic memory associated
with the screen. It also frees other dynamic allocations as well as closes
some files that may be open.
This routine is used to clean up all dynamic memory used by a menu type
structure.
This routine is used to free all of the allocated memory in a VTLINE array.
A VTLINE array is the memory structure used to store all of the screen
information.
This function gets the attribute section of the screen
buffer.
This function gets the character set section of the screen
buffer.
This function gets the data section of the screen buffer.
This function gets the modify flag section of the screen
buffer.
This function gets the line attributes for a line of the screen.
Obtain a Blue rgb value from hue, luminance and
saturation.
Obtain a Green rgb value from hue, luminance and
saturation.
Obtain a Red rgb value from hue, luminance and
saturation.
This function is used to find the host address of the current node.
This routine is used to plot high resolution graphics at a specified
location. These graphics are in Xpm format. Please notice that this
routine protects sections of the screen from further plots. This may
block out some text if graphics is located at the same text coordinates.
Scroll up lower part of the screen up to the cursor.
This function compares two attribute variables to determine if they have any
matching set attributes.
init_data initializes all the internal data structures
for the screen. It allocates space sets the cursor in
places and clears the screen.
Insert any number of spaces at the current cursor.
insert_char inserts one character at the current position.
It will move characters out of the way to make room for
the character to be printed.
Insert any number of blank lines at the current cursor.
This function is true if any attributes are set in an attribute variable.
This function is true if the two provided attribute variables have the same
attributes set.
This boolean check determines whether a character is
one of those which forces a set RGB value to be loaded
into a terminal colormap.
This function is true only if there are no attributes set in an attribute
variable.
This routine finds those characters that are non viewable for the Vt widget.
it returns True if the passed character is not viewable. The general rules
for the vtwidget is to not print any characters less that character 28 except
for character 22. The reason for this set up is to allow the printing of
DOS ANSI graphics characters (something rxvt and color_xterm do not do).
There still may be some DOS ANSI graphics characters not printed, I have no
references here. I just test with a nice ANSI artwork file I found.
This function is a boolean function that determines if a particular bit is
set in an attribute.
This routine is used to load a given menu file to derive a dynamic popup
menu for the Vt widget right hand mouse press action.
This routine is called when the Primary selection is
lost on the X server. This means that the VT widget
must clean up the highlighting representing the
selected data because it no longer is truly selected.
make_lines takes a string of characters and converts
them to the proper line drawing characters.
message parses an escape sequence that is sent to provide
a message to the terminal. This message is stored in the
vt structure.
This function calls the special callback for the message escape sequence.
When a message is sent to the Vt Widget this routine is called and then
the callback message_callback is executed.
This function handles those cases of setting more than
one character attribute at one time with the attribute
sequence. Unfortunatly this routine is short because
it is recursive it calls execute_esc to set the
proper attributes. This can be changed if this is
not proper. I do not mind recursive code if its easy
to read. However it can be hard to read if it is
complicated. This is not.
This function begins a new line. It does not need to check any modes unline
the normal carriage return. It is basicly a carriage return/ line feed.
Execute the non printable character actions like
Carage return, line feed and escape.
This routine is called to OK a total revival of all characters on the displayed
screen. This is used when a scroll has taken place. This causes the
update_image routine to call revive_all. This is an API call that is used by
screen.c.
This function is called to authorize an update to the screen whenever the
X system finds some extra time or imediately if smooth_mode is TRUE.
If smooth_mode is FALSE, this does not actualy perform the update
to the screen, it just sets the wheels in motion by setting the appropriate
flag in the widget. This is an API call for screen.c to use.
This routine is the callback for the Paste routine.
It is called when the X Server is ready for the
actual data transfer. It performs the actual paste
of data. In this case it simple sends the data to
the keyboard queue.
This routine paints the current data to the output device. It accesses the
memory structures of vt.vtscreen directly so if any changes are made to
these structures coorisponding changes need to be made here.
This routine is rather
hard to understand, especialy if you do not understand how Vt.c is processing
information it receives from screen.c. It has been optimized to accelerate the
painting of data on the Vt widget window. This is my only excuse for such
hard to read code. I basicaly loop through the data line by line column by
column looking for modified data (S_MOD). I then try to find similar chunks
of screen info (same attributes and cset) and plot them with the plot routine.
At some point another optimization will be to simply plot the data directly
from the vt.vtscreen area instead of memcpy-ing it to a pldata area. This
memcpy takes a little time when you are looping it so much. This routine
was originaly in Vt.c but was moved to this module when it was rewritten to
access screen data structures directly. It is now a low level routine even
though it calls the plot routine in Vt.c.
This routine properly decodes complete DEC color
sequences for setting terminal color maps. These color
maps are a different type than the X color maps. They
are related specificaly for DEC VT240 type color usage.
parse_esc isolates an escape sequence to be later
executed by execute_esc.
This routine properly decodes just the Hue, Luminiance
and Saturation part of a DEC color sequence. It returns
the X RGB color value that is appropriate. It also
finds which terminal color map to load with the new
color.
Find all the commands and parameters on a line and place
these into string arrays for future parsing.
Place the cursor in a specific location.
This is a routine called by the screen system,
and is located in the graphics subsystem.
Plot a string in a specific location. This is
a routine called by the screen system, and is
located in the graphics subsystem.
This routine is used to process each line of the vtrc file individualy. It
scans each line for various pieces of information such as menu name, command
to execute on that menu item, data to operate upon and a description for
the menu item.
This function will protect an area of the screen from having text data
written to it. This is used to protect graphics areas. If this was not
done text would overwrite the graphics.
This routine is used to trim white space characters from the end of
a string.
This routine is used to trim only the space character from the end of
a string.
This function checks a file descriptor to find if
it is ready to be read from. This is used as a
non-blocking mode check on a file descriptor.
Remove the cursor from a specific location.
This is a routine called by the screen system,
and is located in the graphics subsystem.
This function destroys the scrollbar widget when SetValues finds that the
scrolled flag has been set to false.
This routine reserves a range of lines on the screen
for scrolling. This permits localized scrolling of
part of the screen. This is commonly used in editors.
Reset initializes all of the soft parameters for the
screen. This includes where the cursor is and clearing
the screen as well as setting insert and attributes.
This function clears an attribute variable.
resize data changes the values of the rows and columns
of the screen. It does some dynamic memory changes
and ensures all memory is accounted for.
Insert one line at the cursor.
This function revives any character on the screen that
is visible. This is done for a redisplay.
This function is used when there has been a scroll or
several scrolls that have taken place during a write.
To make the widget use its time best it will only
mark all screen bytes as modified only if a scroll has
occured and it will only do this at the end of the
write. To demonstrate, consider a buffer full of
line feeds. If the widget looped the entire screen for
each line feed there would be millions of iterations
of the marking loop while, by using revive_all, there
is only a single marking of the entire screen.
Check to see if the cursor is at the right edge, if
true move to next line.
This function sets the attribute section of the screen
This function sets many characteristics across a defined section of a line.
It will set the data, attributes, and character set information for a whole
line if necesary. This function is built to provide optimization for
the many calls made to clear lines or set lines to a particular value.
This function is used to copy one line to another line using the memcpy type
functions. This function is used for optimization of reverse index and
scrolling type functions.
This function sets the character set section of the screen
buffer.
This function sets the data section of the screen buffer.
This function sets the modify flag section of the screen
buffer.
This function sets the line attribute for a line of the screen.
buffer.
This routine works a little like a combination of s_data, s_attr, s_flag and
s_cset. It also works with a complete string. It adds multiple components
to the vtscreen element of the Vt widget. This routine could probably also
be named add_string because it works alot like insert_char except it adds the
data instead of inserting it and it adds a full string of characters.
This routine can only enough characters to fill a line. If more characters
are sent to it than what it needs to fill a line it will ignore them. It does
however return the number of characters it actualy outputs.
This function fills the screen with 'E's. This is used as a self test for
most DEC terminals.
Send_keys is used to send data to the input buffer
of the widget from a non-keyboard input method.
This function sets the appropriate bit in an attribute.
This routine is called from the screen command interpreter to cause the Vt
widget to output a graphics image to the screen. The vt.graphics_name element
of the widget has the filename of the graphics image.
This function removes all extranious spaces or tabs and
replaces them with a single space or tab. EXCEPT within a
double quotes delimited string. This is how this function
differs from the regular singlespc function. It also adds a
simple mask to be used by other functions that will be a
string of Xs where a string resides in the original input
string.
This routine is a Special string compare that works
alot like strncmp except that ; characters are removed
from the first string before the comparison is made.
This basicaly means that the ; character is ignored.
This routine parses an escape sequence that is sent to provide
a special_message to the VT widget. This message is a command sequence
that is used to access special features such as GIF picture loading.
This function is used to service a special message. These special messages.
can have a variety of commands directed towards the widget.
Concatenate a character to a string.
This routine works exactly like strcmp except that the comparison is case
insensitive. (Notice the 'ci' in the name.)
This routine works exactly like strncmp except that the comparison is case
insensitive. (Notice the 'ci' in the name.)
This function translates a string of attributes into a value to bitwise OR
into an attribute varable. This is used for instance to set the Hyperattribute
resource from string values.
Sub process an 'escape[?ParmsCode' seqence for parameters.
Most of these will be hard coded in the execute_esc
function. Only those that are not being processed will
end up here.
This routine is used to sub process an 'escape[Pal' type escape sequence.
This type sequence is used to behavior mode type flags in the emulation
typicaly. A subcode of l means to reset the flag. A subcode of h
means to set the flag and a subcode of $p means to report the flags
state back to the host.
Sub process an 'escape[ParmsCode' seqence for parameters.
Some of these will be hard coded in the execute_esc
function. Several heavily used functions like relocating
the cursor are located here.
Make sure that the screen cursor is not outside the bounds
of the screen.
This function clears a tab at the current cursor location.
This function clears all tabs.
Tab over to the next screen defined tab.
This function sets a tab at the current cursor location.
This function is called when a client is done
transfering a selection into its application. The
routine is not used in this widget.
unmanage_unpainted_widgets
As its name implies this routine searches the child widget list to find all
those widgets that have not been plotted on the current Vt widget. When
it finds one it unmanages the widget.
This routine is called repeatedly whenever possible every TOUT # of
milliseconds. It repaints the screen to the current state and places the
cursor in the appropriate coordinates. It then reschedules itself in another
TOUT # of milliseconds.
This routine is used under several circumstances to update the scrollbar on
the right hand side of the Vt widget. These circumstances might include a
change in background color or a change in the number of rows.
This routine is called by the signal handler for
SIGCLD. It sorts out which child to which widget
has just died. It then sets the appropriate flag
in the proper widget.
This routine is used to place widgets at a specified
location. These widgets are standard Motif widgets. Please notice that this
routine can only place one widget of a given identity a very odd effect can
occur if a particular widget is plotted twice on the same screen.
write_s works just like write except no file descriptor
is passed because write_s only writes to the screen.
This function checks a file descriptor to find if
it is ready to be written to. This is used as a
non-blocking mode check on a file descriptor.
C. API Varables List
String to substitute if s directive is found.
This is the application name to obtain the popup menu for.
Attribute number 1 for compare.
Attribute number 2 for compare.
Attribute data in string format.
This is the background Pixel for the new GC.
This variable defines callback reasons.
This is data to be sent if the button is activated.
This is a single character.
Client data passed to callback
Input data from the drop. In this case the parent vt widget.
This is the command string to evaluate.
Count of characters to write
This is a boolean value sent to the dynamic instantiation routine.
Thickness of the edge or shadow to draw.
This is the destination line to copy to.
Elements parsed from line.
String data to extend the value of the text widget.
This is the font list to examine.
This is the foreground Pixel for the new GC.
This is data to be sent if the hyper link is activated.
Identity of the element. This is a single character that will identify the
element on the screen.
Column to convert to a pixel X coordinate
Row to convert to a pixel Y coordinate
The name of the icon to load.
This is the special message command and data.
Label for a button on the menu.
Line attribute information.
This is the location of the menu file.
This is the main menu array to create sub menus with.
This is the full path to a menu file to load.
This is the new menu information structure.
The new popup menu stub to add options to.
This is the new font for the new GC.
Number of actions to take
Plotting attribute value.
Parent widget for new menu.
Post-printed tag data from a text widget.
Pre-printed tag data from a text widget.
This is the menu that should be the root menu.
Count of rows in 2D array
Second string to compare.
Selection type of transfer.
This is the widget that is sending the callback.
Menu shell widget to store away in the Vt widget.
Signal number provided to the signal handler by UNIX.
This is the source line to copy from.
This is the input string to single space.
Actual string width of strings
Target type of conversion
Type of selection returned
Value to set resource to.
This is a menu structure to free.
This is the current vtscreen to manipulate.
Character width of widget to realize.
Input widget to callback.
Widget to be used for processing.
Character height of widget to realize.
The type of widget to realize.
X coordinate one is the left X coordinate of a protected box
X coordinate two is the right X coordinate of a protected box
Y coordinate one is the top Y coordinate of a protected box
Y coordinate two is the bottom Y coordinate of a protected box