Lianja™ Development Roadmap

LIANJA 5.5.1 IS NOW AVAILABLE

AVAILABLE FOR WINDOWS AND LINUX (MACOS COMING SOON)

VISIT THE LIANJA ONLINE STORE NOW

The following represents an overview of the main features that are actively under development by the Lianja Development Team. We'll do our best to update this roadmap as our developers continue their work.

Lianja is a community driven development project so if there is anything specifically that you would like to see supported in the product that you do not see on this list then please submit an enhancement request.

We value your feedback so if you find anything that does not behave as expected please submit a ticket so that we can get it fixed. If we don't know about them they won't get fixed!

If there is something on the roadmap that you would like to see pulled forward in time, these can be developed as sponsored features.

Development Milestones

Development Roadmap Revision History

The development roadmap revision history can be found here.

Lianja App Builder 1.0 Release

Released 3-Feb-2014

The version 1.0 release includes.

Final release of Lianja App Builder for the Desktop on Windows, Linux and Mac.
Available editions; Student, Standard, Professional, and ISV.

Lianja App Builder 1.1 Release

Released 15-Apr-2014

The version 1.1 release includes.

BROWSE/Grid big data performance improvements with automatic grid pagination.
Added the ability to programmatically switch in and out of fullscreen mode using Lianja.fullscreen = 1 or Lianja.fullscreen = 0 respectively.
Added a new icon to the header bar in the "Apps" and "Library" workspace to "Deploy this file to the cloud directory". This provides a way to do a quick change on a file and deploy it.
Added "Tablet App View" and "Phone App View" icon to the header bar. These together with the "Web App View" allow you to view how the App looks in a desktop web browser, Tablet and phone. Each "View" is live against your development data just as the Desktop App runtime View operates. There is also a "Mobile Tools Bar" down the left hand side of each view with a variety of icons that can be clicked to perform view specific operations such as "Refresh", "Save", "Orientation", "Preview" and at the bottom a "Settings" icon for configuring the App specific to that view. More to come.
Added "Debug" support for "Web", "Tablet", and "Phone" Apps. Just click the "Debug" icon in the "Tool Bar" on the left of the view to popup a Web Inspector which includes a DOM inspector and a JavaScript debugger.
Added the ability to hide the icon in the page header bar for web/tablet/phone Apps. This can be set to "Default", "None" or "Custom" in the App settings.
Added new page attribute "Stretch last section min height". On low resolution devices (e.g. phones) if the "Stretch last section" is checked and the section height is less that the "Stretch last section min height" then the section height is set to the specified value and the page automatically becomes scrollable.
Added new documentation tiles "jQuery Mobile" and "PhoneGap".
Added a new attribute for Grid sections "Show logicals as CheckBoxes". The default is to display a CheckBox for logical/boolean values in the grid.
Automatic HTML5 and JavaScript code generation of the Lianja Mobile Client for an App specifically tailored for phones with a small real estate.
Added some new UI Presentation Rules to the Page, Section and Field attributes dialog. You can now specify the UI element (page, section, field or gadget) to be included in the HTML5 JavaScript client depending on "Desktop", "Web", "Tablet" or "Phone". This simplifies the building of one app that will run on all devices.
New "Search Panel" that can render a custom search form specific to a section. This is shown when the search icon is clicked for a section. There are also some new actions on showDocument() to hide and show the search panel underneath the section header. These are action=showsearchpanel, action=hidesearchpanel and action=togglesearchpanel. Just specify these on Lianja.showDocument("page.section?action=togglesearchpanel"). If you specify "Auto create" in the search panel section attributes then the search form will be created automatically based on the "Search panel fields" in a form and also in a grid. This provides the ability to query subsets of data to view without having to write any code. This will be made available in desktop, web, tablet and phone apps.
Added some new properties to the "Container" class. border, borderWidth, borderColor, borderTop, borderTopHeight, borderTopColor, borderBottom, borderBottomHeight, borderBottomColor, borderLeft, borderLeftWidth, borderLeftColor, borderRight, borderRightWidth, borderRightColor, borderInset.
Added "Build a Desktop installer" for packaging up desktop runtime apps for deployment. This is now integrated into the "Deploy" workspace.
Added some new attributes to "Grid Gadgets" allowing the OK/Cancel and/or the ActionBar to be hidden.
Added an optional third parameter to "NetworkRequest" class postData() method which is a filename that the result from the HTPP request will be written into.
Made various enhancements to the "Deploy" workspace to simplify deployment of Desktop, Web and Mobile Apps.
Fixed an issue when trying to run the debugger with no App open and/or no custom libraries specified.
Fixed a random issue with MySQL int columns when the MySQL ODBC driver was not behaving as expected.
Added an additional (optional) parameter to postUrl() which will allow you to specify a filename where the result sent back from the remote HTTP server is stored.
The following functions have been enhanced to now handle JavaScript (.js files), PHP (.php files) and Python (.py files) in addition to their original functionality. This makes it easier to integrate existing JavaScript, PHP or Python libraries in with Lianja/VFP code and call functions in them using the execJavaScript(), execPHP() and execPython() functions respectively.
loadLibrary( filename )
require( filename )
require_once( filename )
Added two new functions to simplify querying XML data (strings or files containing XML). These are based on XQuery syntax. XQuery is designed to query XML data and XML files.

result = xquery( string, path, occurrence)
result = xquery_file( filename, path, occurrence)

