Embed Size (px)
Citation preview
Who is Querix ?
Development of Tools for 4GL,
Java, ESQL/C, C, C++, BDS, Fourgen, NewEra and Genero
All common Databases
All common Operating Systems
Product modernization
.NET clients and fully Web enabled applications
Development support and Consultancy
Application Migration to Lycia
What‘s in it for me ?
What Lycia 4GL provides for your existing
applications: Modernize existing 4GL & ESQL/C applications
Maximize Software Development Life Cycle
Reduce time to market for new applications
Maximize existing Intellectual Capital Investment (ROI)
OS (P-Code) and Database Vendor Independence
Applications that provide…..
Customer Ecstasy
Architectural Diagram
Example: Modernized Screen 1
Example: Modernized Screen 2
How did we get there ?
Migration Process in a Nutshell
Compile & Run
Enhancing initial GUI
Using XML templates (CSS) designed using Lycia’s
graphical Theme Designer
Enhancing forms and 4GL code
That’s it!
What makes Lycia 4GL great ?
Ease of Use
Native Look & Feel (Web and .NET clients)
Enhanced Security
Highest Level Encryption
Authentication (Native, Crypt, Shadow, PAM)
SOAP
Graphical Eclipse based IDE (Debugger,
Revision Control, Form Designer..)
Multi-Database / Multi-Platform / Multi-Byte
SOAP / Web Services
SOAP 1.1/1.2 Support
Support for IBM WebSphere, Apache,
Tomcat & BEA WebLogic Servers.
Hot Deployment
RPC & Document Messaging Patterns
Synchronous & Asynchronous Requests
SOAP with Attachment
Security
SSL Encryption
Support for Asymetric Keys
Operating System and PAM Based User
Authentication
Centralized Server
True Three-Tier Architecture
Graphical IDE
Industry Standard Eclipse
Project Management
Rapid Application Development (RAD)
Graphical Debugger
Program Flow Control
Graphical and Console Debugging
Manipulation of Program Data
GUI Form Designer
Revision Control (cvs, subversion…)
Graphical IDE - Debugger
Graphical Debugger
Program Flow Control
Set/Remove/Ignore/… Break Points at any time
Step Over or Into a function (call)
Remote Debugging
Manipulation of Program Data
All program variables organized into
Local / Global / Internal
can be viewed and changed at runtime
LyciaBI – Graphical Reporting 1
Lycia II suite can also be extended with
'LyciaBI' for fully fledged enterprise business
intelligence tasks
Reports can be created from within
LyciaStudio using the professional and market
leading tools - BIRT and Jasper
Pixel-perfect professional looking reports.
REPORT data type with methods/properties to
communicate with the LyciaBI server and fully
control the execution within 4GL.
LyciaBI – Graphical Reporting 2
Graphical reports supporting many formats
Web-enabled Application Dev.
Your Lycia compiled application can be accessed via the internet by using all common browsers.
The web application can also be integrated into an existing web-page (defined area within that page)
Low Maintenance – zero footprint
Detects the Browser capabilities and produces corresponding HTML code (up to HTML 5)
The Web-enabled app will use server resources
Local Printing and HTML creation
GUI clients allow to utilize the local printer
Html files can be generated dynamically,
downloaded to the client and send to the
printer.
Using the windows registry information on file
type (extension) – application association, any
document file (i.e. word.doc) could be
executed to print or edit this file by using the
default editor/printer.
XML-Capabilities DOM & SAX
A set of data types and methods for dealing with XML data allow the developer to create and parse XML data directly from 4GL.
Both DOM and SAX standards can be used to process the data. DOM methods offer more flexibility and a wider
range of features
SAX method offer the speed in processing ready XML documents.
XML interface is easy in use
Great to process vast amounts of information.
Microsoft Office® Compatibility
Using the Windows DDE (Dynamic Data Exchange) Interface is another way of transferring data from and to Microsoft Office applications.
An alternative method would be to export temporary text data files (i.e. csv, xml) and import them into the Office application using your custom macro or VB-Script.
Screen Array (Grid contents) can be exported using the Clipboard in text and html format.
Interoperational Java Integration
Providing 4GL application developers with the ability to implement diverse software development projects by inter-operating with Java programs and modules.
Only Requirement: You need Java JRE
Unique native data type mapping Java<->4GL
Java objects are defined like 4gl data types
The scope of a reference to a Java Class can
be modular or global.
Integrated BLOB Viewer
Graphical clients have got an embedded
BLOB Viewer.
An external BLOB Editor can be associated.
Modern Grid Control
Classic Screen Array And Grid Control
In the form, the developer can choose between the classic and a modern grid control with an improved appearance, usability and functionality. Grid Column clicks can either trigger a client side array sort or trigger any other event (function call, event, key…).
Data Transmission Between Grid Control And Server
To optimize the performance of graphical grids, data can be sent to the client in chunks of a specified size.
Grid with different graphical widgets Any widget can be placed to visualize and modify column data. Grids
use special widgets optimized for grids.
Text only grids Should the runtime detect, that no graphical widget is applied for any column,
it will use a special text only grid to decrease systems memory requirement and performance.
Modern Grid Control (Data Export)
Exporting Of Grid Data The Grid control functions offer the developer the opportunity
to cater for Grid data export. Grid data can be passed on to other applications for further processing and reporting purposes.
Export Data Range The data range can be specified by columns and limited
between all data, or only the data currently displayed in the Grid control.
Supported Data Format Supported data formats are standard text, CSV and HTML.
Export Target The target location can be a file or simply the clipboard.
Modern grid with graphical widgets
The grid screen array allows to include any
graphical form widget such as
Combo
Function Fields
Radio Buttons
Check Boxes
Hotlinks
Images
…
Toolbar and Mouse Context Menu
Dynamic Combo List
Example function to populate a combo list dynamically from a DB FUNCTION populate_data_combo_list(p_cb_field_name)
…
DECLARE c_string_scroll2 CURSOR FOR SELECT qxt_string_tool.string_data FROM qxt_string_tool ORDER BY string_data ASC
…
LET count = 1
FOREACH c_string_scroll2 INTO l_string_data
CALL fgl_list_set(p_cb_field_name,count,l_string_data)
LET count = count + 1
END FOREACH
END FUNCTION
Migration Project Outline
Like with any other project, it is essential to define clearly
your migration project. Typical factors are:
Estimate Available Man Resources
Consider Impact due to Maintenance work for the current
application
How far do you want to take your gui
Divide and Conquer
Define clear requirement borders to prevent ‘gold plating’
The importance of a pixel perfect application is less important for
internal applications.
We are now going to talk about the different project
stages
GUIfy - Introduction
Before you start to GUIfy your application, you
need to know areas which require special
considerations/attention.
There is also a clear distinction between the
4gl window and the (none-4gl) window
decoration (titlebar, toolbar and statusbar).
Graphical forms use different layout
panels/managers. The closest match to 4gl is
the co-ordinate panel.
GUIfy – Migration Steps
Consider Code Page / Text BYTE format
Import your project to Lycia
Review/Define new printing mechanisms
Define Default Font (Family, Size and colour)
Define Window background colour
Consider Impact on Text labels due to
proportional fonts
Define window style: Flat/Windowed
Define default Titlebar Text
Define Error / Message / Display AT statements
1st Migration Cycle
Import and run ‘Out of the Box’ P1
The objective of the first migration cycle is to
get your application run and behave
correctly/as expected without any major
changes or gui customizations
import your project
define build configurations
Configure your environment
Compile and run your applications in a ‘out of the
box mode’ (no gui defnitions in 4gl, per or themes)
1st Migration Cycle
Import and run ‘Out of the Box’ P2
Set your gui server environment
If required, convert your text sources to a more
appropiate code page (ISOxxx, UTF-8)
Set your Code Page in LyciaStudio
Import your projects to a Lycia workspace
Analyze your current project directory structure
and if required, change it now
If required, define your different software build
configurations
1st Migration Cycle
Import and run ‘Out of the Box’ P3
Create your program definitions in the project
manager and
Assign the required 4gl & per sources
Assign any other required sources (i.e. unl text
files, configuration text files etc..)
If required, specify the default arguments to run the
application
OPTIONS AUTOREFRESH & ON CLOSE
Create your repository and synchronize your
project (i.e. cvs)
1st Migration Cycle
Import and run ‘Out of the Box’ P4
Compile, run and test your applications
Before you apply any changes to your project,
ensure, it runs correctly.
It is very common that you will encounter warnings
or runtime errors on your first attempts.
Start with testing one of the smaller programs.
Document any found issues to aid you when you address
the larger programs
Follow your testing plan
2nd Migration Cycle
Apply generic GUI features’ P1
The objective of the second migration cycle is
to get your application render in more
attractive/modern presentation without any
major changes to your sources or program
logic using themes and minor form changes
Run your application using LyciaDesktop and
start the theme designer
Default Font & Background colour
Minor Layout corrections on the form level
Titlebar, Statusbar and Toolbar
2nd Migration Cycle
Apply generic GUI features’ P2
Set default Font
Set window Background Colour
Probably redefine “OPTIONS ACCEPT”
Set Titlebar default text
Validate and/or modify DISPLAY AT, ERROR,
MESSAGE and PROMPT statements if required
If required, convert forms to xml forms
Form Label size/location modifications
Generic Widgets for Fields replacements
Set Global Toolbar definitions (optional)
Lycia II - ThemeDesigner
Graphical tool to manage the look and feel of
your 4GL application
3rd Migration Cycle
Apply advanced GUI features’ P1
After the 2nd migration cycle is completed, you
can dive deeper into the gui world by utilizing
the more advanced features.
Typical tasks would include:
Apply & reorganize your forms with layout panels
Remove the dependency of DISPLAY AT
statements.
Utilize third party (or your own) web services
Integrate new form widgets.
Hardware Requirements
Common OS (32/64 - Windows, Linux, Unix,
Mac)
Server Memory requirements depend on
Your application (memory allocated by your variables)
Graphical client (.NET or Web)
Average application uses between 20-50 Mb per
session
If you use a web client, the html engine and
communication (Ajax) to the client browser also uses
up server resources. (add 50Mb per session)
Licence cost
Single Development Seat €1’000
Enterprise Site Development €2’000
Client Seat €50 (each seat can run one or more
processes)
Example
Company with 10 developers and 200 con-current
seats
€2000 + 200 x €50 = €12’000
Note: Prices are also published on www.querix.com
Try it yourself
All shown demo applications are available for
the Querix 4GL package. Simply download
and install the tools. Run cvs and import our
demos from our cvs-demo repository. You will
find a Demo programs showing most of the
features.
http://www.querix.com/downloads
Contact Us !
Web Demo?
Site Visit?
Quotation?
Querix (UK) Ltd.
Querix House, 50 The Avenue
Southampton S0171XQ
United Kingdom
Phone: +44 2380 232345
http://www.querix.com
Begooden-IT Consulting
5, Rue du Lycée
F-29120 Pont l’Abbé
Phone: +33 (0)2 98 51 32 10
http://www.begooden-it.com
Appendix
Drilling down into more detail
GUIfy – Default Font
The default font family and size defines, how
normal text is displayed.
Windows will be sized depending on the default
font the form size/ environment row/col value.
Max Font Letter Height in Pixel x Lines
= Screen Window Height
Average Font Letter Width in Pixel x Columns
= Screen Window Width
The default font will be defined in the theme.
You can still use other fonts.
GUIfy – Text Identifier
Classic 4gl has no concept of text identifiers or
dynamic updates.
When a form is converted to XML, all static
labels (screen section) will be converted to text
elements (can be updated or protected from
updates and have a full set of properties)
DISPLAY AT statements match the required
location only for forms with a co-ordinate panel.
GUIfy – Text Merging
Classic 4gl uses non-proportional screen fonts
and modern applications use proportional fonts.
The 4GL column width (in pixel) will be
calculated on the ‘average font width’
To make the migration of classic 4gl
applications smoother, Lycia merges text based
on a few criteria
Text must have the same attributes to be merged
The space between words must be 0 or 1 character.
GUIfy – Window General
Most 4GL applications area written or 24Lines/80Columns screens.
Sometimes, Classic 4GL Forms/Windows are very crowded with information, because of the original Text Terminal Size (column/rows) limitation.
In GUI, using proportional fonts and dynamic labels, you have nearly twice the space – use it and re-arrange your window/form layouts!
If you only want to support gui clients, enlarge your windows.
The initial screen window can be resized using the environment variables COLUMNS and LINES
GUIfy – Window Style P1
4GL addresses and renders windows only as
areas of your screen and allows some
attributes to be defined like BORDER.
In Lycia, two kinds of windows are available.
Flat and Windowed.
…WINDOW
Flat window
…WINDOW ..(ATTRIBUTE BORDER)
Windowed window
GUIfy – Window Style P2
To line-up rows/text lines from two different
windows, they need to be
rendered flat (no border attribute)
Form’s root container has to be of type co-ordinate
Your 4gl application should not rely on lining up
text between different windows
Cascaded / too many windows don’t look or feel
good in a gui (i.e. don’t use cascaded menus
where each sub-menu in located a new sub-
window)
GUIfy – Window Style P3
Some applications use flat windows to cover
only a part of another window.
Querix clients can cope with it but users may have
an issue with it as only one window can be active at
any time, but the user does not see/recognise it as a
separate window.
A Flat window is a child window of the parent
window
A Flat window can overwrite/cover it’s parent
window fully.
GUIfy – Window Style P4
Window decorations can also be defined in the
theme
Example Window styles
GUIfy – Window Style P5
Windowed/Floating Windows need additional/optional Window Decoration information. Titlebar Text
Titlebar Icon
Titlebar default buttons (mini-maximize, close) If they are displayed
And what should happen if they are clicked on
Statusbar
GUIfy – Titlebar P1
Classic 4gl has no concept of window
decorations such as a titlebar or statusbar
By default, the current window name is
displayed as the titlebar caption and the Lycia
icon is used for the titlebar image. It can be
overwritten dynamically using fgl_settitle()
function and/or by the theme.
GUIfy – Titlebar P2
Minimize/Maximize Window
The titlebar options can be removed/disabled
Exit/Close
Ability to specify extended actions to perform when
the user clicks the ‘x’ button on a window. Options
are:
Continue as nothing happened
Exit program
Call a function
Trigger a key press
GUIfy – Titlebar P3
OPTIONS ON CLOSE APPLICATION STOP
OPTIONS ON CLOSE APPLICATION CONTINUE
OPTIONS ON CLOSE APPLICATION CALL function
OPTIONS ON CLOSE APPLICATION KEY key_name
STOP Action = The application will halt execution when the user presses the ‘X’ button.
CONTINUE Action = The application will not respond to the user pressing the ‘X’ button.
CALL Action = The specified function name will be called when the user presses the ‘X’ button.
KEY Action = The specified keypress will be sent to the application when the user presses the ‘X’ button.
GUIfy – Statusbar P1
Classic 4GL has no concept of a statusbar
In GUI, ERROR/MESSAGE statements and
field comments are displayed to the statusbar
by default
Dialog/Message boxes can be displayed by
using the fgl_winmessage() & fgl_winbutton()
functions.
Ringmenu comment text is displayed in the 4gl
line, but can also be redirected to the
statusbar
GUIfy – Statusbar P2
Exists only for floating/windowed Windows
Is Used for:
Error/Messages & Ringmenu comment
Side Effect:
Increases Window height
Can be hidden using the theme
GUIfy – Statusbar P3
Recommendation
Replace error/message statements which impact
the user with fgl_winmessage() statements
Keep in mind that the statusbar text will be
overwritten by the next statusbar text update.
Keep in mind that the user may not notice a
message or error in the statusbar.
GUIfy – Options
ACCEPT KEY
Escape key is no longer a natural accept key
(ENTER)
AUTOREFRESH
1 = Display updates must be invoked implicit in the
code
2 = UI situations (input, prompt, menu)
refresh/update the display
3 = Every screen instruction will be refreshed
imediatly
Implicit call ui.interface.refresh
GUIfy – Toolbar
Classic 4GL has no concept of a toolbar
Toolbars can be defined in forms and in the
4gl code.
Toolbar buttons are simply associated with
key/action events. If the assigned event does
not exist in your 4gl logic, the button will be
hidden or displayed disabled depending on
your theme.
Toolbar buttons can be dynamically defined
globally or on a code block (i.e. input) scope
GUIfy – GUI interaction Events
By default, a double mouse click on a display
array line triggers the ACCEPT key event.
The developer can assign a rich set of events
to any graphical object on a form (inField,
outField, moveOver, click, double click…)
Each of these form model events can trigger
Key press
Action event
Function call
GUIfy – Dialog/Message calls
fgl_winbutton()
fgl_winmessage()
fgl_winprompt()
GUIfy – Other
Resource Management
Theme Designer
Combo List (Include)
Easy to adopt widgets (without changing your
program logic)
Input field order constraint
GUIfy – BLOB handling
Many standard File Types downloaded directly
from the server or in Form of a BLOB can be
viewed using the embedded File Viewer
A configuration file allows you to assign file
extensions to file types and a corresponding
application (Editor) which can also view &
modify this file.
The corresponding file editor can be launched
with a button click.
Text can be modified without an external editor
Architectural Diagram ‘BI’
Language compatibility
Language compatibility
