Flynet Viewer breaks new ground in the implementation of improved business processes. It provides fast, direct terminal emulation using thin-client browser technology, with the ability to program screen data both at the client and the server. This unique implementation of true middleware is the first available product to allow developers access at both the desktop and inside an ASP.NET server for terminal emulation control of mainframe or midrange (AS/400, iSeries, UNIX or VAX/VMS) screen-based applications.

Benefits

Familiar Emulation Inside a Standard Browser - Instantly
For the user, a Flynet Viewer session looks and feels like a traditional terminal emulator. The emulation is instantly available anywhere the user can access an Internet Explorer session - i.e. with no client-side software installation or set-up.

• Reduced software licensing and maintenance costs
• Broader access to host-based applications from a browser - even on mobile devices
• Incorporation of host screens within other web-based applications

Minimal Network Impact
Unlike first generation HTML-based emulators, Flynet Viewer utilizes the exclusive Flynet Emulation DataStream - a fully HTTP-compatible, compressed emulation data stream. As a result, the network traffic is significantly less than with other HTML-based emulators - in fact only marginally larger than when using traditional emulators, and in some cases smaller.

Based on ASP.NET
Flynet Viewer, rather than utilizing a proprietary emulation server, is the first emulator to be built on top of and fully integrated with Microsoft's ASP.NET web application platform. Using standard .NET programming design patterns and techniques, developers can easily manage sessions and implement integration 'hooks' at the server side. This means that Flynet Viewer can be used as a 'bridge' to a new improved architecture - it is the first step in implementing a development and deployment solution that converges traditional host-based terminal applications with .NET.

• Programmatic access at both client and server side - emulation is provided at the middleware level by the Flynet Viewer server, which also has the ability to programmatically extract data from the emulation stream to and from the client. Information can be 'siphoned' directly off the emulation stream for use in other data systems and applications.
• Built on .NET - the first terminal emulator to be integrated at the server level with ASP.NET, providing an easy to implement terminal emulation solution for any client computers running Internet Explorer 5.5 and above. Developers can integrate with host screens on an event-driven basis at the ASP.NET server side as well as at the client side (Javascript or VBScript).
• Improved Network Performance - Flynet Viewer uses AJAX (Asynchronous Javascript and XML) technology with a compressed XML data stream between the middleware server and the client.  This greatly reduces bandwidth usage compared to other 'thin client' screen-to-html emulators.
• Auto-emulation enabled for Enhanced User Interfaces - Using the Flynet Viewer Studio ASP.NET User Interface generator, that ASP.NET environment is setup so that developers can mix enhanced web pages (replacing frequently used screens) and our dynamic HTML terminal emulation.  A checkbox on a screen in Studio determines if a screen is represented in an enhanced ASPX page or not--otherwise, it is seamlessly delivered to the browser in pass-through emulation mode.

All this in addition to the general benefits of browser based terminal emulation - including low maintenance, central management of the solution, no client to download and cost-effective, flexible concurrent licensing plans.

Use Flynet Viewer as a standard terminal emulator, to integrate existing host systems with new applications and devices, or as a bridge to a better, new architecture - Flynet Viewer is the first step in implementing a development and deployment solution that converges traditional host-based terminal applications with .NET.

The Flynet Viewer VT plug-in provides unique UNIX 'pass-through' capability, enabling terminal emulation of any DEC or UNIX application in a browser with minimal configuration.

Features

Traditional Emulation Delivered within a Web Browser
Emulation is instantly available anywhere the user can access an Internet Explorer session. Flynet Viewer gives you all the features normally associated with 'native' stand-alone emulators including:

• Scalable fonts - as browser is re-sized, font sizes re-scale to fit the window
• Customizable keyboard including all function keys
• Keyboard buffering or 'type ahead' - users can type input before screens are visible, as they are often used to doing with terminal-based applications
• True colors
• All host writes are synchronized with the web page 

Instant Installation
Rapid, simple installation on the server and no client-side installation.

The First Terminal Emulator Built on ASP.NET
Flynet Viewer is integrated at the server level with ASP.NET, providing organizations with an easily implemented solution for providing terminal emulation to any client personal computer running Microsoft Internet Explorer 5.5 and above. Developers can integrate with host screens on an event-driven basis both at the ASP.NET server side (any .NET language) as well as at the client side (Javascript or VBScript)

Full Keyboard Support
Using a small ActiveX control, the full PC keyboard may be utilized to emulate host keys

Easily Administered
A configuration file in the ASP.NET folder provides administrators with control over the default look and feel of the emulator. Additionally, the administrator can choose to prevent users from modifying the default settings. This can make helpdesk interactions more productive, as it is easier for help desk personnel to identify fields if the colors are consistent across the clients.

Configurable Color and Font Settings
A Flynet Viewer server can be configured to support any number of color styles (a number of style sheets are provided and customers can modify these or create new ones). In addition, the use of a selection of non-standard fonts is made possible by font embedding technology.

Client-Side Integration
Web developers can use their own JavaScript file to respond to two frequent events; whenever a new screen is displayed at the client and whenever the user has pressed a key that will send the screen to the host. In addition to these two events, there are functions provided in the client-side framework for reading any area of the screen and for automatically inserting values into entry fields.

Server-Side Integration
A user-modifiable aspx and aspx.cs module can be used for ASP.NET server-side integration. In this module, a method (Enter) provides access to the screen immediately before it is sent to the host (due to the user pressing an ENTER or function key) and immediately after the next screen is received. As with the client-side integration, methods are provided for reading and writing the screen, enabling integration of the screen data with other ASP databases and applications.

Remote Administration and Control
Provided with the Flynet Viewer Service is a set of administration applications that may be separately installed on any machine from which access to the live Flynet Viewer Emulation Service is desired (such as an administrator's desktop). These applications then access the service through a configurable HTTP port to enable remote administration. The Administration Applications include the following functions: 

• View active or available sessions and status
• Start/Stop a session
• View a live session in a special administrator's emulation window -- enables both debugging as well as help desk capabilities
• Configure the service using tree-view property sheets
• Start/Stop/Clear Application Tracing
• View Application trace file which optionally includes buffers, screens, API calls and internals

High Performance Windows Service
The core emulation engine runs as a standard Win32 service, providing control through the system services applet as well as event reporting using the standard Windows Event Log. This service provides up to hundreds of concurrent emulation sessions that persist independently of client .NET object processes and threads.  The core emulation engine is written in highly optimized C and C++, ensuring efficient use of resources and the fastest possible handling of the terminal data streams.