Touch-Base Support

Photo editing applications

Dave Bhattacharjee — Fri, 20 Feb 2026 18:07:41 GMT

With Commander 1.13.0 (19th Feb 2026), we have added a "other' keystroke as a modifier for click and drag feature to cater for clean scrolling a canvas in any photo editor that uses space bar for fine scrilling, such as Photoshop and Affinity Photo, but probably others that do the same.

Under macOS we have gesture presets for both applications as well as a new preset for Photoshop in Windows.

On Windows we found it was important to have a preset, because Photoshop doesn't respond to native Windows touches.

The Photoshop preset makes it so that single touches perform mouse clicks so you can use Photoshop's tools with touches, and also sets it up so that two finger pinch/expand and two finger drag allow zooming and panning the canvas.

Other macOS and Windows photo editing apps may need to be configured the same within Commander for them to fully function with touch.

Microsoft OneNote

Administrator — Tue, 09 Dec 2025 13:35:14 GMT

In OneNote, to be able to ink in the drawing area, you need the One Finger Drag gesture for scrollable areas to be set to the Click and Drag action (overriding the default action which is scroll)
Since December 2025 we have been shipping Commander with an embedded application settings file to handle this.

If you have a Commander installation that pre dates December 2025 you will need to make this customisation manually.

You have two options: Import the customisation file or configure the custom setting manually.

Option 1 - Import the customisation file

Download the OneNote.ucapp file.

Open Commander Settings from the Commander menu in the mac title bar and from the application menu choose File, Import Application Settings.
Then browse for the ucapp file you just downloaded and click Open
If OneNote was not already in your list of applications (because you installed it since installing Commander) It will now appear in your list of applications with the correct gesture action defined.
If it was already in the list you will be asked "Replace existing application?" to which you should choose Replace.
You now have the necessary gesture action set to draw within OneNote

Option 2 - Configure the custom setting manually

Open Commander Settings from the Commander menu in the mac title bar

Under the list of applications on the left, if OneNote is not already listed, choose the + icon drop down and choose Add New Application (as detailed here) . Then pick OneNote from your mac's list of applications and click Open
It will now be added in your application definitions list.
Now select OneNote from the list and expand its options with the > icon and select Scrollable areas
Change the action on One Finger Drag from scroll to Click and drag.

You now have the necessary gesture action set to draw within OneNote.

Move Window action

Dave Bhattacharjee — Thu, 06 Nov 2025 17:47:02 GMT

The UPDD Commander uses an Accessibility framework provided by Apple to move windows, and unfortunately this does not work on some of Logic Pro's windows.

This is the only method of moving windows that an app like UPDD Commander can use, so if it doesn't work, there's no realistic alternative.

iOS emulation

Dave Bhattacharjee — Tue, 04 Nov 2025 15:48:42 GMT

Commander version 1.10.0 (4th Nov 2025) ships with a new preset for the iOS simulator, whose application name is simply "Simulator"

The Application is automatically added into Commander's application list if Xcode + the simulator is installed.

This utilises the new "Pass Two Finger Gestures to iOS Simulator" gesture action.

By default, the app will visually show the performed dual touches within the simulator (grey blobs).

However, there is a setting in the Simulator for disabling this visual feedback. Pick the menu Simulator > Settings and then uncheck the box "Show pinch gestures".

Unfortunately, it's not possible for Commander to accurately send two finger gestures into Simulator due to its limitations with how it allows two finger gestures to be performed.

Given this 'accuracy' issue, it is possible that gestures will cause the two touches to reach the top and bottom of the screen even if the touches are not positioned there, which can trigger the Notification Center or cause the simulated phone to go back to the home screen.

Therefore, it can be helpful to show the position of the gestures to see precisely how the gesture is being performed within the Simulator.

Generally, you'll get the best results performing gestures in the centre of the simulated screen.

Widgets - right click

Dave Bhattacharjee — Thu, 16 Oct 2025 19:31:52 GMT

Touches that fall inside of a desktop widget are considered part of Notification Center, which is set up to have a "one finger press" gesture do a normal click and drag.

The intent is for users to be able to rearrange widgets, since normally in the Notification Center dragging with one finger would scroll it rather than doing a click and drag, and this way it works somewhat similarly to iOS.

