Add files using upload-large-folder tool

local-test-freerdp-delta-01/afc-freerdp/client/Android/Studio/aFreeRDP/lint.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<lint></lint>

local-test-freerdp-delta-01/afc-freerdp/client/Android/Studio/aFreeRDP/src/main/AndroidManifest.xml

@@ -0,0 +1,107 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    android:installLocation="auto">
+
+    <application
+        android:name="com.freerdp.afreerdp.application.GlobalApp"
+        android:icon="@drawable/icon_launcher_freerdp"
+        android:label="aFreeRDP"
+        android:resizeableActivity="true">
+
+        <!-- Main activity -->
+        <activity
+            android:exported="true"
+            android:name="com.freerdp.freerdpcore.presentation.HomeActivity"
+            android:alwaysRetainTaskState="true"
+            android:label="@string/app_title"
+            android:theme="@style/Theme.Main"
+            android:configChanges="orientation|keyboardHidden|screenSize|smallestScreenSize|density|screenLayout">
+
+            <intent-filter android:label="@string/app_title">
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+
+                <data android:mimeType="application/rdp" />
+                <data android:mimeType="application/x-rdp" />
+            </intent-filter>
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+
+                <data android:scheme="rdp" />
+                <data android:scheme="Rdp" />
+            </intent-filter>
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+
+                <data android:scheme="file" />
+                <data android:scheme="http" />
+                <data android:scheme="https" />
+                <data android:scheme="content" />
+                <data android:host="*" />
+
+                <!-- Ugly hack to match all files with a dot in its name.
+                Remove if a better way is found / supported.
+                https://stackoverflow.com/questions/3400072/pathpattern-to-match-file-extension-does-not-work-if-a-period-exists-elsewhere-i/8599921#8599921
+                -->
+                <data android:pathPattern=".*\\.rdp" />
+                <data android:pathPattern=".*\\..*\\.rdp" />
+                <data android:pathPattern=".*\\..*\\..*\\.rdp" />
+                <data android:pathPattern=".*\\..*\\..*\\..*\\.rdp" />
+                <data android:pathPattern=".*\\..*\\..*\\..*\\..*\\.rdp" />
+                <data android:pathPattern=".*\\..*\\..*\\..*\\..*\\..*\\.rdp" />
+                <data android:pathPattern=".*\\..*\\..*\\..*\\..*\\..*\\..*\\.rdp" />
+                <data android:pathPattern=".*\\..*\\..*\\..*\\..*\\..*\\..*\\..*\\.rdp" />
+                <data android:pathPattern=".*\\..*\\..*\\..*\\..*\\..*\\..*\\..*\\..*\\.rdp" />
+            </intent-filter>
+        </activity>
+
+        <!-- Session request handler activity - used for search and internally to start sessions -->
+        <!-- This should actually be defined in FreeRDPCore lib but Android manifest merging will -->
+        <!-- append the libs manifest to the apps manifest and therefore aliasing is not possible -->
+        <activity
+            android:exported="true"
+            android:name="com.freerdp.freerdpcore.services.SessionRequestHandlerActivity"
+            android:excludeFromRecents="true"
+            android:noHistory="true"
+            android:theme="@android:style/Theme.NoDisplay">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+            </intent-filter>
+        </activity>
+
+        <activity-alias
+            android:exported="true"
+            android:name=".services.SessionRequestHandlerActivity"
+            android:targetActivity="com.freerdp.freerdpcore.services.SessionRequestHandlerActivity">
+            <intent-filter>
+                <action android:name="android.intent.action.SEARCH" />
+            </intent-filter>
+            <meta-data
+                android:name="android.app.searchable"
+                android:resource="@xml/searchable" />
+        </activity-alias>
+
+        <provider
+            android:name="com.freerdp.freerdpcore.services.FreeRDPSuggestionProvider"
+            android:authorities="com.freerdp.afreerdp.services.freerdpsuggestionprovider"
+            android:exported="false"></provider>
+
+        <meta-data android:name="com.samsung.android.keepalive.density" android:value="true"/>
+
+    </application>
+
+</manifest>
+

local-test-freerdp-delta-01/afc-freerdp/client/Android/Studio/aFreeRDP/src/main/res/values/strings.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_title" translatable="false">aFreeRDP</string>
+    <!-- Search strings -->
+    <string name="search_label" translatable="false">aFreeRDP</string>
+    <string name="search_settings_description">Remote Computers</string>
+</resources>

local-test-freerdp-delta-01/afc-freerdp/client/Android/Studio/build.gradle

@@ -0,0 +1,70 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+Properties releaseProperties = new Properties()
+File file = new File('release.properties')
+if (file.canRead()) {
+    releaseProperties.load(new FileInputStream(file))
+}
+   
+if (!hasProperty('RELEASE_STORE_FILE')) {
+    RELEASE_STORE_FILE=releaseProperties.get('RELEASE_STORE_FILE', '~/.android/debug.keystore')
+}
+if (!hasProperty('RELEASE_KEY_ALIAS')) {
+    RELEASE_KEY_ALIAS=releaseProperties.get('RELEASE_KEY_ALIAS', 'androiddebugkey')
+}
+if (!hasProperty('RELEASE_KEY_PASSWORD')) {
+    RELEASE_KEY_PASSWORD=releaseProperties.get('RELEASE_KEY_PASSWORD', 'android')
+}
+if (!hasProperty('RELEASE_STORE_PASSWORD')) {
+    RELEASE_STORE_PASSWORD=releaseProperties.get('RELEASE_STORE_PASSWORD', 'android')
+}
+
+ext {
+    compileApi = releaseProperties.get('COMPILE_API', 35)
+    targetApi = releaseProperties.get('TARGET_API', 35)
+    minApi = releaseProperties.get('MIN_API', 23)
+    toolsVersion = releaseProperties.get('TOOLS_VERSION', '35.0.0')
+
+    println '----------------- Project configuration -------------------'
+    println 'RELEASE_STORE_FILE: ' + RELEASE_STORE_FILE
+    println 'RELEASE_KEY_ALIAS:  ' + RELEASE_KEY_ALIAS
+    println 'compile API:        ' + compileApi
+    println 'target API:         ' + targetApi
+    println 'min API:            ' + minApi
+    println 'tools version:      ' + toolsVersion
+    println '-----------------------------------------------------------'
+}
+
+buildscript {
+    repositories {
+        mavenCentral()
+        google()
+        maven {
+            url 'https://maven.google.com'
+        }
+    }
+    dependencies {
+       classpath 'com.android.tools.build:gradle:8.8.0'
+    }
+}
+
+allprojects {
+    repositories {
+        mavenCentral()
+        google()
+        maven {
+            url 'https://maven.google.com'
+        }
+    }
+
+    subprojects {
+        afterEvaluate { project ->
+            if (project.hasProperty('android')) {
+                project.android {
+                    if (namespace == null) {
+                        namespace 'com.freerdp.' + project.name.toLowerCase()
+                    }
+                }
+            }
+        }
+    }
+}

local-test-freerdp-delta-01/afc-freerdp/client/Android/Studio/freeRDPCore/build.gradle

@@ -0,0 +1,66 @@
+apply plugin: 'com.android.library'
+
+android {
+    compileSdkVersion = rootProject.ext.compileApi
+    buildToolsVersion = rootProject.ext.toolsVersion
+    packagingOptions {
+        jniLibs {
+            pickFirsts += ['lib/arm64-v8a/libfreerdp3.so', 'lib/armeabi-v7a/libfreerdp3.so', 'lib/x86/libfreerdp3.so', 'lib/x86_64/libfreerdp3.so', 'lib/arm64-v8a/libfreerdp-client3.so', 'lib/armeabi-v7a/libfreerdp-client3.so', 'lib/x86/libfreerdp-client3.so', 'lib/x86_64/libfreerdp-client3.so', 'lib/arm64-v8a/libwinpr3.so', 'lib/armeabi-v7a/libwinpr3.so', 'lib/x86/libwinpr3.so', 'lib/x86_64/libwinpr3.so']
+        }
+    }
+
+
+    defaultConfig {
+        minSdkVersion rootProject.ext.minApi
+        targetSdkVersion rootProject.ext.targetApi
+        vectorDrawables.useSupportLibrary = true
+	ndkVersion = "27.2.12479018"
+
+        ndk {
+            File jniLibsDirectory = new File(project.projectDir, "src/main/jniLibs")
+            ArrayList<String> abiFiltersList = new ArrayList<String>()
+            if (new File(jniLibsDirectory, "arm64-v8a/libfreerdp3.so").exists())
+                abiFiltersList.add("arm64-v8a")
+            if (new File(jniLibsDirectory, "armeabi-v7a/libfreerdp3.so").exists())
+                abiFiltersList.add("armeabi-v7a")
+            if (new File(jniLibsDirectory, "x86_64/libfreerdp3.so").exists())
+                abiFiltersList.add("x86_64")
+            if (new File(jniLibsDirectory, "x86/libfreerdp3.so").exists())
+                abiFiltersList.add("x86")
+            
+            abiFilters = abiFiltersList
+        }
+
+        externalNativeBuild {
+            cmake {
+                arguments "-DWITH_CLIENT_CHANNELS=ON"
+            }
+        }
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt'
+        }
+        debug {
+            jniDebuggable true
+            renderscriptDebuggable true
+        }
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+    externalNativeBuild {
+        cmake {
+            path file('src/main/cpp/CMakeLists.txt')
+        }
+    }
+}
+
+dependencies {
+    implementation 'com.android.support:appcompat-v7:28.0.0'
+    implementation 'com.android.support:support-v4:28.0.0'
+    implementation 'com.android.support:support-vector-drawable:28.0.0'
+}

local-test-freerdp-delta-01/afc-freerdp/client/Android/Studio/freeRDPCore/lint.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<lint></lint>

local-test-freerdp-delta-01/afc-freerdp/client/Android/Studio/gradle.properties

@@ -0,0 +1,3 @@
+org.gradle.jvmargs=-Xmx4096M
+android.useAndroidX = true
+android.enableJetifier = true

local-test-freerdp-delta-01/afc-freerdp/client/Android/Studio/gradlew

