IMDTouchKnowledge BaseShop main store

How-to

Run an HMI application touch-only in forced full screen

HMI and touchscreens Published 6 min read

Short answer

Enable the built-in on-screen keyboard with System.OnScreenKeyboard = 3 so page and popup-dialog entry both work by finger, and launch the runtime through a shortcut whose Target field ends in the -f switch to force full screen. Because -f cannot be exited in-session, keep a second shortcut without it for development, and pass every page and entry field by touch before removing the keyboard and mouse.

On this page
  1. Set the on-screen keyboard to cover pages and dialogs
  2. Size pages for fingers, not for the mouse pointer
  3. Launch full screen with the -f switch
  4. Build the touch-only launch
  5. Read the results before you trust the setup
  6. Questions asked

A machine interface can run with no keyboard, no mouse, and no operator hunting for a full-screen key. On a DAQFactory runtime two settings do the work: the script line System.OnScreenKeyboard = 3, which turns on the built-in on-screen keyboard everywhere the application accepts entry, and the -f command-line switch in the launch shortcut, which opens the document full screen. -f cannot be left from inside the session, so keep a second shortcut without it for development, and pass every page and entry field by finger before the physical input devices come off.

Set the on-screen keyboard to cover pages and dialogs #

Entry happens in two kinds of places: directly on a page, and in the popup dialogs the application opens for value entry. The System.OnScreenKeyboard script variable controls both locations, with four documented values:

Value Where the keyboard appears Fit
0 Nowhere A physical keyboard is always present
1 Page entry only Every operator field sits on a page
2 Popup dialogs only, not user popups Entry lives only in the built-in dialogs
3 Page entry and popup dialogs Touch-only operation using both locations

Put the assignment in script that runs when the document starts, so every session begins already configured:

System.OnScreenKeyboard = 3

Mode 3 carries one documented limit: it enables the main and system-popup keyboards, but it does not make user-created popups accept the built-in keyboard. Any popup you built yourself needs its own input method or its entry moved onto a page; test each one with a finger instead of assuming the mode covers it.

Decision: for a touch-only interface that enters values on pages and in dialogs, set System.OnScreenKeyboard = 3 at startup and treat a user popup that refuses the keyboard as a layout problem, not a setting problem. The same attach-a-keyboard-from-script idea exists on other runtimes; the Cicode on-screen keyboard function for panel PC data entry is one example.

Size pages for fingers, not for the mouse pointer #

A mouse pointer selects a single point; a finger covers the control and part of what surrounds it. Pages that look fine on the development monitor miss presses at the machine, so judge every operator page on the installed display, at its configured scaling, from the operator's working position. Enlarge and separate controls before investigating anything else, because no communication fix repairs a layout problem.

Convert pixels to millimetres so the sizing call is real. Worked example for a 10.1-inch diagonal touch panel running 1280 × 800:

  • Diagonal in pixels: √(1280² + 800²) = √(1,638,400 + 640,000) = √2,278,400 ≈ 1509 px
  • Pixel pitch: 10.1 in ÷ 1509 px ≈ 0.0067 in ≈ 0.17 mm per pixel
  • A 40 px control is 40 × 0.17 mm ≈ 6.8 mm wide, smaller than the roughly 10 mm contact a fingertip presses onto the glass, so the touch spills toward neighboring controls
  • An 80 px control is ≈ 13.6 mm, larger than the contact, so the press lands inside the control

Decision: compute your own panel's pitch the same way and size every operator control larger than the fingertip contact it must receive — on the example panel that means about 80 px, not 40.

Position matters as much as size. Capacitive touch layers report fewer reliable presses near the frame, so keep critical buttons off the outermost margins; the failure pattern is described in why capacitive touch buttons miss presses near screen edges.

Launch full screen with the -f switch #

In a regular session the F4 function key brings the application up full screen, which is the usual move before a demonstration. Remove the keyboard and F4 goes with it, so if the interface should always run full screen, decide that at launch instead of asking an operator to reproduce a keystroke.

DAQFactory runs on Windows 10 or newer, 32- or 64-bit, so the launch method is an ordinary Windows shortcut. Give the operator shortcut three entries in its Target field, space-separated: the full path to the application executable, the full path to your document, and -f. Quote any path that contains spaces. The guide documents this construction under Other Features - Runtime.

-f is a commitment, not a preference: it forces the application into full screen mode and does not let the session out of it. That is what a dedicated demonstration station wants and what a development bench must not have.

Launch method Target field Behavior
Operator shortcut Executable path, document path, -f Opens full screen and stays there
Development shortcut Executable path, document path Regular window, F4 available
Direct start None — start the executable and load the document by hand Regular mode without a second shortcut

