Project Upgrade Guide

This guide is intended for users with previous knowledge about projects in the product and want to
convert them to this version.
When opening a project it is automatically converted to this version with the exception of scripts.
Since scripts enable a very high level of freedom it is not possible to automatically convert them.
It is recommended to follow the option to back up the old project when opening it in this version
before the project is upgraded.

Installation
The installers are now single setup files and hold all prerequisites needed to run the installation.

Windows 8.1 and Windows 10

Windows 8.1 and Windows 10 are now supported operating systems. On Windows 8.1, desktop
mode is automatically enabled during installation. This setting can be manually changed from the
Taskbar and Navigation properties dialog, in the Start screen property group, under the Navigation
tab. The Taskbar and Navigation properties dialog can be reached by right-clicking on any open area
in the taskbar and clicking the Properties menu item.
On Windows 8.1 and Windows 10, the .Net Framework 3.5 is an operating system feature that needs
to be enabled. The installer will automatically detect whether .Net Framework 3.5 is to be installed
or enabled as a feature.

Windows XP Support Removed

Beginning with this version, Windows XP is no longer a supported operating system.

API Changes when scripting

There is a separate document for changes in the API. See this separate document for changed names
of namespaces, classes, interfaces, methods etc. Entities that have been removed, added or changed
are listed per assembly in this document.
When opening an old project you will get the option to let the application try to automatically
change the most commonly used classes and namespaces that have changed between versions in
your scripts. There can still be some using statements and classes that you manually have to take a
look at to get the project to build.

Code Generation of Tags

Tags are now generated as public fields instead of properties (in Tags.cs). This change was made to
reduce the amount of generated code and thereby improve the performance and lower the memory
consumption. If you use reflection to get tags you will have to use the method Type.GetField instead
of Type.GetProperty.

Database
The supported database is SQLite. Upgraded/converted projects will by default be changed to SQLite.
When converting an old project all recipe data and data logger data will be kept both in designtime
and on the target unless changes have been made in the recipe structure at the same time such as
adding or removing a recipe item. Just changing data values in a recipe will not result in data loss.
Recipe data is not stored in a database in designtime anymore. Instead the recipe data is transferred
to the target, and the database on the target is updated if needed at first startup of project which
then might take longer time than normal. This makes it possible to change a recipe without deleting
any existing recipes when transferring the project to the target. The same applies for data loggers,
changing the configuration of one data logger doesn't affect the other data loggers and recipes.
The database supports automatic reuse of an internal backup of the database if the loading of the
database fails at startup. The backup can be created at startup and/or at any time via a new action
called Back up all databases for recovery. You can let the project automatically back up the database
at startup in Project -> Settings -> Database.

Screen Cache
To decrease screen switching times it is now possible to cache the screen in memory while not
shown. The default behavior is that the screen is being cached when closed. A screen can be marked
as a screen that should not be cached when closed. When a screen is cached its internal state is
preserved, hence scripting variables will keep their values. The next time the screen is shown these
variables, objects etc. will be in the same state as when the screen was closed. If this behavior is
unwanted there are two options:
1. Uncheck the Cached property on the General tab for the screen. This will cause the screen to
close and dispose in the same way as before. The screen will be created from scratch each
time it is opened.
2. Hook up event handlers to the open and close event for the screen. In these handlers it is
possible to initialize and reset variables, timers or any other stated objects.

Function Keys
Enabling function keys in previous versions of the application resulted in a full set of function keys
mapping for each screen in the project, regardless if they were configured or not. Now the user must
explicitly add a function key configuration for each screen where this is desired. This improves
performance. In order to take advantage of this in a project created in an older version the following
manual options are available:
1. Delete the function keys function and add it again. This way all old configurations will be lost.
2. Manually delete unwanted configurations.

Passive Value Change Event

The difference between ordinary value change event and the passive is that the passive will not set
the tag to be active. The passive event will only fire if the tag is active, hence the tag can be
deactivated if not in use by anything else. When the tag is deactivated the passive event will remain
idle until the tag is activated.

Rendering Transparency
The new rendering strategy analyzes the visual stack of elements to determine what elements can be
rendered without transparency and hence avoid the extra performance cost. This is done by
analyzing several properties and checking for intersecting elements deeper in the visual stack.
This automatic analysis can be overridden through the property grid by checking the Force
Transparency checkbox.
Examples of when using the Force Transparency checkbox might be required:

When a background screen has elements that are used in multiple screens that in turn
override the background color.
When move/size dynamics are used on elements that during their transformation end up
intersecting a deeper element.