@@ -0,0 +1,160 @@
+#!/usr/bin/env bash
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn ( ) {
+    echo "$*"
+}
+
+die ( ) {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+esac
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+function splitJvmOpts() {
+    JVM_OPTS=("$@")
+}
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+
+exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"

local-test-freerdp-delta-01/afc-freerdp/client/Android/Studio/settings.gradle

@@ -0,0 +1,2 @@
+include ':freeRDPCore'
+include ':aFreeRDP'

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/dialogs/CMakeLists.txt

@@ -0,0 +1,72 @@
+set(SRCS
+    sdl_button.hpp
+    sdl_button.cpp
+    sdl_buttons.hpp
+    sdl_buttons.cpp
+    sdl_dialogs.cpp
+    sdl_dialogs.hpp
+    sdl_widget.hpp
+    sdl_widget.cpp
+    sdl_input.hpp
+    sdl_input.cpp
+    sdl_input_widgets.cpp
+    sdl_input_widgets.hpp
+    sdl_select.hpp
+    sdl_select.cpp
+    sdl_selectlist.hpp
+    sdl_selectlist.cpp
+    sdl_connection_dialog.cpp
+    sdl_connection_dialog.hpp
+)
+
+list(APPEND LIBS sdl2_client_res winpr)
+
+if(NOT WITH_SDL_LINK_SHARED)
+  list(APPEND LIBS SDL2::SDL2-static)
+else()
+  list(APPEND LIBS SDL2::SDL2)
+endif()
+
+macro(find_sdl_component name)
+  find_package(${name})
+  if(NOT ${name}_FOUND)
+    find_package(PkgConfig REQUIRED)
+    pkg_check_modules(${name} REQUIRED ${name})
+
+    if(BUILD_SHARED_LIBS)
+      list(APPEND LIBS ${${name}_LIBRARIES})
+      link_directories(${${name}_LIBRARY_DIRS})
+      include_directories(SYSTEM ${${name}_INCLUDE_DIRS})
+    else()
+      list(APPEND LIBS ${${name}_STATIC_LIBRARIES})
+      link_directories(${${name}_STATIC_LIBRARY_DIRS})
+      include_directories(SYSTEM ${${name}_STATIC_INCLUDE_DIRS})
+    endif()
+  else()
+    if(WITH_SDL_LINK_SHARED)
+      list(APPEND LIBS ${name}::${name})
+      set_target_properties(${name}::${name} PROPERTIES SYSTEM TRUE)
+    else()
+      list(APPEND LIBS ${name}::${name}-static)
+      set_target_properties(${name}::${name}-static PROPERTIES SYSTEM TRUE)
+    endif()
+  endif()
+endmacro()
+
+find_sdl_component(SDL2_ttf)
+
+option(WITH_SDL_IMAGE_DIALOGS "Build with SDL_image support (recommended)" OFF)
+if(WITH_SDL_IMAGE_DIALOGS)
+  find_sdl_component(SDL2_image)
+  add_compile_definitions(WITH_SDL_IMAGE_DIALOGS)
+endif()
+
+add_subdirectory(res)
+
+add_library(sdl2-dialogs STATIC ${SRCS})
+
+target_link_libraries(sdl2-dialogs PRIVATE ${LIBS})
+
+if(BUILD_TESTING_INTERNAL OR BUILD_TESTING)
+  #	add_subdirectory(test)
+endif()

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/dialogs/res/CMakeLists.txt

@@ -0,0 +1,30 @@
+# FreeRDP: A Remote Desktop Protocol Implementation
+# FreeRDP SDL Client
+#
+# Copyright 2024 Armin Novak <[email protected]>
+# Copyright 2024 Thincast Technologies GmbH
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set(SRCS sdl2_resource_manager.cpp sdl2_resource_manager.hpp)
+
+add_library(sdl2_client_res STATIC ${SRCS})
+
+if(NOT WITH_SDL_LINK_SHARED)
+  target_link_libraries(sdl2_client_res ${SDL2_STATIC_LIBRARIES})
+else()
+  target_link_libraries(sdl2_client_res ${SDL2_LIBRARIES})
+endif()
+
+set_target_properties(sdl2_client_res PROPERTIES POSITION_INDEPENDENT_CODE ON INTERPROCEDURAL_OPTIMIZATION OFF)
+target_link_libraries(sdl2_client_res sdl-common-client-res)

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/dialogs/res/sdl2_resource_manager.cpp

@@ -0,0 +1,37 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ *
+ * Copyright 2023 Armin Novak <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "sdl2_resource_manager.hpp"
+#include <iostream>
+
+SDL_RWops* SDL2ResourceManager::get(const std::string& type, const std::string& id)
+{
+	if (useCompiledResources())
+	{
+		auto d = data(type, id);
+		if (!d)
+			return nullptr;
+
+		auto s = d->size();
+		if (s > INT32_MAX)
+			return nullptr;
+		return SDL_RWFromConstMem(d->data(), static_cast<int>(s));
+	}
+
+	auto name = filename(type, id);
+	return SDL_RWFromFile(name.c_str(), "rb");
+}

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/dialogs/res/sdl2_resource_manager.hpp

@@ -0,0 +1,38 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ *
+ * Copyright 2023 Armin Novak <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <string>
+#include <map>
+#include <vector>
+#include <SDL.h>
+
+#include <res/sdl_resource_manager.hpp>
+
+class SDL2ResourceManager : public SDLResourceManager
+{
+  public:
+	SDL2ResourceManager() = delete;
+	SDL2ResourceManager(const SDL2ResourceManager& other) = delete;
+	SDL2ResourceManager(const SDL2ResourceManager&& other) = delete;
+	~SDL2ResourceManager() = delete;
+	SDL2ResourceManager& operator=(const SDL2ResourceManager& other) = delete;
+	SDL2ResourceManager& operator=(SDL2ResourceManager&& other) = delete;
+
+	static SDL_RWops* get(const std::string& type, const std::string& id);
+};

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/dialogs/sdl_button.cpp

@@ -0,0 +1,71 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client Channels
+ *
+ * Copyright 2023 Armin Novak <[email protected]>
+ * Copyright 2023 Thincast Technologies GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <cassert>
+#include <utility>
+
+#include "sdl_button.hpp"
+
+static const SDL_Color buttonbackgroundcolor = { 0x69, 0x66, 0x63, 0xff };
+static const SDL_Color buttonhighlightcolor = { 0xcd, 0xca, 0x35, 0x60 };
+static const SDL_Color buttonmouseovercolor = { 0x66, 0xff, 0x66, 0x60 };
+static const SDL_Color buttonfontcolor = { 0xd1, 0xcf, 0xcd, 0xff };
+
+SdlButton::SdlButton(SDL_Renderer* renderer, std::string label, int id, SDL_Rect rect)
+    : SdlWidget(renderer, rect, false), _name(std::move(label)), _id(id)
+{
+	assert(renderer);
+
+	update_text(renderer, _name, buttonfontcolor, buttonbackgroundcolor);
+}
+
+SdlButton::SdlButton(SdlButton&& other) noexcept = default;
+
+SdlButton::~SdlButton() = default;
+
+bool SdlButton::highlight(SDL_Renderer* renderer)
+{
+	assert(renderer);
+
+	std::vector<SDL_Color> colors = { buttonbackgroundcolor, buttonhighlightcolor };
+	if (!fill(renderer, colors))
+		return false;
+	return update_text(renderer, _name, buttonfontcolor);
+}
+
+bool SdlButton::mouseover(SDL_Renderer* renderer)
+{
+	std::vector<SDL_Color> colors = { buttonbackgroundcolor, buttonmouseovercolor };
+	if (!fill(renderer, colors))
+		return false;
+	return update_text(renderer, _name, buttonfontcolor);
+}
+
+bool SdlButton::update(SDL_Renderer* renderer)
+{
+	assert(renderer);
+
+	return update_text(renderer, _name, buttonfontcolor, buttonbackgroundcolor);
+}
+
+int SdlButton::id() const
+{
+	return _id;
+}

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/dialogs/sdl_button.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <string>
+
+#include "sdl_widget.hpp"
+
+class SdlButton : public SdlWidget
+{
+  public:
+	SdlButton(SDL_Renderer* renderer, std::string label, int id, SDL_Rect rect);
+	SdlButton(const SdlButton& other) = delete;
+	SdlButton(SdlButton&& other) noexcept;
+	~SdlButton() override;
+
+	SdlButton& operator=(const SdlButton& other) = delete;
+	SdlButton& operator=(SdlButton&& other) = delete;
+
+	bool highlight(SDL_Renderer* renderer);
+	bool mouseover(SDL_Renderer* renderer);
+	bool update(SDL_Renderer* renderer);
+
+	[[nodiscard]] int id() const;
+
+  private:
+	std::string _name;
+	int _id;
+};

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/dialogs/sdl_buttons.cpp

@@ -0,0 +1,112 @@
+#include <cassert>
+#include <algorithm>
+
+#include <winpr/cast.h>
+
+#include "sdl_buttons.hpp"
+
+static const Uint32 hpadding = 10;
+
+SdlButtonList::~SdlButtonList() = default;
+
+bool SdlButtonList::populate(SDL_Renderer* renderer, const std::vector<std::string>& labels,
+                             const std::vector<int>& ids, Sint32 total_width, Sint32 offsetY,
+                             Sint32 width, Sint32 height)
+{
+	assert(renderer);
+	assert(width >= 0);
+	assert(height >= 0);
+	assert(labels.size() == ids.size());
+
+	_list.clear();
+	size_t button_width =
+	    ids.size() * (WINPR_ASSERTING_INT_CAST(uint32_t, width) + hpadding) + hpadding;
+	size_t offsetX =
+	    WINPR_ASSERTING_INT_CAST(uint32_t, total_width) -
+	    std::min<size_t>(WINPR_ASSERTING_INT_CAST(uint32_t, total_width), button_width);
+	for (size_t x = 0; x < ids.size(); x++)
+	{
+		const size_t curOffsetX = offsetX + x * (static_cast<size_t>(width) + hpadding);
+		const SDL_Rect rect = { static_cast<int>(curOffsetX), offsetY, width, height };
+		_list.emplace_back(renderer, labels[x], ids[x], rect);
+	}
+	return true;
+}
+
+SdlButton* SdlButtonList::get_selected(const SDL_MouseButtonEvent& button)
+{
+	const Sint32 x = button.x;
+	const Sint32 y = button.y;
+
+	return get_selected(x, y);
+}
+
+SdlButton* SdlButtonList::get_selected(Sint32 x, Sint32 y)
+{
+	for (auto& btn : _list)
+	{
+		auto r = btn.rect();
+		if ((x >= r.x) && (x <= r.x + r.w) && (y >= r.y) && (y <= r.y + r.h))
+			return &btn;
+	}
+	return nullptr;
+}
+
+bool SdlButtonList::set_highlight_next(bool reset)
+{
+	if (reset)
+		_highlighted = nullptr;
+	else
+	{
+		auto next = _highlight_index++;
+		_highlight_index %= _list.size();
+		auto& element = _list[next];
+		_highlighted = &element;
+	}
+	return true;
+}
+
+bool SdlButtonList::set_highlight(size_t index)
+{
+	if (index >= _list.size())
+	{
+		_highlighted = nullptr;
+		return false;
+	}
+	auto& element = _list[index];
+	_highlighted = &element;
+	_highlight_index = ++index % _list.size();
+	return true;
+}
+
+bool SdlButtonList::set_mouseover(Sint32 x, Sint32 y)
+{
+	_mouseover = get_selected(x, y);
+	return _mouseover != nullptr;
+}
+
+void SdlButtonList::clear()
+{
+	_list.clear();
+	_mouseover = nullptr;
+	_highlighted = nullptr;
+	_highlight_index = 0;
+}
+
+bool SdlButtonList::update(SDL_Renderer* renderer)
+{
+	assert(renderer);
+
+	for (auto& btn : _list)
+	{
+		if (!btn.update(renderer))
+			return false;
+	}
+
+	if (_highlighted)
+		_highlighted->highlight(renderer);
+
+	if (_mouseover)
+		_mouseover->mouseover(renderer);
+	return true;
+}

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/dialogs/sdl_buttons.hpp

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <vector>
+#include <cstdint>
+
+#include "sdl_button.hpp"
+
+class SdlButtonList
+{
+  public:
+	SdlButtonList() = default;
+	virtual ~SdlButtonList();
+
+	bool populate(SDL_Renderer* renderer, const std::vector<std::string>& labels,
+	              const std::vector<int>& ids, Sint32 total_width, Sint32 offsetY, Sint32 width,
+	              Sint32 height);
+
+	bool update(SDL_Renderer* renderer);
+	SdlButton* get_selected(const SDL_MouseButtonEvent& button);
+	SdlButton* get_selected(Sint32 x, Sint32 y);
+
+	bool set_highlight_next(bool reset = false);
+	bool set_highlight(size_t index);
+	bool set_mouseover(Sint32 x, Sint32 y);
+
+	void clear();
+
+	SdlButtonList(const SdlButtonList& other) = delete;
+	SdlButtonList(SdlButtonList&& other) = delete;
+	SdlButtonList& operator=(const SdlButtonList& other) = delete;
+	SdlButtonList& operator=(SdlButtonList&& other) = delete;
+
+  private:
+	std::vector<SdlButton> _list;
+	SdlButton* _highlighted = nullptr;
+	size_t _highlight_index = 0;
+	SdlButton* _mouseover = nullptr;
+};

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/dialogs/sdl_connection_dialog.cpp

@@ -0,0 +1,539 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client helper dialogs
+ *
+ * Copyright 2023 Armin Novak <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <cassert>
+#include <thread>
+
+#include "sdl_connection_dialog.hpp"
+#include "../sdl_utils.hpp"
+#include "../sdl_freerdp.hpp"
+#include "res/sdl2_resource_manager.hpp"
+
+static const SDL_Color backgroundcolor = { 0x38, 0x36, 0x35, 0xff };
+static const SDL_Color textcolor = { 0xd1, 0xcf, 0xcd, 0xff };
+static const SDL_Color infocolor = { 0x43, 0xe0, 0x0f, 0x60 };
+static const SDL_Color warncolor = { 0xcd, 0xca, 0x35, 0x60 };
+static const SDL_Color errorcolor = { 0xf7, 0x22, 0x30, 0x60 };
+
+static const Uint32 vpadding = 5;
+static const Uint32 hpadding = 5;
+
+SDLConnectionDialog::SDLConnectionDialog(rdpContext* context) : _context(context)
+{
+	SDL_Init(SDL_INIT_TIMER | SDL_INIT_VIDEO);
+	hide();
+}
+
+SDLConnectionDialog::~SDLConnectionDialog()
+{
+	resetTimer();
+	destroyWindow();
+	SDL_Quit();
+}
+
+bool SDLConnectionDialog::visible() const
+{
+	if (!_window || !_renderer)
+		return false;
+
+	auto flags = SDL_GetWindowFlags(_window);
+	return (flags & (SDL_WINDOW_HIDDEN | SDL_WINDOW_MINIMIZED)) == 0;
+}
+
+bool SDLConnectionDialog::setTitle(const char* fmt, ...)
+{
+	std::lock_guard lock(_mux);
+	va_list ap = {};
+	va_start(ap, fmt);
+	_title = print(fmt, ap);
+	va_end(ap);
+
+	return show(MSG_NONE);
+}
+
+bool SDLConnectionDialog::showInfo(const char* fmt, ...)
+{
+	va_list ap = {};
+	va_start(ap, fmt);
+	auto rc = show(MSG_INFO, fmt, ap);
+	va_end(ap);
+	return rc;
+}
+
+bool SDLConnectionDialog::showWarn(const char* fmt, ...)
+{
+	va_list ap = {};
+	va_start(ap, fmt);
+	auto rc = show(MSG_WARN, fmt, ap);
+	va_end(ap);
+	return rc;
+}
+
+bool SDLConnectionDialog::showError(const char* fmt, ...)
+{
+	va_list ap = {};
+	va_start(ap, fmt);
+	auto rc = show(MSG_ERROR, fmt, ap);
+	va_end(ap);
+	if (!rc)
+		return rc;
+	return setTimer();
+}
+
+bool SDLConnectionDialog::show()
+{
+	std::lock_guard lock(_mux);
+	return show(_type_active);
+}
+
+bool SDLConnectionDialog::hide()
+{
+	std::lock_guard lock(_mux);
+	return show(MSG_DISCARD);
+}
+
+bool SDLConnectionDialog::running() const
+{
+	std::lock_guard lock(_mux);
+	return _running;
+}
+
+bool SDLConnectionDialog::update()
+{
+	std::lock_guard lock(_mux);
+	switch (_type)
+	{
+		case MSG_INFO:
+		case MSG_WARN:
+		case MSG_ERROR:
+			_type_active = _type;
+			createWindow();
+			break;
+		case MSG_DISCARD:
+			resetTimer();
+			destroyWindow();
+			break;
+		default:
+			if (_window)
+			{
+				SDL_SetWindowTitle(_window, _title.c_str());
+			}
+			break;
+	}
+	_type = MSG_NONE;
+	return true;
+}
+
+bool SDLConnectionDialog::setModal()
+{
+	if (_window)
+	{
+		auto sdl = get_context(_context);
+		if (sdl->windows.empty())
+			return true;
+
+		auto parent = sdl->windows.begin()->second.window();
+		SDL_SetWindowModalFor(_window, parent);
+		SDL_RaiseWindow(_window);
+	}
+	return true;
+}
+
+bool SDLConnectionDialog::clearWindow(SDL_Renderer* renderer)
+{
+	assert(renderer);
+
+	const int drc = SDL_SetRenderDrawColor(renderer, backgroundcolor.r, backgroundcolor.g,
+	                                       backgroundcolor.b, backgroundcolor.a);
+	if (widget_log_error(drc, "SDL_SetRenderDrawColor"))
+		return false;
+
+	const int rcls = SDL_RenderClear(renderer);
+	return !widget_log_error(rcls, "SDL_RenderClear");
+}
+
+bool SDLConnectionDialog::update(SDL_Renderer* renderer)
+{
+	std::lock_guard lock(_mux);
+	if (!renderer)
+		return false;
+
+	if (!clearWindow(renderer))
+		return false;
+
+	for (auto& btn : _list)
+	{
+		if (!btn.widget.update_text(renderer, _msg, btn.fgcolor, btn.bgcolor))
+			return false;
+	}
+
+	if (!_buttons.update(renderer))
+		return false;
+
+	SDL_RenderPresent(renderer);
+	return true;
+}
+
+bool SDLConnectionDialog::wait(bool ignoreRdpContext)
+{
+	while (running())
+	{
+		if (!ignoreRdpContext)
+		{
+			if (freerdp_shall_disconnect_context(_context))
+				return false;
+		}
+		std::this_thread::yield();
+	}
+	return true;
+}
+
+bool SDLConnectionDialog::handle(const SDL_Event& event)
+{
+	Uint32 windowID = 0;
+	if (_window)
+	{
+		windowID = SDL_GetWindowID(_window);
+	}
+
+	switch (event.type)
+	{
+		case SDL_USEREVENT_RETRY_DIALOG:
+			return update();
+		case SDL_QUIT:
+			resetTimer();
+			destroyWindow();
+			return false;
+		case SDL_KEYDOWN:
+		case SDL_KEYUP:
+			if (visible())
+			{
+				auto& ev = reinterpret_cast<const SDL_KeyboardEvent&>(event);
+				update(_renderer);
+				switch (event.key.keysym.sym)
+				{
+					case SDLK_RETURN:
+					case SDLK_RETURN2:
+					case SDLK_ESCAPE:
+					case SDLK_KP_ENTER:
+						if (event.type == SDL_KEYUP)
+						{
+							freerdp_abort_event(_context);
+							sdl_push_quit();
+						}
+						break;
+					case SDLK_TAB:
+						_buttons.set_highlight_next();
+						break;
+					default:
+						break;
+				}
+
+				return windowID == ev.windowID;
+			}
+			return false;
+		case SDL_MOUSEMOTION:
+			if (visible())
+			{
+				auto& ev = reinterpret_cast<const SDL_MouseMotionEvent&>(event);
+
+				_buttons.set_mouseover(event.button.x, event.button.y);
+				update(_renderer);
+				return windowID == ev.windowID;
+			}
+			return false;
+		case SDL_MOUSEBUTTONDOWN:
+		case SDL_MOUSEBUTTONUP:
+			if (visible())
+			{
+				auto& ev = reinterpret_cast<const SDL_MouseButtonEvent&>(event);
+				update(_renderer);
+
+				auto button = _buttons.get_selected(event.button);
+				if (button)
+				{
+					if (event.type == SDL_MOUSEBUTTONUP)
+					{
+						freerdp_abort_event(_context);
+						sdl_push_quit();
+					}
+				}
+
+				return windowID == ev.windowID;
+			}
+			return false;
+		case SDL_MOUSEWHEEL:
+			if (visible())
+			{
+				auto& ev = reinterpret_cast<const SDL_MouseWheelEvent&>(event);
+				update(_renderer);
+				return windowID == ev.windowID;
+			}
+			return false;
+		case SDL_FINGERUP:
+		case SDL_FINGERDOWN:
+			if (visible())
+			{
+				auto& ev = reinterpret_cast<const SDL_TouchFingerEvent&>(event);
+				update(_renderer);
+#if SDL_VERSION_ATLEAST(2, 0, 18)
+				return windowID == ev.windowID;
+#else
+				return false;
+#endif
+			}
+			return false;
+		case SDL_WINDOWEVENT:
+		{
+			auto& ev = reinterpret_cast<const SDL_WindowEvent&>(event);
+			switch (ev.event)
+			{
+				case SDL_WINDOWEVENT_CLOSE:
+					if (windowID == ev.windowID)
+					{
+						freerdp_abort_event(_context);
+						sdl_push_quit();
+					}
+					break;
+				default:
+					update(_renderer);
+					setModal();
+					break;
+			}
+
+			return windowID == ev.windowID;
+		}
+		default:
+			return false;
+	}
+}
+
+bool SDLConnectionDialog::createWindow()
+{
+	destroyWindow();
+
+	const int widget_height = 50;
+	const int widget_width = 600;
+	const int total_height = 300;
+
+	auto flags = WINPR_ASSERTING_INT_CAST(
+	    uint32_t, SDL_WINDOW_ALLOW_HIGHDPI | SDL_WINDOW_MOUSE_FOCUS | SDL_WINDOW_INPUT_FOCUS);
+	auto rc = SDL_CreateWindowAndRenderer(widget_width, total_height, flags, &_window, &_renderer);
+	if (rc != 0)
+	{
+		widget_log_error(rc, "SDL_CreateWindowAndRenderer");
+		return false;
+	}
+	SDL_SetWindowTitle(_window, _title.c_str());
+	setModal();
+
+	SDL_Color res_bgcolor;
+	switch (_type_active)
+	{
+		case MSG_INFO:
+			res_bgcolor = infocolor;
+			break;
+		case MSG_WARN:
+			res_bgcolor = warncolor;
+			break;
+		case MSG_ERROR:
+			res_bgcolor = errorcolor;
+			break;
+		case MSG_DISCARD:
+		default:
+			res_bgcolor = backgroundcolor;
+			break;
+	}
+
+#if defined(WITH_SDL_IMAGE_DIALOGS)
+	std::string res_name;
+	switch (_type_active)
+	{
+		case MSG_INFO:
+			res_name = "icon_info.svg";
+			break;
+		case MSG_WARN:
+			res_name = "icon_warning.svg";
+			break;
+		case MSG_ERROR:
+			res_name = "icon_error.svg";
+			break;
+		case MSG_DISCARD:
+		default:
+			res_name = "";
+			break;
+	}
+
+	int height = (total_height - 3ul * vpadding) / 2ul;
+	SDL_Rect iconRect{ hpadding, vpadding, widget_width / 4ul - 2ul * hpadding, height };
+	widget_cfg_t icon{ textcolor,
+		               res_bgcolor,
+		               { _renderer, iconRect,
+		                 SDL2ResourceManager::get(SDLResourceManager::typeImages(), res_name) } };
+	_list.emplace_back(std::move(icon));
+
+	iconRect.y += height;
+
+	widget_cfg_t logo{ textcolor,
+		               backgroundcolor,
+		               { _renderer, iconRect,
+		                 SDL2ResourceManager::get(SDLResourceManager::typeImages(),
+		                                          "FreeRDP_Icon.svg") } };
+	_list.emplace_back(std::move(logo));
+
+	SDL_Rect rect = { widget_width / 4ul, vpadding, widget_width * 3ul / 4ul,
+		              total_height - 3ul * vpadding - widget_height };
+#else
+	SDL_Rect rect = { hpadding, vpadding, widget_width - 2ul * hpadding,
+		              total_height - 2ul * vpadding };
+#endif
+
+	widget_cfg_t w{ textcolor, backgroundcolor, { _renderer, rect, false } };
+	w.widget.set_wrap(true, widget_width);
+	_list.emplace_back(std::move(w));
+	rect.y += widget_height + vpadding;
+
+	const std::vector<int> buttonids = { 1 };
+	const std::vector<std::string> buttonlabels = { "cancel" };
+	_buttons.populate(_renderer, buttonlabels, buttonids, widget_width,
+	                  total_height - widget_height - vpadding,
+	                  static_cast<Sint32>(widget_width / 2), static_cast<Sint32>(widget_height));
+	_buttons.set_highlight(0);
+
+	SDL_ShowWindow(_window);
+	SDL_RaiseWindow(_window);
+
+	return true;
+}
+
+void SDLConnectionDialog::destroyWindow()
+{
+	_buttons.clear();
+	_list.clear();
+	SDL_DestroyRenderer(_renderer);
+	SDL_DestroyWindow(_window);
+	_renderer = nullptr;
+	_window = nullptr;
+}
+
+bool SDLConnectionDialog::show(MsgType type, const char* fmt, va_list ap)
+{
+	std::lock_guard lock(_mux);
+	_msg = print(fmt, ap);
+	return show(type);
+}
+
+bool SDLConnectionDialog::show(MsgType type)
+{
+	_type = type;
+	return sdl_push_user_event(SDL_USEREVENT_RETRY_DIALOG);
+}
+
+std::string SDLConnectionDialog::print(const char* fmt, va_list ap)
+{
+	int size = -1;
+	std::string res;
+
+	do
+	{
+		res.resize(128);
+		if (size > 0)
+			res.resize(WINPR_ASSERTING_INT_CAST(size_t, size));
+
+		va_list copy;
+		va_copy(copy, ap);
+		WINPR_PRAGMA_DIAG_PUSH
+		WINPR_PRAGMA_DIAG_IGNORED_FORMAT_NONLITERAL
+		size = vsnprintf(res.data(), res.size(), fmt, copy);
+		WINPR_PRAGMA_DIAG_POP
+		va_end(copy);
+
+	} while ((size > 0) && (static_cast<size_t>(size) > res.size()));
+
+	return res;
+}
+
+bool SDLConnectionDialog::setTimer(Uint32 timeoutMS)
+{
+	std::lock_guard lock(_mux);
+	resetTimer();
+
+	_timer = SDL_AddTimer(timeoutMS, &SDLConnectionDialog::timeout, this);
+	_running = true;
+	return true;
+}
+
+void SDLConnectionDialog::resetTimer()
+{
+	if (_running)
+		SDL_RemoveTimer(_timer);
+	_running = false;
+}
+
+Uint32 SDLConnectionDialog::timeout(Uint32 intervalMS, void* pvthis)
+{
+	auto self = static_cast<SDLConnectionDialog*>(pvthis);
+	self->hide();
+	self->_running = false;
+	return 0;
+}
+
+SDLConnectionDialogHider::SDLConnectionDialogHider(freerdp* instance)
+    : SDLConnectionDialogHider(get(instance))
+{
+}
+
+SDLConnectionDialogHider::SDLConnectionDialogHider(rdpContext* context)
+    : SDLConnectionDialogHider(get(context))
+{
+}
+
+SDLConnectionDialogHider::SDLConnectionDialogHider(SDLConnectionDialog* dialog) : _dialog(dialog)
+{
+	if (_dialog)
+	{
+		_visible = _dialog->visible();
+		if (_visible)
+		{
+			_dialog->hide();
+		}
+	}
+}
+
+SDLConnectionDialogHider::~SDLConnectionDialogHider()
+{
+	if (_dialog && _visible)
+	{
+		_dialog->show();
+	}
+}
+
+SDLConnectionDialog* SDLConnectionDialogHider::get(freerdp* instance)
+{
+	if (!instance)
+		return nullptr;
+	return get(instance->context);
+}
+
+SDLConnectionDialog* SDLConnectionDialogHider::get(rdpContext* context)
+{
+	auto sdl = get_context(context);
+	if (!sdl)
+		return nullptr;
+	return sdl->connection_dialog.get();
+}

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/dialogs/sdl_connection_dialog.hpp

@@ -0,0 +1,131 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client helper dialogs
+ *
+ * Copyright 2023 Armin Novak <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <memory>
+#include <mutex>
+#include <string>
+#include <vector>
+
+#include <SDL.h>
+
+#include <freerdp/freerdp.h>
+
+#include "sdl_widget.hpp"
+#include "sdl_buttons.hpp"
+
+class SDLConnectionDialog
+{
+  public:
+	explicit SDLConnectionDialog(rdpContext* context);
+	SDLConnectionDialog(const SDLConnectionDialog& other) = delete;
+	SDLConnectionDialog(const SDLConnectionDialog&& other) = delete;
+	virtual ~SDLConnectionDialog();
+
+	SDLConnectionDialog& operator=(const SDLConnectionDialog& other) = delete;
+	SDLConnectionDialog& operator=(SDLConnectionDialog&& other) = delete;
+
+	bool visible() const;
+
+	bool setTitle(const char* fmt, ...);
+	bool showInfo(const char* fmt, ...);
+	bool showWarn(const char* fmt, ...);
+	bool showError(const char* fmt, ...);
+
+	bool show();
+	bool hide();
+
+	bool running() const;
+	bool wait(bool ignoreRdpContextQuit = false);
+
+	bool handle(const SDL_Event& event);
+
+  private:
+	enum MsgType
+	{
+		MSG_NONE,
+		MSG_INFO,
+		MSG_WARN,
+		MSG_ERROR,
+		MSG_DISCARD
+	};
+
+	bool createWindow();
+	void destroyWindow();
+
+	bool update();
+
+	bool setModal();
+
+	static bool clearWindow(SDL_Renderer* renderer);
+
+	bool update(SDL_Renderer* renderer);
+
+	bool show(MsgType type, const char* fmt, va_list ap);
+	bool show(MsgType type);
+
+	static std::string print(const char* fmt, va_list ap);
+	bool setTimer(Uint32 timeoutMS = 15000);
+	void resetTimer();
+
+	static Uint32 timeout(Uint32 intervalMS, void* pvthis);
+
+	struct widget_cfg_t
+	{
+		SDL_Color fgcolor = {};
+		SDL_Color bgcolor = {};
+		SdlWidget widget;
+	};
+
+	rdpContext* _context = nullptr;
+	SDL_Window* _window = nullptr;
+	SDL_Renderer* _renderer = nullptr;
+	mutable std::mutex _mux;
+	std::string _title;
+	std::string _msg;
+	MsgType _type = MSG_NONE;
+	MsgType _type_active = MSG_NONE;
+	SDL_TimerID _timer = -1;
+	bool _running = false;
+	std::vector<widget_cfg_t> _list;
+	SdlButtonList _buttons;
+};
+
+class SDLConnectionDialogHider
+{
+  public:
+	explicit SDLConnectionDialogHider(freerdp* instance);
+	explicit SDLConnectionDialogHider(rdpContext* context);
+
+	explicit SDLConnectionDialogHider(SDLConnectionDialog* dialog);
+	SDLConnectionDialogHider(const SDLConnectionDialogHider& other) = delete;
+	SDLConnectionDialogHider(SDLConnectionDialogHider&& other) = delete;
+	SDLConnectionDialogHider& operator=(const SDLConnectionDialogHider& other) = delete;
+	SDLConnectionDialogHider& operator=(SDLConnectionDialogHider& other) = delete;
+
+	~SDLConnectionDialogHider();
+
+  private:
+	SDLConnectionDialog* get(freerdp* instance);
+	static SDLConnectionDialog* get(rdpContext* context);
+
+	SDLConnectionDialog* _dialog = nullptr;
+	bool _visible = false;
+};

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/dialogs/sdl_dialogs.cpp

@@ -0,0 +1,623 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client helper dialogs
+ *
+ * Copyright 2023 Armin Novak <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <vector>
+#include <string>
+#include <cassert>
+
+#include <freerdp/log.h>
+#include <freerdp/utils/smartcardlogon.h>
+
+#include <SDL.h>
+
+#include "../sdl_freerdp.hpp"
+#include "sdl_dialogs.hpp"
+#include "sdl_input.hpp"
+#include "sdl_input_widgets.hpp"
+#include "sdl_select.hpp"
+#include "sdl_selectlist.hpp"
+
+enum
+{
+	SHOW_DIALOG_ACCEPT_REJECT = 1,
+	SHOW_DIALOG_TIMED_ACCEPT = 2
+};
+
+static const char* type_str_for_flags(UINT32 flags)
+{
+	const char* type = "RDP-Server";
+
+	if (flags & VERIFY_CERT_FLAG_GATEWAY)
+		type = "RDP-Gateway";
+
+	if (flags & VERIFY_CERT_FLAG_REDIRECT)
+		type = "RDP-Redirect";
+	return type;
+}
+
+static BOOL sdl_wait_for_result(rdpContext* context, Uint32 type, SDL_Event* result)
+{
+	const SDL_Event empty = {};
+
+	WINPR_ASSERT(context);
+	WINPR_ASSERT(result);
+
+	while (!freerdp_shall_disconnect_context(context))
+	{
+		*result = empty;
+		const int rc = SDL_PeepEvents(result, 1, SDL_GETEVENT, type, type);
+		if (rc > 0)
+			return TRUE;
+		Sleep(1);
+	}
+	return FALSE;
+}
+
+static int sdl_show_dialog(rdpContext* context, const char* title, const char* message,
+                           Sint32 flags)
+{
+	SDL_Event event = {};
+
+	if (!sdl_push_user_event(SDL_USEREVENT_SHOW_DIALOG, title, message, flags))
+		return 0;
+
+	if (!sdl_wait_for_result(context, SDL_USEREVENT_SHOW_RESULT, &event))
+		return 0;
+
+	return event.user.code;
+}
+
+BOOL sdl_authenticate_ex(freerdp* instance, char** username, char** password, char** domain,
+                         rdp_auth_reason reason)
+{
+	SDL_Event event = {};
+	BOOL res = FALSE;
+
+	SDLConnectionDialogHider hider(instance);
+
+	const char* target = freerdp_settings_get_server_name(instance->context->settings);
+	switch (reason)
+	{
+		case AUTH_NLA:
+			break;
+
+		case AUTH_TLS:
+		case AUTH_RDP:
+		case AUTH_SMARTCARD_PIN: /* in this case password is pin code */
+			if ((*username) && (*password))
+				return TRUE;
+			break;
+		case GW_AUTH_HTTP:
+		case GW_AUTH_RDG:
+		case GW_AUTH_RPC:
+			target =
+			    freerdp_settings_get_string(instance->context->settings, FreeRDP_GatewayHostname);
+			break;
+		default:
+			break;
+	}
+
+	char* title = nullptr;
+	size_t titlesize = 0;
+	winpr_asprintf(&title, &titlesize, "Credentials required for %s", target);
+
+	std::unique_ptr<char, decltype(&free)> scope(title, free);
+	char* u = nullptr;
+	char* d = nullptr;
+	char* p = nullptr;
+
+	assert(username);
+	assert(domain);
+	assert(password);
+
+	u = *username;
+	d = *domain;
+	p = *password;
+
+	if (!sdl_push_user_event(SDL_USEREVENT_AUTH_DIALOG, title, u, d, p, reason))
+		return res;
+
+	if (!sdl_wait_for_result(instance->context, SDL_USEREVENT_AUTH_RESULT, &event))
+		return res;
+
+	auto arg = reinterpret_cast<SDL_UserAuthArg*>(event.padding);
+
+	res = arg->result > 0;
+
+	free(*username);
+	free(*domain);
+	free(*password);
+	*username = arg->user;
+	*domain = arg->domain;
+	*password = arg->password;
+
+	return res;
+}
+
+BOOL sdl_choose_smartcard(freerdp* instance, SmartcardCertInfo** cert_list, DWORD count,
+                          DWORD* choice, BOOL gateway)
+{
+	BOOL res = FALSE;
+
+	WINPR_ASSERT(instance);
+	WINPR_ASSERT(cert_list);
+	WINPR_ASSERT(choice);
+
+	SDLConnectionDialogHider hider(instance);
+	std::vector<std::string> strlist;
+	std::vector<const char*> list;
+	for (DWORD i = 0; i < count; i++)
+	{
+		const SmartcardCertInfo* cert = cert_list[i];
+		char* reader = ConvertWCharToUtf8Alloc(cert->reader, nullptr);
+		char* container_name = ConvertWCharToUtf8Alloc(cert->containerName, nullptr);
+
+		char* msg = nullptr;
+		size_t len = 0;
+
+		winpr_asprintf(&msg, &len,
+		               "%s\n\tReader: %s\n\tUser: %s@%s\n\tSubject: %s\n\tIssuer: %s\n\tUPN: %s",
+		               container_name, reader, cert->userHint, cert->domainHint, cert->subject,
+		               cert->issuer, cert->upn);
+
+		strlist.emplace_back(msg);
+		free(msg);
+		free(reader);
+		free(container_name);
+
+		auto& m = strlist.back();
+		list.push_back(m.c_str());
+	}
+
+	SDL_Event event = {};
+	const char* title = "Select a logon smartcard certificate";
+	if (gateway)
+		title = "Select a gateway logon smartcard certificate";
+	if (!sdl_push_user_event(SDL_USEREVENT_SCARD_DIALOG, title, list.data(), count))
+		return res;
+
+	if (!sdl_wait_for_result(instance->context, SDL_USEREVENT_SCARD_RESULT, &event))
+		return res;
+
+	res = (event.user.code >= 0);
+	*choice = static_cast<DWORD>(event.user.code);
+
+	return res;
+}
+
+SSIZE_T sdl_retry_dialog(freerdp* instance, const char* what, size_t current, void* userarg)
+{
+	WINPR_ASSERT(instance);
+	WINPR_ASSERT(instance->context);
+	WINPR_ASSERT(what);
+
+	auto sdl = get_context(instance->context);
+	auto settings = instance->context->settings;
+	const size_t delay = freerdp_settings_get_uint32(settings, FreeRDP_TcpConnectTimeout);
+	std::lock_guard<CriticalSection> lock(sdl->critical);
+	if (!sdl->connection_dialog)
+		return WINPR_ASSERTING_INT_CAST(SSIZE_T, delay);
+
+	sdl->connection_dialog->setTitle("Retry connection to %s",
+	                                 freerdp_settings_get_server_name(instance->context->settings));
+
+	if ((strcmp(what, "arm-transport") != 0) && (strcmp(what, "connection") != 0))
+	{
+		sdl->connection_dialog->showError("Unknown module %s, aborting", what);
+		return -1;
+	}
+
+	if (current == 0)
+	{
+		if (strcmp(what, "arm-transport") == 0)
+			sdl->connection_dialog->showWarn("[%s] Starting your VM. It may take up to 5 minutes",
+			                                 what);
+	}
+
+	const BOOL enabled = freerdp_settings_get_bool(settings, FreeRDP_AutoReconnectionEnabled);
+
+	if (!enabled)
+	{
+		sdl->connection_dialog->showError(
+		    "Automatic reconnection disabled, terminating. Try to connect again later");
+		return -1;
+	}
+
+	const size_t max = freerdp_settings_get_uint32(settings, FreeRDP_AutoReconnectMaxRetries);
+
+	if (current >= max)
+	{
+		sdl->connection_dialog->showError(
+		    "[%s] retries exceeded. Your VM failed to start. Try again later or contact your "
+		    "tech support for help if this keeps happening.",
+		    what);
+		return -1;
+	}
+
+	sdl->connection_dialog->showInfo("[%s] retry %" PRIuz "/%" PRIuz ", delaying %" PRIuz
+	                                 "ms before next attempt",
+	                                 what, current, max, delay);
+	return WINPR_ASSERTING_INT_CAST(SSIZE_T, delay);
+}
+
+BOOL sdl_present_gateway_message(freerdp* instance, UINT32 type, BOOL isDisplayMandatory,
+                                 BOOL isConsentMandatory, size_t length, const WCHAR* wmessage)
+{
+	if (!isDisplayMandatory)
+		return TRUE;
+
+	char* title = nullptr;
+	size_t len = 0;
+	winpr_asprintf(&title, &len, "[gateway]");
+
+	Sint32 flags = 0;
+	if (isConsentMandatory)
+		flags = SHOW_DIALOG_ACCEPT_REJECT;
+	else if (isDisplayMandatory)
+		flags = SHOW_DIALOG_TIMED_ACCEPT;
+	char* message = ConvertWCharNToUtf8Alloc(wmessage, length, nullptr);
+
+	SDLConnectionDialogHider hider(instance);
+	const int rc = sdl_show_dialog(instance->context, title, message, flags);
+	free(title);
+	free(message);
+	return rc > 0;
+}
+
+int sdl_logon_error_info(freerdp* instance, UINT32 data, UINT32 type)
+{
+	int rc = -1;
+	const char* str_data = freerdp_get_logon_error_info_data(data);
+	const char* str_type = freerdp_get_logon_error_info_type(type);
+
+	if (!instance || !instance->context)
+		return -1;
+
+	/* ignore LOGON_MSG_SESSION_CONTINUE message */
+	if (type == LOGON_MSG_SESSION_CONTINUE)
+		return 0;
+
+	SDLConnectionDialogHider hider(instance);
+
+	char* title = nullptr;
+	size_t tlen = 0;
+	winpr_asprintf(&title, &tlen, "[%s] info",
+	               freerdp_settings_get_server_name(instance->context->settings));
+
+	char* message = nullptr;
+	size_t mlen = 0;
+	winpr_asprintf(&message, &mlen, "Logon Error Info %s [%s]", str_data, str_type);
+
+	rc = sdl_show_dialog(instance->context, title, message, SHOW_DIALOG_ACCEPT_REJECT);
+	free(title);
+	free(message);
+	return rc;
+}
+
+static DWORD sdl_show_ceritifcate_dialog(rdpContext* context, const char* title,
+                                         const char* message)
+{
+	SDLConnectionDialogHider hider(context);
+	if (!sdl_push_user_event(SDL_USEREVENT_CERT_DIALOG, title, message))
+		return 0;
+
+	SDL_Event event = {};
+	if (!sdl_wait_for_result(context, SDL_USEREVENT_CERT_RESULT, &event))
+		return 0;
+	return static_cast<DWORD>(event.user.code);
+}
+
+static char* sdl_pem_cert(const char* pem)
+{
+	rdpCertificate* cert = freerdp_certificate_new_from_pem(pem);
+	if (!cert)
+		return nullptr;
+
+	char* fp = freerdp_certificate_get_fingerprint(cert);
+	char* start = freerdp_certificate_get_validity(cert, TRUE);
+	char* end = freerdp_certificate_get_validity(cert, FALSE);
+	freerdp_certificate_free(cert);
+
+	char* str = nullptr;
+	size_t slen = 0;
+	winpr_asprintf(&str, &slen,
+	               "Valid from:  %s\n"
+	               "Valid to:    %s\n"
+	               "Thumbprint:  %s\n",
+	               start, end, fp);
+	free(fp);
+	free(start);
+	free(end);
+	return str;
+}
+
+DWORD sdl_verify_changed_certificate_ex(freerdp* instance, const char* host, UINT16 port,
+                                        const char* common_name, const char* subject,
+                                        const char* issuer, const char* new_fingerprint,
+                                        const char* old_subject, const char* old_issuer,
+                                        const char* old_fingerprint, DWORD flags)
+{
+	const char* type = type_str_for_flags(flags);
+
+	WINPR_ASSERT(instance);
+	WINPR_ASSERT(instance->context);
+	WINPR_ASSERT(instance->context->settings);
+
+	SDLConnectionDialogHider hider(instance);
+	/* Newer versions of FreeRDP allow exposing the whole PEM by setting
+	 * FreeRDP_CertificateCallbackPreferPEM to TRUE
+	 */
+	char* new_fp_str = nullptr;
+	size_t len = 0;
+	if (flags & VERIFY_CERT_FLAG_FP_IS_PEM)
+		new_fp_str = sdl_pem_cert(new_fingerprint);
+	else
+		winpr_asprintf(&new_fp_str, &len, "Thumbprint:  %s\n", new_fingerprint);
+
+	/* Newer versions of FreeRDP allow exposing the whole PEM by setting
+	 * FreeRDP_CertificateCallbackPreferPEM to TRUE
+	 */
+	char* old_fp_str = nullptr;
+	size_t olen = 0;
+	if (flags & VERIFY_CERT_FLAG_FP_IS_PEM)
+		old_fp_str = sdl_pem_cert(old_fingerprint);
+	else
+		winpr_asprintf(&old_fp_str, &olen, "Thumbprint:  %s\n", old_fingerprint);
+
+	const char* collission_str = "";
+	if (flags & VERIFY_CERT_FLAG_MATCH_LEGACY_SHA1)
+	{
+		collission_str =
+		    "A matching entry with legacy SHA1 was found in local known_hosts2 store.\n"
+		    "If you just upgraded from a FreeRDP version before 2.0 this is expected.\n"
+		    "The hashing algorithm has been upgraded from SHA1 to SHA256.\n"
+		    "All manually accepted certificates must be reconfirmed!\n"
+		    "\n";
+	}
+
+	char* title = nullptr;
+	size_t tlen = 0;
+	winpr_asprintf(&title, &tlen, "Certificate for %s:%" PRIu16 " (%s) has changed", host, port,
+	               type);
+
+	char* message = nullptr;
+	size_t mlen = 0;
+	winpr_asprintf(&message, &mlen,
+	               "New Certificate details:\n"
+	               "Common Name: %s\n"
+	               "Subject:     %s\n"
+	               "Issuer:      %s\n"
+	               "%s\n"
+	               "Old Certificate details:\n"
+	               "Subject:     %s\n"
+	               "Issuer:      %s\n"
+	               "%s\n"
+	               "%s\n"
+	               "The above X.509 certificate does not match the certificate used for previous "
+	               "connections.\n"
+	               "This may indicate that the certificate has been tampered with.\n"
+	               "Please contact the administrator of the RDP server and clarify.\n",
+	               common_name, subject, issuer, new_fp_str, old_subject, old_issuer, old_fp_str,
+	               collission_str);
+
+	const DWORD rc = sdl_show_ceritifcate_dialog(instance->context, title, message);
+	free(title);
+	free(message);
+	free(new_fp_str);
+	free(old_fp_str);
+
+	return rc;
+}
+
+DWORD sdl_verify_certificate_ex(freerdp* instance, const char* host, UINT16 port,
+                                const char* common_name, const char* subject, const char* issuer,
+                                const char* fingerprint, DWORD flags)
+{
+	const char* type = type_str_for_flags(flags);
+
+	/* Newer versions of FreeRDP allow exposing the whole PEM by setting
+	 * FreeRDP_CertificateCallbackPreferPEM to TRUE
+	 */
+	char* fp_str = nullptr;
+	size_t len = 0;
+	if (flags & VERIFY_CERT_FLAG_FP_IS_PEM)
+		fp_str = sdl_pem_cert(fingerprint);
+	else
+		winpr_asprintf(&fp_str, &len, "Thumbprint:  %s\n", fingerprint);
+
+	char* title = nullptr;
+	size_t tlen = 0;
+	winpr_asprintf(&title, &tlen, "New certificate for %s:%" PRIu16 " (%s)", host, port, type);
+
+	char* message = nullptr;
+	size_t mlen = 0;
+	winpr_asprintf(
+	    &message, &mlen,
+	    "Common Name: %s\n"
+	    "Subject:     %s\n"
+	    "Issuer:      %s\n"
+	    "%s\n"
+	    "The above X.509 certificate could not be verified, possibly because you do not have\n"
+	    "the CA certificate in your certificate store, or the certificate has expired.\n"
+	    "Please look at the OpenSSL documentation on how to add a private CA to the store.\n",
+	    common_name, subject, issuer, fp_str);
+
+	SDLConnectionDialogHider hider(instance);
+	const DWORD rc = sdl_show_ceritifcate_dialog(instance->context, title, message);
+	free(fp_str);
+	free(title);
+	free(message);
+	return rc;
+}
+
+BOOL sdl_cert_dialog_show(const char* title, const char* message)
+{
+	int buttonid = -1;
+	enum
+	{
+		BUTTONID_CERT_ACCEPT_PERMANENT = 23,
+		BUTTONID_CERT_ACCEPT_TEMPORARY = 24,
+		BUTTONID_CERT_DENY = 25
+	};
+	const SDL_MessageBoxButtonData buttons[] = {
+		{ 0, BUTTONID_CERT_ACCEPT_PERMANENT, "permanent" },
+		{ SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT, BUTTONID_CERT_ACCEPT_TEMPORARY, "temporary" },
+		{ SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT, BUTTONID_CERT_DENY, "cancel" }
+	};
+
+	const SDL_MessageBoxData data = { SDL_MESSAGEBOX_WARNING, nullptr, title,  message,
+		                              ARRAYSIZE(buttons),     buttons, nullptr };
+	const int rc = SDL_ShowMessageBox(&data, &buttonid);
+
+	Sint32 value = -1;
+	if (rc < 0)
+		value = 0;
+	else
+	{
+		switch (buttonid)
+		{
+			case BUTTONID_CERT_ACCEPT_PERMANENT:
+				value = 1;
+				break;
+			case BUTTONID_CERT_ACCEPT_TEMPORARY:
+				value = 2;
+				break;
+			default:
+				value = 0;
+				break;
+		}
+	}
+
+	return sdl_push_user_event(SDL_USEREVENT_CERT_RESULT, value);
+}
+
+BOOL sdl_message_dialog_show(const char* title, const char* message, Sint32 flags)
+{
+	int buttonid = -1;
+	enum
+	{
+		BUTTONID_SHOW_ACCEPT = 24,
+		BUTTONID_SHOW_DENY = 25
+	};
+	const SDL_MessageBoxButtonData buttons[] = {
+		{ SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT, BUTTONID_SHOW_ACCEPT, "accept" },
+		{ SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT, BUTTONID_SHOW_DENY, "cancel" }
+	};
+
+	const int button_cnt = (flags & SHOW_DIALOG_ACCEPT_REJECT) ? 2 : 1;
+	const SDL_MessageBoxData data = {
+		SDL_MESSAGEBOX_WARNING, nullptr, title, message, button_cnt, buttons, nullptr
+	};
+	const int rc = SDL_ShowMessageBox(&data, &buttonid);
+
+	Sint32 value = -1;
+	if (rc < 0)
+		value = 0;
+	else
+	{
+		switch (buttonid)
+		{
+			case BUTTONID_SHOW_ACCEPT:
+				value = 1;
+				break;
+			default:
+				value = 0;
+				break;
+		}
+	}
+
+	return sdl_push_user_event(SDL_USEREVENT_SHOW_RESULT, value);
+}
+
+BOOL sdl_auth_dialog_show(const SDL_UserAuthArg* args)
+{
+	std::vector<std::string> auth = { "Username:        ", "Domain:          ",
+		                              "Password:        " };
+	std::vector<std::string> authPin = { "Device:       ", "PIN:        " };
+	std::vector<std::string> gw = { "GatewayUsername: ", "GatewayDomain:   ", "GatewayPassword: " };
+	std::vector<std::string> prompt;
+	Sint32 rc = -1;
+
+	switch (args->result)
+	{
+		case AUTH_SMARTCARD_PIN:
+			prompt = std::move(authPin);
+			break;
+		case AUTH_TLS:
+		case AUTH_RDP:
+		case AUTH_NLA:
+			prompt = std::move(auth);
+			break;
+		case GW_AUTH_HTTP:
+		case GW_AUTH_RDG:
+		case GW_AUTH_RPC:
+			prompt = std::move(gw);
+			break;
+		default:
+			break;
+	}
+
+	std::vector<std::string> result;
+
+	if (!prompt.empty())
+	{
+		std::vector<std::string> initial{ args->user ? args->user : "Smartcard", "" };
+		std::vector<Uint32> flags = { SdlInputWidget::SDL_INPUT_READONLY,
+			                          SdlInputWidget::SDL_INPUT_MASK };
+		if (args->result != AUTH_SMARTCARD_PIN)
+		{
+			initial = { args->user ? args->user : "", args->domain ? args->domain : "",
+				        args->password ? args->password : "" };
+			flags = { 0, 0, SdlInputWidget::SDL_INPUT_MASK };
+		}
+		SdlInputWidgetList ilist(args->title, prompt, initial, flags);
+		rc = ilist.run(result);
+	}
+
+	if ((result.size() < prompt.size()))
+		rc = -1;
+
+	char* user = nullptr;
+	char* domain = nullptr;
+	char* pwd = nullptr;
+	if (rc > 0)
+	{
+		user = _strdup(result[0].c_str());
+		if (args->result == AUTH_SMARTCARD_PIN)
+			pwd = _strdup(result[1].c_str());
+		else
+		{
+			domain = _strdup(result[1].c_str());
+			pwd = _strdup(result[2].c_str());
+		}
+	}
+	return sdl_push_user_event(SDL_USEREVENT_AUTH_RESULT, user, domain, pwd, rc);
+}
+
+BOOL sdl_scard_dialog_show(const char* title, Sint32 count, const char** list)
+{
+	const auto scount = WINPR_ASSERTING_INT_CAST(size_t, count);
+	std::vector<std::string> vlist;
+	vlist.reserve(scount);
+	for (size_t x = 0; x < scount; x++)
+		vlist.emplace_back(list[x]);
+	SdlSelectList slist(title, vlist);
+	Sint32 value = slist.run();
+	return sdl_push_user_event(SDL_USEREVENT_SCARD_RESULT, value);
+}

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/dialogs/sdl_dialogs.hpp

@@ -0,0 +1,53 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client helper dialogs
+ *
+ * Copyright 2023 Armin Novak <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <winpr/wtypes.h>
+#include <freerdp/freerdp.h>
+
+#include "../sdl_types.hpp"
+#include "../sdl_utils.hpp"
+
+BOOL sdl_authenticate_ex(freerdp* instance, char** username, char** password, char** domain,
+                         rdp_auth_reason reason);
+BOOL sdl_choose_smartcard(freerdp* instance, SmartcardCertInfo** cert_list, DWORD count,
+                          DWORD* choice, BOOL gateway);
+
+SSIZE_T sdl_retry_dialog(freerdp* instance, const char* what, size_t current, void* userarg);
+
+DWORD sdl_verify_certificate_ex(freerdp* instance, const char* host, UINT16 port,
+                                const char* common_name, const char* subject, const char* issuer,
+                                const char* fingerprint, DWORD flags);
+
+DWORD sdl_verify_changed_certificate_ex(freerdp* instance, const char* host, UINT16 port,
+                                        const char* common_name, const char* subject,
+                                        const char* issuer, const char* new_fingerprint,
+                                        const char* old_subject, const char* old_issuer,
+                                        const char* old_fingerprint, DWORD flags);
+
+int sdl_logon_error_info(freerdp* instance, UINT32 data, UINT32 type);
+
+BOOL sdl_present_gateway_message(freerdp* instance, UINT32 type, BOOL isDisplayMandatory,
+                                 BOOL isConsentMandatory, size_t length, const WCHAR* message);
+
+BOOL sdl_message_dialog_show(const char* title, const char* message, Sint32 flags);
+BOOL sdl_cert_dialog_show(const char* title, const char* message);
+BOOL sdl_scard_dialog_show(const char* title, Sint32 count, const char** list);
+BOOL sdl_auth_dialog_show(const SDL_UserAuthArg* args);

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/dialogs/sdl_input.cpp

@@ -0,0 +1,177 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client helper dialogs
+ *
+ * Copyright 2023 Armin Novak <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "sdl_input.hpp"
+
+#include <cassert>
+
+#include <string>
+#include <utility>
+
+#include <SDL.h>
+#include <SDL_ttf.h>
+
+#include "sdl_widget.hpp"
+#include "sdl_button.hpp"
+#include "sdl_buttons.hpp"
+
+static const SDL_Color inputbackgroundcolor = { 0x56, 0x56, 0x56, 0xff };
+static const SDL_Color inputhighlightcolor = { 0x80, 0, 0, 0x60 };
+static const SDL_Color inputmouseovercolor = { 0, 0x80, 0, 0x60 };
+static const SDL_Color inputfontcolor = { 0xd1, 0xcf, 0xcd, 0xff };
+static const SDL_Color labelbackgroundcolor = { 0x56, 0x56, 0x56, 0xff };
+static const SDL_Color labelfontcolor = { 0xd1, 0xcf, 0xcd, 0xff };
+static const Uint32 vpadding = 5;
+static const Uint32 hpadding = 10;
+
+SdlInputWidget::SdlInputWidget(SDL_Renderer* renderer, std::string label, std::string initial,
+                               Uint32 flags, size_t offset, size_t width, size_t height)
+    : _flags(flags), _text(std::move(initial)), _text_label(std::move(label)),
+      _label(renderer,
+             { 0, static_cast<int>(offset * (height + vpadding)), static_cast<int>(width),
+               static_cast<int>(height) },
+             false),
+      _input(renderer,
+             { static_cast<int>(width + hpadding), static_cast<int>(offset * (height + vpadding)),
+               static_cast<int>(width), static_cast<int>(height) },
+             true),
+      _highlight(false), _mouseover(false)
+{
+}
+
+SdlInputWidget::SdlInputWidget(SdlInputWidget&& other) noexcept
+    : _flags(other._flags), _text(std::move(other._text)),
+      _text_label(std::move(other._text_label)), _label(std::move(other._label)),
+      _input(std::move(other._input)), _highlight(other._highlight), _mouseover(other._mouseover)
+{
+}
+
+bool SdlInputWidget::fill_label(SDL_Renderer* renderer, SDL_Color color)
+{
+	if (!_label.fill(renderer, color))
+		return false;
+	return _label.update_text(renderer, _text_label, labelfontcolor);
+}
+
+bool SdlInputWidget::update_label(SDL_Renderer* renderer)
+{
+	return _label.update_text(renderer, _text_label, labelfontcolor, labelbackgroundcolor);
+}
+
+bool SdlInputWidget::set_mouseover(SDL_Renderer* renderer, bool mouseOver)
+{
+	if (readonly())
+		return true;
+	_mouseover = mouseOver;
+	return update_input(renderer);
+}
+
+bool SdlInputWidget::set_highlight(SDL_Renderer* renderer, bool highlight)
+{
+	if (readonly())
+		return true;
+	_highlight = highlight;
+	return update_input(renderer);
+}
+
+bool SdlInputWidget::update_input(SDL_Renderer* renderer)
+{
+	std::vector<SDL_Color> colors = { inputbackgroundcolor };
+	if (_highlight)
+		colors.push_back(inputhighlightcolor);
+	if (_mouseover)
+		colors.push_back(inputmouseovercolor);
+
+	if (!_input.fill(renderer, colors))
+		return false;
+	return update_input(renderer, inputfontcolor);
+}
+
+bool SdlInputWidget::resize_input(size_t size)
+{
+	_text.resize(size);
+
+	return true;
+}
+
+bool SdlInputWidget::set_str(SDL_Renderer* renderer, const std::string& text)
+{
+	if (readonly())
+		return true;
+	_text = text;
+	if (!resize_input(_text.size()))
+		return false;
+	return update_input(renderer);
+}
+
+bool SdlInputWidget::remove_str(SDL_Renderer* renderer, size_t count)
+{
+	if (readonly())
+		return true;
+
+	assert(renderer);
+	if (_text.empty())
+		return true;
+
+	if (!resize_input(_text.size() - count))
+		return false;
+	return update_input(renderer);
+}
+
+bool SdlInputWidget::append_str(SDL_Renderer* renderer, const std::string& text)
+{
+	assert(renderer);
+	if (readonly())
+		return true;
+
+	_text.append(text);
+	if (!resize_input(_text.size()))
+		return false;
+	return update_input(renderer);
+}
+
+const SDL_Rect& SdlInputWidget::input_rect() const
+{
+	return _input.rect();
+}
+
+std::string SdlInputWidget::value() const
+{
+	return _text;
+}
+
+bool SdlInputWidget::readonly() const
+{
+	return (_flags & SDL_INPUT_READONLY) != 0;
+}
+
+bool SdlInputWidget::update_input(SDL_Renderer* renderer, SDL_Color fgcolor)
+{
+	std::string text = _text;
+	if (!text.empty())
+	{
+		if (_flags & SDL_INPUT_MASK)
+		{
+			for (char& x : text)
+				x = '*';
+		}
+	}
+
+	return _input.update_text(renderer, text, fgcolor);
+}

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/dialogs/sdl_input.hpp

@@ -0,0 +1,73 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client helper dialogs
+ *
+ * Copyright 2023 Armin Novak <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <vector>
+#include <string>
+
+#include <SDL.h>
+#include "sdl_widget.hpp"
+
+class SdlInputWidget
+{
+  public:
+	enum
+	{
+		SDL_INPUT_MASK = 1,
+		SDL_INPUT_READONLY = 2
+	};
+
+	SdlInputWidget(SDL_Renderer* renderer, std::string label, std::string initial, Uint32 flags,
+	               size_t offset, size_t width, size_t height);
+	SdlInputWidget(SdlInputWidget&& other) noexcept;
+	SdlInputWidget(const SdlInputWidget& other) = delete;
+
+	SdlInputWidget& operator=(const SdlInputWidget& other) = delete;
+	SdlInputWidget& operator=(SdlInputWidget&& other) = delete;
+
+	bool fill_label(SDL_Renderer* renderer, SDL_Color color);
+	bool update_label(SDL_Renderer* renderer);
+
+	bool set_mouseover(SDL_Renderer* renderer, bool mouseOver);
+	bool set_highlight(SDL_Renderer* renderer, bool highlight);
+	bool update_input(SDL_Renderer* renderer);
+	bool resize_input(size_t size);
+
+	bool set_str(SDL_Renderer* renderer, const std::string& text);
+	bool remove_str(SDL_Renderer* renderer, size_t count);
+	bool append_str(SDL_Renderer* renderer, const std::string& text);
+
+	[[nodiscard]] const SDL_Rect& input_rect() const;
+	[[nodiscard]] std::string value() const;
+
+	[[nodiscard]] bool readonly() const;
+
+  protected:
+	bool update_input(SDL_Renderer* renderer, SDL_Color fgcolor);
+
+  private:
+	Uint32 _flags;
+	std::string _text;
+	std::string _text_label;
+	SdlWidget _label;
+	SdlWidget _input;
+	bool _highlight;
+	bool _mouseover;
+};

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/dialogs/sdl_input_widgets.cpp

@@ -0,0 +1,299 @@
+#include <cassert>
+#include <limits>
+#include <algorithm>
+#include <cinttypes>
+
+#include "sdl_input_widgets.hpp"
+
+static const Uint32 vpadding = 5;
+
+SdlInputWidgetList::SdlInputWidgetList(const std::string& title,
+                                       const std::vector<std::string>& labels,
+                                       const std::vector<std::string>& initial,
+                                       const std::vector<Uint32>& flags)
+    : _window(nullptr), _renderer(nullptr)
+{
+	assert(labels.size() == initial.size());
+	assert(labels.size() == flags.size());
+	const std::vector<int> buttonids = { INPUT_BUTTON_ACCEPT, INPUT_BUTTON_CANCEL };
+	const std::vector<std::string> buttonlabels = { "accept", "cancel" };
+
+	const size_t widget_width = 300;
+	const size_t widget_heigth = 50;
+
+	const size_t total_width = widget_width + widget_width;
+	const size_t input_height = labels.size() * (widget_heigth + vpadding) + vpadding;
+	const size_t total_height = input_height + widget_heigth;
+
+	assert(total_width <= INT32_MAX);
+	assert(total_height <= INT32_MAX);
+	Uint32 wflags = SDL_WINDOW_ALLOW_HIGHDPI | SDL_WINDOW_MOUSE_FOCUS | SDL_WINDOW_INPUT_FOCUS;
+	auto rc =
+	    SDL_CreateWindowAndRenderer(static_cast<int>(total_width), static_cast<int>(total_height),
+	                                wflags, &_window, &_renderer);
+	if (rc != 0)
+		widget_log_error(rc, "SDL_CreateWindowAndRenderer");
+	else
+	{
+		SDL_SetWindowTitle(_window, title.c_str());
+		for (size_t x = 0; x < labels.size(); x++)
+			_list.emplace_back(_renderer, labels[x], initial[x], flags[x], x, widget_width,
+			                   widget_heigth);
+
+		_buttons.populate(_renderer, buttonlabels, buttonids, total_width,
+		                  static_cast<Sint32>(input_height), static_cast<Sint32>(widget_width),
+		                  static_cast<Sint32>(widget_heigth));
+		_buttons.set_highlight(0);
+	}
+}
+
+ssize_t SdlInputWidgetList::next(ssize_t current)
+{
+	size_t iteration = 0;
+	auto val = static_cast<size_t>(current);
+
+	do
+	{
+		if (iteration >= _list.size())
+			return -1;
+
+		if (iteration == 0)
+		{
+			if (current < 0)
+				val = 0;
+			else
+				val++;
+		}
+		else
+			val++;
+		iteration++;
+		val %= _list.size();
+	} while (!valid(static_cast<ssize_t>(val)));
+	return static_cast<ssize_t>(val);
+}
+
+bool SdlInputWidgetList::valid(ssize_t current) const
+{
+	if (current < 0)
+		return false;
+	auto s = static_cast<size_t>(current);
+	if (s >= _list.size())
+		return false;
+	return !_list[s].readonly();
+}
+
+SdlInputWidget* SdlInputWidgetList::get(ssize_t index)
+{
+	if (index < 0)
+		return nullptr;
+	auto s = static_cast<size_t>(index);
+	if (s >= _list.size())
+		return nullptr;
+	return &_list[s];
+}
+
+SdlInputWidgetList::~SdlInputWidgetList()
+{
+	_list.clear();
+	_buttons.clear();
+	SDL_DestroyRenderer(_renderer);
+	SDL_DestroyWindow(_window);
+}
+
+bool SdlInputWidgetList::update(SDL_Renderer* renderer)
+{
+	for (auto& btn : _list)
+	{
+		if (!btn.update_label(renderer))
+			return false;
+		if (!btn.update_input(renderer))
+			return false;
+	}
+
+	return _buttons.update(renderer);
+}
+
+ssize_t SdlInputWidgetList::get_index(const SDL_MouseButtonEvent& button)
+{
+	const Sint32 x = button.x;
+	const Sint32 y = button.y;
+
+	assert(_list.size() <= std::numeric_limits<ssize_t>::max());
+	for (size_t i = 0; i < _list.size(); i++)
+	{
+		auto& cur = _list[i];
+		auto r = cur.input_rect();
+
+		if ((x >= r.x) && (x <= r.x + r.w) && (y >= r.y) && (y <= r.y + r.h))
+			return static_cast<ssize_t>(i);
+	}
+	return -1;
+}
+
+int SdlInputWidgetList::run(std::vector<std::string>& result)
+{
+	int res = -1;
+	ssize_t LastActiveTextInput = -1;
+	ssize_t CurrentActiveTextInput = next(-1);
+
+	if (!_window || !_renderer)
+		return -2;
+
+	try
+	{
+		bool running = true;
+		std::vector<SDL_Keycode> pressed;
+		while (running)
+		{
+			if (!clear_window(_renderer))
+				throw;
+
+			if (!update(_renderer))
+				throw;
+
+			if (!_buttons.update(_renderer))
+				throw;
+
+			SDL_Event event = {};
+			SDL_WaitEvent(&event);
+			switch (event.type)
+			{
+				case SDL_KEYUP:
+				{
+					auto it = std::remove(pressed.begin(), pressed.end(), event.key.keysym.sym);
+					pressed.erase(it, pressed.end());
+
+					switch (event.key.keysym.sym)
+					{
+						case SDLK_BACKSPACE:
+						{
+							auto cur = get(CurrentActiveTextInput);
+							if (cur)
+							{
+								if (!cur->remove_str(_renderer, 1))
+									throw;
+							}
+						}
+						break;
+						case SDLK_TAB:
+							CurrentActiveTextInput = next(CurrentActiveTextInput);
+							break;
+						case SDLK_RETURN:
+						case SDLK_RETURN2:
+						case SDLK_KP_ENTER:
+							running = false;
+							res = INPUT_BUTTON_ACCEPT;
+							break;
+						case SDLK_ESCAPE:
+							running = false;
+							res = INPUT_BUTTON_CANCEL;
+							break;
+						case SDLK_v:
+							if (pressed.size() == 2)
+							{
+								if ((pressed[0] == SDLK_LCTRL) || (pressed[0] == SDLK_RCTRL))
+								{
+									auto cur = get(CurrentActiveTextInput);
+									if (cur)
+									{
+										auto text = SDL_GetClipboardText();
+										cur->set_str(_renderer, text);
+									}
+								}
+							}
+							break;
+						default:
+							break;
+					}
+				}
+				break;
+				case SDL_KEYDOWN:
+					pressed.push_back(event.key.keysym.sym);
+					break;
+				case SDL_TEXTINPUT:
+				{
+					auto cur = get(CurrentActiveTextInput);
+					if (cur)
+					{
+						if (!cur->append_str(_renderer, event.text.text))
+							throw;
+					}
+				}
+				break;
+				case SDL_MOUSEMOTION:
+				{
+					auto TextInputIndex = get_index(event.button);
+					for (auto& cur : _list)
+					{
+						if (!cur.set_mouseover(_renderer, false))
+							throw;
+					}
+					if (TextInputIndex >= 0)
+					{
+						auto& cur = _list[static_cast<size_t>(TextInputIndex)];
+						if (!cur.set_mouseover(_renderer, true))
+							throw;
+					}
+
+					_buttons.set_mouseover(event.button.x, event.button.y);
+				}
+				break;
+				case SDL_MOUSEBUTTONDOWN:
+				{
+					auto val = get_index(event.button);
+					if (valid(val))
+						CurrentActiveTextInput = val;
+
+					auto button = _buttons.get_selected(event.button);
+					if (button)
+					{
+						running = false;
+						if (button->id() == INPUT_BUTTON_CANCEL)
+							res = INPUT_BUTTON_CANCEL;
+						else
+							res = INPUT_BUTTON_ACCEPT;
+					}
+				}
+				break;
+				case SDL_QUIT:
+					res = INPUT_BUTTON_CANCEL;
+					running = false;
+					break;
+				default:
+					break;
+			}
+
+			if (LastActiveTextInput != CurrentActiveTextInput)
+			{
+				if (CurrentActiveTextInput < 0)
+					SDL_StopTextInput();
+				else
+					SDL_StartTextInput();
+				LastActiveTextInput = CurrentActiveTextInput;
+			}
+
+			for (auto& cur : _list)
+			{
+				if (!cur.set_highlight(_renderer, false))
+					throw;
+			}
+			auto cur = get(CurrentActiveTextInput);
+			if (cur)
+			{
+				if (!cur->set_highlight(_renderer, true))
+					throw;
+			}
+
+			SDL_RenderPresent(_renderer);
+		}
+
+		for (auto& cur : _list)
+			result.push_back(cur.value());
+	}
+	catch (...)
+	{
+		res = -2;
+	}
+
+	return res;
+}

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/dialogs/sdl_input_widgets.hpp

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <SDL.h>
+
+#include "sdl_input.hpp"
+#include "sdl_buttons.hpp"
+
+class SdlInputWidgetList
+{
+  public:
+	SdlInputWidgetList(const std::string& title, const std::vector<std::string>& labels,
+	                   const std::vector<std::string>& initial, const std::vector<Uint32>& flags);
+	SdlInputWidgetList(const SdlInputWidgetList& other) = delete;
+	SdlInputWidgetList(SdlInputWidgetList&& other) = delete;
+
+	SdlInputWidgetList& operator=(const SdlInputWidgetList& other) = delete;
+	SdlInputWidgetList& operator=(SdlInputWidgetList&& other) = delete;
+
+	virtual ~SdlInputWidgetList();
+
+	int run(std::vector<std::string>& result);
+
+  protected:
+	bool update(SDL_Renderer* renderer);
+	ssize_t get_index(const SDL_MouseButtonEvent& button);
+
+  private:
+	enum
+	{
+		INPUT_BUTTON_ACCEPT = 1,
+		INPUT_BUTTON_CANCEL = -2
+	};
+
+	ssize_t next(ssize_t current);
+	[[nodiscard]] bool valid(ssize_t current) const;
+	SdlInputWidget* get(ssize_t index);
+
+	SDL_Window* _window;
+	SDL_Renderer* _renderer;
+	std::vector<SdlInputWidget> _list;
+	SdlButtonList _buttons;
+};

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/dialogs/sdl_select.cpp

@@ -0,0 +1,72 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client helper dialogs
+ *
+ * Copyright 2023 Armin Novak <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <cassert>
+
+#include <string>
+#include <utility>
+
+#include <SDL.h>
+#include <SDL_ttf.h>
+
+#include "sdl_select.hpp"
+#include "sdl_widget.hpp"
+#include "sdl_button.hpp"
+#include "sdl_buttons.hpp"
+#include "sdl_input_widgets.hpp"
+
+static const SDL_Color labelmouseovercolor = { 0, 0x80, 0, 0x60 };
+static const SDL_Color labelbackgroundcolor = { 0x69, 0x66, 0x63, 0xff };
+static const SDL_Color labelhighlightcolor = { 0xcd, 0xca, 0x35, 0x60 };
+static const SDL_Color labelfontcolor = { 0xd1, 0xcf, 0xcd, 0xff };
+
+SdlSelectWidget::SdlSelectWidget(SDL_Renderer* renderer, std::string label, SDL_Rect rect)
+    : SdlWidget(renderer, rect, true), _text(std::move(label)), _mouseover(false), _highlight(false)
+{
+	update_text(renderer);
+}
+
+SdlSelectWidget::SdlSelectWidget(SdlSelectWidget&& other) noexcept = default;
+
+SdlSelectWidget::~SdlSelectWidget() = default;
+
+bool SdlSelectWidget::set_mouseover(SDL_Renderer* renderer, bool mouseOver)
+{
+	_mouseover = mouseOver;
+	return update_text(renderer);
+}
+
+bool SdlSelectWidget::set_highlight(SDL_Renderer* renderer, bool highlight)
+{
+	_highlight = highlight;
+	return update_text(renderer);
+}
+
+bool SdlSelectWidget::update_text(SDL_Renderer* renderer)
+{
+	assert(renderer);
+	std::vector<SDL_Color> colors = { labelbackgroundcolor };
+	if (_highlight)
+		colors.push_back(labelhighlightcolor);
+	if (_mouseover)
+		colors.push_back(labelmouseovercolor);
+	if (!fill(renderer, colors))
+		return false;
+	return SdlWidget::update_text(renderer, _text, labelfontcolor);
+}

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/dialogs/sdl_select.hpp

@@ -0,0 +1,47 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client helper dialogs
+ *
+ * Copyright 2023 Armin Novak <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include <SDL.h>
+#include "sdl_widget.hpp"
+
+class SdlSelectWidget : public SdlWidget
+{
+  public:
+	SdlSelectWidget(SDL_Renderer* renderer, std::string label, SDL_Rect rect);
+	SdlSelectWidget(SdlSelectWidget&& other) noexcept;
+	~SdlSelectWidget() override;
+
+	bool set_mouseover(SDL_Renderer* renderer, bool mouseOver);
+	bool set_highlight(SDL_Renderer* renderer, bool highlight);
+	bool update_text(SDL_Renderer* renderer);
+
+	SdlSelectWidget(const SdlSelectWidget& other) = delete;
+	SdlSelectWidget& operator=(const SdlSelectWidget& other) = delete;
+	SdlSelectWidget& operator=(SdlSelectWidget&& other) = delete;
+
+  private:
+	std::string _text;
+	bool _mouseover;
+	bool _highlight;
+};

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/dialogs/sdl_selectlist.cpp

@@ -0,0 +1,217 @@
+#include <cassert>
+
+#include <winpr/cast.h>
+
+#include "sdl_selectlist.hpp"
+
+static const Uint32 vpadding = 5;
+
+SdlSelectList::SdlSelectList(const std::string& title, const std::vector<std::string>& labels)
+    : _window(nullptr), _renderer(nullptr)
+{
+	const size_t widget_height = 50;
+	const size_t widget_width = 600;
+
+	const size_t total_height = labels.size() * (widget_height + vpadding) + vpadding;
+	const size_t height = total_height + widget_height;
+	assert(widget_width <= INT32_MAX);
+	assert(height <= INT32_MAX);
+
+	auto flags = WINPR_ASSERTING_INT_CAST(
+	    uint32_t, SDL_WINDOW_ALLOW_HIGHDPI | SDL_WINDOW_MOUSE_FOCUS | SDL_WINDOW_INPUT_FOCUS);
+	auto rc = SDL_CreateWindowAndRenderer(static_cast<int>(widget_width), static_cast<int>(height),
+	                                      flags, &_window, &_renderer);
+	if (rc != 0)
+		widget_log_error(rc, "SDL_CreateWindowAndRenderer");
+	else
+	{
+		SDL_SetWindowTitle(_window, title.c_str());
+
+		SDL_Rect rect = { 0, 0, widget_width, widget_height };
+		for (auto& label : labels)
+		{
+			_list.emplace_back(_renderer, label, rect);
+			rect.y += widget_height + vpadding;
+		}
+
+		const std::vector<int> buttonids = { INPUT_BUTTON_ACCEPT, INPUT_BUTTON_CANCEL };
+		const std::vector<std::string> buttonlabels = { "accept", "cancel" };
+		_buttons.populate(_renderer, buttonlabels, buttonids, widget_width,
+		                  static_cast<Sint32>(total_height), static_cast<Sint32>(widget_width / 2),
+		                  static_cast<Sint32>(widget_height));
+		_buttons.set_highlight(0);
+	}
+}
+
+SdlSelectList::~SdlSelectList()
+{
+	_list.clear();
+	_buttons.clear();
+	SDL_DestroyRenderer(_renderer);
+	SDL_DestroyWindow(_window);
+}
+
+int SdlSelectList::run()
+{
+	int res = -2;
+	ssize_t CurrentActiveTextInput = 0;
+	bool running = true;
+
+	if (!_window || !_renderer)
+		return -2;
+	try
+	{
+		while (running)
+		{
+			if (!clear_window(_renderer))
+				throw;
+
+			if (!update_text())
+				throw;
+
+			if (!_buttons.update(_renderer))
+				throw;
+
+			SDL_Event event = {};
+			SDL_WaitEvent(&event);
+			switch (event.type)
+			{
+				case SDL_KEYDOWN:
+					switch (event.key.keysym.sym)
+					{
+						case SDLK_UP:
+						case SDLK_BACKSPACE:
+							if (CurrentActiveTextInput > 0)
+								CurrentActiveTextInput--;
+							else
+								CurrentActiveTextInput =
+								    WINPR_ASSERTING_INT_CAST(ssize_t, _list.size() - 1);
+							break;
+						case SDLK_DOWN:
+						case SDLK_TAB:
+						{
+							if (CurrentActiveTextInput < 0)
+								CurrentActiveTextInput = 0;
+							else
+								CurrentActiveTextInput++;
+
+							const auto s = _list.size();
+							if (s <= 0)
+								CurrentActiveTextInput = 0;
+							else
+								CurrentActiveTextInput =
+								    CurrentActiveTextInput % WINPR_ASSERTING_INT_CAST(ssize_t, s);
+						}
+						break;
+						case SDLK_RETURN:
+						case SDLK_RETURN2:
+						case SDLK_KP_ENTER:
+							running = false;
+							res = WINPR_ASSERTING_INT_CAST(int, CurrentActiveTextInput);
+							break;
+						case SDLK_ESCAPE:
+							running = false;
+							res = INPUT_BUTTON_CANCEL;
+							break;
+						default:
+							break;
+					}
+					break;
+				case SDL_MOUSEMOTION:
+				{
+					ssize_t TextInputIndex = get_index(event.button);
+					reset_mouseover();
+					if (TextInputIndex >= 0)
+					{
+						auto& cur = _list[WINPR_ASSERTING_INT_CAST(size_t, TextInputIndex)];
+						if (!cur.set_mouseover(_renderer, true))
+							throw;
+					}
+
+					_buttons.set_mouseover(event.button.x, event.button.y);
+				}
+				break;
+				case SDL_MOUSEBUTTONDOWN:
+				{
+					auto button = _buttons.get_selected(event.button);
+					if (button)
+					{
+						running = false;
+						if (button->id() == INPUT_BUTTON_CANCEL)
+							res = INPUT_BUTTON_CANCEL;
+						else
+							res = static_cast<int>(CurrentActiveTextInput);
+					}
+					else
+					{
+						CurrentActiveTextInput = get_index(event.button);
+					}
+				}
+				break;
+				case SDL_QUIT:
+					res = INPUT_BUTTON_CANCEL;
+					running = false;
+					break;
+				default:
+					break;
+			}
+
+			reset_highlight();
+			if (CurrentActiveTextInput >= 0)
+			{
+				auto& cur = _list[WINPR_ASSERTING_INT_CAST(size_t, CurrentActiveTextInput)];
+				if (!cur.set_highlight(_renderer, true))
+					throw;
+			}
+
+			SDL_RenderPresent(_renderer);
+		}
+	}
+	catch (...)
+	{
+		return -1;
+	}
+	return res;
+}
+
+ssize_t SdlSelectList::get_index(const SDL_MouseButtonEvent& button)
+{
+	const Sint32 x = button.x;
+	const Sint32 y = button.y;
+	for (size_t i = 0; i < _list.size(); i++)
+	{
+		auto& cur = _list[i];
+		auto r = cur.rect();
+
+		if ((x >= r.x) && (x <= r.x + r.w) && (y >= r.y) && (y <= r.y + r.h))
+			return WINPR_ASSERTING_INT_CAST(ssize_t, i);
+	}
+	return -1;
+}
+
+bool SdlSelectList::update_text()
+{
+	for (auto& cur : _list)
+	{
+		if (!cur.update_text(_renderer))
+			return false;
+	}
+
+	return true;
+}
+
+void SdlSelectList::reset_mouseover()
+{
+	for (auto& cur : _list)
+	{
+		cur.set_mouseover(_renderer, false);
+	}
+}
+
+void SdlSelectList::reset_highlight()
+{
+	for (auto& cur : _list)
+	{
+		cur.set_highlight(_renderer, false);
+	}
+}

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/dialogs/sdl_selectlist.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include <SDL.h>
+
+#include "sdl_select.hpp"
+#include "sdl_button.hpp"
+#include "sdl_buttons.hpp"
+
+class SdlSelectList
+{
+  public:
+	SdlSelectList(const std::string& title, const std::vector<std::string>& labels);
+	virtual ~SdlSelectList();
+
+	int run();
+
+	SdlSelectList(const SdlSelectList& other) = delete;
+	SdlSelectList(SdlSelectList&& other) = delete;
+	SdlSelectList& operator=(const SdlSelectList& other) = delete;
+	SdlSelectList& operator=(SdlSelectList&& other) = delete;
+
+  private:
+	enum
+	{
+		INPUT_BUTTON_ACCEPT = 0,
+		INPUT_BUTTON_CANCEL = -2
+	};
+
+	ssize_t get_index(const SDL_MouseButtonEvent& button);
+	bool update_text();
+	void reset_mouseover();
+	void reset_highlight();
+
+	SDL_Window* _window;
+	SDL_Renderer* _renderer;
+	std::vector<SdlSelectWidget> _list;
+	SdlButtonList _buttons;
+};

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/dialogs/sdl_widget.cpp

@@ -0,0 +1,290 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client helper dialogs
+ *
+ * Copyright 2023 Armin Novak <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <cassert>
+#include <cstdio>
+#include <cstdlib>
+#include <algorithm>
+
+#include <SDL.h>
+#include <SDL_ttf.h>
+
+#include "sdl_widget.hpp"
+#include "../sdl_utils.hpp"
+
+#include "res/sdl2_resource_manager.hpp"
+
+#include <freerdp/log.h>
+
+#if defined(WITH_SDL_IMAGE_DIALOGS)
+#include <SDL_image.h>
+#endif
+
+#define TAG CLIENT_TAG("SDL.widget")
+
+static const SDL_Color backgroundcolor = { 0x38, 0x36, 0x35, 0xff };
+
+static const Uint32 hpadding = 10;
+
+SdlWidget::SdlWidget(SDL_Renderer* renderer, SDL_Rect rect, bool input) : _rect(rect), _input(input)
+{
+	assert(renderer);
+
+	auto ops = SDL2ResourceManager::get(SDLResourceManager::typeFonts(),
+	                                    "OpenSans-VariableFont_wdth,wght.ttf");
+	if (!ops)
+		widget_log_error(-1, "SDLResourceManager::get");
+	else
+	{
+		_font = TTF_OpenFontRW(ops, 1, 64);
+		if (!_font)
+			widget_log_error(-1, "TTF_OpenFontRW");
+	}
+}
+
+#if defined(WITH_SDL_IMAGE_DIALOGS)
+SdlWidget::SdlWidget(SDL_Renderer* renderer, SDL_Rect rect, SDL_RWops* ops) : _rect(rect)
+{
+	if (ops)
+	{
+		_image = IMG_LoadTexture_RW(renderer, ops, 1);
+		if (!_image)
+			widget_log_error(-1, "IMG_LoadTextureTyped_RW");
+	}
+}
+#endif
+
+SdlWidget::SdlWidget(SdlWidget&& other) noexcept
+    : _font(other._font), _image(other._image), _rect(other._rect), _input(other._input),
+      _wrap(other._wrap), _text_width(other._text_width)
+{
+	other._font = nullptr;
+	other._image = nullptr;
+}
+
+SDL_Texture* SdlWidget::render_text(SDL_Renderer* renderer, const std::string& text,
+                                    SDL_Color fgcolor, SDL_Rect& src, SDL_Rect& dst)
+{
+	auto surface = TTF_RenderUTF8_Blended(_font, text.c_str(), fgcolor);
+	if (!surface)
+	{
+		widget_log_error(-1, "TTF_RenderText_Blended");
+		return nullptr;
+	}
+
+	auto texture = SDL_CreateTextureFromSurface(renderer, surface);
+	SDL_FreeSurface(surface);
+	if (!texture)
+	{
+		widget_log_error(-1, "SDL_CreateTextureFromSurface");
+		return nullptr;
+	}
+
+	TTF_SizeUTF8(_font, text.c_str(), &src.w, &src.h);
+
+	/* Do some magic:
+	 * - Add padding before and after text
+	 * - if text is too long only show the last elements
+	 * - if text is too short only update used space
+	 */
+	dst = _rect;
+	dst.x += hpadding;
+	dst.w -= 2 * hpadding;
+	const auto scale = static_cast<float>(dst.h) / static_cast<float>(src.h);
+	const auto sws = static_cast<float>(src.w) * scale;
+	const auto dws = static_cast<float>(dst.w) / scale;
+	if (static_cast<float>(dst.w) > sws)
+		dst.w = static_cast<int>(sws);
+	if (static_cast<float>(src.w) > dws)
+	{
+		src.x = src.w - static_cast<int>(dws);
+		src.w = static_cast<int>(dws);
+	}
+	return texture;
+}
+
+static int scale(int w, int h)
+{
+	const auto dw = static_cast<double>(w);
+	const auto dh = static_cast<double>(h);
+	const auto scale = dh / dw;
+	const auto dr = dh * scale;
+	return static_cast<int>(dr);
+}
+
+SDL_Texture* SdlWidget::render_text_wrapped(SDL_Renderer* renderer, const std::string& text,
+                                            SDL_Color fgcolor, SDL_Rect& src, SDL_Rect& dst)
+{
+	Sint32 w = 0;
+	Sint32 h = 0;
+	TTF_SizeUTF8(_font, " ", &w, &h);
+
+	assert(_text_width <= UINT32_MAX);
+	auto surface = TTF_RenderUTF8_Blended_Wrapped(_font, text.c_str(), fgcolor,
+	                                              static_cast<Uint32>(_text_width));
+	if (!surface)
+	{
+		widget_log_error(-1, "TTF_RenderText_Blended");
+		return nullptr;
+	}
+
+	src.w = surface->w;
+	src.h = surface->h;
+
+	auto texture = SDL_CreateTextureFromSurface(renderer, surface);
+	SDL_FreeSurface(surface);
+	if (!texture)
+	{
+		widget_log_error(-1, "SDL_CreateTextureFromSurface");
+		return nullptr;
+	}
+
+	/* Do some magic:
+	 * - Add padding before and after text
+	 * - if text is too long only show the last elements
+	 * - if text is too short only update used space
+	 */
+	dst = _rect;
+	dst.x += hpadding;
+	dst.w -= 2 * hpadding;
+	auto dh = scale(src.w, src.h);
+	dst.h = std::min<int>(dh, dst.h);
+
+	return texture;
+}
+
+SdlWidget::~SdlWidget()
+{
+	TTF_CloseFont(_font);
+	if (_image)
+		SDL_DestroyTexture(_image);
+}
+
+bool SdlWidget::error_ex(Sint32 res, const char* what, const char* file, size_t line,
+                         const char* fkt)
+{
+	static wLog* log = nullptr;
+	if (!log)
+		log = WLog_Get(TAG);
+	return sdl_log_error_ex(res, log, what, file, line, fkt);
+}
+
+static bool draw_rect(SDL_Renderer* renderer, const SDL_Rect* rect, SDL_Color color)
+{
+	const int drc = SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, color.a);
+	if (widget_log_error(drc, "SDL_SetRenderDrawColor"))
+		return false;
+
+	const int rc = SDL_RenderFillRect(renderer, rect);
+	return !widget_log_error(rc, "SDL_RenderFillRect");
+}
+
+bool SdlWidget::fill(SDL_Renderer* renderer, SDL_Color color)
+{
+	std::vector<SDL_Color> colors = { color };
+	return fill(renderer, colors);
+}
+
+bool SdlWidget::fill(SDL_Renderer* renderer, const std::vector<SDL_Color>& colors)
+{
+	assert(renderer);
+	SDL_BlendMode mode = SDL_BLENDMODE_INVALID;
+	SDL_GetRenderDrawBlendMode(renderer, &mode);
+	SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE);
+	for (auto color : colors)
+	{
+		draw_rect(renderer, &_rect, color);
+		SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_ADD);
+	}
+	SDL_SetRenderDrawBlendMode(renderer, mode);
+	return true;
+}
+
+bool SdlWidget::update_text(SDL_Renderer* renderer, const std::string& text, SDL_Color fgcolor,
+                            SDL_Color bgcolor)
+{
+	assert(renderer);
+
+	if (!fill(renderer, bgcolor))
+		return false;
+	return update_text(renderer, text, fgcolor);
+}
+
+bool SdlWidget::wrap() const
+{
+	return _wrap;
+}
+
+bool SdlWidget::set_wrap(bool wrap, size_t width)
+{
+	_wrap = wrap;
+	_text_width = width;
+	return _wrap;
+}
+
+const SDL_Rect& SdlWidget::rect() const
+{
+	return _rect;
+}
+
+bool SdlWidget::update_text(SDL_Renderer* renderer, const std::string& text, SDL_Color fgcolor)
+{
+
+	if (text.empty())
+		return true;
+
+	SDL_Rect src{};
+	SDL_Rect dst{};
+
+	SDL_Texture* texture = nullptr;
+	if (_image)
+	{
+		texture = _image;
+		dst = _rect;
+		auto rc = SDL_QueryTexture(_image, nullptr, nullptr, &src.w, &src.h);
+		if (rc < 0)
+			widget_log_error(rc, "SDL_QueryTexture");
+	}
+	else if (_wrap)
+		texture = render_text_wrapped(renderer, text, fgcolor, src, dst);
+	else
+		texture = render_text(renderer, text, fgcolor, src, dst);
+	if (!texture)
+		return false;
+
+	const int rc = SDL_RenderCopy(renderer, texture, &src, &dst);
+	if (!_image)
+		SDL_DestroyTexture(texture);
+	if (rc < 0)
+		return !widget_log_error(rc, "SDL_RenderCopy");
+	return true;
+}
+
+bool clear_window(SDL_Renderer* renderer)
+{
+	assert(renderer);
+
+	const int drc = SDL_SetRenderDrawColor(renderer, backgroundcolor.r, backgroundcolor.g,
+	                                       backgroundcolor.b, backgroundcolor.a);
+	if (widget_log_error(drc, "SDL_SetRenderDrawColor"))
+		return false;
+
+	const int rcls = SDL_RenderClear(renderer);
+	return !widget_log_error(rcls, "SDL_RenderClear");
+}

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/dialogs/sdl_widget.hpp

