Product Updates

A new hotfix has been made to improve the performance in some situations when starting an end product against the Software Factory 2019.1. Technical: adjustments were made in the stored procedure get_gui_tab_variant_col.

Hello everyone, we have a new Universal Development Update for you! This past time we've been working on showing you if Universal is saving or cancelling, added the combo control, added executing tasks that have no (visible) parameters and improvement lots of styling. As always we made a demo for you: try it here. We'll keep you updated regularly about Universal's progress.   Alpha build Like with every blog, we've released an alpha build so you can test Universal out for yourself. Don't forget the documentation and be sure to keep the following in mind:   Universal must be deployed on the same server as Indicium or it should be an allowed origin in appsettings.json. Universal only works with version 2018.3 and up of the Thinkwise Platform. Furthermore, make sure you run all hotfixes on the IAM and SF that you plan to use for Universal. Make sure you are on the latest version of Indicium Universal. This is an Alpha version, there is no compatibility plan in place for Universal just yet. Indicium updates and IAM hotfixes will eventually break this Alpha release. Download your alpha build here     Edit mode We've made several improvements to edit mode this past sprint: First off, the save button is always enabled when saving is allowed. Universal previously always made sure everything was up-to-date before allowing users to save. This meant that when you changed the value of a field, you had to click away from the field to indicate you were done with your changes, Universal then did some checks and finally the save button would be enabled. Now we let you press the save button at any time and wait to perform the save until everything is fine and dandy. When you press the save button and before the record has been successfully saved, the save button animates to indicate that a save is happening. The cancel button is also disabled because it is not possible to cancel a save action. The form fields are also disabled at this point, so no data changes can be made that would be overwritten when the save successfully returns. It looks like this:         Action bar behavior when saving This is usually only apparent when you have a very slow internet connection. The same concept has also been implemented for cancelling. When you press cancel and before the record has been successfully cancelled, the cancel button animates to indicate that a cancel is happening. The save button is also disabled because it's not possible to save cancelled changes. The form fields are also disabled because any change you make would be immediately discarded. It looks like this:         Action bar behavior when cancelling         Controls       Lookup combo We recently implemented a 'starts with' suggestion control for lookups. But sometimes you just want to pick an item rather than search for it. For that we created a lookup combo control. It loads all values, rather than just the top eight. You also can't type to search for a value.       The lookup combo control         Tasks The first version of tasks is here. For now we execute tasks that have no (visible) parameters. After this we'll be laying the groundwork to execute tasks with parameters (think showing a popup with a form to enter your data) We'll also visually indicate when a task cannot be executed for the current row.         Executing a task without parameters         Layouts We laid the groundwork to execute layouts in non-edit mode when navigating rows in the grid / cardlist. For the next version we'll be working on actually using the layout in the form and the action bar.         Unit tests Like before, we've added 41 more unit test cases for our components, controls and the fetching of data.         Lots of minor fixes/tasks       Styling   The active cardlist row is now scrolled into view (e.g. when adding a new row that gets added to the bottom of the list The grid now occupies the full width When logging in fails, the username and password will still be remembered Detail tiles are now responsive, reducing the chance of scrollbars The font is now correct when there are multiple conditional layouts applied to a single row Form labels now have a tooltip Label control now has the correct font Technical We removed the CORS proxy to make the application faster when developing All common colors were made into variables rather than hardcoded strings Performance We now return the same empty result instead of creating a new one each time for lookups Fixed typing issues for various containers which reduces the number of times we need to update the screen

A new hotfix is available for IAM 2019.1. To make it possible to synchronize, build a deployment package or execute a unit test, the Software Factory makes use of project version related modelers. When the project version had the status 'Production', the record disappeared in the modelers because of the 'Development and test versions' prefilter, resulting in a empty screen. By disabling this prefilter for these modelers in this hotfix, the project/project version will be available again and the expected data will be shown.

The 2019.1.7 release of Indicium has added support for an OpenAPI endpoint. This endpoint can be used in collaboration with tools like Postman or Swagger UI to explore what kinds of endpoints/requests an application exposes through Indicium. By exploring the application's endpoint/request definitions through these tools, a developer can more easily prototype and test their own requests when, for example, building an external service that consumes data from the application. Accessing the endpointTo access the OpenAPI endpoint of an application, send a GET request to the openapi path on the regular application root endpoint. Given an Indicium that is running on localhost and an application with the alias myapp that has been synced to IAM, the OpenAPI URL would be: https://localhost/iam/myapp/openapi Do note that, like all application endpoints, the OpenAPI endpoint requires a client to login before it can be used. On success the response will contain a JSON object describing the available requests for the application in OpenAPI specification version 3 format. PostmanTo import the OpenAPI definition into Postman first navigate to the application's openapi endpoint using a browser. Save the entire JSON document to a file or copy it from within your browser window. In Postman, open the workspace where the collection must be imported to and click the Import button. The window that pops up offers several ways to import an OpenAPI JSON document. For instance by selecting a saved OpenAPI document: Or pasting the document's content directly: Do note however, that because the openapi endpoint requires authorization, the Import From Link option cannot be used. The imported collection should now have been added to the Collections tab. Next, select a request and add an authorization method that works with the Indicium in question. For instance, Basic Auth with a username and password. Please note: Postman currently has an issue with importing OpenAPI requests for OData when the request contains a key parameter. These parameters will show up in the Params tab as so called Path Variables which are formatted like :variable in the request itself. While it may look like a value can be set for these variables using the Params tab, when sending the request, the variable name is not being replaced with the entered value. This means that requests containing a key will not work directly after importing the OpenAPI document. For now, to get around this, substitute the variable directly in the request url before sending it. An issue has been filed on the postman repository to track this. Swagger UITo use Swagger UI to explore the available requests for an application it must first be deployed to the same server (and domain) Indicium is running on. The following example will be using the dist deployment variant. This basically means that one must download the source code archive from the latest release and deploy the contents of the dist directory as a static website. To do this using IIS, create a swagger directory under the same website root that Indicium was deployed to. Then copy the contents of the dist package to it. Navigate to the swagger path using a browser, in the case of the example that would be http://localhost/swagger, and the Swagger UI should show up. Make sure your browser session has been logged into the target Indicium by opening a tab and navigating to any of the endpoints that are protected with authentication. The openapi endpoint is one of them so that can be used if you do not know any others. After logging in, enter the openapi endpoint url for the application whose endpoints you want to see in the Swagger UI search bar and click Explore. The endpoints for the application should now be loaded and shown on screen. Click on any of the endpoints to expand them and try them out.

What's up, Doc? We have another Universal Development Update for you. We've made a lot of progress on edit mode again, started working on tasks, and much more. Read on to find out all about it. We'll be releasing a blog post soon detailing the roadmap for getting Universal out of beta. Be sure to look out for that! You can subscribe to the blog to get a notification.Try the demo here   Alpha build Like with every blog, we've released an alpha build so you can test Universal out for yourself. Don't forget the documentation and be sure to keep the following in mind: Universal must be deployed on the same server as Indicium or it should be an allowed origin in appsettings.json. Universal only works with version 2018.3 and up of the Thinkwise Platform. Furthermore, make sure you run all hotfixes on the IAM and SF that you plan to use for Universal. Make sure you are on the latest version of Indicium Universal. This is an Alpha version, there is no compatibility plan in place for Universal just yet. Indicium updates and IAM hotfixes will eventually break this Alpha release. Download your alpha build here     Controls       Suggestion control Some of you may already have seen this, since we issued an extra release for this feature. We now translate lookup values in edit mode and you can edit those values using a suggestion control. First of all, this is what it looks like:       Suggestion control You can start typing and the control will suggest matching values from Indicium. You'll see the top 8 values that start with what you've typed in the field. As you'd expect, any prefilters that have been set in the model will apply to the results you'll get. You might notice that the suggestion control has a dropdown arrow. The suggestion control in Universal is like a combination of the combobox and suggestion control you know from the Windows and Web GUI's. If you do not know what to type, you can press the dropdown button and see what kind of data you need to enter. This also shows 8 results.         Google maps control We've made the Google maps control editable. This control is often used in your mobile apps. You can now edit the text and it has a button to open the location in Google Maps.         Google maps control         Edit mode When you previously checked a checkbox for example, you needed to click away before the value was updated. This meant that defaults and layouts were triggered later. We've changed the way changing the value works, and now you see the updates without needing to click away.           Default is triggered without clicking away This happens for the following controls:       Checkbox Combo Suggestion Radio   Copy / delete row We've added functionality to copy and delete rows. These actions can be executed from the action bar and work as you'd expect.   Copy and delete     Disabled moving away from a record in edit mode When editing a record, you want to stay with that record until the changes are done. To help avoid mistakes, and potentially the loss of work, we've disabled a couple features when you're editing a record:       Filtering (searching) Changing prefilters Going to a different row in the grid or cardlist   Unsaved changes We've added an unsaved changes indicator. When a document has unsaved changes, a dot will appear over the close button in the open documents and in the topbar. This also works for inactive documents, so you can see at a glance which documents have unsaved changes before you try to close one.   Unsaved changes indicator in open documents and topbar When you try to close a document with unsaved changes, Universal will not allow this, asking you to either save of discard your changes. If the document you're trying to close is not already active, it will be activated for you. We are designing a better-looking notification, for now we have something that works to ensure that you don't accidentally throw away unsaved changes.     Unsaved changes notification         Navigating to saved row When you add a new row, you want to have that row selected when you press save. Now this behavior has been implemented in Universal.         Tasks We've started working on tasks. For now, they are shown disabled in the action bar, since we haven't built executing them yet. This will follow shortly. We're currently working hard on the design phase. This is what tasks look like:         Tasks in the action bar We'll be working on making the action bar responsive so it'll fit neatly on any device without causing a scrollbar since tasks take up quite a bit of space for now.         Overlay sidebar We already had the option to make the sidebar very small, but on small devices you need all the space you can get. The sidebar now disappears completely when your screen gets smaller than 768px. You can get it to appear with the hamburger icon. To get rid of the sidebar again we've added a close icon, or you can press the darkened area next to the sidebar. Opening a document also closes the sidebar. It looks like this:         The overlay sidebar in action         Unit tests Like before, we've added 174 more unit test cases for       Several components Form controls Data fetching     Lots of minor fixes/tasks Styling     Date/time/datetime/radio button control labels are no longer always blue All fields on the login screen now use the correct colors The HTML control now changes the text color when switching between dark and light mode Note that the HTML control can add default (black) colors to the text. We do not override explicitly set colors. If these colors are undesirable, you can use [dbo].[sanitize_html] on the field The HTML control now uses the correct font by default Readonly fields no longer have a required asterisk Made all font sizes in the form the same DateTime/Time controls now show formatted value rather than timestamp Some SVG's with color got recolored when you switched dark/light mode. This has been fixed. Extended property theme colors are now correctly applied The label of a form field no longer animates down when field has a value Edit mode     Disabled Ctrl + Z (undo) and Ctrl + Y (redo) in the form Editing records that have a Date/Time field for a PK now works correctly Action bar now listens to edit mode of document, rather than its own Disabled fields in the form are now styled correctly Technical     Made it easier to see if the document is in edit mode Made it easier to see and fetch changes when reviewing code Enforced more code style in our development process Fixed bug where the current document would change when you close a different document Renamed 'Container' to descriptive names Added a size observer to help make Universal more responsive Refactored mapDispatchToProps from functions to objects where applicable Rename resource_id to staged_resource_id to comply with Indicium Properly handle alphanumeric PK's when editing, copying or deleting records Sanitize SVG's to prevent script execution Performance     Virtualized rendering for the Cardlist Reduced prop drilling in the ScreenBuilder Don't rerender form as much  

When disabling filters in the project ribbon, data was not shown correctly in the model rights screen. A prefilter was always active for model rights that filtered all data for projects with the status inactive, production or acceptance. With this hotfix we disabled the prefilter on model rights.

Sometimes when copying users in IAM, the wrong datatype would be inserted into the table that tracks user prefilter statuses, resulting in an error. A more structural fix is coming with the next Software Factory release. This hotfix will resolve the current errors that can occur when copying users.

With 2019.1 the synchronization has been moved to the SF. This has resulted in a bug where the reachable objects were not calculated correctly for mobile. The bug only occurred after a new project version was synchronized to IAM. The menu was not shown correctly on mobile devices. With this hotfix, the reachable object are now calculated correct during synchronization.

The synchronization to IAM and to script had some delays with the part about synchronizing roles and role rights. We took some time to improve this in a hotfix.

Data modeling is one of the key activities in creating an application with the Thinkwise Platform. Through the data modeler in the Software Factory you can design your own data structure and the validator will do several basic checks to guarantee a certain level of model quality. At Thinkwise we have developed guidelines to improve the quality and consistency of your data model even more. Earlier I wrote a blog about these guidelines. We now moved the guidelines to Thinkwise Docs. For the most recent version of the guidelines, go to: https://office.thinkwisesoftware.com/docs/docs/sf/guidelines_data_modeling.html Good luck in reading and using these guidelines!

Good news everyone! We have another Universal Development update for you. We've been working on implementing more controls so edit mode works even better. Besides more controls we've fixed some bugs, worked on ensuring the quality of the GUI. We've also been working hard on lookups in edit mode, so you'll soon see the translated values when working with data. You'll get more on this later.Try the demo here   Alpha build Like with every blog, we've released an alpha build so you can test Universal out for yourself. Don't forget the documentation and be sure to keep the following in mind:   Universal must be deployed on the same server as Indicium or it should be an allowed origin in appsettings.json. Universal only works with version 2018.3 and up of the Thinkwise Platform. Furthermore, make sure you run all hotfixes on the IAM and SF that you plan to use for Universal. Make sure you are on the latest version of Indicium Universal. This is an Alpha version, there is no compatibility plan in place for Universal just yet. Indicium updates and IAM hotfixes will eventually break this Alpha release. Download your alpha build here     Controls We've implemented more controls this sprint, making it easier for users to edit more types of data:         Date editor We've implemented a date editor. It shows the date in the browser's date format and allows a user to either type or pick a date:         The date editor         Time editor We've also implemented a time editor. The time editor shows the time in the browsers' format and allows users to edit it by typing:       The time editor       DateTime editor We combined the date and time editors to form a DateTime editor. The user can also use the arrow keys on the keyboard to change the values for both the date and the time parts:       The DateTime editor       Phone number editor We also built the phone number editor. In edit mode, the field is no longer displayed as a link. A phone icon is shown to the right of the field. Clicking this icon opens the default app ready to call the number.       The phone number editor       Email editor We've implemented the email editor. In edit mode, the field is no longer displayed as a link. An icon is shown to the right of the field. Clicking this icon will compose an email in the default email client with the email address already filled in.       The email editor       URL editor The URL editor has been implemented. In edit mode, the field is no longer displayed as a link. An icon is visible to the right of the field. Clicking this icon opens the URL in a new browser window.       The URL editor       Radio button editor The radio buttons are now fully functional in edit mode. When a radio button is not required you can click on a selected radio button to remove the value altogether.       The radio buttons       [Preview] Lookup suggestion editor You can't try this yet, but we've been working very hard on lookups in edit mode. You can expect an extra release with this feature soon. It looks something like this:       Lookups in edit mode via a suggestion editor       Unit tests To ensure that the GUI keeps working correctly with all the changes we make, we've added about 300 unit test cases for among others:       Several components Form controls Data fetching   Lots of minor fixes/tasks Fixed bug where scrollbar didn't update after resizing the browser Fixed bug where field layouts HiddenInsideForm and HiddenOutsideForm didn't work Fixed bug where the login screen didn't get a scrollbar if it was taller than the browser height Fixed bug where open documents had no hover or ripple effect Fixed bug where the background image size was wrong Moved form control pristine state to Base Editable Control Improved unit test performance by utilizing cache Upgraded test framework Upgraded Material UI Improved our testing method Made authentication compatible with forms authentication Added design documentation for DateTime, Date and Time controls Researched preventing unnecessary updates to improve performance Researched whether we use correct form event handling (we do!) Disable refresh when in edit mode Created a technical design to optimize the loading of the dataset Researched impact on the state of letting the save and cancel user actions wait for the changes to be processed Researched and implemented code obfuscations Refactored the way files are loaded Refactored the way badges are loaded Researched visual testing to ensure ongoing development doesn't result in unintended visual changes

We’re a few months into the new year and we’ve been working hard on getting our first release for 2019 ready. Among this release’s headline features is Unit tests. Unit tests makes it easy to automate your application logic testing and ensure a consistent quality for your applications. To find out more about it we'll have a separate blog post coming soon. Stay tuned! Our other big feature for this release is Access control in the Software Factory. We’ve moved role configuration from IAM over to the Software Factory. We’ve made a more detailed blog post for this feature which you can find here. New features We have a lot more besides unit tests and roles in the Software Factory with this release. A short summary of what's in this release: Task to renumber task and report parameters Appendices on requirement report Sorted look-up combo’s Copy project version after upgrade Automatically copy translations for renamed objects Table-valued CLR functions Approve validation messages Many smaller features and fixes Check out the release notes for a comprehensive list of all new features, changes and fixes. The 2019.1 release is available for download in TCP right now!

A new hotfix is available for IAM. During some testing on 2019.1 we found out that the lookup for report parameters is not calculated correctly in older versions. This bug has been introduced in 2017.1 and will automatically correct itself after upgrading to 2019.1 IAM. The result is that report parameters with a look-up to a table or column, that was not available to that user, will now be hidden. Before the hotfix, the parameter could be visible but untranslated.

A hotfix has been released to resolve a problem with generating recommendations (advices) in Windows and Web. This hotfix also requires version 2018.3.18 or up of the Windows and Web user interfaces. The hotfix can be installed by downloading and running the latest installation package.

Several reports indicated a problem with IAM 2018.3 when attempting to delete user-defined prefilters. This scenario occurs when a user defined prefilter has been enabled by default. A hotfix has been released which resolves this problem. The hotfix can be installed by downloading and running the latest installation package.

Today's GUI release with version 2018.3.19 contains a breaking change involving form default edit mode. It affects both Windows and Web GUIs. Previously, if 'Default editable' was checked, the 'Auto-save form' setting was ignored and the form would automatically save changes when it lost focus. In versions 2018.3.19 and higher, this is no longer the case. It instead requires an explicit save or cancel action. To restore the existing behavior, the 'Auto-save form' checkbox must now be checked. See below screenshot where you can find the two checkboxes in the Software Factory: To quickly find all tables and variants which are affected by this change, these queries can be used on your Software Factory: code:select tab_idfrom tabwhere project_id = 'MY_PROJECT' and project_vrs_id = '1.00' and form_default_editable = 1 and form_auto_save = 0select tab_id, tab_variant_idfrom tab_variantwhere project_id = 'MY_PROJECT' and project_vrs_id = '1.00' and form_default_editable = 1 and form_auto_save = 0

Howdy everyone, the time has come for another Universal development update and we have got some treats for you! The Universal GUI has had some major changes, both visually and functionally. With edit mode we're getting closer and closer to a replacement of the Mobile GUI. Try the demo here You can expect these blogs to come every six weeks from now on.   Alpha build Like with every blog, we've released an alpha build so you can test Universal out for yourself. Don't forget the documentation and be sure to keep the following in mind:   Universal must be deployed on the same server as Indicium. Browser security prohibits us from deploying this otherwise. For now. Universal only works with version 2018.3 of the Thinkwise Platform. Furthermore, make sure you run all hotfixes on the IAM and SF that you plan to use for Universal. Make sure you are on the latest version of Indicium. This is an Alpha version, there is no compatibility plan in place for Universal just yet. Indicium updates and IAM hotfixes will eventually break this Alpha release. Download your alpha build here     Add / Edit implementation According to our design, we've implemented the technical details for working with add and edit mode. We've added the options to add a new record, or update an existing record. This works as you'd expect, using the buttons in the action bar:       Adding a new row       Editing an existing row You'll notice in the images above that the action bar also reacts to edit mode. The save and cancel buttons are only visible in edit mode, and the edit button is only visible in non-edit mode. The asterisk that indicates that a field is mandatory is only shown in edit mode.         Controls We've created a base control which helps all other controls handle events like when a users leaves a field or when the value changed. This makes developing other controls much easier.Implemented controls We're working hard on implementing edit mode for each control. As you can imagine this takes quite a lot of work and care to ensure each control works as expected. Besides the base control, we've already implemented the following controls:Text       A text control in edit modeMultiline     A multiline control in edit modeNumeric     A numeric control in edit modeCombo     A combo control in edit modeCheckbox     A checkbox control in edit mode We'll continue to work on implementing the remaining controls and supporting lookups in edit mode.       Layouts / defaults We've also implemented layouts and defaults. For now the layout is executed when a field loses focus. We'll be making this more immediate in the future.Visibility       The field 'Beëindigd per' is only visible when 'Contract beëindigd' is checkedAlso notice in the above image that the date is filled by default with the current date.Mandatory     'Verstuurd door' becomes mandatory if 'Gepubliceerd' is checked.       Tooltips Because we don't have resizable components like splitters or the columns in the grid, it's possible that data gets hidden. To ensure it's still possible to read all the data, we've added tooltips.         A tooltip is shown on overflowing elements The general idea is that the tooltip is only shown when the content doesn't fit. It shouldn't matter what the content exactly is. There are some exceptions of course, like prefilters where you only see the icon, and always want to see the name on hover. Another exception is open documents. These always show a tooltip, and the tooltip also has the context when the open document is zoomed.         Tooltip on a zoomed document, more on this in the next section         Zoomed details in open documents The name of the currently open document got pushed away very quickly because we prepended the path, especially when you zoomed in multiple times. We've opted to simply show the name of the opened detail document. The user gets to see the path she took to get to that detail in the tooltip. The icon of the zoomed document is now correctly shown, rather than the icon of the parent. It looks like this:         'Emails' is a detail of 'Medewerkers', showing the parent row (Dave Brumfield) Zooming multiple times shows the path the user took to get to the current subject:         Zoomed in multiple times, each parent subject separated with a '>'         Papers To better distinguish visually between components, we've put papers around them. We already had papers around the login component and around detail tiles, but now the grid, form and cardlist components also have them. It looks like this:         Papers around the cardlist and the form And the same screen in dark mode (use the lightbulb in the topbar to switch modes):         Papers around the cardlist and the form in dark mode The paper has been put around the entire form, and the sections (what now are tabs) have been separated with a divider line.         Papers around the grid and detail tiles And the same screen in dark mode:         Papers around the grid and detail tiles in dark mode Adding paper to components makes it easier to see where one component ends and the next starts. It makes the screen look a lot cleaner and less cluttered because components are being lifted from the surface by papers.         Lots of minor fixes / tasks A lot of work has been done to ensure that the Universal GUI has the highest quality.         Fixed checkbox styling Fixed the selected and hover state of rows in the grid with conditional layout Made the 'Open documents' text animation Fixed nested lookups sometimes not being translated Put form controls closer together Only the available applications per platform are loaded, rather than all applications Fixed issue where there was no dataset available Fixed logout request not being sent when logging out Hide columns based on context filter in zoomed documents Fixed max-length property for multiline controls Fixed form multiline controls not showing on one line Several code and development improvements    

Hello everyone! Today we have the new monthly status update for the universal GUI. Like always, a demo environment of Universal on the Insights application is accessible here using your Thinkwise credentials as login.   Alpha build With this update we’ve also released an alpha build so you can test it out for yourself. To aid (external) developers, we’ve created documentation for deploying, running and troubleshooting Universal. Be sure to keep the following in mind:   Universal must be deployed on the same server as Indicium. Browser security prohibits us from deploying this otherwise. For now. Universal only works with version 2018.3 of the Thinkwise Platform. Furthermore, make sure you run all hotfixes on the IAM and SF that you plan to use for Universal. Make sure you are on the latest version of Indicium. This is an Alpha version, there is no compatibility plan in place for Universal just yet. Indicium updates and IAM hotfixes will eventually break this Alpha release. Download your alpha build here       Breadcrumbs The breadcrumbs are finished! With the complete breadcrumb you always know where you are in the application. We can divide the breadcrumb in three parts:   Active row indicates the current selected row. Between the parentheses the current type of subject is shown. The path summarizes the parents, how did you get to this screen.   Filtering on lookups After sorting we now also support filtering on lookup translation values as we promised in the previous Universal post. It maybe seems like an obvious feature to an end user, but under the hood it may be quite sophisticated. It means we should order or filter the current data set based on data values from a related subject, possibly with some other related subjects in between: called lookup value resolvement. From the end user’s point of view, this means (s)he gets the to see the expected filter results based on the values shown in the GUI, rather than their database values. In our Insights application, the direct result of this feature is visible in e.g. “Employee->Hours”, filtered on an Activity like “boatmans”. The name of the Activity is selected from the Activity via another subject, as shown in the image below.     The name of the activity is fetched using an intermediate table.         Scroll to selected row after filtering The Cardlist and Grid now scroll the selected row into the visible area of the screen after filtering. When the selected row is already visible, no scrolling will take place.     Scrolling to the selected row after filtering in the Grid.         Restoring vertical scroll position When switching to another document and back, the vertical scroll position is now restored. This is implemented for the Cardlist, Grid and Form.     Restoring vertical scroll position in the Grid.         Background image It's back from the past! We can apply the background image once again. For now we have one option available: we implemented this feature with a stretched background in mind. So smaller images won't look good because they will be stretched and become blurry, but other options are being considered as an setting in the SF.   Clear cache on errors We've added the ability to clear the cache when a severe error occurs. So when something really bad happens you can keep using Universal with a clean slate without needing to do anything technical. It looks like this:       Research Styling We noticed that the styling of Universal took an disproportional amount of time and resources to be applied in Universal. We figured out why this is and have made a design to remedy this. This will also make developing easier, but the most important part is that Universal will get a bit faster.Editing and adding data The moment we've all been waiting for. We're putting the finishing touches on the research and the plan to implement adding and editing data. This means that next month we can start work on building these features. Stay tuned for the next blog!Lookup translation strategies While implementing Breadcrumbs, we ran into a situation where a new kind of lookup translation strategy was requested. In this period we took our time to describe and design different strategies and their ideal application. This resulted into two strategies: #1: Translate an entire data set column at once with a single call to Indicium. We currently use this strategy.       1 call to Indicium, who calls the database once Returns duplicate results for the same value of data set rows Result is shown afterwards at once Translates invisible values #2: (new) Select the translation of a single data value directly from the lookup subject.     Multiple smaller requests to Indicium and the database, possibly optimized by HTTP2 Caching prevents duplicate translation requests Single result shown immediately Translate values only from visible parts of the GUI, e.g. optimistic scrolling in Grid or Cardlist. Currently possible, since the Universal now has knowledge about lookup value resolvement paths from the SF datamodel. We need the second strategy right away for the new Breadcrumb component on a detail subject with an empty set. The breadcrumb shows the identity values of the parent subject to let the user know the path to the zoomed detail document. Possibly, these identity values should be translated into human readable values by using the lookup mechanism. In this case we have no data row to let Indicium know where to translate its values from. So right now these values are untranslated, and by implementing the second strategy they will also be translated. Both strategies use the same caching mechanism, so each can use the data loaded and cached by the other one.       Lots of minor fixes / tasks We keep putting an enormous amount of work in ensuring a high-quality product:       Designed zoom details in open documents Designed scroll to active row Fix deprecated AgGrid toolpanel properties Fix console error on search Added script to get test coverage Fixed bug where conditional layout sometimes didn’t work Fix grid values not updating when refreshing Fix bug where browser refresh resulted in logout Removed the React Router Implemented compatibility with empty string as nulls in i_ui_views Refactored away deprecated React lifecycle hooks Fixed error when logging out immediately after a search Fixed grid data jumping when loading multilines Implemented domain alignment for grid cells and headers Refactored away any types No longer close open documents when switching applications Use file API for meta images Refactored sidebar Implemented Look-up display value resolvement. For more details, visit the previous December blog. Fixed grid line width Fixed the margins around grid data   What we’ll be working on next month Squashing another dozen or so bugs Form add / edit Adding paper to components to better separate them without splitter lines. Global application breakpoint Responsive filter Responsive search Responsive action bar Improving the way we style components Improving our build flow Zoomed details in open documents Form field alignment

Hello everyone. Today we have a new monthly status update for the Universal GUI. Like always, a demo environment of Universal on the Insights application is accessible here using your Thinkwise credentials as login. Alpha buildWith this update we’ve also released an alpha build so you can test it out for yourself. To aid (external) developers, we’ve created documentation for deploying, running and troubleshooting Universal. Like always, keep the following in mind: Universal must be deployed on the same server as Indicium. Browser security prohibits us from deploying this otherwise. For now. Universal only works with version 2018.3 of the Thinkwise Platform. Furthermore, make sure you run all hotfixes on the IAM and SF that you plan to use for Universal. Make sure you are on the latest version of Indicium. This is an Alpha version, there is no compatibility plan in place for Universal just yet. Indicium updates and IAM hotfixes will eventually break this Alpha release. Click here to download your alpha build Detail tilesThe first version of the detail tiles has been released, which is just a simple tile with no special abilities yet like badges or disabling. The only thing it does is open the detail. They can be placed like any screen component and will automatically position all the tiles in the available space. The detail tiles will be further improved in future sprints, for now you can enjoy the simple detail tiles. Refresh buttonSmall, but important. Refreshing will reload the data and the look-ups for the current document. It has a sweet animation too! Improved configuration optionsThe login screen has been extended with several configuration options: The previous release of Universal has support for logging in to your own IAM using https://server/indicium in the login screen. This URL format is old news, we don’t use it anymore. Now, you can use https://server/indicium/iam/iam to load products from IAM and https://server/indicium/iam/sf to load products from the Software Factory. Furthermore, you can configure Universal to load a specific application, which can be set by using the application ID or alias. When running against a Software Factory, the application points to a specific runtime configuration. Nothing new here. The interesting thing is that you can also choose to load a specific application when starting against IAM. This opens up possibilities like separate shortcuts for different applications. You can also choose to leave the application field empty and load all applications, like the GUI’s do now for IAM. With Universal, you can also choose to do this for the Software Factory. Universal will have all runtime configurations assigned to the current user available to switch to as if they were different applications. You can choose which runtime configurations are available per user in the Software Factory. A developer can create a menu specifically to Mobile, Windows or Web in the Software Factory. Since Universal is not bound to a specific platform, you can choose the platform it should load the menu for in the login options. Clear cacheWhen you log out in Universal, the cached model is deleted and will have to be reloaded. But there can be situations where you completely want to reset any data that might have remained offline. This can be the login settings, the status of the light switch or perhaps cached model data or offline data in the future. Hit that clear cache button to reset everything! Improved look-up mechanismsLook-up display value resolvement For a while, we were thinking about the perplexing feature of lookup references, called: Look display value resolvement. Especially the case where the lookup links to another lookup – and so on – to get the display value. To learn more about lookups, read this article. In the past month we figured out the plan and wrote a technical design for the Universal GUI. Until the development of this is completed, we handle such columns as untranslated lookup columns. Development is planned for the upcoming period. Our first though was to leave it completely to Indicium to figure this out, but we quickly found out this wouldn’t work. We switched over to the $expand statement of ODATA in Indicium to request lookup presentation values. code:GET http://localhost/odata/Categories(1)?$expand=Products/Supplier In this case the “Products” subject may of may not be directly referenced by “Categories”. From the Universal GUI point of view we should resolvethe path to “Products” by recursively walking over the lookup references of “Categories” to find the column with the presentation value (in this case “Supplier”). Sorting on display value The Universal GUI already supported default sorting as configured on the subject from the SF, however the sorting was applied to the data value rather than the presentation value when the column contained a lookup reference. This caused unexpected ordering of data after the data values been translated with their lookup display value by the GUI. From now on, the GUI sorts columns on its lookup display value rather than its data value. In our Insights application, direct result of this is visible in e.g. “Projects” sorted on “Customer”. Filtering on display value Granted, filtering on display value hasn’t made it into this release since we wanted to make sure the look-up mechanisms are high quality. The next release will have it! Design, design, designNothing in Universal is built without a good design. An improved design for all components has been done to make a clearer distinction between them, without having to resort to splitter-lines. Title bar and breadcrumb has been designed and will be implemented soon. A global design for editing is currently under review by the team. Many, many minor fixesAs always, we’ve put an enormous amount of energy in ensuring a top-quality GUI: Corrected path for placeholder Hide database value for lookups Made cardlist items all the same size Added target_tab_col_id to i_ui_tab_lookup Images in grid are now the same size, regardless of row height Fixed alignment of listbar items without icons Fixed the size of group icons in the listbar Fixed grid header font size Filter out untranslated lookups to avoid 500 statuscodes Data is properly loaded when starting against an SF Reinstated default prefilter button colors Properly aligned the HTML control content to the rest of the form Fixed alignment of items in the cardlist overflow menu Made input label styling consistent Validated and closed bugs that were no longer reproducible What we are working on next month Squashing about a dozen bugs Better quality control: Test coverage, typings and enabling strict mode Filtering on lookup presentation Look-up display value resolvement Breadcrumbs Refactoring the sidebar Scrolling the grid and cardlist to the active row after filtering Replacing our router Layout logic for the current row Align controls according to domain control alignment from SF Multiple designs for how to make Universal responsive

This month, an Alpha build has been made available for everyone to download and install! Furthermore, three major features have been developed. The configuration screen, access to details and the magical breakpoints. Granted, detail tiles and layout logic didn’t make it to this release. Instead many small issues and bugs have been fixed and the design for the beforementioned features has been greatly improved. We prefer to resolve the issues and bugs right away instead of letting them pile up in favor of new features. Like last time, a demo environment of Universal on the Insights application is accessible here using demo/demo as login. Configuration screen & Alpha downloadUniversal had a link to our development Insights IAM. This link was written hard-coded in the source code, forged in the crucible of the TypeScript compiler to an unchangeable constant in the runtime. This was a bit of a problem. The Insights is a nice application and all but we want to run Universal on every Thinkwise platform product imaginable. We’d need either a config screen or an INI. The config screen is the most accessible way of configuring the application and the values configured will be remembered by your browser. This way, an INI will not be needed for a while. Pointing Universal to the correct Indicium Universal is configured by pointing the service URL to https://server/indicium/. Right now, only IAM is supported. Running Universal on SF will follow shortly, we just need to be able to point to the right runtime configuration. Universal does not need an application pool and can be deployed as a regular folder in IIS. Universal folder installation, next to Indicium Please note the following important details: Universal must be deployed on the same server as Indicium. Browser security prohibits us from deploying this otherwise. For now. Universal only works with version 2018.3 of the Thinkwise Platform. Furthermore, make sure you run all hotfixes on the IAM and SF that you plan to use for Universal. Make sure you are on the latest version of Indicium. This is an Alpha version, there is no compatibility plan in place for Universal just yet. Indicium updates and IAM hotfixes will eventually break this Alpha release. Click here to download your Alpha build! Access to detailsWhile the design of detail tiles is being finished up, much of the technical implementation has been developed. We didn’t want to keep this away from you all, so instead of detail tiles a combo has been added to open a detail. The functionality described here is called zooming. Accessing a detail as a new document, based on the selected parent row in the original document. As soon as the zoomed document is opened, it is no longer connected to the original document. Switching rows will have no effect on the zoomed document. This functionality is present in the current user interface by double-clicking on a detail tab, clicking on a detail tile or through a zoom process action in a process flow. The detail combo can be found next to the action bar BreakpointsThis has been hinted at for a while now in previous blogs. We would soon see the magical Breakpoints… Well, they are done! But what are they? In the Windows and Web GUI’s, a screen type is responsive to the width and height of the application. When the width changes, the components within the screen type become smaller. The components in the screen are often adaptive. They don’t shrink their contents but they respond to the available space by reorganizing themselves. The form changes its layout by creating tabs tabs, the grid creates a scrollbar. With Universal, we are planning to allow screen types to grow vertically beyond the visible boundaries. This will introduce vertical scrolling. This means that the developer no longer has to worry much about limited height, both for screen types and components. There is no need for a screen type to be responsive or adaptive when it comes to vertical space. This is all good and well, but how do we deal with limited horizontal space? A responsive screen type can make the components so narrow, the components will eventually not be able to solve the problem, no matter how adaptive they are. Breakpoints save the day here. Instead of a fixed component layout for your screen type, you can define multiple component layouts for your screen type, depending on the available width. Universal will choose the correct component layout depending on the available width for the screen type. Basically, the screen types become adaptive to changes in horizontal space! A table or variant will still have a main, detail, look-up and zoom screen type. But this screen type will have as many component layouts for different horizontal sizes as the developer wants. You can even choose completely different components for various breakpoints. For instance, the developer can choose to replace a grid with a card list when the width becomes too small. When there are multiple breakpoints defined for a screen type, the largest breakpoint that fits will be used. Specific screen types for Mobile should not be needed anymore because of this. This is part of the effort to ensure the entire application can be accessed from every device. Breakpoints in action Furthermore, this not only applies on Mobile but also on a desktop or browser window that is resized. Expanding or collapsing the menu can also change the applied breakpoint for a document. When detail tabs are implemented, the available horizontal space for the detail tab will also determine the breakpoint used for the detail. Keep this in mind; a narrow breakpoint is not equal to a mobile device. Breakpoints – How to model themThe Software Factory has not yet been updated to allow breakpoints to be modeled. Instead, a temporary solution is in place to allow breakpoints to be defined, called breakpoint screen types. A breakpoint screen type can be added by creating a new screen type with the same name, suffixed with _(lessthan)###, where ### is the width in pixels where the breakpoint should kick in. The breakpoint screen types will be loaded on-demand. For example, most of you are familiar with the screen type master_detail_vertical. For the sake of simplicity, assume this is a grid and a form next to each other. Universal will always use the configuration of this screen type when no breakpoint is active. A simplified master_detail_vertical screen type The developer can create a breakpoint that will become active at 640px width by creating a new screen type called master_detail_vertical_(lessthan)640. The developer can choose to put the grid above the form in this breakpoint screen type, since the form would get very limited space at 640 pixels and less. The breakpoint screen type master_detail_vertical_(lessthan)640 Say the developer want a second breakpoint at 400px, to replace the grid with a cardlist, since the grid is also getting too small. This breakpoint screen type would have master_detail_vertical_(lessthan)400 as id. The breakpoint screen type master_detail_vertical_(lessthan)400 The breakpoint screen types are a temporary solution and should not be used anywhere as a screen type and should not be available for UP. Universal doesn’t treat them like screen types, so using a breakpoint as a screen type will result in an error message reminding you that this cannot be done. With the next Software Factory release, we plan on formalizing breakpoints in the Software Factory so they will be part of the screen type instead of separate screen types with weird ids. Many, many minor fixesThis chapter will probably be a part of every Universal development update, but I cannot stress enough how much work goes into ensuring a top-quality GUI. The filter now properly splits words on spaces and generates an orred-filter Visual improvements and alignment improvements of the grid Look-ups no longer crash on multi-level resolved display values but instead show the data value (for now) Multiline controls on cardlists have been fixed to span multiple lines Badges have been fixed when Universal is connected to a product via the Software Factory Form now translates look-ups properly when reopening for a second time Datasets are loaded properly when rapidly opening multiple documents Performance improvements when it comes to drawing the sidebar and conditional layouts Performance improvements when it comes to drawing the grid, form and cardlist Badges have been improved to only execute once per input instead of once per occurrence The action bar now waits for data before showing itself Is anyone still reading this Prefilter button order and alignment has been fixed Prefilter icons have been provided when they do not have an icon Input labels in specific form controls no longer shrink when the value is an empty string but look like a null-value Technical updates, such as framework upgrades, improved compilation times, build times and bundle size And many more! What we are working on next monthDecember – the jolly time of year with presents, good food and holidays. We are going to be running on limited capacity in December as many of the team will be going on a well-deserved break around Christmas. At any rate, we’ll be working on the following things: Quality: There are 38 identified bugs – we plan to squash about half of them Detail tiles Refresh button Improved look-up mechanisms Look-up display value resolvement Sorting on display value Filtering on display value Layout logic for the current row Titlebar and breadcrumbs When will we get edit mode?The Indicium team has just started working on a massive modification to make security air-tight. This will probably be discussed in a separate blog. After the rework, changes will be in effect that limit users calling the Indicium API directly. With the modifications, the following changes will be in effect: New rows and rows in edit mode will be managed by Indicium. Values of the parent row when adding in a detail will be set by Indicium instead of the GUI Values of the original row will be copied by Indicium when copying a row Default values will be set by Indicium instead of the GUI The user can no longer set a look-up value outside of the look-up prefilters Column rights for new rows and rows in edit mode will be checked by Indicium The user can no longer add or edit a row if editing is disabled by the Layout logic The user can no longer ignore the access type set by the model, rights or the Layout logic The user can no longer ignore mandatory fields The user can no longer save the record if saving is disabled by the Layout logic Default logic will be executed by Indicium The Default logic is not bound by rights and can change fields and set values not accessible to the user Simliar rules will be in effect for task- and report parameter pop-ups. This introduces a massive improvement in security, opens the way for Indicium to manage the process flows and paves the road for column and cell-level data selection autorization. A small step further is to provide these levels of authorization on variants as well. Naturally, this will have a quite some impact on the way Indicium and the GUI’s communicate when it comes to adding and editing rows. We planned to build adding and editing for Universal before this change would be implemented. However, Indicium caught up and we’ve gotten to the point where we would need to rebuild adding and editing in Universal very shortly after the development for Universal would be finished. Because of this, actual editing and adding rows will be implemented once the change has been implemented in Indicium. Any groundwork we can do, the UI modifications neccesary to edit and add rows, will be developed in advance. Thanks for reading, see you next year!

In the upcoming release of the Web GUI, a major and possibly breaking change has been made in the way in which database connections are set up. Regardless of the type of authentication (database, Windows, IAM or Kerberos), the Web GUI now always uses a single database pool user to connect. This change is required for future developments but also offers a number of important advantages right now: Improved performance through more efficient connection pooling. Better support for DB2 and Oracle end products using a SQL Server IAM. Improved security as users do no longer need direct access to the database and the GUI does not have to keep passwords in memory. Simpler and more efficient code because the GUI does not have to switch context as often to impersonate users. Easier user rights management without the need to apply rights on the database. Impact on reportsUsing a single pool user instead of impersonating end users may have an impact on existing reports. At present, only when using database authentication, reports can make use of queries or views that use the Tsf_user() function, for example for filtering data. Connections to the database are set up by the reporting tool with the user’s credentials, and the Tsf_user() function returns the database username if the session user name is not explicitly set. Now that the connection is initiated with the pool user’s credentials, the Tsf_user() function no longer returns the correct user name. (For authentication types other than database this has never been the case.) What to do next?First, check if your application uses database authentication, as the change has no impact on other authentication types. Next, check the reporting tool you are using. For DevExpress and SQL Server reports, we managed to intercept the report generation to correctly set the session user, even for IAM and Windows authentication! Unfortunately, this is impossible for Crystal Reports and iNet Clear reports. It is therefore necessary to adjust or replace these reports if they use queries or views in which the Tsf_user() function is used. Two options are available: Provide the user name as a parameter of the report. Make sure to always set the user name in the default so that the value can not be tampered with when using Indicium. Switch to SQL Server Reporting or DevExpress Reporting. DevExpress provides the option to import (simple) Crystal Reports reports. Which option is best for your project depends on various factors, such as the complexity of the reports and queries and of course the number of reports. More information on the pros and cons of the different reporting tools will follow soon in a separate blog post… ConfigurationThe new database pool identity can be set up in the web.config file. If no database pool identity is specified, the IIS application pool identity is used for database connections. The database (or application) pool user must be granted full permissions on the IAM database and the end product database. The pool user should not be an IAM user, so that it can not be used to log in to IAM. Need help or advice? Please refer to the Deployment manual for detailed instructions or drop by at Product Innovation!

Gather ’round, gather ’round, we got another Universal Development Update for you! We are closing in on a version which has most of the features covered to act as a read-only version of the current Mobile GUI. The plan is to have something for you all to play around with by the time 2018.3 releases! FormA read-only version of the form has been completed for Universal. The basic controls have been implemented like the different text control for email, phone number, multi-line etc. The controls for checkbox and radio buttons are in development as we speak. The form positions the fields according to the optimal placement over the suggested number of columns, so there is no space wasted. The “number of columns” setting in the Software Factory will be moved from subject to the screen type, so you can modify the number based on the available room on the screen. You might want fewer columns on a detail screen type, or even when the screen gets smaller (using a breakpoint). A new concept “keep groups together” is introduced to specify whether grouped controls are placed together in the same column or not. If you don’t keep groups together, the group might be spread out over multiple columns. Let’s talk more about setting the number of columns. Let’s say we want three columns as an example. The form will now have at most three columns, but if the controls fit in only two columns, the third column will be dropped. Tabs have been replaced by vertical scrolling. The fields which are placed in a tab by the Software Factory will be put in their own section. The decision on how many columns are needed will be made for each section. So if you have three sections, it’s possible the first section has three columns, the second section two and the last only one column. The width of the controls is equal to the width of the column. If you want a control (like a multiline) to span multiple columns, place it in its own section. There are some things that are not yet implemented: Controls side-by-side on the same line Field width as a percentage of the width of the column The good old tabpage-based layout A form with one section containing 3 groups spread over 3 columns Card list improvementsTo finish up development on the card list, we’ve managed to surpass the features of the Mobile card list. This was needed since we will be relying a lot more on the card list in the future, when the good old grids from master-details won’t display data to our satisfaction on small phone screens. Instead of implementing all control types for the card list, we’ve decided to add an overflow menu to each card. This menu allows you to execute the actions normally available on the control, such as URL navigation, calling a phone number, sending an e-mail or checking out the location on a map. Overflow menu showing the control actions for a card FilteringFiltering using the global filter and prefilters has seen great progress. Thanks to the Indicium team, filtering works blazingly fast and feels incredibly smooth in the Universal GUI. The filter and prefilter components are still in development, this is planned to be completed by the next update. Screen typesScreen types are now being loaded by Universal, components are placed according to the definition of the screen type. The definition of the screen type needs to be converted into a definition which only includes supported components, since not all components are supported yet. A tabpage will, for now, show the first component that is supported. And a splitter which has a grid (supported) on one side, and a cube (not supported) on the other side gets replaced by only the grid. This still needs to pass QA but the development is mostly done. This is the first step of 5 phases when it comes to screen types. The second step involves a concept called ‘breakpoints‘ to ensure the screen type always fits, no matter the size of the device, browser window or application, or the room it has when shown as a detail. More about this in a future blog. Once this is completed, we can work towards autosizing components, for instance a grid or form that keeps growing vertically. What happens when this autosizing grid is in a detail? That’s what we try to tackle in this phase. Navigating within a screen type is something that was very common in mobile (cardlist to form, form to detail) but not in Windows or Web. We plan to create a common solution between those two, by having hierarchy-like screen types act as fullscreen navigation. Tabpages, as we know them now, will be the last milestone to achieve and will herald the completion of screen types in Universal. Lazy model loadingA massive change has been completed regarding model loading. This will not affect developers using the Software Factory much at all, but it might be interesting to take a peek under the hood. First, a bit of history. The Windows, Web and Mobile user interface have always loaded the entire application up-front. This is quite a bit of work. Loading every prefilter condition, every grid position of every column in every variant and every drag-drop bound parameter takes some time. The mechanism that we use for this are so-called get-gui’s. The get-gui’s get the GUI information from the SF or IAM. As time went by, the model got larger, more get-gui’s were introduced and existing get-gui’s got bigger. The amount of get-gui’s called by the user interfaces has increased quite a bit over time. The total number of columns returned by all get-gui’s has also doubled over time. Because of this, applications boot slower and slower. We’ve improved this by loading the model in the background and some funny caching mechanisms, but this is a band-aid and not a proper solution. We’ve also gotten to the point where we have to limit the model for Mobile. This is currently done by creating a specific menu so it can load properly on a 3G connection. After all, loading a 50mb model is just not feasible. The size of the model will continue to grow in the future. Adding schedulers, maps and other components to the model will only increase the size of the model further. Furthermore, Indicium was also built to use the get-gui’s to load the model, but couldn’t care less about icons, form groups or screen types. Universal, on the other hand, doesn’t want anything to do with prefilter queries, file storage types and database connections, since this is all handled by Indicium. Time for change! We’ve revised the way the model is loaded for Universal, in concert with some changes for Indicium. We’ve split up the get-gui’s and replaced them with 3 different segments, called core, api and ui. The core segment is only used by Indicium to load information about the database and back-end logic. This part of the model is the same for all users. It is loaded on-demand by Indicium when the first user accesses an application. The api segment is loaded by Indicium for an authenticated user and determines which actions an authenticated user can perform. This is loaded on-demand by Indicium when the user logs in. Users with the same authentication profile will share this data. The ui segment contains relevant model information for the user interface, split up into different parts corresponding to visual components. Universal will load specific slices of specific parts, and only when it is needed. The current number of data sources and total columns available per segment. Data is loaded on-demand by Indicium and Universal. For instance, when the user logs in, Indicium will ensure the core model is loaded and the API model for this user is loaded. Universal will only load the active menu and the corresponding menu items. When the user clicks on a table, the table is loaded and the screen type for this table is loaded. If the screen type contains a form and a grid, form information and grid information is loaded for this table. When a slice of UI information has been loaded once, it will be saved for later. If the user opens the same screen again, this slice of the model won’t have to load again from IAM. If two tables use the same tasks, opening the second table will be faster since the tasks are already loaded. This way, a model with thousands of entities can still boot within seconds. Additionally, Universal doesn’t care about the order in which the model is loaded. When a screen is opened and the grid definition has been loaded, the grid will be shown while the form definition is still loading. Components will just wait to receive the model. Generally, this is loaded super fast (less than 1kb) and won’t be delayed very often, but it’s a robust way of dealing with shaky internet connections. Further improvements will be done to pre-fetch slices of the model. For instance, when the application loads we can start loading offline objects, start objects, entities used often by the current user, etcetera. When a screen is opened, we might as well already start loading the model for the details. Indicium loading speeds have also been vastly improved in 2018.3 because of these changes, but we’ll probably save this for another blog. Other accomplishments this month Displaying multiline data in the grid Improved usability of the login screen Active row change in the grid Improvements of the documentation Date and time visualization improvements Sidebar technical improvements On the next episode of Universal Development Update: Filter and prefilter component More form controls Breakpoints Lookups Navigation to details in the form of detail tiles

Some of our colleagues are currently working hard to create a Thinkwise community website, which includes e-learning, webinars, documentation and a forum. In preparation for this, we at Product Innovation have been busy converting the existing Word documents into a more consistent and reusable format: MarkDown. And because the Community site is not yet live, we have made the documentation available for now through our Office website. Check it out! Online Documentation The documentation is stored on our new Azure DevOps environment. Because MarkDown files are plain text files we can use the integrated GIT version control to easily make and review changes. Docusaurus is used to generate a website from the MarkDown files. Help us improve the docs!We have already done some serious sanitizing of the documentation to correct inaccuracies, supplement omissions and improve the worst steenkolenengels. Fortunately, our English teacher Rob will soon do a final check of the documentation as well. The coming period we’ll also be adding more documents and, of course, the upcoming 2018.3 features. In the meantime, if you see any errors or missing features, please help us improve the documentation by reporting a ticket via TCP. (Select the Documentation product!)

Hello everyone! Today we have another monthly status update for the new Universal GUI, the next generation user interface for Software Factory products. Architectural groundworkA lot of architectural groundwork and design has been completed for Universal in the last month, to ensure new features and concepts and performance improvements will be easy to implement. Indicium, the Software Factory and the Intelligent Application Manager all have had massive technical reworks to support all of this, all without affecting existing applications and GUI’s. A lot more under-the-hood design has been completed but this might go a bit too far for this blog. The key aspects are: Making life easier for the developer: Vertical scrolling strategies have been designed for screen types to prevent the need for tabs or pagination when components get too big. Strategies have been designed to change the screen type when the horizontal space becomes limited. We are attempting to get rid of all pixel-based settings in the form. Instead, have them be percentual settings. If you want two fields next to each other, you want them to be 50% and 50%, not (field_width + label width) / 2. Providing optimal performance: The way files are loaded and saved by Indicium has been reworked to make it easier for Universal to cache files and images. The files are transported in a binary format to provide less traffic than the current base64 counterparts. The way applications are loaded has been redesigned to prevent the need for mobile-specific models, using a strategy called ‘Lazy application loading’. More about this later in this blog. The loaded model can now be saved in the browser and can be reloaded when the user logs in again and the model and rights have not been changed or when the user accesses the application while offline. Future-proofing for new features: In the future, booting against the Software Factory or the IAM will be exactly the same from a client perspective. This means you can choose to run against the Software Factory without specifying the project, project version and runtime configuration and have them all available as ‘applications’. On contrast, you can configure Universal to load only a single IAM application. This is handy when you want to roll out multiple apps in the store that use a single model or if you really want the IAM to have a separate shortcut on the desktop. To capitalize on this, we want to allow developer to save user preferences (think grid column order, prefilters, cube views) straight into the model when running against a Software Factory. The way user preferences will be saved has been completely redesigned to support this. Completed features In addition to designing and developing a good foundation for the Universal GUI, the following features have been completed in the last month: Support for images in dataApplication switchingCard list Image Title Grid controls Image Image combo’s Text Date Time Datetime Numeric URL Email Phone Checkbox HTML Multiline Element combo’s Universal has also taken the first steps towards becoming a fully fledged Progressive Web App. You can now install the website as an app on your mobile device or install the website as a stand-alone application on your desktop. Neat! The form structure has been developed but have not passed QA as of yet. Most of the form controls have been developed and are waiting for the form structure to be completed. You can expect to see them in the next update. The visualization of an action bar has also been developed, but the actions themselves are not yet operational. A quick preview to see what this will look like: The buttons, they do nothing! Another feature that’s almost finished is lazy application loading. The current generation of user interfaces load the entire model on start-up. The Universal GUI will load only the bare essentials, such as the menu. The rest of the model will be loaded on-demand, for instance when a screen is opened. This allow access to massive applications without long start-up times and prevents reaching device storage limitations on start-up. On the next episode of Universal Development Update: Stuff that almost made it to this update, but will be included in the next update: Form & form controls More about lazy application loading A new HTML & multiline strategy for the grid New stuff we are working on this month: Placing components according to the screen type Filtering using prefilters and a filter input field Look-up translations Navigation to details in the form of detail tiles Once these features have been implemented, a future update will be focused around getting the action bar operational, providing data manipulation and corresponding application logic.

This is the first in a series of a monthly status updates for the new Universal GUI. The Universal GUI is the next generation user interface for Software Factory products. Using cutting-edge web-based technologies, the goal is to eventually rival and replace the existing Mobile, Web and Windows GUI’s. To be able to show anything to begin with, a lot of architectural groundwork has been done by the team to create the very basics of the Universal GUI. In addition, Indicium is being improved continuously to work seamlessly as mandatory back-end for the Universal GUI. The following features have been implemented up until July and are currently being tested and improved: Login page & logic Main application structure Application selection menu List bar Multi-document (above the list bar) Badges Grid (basic) Conditional layout Besides this, a lot of work is being put into the non-visual inner workings of the Universal GUI to ensure optimal performance and stability. On the next episode of Universal Development Update:The following features are being worked on and will most likely show up in the Universal Development Update – August 2018: Form Form controls Grid controls Images Card list Stay tuned!