WinCC Close External Application Using C-Script and VBScript

1. Problem Scope and Architecture Overview

WinCC Runtime hosts two fundamentally different kinds of visual surfaces. The first is an internal Picture (PDL) rendered inside the WinCC Graphics Runtime. The second is an external Win32 process (for example, notepad.exe) launched from a script via ProgramExecute or WScript.Shell.Run. The two surfaces do not share a parent-child window relationship, so the standard "picture closes -> children close" rule does not apply when one of the surfaces is an external executable.

The engineering problem becomes: how do you guarantee that notepad.exe (or any external program started from a button on a PDL) is terminated whenever the user closes the picture that originally launched it? This article documents the working C-Script and VBScript solutions for both WinCC V7.x (SIMATIC WinCC) and TIA Portal WinCC Professional / Comfort, including the correct event hooks, the Win32 API sequence (FindWindow -> PostMessage WM_CLOSE), and the taskkill fallback.

2. Internal PictureWindow vs External Process

The PictureWindow object in WinCC Graphics Designer is a container. When you load a different PDL into the parent picture, the child PictureWindow is destroyed automatically. An notepad.exe window is not embedded in that container - it is a sibling top-level window of the WinCC Runtime itself, so it survives the picture change unless you explicitly close it.

3. WinCC Picture Event Reference

WinCC V7.x Graphics Designer exposes the following events on a picture object (right-click the picture background, choose Properties -> Events):

In TIA Portal WinCC Professional the same events are exposed in the picture properties dialog of the HMI device. The VBScript function name generated is OnClose (or OnOpen).

4. Launching External Applications

There are three reliable launch paths. Pick the one matching your platform.

4.1 WinCC V7.x - C-Script with ProgramExecute

#include "apdefap.h"

void OnClick(char* lpszPictureName,
             char* lpszObjectName,
             char* lpszPropertyName,
             UINT  nFlags,
             int   x,
             int   y)
{
    ProgramExecute("notepad.exe C:\\Logs\\Runtime.log");
}

ProgramExecute is declared in apdefap.h and synchronously launches the external process. If you need the script to continue while the external program runs, use WinExec("notepad.exe", SW_SHOWNORMAL) from the Win32 API instead.

4.2 TIA WinCC Professional - VBScript with WScript.Shell

Sub OnClick(ByVal Item)
    Dim oShell
    Set oShell = CreateObject("WScript.Shell")
    oShell.Run "notepad.exe C:\Logs\Runtime.log", 1, False
    Set oShell = Nothing
End Sub

The third argument (False) means "do not wait for completion". This is mandatory for a button click handler - otherwise the HMI freezes until Notepad is closed by the user.

4.3 WinCC Unified (TIA V16+) - JavaScript

export function Button_1_OnClick(item) {
    const { exec } = imports("@runtime/Application");
    // Project property "ExtProgram" = "notepad.exe"
    const program = Tags("ExtProgram").Read();
    exec(program);
}

WinCC Unified uses the JavaScript-based action API. The exec method is documented in the TIA Portal WinCC Unified online help.

5. Capturing the Window Handle with FindWindow

To close a specific external window without killing the entire process, you must obtain its HWND. The Win32 API function FindWindow matches either by window class name or by window title. For Notepad the class name is Notepad (Windows 10/11) or NotepadClass (older). The title is dynamic.

5.1 C-Script (WinCC V7) - Win32 API Access

WinCC C-Scripts can call Win32 API functions directly. Declare once in a project header:

// In a project header file included by every C action
typedef unsigned long DWORD;
typedef unsigned int  UINT;
typedef int           BOOL;
typedef char*         LPSTR;
typedef void*         HWND;
typedef long          LRESULT;

#define WM_CLOSE 0x0010

HWND  __stdcall FindWindowA(LPSTR lpClassName, LPSTR lpWindowName);
LRESULT __stdcall PostMessageA(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);

5.2 VBScript (TIA WinCC Professional) - Win32 API via external helper

VBScript cannot call FindWindow directly. Two practical options:

1. Use the AppActivate method on WScript.Shell to focus the window, then send Alt+F4 with SendKeys.
2. Use a small VB6 / .NET helper COM object that exposes FindWindow and PostMessage as methods.

Sub CloseNotepadWindow()
    Dim oShell
    Set oShell = CreateObject("WScript.Shell")
    ' Returns True if window found
    If oShell.AppActivate("Runtime.log - Notepad") Then
        oShell.SendKeys "%{F4}"   ' Alt+F4 = WM_CLOSE on focused window
    End If
    Set oShell = Nothing
End Sub

6. Closing the External Window: WM_CLOSE vs DestroyWindow vs TerminateProcess

The correct sequence is:

1. Save the HWND returned by FindWindow into a project-wide tag (WinCC tag of type Text tag 8-bit character set for hex storage, or a custom internal variable).
2. In the Close handler, retrieve the saved HWND and call PostMessage(hWnd, WM_CLOSE, 0, 0).
3. If the process is still alive after a 500 ms delay, fall back to taskkill /IM notepad.exe /F.

7. Why There Is No "PictureClose" Event on the Base Picture

WinCC Runtime architecture reserves Open / Close events for picture change operations. The base picture loaded at Runtime start has no preceding picture, and Runtime termination destroys the entire process rather than closing a picture object. The Siemens support response that there is "no PictureClose event" refers to this base-picture case, and the standard mitigation patterns are:

• Embed the launch in a PictureWindow: the PictureWindow itself fires OnClose when the parent picture changes, so the cleanup script hooks there.
• Use a project-wide shutdown hook: in WinCC V7 the Computer Properties -> Shutdown event can run a global cleanup script. TIA WinCC Professional provides Schedules and the Runtime's own OnShutdown event.
• Use Windows session events: subscribe to WM_QUERYENDSESSION / WM_ENDSESSION from a global C action to receive Windows logoff / shutdown notifications.

8. Complete C-Script Example for WinCC V7.x

This example uses a PictureWindow to launch Notepad on a button click and close it on PictureWindow close.

8.1 Button click action - launch and store HWND

#include "apdefap.h"

// Persisted across actions via a project tag "@NotepadHwnd"
extern "C" long FindWindowA(const char*, const char*);

void OnClick(char* lpszPictureName,
             char* lpszObjectName,
             char* lpszPropertyName,
             UINT  nFlags,
             int   x,
             int   y)
{
    ProgramExecute("notepad.exe");

    // Allow notepad to create its window
    DWORD tick = GetTickCount();
    long  hwnd = 0;
    while ((GetTickCount() - tick) < 3000)  // up to 3 s
    {
        hwnd = FindWindowA("Notepad", NULL);
        if (hwnd != 0) break;
        Sleep(100);
    }

    // Persist HWND as decimal text in a WinCC tag
    char buf[16];
    sprintf(buf, "%ld", hwnd);
    SetTagChar("@NotepadHwnd", buf);
}

8.2 PictureWindow close action - send WM_CLOSE

#include "apdefap.h"

extern "C" long PostMessageA(long hWnd, unsigned int Msg, long wParam, long lParam);
extern "C" DWORD GetTickCount(void);
extern "C" void Sleep(DWORD ms);

void OnClose(char* lpszPictureName,
             char* lpszObjectName,
             char* lpszPropertyName,
             BOOL  bClosing)
{
    char buf[16];
    GetTagChar(buf, "@NotepadHwnd");
    long hwnd = atol(buf);
    if (hwnd != 0)
    {
        PostMessageA(hwnd, 0x0010 /* WM_CLOSE */, 0, 0);   // graceful

        // Optional: hard-kill fallback after 500 ms
        DWORD tick = GetTickCount();
        while ((GetTickCount() - tick) < 500) { Sleep(50); }
        // system("taskkill /IM notepad.exe /F >NUL");
    }
    SetTagChar("@NotepadHwnd", "");
}

9. Complete VBScript Example for TIA Portal WinCC Professional

TIA WinCC does not support C-Script. Use VBScript only. Hook the cleanup to the PictureWindow close event.

9.1 PictureWindow close event - hard kill via taskkill

Sub OnClose(ByVal Item)
    Dim oShell
    Set oShell = CreateObject("WScript.Shell")

    ' Wait briefly so any in-flight save dialog can be dismissed
    Dim wshExec
    Set wshExec = oShell.Run("taskkill /IM notepad.exe /F", 0, True)

    ' oShell.Run with bWaitOnReturn=True returns exit code
    ' 0 = success, 128 = no process found
    Set wshExec = Nothing
    Set oShell = Nothing
End Sub

9.2 Graceful alternative - AppActivate + SendKeys

Sub OnClose(ByVal Item)
    Dim oShell
    Set oShell = CreateObject("WScript.Shell")
    If oShell.AppActivate("Notepad") Then
        oShell.SendKeys "%{F4}"   ' Alt+F4 -> WM_CLOSE
    End If
    Set oShell = Nothing
End Sub

9.3 Polling fallback when no event is reliable

Sub CyclicCleanup()
    Dim oShell, intFound
    Set oShell = CreateObject("WScript.Shell")
    intFound = oShell.Run("tasklist /FI ""IMAGENAME eq notepad.exe"" /NH", _
                          0, True)
    If intFound = 0 Then
        oShell.Run "taskkill /IM notepad.exe /F", 0, True
    End If
    Set oShell = Nothing
End Sub

Schedule this VBScript via a 2-second cyclic trigger while the parent picture is visible.

10. Process Termination Fallback Using taskkill

The taskkill utility ships with every Windows installation since Windows XP and is the safest hard-kill mechanism for WinCC panels running Windows Embedded Standard 7 / Windows 10 IoT.

taskkill /IM notepad.exe /F /T
taskkill /F /FI "WINDOWTITLE eq Runtime.log*"

Always verify the exit code (0 = success, 128 = no match, 1 = error) via oShell.Run(..., 0, True) in VBScript.

11. Commissioning and Verification Procedure

1. Compile the script: in WinCC V7 Graphics Designer press Compile -> C-Editor. Look for unresolved Win32 references in the build log.
2. Set Runtime properties: in Computer Properties -> Graphics Runtime ensure Runtime start picture is set to the picture containing your test button.
3. Enable diagnostic output: use printf("%s\n", "...") in C-Script or HMIRuntime.Trace in VBScript to log to the WinCC diagnostic file WinCC_Sys_.log.
4. Activate Runtime: launch the project. Click the button - Notepad must appear within 1 s.
5. Verify handle capture: read the @NotepadHwnd tag in WinCC Explorer. It must contain a non-zero decimal value.
6. Trigger the close path: change the base picture or close the PictureWindow. Verify Notepad disappears. If it does not, switch to taskkill /F fallback.
7. Test Runtime shutdown: stop the Runtime. If the external program remains, hook the Shutdown event in Computer Properties to execute the cleanup script.
8. Test Windows logoff: log off the panel. Verify that the WinCC shutdown event fires and terminates external processes.

12. Troubleshooting Matrix

13. Frequently Asked Questions