|
LIANJA 4.1 IS NOW AVAILABLE
AVAILABLE FOR ALL OPERATING SYSTEMS: WINDOWS, LINUX AND MACOS
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
Lianja App Builder 3.4 Release
Lianja SQL Server 3.4 Release
Lianja Cloud Server 3.4 Release
Lianja App Builder 4.0 Release
Lianja SQL Server 4.0 Release
Lianja Cloud Server 4.0 Release
Lianja App Builder 4.1 Release (Latest)
Lianja SQL Server 4.1 Release (Latest)
Lianja Cloud Server 4.1 Release (Latest)
Lianja App Builder 4.2 Release
Lianja SQL Server 4.2 Release
Lianja Cloud Server 4.2 Release
Lianja App Builder 5.0 Release
Lianja SQL Server 5.0 Release
Lianja Cloud Server 5.0 Release
Lianja Cloud 1.0 Release
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.
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
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
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:
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.
https://docs.microsoft.com/en-us/sql/t-sql/functions/charindex-transact-sql
- Added the Transact-SQL choose() function.
https://docs.microsoft.com/en-us/sql/t-sql/functions/logical-functions-choose-transact-sql
- 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
Expected release May 2018
The version 4.2 release will include:
- Various 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.
https://www.lianja.com/doc/index.php/Background_Tasks
- New lpk() package manager. See forums for details.
https://www.lianja.com/community/showthread.php?4139-Lianja-4-2-package-manager
- Performance and stability improvements.
- Fix reported bugs.
Lianja App Builder 5.0 Release
Expected release Q3 2018
The version 5.0 release will include:
- New Lianja UI framework class "moverview". This is an implementation of the VFP "mover" classes.
- New section "cascadinglistview". This is an implementation of data bound "Miller Columns". 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 the following link for details:
https://en.wikipedia.org/wiki/Miller_columns
- Lianja Cloud availability.
- Integration with the Lianja Cloud.
- Performance and stability improvements.
- Fix reported bugs.
Lianja App Builder 5.1 Release
Expected release date 2018
The version 5.1 release will include:
- Sections can be laid out horizontally at runtime into a "Horizontal Group" (A new attribute). you specify the id of a section on the page as the Horizontal group. If a section has a Horizontal group specified then all the sections in that group are laid out horizontally alongside the section with the same id as that specified as the Horizontal group. The "Horizontal StretchFactor" of a section determines the layout width of the section in the group. The height of the section is based on the tallest section. This provides the ability to have the whole of a page responsive to resizing and switching orientations on mobile devices. In the existing UI presentation rules you can hide/show sections depending on orientation. With this functionality you can have for example a form/canvas section on the left then a chart and then a grid on the right and these are all related together automatically Based on their parent/child relationships.
- Add support for visually designing pages and sections that are not included in the desktop/web/mobile generated runtime code. These are known as “Custom Component” pages (a new attribute in the page attributes). Their primary purpose is to provide the ability to build custom components visually. (See below).
- Add the ability to save a section as a custom component which can be embedded in a cell of a grid or embedded in a cell of a formgrid section. Custom components are saved into the lib:/components/component directory as code in the scripting language specified for the section. If you want the component to be able to be used in desktop/web and mobile apps then you should specify javascript or typescript as the scripting language. When you save a section as a custom component the code for it will be automatically generated. The name of the component is taken from the custom component library name (in the page attributes) and the section name and should be globally unique. For example, a page with the custom component library name of “com_lianja” and a section id of “orderform” would generate a lib:/components/com_lianja/com_lianja_orderform directory containing (in the case of javascript) a single file named com_lianja_orderform.js which contains a javascript function com_lianja_orderform() which dynamically creates the component when invoked. You should not edit this code as it will be generated automatically every time you save changes to a “Custom Component page”. Note also that whenever a custom component is saved during development and it’s code generated there is a Lianja package automatically generated called (in this case) com_lianja.lpk which contains all its custom components. This is placed in the packages directory. You can then redistribute this package file as a third party component library which can be used by programmers and NoCode developers.
- Performance and stability improvements.
- Fix reported bugs.
Lianja App Builder 5.2 Release
Expected release date 2018
The version 5.2 release will include:
- 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.
- Add a new "Material design theme" to the "Themes" combo in the HeaderBar.
- Custom "tree" class in Web/Mobile.
- Mobile Apps to optionally be generated as "React Native" Apps.
- Performance and stability improvements.
- Fix reported bugs.
Lianja App Builder 5.3 Release
Expected release date 2018
The version 5.3 release will include:
- New "LabelEngine" class for generating and optionally printing mailing labels. The LabelEngine class provides a set of useful properties for laying out mailing labels and how they should be printed.
- New "ReportEngine" class for generating and optionally printing or emailing HTML or PDF reports. The ReportEngine class provides a set of useful properties for describing the layout of pages with headers, footers, groups and other useful graphical assetts such as icons. There will be several template reports such as an Invoice Report and a Master Detail report to simplify report generation. This class will be available in the Lianja Cloud Server also so reports can be generated and either sent to the client for display or emailed as a PDF. The purpose of this class is to provide a simple way to quickly generate business (BI) reports that include not only textual elements but also charts. This ReportEngine will be used by the Lianja Report Builder which is scheduled for the Lianja v6.0 release.
- Performance and stability improvements.
- Fix reported bugs.
Lianja App Builder 6.0 Release
Expected release date 2018
The version 6.0 release will include:
- Includes the Lianja Report Builder. This is a separate executable that will be included with Lianja App Builder. It will be web browser based and will be available from the Lianja Cloud Server so end users can design their own business (BI) reports visually using drag and drop.
- 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 7.0 Release
Expected release date 2018
The version 7.0 release will include:
- WorkFlow Manager. Transition to UI and other application states based on actions associated with the current state and active data.
- Native Windows x64 build.
- Cross platform .NET Core SDK integation
- Add dynamically compiled C#.NET as a supported language cross platform using the Roslyn compiler
- Add dynamically compiled VB.NET as a supported language cross platform using the Roslyn compiler
- 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
Version 1.2.3 Released 10-Sep-2014
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
Expected release May 2018
The version 4.2 release will include:
- Performance and stability improvements.
- Fix reported bugs.
Lianja SQL Server 5.0
Expected release Q3 2018
The version 5.0 release will include.
- Performance and stability improvements.
- Fix reported bugs.
Lianja SQL Server 6.0 Release (codename JackalDB)
Expected release TBA
This will be a major upgrade to Lianja SQL Server offering MSSQL SQL and T-SQL syntax compatibility as well as incorporating the unrivalled JSON/JQL CRUD capabilities of the existing Lianja SQL Server engine.
The version 6.0 release will include:
- Native Windows x64 build. (Linux is x64 already)
- MSSQL SQL compatibility.
- MSSQL T-SQL compatibility.
- Optional Memory Resident databases for transient real-time data.
- Small footprint suitable for IoT device installations.
- High Availability and Fault Tolerant with automatic failover and fallback.
- Performance and stability improvements.
- Load balanced server instances.
- Synchronous and Asynchronous replication (configurable) across local instances and cloud instances.
- Lianja Admin Studio with Database Compare and Upgrade Tools.
- Web based and mobile App performance monitoring dashboard.
- 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 it's 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
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
Expected release May 2018
The version 4.2 release will include:
- 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
Expected release Q3 2018
The version 5.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.
- Enable full "tenancies" of Apps, Library and Data. Database tenancies are already implemented in v1.3. This provides the ability to host multiple customers on the same Lianja Cloud Server which can be load balanced if required.
- Fix reported bugs.
Lianja Cloud Server 5.1 Release
Expected release 2018
The version 5.1 release will include.
- 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.
- Performance and stability improvements.
- Fixed various reported tickets.
Lianja Cloud Server 6.0 Release
Expected release date Q1 2018
The version 6.0 release will include.
- Native Windows x64 build. (Linux is x64 already)
- PHP server side scripting integration in the Cloud Server.
- Python server side scripting integration in the Cloud Server.
- New LianjaWebFramework functions for calling server-side PHP/Python functions; Lianja.evaluatePHP(), Lianja.evaluatePython().
- Lianja Admin Studio with Database Compare and Upgrade Tools.
- Web based performance monitoring dashboard.
- Fix reported bugs.
Lianja Cloud 1.0 Release
Expected release date Q2 2018
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.
- Includes a free Lianja Cloud Admin App for iOS and Android which can be downloaded from the relevant App Store.
- 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 "updates" 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 Amazon CodeCommit, CodeDeploy and CodePipeline.
|