If a right click is needed, either change the "One finger press" gesture in Notification Center to right click, or use a different gesture, such as "Press and tap" to perform the right click.

UA LUNA

Dave Bhattacharjee — Wed, 06 Aug 2025 19:27:40 GMT

Click based actions stopped working in an updated version of this macOS application, but we discovered that using an old, previous method of generating click, reinstated click processing for this app.

In the Advanced option of the Click actions, select 'Use legacy method for creating mouse clicks' to invoke the alternative method.

UPDD API Clients

brian@touch-base.com — Tue, 05 Aug 2025 22:30:19 GMT

Starting with UPDD Commander 1.6.0, it is possible to configure it to interact with other UPDD client applications such that only desired gestures will control the client application, while other gestures will still be handled by Commander itself.

The first step is to add the application into the application list. Then, there are two ways to proceed depending on whether the app will handle all touches on its own or just certain gestures.

The client application handles all touches

If the application is expecting to handle all touches and you don't want Commander to perform any gesture processing for touches that fall within the app, then you can simply add the "Pass all touches to UPDD client app" gesture:

That will override all other gestures, and no further configuration for the app is required.

Maintaining gesture processing with the client application

If you want some gesture processing with the client application, then edit its gestures so that some of them are configured to the action "Pass touches to UPDD client app". When performing gestures assigned to that action, touches will be received and processed by the client application. Note that there may be a slight delay (usually in the order of tens of milliseconds) for Commander to detect the gesture before the client application will receive the touches.

If the gestures are inherited, then you need to add them directly to the application before you can change their action. (A shortcut for this is to double click the inherited gesture.)

This way some gestures can retain their functionality, for example default gestures used for showing the Notification Center or the Smart Magnifier, while other touches will be processed by the application itself. In this case, you can either set the application not to inherit gestures from "Default Gestures" as described above and then create only the set of gestures you want to apply to this application, or set it to keep inheriting gestures, but add the gestures you want to only be handled by the application and set their action to "Pass touches to UPDD client app". This way, the gestures defined for the application itself will override Default Gestures.

Expiried Licence key support

Dave Bhattacharjee — Mon, 30 Jun 2025 11:49:53 GMT

When UPDD driver licences are purchased, you are entitled to lifetime usage of the software with the release of the software purchased at the time.

The driver comes, by default, with 3 months support (maintenance and software upgrades) but at the same time as purchasing a driver licence, you can also opt to purchase extended support for 1, 3 or 5 years, that allows you to upgrade your software to the latest during the support period.

Notification 'Licence support expired' indicates the support on your Licence key has expired.

If you subsequently download and install the latest software on a system running a licensed version, the installer checks the release date of the software being installed against the licence key support expiry date.

If the release date is after the expiry date, you are not entitled to the upgrade, and it issues this notification (this prevents an evaluation version of the driver being installed over a licensed version)

You can of course use the driver you purchased with the licence (it may or may not work depending on the age of the driver) or purchase an upgrade at 50% of the current licence fee. This will come with 3-month support and allow you to use the latest software. You can extend this support period for 1 year @ 10% of the current licence fee, 3 years for 20% and 5 years for 30%.

Please visit https://portal.touch-base.com/purchase/extendto extend the current licence key using our online purchase form.

You will be asked to enter the licence key. The email address entered on the form must match the email address associated with the key.

Lightkey

Dave Bhattacharjee — Thu, 01 May 2025 15:14:44 GMT

A customer reported that using a single finger to move sliders they needed to move the finger in the opposite directing to get the slider movement, down for up, up for down

UPDD Commander tries to determine the application and UI element over which the gesture is being performed