@@ -0,0 +1,90 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client helper dialogs
+ *
+ * Copyright 2023 Armin Novak <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+#include <vector>
+#include <SDL.h>
+#include <SDL_ttf.h>
+
+#if defined(_MSC_VER)
+#include <BaseTsd.h>
+typedef SSIZE_T ssize_t;
+#endif
+
+#if !defined(HAS_NOEXCEPT)
+#if defined(__clang__)
+#if __has_feature(cxx_noexcept)
+#define HAS_NOEXCEPT
+#endif
+#elif defined(__GXX_EXPERIMENTAL_CXX0X__) && __GNUC__ * 10 + __GNUC_MINOR__ >= 46 || \
+    defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023026
+#define HAS_NOEXCEPT
+#endif
+#endif
+
+#ifndef HAS_NOEXCEPT
+#define noexcept
+#endif
+
+class SdlWidget
+{
+  public:
+	SdlWidget(SDL_Renderer* renderer, SDL_Rect rect, bool input);
+#if defined(WITH_SDL_IMAGE_DIALOGS)
+	SdlWidget(SDL_Renderer* renderer, SDL_Rect rect, SDL_RWops* ops);
+#endif
+	SdlWidget(SdlWidget&& other) noexcept;
+	virtual ~SdlWidget();
+
+	bool fill(SDL_Renderer* renderer, SDL_Color color);
+	bool fill(SDL_Renderer* renderer, const std::vector<SDL_Color>& colors);
+	bool update_text(SDL_Renderer* renderer, const std::string& text, SDL_Color fgcolor);
+	bool update_text(SDL_Renderer* renderer, const std::string& text, SDL_Color fgcolor,
+	                 SDL_Color bgcolor);
+
+	[[nodiscard]] bool wrap() const;
+	bool set_wrap(bool wrap = true, size_t width = 0);
+	[[nodiscard]] const SDL_Rect& rect() const;
+
+#define widget_log_error(res, what) SdlWidget::error_ex(res, what, __FILE__, __LINE__, __func__)
+	static bool error_ex(Sint32 res, const char* what, const char* file, size_t line,
+	                     const char* fkt);
+
+	SdlWidget(const SdlWidget& other) = delete;
+	SdlWidget& operator=(const SdlWidget& other) = delete;
+	SdlWidget& operator=(SdlWidget&& other) = delete;
+
+  private:
+	SDL_Texture* render_text(SDL_Renderer* renderer, const std::string& text, SDL_Color fgcolor,
+	                         SDL_Rect& src, SDL_Rect& dst);
+	SDL_Texture* render_text_wrapped(SDL_Renderer* renderer, const std::string& text,
+	                                 SDL_Color fgcolor, SDL_Rect& src, SDL_Rect& dst);
+
+	TTF_Font* _font = nullptr;
+	SDL_Texture* _image = nullptr;
+	SDL_Rect _rect;
+	bool _input = false;
+	bool _wrap = false;
+	size_t _text_width = 0;
+};
+
+bool clear_window(SDL_Renderer* renderer);

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/dialogs/test/CMakeLists.txt

