1. 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

2. 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

3. Architectural Diagram

4. Example: Modernized Screen 1

5. Example: Modernized Screen 2

6. 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!

7. 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

8. 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

9. Security
 SSL Encryption
 Support for Asymetric Keys
 Operating System and PAM Based User
Authentication
 Centralized Server
 True Three-Tier Architecture

10. 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…)

11. 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

12. 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.

13. LyciaBI – Graphical Reporting 2
 Graphical reports supporting many formats

14. 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

15. 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.

16. 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.

17. 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.

18. 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.

19. Integrated BLOB Viewer
 Graphical clients have got an embedded
BLOB Viewer.
 An external BLOB Editor can be associated.

20. 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.

21. 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.

22. 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
 …

23. Toolbar and Mouse Context Menu

24. 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

25. 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

26. 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.

27. 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

28. 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)

29. 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

30. 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)

31. 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

32. 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

33. 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)

34. Lycia II - ThemeDesigner
 Graphical tool to manage the look and feel of
your 4GL application

35. 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.

36. 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)

37. 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

38. 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

39. Contact Us !
 Web Demo?
 Site Visit?
 Quotation?
Querix (UK) Ltd. Begooden-IT Consulting
Querix House, 50 The Avenue 5, Rue du Lycée
Southampton S0171XQ F-29120 Pont l’Abbé
United Kingdom Phone: +33 (0)2 98 51 32 10
Phone: +44 2380 232345 info@fr.querix.com
sales@querix.com http://www.begooden-it.com
http://www.querix.com

40. Appendix
Drilling down into more detail

41. 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.

42. 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.

43. 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.

44. 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

45. 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

46. 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)

47. 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.

48. GUIfy – Window Style P4
 Window decorations can also be defined in the
theme
 Example Window styles

49. 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

50. 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.

51. 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

52. 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.

53. 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

54. 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

55. 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.

56. 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

57. 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

58. 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

59. GUIfy – Dialog/Message calls
 fgl_winbutton()
 fgl_winmessage()
 fgl_winprompt()

60. GUIfy – Other
 Resource Management
 Theme Designer
 Combo List (Include)
 Easy to adopt widgets (without changing your
program logic)
 Input field order constraint

61. 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

62. Architectural Diagram ‘BI’

63. Language compatibility

64. Language compatibility