In the case of Lightkey we believe it reports parts of its application UI as being a scrollable area (even though it isn't!) so Commander is deciding to use a scroll action when touching in those areas rather than a click and drag. Scrolling often goes in the reverse direction of the gesture, since scrolling down moves the contents up and vice versa. If you change the gestures to just always use click and drag for Lightkey it should work properly, such as on sliders, so long as you're only using one touch. Multitouch is not supported by Lightkey under macOS.

To overcome the scroll issue, we suggest Lightkey app is added in to the lefthand application list and change the One finger drag from Scroll to Click and Drag, as shown below. The user confirmed this worked.

Add New Application, expand and highlight Scrollable areas, double click on One finger drag and change the action:

Python scripts

brian@touch-base.com — Wed, 12 Mar 2025 15:03:17 GMT

Python scripts can utilise the UPDD API using the ctypes library. To that end, we've provided upddapi.py, which provides definitions for the UPDD API's important constants, structures (such as _PointerEvent) and functions, as well as a few convenience functions to help common use cases.

Generally, the UPDD API works the same in Python as it does in C or C++. There are a few Python specific caveats regarding callback functions, such as those passed to TBApiRegisterEvent:

Callback functions will be executed in a dedicated thread managed by the UPDD API. We recommend using Python's threading or asynchronous libraries to process events in a Python-controlled thread.
Be aware that pointers to a C structure passed to callback functions are not guaranteed to remain valid after the callback function finishes executing. It's best to make your own copy of that structure for further processing, since it will remain valid as long as Python has a reference to it.

upddapi.py provides two convenience functions to help mitigate the above issues:

create_event_callback: This returns a ctypes callback that can be passed to TBApiRegisterEvent. It takes as its only argument a Python function with two parameters: the event type, and the event itself. This automatically handles copying the pointer provided by the UPDD API into a _PointerEvent ctypes structure whose memory is managed by Python normally.

create_event_callback_async: This is the same as create_event_callback, but instead you pass it an asynchronous function, for scripts that use Python's asyncio library. It has one optional keyword argument event_loop, which specifies the event loop that the asynchronous function will be called in. If it's not provided, then the current event loop is used.

Here is a simple script demonstrating the use of upddapi.py with Python's asyncio library to process digitiser events safely in Python's main thread.

Prevent HID driver blocking UPDD from accessing a device

Dave Bhattacharjee — Thu, 27 Feb 2025 11:23:49 GMT

Issue: Touch was working OK until monitor power is removed such that the touch device powered down. The touch device was re-enumerated when powered on again, it appears that the built-in HID driver has taken control of the device. When UPDD tries to remove this 'system HID' device to gain access, it fails for some unknown reason.

Possible solution: The instruction here may help in this situation:

https://stackoverflow.com/questions/51858074/preventing-usbhid-from-claiming-device

The aim is to prevent the built-in HID device driver taking control of the device when the USB stack is re-enumerated after the power event, as this will allow UPDD driver to access the device.

Firefox UI Element bug

Dave Bhattacharjee — Wed, 22 Jan 2025 19:14:38 GMT

At the time of writing, 2nd Jan 2025, Firefox has a bug that prevents UPDD Commander from being able to detect its UI elements during a gesture.

This bug applies when the following conditions are met:

The touch screen being used is not the main display for the system
The touch screen is not a high DPI display
The main display is a high DPI display / retina display

Since the above three conditions are likely to be the case when using a touch screen as an external monitor on a Mac, especially a iMac or MacBook, we can't currently suggest using Firefox in cases where you need to be able to customise gestures depending on which of its UI elements are being gestured over.

Safari, Chrome, or another Chrome-based browser are better tailored for gesture use.

URL UI Element definition

Dave Bhattacharjee — Wed, 22 Jan 2025 18:09:42 GMT

This feature was introduced in UPDD Commander 1.9.0

When adding a UI element to an application or app group in Commander that contains a web browser, or adding to Default Gestures, there's now the option to add a UI element corresponding to a webpage. This allows customising gestures that occur within a specific webpage.

There's are a few options on how to specify the URL:

A partial match: You can enter part of a URL like “touch-base.com” or “touch-base.com/support” and if Commander finds that in the browser's URL, then it's a match. You can also use an asterix (*) as a wildcard, such as “*.touch-base.com" or “website.com/*/info”
A full match: If you include “https://” at the beginning, then Commander will only match the full URL. Wildcards are allowed here too. In this case “https://touch-base.com” would only match the main page of the touch-base website, and not, for example, “https://touch-base.com/contact”. However “https://touch-base.com/*” would match “https://touch-base.com/contact”, but not “https://support.touch-base.com”
A regular expression: if the text is in between two forward slashes, such as /pattern/ then it's interpreted as a regular expression. No need to describe those here, as they're well documented all over the web.

In cases where there are more than one webpage defined for an app and the current page matches multiple, Commander decides which one to use based on its specificity.

The order of precedence is:

A regular expression
A full match without wildcards
A full match with wildcards
A partial match without wildcards
A partial match with wildcards

As standard, we support the following web browsers: Safari, Firefox, Chrome, Opera, Brave, Ungoogled Chromium, Vivaldi, LibreWolf, Orion, and Safari Technology Preview.

The first time a user gestures over any Chrome or Safari based web browser (basically all of them except Firefox and LibreWolf, or any other Firefox-based browser), Commander will prompt for permission to automate those apps. This is so that Commander can directly request the browsers to report their current URL. This only needs to be done once per web browser. It's not needed for Firefox and its derivatives, because it doesn't support the automation features Commander is using to get its URL (and so Commander has to use a less reliable method, albeit one that doesn't require extra permissions).

If this prompt does not appear, this command will likely suffice: tccutil reset AppleEvents com.touch-base.upddcommander

Please note that in some monitor layouts, Firefox has a bug that prevents Commander identifying UI elements within the browser.

However, there are more browsers than specified above, so in cases where this feature is to be tried in a different one, there is a UPDD global setting that can be used to specify more:

upddcommander.applicationsettings.extra_web_browser_ids

This can be set via the UPDD Command line utility, using the syntax ; upddutils global set [setting name] [setting value]

This setting can be set to a comma or colon separated list of browsers. Each item in the list is the browser's app application's bundle ID (e.g. such as com.google.Chrome) followed by an equal sign, and then one of the following three words: chrome, firefox, or safari, to specify which browser it's derived from.

An example, the setting value would be something like:
com.company.browser=chrome,org.organization.OtherBrowser=firefox

There is no guarantee that Commander will work with an added browser. However, it will allow adding a webpage to the added browser, and Commander will attempt to get the URL, but it may fail and adding support would require further development.

Example

A web site is using a signature page that requires a One Finger Drag performs a click and drag action, but other pages on the web site require One Finger Drag to perform the Scroll action.

To ensure the signature page works as expected, we can add the URL into the Browsers group

The UI element will inherit the standard set of Gesture / actions that can be adjusted as required:

allowing the signature to be entered via touch

MP Controllerbyte

Dave Bhattacharjee — Thu, 16 Jan 2025 15:32:40 GMT

An MP ControllerByte device is a specialised touch monitor with analogue controls used with DAW applications and plugins.

The UPDD driver can offer additional touch functionality to that offered by default drivers.

The driver is available for Windows and macOS, delivered as .exe or .dmg files respectively.

You simply run the installation files and follow the instructions.

With macOS security considerations, during install you must grant permission to UPDD Commander to allow access to the system and, since macOS 10.13, manually 'Allow' our software to install in Security and Privacy section.

In multi-monitor environments, you may need to make the association between the touch screen and the MP Midi device by running the UPDD Identify procedure.

For specific installation instructions, please refer to the macOS and Windows Quick Installation Guides.

Home Assitant

Dave Bhattacharjee — Wed, 15 Jan 2025 17:43:33 GMT

The onscreen keyboard is not activated when touching in a text field.

Home Assistant does not correctly report the focused UI element using Apple's Accessibility features. When a text field in Home Assistance has keyboard focus, the Accessibility API does not report a UI element with the role “text field” or “text area” as having focus, but rather a generic group. This prevents Accessibility-enabled tools from being able to detect when a user might need assistance typing into a text field.

JUCE Applications - DAW plugins

Dave Bhattacharjee — Mon, 02 Dec 2024 18:27:03 GMT

JUCE is an open-source cross-platform framework for developing applications and plug-ins, especially for DAW applications. While it has built-in support for multi-touch on operating systems that have native touch support, such as Windows or iOS, it doesn't currently support multi-touch on macOS. Consequently, we've made an addition to JUCE that implements multi-touch on macOS for systems that have installed the UPDD and submitted it as a pull request to the JUCE GitHub repository. We hope that the JUCE development team will eventually incorporate these changes into the library officially.

In the mean time, it's fairly simple for a JUCE developer to include these changes in their application or plug-in. All that's necessary is changing a few files in JUCE's source code. This can be done by applying a patchfile to your local JUCE installation, or by checking out the pull request from the JUCE GitHub repository.

Afterwards, if you're running UPDD Commander, you'll need to configure it to skip gesture processing for touches that fall within your application and instead pass the touches along directly.

More information is available in the JUCE integration document, including showing how to configure JUCE based DAW plugins with UPDD Commander.

Commander won't load

Dave Bhattacharjee — Tue, 26 Nov 2024 02:05:14 GMT

Very occasionally, Commander won't load.

This could be caused by a corrupt component or bad installation, in which case a reinstallation may resolve.

However, sometimes it is useful to run Commander from a Terminal Window to see if any errors are issued that are preventing it from loading.

This command, including the quotes, can be used to invoke Commander

"/Library/Application Support/UPDD/UPDD Commander.app/Contents/MacOS/UPDD Commander"

Client App Considerations

Dave Bhattacharjee — Tue, 15 Oct 2024 21:30:02 GMT

In most cases, where a UPDD Client application is responsible for touch control, it is likely to be the main/or only client handling the touch interface.

However, in cases where two or more client apps want to process touch, it is important that there is a degree of co-operation between client apps, so as to avoid touch conflicts between competing applications.

In most cases, with UPDD software, the clash will be between UPDD utility applications themselves or the user client app and the UPDD utility client applications.

To avoid the clash with the various UPDD utility applications; Commander, Annotate and Test, we utilise an internal priority system and the driver delivers touch data to the highest priority app.

In the case of the UPDD client apps, the highest priority is Test, followed by Annotate and then Commander. If none of these are loaded, the API is delivered to all user client applications.

However, in systems where UPDD Commander is utilised, this means that there is always a UPDD Client app taking priority over any user written apps as it is always active, and will only stop processing touch if Test or Annotate are running.

To cater for this situation, such that User client apps are not blocked from receiving touch data whilst Commander is active, we have introduced a mechanism whereby an application can instruct Commander to pass through touch data to the application.

This is configured within Commander as follows:

Use the 'Add New Application' option to add the UPDD Client App into the Application list.

In this example, we selected and added an Application called Flexi-deck, as listed in the Application list:

Now add the special 'All Touches' item to instruct Commander to pass through all touch data to the application:

If you would also like the standard Commander gesture/action processing to be active within your application, select the 'Alongside Gesture' option above. You can tailor the inherited set of gestures / actions as required by your application.

At this point, the client app should receive touch data.

To avoid having to perform the above with each install, you can save the application to a preset file.

This file can then be either loaded from the Commander file menu, Import Application Settings... (as seen above) or, if you receive a branded or tailored driver from Touch-Base, passed to us for inclusion in your software build.

When included in a driver build, the preset will be automatically loaded by Commander if the application is found on the system at install time, or can be loaded manually from the Commander file menu.

Touch Programing Considerations

Dave Bhattacharjee — Thu, 15 Aug 2024 14:00:05 GMT

When programming touch within an application that is potentially running on a system with other touch based applications, it's possible for conflicts to arise.

For our own utility touch applications, that could all be running at the same time, whereby it makes sense that only one application should be processing touch at any given time, we use an undocumented internal priority setting, such that the one with the lowest priority gets exclusive access to UPDD's API.

We have allocated UPDD test to be the highest priority, followed by our Annotation program and then UPDD Commander.

Currently, this setting is for internal use only, but if either of these three applications are running, it will block touch events being sent to other client applications.

Given that most macOS touch systems utilise UPDD Commander, most conflicts can occur between Commander processing touches and end user touch client apps.

In this case, you need to consider if Commander is required in your environment, or if you need to configure your touch application within Commander to avoid duplicating touch processing whilst touching within your application.

If standard gesture processing is not required within your application, you can either:

Use a software build that does not contain Commander.
Stop Commander and /or prevent it from automatically starting at system boot up.
Disable Commander processing using the 'Master kill' global setting in the settings dialog, available since version 1.7.0, issued 23rd Aug 2024.
Remove all gesture processing definitions within Commander and replace it with a single “Pass all touches to UPDD client app” gesture.

If Commander is required for other system and application touch processing, then Commander must be configured to cater for specific touch applications and to pass touch events to the Application.

In this situation, you can add your UPDD Client application to Commander and associate a “Pass all touches to UPDD client” gesture to the application, so that all touches that fall within the application get passed along to it via the UPDD API.

This allows for any touches/gestures outside the application to be processed as normal by Commander.

When configuring and application in this way, you should be mindful of which UI elements are configured under the application in Commander and set up gestures in those as appropriate. You may, for example, want to keep the default gestures in Commander so that touches will scroll a scrollable area as is the default behaviour, or you may want to remove all of those gestures and just assign “Pass all touches to UPDD client” for all UI elements as well.

Custom Touch Controls

If an application, or parts of an application UI, is implementing custom touch controls, it is important to consider that external generic touch mouse emulation software is not active on the custom control at the same time as the application is also handling the touch. When using UPDD software, the UPDD Commander function can be used to disable touches being processed on top of specific applications or UI elements within the application such that external touches do not interfere with custom touches within the application.

Managing Licences

Dave Bhattacharjee — Fri, 07 Jun 2024 09:30:58 GMT

In cases where licence keys are used to register the software, the licence key will reside on our Licence Server and be associated with the system where the licence is used.

In most cases, a licence key is configured to be used on one system, but they can be set to work on multiple systems.

Given that a licence key is associated with a system, it needs to be released when it is no longer required as described here, such that it is available for reuse.

In cases where system administrators need to manage numerous licences across many systems, we offer the facility to create a user account on our licence server to help manage the organisation's licences.

You can create an account, and subsequently login, at the Licence Server login screen:

Use the 'No Account, Register here' link to create an account, as per this example:

You will now be sent a verification email to verify your account:

Once you verify the account, you will be logged in and shown the licence keys associated with your email address.

Where an email is used, that is not associated with your licence keys, or your you need additional email accounts to manage the licences, we can associate those emails with the company name associated with the licence keys.

It is therefore important that your organisation's licence keys be created with the same company name if multiple accounts are used to manage the licences.

Your licences are displayed as follows. This listing shows 5 individual licence keys associated with order TB30921.

In this example, there are individual licence keys. However, a single licence key and be configured to be used in more than one system, in which case you will see a single key that when selected will show the key and its status for each instance.

The Registration status column indicates if the licence key is unused (Waiting registration) or used (Active).

Usage statistics are shown in the status panel with the option to copy unused keys to the clip board or create a spreadsheet showing licence usage, as in this example:

Within the licence listing, you can select the 'updd' link to show details of the licence key and use the 'unlock' option if the key needs to be unlocked from the system.

In this example, the licence key is in use on system nnnnnnnnnnnnn, as listed in the spreadsheet:

JUCE macOS Applications and Plug-ins

brian@touch-base.com — Wed, 08 May 2024 16:11:53 GMT

Afterwards, if you're running UPDD Commander, you'll need to configure it to skip gesture processing for touches that fall within your application and instead pass the touches along directly.

Obtaining the code changes

Option 1: Applying the patchfile

Download and unzip the patchfile from here
Move it into the root of your JUCE directory. This is the directory that contains the "modules" subdirectory.
In a terminal window, change the current directory to your JUCE directory and then apply the patch:
cd /path/to/your/JUCE
patch -p1 < updd-multitouch.patch
Clean and do a full rebuild of your project

Option 2: Checking out the pull request

If you've installed JUCE from its official git repository, you can check out Touch-Base's pull request into a separate branch by executing the following terminal commands:

cd /path/to/your/JUCE
git fetch origin pull/1382/head:updd-multitouch
git checkout updd-multitouch

Afterwards, perform a clean and full rebuild of your project.

Option 3: Applying the changes manually

The latest changes to JUCE can be obtained from Touch-Base's fork of the repo, in the updd-multitouch branch, available here: https://github.com/Touch-Base-Ltd/JUCE/tree/updd-multitouch

These changes include modifications to two existing JUCE source files, and the addition of two new source files. The two modified files are:

modules/juce_gui_basics/juce_gui_basics.cpp
modules/juce_gui_basics/native/juce_NSViewComponentPeer_mac.mm

The two new files are:

modules/juce_gui_basics/native/juce_UPDDMultitouch_mac.mm
modules/juce_gui_basics/native/juce_UPDDMultitouch_upddapi.h

At the time of this writing (8th May 2024), these files are based off of the latest commit to JUCE's develop branch, commit eac95d59. If your JUCE source tree is based off of that commit or the above two modified source files are compatible with it, then you can copy these four files into your JUCE source tree, or copy in the two new files and manually edit in the changes to the two modified files manually. We recommend applying the patch file, though, since it should only apply in cases where the affected code has not been changed in a later commit.

Hardened Runtime and App Sandbox

Because connecting to the UPDD requires both loading a third party library and establishing an inter-process connection, in order for multi-touch to work in a JUCE application, it needs to grant itself certain permissions if Hardened Runtime or App Sandbox are enabled.

With App Sandbox enabled, be sure to grant your application permission for "Outgoing Connections (Client)" so that the app can connect to the UPDD.

With Hardened Runtime enabled, grant your application the runtime exception "Disable Library Validation" so that it can load functions from the UPDD API dynamic library.

Configuring UPDD Commander

When using UPDD Commander, it's necessary to configure it to send touches to your JUCE application or plug-in, so that it can process them directly. Currently this must be done manually, but we hope in the future to make this sort of configuration unnecessary by having UPDD Commander automatically detect UPDD clients, including plug-ins running in a host DAW application.

JUCE standalone applications

For a standalone application, configuring UPDD Commander to send touches to it is fairly simple. Click the + button underneath of UPDD Commander's list of applications and pick the menu "Add New Application..." Select your application to add it to the list, and then make the following two changes to it:

1. Click the + button under the list of gestures and select the menu All Touches > Pass all touches to UPDD client app. This special gesture configures UPDD Commander to pass any touches that occur within the application directly to that application, skipping gesture processing.

2. With your JUCE application selected in the lefthand list, click the gear icon below the application list, and then check the box "Inherit UI element gestures before [app name] gestures". This will allow touches that fall within any UI elements configured under "Default Gestures" to continue working as before, such as menus, window title bars, and system file dialogs. This is important because these UI elements will not respond to JUCE touch events, so when the user touches them, UPDD Commander will need to process gestures and produce mouse clicks that can interact with them.

JUCE plug-ins, such as VST3 or AU plug-ins:

When a JUCE plug-in is running inside another application, such as Logic Pro or Pro Tools, it can be trickier to set it up so that it will receive direct touches without interrupting touch functionality in the host application. Generally a host application will still need UPDD Commander to process its touches and convert them into mouse clicks, keyboard presses, and scrolling.

Each host application will have different requirements, but the general method is to add the host application to UPDD Commander, and then add a new UI element to it that will match the window that contains the UI for your JUCE plug-in.

To do so, add the host application to UPDD Commander using the + button below the list of applications, select your application after it's added, and then use the + button again to add a new UI element to the host application. Set it to "Specific UI element":

Then click the "Select UI Element" button, and move the mouse cursor over the window that contains your plug-in's UI. It should hopefully highlight just the area for your plug-in. (This may not work in certain applications, though it has been tested in Logic Pro and Pro Tools.)

Press the return key to select that UI element, and then click OK in the dialog box for adding a UI element. Now that the UI element has been added, give it a descriptive name (such as "MyPlugin window") and then give it a single gesture: click the + button beneath the list of gestures and select "All touches" > "Pass all touches to UPDD client app".

Slate / Raven systems

Dave Bhattacharjee — Wed, 03 Apr 2024 19:14:48 GMT

The Slate hardware is utilised to run the Raven software that is supplied with a tailored version of UPDD.

In cases where the system using a Slate touch console also needs to support additional touch monitors, a separate driver will be required that supports all the connected touch screens.

A license key will be required for this custom driver as it's not covered by the Raven UPDD license.

The Raven software processes touch from the UPDD TUIO server and by default all touches from all touchscreens will be delivered to the Raven software so its likely that any additional touchscreen should be excluded from the TUIO server configuration.

To achieve this you need to check the "Configure TUIO servers separately for each device" check box and select "Relative to display, dividing X axis evenly..." in the TUIO gesture advanced options.

Thereafter, you need to assign each display you want to trigger TUIO touches to use the host localhost and port 3333, and uncheck the box next to the devices you want to disable.

Commander should now only generate TUIO touches for the displays that are checked (and used by Raven), and divide up the X-axis as though the unchecked displays weren't there.

e.g. if there are three displays total, and you uncheck one of them, it will divide the X-axis in half (not into thirds) for the two remaining displays.

Contact support@touch-base.com for more information.

Specialist builds

Dave Bhattacharjee — Wed, 03 Apr 2024 19:08:24 GMT

Our driver has been adopted by a number of touch based systems that utilise a tailored driver and/or specific functionality to implement touch support.

However, in some cases, users may find it desirable to add additional touch monitors to these systems and in doing so may need to consider the implications when doing so.

This document attempts to highlight some of the specilist builds and the issues that can arise.

Build debugging

Dave Bhattacharjee — Mon, 25 Mar 2024 15:25:11 GMT

Gary added this in WebTBA3 Marc 2024 whilst investigating a maxOS build issue...

This was a scripting issue and difficult to track as we didn’t have a good script debug environment.

We had this in the old tba (release with debug option) but this could not be directly supported in webtba and was never supported as we haven’t needed up until now.

I’ve now implemented something equivalent. If any job fails it can be re-run in debug mode by running the debug script in the corresponding tempo channel folder.

E.g. if a job fails in channel 7

Then open an admin command prompt and run d:\config\v6\temp\007\debug.bat

I doubt you’ll ever need to do this, but just in case!

ProPresenterand video control apps

Dave Bhattacharjee — Thu, 21 Mar 2024 19:42:35 GMT

Generally UPDD Commander assumes that a touch screen is acting as a normal display for the system that's running it, in that the screen is displaying the windows and desktop of that system and that any touches on the screen will correspond to a specific application and window. It then allows defining a set of multi-touch gestures that can be configured on the basis of a specific application or one of the UI elements in that application's windows.

However, some applications, for example ProPresenter, output a video feed to an external monitor for the purposes of displaying a presentation. When using a touch screen to display and control a video feed like a presentation, it wouldn't be desirable for UPDD Commander to associate those touches with an application on screen and perform different gestures depending on where the touches landed, as the screen isn't displaying any applications. In such a case, you'd want there to be only one set of gestures that always apply and control the presentation.

To configure UPDD Commander to do this, open its Settings window, and in its "Touch" section remove all the applications listed in the left-hand list so that only "Default Gestures" remains:

Then click the expander arrow to the left of "Default Gestures" to expand all of the UI elements that have been configured for it: (e.g. Scrollable areas, Menus and menu items, Menu items with submenus, etc.)

Remove all of these UI elements so that the only item left in the left-hand list is "Default Gestures" and nothing else.

Then click "Default Gestures" to select it, and remove all of the gestures in the right-hand list, so that the right hand list is empty.

Once this is done, there should be no items in UPDD Commander's "Touch" section other than Default Gestures:

Now you can add gestures to "Default Gestures", and they will apply consistently no matter where on the touch screen you touch.

For example, you can add gestures for "One Finger Swipe Left" and "One Finger Swipe Right" and assign them to press the left and right arrow keys respectively, so that you can use touch gestures to control your presentation:

However, if you use "Keystroke" actions to try and control the presentation, there is an important setting to change for those actions so that UPDD Commander will not try to switch the current application when you perform the keystrokes.

By default, "Keystroke" actions are configured to raise whichever window you performed the gesture over so that the window is frontmost and has keyboard focus before typing the keystroke. This is normally desirable when a touch-screen is acting as a normal display, since otherwise the keystrokes might not be received by whichever window you gestured over. However, when the touch-screen is being used to display a presentation, you don't want the focused window or application to change. So to configure these keystroke actions not to try and raise any windows, click on the "Advanced Options..." button for each of them, and uncheck the box that reads "Focus window under gesture before performing keystrokes":

With these gestures and settings in place, you can now use gestures on your touch screen to control your presentation.