last update 03 sep 98 / greg goebel / public domain / vwv_5_0
* This document provides introduction notes on the VEE 5.0 release in the spring of 1998.
* The VEE 5.0 release contains a number of enhancements. The most important
of them are the following three:
To support the new ActiveX features, VEE now has a third mode of operation.
The modes are now:
Other enhancments include a function to save panel images into graphics
files; improved clipboard support; revised graphics display objects; updated
sliders, knobs, and indicators; a multiline formula box; improved memory
management; and a number of other small improvements.
The ActiveX features are not supported on HP-UX, as the operating system does
not support them. The Web server capability is supported on HP-UX. As with
all major revisions of VEE, programs created in VEE 5.0 cannot be loaded on
earlier versions of VEE.
* VEE 5.0 is on the 1 May 1998 CPL and should be shipping presently. Bits
will be available for HP support people as soon as they are validated. There
are a few important changes in pricing from VEE 4.X:
The catch for this is that VEE 5.0 has stronger serial-number protection
than earlier versions of VEE ... you must already have a valid
serial number to upgrade.
Ordering information is as follows:
* ActiveX Controls are essentially third-party "widgets" that can be
integrated into any package that supports the protocol. Such widgets might
include specialized graphics objects (such as 3D charts or waterfall
diagrams), multimedia tools for video or audio presentation, statistical
analysis packages, interface libraries for data-acquisition cards, and so on.
Thousands are available as shareware or commercially.
ActiveX Controls are conceptually very similar to the Visual BASIC Extension
(VBX) controls that were available for Windows 3, but are 32-bit
implementations, not 16-bit implementations. Unlike VBX controls, they can
be used with many applications (as long as they are ActiveX compliant), not
just Visual BASIC.
As with ActiveX Automation, a VEE user can select among ActiveX Controls, and
having selected one can use formulas to access the control. While the
controls are part of the VEE program, they are not wired into the program as
such, since they don't obey VEE control flow rules; but they can be easily
controlled through formula boxes.
Note that if a user creates a VEE program using ActiveX Controls, the
libraries for the controls have to be shipped along with the program, under
the licensing arrangements defined by the vendor of the controls.
* For an example of how to use ActiveX Controls with VEE, I went out on the
Web to the CNET (www.cnet.com) to find some useful ActiveX Controls that I
could use for a demo.
I found an interesting shareware ActiveX control named Sysinfo, by a Jin Hui
of China. This provided some useful status ("properties") about a PC like
processor type, memory size and so on, and some useful actions ("methods")
such as programmably rebooting the PC.
I unpacked the archive containing the Sysinfo control and got the ActiveX
Control for it, which was named "sysinfo.ocx", where ".ocx" was the extension
designating an ActiveX control. I then ran VEE 5.0 so I could play with this
control.
* The first thing to do in VEE was to "reference" the ActiveX control -- in
essence, make VEE aware of it. I went to the "Device" menu and selected
"ActiveX Control References". This gave me a dialogue box that listed the
available ActiveX Controls:
In any case, I was after the Sysinfo control. I found a Microsoft Sysinfo
control in the list, but this was different from and less useful than Jin
Hui's Sysinfo control, and so I had to click on "Browse" to reference that
item (as it had no installation program, obviously it was not going to be
identified in the Windows Registry). A file browser popped up, and I used it
to cruise through the file system to find and select "sysinfo.ocx".
The list now included "System Information Control". I set the flag to make
sure it was referenced, and then clicked on OK to close the dialog box.
* Next, I had to create an "instance" of the control in my program to play
with. I went to "Device" -> "ActiveX Controls" and selected "Sysinfo". I
got a VEE object labeled:
I could change this name to whatever I wanted, and if I created duplicate
instances of the control they would be given different names such as
"Sysinfo2", "Sysinfo3", and so on, that I could change as well. The names
were simply "handles" to the particular instance of the control.
* Once I had an instance of the control in the program I could then start
to make use of it by adding formula boxes containing the appropriate
properties and methods.
I clicked on the "fx" button on the VEE Toolbar and got the "Function &
Object Browser" dialog (which was named "Select Function" in its VEE 4.0
incarnation). I selected "ActiveX Objects" from "Type", then selected
"Sysinfo" from "Library", and got a list of the Sysinfo properties and
methods:
That's not always the case, and many ActiveX Controls have "events"
associated with them, where a mouse click (or whatever) interrupts the
program. VEE has a mechanism for handling such events.
I was able to find a different control, the Microsoft Calendar control, that
had events and would be useful for a demo. I referenced the Microsoft
Calendar control, then got an instance of it, named:
In any case, this object -- not the Function & Object browser -- allowed
me to set up an event handler. I went to the object menu and selected the
menu entry "CreateEventHandler", and got the dialog box:
As a first step, I implemented the handler to simply pop up a panel to show
off the new date provided by the user, using the Calendar's properties as
obtained through the Function & Object Browser:
* It was easy to modify this program to allow the Event Handler to communicate
back to the main program. I eliminated the Panel View in the handler
UserFunction and changed it to put its text into a Global Variable named
"globalstat":
* ActiveX Automation is a relatively new scheme by which different Windows
programs can communicate with each other. It is conceptually similar to the
old DDE scheme, but is much better implemented.
ActiveX Automation is much more robust, faster, and better documented than
DDE. When applications are installed under Windows, they are "registered" as
ActiveX applications. A user wishing to program VEE as a Windows
"client" application that makes use of another Windows "server"
application can bring up a list of available server applications, and enable
an application for use in VEE.
Then VEE has access to a list of functions for dealing with the server
application. The VEE programmer can create formulas containing these
commands to access the other application.
Note that the new VEE 5.0 ActiveX Automation features allow it to act as a
client. As for server capabilities, those were available in VEE 4.0 through
the VEE ActiveX control. These server capabilities were limited to allowing
other applications to call VEE userfunctions.
* The ActiveX Automation scheme works very much like the ActiveX Control
scheme, and in fact both share the same "object oriented" design philosophy
(under a Microsoft spec known as "COM", for "Component Object Model").
As with ActiveX Controls, the first thing to do is "reference" the
application and create an "instance" of an "object" for it. I went to the
"Device" menu and selected "ActiveX Automation References". This gave me a
dialog box that listed the available applications:
I then selected the "ActiveX Automation" category and the "CreateObject"
function:
Supposing we want to get an Excel spreadsheet, we would then modify this as
follows:
* VEE 5.0 has a simple means of interfacing to the World-Wide Web. You can
enable a simple HP VEE HTTP server that will allow inspection (though not
control) of a VEE program over the Web.
The VEE HTTP server supports a number of commands that are defined as Web
addresses (URLs). These commands take a "snapshot" of some element of the
VEE display (such as the Runtime window or a function panel) and send a
bitmap of it back to the Web surfer. Since as far as the Web is concerned,
these commands look like addresses, they are transparent to the Web and no
special knowledge of the VEE HTTP server is required.
* All you have to do to enable the VEE HTTP server is go to the VEE Default
Preferences configuration dialog box, and click on "Enable Server":
This page is built with standard Hypertext Markup Language (HTML) tags, with
the various commands used to access VEE implemented as extensions to the
Web server's URL:
* One of the other important changes in VEE 5.0 has been the introduction of
bitmap handling features. There is a new function named SavePanelImage()
that allows saving the image of a UserFunction panel. It has the syntax:
The first parameter is the name of the UserFunction panel. It won't work
on UserObjects, but you can get it to work on the Main panel by specifying
"Execution Window" as the text.
The second parameter is the name of a bitmap file that will store the image;
a full path can be specified. If this parameter is not specified, the bitmap
file will be given the name of the UserFunction panel and stored in the VEE
installation directory. Supported bitmap formats are .BMP (not supported on
HP-UX) or .JPEG (.JPG).
The third parameter is the number of colors, and this must be a power of 2:
2,4,8,16, 256, or whatever. This defaults to 256 if not specified. It only
applies to .BMP files, as JPEGs are alway 24-bit color.
A related improvement is better clipboard support. While in VEE 4.X, a user
could cut and paste VEE objects between different copies of VEE running on
the same PC, in VEE 5.0 he or she can also cut and paste VEE objects to any
Windows application (such as Word or Paint) that supports "bitmap rendering".
UserObject and UserFunction object menus now have a new function, "Copy", to
support clipboard transfers.
* Other changes in VEE 5.0 include:
This enhancement is also encorporated in the Program Explorer menu
associated with UserFunctions.
* The following bugs were fixed in VEE 5.0:
You can also bring out a pin on Direct I/O to allow you to specify an I/O
configuration name ... it had the same problem as the address pin.
A segmentation violation would also occur if VEE tried to read back the
output of an RPC UserFunction that had no data on the output.
Many other obscure bugs were fixed:
[1] VEE 5.0 OVERVIEW
[2] VEE & ACTIVEX CONTROLS
[3] VEE & ACTIVEX AUTOMATION
[4] VEE & THE WORLD-WIDE WEB
[5] OTHER CHANGES
[6] BUGS FIXED IN VEE 5.0
[1] VEE 5.0 OVERVIEW
________________________________________________________________________
VEE 5.0 for Windows95/NT: E2120F (option AA8 for floppies)
Upgrade from VEE 4.X: option UP1
Upgrade from VEE before 4.X: option UP2
VEE 5.0 for HP-UX Series 700: E2111F
Upgrade from VEE 4.X: option UP1
Upgrade from VEE before 4.X: option UP2
VEE 5.0 Automation Kit: 82345F (includes 82341C HPIB card)
VEE 5.0 10-User Site License: E2119F (option AGE for upgrade)
VEE 5.0 50-User Site License: E2117F (option AGE for upgrade)
VEE 5.0 Educational License: H2327F option WNT
Add HPIB Card: H2327F option PCN
Lab Starter Kit: H2326A
________________________________________________________________________
Please consult HP for local prices.
[2] VEE & ACTIVEX CONTROLS
+----------------------------------------------------------+
| ActiveX Control References |
+----------------------------------------------------------+
| Registered Controls: |
| +----------------------------------------+ |
| |[ ] Acrobat Control For ActiveX | [ OK ] |
| |[ ] Callable VEE OLE Control Module | [ Cancel ] |
| |[ ] Microsoft ActiveX Plugin | |
| |[ ] Microsoft Calendar Control | [ Browse... ] |
| |[ ] Microsoft Comm Control | |
| |[ ] Microsoft Common Dialog Control | |
| |[ ] Microsoft HTML Intrinsic Controls | |
| |[ ] Microsoft Internet Transfer Control | [ Help ] |
| +----------------------------------------+ |
| |
| +- Acrobat Control For ActiveX ------------------------+ |
| | Location: C:\Acrobat\ActiveX\PDF.OCX | |
| +------------------------------------------------------+ |
+----------------------------------------------------------+
There was a long set of ActiveX controls available ... apparently the list
was derived from Windows Registry entries established when the applications
that incorporated the controls (like Visual BASIC) were installed. A sample
inspection of these controls showed some of them to be very specialized and
cryptic, and of no interest to a VEE user.
Sysinfo: Sysinfo1
Since this particular control didn't have a visual interface worth thinking
about, I turned it into its iconized form and left it that way. Essentially
the control simply declared the type, "Sysinfo", and the name of this
"instance" of the control in the program, "Sysinfo1", that I would need to
make use of it.
+--------------------------------------------------------------------+
| Function & Object Browser [x]|
+--------------------------------------------------------------------+
| Type: Library: Member: |
| +-------------------------+ +--------------+ +-------------------+ |
| | Operators | |*SysInfo | | ACOnLine | |
| | Built-in Functions | | | | BatteryLifeTime | |
| | Local User Functions | | | | BatteryPercent | |
| | Imported User Functions | | | | BatteryStatus | |
| | Compiled Functions | +--------------+ | BuildNumber | |
| |*ActiveX Objects | Class: | CDROM | |
| | | +--------------+ |*ComputerName | |
| | | |*SysInfo | | Disk | |
| | | | enumUnit | | DiskCacheSize | |
| | | | | | DiskDrive | |
| +-------------------------+ +--------------+ +-------------------+ |
| |
| +----------------------------------------------------------------+ |
| | ComputerName As Text | |
| +----------------------------------------------------------------+ |
| |
+--------------------------------------------------------------------+
| [ Create Formula ] [ Cancel ] [ Help ] |
+--------------------------------------------------------------------+
The list of properties and methods is at the right of the panel. Selecting
one gives a little documentation on the property at the bottom of the display
... not very much in this case. Anyway, selecting the "ComputerName"
property (which gives the network name of the computer) and clicking on
"Create Formula" gave me the formula box:
+-----------------------------------------+
| SysInfo.ComputerName |
+---------+----------------------+--------+
| SysInfo | SysInfo.ComputerName | Result |
+---------+----------------------+--------+
I deleted the input pin and type the name of the object instance into the
formula field:
+--------------------------------+
| SysInfo.ComputerName |
+-----------------------+--------+
| SysInfo1.ComputerName | Result |
+-----------------------+--------+
Either way, running it gave my computer name, "HPLVLGVG". I then wrote
a program that used the following properties:
SysInfo1.ComputerName (HPLVLGVG)
SysInfo1.ProcessorType (Pentium)
SysInfo1.UserName (gvg)
SysInfo1.PhysicalMemory (32899072)
-- and then added a method, controlled by a Message Box, to reboot the
computer:
SysInfo1.ShutdownSystem()
* The SysInfo control had properties and methods associated with it, but it
had no need to interrupt the program using it, since a program user couldn't
punch buttons or tweak widgets on it ... there weren't any.
Calendar.Calendar1
This provided a widget that looked like a little calendar. Note in passing
that this object has properties of its own that are independent of VEE, and
they can be accessed and controlled through the "Control Properties" entry
in the object menu.
+--------------------------------------------------------------------+
| Create Event Handler UserFunction [x]|
+--------------------------------------------------------------------+
| Type: Library: Member: |
| +-------------------------+ +--------------+ +-------------------+ |
| | ActiveX Objects | | MSACAL | | AfterUpdate | |
| | | | | | BeforeUpdate | |
| | | | | | Click | |
| | | | | | DblClick | |
| | | +--------------+ | KeyDown | |
| | | Class: | KeyPress | |
| | | +--------------+ | KeyUp | |
| | | | Calendar | | NewMonth | |
| | | | | | NewYear | |
| | | | | | | |
| +-------------------------+ +--------------+ +-------------------+ |
| |
| +----------------------------------------------------------------+ |
| | EVENT Void AfterUpdate() | |
| +----------------------------------------------------------------+ |
| |
+--------------------------------------------------------------------+
| "Calendar1_AfterUpdate" UserFunction will be created |
| |
| [ Create Handler ] [ Cancel ] [ Help ] |
+--------------------------------------------------------------------+
I selected "AfterUpdate" and indeed got an event handler:
+------------------------------------------------+
| Calendar1_AfterUpdate |
+------------------------------------------------+
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
+------------------------------------------------+
This handler is a UserFunction, but one with some odd restrictions. You
can't put input or output pins on it, and in most cases it won't be wired
into a program directly. The only way it can communicate with the rest of
the program is through global variables. It is essentially a self-contained
subprogram that is called when the event (in this case, any update to the
Calendar object) occurs.
+------------------------------------------------+
| Calendar1_AfterUpdate |
+------------------------------------------------+
| |
| +-------------------+ |
| | Formula | |
| +-------------------+ note use of multiline |
| | "New Date: " + | Formula box |
| | Calendar1.Day + | |
| | "/" + +------------+ |
| | Calendar1.Month + | | |
| | "/" + | +---------+---------+ |
| | Calendar1.Year | | AlphaNumeric | |
| +-------------------+ +-------------------+ |
| | | |
| +---------+---------+ |
| | |
| +--+--+ |
| | OK | |
| +-----+ |
| |
+------------------------------------------------+
I then set up a Panel View as follows:
+--------------------------+
| +--------------------+ |
| | AlphaNumeric | |
| +--------------------+ |
| | New Date: 3/5/1998 | |
| +--------------------+ |
| +-----+ |
| | OK | |
| +-----+ |
| |
+--------------------------+
I set this UserFunction to "Show Panel On Execute". I created a Main Program
consisting of an Until Break and ran that, then played with the Calendar
object. When I updated the day of the month, I got the pop-up.
+---------------------------------------------+
| Calendar1_AfterUpdate |
+---------------------------------------------+
| |
| +-------------------+ |
| | Formula | |
| +-------------------+ +--------------+ |
| | "New Date: " + | | Set Variable | |
| | Calendar1.Day + | +--------------+ |
| | "/" + +-->| globalstat | |
| | Calendar1.Month + | +--------------+ |
| | "/" + | |
| | Calendar1.Year | |
| +-------------------+ |
| |
+---------------------------------------------+
I then extended the main program as follows:
+--------+ +--------------+
| Text | | Set Variable |
+--------+ +--------------+
| NIL +-->| globalstat | "NIL" is default setting of global variable
+--------+ +------+-------+
|
+---+---+
| Until +-----------------+
| Break | |
+-------+ +------------+-------------+
| If/Then/Else |
+-------------------+------+
test for change in | globalstat!="NIL" | Then +--+
global variable | | Else | |
+-------------------+------+ |
|
+--------------------------------------+
|
+------+-------+ +---------------------+
| Get Variable | | AlphaNumeric |
+--------------+ +---------------------+
| globalstat +-->| New Date: 11/4/1900 |
+--------------+ +----------+----------+
|
+--------+---------+
| Formula |
+------------------+
reset global variable | globalstat="NIL" |
+------------------+
This scheme could be extended to handle other events.
[3] VEE & ACTIVEX AUTOMATION
+----------------------------------------------------------+
| ActiveX Automation References |
+----------------------------------------------------------+
| Registered Automation Servers: |
| +----------------------------------------+ |
| |[ ] API Declaration Loader | [ OK ] |
| |[ ] Marquee Control Library | [ Cancel ] |
| |[ ] Microsoft ActiveX Plugin | |
| |[*] Microsoft Excel 8.0 Object Library | [ Browse... ] |
| |[ ] Microsoft Graph 8.0 Object Library | |
| |[ ] Microsoft Internet Controls | |
| |[ ] Microsoft Map | |
| |[ ] Microsoft Repository | [ Help ] |
| +----------------------------------------+ |
| |
| +- Microsoft Excel 8.0 Object Library -----------------+ |
| | Location: C:\Program Files\MS Office\Excel 8.0 | |
| +------------------------------------------------------+ |
+----------------------------------------------------------+
Having referenced the Excel 8.0 object library, I was then able to create an
instance of an object to deal with Excel. This was done somewhat differently
from the way an ActiveX Control instance is created; in this case I went
directly to the Function & Object Browser ... and selected "Built-in
Functions" (not "ActiveX Objects").
+---------------------------------------------------------------------+
| Function & Object Browser [x]|
+---------------------------------------------------------------------+
| Type: Category: Member: |
| +-------------------------+ +--------------------+ +--------------+ |
| | Operators | | <All> | |*CreateObject | |
| |*Built-in Functions | |*ActiveX Automation | | GetObject | |
| | Local User Functions | | Array | | | |
| | Imported User Functions | | Bessel | | | |
| | Compiled Functions | | Bitwise | | | |
| | ActiveX Objects | | Calculus | | | |
| | | | Complex Parts | | | |
| | | | Data Filtering | | | |
| | | | Generate | | | |
| | | | Matrix | | | |
| +-------------------------+ +--------------------+ +--------------+ |
| |
| +-----------------------------------------------------------------+ |
| | CreateObject(objectName) | |
| | Creates a new instance of the object specified by 'objectname' | |
| | and returns a reference to it. | |
| +-----------------------------------------------------------------+ |
| |
+---------------------------------------------------------------------+
| [ Create Formula ] [ Cancel ] [ Help ] |
+---------------------------------------------------------------------+
This gave me the function:
+------------------------------------------------+
| CreateObject(objectName) |
+------------+--------------------------+--------+
| ObjectName | CreateObject(objectName) | Result |
+------------+--------------------------+--------+
What the exact syntax for this object is must be determined by examination of
the target application's documentation ... it will generally reference Visual
BASIC as the controlling software, but the syntax will be the same for VEE.
+---------------------------------------------------+
| CreateObject(objectName) |
+------------------------------------------+--------+
| CreateObject("Excel.Sheet").worksheet(1) | Result |
+------------------------------------------+--------+
The result of this function is a handle that will be used by functions that
set properties or execute methods for that spreadsheet. As with ActiveX
Controls, these are obtained with the Function & Object Browser:
+--------------------------------------------------------------------+
| Function & Object Browser [x]|
+--------------------------------------------------------------------+
| Type: Library: Member: |
| +-------------------------+ +--------------+ +-------------------+ |
| | Operators | |*Excel | | Application | |
| | Built-in Functions | | | | Creator | |
| | Local User Functions | | | | FullName | |
| | Imported User Functions | | | | Installed | |
| | Compiled Functions | +--------------+ | Name | |
| |*ActiveX Objects | Class: | Parent | |
| | | +--------------+ | Path | |
| | | | Addin | | | |
| | | | Addins | | | |
| | | | Adjustments | | | |
| +-------------------------+ +--------------+ +-------------------+ |
| |
| +----------------------------------------------------------------+ |
| | PROPERTY Application As Application | |
| | read-only | |
| +----------------------------------------------------------------+ |
| |
+--------------------------------------------------------------------+
| [ Create Formula ] [ Cancel ] [ Help ] |
+--------------------------------------------------------------------+
For example, an elementary property would be to make the spreadsheet visible.
This can be done with:
+---------------------------------------------------+
| CreateObject(objectName) |
+------------------------------------------+--------+
| CreateObject("Excel.Sheet").worksheet(1) | Result +--+
+------------------------------------------+--------+ |
|
+---------------------------------------------------+
|
| +-----------------------------------------------+
| | Formula |
| +-----------+-----------------------------------+
+->| Worksheet | worksheet.application.visible = 1 |
+-----------+-----------------------------------+
Further properties and methods can be implemented in the same way. However,
more details will require a more extensive document than this one.
[4] VEE & THE WORLD-WIDE WEB
+---------------------------------------------------------------+
| Default Preferences |
+---------------------------------------------------------------+
| +---------+--------+-------+--------+----------+------------+ |
| | General | Colors | Fonts | Number | Printing | Web Server | |
| +---------+--------+-------+--------+----------+ | |
| | +-[x] Enable Server ------------------------------------+ | |
| | | | | |
| | | Root Directory: [ C:\VEE\ ] | | |
| | | HTTP Port Number: [ 80 ] | | |
| | | Server Timeout: [ 60 ] | | |
| | | Log File [ C:\Temp\http.log ] | | |
| | +-------------------------------------------------------+ | |
| +-----------------------------------------------------------+ |
| |
+---------------------------------------------------------------+
| [ OK ][ Save ][ Reset ][ Cancel ][ Help ] |
+---------------------------------------------------------------+
Once this was done, I could then use the name of my PC -- "http://hplvlgvg"
-- as an address for my Web browser to access the VEE Web server that was
then installed. This default Web page looked like this:
+-------------------------------------------------------------------+
| |
| Remotely Monitoring A VEE Program |
| |
| Welcome to the HP VEE Web Monitor Home Page. You can remotely |
| monitor a VEE program by selecting a target view (such as VEE |
| Workspace or Execution Window) and then clicking on *View*. |
| _________________________________________________________________ |
| |
| Basic Monitoring |
| |
| To monitor a VEE program, select the desired item and press the |
| View button. |
| |
| +---------------------------------------------------------------+ |
| | Basic VEE Monitoring | |
| +---------------------------------------------------------------+ |
| | (*) VEE Workspace snapshot | |
| | ( ) VEE Workspace with [ ] second updates | |
| | ( ) Execution Window snapshot | |
| | ( ) Execution Window with [ ] second updates | |
| +---------------------------------------------------------------+ |
| [ View ] |
| |
| _________________________________________________________________ |
| |
| Advanced Monitoring |
| |
| To monitor a VEE program, select the desired item and press the |
| View button. |
| |
| +---------------------------------------------------------------+ |
| | Advanced VEE Monitoring | |
| +---------------------------------------------------------------+ |
| | ( ) Last Error Message | |
| | ( ) Main Panel | |
| | ( ) Main Detail | |
| | | |
| | ( ) Panel View of UserFunction [ ] | |
| | ( ) Detail View of UserFunction [ ] | |
| +---------------------------------------------------------------+ |
| [ View ] |
| |
+-------------------------------------------------------------------+
This default Web page shows off the capabilities of the VEE Web server, which
allows you to take bitmap snapshots of different VEE views, such as the VEE
Workspace, the Execution Window, error messages, main panel, the panel view
of a specified UserFunction, and so on.
see entire VEE window: http://<server>/ViewVEE
see main VEE panel: http://<server>/ViewMainPanel
see main program: http://<server>/ViewMainDetail
see Execution Window http://<server>/ViewExecWindow
see UserFunction panel: http://<server>/ViewPanel?<userfunction_name>
see UserFunction program: http://<server>/ViewDetail?<userfunction_name>
see last error message: http://<server>/ViewError
For example, to view the Execution Window of VEE on my pc, I could type the
following URL into my browser:
http://hplvlgvg/ViewExecWindow
If I wanted to get the Panel View of a UserFunction named "DataGen", I would
enter:
http://hplvlgvg/ViewPanel?DataGen
A user could build his or her own web page using these commands and standard
HTML codes. There are additional techniques for building more sophisticated
VEE web servers using other VEE tools that will eventually be detailed in
application notes.
[5] OTHER CHANGES
SavePanelImage( "SomePanel", "SomeBitMapFile.bmp", 256 )
[6] BUGS FIXED IN VEE 5.0