Decision: -f belongs only in the shortcut the operator uses, never in the one you develop with.

Build the touch-only launch #

  1. Lay out every operator page on the installed display using the pixel-pitch arithmetic above, and fix any control a finger overshoots before moving on.
  2. Add the startup script assignment: System.OnScreenKeyboard = 3 when entry happens on pages and in dialogs, or 1 or 2 when your layout uses only one of those locations.
  3. List every field an operator can edit and classify it as page entry, built-in popup dialog, or your own popup, and give each of your own popups its own entry method if the built-in keyboard does not take to it.
  4. Build the operator shortcut with executable path, document path, and -f in the Target field, exactly as laid out in the previous section.
  5. Build the second shortcut without -f and label the two so nobody demos from the development icon.
  6. Restart through the operator shortcut and confirm the document opens full screen with no keystroke.
  7. Work the whole interface by finger: every page, every entry field, every dialog. Enter only values the machine accepts safely in its approved test state — on live plant, a touch button that writes a setpoint is a real command.
  8. Remove the keyboard and mouse only after a clean finger pass through all of it.

Read the results before you trust the setup #

Each check proves one thing. A document filling the display proves the launch mode, not that the pages are usable. A keyboard rising at a field proves entry assistance, not that the value reached the controller — follow one real command from press to controller response before you trust the chain. Touches that land offset from where you pressed are not a layout fault but a calibration fault, and running touch calibration without administrator rights on a panel PC covers the permission tangle that usually blocks that fix.

None of these settings helps a machine-side computer with no touch surface at all. A touch-only runtime needs a touch display at the operator position; where the demo computer is being replaced outright, industrial panel PCs put the runtime and the touch screen in one panel-mount unit.

Questions asked

Which keyboard mode should I use if entry happens only on the pages themselves?

Use mode 1. Setting System.OnScreenKeyboard to 1 shows the built-in keyboard for page entry only, which is the narrowest choice when every operator field sits on a page. Mode 3 additionally covers the built-in popup dialogs, so it is only needed when values are entered inside those dialogs too. Mode 0 has no place in a touch-only design, because it disables the on-screen keyboard entirely.

Can I put the full-screen toggle on a page button instead of using the -f switch?

The settings described here provide no documented script call that reproduces the full-screen function key on a page button. The supported routes to full screen are the function key in a regular session and the -f switch at launch. If operators must move between full-screen and regular views during a shift, keep the plain shortcut available to maintenance staff rather than recreating the toggle inside the project.

Does the -f switch change anything besides the window size?

Its documented effect is the window state: it forces full screen and does not allow leaving that mode during the session. Nothing in the switch controls permissions or access. Removing the keyboard and mouse limits convenience, not authority, since anyone who plugs a keyboard back in returns to regular mode, so restrict anything an operator must not change in the project design itself rather than relying on the forced window.

Can the Windows on-screen keyboard be used as a backup?

Yes, as a stopgap in regular mode. Windows 10 and newer include an accessibility on-screen keyboard that you switch on under Settings > Accessibility > Keyboard, and it types into any focused field. For a dedicated touch-only station, prefer the runtime's built-in keyboard set with the mode script line, because it appears automatically at entry fields instead of waiting for an operator to open it.

Keep reading

  • Explainer

    Where JavaScript and WebAssembly Actually Run on an HMI

    JavaScript and WebAssembly execute in the HMI client's browser engine — the panel itself, a panel PC, or a desktop browser — never inside the PLC, which only serves the files and exposes data through a documented interface. Decide on the rendering route the installed runtime provides, then verify rendering, module execution, and the data path in that order.

    HMI and touchscreens

  • Explainer

    How multiple HMI projects run on one server host

    One server host can run several HMI projects at the same time: this platform sets no software limit on running projects. What decides success is the license — two concurrent client connections included by default, extendable with a documented three-client add-on — and the host's CPU and memory headroom. Size from measured simultaneous browser sessions and controller load, never from project count.

    HMI and touchscreens

  • Troubleshooting

    How to Recover a WinCC On-Screen Keyboard Placed Off-Screen

    Set PosLeft, PosTop, PosRight and PosBottom to 0 under the Windows account that runs the HMI, then restart Windows: the keyboard reopens at a sensible default. The values live under HKEY_CURRENT_USER\SOFTWARE\Siemens\SimaticHmiIM on a documented WinCC V17 station, but the subkey varies, so search for PosLeft under HKCU\SOFTWARE\Siemens when the key is not there.

    HMI and touchscreens