These currently only handle paths such as /tag/subtag/subsubtag... but they will be extended later to include proper querying as per the XQuery standard. You can iterate through an XML file in a loop which increments "occurrence". An empty string is returned when there are no more occurrences. If you do not specify a path in the /tag/subtag/... notation then the contents of the specified XML tag will be returned. These functions are particularly useful when reading XML data from web services using geturl() or the "NetworkRequest" class.
The GETFILE(), PUTFILE() and GETDIR() functions now use the native functions on Windows providing a more consistent user experience on Windows 7 and Windows 8. Linux and Mac already used the native functions in v1.0.
The Lianja APaaS Developer edition license now allows remote Lianja Cloud Server connections (up to 10 connections) so that Web, Tablet and Phone Apps can be tested properly. In v1.0 the APaaS Developer license restricted Lianja Cloud Server connections to local connections only.
Added a new "Subtitle" to sections. This can be made visible in the section attributes. There are also attributes for specifying its height, background color, foreground color, font and caption. It is displayed just above the section contents beneath the menu and search panel. If you specify "Hide header" to hide the section header at runtime you can arrange the sections out with nice subtitles which provides a better user experience.
Improved page scrolling for pages that have many sections and do not "Stretch Last Section". The mouse wheel (or swiping up and down on a tablet) correctly scrolls now.
Added a new attribute in the page attributes "Full page edit". This causes all sections on a page to be edited when the "Edit" tool button is clicked in the navigation bar (at the bottom) or the page is switched into edit mode using Lianja.showDocument("page":page1?action=edit"). This provides for a better user experience when a page is laid out in multiple sections and you want to edit the complete "DataView" as opposed to just the main form section that has the "Search Key" field defined.
Fixed an issue with GETDIR() not selecting the given directory correctly.
Fixed an issue with Lianja.spawnApp( filename ) not running Lianja/VFP (.prg) files correctly.
Fixed an issue whereby runtime deployment required the .prg source files in a few places. Now you just need to package up the .dbo object files that are generated by the compiler.
Added support for SET XMLTYPE TO EXCEL and COPY TO TYPE XML on the Mac. This is already available on Windows and Linux.
Added a new grid attribute "Alternating row colors" to allow turning these off if required. This is in the grid section attributes dialog.
Added a new function execRSP( page.rsp, outputfile.html) that will execute a Lianja/VFP server page (.rsp file) and send its output to the specified html file. This can be used effectively for generating HTML reports that can be emailed using the built-in email functions.
Added a new function execJSSP( page.jssp, outputfile.html) that will execute a JavaScript server page (.rsp file) and send its output to the specified html file. This can be used effectively for generating HTML reports that can be emailed using the built-in email functions.
When deploying files through the "Deploy" workspace, if the object file does not exist it is now automatically compiled.
Added printPreview() as a new method on the WebView class. This operates similar to print() (and takes the same arguments) but displays a print preview dialog first allowing you to change settings before printing.
Simplified layout for the "Data", "Apps", and "Pages" workspaces for improved usability on low resolution devices.
Added two new grid column attributes "Dynamic backcolor" and "Dynamic forecolor". These can be simple expressions or can call functions in custom libraries. For example, if you want to display all negative values with a "red" background and a "yellow" foreground you could just specify the following simple expressions for the dynamic cell backcolor and dynamic cell forecolor respectively. Note the use of the {} macro that always substitutes the "current item value". Hint: you can also use the icase() built-in function if you want to have varying colors depending upon the current cell value.

iif( val("{}") < 0, "red", "") iif( val("{}") < 0, "yellow", "")
Added the ability to exclude specific grid columns from being "striped" when the grid has "Stripe alternate rows" enabled.
Added a new grid column attribute "Recalculate". When data is entered into a grid cell interactively any readonly or calculated grid columns on that row are automatically recalculated and re-displayed. This is typically used to calculate totals e.g. if you have three columns; Quantity,Price,Cost and "Cost" is calculated by quantity*price, then as you change either quantity or price the "Cost" column in the grid row will be recalculated.
Added a new field (form and canvas sections) attribute "Recalculate". When data is entered into a field interactively any readonly or calculated fields are automatically recalculated and re-displayed. This is typically used to calculate totals e.g. if you have three columns; Quantity,Price,Cost and "Cost" is calculated by quantity*price, then as you change either quantity or price the "Cost" field will be recalculated and refreshed.
Fixed an issue displaying and editing numeric grid columns which have input masks.
Added a new grid column attribute "Text alignment" which allows for control over how data is displayed in grid columns. Set this to "Left" if you want to align CheckBoxes in a small column width.
Added the ability to set a grid column to be a fixed width in the grid column attributes.
Added a new "Timer" delegate to sections (in the attributes). If the "Refresh Interval" is specified and a timer delegate exists it will be called rather than just refreshing the section. This is only active in runtime mode. It is particularly useful for refreshing dynamic content in Canvas and WebView sections at given intervals. This is implemented in Desktop, Web and Mobile.
Improved "Input masks" in Forms and Grids. Numeric pictures e.g. 999,999,999,999.99 or @C2 correctly display with the thousands separators and provide better field editing.
Added "Input mask type" to formitem and grid column attributes; Custom (the default), "Currency", "Date", "Email address", "Number", "Text", "Time".
The "fontsize" property on all objects can now take either a numeric size (as previously) or you can use the CSS font-size string values; "small", "medium", "large", "x-large", "xx-large". These are particularly useful when designing responsive web and mobile apps.
Added the "right" and "bottom" properties in all UI components. These are particularly useful when building responsive UI canvas and custom sections in JavaScript for tablets and phones. So rather than set the geometry of the UI control using left,top,width and height if you use left,top,right and bottom the control will adjust its size on different devices or orientation changes on a tablet or phone.
Added a new method the Lianja System Object; Lianja.getCursor( aliasname ) that returns a "Cursor" object that can be used from any of the supported scripting languages.
Fixed various bugs from reported tickets.

Version 1.1.1 Released 17-Apr-2014

Fixed various bugs from reported tickets.

Version 1.1.2 Released 25-Apr-2014

Fixed various bugs from reported tickets.

Version 1.1.3 Released 04-Jun-2014

Added a new "Initial UI state" attribute for App, Page, Section and Field. When an App is switched into runtime view the initial UI state is applied. This provides the ability to design the App visually and hide various UI elements until they need to be shown.
New "Custom Actions" for pages. These can be optionally specified in the page attributes. This enables you to call app specific business procedures that handle the page actions (Add, Delete, Refresh, First, Previous, Next, Last, Save, Cancel) when you navigate data (by clicking buttons in the Action Bar or when you call Lianja.showDocument() ) and you want to handle these programmatically.
Script editor performance improvements on large files.
Improved color syntax highlighting in the script editor.
Added popup "IntelliTips" (intellisense-like functionality) as you type in the script editor.
Added a new attribute to App settings, "Initial Page". If specified the specified page is selected when the App is switched into runtime mode.
Fixed a few issues that were reported when importing VFP tables into Lianja.
Made a few minor UI changes e.g. The "Data" panel tabs for Database,Tables,Procs, and Events are grouped together to avoid confusion. The "Advanced" section in the App,Page,Section and Field attributes is now labeled as "Custom Delegates".
Added a progressbar when importing large ODBC databases to provide feedback as to the progress of the import.
Added a "Change" delegate for pages. When any data is edited in a field the "Change" delegate for the field is called (if present) then this calls the "Change" delegate for the section (if present) then this calls the "Change" delegate for the page (if present).
Added the VFP sys(2007, expC) function.
Added CRC32( expC ) to calculate the CRC32 of the given expression. Use CRC32(RTOS()) to calculate a CRC32 checksum of the current record.
Fixed an issue importing large MSSQL tables with large varchar columns.
Added the ability to display form fields and grid columns as hyperlinks. There is a new LinkClick delegate that is called with the controlsource and the text value of the field as arguments when the hyperlink is clicked (or touched).
Added the ability to display grid cells as Buttons. When the button is clicked the LinkClick delegate is called with controlsource,text just as a hyperlink delegate is called.
Added the ability to display grid cells as "Custom controls".
Added "Insert Before" and "Insert After" to the right-click context menu in the grid column headers.
Performance improvements.
Added the ability to "Total" grid columns as a summary row at the bottom of grid sections. The "Summary" attribute in the grid section attributes can be checked on and then you can specify what columns should be totaled in the grid column attributes (double click on a grid column header). You can optionally specify an expression (a function call) that will be called to calculate the value to be displayed.
Made a small change to the requery() method in the CursorAdaptor (for use with Virtual Tables). If you requery("limit 20,50") then you can paginate the data from the remote data source (if the remote database engine supports the LIMIT clause; MySQL, Lianja and PostgreSQL do, MSSQL does not). This allows you to specify an empty Virtual Table using WHERE 1=0 and provides you with the ability to handle data retrieval manually in the "Ready" delegate or from your own UI buttons in your Apps.
Fixed various bugs from reported tickets.

Version 1.1.4 Released 16-Jun-2014

Added some new "Input masks". "Alphabetic", "Upper Case", "Upper Case Alphabetic".
Fixed an issue activating a "Standard Edition License".
Fixed an issue changing the "Caption width" in a Canvas section control.
Enhanced "Section footer menus" to support Buttons. e.g. #Save,Cancel will center the two buttons in the section footer.
Fixed various bugs from reported tickets.

Version 1.1.5 Released 18-Jun-2014

Fixed an issue with layout of the Script Editor on low resolution displays with small font settings.
Fixed various bugs from reported tickets.

Version 1.1.6 Released 02-Jul-2014

Fixed an issue whereby empty dates were displayed correctly as "None" but the popup calendar was not defaulting to the current date.
Exposed some new methods on the "Grid" to make it easier to customize its operation; save(), cancel(), add(), delete(), first(), previous(), next(), last() and refresh(). Additionally, the "filter" property can now be get/set in custom code.
Added support for App "Themes". These are in c:\lianja\themes on Windows. You can create custom themes and apply the theme to all pages/sections at any time. The Lianja.theme property also provides the ability to change the theme at runtime so users can adjust the theme to their personal preference.
The App Inspector now includes a trace in the "Events" tab when Lianja.showDocument() is called by custom code or inline delegates. This has been added to assist in debugging so you can better see what is going on "behind the scenes".
Fixed various bugs from reported tickets.

Lianja App Builder 1.2 Release

Released 11-Aug-2014

Added several new command line switches that can be used with the Lianja App Center.

--rdp
This will display the login screen with a plain background (no image) and the progress bar when loading an App is not displayed.

--kiosk
This will run the Lianja App center (and login) in full screen kiosk mode with no window frame or title bar. This prevents users from minimizing the window and breaking out of your App in RDP sessions and information kiosks.

--customer name
This will be used as the suffix to display a customized login file and a customized appcenter file. You can copy the existing login.rsp and appcenter.rsp in the c:\cloudserver\appcenter directory and customize these with your own login captions and icons. The name is a suffix that will be appended onto the login.rsp and appcenter.rsp filenames e.g. --customer myco will look for login_myco.rsp and appcenter_myco.rsp respectively.

--loginapp appname
This will load the App immediately after login without displaying the Lianja App Center. This provides you with the ability to replace the Lianja App Center with your own that you have written as a Lianja App or alternatively run an App directly after login bypassing the App Center.

--splashscreen none
This will not display the splashscreen when loading the Lianja App Center. This provides better performance when RDP clients are running Apps across the internet. You can also specify the full path to your own spashscreen if required in place of "none".
Fixed a layout issue with the "Visible when" presentation rule for fields in form sections that have gadgets in them.
Added new "presentation rules" for Grid columns; Desktop, Web, Tablet, Phone. Unchecking any of these will hide the columns when displayed on the respective device.
Added new "presentation rule" for Grid columns "Display orientation" which can set set to "Always", "Portrait" or "Landscape". On a tablet or phone as the device orientation changes then UI elements can be hidden or shown to provide a more responsive UI.
Added a new "Page/Section/Field" attribute called "Apply rules". If this is checked then when navigating between records or when editing interactively all the "Visible when" and "Readonly when" UI Presentation Rules for the page (and it's sections and fields) containing the field are applied. This functionality is only active in runtime mode.
Double clicking the "Page header" now slides in the "Page attributes" dialog just as double clicking the "Section header" slides in the "Section attributes".
Now supports macro substitution up to three levels deep using {expression}, {{expression}} and {{{expression}}} which can nested. Macros are evaluated inside out from left to right starting with {{{...}}} followed by {{...}} then finally {...}.
Fixed an issue where section custom search panels were not being displayed correctly when the delegate to generate them was edited in a custom library.
The captions for the fields/gadgets in form sections can now contain {...} macro expressions. They are re-evaluated and refreshed whenever the section is refreshed or when a field is changed interactively that has the "Recalc" atttribute checked.
The captions for the fields/gadgets in form sections can now be formatted with html. This includes html tables which can be used very effectively to display summary information for the active record displayed in the section Inside subtitles.
Added getJSON() as a method on pages and sections to return a JSON formatted string. This has the same functionality as the getJSON() method that is available in the LianjaWebFramework.
Added a new attribute to the App Settings "Runtime database". This provides the ability to develop an App against "local" Virtual Tables (you can import these into a development database) and then when the App is generated as an HTML5 JavaScript Web/Mobile App the runtime database is used in production.
Added a new attribute in the App Settings "Build mode". When generating the HTML5 JavaScript Web/Mobile App if "Release" is selected then the LianjaWebFramework is included into the client compressed and minified for production deployment. You should select "Debug" when developing and testing your Apps so that you can open the Web Inspector and use the JavaScript console and debugger.
Added the json_encode(object) and json_decode(jsonstring) functions into Desktop JavaScript.
Added the following new methods to the page and section object that is returned from Lianja.get()
add()
delete()
refresh()
first()
previous()
next()
last()
edit() / editmode()
save()
cancel()
applyRules()

These correspond to the actions that can be given to showDocument() but do not change the active page, they merely perform the action on the hidden page.
Added additional information in the "Events" Tab of the App Inspector. Specifically, you can now see when "refresh" of pages, sections and gadgets is occurring to assist in performance tuning of your Apps.
Performance improvements with related parent/child grids.
Added a new attribute to the "Calendar" section "Readonly" which hides the form at the top of the calendar and displays the calendar in readonly mode. This provides the ability to place a custom/canvas section above the calendar to provide better customization. You would typically enter events in your canvas section and have some buttons that perform CRUD operations in a table then you would refresh() the calendar section to display the new events.
Page header captions can now contain {...} macros which are refreshed as you navigate between records.
Added Lianja.lockscreen to the Lianja system object to disable then re-enable screen updating.

Lianja.lockscreen = 1 // disables screen updates
Lianja.lockscreen = 0 // enables screen updates
Added a new SQLLOOKUP() function. This operates in a similar way to the KEYLOOKUP() function but uses SQL SELECT so the table specified does not have to be open. The function will autodetect if the specified table is a native Lianja table or a Virtual Table and act accordingly. It can be used to perform cross-table lookups in validation or data mapping. The arguments are as follows:

result = sqlLookup(cTable, cKeyField, cKeyValue, cResultExpr, cNotfoundExpr)

cTable as a character expression to specify the table to be queried (native or Virtual Table).

cKeyField is a character expression to specify the column in the table to be queried.

cKeyValue is a character expression containing the value to be compared against cKeyField. If this is a character field then enclose it in "'somevalue'". If it is a numeric then enclose it like this "1".

cResultExpr is a character expression to specify what to be returned from the query. This can include LianjaVFP functions as it is evaluated against the record returned from the query.

cNotFoundExpr is a character expression that will be evaluated and returned if no record was found that matches the query.

The current state of all active cursors is saved and restored automatically so that you can query tables that are already open.

cKeyField has some special ways in how it can be specified above and beyond what is described above.

If cKeyField is a valid where clause (starts with "where ") then that will be used as the where condition for the SQL SELECT statement that is executed.

If cKeyField is a SQL SELECT statement (starts with "select ") then that will be used as the complete SQL SELECT statement that is executed.
Fixed an issue editing the time portion of a datetime field.
The Lianja App Builder APaaS Developer license now supports up to 50 concurrent cloud connections (previously was only 10). This enables local and remote users to connect in to the Lianja Cloud Server (which you install alongside the Lianja App Builder on the same machine) and use up to 50 connections which equates to 8-10 users.
Added special keys in development mode for fast switching between the various workspaces.
Ctrl+F1 Home
Ctrl+F2 Apps
Ctrl+F3 Data
Ctrl+F4 Pages
Ctrl+F5 Library
Ctrl+F6 Tools
Ctrl+F7 Versions
Ctrl+F8 Console
Ctrl+F9 Users
Ctrl+F10 Deploy
Fixed an issue where LianjaVFP triggers that were created for Virtual Tables were not being called correctly.
Fixed an issue whereby the data dictionary for a Virtual Table was being removed when the Virtual Table was closed.
New App Wizard when creating a new App.
Fix various bugs from reported tickets.

Version 1.2.1 Released 01-Sep-2014

Enhanced Calendar sections to provide the ability to dynamically set the background color for the days and the type of events within each day that are displayed in the calendar.
Automatically detect locale for Chinese, Japanese, Korean, Russian, Indian, Arabic and other languages and use UTF-8 if --locale is not specified on the command line switches. This is the best character encoding to use for apps that contain multiple languages as it is used by web browsers as well so data can be shared across desktop and web/mobile apps. Note that you need to install language fonts for these characters to be displayed if you are on a computer that is not in the language locale. In Windows you do this through the control panel.
Added the following VFP functions to handle Unicode/UTF-8 character processing. You can now use the following functions with Chinese, Japanese, Korean etc character strings. LENC(), LEFTC(), RIGHTC(), AT_C(), RAT_C(), SUBSTRC(), CHRTRANC(), STUFFC().
Improved UI fonts and graphics rendering on the Mac.
Added a new command line switch --networkshare which simplifies the sharing of databases hosted on a linux server that are shared between windows clients and linux clients. SET NETWORKSHARE ON is the equivalent if you need to do this in code.
Added a new function DIFFOBJ(obj1, obj2) that compares two objects which have the same property names and returns an object containing only the members that are different.
Enhanced the Lianja/VFP SCATTER command with a new keyword OLDVALUES that places the old buffer values into an object that can be compared with DIFFOBJ() to return an object containing only the changed field values. e.g. SCATTER OLDVALUES NAME m_oldvalues.
Fixed a memory buffer overflow when importing large ODBC data sources containing Unicode characters.
Added a new gadget "EditBox" in form sections for editing plain text with no HTML formatting.
Various performance improvements when using Virtual Tables.
Added a new "Quick Start Guide" dialog when the App Builder is first run. You can disable this in the dialog and view it again from the "View" menu. This is primarily to assist new developers to better understand how to build Apps in a Lianja.
Added the username() function into JavaScript for desktop and Web Clients.
Fixed various bugs from reported tickets.

Version 1.2.2 Released 09-Sep-2014

Fixed a crash when SQLLOOKUP() has a syntax error in the SQL SELECT.
Fixed a random crash when an .rsp page fails to compile under certain conditions.
Fixed an issue where data was not being saved correctly as utf-8 in databases when --locale utf-8 was specified. Now, if the locale is utf-8 the data stored is in utf-8 format in both web and desktop to maintain the correct collating sequence for indexes.
Fixed an issue generating HTML5 web apps with foreign character sets which were used as TabView captions.
Added a dynamic "Where condition" attribute to sections. This can be used with Virtual Tables that have been created as SELECT * FROM table WHERE 1=0. The where condition can contain {...} macros to reference values from other sections or variables. This provides for a much faster user experience when working with very large external database tables. You can reference the "where" attribute using Lianja.get("page1.section1").where = "condition" or Lianja.showDocument("page: page1.section1?action=where&text=condition").
requery() is now supported in JavaScript cursors for Virtual Tables.
Fixed an issue using the Microsoft VFP ODBC driver with Virtual Tables that have logical fields.
Fixed various tickets.

Version 1.2.3 Released 10-Sep-2014

Fixed an issue editing scripts that contain Unicode/UTF-8 characters for Chinese, Japanese, Korean, Russian character sets. You don't need this update if you aren't editing scripts containing these characters in your scripts.

Version 1.2.4 Released 27-Oct-2014

Fixed an issue with the "Readonly when" UI presentation rules which were not disabling the pages, sections and fields correctly.
Added support for dynamic roles and permissions. These override the static roles specified in an app,page.section,field and are assigned when a user authenticates. They are only effective in runtime mode. These permissions are maintained in the system!sysperms table and are setup in the "Users" workspace.
Fixed an issue whereby the "Click delegate" in the calendar section was not being called correctly when the delegate was written in JavaScript. This issue was in desktop and web apps.
Fixed an issue which caused the "EditBox" UI element to incorrectly return rich text rather than plain text.
Fixed an issue whereby a right click on a "CommandButton" was also calling the "Click" delegate afterwards.
Added the "Lianja Page Center". See this forum post for details.
Added a new section attribute "Apply rules on parent data change". This causes the UI presentation rules to be evaluated dynamically as you navigate data in the parent section. You can therefore hide/show other related sections based on the data that is being displayed in the parent section. Note that when the UI presentation rules are applied the "Visible When" and "Readonly When" conditions are evaluated. This is only effective in runtime mode.
Added the ability to dynamically sort the data displayed in a grid by clicking on the grid column headers. This is implemented in both desktop and web clients. There is a new grid section attribute "Sortable" which you can check to enable this on a grid.
Added "RightToLeft" as a caption position in Form and Canvas sections for both desktop and web to better support RTL languages such as Arabic.
Fixed an issue which was causing COM/ActiveX controls not to be destroyed when the object variable was destroyed.
Fixed an issue where "UI Presentation Rules" were not being applied correctly inside "TabView" sections.
Enhanced the "Choicelist" SQL SELECT processing. if you prefix the SELECT statement with a + then a blank entry will be added at the top of the list of items if the column count is one. This allows the user to reset the bound data contents and also enables selection of a choice list item when there is only one record returned from the SQL SELECT.
The icon specified for an App tile is now deployed automatically and displayed in an App Center tile in both desktop and Web. Note that the optimum size for an App tile icon is 96x96.
SQL Optimizer improvements.
Enhanced sqlLookup() so that the first parameter "table" can be qualified by the "database" e.g. "southwind!customers". This provides the ability to use it in client-side validation in the Web/Mobile clients. Be sure to create an index on the specified column that is being queried so that the optimizer can do its job properly.
Included over 1500 "Modern" icons in the library\icons directory. These can be used as the icons for App Center tiles and Page Center tiles. You reference them like this in the attributes lib:/icons/name.png.
The system!sysroles table now includes a column for the "Name" of a user which can be used when emailing then. This new column will automatically be added to the sysroles table when you run the App Builder. You will then need to "Deploy" the "System" database to be able to use it.
Now includes an additional example App for registering users through a Web App. This App demonstrates how to build a client form using a Canvas section that calls server-side procedures that serialize and pass data between the Web/Mobile client and the Cloud Server.
Improved the layout of "Inline gadgets" in Form sections.
Improved the handling of non-editable choicelists and ComboBoxes.
Fixed various tickets.

Lianja App Builder 1.3 Release

Released 04-Feb-2015

Improved COM/ActiveX support for subobjects that were not being returned correctly with certain ActiveX components.
new STR_ESCAPE() function
- escapes single quotes as '' to enable embedding within strings
- disallows embedded SQL statements in strings to prevent SQL insertion attacks
new command; SET STRCOMPARE ON|OFF
- auto trim of strings
- case insensitive string comparisons
- case insensitive index lookups
- improves SQL query optimizations
ALTER VIRTUALTABLE enhancements
- ALTER VIRTUALTABLE clauses now just update the clause in the Virtual Table definition. e.g.
- ALTER VIRTUALTABLE vt_tablename CONNSTR "newconnectionstring"
- ALTER VIRTUALTABLE vt_tablename ADDPROPERTY "name=value"
- ALTER VIRTUALTABLE vt_tablename REMOVEPROPERTY "name"
- ALTER VIRTUALTABLE vt_tablename MODIFYPROPERTY "name=value"
- ALTER VIRTUALTABLE vt_tablename PROPERTIES "debug=1"
- ALTER VIRTUALTABLE vt_tablename PROPERTIES "keepalive=1;ttl=30"
USE vt_name WHERE ... now uses SQL passthru
USE vt_name AS ... now uses SQL passthru
OData_Create(), OData_Read(), OData_Update(), OData_Delete() functions now handle Virtual Tables
Enhanced the "Navigation Panel" configuration files to handle collapsible sub panels and subtitle color specs
SAVE/RESTORE DATASESSION now handle saving and restoring the state of Virtual Tables as well as native tables
Added a new parameter to the TTOC() function; TTOC(datetime(), 4) to return the datetime in ISO 8601 format i.e. YYYY-MM-DDTHH:II:SS.000Z
Added "Click" and "DblClick" delegates to the "ImageStrip" section.
Enhanced Lianja.showDialog() and Lianja.showDialogPanel() to allow dynamic generation of the content by specifying a .rsp page, a .jssp page, a custom function or a .html/.php/.aspx page.
Added several new functions; appdir(), libdir() and datadir().
Added a new console command 'pwd' to print the current default directory.
Added new function userFullName( ) to return the full name of the logged in user. The other functions that can be used to obtain current user information are; userName(), userEmail(), useRoles(), userDomain(), userTenancy(). Each of these can optionally be given one parameter which is a username. This information is all setup in the "Users" workspace.
Fixed an issue where after logging out and then logging in as a different user, the App Builder was not showing the ModeBar on the left of the main window until an App was opened.
Added the ability for a grid section to have "Multi Select Rows". This displays a checkbox column for each row. As the user clicks a checkbox, the "selectionChanged" delegate is called with a comma separated list of values. These values are determined by the "Multi Select Row Expression" e.g. You can multi select rows in a grid and then call your own business procedure to handle app specific business logic.
Enabled the "Runtime Database" App setting in a runtime application. If this is specified in the App Settings then it will be used as the "Runtime database". This provides the ability to develop against a development database and deploy against a runtime database. See details below concerning database tenancies.
Enabled database tenancies based on the authenticated user. The "Database" used by an App for a user in a specified tenancy is postfixed with an "_" followed by the tenancy (domain) for the user specified in the "Users" workspace. For example, if the database for an App is southwind and the user has a tenacy (domain) specified of xyzco then the database used for that user will be southwind_xyzco. When the user authenticates in Desktop, Web or Mobile apps the specified database will be used rather than the default database for the App. Remember to "Deploy" the system!sysroles table and the database for that tenancy from the "Deploy" workspace. Note that if the tenancy name contains '.' or '@' characters these are replaced with '_' characters e.g. lianja.com using the southwind database would expect the database southwind_lianja_com to exist. You can "copy" a complete database to another using the COPY DATABASE command in the console or the "Copy" menu selection in the "Data" workspace.
New data bound "Org Chart" section type that displays an organization chart graphically. This "Org Chart" can be used to grahically represent a workflow as well as an "Organization hierarchy". It is fully configurable with dynamic tile contents and colors. The content can contain hyperlinks to perform any operation on the LOM (Lianja Object Model) such as opening other apps, selecting different pages or searching and editing related information stored in other tables.
Fixed a random crash when an error occurred during .rsp dynamic page rendering.
Fixed a crash when creating and loading a table from an ADO format XML file.
Fixed an issue that was causing Unicode/utf-8 (chinese) characters not to update correctly in the Web/Tablet/Phone App Views. This was not an issue in desktop apps or deployed web/tablet/phone apps, just in the development "views".
Fixed an issue when using Python scripting when an incompatible version of Python was already installed prior to installing the App Builder. Lianja will now correctly use the embedded Python version and existing Python installations will not have any adverse effect on it.
Added two new "Advanced" canvas section controls; "LCD Number" and "Progress Bar". The "Progress Bar" has several attributes that can be set in delegates; "minimum", "maximum" and "value". It can used to provide user feedback during long operations. The "LCD Number" displays an LCD style label with a segmented numeric value like an LED display.
Fixed a crash when loading a new App using Lianja.openApp() from inside a modal dialog button click event.
Added a new section type "Page Center" with a new attribute "Custom title". This provides the ability to have a custom Page Center page with other sections above or below it e.g. a custom section with a clock or user login information above it and a news ticker underneath it.
Added a new function inputEvents(). You can determine in a timer if there has been no keyboard or mouse/touch activity and logout or return to the App Center or Page Center (or whatever page you want). This can be used to handle App inactivity timeouts at runtime.
Added a new App delegate "Inactive" which is called in runtime mode if the "Inactive interval" has expired and no input events have occurred (key presses, mouse events or touch events). This provides the ability to auto-logout an inactive user.
Added a new "Advanced" canvas section control; "Slider". The "Slider" has several attributes; "Orientation", "Tick position", "Tick Interval", "Mimimum value", "Maximum value" and "value" which can be set/get in a delegate and optionally be data bound. The "Change" delegate is called as the user changes the slider interactively.
Added Lianja.beep() to sound a short "beep". This works in Desktop, Web and Mobile Apps.
Section footer menu buttons now autoresize their height into the footer height. They can also be styled with CSS. See this forum post for details.
Now works with the Microsoft VFP OleDB driver. See this forum post for details.
Added addStretch() as a method on containers. If the container has a layout i.e. "Horizontal" or "Vertical" then a spacer will be added to the container to fill up the remaining space.
Added "autocenter" as a core property. If this is set to 1 or .t. then the UI component is centered inside its parent container. This adjusts automatically as the window is resized.
Added a new attribute to the calendar section "Autosize" which will auto resize the calendar into the section viewport removing any requirement to scroll.
If a "where condition" on a grid or form section is specified and it contains {...} macros (for Virtual Tables) and the page containing the the grid/form section has "Refresh on activate" checked, then the SQL query will automatically be re-evaluated and the grid refreshed with the new query when the page is activated (selected).
The global CSS style for an App can now be specified in the App Settings.
Added a new attribute "Footer button width" to provide the ability to set the width of the section footer buttons.
If the section footer menu starts with a + then the buttons autosize horizontally into the footer menu (Tablet style buttons).
Added a new "Projects" workspace. You can now organize your Apps, Database and Library files into projects. After you open a project only the files contained within the project are displayed in the files tree of the Apps and Library workspaces. Additionally the "Home" workspace will only display Apps that are contained within the current project. When you want to deploy a project from the "Deploy" workspace then select it from the "Projects" branch in the deploy files tree and all files contained in the projects will be deployed.
The "Full page Edit" attribute on a page now causes all sections to be switched into "Add" mode when adding new records.
When rows are retrieved for Virtual Tables the "maxrecords" VT property is now enforced. So, if you only want to fetch 1000 records set the property in the VT definition as maxrecords=1000 or modify it dynamically in the underyling CursorAdaptor in your delegates.
Added some new attributes to formitems "sectionid" and "pageid" to simplify traversal of the Lianja Object Model in custom delegate code.
Added a new attribute to sections "pageid" to simplify traversal of the Lianja Object Model in custom delegate code.
The mailOpen() function has been extended and now supports ESMTP as well as POP and SMTP.
The "Deploy" workspace now has built-in SFTP support for deploying Web Apps to a remote server in the cloud.
Various other improvements
Fixed various reported bugs.

Lianja App Builder 1.4 Release

Released 17-Mar-2015

Search panels can now be used in Canvas sections.
New "Query Page" pages attribute. When this is checked no data is displayed in the page until a search panel query is applied, a filter is applied or instant search is used.
Added a new command line switch to the desktop runtime client --runtimedatadir to be able to specify the shared LAN directory where databases reside. You can alternatively set the environment variable LIANJA_RUNTIMEDATADIR. Note that when a "runtimedatadir" is specified then --networkshare is also implied and turned on.
Added "Create Local Virtual Tables" to the database context menu. This causes a virtual table (name prefixed with vt_) to be created in the database for each native table and its connection string is set to "local".
Added a new "PhoneGap" workspace in preparation for the v2.0 release.
Added Lianja.showDocument("back:") and Lianja.showDocument("forward:") in desktop/web/mobile to navigate between pages in the history.
Added $format=csv $format=ado and $format=excel as output data format types for odata queries.
Added a new "TreeView" section type.
Enhanced the page "Navigation Panel" so that the "Data source" may be a .rsp or a .jssp page e.g. lib:/treeview.rsp. See the example_jqueryui sample App to see how to specify this.
Added several new example Apps.
Minor UI improvements.
Further SQL optimizer performance improvements.
Performance and stability improvements.
Fixed various bugs from reported tickets.

Version 1.4.1 Released 20-Mar-2015

Performance and stability improvements.
Fixed various bugs from reported tickets.

Lianja App Builder 1.5 Release

Released 7-Apr-2015

Enhanced CatalogView section with "Custom library", "Tile producer" and pagination.
Added a new CarouselView section.
Added a new PanelView section.
Added --tenancy x:\ (or LIANJA_TENANCY environment variable) to simplify App Center sharing Apps, Library and Data on a LAN.
The navigation panel can now be dynamically generated by a custom .rsp or .jssp page. Set the "Data source" for the "Navigation panel" in the page attributes to the name of the .rsp or .jssp file.
Now supports a custom section menu panel that can be dynamically generated by a custom .rsp or .jssp page. Set the "Custom menu panel" to the name of a .rsp or .jssp page in section attributes "Menu" panel. This provides the ability to use modern bootstrap or jQuery mobile dropdown menus in all types of Apps; Desktop, Web and Mobile.
"Stretch last section" on a page now expands the previous section to fill available space if the last section has a fixed height specified.
Performance and stability improvements.
Fixed various bugs from reported tickets.

Lianja App Builder 2.0 Release

Released 29-Oct-2015

This is a major upgrade. The App Builder has been upgraded to the very latest version of Qt (5.5) providing a much faster and snappier user experience particularly in WebViews which can now be debugged using the Web Inspector by right clicking on them and setting breakpoints and watchpoints. This latest version of WebKit is a lot faster and provides much better HTML5/CSS3 compliance than the older versions.
New "CommentsView" section (similar to facebook commenting) that can be related to a parent section. (useful for CRM-like collaboration on records displayed in a DataView).
New "DocumentView" section. Display PDF files without any plugins required.
New animated "GalleryView" section.
Fixed an issue with sqlexec() calls that execute stored procedures. This did not affect Virtual Tables just the sqlexec() function.
Fixed touch issues in the App Center and Page Center.
The App Builder and the Lianja runtime (App Center) now have a built-in web server running internally. This provides you with the ability to write web services (or a management console) that can provide information from a running application. See this forum article for details. These web services can be written in Lianja/VFP, JavaScript, PHP or Python. This provides the ability for all desktop apps to provide an API .
New "sharedmemory" class.

myshmem = createObject("sharedmemory") myshmem.attach("com.lianja.myshmem", 64*1024) // you can optionally lock() and unlock() // if you want to access many items. // If you don't lock() it will be done for you // as you access items in sharedmemory myshmem.lock() myshmem.setItem("key", "value") value = myshmem.getItem("key") myshmem.clear() myshmem.unlock()
New "systemsemaphore" class.

mysem = createObject("systemsemaphore") mysem.setKey("com.lianja.mysem") // get exclusive access to a resource mysem.acquire() // do some work... // release exclusive access mysem.release()
New "httpserver" class. Embed a custom web server into your App that listens for requests on a port of your choice to expose information by web services. Desktop App only.

myhttpserver = createObject("httpserver") myhttpserver.listen("localhost", 8003) if not myhttpserver.isListening() // error endif myhttpserver.pause() myhttpserver.resume() // now any request for // "http://localhost:8003/desktopwebserver/dws_getsomedata.rsp?args.." // will be handled internally // to listen on all interfaces e.g. for external access // specify an empty nodename myhttpserver.listen("", 8003)
New strConv(cExpr[,codepage]) function that converts a codepage encoded character expression to its UTF-8 equivalent.
Lianja.sessionStorage is now shared in real-time across all running Lianja processes. You can now share data across multiple desktop windows and background worker processes that have no UI. There is a new delegate "Session data changed" in the App Settings that is called when sessionStorage data changes.
New Mobile-ready CarouselView section
New Mobile-ready CatalogView section
New Mobile-ready GalleryView section
Fixed an issue with SMARTQUERY (SET SMARTQUERY ON) in SQL on Windows which was not using the SQL resultset cache correctly. This is now working as expected with much improved performance.
New CONVERTUTF8 DATABASE name [CODEPAGE id] command
New CONVERTUTF8 TABLE name [CODEPAGE id] command
New CONVERTUTF8 APP name [CODEPAGE id] command
New CONVERTUTF8 FILE name [CODEPAGE id] command
ODBC Driver improvements to work properly with Crystal Reports
New SELECT * FROM table INTO ARRAYOFOBJECTS aobj to generate a one dimensional array of objects that represent rows in a table. This array can be given to json_encode() to generate a JSON encoded array of objects.
New LianjaWebFramework function called Lianja.evaluateJavaScript() for calling server-side JavaScript code. Note that the Google V8 JavaScript engine is embedded into the Lianja Cloud Server so this is the same JavaScript engine that is used in node.js. This provides you with the ability to write end-to-end JavaScript code on the client and server and generate dynamic pages with .jssp pages also.

// Server: The file myfunction.js should be in the // app or library directory and contain a function with the same // name as the file. function myfunction(arg) { // do something useful... return arg; }; // Client: Call a server-side JavaScript function called myfunction // from a client delegate var result = Lianja.evaluateJavaScript("myfunction('hello world')");

Note that if the file myfunction.js file does not exist in the app or library directory and the file server_functions.js exists then the function myfunction is assumed to be defined in the server_functions.js file.
Added several additional "Page defaults" attributes in the App settings to help speedup visual design by removing the repetitive tasks of hiding the left and right sidebars and various icons from the page headerbar.
Node.js is now included in the distribution. This is used by the phonegap live app view which is currently under development.
Fixed an ODBC driver issue
Added SELECT * FROM table INTO ARRAYOFOBJECTS CONSOLE which outputs a JSON array of objects directly in one command. You can use this effectively in custom Data Web Services written in Lianja/VFP .rsp pages.
Added a new SQL command TRUNCATE TABLE tablename [IF EXISTS]. This is the equivalent of USE tablename followed by ZAP.
SET STRCOMPARE ON is now on by default in the App Builder and the runtime App Center. This is now consistent across Lianja desktop Apps, Lianja Cloud Server, and Lianja SQL Server.
SQL JSON data type (using CREATE TABLE tablename (data json)) with native SQL support (INSERT, SELECT, UPDATE, DELETE) for JSON data stored in single columns of tables.
The Lianja.evaluate() method in the Web/Mobile client now handles the ability to call business procedures that are contained within custom libraries on the server. To call a procedure in a library prefix the procedure name with the library name followed by :: e.g.

var result = Lianja.evaluate("mylib::myproc()");
In Web and Mobile Apps you can now call server-side functions written in Lianja/VFP or JavaScript directly from the Web client JavaScript code. See this article on the forums for details.
Fixed an issue where the CSS on a canvas field was not being included in the Web/Mobile App if the CSS was being read from a file rather than just an inline CSS declaration.
Integration with the Adobe PhoneGap build service (in the "PhoneGap" workspace) to package up mobile apps, upload them to the build service and build installable Android and iOS Apps that can be submitted to the Apple App Store and Google Play.
New responsive UI Mobile CalendarView section.
New responsive UI Mobile GridView section.
New responsive UI Mobile CommentsView section.
Added some new methods to the Lianja system object in the LianjaWebFrameWork. Some of these provide an abstraction above PhoneGap and will only function when run on a mobile device.

Lianja.getPicture( onSuccess, onError, cameraOptions )
Lianja.beep( )
Lianja.vibrate( nSeconds )
Lianja.getConnection( )
Lianja.getCurrentPosition( onSuccess, onError )
Lianja.getCurrentAcceleration( onSuccess, onError )

Note that orientation changes are automatically detected and the "Orientation changed" delegate is called.

Additionally, in the presentation rules for sections, gadgets and fields you can specify whether these should be visible based on the orientation of "Portrait", "Landscape" or "Both". So, an automatic relayout of the UI will be performed as you change the orientation of a phone or tablet.
Added some new functions to Lianja/VFP which can be used in .rsp pages and/or server-side procedures called from a mobile device.

isPhoneGap()
phoneGapDevice() // returns phone, tablet or an empty string
phoneGapPlatform() // returns android, ios, winphone or an empty string
phoneGapVersion() // returns the version of phonegap the app was built against
The following new Lianja system object methods render as platform specific native UI when called on mobile devices.

Lianja.messageBox()
Lianja.alert( )
Lianja.confirm( )
Lianja.inputBox( )
The following new methods on the Lianja system object can be called to determine if your App is running on a mobile device.

isPhoneGap()
phonegapDevice() // returns phone, tablet or an empty string
phonegapPlatform() // returns android, ios, winphone or an empty string
phonegapPlatformVersion() // returns the version of phonegap the app was built against

if (!Lianja.isPhoneGap())
{
// not running on a mobile device so just return
console.log("This function only operates on a mobile device");
return;
}

if (Lianja.phonegapDevice() === "phone")
{
// phone specific code
}
else if (Lianja.phonegapDevice() === "tablet")
{
// tablet specific code
}
Touching an editable image gadget now displays the photo gallery (or camera) on mobile devices where the user can choose an existing photo or take a new photo with the camera. This new photo is automatically uploaded and replaces the one in the database column on the server. This is all handled by data binding with no coding being required.
The following sections are now working on mobile devices in the same way as they work in Web Apps and can now be used in PhoneGap Apps.

form section
grid section
pagecenter section
webview section
custom section
canvas section
tabview section
catalogview section
attachments section
panelview section
carouselview section
commentsview section
galleryview section
calendarview section
report section
chart sections
orgchart section
imagestrip section
When building a PhoneGap mobile App in Lianja you build a database-oriented business App that you submit to the Apple App Store or Google Play. If you check the "Login required" attribute in the App Settings, Lianja looks for a page in the App which is a "Login Page" (new attribute in the Page Settings). This becomes the first page to be made visible when you run the App on a mobile device. If no "Login Page" is found then Lianja will create a default one for you that you use to sign in. Once authenticated, the "Initial Page" (as defined in the App Settings) is made visible. To logout and return to the "Login Page" touch the "Home" icon in the page headerbar.
Many improvements and optimizations to page/section layouts to provide a better appearance on mobile devices.
Integrated support for building and testing Lianja PhoneGap mobile Apps for phones and tablets. You develop your Apps locally then see the changes instantly on your mobile device (iOS, Android and WinPhone). There is no need to re-sign, re-compile, or reinstall your app to test your code as Lianja App Builder integrates in with the Adobe PhoneGap Developer App which is a free download for iOS (Apple App Store), Android (Google Play) and Windows Phone (Windows Phone App Store). Running the Adobe Developer App on your mobile device and entering the IP address of the machine that Lianja App Builder is running on, you will see your app on the mobile device changing dynamically as you develop it visually in Lianja. There is no need to install any SDK or other software (everything is included in Lianja APaaS Developer) and you can develop and test iOS, Android and WinPhone Apps on any of the operating systems that Lianja APaaS Developer runs on. Additionally, as you change the visual appearance and/or code of your App in the Lianja App Builder, the mobile app will instantly show your latest changes. With access to device APIs not available in web browsers, you don't have to sacrifice the confidence that your app will work as you intended on the devices you are targeting.
Added a new page attribute "Auto layout sections" and a new section attribute "Auto layout percent". This provides for a more responsive UI on mobile devices as the sections on a page will be automatically adjusted to a height which is a percentage of the viewport size rather than a fixed value. If the section attribute "Auto layout percent" is left at the default value of 0 then the sections on a page are all made equal height. This may not provide the desired effect when the device orientation is changed to landscape mode, in which case you should use presentation rules to hide various sections in landscape and only show them in portrait mode.
Fixed an issue with two-phase commit in SQL transactions which was broken due to some internal caching issues.
Fixed an issue with SQLEXEC() when it was being used to perform multiple SQL queries on the same connection where the database connection was being disconnected incorrectly if the same cursor name was being used for each SQLEXEC() command execution.
Improved ODBC connection pooling for Virtual Tables.
Fixed an issue closing ODBC connections that are pooled and have no active connections. The "keepalive" and "ttl" (time to live) are now honored properly and the connection closed once the 'ttl' grace period expires.
Performance and stability improvements.
Fixed various reported tickets.

Version 2.0.1 Released 4-Nov-2015

Performance and stability improvements.
Fixed various reported tickets.

Lianja App Builder 3.0 Release

Released 12-Aug-2016

This release provides major functionality, productivity (MetaTypes with multiple inheritance) and performance improvements (Deferred page loading, Virtual Table fetch as needed, Native LianjaSQL engine) to Lianja overall and is a recommended upgrade for all users. The App Builder IDE has been redesigned with an emphasis on developer productivity.

The version 3.0 release includes:

Fixed an issue which prevented unicode table names and column names being used.
convertutf8 now automatically converts column names and descriptions from codepage data to utf8.
Added two new functions des3_encrypt(cExp1, cExp2 [, cExp3, cExp4] ) and des3_decrypt(cExp1, cExp2 [, cExp3, cExp4] ) which can be used to des3 encrypt and decrypt any character data. When the data is encypted it is base64 encoded and base64 decoded when decrypted.
Many script editor improvements (Right click for context menu).
New layout for the pages menu in the HeaderBar. It now uses a "hamburger menu" so that it can handle a lot more pages. See this forum post for details.
Added the ability to control the visibility of the left and right sidebars.

Lianja.showDocument("page:page1?action=showleftsidebar") Lianja.showDocument("page:page1?action=hideleftsidebar") Lianja.showDocument("page:page1?action=toggleleftsidebar") Lianja.showDocument("page:page1?action=showrightsidebar") Lianja.showDocument("page:page1?action=hiderightsidebar") Lianja.showDocument("page:page1?action=togglerightsidebar")
Fixed an issue with DECLARE DLL C functions being called with parameters passed by reference using @variable syntax.
Added in height and width as exposed properties on the section object in desktop, web and mobile. Access these using:
Lianja.get('page1.section1').width Lianja.get('page1.section1').height
Fixed up the top, left, bottom and right (absolute positioning) properties to work in the same way as their CSS counterparts on custom/canvas UI elements to provide a more responsive UI for custom/canvas sections.
Added a 'resized' delegate on canvas and custom sections (section attributes dialog) so you can detect when the section is resized and adjust the geometry of the UI components contained within it accordingly.
Fixed a compiler parser bug when referencing nested objects within subobjects.
Added --codepage as a synonym to the --locale command line switch.
Added SET CODEPAGE TO "value" so that the codepage can be changed inside the config file or the init of an application. The codepages supported are:

Big5
Big5-HKSCS
CP949
EUC-JP
EUC-KR
GB18030
HP-ROMAN8
IBM 850
IBM 866
IBM 874
ISO 2022-JP
ISO 8859-1 to 10
ISO 8859-13 to 16
Iscii-Bng, Dev, Gjr, Knd, Mlm, Ori, Pnj, Tlg, and Tml
KOI8-R
KOI8-U
Macintosh
Shift-JIS
TIS-620
TSCII
UTF-8
UTF-16
UTF-16BE
UTF-16LE
UTF-32
UTF-32BE
UTF-32LE
Windows-1250 to 1258
We strongly recommend that you use utf-8 at all times.
Added SET CODEPAGEDATA TO "value" so that the codepage for data can be changed inside the config file or the init of an application. The codepages supported are:

Big5
Big5-HKSCS
CP949
EUC-JP
EUC-KR
GB18030
HP-ROMAN8
IBM 850
IBM 866
IBM 874
ISO 2022-JP
ISO 8859-1 to 10
ISO 8859-13 to 16
Iscii-Bng, Dev, Gjr, Knd, Mlm, Ori, Pnj, Tlg, and Tml
KOI8-R
KOI8-U
Macintosh
Shift-JIS
TIS-620
TSCII
UTF-8
UTF-16
UTF-16BE
UTF-16LE
UTF-32
UTF-32BE
UTF-32LE
Windows-1250 to 1258
We strongly recommend that you use utf-8 at all times.
When generating the code for a Mobile Phone the left sidebar, right sidebar and searchpanel are ignored to provide for a more responsive UI from a single codebase.
Added a new attribute called "Meta Types" in the page, section, and formitem attributes. This should be a comma separated list of MetaType names. You create "Meta Types" using the new "Meta Type Editor". Meta types are applied to Apps when they are loaded. For example, based on the meta types specified for a section you could set its header and footer menus and the delegate that handles actions performed on these menus. You can reference this attribute using the name metatypes and set it dynamically if required.
New MetaDataBuilder API. See this blog article for details. This functionality is only available in the Lianja APaaS Developer edition.
Added a new "VideoPlayer" section and class (which you can use in custom sections) in v2.1.
It currently has the following methods.

play()
stop()
pause()
hideOpen()
hideControls()
+ core methods.

and the following properties.

url as character
volume as numeric
position as numeric
+ core properties

It is currently for desktop apps only.

You can assign a url or bind its data source (control source) to a character column containing a url or filename.

You can get a reference to the "videoplayer" in a section like this:

ovp = Lianja.get("page1.section1").videoplayer

Note that to use the "VideoPlayer" you will need to install the K-lite codecs from here.
Added LCASE(), UCASE() and MID() as function name synonyms for LOWER(), UPPER() and SUBSTR() respectively.
Fixed some issues with require() and require_once() JavaScript module loading in the Web/Mobile client and changed the implementation in the desktop client to be compatible with node.js module loading.

var mylib = require_once("this_file_is_in_the_app_directory.js"); var mylib2 = require_once("lib:/this_file_is_in_the_library_directory.js"); // example file in "this_file_is_in_the_app_directory.js" function func1() { }; function func2() { }; module.exports = {}: module.exports.func1 = func1; module.exports.func2 = func2; now you can call these functions like this: mylib.func1(); mylib.func2();
Fixed an issue with Lianja.evaluateJavaScript() for calling server-side JavaScript functions.
Added several new functions to simplify working with MetaData and MetaType key/value pairs. This representation can be used as an alternative to JSON format and is much smaller.

// create an object from a metadata string obj = metadata_decode("name=barry;company=Lianja;amount=10") // encode a string from an object representing metadata str = metadata_encode( obj ) // Create an object from a metadata string obj = metadata_decode("[type1]name=barry;backcolor=red;[type2]name=bill;backcolor=pink") // Extract the attributes for a given metatype in a metadata string str = metadata_findtype("type1", "[type1]name=barry;backcolor=red;[type2]name=bill;backcolor=pink")
Enhanced the XML parsing xquery() functions and added some new ones; xquery_open(), xquery_node(), xquery_select(), xquery_attributes(), xquery_decode() and xquery_close(). See this blog article for details. These functions can now be used to read XML documents of any reasonable size and XML element attributes are also now handled.
Improved the built-in desktop http server which exposes an HTTP API in desktop apps.

- Added support for a Runtime Http port into the App Settings.
- Added support for specifying an apikey=value in the URI. This must match the apikey that is specified in the App Settings.
Added a new MetaType Editor. You create "MetaTypes" (which are essentially class definitions) for Pages, Sections or FormItems using the "Meta Type Editor". You can edit these "Meta Types" in the "Projects" or "App" workspace. The "Meta Type Editor" is a dialog similar in operation to the App Inspector as it stays on top of the UI as you are designing your App pages. You can add/edit "Meta Types" and "Apply" the changes against your App as you design/develop it. Each UI element: Pages, Sections or FormItems can have a list of "Meta Types" specified. Unlike a "Class Editor" (or similar that you may be familiar with) this provides the ability to handle multiple inheritance of attributes and delegates in a scripting language independent manner. These "Meta Types" are applied when an App is loaded. If you are building Web and/or mobile Apps you then need to deploy your apps. If you are building desktop apps the "Meta Types" are applied dynamically when the app is loaded. "Meta Types" are stored in a new sub-directory called c:\lianja\metatypes and each file is named like this: projectname.metatypes. You can override this name in the app settings on an app by app basis if required. The default file name however will be projectname.metatypes if you have a project open or appname.metatypes if you have no project open but have an App open. Note that you can select a "Type" in the MetaType Editor then drag it onto a page, section or formitem to add it to the "Meta Types" for that UI element. This functionality is only enabled in the Lianja APaaS Developer edition.
Added a new page attribute called "Deferred load". If this is checked then data is not loaded into the associated page until the page is activated and becomes the current page. So in other words, the loading of the page with data and the refresh of this data does not occur for hidden pages until they are first activated. By default "Deferred load" is off. Bear in mind that if you check this on the data in the page will not be accessible until the page has been activated at least once. In many cases this is acceptable. This speeds up App load time quite significantly when an App consists of a large number of pages. Also note that there is a "Deferred Load" attribute in the App Settings that forces all pages in an App to handle deferred loading. Additionally, you can specify --deferredload or --nodeferredload as a command line switch on your desktop shortcut without the requirement to modify an App. By default in Lianja v2.1 "Deferred page loading" is on. To disable it specify --nodeferredload as a command line switch on the Lianja App Builder or the Lianja App Center.
Added two new methods on Pages, Sections and FormItems (fields and gadgets). These are setAttribute(name, value) and getAttribute(name). These methods handle all attributes as documented and described in the MetaType Editor. Note that there are shortened forms of these also, setAttr(name,value) and getAttr(name) respectively. These are available to all supported scripting languages.
App Inspector improvements including display of elapsed time between messages logged in the Events tab.
Major App loading performance improvement with load times being displayed in the App Inspector Events tab.
Major performance improvement when opening Virtual Tables. Rows are now "fetched as needed" rather than preloading all rows when the VT is opened. The "fetchsize" property determines how many rows are fetched. By default this is 100. Setting it to 0 or setting the "fetchasneeded" property to 0 disables this functionality.
To speed up Virtual Table queries you can now specify "dbtype=xxx" in the VT PROPERTIES where xxx is MSSQL2016, MSSQL2014, MSSQL2012, MSSQL2010, MSSQL2008, MSSQL, MYSQL, POSTGRES, LIANJA, VFP, SQLLITE, MSACCESS or ORACLE. This tells Lianja that you know the type of database so it will not use heuristics to determine the database type.
If you are using MSSQL2012 Virtual Tables and you do not want Lianja to use the new OFFSET ... FETCH NEXT clauses (in favor of the older OVER clause) then specify "nosupportsoffset=1" in the VT PROPERTIES.
If you want to disable the SQL command mangling that is required to handle pagination of the resultset returned from a SQL SELECT then specify "pagination=0" in the VT PROPERTIES.
To assist in debugging individual Virtual Table CRUD operations you can specify "debug=1" in the VT PROPERTIES.
Made a small change when editing "Field" captions using inline editing of a form section. In previous versions of Lianja unless you had disabled "Inherit dictionary rules" the caption would resort to the "Description" in the data dictionary for the table when the App was loaded. This confused some developers so in v2.1 you can edit these captions inline now as there is a new attribute "Inherit dictionary caption" which is disabled if you edit the caption inline.
Added several new section attributes for grid and attachment sections to handle dynamic grid row colors dependent on an expression. This is similar to dynamic cell colors for grid columns but affects the whole grid row. It is particularly useful when a grid is being refreshed at intervals and you want to hilite certain rows.
Honor the "Pagination" attribute setting for grids in the web/mobile client so all rows fetched are loaded into the grid if pagination and auto pagination is off.
New command SET EXPLAIN ON. When this is ON all SQL SELECT commands executed output their EXPLAIN execution plan to the console.
Much improved execution plan output from SQL EXPLAIN to assist in tuning SQL SELECTs.
Major performance improvements of SQL SELECTs on shared network drives.
SQL SELECT statements now honor the transaction isolation levels correctly. The following isolation level is recommended when querying data from a shared network drive. SET TRANSACTION ISOLATION LEVEL REPEATABLE READ. This places shared(read) locks on the tables in the query which enables client side caching that results in a major performance improvement. The default transaction isolation level is UNCOMMITTED. These isolation levels are compatible with MSSQL transaction isolation levels.
Added the smartquery and nosmartquery optional keywords to SQL SELECT to enable/disable SMARTQUERY caching on a statement by statement basis.
Added a new command line switch for the App Builder --appinspector which causes the App Inspector to be shown whenever the "Pages" workspace is selected.
You can now deploy Apps in the "Deploy" workspace while an App is open.
Added two new commands PUSH DATASESSION and POP DATASESSION. These operate in the same way as SAVE and RESTORE DATASESSION but enable pushing and popping data session state (database, tables, and cursor state) up to 256 levels deep.
In Virtual Table definitions you can now specify "nodata=1" in the VT PROPERTIES. This causes the VT queries to return no data unless a "filter" is specified. It is particularly useful for Web and Mobile Apps. Desktop Apps can specify a WHERE condition on the USE command to perform queries against the Virtual Table e.g.

use vt_customers where accountBalance > 5000
New Quick Deploy icon in the Pages, Apps and Library workspaces. Quick Deploy speeds up the iterative Develop, Deploy and Share process by deploying directly from the Page Builder without the need to switch workspaces. To perform a Quick Deploy you first need to select the "Deploy" workspace and choose the files that you want to deploy. After that you can perform a Quick Deploy by clicking on its icon in the HeaderBar.
Fixed a few issues with PhoneGap LiveView.
The iOS StatusBar area is now taken into consideration in PhoneGap LiveView.
Improved Web/Mobile responsive UI layouts when Web/Mobile Apps are generated.
Added a new field attribute (in the Field Attributes Dialog):
"Ignore update after change" (MetaTypeEditor attribute ignoreUpdateAfterChange)

After data is edited the 'Change' delegate only is called which is assumed to update the field. No internal update or validation is performed. This provides the ability to handle custom search/autosuggestion logic in the App for this field.
PhoneGap Build templates (used when generating files to upload to the PhoneGap Build service) have been updated to use PhoneGap Build cli-6.3.0 which is the latest version at the time of writing this. You can also now specify an alternate PhoneGap version to build with in the PhoneGap settings.
Lianja Mobile Apps now allow you to navigate the records in your apps using the familiar left, right, up and down "swipe" gestures. Swipe Left navigates to the next record, Swipe Right navigates to the previous record, Swipe Up goes to the last record and Swipe Down goes to the first record. These gestures are only effective in Form, Canvas and Custom sections. You can override this behavior by enabling gestures in the section attributes and write your own gesture delegate (which may me specified using the inline delegate syntax). Note also that navigation swipe gestures are not available if you have enabled "Swipe Navigation" is the page attributes. If you have enabled "Swipe Navigation" in the page attributes, then Swipe Left and Swipe Right navigates between the next and previous pages in the App. Swipe navigation is also available in TabPanel sections.Swiping Left and Right navigates between the different Tabs.
PhoneGap Apps built in Lianja can now optionally use CrossWalk to improve performance up to 10x from the standard Android and iOS WebViews. Other than a performance improvement, CrossWalk also provides a consistent UI on all supported versions of Android and your apps are unaffected by Android updates that could break something. Crosswalk optimization is optional but recommended on both Android and iOS.
A small change. If the debug files are empty after running an application they are deleted, so if you wonder why they are not being generated its because there was nothing in them.
Made some small changes in the PhoneGap workspace:
- Username and password for PhoneGap Build can be "Remembered" between sessions now.
- "Configuration" ComboBox has been moved below "Username/Password/Remember me". This ComboBox is populated after you open a project or create a new configuration. After selecting a configuration the "PhoneGap Build Service" tab is automatically selected. Every click saved is important in developer productivity!
Changed the layout of the "Users" workspace and the "PhoneGap" workspace so that they are more responsive and layout correctly on low resolution displays.
Added a new method on the Lianja system object.

Lianja.showPagesMenu()

This is the same as clicking or touching the pages "Hamburger" menu icon. It is most useful in conjunction with gestures in mobile Apps.

The equivalent Lianja.showDocument("showpagesmenu") can also be used.
When generating code for Android devices, the mobile App now handles touching of the "menubutton" (if your device has one) which will now slide in the pages menu.
The App Builder now has a flatter and more simplistic UI appearance overall.
Various editor UI improvements.
When you run the App Builder it will now restore the previous development session. It will open the previously opened App and all of the editor files are re-opened then positioned on the last line selected. This can be disabled in the App "Settings". If you have any problems opening an App just start the App Builder with --reset on the command line.
The App Builder now has a standard MenuBar at the top of the window. In earlier versions a context menu was used but this was found to be less intuitive for many to find.
Impoved editing productivity by opening the editor advanced panel and refreshing the tasks, procs and events which are shared across all editor tabs. This makes it much easier to navigate to all the procs and classes in different files within an App by just double clicking on rows in the grids.
The App Builder now uses standard/native host operating system dialogs whenever appropriate.
Added a new attribute to sections called metadataversion. You can get/set this in the setupUI hook when applying your own MetaData. See this article for details.
Added a new method setupUI() to pages and sections. You should call this in the setupUI hook when applying new MetaData. See this article for an example.
New Attributes Tab (for the current page, section, and selected formitem) in the App Inspector. The App Inspector stays on top of the pagebuilder in development mode so you can change attributes without having to slide in the Attribute Dialogs. This provides a more productive visual development experience.
Attributes in the slide-in Attribute Dialogs and in the App Inspector are displayed in grouped categories with a ComboBox at the top providing quicker access to attributes in a specific category e.g. All (the default), Appearance, Menu, Footer, Data, Delegates etc.
Switching between workspaces now automatically hides the App Inspector and the Web, Tablet and Phone App views.
Added several new methods to the Lianja system object in desktop to allow managing of the internal http server connections. Note that the default port is 8002 for the App Builder and 8003 for the App Center.

Lianja.startHttpServer( [optional port number ] )
Lianja.pauseHttpServer()
Lianja.resumeHttpServer()
Lianja.stopHttpServer()
The App Inspector is now dockable into the Main Window. From the MenuBar choose "Window|Dock Windows" to dock it and "Window|Side by Side Windows" to undock it and arrange the App Inspector window on the left and the Main Window on the right. See this forum post for a screenshot.
Upgraded node.js (included in the distribution) to LTS v4.4.7 (includes npm 2.15.8).
Double-clicking an editor tab will detach the editor into its own floating window which can be dragged out of the main window for those of you who prefer editing with multiple displays. Double-clicking the titlebar of the editor window will attach it back into the tabs. Once a window is floating the "Window" menu has a list of editing windows at the bottom of it enabling quick access to raise the editing window into the foreground. As with all script editors in Lianja the "Advanced" tabs which contain search results, procs, functions, todo lists and classes are all kept in sync across all the tabs and floating windows.
Now includes Git integration. See this announcement of the Lianja developer community forums.
Now includes LiveCode editing in the editor and the debugger for Lianja/VFP. Move the mouse cursor over a variable/field name to see its datatype and value. You can toggle this functionality on and off by pressing Ctrl+/. Note that if the cursor is over an object.property the value of that property will be displayed. The tooltip displayed for each variable/field/object.property includes the datatype, width, decimal places and current value.
Attributes in the App Inspector are now searchable. Click the top row of the Attributes grid and repeatedly press the first letter of the attribute you want to search and the attributes starting with that letter will be selected one by one.
Hot Backup and Restore of Apps and Databases while developing in the App Builder. Use "Apps | Backup App", "Apps | Restore App", "Database | Backup Database", "Database | Restore Database" in the MenuBar. There is no need to close the App or Database to perform these operations.
Pressing F1 help while editing now auto detects the command / function() being typed and displays the associated documentation page from the Lianja Documentation Wiki. You can provide your own custom help by specifying the "Help Provider Homepage URL" and the "Help Provider Search URL" in the App Settings. Use {keyword} in the search URL which will be substituted for you. Note that function names always have () postfixed to them, while commands do not.
For all you VFP die-hards we have added a "Command Window" that sits on top of all of the workspaces while in development mode. The visibility and geometry of this is saved and restored when you restart.
Many Lianja/VFP debugger improvements including "Edit Code" (A button in the ActionBar) and, to assist in tracking down hard to find bugs, the debugger will be triggerred when an error occurs.
Now includes a JavaScript debugger. This will be triggered when an error occurs in any of your JavaScript delegates, when you choose "Debug..." from the "Program" menu (or ModeBar button) and choose a JavaScript file, or when a debug() function call is encountered in any JavaScript code. Note that debug() is a noop in the Web/Mobile clients.
Added a new attribute to Fields and Columns "Hidden at runtime". This is effective in desktop/web/mobile and can be used to hide certain fields in a form or grid that you may need but do not want the users to see e.g. a primary key field which is needed to be defined for Virtual Tables so that Update and Delete operations can be performed.
The choicelist attribute for fields and grid columns can now be specified as a macro expression "{myproc('arg',...}" that will be expanded in desktop, web and mobile.
The following new commands can be used from the "Command Window CLI" to speed up development for those of you who prefer to use a CLI.

open/create/modify/close/delete project/app/application [filename]
create page [pagename]
list databases
list tables
list apps
list projects
modify command [filename]
modify file [filename.ext]
modify library [filename]
help
help commandName
help functionName()
"Help" is now integrated into the "Command Window CLI" for Lianja/VFP, Python, PHP and JavaScript.
Added database event hooks dbc_insert, dbc_delete, dbc_update, dbc_library. These can be used to provide audit trails and also perform data mapping. See this forum post for details. You can enable|disable database events with SET DBCEVENTS ON|OFF.
Performance and stability improvements.
Fixed various reported bugs.

Lianja App Builder 3.1 Release

Released 14-Oct-2016

The version 3.1 release includes:

Added TypeScript as a supported scripting language. TypeScript is dynamically compiled into JavaScript if the TypeScript (.ts) file is newer than the associated JavaScript (.js) file. Due to the nature of typing in TypeScript (hence the name) parameter and variable intellisense is much more helpful than can be achieved with dynamic languages with weak typing.
You can now "Compile" and "Run" scripts from within the editor.
Added Electron integration for generating executable self-contained Apps for Windows, MacOS and Linux. Electron is used to package up many leading applications such as Visual Studio Code. With Electron you can package up a Lianja Web App into an executable for Windows, MacOS or Linux. This is similar to the way in which PhoneGap operates insofar as the Apps are visually designed in Lianja, TypeScript and/or JavaScript is used, but the target is a desktop application Which can be submitted to the Windows and MacOS App stores. You build Electron executables in the "Electron" workpace.
Container and Image objects are now drawable. The draw(operation, args) method can be used to superimpose a drawing on top of a container or image. You create a "drawing" by issuing a list of drawing operations specified by the draw() method. Operations consist of: clear, moveto, lineto, point, rectangle, fill, eclipse, image, save, restore, pen, font, brush. Further details to be provided prior to release. This functionality can be used in data collection applications such as insurance inspection to draw on top of photos. You can detect mouseDown, mouseUp and mouseMove events by declaring delegates for these and issue draw() operations. There are several new methods and properties that can be used to draw; mouseDown(), mousex and mousey. The example_drawable app shows you how to use this functionality.
Added Locale settings into the App Settings for specifying the Currency character(s), Separator and Point characters. These default to "$", "," and "." respectively.
The Lianja/VFP transform() and currency() functions are now available in JavaScript -- Desktop/Web and Mobile.
The "Tools" workspace has been removed and replaced with the "Electron" workspace. Tools still work as they did previously but are now embedded in their own floating window. You activate them from the "Tools" system menu. Did you know that you can extend the Lianja App Builder with your own tools written in Lianja/VFP, Python, PHP, JavaScript or TypeScript?
Added a new Lianja/VFP function called html_toPlainText( cExpr [,lKeepNewlines] ) which takes an HTML encoded string and returns the plain text without the HTML tags. If the second arg is specified then newlines are included.
Added some additional functionality to the "videoplayer" section and class. So if you want to build kiosk Apps with the ability to take photos or record videos you can now.

New methods.
showControls()
showOpen()
getPhoto(filename : string) : string (returns empty string if no photo taken)
getVideo(filename : string)
startCamera()
stopCamera()

New properties.

duration : number
aspectRatio : number (IgnoreAspectRatio=0, KeepAspectRatio=1, KeepAspectRatioByExpanding=2)
fullscreen : boolean
Exposed several new properties in the slider class:

tickInterval : number
tickPosition : string // None, Above, Below, Left, Right, BothSides
Added a new core property mouseCursor (inherited by all classes):

This can take any of the following numeric values.

0 The standard arrow cursor.
1 An arrow pointing upwards toward the top of the screen.
2 A crosshair cursor, typically used to help the user accurately select a point on the screen.
3 An hourglass or watch cursor, usually shown during operations that prevent the user from interacting with the application.
4 A caret or ibeam cursor, indicating that a widget can accept and display text input.
5 A cursor used for elements that are used to vertically resize top-level windows.
6 A cursor used for elements that are used to horizontally resize top-level windows.
7 A cursor used for elements that are used to diagonally resize top-level windows at their top-right and bottom-left corners.
8 A cursor used for elements that are used to diagonally resize top-level windows at their top-left and bottom-right corners.
9 A cursor used for elements that are used to resize top-level windows in any direction.
10 A blank/invisible cursor, typically used when the cursor shape needs to be hidden.
11 A cursor used for vertical splitters, indicating that a handle can be dragged horizontally to adjust the use of available space.
12 A cursor used for horizontal splitters, indicating that a handle can be dragged vertically to adjust the use of available space.
13 A pointing hand cursor that is typically used for clickable elements such as hyperlinks.
14 A slashed circle cursor, typically used during drag and drop operations to indicate that dragged content cannot be dropped on particular widgets or inside certain regions.
17 A cursor representing an open hand, typically used to indicate that the area under the cursor is the visible part of a canvas that the user can click and drag in order to scroll around.
18 A cursor representing a closed hand, typically used to indicate that a dragging operation is in progress that involves scrolling.
15 An arrow with a question mark, typically used to indicate the presence of What's This? help for a widget.
16 An hourglass or watch cursor, usually shown during operations that allow the user to interact with the application while they are performed in the background.
20 A cursor that is usually used when dragging an item.
19 A cursor that is usually used when dragging an item to copy it.
21 A cursor that is usually used when dragging an item to make a link to it.
Containers ( i.e. cont = createObject("container") ) can now arrange UI objects added to them in a "grid" layout. A container which has a "grid" layout specified for it takes the space made available to it (by its parent layout or by its parent container), divides it up into rows and columns, and puts each UI object it manages into a grid cell. You add objects to the container grid using the addObject() method:

cont = createObject("container")
cont.layout = "grid" // can be... grid, form, horizontal or vertical
cont.addObject('mybtn', 'commandbutton', nRow, nCol, nRowspan, nColspan)

nRowspan and nColspan are optional and default to 1.

UI objects added to the grid layout of the container can occupy multiple rows and/or multiple columns.

This new layout type provides a flexible means of laying out complex UIs as the containers can be nested and each container can itself have a layout.
Added a ToggleButton in the HeaderBar of the App Builder to allow toggling of CommandButton click events on canvas sections when in development mode. This makes it easier to select UI elements while designing a UI.
The "Disable inline editing" attribute in the App Settings now operates in desktop apps as well as web and mobile.
Fixed an issue that prevented unicode characters in WebViews from being translated propertly when Lianja.execute() or Lianja.evaluate() was being called from JavaScript inside webviews in hybrid Desktop Apps.
Fixed up a few issues where UTF8 characters were not being returned correctly for ComboBox and ListBox.
Improved the way in which row buffering is handled internally. Previously, when adding a new record the APPEND BLANK command caused the dictionary attributes (for the default and validation criteria) to be applied and the record was committed to the database table if it validated Ok. Now, the new blank record is not committed until a "Save" is made in the UI or tableupdate() is called. Previously "Save" did not commit until the record pointer was moved in the UI. Now, "Save" checks the data against any validation criteria (dictionary and UI) then commits the record. This causes only one SQL operation to occur when Virtual Tables are used. This change causes Desktop Apps to operate in the same way as Web/Mobile Apps do.
Added LDAP/ActiveDirectory integration for roles and permissions. If the environment variable LIANJA_LDAP=ON is set then LDAP user authentication is performed and the "Groups" that the user belongs to correspond to "Roles" in the App. You also need to specify the "base dn" as an environment variable which is used as the root to search for groups assigned to a specific user e.g

LIANJA_LDAP_BASEDN="ou=users,dc=yourdomain,dc=com"
For testing you can set LIANJA_LDAP=OFF and use the Lianja users. So just to clarify the following environment variables are required when LDAP/AD is used for roles and permissions.

LIANJA_LDAP=ON LIANJA_LDAP_SERVER=IPaddress[:port] LIANJA_LDAP_BASEDN="ou=users,dc=yourdomain,dc=com"
You can test the AD/LDAP authentication using:

ldap_login(cUserName cPassword [, cLdapServer[:port] [,[cLdapBasedn]] ) or ldap_userroles(cUserName, [, cLdapServer[:port] [,[cLdapBasedn]] )
These functions return the ActiveDirectory/LDAP "groups" that the user belongs to which correspond to roles in Lianja.

The Lianja Cloud Server and the Lianja App Center (runtime) will use LDAP if the above environment variables are specified.

If you have any problems with LDAP you can SET DEBUG ON and a trace file will be written into the debug directory "ldap_xxx.txt" where xxx is the process id of the user.
Added NOACTIONBAR as a BROWSE keyword. This hides the actionbar at the bottom of the grid.
Added STYLE "text" as a BROWSE keyword. The "text" should be CSS. It may be a reference to a filename.css containing the CSS. This may be prefixed with "app:/filename.css" or "lib:/filename.css" which causes the file contents to be read and applied as CSS.
Added a new function used to obtain information about Virtual Tables.

cResult = vtInfo( cAlias | select(), "database" | "name" | "connstr" | "basetable" | "primarykey" | "properties")
Performance and stability improvements.
Fixed various reported bugs.

Version 3.1.1 Released 18-Oct-2016

Performance and stability improvements.
Fixed various bugs from reported tickets.

Lianja App Builder 3.2 Release

Released 02-Feb-2017

In Lianja 3.2 we have fixed a significant number of bugs that had been reported on tickets. So, although we have added many requested enhancements, the focus of this release is primarily on performance and stability improvements. The Lianja SQL engine is getting faster in each release. In 3.2 we have made significant performance improvements once again with particular emphasis on multi table joins and aggregate processing. Lianja SQL now supports aggregate functions in GROUP BY ... HAVING and also ORDER BY. Query performance is an order of magnitude faster than previous versions and we will continue to fine tune this as we release new versions.

Added a new "Hotkey" delegate to "App", "Page" and "Section". This is only called in runtime mode so you need to switch into that mode to test your delegates. The delegate is called with one argument which is the keycode string e.g. "F5", "Ctrl+F5", "Ctrl+Shift+F5". If the current section has a hotkey delegate that is called otherwise if the page has a hotkey delegate that is called otherwise if the app has a hotkey delegate that is called. If the delegate does not handle the key presses then you should return false.
Improved and more productive grid editing experience in desktop Apps. When navigating between the records displayed in a grid that is set to "Double Click To Edit", the Return/Enter key now behaves like a double mouse click. If the grid is setup as a split editing grid (Grid and Form), then while editing in the form, pressing Ctrl+W or Esc will exit the form and focus back onto the grid. You can then navigate the grid using the standard keyboard Up/Down keys.
Improved embedded HTTP server with improved performance. Providing an API for your desktop Apps is simple using the Lianja embedded HTTP server and this works with all supported scripting languages.
Added a new page attribute "Hide hamburger menu icon" providing the ability to hide the hamburger menu icon from the page header at runtime. You can then handle page switching in your App programatically in delegates. For Apps that consist of a single page the hamburger menu icon is not needed and makes for a cleaner UI.
Implemented the VFP NODATA keyword on the USE command. When used with Virtual Tables specifies that only the structure of a SQL view is downloaded. The SQL view's data isn't downloaded. NODATA provides the fastest method for determining a SQL view's structure.
The App Builder and the App Center now always use UTF-8 character encoding unless you explicitly specify a --CODEPAGE or specify --NOUTF8 as a command line switch.
Lianja UI States provide you with a powerful mechanism for handling complex business processes using a UI State machine which is built into Lianja. Each UI element (App, Page, Section and FormItem) can contain (an optional) comma separated list of "States" that the UI element responds to. In Lianja 3.2 we have added a new delegate called stateChanged(cState) which is called whenever a UI State is changed e.g:

Lianja.showDocument("changestate:namelist")
or
Lianja.showDocument("page:page1?action=changestate&state=namelist")
or
Lianja.showDocument("section:section1?action=changestate&state=namelist")

The delegate is called with one argument, the name of the state. Note that the namelist is a comma separated list so you can trigger multiple UI state changes at once.

When a "resetstate:namelist" is applied to the App the delegate is called with a single argument which is preceeded by a "-" sign e.g. "-editing".

Note that changing UI state is only handled in runtime mode not the development view.
Many SQL engine enhancements with improvements to the query optimizer as well as improvements to aggregate function processing with GROUP BY and ORDER BY on joined tables.
Added a new function sqlParams( string ) : string. This function substitutes SQL parameter markers and returns a character string. When executed with a cursor selected that is a Virtual Table, the format of date types (e.g. datetime) for the target database type (e.g. MSSQL) is honored.
In runtime mode, when a user clicks the "Hamburger Menu icon", only those pages that the user has permission to read are included in the menu.
The "ODBC" tab in the "Console" workspace when selected now causes all typed commands to be sent to the remote database server.
Various Virtual Table performance optimizations.
Performance and stability improvements.
Fixed various bugs from reported tickets.

Lianja App Builder 3.3 Release

Released 15-Feb-2017

The version 3.3 release includes:

Enhanced COPY command to support COPY TO ARRAYOFOBJECTS name
Implemented VFP SET KEY TO command. Use SET KEY to limit the range of records you can access in a table. The table must be indexed, and the index key value or values you include must be the same data type as the index expression of the master index file or master tag.
Issue SET KEY TO without any additional arguments to restore access to all records in the table.

SET KEY TO [eExpression1 | RANGE eExpression2 [, eExpression3]] [IN cTableAlias | nWorkArea]
Now supports DropDown forms from textBoxes. You typically show these in a "DialogButton delegate" or when an application specific hotkey is pressed.

The “Form” class now has a new method called showDropDown(cControlID [, nWidth, nHeight] )
cCcontrolID is in the page1.section1.field1 notation and it identifies the UI control that you want to attach the DropDown Form to.

The nWidth is the width you want the form to display when it is dropped down. If this is omitted or is zero then the for will adjust to the width of the textBox it is attached to.

If nHeight is omitted the default is 250.

You can create the form inside a “DialogButton” delegate or in a hotkey delegate if you want to use function keys to drop down pick lists.

Hint: add a container to the form and set its layout to “grid” is the easiest way to create a responsive UI form.

// Example
myForm = createObject(“Form”)
// add a search panel, grid and command buttons (See use of embedded BROWSE below)
myForm.showDropDown(“page1.section1.field21”)

// You should have a means to close the DropDown Form such as in a CommandButton click event
myForm.close()

// closing the form will not destroy it but rather it will hide it so it can be dropped down again
Added the ability to embed a BROWSE command inside a container.
myCont = createObject("Container")
select * from customers into cursor mycust
myGrid = myCont.browse("BROWSE keywords/columns/etc", "mycust" [, "clickHandler()" [, "dblclickhandler()"]] )

You can re-execute the myCont.browse(...) command repeatedly. This causes the BROWSE grid to be replaced by the new BROWSE grid and data in the "alias" cursor. For best results assign a horizontal or vertical layout to the container.

You can nest containers inside a "grid" layout applied to a "Form" and then use the myForm.showDropDown(...) method to drop down complex pick lists which have data rendered inside the embedded browse grid.
Performance and stability improvements.
Fixed various bugs from reported tickets.

Lianja App Builder 3.4 Release

Released 26-Apr-2017

The version 3.4 release includes:

Row level security based on authenticated user roles.
Added a few new commands and functions to assist with row level security.

set rowfilter to
set rowfilter on|off

userRowFilter('username' [, 'database', 'table'] )

Returns the rowfilter for a given user for a given database table. If 'database' and 'table' are not specified the current database and table open in the active cursor are used. If the 'username' is not specified, the currently logged in user is used.

New $rowfilter=condition OData argument
Dynamic data masking based on authenticated user roles.
Added some new helper functions to assist with dynamic data masking.

userDataMask('table', 'column')

Returns the dynamic data mask for the specified column for the current user.

maskedData('table', 'column' [, 'mask'] )

If 'mask' is not specified then the dynamic data mask for the current user is used. Returns a string representing the masked data.

The 'mask' can currently be specified as:

default
partial
email
encrypted
Added a graphical MetaData Editor for Database, Tables and Columns. Click the "Edit" icon in the ActionBar to show the MetaData Editor. You can find information about the MetaData API here.
Extended the MetaData system to handle conditional MetaData that is dynamically applied to sections and formitems when refreshed. You can find information about the conditional MetaData here. Note that setting the "visible" or "enabled" attribute is only applied at runtime. This provides the ability to dynamically change the appearance of sections and formitems depending on the data currently being viewed. All without any special coding being required (NoCode) as attributes can be conditional e.g.

formitem.enabled=[emptype eq 'manager']true,false
formitem.backcolor=[emptype eq 'manager']green
formitem.backcolor=[emptype eq 'supervisor']pink
Added SYS(2017) for VFP compatibility. Returns a checksum value based on the current record in the current work area. You can use a checksum to test the validity of data. cExpression is a comma separated list of field names to exclude from the checksum. If nFlags is 2 then memos are included in the calculation.

SYS(2017, cExpression [, nSeed [, nFlags]])
The following functions now honor the the STRCOMPARE setting (right trimmed, case insensitive comparisons):

inlist()
startsWith()
endsWith()
contains()
indexOf()
substringOf()
Added applyMetaData() to the Lianja system object, the pagebuilder object, the section object and the formitem object. You can call these to reapply metadata to sections and formitems across a complete App. It can be used effectively if you want to change the UI appearance while data is being entered interactively by a user. "applymetadata" has also been added to Lianja.showDocument() so that it can be used in inline delegates.
Added a new function to assist with testing conditional metadata.

metadata_value("name", "name=value")
metadata_value("name", "name=[ condition ]value")
metadata_value("name", tableMetaData() )

Returns the value of the metadata attribute value or "" if none or non matching condition. The condition should be specified in OData format e.g. name eq 'smith'.
*New* CodeAssistant in the Lianja/VFP script editor. The Lianja CodeAssistant consists of:
Intellisense
IntelliTips
Statement completion
Context sensitive statement assistance while typing
Code suggestions
Function and method parameter hints
If you press Ctrl and hover over a command word "Quick Info" for the command will appear as a tooltip
If you press Ctrl and hover over a variable the "Quick Info" value of the variable will appear as a tooltip
Variable/word hilighting while typing
Code snippets
Code folding with Code QuickView when mouse hovered over a collapsed code block icon.
Auto indenting
Code beautifier
+ much more
Pressing F1 when in the command window or the Lianja/VFP code editor will now fetch and display the help page from the Documentation Wiki for the command being typed.
High DPI displays are now automatically detected and the fonts are autoscaled.
The messaging functions MQCLOSE(), MQCREATE(), MQCURMSGS(), MQRECEIVE(), MQSEND(), MQSENDMESSAGE(), and MQUNLINK() are now available for Windows as well as Linux. You can use these to build producer/consumer background services.
When bulding pages visually you can now drag and drop tables/columns from the "Data files" as well as the "Pages files". This confused a few people so it has been made more intuitive.
Added "Editor" configuration to "Settings".
Added some new functions to control shared/exclusive access to named resources. These functions are cluster aware and can safely be used across multiple running instances of either Lianja desktop Apps on a network or Lianja Cloud Server instances.

nResult = lockResource(name as character, mode as character) // "mode" can be "shared" or "exclusive"
nResult = unlockResource(name as character)
unlockResourceAll()

If the named resource is locked exclusive by another process then the requesting process will wait until the resource is available in a compatible lock mode.

"Shared" locks provide the ability to have multiple readers whereby "exclusive" locks only provide access to a named resource one process at a time.
"local" stored procedures are now supported for Virtual Tables. See this forum post for details.
Updated versions of node.js, PhoneGap and Electron.
Added a new delegate for pages and sections called "afterRefresh". This is called after a "Refresh". It can be used to provide special display formating specific to the context of the data being displayed.
Performance and stability improvements.
Fixed reported bugs.
PHP scripting support is deprecated in this release and may be removed in Lianja 4.0.

Version 3.4.1 Released 09-May-2017

Performance and stability improvements.
Fixed various bugs from reported tickets.

Version 3.4.1 Released 09-May-2017

Performance and stability improvements.
Fixed various bugs from reported tickets.

Lianja App Builder 4.0 Release

Released 30-Aug-2017

The version 4.0 release includes:

Available for all operating systems; Windows, Linux and MacOS
Lianja App Builder now includes everything that was previously only available in Lianja APaaS Developer.
A few new attributes added the "PageCenter" pages to provide better customization of "Tile order", "Background Color" and "Text Color".
Added a new property to the "pageframe" class. "tabposition" can be set to "north", "south", "east" or west" to position the "tabbar" for the "pageframe".
When setting up users and their roles and permissions, you can now specify an expiry date for the user. When a user logs in or when an http request is made a check is made for expired users and the login or request is rejected. This provides improved support for subscription based users in a SaaS environment.
You can now deploy with sftp using a private key file (.pem file) which can be specified in "App Settings" or alternatively in the "Deploy" workspace. This provides for better security and also satisfies the requirements for deploying to Amazon AWS instances.
Improved and simplified VFP migration with deferred subclassing (no requirement to re-arrange class definitions in source files).
Improved "Electron" integration.
Performance and stability improvements.
Fixed various bugs from reported tickets.

Lianja App Builder 4.1 Release

Released 20-Apr-2018

The version 4.1 release includes:

Enhanced grids in Desktop/web/mobile supporting JSON and programmatic dynamic row and dynamic cell background and foreground colors.

The following new methods are available for grid sections to handle dynamic row/cell colors:

setRowColor(row as numeric, fgcolor as character, bgcolor as character) setItemColor(row as numeric, column as numeric, fgcolor as character, bgcolor as character)

You can apply custom colors in the "afterrefresh" delegate of a section. After the grid is loaded the text in the cells of the grid can be referenced using the item(row as numeric, column as numeric) method. Based on the text in the cell you can dynamically adjust the colors.

You can also update individual cells using the item(row as numeric, column as numeric, text as character) method.

You can now load JSON encoded data directly into a grid section using:

setJSON( jsondata as character )

If the "jsondata" specified is a valid URL starting with http:// or https:// then the data will be fetched from the remote server and then loaded into the grid.

If you want to relate JSON grid data to a form section or another grid section you should use setJSON() in the "datachanged" delegate for the parent section.

Note also that the JSON should typically be an "array of objects". The member names of the objects are data bound to the grid using the "Data source" of the grid column. This enables data binding so that even if the JSON returned from a web service returns rows (JSON objects) with a lot of members, only those specified in the grid will be displayed. Others will be discarded.
Implemented custom "grids" in Web/Mobile custom sections.

// // Lianja custom JavaScript section "page1_section3" // oSection = createObject("oSection", "section"); oSection.addObject("oGrid", "grid"); // init the attributes for the grid object. oGrid.initObject( { readonly: true, columns: [ { caption: 'column1', controlsource: 'column1', backcolor: 'lightgreen'},> { caption: 'column2', controlsource: 'column2'} ] }); // load the grid from JSON. Notice how this is an array of objects. // The names match the 'controlsource' for the columns. oGrid.setJSON( [ { column1: 'hello', column2: 'world' }, { column1: 'hello', column2: 'again'} ]); // alternatively, the setJSON() method may now be given a URL and the JSON data will be read from that URL and loaded into the grid. oGrid.setJSON("http://services.mydomain.com/getcustomers.rsp"); returnvalue = oSection;
Various other grid enhancements such as attributes to hide the grid lines and column headers.
Grids can now have columns that contain embedded images, embedded memo/varchar, and subforms. For each column you can now specify an optional “Custom editor” delegate and a “Custom display” delegate. The “Custom editor” delegate should return a UI element which typically is a container for sub forms. The “Custom display” delegate can return a container of laid out content or an HTML string. For example, you can embed a chart in a cell when building management information dashboards. Double clicking (or touching in mobile Apps) on a grid cell whitch has a “Custom editor” will switch the cell into editing mode.
A subtle change to the way JavaScript methods are called on objects. "this" is now set to the object containing the function. e.g.

editbtn = createObject("commandbutton"); editbtn.setItem("row", row); editbtn.setItem("col", col); editbtn.mouseenter = function() { this.attr("border", "1px solid black"); this.attr("background-color", "white"); this.attr("color", "black"); }; editbtn.mouseleave = function() { this.attr("border", "1px solid white"); this.attr("background-color", "orange"); this.attr("color", "white"); }; editbtn.click = function() { var row = this.getItem("row"); var col = this.getItem("col"); Lianja.get("page1.section1").grid.activateCell(row+1, col+1); };
Added a new method handleChildEvents(state as boolean) to the "container" class so that mouseenter, mouseleave, click and dblclick events for inner child components are propagated to the container.
Added a new core method to all of the UI framework components. The attr(name as character [,value as character]) core method can be used to add or update a CSS attribute for a component. If the CSS attribute is not already specified it will be added to the list of attribute/value pairs in the "css" for the framework component. Alternatively if it is already specified it will be updated. This new method is equivalent to the jQuery attr() method but is functional across desktop/web and mobile Apps.
Added evaluate(expr as character) as a method on sections and gadgets. If the section or gadget has an embedded webview you can evaluate() javascript inside the webview to better interact with web components.
added a new Lianja method called clipBoard().
text = Lianja.clipBoard() Lianja.clipBoard(newtext)
This provides the ability to read and write to the system clipboard and works with the system cut/copy/paste capabilities.
Improved web/mobile method and properties support for custom classes.
Added a new App attribute "CSS libraries" to enable simplified and consistent UI theming.

The CSS file is parsed and CSS classes attributes/properties are resolved from this.

Multiple CSS libraries can be specified by separating each with ; Prefix with lib:/ to reference libraries in the libraries directory. e.g.

lib:/mycsslib.css

Note that the following common bootstrap classes are automatically recognized in desktop, web and mobile Apps so you do not need to specify the bootstrap CSS library to use these.

To use them just specify them in the "CSS style" attribute or use the addClass("classname") common object method.

We recommend using these CSS classes whenever possible to maintain consistency in your Apps.

Alerts

alert, alert alert-primary, alert alert-secondary, alert alert-success, alert alert-warning, alert alert-danger, alert alert-info, alert alert-light
alert alert-dark

Badges

badge, badge badge-primary, badge badge-secondary, badge badge-success, badge badge-warning, badge badge-danger, badge badge-info
badge badge-light, badge badge-dark, badge badge-pill badge-primary, badge badge-pill badge-secondary
badge badge-pill badge-success, badge badge-pill badge-warning, badge badge-pill badge-danger, badge badge-pill badge-info
badge badge-pill badge-light, badge badge-pill badge-dark

Borders

border, border border-primary, border border-secondary, border border-success, border border-warning, border border-danger
border border-info, border border-light, border border-dark, border-0, border-top-0, border-right-0, border-bottom-0, border-left-0

Buttons

btn, btn btn-primary, btn btn-secondary, btn btn-success, btn btn-warning, btn btn-danger, btn btn-info, btn btn-light
btn btn-dark, btn btn-link, btn btn-sm, btn btn-lg

Font Styles

font-weight-bold, font-weight-normal, font-weight-light, font-italic

Border Styles

rounded, rounded-top, rounded-left, rounded-bottom, rounded-right, rounded-circle, rounded-0

Text Colors

text-primary, text-secondary, text-success, text-danger, text-warning, text-info
text-light, text-dark
text-blue, text-indigo, text-puple, text-pink, text-red, text-orange, text-yellow, text-green, text-teal, text-cyan, text-white
text-gray, text-gray-dark

Text Alignment

text-left, text-center, text-right

Background Colors

bg-primary, bg-secondary, bg-success, bg-danger, bg-warning, bg-info
bg-light, bg-dark
bg-blue, bg-indigo, bg-puple, bg-pink, bg-red, bg-orange, text-yellow, bg-green, bg-teal, bg-cyan, bg-white
bg-gray, bg-gray-dark
Typography

h1, h2, h3, h4, h5, h6

Wells

well, well well-sm, well well-lg

Labels

label, label label-default, label label-primary, label label-success, label label-info, label label-warning, label label-danger

Full documentation for bootstrap can be found here.
Add a new core method addClass(classname as character) so the UI can be easier themed. This can be set to any CSS class defined in any of your "CSS libraries" libraries. This is equivalent to the jQuery addClass() method but operates across Desktop, Web and Mobile.
Add a new core method removeClass(classname as character) so the UI can be easier themed. This is equivalent to the jQuery removeClass() method but operates across Desktop, Web and Mobile.
The "CSS style" attribute can now handle CSS classes defined in your App cssLibs. If you specify a classname e.g. btn-success the "btn-success" CSS class will be looked up in the internal CSS map and the attributes defined in it applied to the UI element. You can specify multiple classes by separating them with a space e.g. btn btn-sm. These are applied from left to right. In other words any attributes to the right overwrite those on the left.
Added a new core property "dropshadow" which when set to true draws a drop shadow under and to the right of the component. You can use this to provide a nice visual effect.
Added two new events and one new property to the "Form" class.

beforeclose()
afterclose()
accepted

When a form is being closed the beforeclose() event is dispatched to the object (any supported scripting language). You can validate the data in the form and reject the "close" operation by setting accepted to false.

The afterclose() event is dispatched when the form is closed. In web/mobile apps this is particularly useful as you cannot block execution with a modal form so you can use this event to extract data from the form and then update the UI and possibly change the state of your UI e.g. switch pages or update data on the server.
Custom "form" class now also available in Web/Mobile.
Custom "webview" class now also available in Web/Mobile.
Custom "pageframe" and "page" (Tabs) class now also available in Web/Mobile.
Added a new property to the "form" custom class called "mobilefullscreen". To provide a better mobile experience you can set the mobilefullscreen form property to true. This is ignored unless the App is running on a phone. On a phone this maximizes the form into the viewport of the phone and removes the border. Note that you can show the form fullscreen on all devices by setting the "fullscreen" property to true.
Audit trails and data security go hand in hand and it is highly desirable that this functionality is built-in. Lianja database timelines provide row versioning for database tables for all CRUD operations performed on data. Whenever a change is made to a table that is timeline enabled then delta changes are automatically recorded for each transaction. Changes made to any tables that are timeline enabled can be undone much like you would undo changes to program code that you edit in a text editor. Database timelines record who did what from where, when did they do it and what did they change. An invaluable feature for SaaS applications.
In Lianja 4.1 you can enable timelines globally for a database.

alter database yourdatabase metadata "timeline=on"
This will enable timelines for all non temporary tables contained within the database. You can disable timelines for individual tables like this:

alter table yourtable metadata "timeline=off"
The LIST TIMELINE COMMAND has been extended.

list timeline list timeline for condition list timeline range "YYYYMMDD[HH:MM]" list timeline range "YYYYMMDD[HH:MM]", "YYYYMMDD[HH:MM]" list timeline since "YYYYMMDD[HH:MM]"
Added Babel as a supported scripting language. Babel is a tool for transpiling (compiling) ES6/ES7 code to ECMAScript 5 code, which can be used today in any modern browser. Even more - Babel has extensions for transpiling JSX for React and Flow syntax for static type checking.
Babel and its surrounding ecosystem is playing an essential role for today’s modern web applications. Now with Babel fully integrated into Lianja you are ready to start using the latest JavaScript specs and accompanied technologies (JSX, Flow, etc.) from now on.

Babel files have a ".esx" extension. You can set the scripting language in your App to "Babel" in the App settings.

Any editing changes to the ".esx" file cause it to be automatically transpiled into a ".js" file in the same way a ".ts" TypeScript file is transpiled into a ".js" file.
Custom "chart" class now available which wraps the chart gadgets. This can be used in desktop, web and mobile. It can be used very effectively in FormGrid and custom grid cells.

chart = createObject("chart") // or cont.addObject("ochart", "chart") // properties and their defaults are as follows. // "pie" // "horizontal bar" // "vertical bar" // "line" // "gantt" // "donut" // "bipolar" // "fuel" // "funnel" // "gauge" // "meter" // "odometer" // "radar" // "rose" // "radial scatter" // "scatter" // "thermometer" // "waterfall" // "vertical progress bar" // "horizontal progress bar" ochart.charttype = "pie" ochart.charttable = "" ochart.chartwidth = 250 ochart.chartheight = 250 ochart.charttitle = "" ochart.charttitleforecolor = "" ochart.charttitlebackcolor = "" ochart.chartdata = "" // comma separated list which can contain {macros} ochart.chartlabels = "" // comma separated list which can contain {macros} ochart.chartlabelsabove = true ochart.chartkeylabels = "" // comma separated list ochart.chartlabelforecolor = "" ochart.chartbackcolor = "" ochart.chartgutterleft = 60 ochart.chartgutterright = 60 ochart.chartguttertop = 40 ochart.chartgutterbottom = 25 ochart.chartshadow = true ochart.charteffects = true ochart.chartgradient = true ochart.chartgradientstart = "" ochart.chartgradientend = "" ochart.charttooltips = "" // comma separated list ochart.chartcolors = "" //comma separated list ochart.chartdelegate = "" // call refresh() to update the chart after changing any properties ochart.refresh()

The code above is Lianja/VFP but is exactly the same in JavaScript/TypeScript/Babel, just add semi colons to the end of the lines.
Added a new core property "raisedshadow" which when set to true draws a shadow effect around the component. You can use this to provide a nice visual effect.
Improved TypeScript integration with the ability to specify TypeScript as a scripting language. TypeScript custom sections and gadgets are now correctly auto-compiled.
Added the following new properties to a container which turns it into a GroupBox:

caption captionalignment (0,1,2 or 'left', 'right', 'center') captionfontsize (number or 'small', 'medium', 'large','x-large' or 'xx-large') captionforecolor

Change the GroupBox color by setting "bordercolor".
Added a new property for "container" objects. "borderradius" can be specified in conjunction with "border" to draw a rounded rectangle.
Support "jsx" TypeScript/React file compilation.
Added a new setStretchFactor() container method to inform the container the relative sizes of each of the UIcontrols inside the container. To better handle a responsive UI you can assign a stretchfactor to each UIcontrol in the layout. So for example if you set the stretchfactor of the first UIcontrol (index 0) to 2 and the others to 1, then the first UIcontrol will be twice the width of the others.

setStretchFactor(index as numeric, stretchfactor as numeric)
The height and/or width of a custom UIcontrol can now be specified as a percentage. This is equivalent to using setStretchFactor() on the parent container.
Upgraded node.js installer to 8.9.1 LTS. This is used internally for PhoneGap, Electron, TypeScript and Babel support.
Added a new class to the Lianja Framework "scrollpanel". Use this class to embed a large scrollable UIcontrol e.g. a "container" or an "image". This can be used in desktop, web and mobile.

scroller = createObject("scrollpanel") scroller.resize(200, 200) scroller.addObject("cont", "container") cont.resize(800, 600)
Added support for page/section/formitem alias names. Lianja handles building Apps for multiple form factors using UI Personalities. Using alias names resolves the problem where you want to have a page for phone to be different to the page for web. The "Name" of the page is needed at development time but you may want to have the same name for a "web page" and a "phone page". By defining an "Alias name" for the page/section or formitem, when generating the code for web, tablet, or phone you can exclude certain UI elements and generate the code with known names through alias names.
Added some new "Page attributes" to enable some fine styling of the page headers.

Header bottom border (headerbottomborder)
Header bottom border height (headerbottomborderheight)
Header bottom border color (headerbottombordercolor)
Added some new "Section attributes" to enable some fine styling of the section headers.
Use custom header style (headercustomstyle)
Header background color (headerbackcolor)
Header foreground color (headerforecolor)
Header bottom border (headerbottomborder)
Header bottom border height (headerbottomborderheight)
Header bottom border color (headerbottombordercolor)
Added support for scrollable form and canvas sections. There is a new "Section Attribute" called "Scrollable". Check this and Form/Canvas sections can scroll inside the section viewport. Specify the "Scrollable height" and "Scrollable width" attributes for the Form/Canvas inside the ScrollPanel. If the Form/Canvas is larger than the ScrollPanel scrollBars will automatically be displayed. On Mobile this scrollBar is only visible as you flick up and down inside the Form/Canvas. This new scrollable section functionality can be used to great effect with the new FormGrid layout of a Form section and is particularly useful in mobile Apps due to the limited screen size.
Added a new "Page attribute" to enable styling of the "Navigation bar Background color" (Data Navigation Bar at the bottom of a page).
Improved the layout of the CommentsView section in mobile Apps.
Simplified the theming of Form/Canvas section UI Controls (fields and gadgets) by adding "CSS style" for the "Caption", the "Data" and the "Control". This is very effective when used in the new FormGrid layouts and/or Canvas section UI controls.
Added a new "Page attribute" UI Presentation Rule called "Use mobile navigation bar". When generating a phone App if this is checked then a "Material UI" compliant navigation bar is used as the Navigation Bar at the bottom of a page. This mobile navigation bar only has five touchable icons; Add, Delete, Previous, Next, Edit. When Edit is touched and you are editing a form/canvas section then there are only two icons displayed; Save, Cancel. This reduces clutter in the UI and makes it easier to work with on small screens.
A small change but useful. While developing an App if any error messages are written to the "Console" Tab in the "App Inspector" the tab text will blink red/black until you select the tab to look at the messages then clear them by pressing the "Clear" icon. THis is a small change to help spot errors during development.
Added a new Lianja/VFP command.

SET LOCAL ON

This causes any variables being created dynamically (when SET STRICT is OFF) to be created as LOCAL variables rather than PRIVATE variables. This protects you from variable scoping issues. When LOCAL is ON the PARAMETER statement is also treated as a LPARAMETER statement.
Enhanced "Form" section layout to provide a more compelling UI for Desktop/Web/Mobile Apps using NoCode. The "Form" section can now be defined as having a "FormGrid layout" in the section attributes. When FormItems (Fields, Gadgets and/or Components) are added to a "FormGrid" section, you can specify the cell row/col position within the FormGrid, the number of rows and columns that the cell should occupy and (optionally) a fixed width and height for the cell. The layout engine will then lay the form out adhering to these specifications. With this in place, you can adjust the font and appearance (colors etc) of each individual cell. Additionally, as with grid cells, for each FormItem cell you can now specify an optional “Custom editor” delegate and a “Custom display” delegate. The “Custom editor” delegate should return a UI element which typically is a container for sub forms. The “Custom display” delegate can return a container of laid out content or an HTML string. When navigating data in a form section the formitem is displayed using the “Custom display” delegate. When editing the form section and formitems which have a “Custom editor” delegate render the editor in the formitem cell of the FormGrid.
Added two new methods to the "timer" class to simplify its use; start() and stop().
Custom "timer" class now available in Web/Mobile.
Made a few small Code Editor improvements.

Move the mouse over a word while holding the shift key down will highlight that word in the file.
Improved CodeAssist popups and variable highlighting by waiting until the "Activation timeout" (App Editor Settings) expires.
Improved Web/Mobile HTML5 code generation resulting in improved performance.
Improved the "Canvas" visual designer.

Drag and drop operation drops at the position you raise the mouse button.
The current Tab in the App Inspector stays current after a drop operation.
Added "Snap objects to grid" and "Snap objects to grid size" section attributes.
Horizontal and Vertical rulers.
Crosshairs track x,y position as a UI control is dragged around the canvas.
Intellisense improvements.
The following section delegates which previously only worked in Desktop Apps now work in Web/Mobile Apps too.

initformdefaults
beforecreate
aftercreate
beforeupdate
afterupdate
beforedelete
afterdelete
refresh
afterrefresh
datachanged
parentdatachanged
Improved the Lianja/VFP debugging experience. Place either of these commands in your Lianja/VFP code (e.g. in a custom delegate) and when executed the Lianja/VFP debugger will be activated. If the debugger command is used the debug tab will be automatically undocked from the App Inspector into its own floating window.

debug
debugger
Improved the JavaScript debugging experience. Place the following command in your JavaScript code (e.g. in a custom delegate) and when it is executed the JavaScript debugger will be activated.

debugger
Added a new page attribute "Hide navigation history Icons" (hidenavigationhistorybuttons) to hide the navigation history buttons in the page header. THis overrides the setting in app settings if it is checked.
The section methods setJSON() and getJSON() now work across desktop/web/mobile.
Many improvements to the documentation with a lot of new articles and visual guides. See the documentation wiki for details.
Canvas sections can now be traversed in the LOM using .count and .item(n) on the canvas section as documented here.
Added Google reCAPTCHA v2 to App Center Login for Web Apps.
Lianja/VFP procedure/function/classnames can now be up to 64 characters.
Custom page headers. Page headers can now be optionally created by custom code. Use these to display dynamic custom page banners.
There are several new page attributes to support this; "Custom header", "Custom header display delegate".
Custom page footers. Page footers can now be optionally created by custom code. Use these to display dynamic custom page footers.
There is a new attribute attribute to support this: "Custom footer display delegate.
Added a new App delegate "Text translator" to handle localization and message translation.
Added the ability to login and run a Web App rather than navigate to the App Center. See this forum article for details.
Added a new section method called setAllSelected(name, value). You can use this with extensions to apply attributes to all selected UI controls in a Canvas section.
In preparation for data mapping in Web/Mobile clients the keyLookup() and sqlLookup() functions have been added to the Lianja Web Framework and also as built-in JavaScript functions in desktop clients.
Script Editor improvements.
Added a new method called setNamedParameter(name, value) to the Section, CursorAdaptor and Cursor classes. "Named parameters" can be used in desktop/web/mobile Apps to query Virtual Tables which contain ?parameters and {macros}. Default values for named parameters can be specified in the Virtual Table "properties" e.g. "mycvar=hello;mynvar=n:123" etc.
Added a new section attribute called "OrderBy". This affects the order in which records are displayed in desktop/web and mobile. It is a dynamic attribute so it can be changed inside delegates. It has no effect on child sections which require a specific record order based the parent->child relationship. Specifying an "OrderBy" will create an index on the specified column if it does not yet exist.
Added a new section method reopenTable(). This can be used with VTs to reopen parameterized views. It is available in desktop/web/mobile.
Upgraded PhoneGap build to use CLI 8.0.0 (latest).
Grids in Web/Mobile now honor the column input mask when displaying data.
Grids in Web/Mobile now honor the column alignment when displaying data.
Grids in Web/Mobile now handle row dynamic background/foreground colors.
Grids in Web/Mobile now handle column dynamic background/foreground colors.
Grids in Web/Mobile now handle calculated columns.
When positioned on a grid row in Web/Mobile, the current column names of the bound cursor are created as global JavaScript variables. This simplifies validation, calculated fields and other attributes such as dynamic row/column expression evaluation.
To simplify watching for directory and/or file changes I have added a new Lianja system method called Lianja.watchFile(filename). There is a corresponding App delegate called "filesystemwatcher" which is called with one argument which is the directory/file that has changed. The method Lianja.unWatchFile(filename) stops watching the file.
Custom "listbox" class now also available in Web/Mobile.
Added support for ThirdParty Libraries. The "library" workspace now has a category in the files tree "ThirdParty Libs". You can create "New folder..." there and create/edit files in these sub-folders. This provides the ability to package up and distribute third party libraries as lpk files.
Support for using external editors. You can now integrate Visual Studio Code to handle editing of specified file types. App Settinngs has some new attributes to enable this functionality.
SQL query optimizer improvements.
Added a new function reverse( cExp ) which returns the given character expression in reverse character order. This function is useful for creating indexes so that the SQL query optimizer can optimize WHERE column LIKE “%xxx” clauses.
Added the Transact-SQL charindex() function.
Added the Transact-SQL choose() function.
Added a new function dataSessionLevel() which returns the stack depth of PUSH/POP DATASESSION.
Fixed an issue with the caching of rso files. This is now working correctly resulting in improved performance.
Data mapping can now be declared in the data dictionary for a table. If the section attribute "Inherit dictionary rules" is checked then the data dictionary attributes for columns are inherired by Form, Canvas, Grid and Attachment sections. The new "Get data mapping" and "Set data mapping" attributes in the dictionary are now handled by the Lianja Cloud Server also so these are now effective in Web/Mobile Apps. These new column attributes can be declared in the SQL ALTER TABLE statement or in the "Data" workspace column attributes dialog. e.g.

ALTER TABLE "order_details" ; MODIFY CONSTRAINT PRODUCTID ; SET GETDATAMAPPING [keylookup("products", "productid",{}, productname)] ; SET SETDATAMAPPING [keylookup("products", "productname", "{}", productid )]
Autosuggestions can now be declared in the data dictionary for a table. These new column attributes can be declared in the SQL ALTER TABLE statement or in the "Data" workspace column attributes dialog and they now work across Desktop/Web and are ignored in Mobile Apps e.g.

ALTER TABLE "customers" ; MODIFY CONSTRAINT contacttitle ; SET AUTOSUGGESTIONS [select distinct contacttitle,contactname from customers] ; SET AUTOSUGGESTIONHEADERS [Title,Name]
The Script Editor can now be themed in the Settings.
Added kinetic scrolling support for any scrolling UI element such as grids, scrollarea, tree and listbox. With kinetic scrolling, the user can flick in a given direction and it will continue to scroll in this direction until it is stopped either by the user or by friction.

You set the new kineticscrolling property to true to enable Kinetic Scrolling. This provides touch scrolling on touch aware deviced and left mouse button pressed and moved scrolling on non-touch aware devices.
The console workspace and the command window now handle VFP-style & macro substitution.
Improved LDAP/ Active Directory support.
Performance and stability improvements.
Fixed various bugs from reported tickets.

Lianja App Builder 4.2 Release

Released 20-Jun-2018

The version 4.2 release includes:

Many improvements to Web/Mobile App UI layouts.
Various developer productivity improvements:
- Double clicking on a custom gadget caption or custom gadget webview caption will switch into the script editor without having to navigate the attributes in the App Inspector.
- Intellisense for Lianja/VFP has been re-engineered and it is now faster and less obtrusive than it was previously.
- App "Settings" are now embedded as a Tab in the App Inspector.
You can now prefix section menus, footer menus and metatypes with + or - in 4.2. you can add an item by prefixing with a + or remove an item by prefixing with a - so now you can add or remove menuitems based on conditional metadata.
Section attributes for the grid row height can now be individually specified for Desktop, Web, Phone and Tablet.
New lianjarun command for running background/batch jobs. See doc for details.
New lpk() package manager. See forums for details.
*New* Query Builder. See forums for details.
*New* Query Picker. This is a combination of data bound "Miller Columns" and a searchable data grid. It is a powerful means of querying tree structured data that dynamically change the items in the columns to the right as you click on a column item. It is data bound and can result in child sections to be refreshed dynamically as the columns selections change. See forums for details.
*New* Section right-click context menus across Desktop, Web and Mobile
Dialog Buttons on UI fields now operate across Desktop, Web and Mobile
Improved input mask handling
*New * Now supports printing of sections and pages. Pages and sections have a new "Print" icon and a new "Print delegate".
Significant Web and Mobile App performance improvements. Release mode now caches static content better than previously.
Performance and stability improvements.
Fix reported bugs.

Lianja App Builder 5.0 Release

Released 06-Dec-2019

The version 5.0 release is a major release focused on developer productivity and much improved performance. It includes:

Added showcolumns=false parameter to the QueryPicker to display just a data grid without any cascading columns above it
Extended the right click context menu in editor tabs (App and Library workspace) to add;
* Show In Explorer
* Open Command Prompt Here
* Quick Deploy. If the file is a script file, it is automatically compiled then deployed if compilation is successful.
Added a new CHECK DATABASE command for checking the integrity of a database and all its tables, indexes and memo files.

CHECK DATABASE database_name [REPAIR]
CHECK TABLE table_name [REPAIR]

If the optional REPAIR keyword is specified:
- If index errors are detected they are auto repaired.
- memo files are checked for duplicate links and if any are detected they are unlinked.

The CHECK command can be run on shared data.

After execution the "_tally" system variable is set to the number of errors detected.

Added support for "Additional file path" and "Autoload libraries" in App "Settings". Any libraries that are auto loaded are monitored for changes and reloaded if changes are detected.
Added several new methods to the Lianja system object.

Lianja.loadLibrary(filename as character) returns logical.

This loads a library and supports all scripting languages i.e. prg/dbo, js, ts, py, php, esx. The fllename can be prefixed with known locations and will be translated i.e. app:/, lib:/, pagelib:/, extensions:/, packages:/, data:/, themes:/, metatypes:/, cloudserver:/, wwwroot:/, images:/.

When using Lianja.loadLibrary() in development mode any changes to the library are detected and it is reloaded.

Lianja.fullPath(filename as character) returns character.

The fllename can be prefixed with known locations and will be translated i.e. app:/, lib:/, pagelib:/, extensions:/, packages:/, data:/, themes:/, metatypes:/, cloudserver:/, wwwroot:/, images:/

Lianja.loadAddIns()

Searches the "Additional file path" and for each of the paths will load a library if a file of the same name as the directory exists. This supports all scripting languages i.e. prg/dbo, js, ts, py, php, esx.
Clicking on a "Tab" in a "TabView" section will select the attributes for that Tab in the App Inspector.
Double clicking on a "Tab" in a "TabView" section will switch to code editing if the tab contains a "custom" section.
Added a new method removeAll() to the "container" UI Framework class. This removes all controls inside the container.
Added several new App Editor Settings; "App file search path" and "Library file search path". These contain a ; separated list of directories to be searched for files that are scanned for procs/functions/classes in the script editor.
Navigation panels on pages are now auto scrollable if there is not enough space to display the navigation items.
The navigation panel items can now reference a page as well as page.section
The navigation panel items can now handle all special command for Lianja.showDocument().
Accordion stack at runtime now honors the section "Hide header" attribute.
Added a new Lianja system object method Lianja.setRelationship(cPageID, cParentSectionID, cChildSectionID, cParentKeyExpr, cChildKeyExpr)
Added a new page method page.setRelationship(cParentSectionID, cChildSectionID, cParentKeyExpr, cChildKeyExpr)
Added a new section method section.setRelationship(cChildSectionID, cParentKeyExpr, cChildKeyExpr)
Various web/mobile grid improvements.
- The page navigation bar can now be used to navigate records in grids when there is only one grid on the page.
- Editing or Deleting a record stays on the same row index after the operation completes.
The navigation menu in web/mobile is now scrollable for those who want to place many items in this.
The Query Builder can now be used with Report sections and any WebView based sections to dynamically filter the data displayed. This is functional across Desktop, Web and Mobile.
Many Web/Mobile UI layout improvements.
Enhanced "Report" sections.
- Improved bootstrap-like UI look
- Use the Query Builder to drilldown and filter data interactively
- Now supports custom cell formatting
- Customizable column alignments
- Customizable column display masks
- Customizable cell dynamic foreground and background colors
- Customizable column dynamic data mapping
- You can now specify SQL statements as the data source providing the ability to join multiple tables and generate Crosstab reports
- Reports can be generated in a custom sort order
- You can drill down in reports by specifying a "click" and/or "dblclick" delegate.
- Row heights can now be customized
- You can provide your own CSS library to style the report
- You can sort interactively by clicking or touching on column headers
- You can now generate a "summary only" report
Includes the Lianja Report Builder which provides end users with the ability to design their own business (BI) reports visually using drag and drop.
Significant improvements to the ODBC driver so that it works better with Crystal Reports, PowerBI and Excel 365.
Added a new function str_expand(cExp) that will expand {macros} in the specified character argument.
The Lianja ODBC driver now authenticates with Lianja SQL Server in the same way as Lianja Cloud Server and honors row filters and dynamic data masks depending on the authenticated user roles.
Productivity improvement: The "Users" workspace now has a "Deploy" button which allows quick deployment of users, roles, row filters and dynamic data masks.
The include directive in .rsp/.jssp pages can now automatically convert from a codepage to utf-8
Productivity improvement: Added a new "Shortcuts" icon in the modebar. This contains "Recent Projects", "Recent Apps" and "Recent Files".
Productivity improvement: New "Skill levels" for attributes in the App Inspector.
Productivity improvement: Added Forums and Doc workspaces.
Productivity improvement: Dramatically faster startup and loading of Apps.
Improved support for lowres displays. The ModeBar now auto hides icon text if not enough space.
Productivity improvement: "Builders" and "Wizards" to assist in Creating new Apps, adding new pages, sections and gadgets.
New Lianja system object methods implementing of the VFP "mover" classes.
"Richtext Editor" improvements including the ability to insert images.
Fixed an issue with Google Maps which stopped working as the Google API changed.
Improved Google Charts gadgets properly centering them in the gadget container.
Productivity improvement: You can now create template Apps and "Save as App Template" from the "Apps" menu. These then appear in the new App Wizard "Templates" panel. Template names that contain "__" is replaced with a newline. "_" characters are replaced with spaces. THis provides the ability to provide meaningful names for the templates in the App Wizard.
Productivity improvement: Many Canvas Designer improvements:
- Added new section attribute "Render same as desktop" so that exact pixel poistioning, font and dimensions work better in Web/Mobile Apps.
- Added support for anchors in Web/Mobile.
- Added a right click context menu to speed up development.
- Added "Same tag" and "Select all tag" to the context menu and the formtoolsbar.
This allows you to group controls, select the group and change attributes across the whole group of controls.
- Improved relaying out of UI controls as the window is resized.
Added support for optiongroup and optionbutton in Web/Mobile canvas sections.
Productivity improvement: Now includes "Team" development functionality with a close github integration. Development teams can now work better together on shared applications.
Productivity improvement: Now includes the ability to deploy application packages to the "Team" or "Applications" repository in github. This is a major productivity improvement providing centralized application distribution and update management. There is a new menuitem in the App Center after login called "Repository" which allows users to Download new Apps, Update existing Apps or Open apps they have already installed that have no updates. This is similar to the Apple App Store but is for Lianja Application distribution in private clouds. This works across desktop and web.
Productivity improvement: The “Page Builder Assistant”. This floating Dialog sits to the right of the pages workspace to assist you designing and coding delegates in pages. It provides shortcuts for many common operations and the ability to navigate quickly between the pages, sections and formitems. Page, section and formitem delegates can then be edited in a floating editor directly in the pages workspace.
Productivity improvement: MetaData is now applied to "Grid Columns" and "Canvas" sections.
Productivity improvement: New "UI Explorer" in the App Inspector.
New UI icons throughout all tree views to provide a more modern appearance.
Handle app specific favicons in web apps. If the file favicon.ico or favicon.png exists in the app deirectory it is used as the favicon for the web app.
Added the ability to create and drop indexes on columns from the Data workspace. Lianja uses case insensitive indexes to simplify SQL queries so you do not need to use UPPER() or LOWER() when creating indexes. The SQL query optimizer will optimise using indexes if any exist. This is true for LIKE pattern matching too.
Added support for some additional controls in Web/Mobile canvas sections:
- LCDnumber
- ProgressBar (Vertical and Horizontal)
- Slider (Vertical and Horizontal)
Added a new function dbd() with the same arguments as dbf(). This returns the name of the data dictionary or "" if none is active.
Now supports Continuous Integration / Continuous Delivery of database schema updates.

One of the challenges in Web and Mobile Apps is to provide a seamless upgrade experience while the Web/Mobile apps are being used by end users. It is clearly not practical to ask users to "log off" as they can be logged in from all over the world and be operating in different timezones.
Lianja 5 includes the ability to apply database and app updates to live systems without affecting the logged in users. Database schema updates can be deployed as a Lianja package.
The new database compare command compares two databases and generates an upgrade script that can be packaged up and uploaded to a live system. It is automatically detected and installed by the Lianja Cloud Server without requiring any machine downtime.

compare database db1 with db2 [to file upgrade.prg]

See this forum post for details.
Added two new functions binStrToFile() and binFileToStr() that are the same as strToFile() and fileToStr() but they operate on binary data.
Much improved COM/ActiveX support on Windows.
Productivity improvement: Now supports visual components. You design these in the canvas designer and then save as a visual component which can be used as a custom gadget, embedded in a cell of a grid or embedded in a cell of a formgrid section.
- Visual components are saved into the following directory as JavaScript code so that they can be used in Desktop, Web and Mobile Apps:

lib:/components/component_library/component_name
- When you save a canvas section as a visual component the JavaScript code is automatically generated.
- The name of the component is specified in the canvas section "Visual Component Details" attributes.
- You should not edit this code as it will be generated automatically every time you save changes.
- You can reference components using the notation
component:/component_lib.component_name.

- It is best practice to make your component libraries unique to your organization e.g. com_yourcompany. This will allow them to be used by other developers without causing any name clashes.
- When generating Web and Mobile Apps visual components are included in the index.html file so there is no need to deploy them specifically.
- Visual components can also be used in custom section and custom gadget code. You simply call the constructor function in JavaScript like this:

mycomponent = yourcomponentlib_componentname();
Improved the VFP compatible messageBox() function in JavaScript.

messageBox(text as string, flags as numeric, title as string, okcallback as function, cancelcallback as function)

The callbacks are implemented in desktop, web and mobile JavaScript Apps.

See this forum post for details.
Added the VFP compatible inputBox() function in JavaScript.

inputBox(caption as string, title as string, default value as string, okcallback as function, cancelcallback as function)

The callbacks are implemented in desktop, web and mobile JavaScript Apps. The okcallback function is passed one argument, the value input.
The VFP space(len as numeric) function is now implemented in desktop, web and mobile JavaScript Apps.
The VFP choose(index as number, args as list...) function is now implemented in desktop, web and mobile javascript apps.
console.log(text as string) is now available in desktop javascript. Text is written to the console output.
Web/Mobile Apps now support inline editing of grid cells.

See the following forum post for details.
Inline editing of grid cells now supported
Added several new database events.

See the following forum post for details.
New database events
Added refreshNavigationPanel(url as string) to the desktop page builder object.
Improved Web layout for calendar sections making them better adjust into the viewport.
Improvements to the custom layout managers in web/mobile.
Added a new method to the Lianja system object. Lianja.uploadImageFiles(). You can use this in desktop, web and mobile apps to upload one or more image files and store them in a table on the server (or desktop).

Lianja.uploadImageFiles(controlsource as string, multiple as boolean, title as string, onsuccess as function, onerror as function)

The callbacks are implemented in desktop, web and mobile JavaScript Apps. The onsuccess function is passed one argument a string containing a comma separated list of the files uploaded.
Productivity improvement: New Troubleshooter. The Troubleshooter is displayed as a tabbed dialog on top of an app. It provides a powerful means of measuring App performance in the "Performance Metrics" tab, profiling code in the "Profile Metrics" tab and a lot of new debugging functionality.

The Troubleshooter and code profiler
Productivity improvement: Much improved Lianja/VFP debugger which can now be used to debug .rsp pages.

See the following forum post for details.
Debugger enhancements
Improved syntax highlighting for rsp files (html, javascript and Lianja/VFP).
Productivity improvement: Apps load 2-3 times faster than previous versions.
Added new code profiling tools. When editing a script file, click the "Profile this file" and it will be run and profiled. The profile metrics are displayed in the Troubleshooter "Profile Metrics" tab.
Added a new Lianja system method; Lianja.logEvent(expr as character). This can be used to pinpoint performance bottelenecks in your code. The text passed an argument is displayed in the "Performance Metrics" tab in the Troubleshooter.
The "Events" tab in the App Inspector has been moved to the "Troubleshooter" and has been renamed to "Performance Metrics" and enhanced.
Added a new function; typeof(expression) as character, which returns string, number, date, boolean, currency, datetime, array, object, undefined or null.
Improved Python memory management and garbage colection.
Ability to install python packages using pip in the python console.

pip reference guide
Python server side scripting in the Cloud Server.

Python Server Pages
Productivity improvement: When adding section WebViews or gadget WebViews you can now choose what language the custom renderer code should be written in; Inherit, Recital, Visual FoxPro, Python, PHP or JavaScript.
Added LIanja.switchDatabase(name as character) to the Lianja system object. Switches databases in desktop runtime applications and web/mobile apps. The database should have the same tables and table structure as the database used to decvelop the app.
Added Lianja.getUrl(url as character [, username as character, password as character [,filename as character]]). Returns a string or the file size if filename is specified.
Added SET CONNSTR TO "...". This specified a global connection strng for all non temporary tables. If you do this in an App make sure your tables all exist and are of the same structure. Note also the PUSH/POP DATASESSION save and restore the global connection string.
Productivity improvement: Much improved Common Language Debugger. This is now used for Lianja/VFP, Python and JavaScript debugging. Improvements include:
- Hover variables all scripting languages
- Local variable inspection on breakpoint
- Global variable inspection on breakpoint
- Code navigation by clicking grid rows in the call stack
- Conditional breakpoints
Added Lianja.refreshAppInspector() in desktop. Call this after setting attributes programatically to refresh the attributes in the App Inspector and the Page Builder Assistant.
Productivity improvement: The Versions Workspace now has a built-in graphical diff viewer.
Python 3.7 is now embedded.
Implemented many of the enhancement requests (ER) submitted by developers.
Performance and stability improvements.
Fix reported bugs.

Lianja App Builder 5.1 Release

Released 12-Dec-2019

The version 5.1 release includes:

Ability to group Apps together into Tabbed groups in the App Center.
Support for tiles with dynamically generated badges.
Performance and stability improvements.
Fix reported bugs.

Lianja App Builder 5.2 Release

Released 14-Jan-2020

The version 5.2 release includes:

Collapsible Navigation Panel lists are now also supported in the web client (previously desktop only).
Added "Like" and "Sounds Like" to search panel conditions.
Fixed an issue importing Python modules in Linux.
Added upperc() and lowerc() functions that convert utf-8 character data e.g. German.
Subtitles can now contain {} macros which are dynamically updated in the UI as you navigate records. This was already in desktop but now works in Web/Mobile too.
Added the ability to "Show Record Mark" as the first column of grids and "Record Mark Expr" which is evaluated and displayed in the horizontal row header. Additionally the "Record Mark Tooltip" will be displayed if the mouse hovers over it. Both of these attributes can contain {} macros. This is currently desktop only.
Improved operation of TabViews that contain related sections. Navigating records using the ActionBar buttons navigates the section that has a "Search field" specified then refreshes related sections. See example_reltabs sample App. Basically you do not need to have the "Search field" Tab selected to navigate related data (grid for example).
Added a new grid attribute "Show record mark". This displays the row number down the left of the grid similar to a spreadsheet.
Added deployment branches so that deployment can be automatically done during testing against local / remote servers. This is a ComboBox at the top of the ModeBar on the left side of the main window.
Added ComboBox at top of the ModeBar to switch between Debug/Release mode.
http(s) upload of packages to Cloud Server now supported.
*New* dashboard section. Open example_dashboard App then switch to runtime. Switch back to development view and run live in browser.
Auto updates can now be optionally turned on.
Improvements to licensing messages.
*New* app security for unauthenticated Apps. If you want to have unauthenticated Apps then:
- Set envvar (registry on Windows):
  DB_ALLOWUNAUTHENTICATED_APPS=true
- Set envvar (registry on Windows):
  DB_UNAUTHENTICATED_APPS=appname1,appname2,appname3,...
- Check "Enable guest access" in the App settings.
- Only Apps that have been granted access (are in the DB_UNAUTHENTICATED_APPS list) can be run without authentication.
Increased cloud server connections from 10 to 25 for development and testing.
Productivity improvements.
Security improvements.
Performance and stability improvements.
Various bug fixes

Lianja App Builder 5.3 Release

Released 01-Jul-2020

The version 5.3 release includes:

Added Visual Components to "Section" and "Gadgets" in the Form Tools. You create Visual Components using the Canvas Designer. They can then be used in desktop/web/mobile Apps in Custom Sections, Custom Gadgets, Grid Cells, Custom Search Panels and Custom DialogPanels.
Added a new Component Gallery to the Form Tools. You can now create a custom section based on a Visual Component.
Added the ability to customize Visual Components in Custom Sections and Gadgets using a new Custom Attribute Editor. You can now change the attributes on any attribute inside the Visual Component without coding.
Clicking the keyboard icon in the section header of a Custom Section or WebView Section which has a component embedded in it now pops up the "Custom Attribute Editor" for the component.
Clicking the keyboard icon in the header of a Custom Gadget or WebView Gadget which has a component embedded in it now pops up the "Custom Attribute Editor" for the component.
Added "Component Gallery" to the Windows menu and as an icon "Components" in the bottom panel of the ModeBar.
Improved code generation for sections/gadgets containing components.
Added support for saving WebView Sections as components. All you need to do is define the Visual Component Details in the section attributes.
- Component Library
- Component Name
- Component Author
- Component Version
- Component Description
Custom Search Panels can now embed components. Specify like this:

component:/example_component.barrytest('field3.backcolor=red;field3.forecolor=yellow;')

example_component is the name of the component library and barrytest is the name of the component.
Lianja.showDialog() and Lianja.showDialogPanel() can now embed components. e.g.

Lianja.showDialog("Title", "component:/example_component.barrytest('field3.backcolor=red; field3.forecolor=yellow;')") Lianja.showDialogPanel("Title", "component:/example_component.barrytest('field3.backcolor=red; field3.forecolor=yellow;'')", "50%")

If the component is a WebView you can customize the parameters like this:

Lianja.showDialog("Component", "component:/example_component.barrytest_chart?title=This is a chart&backcolor=lightblue",0,0,true)
New ArticleView section. This renders an HTML page with a (default) bootstrap theme.
The HTML can be edited in development mode with a WYSIWYG HTML editor subject to roles and permissions by clicking on the keyboard icon in the section header.
You can use this to design a front page or generate UI design elements for your Apps.
HTML files are now edited using a WYSIWYG HTML editor.
The HTML editor now supports the inserting of inline images into the html file being edited.
New 'Server Status' indicator in the top right of the Lianja App Builder MenuBar.
The indicator is green if the Lianja Server is running and red if it is not running.
Clicking the indicator opens the Lianja Server Manager. If you are not administrator you will be asked for credentials.
Added "Custom Props" to Page, Section and Formitem attributes. This should be in metadata format i.e name=value;name2=value. You can get the value of this using Lianja.get("id").customprops. The value can be decoded as an object using metadata_decode(Lianja.get("id").customprops ). This is available in Desktop, Web and Mobile.
Added metadata_decode("name=value;name2=value") to JavaScript.
It is already available in Lianja/VFP. This returns an object which can reference "Custom Props".
Added support for inline Virtual Table VARCHAR editing, long string editing and a new Stringlist Editor. See a preview here.
Added the ability to update Virtual Table VARCHAR fields using the standard VFP-style replace command.
Virtual Table VARCHAR fields that are bound to WebView Sections and Gadgets are now correctly updated in the target SQL database.
In other words they operate just like memo fields in the native Lianja database.
Improved dashboard sections. They can now layout horizontally on the same row as well as top to bottom, left to right. Lianja App Builder v5.3 includes additional example Apps to demonstrate dashboard sections. Find them listed under 'General' in the App Names explorer panel in the Apps Workspace.
- The example_dashboard2 App shows how to layout sections horizontally.
- The example_dashboard3 App displays a grid on the left and a form on the right in a dashboard section. The action bar buttons navigate between records in the form section. Clicking on a row in the grid (on the left) relates a record in the form. You can then navigate the records with that "child key".
Added new set command: set backticks on/off. This enables or disables `backticks` command line substitution
Lianja.clipBoard(expr) is now supported in Web Apps.
Lianja/VFP now recognizes true, false and null as well as the traditional .t., .f., and .null.
Faster App Wizard startup.
Added Section "Footer CSS" attribute. If you want to display multiple lines of text in the section footer or subtitle specify using '
' for newlines and specify 'line-height:25px !important' in the CSS.
Added the list( n ) method to JavaScript ComboBox class.
Added ability to use the linecount and linenumber properties as well as the line(n) method with JavaScript Editbox in Desktop and Web.
New format() function. The format() function formats a string substituting {} parameters with the expressions in the comma-separated list of arguments. This is similar to C# string formatting. Also available in JavaScript on desktop, web and mobile.

str = format("Hello {0} the number is {1} and the date is {2}", "world", 2020, dtos(date()))

It is particularly useful with the Lianja.evaluate() method when passing parameters to a server-side procedure library from a JavaScript delegate in a web App.

var evalstring = format("mylib::mylibproc({0},{1})",num1,num2); var result = Lianja.evaluate(evalstring);
New environment variable DB_ODATATRACE. During Web App development you can set DB_ODATATRACE to true. Run the Web App then check the debug directory for odata_tracexxx.log files. These are text files that contain full OData performance metrics tracing information. For Windows, there is a toggle for OData Tracing in the Lianja Server Manager.
Implemented selected enhancement requests (ER) submitted by developers.
Web/Mobile App UI performance and layout improvements.
MS SQL Server Virtual Table performance improvements in Web Apps.
Fixed and issue with Instant Search against MS SQL Server Virtual Tables in Web Apps.
The 'Create' and 'Modify' Virtual Table dialogs now include a [...] button that opens an editor in a dialog panel for the 'SQL command', 'ODBC Connection', 'Key field list' and 'Properties'. This makes it easier to specify long statements.
Productivity improvement: hovering the mouse over the caption of a formitem (Form Section Field or Canvas Section Advanced Control) displays a tooltip which includes the UI element's id and common business rules. This speeds up the ability to review the UI with other team members.
Improved anchors in Canvas Sections for Web Apps.
Grid Section Column subtotals are now supported in the Web/Mobile clients in the Grid Section Summary.
Section Menus can now have the selected menu option highlighted.
Inline Gadgets can flow with fields in a Form Section. Just check the Inline attribute and set a Fixed height. The caption, if not hidden, will be displayed beside.
Gadgets now have additional attributes Desktop Margin Top and Web Margin Top allowing the top margin for inline gadgets to be set in Desktop, Web and Mobile Apps.
New section.updateCursor() method. This updates the underlying cursor with the Section's field values in Web Apps. This can be used with a Page Custom Save Action.
New sqlCheckUnique() function. This checks whether a prospective column value is unique:
- sqlCheckUnique(cTable, cKeyField, cKeyValue [, lAllowBlank])
// Character cKeyField lCustIDUnique = sqlcheckunique("southwind!customers","customerid","'ALFKI'") // Numeric cKeyField lEmpIDUnique = sqlcheckunique("southwind!employees","employeeid","3") // Ignore blanks lCustIDUnique = sqlcheckunique("southwind!customers","customerid","''",.t.) // Include blanks lCustIDUnique = sqlcheckunique("southwind!customers","customerid","''",.f.)
Three new showdocument() / Lianja.showDocument() actions:
- closeapp:
- exit:
- logout:
Additional page menuitems in the format caption,action|caption,action... where action corresponds to a showdocument() / Lianja.showDocument() argument, e.g. exit: or closeapp:
Improved browsing of Virtual Tables in the data workspace with much improved performance calculating row counts.
New Grid methods: getRowColor(nRow) and getItemColor(nRow,nCol).
MS SQL Server syntax nested select 'from' now supported by SQL SELECT, e.g.

SELECT COUNT(*) FROM (SELECT * FROM customers WHERE country = "UK")
or

SELECT COUNT(*) AS ukcos FROM (SELECT * FROM customers WHERE country = "UK") ukcustomers
New Column field attribute Check unique and corresponding checkunique Column Constraint to check for uniqueness.
New Script Editor tab context menu options: 'Quick Preview' and 'Quick Preview All'.
Timeline Sections are now supported in the Web client if the database has timeline=on metadata set.
New example_timeline example App ('Database Timelines Example' in Demo Web/Mobile Apps) shows how to view dynamic timelines as you edit data.
When reloading an App by clicking on the "Reload" icon in the HeaderBar, all App and Library files being edited are now left open.
The Lianja.writeOutput() and Lianja.console() Lianja system object methods can now be used in server-side Lianja Server Pages in Web Apps to assist in debugging. The output is sent to the current debug_server_xxx.txt file in the Lianja debug directory.
New system tables to provide information for Lianja Cloud Server administration:
- sysapps: currently deployed Apps
- syspackages: currently available Packages and their installation status
- sysreports: currently deployed Reports
New str_date(dExp) function to return a character representation of a date, e.g. Today, Yesterday, Wednesday 7d ago.
New str_size(nExp) function to return a 'human readable' character string for a number in KB, MB or GB.
Grid section column headers can now have their foreground/background colors customized.
Improved performance of the auto installation of Packages.
Improved login performance.
Improvements to delegate code generation when editing: (args) are specified on the generated function and given meaningful names to provide a coding hint.
When clicking on a tab in a TabView section, if an "activate" delegate is declared then it is called after the tab is selected. You can use this to refresh data and execute custom code.
New Shortcuts for 'Quick Project Package...' and 'Quick Package...' options to allow the creation of Lianja Package Files from the currently open Project or App.
New Lianja method Lianja.getElementByControlsource(cSource) and synonym Lianja.getControlsource(cSource) to obtain a reference to data-bound UI formitems (Canvas Section advanced controls, fields and gadgets). The cSource corresponds to the formitem's Data source. See also Working with the Lianja Object Model.
Much improved support for web sockets in both the client and the server. Websockets can be used effectively to handle asynchronous notifications from a remote server. The new Websocket class supports both client and server functionality.
The built-in functions json_encode() and json_decode() can be used to pass objects backwards and forwards between the web client and the server.
The Windows Task Scheduler can be used to run your web sockets service via lianjarun. On Linux, cron can be used.
New functions to get and set Windows Registry values: reg_getValue() and reg_setValue().
Navigation panels now respect page read role settings in the web client. If the page read role does not allow the user to see the page, the navigation panel item will not be visible.
Grid Section column headers can now have their foreground and background colors customized.
The Lianja Cloud Server distributions for Windows and Linux now include 'lianjarun' in the 'bin' sub-directory of the 'server' directory. This can be used to run background tasks.
Added a new library that can be included in WebViews: LianjaFunctions.js. This library contains the core Lianja/VFP functions which are included in the LianjaWebFramework packaged up so that they can be used to generate WebViews. It is now automatically included in any new .rsp, .pysp and .jssp WebViews you create. It is located in the LianjaWebFramework sub-directory of the library directory.
New Lianja method Lianja.evaluateAsync(expr, onsuccess_function, on error_function). This provides an asynchronous evaluation of server side expressions.
When creating new WebView sections the JavaScript and CSS files that are automatically referenced are defined in references.txt (in the webviews sub-directory of the templates directory) and in app:/webview_references.txt (if it exists). This speeds up the development of WebView sections with a consistent UI.
New command buttons added to the popup calendar for date type formitems and grid columns. Desktop: Today, Clear, Done. Web: Today, Clear.
Minor script editor improvements.
New 'lianjadev' static role for testing roles and permissions during development.
New '--minimalui' command line switch to start the Lianja App Builder with 'minimal' ModeBar icons: 'Teams', 'Doc' and 'Forums' are excluded.
The source of text file based Page Navigation Panels can now be accessed via a quick link icon in the Navigation panel caption. See here for details.
Added a charting library that can be used in WebView custom .rsp pages. This library is in lib:/chartlib.prg. You can edit it in the library workspace to see the parameters to the charting functions:
- bar_chart()
- doughnut_chart()
- line_chart()
- pie_chart()
When you create a new custom WebView section the JavaScript charting library is included now by default. You can of course customize this behavior if you need to.
A keyboard icon is now displayed in the Command Window header and can be used to open the Command editor window. If any text is already selected in the Command Window it is loaded into the Command editor window. The editor window has buttons that include the options to save and run the code and open existing script files.
JavaScript delegates (desktop and web) can now reference the UI element for the delegate using 'This' (note upper case 'T'), 'thisElement' or 'thiselement'.
Enhancements to building TabView Sections:
- Click on the new tab bar + icon to create a new section and add it to the TabView section.
- For a Custom Section or custom WebView Section, double-clicking the section's tab opens its source code base in the Script Editor.
The Lianja Admin Console for Lianja Cloud provides you with everything you need to administer your users, databases, packages, reports and - very importantly - forensics in the cloud. It also contains a real time dashboard that is dynamically updated. This monitors the users connected and the CPU, memory and disk usage. The Lianja Admin Console is a Lianja App so you can open it in the App Builder, study how it is implemented, modify it and enhance it and deploy it to your server. Console tabs:
- Dashboard
- Databases
- Snapshots
- Users
- Packages
- Apps
- Reports
- Forensics
Instant search for all file lists in workspaces and the App Inspector tabs:
- Apps and their files
- Databases, tables, columns, triggers, stored procedures and events in the Data Workspace
- Attributes: App, page, section, formitem, column
- Databases, tables and columns in the Pages Workspace
- Library files
- Deployment files
New Lianja methods Lianja.toggleleftsidebarvisibility() and Lianja.togglerightsidebarvisibility() to toggle the visibility of the sidebars in desktop Apps.
UI tweaks and improvements.
Performance, security and stability improvements.
Fixed reported bugs.

Lianja App Builder 5.3.1 Release

Released 17-Jul-2020

The version 5.3.1 release includes:

Performance, security and stability improvements.
Fixed reported bugs.

Lianja App Builder 5.3.2 Release

Released 19-Aug-2020

The version 5.3.2 release includes:

Performance, security and stability improvements.
Fixed reported bugs.

Lianja App Builder 5.4 Release

Released 08-Oct-2020

The version 5.4 release includes:

The Mobile Web Editor now supports inserting inline images. Click the image icon in the editor toolbar to select and insert an image.
Added the Lianja/VFP atline() function.
Web/Mobile UI layout improvements.
Image gadgets and Image control now can “Maintain aspect ratio”.
Clicking the keyboard icon on the right of a section section menu edits the menu selection delegate code.
Script Editor improvements including better smart indenting.
Added two new delegates "beforeedit" and "afteredit".
Added several new methods to the "Lianja" system object.

Lianja.hideNavigationPanel()
Lianja.showNavigationPanel()
Lianja.toggleNavigationPanel()

These change the visibility of the "Navigation Panel". They can be used effectively in the "beforeedit" and the "afteredit" delegates to provide more space to edit data.
Added a new page attribute "Hide Navigation Panel when editing". This causes the navigation panel visibility to be hidden/shown before/after editing the page.
Added support for Progressive Web Apps (PWA) in the "Build" WorkSpace. You can configure the "manifest" file for an App. This manifest is included in the generated html files (index, tablet_index and phone_index).
*new* Responsive UI navigation panel. Specify the "Responsive UI width breakpoint" and the "Navigation Panel" will automatically collapse as icons and expand with captions if the breakpoint is reached on window resizing or mobile viewport size.
*new* Responsive UI section menus. Specify the "Responsive UI width breakpoint" and the "Section Menu" will automatically collapse and expand if the breakpoint is reached on window resizing or mobile (phone/tablet) viewport size.
*new* Responsive UI section search panels. Specify the "Responsive UI width breakpoint" and the "Search Panel" will automatically hide and show if the breakpoint is reached on window resizing or mobile (phone/tablet) viewport size.
*new* all formitems (fields and gadgets) can now be automatically shown/hidden depending on new attributes in the "UI Presentation rules". These new attributes are the "Responsive UI width breakpoint" and the "Responsive UI height breakpoint". As a window (or device such as a phone or tablet changes orientation) the UI is automatically adjusted.
*new* all sections can now be automatically shown/hidden depending on new attributes in the "UI Presentation rules". These new attributes are the "Responsive UI width breakpoint" and the "Responsive UI height breakpoint". As a window (or device such as a phone or tablet changes orientation) the UI is automatically adjusted.
*new* responsive UI form sections. There is an attribute in the "UI Presentation rules" called "Responsive UI minimum width" for each formitem (fields and gadgets). If the viewport is not wide enough to contain the columns in the form section it will automatically handle horizontal scrolling. On a mobile device this allows flicking left and right to scroll the form contents.
Added an additional argument to the set() function. set("installationdrive") returns the drive letter on windows where Lianja is installed.
Added several new functions that can be used to obtain the viewport size; screenWidth() and screenHeight(). You can use these to conditionally hide and show UI elements in the "Visible when" condition or other custom code.Added today() as a synonym for date().
Added a new "cursoradaptor" method to help building of database dependent conditions for use with the requery() method of the cursoradaptor.
ca = new cursorAdaptor() ? ca.queryBuilder("mssql", "territoryid,modifieddate,lower(msg)", "10,2020-10-31,hello world", "N,D,C", ">=,<=,=") // Output for MSSQL is: isnull(territoryid,0)>=10 and isnull(modifieddate,'')<='2020-10-31' and isnull(lower(msg),'')='hello world'
Added a new section attribute "Hide SearchBox". If this is checked and the section is in an accordion stack, when the section is selected the visibility of the "Instant Search" box in the page header is changed.
Added new "pagebuilder" methods (desktop/web/mobile):

Lianja.get("page1").hideSearchBox() Lianja.get("page1").showSearchBox()
Performance, security and stability improvements.
Fixed reported bugs.

Lianja App Builder 5.5.1 Release

Released 16-Nov-2020

The version 5.5.1 release includes:

New argument to the Grid goto() method to move to a record number. The new scroll argument allows the position of the row in the viewport to be specified:
- 0 = scroll to ensure that the item is visible
- 1 = scroll to position the item at the top of the viewport
- 2 = scroll to position the item at the bottom of the viewport
- 3 = scroll to position the item at the center of the viewport
New Listbox property, selectionmode, which specifies how items can be selected:
- 0 = No items can be selected. No item is highlighted, but the value property returns the last clicked item.
- 1 = Single item can be selected. The value property returns the last clicked item.
- 2 = Multiple items can be selected (click one after the other). The value property returns a comma-separated list.
- 3 = Multiple items can be selected (use shift-click and ctrl-click to select). The value property returns a comma-separated list.
- 4 = Multiple items can be selected using shift-click and ctrl-click, but the value property returns only the last selected item.
Many modern languages support the ability to pass functions as parameters to a proc/function. This is a common programming paradigm to implement polymorphism and/or handle completion callbacks. LianjaScript already allows you to assign procs/functions to variables or object members, so to further enhance this it now handles this parameter passing functionality. e.g.
```
function test(callback)
	callback()
endfunc
proc callback1 
	? "callback1 was called"
endproc
proc callback2 
	? "callback2 was called"
endproc
test(callback1)
test(callback2)
```
TabView Sections can now have a TabBar Responsive UI width breakpoint set.
Added Lianja.showWarningMessage() system object method to JavaScript (desktop, web, mobile).
New dynamic language translation in web and mobile Apps, with the option to use Google translate or a custom script. App Settings: Enable google translate and Enable text translator.
Option to allow users to switch languages by clicking a flag in the page header and selecting from the languages pulldown. App Settings: Enable user translate.
New Lianja.switchLanguage(code) system object method available in the Lianja Web Framework (web, mobile). It switches the applicable UI text to the language code specified.
The example_webapp1 sample App (Lianja Tablet Web UI Demo) included in the distribution demonstrates the new dynamic language translation functionality.
Added section.refreshHeaderBadge(cLabel, nReccount) method to the Lianja Web Framework (desktop). This updates the section header badge as used by Instant Search and Instant Selections with the specified label text and record count.
PhoneGap Build, which was deprecated in Lianja v5.4, has been removed because Adobe have discontinued this service. In Lianja v5.5, you can build effective mobile Apps as Progressive Web Apps.
The 'Web App View', 'Tablet App View' and 'Phone App View' headerbar buttons have been removed from the App Builder as they are no longer required. Using 'Preview live in browser' generates the html code for all three clients and current browsers allow you to view the App on a variety of device sizes. See Deploying to Local Directory for more details.
Much improved Progressive Web App caching resulting in a massive performance boost. Note: Internet Explorer is no longer supported by the web client; Microsoft's current 'Edge' browser can be used as an alternative.
When editing files in the script editor, Open file in debugger no longer closes the file in the script editor. Any changes made are synced into the debugger.
New Custom builders intercept the creation of new Apps, Pages, Databases and Tables.
Custom builders can be coded in Lianja (.prg), Python (.py), JavaScript (.js), PHP (.php), TypeScript (.ts) or as Lianja Server Pages (.rsp).
Custom builders can be project specific or apply to all.
For example, a custom builder can be called after the App Wizard completes to specify App Settings for each of the Apps created in a Project.
The following methods have been added to the Lianja system object (desktop) to support custom builders
- Lianja.getAttr(name)
- Lianja.setAttr(name,value)
- Lianja.saveApp()
- Lianja.showAppWizard()
Improved ActiveX support on Windows for "ADODB" with specific use with the VFP OLEDB driver.
The "ADODB.Connection" object method "execute" when used with SQL UPDATE, DELETE and INSERT now returns the "NumberOfRecordsAffected". Remember to code your updates using optimistic locking for multiuser concurrent updating.
Improved ActiveX error reporting.
When editing script files in the script editor, you can now click the line number panel to set breakpoints. This will display the Troubleshooter if it is not yet visible. Toggling breakpoints is synced between the debugger (in the Troubleshooter) and the script editor and vice versa.
The Instant Search delegate, which is called when a printable character is typed in the Instant Search Box, is now also called when a Page Left Sidebar Favorites, Recently Viewed or Recently Modified item is clicked.
New Instant Selection delegate. This is called when an Instant Selection is clicked. The selection's filter condition string is passed to the delegate as a parameter.
Instant Selections now also support 'is like' and 'is not like' comparisons.
New time command to determine how long a given command takes to run.
UI improvements.
Performance and stability improvements.
Fix reported bugs.

Lianja App Builder 6.0 Release

Expected release March 2021

The version 6.0 release will include:

The set rushmore command enables or disables Rushmore-style (Visual FoxPro) index scanning optimization for NoSQL and SQL commands.
Set rushmore is on by default.
With set rushmore on, the speed of the following NoSQL commands is increased by optimizing the for condition, active filter condition or active rowfilter condition. Indexes should be created on the fields specified in the condition to enable the optimization. For optimum performance, use filtered indexes. Use of the upper() and/or lower() functions is not required: with set strcompare on (default), indexes and comparison operators are case insensitive.
- average
- blank
- calculate
- copy
- count
- delete
- list
- locate...continue
- recall
- replace
- scan...endscan
- sum
- total
With set rushmore on, there is also a major performance boost for very large tables when issuing SQL queries using the >, >=, < and <= operators. The = and == operators are always optimized.
Improved SQL optimizer with filtered indexes. (Hint: use the EXPLAIN command to see what's happening).
Added the BACKUP/RESTORE DATABASE and LIST BACKUPS commands.
The 'IN <workarea>|<alias>' clause has been added to the following commands:
- average
- blank
- calculate
- continue
- count
- delete
- exit
- list
- locate
- loop
- recall
- scan
- sum
Note that the IN clause must be the first clause as IN is also an operator in Lianja.
Added new App attribute "Enable PerfMeter" which shows the perfmeter in the "Console" workspace for long operations.
Added a StatusBar to the console workspace. SET PERFMETER ON if you want to see a progress bar displayed in the StatusBar when performing long operations.
Page, section and formitems names can now contain _ in desktop/web/mobile apps.
Virtual Tables bound to sections have much improved performance of section relationships. No need for custom code in the parentdatachanged event delegate any more. The relationship is now satisfied using requery() on the child data source.
Grid columns: new Only visible when editing attribute. Columns are hidden until the grid row is being edited. This provides a better UI grid for mobile devices.
Switching between Pages, Sections, Formitems and GridColumn attributes now maintains the search text. This speeds up the reviewing of attributes during development.
When using the debugger with LianjaScript, clicking the Stop icon now cancels execution when the debugger is active.
Lianja.showDialog() and Lianja.showDialogPanel() are now responsive in web / mobile. This can be seen when using the QueryBuilder on mobile devices.
New App UiLibs. Design pages visually then add them to the App UIlib enabling them to be used with Lianja.showDialog() and Lianja.showDialogPanel(). Check the page attribute "Register in UIlib". The pages are not included in the pages menu but can be used with dialogs by specifying "page:pagename" as the file name.
DialogPanels can be be shown on top of existing ones. So, for example, if a page in the UiLib contains a grid section, then editing a row in the grid will overlay the grid with the "EDIT FORM" and clicking "Done" or "Cancel" will switch back to the previous DialogPanel i.e the grid section. This provides smoother UI transitions and a better mobile experience when screen size is limited.
New delegates for Grid sections. Interactive Change is called after a cell is edited. Row/Col Change is called when a cell is selected, before being edited. Both are passed three arguments: nRow, nColumn, cValue.
New properties for Virtual Tables:
- translatequeryfunction=function
  The function is called to translate a native Lianja SQL WHERE condition for a target SQL database syntax.
  It is called with two arguments: cWhereCondition, cDBtype. It should reside in the database container.
- convertuint=1
  Use this to correct the ODBC interpretation of BIT fields in MySQL.
- datsourceoptions=options
  Where options are database specific, e.g. for ODBC to increase packet size:
```
SQL_ATTR_PACKET_SIZE:102410
```
Several improvements made to Image Strip Sections.
- Image notes are now supported in the web/mobile client.
- HTML image notes are now handled correctly.
- In web/mobile Apps, the images are touch-friendly and can call the Double click event delegate.
- Image notes are now editable: new attribute Image notes editable.
- Touch or click the image notes text to display the slide-in dialog panel editor.
Improved error reporting.
Page, Section and Formitem names can now contain underscore characters (_) in desktop and web/mobile Apps.
Mailing label printing is now supported using the create label and label form commands.
The Console workspace now has a Statusbar. The display of the Statusbar can be toggled from the View menu.
New set perfmeter command. With set perfmeter on, a progress bar is displayed in the Console workspace Statusbar when performing long operations.
Added new App attribute 'Enable PerfMeter' which shows the perfmeter in the Console workspace for long operations.
The Deploy workspace has been enhanced to allow package files to be built for a specified deployment target. This also includes the ability to exclude files and use wildcard characters in filenames when defining the package file to facilitate team development.
Fixed a caching issue with very large SQL queries (millions of records) that would cause a crash.
Added additional information to dir command when no database open.
Added additional information to the list structure command with Virtual Tables.
Performance improvements when bulk loading tables using append from, append blank and generate. Set timeline off is automatically executed and turned back on afterwards.
Performance improvement when using the count command with no filter condition.
The Grid Section Summary can now optionally include Minimum, Maximum and Average column values along with the column Totals. The 'Lianja Tablet Web UI Demo' (example_webapp1) App demonstrates this.
The Responsive UI breakpoint attributes have been added to the Generate App Doc output file.
Added improved package management for Team Development and Release Management in the Deploy workspace. Packages can be created in the Deploy workspace then published to Team or Release GitHub repositories. Options to Unpublish published packages and List published packages are also now available.
The lianja command can be used to install Lianja package files with automatic version checking.
The new lianja-lpk command can be used to install a Lianja package file or list its contents.
Available for macOS (Big Sur, 11.1), as well as Windows and Linux.
The macOS Lianja distribution is now notarized by Apple:
- "Notarization gives users more confidence that the Developer ID-signed software distributed has been checked by Apple for malicious components."
- "When the user first installs or runs your software, the presence of a ticket (either online or attached to the executable) tells Gatekeeper that Apple notarized the software. Gatekeeper then places descriptive information in the initial launch dialog to help the user make an informed choice about whether to launch the app."
The Linux license management utility, lianja-lm, has been enhanced to return additional information when validating the license with the --validate option.
```
$ sudo lianja-lm --validate
```
Faster switching to home page on macOS and Linux.
The location of the Lianja 64 bit ISAPI extension for IIS has changed. See ISAPI Extension for IIS for full details.
Arguments passed to an App using the --args command line switch, specified in Lianja.openApp() or included in a web App URL can now be queried using Lianja.args.
The new lianja-lpk command line tool can be used to install a Lianja package file or list its contents.
The new lianja-comp command line tool can be used to compile .prg script files.
The compare database command now includes all database events and generates an optimized upgrade.prg file.
App Doc now includes Grid columns.
The section attributes Visible when and Readonly when can now reference "this" and "thisform" e.g. readonlywhen could be set to !this.editing which causes the section to be readonly unless in edit mode.
The Enable when editing attribute is now supported on Form, Grid and Attachments sections as well as Canvas sections. This is only effective in runtime mode. It causes sections to be readonly until editing is in effect.
Exposed the "state" attribute for Page, Section and Formitem objects. "State" is a comma separated list of UI States that the UI element handles.
Exposed the "uistate" attribute for Page, Section and Formitem objects and the Lianja system object. "Uistate" is the last UI State applied.
The SQL Select aggregate functions min() and max() now handle a list of arguments and additional data types: character, currency and datetime as well as date and numeric.
New list library command to list all currently loaded procedure and function libraries.
Various UI tweaks and improvements.
Performance and stability improvements.
Fix reported bugs.

Lianja App Builder 7.0 Release

Expected release Q1 2021

The version 7.0 release will include:

Lianja Cloud release with various Cloud App Builder tools.
- Form Builder
- Report Builder
- Chart Builder
- Script Builder
- App Builder
New: Build Apps faster than ever with 'Relationships'. Drag 'n' drop a Relationship onto a Page to create a section for each table in the relationship and have them be automatically related on the page. The optional 'attributes' can be used to override automatic relationships and/or add additional functionality e.g. cascadedeletes. The table list can contain native Lianja tables and/or Virtual tables. A '+' prefix on a table name defines a one to many relationship which results in a Grid section otherwise it is a Form section. Columns included are determined by user roles and permissions. Metadata and DD business rules attached to the table and columns are inherited by the sections.
create/alter relationship customer_orders[pageattributes] as customers[sectionattributes],+orders[sectionattributes],+order_details[sectionattributes]
New visual relationship builder tool in the data workspace. These 'Relationships' are added into the database container just as virtual tables are. You can USE a relationship which dynamically creates a SQL statement that joins the tables described by the relationship. When dragged into a page in the page builder the page is automatically generated.
New web based 'Form Builder' with a UI similar to the 'Report Builder'. 'Forms' can be designed by end users by simply dragging 'Relationships' onto a blank page. Once a form (page) has been created it can be saved and selected from the left sidebar files tree at runtime. This is based on the way the report builder operates. 'Forms' can be secured with roles and permissions. This provides secure end user development of forms using NoCode.
New web based 'Chart Builder'
New web based 'Script Builder'.
New web based 'App Builder'. Combines forms, charts, reports into an App with page navigation.
Performance and stability improvements.
Various bug fixes.

Lianja App Builder 8.0 Release

Expected release date 2021

The version 8.0 release will include:

Support for "Web Components". These will provide the ability to develop and embed "Web Components" in WebViews using a WebComponent architecture that will enable Telerik and other composite components to be used seamlessly in Lianja. We will provide common Web Components for Telerik such as grids, charts and other composites that we feel are useful. Web Components know about "Dependencies" and will inform you if the underlying component is not installed and give you the opportunity to purchase it online and download it. This will provide a fully extensible component architecture which lives inside Lianja. Web Components are defined in a special config file which contains attribute information (properties and events) and the name of the .rsp/.pysp/.jssp file which renders this component. This allows custom properties to be displayed in the "App Inspector" and the "Page Builder Assistant". To developers the web component just looks like a build in Lianja UI section or gadget.
Support .tssp files. These are TypeScript server-side files that are dynamically transpiled. New Mobile-centric grid attribute "Infinitely scrollable". This causes the grid data to be dynamically fetched into view as you flick your finger up and down in Mobile Apps or use the mouse wheel in Web Apps. New "Theme builder" from themes combo New... providing the ability to theme the UI with one click.
Custom "tree" class in Web/Mobile.
Integrate react and improve javascript debugging with Babel (ES6) and TypeScript source maps.
Apps to optionally be generated as "React Native" Apps.
Native Windows x64 build.
Visual FoxPro Report (.frx file) import tool into the Lianja Report Builder.
Visual Form/Dialog Builder that works with existing VFP .scx and .vcx files.
Performance and stability improvements.
Fix reported bugs.

Lianja App Builder 9.0 Release

Expected release date 2021

The version 9.0 release will include:

Cross platform .NET Core SDK integation
Add dynamically compiled C#.NET as a supported language cross platform.
Performance and stability improvements.
Fix reported bugs.

Lianja SQL Server 1.0 Release

Released 3-Feb-2014

The version 1.0 release includes.

Lianja SQL Server for Windows and Linux.
Includes an ODBC driver for the Lianja SQL Server.
Includes a JDBC driver for Lianja SQL Server.

Lianja SQL Server 1.1 Release

Released 15-Apr-2014

The version 1.1 release includes.

Fixed various bugs from reported tickets.

Version 1.1.1 Released 17-Apr-2014

Fixed various bugs from reported tickets.

Version 1.1.2 Released 25-Apr-2014

Fixed various bugs from reported tickets.

Version 1.1.3 Released 04-Jun-2014

Fixed various bugs from reported tickets.

Version 1.1.4 Released 16-Jun-2014

Fixed various bugs from reported tickets.

Version 1.1.5 Released 18-Jun-2014

Fixed various bugs from reported tickets.

Version 1.1.6 Released 02-Jul-2014

Fixed various bugs from reported tickets.

Lianja SQL Server 1.2 Release

Released 11-Aug-2014

Fixed various bugs from reported tickets.

Version 1.2.1 Released 01-Sep-2014

Fixed various bugs from reported tickets.

Version 1.2.2 Released 09-Sep-2014

Fixed various tickets.

Version 1.2.3 Released 10-Sep-2014

Minor bug fixes.

Version 1.2.4 Released 27-Oct-2014

SQL Optimizer improvements.
Minor bug fixes.

Lianja SQL Server 1.3 Release

Released 04-Feb-2015

Further SQL Optimizer improvements
The Lianja SQL Server now runs with STRCOMPARE ON by default. This provides better compatibility with MySQL and MSSQL with regards to character column comparisons. These comparisons are case insensitive and are automatically trimmed. This provides for better query optimizations and simplified CRUD operations.
Fix reported bugs.

Lianja SQL Server 1.4 Release

Released 17-Mar-2015

Further SQL optimizer performance improvements.
Performance and stability improvements.
Fixed various bugs from reported tickets.

Version 1.4.1 Released 20-Mar-2015

Performance and stability improvements.
Fixed various bugs from reported tickets.

Lianja SQL Server 1.5 Release

Released 7-Apr-2015

Performance and stability improvements.
Fixed various bugs from reported tickets.

Lianja SQL Server 2.0 Release

Released 29-Oct-2015

ODBC Driver improvements
Fixed an issue which affected SMARTQUERY caching
Performance improvements
SQL optimizer improvements
JQL/JSON extensions
Fix reported bugs.

Version 2.0.1 Released 4-Nov-2015

Performance and stability improvements.
Fixed various reported tickets.

Lianja SQL Server 3.0

Released 12-Aug-2016

The version 3.0 release includes:

Major SQL SELECT performance improvements.
Performance and stability improvements.
Fix reported bugs.

Lianja SQL Server 3.1

Released 14-Oct-2016

The version 3.1 release includes:

Performance and stability improvements.
Fix reported bugs.

Lianja SQL Server 3.2

Released 02-Feb-2017

Performance and stability improvements.
Fixed various bugs from reported tickets.

Lianja SQL Server 3.3

Released 15-Feb-2017

Performance and stability improvements.
Fixed various bugs from reported tickets.

Lianja SQL Server 3.4

Released 26-Apr-2017

The version 3.4 release includes.

Performance and stability improvements.
Fixed various bugs from reported tickets.

Lianja SQL Server 4.0

Released 30-Aug-2017

The version 4.0 release includes:

Available for all operating systems; Windows, Linux and MacOS
Performance and stability improvements.
Fixed various bugs from reported tickets.

Lianja SQL Server 4.1

Released 20-Apr-2018

The version 4.1 release includes:

Performance and stability improvements.
Fix reported bugs.

Lianja SQL Server 4.2 Release

Released 20-Jun-2018

The version 4.2 release includes:

Performance and stability improvements.
Fix reported bugs.

Lianja SQL Server 5.0 Release

Released 06-Dec-2019

The version 5.0 release includes:

Updated ODBC driver certified for use with Excel 365, Crystal Reports 2016 and Power BI.
User authentication (ODBC login) now honors row level security and dynamic data masks associated with user roles.
Performance and stability improvements.
Fix reported bugs.

Lianja SQL Server 5.1 Release

Released 12-Dec-2019

The version 5.1 release includes.

Performance and stability improvements.
Fix reported bugs.

Lianja SQL Server 5.2 Release

Released 14-Jan-2020

The version 5.2 release includes.

Performance and stability improvements.
Fix reported bugs.

Lianja SQL Server 5.3 Release

Released 01-Jul-2020

The version 5.3 release includes:

Performance and stability improvements.
Fix reported bugs.

Lianja SQL Server 5.3.1 Release

Released 17-Jul-2020

The version 5.3.1 release includes:

Performance and stability improvements.
Fix reported bugs.

Lianja SQL Server 5.3.2 Release

Released 19-Aug-2020

The version 5.3.2 release includes:

Performance and stability improvements.
Fix reported bugs.

Lianja SQL Server 5.4 Release

Released 08-Oct-2020

The version 5.4 release includes:

Performance and stability improvements.
Fix reported bugs.

Lianja SQL Server 5.5.1 Release

Released 16-Nov-2020

The version 5.5.1 release includes:

Performance and stability improvements.
Fix reported bugs.

Lianja SQL Server 6.0 Release

Expected release March 2021

The version 6.0 release will include:

Performance and stability improvements.
Fix reported bugs.

Lianja SQL Server 7.0 Release

Expected release 2021

The version 7.0 release will include:

Available as a docker image.
Native Windows x64 build.
Fix reported bugs.

Lianja Cloud Server 1.0 Release

Released 3-Feb-2014

The version 1.0 release includes.

The Lianja Web Client. This is a pure HTML5 and JavaScript RIA client for desktop and tablet browsers. Developers build and test apps using the Lianja App Builder on the desktop and "publish" the apps into the Lianja Cloud Server for deployment.
The Lianja Web/mobile client is built on top of the LianjaWebFramework which uses industry standard HTML5 and Javascript incorporating JQuery, JQuery Mobile, Twitter Bootstrap, knockout.js, underscore.js and other best-in-breed open source technologies which we integrated together.
This has the Lianja SQL Server built-in also. Data can be accessed using the Lianja ODBC Driver or an OData compliant RESTful API from third-party remote clients.
Auto detection of client device to provide a rich desktop or mobile tablet browser experience.
Read the Introduction to Lianja Cloud Server for product details.
Automatic HTML5 JavaScript code generation from the App Builder for an App.
Fully responsive UI that automatically adjusts based on the viewport size or orientation (switching from landscape to portrait on a tablet or resizing/maximizing the browser window).
Lianja/VFP server pages (.rsp files). Write custom server pages that generate dynamic content in Lianja/VFP.
JavaScript server pages (.jssp files). Write custom server pages that generate dynamic content in JavaScript.
Automatic parent-child-grandchild section relationships reduces the complexity of building database Web and Mobile Apps.
Local cursor data access in the Web Client from JavaScript code.
Many data bound standard sections and gadgets are included as detailed below providing massive productivity gains over competing products.
Form sections with editing.
Grid sections with editing. Grid sections have built-in pagination for working with large data sets.
Attachment sections with editing. Attachment sections support drag and drop uploading of documents.
WebView sections with optional HTML editing.
ImageStrip sections with editing. ImageStrip sections support drag and drop uploading/editing of images.
Navigation panel. Provides instantaneous switching between related Data Views.
Pages menu.
Data navigation.
Instant search.
Instant selections.
Lianja system object.
Cross-iframe Lianja system object referencing.
Dynamic Google Maps and Charts.
TabView sections.
Report sections.
Chart sections.
Image gadgets with drag and drop uploading of images/photos.
WebView gadgets.
Chart gadgets.
CatalogView sections.
Macro substitution via local cursors.
Refresh section headers with macros.
Refresh section footers with macros.
Automatic check for field update conflicts using optimistic locking at the field level.
Display attachments (e.g. PDF report files) in a new tab when a hyperlink is clicked.
Lianja.evaluate(expr, function(result) {} ) which provides async server side function/procedure calls (or other expression) from the Web/Mobile client.
Async server-side field validation.
Field input masks.
Complete {...} server side macro substitution when cannot be fulfilled via local cursors using Lianja.evaluate().
Grid column input masks.
Async server side grid column validation.
Collapsible left sidebar with "Favorites", "Recently viewed", "Recently modified", "Instant Selections"
Collapsible right sidebar with server side .rsp page gadget content.
Added a new "Settings" attribute to Apps that allow "Enable running external from App Center". This enables Lianja Apps to be embedded in existing websites or as facebook apps or embedded in other app containers.

Lianja Cloud Server 1.1

Released 15-Apr-2014

The version 1.1 release includes.

Fixed various IE11 rendering issues.
Phonegap is now included in the Tablet and Phone HTML5 JavaScript App that is generated by the Lianja App Builder. The actual cordova.js file that is loaded into the App is determined when the App loads. This is required as there is a different cordova.js file for each mobile device. We currently handle iOS, Android and Windows Phone 8. Others will be added later if required.
Load custom JavaScript libraries into the client when HTML5 JavaScript code is generated.
Section header menus with JavaScript delegates.
Section footer menus with JavaScript delegates.
Fixed an issue where custom Lianja/VFP (.rsp pages) and custom JavaScript (.jssp pages) server pages were not being correctly referenced in the HTML5 JavaScript App that is generated for WebView sections.
TabView sections now honor the "Hide TabBar at runtime" attribute so the sections in the Tab Panels can be shown programmatically using Lianja.showDocument("page.section?action=select&text=CaptionText. You can use this in conjunction with the section header menus to navigate between the Tab Panels programmatically.
Implemented Lianja.showNotification( message ) in the Lianja HTML5 Client.
Implemented Lianja.showMessage( message) in the Lianja HTML5 Client.
Implemented "Search Panels" in the Web/Mobile clients.
Tidied up a few cosmetic layout issues.
The Lianja APaaS Developer edition license now allows remote Lianja Cloud Server connections (up to 10 connections) so that Web, Tablet and Phone Apps can be tested properly. In v1.0 the APaaS Developer license restricted Lianja Cloud Server connections to local connections only.
Added support for Section and Formitem refresh interval timers.
Handle custom JavaScript delegates for the core UI events in app, pages, sections and formitems;

init, load, ready, change, interactiveChange, dataChanged, gotfocus, lostfocus, refresh, activate, deactivate, click, timer, and mouse events

Others will be added soon.
The following Lianja/VFP functions are now included in the Lianja HTML5 Client API in JavaScript;

substr(), iif(), messageBox(), str_replace(), trim(), alltrim(), ltrim(), rtrim(), at(), upper(), lower(), proper(), str(), val(), addslashes(), recno(alias), reccount(alias), rowcount(alias), len(), require("library.js"), require_once("library.js"), left(), right(), loadlibrary("library.js"), createObject(), startsWith(), endsWith(), indexOf(), rpad(), padr(), lpad(), padl(), inlist(), icase()

Others to be added soon. Note that as in Lianja/VFP string indexes are all 1 based as opposed to JavaScript which is 0 based.
The HTML5 Web/Mobile client now handles inline delegates.
The following Lianja System Object methods are now enabled in the Lianja HTML5 Client API from JavaScript.

Lianja.showDocument()
Lianja.getElementByID()
Lianja.createObject()
Technology preview. JavaScript Canvas sections with LianjaWebFramework JavaScript classes (VFP 9 core UI classes using Lianja.createObject() and object.addObject()). This does not yet include composite components such as Grid, Tree and PageFrame. The core UI classes and their delegates are now implemented in Canvas sections.
Technology preview. Javascript Custom sections with LianjaWebFramework JavaScript classes (VFP 9 core UI classes using Lianja.createObject() and object.addObject()). This does not yet include composite components such as Grid, Tree and PageFrame. The core classes and their delegates are now implemented in Custom sections.
Technology preview. JavaScript Canvas gadgets with LianjaWebFramework JavaScript classes (VFP 9 core UI classes using Lianja.createObject() and object.addObject()).
Fixed various bugs from reported tickets.

Version 1.1.1 Released 17-Apr-2014

Fixed various bugs from reported tickets.

Version 1.1.2 Released 25-Apr-2014

Fixed various bugs from reported tickets.

Version 1.1.3 Released 04-Jun-2014

Fixed various bugs from reported tickets.

Version 1.1.4 Released 16-Jun-2014

Login authentication.
App Center integration.
Fixed various bugs from reported tickets.

Version 1.1.5 Released 18-Jun-2014

Support for static choicelists.
Fixed an IE11 rendering issue.
Added support for "Section footer menus" to support Buttons. e.g. #Save,Cancel will center the two buttons in the section footer. You can specify an icon and text for each button using this notation; app:/image.png@Text
Fixed a buffer overflow issue on very long HTTP GET requests.
Fixed various bugs from reported tickets.

Version 1.1.6 Released 02-Jul-2014

Fixed an issue with custom HTTP POST requests not correctly setting up the _request[], _post[] and _args[] associative arrays.
Made a few performance improvements to make the server even faster than it already is.
Added a new "Presentation rule" attribute for sections and fields/gadgets. "Display orientation" which can be set to "Always" (Default), "Portrait" or "Landscape". On a tablet or phone as the device orientation changes then UI elements can be hidden or shown to provide a more responsive UI.
Handle page transitions based on a new page attribute in the HTML5 Web/Mobile Client (Fade, Pop, Flip, Turn, Flow, SlideFade, Slide, SlideUp, SlideDown, None (default) ).
Handle gesture delegates in the HTML5 Web/Mobile Clients for touch enabled devices (SwipeLeft, SwipeRight, SwipeUp, SwipeDown, Pan, Pinch, Tap, TapAndHold). These can now be specified for pages and sections.
Enhanced OData to provide native SQL commands. e.g. "http://localhost/odata/southwind?$sql=select * from customers". The data will be returned as Lianja OData JSON data.
Support for dynamic choicelists.
Added support for "Custom Actions" in pages. These can be optionally specified in the page attributes. This enables you to call app specific business procedures that handle all page actions (Add, Delete, Refresh, First, Previous, Next, Last, Save, Cancel) when you navigate data and you want to handle these actions programmatically.
Pages and sections now have a new method getJSON() that you can call to obtain the current page (or section) data as JSON and then call a server side business procedure using Lianja.evaluate() or JQuery AJAX POST to handle the processing.
Handle calculated fields in forms and grids.
Added Lianja/VFP date functions into the LianjaWebFramework.
Fixed an issue that was causing custom JavaScript sections not to be rendered correctly.
Added a new attribute on TabView sections "Swipe navigation" which switches between tab panels (swipe left and right) on touch enabled devices such as tablets, phones and touch screen laptops. Best used in conjunction with "Hide TabBar at runtime". This is only active in runtime mode in the desktop client.
Added a new attribute on Pages "Swipe navigation" which switches between pages (swipe left and right) on touch enabled devices such as tablets, phones and touch screen laptops. This is only active in runtime mode in the desktop client.
Added a new App attribute "Disable right click" which disables the context menu in Web Apps.
Added a new App attribute "Disable inline editing" which disables inline editing of fields in form sections. This is particularly useful when using swipe left and right gestures to perform page or Tab panel navigation.
Added a new App attribute "Mini navigation panel" which always renders the navigation panel on pages only using the icon with no caption to make better use of display real estate.
Fixed various bugs from reported tickets.

Lianja Cloud Server 1.2 Release

Released 11-Aug-2014

Handle default fields in forms and grids.
JavaScript minification of the LianjaWebFramework when the "Build mode" attribute in the App Settings "Release" is selected.
Fixed an issue when adding records in a page that had only one form section and no search key field was specified.
Extended Lianja.openApp() so that it can be used from within delegates of an existing App to load a new one to take its place.
Setting a Grid section "Readonly" now correctly displays the grid with no actionbar and no ability to add/delete/update any of its cells.
Now supports macro substitution up to three levels deep using {expression}, {{expression}} and {{{expression}}} which can nested. Macros are evaluated inside out from left to right starting with {{{...}}} followed by {{...}} then finally {...}.
Added the json_encode(object) and json_decode(jsonstring) functions into the LianjaWebFramework so that the same functions can be used in Desktop Apps and Web/Mobile Apps.
Fixed an issue which was causing the footer menu delegates not be be called correctly.
Fixed a few minor layout issues relating to sections that have a search panel and a footer menu.
Fixed an issue displaying grids that have only one column.
Fixed a performance issue on mobile devices when testing against a numeric IP address that has no reverse name lookup setup. This was causing a delay on ChromeBooks, Tablets and Phones.
Added support for CheckListView gadgets In the Web and Mobile clients.
The following Lianja/VFP functions are now included in the Lianja HTML5 Client API in JavaScript; date(), dtos(), dtoc(), ctod(), day(), month(), year(), cmonth(), cdow(), dow(), time(), implode(), explode(), empty(), etos(), strlen(), between(), indexof(), tostring(), replicate(), in_array(), function_exists(), is_function(), is_string(), is_float(), is_int(), is_numeric(), is_logical(), is_date(), is_object(), is_array()
Added support for HTTP gzip compression into the Lianja Cloud Server to better utilize available bandwidth.
Overall performance improvements.
Page header captions can now contain {...} macros which are refreshed as you navigate between records.
Removed the example Apps from the installer.
After installation port 80 is now disabled by default. Use the default port 8001 to access your Web, Tablet and Mobile Apps. To enable port 80 on Windows use the "Lianja Server Manager" in the control panel. On Linux, edit the file /etc/lianja.d/lianja.conf and set DB_PORT80_ENABLED="true".
Fixed various reported tickets.

Version 1.2.1 Released 01-Sep-2014

Support Calendar sections in the Web Client.
The Cloud Server now handles caching of compiled .rsp pages and also enables the caching of the LianjaWebFramework JavaScript libraries and other assets (images etc). This is off by default in development mode. When you install a Cloud Server on another machine (other than your development machine) you can "Enable caching" in the "Server Manager" on windows. On Linux if you set the environment variable DB_CACHE_ENABLED=ON and DB_RSOCACHE_ENABLED=ON the server will check for updated .rsp files and automatically compile them if the corresponding .rso file does not exist or is out of date.
Significant performance improvements overall.
Fix various reported tickets.

Version 1.2.2 Released 09-Sep-2014

Added support for plain text EditBox gadgets in form sections.
Fixed an issue editing memos that was causing a random crash.
Hyperlink delegates are now supported in Form section fields and grid section columns.
Fixed an IE11 rendering issue on Windows 8.x that appeared with a recent Windows update.
Fixed a few minor UI rendering issues with "Stretch last section" when the last section was a "TabView".
Fixed an issue which caused related sections contained with TabViews not to refresh correctly when the parent sections were navigated.
Further performance optimizations in the Web Client and the Cloud Server.
Fixed various tickets.

Version 1.2.3 Released 10-Sep-2014

Minor bug fixes.

Version 1.2.4 Released 27-Oct-2014

Fixed an issue selecting a "TabView" panel programmatically with Lianja.showDocument("page:page1.section1?action=select&text=caption").
Added the Lianja ISAPI Extension for Windows/IIS integration.
Fixed a few cosmetic UI issues.
Performance improvements.
Fixed a tile rendering issue in Firefox.
Fixed a UI rendering issue with the "Image" and "Attachment" upload dialog.
Added the "Page Center" which provides two level menu support for Applications. The general flow of the UI for a user can now be configured as:

1. Login
2. App Center to display the Apps
3. Page Center to display the Pages for a selected App
4. Pages. Clicking the "Pages Menu" icon switches back to the "Page Center". Clicking the "Home" icon switches back to the App Center.

This provides a consistent interface for navigating around Apps and Pages.
Added the ability to dynamically sort the data displayed in a grid by clicking on the grid column headers. This is implemented in both desktop and web clients. There is a new grid section attribute "Sortable" which you can check to enable this on a grid.
Fixed an issue with "Upper case" input masks.
Now supports locale specific popup date picker.
The icon specified for an App tile is now deployed automatically and displayed in an App Center tile in both desktop and Web. Note that the optimum size for an App tile icon is 96x96.
SQL Optimizer improvements resulting is better OData performance. The Web/Mobile Clients use OData extensively so you will experience much faster response times as you navigate data in your Web/Mobile Apps.
Cascading deletes are now implemented in the Web/Mobile client.
Fields in Canvas sections now correctly handle the "Password" attribute.
Canvas sections are now generated honoring the specified "Tab Order" of the fields.
Static and Dynamic (SQL SELECT) choicelists are now implemented in "Form", "Canvas" and "Custom" sections.
Canvas and Custom sections can now contain "ComboBoxes".
Improved "EditBox" which now honors the "Editable" attribute and is integrated into Form sections much better.
Fixed various tickets.

Lianja Cloud Server 1.3 Release

Released 04-Feb-2015

Data source independent data access to Lianja SQL Server, MSSQL, PostgreSQL, Oracle and MySQL using Lianja Virtual Tables.
Support ODBC data access in the Cloud Server.
Support "CursorAdaptor" in the Cloud Server.
COM/ActiveX support in the Cloud Server on Windows.
Support "NetworkRequest" in the Cloud Server.
All ODBC sqlXXX() functions now supported in the Cloud Server
Virtual Table ODBC connection pooling
Web / Mobile Clients now handle popup DateTime picker
Web / Mobile Clients now work with Virtual Tables with full CRUD and Instant Search
LIST HTML. The HTML keyword causes the data to be output as an html table with bootstrap classes. These will be ignored if you have not included bootstrap in your .rsp file. This saves a lot of coding when you want to display a nice looking styled table in a WebView. The optional clause ONCLICK "columnname", "javascriptfunction('{}')" can also be specified to generate a hyperlink for "columnname" that calls the specified javascriptfunction when it is clicked. The {} is substituted with the value if the "columnname". This can be used to link across to other pages and search for data. The example_tablelist App included in the distro shows how to use this.
Added Lianja.showDialog() with the ability to embed a .rsp/.jssp/.html/.php/.aspx page or a JavaScript component created using the Lianja UI Framework into the Dialog that pops up on top of the page being displayed. These are custom Dialogs that you create in JavaScript. They can be used to display a custom query dialog or information relevant to your app e.g. popup a google map. The JavaScript function should create a container then return it. This will then be embedded into the Dialog. Hint: use createObject("classname") and addObject("varname", "classname") just as you would in a desktop App.

function page1_myDialog(){ var cont = createObject("myContainer", "container"); cont.backcolor = "white"; cont.addObject("myTextBox", "textbox"); return cont; }; Lianja.showDialog("Select a customer", "page1_myDialog()", 500, 240); // alternatively displaying some custom dynamically generated content Lianja.showDialog("Customer Details", "getCustomerDetails.rsp?customer={customer.customerid}", 500, 400);
Lianja.showDialogPanel() with the ability to embed a .rsp/.jssp/.html/.php/.aspx page or a JavaScript component created using the Lianja UI Framework into the Panel that slides in from the right hand side of the page being displayed. These are custom Dialog Panels that you create in JavaScript. They can be used to display custom query panels or information relevant to your App. The JavaScript function should create a container then return it.

function page1_myDialogPanel(){ var cont = createObject("myContainer", "container"); cont.backcolor = "lightgray"; cont.addObject("myLabel", "label"); myLabel.text = "Customer name"; return cont; }; Lianja.showDialogPanel("Select a customer", "page1_myDialogPanel()", 400); // alternatively displaying some custom dynamically generated content Lianja.showDialogPanel("Customer Details", "getCustomerDetails.rsp?customer={customer.customerid}", 400);
Optimized some HTML5 rendering to make it more snappy navigating through data in pages with unrelated sections.
Enhanced the Cloud Server to handle Content-Type of "application/json" and "application/xml" POST requests. The _server["body"] variable contains the posted body of the request. This is primarily used when writing web services as .rsp or .jssp pages.
The "Click" and "Dblclick" events are now working in "ImageStrip" sections. You can double click on an image to slide in a DialogPanel with information pertaining to the image e.g. Employee imformation.
Enabled the "Runtime Database" App setting in a Web/Mobile application. If this is specified in the App Settings then it will be used as the "Runtime database". This provides the ability to develop against a development database and deploy against a runtime database. See details below concerning database tenancies.
Enabled database tenancies based on the authenticated user. The "Database" used by an App for a user in a specified tenancy is postfixed with an "_" followed by the tenancy (domain) for the user specified in the "Users" workspace. For example, if the database for an App is southwind and the user has a tenacy (domain) specified of xyzco then the database used for that user will be southwind_xyzco. When the user authenticates in Desktop, Web or Mobile apps the specified database will be used rather than the default database for the App. Remember to "Deploy" the system!sysroles table and the database for that tenancy from the "Deploy" workspace. Note that if the tenancy name contains '.' or '@' characters these are replaced with '_' characters e.g. lianja.com using the southwind database would expect the database southwind_lianja_com to exist. You can "copy" a complete database to another using the COPY DATABASE command in the console or the "Copy" menu selection in the "Data" workspace.
Added "lib:/showdialog_map.rsp?adddress=" to the library as a standard script for looking up an address and displaying in a google map.
Roles and permissions for displaying App tiles in the App Center in Web / Mobile Apps has now been implemented. An authenticated user who does not have the "read" role for an App causes the tile not to be displayed in the App Center". This is a pre-cursor to enabling all CRUD roles and permissions which is scheduled for v1.4.
New "Org Chart" section type that displays an organization chart graphically.
Custom JavaScript sections and containers used to programmatically layout Lianja.showDialog() and Lianja.showDialogPanel() now handle "Horizontal" and "Vertical" container layouts.
Clicking or touching on section headers now animates the section being selected into view. This can be disabled in the App Settings if desired.
Fixed various reported tickets
** Not yet implemented in the Web Client (currently under development will be released as a point release later) **
- Editable WebViews bound to SQL columns in Virtual Tables
- EditBoxes bound to SQL columns in Virtual Tables
- Instant Selections using contains() which is SQL dialect dependent

Lianja Cloud Server 1.4 Release

Released 17-Mar-2015

Search panels can now be used in Canvas sections.
New "Query Page" page attribute works in Web/Mobile Apps as well as Desktop Apps.
Added Lianja.showDocument("back:") and Lianja.showDocument("forward:") in desktop/web/mobile to navigate between pages in the history.
Added new "TreeView" section.
Enhanced the Page "Navigation Panel" so that it can render a tree if you specify the "Data source" as lib:/treeview.rsp. See the example_jqueryui sample App to see how this is achieved.
Added several new example Apps.
Minor UI improvements.
WebView sections now support printing to local printers. The section returned from Lianja.getElementByID() now has print(), expand() and collapse() implemented.
Some firefox rendering issues resolved.
Performance and stability improvements.
Fixed various bugs from reported tickets.

Version 1.4.1 Released 20-Mar-2015

Performance and stability improvements.
Fixed various bugs from reported tickets.

Lianja Cloud Server 1.5 Release

Released 7-Apr-2015

The Web/Mobile client now honors hiding of the page header. This provides the ability to have a custom page that has no page header or page navigation action bar. It makes it much simpler to build modern desktop/mobile web sites in Lianja that are all data bound.
Now supports the CarouselView section.
Now supports the PanelView section.
Now supports the enhancements to the CatalogView section (pagination etc).
Now supports a custom navigation panel that can be dynamically generated. Just specify a .rsp or a .jssp page in the "Navigation panel" "Data source" attribute in the page attributes.
Now supports a custom section menu panel that can be dynmically generated by a custom .rsp or .jssp page. Set the "Custom menu panel" to the name of a .rsp or .jssp page in section attributes "Menu" panel. This provides the ability to use modern bootstrap or jQuery mobile dropdown menus in all types of Apps; Desktop, Web and Mobile.
Fixed a memory leak in the http server.
HTTP connections are automatically closed if they are inactive for 5 minutes.
Performance and stability improvements.
Fixed various bugs from reported tickets.

Lianja Cloud Server 2.0 Release

Released 29-Oct-2015

New responsive UI Mobile CalendarView section.
New responsive UI Mobile GridView section.
New "CommentsView" section (similar to facebook commenting) that can be related to a parent section. (useful for CRM-like collaboration on records displayed in a DataView).
New "DocumentView" section. Display PDF files without any plugins required.
New animated "GalleryView" section.
New Mobile-ready CarouselView section
New Mobile-ready CatalogView section
New Mobile-ready GalleryView section
Fixed touch issues in the App Center and Page Center.
Added support for the Inactive delegate in the Web/Mobile client. Use this to logout inactive users automatically.
Includes LianjaCloudDataServices.js, a small JavaScript library that provides Authentication services, CRUD ODATA data services and remote procedure call services to the Lianja Cloud Server. You can use this with third party development tools and frameworks to work with the Cloud Server.
New LianjaWebFramework function called Lianja.evaluateJavaScript() for calling server-side JavaScript code. Note that the Google V8 JavaScript engine is embedded into the Lianja Cloud Server so this is the same JavaScript engine that is used in node.js. This provides you with the ability to write end-to-end JavaScript code on the client and server and generate dynamic pages with .jssp pages also.

// Server: The file myfunction.js should be in the app or library directory and contain a function with the same
// name as the file.

function myfunction(arg)
{
// do something useful...
return arg;
};

// Client: Call a server-side JavaScript function called myfunction from a client delegate

var result = Lianja.evaluateJavaScript("myfunction('hello world')");

Note that if the file myfunction.js file does not exist in the app or library directory and the file server_functions.js exists then the function myfunction is assumed to be defined in the server_functions.js file.

The Lianja.evaluate() method in the Web/Mobile client now handles the ability to call business procedures that are contained within custom libraries on the server. To call a procedure in a library prefix the procedure name with the library name followed by :: e.g.

var result = Lianja.evaluate("mylib::myproc()");
In Web and Mobile Apps you can now call server-side functions written in Lianja/VFP or JavaScript directly from the Web client JavaScript code. See this article on the forums for details.
Fixed an issue where the CSS on a canvas field was not being included in the Web/Mobile App if the CSS was being read from a file rather than just an inline CSS declaration.
Added some new methods to the Lianja system object in the LianjaWebFrameWork. Some of these provide an abstraction above PhoneGap and will only function when run on a mobile device.
Lianja.getPicture( onSuccess, onError, cameraOptions )
Lianja.beep( )
Lianja.vibrate( nSeconds )
Lianja.getConnection( )
Lianja.getCurrentPosition( onSuccess, onError )
Lianja.getCurrentAcceleration( onSuccess, onError )

Note that orientation changes are automatically detected and the "orientation_changed" delegate is called.

Additionally, in the presentation rules for sections, gadgets and fields you can specify whether these should be visible based on the orientation of "Portrait", "Landscape" or "Both". So, an automatic relayout of the UI will be performed as you change the orientation of a phone or tablet.
Added some new functions to Lianja/VFP which can be used in .rsp pages and/or server-side procedures called from a mobile device.
isPhoneGap()
phoneGapDevice() // returns phone,tablet or an empty string
phoneGapPlatform() // returns android,ios,winphone or an empty string
phoneGapVersion() // returns the version of phonegap the app was built against
The following new Lianja system object methods render as platform specific native UI when called on mobile devices.
Lianja.messageBox()
Lianja.alert( )
Lianja.confirm( )
Lianja.inputBox( )
The following new methods on the Lianja system object can be called to determine if your App is running on a mobile device.
isPhoneGap()
phoneGapDevice() // returns phone,tablet or an empty string
phoneGapPlatform() // returns android,ios,winphone or an empty string
phoneGapVersion() // returns the version of phonegap the app was built against

if (!Lianja.isPhoneGap())
{
// not running on a mobile device so just return
console.log("This function only operates on a mobile device");
return;
}

if (Lianja.phoneGapDevice() === "phone")
{
// phone specific code
}
else if (Lianja.phoneGapDevice() === "tablet")
{
// tablet specific code
}
Touching an editable image gadget now displays the photo gallery (or camera) on mobile devices where the user can choose an existing photo or take a new photo with the camera. This new photo is automatically uploaded and replaces the one in the database column on the server. This is all handled by data binding with no coding being required.
The following sections are now working on mobile devices in the same way as they work in Web Apps and can now be used in PhoneGap Apps.
form section
grid section
pagecenter section
webview section
custom section
canvas section
tabview section
catalogview section
attachments section
panelview section
carouselview section
commentsview section
galleryview section
calendarview section
report section
chart sections
orgchart section
imagestrip section
Many improvements and optimizations to page/section layouts to provide a better appearance on mobile devices.
SET DEBUGOUT ON and DEBUGOUT commands can now be used in .rsp pages to assist in debugging. If an error occurrs and SET DEBUGOUT is ON then error details are written to a file in the lianja\debug directory. This file is called firecat_debugXXX.txt where XXX is the unique connection id as many requests can occur concurrently.
Added Lianja.evaluateJavaScript() to the LianjaWebFramework.
Performance and stability improvements.
Fix reported bugs.

Version 2.0.1 Released 4-Nov-2015

Performance and stability improvements.
Fixed various reported tickets.

Lianja Cloud Server 3.0 Release

Released 12-Aug-2016

The version 3.0 release includes:

Handle full user roles and permissions in the Web and Mobile clients.
Many framework improvements.
Web and Mobile App layout improvements.
Performance and stability improvements.
Fix reported bugs.

Lianja Cloud Server 3.1 Release

Released 14-Oct-2016

The version 3.1 release includes:

Improved handling of numeric and currency input masks.
Fom fields and grid columns are displayed according to the input mask if one is specified.
Currency character, separator and decimal point characters can now be specified in the App settings so that localized currency fields can be correctly displayed.
The Lianja/VFP transform() and currency() functions is now available in the LianjaWebFramework.
Performance and stability improvements.
Fix reported bugs.

Lianja Cloud Server 3.2 Release

Released 02-Feb-2017

Performance and stability improvements.
Fixed various bugs from reported tickets.

Lianja Cloud Server 3.3 Release

Released 15-Feb-2017

OData enhancements including user authentication, APIKEY authentication and support for calling stored database procedures.
Dynamic page requests (rsp, jssp) can now optionally be restricted by user authentication or APIKEY authentication.
Security improvements.
Performance and stability improvements.
Fixed various bugs from reported tickets.

Lianja Cloud Server 3.4 Release

Released 26-Apr-2017

Added $rowfilter=odata_expression as an additional odata argument. Specifying a $rowfilter causes filtering out of records in the cloud server no matter where the data was retrieved from. This provides the ability to use Lianja/VFP expressions to filter out records after they have been retrieved from a remote database server e.g. MSSQL or MySQL.
Performance and stability improvements.
Fixed various bugs from reported tickets.

Lianja Cloud Server 4.0 Release

Released 30-Aug-2017

The version 4.0 release includes:

Available for all operating sytems; Windows, Linux and MacOS
Provide the Apache plugin mod_lianja for Linux. The IIS extension is already shipping since v1.2.4 for Windows.
The section getJSON() and setJSON(data) methods are now available in the Web/Mobile clients for "form", "canvas" and "grid" sections.
Fixed a few issues with input masks.
When setting up users and their roles and permissions, you can now specify an expiry date for the user. When a user logs in or when an http request is made a check is made for expired users and the login or request is rejected. This provides improved support for subscription based users in a SaaS environment.
Performance and stability improvements.
Fixed various bugs from reported tickets.

Lianja Cloud Server 4.1 Release

Released 20-Apr-2018

The version 4.1 release includes:

Support custom form in Web/Mobile using createObject(“form”)
Support custom grid in Web/Mobile using createObject("grid")
Support custom webview in Web/Mobile using createObject("webview")
Support custom "timer" class in Web/Mobile using createObject("timer").
Custom pageframe/page (tabs) in Web/Mobile using createObject("pageframe") / createObject("page")
Support custom "chart" class in Web/Mobile using createObject("chart").
Support custom listbox in Web/Mobile using createObject("listbox")
Added better support for downloadable font files. In order to display fonts right a browser must receive font files with correct http headers. If the server does not set required headers some browsers can report errors in console or completely fail to display fonts.
Performance and stability improvements.
Fixed various bugs from reported tickets.

Lianja Cloud Server 4.2 Release

Released 20-Jun-2018

The version 4.2 release includes:

Lianja packages (.lpk files) deployed to the Lianja Cloud Server "packages" directory from the App Builder are autoinstalled/autoupdated without the need for any downtime.
Performance and stability improvements.
Fixed various bugs from reported tickets.

Lianja Cloud Server 5.0 Release

Released 06-Dec-2019

The version 5.0 release includes:

The Cloud Server can now be configured to use a custom login page and a custom appcenter page. Set the following environment variables to customize these.

DB_TENANCY_LOGIN_PAGE e.g. /mylogin.rsp
DB_TENANCY_LOGIN_RECAPTCHA_PAGE e.g. /myloginrecaptcha.rsp
DB_TENANCY_APPCENTER_PAGE e.g. /myappcenter.rsp
Python 3 server side scripting. You can now generate dynamic HTML content in Lianja/VFP (.rsp files), JavaScript (.jssp files) and Python (.pysp files).
New LianjaWebFramework functions for calling server-side Python functions from Web/Mobile clients using Lianja.evaluatePython() and also provide support for server side python functions using exports.conf.
The IIS handler on Windows is now multi threaded and supports persistent connection pooling.
Performance and stability improvements.
Fix reported bugs.

Lianja Cloud Server 5.1 Release

Released 12-Dec-2019

The version 5.1 release includes.

Ability to group Apps together into Tabbed groups in the App Center.
Support for tiles with dynamically generated badges.
Performance and stability improvements.
Fix reported bugs.

Lianja Cloud Server 5.2 Release

Released 14-Jan-2020

The version 5.2 release includes.

Performance and stability improvements.
Fixed various reported tickets.

Lianja Cloud Server 5.3 Release

Released 01-Jul-2020

The version 5.3 release includes:

Performance and stability improvements.
Fixed various reported tickets.

Lianja Cloud Server 5.3.1 Release

Released 17-Jul-2020

The version 5.3.1 release includes:

Performance and stability improvements.
Fixed various reported tickets.

Lianja Cloud Server 5.3.2 Release

Released 19-Aug-2020

The version 5.3.2 release includes:

Performance and stability improvements.
Fixed various reported tickets.

Lianja Cloud Server 5.4 Release

Released 08-Oct-2020

The version 5.4 release includes:

The Cloud server now handles Progressive Web Apps.
The Cloud Server App Center can now be installed as an icon on desktop and mobile home screens.
The login page now provides the ability to:
- Change your password
- Forgot your password?
- Forgot your username?
Performance and stability improvements.
Fixed various reported tickets.

Lianja Cloud Server 5.5.1 Release

Released 16-Nov-2020

The version 5.5.1 release includes:

Performance and stability improvements.
Fix various reported tickets.

Lianja Cloud Server 6.0 Release

Expected release March 2021

The version 6.0 release will include.

Note: the location of the Lianja 64 bit ISAPI extension for IIS has changed. See ISAPI Extension for IIS for full details.
Performance and stability improvements.
Fixed various reported tickets.

Lianja Cloud Server 7.0 Release

Expected release 2021

The version 7.0 release will include.

Available as a docker image.
Performance and stability improvements.
Fixed various reported tickets.

Lianja Cloud Server 8.0 Release

Expected release 2021

The version 8.0 release will include.

Handle UI states in the Web and Mobile clients.
Handle dynamic roles and permissions just like the desktop version already does.
Synchronization of data from offline to online (Lianja Cloud Server) mode in Lianja Mobile Apps.
Native SSL support (https://) without having to use IIS or Apache.
Native windows x64 build.
Performance and stability improvements.
Fixed various reported tickets.

Lianja Cloud Server 9.0 Release

Expected release date 2021

The version 9.0 release will include.

Cross platform .NET Core integation.
Performance and stability improvements.
Fix reported bugs.

Lianja Cloud 1.0 Release

Expected release Q1 2021

The version 1.0 release will include.

Lianja Cloud is a no compromise solution that takes the pain out of cloud adoption and lets you concentrate on your business Apps.

A multi-tenant solution running on AWS.
Subscribe online at www.lianjacloud.com for your own tenancy.
Pay monthly or annually to save money. View you AWS monthly costs in real time in the Lianja Cloud Admin Console "Billing" panel.
A fully scaleable architecture using best-of-breed Amazon AWS technologies. Load balanced, Containerized, horizontally scaleable, replicated data, automatic backups.
Use Lianja App Builder to DEVELOP, TEST and DEPLOY your custom Apps and Data then easily SHARE these with your team, company or customers in the cloud. Lianja Cloud provides secure, reliable access to your custom Web and Mobile apps developed using Lianja App Builder.
Configure your own custom domain name e.g. apps.yourcompany.com in the Lianja Cloud Admin Console.
Users access your custom web apps through the Lianja App Center after authenticating in your Lianja Cloud tenancy.
Includes the Lianja Cloud Admin Console for administration of users, permissions, row level security and column data masking based on user roles. The Lianja Cloud Admin Console is a web-based UI that allows you to monitor and administer your Lianja Cloud tenancy.
After you create and set up your Lianja Cloud tenancy you can use the Lianja Cloud Admin Console to assign an SSL certificate and perform tenancy monitoring and a variety of administration tasks.
Monitor your Lianja Cloud tenancy in the Lianja Cloud Admin Console "Dashboard" panel. View connected users, disk usage, CPU usage, network I/O and other useful information in the "Dashboard".
Configure automatic and/or manual snapshot backups in the Lianja Cloud Admin Console "Backups" panel. Easily restore from a snapshot backup.
ODBC drivers for Lianja, MySQL, MSSQL and PostgreSQL are pre-installed.
Handles hot updating of Apps, Library and Data schemas while users are active simply by creating a lianja .lpk file in the "Deploy" workspace and upload it to your Lianja Cloud tenancy "packages" folder. The Lianja Cloud tenancy can handle both "automatic" updates and manual updates as specified in the Lianja Cloud Admin Console "Configuration" panel.
Pay as you grow: Available for 5, 10, 25 or 100 concurrent users, or alternatively BYOL (Bring Your Own License). Upgrade at any time in the Lianja Cloud Admin Console "Subscriptions" panel.
Running on Linux x64 instances to minimize costs and optimize performance.
Continuous Deployment of your Lianja Web and Mobile Apps. Integrated with GitHub.