@@ -0,0 +1,25 @@
+set(MODULE_NAME "TestSDL")
+set(MODULE_PREFIX "TEST_SDL")
+
+set(DRIVER ${MODULE_NAME}.cpp)
+
+disable_warnings_for_directory(${CMAKE_CURRENT_BINARY_DIR})
+
+set(TEST_SRCS TestSDLDialogs.cpp)
+
+create_test_sourcelist(SRCS ${DRIVER} ${TEST_SRCS})
+
+add_library(${MODULE_NAME} ${SRCS})
+
+list(APPEND LIBS dialogs)
+
+target_link_libraries(${MODULE_NAME} ${LIBS})
+
+set_target_properties(${MODULE_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${TESTING_OUTPUT_DIRECTORY}")
+
+foreach(test ${TESTS})
+  get_filename_component(TestName ${test} NAME_WE)
+  add_test(${TestName} ${TESTING_OUTPUT_DIRECTORY}/${MODULE_NAME} ${TestName})
+endforeach()
+
+set_property(TARGET ${MODULE_NAME} PROPERTY FOLDER "FreeRDP/Client/Test")

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/dialogs/test/TestSDLDialogs.cpp

@@ -0,0 +1,99 @@
+#include "../sdl_selectlist.hpp"
+#include "../sdl_input_widgets.hpp"
+
+#include <freerdp/api.h>
+#include <winpr/wlog.h>
+
+BOOL sdl_log_error_ex(Uint32 res, wLog* log, const char* what, const char* file, size_t line,
+                      const char* fkt)
+{
+	return FALSE;
+}
+
+static bool test_input_dialog()
+{
+	const auto title = "sometitle";
+	std::vector<std::string> labels;
+	std::vector<std::string> initial;
+	std::vector<Uint32> flags;
+	for (size_t x = 0; x < 12; x++)
+	{
+		labels.push_back("label" + std::to_string(x));
+		initial.push_back(std::to_string(x));
+
+		Uint32 flag = 0;
+		if ((x % 2) != 0)
+			flag |= SdlInputWidget::SDL_INPUT_MASK;
+		if ((x % 3) == 0)
+			flag |= SdlInputWidget::SDL_INPUT_READONLY;
+
+		flags.push_back(flag);
+	}
+	SdlInputWidgetList list{ title, labels, initial, flags };
+	std::vector<std::string> result;
+	auto rc = list.run(result);
+	if (rc < 0)
+	{
+		return false;
+	}
+	if (result.size() != labels.size())
+	{
+		return false;
+	}
+	return true;
+}
+
+static bool test_select_dialog()
+{
+	const auto title = "sometitle";
+	std::vector<std::string> labels;
+	for (size_t x = 0; x < 12; x++)
+	{
+		labels.push_back("label" + std::to_string(x));
+	}
+	SdlSelectList list{ title, labels };
+	auto rc = list.run();
+	if (rc < 0)
+	{
+		return false;
+	}
+	if (static_cast<size_t>(rc) >= labels.size())
+		return false;
+
+	return true;
+}
+
+extern "C"
+{
+	FREERDP_API int TestSDLDialogs(int argc, char* argv[]);
+}
+
+int TestSDLDialogs(int argc, char* argv[])
+{
+	int rc = 0;
+
+	(void)argc;
+	(void)argv;
+
+#if 0
+	SDL_Init(SDL_INIT_VIDEO);
+	try
+	{
+#if 1
+		if (!test_input_dialog())
+			throw -1;
+#endif
+#if 1
+		if (!test_select_dialog())
+			throw -2;
+#endif
+	}
+	catch (int e)
+	{
+		rc = e;
+	}
+	SDL_Quit();
+
+#endif
+	return rc;
+}

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/man/CMakeLists.txt

@@ -0,0 +1,8 @@
+set(DEPS
+    ../../../common/man/freerdp-global-options.1 ../../common/man/sdl-freerdp-config.1
+    ../../../common/man/freerdp-global-envvar.1 ../../../common/man/freerdp-global-config.1
+    ../../common/man/sdl-freerdp-examples.1 ../../../common/man/freerdp-global-links.1
+)
+
+set(VAR_NAMES "VENDOR" "PRODUCT" "VENDOR_PRODUCT" "CMAKE_INSTALL_FULL_SYSCONFDIR")
+generate_and_install_freerdp_man_from_xml(${MODULE_NAME} "1" "${DEPS}" "${VAR_NAMES}")

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL2/man/sdl2-freerdp.1.in

@@ -0,0 +1,15 @@
+.TH "@MANPAGE_NAME@" "1" "@MAN_TODAY@" "freerdp" "@MANPAGE_NAME@"
+.ie \n(.g .ds Aq \(aq
+.el       .ds Aq '
+.nh
+.ad l
+.SH "NAME"
+@MANPAGE_NAME@ \- FreeRDP SDL client
+.SH "SYNOPSIS"
+.PP
+\fB@MANPAGE_NAME@\fR
+[file] [options] [/v:server[:port]]
+.SH "DESCRIPTION"
+.PP
+\fB@MANPAGE_NAME@\fR
+is an SDL Remote Desktop Protocol (RDP) client which is part of the FreeRDP project\&. An RDP server is built\-in to many editions of Windows\&. Alternative servers included ogon, gnome\-remote\-desktop, xrdp and VRDP (VirtualBox)\&.

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL3/dialogs/font/OFL.txt

@@ -0,0 +1,93 @@
+Copyright 2020 The Open Sans Project Authors (https://github.com/googlefonts/opensans)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL3/dialogs/font/README.txt

@@ -0,0 +1,100 @@
+Open Sans Variable Font
+=======================
+
+This download contains Open Sans as both variable fonts and static fonts.
+
+Open Sans is a variable font with these axes:
+  wdth
+  wght
+
+This means all the styles are contained in these files:
+  OpenSans-VariableFont_wdth,wght.ttf
+  OpenSans-Italic-VariableFont_wdth,wght.ttf
+
+If your app fully supports variable fonts, you can now pick intermediate styles
+that aren’t available as static fonts. Not all apps support variable fonts, and
+in those cases you can use the static font files for Open Sans:
+  static/OpenSans_Condensed-Light.ttf
+  static/OpenSans_Condensed-Regular.ttf
+  static/OpenSans_Condensed-Medium.ttf
+  static/OpenSans_Condensed-SemiBold.ttf
+  static/OpenSans_Condensed-Bold.ttf
+  static/OpenSans_Condensed-ExtraBold.ttf
+  static/OpenSans_SemiCondensed-Light.ttf
+  static/OpenSans_SemiCondensed-Regular.ttf
+  static/OpenSans_SemiCondensed-Medium.ttf
+  static/OpenSans_SemiCondensed-SemiBold.ttf
+  static/OpenSans_SemiCondensed-Bold.ttf
+  static/OpenSans_SemiCondensed-ExtraBold.ttf
+  static/OpenSans-Light.ttf
+  static/OpenSans-Regular.ttf
+  static/OpenSans-Medium.ttf
+  static/OpenSans-SemiBold.ttf
+  static/OpenSans-Bold.ttf
+  static/OpenSans-ExtraBold.ttf
+  static/OpenSans_Condensed-LightItalic.ttf
+  static/OpenSans_Condensed-Italic.ttf
+  static/OpenSans_Condensed-MediumItalic.ttf
+  static/OpenSans_Condensed-SemiBoldItalic.ttf
+  static/OpenSans_Condensed-BoldItalic.ttf
+  static/OpenSans_Condensed-ExtraBoldItalic.ttf
+  static/OpenSans_SemiCondensed-LightItalic.ttf
+  static/OpenSans_SemiCondensed-Italic.ttf
+  static/OpenSans_SemiCondensed-MediumItalic.ttf
+  static/OpenSans_SemiCondensed-SemiBoldItalic.ttf
+  static/OpenSans_SemiCondensed-BoldItalic.ttf
+  static/OpenSans_SemiCondensed-ExtraBoldItalic.ttf
+  static/OpenSans-LightItalic.ttf
+  static/OpenSans-Italic.ttf
+  static/OpenSans-MediumItalic.ttf
+  static/OpenSans-SemiBoldItalic.ttf
+  static/OpenSans-BoldItalic.ttf
+  static/OpenSans-ExtraBoldItalic.ttf
+
+Get started
+-----------
+
+1. Install the font files you want to use
+
+2. Use your app's font picker to view the font family and all the
+available styles
+
+Learn more about variable fonts
+-------------------------------
+
+  https://developers.google.com/web/fundamentals/design-and-ux/typography/variable-fonts
+  https://variablefonts.typenetwork.com
+  https://medium.com/variable-fonts
+
+In desktop apps
+
+  https://theblog.adobe.com/can-variable-fonts-illustrator-cc
+  https://helpx.adobe.com/nz/photoshop/using/fonts.html#variable_fonts
+
+Online
+
+  https://developers.google.com/fonts/docs/getting_started
+  https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Fonts/Variable_Fonts_Guide
+  https://developer.microsoft.com/en-us/microsoft-edge/testdrive/demos/variable-fonts
+
+Installing fonts
+
+  MacOS: https://support.apple.com/en-us/HT201749
+  Linux: https://www.google.com/search?q=how+to+install+a+font+on+gnu%2Blinux
+  Windows: https://support.microsoft.com/en-us/help/314960/how-to-install-or-remove-a-font-in-windows
+
+Android Apps
+
+  https://developers.google.com/fonts/docs/android
+  https://developer.android.com/guide/topics/ui/look-and-feel/downloadable-fonts
+
+License
+-------
+Please read the full license text (OFL.txt) to understand the permissions,
+restrictions and requirements for usage, redistribution, and modification.
+
+You can use them in your products & projects – print or digital,
+commercial or otherwise.
+
+This isn't legal advice, please consider consulting a lawyer and see the full
+license for all details.

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL3/dialogs/res/CMakeLists.txt

@@ -0,0 +1,29 @@
+# FreeRDP: A Remote Desktop Protocol Implementation
+# FreeRDP SDL Client
+#
+# Copyright 2024 Armin Novak <[email protected]>
+# Copyright 2024 Thincast Technologies GmbH
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+set(SRCS sdl3_resource_manager.cpp sdl3_resource_manager.hpp)
+
+add_library(sdl3_client_res STATIC ${SRCS})
+if(NOT WITH_SDL_LINK_SHARED)
+  target_link_libraries(sdl3_client_res ${SDL3_STATIC_LIBRARIES})
+else()
+  target_link_libraries(sdl3_client_res ${SDL3_LIBRARIES})
+endif()
+
+target_link_libraries(sdl3_client_res sdl-common-client-res)
+
+set_target_properties(sdl3_client_res PROPERTIES POSITION_INDEPENDENT_CODE ON INTERPROCEDURAL_OPTIMIZATION OFF)

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL3/dialogs/sdl_input.hpp

@@ -0,0 +1,73 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client helper dialogs
+ *
+ * Copyright 2023 Armin Novak <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <vector>
+#include <string>
+
+#include <SDL3/SDL.h>
+#include "sdl_widget.hpp"
+
+class SdlInputWidget
+{
+  public:
+	enum
+	{
+		SDL_INPUT_MASK = 1,
+		SDL_INPUT_READONLY = 2
+	};
+
+	SdlInputWidget(SDL_Renderer* renderer, std::string label, std::string initial, Uint32 flags,
+	               size_t offset, size_t width, size_t height);
+	SdlInputWidget(SdlInputWidget&& other) noexcept;
+	SdlInputWidget(const SdlInputWidget& other) = delete;
+
+	SdlInputWidget& operator=(const SdlInputWidget& other) = delete;
+	SdlInputWidget& operator=(SdlInputWidget&& other) = delete;
+
+	bool fill_label(SDL_Renderer* renderer, SDL_Color color);
+	bool update_label(SDL_Renderer* renderer);
+
+	bool set_mouseover(SDL_Renderer* renderer, bool mouseOver);
+	bool set_highlight(SDL_Renderer* renderer, bool highlight);
+	bool update_input(SDL_Renderer* renderer);
+	bool resize_input(size_t size);
+
+	bool set_str(SDL_Renderer* renderer, const std::string& text);
+	bool remove_str(SDL_Renderer* renderer, size_t count);
+	bool append_str(SDL_Renderer* renderer, const std::string& text);
+
+	[[nodiscard]] const SDL_FRect& input_rect() const;
+	[[nodiscard]] std::string value() const;
+
+	[[nodiscard]] bool readonly() const;
+
+  protected:
+	bool update_input(SDL_Renderer* renderer, SDL_Color fgcolor);
+
+  private:
+	Uint32 _flags;
+	std::string _text;
+	std::string _text_label;
+	SdlWidget _label;
+	SdlWidget _input;
+	bool _highlight;
+	bool _mouseover;
+};

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL3/dialogs/sdl_selectlist.cpp

@@ -0,0 +1,215 @@
+#include <cassert>
+#include <winpr/cast.h>
+#include "sdl_selectlist.hpp"
+
+static const Uint32 vpadding = 5;
+
+SdlSelectList::SdlSelectList(const std::string& title, const std::vector<std::string>& labels)
+    : _window(nullptr), _renderer(nullptr)
+{
+	const size_t widget_height = 50;
+	const size_t widget_width = 600;
+
+	const size_t total_height = labels.size() * (widget_height + vpadding) + vpadding;
+	const size_t height = total_height + widget_height;
+	static_assert(widget_width <= INT32_MAX);
+	assert(height <= INT32_MAX);
+	auto rc = SDL_CreateWindowAndRenderer(
+	    title.c_str(), static_cast<int>(widget_width), static_cast<int>(height),
+	    SDL_WINDOW_HIGH_PIXEL_DENSITY | SDL_WINDOW_MOUSE_FOCUS | SDL_WINDOW_INPUT_FOCUS, &_window,
+	    &_renderer);
+	if (rc != 0)
+		widget_log_error(rc, "SDL_CreateWindowAndRenderer");
+	else
+	{
+		SDL_FRect rect = { 0, 0, widget_width, widget_height };
+		for (auto& label : labels)
+		{
+			_list.emplace_back(_renderer, label, rect);
+			rect.y += widget_height + vpadding;
+		}
+
+		const std::vector<int> buttonids = { INPUT_BUTTON_ACCEPT, INPUT_BUTTON_CANCEL };
+		const std::vector<std::string> buttonlabels = { "accept", "cancel" };
+		_buttons.populate(_renderer, buttonlabels, buttonids, widget_width,
+		                  static_cast<Sint32>(total_height), static_cast<Sint32>(widget_width / 2),
+		                  static_cast<Sint32>(widget_height));
+		_buttons.set_highlight(0);
+	}
+}
+
+SdlSelectList::~SdlSelectList()
+{
+	_list.clear();
+	_buttons.clear();
+	SDL_DestroyRenderer(_renderer);
+	SDL_DestroyWindow(_window);
+}
+
+int SdlSelectList::run()
+{
+	int res = -2;
+	ssize_t CurrentActiveTextInput = 0;
+	bool running = true;
+
+	if (!_window || !_renderer)
+		return -2;
+	try
+	{
+		while (running)
+		{
+			if (!clear_window(_renderer))
+				throw;
+
+			if (!update_text())
+				throw;
+
+			if (!_buttons.update(_renderer))
+				throw;
+
+			SDL_Event event = {};
+			SDL_WaitEvent(&event);
+			switch (event.type)
+			{
+				case SDL_EVENT_KEY_DOWN:
+					switch (event.key.key)
+					{
+						case SDLK_UP:
+						case SDLK_BACKSPACE:
+							if (CurrentActiveTextInput > 0)
+								CurrentActiveTextInput--;
+							else if (_list.empty())
+								CurrentActiveTextInput = 0;
+							else
+							{
+								auto s = _list.size();
+								CurrentActiveTextInput = WINPR_ASSERTING_INT_CAST(ssize_t, s) - 1;
+							}
+							break;
+						case SDLK_DOWN:
+						case SDLK_TAB:
+							if ((CurrentActiveTextInput < 0) || _list.empty())
+								CurrentActiveTextInput = 0;
+							else
+							{
+								auto s = _list.size();
+								CurrentActiveTextInput++;
+								if (s > 0)
+								{
+									CurrentActiveTextInput = CurrentActiveTextInput %
+									                         WINPR_ASSERTING_INT_CAST(ssize_t, s);
+								}
+							}
+							break;
+						case SDLK_RETURN:
+						case SDLK_RETURN2:
+						case SDLK_KP_ENTER:
+							running = false;
+							res = static_cast<int>(CurrentActiveTextInput);
+							break;
+						case SDLK_ESCAPE:
+							running = false;
+							res = INPUT_BUTTON_CANCEL;
+							break;
+						default:
+							break;
+					}
+					break;
+				case SDL_EVENT_MOUSE_MOTION:
+				{
+					ssize_t TextInputIndex = get_index(event.button);
+					reset_mouseover();
+					if (TextInputIndex >= 0)
+					{
+						auto& cur = _list[WINPR_ASSERTING_INT_CAST(size_t, TextInputIndex)];
+						if (!cur.set_mouseover(_renderer, true))
+							throw;
+					}
+
+					_buttons.set_mouseover(event.button.x, event.button.y);
+				}
+				break;
+				case SDL_EVENT_MOUSE_BUTTON_DOWN:
+				{
+					auto button = _buttons.get_selected(event.button);
+					if (button)
+					{
+						running = false;
+						if (button->id() == INPUT_BUTTON_CANCEL)
+							res = INPUT_BUTTON_CANCEL;
+						else
+							res = static_cast<int>(CurrentActiveTextInput);
+					}
+					else
+					{
+						CurrentActiveTextInput = get_index(event.button);
+					}
+				}
+				break;
+				case SDL_EVENT_QUIT:
+					res = INPUT_BUTTON_CANCEL;
+					running = false;
+					break;
+				default:
+					break;
+			}
+
+			reset_highlight();
+			if (CurrentActiveTextInput >= 0)
+			{
+				auto& cur = _list[WINPR_ASSERTING_INT_CAST(size_t, CurrentActiveTextInput)];
+				if (!cur.set_highlight(_renderer, true))
+					throw;
+			}
+
+			SDL_RenderPresent(_renderer);
+		}
+	}
+	catch (...)
+	{
+		return -1;
+	}
+	return res;
+}
+
+ssize_t SdlSelectList::get_index(const SDL_MouseButtonEvent& button)
+{
+	const auto x = button.x;
+	const auto y = button.y;
+	for (size_t i = 0; i < _list.size(); i++)
+	{
+		auto& cur = _list[i];
+		auto r = cur.rect();
+
+		if ((x >= r.x) && (x <= r.x + r.w) && (y >= r.y) && (y <= r.y + r.h))
+			return WINPR_ASSERTING_INT_CAST(ssize_t, i);
+	}
+	return -1;
+}
+
+bool SdlSelectList::update_text()
+{
+	for (auto& cur : _list)
+	{
+		if (!cur.update_text(_renderer))
+			return false;
+	}
+
+	return true;
+}
+
+void SdlSelectList::reset_mouseover()
+{
+	for (auto& cur : _list)
+	{
+		cur.set_mouseover(_renderer, false);
+	}
+}
+
+void SdlSelectList::reset_highlight()
+{
+	for (auto& cur : _list)
+	{
+		cur.set_highlight(_renderer, false);
+	}
+}

local-test-freerdp-delta-01/afc-freerdp/client/SDL/SDL3/dialogs/test/CMakeLists.txt

@@ -0,0 +1,25 @@
+set(MODULE_NAME "TestSDL")
+set(MODULE_PREFIX "TEST_SDL")
+
+set(DRIVER ${MODULE_NAME}.cpp)
+
+disable_warnings_for_directory(${CMAKE_CURRENT_BINARY_DIR})
+
+set(TEST_SRCS TestSDLDialogs.cpp)
+
+create_test_sourcelist(SRCS ${DRIVER} ${TEST_SRCS})
+
+add_library(${MODULE_NAME} ${SRCS})
+
+list(APPEND LIBS dialogs)
+
+target_link_libraries(${MODULE_NAME} ${LIBS})
+
+set_target_properties(${MODULE_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${TESTING_OUTPUT_DIRECTORY}")
+
+foreach(test ${TESTS})
+  get_filename_component(TestName ${test} NAME_WE)
+  add_test(${TestName} ${TESTING_OUTPUT_DIRECTORY}/${MODULE_NAME} ${TestName})
+endforeach()
+
+set_property(TARGET ${MODULE_NAME} PROPERTY FOLDER "FreeRDP/Client/Test")

local-test-freerdp-delta-01/afc-freerdp/client/SDL/common/aad/CMakeLists.txt

@@ -0,0 +1,63 @@
+# FreeRDP: A Remote Desktop Protocol Implementation
+# FreeRDP SDL Client
+#
+# Copyright 2024 Armin Novak <[email protected]>
+# Copyright 2024 Thincast Technologies GmbH
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+set(WITH_WEBVIEW_DEFAULT OFF)
+
+option(WITH_WEBVIEW "Build with WebView support for AAD login popup browser" ${WITH_WEBVIEW_DEFAULT})
+if(WITH_WEBVIEW)
+  option(WITH_WEBVIEW_QT "Build with QtWebEngine support for AAD login broweser popup" OFF)
+
+  set(SRCS sdl_webview.hpp webview_impl.hpp sdl_webview.cpp)
+  set(LIBS winpr)
+
+  if(WITH_WEBVIEW_QT)
+    find_package(Qt5 COMPONENTS WebEngineWidgets REQUIRED)
+
+    list(APPEND SRCS qt/webview_impl.cpp)
+
+    list(APPEND LIBS Qt5::WebEngineWidgets)
+  else()
+    list(APPEND SRCS wrapper/webview.h wrapper/webview_impl.cpp)
+
+    if(APPLE)
+      find_library(WEBKIT Webkit REQUIRED)
+      list(APPEND LIBS ${WEBKIT})
+    elseif(NOT WIN32)
+      find_package(PkgConfig REQUIRED)
+      pkg_check_modules(WEBVIEW_GTK webkit2gtk-4.1)
+      if(NOT WEBVIEW_GTK_FOUND)
+        pkg_check_modules(WEBVIEW_GTK webkit2gtk-4.0 REQUIRED)
+      endif()
+      include_directories(SYSTEM ${WEBVIEW_GTK_INCLUDE_DIRS})
+      list(APPEND LIBS ${WEBVIEW_GTK_LIBRARIES})
+    endif()
+  endif()
+else()
+  set(SRCS dummy.cpp)
+endif()
+
+cleaning_configure_file(sdl_config.hpp.in sdl_config.hpp @ONLY)
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+
+add_library(sdl-common-aad-view STATIC ${SRCS})
+target_include_directories(sdl-common-aad-view PUBLIC ${CMAKE_CURRENT_BINARY_DIR})
+target_link_libraries(sdl-common-aad-view PRIVATE ${LIBS})
+target_compile_definitions(sdl-common-aad-view PUBLIC ${DEFINITIONS})
+if(WITH_WEBVIEW AND NOT WITH_WEBVIEW_QT)
+  include(WebView2)
+  target_link_webview2("sdl-common-aad-view")
+endif()

local-test-freerdp-delta-01/afc-freerdp/client/SDL/common/aad/qt/webview_impl.cpp

@@ -0,0 +1,105 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Popup browser for AAD authentication
+ *
+ * Copyright 2023 Isaac Klein <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *		 http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <QApplication>
+#include <QWebEngineView>
+#include <QWebEngineProfile>
+#include <QWebEngineUrlScheme>
+#include <QWebEngineUrlSchemeHandler>
+#include <QWebEngineUrlRequestJob>
+
+#include <string>
+#include <cstdlib>
+#include <cstdarg>
+#include <winpr/string.h>
+#include <winpr/assert.h>
+#include <freerdp/log.h>
+#include <freerdp/build-config.h>
+
+#include "../webview_impl.hpp"
+
+#define TAG CLIENT_TAG("sdl.webview")
+
+class SchemeHandler : public QWebEngineUrlSchemeHandler
+{
+  public:
+	explicit SchemeHandler(QObject* parent = nullptr) : QWebEngineUrlSchemeHandler(parent)
+	{
+	}
+
+	void requestStarted(QWebEngineUrlRequestJob* request) override
+	{
+		QUrl url = request->requestUrl();
+
+		int rc = -1;
+		for (auto& param : url.query().split('&'))
+		{
+			QStringList pair = param.split('=');
+
+			if (pair.size() != 2 || pair[0] != QLatin1String("code"))
+				continue;
+
+			auto qc = pair[1];
+			m_code = qc.toStdString();
+			rc = 0;
+			break;
+		}
+		qApp->exit(rc);
+	}
+
+	[[nodiscard]] std::string code() const
+	{
+		return m_code;
+	}
+
+  private:
+	std::string m_code{};
+};
+
+bool webview_impl_run(const std::string& title, const std::string& url, std::string& code)
+{
+	int argc = 1;
+	const auto vendor = QLatin1String(FREERDP_VENDOR_STRING);
+	const auto product = QLatin1String(FREERDP_PRODUCT_STRING);
+	QWebEngineUrlScheme::registerScheme(QWebEngineUrlScheme("ms-appx-web"));
+
+	std::string wtitle = title;
+	char* argv[] = { wtitle.data() };
+	QCoreApplication::setOrganizationName(vendor);
+	QCoreApplication::setApplicationName(product);
+	QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
+	QApplication app(argc, argv);
+
+	SchemeHandler handler;
+	QWebEngineProfile::defaultProfile()->installUrlSchemeHandler("ms-appx-web", &handler);
+
+	QWebEngineView webview;
+	webview.load(QUrl(QString::fromStdString(url)));
+	webview.show();
+
+	if (app.exec() != 0)
+		return false;
+
+	auto val = handler.code();
+	if (val.empty())
+		return false;
+	code = val;
+
+	return !code.empty();
+}

local-test-freerdp-delta-01/afc-freerdp/client/SDL/common/aad/sdl_config.hpp.in

@@ -0,0 +1,3 @@
+#pragma once
+
+#cmakedefine WITH_WEBVIEW

local-test-freerdp-delta-01/afc-freerdp/client/SDL/common/aad/sdl_webview.cpp

@@ -0,0 +1,154 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Popup browser for AAD authentication
+ *
+ * Copyright 2023 Isaac Klein <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *		 http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <string>
+#include <sstream>
+#include <cstdlib>
+#include <winpr/string.h>
+#include <freerdp/log.h>
+#include <freerdp/utils/aad.h>
+
+#include "sdl_webview.hpp"
+#include "webview_impl.hpp"
+
+#define TAG CLIENT_TAG("SDL.webview")
+
+static std::string from_settings(const rdpSettings* settings, FreeRDP_Settings_Keys_String id)
+{
+	auto val = freerdp_settings_get_string(settings, id);
+	if (!val)
+	{
+		WLog_WARN(TAG, "Settings key %s is NULL", freerdp_settings_get_name_for_key(id));
+		return "";
+	}
+	return val;
+}
+
+static std::string from_aad_wellknown(rdpContext* context, AAD_WELLKNOWN_VALUES which)
+{
+	auto val = freerdp_utils_aad_get_wellknown_string(context, which);
+
+	if (!val)
+	{
+		WLog_WARN(TAG, "[wellknown] key %s is NULL", freerdp_utils_aad_wellknwon_value_name(which));
+		return "";
+	}
+	return val;
+}
+
+static BOOL sdl_webview_get_rdsaad_access_token(freerdp* instance, const char* scope,
+                                                const char* req_cnf, char** token)
+{
+	WINPR_ASSERT(instance);
+	WINPR_ASSERT(scope);
+	WINPR_ASSERT(req_cnf);
+	WINPR_ASSERT(token);
+
+	WINPR_UNUSED(instance);
+	WINPR_UNUSED(instance->context);
+
+	auto client_id = from_settings(instance->context->settings, FreeRDP_GatewayAvdClientID);
+	std::string redirect_uri = "ms-appx-web%3a%2f%2fMicrosoft.AAD.BrokerPlugin%2f" + client_id;
+
+	*token = nullptr;
+
+	auto ep = from_aad_wellknown(instance->context, AAD_WELLKNOWN_authorization_endpoint);
+	auto url = ep + "?client_id=" + client_id + "&response_type=code&scope=" + scope +
+	           "&redirect_uri=" + redirect_uri;
+
+	const std::string title = "FreeRDP WebView - AAD access token";
+	std::string code;
+	auto rc = webview_impl_run(title, url, code);
+	if (!rc || code.empty())
+		return FALSE;
+
+	auto token_request = "grant_type=authorization_code&code=" + code + "&client_id=" + client_id +
+	                     "&scope=" + scope + "&redirect_uri=" + redirect_uri +
+	                     "&req_cnf=" + req_cnf;
+	return client_common_get_access_token(instance, token_request.c_str(), token);
+}
+
+static BOOL sdl_webview_get_avd_access_token(freerdp* instance, char** token)
+{
+	WINPR_ASSERT(token);
+	WINPR_ASSERT(instance);
+	WINPR_ASSERT(instance->context);
+
+	auto client_id = from_settings(instance->context->settings, FreeRDP_GatewayAvdClientID);
+	std::string redirect_uri = "ms-appx-web%3a%2f%2fMicrosoft.AAD.BrokerPlugin%2f" + client_id;
+	std::string scope = "https%3A%2F%2Fwww.wvd.microsoft.com%2F.default";
+
+	*token = nullptr;
+
+	auto ep = from_aad_wellknown(instance->context, AAD_WELLKNOWN_authorization_endpoint);
+	auto url = ep + "?client_id=" + client_id + "&response_type=code&scope=" + scope +
+	           "&redirect_uri=" + redirect_uri;
+	const std::string title = "FreeRDP WebView - AVD access token";
+	std::string code;
+	auto rc = webview_impl_run(title, url, code);
+	if (!rc || code.empty())
+		return FALSE;
+
+	auto token_request = "grant_type=authorization_code&code=" + code + "&client_id=" + client_id +
+	                     "&scope=" + scope + "&redirect_uri=" + redirect_uri;
+	return client_common_get_access_token(instance, token_request.c_str(), token);
+}
+
+BOOL sdl_webview_get_access_token(freerdp* instance, AccessTokenType tokenType, char** token,
+                                  size_t count, ...)
+{
+	WINPR_ASSERT(instance);
+	WINPR_ASSERT(token);
+	switch (tokenType)
+	{
+		case ACCESS_TOKEN_TYPE_AAD:
+		{
+			if (count < 2)
+			{
+				WLog_ERR(TAG,
+				         "ACCESS_TOKEN_TYPE_AAD expected 2 additional arguments, but got %" PRIuz
+				         ", aborting",
+				         count);
+				return FALSE;
+			}
+			else if (count > 2)
+				WLog_WARN(TAG,
+				          "ACCESS_TOKEN_TYPE_AAD expected 2 additional arguments, but got %" PRIuz
+				          ", ignoring",
+				          count);
+			va_list ap = {};
+			va_start(ap, count);
+			const char* scope = va_arg(ap, const char*);
+			const char* req_cnf = va_arg(ap, const char*);
+			const BOOL rc = sdl_webview_get_rdsaad_access_token(instance, scope, req_cnf, token);
+			va_end(ap);
+			return rc;
+		}
+		case ACCESS_TOKEN_TYPE_AVD:
+			if (count != 0)
+				WLog_WARN(TAG,
+				          "ACCESS_TOKEN_TYPE_AVD expected 0 additional arguments, but got %" PRIuz
+				          ", ignoring",
+				          count);
+			return sdl_webview_get_avd_access_token(instance, token);
+		default:
+			WLog_ERR(TAG, "Unexpected value for AccessTokenType [%" PRIuz "], aborting", tokenType);
+			return FALSE;
+	}
+}

local-test-freerdp-delta-01/afc-freerdp/client/SDL/common/aad/sdl_webview.hpp

@@ -0,0 +1,38 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Popup browser for AAD authentication
+ *
+ * Copyright 2023 Isaac Klein <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *		 http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <freerdp/freerdp.h>
+
+#include <sdl_config.hpp>
+
+#if defined(WITH_WEBVIEW)
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	BOOL sdl_webview_get_access_token(freerdp* instance, AccessTokenType tokenType, char** token,
+	                                  size_t count, ...);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

local-test-freerdp-delta-01/afc-freerdp/client/SDL/common/aad/webview_impl.hpp

@@ -0,0 +1,24 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Popup browser for AAD authentication
+ *
+ * Copyright 2023 Isaac Klein <[email protected]>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *		 http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+bool webview_impl_run(const std::string& title, const std::string& url, std::string& code);

local-test-freerdp-delta-01/afc-freerdp/client/SDL/common/aad/wrapper/README

@@ -0,0 +1 @@
+upstream at https://github.com/webview/webview/

local-test-freerdp-delta-01/afc-freerdp/client/SDL/common/aad/wrapper/webview.h

@@ -0,0 +1,2811 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2017 Serge Zaitsev
+ * Copyright (c) 2022 Steffen André Langnes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef WEBVIEW_H
+#define WEBVIEW_H
+
+#ifndef WEBVIEW_API
+#define WEBVIEW_API extern
+#endif
+
+#ifndef WEBVIEW_VERSION_MAJOR
+// The current library major version.
+#define WEBVIEW_VERSION_MAJOR 0
+#endif
+
+#ifndef WEBVIEW_VERSION_MINOR
+// The current library minor version.
+#define WEBVIEW_VERSION_MINOR 10
+#endif
+
+#ifndef WEBVIEW_VERSION_PATCH
+// The current library patch version.
+#define WEBVIEW_VERSION_PATCH 0
+#endif
+
+#ifndef WEBVIEW_VERSION_PRE_RELEASE
+// SemVer 2.0.0 pre-release labels prefixed with "-".
+#define WEBVIEW_VERSION_PRE_RELEASE ""
+#endif
+
+#ifndef WEBVIEW_VERSION_BUILD_METADATA
+// SemVer 2.0.0 build metadata prefixed with "+".
+#define WEBVIEW_VERSION_BUILD_METADATA ""
+#endif
+
+// Utility macro for stringifying a macro argument.
+#define WEBVIEW_STRINGIFY(x) #x
+
+// Utility macro for stringifying the result of a macro argument expansion.
+#define WEBVIEW_EXPAND_AND_STRINGIFY(x) WEBVIEW_STRINGIFY(x)
+
+// SemVer 2.0.0 version number in MAJOR.MINOR.PATCH format.
+#define WEBVIEW_VERSION_NUMBER                                                                \
+	WEBVIEW_EXPAND_AND_STRINGIFY(WEBVIEW_VERSION_MAJOR)                                       \
+	"." WEBVIEW_EXPAND_AND_STRINGIFY(WEBVIEW_VERSION_MINOR) "." WEBVIEW_EXPAND_AND_STRINGIFY( \
+	    WEBVIEW_VERSION_PATCH)
+
+// Holds the elements of a MAJOR.MINOR.PATCH version number.
+typedef struct
+{
+	// Major version.
+	unsigned int major;
+	// Minor version.
+	unsigned int minor;
+	// Patch version.
+	unsigned int patch;
+} webview_version_t;
+
+// Holds the library's version information.
+typedef struct
+{
+	// The elements of the version number.
+	webview_version_t version;
+	// SemVer 2.0.0 version number in MAJOR.MINOR.PATCH format.
+	char version_number[32];
+	// SemVer 2.0.0 pre-release labels prefixed with "-" if specified, otherwise
+	// an empty string.
+	char pre_release[48];
+	// SemVer 2.0.0 build metadata prefixed with "+", otherwise an empty string.
+	char build_metadata[48];
+} webview_version_info_t;
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	typedef void* webview_t;
+
+	// Creates a new webview instance. If debug is non-zero - developer tools will
+	// be enabled (if the platform supports them). Window parameter can be a
+	// pointer to the native window handle. If it's non-null - then child WebView
+	// is embedded into the given parent window. Otherwise a new window is created.
+	// Depending on the platform, a GtkWindow, NSWindow or HWND pointer can be
+	// passed here. Returns null on failure. Creation can fail for various reasons
+	// such as when required runtime dependencies are missing or when window creation
+	// fails.
+	WEBVIEW_API webview_t webview_create(int debug, void* window);
+
+	// Destroys a webview and closes the native window.
+	WEBVIEW_API void webview_destroy(webview_t w);
+
+	// Runs the main loop until it's terminated. After this function exits - you
+	// must destroy the webview.
+	WEBVIEW_API void webview_run(webview_t w);
+
+	// Stops the main loop. It is safe to call this function from another other
+	// background thread.
+	WEBVIEW_API void webview_terminate(webview_t w);
+
+	// Posts a function to be executed on the main thread. You normally do not need
+	// to call this function, unless you want to tweak the native window.
+	WEBVIEW_API void webview_dispatch(webview_t w, void (*fn)(webview_t w, void* arg), void* arg);
+
+	// Returns a native window handle pointer. When using GTK backend the pointer
+	// is GtkWindow pointer, when using Cocoa backend the pointer is NSWindow
+	// pointer, when using Win32 backend the pointer is HWND pointer.
+	WEBVIEW_API void* webview_get_window(webview_t w);
+
+	// Updates the title of the native window. Must be called from the UI thread.
+	WEBVIEW_API void webview_set_title(webview_t w, const char* title);
+
+// Window size hints
+#define WEBVIEW_HINT_NONE 0  // Width and height are default size
+#define WEBVIEW_HINT_MIN 1   // Width and height are minimum bounds
+#define WEBVIEW_HINT_MAX 2   // Width and height are maximum bounds
+#define WEBVIEW_HINT_FIXED 3 // Window size can not be changed by a user
+	// Updates native window size. See WEBVIEW_HINT constants.
+	WEBVIEW_API void webview_set_size(webview_t w, int width, int height, int hints);
+
+	// Navigates webview to the given URL. URL may be a properly encoded data URI.
+	// Examples:
+	// webview_navigate(w, "https://github.com/webview/webview");
+	// webview_navigate(w, "data:text/html,%3Ch1%3EHello%3C%2Fh1%3E");
+	// webview_navigate(w, "data:text/html;base64,PGgxPkhlbGxvPC9oMT4=");
+	WEBVIEW_API void webview_navigate(webview_t w, const char* url);
+
+	// Set webview HTML directly.
+	// Example: webview_set_html(w, "<h1>Hello</h1>");
+	WEBVIEW_API void webview_set_html(webview_t w, const char* html);
+
+	// Injects JavaScript code at the initialization of the new page. Every time
+	// the webview will open a the new page - this initialization code will be
+	// executed. It is guaranteed that code is executed before window.onload.
+	WEBVIEW_API void webview_init(webview_t w, const char* js);
+
+	// Evaluates arbitrary JavaScript code. Evaluation happens asynchronously, also
+	// the result of the expression is ignored. Use RPC bindings if you want to
+	// receive notifications about the results of the evaluation.
+	WEBVIEW_API void webview_eval(webview_t w, const char* js);
+
+	// Binds a native C callback so that it will appear under the given name as a
+	// global JavaScript function. Internally it uses webview_init(). Callback
+	// receives a request string and a user-provided argument pointer. Request
+	// string is a JSON array of all the arguments passed to the JavaScript
+	// function.
+	WEBVIEW_API void webview_bind(webview_t w, const char* name,
+	                              void (*fn)(const char* seq, const char* req, void* arg),
+	                              void* arg);
+
+	// Removes a native C callback that was previously set by webview_bind.
+	WEBVIEW_API void webview_unbind(webview_t w, const char* name);
+
+	// Allows to return a value from the native binding. Original request pointer
+	// must be provided to help internal RPC engine match requests with responses.
+	// If status is zero - result is expected to be a valid JSON result value.
+	// If status is not zero - result is an error JSON object.
+	WEBVIEW_API void webview_return(webview_t w, const char* seq, int status, const char* result);
+
+	// Get the library's version information.
+	// @since 0.10
+	WEBVIEW_API const webview_version_info_t* webview_version();
+
+#ifdef __cplusplus
+}
+
+#ifndef WEBVIEW_HEADER
+
+#if !defined(WEBVIEW_GTK) && !defined(WEBVIEW_COCOA) && !defined(WEBVIEW_EDGE)
+#if defined(__APPLE__)
+#define WEBVIEW_COCOA
+#elif defined(__unix__)
+#define WEBVIEW_GTK
+#elif defined(_WIN32)
+#define WEBVIEW_EDGE
+#else
+#error "please, specify webview backend"
+#endif
+#endif
+
+#ifndef WEBVIEW_DEPRECATED
+#if __cplusplus >= 201402L
+#define WEBVIEW_DEPRECATED(reason) [[deprecated(reason)]]
+#elif defined(_MSC_VER)
+#define WEBVIEW_DEPRECATED(reason) __declspec(deprecated(reason))
+#else
+#define WEBVIEW_DEPRECATED(reason) __attribute__((deprecated(reason)))
+#endif
+#endif
+
+#ifndef WEBVIEW_DEPRECATED_PRIVATE
+#define WEBVIEW_DEPRECATED_PRIVATE WEBVIEW_DEPRECATED("Private API should not be used")
+#endif
+
+#include <array>
+#include <atomic>
+#include <functional>
+#include <future>
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
+#include <locale>
+#include <codecvt>
+#include <cstring>
+
+namespace webview
+{
+
+	using dispatch_fn_t = std::function<void()>;
+
+	namespace detail
+	{
+
+		// The library's version information.
+		constexpr const webview_version_info_t library_version_info{
+			{ WEBVIEW_VERSION_MAJOR, WEBVIEW_VERSION_MINOR, WEBVIEW_VERSION_PATCH },
+			WEBVIEW_VERSION_NUMBER,
+			WEBVIEW_VERSION_PRE_RELEASE,
+			WEBVIEW_VERSION_BUILD_METADATA
+		};
+
+		inline int json_parse_c(const char* s, size_t sz, const char* key, size_t keysz,
+		                        const char** value, size_t* valuesz)
+		{
+			enum
+			{
+				JSON_STATE_VALUE,
+				JSON_STATE_LITERAL,
+				JSON_STATE_STRING,
+				JSON_STATE_ESCAPE,
+				JSON_STATE_UTF8
+			} state = JSON_STATE_VALUE;
+			const char* k = nullptr;
+			int index = 1;
+			int depth = 0;
+			int utf8_bytes = 0;
+
+			*value = nullptr;
+			*valuesz = 0;
+
+			if (key == nullptr)
+			{
+				index = static_cast<decltype(index)>(keysz);
+				if (index < 0)
+				{
+					return -1;
+				}
+				keysz = 0;
+			}
+
+			for (; sz > 0; s++, sz--)
+			{
+				enum
+				{
+					JSON_ACTION_NONE,
+					JSON_ACTION_START,
+					JSON_ACTION_END,
+					JSON_ACTION_START_STRUCT,
+					JSON_ACTION_END_STRUCT
+				} action = JSON_ACTION_NONE;
+				auto c = static_cast<unsigned char>(*s);
+				switch (state)
+				{
+					case JSON_STATE_VALUE:
+						if (c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == ',' || c == ':')
+						{
+							continue;
+						}
+						else if (c == '"')
+						{
+							action = JSON_ACTION_START;
+							state = JSON_STATE_STRING;
+						}
+						else if (c == '{' || c == '[')
+						{
+							action = JSON_ACTION_START_STRUCT;
+						}
+						else if (c == '}' || c == ']')
+						{
+							action = JSON_ACTION_END_STRUCT;
+						}
+						else if (c == 't' || c == 'f' || c == 'n' || c == '-' ||
+						         (c >= '0' && c <= '9'))
+						{
+							action = JSON_ACTION_START;
+							state = JSON_STATE_LITERAL;
+						}
+						else
+						{
+							return -1;
+						}
+						break;
+					case JSON_STATE_LITERAL:
+						if (c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == ',' ||
+						    c == ']' || c == '}' || c == ':')
+						{
+							state = JSON_STATE_VALUE;
+							s--;
+							sz++;
+							action = JSON_ACTION_END;
+						}
+						else if (c < 32 || c > 126)
+						{
+							return -1;
+						} // fallthrough
+					case JSON_STATE_STRING:
+						if (c < 32 || (c > 126 && c < 192))
+						{
+							return -1;
+						}
+						else if (c == '"')
+						{
+							action = JSON_ACTION_END;
+							state = JSON_STATE_VALUE;
+						}
+						else if (c == '\\')
+						{
+							state = JSON_STATE_ESCAPE;
+						}
+						else if (c >= 192 && c < 224)
+						{
+							utf8_bytes = 1;
+							state = JSON_STATE_UTF8;
+						}
+						else if (c >= 224 && c < 240)
+						{
+							utf8_bytes = 2;
+							state = JSON_STATE_UTF8;
+						}
+						else if (c >= 240 && c < 247)
+						{
+							utf8_bytes = 3;
+							state = JSON_STATE_UTF8;
+						}
+						else if (c >= 128 && c < 192)
+						{
+							return -1;
+						}
+						break;
+					case JSON_STATE_ESCAPE:
+						if (c == '"' || c == '\\' || c == '/' || c == 'b' || c == 'f' || c == 'n' ||
+						    c == 'r' || c == 't' || c == 'u')
+						{
+							state = JSON_STATE_STRING;
+						}
+						else
+						{
+							return -1;
+						}
+						break;
+					case JSON_STATE_UTF8:
+						if (c < 128 || c > 191)
+						{
+							return -1;
+						}
+						utf8_bytes--;
+						if (utf8_bytes == 0)
+						{
+							state = JSON_STATE_STRING;
+						}
+						break;
+					default:
+						return -1;
+				}
+
+				if (action == JSON_ACTION_END_STRUCT)
+				{
+					depth--;
+				}
+
+				if (depth == 1)
+				{
+					if (action == JSON_ACTION_START || action == JSON_ACTION_START_STRUCT)
+					{
+						if (index == 0)
+						{
+							*value = s;
+						}
+						else if (keysz > 0 && index == 1)
+						{
+							k = s;
+						}
+						else
+						{
+							index--;
+						}
+					}
+					else if (action == JSON_ACTION_END || action == JSON_ACTION_END_STRUCT)
+					{
+						if (*value != nullptr && index == 0)
+						{
+							*valuesz = (size_t)(s + 1 - *value);
+							return 0;
+						}
+						else if (keysz > 0 && k != nullptr)
+						{
+							if (keysz == (size_t)(s - k - 1) && memcmp(key, k + 1, keysz) == 0)
+							{
+								index = 0;
+							}
+							else
+							{
+								index = 2;
+							}
+							k = nullptr;
+						}
+					}
+				}
+
+				if (action == JSON_ACTION_START_STRUCT)
+				{
+					depth++;
+				}
+			}
+			return -1;
+		}
+
+		inline std::string json_escape(const std::string& s)
+		{
+			// TODO: implement
+			return '"' + s + '"';
+		}
+
+		inline int json_unescape(const char* s, size_t n, char* out)
+		{
+			int r = 0;
+			if (*s++ != '"')
+			{
+				return -1;
+			}
+			while (n > 2)
+			{
+				char c = *s;
+				if (c == '\\')
+				{
+					s++;
+					n--;
+					switch (*s)
+					{
+						case 'b':
+							c = '\b';
+							break;
+						case 'f':
+							c = '\f';
+							break;
+						case 'n':
+							c = '\n';
+							break;
+						case 'r':
+							c = '\r';
+							break;
+						case 't':
+							c = '\t';
+							break;
+						case '\\':
+							c = '\\';
+							break;
+						case '/':
+							c = '/';
+							break;
+						case '\"':
+							c = '\"';
+							break;
+						default: // TODO: support unicode decoding
+							return -1;
+					}
+				}
+				if (out != nullptr)
+				{
+					*out++ = c;
+				}
+				s++;
+				n--;
+				r++;
+			}
+			if (*s != '"')
+			{
+				return -1;
+			}
+			if (out != nullptr)
+			{
+				*out = '\0';
+			}
+			return r;
+		}
+
+		inline std::string json_parse(const std::string& s, const std::string& key, const int index)
+		{
+			const char* value = nullptr;
+			size_t value_sz = 0;
+			if (key.empty())
+			{
+				json_parse_c(s.c_str(), s.length(), nullptr, index, &value, &value_sz);
+			}
+			else
+			{
+				json_parse_c(s.c_str(), s.length(), key.c_str(), key.length(), &value, &value_sz);
+			}
+			if (value != nullptr)
+			{
+				if (value[0] != '"')
+				{
+					return { value, value_sz };
+				}
+				int n = json_unescape(value, value_sz, nullptr);
+				if (n > 0)
+				{
+					char* decoded = new char[1ull + n];
+					json_unescape(value, value_sz, decoded);
+					std::string result(decoded, n);
+					delete[] decoded;
+					return result;
+				}
+			}
+			return "";
+		}
+
+	} // namespace detail
+
+	WEBVIEW_DEPRECATED_PRIVATE
+	inline int json_parse_c(const char* s, size_t sz, const char* key, size_t keysz,
+	                        const char** value, size_t* valuesz)
+	{
+		return detail::json_parse_c(s, sz, key, keysz, value, valuesz);
+	}
+
+	WEBVIEW_DEPRECATED_PRIVATE
+	inline std::string json_escape(const std::string& s)
+	{
+		return detail::json_escape(s);
+	}
+
+	WEBVIEW_DEPRECATED_PRIVATE
+	inline int json_unescape(const char* s, size_t n, char* out)
+	{
+		return detail::json_unescape(s, n, out);
+	}
+
+	WEBVIEW_DEPRECATED_PRIVATE
+	inline std::string json_parse(const std::string& s, const std::string& key, const int index)
+	{
+		return detail::json_parse(s, key, index);
+	}
+
+} // namespace webview
+
+#if defined(WEBVIEW_GTK)
+//
+// ====================================================================
+//
+// This implementation uses webkit2gtk backend. It requires gtk+3.0 and
+// webkit2gtk-4.0 libraries. Proper compiler flags can be retrieved via:
+//
+//   pkg-config --cflags --libs gtk+-3.0 webkit2gtk-4.0
+//
+// ====================================================================
+//
+#include <JavaScriptCore/JavaScript.h>
+#include <gtk/gtk.h>
+#include <webkit2/webkit2.h>
+
+namespace webview
+{
+	namespace detail
+	{
+
+		class gtk_webkit_engine
+		{
+		  public:
+			gtk_webkit_engine(bool debug, void* window) : m_window(static_cast<GtkWidget*>(window))
+			{
+				if (gtk_init_check(nullptr, nullptr) == FALSE)
+				{
+					return;
+				}
+				m_window = static_cast<GtkWidget*>(window);
+				if (m_window == nullptr)
+				{
+					m_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+				}
+				g_signal_connect(G_OBJECT(m_window), "destroy",
+				                 G_CALLBACK(+[](GtkWidget*, gpointer arg)
+				                            { static_cast<gtk_webkit_engine*>(arg)->terminate(); }),
+				                 this);
+				// Initialize webview widget
+				m_webview = webkit_web_view_new();
+				WebKitUserContentManager* manager =
+				    webkit_web_view_get_user_content_manager(WEBKIT_WEB_VIEW(m_webview));
+				g_signal_connect(manager, "script-message-received::external",
+				                 G_CALLBACK(+[](WebKitUserContentManager*,
+				                                WebKitJavascriptResult* r, gpointer arg)
+				                            {
+					                            auto* w = static_cast<gtk_webkit_engine*>(arg);
+					                            char* s = get_string_from_js_result(r);
+					                            w->on_message(s);
+					                            g_free(s);
+				                            }),
+				                 this);
+				webkit_user_content_manager_register_script_message_handler(manager, "external");
+				init("window.external={invoke:function(s){window.webkit.messageHandlers."
+				     "external.postMessage(s);}}");
+
+				gtk_container_add(GTK_CONTAINER(m_window), GTK_WIDGET(m_webview));
+				gtk_widget_grab_focus(GTK_WIDGET(m_webview));
+
+				WebKitSettings* settings = webkit_web_view_get_settings(WEBKIT_WEB_VIEW(m_webview));
+				webkit_settings_set_javascript_can_access_clipboard(settings, true);
+				if (debug)
+				{
+					webkit_settings_set_enable_write_console_messages_to_stdout(settings, true);
+					webkit_settings_set_enable_developer_extras(settings, true);
+				}
+
+				gtk_widget_show_all(m_window);
+			}
+			virtual ~gtk_webkit_engine() = default;
+			void* window()
+			{
+				return (void*)m_window;
+			}
+			void run()
+			{
+				gtk_main();
+			}
+			void terminate()
+			{
+				gtk_main_quit();
+			}
+			void dispatch(std::function<void()> f)
+			{
+				g_idle_add_full(G_PRIORITY_HIGH_IDLE, (GSourceFunc)([](void* f) -> int {
+					                (*static_cast<dispatch_fn_t*>(f))();
+					                return G_SOURCE_REMOVE;
+				                }),
+				                new std::function<void()>(f),
+				                [](void* f) { delete static_cast<dispatch_fn_t*>(f); });
+			}
+
+			void set_title(const std::string& title)
+			{
+				gtk_window_set_title(GTK_WINDOW(m_window), title.c_str());
+			}
+
+			void set_size(int width, int height, int hints)
+			{
+				gtk_window_set_resizable(GTK_WINDOW(m_window), hints != WEBVIEW_HINT_FIXED);
+				if (hints == WEBVIEW_HINT_NONE)
+				{
+					gtk_window_resize(GTK_WINDOW(m_window), width, height);
+				}
+				else if (hints == WEBVIEW_HINT_FIXED)
+				{
+					gtk_widget_set_size_request(m_window, width, height);
+				}
+				else
+				{
+					GdkGeometry g;
+					g.min_width = g.max_width = width;
+					g.min_height = g.max_height = height;
+					GdkWindowHints h =
+					    (hints == WEBVIEW_HINT_MIN ? GDK_HINT_MIN_SIZE : GDK_HINT_MAX_SIZE);
+					// This defines either MIN_SIZE, or MAX_SIZE, but not both:
+					gtk_window_set_geometry_hints(GTK_WINDOW(m_window), nullptr, &g, h);
+				}
+			}
+
+			void navigate(const std::string& url)
+			{
+				webkit_web_view_load_uri(WEBKIT_WEB_VIEW(m_webview), url.c_str());
+			}
+
+			void add_navigate_listener(std::function<void(const std::string&, void*)> callback,
+			                           void* arg)
+			{
+				g_signal_connect(WEBKIT_WEB_VIEW(m_webview), "load-changed",
+				                 G_CALLBACK(on_load_changed), this);
+				navigateCallbackArg = arg;
+				navigateCallback = std::move(callback);
+			}
+
+			void add_scheme_handler(const std::string& scheme,
+			                        std::function<void(const std::string&, void*)> callback,
+			                        void* arg)
+			{
+				auto view = WEBKIT_WEB_VIEW(m_webview);
+				auto context = webkit_web_view_get_context(view);
+
+				scheme_handlers.insert({ scheme, { .arg = arg, .fkt = callback } });
+				webkit_web_context_register_uri_scheme(context, scheme.c_str(), scheme_handler,
+				                                       static_cast<gpointer>(this), nullptr);
+			}
+
+			void set_html(const std::string& html)
+			{
+				webkit_web_view_load_html(WEBKIT_WEB_VIEW(m_webview), html.c_str(), nullptr);
+			}
+
+			void init(const std::string& js)
+			{
+				WebKitUserContentManager* manager =
+				    webkit_web_view_get_user_content_manager(WEBKIT_WEB_VIEW(m_webview));
+				webkit_user_content_manager_add_script(
+				    manager, webkit_user_script_new(
+				                 js.c_str(), WEBKIT_USER_CONTENT_INJECT_TOP_FRAME,
+				                 WEBKIT_USER_SCRIPT_INJECT_AT_DOCUMENT_START, nullptr, nullptr));
+			}
+
+			void eval(const std::string& js)
+			{
+				webkit_web_view_run_javascript(WEBKIT_WEB_VIEW(m_webview), js.c_str(), nullptr,
+				                               nullptr, nullptr);
+			}
+
+		  private:
+			virtual void on_message(const std::string& msg) = 0;
+
+			struct handler_t
+			{
+				void* arg;
+				std::function<void(const std::string&, void*)> fkt;
+			};
+
+			std::map<std::string, handler_t> scheme_handlers;
+
+			void scheme_handler_call(const std::string& scheme, const std::string& url)
+			{
+				auto handler = scheme_handlers.find(scheme);
+				if (handler != scheme_handlers.end())
+				{
+					const auto& arg = handler->second;
+					arg.fkt(url, arg.arg);
+				}
+			}
+
+			static void scheme_handler(WebKitURISchemeRequest* request, gpointer user_data)
+			{
+				auto _this = static_cast<gtk_webkit_engine*>(user_data);
+
+				auto scheme = webkit_uri_scheme_request_get_scheme(request);
+				auto uri = webkit_uri_scheme_request_get_uri(request);
+				_this->scheme_handler_call(scheme, uri);
+			}
+
+			static char* get_string_from_js_result(WebKitJavascriptResult* r)
+			{
+				char* s = nullptr;
+#if WEBKIT_MAJOR_VERSION >= 2 && WEBKIT_MINOR_VERSION >= 22
+				JSCValue* value = webkit_javascript_result_get_js_value(r);
+				s = jsc_value_to_string(value);
+#else
+				JSGlobalContextRef ctx = webkit_javascript_result_get_global_context(r);
+				JSValueRef value = webkit_javascript_result_get_value(r);
+				JSStringRef js = JSValueToStringCopy(ctx, value, nullptr);
+				size_t n = JSStringGetMaximumUTF8CStringSize(js);
+				s = g_new(char, n);
+				JSStringGetUTF8CString(js, s, n);
+				JSStringRelease(js);
+#endif
+				return s;
+			}
+
+			GtkWidget* m_window;
+			GtkWidget* m_webview;
+
+			void* navigateCallbackArg = nullptr;
+			std::function<void(const std::string&, void*)> navigateCallback = nullptr;
+
+			static void on_load_changed(WebKitWebView* web_view, WebKitLoadEvent load_event,
+			                            gpointer arg)
+			{
+				if (load_event == WEBKIT_LOAD_FINISHED)
+				{
+					auto inst = static_cast<gtk_webkit_engine*>(arg);
+					inst->navigateCallback(webkit_web_view_get_uri(web_view),
+					                       inst->navigateCallbackArg);
+				}
+			}
+		};
+
+	} // namespace detail
+
+	using browser_engine = detail::gtk_webkit_engine;
+
+} // namespace webview
+
+#elif defined(WEBVIEW_COCOA)
+
+//
+// ====================================================================
+//
+// This implementation uses Cocoa WKWebView backend on macOS. It is
+// written using ObjC runtime and uses WKWebView class as a browser runtime.
+// You should pass "-framework Webkit" flag to the compiler.
+//
+// ====================================================================
+//
+
+#include <CoreGraphics/CoreGraphics.h>
+#include <objc/NSObjCRuntime.h>
+#include <objc/objc-runtime.h>
+
+namespace webview
+{
+	namespace detail
+	{
+		namespace objc
+		{
+
+			// A convenient template function for unconditionally casting the specified
+			// C-like function into a function that can be called with the given return
+			// type and arguments. Caller takes full responsibility for ensuring that
+			// the function call is valid. It is assumed that the function will not
+			// throw exceptions.
+			template <typename Result, typename Callable, typename... Args>
+			Result invoke(Callable callable, Args... args) noexcept
+			{
+				return reinterpret_cast<Result (*)(Args...)>(callable)(args...);
+			}
+
+			// Calls objc_msgSend.
+			template <typename Result, typename... Args> Result msg_send(Args... args) noexcept
+			{
+				return invoke<Result>(objc_msgSend, args...);
+			}
+
+		} // namespace objc
+
+		enum NSBackingStoreType : NSUInteger
+		{
+			NSBackingStoreBuffered = 2
+		};
+
+		enum NSWindowStyleMask : NSUInteger
+		{
+			NSWindowStyleMaskTitled = 1,
+			NSWindowStyleMaskClosable = 2,
+			NSWindowStyleMaskMiniaturizable = 4,
+			NSWindowStyleMaskResizable = 8
+		};
+
+		enum NSApplicationActivationPolicy : NSInteger
+		{
+			NSApplicationActivationPolicyRegular = 0
+		};
+
+		enum WKUserScriptInjectionTime : NSInteger
+		{
+			WKUserScriptInjectionTimeAtDocumentStart = 0
+		};
+
+		enum NSModalResponse : NSInteger
+		{
+			NSModalResponseOK = 1
+		};
+
+		// Convenient conversion of string literals.
+		inline id operator"" _cls(const char* s, std::size_t)
+		{
+			return (id)objc_getClass(s);
+		}
+		inline SEL operator"" _sel(const char* s, std::size_t)
+		{
+			return sel_registerName(s);
+		}
+		inline id operator"" _str(const char* s, std::size_t)
+		{
+			return objc::msg_send<id>("NSString"_cls, "stringWithUTF8String:"_sel, s);
+		}
+
+		class cocoa_wkwebview_engine
+		{
+		  public:
+			cocoa_wkwebview_engine(bool debug, void* window)
+			    : m_debug{ debug }, m_parent_window{ window }
+			{
+				auto app = get_shared_application();
+				auto delegate = create_app_delegate();
+				objc_setAssociatedObject(delegate, "webview", (id)this, OBJC_ASSOCIATION_ASSIGN);
+				objc::msg_send<void>(app, "setDelegate:"_sel, delegate);
+
+				// See comments related to application lifecycle in create_app_delegate().
+				if (window)
+				{
+					on_application_did_finish_launching(delegate, app);
+				}
+				else
+				{
+					// Start the main run loop so that the app delegate gets the
+					// NSApplicationDidFinishLaunchingNotification notification after the run
+					// loop has started in order to perform further initialization.
+					// We need to return from this constructor so this run loop is only
+					// temporary.
+					objc::msg_send<void>(app, "run"_sel);
+				}
+			}
+			virtual ~cocoa_wkwebview_engine() = default;
+			void* window()
+			{
+				return (void*)m_window;
+			}
+			void terminate()
+			{
+				auto app = get_shared_application();
+				objc::msg_send<void>(app, "terminate:"_sel, nullptr);
+			}
+			void run()
+			{
+				auto app = get_shared_application();
+				objc::msg_send<void>(app, "run"_sel);
+			}
+			void dispatch(std::function<void()> f)
+			{
+				dispatch_async_f(dispatch_get_main_queue(), new dispatch_fn_t(f),
+				                 (dispatch_function_t)([](void* arg) {
+					                 auto f = static_cast<dispatch_fn_t*>(arg);
+					                 (*f)();
+					                 delete f;
+				                 }));
+			}
+			void set_title(const std::string& title)
+			{
+				objc::msg_send<void>(
+				    m_window, "setTitle:"_sel,
+				    objc::msg_send<id>("NSString"_cls, "stringWithUTF8String:"_sel, title.c_str()));
+			}
+			void set_size(int width, int height, int hints)
+			{
+				auto style = static_cast<NSWindowStyleMask>(NSWindowStyleMaskTitled |
+				                                            NSWindowStyleMaskClosable |
+				                                            NSWindowStyleMaskMiniaturizable);
+				if (hints != WEBVIEW_HINT_FIXED)
+				{
+					style = static_cast<NSWindowStyleMask>(style | NSWindowStyleMaskResizable);
+				}
+				objc::msg_send<void>(m_window, "setStyleMask:"_sel, style);
+
+				if (hints == WEBVIEW_HINT_MIN)
+				{
+					objc::msg_send<void>(m_window, "setContentMinSize:"_sel,
+					                     CGSizeMake(width, height));
+				}
+				else if (hints == WEBVIEW_HINT_MAX)
+				{
+					objc::msg_send<void>(m_window, "setContentMaxSize:"_sel,
+					                     CGSizeMake(width, height));
+				}
+				else
+				{
+					objc::msg_send<void>(m_window, "setFrame:display:animate:"_sel,
+					                     CGRectMake(0, 0, width, height), YES, NO);
+				}
+				objc::msg_send<void>(m_window, "center"_sel);
+			}
+			void navigate(const std::string& url)
+			{
+				auto nsurl = objc::msg_send<id>(
+				    "NSURL"_cls, "URLWithString:"_sel,
+				    objc::msg_send<id>("NSString"_cls, "stringWithUTF8String:"_sel, url.c_str()));
+
+				objc::msg_send<void>(
+				    m_webview, "loadRequest:"_sel,
+				    objc::msg_send<id>("NSURLRequest"_cls, "requestWithURL:"_sel, nsurl));
+			}
+
+			void add_navigate_listener(std::function<void(const std::string&, void*)> callback,
+			                           void* arg)
+			{
+				m_navigateCallback = callback;
+				m_navigateCallbackArg = arg;
+			}
+
+			void add_scheme_handler(const std::string& scheme,
+			                        std::function<void(const std::string&, void*)> callback,
+			                        void* arg)
+			{
+				// TODO: Implement
+			}
+
+			void set_html(const std::string& html)
+			{
+				objc::msg_send<void>(
+				    m_webview, "loadHTMLString:baseURL:"_sel,
+				    objc::msg_send<id>("NSString"_cls, "stringWithUTF8String:"_sel, html.c_str()),
+				    nullptr);
+			}
+			void init(const std::string& js)
+			{
+				// Equivalent Obj-C:
+				// [m_manager addUserScript:[[WKUserScript alloc] initWithSource:[NSString
+				// stringWithUTF8String:js.c_str()]
+				// injectionTime:WKUserScriptInjectionTimeAtDocumentStart forMainFrameOnly:YES]]
+				objc::msg_send<void>(
+				    m_manager, "addUserScript:"_sel,
+				    objc::msg_send<id>(
+				        objc::msg_send<id>("WKUserScript"_cls, "alloc"_sel),
+				        "initWithSource:injectionTime:forMainFrameOnly:"_sel,
+				        objc::msg_send<id>("NSString"_cls, "stringWithUTF8String:"_sel, js.c_str()),
+				        WKUserScriptInjectionTimeAtDocumentStart, YES));
+			}
+			void eval(const std::string& js)
+			{
+				objc::msg_send<void>(
+				    m_webview, "evaluateJavaScript:completionHandler:"_sel,
+				    objc::msg_send<id>("NSString"_cls, "stringWithUTF8String:"_sel, js.c_str()),
+				    nullptr);
+			}
+
+		  private:
+			virtual void on_message(const std::string& msg) = 0;
+			id create_app_delegate()
+			{
+				// Note: Avoid registering the class name "AppDelegate" as it is the
+				// default name in projects created with Xcode, and using the same name
+				// causes objc_registerClassPair to crash.
+				auto cls =
+				    objc_allocateClassPair((Class) "NSResponder"_cls, "WebviewAppDelegate", 0);
+				class_addProtocol(cls, objc_getProtocol("NSTouchBarProvider"));
+				class_addMethod(cls, "applicationShouldTerminateAfterLastWindowClosed:"_sel,
+				                (IMP)(+[](id, SEL, id) -> BOOL { return 1; }), "c@:@");
+				// If the library was not initialized with an existing window then the user
+				// is likely managing the application lifecycle and we would not get the
+				// "applicationDidFinishLaunching:" message and therefore do not need to
+				// add this method.
+				if (!m_parent_window)
+				{
+					class_addMethod(cls, "applicationDidFinishLaunching:"_sel,
+					                (IMP)(+[](id self, SEL, id notification)
+					                      {
+						                      auto app =
+						                          objc::msg_send<id>(notification, "object"_sel);
+						                      auto w = get_associated_webview(self);
+						                      w->on_application_did_finish_launching(self, app);
+					                      }),
+					                "v@:@");
+				}
+				objc_registerClassPair(cls);
+				return objc::msg_send<id>((id)cls, "new"_sel);
+			}
+			id create_script_message_handler()
+			{
+				auto cls = objc_allocateClassPair((Class) "NSResponder"_cls,
+				                                  "WebkitScriptMessageHandler", 0);
+				class_addProtocol(cls, objc_getProtocol("WKScriptMessageHandler"));
+				class_addMethod(
+				    cls, "userContentController:didReceiveScriptMessage:"_sel,
+				    (IMP)(+[](id self, SEL, id, id msg)
+				          {
+					          auto w = get_associated_webview(self);
+					          w->on_message(objc::msg_send<const char*>(
+					              objc::msg_send<id>(msg, "body"_sel), "UTF8String"_sel));
+				          }),
+				    "v@:@@");
+				objc_registerClassPair(cls);
+				auto instance = objc::msg_send<id>((id)cls, "new"_sel);
+				objc_setAssociatedObject(instance, "webview", (id)this, OBJC_ASSOCIATION_ASSIGN);
+				return instance;
+			}
+			static id create_webkit_ui_delegate()
+			{
+				auto cls = objc_allocateClassPair((Class) "NSObject"_cls, "WebkitUIDelegate", 0);
+				class_addProtocol(cls, objc_getProtocol("WKUIDelegate"));
+				class_addMethod(
+				    cls,
+				    "webView:runOpenPanelWithParameters:initiatedByFrame:completionHandler:"_sel,
+				    (IMP)(+[](id, SEL, id, id parameters, id, id completion_handler)
+				          {
+					          auto allows_multiple_selection =
+					              objc::msg_send<BOOL>(parameters, "allowsMultipleSelection"_sel);
+					          auto allows_directories =
+					              objc::msg_send<BOOL>(parameters, "allowsDirectories"_sel);
+
+					          // Show a panel for selecting files.
+					          auto panel = objc::msg_send<id>("NSOpenPanel"_cls, "openPanel"_sel);
+					          objc::msg_send<void>(panel, "setCanChooseFiles:"_sel, YES);
+					          objc::msg_send<void>(panel, "setCanChooseDirectories:"_sel,
+					                               allows_directories);
+					          objc::msg_send<void>(panel, "setAllowsMultipleSelection:"_sel,
+					                               allows_multiple_selection);
+					          auto modal_response =
+					              objc::msg_send<NSModalResponse>(panel, "runModal"_sel);
+
+					          // Get the URLs for the selected files. If the modal was canceled
+					          // then we pass null to the completion handler to signify
+					          // cancellation.
+					          id urls = modal_response == NSModalResponseOK
+					                        ? objc::msg_send<id>(panel, "URLs"_sel)
+					                        : nullptr;
+
+					          // Invoke the completion handler block.
+					          auto sig = objc::msg_send<id>("NSMethodSignature"_cls,
+					                                        "signatureWithObjCTypes:"_sel, "v@?@");
+					          auto invocation = objc::msg_send<id>(
+					              "NSInvocation"_cls, "invocationWithMethodSignature:"_sel, sig);
+					          objc::msg_send<void>(invocation, "setTarget:"_sel,
+					                               completion_handler);
+					          objc::msg_send<void>(invocation, "setArgument:atIndex:"_sel, &urls,
+					                               1);
+					          objc::msg_send<void>(invocation, "invoke"_sel);
+				          }),
+				    "v@:@@@@");
+				objc_registerClassPair(cls);
+				return objc::msg_send<id>((id)cls, "new"_sel);
+			}
+			id create_webkit_navigation_delegate()
+			{
+				auto cls =
+				    objc_allocateClassPair((Class) "NSObject"_cls, "WebkitNavigationDelegate", 0);
+				class_addProtocol(cls, objc_getProtocol("WKNavigationDelegate"));
+				class_addMethod(cls, "webView:didFinishNavigation:"_sel,
+				                (IMP)(+[](id delegate, SEL sel, id webview, id navigation)
+				                      {
+					                      auto w = get_associated_webview(delegate);
+					                      auto url = objc::msg_send<id>(webview, "URL"_sel);
+					                      auto nstr = objc::msg_send<id>(url, "absoluteString"_sel);
+					                      auto str = objc::msg_send<char*>(nstr, "UTF8String"_sel);
+					                      w->m_navigateCallback(str, w->m_navigateCallbackArg);
+				                      }),
+				                "v@:@");
+				objc_registerClassPair(cls);
+				auto instance = objc::msg_send<id>((id)cls, "new"_sel);
+				objc_setAssociatedObject(instance, "webview", (id)this, OBJC_ASSOCIATION_ASSIGN);
+				return instance;
+			}
+			static id get_shared_application()
+			{
+				return objc::msg_send<id>("NSApplication"_cls, "sharedApplication"_sel);
+			}
+			static cocoa_wkwebview_engine* get_associated_webview(id object)
+			{
+				auto w = (cocoa_wkwebview_engine*)objc_getAssociatedObject(object, "webview");
+				assert(w);
+				return w;
+			}
+			static id get_main_bundle() noexcept
+			{
+				return objc::msg_send<id>("NSBundle"_cls, "mainBundle"_sel);
+			}
+			static bool is_app_bundled() noexcept
+			{
+				auto bundle = get_main_bundle();
+				if (!bundle)
+				{
+					return false;
+				}
+				auto bundle_path = objc::msg_send<id>(bundle, "bundlePath"_sel);
+				auto bundled = objc::msg_send<BOOL>(bundle_path, "hasSuffix:"_sel, ".app"_str);
+				return !!bundled;
+			}
+			void on_application_did_finish_launching(id /*delegate*/, id app)
+			{
+				// See comments related to application lifecycle in create_app_delegate().
+				if (!m_parent_window)
+				{
+					// Stop the main run loop so that we can return
+					// from the constructor.
+					objc::msg_send<void>(app, "stop:"_sel, nullptr);
+				}
+
+				// Activate the app if it is not bundled.
+				// Bundled apps launched from Finder are activated automatically but
+				// otherwise not. Activating the app even when it has been launched from
+				// Finder does not seem to be harmful but calling this function is rarely
+				// needed as proper activation is normally taken care of for us.
+				// Bundled apps have a default activation policy of
+				// NSApplicationActivationPolicyRegular while non-bundled apps have a
+				// default activation policy of NSApplicationActivationPolicyProhibited.
+				if (!is_app_bundled())
+				{
+					// "setActivationPolicy:" must be invoked before
+					// "activateIgnoringOtherApps:" for activation to work.
+					objc::msg_send<void>(app, "setActivationPolicy:"_sel,
+					                     NSApplicationActivationPolicyRegular);
+					// Activate the app regardless of other active apps.
+					// This can be obtrusive so we only do it when necessary.
+					objc::msg_send<void>(app, "activateIgnoringOtherApps:"_sel, YES);
+				}
+
+				// Main window
+				if (!m_parent_window)
+				{
+					m_window = objc::msg_send<id>("NSWindow"_cls, "alloc"_sel);
+					auto style = NSWindowStyleMaskTitled;
+					m_window = objc::msg_send<id>(
+					    m_window, "initWithContentRect:styleMask:backing:defer:"_sel,
+					    CGRectMake(0, 0, 0, 0), style, NSBackingStoreBuffered, NO);
+				}
+				else
+				{
+					m_window = (id)m_parent_window;
+				}
+
+				// Webview
+				auto config = objc::msg_send<id>("WKWebViewConfiguration"_cls, "new"_sel);
+				m_manager = objc::msg_send<id>(config, "userContentController"_sel);
+				m_webview = objc::msg_send<id>("WKWebView"_cls, "alloc"_sel);
+
+				if (m_debug)
+				{
+					// Equivalent Obj-C:
+					// [[config preferences] setValue:@YES forKey:@"developerExtrasEnabled"];
+					objc::msg_send<id>(
+					    objc::msg_send<id>(config, "preferences"_sel), "setValue:forKey:"_sel,
+					    objc::msg_send<id>("NSNumber"_cls, "numberWithBool:"_sel, YES),
+					    "developerExtrasEnabled"_str);
+				}
+
+				// Equivalent Obj-C:
+				// [[config preferences] setValue:@YES forKey:@"fullScreenEnabled"];
+				objc::msg_send<id>(objc::msg_send<id>(config, "preferences"_sel),
+				                   "setValue:forKey:"_sel,
+				                   objc::msg_send<id>("NSNumber"_cls, "numberWithBool:"_sel, YES),
+				                   "fullScreenEnabled"_str);
+
+				// Equivalent Obj-C:
+				// [[config preferences] setValue:@YES forKey:@"javaScriptCanAccessClipboard"];
+				objc::msg_send<id>(objc::msg_send<id>(config, "preferences"_sel),
+				                   "setValue:forKey:"_sel,
+				                   objc::msg_send<id>("NSNumber"_cls, "numberWithBool:"_sel, YES),
+				                   "javaScriptCanAccessClipboard"_str);
+
+				// Equivalent Obj-C:
+				// [[config preferences] setValue:@YES forKey:@"DOMPasteAllowed"];
+				objc::msg_send<id>(objc::msg_send<id>(config, "preferences"_sel),
+				                   "setValue:forKey:"_sel,
+				                   objc::msg_send<id>("NSNumber"_cls, "numberWithBool:"_sel, YES),
+				                   "DOMPasteAllowed"_str);
+
+				auto ui_delegate = create_webkit_ui_delegate();
+				objc::msg_send<void>(m_webview, "initWithFrame:configuration:"_sel,
+				                     CGRectMake(0, 0, 0, 0), config);
+				objc::msg_send<void>(m_webview, "setUIDelegate:"_sel, ui_delegate);
+
+				auto navigation_delegate = create_webkit_navigation_delegate();
+				objc::msg_send<void>(m_webview, "setNavigationDelegate:"_sel, navigation_delegate);
+				auto script_message_handler = create_script_message_handler();
+				objc::msg_send<void>(m_manager, "addScriptMessageHandler:name:"_sel,
+				                     script_message_handler, "external"_str);
+
+				init(R""(
+      window.external = {
+        invoke: function(s) {
+          window.webkit.messageHandlers.external.postMessage(s);
+        },
+      };
+      )"");
+				objc::msg_send<void>(m_window, "setContentView:"_sel, m_webview);
+				objc::msg_send<void>(m_window, "makeKeyAndOrderFront:"_sel, nullptr);
+			}
+			bool m_debug;
+			void* m_parent_window;
+			id m_window;
+			id m_webview;
+			id m_manager;
+			void* m_navigateCallbackArg = nullptr;
+			std::function<void(const std::string&, void*)> m_navigateCallback = 0;
+		};
+
+	} // namespace detail
+
+	using browser_engine = detail::cocoa_wkwebview_engine;
+
+} // namespace webview
+
+#elif defined(WEBVIEW_EDGE)
+
+//
+// ====================================================================
+//
+// This implementation uses Win32 API to create a native window. It
+// uses Edge/Chromium webview2 backend as a browser engine.
+//
+// ====================================================================
+//
+
+#define WIN32_LEAN_AND_MEAN
+#include <shlobj.h>
+#include <shlwapi.h>
+#include <stdlib.h>
+#include <windows.h>
+
+#include "WebView2.h"
+
+#ifdef _MSC_VER
+#pragma comment(lib, "advapi32.lib")
+#pragma comment(lib, "ole32.lib")
+#pragma comment(lib, "shell32.lib")
+#pragma comment(lib, "shlwapi.lib")
+#pragma comment(lib, "user32.lib")
+#pragma comment(lib, "version.lib")
+#endif
+
+namespace webview
+{
+	namespace detail
+	{
+
+		using msg_cb_t = std::function<void(const std::string)>;
+
+		// Converts a narrow (UTF-8-encoded) string into a wide (UTF-16-encoded) string.
+		inline std::wstring widen_string(const std::string& input)
+		{
+			if (input.empty())
+			{
+				return std::wstring();
+			}
+			UINT cp = CP_UTF8;
+			DWORD flags = MB_ERR_INVALID_CHARS;
+			auto input_c = input.c_str();
+			auto input_length = static_cast<int>(input.size());
+			auto required_length =
+			    MultiByteToWideChar(cp, flags, input_c, input_length, nullptr, 0);
+			if (required_length > 0)
+			{
+				std::wstring output(static_cast<std::size_t>(required_length), L'\0');
+				if (MultiByteToWideChar(cp, flags, input_c, input_length, &output[0],
+				                        required_length) > 0)
+				{
+					return output;
+				}
+			}
+			// Failed to convert string from UTF-8 to UTF-16
+			return std::wstring();
+		}
+
+		// Converts a wide (UTF-16-encoded) string into a narrow (UTF-8-encoded) string.
+		inline std::string narrow_string(const std::wstring& input)
+		{
+			if (input.empty())
+			{
+				return std::string();
+			}
+			UINT cp = CP_UTF8;
+			DWORD flags = WC_ERR_INVALID_CHARS;
+			auto input_c = input.c_str();
+			auto input_length = static_cast<int>(input.size());
+			auto required_length =
+			    WideCharToMultiByte(cp, flags, input_c, input_length, nullptr, 0, nullptr, nullptr);
+			if (required_length > 0)
+			{
+				std::string output(static_cast<std::size_t>(required_length), '\0');
+				if (WideCharToMultiByte(cp, flags, input_c, input_length, &output[0],
+				                        required_length, nullptr, nullptr) > 0)
+				{
+					return output;
+				}
+			}
+			// Failed to convert string from UTF-16 to UTF-8
+			return std::string();
+		}
+
+		// Parses a version string with 1-4 integral components, e.g. "1.2.3.4".
+		// Missing or invalid components default to 0, and excess components are ignored.
+		template <typename T>
+		std::array<unsigned int, 4> parse_version(const std::basic_string<T>& version) noexcept
+		{
+			auto parse_component = [](auto sb, auto se) -> unsigned int
+			{
+				try
+				{
+					auto n = std::stol(std::basic_string<T>(sb, se));
+					return n < 0 ? 0 : n;
+				}
+				catch (std::exception&)
+				{
+					return 0;
+				}
+			};
+			auto end = version.end();
+			auto sb = version.begin(); // subrange begin
+			auto se = sb;              // subrange end
+			unsigned int ci = 0;       // component index
+			std::array<unsigned int, 4> components{};
+			while (sb != end && se != end && ci < components.size())
+			{
+				if (*se == static_cast<T>('.'))
+				{
+					components[ci++] = parse_component(sb, se);
+					sb = ++se;
+					continue;
+				}
+				++se;
+			}
+			if (sb < se && ci < components.size())
+			{
+				components[ci] = parse_component(sb, se);
+			}
+			return components;
+		}
+
+		template <typename T, std::size_t Length>
+		auto parse_version(const T (&version)[Length]) noexcept
+		{
+			return parse_version(std::basic_string<T>(version, Length));
+		}
+
+		std::wstring get_file_version_string(const std::wstring& file_path) noexcept
+		{
+			DWORD dummy_handle; // Unused
+			DWORD info_buffer_length = GetFileVersionInfoSizeW(file_path.c_str(), &dummy_handle);
+			if (info_buffer_length == 0)
+			{
+				return std::wstring();
+			}
+			std::vector<char> info_buffer;
+			info_buffer.reserve(info_buffer_length);
+			if (!GetFileVersionInfoW(file_path.c_str(), 0, info_buffer_length, info_buffer.data()))
+			{
+				return std::wstring();
+			}
+			auto sub_block = L"\\StringFileInfo\\040904B0\\ProductVersion";
+			LPWSTR version = nullptr;
+			unsigned int version_length = 0;
+			if (!VerQueryValueW(info_buffer.data(), sub_block, reinterpret_cast<LPVOID*>(&version),
+			                    &version_length))
+			{
+				return std::wstring();
+			}
+			if (!version || version_length == 0)
+			{
+				return std::wstring();
+			}
+			return std::wstring(version, version_length);
+		}
+
+		// A wrapper around COM library initialization. Calls CoInitializeEx in the
+		// constructor and CoUninitialize in the destructor.
+		class com_init_wrapper
+		{
+		  public:
+			com_init_wrapper(DWORD dwCoInit)
+			{
+				// We can safely continue as long as COM was either successfully
+				// initialized or already initialized.
+				// RPC_E_CHANGED_MODE means that CoInitializeEx was already called with
+				// a different concurrency model.
+				switch (CoInitializeEx(nullptr, dwCoInit))
+				{
+					case S_OK:
+					case S_FALSE:
+						m_initialized = true;
+						break;
+				}
+			}
+
+			~com_init_wrapper()
+			{
+				if (m_initialized)
+				{
+					CoUninitialize();
+					m_initialized = false;
+				}
+			}
+
+			com_init_wrapper(const com_init_wrapper& other) = delete;
+			com_init_wrapper& operator=(const com_init_wrapper& other) = delete;
+			com_init_wrapper(com_init_wrapper&& other) = delete;
+			com_init_wrapper& operator=(com_init_wrapper&& other) = delete;
+
+			bool is_initialized() const
+			{
+				return m_initialized;
+			}
+
+		  private:
+			bool m_initialized = false;
+		};
+
+		// Holds a symbol name and associated type for code clarity.
+		template <typename T> class library_symbol
+		{
+		  public:
+			using type = T;
+
+			constexpr explicit library_symbol(const char* name) : m_name(name)
+			{
+			}
+			constexpr const char* get_name() const
+			{
+				return m_name;
+			}
+
+		  private:
+			const char* m_name;
+		};
+
+		// Loads a native shared library and allows one to get addresses for those
+		// symbols.
+		class native_library
+		{
+		  public:
+			explicit native_library(const wchar_t* name) : m_handle(LoadLibraryW(name))
+			{
+			}
+
+			~native_library()
+			{
+				if (m_handle)
+				{
+					FreeLibrary(m_handle);
+					m_handle = nullptr;
+				}
+			}
+
+			native_library(const native_library& other) = delete;
+			native_library& operator=(const native_library& other) = delete;
+			native_library(native_library&& other) = default;
+			native_library& operator=(native_library&& other) = default;
+
+			// Returns true if the library is currently loaded; otherwise false.
+			operator bool() const
+			{
+				return is_loaded();
+			}
+
+			// Get the address for the specified symbol or nullptr if not found.
+			template <typename Symbol> typename Symbol::type get(const Symbol& symbol) const
+			{
+				if (is_loaded())
+				{
+					return reinterpret_cast<typename Symbol::type>(
+					    GetProcAddress(m_handle, symbol.get_name()));
+				}
+				return nullptr;
+			}
+
+			// Returns true if the library is currently loaded; otherwise false.
+			bool is_loaded() const
+			{
+				return !!m_handle;
+			}
+
+			void detach()
+			{
+				m_handle = nullptr;
+			}
+
+		  private:
+			HMODULE m_handle = nullptr;
+		};
+
+		struct user32_symbols
+		{
+			using DPI_AWARENESS_CONTEXT = HANDLE;
+			using SetProcessDpiAwarenessContext_t = BOOL(WINAPI*)(DPI_AWARENESS_CONTEXT);
+			using SetProcessDPIAware_t = BOOL(WINAPI*)();
+
+			static constexpr auto SetProcessDpiAwarenessContext =
+			    library_symbol<SetProcessDpiAwarenessContext_t>("SetProcessDpiAwarenessContext");
+			static constexpr auto SetProcessDPIAware =
+			    library_symbol<SetProcessDPIAware_t>("SetProcessDPIAware");
+		};
+
+		struct shcore_symbols
+		{
+			typedef enum
+			{
+				PROCESS_PER_MONITOR_DPI_AWARE = 2
+			} PROCESS_DPI_AWARENESS;
+			using SetProcessDpiAwareness_t = HRESULT(WINAPI*)(PROCESS_DPI_AWARENESS);
+
+			static constexpr auto SetProcessDpiAwareness =
+			    library_symbol<SetProcessDpiAwareness_t>("SetProcessDpiAwareness");
+		};
+
+		class reg_key
+		{
+		  public:
+			explicit reg_key(HKEY root_key, const wchar_t* sub_key, DWORD options,
+			                 REGSAM sam_desired)
+			{
+				HKEY handle;
+				auto status = RegOpenKeyExW(root_key, sub_key, options, sam_desired, &handle);
+				if (status == ERROR_SUCCESS)
+				{
+					m_handle = handle;
+				}
+			}
+
+			explicit reg_key(HKEY root_key, const std::wstring& sub_key, DWORD options,
+			                 REGSAM sam_desired)
+			    : reg_key(root_key, sub_key.c_str(), options, sam_desired)
+			{
+			}
+
+			virtual ~reg_key()
+			{
+				if (m_handle)
+				{
+					RegCloseKey(m_handle);
+					m_handle = nullptr;
+				}
+			}
+
+			reg_key(const reg_key& other) = delete;
+			reg_key& operator=(const reg_key& other) = delete;
+			reg_key(reg_key&& other) = delete;
+			reg_key& operator=(reg_key&& other) = delete;
+
+			bool is_open() const
+			{
+				return !!m_handle;
+			}
+			bool get_handle() const
+			{
+				return m_handle;
+			}
+
+			std::wstring query_string(const wchar_t* name) const
+			{
+				DWORD buf_length = 0;
+				// Get the size of the data in bytes.
+				auto status =
+				    RegQueryValueExW(m_handle, name, nullptr, nullptr, nullptr, &buf_length);
+				if (status != ERROR_SUCCESS && status != ERROR_MORE_DATA)
+				{
+					return std::wstring();
+				}
+				// Read the data.
+				std::wstring result(buf_length / sizeof(wchar_t), 0);
+				auto buf = reinterpret_cast<LPBYTE>(&result[0]);
+				status = RegQueryValueExW(m_handle, name, nullptr, nullptr, buf, &buf_length);
+				if (status != ERROR_SUCCESS)
+				{
+					return std::wstring();
+				}
+				// Remove trailing null-characters.
+				for (std::size_t length = result.size(); length > 0; --length)
+				{
+					if (result[length - 1] != 0)
+					{
+						result.resize(length);
+						break;
+					}
+				}
+				return result;
+			}
+
+		  private:
+			HKEY m_handle = nullptr;
+		};
+
+		inline bool enable_dpi_awareness()
+		{
+			auto user32 = native_library(L"user32.dll");
+			if (auto fn = user32.get(user32_symbols::SetProcessDpiAwarenessContext))
+			{
+				if (fn(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE))
+				{
+					return true;
+				}
+				return GetLastError() == ERROR_ACCESS_DENIED;
+			}
+			if (auto shcore = native_library(L"shcore.dll"))
+			{
+				if (auto fn = shcore.get(shcore_symbols::SetProcessDpiAwareness))
+				{
+					auto result = fn(shcore_symbols::PROCESS_PER_MONITOR_DPI_AWARE);
+					return result == S_OK || result == E_ACCESSDENIED;
+				}
+			}
+			if (auto fn = user32.get(user32_symbols::SetProcessDPIAware))
+			{
+				return !!fn();
+			}
+			return true;
+		}
+
+// Enable built-in WebView2Loader implementation by default.
+#ifndef WEBVIEW_MSWEBVIEW2_BUILTIN_IMPL
+#define WEBVIEW_MSWEBVIEW2_BUILTIN_IMPL 1
+#endif
+
+// Link WebView2Loader.dll explicitly by default only if the built-in
+// implementation is enabled.
+#ifndef WEBVIEW_MSWEBVIEW2_EXPLICIT_LINK
+#define WEBVIEW_MSWEBVIEW2_EXPLICIT_LINK WEBVIEW_MSWEBVIEW2_BUILTIN_IMPL
+#endif
+
+// Explicit linking of WebView2Loader.dll should be used along with
+// the built-in implementation.
+#if WEBVIEW_MSWEBVIEW2_BUILTIN_IMPL == 1 && WEBVIEW_MSWEBVIEW2_EXPLICIT_LINK != 1
+#undef WEBVIEW_MSWEBVIEW2_EXPLICIT_LINK
+#error Please set WEBVIEW_MSWEBVIEW2_EXPLICIT_LINK=1.
+#endif
+
+#if WEBVIEW_MSWEBVIEW2_BUILTIN_IMPL == 1
+		// Gets the last component of a Windows native file path.
+		// For example, if the path is "C:\a\b" then the result is "b".
+		template <typename T>
+		std::basic_string<T> get_last_native_path_component(const std::basic_string<T>& path)
+		{
+			if (auto pos = path.find_last_of(static_cast<T>('\\'));
+			    pos != std::basic_string<T>::npos)
+			{
+				return path.substr(pos + 1);
+			}
+			return std::basic_string<T>();
+		}
+#endif /* WEBVIEW_MSWEBVIEW2_BUILTIN_IMPL */
+
+		template <typename T> struct cast_info_t
+		{
+			using type = T;
+			IID iid;
+		};
+
+		namespace mswebview2
+		{
+			static constexpr IID IID_ICoreWebView2CreateCoreWebView2ControllerCompletedHandler{
+				0x6C4819F3, 0xC9B7, 0x4260, 0x81, 0x27, 0xC9, 0xF5, 0xBD, 0xE7, 0xF6, 0x8C
+			};
+			static constexpr IID IID_ICoreWebView2CreateCoreWebView2EnvironmentCompletedHandler{
+				0x4E8A3389, 0xC9D8, 0x4BD2, 0xB6, 0xB5, 0x12, 0x4F, 0xEE, 0x6C, 0xC1, 0x4D
+			};
+			static constexpr IID IID_ICoreWebView2PermissionRequestedEventHandler{
+				0x15E1C6A3, 0xC72A, 0x4DF3, 0x91, 0xD7, 0xD0, 0x97, 0xFB, 0xEC, 0x6B, 0xFD
+			};
+			static constexpr IID IID_ICoreWebView2WebMessageReceivedEventHandler{
+				0x57213F19, 0x00E6, 0x49FA, 0x8E, 0x07, 0x89, 0x8E, 0xA0, 0x1E, 0xCB, 0xD2
+			};
+
+#if WEBVIEW_MSWEBVIEW2_BUILTIN_IMPL == 1
+			enum class webview2_runtime_type
+			{
+				installed = 0,
+				embedded = 1
+			};
+
+			namespace webview2_symbols
+			{
+				using CreateWebViewEnvironmentWithOptionsInternal_t = HRESULT(STDMETHODCALLTYPE*)(
+				    bool, webview2_runtime_type, PCWSTR, IUnknown*,
+				    ICoreWebView2CreateCoreWebView2EnvironmentCompletedHandler*);
+				using DllCanUnloadNow_t = HRESULT(STDMETHODCALLTYPE*)();
+
+				static constexpr auto CreateWebViewEnvironmentWithOptionsInternal =
+				    library_symbol<CreateWebViewEnvironmentWithOptionsInternal_t>(
+				        "CreateWebViewEnvironmentWithOptionsInternal");
+				static constexpr auto DllCanUnloadNow =
+				    library_symbol<DllCanUnloadNow_t>("DllCanUnloadNow");
+			} // namespace webview2_symbols
+#endif /* WEBVIEW_MSWEBVIEW2_BUILTIN_IMPL */
+
+#if WEBVIEW_MSWEBVIEW2_EXPLICIT_LINK == 1
+			namespace webview2_symbols
+			{
+				using CreateCoreWebView2EnvironmentWithOptions_t = HRESULT(STDMETHODCALLTYPE*)(
+				    PCWSTR, PCWSTR, ICoreWebView2EnvironmentOptions*,
+				    ICoreWebView2CreateCoreWebView2EnvironmentCompletedHandler*);
+				using GetAvailableCoreWebView2BrowserVersionString_t =
+				    HRESULT(STDMETHODCALLTYPE*)(PCWSTR, LPWSTR*);
+
+				static constexpr auto CreateCoreWebView2EnvironmentWithOptions =
+				    library_symbol<CreateCoreWebView2EnvironmentWithOptions_t>(
+				        "CreateCoreWebView2EnvironmentWithOptions");
+				static constexpr auto GetAvailableCoreWebView2BrowserVersionString =
+				    library_symbol<GetAvailableCoreWebView2BrowserVersionString_t>(
+				        "GetAvailableCoreWebView2BrowserVersionString");
+			} // namespace webview2_symbols
+#endif /* WEBVIEW_MSWEBVIEW2_EXPLICIT_LINK */
+
+			class loader
+			{
+			  public:
+				HRESULT create_environment_with_options(
+				    PCWSTR browser_dir, PCWSTR user_data_dir,
+				    ICoreWebView2EnvironmentOptions* env_options,
+				    ICoreWebView2CreateCoreWebView2EnvironmentCompletedHandler* created_handler)
+				    const
+				{
+#if WEBVIEW_MSWEBVIEW2_EXPLICIT_LINK == 1
+					if (m_lib.is_loaded())
+					{
+						if (auto fn = m_lib.get(
+						        webview2_symbols::CreateCoreWebView2EnvironmentWithOptions))
+						{
+							return fn(browser_dir, user_data_dir, env_options, created_handler);
+						}
+					}
+#if WEBVIEW_MSWEBVIEW2_BUILTIN_IMPL == 1
+					return create_environment_with_options_impl(browser_dir, user_data_dir,
+					                                            env_options, created_handler);
+#else
+					return S_FALSE;
+#endif
+#else
+					return ::CreateCoreWebView2EnvironmentWithOptions(browser_dir, user_data_dir,
+					                                                  env_options, created_handler);
+#endif /* WEBVIEW_MSWEBVIEW2_EXPLICIT_LINK */
+				}
+
+				HRESULT
+				get_available_browser_version_string(PCWSTR browser_dir, LPWSTR* version) const
+				{
+#if WEBVIEW_MSWEBVIEW2_EXPLICIT_LINK == 1
+					if (m_lib.is_loaded())
+					{
+						if (auto fn = m_lib.get(
+						        webview2_symbols::GetAvailableCoreWebView2BrowserVersionString))
+						{
+							return fn(browser_dir, version);
+						}
+					}
+#if WEBVIEW_MSWEBVIEW2_BUILTIN_IMPL == 1
+					return get_available_browser_version_string_impl(browser_dir, version);
+#else
+					return S_FALSE;
+#endif
+#else
+					return ::GetAvailableCoreWebView2BrowserVersionString(browser_dir, version);
+#endif /* WEBVIEW_MSWEBVIEW2_EXPLICIT_LINK */
+				}
+
+			  private:
+#if WEBVIEW_MSWEBVIEW2_BUILTIN_IMPL == 1
+				struct client_info_t
+				{
+					bool found = false;
+					std::wstring dll_path;
+					std::wstring version;
+					webview2_runtime_type runtime_type;
+				};
+
+				HRESULT create_environment_with_options_impl(
+				    PCWSTR browser_dir, PCWSTR user_data_dir,
+				    ICoreWebView2EnvironmentOptions* env_options,
+				    ICoreWebView2CreateCoreWebView2EnvironmentCompletedHandler* created_handler)
+				    const
+				{
+					auto found_client = find_available_client(browser_dir);
+					if (!found_client.found)
+					{
+						return -1;
+					}
+					auto client_dll = native_library(found_client.dll_path.c_str());
+					if (auto fn = client_dll.get(
+					        webview2_symbols::CreateWebViewEnvironmentWithOptionsInternal))
+					{
+						return fn(true, found_client.runtime_type, user_data_dir, env_options,
+						          created_handler);
+					}
+					if (auto fn = client_dll.get(webview2_symbols::DllCanUnloadNow))
+					{
+						if (!fn())
+						{
+							client_dll.detach();
+						}
+					}
+					return ERROR_SUCCESS;
+				}
+
+				HRESULT
+				get_available_browser_version_string_impl(PCWSTR browser_dir, LPWSTR* version) const
+				{
+					if (!version)
+					{
+						return -1;
+					}
+					auto found_client = find_available_client(browser_dir);
+					if (!found_client.found)
+					{
+						return -1;
+					}
+					auto info_length_bytes =
+					    found_client.version.size() * sizeof(found_client.version[0]);
+					auto info = static_cast<LPWSTR>(CoTaskMemAlloc(info_length_bytes));
+					if (!info)
+					{
+						return -1;
+					}
+					CopyMemory(info, found_client.version.c_str(), info_length_bytes);
+					*version = info;
+					return 0;
+				}
+
+				client_info_t find_available_client(PCWSTR browser_dir) const
+				{
+					if (browser_dir)
+					{
+						return find_embedded_client(api_version, browser_dir);
+					}
+					auto found_client =
+					    find_installed_client(api_version, true, default_release_channel_guid);
+					if (!found_client.found)
+					{
+						found_client =
+						    find_installed_client(api_version, false, default_release_channel_guid);
+					}
+					return found_client;
+				}
+
+				std::wstring make_client_dll_path(const std::wstring& dir) const
+				{
+					auto dll_path = dir;
+					if (!dll_path.empty())
+					{
+						auto last_char = dir[dir.size() - 1];
+						if (last_char != L'\\' && last_char != L'/')
+						{
+							dll_path += L'\\';
+						}
+					}
+					dll_path += L"EBWebView\\";
+#if defined(_M_X64) || defined(__x86_64__)
+					dll_path += L"x64";
+#elif defined(_M_IX86) || defined(__i386__)
+					dll_path += L"x86";
+#elif defined(_M_ARM64) || defined(__aarch64__)
+					dll_path += L"arm64";
+#else
+#error WebView2 integration for this platform is not yet supported.
+#endif
+					dll_path += L"\\EmbeddedBrowserWebView.dll";
+					return dll_path;
+				}
+
+				client_info_t find_installed_client(unsigned int min_api_version, bool system,
+				                                    const std::wstring& release_channel) const
+				{
+					std::wstring sub_key = client_state_reg_sub_key;
+					sub_key += release_channel;
+					auto root_key = system ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
+					reg_key key(root_key, sub_key, 0, KEY_READ | KEY_WOW64_32KEY);
+					if (!key.is_open())
+					{
+						return {};
+					}
+					auto ebwebview_value = key.query_string(L"EBWebView");
+
+					auto client_version_string = get_last_native_path_component(ebwebview_value);
+					auto client_version = parse_version(client_version_string);
+					if (client_version[2] < min_api_version)
+					{
+						// Our API version is greater than the runtime API version.
+						return {};
+					}
+
+					auto client_dll_path = make_client_dll_path(ebwebview_value);
+					return { true, client_dll_path, client_version_string,
+						     webview2_runtime_type::installed };
+				}
+
+				client_info_t find_embedded_client(unsigned int min_api_version,
+				                                   const std::wstring& dir) const
+				{
+					auto client_dll_path = make_client_dll_path(dir);
+
+					auto client_version_string = get_file_version_string(client_dll_path);
+					auto client_version = parse_version(client_version_string);
+					if (client_version[2] < min_api_version)
+					{
+						// Our API version is greater than the runtime API version.
+						return {};
+					}
+
+					return { true, client_dll_path, client_version_string,
+						     webview2_runtime_type::embedded };
+				}
+
+				// The minimum WebView2 API version we need regardless of the SDK release
+				// actually used. The number comes from the SDK release version,
+				// e.g. 1.0.1150.38. To be safe the SDK should have a number that is greater
+				// than or equal to this number. The Edge browser webview client must
+				// have a number greater than or equal to this number.
+				static constexpr unsigned int api_version = 1150;
+
+				static constexpr auto client_state_reg_sub_key =
+				    L"SOFTWARE\\Microsoft\\EdgeUpdate\\ClientState\\";
+
+				// GUID for the stable release channel.
+				static constexpr auto stable_release_guid =
+				    L"{F3017226-FE2A-4295-8BDF-00C3A9A7E4C5}";
+
+				static constexpr auto default_release_channel_guid = stable_release_guid;
+#endif /* WEBVIEW_MSWEBVIEW2_BUILTIN_IMPL */
+
+#if WEBVIEW_MSWEBVIEW2_EXPLICIT_LINK == 1
+				native_library m_lib{ L"WebView2Loader.dll" };
+#endif
+			};
+
+			namespace cast_info
+			{
+				static constexpr auto controller_completed =
+				    cast_info_t<ICoreWebView2CreateCoreWebView2ControllerCompletedHandler>{
+					    IID_ICoreWebView2CreateCoreWebView2ControllerCompletedHandler
+				    };
+
+				static constexpr auto environment_completed =
+				    cast_info_t<ICoreWebView2CreateCoreWebView2EnvironmentCompletedHandler>{
+					    IID_ICoreWebView2CreateCoreWebView2EnvironmentCompletedHandler
+				    };
+
+				static constexpr auto message_received =
+				    cast_info_t<ICoreWebView2WebMessageReceivedEventHandler>{
+					    IID_ICoreWebView2WebMessageReceivedEventHandler
+				    };
+
+				static constexpr auto permission_requested =
+				    cast_info_t<ICoreWebView2PermissionRequestedEventHandler>{
+					    IID_ICoreWebView2PermissionRequestedEventHandler
+				    };
+			} // namespace cast_info
+		}     // namespace mswebview2
+
+		class webview2_com_handler
+		    : public ICoreWebView2CreateCoreWebView2EnvironmentCompletedHandler,
+		      public ICoreWebView2CreateCoreWebView2ControllerCompletedHandler,
+		      public ICoreWebView2WebMessageReceivedEventHandler,
+		      public ICoreWebView2PermissionRequestedEventHandler,
+		      public ICoreWebView2NavigationCompletedEventHandler
+		{
+			using webview2_com_handler_cb_t =
+			    std::function<void(ICoreWebView2Controller*, ICoreWebView2* webview)>;
+
+		  public:
+			webview2_com_handler(HWND hwnd, msg_cb_t msgCb, webview2_com_handler_cb_t cb)
+			    : m_window(hwnd), m_msgCb(msgCb), m_cb(cb)
+			{
+			}
+
+			virtual ~webview2_com_handler() = default;
+			webview2_com_handler(const webview2_com_handler& other) = delete;
+			webview2_com_handler& operator=(const webview2_com_handler& other) = delete;
+			webview2_com_handler(webview2_com_handler&& other) = delete;
+			webview2_com_handler& operator=(webview2_com_handler&& other) = delete;
+
+			ULONG STDMETHODCALLTYPE AddRef()
+			{
+				return ++m_ref_count;
+			}
+			ULONG STDMETHODCALLTYPE Release()
+			{
+				if (m_ref_count > 1)
+				{
+					return --m_ref_count;
+				}
+				delete this;
+				return 0;
+			}
+			HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, LPVOID* ppv)
+			{
+				using namespace mswebview2::cast_info;
+
+				if (!ppv)
+				{
+					return E_POINTER;
+				}
+
+				// All of the COM interfaces we implement should be added here regardless
+				// of whether they are required.
+				// This is just to be on the safe side in case the WebView2 Runtime ever
+				// requests a pointer to an interface we implement.
+				// The WebView2 Runtime must at the very least be able to get a pointer to
+				// ICoreWebView2CreateCoreWebView2EnvironmentCompletedHandler when we use
+				// our custom WebView2 loader implementation, and observations have shown
+				// that it is the only interface requested in this case. None have been
+				// observed to be requested when using the official WebView2 loader.
+
+				if (cast_if_equal_iid(riid, controller_completed, ppv) ||
+				    cast_if_equal_iid(riid, environment_completed, ppv) ||
+				    cast_if_equal_iid(riid, message_received, ppv) ||
+				    cast_if_equal_iid(riid, permission_requested, ppv))
+				{
+					return S_OK;
+				}
+
+				return E_NOINTERFACE;
+			}
+			HRESULT STDMETHODCALLTYPE Invoke(HRESULT res, ICoreWebView2Environment* env)
+			{
+				if (SUCCEEDED(res))
+				{
+					res = env->CreateCoreWebView2Controller(m_window, this);
+					if (SUCCEEDED(res))
+					{
+						return S_OK;
+					}
+				}
+				try_create_environment();
+				return S_OK;
+			}
+			HRESULT STDMETHODCALLTYPE Invoke(HRESULT res, ICoreWebView2Controller* controller)
+			{
+				if (FAILED(res))
+				{
+					// See try_create_environment() regarding
+					// HRESULT_FROM_WIN32(ERROR_INVALID_STATE).
+					// The result is E_ABORT if the parent window has been destroyed already.
+					switch (res)
+					{
+						case HRESULT_FROM_WIN32(ERROR_INVALID_STATE):
+						case E_ABORT:
+							return S_OK;
+					}
+					try_create_environment();
+					return S_OK;
+				}
+
+				ICoreWebView2* webview;
+				::EventRegistrationToken token;
+				controller->get_CoreWebView2(&webview);
+				webview->add_WebMessageReceived(this, &token);
+				webview->add_PermissionRequested(this, &token);
+				webview->add_NavigationCompleted(this, &token);
+
+				m_cb(controller, webview);
+				return S_OK;
+			}
+			HRESULT STDMETHODCALLTYPE Invoke(ICoreWebView2* sender,
+			                                 ICoreWebView2WebMessageReceivedEventArgs* args)
+			{
+				LPWSTR message;
+				args->TryGetWebMessageAsString(&message);
+				m_msgCb(narrow_string(message));
+				sender->PostWebMessageAsString(message);
+
+				CoTaskMemFree(message);
+				return S_OK;
+			}
+			HRESULT STDMETHODCALLTYPE Invoke(ICoreWebView2* sender,
+			                                 ICoreWebView2PermissionRequestedEventArgs* args)
+			{
+				COREWEBVIEW2_PERMISSION_KIND kind;
+				args->get_PermissionKind(&kind);
+				if (kind == COREWEBVIEW2_PERMISSION_KIND_CLIPBOARD_READ)
+				{
+					args->put_State(COREWEBVIEW2_PERMISSION_STATE_ALLOW);
+				}
+				return S_OK;
+			}
+			HRESULT STDMETHODCALLTYPE Invoke(ICoreWebView2* sender,
+			                                 ICoreWebView2NavigationCompletedEventArgs* args)
+			{
+				PWSTR uri = nullptr;
+				auto hr = sender->get_Source(&uri);
+				if (SUCCEEDED(hr))
+				{
+					auto curi = std::wstring_convert<std::codecvt_utf8<wchar_t> >().to_bytes(uri);
+					if (navigateCallback)
+						navigateCallback(curi, navigateCallbackArg);
+				}
+				CoTaskMemFree(uri);
+				return hr;
+			}
+
+			// Checks whether the specified IID equals the IID of the specified type and
+			// if so casts the "this" pointer to T and returns it. Returns nullptr on
+			// mismatching IIDs.
+			// If ppv is specified then the pointer will also be assigned to *ppv.
+			template <typename T>
+			T* cast_if_equal_iid(REFIID riid, const cast_info_t<T>& info,
+			                     LPVOID* ppv = nullptr) noexcept
+			{
+				T* ptr = nullptr;
+				if (IsEqualIID(riid, info.iid))
+				{
+					ptr = static_cast<T*>(this);
+					ptr->AddRef();
+				}
+				if (ppv)
+				{
+					*ppv = ptr;
+				}
+				return ptr;
+			}
+
+			// Set the function that will perform the initiating logic for creating
+			// the WebView2 environment.
+			void set_attempt_handler(std::function<HRESULT()> attempt_handler) noexcept
+			{
+				m_attempt_handler = attempt_handler;
+			}
+
+			// Retry creating a WebView2 environment.
+			// The initiating logic for creating the environment is defined by the
+			// caller of set_attempt_handler().
+			void try_create_environment() noexcept
+			{
+				// WebView creation fails with HRESULT_FROM_WIN32(ERROR_INVALID_STATE) if
+				// a running instance using the same user data folder exists, and the
+				// Environment objects have different EnvironmentOptions.
+				// Source:
+				// https://docs.microsoft.com/en-us/microsoft-edge/webview2/reference/win32/icorewebview2environment?view=webview2-1.0.1150.38
+				if (m_attempts < m_max_attempts)
+				{
+					++m_attempts;
+					auto res = m_attempt_handler();
+					if (SUCCEEDED(res))
+					{
+						return;
+					}
+					// Not entirely sure if this error code only applies to
+					// CreateCoreWebView2Controller so we check here as well.
+					if (res == HRESULT_FROM_WIN32(ERROR_INVALID_STATE))
+					{
+						return;
+					}
+					try_create_environment();
+					return;
+				}
+				// Give up.
+				m_cb(nullptr, nullptr);
+			}
+
+			void STDMETHODCALLTYPE add_navigate_listener(
+			    std::function<void(const std::string&, void*)> callback, void* arg)
+			{
+				navigateCallback = std::move(callback);
+				navigateCallbackArg = arg;
+			}
+
+		  private:
+			HWND m_window;
+			msg_cb_t m_msgCb;
+			webview2_com_handler_cb_t m_cb;
+			std::atomic<ULONG> m_ref_count{ 1 };
+			std::function<HRESULT()> m_attempt_handler;
+			unsigned int m_max_attempts = 5;
+			unsigned int m_attempts = 0;
+			void* navigateCallbackArg = nullptr;
+			std::function<void(const std::string&, void*)> navigateCallback = 0;
+		};
+
+		class win32_edge_engine
+		{
+		  public:
+			win32_edge_engine(bool debug, void* window)
+			{
+				if (!is_webview2_available())
+				{
+					return;
+				}
+				if (!m_com_init.is_initialized())
+				{
+					return;
+				}
+				enable_dpi_awareness();
+				if (window == nullptr)
+				{
+					HINSTANCE hInstance = GetModuleHandle(nullptr);
+					HICON icon = (HICON)LoadImage(hInstance, IDI_APPLICATION, IMAGE_ICON,
+					                              GetSystemMetrics(SM_CXICON),
+					                              GetSystemMetrics(SM_CYICON), LR_DEFAULTCOLOR);
+
+					WNDCLASSEXW wc;
+					ZeroMemory(&wc, sizeof(WNDCLASSEX));
+					wc.cbSize = sizeof(WNDCLASSEX);
+					wc.hInstance = hInstance;
+					wc.lpszClassName = L"webview";
+					wc.hIcon = icon;
+					wc.lpfnWndProc =
+					    (WNDPROC)(+[](HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) -> LRESULT
+					              {
+						              auto w =
+						                  (win32_edge_engine*)GetWindowLongPtr(hwnd, GWLP_USERDATA);
+						              switch (msg)
+						              {
+							              case WM_SIZE:
+								              w->resize(hwnd);
+								              break;
+							              case WM_CLOSE:
+								              DestroyWindow(hwnd);
+								              break;
+							              case WM_DESTROY:
+								              w->terminate();
+								              break;
+							              case WM_GETMINMAXINFO:
+							              {
+								              auto lpmmi = (LPMINMAXINFO)lp;
+								              if (w == nullptr)
+								              {
+									              return 0;
+								              }
+								              if (w->m_maxsz.x > 0 && w->m_maxsz.y > 0)
+								              {
+									              lpmmi->ptMaxSize = w->m_maxsz;
+									              lpmmi->ptMaxTrackSize = w->m_maxsz;
+								              }
+								              if (w->m_minsz.x > 0 && w->m_minsz.y > 0)
+								              {
+									              lpmmi->ptMinTrackSize = w->m_minsz;
+								              }
+							              }
+							              break;
+							              default:
+								              return DefWindowProcW(hwnd, msg, wp, lp);
+						              }
+						              return 0;
+					              });
+					RegisterClassExW(&wc);
+					m_window = CreateWindowW(L"webview", L"", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT,
+					                         CW_USEDEFAULT, 640, 480, nullptr, nullptr, hInstance,
+					                         nullptr);
+					if (m_window == nullptr)
+					{
+						return;
+					}
+					SetWindowLongPtr(m_window, GWLP_USERDATA, (LONG_PTR)this);
+				}
+				else
+				{
+					m_window = *(static_cast<HWND*>(window));
+				}
+
+				ShowWindow(m_window, SW_SHOW);
+				UpdateWindow(m_window);
+				SetFocus(m_window);
+
+				auto cb = std::bind(&win32_edge_engine::on_message, this, std::placeholders::_1);
+
+				embed(m_window, debug, cb);
+				resize(m_window);
+				m_controller->MoveFocus(COREWEBVIEW2_MOVE_FOCUS_REASON_PROGRAMMATIC);
+			}
+
+			virtual ~win32_edge_engine()
+			{
+				if (m_com_handler)
+				{
+					m_com_handler->Release();
+					m_com_handler = nullptr;
+				}
+				if (m_webview)
+				{
+					m_webview->Release();
+					m_webview = nullptr;
+				}
+				if (m_controller)
+				{
+					m_controller->Release();
+					m_controller = nullptr;
+				}
+			}
+
+			win32_edge_engine(const win32_edge_engine& other) = delete;
+			win32_edge_engine& operator=(const win32_edge_engine& other) = delete;
+			win32_edge_engine(win32_edge_engine&& other) = delete;
+			win32_edge_engine& operator=(win32_edge_engine&& other) = delete;
+
+			void run()
+			{
+				MSG msg;
+				BOOL res;
+				while ((res = GetMessage(&msg, nullptr, 0, 0)) != -1)
+				{
+					if (msg.hwnd)
+					{
+						TranslateMessage(&msg);
+						DispatchMessage(&msg);
+						continue;
+					}
+					if (msg.message == WM_APP)
+					{
+						auto f = (dispatch_fn_t*)(msg.lParam);
+						(*f)();
+						delete f;
+					}
+					else if (msg.message == WM_QUIT)
+					{
+						return;
+					}
+				}
+			}
+			void* window()
+			{
+				return (void*)m_window;
+			}
+			void terminate()
+			{
+				PostQuitMessage(0);
+			}
+			void dispatch(dispatch_fn_t f)
+			{
+				PostThreadMessage(m_main_thread, WM_APP, 0, (LPARAM) new dispatch_fn_t(f));
+			}
+
+			void set_title(const std::string& title)
+			{
+				SetWindowTextW(m_window, widen_string(title).c_str());
+			}
+
+			void set_size(int width, int height, int hints)
+			{
+				auto style = GetWindowLong(m_window, GWL_STYLE);
+				if (hints == WEBVIEW_HINT_FIXED)
+				{
+					style &= ~(WS_THICKFRAME | WS_MAXIMIZEBOX);
+				}
+				else
+				{
+					style |= (WS_THICKFRAME | WS_MAXIMIZEBOX);
+				}
+				SetWindowLong(m_window, GWL_STYLE, style);
+
+				if (hints == WEBVIEW_HINT_MAX)
+				{
+					m_maxsz.x = width;
+					m_maxsz.y = height;
+				}
+				else if (hints == WEBVIEW_HINT_MIN)
+				{
+					m_minsz.x = width;
+					m_minsz.y = height;
+				}
+				else
+				{
+					RECT r;
+					r.left = r.top = 0;
+					r.right = width;
+					r.bottom = height;
+					AdjustWindowRect(&r, WS_OVERLAPPEDWINDOW, 0);
+					SetWindowPos(m_window, nullptr, r.left, r.top, r.right - r.left,
+					             r.bottom - r.top,
+					             SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOMOVE | SWP_FRAMECHANGED);
+					resize(m_window);
+				}
+			}
+
+			void navigate(const std::string& url)
+			{
+				auto wurl = widen_string(url);
+				m_webview->Navigate(wurl.c_str());
+			}
+
+			void init(const std::string& js)
+			{
+				auto wjs = widen_string(js);
+				m_webview->AddScriptToExecuteOnDocumentCreated(wjs.c_str(), nullptr);
+			}
+
+			void eval(const std::string& js)
+			{
+				auto wjs = widen_string(js);
+				m_webview->ExecuteScript(wjs.c_str(), nullptr);
+			}
+
+			void add_navigate_listener(std::function<void(const std::string&, void*)> callback,
+			                           void* arg)
+			{
+				m_com_handler->add_navigate_listener(callback, arg);
+			}
+
+			void add_scheme_handler(const std::string& scheme,
+			                        std::function<void(const std::string&, void*)> callback,
+			                        void* arg)
+			{
+				// TODO: Implement
+			}
+
+			void set_html(const std::string& html)
+			{
+				m_webview->NavigateToString(widen_string(html).c_str());
+			}
+
+		  private:
+			bool embed(HWND wnd, bool debug, msg_cb_t cb)
+			{
+				std::atomic_flag flag = ATOMIC_FLAG_INIT;
+				flag.test_and_set();
+
+				wchar_t currentExePath[MAX_PATH];
+				GetModuleFileNameW(nullptr, currentExePath, MAX_PATH);
+				wchar_t* currentExeName = PathFindFileNameW(currentExePath);
+
+				wchar_t dataPath[MAX_PATH];
+				if (!SUCCEEDED(SHGetFolderPathW(nullptr, CSIDL_APPDATA, nullptr, 0, dataPath)))
+				{
+					return false;
+				}
+				wchar_t userDataFolder[MAX_PATH];
+				PathCombineW(userDataFolder, dataPath, currentExeName);
+
+				m_com_handler = new webview2_com_handler(
+				    wnd, cb,
+				    [&](ICoreWebView2Controller* controller, ICoreWebView2* webview)
+				    {
+					    if (!controller || !webview)
+					    {
+						    flag.clear();
+						    return;
+					    }
+					    controller->AddRef();
+					    webview->AddRef();
+					    m_controller = controller;
+					    m_webview = webview;
+					    flag.clear();
+				    });
+
+				m_com_handler->set_attempt_handler(
+				    [&]
+				    {
+					    return m_webview2_loader.create_environment_with_options(
+					        nullptr, userDataFolder, nullptr, m_com_handler);
+				    });
+				m_com_handler->try_create_environment();
+
+				MSG msg = {};
+				while (flag.test_and_set() && GetMessage(&msg, nullptr, 0, 0))
+				{
+					TranslateMessage(&msg);
+					DispatchMessage(&msg);
+				}
+				if (!m_controller || !m_webview)
+				{
+					return false;
+				}
+				ICoreWebView2Settings* settings = nullptr;
+				auto res = m_webview->get_Settings(&settings);
+				if (res != S_OK)
+				{
+					return false;
+				}
+				res = settings->put_AreDevToolsEnabled(debug ? TRUE : FALSE);
+				if (res != S_OK)
+				{
+					return false;
+				}
+				init("window.external={invoke:s=>window.chrome.webview.postMessage(s)}");
+				return true;
+			}
+
+			void resize(HWND wnd)
+			{
+				if (m_controller == nullptr)
+				{
+					return;
+				}
+				RECT bounds;
+				GetClientRect(wnd, &bounds);
+				m_controller->put_Bounds(bounds);
+			}
+
+			bool is_webview2_available() const noexcept
+			{
+				LPWSTR version_info = nullptr;
+				auto res =
+				    m_webview2_loader.get_available_browser_version_string(nullptr, &version_info);
+				// The result will be equal to HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)
+				// if the WebView2 runtime is not installed.
+				auto ok = SUCCEEDED(res) && version_info;
+				if (version_info)
+				{
+					CoTaskMemFree(version_info);
+				}
+				return ok;
+			}
+
+			virtual void on_message(const std::string& msg) = 0;
+
+			// The app is expected to call CoInitializeEx before
+			// CreateCoreWebView2EnvironmentWithOptions.
+			// Source:
+			// https://docs.microsoft.com/en-us/microsoft-edge/webview2/reference/win32/webview2-idl#createcorewebview2environmentwithoptions
+			com_init_wrapper m_com_init{ COINIT_APARTMENTTHREADED };
+			HWND m_window = nullptr;
+			POINT m_minsz = POINT{ 0, 0 };
+			POINT m_maxsz = POINT{ 0, 0 };
+			DWORD m_main_thread = GetCurrentThreadId();
+			ICoreWebView2* m_webview = nullptr;
+			ICoreWebView2Controller* m_controller = nullptr;
+			webview2_com_handler* m_com_handler = nullptr;
+			mswebview2::loader m_webview2_loader;
+		};
+
+	} // namespace detail
+
+	using browser_engine = detail::win32_edge_engine;
+
+} // namespace webview
+
+#endif /* WEBVIEW_GTK, WEBVIEW_COCOA, WEBVIEW_EDGE */
+
+namespace webview
+{
+
+	class webview : public browser_engine
+	{
+	  public:
+		webview(bool debug = false, void* wnd = nullptr) : browser_engine(debug, wnd)
+		{
+		}
+
+		void navigate(const std::string& url)
+		{
+			if (url.empty())
+			{
+				browser_engine::navigate("about:blank");
+				return;
+			}
+			browser_engine::navigate(url);
+		}
+
+		using binding_t = std::function<void(std::string, std::string, void*)>;
+		class binding_ctx_t
+		{
+		  public:
+			binding_ctx_t(binding_t callback, void* arg) : callback(callback), arg(arg)
+			{
+			}
+			// This function is called upon execution of the bound JS function
+			binding_t callback;
+			// This user-supplied argument is passed to the callback
+			void* arg;
+		};
+
+		using sync_binding_t = std::function<std::string(std::string)>;
+
+		// Synchronous bind
+		void bind(const std::string& name, sync_binding_t fn)
+		{
+			auto wrapper = [this, fn](const std::string& seq, const std::string& req, void* /*arg*/)
+			{ resolve(seq, 0, fn(req)); };
+			bind(name, wrapper, nullptr);
+		}
+
+		// Asynchronous bind
+		void bind(const std::string& name, binding_t fn, void* arg)
+		{
+			if (bindings.count(name) > 0)
+			{
+				return;
+			}
+			bindings.emplace(name, binding_ctx_t(fn, arg));
+			auto js = "(function() { var name = '" + name + "';" + R""(
+      var RPC = window._rpc = (window._rpc || {nextSeq: 1});
+      window[name] = function() {
+        var seq = RPC.nextSeq++;
+        var promise = new Promise(function(resolve, reject) {
+          RPC[seq] = {
+            resolve: resolve,
+            reject: reject,
+          };
+        });
+        window.external.invoke(JSON.stringify({
+          id: seq,
+          method: name,
+          params: Array.prototype.slice.call(arguments),
+        }));
+        return promise;
+      }
+    })())"";
+			init(js);
+			eval(js);
+		}
+
+		void unbind(const std::string& name)
+		{
+			auto found = bindings.find(name);
+			if (found != bindings.end())
+			{
+				auto js = "delete window['" + name + "'];";
+				init(js);
+				eval(js);
+				bindings.erase(found);
+			}
+		}
+
+		void resolve(const std::string& seq, int status, const std::string& result)
+		{
+			dispatch(
+			    [seq, status, result, this]()
+			    {
+				    if (status == 0)
+				    {
+					    eval("window._rpc[" + seq + "].resolve(" + result +
+					         "); delete window._rpc[" + seq + "]");
+				    }
+				    else
+				    {
+					    eval("window._rpc[" + seq + "].reject(" + result +
+					         "); delete window._rpc[" + seq + "]");
+				    }
+			    });
+		}
+
+	  private:
+		void on_message(const std::string& msg) override
+		{
+			auto seq = detail::json_parse(msg, "id", 0);
+			auto name = detail::json_parse(msg, "method", 0);
+			auto args = detail::json_parse(msg, "params", 0);
+			auto found = bindings.find(name);
+			if (found == bindings.end())
+			{
+				return;
+			}
+			const auto& context = found->second;
+			context.callback(seq, args, context.arg);
+		}
+
+		std::map<std::string, binding_ctx_t> bindings;
+	};
+} // namespace webview
+
+WEBVIEW_API webview_t webview_create(int debug, void* wnd)
+{
+	auto w = new webview::webview(debug, wnd);
+	if (!w->window())
+	{
+		delete w;
+		return nullptr;
+	}
+	return w;
+}
+
+WEBVIEW_API void webview_destroy(webview_t w)
+{
+	delete static_cast<webview::webview*>(w);
+}
+
+WEBVIEW_API void webview_run(webview_t w)
+{
+	static_cast<webview::webview*>(w)->run();
+}
+
+WEBVIEW_API void webview_terminate(webview_t w)
+{
+	static_cast<webview::webview*>(w)->terminate();
+}
+
+WEBVIEW_API void webview_dispatch(webview_t w, void (*fn)(webview_t, void*), void* arg)
+{
+	static_cast<webview::webview*>(w)->dispatch([=]() { fn(w, arg); });
+}
+
+WEBVIEW_API void* webview_get_window(webview_t w)
+{
+	return static_cast<webview::webview*>(w)->window();
+}
+
+WEBVIEW_API void webview_set_title(webview_t w, const char* title)
+{
+	static_cast<webview::webview*>(w)->set_title(title);
+}
+
+WEBVIEW_API void webview_set_size(webview_t w, int width, int height, int hints)
+{
+	static_cast<webview::webview*>(w)->set_size(width, height, hints);
+}
+
+WEBVIEW_API void webview_navigate(webview_t w, const char* url)
+{
+	static_cast<webview::webview*>(w)->navigate(url);
+}
+
+WEBVIEW_API void webview_set_html(webview_t w, const char* html)
+{
+	static_cast<webview::webview*>(w)->set_html(html);
+}
+
+WEBVIEW_API void webview_init(webview_t w, const char* js)
+{
+	static_cast<webview::webview*>(w)->init(js);
+}
+
+WEBVIEW_API void webview_eval(webview_t w, const char* js)
+{
+	static_cast<webview::webview*>(w)->eval(js);
+}
+
+WEBVIEW_API void webview_bind(webview_t w, const char* name,
+                              void (*fn)(const char* seq, const char* req, void* arg), void* arg)
+{
+	static_cast<webview::webview*>(w)->bind(
+	    name,
+	    [=](const std::string& seq, const std::string& req, void* arg)
+	    { fn(seq.c_str(), req.c_str(), arg); },
+	    arg);
+}
+
+WEBVIEW_API void webview_unbind(webview_t w, const char* name)
+{
+	static_cast<webview::webview*>(w)->unbind(name);
+}
+
+WEBVIEW_API void webview_return(webview_t w, const char* seq, int status, const char* result)
+{
+	static_cast<webview::webview*>(w)->resolve(seq, status, result);
+}
+
+WEBVIEW_API const webview_version_info_t* webview_version()
+{
+	return &webview::detail::library_version_info;
+}
+
+#endif /* WEBVIEW_HEADER */
+#endif /* __cplusplus */
+#endif /* WEBVIEW_H */