Add files using upload-large-folder tool

local-test-freerdp-delta-01/afc-freerdp/client/Android/BuildFlags.java.in

@@ -0,0 +1,6 @@
+package com.freerdp.freerdpcore.utils;
+
+public class BuildFlags
+{
+	private final static boolean USE_OPENSSL_DEFAULT_NAMES = @USE_OPENSSL_DEFAULT_NAMES@;
+}

local-test-freerdp-delta-01/afc-freerdp/client/Mac/CMakeLists.txt

@@ -0,0 +1,92 @@
+cmake_minimum_required(VERSION 3.13)
+
+if(NOT FREERDP_DEFAULT_PROJECT_VERSION)
+  set(FREERDP_DEFAULT_PROJECT_VERSION "1.0.0.0")
+endif()
+
+project(MacFreeRDP-library VERSION ${FREERDP_DEFAULT_PROJECT_VERSION})
+
+message("project ${PROJECT_NAME} is using version ${PROJECT_VERSION}")
+
+cmake_policy(SET CMP0026 OLD)
+cmake_policy(SET CMP0045 OLD)
+
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../cmake/)
+include(CommonConfigOptions)
+
+find_library(FOUNDATION_LIBRARY Foundation REQUIRED)
+find_library(COCOA_LIBRARY Cocoa REQUIRED)
+find_library(APPKIT_LIBRARY AppKit REQUIRED)
+find_library(IOKIT_LIBRARY IOKit REQUIRED)
+find_library(COREGRAPHICS_LIBRARY CoreGraphics REQUIRED)
+
+set(EXTRA_LIBS ${COCOA_LIBRARY} ${FOUNDATION_LIBRARY} ${APPKIT_LIBRARY} ${IOKIT_LIBRARY})
+
+set(XIBS CertificateDialog.xib PasswordDialog.xib)
+
+set(SOURCES "")
+
+set(OBJECTIVE_SOURCES
+    main.m
+    mf_client.m
+    MRDPCursor.m
+    MRDPView.m
+    Keyboard.m
+    Clipboard.m
+    CertificateDialog.m
+    PasswordDialog.m
+)
+
+list(APPEND SOURCES ${OBJECTIVE_SOURCES})
+
+set(HEADERS
+    mfreerdp.h
+    mf_client.h
+    MRDPCursor.h
+    MRDPView.h
+    Keyboard.h
+    Clipboard.h
+    CertificateDialog.h
+    PasswordDialog.h
+)
+
+set(RESOURCES "en.lproj/InfoPlist.strings")
+
+# Include XIB file in Xcode resources.
+if("${CMAKE_GENERATOR}" MATCHES "Xcode")
+  message(STATUS "Adding Xcode XIB resources for ${MODULE_NAME}")
+  list(APPEND RESOURCES ${XIBS})
+  set(IS_XCODE ON)
+endif()
+
+add_library(${PROJECT_NAME} ../common/client.c ${SOURCES} ${HEADERS} ${RESOURCES})
+
+set(LIBS ${EXTRA_LIBS} freerdp-client)
+
+target_link_libraries(${PROJECT_NAME} PUBLIC ${LIBS})
+
+set_target_properties(${PROJECT_NAME} PROPERTIES RESOURCE "${RESOURCES}")
+
+if(NOT IS_XCODE)
+  find_program(IBTOOL ibtool REQUIRED HINTS "/usr/bin" "${OSX_DEVELOPER_ROOT}/usr/bin")
+
+  # Compile the .xib files using the 'ibtool' program with the destination being the app package
+  foreach(xib ${XIBS})
+    get_filename_component(XIB_WE ${xib} NAME_WE)
+    set(NIB ${CMAKE_CURRENT_BINARY_DIR}/${XIB_WE}.nib)
+    list(APPEND NIBS ${NIB})
+
+    add_custom_command(
+      TARGET ${PROJECT_NAME} POST_BUILD COMMAND ${IBTOOL} --errors --warnings --notices --output-format
+                                                human-readable-text --compile ${NIB} ${CMAKE_CURRENT_SOURCE_DIR}/${xib}
+      COMMENT "Compiling ${xib}"
+    )
+  endforeach()
+
+  install(FILES ${NIBS} DESTINATION ${CMAKE_INSTALL_DATADIR})
+endif()
+
+install(TARGETS ${PROJECT_NAME} COMPONENT client RESOURCE DESTINATION ${CMAKE_INSTALL_DATADIR})
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+add_subdirectory(cli)

local-test-freerdp-delta-01/afc-freerdp/client/Mac/CertificateDialog.h

@@ -0,0 +1,60 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * MacFreeRDP
+ *
+ * Copyright 2018 Armin Novak <[email protected]>
+ * Copyright 2018 Thicast 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.
+ */
+
+#import <Cocoa/Cocoa.h>
+
+@interface CertificateDialog : NSWindowController
+{
+  @public
+	NSTextField *textCommonName;
+	NSTextField *textSubject;
+	NSTextField *textIssuer;
+	NSTextField *textFingerprint;
+	NSTextField *textMismatch;
+	NSTextField *messageLabel;
+	NSString *serverHostname;
+
+	BOOL hostMismatch;
+	BOOL changed;
+	int result;
+}
+@property(retain) IBOutlet NSTextField *textCommonName;
+@property(retain) IBOutlet NSTextField *textSubject;
+@property(retain) IBOutlet NSTextField *textIssuer;
+@property(retain) IBOutlet NSTextField *textFingerprint;
+@property(retain) IBOutlet NSTextField *textMismatch;
+@property(retain) IBOutlet NSTextField *messageLabel;
+
+- (IBAction)onAccept:(NSObject *)sender;
+- (IBAction)onTemporary:(NSObject *)sender;
+- (IBAction)onCancel:(NSObject *)sender;
+
+@property(retain) NSString *serverHostname;
+@property(retain) NSString *commonName;
+@property(retain) NSString *subject;
+@property(retain) NSString *issuer;
+@property(retain) NSString *fingerprint;
+@property BOOL hostMismatch;
+@property BOOL changed;
+@property(readonly) int result;
+
+- (int)runModal:(NSWindow *)mainWindow;
+
+@end

local-test-freerdp-delta-01/afc-freerdp/client/Mac/CertificateDialog.m

@@ -0,0 +1,135 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * MacFreeRDP
+ *
+ * Copyright 2018 Armin Novak <[email protected]>
+ * Copyright 2018 Thicast 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.
+ */
+
+#import "CertificateDialog.h"
+#import <freerdp/client/cmdline.h>
+
+#import <CoreGraphics/CoreGraphics.h>
+
+@interface CertificateDialog ()
+
+@property int result;
+
+@end
+
+@implementation CertificateDialog
+
+@synthesize textCommonName;
+@synthesize textFingerprint;
+@synthesize textIssuer;
+@synthesize textSubject;
+@synthesize textMismatch;
+@synthesize messageLabel;
+@synthesize serverHostname;
+@synthesize commonName;
+@synthesize fingerprint;
+@synthesize issuer;
+@synthesize subject;
+@synthesize hostMismatch;
+@synthesize changed;
+@synthesize result;
+
+- (id)init
+{
+	return [self initWithWindowNibName:@"CertificateDialog"];
+}
+
+- (void)windowDidLoad
+{
+	[super windowDidLoad];
+	// Implement this method to handle any initialization after your window controller's window has
+	// been loaded from its nib file.
+	[self.window setTitle:self.serverHostname];
+	if (self.changed)
+		[self.messageLabel setStringValue:[NSString stringWithFormat:@"Changed certificate for %@",
+		                                                             self.serverHostname]];
+	else
+		[self.messageLabel setStringValue:[NSString stringWithFormat:@"New Certificate for %@",
+		                                                             self.serverHostname]];
+
+	if (!self.hostMismatch)
+		[self.textMismatch
+		    setStringValue:[NSString stringWithFormat:
+		                                 @"NOTE: The server name matches the certificate, good."]];
+	else
+		[self.textMismatch
+		    setStringValue:[NSString
+		                       stringWithFormat:
+		                           @"ATTENTION: The common name does not match the server name!"]];
+	[self.textCommonName setStringValue:self.commonName];
+	[self.textFingerprint setStringValue:self.fingerprint];
+	[self.textIssuer setStringValue:self.issuer];
+	[self.textSubject setStringValue:self.subject];
+}
+
+- (IBAction)onAccept:(NSObject *)sender
+{
+	[NSApp stopModalWithCode:1];
+}
+
+- (IBAction)onTemporary:(NSObject *)sender
+{
+	[NSApp stopModalWithCode:2];
+}
+
+- (IBAction)onCancel:(NSObject *)sender
+{
+	[NSApp stopModalWithCode:0];
+}
+
+- (int)runModal:(NSWindow *)mainWindow
+{
+	if ([mainWindow respondsToSelector:@selector(beginSheet:completionHandler:)])
+	{
+		[mainWindow beginSheet:self.window completionHandler:nil];
+		self.result = [NSApp runModalForWindow:self.window];
+		[mainWindow endSheet:self.window];
+	}
+	else
+	{
+		[NSApp beginSheet:self.window
+		    modalForWindow:mainWindow
+		     modalDelegate:nil
+		    didEndSelector:nil
+		       contextInfo:nil];
+		self.result = [NSApp runModalForWindow:self.window];
+		[NSApp endSheet:self.window];
+	}
+
+	[self.window orderOut:nil];
+	return self.result;
+}
+
+- (void)dealloc
+{
+	[textCommonName release];
+	[textFingerprint release];
+	[textIssuer release];
+	[textSubject release];
+	[messageLabel release];
+	[serverHostname release];
+	[commonName release];
+	[fingerprint release];
+	[issuer release];
+	[subject release];
+	[super dealloc];
+}
+
+@end

local-test-freerdp-delta-01/afc-freerdp/client/Mac/CertificateDialog.xib

@@ -0,0 +1,169 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<document type="com.apple.InterfaceBuilder3.Cocoa.XIB" version="3.0" toolsVersion="14460.31" targetRuntime="MacOSX.Cocoa" propertyAccessControl="none">
+    <dependencies>
+        <plugIn identifier="com.apple.InterfaceBuilder.CocoaPlugin" version="14460.31"/>
+        <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
+    </dependencies>
+    <objects>
+        <customObject id="-2" userLabel="File's Owner" customClass="CertificateDialog">
+            <connections>
+                <outlet property="messageLabel" destination="7" id="50"/>
+                <outlet property="textCommonName" destination="2HW-of-a4n" id="4442"/>
+                <outlet property="textFingerprint" destination="cLB-ZO-jvx" id="4445"/>
+                <outlet property="textIssuer" destination="kHA-F4-dxw" id="4444"/>
+                <outlet property="textMismatch" destination="LgQ-ni-jXv" id="5550"/>
+                <outlet property="textSubject" destination="R9r-82-XAH" id="4443"/>
+                <outlet property="window" destination="1" id="3"/>
+            </connections>
+        </customObject>
+        <customObject id="-1" userLabel="First Responder" customClass="FirstResponder"/>
+        <customObject id="-3" userLabel="Application" customClass="NSObject"/>
+        <window title="Window" allowsToolTipsWhenApplicationIsInactive="NO" autorecalculatesKeyViewLoop="NO" visibleAtLaunch="NO" animationBehavior="default" id="1">
+            <windowStyleMask key="styleMask" titled="YES" texturedBackground="YES"/>
+            <windowPositionMask key="initialPositionMask" leftStrut="YES" rightStrut="YES" topStrut="YES" bottomStrut="YES"/>
+            <rect key="contentRect" x="196" y="240" width="641" height="338"/>
+            <rect key="screenRect" x="0.0" y="0.0" width="2560" height="1417"/>
+            <view key="contentView" id="2">
+                <rect key="frame" x="0.0" y="0.0" width="641" height="338"/>
+                <autoresizingMask key="autoresizingMask"/>
+                <subviews>
+                    <textField verticalHuggingPriority="750" id="7">
+                        <rect key="frame" x="47" y="274" width="344" height="17"/>
+                        <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
+                        <textFieldCell key="cell" scrollable="YES" sendsActionOnEndEditing="YES" title="Certificate for SERVER_NAME" placeholderString="" id="20">
+                            <font key="font" metaFont="system"/>
+                            <color key="textColor" name="controlTextColor" catalog="System" colorSpace="catalog"/>
+                            <color key="backgroundColor" name="controlColor" catalog="System" colorSpace="catalog"/>
+                        </textFieldCell>
+                    </textField>
+                    <button verticalHuggingPriority="750" id="8">
+                        <rect key="frame" x="545" y="13" width="82" height="32"/>
+                        <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
+                        <buttonCell key="cell" type="push" title="Cancel" bezelStyle="rounded" alignment="center" borderStyle="border" imageScaling="proportionallyDown" inset="2" id="18">
+                            <behavior key="behavior" pushIn="YES" lightByBackground="YES" lightByGray="YES"/>
+                            <font key="font" metaFont="system"/>
+                            <string key="keyEquivalent" base64-UTF8="YES">
+Gw
+</string>
+                        </buttonCell>
+                        <connections>
+                            <action selector="onCancel:" target="-2" id="52"/>
+                        </connections>
+                    </button>
+                    <button verticalHuggingPriority="750" id="9">
+                        <rect key="frame" x="463" y="13" width="82" height="32"/>
+                        <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
+                        <buttonCell key="cell" type="push" title="OK" bezelStyle="rounded" alignment="center" borderStyle="border" imageScaling="proportionallyDown" inset="2" id="17">
+                            <behavior key="behavior" pushIn="YES" lightByBackground="YES" lightByGray="YES"/>
+                            <font key="font" metaFont="system"/>
+                            <string key="keyEquivalent" base64-UTF8="YES">
+DQ
+</string>
+                        </buttonCell>
+                        <connections>
+                            <accessibilityConnection property="link" destination="8" id="cks-Lf-tCO"/>
+                            <action selector="onAccept:" target="-2" id="522"/>
+                        </connections>
+                    </button>
+                    <button verticalHuggingPriority="750" id="7I5-a2-h65">
+                        <rect key="frame" x="358" y="13" width="105" height="32"/>
+                        <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
+                        <buttonCell key="cell" type="push" title="Temporary" bezelStyle="rounded" alignment="center" borderStyle="border" imageScaling="proportionallyDown" inset="2" id="i6y-0u-COa">
+                            <behavior key="behavior" pushIn="YES" lightByBackground="YES" lightByGray="YES"/>
+                            <font key="font" metaFont="system"/>
+                        </buttonCell>
+                        <connections>
+                            <accessibilityConnection property="link" destination="9" id="5nn-SX-Rqq"/>
+                            <action selector="onTemporary:" target="-2" id="BWk-o1-tug"/>
+                        </connections>
+                    </button>
+                    <textField verticalHuggingPriority="750" id="LgQ-ni-jXv">
+                        <rect key="frame" x="47" y="236" width="582" height="36"/>
+                        <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
+                        <textFieldCell key="cell" scrollable="YES" lineBreakMode="clipping" sendsActionOnEndEditing="YES" alignment="left" title="ATTENTION: The common name does not match the server name!" id="94f-Om-tJh">
+                            <font key="font" metaFont="system"/>
+                            <color key="textColor" name="controlTextColor" catalog="System" colorSpace="catalog"/>
+                            <color key="backgroundColor" name="controlColor" catalog="System" colorSpace="catalog"/>
+                        </textFieldCell>
+                    </textField>
+                    <textField verticalHuggingPriority="750" id="5">
+                        <rect key="frame" x="47" y="186" width="89" height="17"/>
+                        <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
+                        <textFieldCell key="cell" scrollable="YES" lineBreakMode="clipping" sendsActionOnEndEditing="YES" alignment="left" title="Subject" id="22">
+                            <font key="font" metaFont="system"/>
+                            <color key="textColor" name="controlTextColor" catalog="System" colorSpace="catalog"/>
+                            <color key="backgroundColor" name="controlColor" catalog="System" colorSpace="catalog"/>
+                        </textFieldCell>
+                    </textField>
+                    <textField verticalHuggingPriority="750" id="vA4-qf-QuW">
+                        <rect key="frame" x="47" y="161" width="89" height="17"/>
+                        <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
+                        <textFieldCell key="cell" scrollable="YES" lineBreakMode="clipping" sendsActionOnEndEditing="YES" alignment="left" title="Issuer" id="tAl-Qh-OR9">
+                            <font key="font" metaFont="system"/>
+                            <color key="textColor" name="controlTextColor" catalog="System" colorSpace="catalog"/>
+                            <color key="backgroundColor" name="controlColor" catalog="System" colorSpace="catalog"/>
+                        </textFieldCell>
+                    </textField>
+                    <textField verticalHuggingPriority="750" id="10">
+                        <rect key="frame" x="47" y="211" width="89" height="17"/>
+                        <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
+                        <textFieldCell key="cell" scrollable="YES" lineBreakMode="clipping" sendsActionOnEndEditing="YES" alignment="left" title="Common" id="15">
+                            <font key="font" metaFont="system"/>
+                            <color key="textColor" name="controlTextColor" catalog="System" colorSpace="catalog"/>
+                            <color key="backgroundColor" name="controlColor" catalog="System" colorSpace="catalog"/>
+                        </textFieldCell>
+                    </textField>
+                    <textField verticalHuggingPriority="750" id="2HW-of-a4n">
+                        <rect key="frame" x="140" y="211" width="305" height="17"/>
+                        <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
+                        <textFieldCell key="cell" scrollable="YES" lineBreakMode="clipping" sendsActionOnEndEditing="YES" alignment="left" title="COMMON NAME" id="N48-2i-W6H">
+                            <font key="font" metaFont="system"/>
+                            <color key="textColor" name="controlTextColor" catalog="System" colorSpace="catalog"/>
+                            <color key="backgroundColor" name="controlColor" catalog="System" colorSpace="catalog"/>
+                        </textFieldCell>
+                    </textField>
+                    <textField verticalHuggingPriority="750" id="R9r-82-XAH">
+                        <rect key="frame" x="140" y="186" width="305" height="17"/>
+                        <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
+                        <textFieldCell key="cell" scrollable="YES" lineBreakMode="clipping" sendsActionOnEndEditing="YES" alignment="left" title="SUBJECT" id="iGw-oh-i3p">
+                            <font key="font" metaFont="system"/>
+                            <color key="textColor" name="controlTextColor" catalog="System" colorSpace="catalog"/>
+                            <color key="backgroundColor" name="controlColor" catalog="System" colorSpace="catalog"/>
+                        </textFieldCell>
+                    </textField>
+                    <textField verticalHuggingPriority="750" id="kHA-F4-dxw">
+                        <rect key="frame" x="140" y="161" width="305" height="17"/>
+                        <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
+                        <textFieldCell key="cell" scrollable="YES" lineBreakMode="clipping" sendsActionOnEndEditing="YES" alignment="left" title="ISSUER" id="daP-a0-hI1">
+                            <font key="font" metaFont="system"/>
+                            <color key="textColor" name="controlTextColor" catalog="System" colorSpace="catalog"/>
+                            <color key="backgroundColor" name="controlColor" catalog="System" colorSpace="catalog"/>
+                        </textFieldCell>
+                    </textField>
+                    <textField verticalHuggingPriority="750" id="cLB-ZO-jvx">
+                        <rect key="frame" x="140" y="117" width="483" height="36"/>
+                        <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
+                        <textFieldCell key="cell" scrollable="YES" lineBreakMode="clipping" sendsActionOnEndEditing="YES" alignment="left" title="FINGERPRINT" id="VqU-vO-noG">
+                            <font key="font" metaFont="system"/>
+                            <color key="textColor" name="controlTextColor" catalog="System" colorSpace="catalog"/>
+                            <color key="backgroundColor" name="controlColor" catalog="System" colorSpace="catalog"/>
+                        </textFieldCell>
+                    </textField>
+                    <textField verticalHuggingPriority="750" id="VLG-f9-Gcl">
+                        <rect key="frame" x="47" y="136" width="89" height="17"/>
+                        <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMinY="YES"/>
+                        <textFieldCell key="cell" scrollable="YES" lineBreakMode="clipping" sendsActionOnEndEditing="YES" alignment="left" title="Fingerprint" id="49l-Xk-MUH">
+                            <font key="font" metaFont="system"/>
+                            <color key="textColor" name="controlTextColor" catalog="System" colorSpace="catalog"/>
+                            <color key="backgroundColor" name="controlColor" catalog="System" colorSpace="catalog"/>
+                        </textFieldCell>
+                    </textField>
+                </subviews>
+            </view>
+            <connections>
+                <outlet property="delegate" destination="-2" id="4"/>
+            </connections>
+            <point key="canvasLocation" x="228.5" y="102"/>
+        </window>
+    </objects>
+</document>

local-test-freerdp-delta-01/afc-freerdp/client/Mac/Clipboard.h

@@ -0,0 +1,31 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ *
+ * Copyright 2014 Marc-Andre Moreau <[email protected]>
+ * Copyright 2015 Thincast Technologies GmbH
+ * Copyright 2015 DI (FH) Martin Haimberger <[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.
+ */
+
+#import "mfreerdp.h"
+#import "mf_client.h"
+
+#import "freerdp/freerdp.h"
+#import "freerdp/channels/channels.h"
+#import "freerdp/client/cliprdr.h"
+
+int mac_cliprdr_send_client_format_list(CliprdrClientContext* cliprdr);
+
+void mac_cliprdr_init(mfContext* mfc, CliprdrClientContext* cliprdr);
+void mac_cliprdr_uninit(mfContext* mfc, CliprdrClientContext* cliprdr);

local-test-freerdp-delta-01/afc-freerdp/client/Mac/Clipboard.m

@@ -0,0 +1,432 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ *
+ * Copyright 2014 Marc-Andre Moreau <[email protected]>
+ * Copyright 2015 Thincast Technologies GmbH
+ * Copyright 2015 DI (FH) Martin Haimberger <[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.
+ */
+
+#import "Clipboard.h"
+#import "MRDPView.h"
+
+int mac_cliprdr_send_client_format_list(CliprdrClientContext *cliprdr)
+{
+	UINT32 formatId;
+	UINT32 numFormats;
+	UINT32 *pFormatIds;
+	const char *formatName;
+	CLIPRDR_FORMAT *formats;
+	CLIPRDR_FORMAT_LIST formatList = { 0 };
+
+	WINPR_ASSERT(cliprdr);
+	mfContext *mfc = (mfContext *)cliprdr->custom;
+	WINPR_ASSERT(mfc);
+
+	pFormatIds = NULL;
+	numFormats = ClipboardGetFormatIds(mfc->clipboard, &pFormatIds);
+
+	formats = (CLIPRDR_FORMAT *)calloc(numFormats, sizeof(CLIPRDR_FORMAT));
+
+	if (!formats)
+		return -1;
+
+	for (UINT32 index = 0; index < numFormats; index++)
+	{
+		formatId = pFormatIds[index];
+		formatName = ClipboardGetFormatName(mfc->clipboard, formatId);
+
+		formats[index].formatId = formatId;
+		formats[index].formatName = NULL;
+
+		if ((formatId > CF_MAX) && formatName)
+			formats[index].formatName = _strdup(formatName);
+	}
+
+	formatList.common.msgFlags = 0;
+	formatList.numFormats = numFormats;
+	formatList.formats = formats;
+	formatList.common.msgType = CB_FORMAT_LIST;
+
+	mfc->cliprdr->ClientFormatList(mfc->cliprdr, &formatList);
+
+	for (UINT32 index = 0; index < numFormats; index++)
+	{
+		free(formats[index].formatName);
+	}
+
+	free(pFormatIds);
+	free(formats);
+
+	return 1;
+}
+
+static int mac_cliprdr_send_client_format_list_response(CliprdrClientContext *cliprdr, BOOL status)
+{
+	CLIPRDR_FORMAT_LIST_RESPONSE formatListResponse;
+
+	formatListResponse.common.msgType = CB_FORMAT_LIST_RESPONSE;
+	formatListResponse.common.msgFlags = status ? CB_RESPONSE_OK : CB_RESPONSE_FAIL;
+	formatListResponse.common.dataLen = 0;
+
+	cliprdr->ClientFormatListResponse(cliprdr, &formatListResponse);
+
+	return 1;
+}
+
+static int mac_cliprdr_send_client_format_data_request(CliprdrClientContext *cliprdr,
+                                                       UINT32 formatId)
+{
+	CLIPRDR_FORMAT_DATA_REQUEST formatDataRequest = { 0 };
+	WINPR_ASSERT(cliprdr);
+
+	mfContext *mfc = (mfContext *)cliprdr->custom;
+	WINPR_ASSERT(mfc);
+
+	formatDataRequest.common.msgType = CB_FORMAT_DATA_REQUEST;
+	formatDataRequest.common.msgFlags = 0;
+
+	formatDataRequest.requestedFormatId = formatId;
+	mfc->requestedFormatId = formatId;
+	(void)ResetEvent(mfc->clipboardRequestEvent);
+
+	cliprdr->ClientFormatDataRequest(cliprdr, &formatDataRequest);
+
+	return 1;
+}
+
+static int mac_cliprdr_send_client_capabilities(CliprdrClientContext *cliprdr)
+{
+	CLIPRDR_CAPABILITIES capabilities;
+	CLIPRDR_GENERAL_CAPABILITY_SET generalCapabilitySet;
+
+	capabilities.cCapabilitiesSets = 1;
+	capabilities.capabilitySets = (CLIPRDR_CAPABILITY_SET *)&(generalCapabilitySet);
+
+	generalCapabilitySet.capabilitySetType = CB_CAPSTYPE_GENERAL;
+	generalCapabilitySet.capabilitySetLength = 12;
+
+	generalCapabilitySet.version = CB_CAPS_VERSION_2;
+	generalCapabilitySet.generalFlags = CB_USE_LONG_FORMAT_NAMES;
+
+	cliprdr->ClientCapabilities(cliprdr, &capabilities);
+
+	return 1;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT mac_cliprdr_monitor_ready(CliprdrClientContext *cliprdr,
+                                      const CLIPRDR_MONITOR_READY *monitorReady)
+{
+	mfContext *mfc = (mfContext *)cliprdr->custom;
+
+	mfc->clipboardSync = TRUE;
+	mac_cliprdr_send_client_capabilities(cliprdr);
+	mac_cliprdr_send_client_format_list(cliprdr);
+
+	return CHANNEL_RC_OK;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT mac_cliprdr_server_capabilities(CliprdrClientContext *cliprdr,
+                                            const CLIPRDR_CAPABILITIES *capabilities)
+{
+	CLIPRDR_CAPABILITY_SET *capabilitySet;
+	mfContext *mfc = (mfContext *)cliprdr->custom;
+
+	for (UINT32 index = 0; index < capabilities->cCapabilitiesSets; index++)
+	{
+		capabilitySet = &(capabilities->capabilitySets[index]);
+
+		if ((capabilitySet->capabilitySetType == CB_CAPSTYPE_GENERAL) &&
+		    (capabilitySet->capabilitySetLength >= CB_CAPSTYPE_GENERAL_LEN))
+		{
+			CLIPRDR_GENERAL_CAPABILITY_SET *generalCapabilitySet =
+			    (CLIPRDR_GENERAL_CAPABILITY_SET *)capabilitySet;
+
+			mfc->clipboardCapabilities = generalCapabilitySet->generalFlags;
+			break;
+		}
+	}
+
+	return CHANNEL_RC_OK;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT mac_cliprdr_server_format_list(CliprdrClientContext *cliprdr,
+                                           const CLIPRDR_FORMAT_LIST *formatList)
+{
+	CLIPRDR_FORMAT *format;
+	mfContext *mfc = (mfContext *)cliprdr->custom;
+
+	if (mfc->serverFormats)
+	{
+		for (UINT32 index = 0; index < mfc->numServerFormats; index++)
+		{
+			free(mfc->serverFormats[index].formatName);
+		}
+
+		free(mfc->serverFormats);
+		mfc->serverFormats = NULL;
+		mfc->numServerFormats = 0;
+	}
+
+	if (formatList->numFormats < 1)
+		return CHANNEL_RC_OK;
+
+	mfc->numServerFormats = formatList->numFormats;
+	mfc->serverFormats = (CLIPRDR_FORMAT *)calloc(mfc->numServerFormats, sizeof(CLIPRDR_FORMAT));
+
+	if (!mfc->serverFormats)
+		return CHANNEL_RC_NO_MEMORY;
+
+	for (UINT32 index = 0; index < mfc->numServerFormats; index++)
+	{
+		mfc->serverFormats[index].formatId = formatList->formats[index].formatId;
+		mfc->serverFormats[index].formatName = NULL;
+
+		if (formatList->formats[index].formatName)
+			mfc->serverFormats[index].formatName = _strdup(formatList->formats[index].formatName);
+	}
+
+	mac_cliprdr_send_client_format_list_response(cliprdr, TRUE);
+
+	for (UINT32 index = 0; index < mfc->numServerFormats; index++)
+	{
+		format = &(mfc->serverFormats[index]);
+
+		if (format->formatId == CF_UNICODETEXT)
+		{
+			mac_cliprdr_send_client_format_data_request(cliprdr, CF_UNICODETEXT);
+			break;
+		}
+		else if (format->formatId == CF_OEMTEXT)
+		{
+			mac_cliprdr_send_client_format_data_request(cliprdr, CF_OEMTEXT);
+			break;
+		}
+		else if (format->formatId == CF_TEXT)
+		{
+			mac_cliprdr_send_client_format_data_request(cliprdr, CF_TEXT);
+			break;
+		}
+	}
+
+	return CHANNEL_RC_OK;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT
+mac_cliprdr_server_format_list_response(CliprdrClientContext *cliprdr,
+                                        const CLIPRDR_FORMAT_LIST_RESPONSE *formatListResponse)
+{
+	return CHANNEL_RC_OK;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT
+mac_cliprdr_server_lock_clipboard_data(CliprdrClientContext *cliprdr,
+                                       const CLIPRDR_LOCK_CLIPBOARD_DATA *lockClipboardData)
+{
+	return CHANNEL_RC_OK;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT
+mac_cliprdr_server_unlock_clipboard_data(CliprdrClientContext *cliprdr,
+                                         const CLIPRDR_UNLOCK_CLIPBOARD_DATA *unlockClipboardData)
+{
+	return CHANNEL_RC_OK;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT
+mac_cliprdr_server_format_data_request(CliprdrClientContext *cliprdr,
+                                       const CLIPRDR_FORMAT_DATA_REQUEST *formatDataRequest)
+{
+	BYTE *data;
+	UINT32 size;
+	UINT32 formatId;
+	CLIPRDR_FORMAT_DATA_RESPONSE response = { 0 };
+
+	WINPR_ASSERT(cliprdr);
+
+	mfContext *mfc = (mfContext *)cliprdr->custom;
+	WINPR_ASSERT(mfc);
+
+	formatId = formatDataRequest->requestedFormatId;
+	data = (BYTE *)ClipboardGetData(mfc->clipboard, formatId, &size);
+
+	response.common.msgFlags = CB_RESPONSE_OK;
+	response.common.dataLen = size;
+	response.requestedFormatData = data;
+
+	if (!data)
+	{
+		response.common.msgFlags = CB_RESPONSE_FAIL;
+		response.common.dataLen = 0;
+		response.requestedFormatData = NULL;
+	}
+
+	cliprdr->ClientFormatDataResponse(cliprdr, &response);
+
+	free(data);
+
+	return CHANNEL_RC_OK;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT
+mac_cliprdr_server_format_data_response(CliprdrClientContext *cliprdr,
+                                        const CLIPRDR_FORMAT_DATA_RESPONSE *formatDataResponse)
+{
+	UINT32 formatId;
+	CLIPRDR_FORMAT *format = NULL;
+	mfContext *mfc = (mfContext *)cliprdr->custom;
+	MRDPView *view = (MRDPView *)mfc->view;
+
+	if (formatDataResponse->common.msgFlags & CB_RESPONSE_FAIL)
+	{
+		(void)SetEvent(mfc->clipboardRequestEvent);
+		return ERROR_INTERNAL_ERROR;
+	}
+
+	for (UINT32 index = 0; index < mfc->numServerFormats; index++)
+	{
+		if (mfc->requestedFormatId == mfc->serverFormats[index].formatId)
+			format = &(mfc->serverFormats[index]);
+	}
+
+	if (!format)
+	{
+		(void)SetEvent(mfc->clipboardRequestEvent);
+		return ERROR_INTERNAL_ERROR;
+	}
+
+	if (format->formatName)
+		formatId = ClipboardRegisterFormat(mfc->clipboard, format->formatName);
+	else
+		formatId = format->formatId;
+
+	const size_t size = formatDataResponse->common.dataLen;
+
+	ClipboardSetData(mfc->clipboard, formatId, formatDataResponse->requestedFormatData, size);
+
+	(void)SetEvent(mfc->clipboardRequestEvent);
+
+	if ((formatId == CF_TEXT) || (formatId == CF_OEMTEXT) || (formatId == CF_UNICODETEXT))
+	{
+		formatId = ClipboardRegisterFormat(mfc->clipboard, "text/plain");
+
+		UINT32 dstSize = 0;
+		char *data = ClipboardGetData(mfc->clipboard, formatId, &dstSize);
+
+		dstSize = strnlen(data, dstSize); /* we need the size without the null terminator */
+
+		NSString *str = [[NSString alloc] initWithBytes:(void *)data
+		                                         length:dstSize
+		                                       encoding:NSUTF8StringEncoding];
+		free(data);
+
+		NSArray *types = [[NSArray alloc] initWithObjects:NSPasteboardTypeString, nil];
+		[view->pasteboard_wr declareTypes:types owner:view];
+		[view->pasteboard_wr setString:str forType:NSPasteboardTypeString];
+	}
+
+	return CHANNEL_RC_OK;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT
+mac_cliprdr_server_file_contents_request(CliprdrClientContext *cliprdr,
+                                         const CLIPRDR_FILE_CONTENTS_REQUEST *fileContentsRequest)
+{
+	return CHANNEL_RC_OK;
+}
+
+/**
+ * Function description
+ *
+ * @return 0 on success, otherwise a Win32 error code
+ */
+static UINT mac_cliprdr_server_file_contents_response(
+    CliprdrClientContext *cliprdr, const CLIPRDR_FILE_CONTENTS_RESPONSE *fileContentsResponse)
+{
+	return CHANNEL_RC_OK;
+}
+
+void mac_cliprdr_init(mfContext *mfc, CliprdrClientContext *cliprdr)
+{
+	cliprdr->custom = (void *)mfc;
+	mfc->cliprdr = cliprdr;
+
+	mfc->clipboard = ClipboardCreate();
+	mfc->clipboardRequestEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+
+	cliprdr->MonitorReady = mac_cliprdr_monitor_ready;
+	cliprdr->ServerCapabilities = mac_cliprdr_server_capabilities;
+	cliprdr->ServerFormatList = mac_cliprdr_server_format_list;
+	cliprdr->ServerFormatListResponse = mac_cliprdr_server_format_list_response;
+	cliprdr->ServerLockClipboardData = mac_cliprdr_server_lock_clipboard_data;
+	cliprdr->ServerUnlockClipboardData = mac_cliprdr_server_unlock_clipboard_data;
+	cliprdr->ServerFormatDataRequest = mac_cliprdr_server_format_data_request;
+	cliprdr->ServerFormatDataResponse = mac_cliprdr_server_format_data_response;
+	cliprdr->ServerFileContentsRequest = mac_cliprdr_server_file_contents_request;
+	cliprdr->ServerFileContentsResponse = mac_cliprdr_server_file_contents_response;
+}
+
+void mac_cliprdr_uninit(mfContext *mfc, CliprdrClientContext *cliprdr)
+{
+	cliprdr->custom = NULL;
+	mfc->cliprdr = NULL;
+
+	ClipboardDestroy(mfc->clipboard);
+	(void)CloseHandle(mfc->clipboardRequestEvent);
+}

local-test-freerdp-delta-01/afc-freerdp/client/Mac/Credits.rtf

@@ -0,0 +1,21 @@
+{\rtf1\ansi\ansicpg1252\cocoartf1138\cocoasubrtf320
+{\fonttbl\f0\fswiss\fcharset0 Helvetica;}
+{\colortbl;\red255\green255\blue255;}
+\vieww9600\viewh8400\viewkind0
+\pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720
+
+\f0\b\fs24 \cf0 Engineering:
+\b0 \
+	Jay sorg\
+         Marc-Andre Moreau\
+         Vic Lee\
+         Otvaio Salvador \
+         Laxmikant Rashinkar\
+         and others\
+\
+
+\b Human Interface Design:
+\b0 \
+	Laxmikant Rashinkar\
+         Jay Sorg\
+}

local-test-freerdp-delta-01/afc-freerdp/client/Mac/Info.plist

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>NSCameraUsageDescription</key>
+	<string>This application requires camera access to redirect it to the remote host</string>
+	<key>NSMicrophoneUsageDescription</key>
+	<string>This application requires microphone access to redirect it to the remote host</string>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>English</string>
+	<key>CFBundleIconFile</key>
+	<string></string>
+	<key>CFBundleIdentifier</key>
+	<string>FreeRDP.Mac</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string></string>
+	<key>CFBundlePackageType</key>
+	<string>FMWK</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>1</string>
+	<key>NSPrincipalClass</key>
+	<string></string>
+</dict>
+</plist>

local-test-freerdp-delta-01/afc-freerdp/client/Mac/Keyboard.h

@@ -0,0 +1,27 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * MacFreeRDP
+ *
+ * Copyright 2014 Marc-Andre Moreau <[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.
+ */
+
+enum APPLE_KEYBOARD_TYPE
+{
+	APPLE_KEYBOARD_TYPE_ANSI,
+	APPLE_KEYBOARD_TYPE_ISO,
+	APPLE_KEYBOARD_TYPE_JIS
+};
+
+enum APPLE_KEYBOARD_TYPE mac_detect_keyboard_type(void);

local-test-freerdp-delta-01/afc-freerdp/client/Mac/Keyboard.m

@@ -0,0 +1,240 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * MacFreeRDP
+ *
+ * Copyright 2014 Marc-Andre Moreau <[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.
+ */
+
+#import "Keyboard.h"
+
+#include <CoreFoundation/CoreFoundation.h>
+
+#include <IOKit/IOKitLib.h>
+#include <IOKit/hid/IOHIDManager.h>
+
+typedef struct
+{
+	uint32_t ProductId;
+	enum APPLE_KEYBOARD_TYPE Type;
+} APPLE_KEYBOARD_DESC;
+
+/* VendorID: 0x05AC (Apple, Inc.) */
+
+static const APPLE_KEYBOARD_DESC APPLE_KEYBOARDS[] = {
+	{ 0x200, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x201, APPLE_KEYBOARD_TYPE_ANSI }, /* USB Keyboard [Alps or Logitech, M2452] */
+	{ 0x202, APPLE_KEYBOARD_TYPE_ANSI }, /* Keyboard [ALPS] */
+	{ 0x203, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x204, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x205, APPLE_KEYBOARD_TYPE_ANSI }, /* Extended Keyboard [Mitsumi] */
+	{ 0x206, APPLE_KEYBOARD_TYPE_ANSI }, /* Extended Keyboard [Mitsumi] */
+	{ 0x207, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x208, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x209, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x20A, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x20B, APPLE_KEYBOARD_TYPE_ANSI }, /* Pro Keyboard [Mitsumi, A1048/US layout] */
+	{ 0x20C, APPLE_KEYBOARD_TYPE_ANSI }, /* Extended Keyboard [Mitsumi] */
+	{ 0x20D, APPLE_KEYBOARD_TYPE_ANSI }, /* Pro Keyboard [Mitsumi, A1048/JIS layout] */
+	{ 0x20E, APPLE_KEYBOARD_TYPE_ANSI }, /* Internal Keyboard/Trackpad (ANSI) */
+	{ 0x20F, APPLE_KEYBOARD_TYPE_ISO },  /* Internal Keyboard/Trackpad (ISO) */
+	{ 0x210, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x211, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x212, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x213, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x214, APPLE_KEYBOARD_TYPE_ANSI }, /* Internal Keyboard/Trackpad (ANSI) */
+	{ 0x215, APPLE_KEYBOARD_TYPE_ISO },  /* Internal Keyboard/Trackpad (ISO) */
+	{ 0x216, APPLE_KEYBOARD_TYPE_JIS },  /* Internal Keyboard/Trackpad (JIS) */
+	{ 0x217, APPLE_KEYBOARD_TYPE_ANSI }, /* Internal Keyboard/Trackpad (ANSI) */
+	{ 0x218, APPLE_KEYBOARD_TYPE_ISO },  /* Internal Keyboard/Trackpad (ISO) */
+	{ 0x219, APPLE_KEYBOARD_TYPE_JIS },  /* Internal Keyboard/Trackpad (JIS) */
+	{ 0x21A, APPLE_KEYBOARD_TYPE_ANSI }, /* Internal Keyboard/Trackpad (ANSI) */
+	{ 0x21B, APPLE_KEYBOARD_TYPE_ISO },  /* Internal Keyboard/Trackpad (ISO) */
+	{ 0x21C, APPLE_KEYBOARD_TYPE_JIS },  /* Internal Keyboard/Trackpad (JIS) */
+	{ 0x21D, APPLE_KEYBOARD_TYPE_ANSI }, /* Aluminum Mini Keyboard (ANSI) */
+	{ 0x21E, APPLE_KEYBOARD_TYPE_ISO },  /* Aluminum Mini Keyboard (ISO) */
+	{ 0x21F, APPLE_KEYBOARD_TYPE_JIS },  /* Aluminum Mini Keyboard (JIS) */
+	{ 0x220, APPLE_KEYBOARD_TYPE_ANSI }, /* Aluminum Keyboard (ANSI) */
+	{ 0x221, APPLE_KEYBOARD_TYPE_JIS },  /* Aluminum Keyboard (JIS) */
+	{ 0x222, APPLE_KEYBOARD_TYPE_JIS },  /* Aluminum Keyboard (JIS) */
+	{ 0x223, APPLE_KEYBOARD_TYPE_ANSI }, /* Internal Keyboard/Trackpad (ANSI) */
+	{ 0x224, APPLE_KEYBOARD_TYPE_ISO },  /* Internal Keyboard/Trackpad (ISO) */
+	{ 0x225, APPLE_KEYBOARD_TYPE_JIS },  /* Internal Keyboard/Trackpad (JIS) */
+	{ 0x226, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x227, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x228, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x229, APPLE_KEYBOARD_TYPE_ANSI }, /* Internal Keyboard/Trackpad (MacBook Pro) (ANSI) */
+	{ 0x22A, APPLE_KEYBOARD_TYPE_ISO },  /* Internal Keyboard/Trackpad (MacBook Pro) (ISO) */
+	{ 0x22B, APPLE_KEYBOARD_TYPE_JIS },  /* Internal Keyboard/Trackpad (MacBook Pro) (JIS) */
+	{ 0x22C, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x22D, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x22E, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x22F, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x230, APPLE_KEYBOARD_TYPE_ANSI }, /* Internal Keyboard/Trackpad (MacBook Pro 4,1) (ANSI) */
+	{ 0x231, APPLE_KEYBOARD_TYPE_ISO },  /* Internal Keyboard/Trackpad (MacBook Pro 4,1) (ISO) */
+	{ 0x232, APPLE_KEYBOARD_TYPE_JIS },  /* Internal Keyboard/Trackpad (MacBook Pro 4,1) (JIS) */
+	{ 0x233, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x234, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x235, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x236, APPLE_KEYBOARD_TYPE_ANSI }, /* Internal Keyboard/Trackpad (ANSI) */
+	{ 0x237, APPLE_KEYBOARD_TYPE_ISO },  /* Internal Keyboard/Trackpad (ISO) */
+	{ 0x238, APPLE_KEYBOARD_TYPE_JIS },  /* Internal Keyboard/Trackpad (JIS) */
+	{ 0x239, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x23A, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x23B, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x23C, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x23D, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x23E, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x23F, APPLE_KEYBOARD_TYPE_ANSI }, /* Internal Keyboard/Trackpad (ANSI) */
+	{ 0x240, APPLE_KEYBOARD_TYPE_ISO },  /* Internal Keyboard/Trackpad (ISO) */
+	{ 0x241, APPLE_KEYBOARD_TYPE_JIS },  /* Internal Keyboard/Trackpad (JIS) */
+	{ 0x242, APPLE_KEYBOARD_TYPE_ANSI }, /* Internal Keyboard/Trackpad (ANSI) */
+	{ 0x243, APPLE_KEYBOARD_TYPE_ISO },  /* Internal Keyboard/Trackpad (ISO) */
+	{ 0x244, APPLE_KEYBOARD_TYPE_JIS },  /* Internal Keyboard/Trackpad (JIS) */
+	{ 0x245, APPLE_KEYBOARD_TYPE_ANSI }, /* Internal Keyboard/Trackpad (ANSI) */
+	{ 0x246, APPLE_KEYBOARD_TYPE_ISO },  /* Internal Keyboard/Trackpad (ISO) */
+	{ 0x247, APPLE_KEYBOARD_TYPE_JIS },  /* Internal Keyboard/Trackpad (JIS) */
+	{ 0x248, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x249, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x24A, APPLE_KEYBOARD_TYPE_ISO }, /* Internal Keyboard/Trackpad (MacBook Air) (ISO) */
+	{ 0x24B, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x24C, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x24D, APPLE_KEYBOARD_TYPE_ISO }, /* Internal Keyboard/Trackpad (MacBook Air) (ISO) */
+	{ 0x24E, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x24F, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x250, APPLE_KEYBOARD_TYPE_ISO }, /* Aluminium Keyboard (ISO) */
+	{ 0x251, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x252, APPLE_KEYBOARD_TYPE_ANSI }, /* Internal Keyboard/Trackpad (ANSI) */
+	{ 0x253, APPLE_KEYBOARD_TYPE_ISO },  /* Internal Keyboard/Trackpad (ISO) */
+	{ 0x254, APPLE_KEYBOARD_TYPE_JIS },  /* Internal Keyboard/Trackpad (JIS) */
+	{ 0x255, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x256, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x257, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x258, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x259, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x25A, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x25B, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x25C, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x25D, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x25E, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x25F, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x260, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x261, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x262, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x263, APPLE_KEYBOARD_TYPE_ANSI }, /* Apple Internal Keyboard / Trackpad (MacBook Retina) */
+	{ 0x264, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x265, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x266, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x267, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x268, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x269, APPLE_KEYBOARD_TYPE_ANSI },
+	{ 0x26A, APPLE_KEYBOARD_TYPE_ANSI }
+};
+
+static enum APPLE_KEYBOARD_TYPE mac_identify_keyboard_type(uint32_t vendorID, uint32_t productID)
+{
+	enum APPLE_KEYBOARD_TYPE type = APPLE_KEYBOARD_TYPE_ANSI;
+
+	if (vendorID != 0x05AC) /* Apple, Inc. */
+		return type;
+
+	if ((productID < 0x200) || (productID > 0x26A))
+		return type;
+
+	type = APPLE_KEYBOARDS[productID - 0x200].Type;
+	return type;
+}
+
+enum APPLE_KEYBOARD_TYPE mac_detect_keyboard_type(void)
+{
+	CFSetRef deviceCFSetRef = NULL;
+	IOHIDDeviceRef inIOHIDDeviceRef = NULL;
+	IOHIDManagerRef tIOHIDManagerRef = NULL;
+	IOHIDDeviceRef *tIOHIDDeviceRefs = nil;
+	enum APPLE_KEYBOARD_TYPE type = APPLE_KEYBOARD_TYPE_ANSI;
+	tIOHIDManagerRef = IOHIDManagerCreate(kCFAllocatorDefault, kIOHIDOptionsTypeNone);
+
+	if (!tIOHIDManagerRef)
+		return type;
+
+	IOHIDManagerSetDeviceMatching(tIOHIDManagerRef, NULL);
+	IOReturn tIOReturn = IOHIDManagerOpen(tIOHIDManagerRef, kIOHIDOptionsTypeNone);
+
+	if (noErr != tIOReturn)
+		return type;
+
+	deviceCFSetRef = IOHIDManagerCopyDevices(tIOHIDManagerRef);
+
+	if (!deviceCFSetRef)
+		return type;
+
+	CFIndex deviceIndex, deviceCount = CFSetGetCount(deviceCFSetRef);
+	tIOHIDDeviceRefs = malloc(sizeof(IOHIDDeviceRef) * deviceCount);
+
+	if (!tIOHIDDeviceRefs)
+		return type;
+
+	CFSetGetValues(deviceCFSetRef, (const void **)tIOHIDDeviceRefs);
+	CFRelease(deviceCFSetRef);
+	deviceCFSetRef = NULL;
+
+	for (deviceIndex = 0; deviceIndex < deviceCount; deviceIndex++)
+	{
+		CFTypeRef tCFTypeRef;
+		uint32_t vendorID = 0;
+		uint32_t productID = 0;
+		uint32_t countryCode = 0;
+		enum APPLE_KEYBOARD_TYPE ltype;
+
+		if (!tIOHIDDeviceRefs[deviceIndex])
+			continue;
+
+		inIOHIDDeviceRef = tIOHIDDeviceRefs[deviceIndex];
+		tCFTypeRef = IOHIDDeviceGetProperty(inIOHIDDeviceRef, CFSTR(kIOHIDVendorIDKey));
+
+		if (tCFTypeRef)
+			CFNumberGetValue((CFNumberRef)tCFTypeRef, kCFNumberSInt32Type, &vendorID);
+
+		tCFTypeRef = IOHIDDeviceGetProperty(inIOHIDDeviceRef, CFSTR(kIOHIDProductIDKey));
+
+		if (tCFTypeRef)
+			CFNumberGetValue((CFNumberRef)tCFTypeRef, kCFNumberSInt32Type, &productID);
+
+		tCFTypeRef = IOHIDDeviceGetProperty(inIOHIDDeviceRef, CFSTR(kIOHIDCountryCodeKey));
+
+		if (tCFTypeRef)
+			CFNumberGetValue((CFNumberRef)tCFTypeRef, kCFNumberSInt32Type, &countryCode);
+
+		ltype = mac_identify_keyboard_type(vendorID, productID);
+
+		if (ltype != APPLE_KEYBOARD_TYPE_ANSI)
+		{
+			type = ltype;
+			break;
+		}
+	}
+
+	free(tIOHIDDeviceRefs);
+
+	if (deviceCFSetRef)
+	{
+		CFRelease(deviceCFSetRef);
+		deviceCFSetRef = NULL;
+	}
+
+	if (tIOHIDManagerRef)
+		CFRelease(tIOHIDManagerRef);
+
+	return type;
+}

local-test-freerdp-delta-01/afc-freerdp/client/Mac/MRDPCursor.h

@@ -0,0 +1,34 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * MacFreeRDP
+ *
+ * Copyright 2012 Thomas Goddard
+ *
+ * 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.
+ */
+
+#import <Cocoa/Cocoa.h>
+
+#include "freerdp/graphics.h"
+
+@interface MRDPCursor : NSObject
+{
+  @public
+	rdpPointer *pointer;
+	BYTE *cursor_data;
+	NSBitmapImageRep *bmiRep;
+	NSCursor *nsCursor;
+	NSImage *nsImage;
+}
+
+@end

local-test-freerdp-delta-01/afc-freerdp/client/Mac/MRDPCursor.m

@@ -0,0 +1,24 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * MacFreeRDP
+ *
+ * Copyright 2012 Thomas Goddard
+ *
+ * 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.
+ */
+
+#import "MRDPCursor.h"
+
+@implementation MRDPCursor
+
+@end

local-test-freerdp-delta-01/afc-freerdp/client/Mac/MRDPView.h

@@ -0,0 +1,91 @@
+#ifndef FREERDP_CLIENT_MAC_MRDPVIEW_H
+#define FREERDP_CLIENT_MAC_MRDPVIEW_H
+
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * MacFreeRDP
+ *
+ * Copyright 2012 Thomas Goddard
+ *
+ * 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.
+ */
+
+#import <Cocoa/Cocoa.h>
+
+#import "mfreerdp.h"
+#import "mf_client.h"
+#import "Keyboard.h"
+
+#import <CoreGraphics/CoreGraphics.h>
+
+@interface MRDPView : NSView
+{
+	mfContext *mfc;
+	NSBitmapImageRep *bmiRep;
+	NSMutableArray *cursors;
+	NSMutableArray *windows;
+	NSTimer *pasteboard_timer;
+	NSCursor *currentCursor;
+	NSRect prevWinPosition;
+	freerdp *instance;
+	rdpContext *context;
+	CGContextRef bitmap_context;
+	char *pixel_data;
+	int argc;
+	char **argv;
+	DWORD kbdModFlags;
+	BOOL initialized;
+	NSPoint savedDragLocation;
+	BOOL firstCreateWindow;
+	BOOL isMoveSizeInProgress;
+	BOOL skipResizeOnce;
+	BOOL saveInitialDragLoc;
+	BOOL skipMoveWindowOnce;
+  @public
+	NSPasteboard *pasteboard_rd;
+	NSPasteboard *pasteboard_wr;
+	int pasteboard_changecount;
+	int pasteboard_format;
+	int is_connected;
+}
+
+- (int)rdpStart:(rdpContext *)rdp_context;
+- (void)setCursor:(NSCursor *)cursor;
+- (void)setScrollOffset:(int)xOffset y:(int)yOffset w:(int)width h:(int)height;
+
+- (void)onPasteboardTimerFired:(NSTimer *)timer;
+- (void)pause;
+- (void)resume;
+- (void)releaseResources;
+
+@property(assign) int is_connected;
+
+@end
+
+BOOL mac_pre_connect(freerdp *instance);
+BOOL mac_post_connect(freerdp *instance);
+void mac_post_disconnect(freerdp *instance);
+BOOL mac_authenticate_ex(freerdp *instance, char **username, char **password, char **domain,
+                         rdp_auth_reason reason);
+
+DWORD mac_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 mac_verify_changed_certificate_ex(freerdp *instance, const char *host, UINT16 port,
+                                        const char *common_name, const char *subject,
+                                        const char *issuer, const char *fingerprint,
+                                        const char *old_subject, const char *old_issuer,
+                                        const char *old_fingerprint, DWORD flags);
+
+int mac_logon_error_info(freerdp *instance, UINT32 data, UINT32 type);
+#endif /* FREERDP_CLIENT_MAC_MRDPVIEW_H */

local-test-freerdp-delta-01/afc-freerdp/client/Mac/MRDPView.m

@@ -0,0 +1,1534 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * MacFreeRDP
+ *
+ * Copyright 2012 Thomas Goddard
+ *
+ * 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 <winpr/windows.h>
+
+#include "mf_client.h"
+#import "mfreerdp.h"
+#import "MRDPView.h"
+#import "MRDPCursor.h"
+#import "Clipboard.h"
+#import "PasswordDialog.h"
+#import "CertificateDialog.h"
+
+#include <winpr/crt.h>
+#include <winpr/assert.h>
+#include <winpr/input.h>
+#include <winpr/synch.h>
+#include <winpr/sysinfo.h>
+
+#include <freerdp/constants.h>
+
+#import "freerdp/freerdp.h"
+#import "freerdp/types.h"
+#import "freerdp/config.h"
+#import "freerdp/channels/channels.h"
+#import "freerdp/gdi/gdi.h"
+#import "freerdp/gdi/dc.h"
+#import "freerdp/gdi/region.h"
+#import "freerdp/graphics.h"
+#import "freerdp/client/file.h"
+#import "freerdp/client/cmdline.h"
+#import "freerdp/log.h"
+
+#import <CoreGraphics/CoreGraphics.h>
+
+#define TAG CLIENT_TAG("mac")
+
+static BOOL mf_Pointer_New(rdpContext *context, rdpPointer *pointer);
+static void mf_Pointer_Free(rdpContext *context, rdpPointer *pointer);
+static BOOL mf_Pointer_Set(rdpContext *context, rdpPointer *pointer);
+static BOOL mf_Pointer_SetNull(rdpContext *context);
+static BOOL mf_Pointer_SetDefault(rdpContext *context);
+static BOOL mf_Pointer_SetPosition(rdpContext *context, UINT32 x, UINT32 y);
+
+static BOOL mac_begin_paint(rdpContext *context);
+static BOOL mac_end_paint(rdpContext *context);
+static BOOL mac_desktop_resize(rdpContext *context);
+
+static void input_activity_cb(freerdp *instance);
+
+static DWORD WINAPI mac_client_thread(void *param);
+static void windows_to_apple_cords(MRDPView *view, NSRect *r);
+static CGContextRef mac_create_bitmap_context(rdpContext *context);
+
+@implementation MRDPView
+
+@synthesize is_connected;
+
+- (int)rdpStart:(rdpContext *)rdp_context
+{
+	rdpSettings *settings;
+	EmbedWindowEventArgs e;
+	[self initializeView];
+
+	WINPR_ASSERT(rdp_context);
+	context = rdp_context;
+	mfc = (mfContext *)rdp_context;
+
+	instance = context->instance;
+	WINPR_ASSERT(instance);
+
+	settings = context->settings;
+	WINPR_ASSERT(settings);
+
+	EventArgsInit(&e, "mfreerdp");
+	e.embed = TRUE;
+	e.handle = (void *)self;
+	PubSub_OnEmbedWindow(context->pubSub, context, &e);
+	NSScreen *screen = [[NSScreen screens] objectAtIndex:0];
+	NSRect screenFrame = [screen frame];
+
+	if (freerdp_settings_get_bool(settings, FreeRDP_Fullscreen))
+	{
+		if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopWidth, screenFrame.size.width))
+			return -1;
+		if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopHeight, screenFrame.size.height))
+			return -1;
+		[self enterFullScreenMode:[NSScreen mainScreen] withOptions:nil];
+	}
+	else
+	{
+		[self exitFullScreenModeWithOptions:nil];
+	}
+
+	mfc->client_height = freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
+	mfc->client_width = freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
+
+	if (!(mfc->common.thread =
+	          CreateThread(NULL, 0, mac_client_thread, (void *)context, 0, &mfc->mainThreadId)))
+	{
+		WLog_ERR(TAG, "failed to create client thread");
+		return -1;
+	}
+
+	return 0;
+}
+
+DWORD WINAPI mac_client_thread(void *param)
+{
+	@autoreleasepool
+	{
+		int status;
+		DWORD rc;
+		HANDLE events[16] = { 0 };
+		HANDLE inputEvent;
+		DWORD nCount;
+		DWORD nCountTmp;
+		DWORD nCountBase;
+		rdpContext *context = (rdpContext *)param;
+		mfContext *mfc = (mfContext *)context;
+		freerdp *instance = context->instance;
+		MRDPView *view = mfc->view;
+		rdpSettings *settings = context->settings;
+		status = freerdp_connect(context->instance);
+
+		if (!status)
+		{
+			[view setIs_connected:0];
+			return 0;
+		}
+
+		[view setIs_connected:1];
+		nCount = 0;
+		events[nCount++] = mfc->stopEvent;
+
+		if (!(inputEvent =
+		          freerdp_get_message_queue_event_handle(instance, FREERDP_INPUT_MESSAGE_QUEUE)))
+		{
+			WLog_ERR(TAG, "failed to get input event handle");
+			goto disconnect;
+		}
+
+		events[nCount++] = inputEvent;
+
+		nCountBase = nCount;
+
+		while (!freerdp_shall_disconnect_context(instance->context))
+		{
+			nCount = nCountBase;
+			{
+				if (!(nCountTmp = freerdp_get_event_handles(context, &events[nCount], 16 - nCount)))
+				{
+					WLog_ERR(TAG, "freerdp_get_event_handles failed");
+					break;
+				}
+
+				nCount += nCountTmp;
+			}
+			rc = WaitForMultipleObjects(nCount, events, FALSE, INFINITE);
+
+			if (rc >= (WAIT_OBJECT_0 + nCount))
+			{
+				WLog_ERR(TAG, "WaitForMultipleObjects failed (0x%08X)", rc);
+				break;
+			}
+
+			if (rc == WAIT_OBJECT_0)
+			{
+				/* stop event triggered */
+				break;
+			}
+
+			if (WaitForSingleObject(inputEvent, 0) == WAIT_OBJECT_0)
+			{
+				input_activity_cb(instance);
+			}
+
+			{
+				if (!freerdp_check_event_handles(context))
+				{
+					WLog_ERR(TAG, "freerdp_check_event_handles failed");
+					break;
+				}
+			}
+		}
+
+	disconnect:
+		[view setIs_connected:0];
+		freerdp_disconnect(instance);
+
+		ExitThread(0);
+		return 0;
+	}
+}
+
+- (id)initWithFrame:(NSRect)frame
+{
+	self = [super initWithFrame:frame];
+
+	if (self)
+	{
+		// Initialization code here.
+	}
+
+	return self;
+}
+
+- (void)viewDidLoad
+{
+	[self initializeView];
+}
+
+- (void)initializeView
+{
+	if (!initialized)
+	{
+		cursors = [[NSMutableArray alloc] initWithCapacity:10];
+		// setup a mouse tracking area
+		NSTrackingArea *trackingArea = [[NSTrackingArea alloc]
+		    initWithRect:[self visibleRect]
+		         options:NSTrackingMouseEnteredAndExited | NSTrackingMouseMoved |
+		                 NSTrackingCursorUpdate | NSTrackingEnabledDuringMouseDrag |
+		                 NSTrackingActiveWhenFirstResponder
+		           owner:self
+		        userInfo:nil];
+		[self addTrackingArea:trackingArea];
+		// Set the default cursor
+		currentCursor = [NSCursor arrowCursor];
+		initialized = YES;
+	}
+}
+
+- (void)setCursor:(NSCursor *)cursor
+{
+	self->currentCursor = cursor;
+	dispatch_async(dispatch_get_main_queue(), ^{
+		[[self window] invalidateCursorRectsForView:self];
+	});
+}
+
+- (void)resetCursorRects
+{
+	[self addCursorRect:[self visibleRect] cursor:currentCursor];
+}
+
+- (BOOL)acceptsFirstResponder
+{
+	return YES;
+}
+
+- (void)mouseMoved:(NSEvent *)event
+{
+	[super mouseMoved:event];
+
+	if (!self.is_connected)
+		return;
+
+	NSPoint loc = [event locationInWindow];
+	int x = (int)loc.x;
+	int y = (int)loc.y;
+	mf_scale_mouse_event(context, PTR_FLAGS_MOVE, x, y);
+}
+
+- (void)mouseDown:(NSEvent *)event
+{
+	[super mouseDown:event];
+
+	if (!self.is_connected)
+		return;
+
+	NSPoint loc = [event locationInWindow];
+	int x = (int)loc.x;
+	int y = (int)loc.y;
+	mf_press_mouse_button(context, 0, x, y, TRUE);
+}
+
+- (void)mouseUp:(NSEvent *)event
+{
+	[super mouseUp:event];
+
+	if (!self.is_connected)
+		return;
+
+	NSPoint loc = [event locationInWindow];
+	int x = (int)loc.x;
+	int y = (int)loc.y;
+	mf_press_mouse_button(context, 0, x, y, FALSE);
+}
+
+- (void)rightMouseDown:(NSEvent *)event
+{
+	[super rightMouseDown:event];
+
+	if (!self.is_connected)
+		return;
+
+	NSPoint loc = [event locationInWindow];
+	int x = (int)loc.x;
+	int y = (int)loc.y;
+	mf_press_mouse_button(context, 1, x, y, TRUE);
+}
+
+- (void)rightMouseUp:(NSEvent *)event
+{
+	[super rightMouseUp:event];
+
+	if (!self.is_connected)
+		return;
+
+	NSPoint loc = [event locationInWindow];
+	int x = (int)loc.x;
+	int y = (int)loc.y;
+	mf_press_mouse_button(context, 1, x, y, FALSE);
+}
+
+- (void)otherMouseDown:(NSEvent *)event
+{
+	[super otherMouseDown:event];
+
+	if (!self.is_connected)
+		return;
+
+	NSPoint loc = [event locationInWindow];
+	int x = (int)loc.x;
+	int y = (int)loc.y;
+	int pressed = [event buttonNumber];
+	mf_press_mouse_button(context, pressed, x, y, TRUE);
+}
+
+- (void)otherMouseUp:(NSEvent *)event
+{
+	[super otherMouseUp:event];
+
+	if (!self.is_connected)
+		return;
+
+	NSPoint loc = [event locationInWindow];
+	int x = (int)loc.x;
+	int y = (int)loc.y;
+	int pressed = [event buttonNumber];
+	mf_press_mouse_button(context, pressed, x, y, FALSE);
+}
+
+- (void)scrollWheel:(NSEvent *)event
+{
+	UINT16 flags;
+	[super scrollWheel:event];
+
+	if (!self.is_connected)
+		return;
+
+	float dx = [event deltaX];
+	float dy = [event deltaY];
+	/* 1 event = 120 units */
+	UINT16 units = 0;
+
+	if (fabsf(dy) > FLT_EPSILON)
+	{
+		flags = PTR_FLAGS_WHEEL;
+		units = fabsf(dy) * 120;
+
+		if (dy < 0)
+			flags |= PTR_FLAGS_WHEEL_NEGATIVE;
+	}
+	else if (fabsf(dx) > FLT_EPSILON)
+	{
+		flags = PTR_FLAGS_HWHEEL;
+		units = fabsf(dx) * 120;
+
+		if (dx > 0)
+			flags |= PTR_FLAGS_WHEEL_NEGATIVE;
+	}
+	else
+		return;
+
+	/* Wheel rotation steps:
+	 *
+	 * positive: 0 ... 0xFF  -> slow ... fast
+	 * negative: 0 ... 0xFF  -> fast ... slow
+	 */
+	UINT16 step = units;
+	if (step > 0xFF)
+		step = 0xFF;
+
+	/* Negative rotation, so count down steps from top
+	 * 9bit twos complement */
+	if (flags & PTR_FLAGS_WHEEL_NEGATIVE)
+		step = 0x100 - step;
+
+	mf_scale_mouse_event(context, flags | step, 0, 0);
+}
+
+- (void)mouseDragged:(NSEvent *)event
+{
+	[super mouseDragged:event];
+
+	if (!self.is_connected)
+		return;
+
+	NSPoint loc = [event locationInWindow];
+	int x = (int)loc.x;
+	int y = (int)loc.y;
+	// send mouse motion event to RDP server
+	mf_scale_mouse_event(context, PTR_FLAGS_MOVE, x, y);
+}
+
+static DWORD fixKeyCode(DWORD keyCode, unichar keyChar, enum APPLE_KEYBOARD_TYPE type)
+{
+	/**
+	 * In 99% of cases, the given key code is truly keyboard independent.
+	 * This function handles the remaining 1% of edge cases.
+	 *
+	 * Hungarian Keyboard: This is 'QWERTZ' and not 'QWERTY'.
+	 * The '0' key is on the left of the '1' key, where '~' is on a US keyboard.
+	 * A special 'i' letter key with acute is found on the right of the left shift key.
+	 * On the hungarian keyboard, the 'i' key is at the left of the 'Y' key
+	 * Some international keyboards have a corresponding key which would be at
+	 * the left of the 'Z' key when using a QWERTY layout.
+	 *
+	 * The Apple Hungarian keyboard sends inverted key codes for the '0' and 'i' keys.
+	 * When using the US keyboard layout, key codes are left as-is (inverted).
+	 * When using the Hungarian keyboard layout, key codes are swapped (non-inverted).
+	 * This means that when using the Hungarian keyboard layout with a US keyboard,
+	 * the keys corresponding to '0' and 'i' will effectively be inverted.
+	 *
+	 * To fix the '0' and 'i' key inversion, we use the corresponding output character
+	 * provided by OS X and check for a character to key code mismatch: for instance,
+	 * when the output character is '0' for the key code corresponding to the 'i' key.
+	 */
+#if 0
+	switch (keyChar)
+	{
+		case '0':
+		case 0x00A7: /* section sign */
+			if (keyCode == APPLE_VK_ISO_Section)
+				keyCode = APPLE_VK_ANSI_Grave;
+
+			break;
+
+		case 0x00ED: /* latin small letter i with acute */
+		case 0x00CD: /* latin capital letter i with acute */
+			if (keyCode == APPLE_VK_ANSI_Grave)
+				keyCode = APPLE_VK_ISO_Section;
+
+			break;
+	}
+
+#endif
+
+	/* Perform keycode correction for all ISO keyboards */
+
+	if (type == APPLE_KEYBOARD_TYPE_ISO)
+	{
+		if (keyCode == APPLE_VK_ANSI_Grave)
+			keyCode = APPLE_VK_ISO_Section;
+		else if (keyCode == APPLE_VK_ISO_Section)
+			keyCode = APPLE_VK_ANSI_Grave;
+	}
+
+	return keyCode;
+}
+
+- (void)flagsChanged:(NSEvent *)event
+{
+	if (!is_connected)
+		return;
+
+	DWORD modFlags = [event modifierFlags] & NSEventModifierFlagDeviceIndependentFlagsMask;
+
+	WINPR_ASSERT(instance);
+	WINPR_ASSERT(instance->context);
+
+	rdpInput *input = instance->context->input;
+
+#if defined(WITH_DEBUG_KBD)
+	WLog_DBG(TAG, "flagsChanged: modFlags: 0x%04X kbdModFlags: 0x%04X", modFlags, kbdModFlags);
+#endif
+
+	updateFlagStates(input, modFlags, kbdModFlags);
+	kbdModFlags = modFlags;
+}
+
+- (void)keyDown:(NSEvent *)event
+{
+	DWORD keyCode;
+	DWORD keyFlags;
+	DWORD vkcode;
+	DWORD scancode;
+	unichar keyChar;
+	NSString *characters;
+
+	if (!is_connected)
+		return;
+
+	[self flagsChanged:event];
+
+	keyFlags = KBD_FLAGS_DOWN;
+	keyCode = [event keyCode];
+	characters = [event charactersIgnoringModifiers];
+
+	if ([characters length] > 0)
+	{
+		keyChar = [characters characterAtIndex:0];
+		keyCode = fixKeyCode(keyCode, keyChar, mfc->appleKeyboardType);
+	}
+
+	vkcode = GetVirtualKeyCodeFromKeycode(keyCode, WINPR_KEYCODE_TYPE_APPLE);
+	scancode = GetVirtualScanCodeFromVirtualKeyCode(vkcode, 4);
+	keyFlags |= (scancode & KBDEXT) ? KBDEXT : 0;
+	scancode &= 0xFF;
+	vkcode &= 0xFF;
+
+#if defined(WITH_DEBUG_KBD)
+	WLog_DBG(TAG, "keyDown: keyCode: 0x%04X scancode: 0x%04X vkcode: 0x%04X keyFlags: %d name: %s",
+	         keyCode, scancode, vkcode, keyFlags, GetVirtualKeyName(vkcode));
+#endif
+
+	WINPR_ASSERT(instance->context);
+	freerdp_input_send_keyboard_event(instance->context->input, keyFlags, scancode);
+}
+
+- (void)keyUp:(NSEvent *)event
+{
+	DWORD keyCode;
+	DWORD keyFlags;
+	DWORD vkcode;
+	DWORD scancode;
+	unichar keyChar;
+	NSString *characters;
+
+	if (!is_connected)
+		return;
+
+	[self flagsChanged:event];
+
+	keyFlags = KBD_FLAGS_RELEASE;
+	keyCode = [event keyCode];
+	characters = [event charactersIgnoringModifiers];
+
+	if ([characters length] > 0)
+	{
+		keyChar = [characters characterAtIndex:0];
+		keyCode = fixKeyCode(keyCode, keyChar, mfc->appleKeyboardType);
+	}
+
+	vkcode = GetVirtualKeyCodeFromKeycode(keyCode, WINPR_KEYCODE_TYPE_APPLE);
+	scancode = GetVirtualScanCodeFromVirtualKeyCode(vkcode, 4);
+	keyFlags |= (scancode & KBDEXT) ? KBDEXT : 0;
+	scancode &= 0xFF;
+	vkcode &= 0xFF;
+#if defined(WITH_DEBUG_KBD)
+	WLog_DBG(TAG, "keyUp: key: 0x%04X scancode: 0x%04X vkcode: 0x%04X keyFlags: %d name: %s",
+	         keyCode, scancode, vkcode, keyFlags, GetVirtualKeyName(vkcode));
+#endif
+	WINPR_ASSERT(instance->context);
+	freerdp_input_send_keyboard_event(instance->context->input, keyFlags, scancode);
+}
+
+static BOOL updateFlagState(rdpInput *input, DWORD modFlags, DWORD aKbdModFlags, DWORD flag)
+{
+	BOOL press = ((modFlags & flag) != 0) && ((aKbdModFlags & flag) == 0);
+	BOOL release = ((modFlags & flag) == 0) && ((aKbdModFlags & flag) != 0);
+	DWORD keyFlags = 0;
+	const char *name = NULL;
+	DWORD scancode = 0;
+
+	if ((modFlags & flag) == (aKbdModFlags & flag))
+		return TRUE;
+
+	switch (flag)
+	{
+		case NSEventModifierFlagCapsLock:
+			name = "NSEventModifierFlagCapsLock";
+			scancode = RDP_SCANCODE_CAPSLOCK;
+			release = press = TRUE;
+			break;
+		case NSEventModifierFlagShift:
+			name = "NSEventModifierFlagShift";
+			scancode = RDP_SCANCODE_LSHIFT;
+			break;
+
+		case NSEventModifierFlagControl:
+			name = "NSEventModifierFlagControl";
+			scancode = RDP_SCANCODE_LCONTROL;
+			break;
+
+		case NSEventModifierFlagOption:
+			name = "NSEventModifierFlagOption";
+			scancode = RDP_SCANCODE_LMENU;
+			break;
+
+		case NSEventModifierFlagCommand:
+			name = "NSEventModifierFlagCommand";
+			scancode = RDP_SCANCODE_LWIN;
+			break;
+
+		case NSEventModifierFlagNumericPad:
+			name = "NSEventModifierFlagNumericPad";
+			scancode = RDP_SCANCODE_NUMLOCK;
+			release = press = TRUE;
+			break;
+
+		case NSEventModifierFlagHelp:
+			name = "NSEventModifierFlagHelp";
+			scancode = RDP_SCANCODE_HELP;
+			break;
+
+		case NSEventModifierFlagFunction:
+			name = "NSEventModifierFlagFunction";
+			scancode = RDP_SCANCODE_HELP;
+			break;
+
+		default:
+			WLog_ERR(TAG, "Invalid flag: 0x%08" PRIx32 ", not supported", flag);
+			return FALSE;
+	}
+
+	keyFlags = (scancode & KBDEXT);
+	scancode &= 0xFF;
+
+#if defined(WITH_DEBUG_KBD)
+	if (press || release)
+		WLog_DBG(TAG, "changing flag %s[0x%08" PRIx32 "] to %s", name, flag,
+		         press ? "DOWN" : "RELEASE");
+#endif
+
+	if (press)
+	{
+		if (!freerdp_input_send_keyboard_event(input, keyFlags | KBD_FLAGS_DOWN, scancode))
+			return FALSE;
+	}
+
+	if (release)
+	{
+		if (!freerdp_input_send_keyboard_event(input, keyFlags | KBD_FLAGS_RELEASE, scancode))
+			return FALSE;
+	}
+
+	return TRUE;
+}
+
+static BOOL updateFlagStates(rdpInput *input, UINT32 modFlags, UINT32 aKbdModFlags)
+{
+	updateFlagState(input, modFlags, aKbdModFlags, NSEventModifierFlagCapsLock);
+	updateFlagState(input, modFlags, aKbdModFlags, NSEventModifierFlagShift);
+	updateFlagState(input, modFlags, aKbdModFlags, NSEventModifierFlagControl);
+	updateFlagState(input, modFlags, aKbdModFlags, NSEventModifierFlagOption);
+	updateFlagState(input, modFlags, aKbdModFlags, NSEventModifierFlagCommand);
+	updateFlagState(input, modFlags, aKbdModFlags, NSEventModifierFlagNumericPad);
+	return TRUE;
+}
+
+static BOOL releaseFlagStates(rdpInput *input, UINT32 aKbdModFlags)
+{
+	return updateFlagStates(input, 0, aKbdModFlags);
+}
+
+- (void)releaseResources
+{
+	for (int i = 0; i < argc; i++)
+		free(argv[i]);
+
+	if (!is_connected)
+		return;
+
+	free(pixel_data);
+}
+
+- (void)drawRect:(NSRect)rect
+{
+	if (!context)
+		return;
+
+	if (self->bitmap_context)
+	{
+		CGContextRef cgContext = [[NSGraphicsContext currentContext] CGContext];
+		CGImageRef cgImage = CGBitmapContextCreateImage(self->bitmap_context);
+		CGContextSaveGState(cgContext);
+		CGContextClipToRect(
+		    cgContext, CGRectMake(rect.origin.x, rect.origin.y, rect.size.width, rect.size.height));
+		CGContextDrawImage(cgContext,
+		                   CGRectMake(0, 0, [self bounds].size.width, [self bounds].size.height),
+		                   cgImage);
+		CGContextRestoreGState(cgContext);
+		CGImageRelease(cgImage);
+	}
+	else
+	{
+		/* Fill the screen with black */
+		[[NSColor blackColor] set];
+		NSRectFill([self bounds]);
+	}
+}
+
+- (void)onPasteboardTimerFired:(NSTimer *)timer
+{
+	UINT32 formatId;
+	BOOL formatMatch;
+	int changeCount;
+	NSData *formatData;
+	NSString *formatString;
+	const char *formatType;
+	NSPasteboardItem *item;
+	changeCount = (int)[pasteboard_rd changeCount];
+
+	if (changeCount == pasteboard_changecount)
+		return;
+
+	pasteboard_changecount = changeCount;
+	NSArray *items = [pasteboard_rd pasteboardItems];
+
+	if ([items count] < 1)
+		return;
+
+	item = [items objectAtIndex:0];
+	/**
+	 * System-Declared Uniform Type Identifiers:
+	 * https://developer.apple.com/library/ios/documentation/Miscellaneous/Reference/UTIRef/Articles/System-DeclaredUniformTypeIdentifiers.html
+	 */
+	formatMatch = FALSE;
+
+	for (NSString *type in [item types])
+	{
+		formatType = [type UTF8String];
+
+		if (strcmp(formatType, "public.utf8-plain-text") == 0)
+		{
+			formatData = [item dataForType:type];
+
+			if (formatData == nil)
+			{
+				break;
+			}
+
+			formatString = [[NSString alloc] initWithData:formatData encoding:NSUTF8StringEncoding];
+
+			const char *data = [formatString cStringUsingEncoding:NSUTF8StringEncoding];
+			const size_t dataLen = [formatString lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
+			formatId = ClipboardRegisterFormat(mfc->clipboard, "text/plain");
+			ClipboardSetData(mfc->clipboard, formatId, data, dataLen + 1);
+			[formatString release];
+
+			formatMatch = TRUE;
+
+			break;
+		}
+	}
+
+	if (!formatMatch)
+		ClipboardEmpty(mfc->clipboard);
+
+	if (mfc->clipboardSync)
+		mac_cliprdr_send_client_format_list(mfc->cliprdr);
+}
+
+- (void)pause
+{
+	dispatch_async(dispatch_get_main_queue(), ^{
+		[self->pasteboard_timer invalidate];
+	});
+	NSArray *trackingAreas = self.trackingAreas;
+
+	for (NSTrackingArea *ta in trackingAreas)
+	{
+		[self removeTrackingArea:ta];
+	}
+	releaseFlagStates(instance->context->input, kbdModFlags);
+	kbdModFlags = 0;
+}
+
+- (void)resume
+{
+	if (!self.is_connected)
+		return;
+
+	releaseFlagStates(instance->context->input, kbdModFlags);
+	kbdModFlags = 0;
+	freerdp_input_send_focus_in_event(instance->context->input, 0);
+
+	dispatch_async(dispatch_get_main_queue(), ^{
+		self->pasteboard_timer =
+		    [NSTimer scheduledTimerWithTimeInterval:0.5
+		                                     target:self
+		                                   selector:@selector(onPasteboardTimerFired:)
+		                                   userInfo:nil
+		                                    repeats:YES];
+
+		NSTrackingArea *trackingArea = [[NSTrackingArea alloc]
+		    initWithRect:[self visibleRect]
+		         options:NSTrackingMouseEnteredAndExited | NSTrackingMouseMoved |
+		                 NSTrackingCursorUpdate | NSTrackingEnabledDuringMouseDrag |
+		                 NSTrackingActiveWhenFirstResponder
+		           owner:self
+		        userInfo:nil];
+		[self addTrackingArea:trackingArea];
+		[trackingArea release];
+	});
+}
+
+- (void)setScrollOffset:(int)xOffset y:(int)yOffset w:(int)width h:(int)height
+{
+	WINPR_ASSERT(mfc);
+
+	mfc->yCurrentScroll = yOffset;
+	mfc->xCurrentScroll = xOffset;
+	mfc->client_height = height;
+	mfc->client_width = width;
+}
+
+static void mac_OnChannelConnectedEventHandler(void *context, const ChannelConnectedEventArgs *e)
+{
+	rdpSettings *settings;
+	mfContext *mfc = (mfContext *)context;
+
+	WINPR_ASSERT(mfc);
+	WINPR_ASSERT(e);
+
+	settings = mfc->common.context.settings;
+	WINPR_ASSERT(settings);
+
+	if (strcmp(e->name, CLIPRDR_SVC_CHANNEL_NAME) == 0)
+	{
+		mac_cliprdr_init(mfc, (CliprdrClientContext *)e->pInterface);
+	}
+	else if (strcmp(e->name, ENCOMSP_SVC_CHANNEL_NAME) == 0)
+	{
+	}
+	else
+		freerdp_client_OnChannelConnectedEventHandler(context, e);
+}
+
+static void mac_OnChannelDisconnectedEventHandler(void *context,
+                                                  const ChannelDisconnectedEventArgs *e)
+{
+	rdpSettings *settings;
+	mfContext *mfc = (mfContext *)context;
+
+	WINPR_ASSERT(mfc);
+	WINPR_ASSERT(e);
+
+	settings = mfc->common.context.settings;
+	WINPR_ASSERT(settings);
+
+	if (strcmp(e->name, CLIPRDR_SVC_CHANNEL_NAME) == 0)
+	{
+		mac_cliprdr_uninit(mfc, (CliprdrClientContext *)e->pInterface);
+	}
+	else if (strcmp(e->name, ENCOMSP_SVC_CHANNEL_NAME) == 0)
+	{
+	}
+	else
+		freerdp_client_OnChannelDisconnectedEventHandler(context, e);
+}
+
+BOOL mac_pre_connect(freerdp *instance)
+{
+	rdpSettings *settings;
+	rdpUpdate *update;
+
+	WINPR_ASSERT(instance);
+	WINPR_ASSERT(instance->context);
+
+	update = instance->context->update;
+	WINPR_ASSERT(update);
+
+	update->BeginPaint = mac_begin_paint;
+	update->EndPaint = mac_end_paint;
+	update->DesktopResize = mac_desktop_resize;
+
+	settings = instance->context->settings;
+	WINPR_ASSERT(settings);
+
+	if (!freerdp_settings_get_string(settings, FreeRDP_ServerHostname))
+	{
+		WLog_ERR(TAG, "error: server hostname was not specified with /v:<server>[:port]");
+		return FALSE;
+	}
+
+	if (!freerdp_settings_set_uint32(settings, FreeRDP_OsMajorType, OSMAJORTYPE_MACINTOSH))
+		return FALSE;
+	if (!freerdp_settings_set_uint32(settings, FreeRDP_OsMinorType, OSMINORTYPE_MACINTOSH))
+		return FALSE;
+	PubSub_SubscribeChannelConnected(instance->context->pubSub, mac_OnChannelConnectedEventHandler);
+	PubSub_SubscribeChannelDisconnected(instance->context->pubSub,
+	                                    mac_OnChannelDisconnectedEventHandler);
+
+	return TRUE;
+}
+
+BOOL mac_post_connect(freerdp *instance)
+{
+	rdpGdi *gdi;
+	rdpPointer rdp_pointer = { 0 };
+	mfContext *mfc;
+	MRDPView *view;
+
+	WINPR_ASSERT(instance);
+
+	mfc = (mfContext *)instance->context;
+	WINPR_ASSERT(mfc);
+
+	view = (MRDPView *)mfc->view;
+	WINPR_ASSERT(view);
+
+	rdp_pointer.size = sizeof(rdpPointer);
+	rdp_pointer.New = mf_Pointer_New;
+	rdp_pointer.Free = mf_Pointer_Free;
+	rdp_pointer.Set = mf_Pointer_Set;
+	rdp_pointer.SetNull = mf_Pointer_SetNull;
+	rdp_pointer.SetDefault = mf_Pointer_SetDefault;
+	rdp_pointer.SetPosition = mf_Pointer_SetPosition;
+
+	if (!gdi_init(instance, PIXEL_FORMAT_BGRX32))
+		return FALSE;
+
+	gdi = instance->context->gdi;
+	view->bitmap_context = mac_create_bitmap_context(instance->context);
+	graphics_register_pointer(instance->context->graphics, &rdp_pointer);
+	/* setup pasteboard (aka clipboard) for copy operations (write only) */
+	view->pasteboard_wr = [NSPasteboard generalPasteboard];
+	/* setup pasteboard for read operations */
+	dispatch_async(dispatch_get_main_queue(), ^{
+		view->pasteboard_rd = [NSPasteboard generalPasteboard];
+		view->pasteboard_changecount = -1;
+	});
+	[view resume];
+	mfc->appleKeyboardType = mac_detect_keyboard_type();
+	return TRUE;
+}
+
+void mac_post_disconnect(freerdp *instance)
+{
+	mfContext *mfc;
+	MRDPView *view;
+	if (!instance || !instance->context)
+		return;
+
+	mfc = (mfContext *)instance->context;
+	view = (MRDPView *)mfc->view;
+
+	[view pause];
+
+	PubSub_UnsubscribeChannelConnected(instance->context->pubSub,
+	                                   mac_OnChannelConnectedEventHandler);
+	PubSub_UnsubscribeChannelDisconnected(instance->context->pubSub,
+	                                      mac_OnChannelDisconnectedEventHandler);
+	gdi_free(instance);
+}
+
+static BOOL mac_show_auth_dialog(MRDPView *view, NSString *title, char **username, char **password,
+                                 char **domain)
+{
+	WINPR_ASSERT(view);
+	WINPR_ASSERT(title);
+	WINPR_ASSERT(username);
+	WINPR_ASSERT(password);
+	WINPR_ASSERT(domain);
+
+	PasswordDialog *dialog = [PasswordDialog new];
+
+	dialog.serverHostname = title;
+
+	if (*username)
+		dialog.username = [NSString stringWithCString:*username encoding:NSUTF8StringEncoding];
+
+	if (*password)
+		dialog.password = [NSString stringWithCString:*password encoding:NSUTF8StringEncoding];
+
+	if (*domain)
+		dialog.domain = [NSString stringWithCString:*domain encoding:NSUTF8StringEncoding];
+
+	free(*username);
+	free(*password);
+	free(*domain);
+	*username = NULL;
+	*password = NULL;
+	*domain = NULL;
+
+	dispatch_sync(dispatch_get_main_queue(), ^{
+		[dialog performSelectorOnMainThread:@selector(runModal:)
+		                         withObject:[view window]
+		                      waitUntilDone:TRUE];
+	});
+	BOOL ok = dialog.modalCode;
+
+	if (ok)
+	{
+		const char *submittedUsername = [dialog.username cStringUsingEncoding:NSUTF8StringEncoding];
+		const size_t submittedUsernameLen =
+		    [dialog.username lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
+		if (submittedUsername && (submittedUsernameLen > 0))
+			*username = strndup(submittedUsername, submittedUsernameLen);
+
+		if (!(*username))
+			return FALSE;
+
+		const char *submittedPassword = [dialog.password cStringUsingEncoding:NSUTF8StringEncoding];
+		const size_t submittedPasswordLen =
+		    [dialog.password lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
+		if (submittedPassword && (submittedPasswordLen > 0))
+			*password = strndup(submittedPassword, submittedPasswordLen);
+
+		if (!(*password))
+			return FALSE;
+
+		const char *submittedDomain = [dialog.domain cStringUsingEncoding:NSUTF8StringEncoding];
+		const size_t submittedDomainLen =
+		    [dialog.domain lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
+		if (submittedDomain && (submittedDomainLen > 0))
+		{
+			*domain = strndup(submittedDomain, submittedDomainLen);
+			if (!(*domain))
+				return FALSE;
+		}
+	}
+
+	return ok;
+}
+
+static BOOL mac_authenticate_raw(freerdp *instance, char **username, char **password, char **domain,
+                                 rdp_auth_reason reason)
+{
+	BOOL pinOnly = FALSE;
+
+	WINPR_ASSERT(instance);
+	WINPR_ASSERT(instance->context);
+	WINPR_ASSERT(instance->context->settings);
+
+	const rdpSettings *settings = instance->context->settings;
+	mfContext *mfc = (mfContext *)instance->context;
+	MRDPView *view = (MRDPView *)mfc->view;
+	NSString *title = NULL;
+
+	switch (reason)
+	{
+		case AUTH_SMARTCARD_PIN:
+			pinOnly = TRUE;
+			title = [NSString
+			    stringWithFormat:@"%@:%u",
+			                     [NSString stringWithCString:freerdp_settings_get_string(
+			                                                     settings, FreeRDP_ServerHostname)
+			                                        encoding:NSUTF8StringEncoding],
+			                     freerdp_settings_get_uint32(settings, FreeRDP_ServerPort)];
+			break;
+		case AUTH_TLS:
+		case AUTH_RDP:
+		case AUTH_NLA:
+			title = [NSString
+			    stringWithFormat:@"%@:%u",
+			                     [NSString stringWithCString:freerdp_settings_get_string(
+			                                                     settings, FreeRDP_ServerHostname)
+			                                        encoding:NSUTF8StringEncoding],
+			                     freerdp_settings_get_uint32(settings, FreeRDP_ServerPort)];
+			break;
+		case GW_AUTH_HTTP:
+		case GW_AUTH_RDG:
+		case GW_AUTH_RPC:
+			title = [NSString
+			    stringWithFormat:@"%@:%u",
+			                     [NSString stringWithCString:freerdp_settings_get_string(
+			                                                     settings, FreeRDP_GatewayHostname)
+			                                        encoding:NSUTF8StringEncoding],
+			                     freerdp_settings_get_uint32(settings, FreeRDP_GatewayPort)];
+			break;
+		default:
+			return FALSE;
+	}
+
+	if (!username || !password || !domain)
+		return FALSE;
+
+	if (!*username && !pinOnly)
+	{
+		if (!mac_show_auth_dialog(view, title, username, password, domain))
+			goto fail;
+	}
+	else if (!*domain && !pinOnly)
+	{
+		if (!mac_show_auth_dialog(view, title, username, password, domain))
+			goto fail;
+	}
+	else if (!*password)
+	{
+		if (!mac_show_auth_dialog(view, title, username, password, domain))
+			goto fail;
+	}
+
+	return TRUE;
+fail:
+	free(*username);
+	free(*domain);
+	free(*password);
+	*username = NULL;
+	*domain = NULL;
+	*password = NULL;
+	return FALSE;
+}
+
+BOOL mac_authenticate_ex(freerdp *instance, char **username, char **password, char **domain,
+                         rdp_auth_reason reason)
+{
+	WINPR_ASSERT(instance);
+	WINPR_ASSERT(username);
+	WINPR_ASSERT(password);
+	WINPR_ASSERT(domain);
+
+	NSString *title;
+	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:
+			break;
+		default:
+			return FALSE;
+	}
+
+	return mac_authenticate_raw(instance, username, password, domain, reason);
+}
+
+DWORD mac_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)
+{
+	mfContext *mfc = (mfContext *)instance->context;
+	MRDPView *view = (MRDPView *)mfc->view;
+	CertificateDialog *dialog = [CertificateDialog new];
+	const char *type = "RDP-Server";
+	char hostname[8192] = { 0 };
+
+	if (flags & VERIFY_CERT_FLAG_GATEWAY)
+		type = "RDP-Gateway";
+
+	if (flags & VERIFY_CERT_FLAG_REDIRECT)
+		type = "RDP-Redirect";
+
+	sprintf_s(hostname, sizeof(hostname), "%s %s:%" PRIu16, type, host, port);
+	dialog.serverHostname = [NSString stringWithCString:hostname encoding:NSUTF8StringEncoding];
+	dialog.commonName = [NSString stringWithCString:common_name encoding:NSUTF8StringEncoding];
+	dialog.subject = [NSString stringWithCString:subject encoding:NSUTF8StringEncoding];
+	dialog.issuer = [NSString stringWithCString:issuer encoding:NSUTF8StringEncoding];
+	dialog.fingerprint = [NSString stringWithCString:fingerprint encoding:NSUTF8StringEncoding];
+
+	if (flags & VERIFY_CERT_FLAG_MISMATCH)
+		dialog.hostMismatch = TRUE;
+
+	if (flags & VERIFY_CERT_FLAG_CHANGED)
+		dialog.changed = TRUE;
+
+	[dialog performSelectorOnMainThread:@selector(runModal:)
+	                         withObject:[view window]
+	                      waitUntilDone:TRUE];
+	return dialog.result;
+}
+
+DWORD mac_verify_changed_certificate_ex(freerdp *instance, const char *host, UINT16 port,
+                                        const char *common_name, const char *subject,
+                                        const char *issuer, const char *fingerprint,
+                                        const char *old_subject, const char *old_issuer,
+                                        const char *old_fingerprint, DWORD flags)
+{
+	mfContext *mfc = (mfContext *)instance->context;
+	MRDPView *view = (MRDPView *)mfc->view;
+	CertificateDialog *dialog = [CertificateDialog new];
+	const char *type = "RDP-Server";
+	char hostname[8192];
+
+	if (flags & VERIFY_CERT_FLAG_GATEWAY)
+		type = "RDP-Gateway";
+
+	if (flags & VERIFY_CERT_FLAG_REDIRECT)
+		type = "RDP-Redirect";
+
+	sprintf_s(hostname, sizeof(hostname), "%s %s:%" PRIu16, type, host, port);
+	dialog.serverHostname = [NSString stringWithCString:hostname encoding:NSUTF8StringEncoding];
+	dialog.commonName = [NSString stringWithCString:common_name encoding:NSUTF8StringEncoding];
+	dialog.subject = [NSString stringWithCString:subject encoding:NSUTF8StringEncoding];
+	dialog.issuer = [NSString stringWithCString:issuer encoding:NSUTF8StringEncoding];
+	dialog.fingerprint = [NSString stringWithCString:fingerprint encoding:NSUTF8StringEncoding];
+
+	if (flags & VERIFY_CERT_FLAG_MISMATCH)
+		dialog.hostMismatch = TRUE;
+
+	if (flags & VERIFY_CERT_FLAG_CHANGED)
+		dialog.changed = TRUE;
+
+	[dialog performSelectorOnMainThread:@selector(runModal:)
+	                         withObject:[view window]
+	                      waitUntilDone:TRUE];
+	return dialog.result;
+}
+
+int mac_logon_error_info(freerdp *instance, UINT32 data, UINT32 type)
+{
+	const char *str_data = freerdp_get_logon_error_info_data(data);
+	const char *str_type = freerdp_get_logon_error_info_type(type);
+	// TODO: Error message dialog
+	WLog_INFO(TAG, "Logon Error Info %s [%s]", str_data, str_type);
+	return 1;
+}
+
+BOOL mf_Pointer_New(rdpContext *context, rdpPointer *pointer)
+{
+	rdpGdi *gdi;
+	NSRect rect;
+	NSImage *image;
+	NSPoint hotSpot;
+	NSCursor *cursor;
+	BYTE *cursor_data;
+	NSMutableArray *ma;
+	NSBitmapImageRep *bmiRep;
+	MRDPCursor *mrdpCursor = [[MRDPCursor alloc] init];
+	mfContext *mfc = (mfContext *)context;
+	MRDPView *view;
+	UINT32 format;
+
+	if (!mfc || !context || !pointer)
+		return FALSE;
+
+	view = (MRDPView *)mfc->view;
+	gdi = context->gdi;
+
+	if (!gdi || !view)
+		return FALSE;
+
+	rect.size.width = pointer->width;
+	rect.size.height = pointer->height;
+	rect.origin.x = pointer->xPos;
+	rect.origin.y = pointer->yPos;
+	cursor_data = (BYTE *)malloc(rect.size.width * rect.size.height * 4);
+
+	if (!cursor_data)
+		return FALSE;
+
+	mrdpCursor->cursor_data = cursor_data;
+	format = PIXEL_FORMAT_RGBA32;
+
+	if (!freerdp_image_copy_from_pointer_data(cursor_data, format, 0, 0, 0, pointer->width,
+	                                          pointer->height, pointer->xorMaskData,
+	                                          pointer->lengthXorMask, pointer->andMaskData,
+	                                          pointer->lengthAndMask, pointer->xorBpp, NULL))
+	{
+		free(cursor_data);
+		mrdpCursor->cursor_data = NULL;
+		return FALSE;
+	}
+
+	/* store cursor bitmap image in representation - required by NSImage */
+	bmiRep = [[NSBitmapImageRep alloc]
+	    initWithBitmapDataPlanes:(unsigned char **)&cursor_data
+	                  pixelsWide:rect.size.width
+	                  pixelsHigh:rect.size.height
+	               bitsPerSample:8
+	             samplesPerPixel:4
+	                    hasAlpha:YES
+	                    isPlanar:NO
+	              colorSpaceName:NSDeviceRGBColorSpace
+	                bitmapFormat:0
+	                 bytesPerRow:rect.size.width * FreeRDPGetBytesPerPixel(format)
+	                bitsPerPixel:0];
+	mrdpCursor->bmiRep = bmiRep;
+	/* create an image using above representation */
+	image = [[NSImage alloc] initWithSize:[bmiRep size]];
+	[image addRepresentation:bmiRep];
+	mrdpCursor->nsImage = image;
+	/* need hotspot to create cursor */
+	hotSpot.x = pointer->xPos;
+	hotSpot.y = pointer->yPos;
+	cursor = [[NSCursor alloc] initWithImage:image hotSpot:hotSpot];
+	mrdpCursor->nsCursor = cursor;
+	mrdpCursor->pointer = pointer;
+	/* save cursor for later use in mf_Pointer_Set() */
+	ma = view->cursors;
+	[ma addObject:mrdpCursor];
+	return TRUE;
+}
+
+void mf_Pointer_Free(rdpContext *context, rdpPointer *pointer)
+{
+	mfContext *mfc = (mfContext *)context;
+	MRDPView *view = (MRDPView *)mfc->view;
+	NSMutableArray *ma = view->cursors;
+
+	for (MRDPCursor *cursor in ma)
+	{
+		if (cursor->pointer == pointer)
+		{
+			cursor->nsImage = nil;
+			cursor->nsCursor = nil;
+			cursor->bmiRep = nil;
+			free(cursor->cursor_data);
+			[ma removeObject:cursor];
+			return;
+		}
+	}
+}
+
+BOOL mf_Pointer_Set(rdpContext *context, rdpPointer *pointer)
+{
+	mfContext *mfc = (mfContext *)context;
+	MRDPView *view = (MRDPView *)mfc->view;
+	NSMutableArray *ma = view->cursors;
+
+	for (MRDPCursor *cursor in ma)
+	{
+		if (cursor->pointer == pointer)
+		{
+			[view setCursor:cursor->nsCursor];
+			return TRUE;
+		}
+	}
+
+	NSLog(@"Cursor not found");
+	return TRUE;
+}
+
+BOOL mf_Pointer_SetNull(rdpContext *context)
+{
+	return TRUE;
+}
+
+BOOL mf_Pointer_SetDefault(rdpContext *context)
+{
+	mfContext *mfc = (mfContext *)context;
+	MRDPView *view = (MRDPView *)mfc->view;
+	[view setCursor:[NSCursor arrowCursor]];
+	return TRUE;
+}
+
+static BOOL mf_Pointer_SetPosition(rdpContext *context, UINT32 x, UINT32 y)
+{
+	mfContext *mfc = (mfContext *)context;
+
+	if (!mfc)
+		return FALSE;
+
+	/* TODO: Set pointer position */
+	return TRUE;
+}
+
+CGContextRef mac_create_bitmap_context(rdpContext *context)
+{
+	CGContextRef bitmap_context;
+	rdpGdi *gdi = context->gdi;
+	UINT32 bpp = FreeRDPGetBytesPerPixel(gdi->dstFormat);
+	CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+
+	if (bpp == 2)
+	{
+		bitmap_context = CGBitmapContextCreate(
+		    gdi->primary_buffer, gdi->width, gdi->height, 5, gdi->stride, colorSpace,
+		    kCGBitmapByteOrder16Little | kCGImageAlphaNoneSkipFirst);
+	}
+	else
+	{
+		bitmap_context = CGBitmapContextCreate(
+		    gdi->primary_buffer, gdi->width, gdi->height, 8, gdi->stride, colorSpace,
+		    kCGBitmapByteOrder32Little | kCGImageAlphaNoneSkipFirst);
+	}
+
+	CGColorSpaceRelease(colorSpace);
+	return bitmap_context;
+}
+
+BOOL mac_begin_paint(rdpContext *context)
+{
+	rdpGdi *gdi = context->gdi;
+
+	if (!gdi)
+		return FALSE;
+
+	gdi->primary->hdc->hwnd->invalid->null = TRUE;
+	return TRUE;
+}
+
+BOOL mac_end_paint(rdpContext *context)
+{
+	rdpGdi *gdi;
+	HGDI_RGN invalid;
+	NSRect newDrawRect;
+	int ww, wh, dw, dh;
+	mfContext *mfc = (mfContext *)context;
+	MRDPView *view = (MRDPView *)mfc->view;
+	gdi = context->gdi;
+
+	if (!gdi)
+		return FALSE;
+
+	ww = mfc->client_width;
+	wh = mfc->client_height;
+	dw = freerdp_settings_get_uint32(mfc->common.context.settings, FreeRDP_DesktopWidth);
+	dh = freerdp_settings_get_uint32(mfc->common.context.settings, FreeRDP_DesktopHeight);
+
+	if ((!context) || (!context->gdi))
+		return FALSE;
+
+	if (context->gdi->primary->hdc->hwnd->invalid->null)
+		return TRUE;
+
+	invalid = gdi->primary->hdc->hwnd->invalid;
+	newDrawRect.origin.x = invalid->x;
+	newDrawRect.origin.y = invalid->y;
+	newDrawRect.size.width = invalid->w;
+	newDrawRect.size.height = invalid->h;
+
+	if (freerdp_settings_get_bool(mfc->common.context.settings, FreeRDP_SmartSizing) &&
+	    (ww != dw || wh != dh))
+	{
+		newDrawRect.origin.y = newDrawRect.origin.y * wh / dh - 1;
+		newDrawRect.size.height = newDrawRect.size.height * wh / dh + 1;
+		newDrawRect.origin.x = newDrawRect.origin.x * ww / dw - 1;
+		newDrawRect.size.width = newDrawRect.size.width * ww / dw + 1;
+	}
+	else
+	{
+		newDrawRect.origin.y = newDrawRect.origin.y - 1;
+		newDrawRect.size.height = newDrawRect.size.height + 1;
+		newDrawRect.origin.x = newDrawRect.origin.x - 1;
+		newDrawRect.size.width = newDrawRect.size.width + 1;
+	}
+
+	windows_to_apple_cords(mfc->view, &newDrawRect);
+	dispatch_sync(dispatch_get_main_queue(), ^{
+		[view setNeedsDisplayInRect:newDrawRect];
+	});
+	gdi->primary->hdc->hwnd->ninvalid = 0;
+	return TRUE;
+}
+
+BOOL mac_desktop_resize(rdpContext *context)
+{
+	ResizeWindowEventArgs e;
+	mfContext *mfc = (mfContext *)context;
+	MRDPView *view = (MRDPView *)mfc->view;
+	rdpSettings *settings = context->settings;
+
+	if (!context->gdi)
+		return TRUE;
+
+	/**
+	 * TODO: Fix resizing race condition. We should probably implement a message to be
+	 * put on the update message queue to be able to properly flush pending updates,
+	 * resize, and then continue with post-resizing graphical updates.
+	 */
+	CGContextRef old_context = view->bitmap_context;
+	view->bitmap_context = NULL;
+	CGContextRelease(old_context);
+	mfc->width = freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
+	mfc->height = freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
+
+	if (!gdi_resize(context->gdi, mfc->width, mfc->height))
+		return FALSE;
+
+	view->bitmap_context = mac_create_bitmap_context(context);
+
+	if (!view->bitmap_context)
+		return FALSE;
+
+	mfc->client_width = mfc->width;
+	mfc->client_height = mfc->height;
+	[view setFrameSize:NSMakeSize(mfc->width, mfc->height)];
+	EventArgsInit(&e, "mfreerdp");
+	e.width = freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
+	e.height = freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
+	PubSub_OnResizeWindow(context->pubSub, context, &e);
+	return TRUE;
+}
+
+void input_activity_cb(freerdp *instance)
+{
+	int status;
+	wMessage message;
+	wMessageQueue *queue;
+	status = 1;
+	queue = freerdp_get_message_queue(instance, FREERDP_INPUT_MESSAGE_QUEUE);
+
+	if (queue)
+	{
+		while (MessageQueue_Peek(queue, &message, TRUE))
+		{
+			status = freerdp_message_queue_process_message(instance, FREERDP_INPUT_MESSAGE_QUEUE,
+			                                               &message);
+
+			if (!status)
+				break;
+		}
+	}
+	else
+	{
+		WLog_ERR(TAG, "input_activity_cb: No queue!");
+	}
+}
+
+/**
+ * given a rect with 0,0 at the top left (windows cords)
+ * convert it to a rect with 0,0 at the bottom left (apple cords)
+ *
+ * Note: the formula works for conversions in both directions.
+ *
+ */
+
+void windows_to_apple_cords(MRDPView *view, NSRect *r)
+{
+	dispatch_sync(dispatch_get_main_queue(), ^{
+		r->origin.y = [view frame].size.height - (r->origin.y + r->size.height);
+	});
+}
+
+@end

local-test-freerdp-delta-01/afc-freerdp/client/Mac/ModuleOptions.cmake

@@ -0,0 +1,3 @@
+set(FREERDP_CLIENT_NAME "mfreerdp")
+set(FREERDP_CLIENT_PLATFORM "MacOSX")
+set(FREERDP_CLIENT_VENDOR "FreeRDP")

local-test-freerdp-delta-01/afc-freerdp/client/Mac/PasswordDialog.h

@@ -0,0 +1,49 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * MacFreeRDP
+ *
+ * Copyright 2013 Christian Hofstaedtler
+ *
+ * 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.
+ */
+
+#import <Cocoa/Cocoa.h>
+
+@interface PasswordDialog : NSWindowController
+{
+  @public
+	NSTextField *usernameText;
+	NSTextField *passwordText;
+	NSTextField *messageLabel;
+	NSString *serverHostname;
+	NSString *username;
+	NSString *password;
+	NSString *domain;
+	BOOL modalCode;
+}
+@property(retain) IBOutlet NSTextField *usernameText;
+@property(retain) IBOutlet NSTextField *passwordText;
+@property(retain) IBOutlet NSTextField *messageLabel;
+
+- (IBAction)onOK:(NSObject *)sender;
+- (IBAction)onCancel:(NSObject *)sender;
+
+@property(retain) NSString *serverHostname;
+@property(retain) NSString *username;
+@property(retain) NSString *password;
+@property(retain) NSString *domain;
+@property(readonly) BOOL modalCode;
+
+- (BOOL)runModal:(NSWindow *)mainWindow;
+
+@end

local-test-freerdp-delta-01/afc-freerdp/client/Mac/PasswordDialog.m

@@ -0,0 +1,140 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * MacFreeRDP
+ *
+ * Copyright 2013 Christian Hofstaedtler
+ *
+ * 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.
+ */
+
+#import "PasswordDialog.h"
+#import <freerdp/client/cmdline.h>
+
+#import <CoreGraphics/CoreGraphics.h>
+
+@interface PasswordDialog ()
+
+@property BOOL modalCode;
+
+@end
+
+@implementation PasswordDialog
+
+@synthesize usernameText;
+@synthesize passwordText;
+@synthesize messageLabel;
+@synthesize serverHostname;
+@synthesize username;
+@synthesize password;
+@synthesize domain;
+@synthesize modalCode;
+
+- (id)init
+{
+	return [self initWithWindowNibName:@"PasswordDialog"];
+}
+
+- (void)windowDidLoad
+{
+	[super windowDidLoad];
+	// Implement this method to handle any initialization after your window controller's window has
+	// been loaded from its nib file.
+	[self.window setTitle:self.serverHostname];
+	[self.messageLabel
+	    setStringValue:[NSString stringWithFormat:@"Authenticate to %@", self.serverHostname]];
+	NSMutableString *domainUser = [[NSMutableString alloc] initWithString:@""];
+
+	if (self.domain != nil &&
+	    [[self.domain stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet]]
+	        length] > 0)
+	{
+		[domainUser appendFormat:@"%@\\", self.domain];
+	}
+
+	if (self.username != nil)
+	{
+		[domainUser appendString:self.username];
+		[self.window makeFirstResponder:self.passwordText];
+	}
+
+	[self.usernameText setStringValue:domainUser];
+}
+
+- (IBAction)onOK:(NSObject *)sender
+{
+	char *submittedUser = NULL;
+	char *submittedDomain = NULL;
+
+	if (freerdp_parse_username(
+	        [self.usernameText.stringValue cStringUsingEncoding:NSUTF8StringEncoding],
+	        &submittedUser, &submittedDomain))
+	{
+		if (submittedUser)
+			self.username = [NSString stringWithCString:submittedUser
+			                                   encoding:NSUTF8StringEncoding];
+		if (submittedDomain)
+			self.domain = [NSString stringWithCString:submittedDomain
+			                                 encoding:NSUTF8StringEncoding];
+	}
+	else
+	{
+		self.username = self.usernameText.stringValue;
+	}
+
+	self.password = self.passwordText.stringValue;
+	free(submittedUser);
+	free(submittedDomain);
+	[NSApp stopModalWithCode:TRUE];
+}
+
+- (IBAction)onCancel:(NSObject *)sender
+{
+	[NSApp stopModalWithCode:FALSE];
+}
+
+- (BOOL)runModal:(NSWindow *)mainWindow
+{
+	if ([mainWindow respondsToSelector:@selector(beginSheet:completionHandler:)])
+	{
+		[mainWindow beginSheet:self.window completionHandler:nil];
+		self.modalCode = [NSApp runModalForWindow:self.window];
+		[mainWindow endSheet:self.window];
+	}
+	else
+	{
+		[NSApp beginSheet:self.window
+		    modalForWindow:mainWindow
+		     modalDelegate:nil
+		    didEndSelector:nil
+		       contextInfo:nil];
+		self.modalCode = [NSApp runModalForWindow:self.window];
+		[NSApp endSheet:self.window];
+	}
+
+	[self.window orderOut:nil];
+	return self.modalCode;
+}
+
+- (void)dealloc
+{
+	[usernameText release];
+	[passwordText release];
+	[messageLabel release];
+	[serverHostname release];
+	[username release];
+	[password release];
+	[domain release];
+	[super dealloc];
+}
+
+@end

local-test-freerdp-delta-01/afc-freerdp/client/Mac/PasswordDialog.xib

@@ -0,0 +1,132 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<document type="com.apple.InterfaceBuilder3.Cocoa.XIB" version="3.0" toolsVersion="11201" systemVersion="16A323" targetRuntime="MacOSX.Cocoa" propertyAccessControl="none" useAutolayout="YES">
+    <dependencies>
+        <plugIn identifier="com.apple.InterfaceBuilder.CocoaPlugin" version="11201"/>
+    </dependencies>
+    <objects>
+        <customObject id="-2" userLabel="File's Owner" customClass="PasswordDialog">
+            <connections>
+                <outlet property="messageLabel" destination="7" id="50"/>
+                <outlet property="passwordText" destination="6" id="48"/>
+                <outlet property="usernameText" destination="11" id="49"/>
+                <outlet property="window" destination="1" id="3"/>
+            </connections>
+        </customObject>
+        <customObject id="-1" userLabel="First Responder" customClass="FirstResponder"/>
+        <customObject id="-3" userLabel="Application"/>
+        <window title="Window" allowsToolTipsWhenApplicationIsInactive="NO" autorecalculatesKeyViewLoop="NO" oneShot="NO" visibleAtLaunch="NO" animationBehavior="default" id="1">
+            <windowStyleMask key="styleMask" titled="YES" texturedBackground="YES"/>
+            <windowPositionMask key="initialPositionMask" leftStrut="YES" rightStrut="YES" topStrut="YES" bottomStrut="YES"/>
+            <rect key="contentRect" x="196" y="240" width="480" height="270"/>
+            <rect key="screenRect" x="0.0" y="0.0" width="1440" height="877"/>
+            <view key="contentView" id="2">
+                <rect key="frame" x="0.0" y="0.0" width="480" height="270"/>
+                <autoresizingMask key="autoresizingMask"/>
+                <subviews>
+                    <textField verticalHuggingPriority="750" translatesAutoresizingMaskIntoConstraints="NO" id="5">
+                        <rect key="frame" x="47" y="127" width="106" height="17"/>
+                        <textFieldCell key="cell" scrollable="YES" lineBreakMode="clipping" sendsActionOnEndEditing="YES" title="Password:" id="22">
+                            <font key="font" metaFont="system"/>
+                            <color key="textColor" name="controlTextColor" catalog="System" colorSpace="catalog"/>
+                            <color key="backgroundColor" name="controlColor" catalog="System" colorSpace="catalog"/>
+                        </textFieldCell>
+                    </textField>
+                    <secureTextField verticalHuggingPriority="750" translatesAutoresizingMaskIntoConstraints="NO" id="6">
+                        <rect key="frame" x="159" y="124" width="233" height="22"/>
+                        <secureTextFieldCell key="cell" scrollable="YES" lineBreakMode="clipping" selectable="YES" editable="YES" sendsActionOnEndEditing="YES" borderStyle="bezel" placeholderString="Password" drawsBackground="YES" usesSingleLineMode="YES" id="21">
+                            <font key="font" metaFont="system"/>
+                            <color key="textColor" name="textColor" catalog="System" colorSpace="catalog"/>
+                            <color key="backgroundColor" name="textBackgroundColor" catalog="System" colorSpace="catalog"/>
+                            <allowedInputSourceLocales>
+                                <string>NSAllRomanInputSourcesLocaleIdentifier</string>
+                            </allowedInputSourceLocales>
+                        </secureTextFieldCell>
+                    </secureTextField>
+                    <textField verticalHuggingPriority="750" translatesAutoresizingMaskIntoConstraints="NO" id="7">
+                        <rect key="frame" x="47" y="206" width="344" height="17"/>
+                        <constraints>
+                            <constraint firstAttribute="width" constant="340" id="19"/>
+                        </constraints>
+                        <textFieldCell key="cell" scrollable="YES" lineBreakMode="clipping" sendsActionOnEndEditing="YES" title="Connect to SERVER_NAME" placeholderString="" id="20">
+                            <font key="font" metaFont="system"/>
+                            <color key="textColor" name="controlTextColor" catalog="System" colorSpace="catalog"/>
+                            <color key="backgroundColor" name="controlColor" catalog="System" colorSpace="catalog"/>
+                        </textFieldCell>
+                    </textField>
+                    <button verticalHuggingPriority="750" translatesAutoresizingMaskIntoConstraints="NO" id="8">
+                        <rect key="frame" x="384" y="13" width="82" height="32"/>
+                        <buttonCell key="cell" type="push" title="Cancel" bezelStyle="rounded" alignment="center" borderStyle="border" imageScaling="proportionallyDown" inset="2" id="18">
+                            <behavior key="behavior" pushIn="YES" lightByBackground="YES" lightByGray="YES"/>
+                            <font key="font" metaFont="system"/>
+                            <string key="keyEquivalent" base64-UTF8="YES">
+Gw
+</string>
+                        </buttonCell>
+                        <connections>
+                            <action selector="onCancel:" target="-2" id="52"/>
+                        </connections>
+                    </button>
+                    <button verticalHuggingPriority="750" translatesAutoresizingMaskIntoConstraints="NO" id="9">
+                        <rect key="frame" x="302" y="13" width="82" height="32"/>
+                        <constraints>
+                            <constraint firstAttribute="width" constant="70" id="16"/>
+                        </constraints>
+                        <buttonCell key="cell" type="push" title="OK" bezelStyle="rounded" alignment="center" borderStyle="border" imageScaling="proportionallyDown" inset="2" id="17">
+                            <behavior key="behavior" pushIn="YES" lightByBackground="YES" lightByGray="YES"/>
+                            <font key="font" metaFont="system"/>
+                            <string key="keyEquivalent" base64-UTF8="YES">
+DQ
+</string>
+                        </buttonCell>
+                        <connections>
+                            <action selector="onOK:" target="-2" id="51"/>
+                        </connections>
+                    </button>
+                    <textField verticalHuggingPriority="750" translatesAutoresizingMaskIntoConstraints="NO" id="10">
+                        <rect key="frame" x="47" y="159" width="106" height="17"/>
+                        <constraints>
+                            <constraint firstAttribute="width" constant="102" id="14"/>
+                        </constraints>
+                        <textFieldCell key="cell" scrollable="YES" lineBreakMode="clipping" sendsActionOnEndEditing="YES" title="Username:" id="15">
+                            <font key="font" metaFont="system"/>
+                            <color key="textColor" name="controlTextColor" catalog="System" colorSpace="catalog"/>
+                            <color key="backgroundColor" name="controlColor" catalog="System" colorSpace="catalog"/>
+                        </textFieldCell>
+                    </textField>
+                    <textField verticalHuggingPriority="750" translatesAutoresizingMaskIntoConstraints="NO" id="11">
+                        <rect key="frame" x="159" y="156" width="233" height="22"/>
+                        <constraints>
+                            <constraint firstAttribute="width" constant="233" id="12"/>
+                        </constraints>
+                        <textFieldCell key="cell" scrollable="YES" lineBreakMode="clipping" selectable="YES" editable="YES" sendsActionOnEndEditing="YES" state="on" borderStyle="bezel" placeholderString="username@domain" drawsBackground="YES" id="13">
+                            <font key="font" metaFont="system"/>
+                            <color key="textColor" name="textColor" catalog="System" colorSpace="catalog"/>
+                            <color key="backgroundColor" name="textBackgroundColor" catalog="System" colorSpace="catalog"/>
+                        </textFieldCell>
+                    </textField>
+                </subviews>
+                <constraints>
+                    <constraint firstItem="6" firstAttribute="leading" secondItem="11" secondAttribute="leading" id="25"/>
+                    <constraint firstItem="5" firstAttribute="centerY" secondItem="6" secondAttribute="centerY" id="27"/>
+                    <constraint firstItem="6" firstAttribute="leading" secondItem="5" secondAttribute="trailing" constant="8" symbolic="YES" id="28"/>
+                    <constraint firstItem="6" firstAttribute="trailing" secondItem="11" secondAttribute="trailing" id="30"/>
+                    <constraint firstItem="11" firstAttribute="leading" secondItem="10" secondAttribute="trailing" constant="8" symbolic="YES" id="31"/>
+                    <constraint firstItem="8" firstAttribute="leading" secondItem="9" secondAttribute="trailing" constant="12" symbolic="YES" id="32"/>
+                    <constraint firstItem="10" firstAttribute="leading" secondItem="5" secondAttribute="leading" id="34"/>
+                    <constraint firstItem="10" firstAttribute="leading" secondItem="7" secondAttribute="leading" id="37"/>
+                    <constraint firstAttribute="bottom" secondItem="9" secondAttribute="bottom" constant="20" symbolic="YES" id="39"/>
+                    <constraint firstItem="5" firstAttribute="centerY" secondItem="2" secondAttribute="centerY" id="41"/>
+                    <constraint firstAttribute="bottom" secondItem="8" secondAttribute="bottom" constant="20" symbolic="YES" id="42"/>
+                    <constraint firstAttribute="trailing" secondItem="8" secondAttribute="trailing" constant="20" symbolic="YES" id="43"/>
+                    <constraint firstItem="7" firstAttribute="leading" secondItem="2" secondAttribute="leading" constant="49" id="44"/>
+                    <constraint firstItem="7" firstAttribute="top" secondItem="2" secondAttribute="top" constant="47" id="45"/>
+                    <constraint firstItem="6" firstAttribute="top" secondItem="11" secondAttribute="bottom" constant="10" symbolic="YES" id="46"/>
+                    <constraint firstItem="10" firstAttribute="baseline" secondItem="11" secondAttribute="baseline" id="47"/>
+                </constraints>
+            </view>
+            <connections>
+                <outlet property="delegate" destination="-2" id="4"/>
+            </connections>
+        </window>
+    </objects>
+</document>

local-test-freerdp-delta-01/afc-freerdp/client/Mac/main.m

@@ -0,0 +1,25 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * MacFreeRDP
+ *
+ * Copyright 2012 Thomas Goddard
+ *
+ * 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.
+ */
+
+#import <Cocoa/Cocoa.h>
+
+int main(int argc, char *argv[])
+{
+	return NSApplicationMain(argc, argv);
+}

local-test-freerdp-delta-01/afc-freerdp/client/Mac/mf_client.h

@@ -0,0 +1,46 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Windows Client
+ *
+ * Copyright 2009-2011 Jay Sorg
+ * Copyright 2010-2011 Vic Lee
+ * Copyright 2010-2011 Marc-Andre Moreau <[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.
+ */
+
+#ifndef FREERDP_CLIENT_MAC_CLIENT_H
+#define FREERDP_CLIENT_MAC_CLIENT_H
+
+#include <freerdp/client.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+	FREERDP_API void mf_press_mouse_button(void* context, int button, int x, int y, BOOL down);
+	FREERDP_API void mf_scale_mouse_event(void* context, UINT16 flags, UINT16 x, UINT16 y);
+	FREERDP_API void mf_scale_mouse_event_ex(void* context, UINT16 flags, UINT16 x, UINT16 y);
+
+	/**
+	 * Client Interface
+	 */
+
+	FREERDP_API int RdpClientEntry(RDP_CLIENT_ENTRY_POINTS* pEntryPoints);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREERDP_CLIENT_MAC_CLIENT_H */

local-test-freerdp-delta-01/afc-freerdp/client/Mac/mf_client.m

@@ -0,0 +1,220 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * X11 Client Interface
+ *
+ * Copyright 2013 Marc-Andre Moreau <[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 <freerdp/config.h>
+
+#include "mfreerdp.h"
+
+#include <winpr/assert.h>
+
+#include <freerdp/constants.h>
+#include <freerdp/utils/signal.h>
+#include <freerdp/client/cmdline.h>
+
+#include "MRDPView.h"
+
+/**
+ * Client Interface
+ */
+
+static BOOL mfreerdp_client_global_init(void)
+{
+	freerdp_handle_signals();
+	return TRUE;
+}
+
+static void mfreerdp_client_global_uninit(void)
+{
+}
+
+static int mfreerdp_client_start(rdpContext *context)
+{
+	MRDPView *view;
+	mfContext *mfc = (mfContext *)context;
+
+	if (mfc->view == NULL)
+	{
+		// view not specified beforehand. Create view dynamically
+		mfc->view = [[MRDPView alloc]
+		    initWithFrame:NSMakeRect(
+		                      0, 0,
+		                      freerdp_settings_get_uint32(context->settings, FreeRDP_DesktopWidth),
+		                      freerdp_settings_get_uint32(context->settings,
+		                                                  FreeRDP_DesktopHeight))];
+		mfc->view_ownership = TRUE;
+	}
+
+	view = (MRDPView *)mfc->view;
+	return [view rdpStart:context];
+}
+
+static int mfreerdp_client_stop(rdpContext *context)
+{
+	mfContext *mfc = (mfContext *)context;
+
+	freerdp_client_common_stop(context);
+
+	if (mfc->view_ownership)
+	{
+		MRDPView *view = (MRDPView *)mfc->view;
+		[view releaseResources];
+		[view release];
+		mfc->view = nil;
+	}
+
+	return 0;
+}
+
+static BOOL mfreerdp_client_new(freerdp *instance, rdpContext *context)
+{
+	mfContext *mfc;
+
+	WINPR_ASSERT(instance);
+
+	mfc = (mfContext *)instance->context;
+	WINPR_ASSERT(mfc);
+
+	mfc->stopEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+	if (!mfc->stopEvent)
+		return FALSE;
+	context->instance->PreConnect = mac_pre_connect;
+	context->instance->PostConnect = mac_post_connect;
+	context->instance->PostDisconnect = mac_post_disconnect;
+	context->instance->AuthenticateEx = mac_authenticate_ex;
+	context->instance->VerifyCertificateEx = mac_verify_certificate_ex;
+	context->instance->VerifyChangedCertificateEx = mac_verify_changed_certificate_ex;
+	context->instance->LogonErrorInfo = mac_logon_error_info;
+	return TRUE;
+}
+
+static void mfreerdp_client_free(freerdp *instance, rdpContext *context)
+{
+	mfContext *mfc;
+
+	if (!instance || !context)
+		return;
+
+	mfc = (mfContext *)instance->context;
+	(void)CloseHandle(mfc->stopEvent);
+}
+
+static void mf_scale_mouse_coordinates(mfContext *mfc, UINT16 *px, UINT16 *py)
+{
+	UINT16 x = *px;
+	UINT16 y = *py;
+	UINT32 ww = mfc->client_width;
+	UINT32 wh = mfc->client_height;
+	UINT32 dw = freerdp_settings_get_uint32(mfc->common.context.settings, FreeRDP_DesktopWidth);
+	UINT32 dh = freerdp_settings_get_uint32(mfc->common.context.settings, FreeRDP_DesktopHeight);
+
+	if (!freerdp_settings_get_bool(mfc->common.context.settings, FreeRDP_SmartSizing) ||
+	    ((ww == dw) && (wh == dh)))
+	{
+		y = y + mfc->yCurrentScroll;
+		x = x + mfc->xCurrentScroll;
+
+		y -= (dh - wh);
+		x -= (dw - ww);
+	}
+	else
+	{
+		y = y * dh / wh + mfc->yCurrentScroll;
+		x = x * dw / ww + mfc->xCurrentScroll;
+	}
+
+	*px = x;
+	*py = y;
+}
+
+void mf_scale_mouse_event(void *context, UINT16 flags, UINT16 x, UINT16 y)
+{
+	mfContext *mfc = (mfContext *)context;
+	MRDPView *view = (MRDPView *)mfc->view;
+	// Convert to windows coordinates
+	y = [view frame].size.height - y;
+
+	if ((flags & (PTR_FLAGS_WHEEL | PTR_FLAGS_HWHEEL)) == 0)
+		mf_scale_mouse_coordinates(mfc, &x, &y);
+	freerdp_client_send_button_event(&mfc->common, FALSE, flags, x, y);
+}
+
+void mf_scale_mouse_event_ex(void *context, UINT16 flags, UINT16 x, UINT16 y)
+{
+	mfContext *mfc = (mfContext *)context;
+	MRDPView *view = (MRDPView *)mfc->view;
+	// Convert to windows coordinates
+	y = [view frame].size.height - y;
+
+	mf_scale_mouse_coordinates(mfc, &x, &y);
+	freerdp_client_send_extended_button_event(&mfc->common, FALSE, flags, x, y);
+}
+
+void mf_press_mouse_button(void *context, int button, int x, int y, BOOL down)
+{
+	UINT16 flags = 0;
+	UINT16 xflags = 0;
+
+	if (down)
+	{
+		flags |= PTR_FLAGS_DOWN;
+		xflags |= PTR_XFLAGS_DOWN;
+	}
+
+	switch (button)
+	{
+		case 0:
+			mf_scale_mouse_event(context, flags | PTR_FLAGS_BUTTON1, x, y);
+			break;
+
+		case 1:
+			mf_scale_mouse_event(context, flags | PTR_FLAGS_BUTTON2, x, y);
+			break;
+
+		case 2:
+			mf_scale_mouse_event(context, flags | PTR_FLAGS_BUTTON3, x, y);
+			break;
+
+		case 3:
+			mf_scale_mouse_event_ex(context, xflags | PTR_XFLAGS_BUTTON1, x, y);
+			break;
+
+		case 4:
+			mf_scale_mouse_event_ex(context, xflags | PTR_XFLAGS_BUTTON2, x, y);
+			break;
+
+		default:
+			break;
+	}
+}
+
+int RdpClientEntry(RDP_CLIENT_ENTRY_POINTS *pEntryPoints)
+{
+	WINPR_ASSERT(pEntryPoints);
+
+	pEntryPoints->Version = 1;
+	pEntryPoints->Size = sizeof(RDP_CLIENT_ENTRY_POINTS_V1);
+	pEntryPoints->GlobalInit = mfreerdp_client_global_init;
+	pEntryPoints->GlobalUninit = mfreerdp_client_global_uninit;
+	pEntryPoints->ContextSize = sizeof(mfContext);
+	pEntryPoints->ClientNew = mfreerdp_client_new;
+	pEntryPoints->ClientFree = mfreerdp_client_free;
+	pEntryPoints->ClientStart = mfreerdp_client_start;
+	pEntryPoints->ClientStop = mfreerdp_client_stop;
+	return 0;
+}

local-test-freerdp-delta-01/afc-freerdp/client/Mac/mfreerdp.h

@@ -0,0 +1,86 @@
+#ifndef FREERDP_CLIENT_MAC_FREERDP_H
+#define FREERDP_CLIENT_MAC_FREERDP_H
+
+#include <freerdp/freerdp.h>
+#include <freerdp/client/file.h>
+#include <freerdp/api.h>
+#include <freerdp/freerdp.h>
+
+#include <freerdp/gdi/gdi.h>
+#include <freerdp/gdi/dc.h>
+#include <freerdp/gdi/gfx.h>
+#include <freerdp/gdi/region.h>
+#include <freerdp/channels/channels.h>
+
+#include <freerdp/client/channels.h>
+#include <freerdp/client/rdpei.h>
+#include <freerdp/client/rdpgfx.h>
+#include <freerdp/client/cliprdr.h>
+#include <freerdp/client/encomsp.h>
+
+#include <winpr/crt.h>
+#include <winpr/synch.h>
+#include <winpr/thread.h>
+#include <winpr/clipboard.h>
+
+#include "Keyboard.h"
+#include <CoreGraphics/CoreGraphics.h>
+
+typedef struct
+{
+	rdpClientContext common;
+
+	void* view;
+	BOOL view_ownership;
+
+	int width;
+	int height;
+	int offset_x;
+	int offset_y;
+	int fs_toggle;
+	int fullscreen;
+	int percentscreen;
+	char window_title[64];
+	int client_x;
+	int client_y;
+	int client_width;
+	int client_height;
+
+	HANDLE stopEvent;
+	HANDLE keyboardThread;
+	enum APPLE_KEYBOARD_TYPE appleKeyboardType;
+
+	DWORD mainThreadId;
+	DWORD keyboardThreadId;
+
+	BOOL clipboardSync;
+	wClipboard* clipboard;
+	UINT32 numServerFormats;
+	UINT32 requestedFormatId;
+	HANDLE clipboardRequestEvent;
+	CLIPRDR_FORMAT* serverFormats;
+	CliprdrClientContext* cliprdr;
+	UINT32 clipboardCapabilities;
+
+	rdpFile* connectionRdpFile;
+
+	// Keep track of window size and position, disable when in fullscreen mode.
+	BOOL disablewindowtracking;
+
+	// These variables are required for horizontal scrolling.
+	BOOL updating_scrollbars;
+	BOOL xScrollVisible;
+	int xMinScroll;     // minimum horizontal scroll value
+	int xCurrentScroll; // current horizontal scroll value
+	int xMaxScroll;     // maximum horizontal scroll value
+
+	// These variables are required for vertical scrolling.
+	BOOL yScrollVisible;
+	int yMinScroll;     // minimum vertical scroll value
+	int yCurrentScroll; // current vertical scroll value
+	int yMaxScroll;     // maximum vertical scroll value
+
+	CGEventFlags kbdFlags;
+} mfContext;
+
+#endif /* FREERDP_CLIENT_MAC_FREERDP_H */

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

@@ -0,0 +1,394 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * X11 Monitor Handling
+ *
+ * Copyright 2011 Marc-Andre Moreau <[email protected]>
+ * Copyright 2017 David Fort <[email protected]>
+ * Copyright 2018 Kai Harms <[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 <freerdp/config.h>
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <algorithm>
+
+#include <SDL.h>
+
+#include <winpr/assert.h>
+#include <winpr/crt.h>
+
+#include <freerdp/log.h>
+
+#define TAG CLIENT_TAG("sdl")
+
+#include "sdl_monitor.hpp"
+#include "sdl_freerdp.hpp"
+
+using MONITOR_INFO = struct
+{
+	RECTANGLE_16 area;
+	RECTANGLE_16 workarea;
+	BOOL primary;
+};
+
+using VIRTUAL_SCREEN = struct
+{
+	int nmonitors;
+	RECTANGLE_16 area;
+	RECTANGLE_16 workarea;
+	MONITOR_INFO* monitors;
+};
+
+/* See MSDN Section on Multiple Display Monitors: http://msdn.microsoft.com/en-us/library/dd145071
+ */
+
+int sdl_list_monitors(SdlContext* sdl)
+{
+	SDL_Init(SDL_INIT_VIDEO);
+	const int nmonitors = SDL_GetNumVideoDisplays();
+
+	printf("listing %d monitors:\n", nmonitors);
+	for (int i = 0; i < nmonitors; i++)
+	{
+		SDL_Rect rect = {};
+		const int brc = SDL_GetDisplayBounds(i, &rect);
+		const char* name = SDL_GetDisplayName(i);
+
+		if (brc != 0)
+			continue;
+		printf("     %s [%d] [%s] %dx%d\t+%d+%d\n", (i == 0) ? "*" : " ", i, name, rect.w, rect.h,
+		       rect.x, rect.y);
+	}
+
+	SDL_Quit();
+	return 0;
+}
+
+static BOOL sdl_apply_max_size(SdlContext* sdl, UINT32* pMaxWidth, UINT32* pMaxHeight)
+{
+	WINPR_ASSERT(sdl);
+	WINPR_ASSERT(pMaxWidth);
+	WINPR_ASSERT(pMaxHeight);
+
+	auto settings = sdl->context()->settings;
+	WINPR_ASSERT(settings);
+
+	*pMaxWidth = 0;
+	*pMaxHeight = 0;
+
+	for (size_t x = 0; x < freerdp_settings_get_uint32(settings, FreeRDP_MonitorCount); x++)
+	{
+		auto monitor = static_cast<const rdpMonitor*>(
+		    freerdp_settings_get_pointer_array(settings, FreeRDP_MonitorDefArray, x));
+
+		if (freerdp_settings_get_bool(settings, FreeRDP_Fullscreen))
+		{
+			*pMaxWidth = WINPR_ASSERTING_INT_CAST(uint32_t, monitor->width);
+			*pMaxHeight = WINPR_ASSERTING_INT_CAST(uint32_t, monitor->height);
+		}
+		else if (freerdp_settings_get_bool(settings, FreeRDP_Workarea))
+		{
+			SDL_Rect rect = {};
+			SDL_GetDisplayUsableBounds(WINPR_ASSERTING_INT_CAST(int, monitor->orig_screen), &rect);
+			*pMaxWidth = WINPR_ASSERTING_INT_CAST(uint32_t, rect.w);
+			*pMaxHeight = WINPR_ASSERTING_INT_CAST(uint32_t, rect.h);
+		}
+		else if (freerdp_settings_get_uint32(settings, FreeRDP_PercentScreen) > 0)
+		{
+			SDL_Rect rect = {};
+			SDL_GetDisplayUsableBounds(WINPR_ASSERTING_INT_CAST(int, monitor->orig_screen), &rect);
+
+			*pMaxWidth = WINPR_ASSERTING_INT_CAST(uint32_t, rect.w);
+			*pMaxHeight = WINPR_ASSERTING_INT_CAST(uint32_t, rect.h);
+
+			if (freerdp_settings_get_bool(settings, FreeRDP_PercentScreenUseWidth))
+				*pMaxWidth = (WINPR_ASSERTING_INT_CAST(uint32_t, rect.w) *
+				              freerdp_settings_get_uint32(settings, FreeRDP_PercentScreen)) /
+				             100;
+
+			if (freerdp_settings_get_bool(settings, FreeRDP_PercentScreenUseHeight))
+				*pMaxHeight = (WINPR_ASSERTING_INT_CAST(uint32_t, rect.h) *
+				               freerdp_settings_get_uint32(settings, FreeRDP_PercentScreen)) /
+				              100;
+		}
+		else if (freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth) &&
+		         freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight))
+		{
+			*pMaxWidth = freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
+			*pMaxHeight = freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
+		}
+	}
+	return TRUE;
+}
+
+#if SDL_VERSION_ATLEAST(2, 0, 10)
+static UINT32 sdl_orientaion_to_rdp(SDL_DisplayOrientation orientation)
+{
+	switch (orientation)
+	{
+		case SDL_ORIENTATION_LANDSCAPE:
+			return ORIENTATION_LANDSCAPE;
+		case SDL_ORIENTATION_LANDSCAPE_FLIPPED:
+			return ORIENTATION_LANDSCAPE_FLIPPED;
+		case SDL_ORIENTATION_PORTRAIT_FLIPPED:
+			return ORIENTATION_PORTRAIT_FLIPPED;
+		case SDL_ORIENTATION_PORTRAIT:
+		default:
+			return ORIENTATION_PORTRAIT;
+	}
+}
+#endif
+
+static Uint32 scale(Uint32 val, float scale)
+{
+	const auto dval = static_cast<float>(val);
+	const auto sval = dval / scale;
+	return static_cast<Uint32>(sval);
+}
+
+static BOOL sdl_apply_display_properties(SdlContext* sdl)
+{
+	WINPR_ASSERT(sdl);
+
+	rdpSettings* settings = sdl->context()->settings;
+	WINPR_ASSERT(settings);
+
+	if (!freerdp_settings_get_bool(settings, FreeRDP_Fullscreen) &&
+	    !freerdp_settings_get_bool(settings, FreeRDP_UseMultimon))
+		return TRUE;
+
+	const UINT32 numIds = freerdp_settings_get_uint32(settings, FreeRDP_NumMonitorIds);
+	std::vector<rdpMonitor> monitors;
+
+	for (UINT32 x = 0; x < numIds; x++)
+	{
+		auto id = static_cast<const int*>(
+		    freerdp_settings_get_pointer_array(settings, FreeRDP_MonitorIds, x));
+		WINPR_ASSERT(id);
+
+		float ddpi = 1.0f;
+		float hdpi = 1.0f;
+		float vdpi = 1.0f;
+		SDL_Rect rect = {};
+
+		if (SDL_GetDisplayBounds(*id, &rect) < 0)
+			return FALSE;
+
+		if (SDL_GetDisplayDPI(*id, &ddpi, &hdpi, &vdpi) < 0)
+			return FALSE;
+
+		WINPR_ASSERT(rect.w > 0);
+		WINPR_ASSERT(rect.h > 0);
+		WINPR_ASSERT(ddpi > 0);
+		WINPR_ASSERT(hdpi > 0);
+		WINPR_ASSERT(vdpi > 0);
+
+		bool highDpi = hdpi > 100;
+
+		if (highDpi)
+		{
+			// HighDPI is problematic with SDL: We can only get native resolution by creating a
+			// window. Work around this by checking the supported resolutions (and keep maximum)
+			// Also scale the DPI
+			const SDL_Rect scaleRect = rect;
+			for (int i = 0; i < SDL_GetNumDisplayModes(*id); i++)
+			{
+				SDL_DisplayMode mode = {};
+				SDL_GetDisplayMode(WINPR_ASSERTING_INT_CAST(int, x), i, &mode);
+
+				if (mode.w > rect.w)
+				{
+					rect.w = mode.w;
+					rect.h = mode.h;
+				}
+				else if (mode.w == rect.w)
+				{
+					if (mode.h > rect.h)
+					{
+						rect.w = mode.w;
+						rect.h = mode.h;
+					}
+				}
+			}
+
+			const float dw = 1.0f * static_cast<float>(rect.w) / static_cast<float>(scaleRect.w);
+			const float dh = 1.0f * static_cast<float>(rect.h) / static_cast<float>(scaleRect.h);
+			hdpi /= dw;
+			vdpi /= dh;
+		}
+
+#if SDL_VERSION_ATLEAST(2, 0, 10)
+		const SDL_DisplayOrientation orientation = SDL_GetDisplayOrientation(*id);
+		const UINT32 rdp_orientation = sdl_orientaion_to_rdp(orientation);
+#else
+		const UINT32 rdp_orientation = ORIENTATION_LANDSCAPE;
+#endif
+
+		rdpMonitor monitor = {};
+
+		/* windows uses 96 dpi as 'default' and the scale factors are in percent. */
+		const auto factor = ddpi / 96.0f * 100.0f;
+		monitor.orig_screen = x;
+		monitor.x = rect.x;
+		monitor.y = rect.y;
+		monitor.width = rect.w;
+		monitor.height = rect.h;
+		monitor.is_primary = x == 0;
+		monitor.attributes.desktopScaleFactor = static_cast<UINT32>(factor);
+		monitor.attributes.deviceScaleFactor = 100;
+		monitor.attributes.orientation = rdp_orientation;
+		monitor.attributes.physicalWidth = scale(WINPR_ASSERTING_INT_CAST(uint32_t, rect.w), hdpi);
+		monitor.attributes.physicalHeight = scale(WINPR_ASSERTING_INT_CAST(uint32_t, rect.h), vdpi);
+		monitors.emplace_back(monitor);
+	}
+	return freerdp_settings_set_monitor_def_array_sorted(settings, monitors.data(),
+	                                                     monitors.size());
+}
+
+static BOOL sdl_detect_single_window(SdlContext* sdl, UINT32* pMaxWidth, UINT32* pMaxHeight)
+{
+	WINPR_ASSERT(sdl);
+	WINPR_ASSERT(pMaxWidth);
+	WINPR_ASSERT(pMaxHeight);
+
+	rdpSettings* settings = sdl->context()->settings;
+	WINPR_ASSERT(settings);
+
+	if ((!freerdp_settings_get_bool(settings, FreeRDP_UseMultimon) &&
+	     !freerdp_settings_get_bool(settings, FreeRDP_SpanMonitors)) ||
+	    (freerdp_settings_get_bool(settings, FreeRDP_Workarea) &&
+	     !freerdp_settings_get_bool(settings, FreeRDP_RemoteApplicationMode)))
+	{
+		/* If no monitors were specified on the command-line then set the current monitor as active
+		 */
+		if (freerdp_settings_get_uint32(settings, FreeRDP_NumMonitorIds) == 0)
+		{
+			const size_t id = (!sdl->windows.empty())
+			                      ? WINPR_ASSERTING_INT_CAST(
+			                            uint32_t, sdl->windows.begin()->second.displayIndex())
+			                      : 0;
+			if (!freerdp_settings_set_pointer_len(settings, FreeRDP_MonitorIds, &id, 1))
+				return FALSE;
+		}
+		else
+		{
+
+			/* Always sets number of monitors from command-line to just 1.
+			 * If the monitor is invalid then we will default back to current monitor
+			 * later as a fallback. So, there is no need to validate command-line entry here.
+			 */
+			if (!freerdp_settings_set_uint32(settings, FreeRDP_NumMonitorIds, 1))
+				return FALSE;
+		}
+
+		// TODO: Fill monitor struct
+		if (!sdl_apply_display_properties(sdl))
+			return FALSE;
+		return sdl_apply_max_size(sdl, pMaxWidth, pMaxHeight);
+	}
+	return TRUE;
+}
+
+BOOL sdl_detect_monitors(SdlContext* sdl, UINT32* pMaxWidth, UINT32* pMaxHeight)
+{
+	WINPR_ASSERT(sdl);
+	WINPR_ASSERT(pMaxWidth);
+	WINPR_ASSERT(pMaxHeight);
+
+	rdpSettings* settings = sdl->context()->settings;
+	WINPR_ASSERT(settings);
+
+	const int numDisplays = SDL_GetNumVideoDisplays();
+	auto nr = freerdp_settings_get_uint32(settings, FreeRDP_NumMonitorIds);
+	if (numDisplays < 0)
+		return FALSE;
+
+	if (nr == 0)
+	{
+		if (!freerdp_settings_set_pointer_len(settings, FreeRDP_MonitorIds, nullptr,
+		                                      static_cast<size_t>(numDisplays)))
+			return FALSE;
+		for (size_t x = 0; x < static_cast<size_t>(numDisplays); x++)
+		{
+			if (!freerdp_settings_set_pointer_array(settings, FreeRDP_MonitorIds, x, &x))
+				return FALSE;
+		}
+	}
+	else
+	{
+
+		/* There were more IDs supplied than there are monitors */
+		if (nr > static_cast<UINT32>(numDisplays))
+		{
+			WLog_ERR(TAG,
+			         "Found %" PRIu32 " monitor IDs, but only have %" PRIu32 " monitors connected",
+			         nr, numDisplays);
+			return FALSE;
+		}
+
+		std::vector<UINT32> used;
+		for (size_t x = 0; x < nr; x++)
+		{
+			auto cur = static_cast<const UINT32*>(
+			    freerdp_settings_get_pointer_array(settings, FreeRDP_MonitorIds, x));
+			WINPR_ASSERT(cur);
+
+			auto id = *cur;
+
+			/* the ID is no valid monitor index */
+			if (id >= nr)
+			{
+				WLog_ERR(TAG,
+				         "Supplied monitor ID[%" PRIuz "]=%" PRIu32 " is invalid, only [0-%" PRIu32
+				         "] are allowed",
+				         x, id, nr - 1);
+				return FALSE;
+			}
+
+			/* The ID is already taken */
+			if (std::find(used.begin(), used.end(), id) != used.end())
+			{
+				WLog_ERR(TAG, "Duplicate monitor ID[%" PRIuz "]=%" PRIu32 " detected", x, id);
+				return FALSE;
+			}
+			used.push_back(*cur);
+		}
+	}
+
+	if (!sdl_apply_display_properties(sdl))
+		return FALSE;
+
+	return sdl_detect_single_window(sdl, pMaxWidth, pMaxHeight);
+}
+
+INT64 sdl_monitor_id_for_index(SdlContext* sdl, UINT32 index)
+{
+	WINPR_ASSERT(sdl);
+	auto settings = sdl->context()->settings;
+
+	auto nr = freerdp_settings_get_uint32(settings, FreeRDP_NumMonitorIds);
+	if (nr == 0)
+		return index;
+
+	if (nr <= index)
+		return -1;
+
+	auto cur = static_cast<const UINT32*>(
+	    freerdp_settings_get_pointer_array(settings, FreeRDP_MonitorIds, index));
+	WINPR_ASSERT(cur);
+	return *cur;
+}

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

@@ -0,0 +1,29 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Monitor Handling
+ *
+ * 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 <freerdp/api.h>
+#include <freerdp/freerdp.h>
+
+#include "sdl_types.hpp"
+
+int sdl_list_monitors(SdlContext* sdl);
+BOOL sdl_detect_monitors(SdlContext* sdl, UINT32* pMaxWidth, UINT32* pMaxHeight);
+INT64 sdl_monitor_id_for_index(SdlContext* sdl, UINT32 index);

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

@@ -0,0 +1,36 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP SDL touch/mouse input
+ *
+ * Copyright 2022 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 <SDL.h>
+#include "sdl_types.hpp"
+
+BOOL sdl_scale_coordinates(SdlContext* sdl, Uint32 windowId, INT32* px, INT32* py,
+                           BOOL fromLocalToRDP, BOOL applyOffset);
+
+BOOL sdl_handle_mouse_motion(SdlContext* sdl, const SDL_MouseMotionEvent* ev);
+BOOL sdl_handle_mouse_wheel(SdlContext* sdl, const SDL_MouseWheelEvent* ev);
+BOOL sdl_handle_mouse_button(SdlContext* sdl, const SDL_MouseButtonEvent* ev);
+
+BOOL sdl_handle_touch_down(SdlContext* sdl, const SDL_TouchFingerEvent* ev);
+BOOL sdl_handle_touch_up(SdlContext* sdl, const SDL_TouchFingerEvent* ev);
+BOOL sdl_handle_touch_motion(SdlContext* sdl, const SDL_TouchFingerEvent* ev);

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

@@ -0,0 +1,342 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client
+ *
+ * Copyright 2022 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 "sdl_utils.hpp"
+
+#include "sdl_freerdp.hpp"
+
+#include <SDL.h>
+
+#include <freerdp/version.h>
+
+const char* sdl_event_type_str(Uint32 type)
+{
+#define STR(x) #x
+#define EV_CASE_STR(x) \
+	case x:            \
+		return STR(x)
+
+	switch (type)
+	{
+		EV_CASE_STR(SDL_FIRSTEVENT);
+		EV_CASE_STR(SDL_QUIT);
+		EV_CASE_STR(SDL_APP_TERMINATING);
+		EV_CASE_STR(SDL_APP_LOWMEMORY);
+		EV_CASE_STR(SDL_APP_WILLENTERBACKGROUND);
+		EV_CASE_STR(SDL_APP_DIDENTERBACKGROUND);
+		EV_CASE_STR(SDL_APP_WILLENTERFOREGROUND);
+		EV_CASE_STR(SDL_APP_DIDENTERFOREGROUND);
+#if SDL_VERSION_ATLEAST(2, 0, 10)
+		EV_CASE_STR(SDL_DISPLAYEVENT);
+#endif
+		EV_CASE_STR(SDL_WINDOWEVENT);
+		EV_CASE_STR(SDL_SYSWMEVENT);
+		EV_CASE_STR(SDL_KEYDOWN);
+		EV_CASE_STR(SDL_KEYUP);
+		EV_CASE_STR(SDL_TEXTEDITING);
+		EV_CASE_STR(SDL_TEXTINPUT);
+		EV_CASE_STR(SDL_KEYMAPCHANGED);
+		EV_CASE_STR(SDL_MOUSEMOTION);
+		EV_CASE_STR(SDL_MOUSEBUTTONDOWN);
+		EV_CASE_STR(SDL_MOUSEBUTTONUP);
+		EV_CASE_STR(SDL_MOUSEWHEEL);
+		EV_CASE_STR(SDL_JOYAXISMOTION);
+		EV_CASE_STR(SDL_JOYBALLMOTION);
+		EV_CASE_STR(SDL_JOYHATMOTION);
+		EV_CASE_STR(SDL_JOYBUTTONDOWN);
+		EV_CASE_STR(SDL_JOYBUTTONUP);
+		EV_CASE_STR(SDL_JOYDEVICEADDED);
+		EV_CASE_STR(SDL_JOYDEVICEREMOVED);
+		EV_CASE_STR(SDL_CONTROLLERAXISMOTION);
+		EV_CASE_STR(SDL_CONTROLLERBUTTONDOWN);
+		EV_CASE_STR(SDL_CONTROLLERBUTTONUP);
+		EV_CASE_STR(SDL_CONTROLLERDEVICEADDED);
+		EV_CASE_STR(SDL_CONTROLLERDEVICEREMOVED);
+		EV_CASE_STR(SDL_CONTROLLERDEVICEREMAPPED);
+#if SDL_VERSION_ATLEAST(2, 0, 14)
+		EV_CASE_STR(SDL_LOCALECHANGED);
+		EV_CASE_STR(SDL_CONTROLLERTOUCHPADDOWN);
+		EV_CASE_STR(SDL_CONTROLLERTOUCHPADMOTION);
+		EV_CASE_STR(SDL_CONTROLLERTOUCHPADUP);
+		EV_CASE_STR(SDL_CONTROLLERSENSORUPDATE);
+#endif
+		EV_CASE_STR(SDL_FINGERDOWN);
+		EV_CASE_STR(SDL_FINGERUP);
+		EV_CASE_STR(SDL_FINGERMOTION);
+		EV_CASE_STR(SDL_DOLLARGESTURE);
+		EV_CASE_STR(SDL_DOLLARRECORD);
+		EV_CASE_STR(SDL_MULTIGESTURE);
+		EV_CASE_STR(SDL_CLIPBOARDUPDATE);
+		EV_CASE_STR(SDL_DROPFILE);
+		EV_CASE_STR(SDL_DROPTEXT);
+		EV_CASE_STR(SDL_DROPBEGIN);
+		EV_CASE_STR(SDL_DROPCOMPLETE);
+		EV_CASE_STR(SDL_AUDIODEVICEADDED);
+		EV_CASE_STR(SDL_AUDIODEVICEREMOVED);
+#if SDL_VERSION_ATLEAST(2, 0, 9)
+		EV_CASE_STR(SDL_SENSORUPDATE);
+#endif
+		EV_CASE_STR(SDL_RENDER_TARGETS_RESET);
+		EV_CASE_STR(SDL_RENDER_DEVICE_RESET);
+		EV_CASE_STR(SDL_USEREVENT);
+
+		EV_CASE_STR(SDL_USEREVENT_CERT_DIALOG);
+		EV_CASE_STR(SDL_USEREVENT_CERT_RESULT);
+		EV_CASE_STR(SDL_USEREVENT_SHOW_DIALOG);
+		EV_CASE_STR(SDL_USEREVENT_SHOW_RESULT);
+		EV_CASE_STR(SDL_USEREVENT_AUTH_DIALOG);
+		EV_CASE_STR(SDL_USEREVENT_AUTH_RESULT);
+		EV_CASE_STR(SDL_USEREVENT_SCARD_DIALOG);
+		EV_CASE_STR(SDL_USEREVENT_RETRY_DIALOG);
+		EV_CASE_STR(SDL_USEREVENT_SCARD_RESULT);
+		EV_CASE_STR(SDL_USEREVENT_UPDATE);
+		EV_CASE_STR(SDL_USEREVENT_CREATE_WINDOWS);
+		EV_CASE_STR(SDL_USEREVENT_WINDOW_RESIZEABLE);
+		EV_CASE_STR(SDL_USEREVENT_WINDOW_FULLSCREEN);
+		EV_CASE_STR(SDL_USEREVENT_WINDOW_MINIMIZE);
+		EV_CASE_STR(SDL_USEREVENT_POINTER_NULL);
+		EV_CASE_STR(SDL_USEREVENT_POINTER_DEFAULT);
+		EV_CASE_STR(SDL_USEREVENT_POINTER_POSITION);
+		EV_CASE_STR(SDL_USEREVENT_POINTER_SET);
+		EV_CASE_STR(SDL_USEREVENT_QUIT);
+
+		EV_CASE_STR(SDL_LASTEVENT);
+		default:
+			return "SDL_UNKNOWNEVENT";
+	}
+#undef EV_CASE_STR
+#undef STR
+}
+
+const char* sdl_error_string(Sint32 res)
+{
+	if (res == 0)
+		return nullptr;
+
+	return SDL_GetError();
+}
+
+BOOL sdl_log_error_ex(Sint32 res, wLog* log, const char* what, const char* file, size_t line,
+                      const char* fkt)
+{
+	const char* msg = sdl_error_string(res);
+
+	WINPR_UNUSED(file);
+
+	if (!msg)
+		return FALSE;
+
+	WLog_Print(log, WLOG_ERROR, "[%s:%" PRIuz "][%s]: %s", fkt, line, what, msg);
+	return TRUE;
+}
+
+BOOL sdl_push_user_event(Uint32 type, ...)
+{
+	SDL_Event ev = {};
+	SDL_UserEvent* event = &ev.user;
+
+	va_list ap = {};
+	va_start(ap, type);
+	event->type = type;
+	switch (type)
+	{
+		case SDL_USEREVENT_AUTH_RESULT:
+		{
+			auto arg = reinterpret_cast<SDL_UserAuthArg*>(ev.padding);
+			arg->user = va_arg(ap, char*);
+			arg->domain = va_arg(ap, char*);
+			arg->password = va_arg(ap, char*);
+			arg->result = va_arg(ap, Sint32);
+		}
+		break;
+		case SDL_USEREVENT_AUTH_DIALOG:
+		{
+			auto arg = reinterpret_cast<SDL_UserAuthArg*>(ev.padding);
+
+			arg->title = va_arg(ap, char*);
+			arg->user = va_arg(ap, char*);
+			arg->domain = va_arg(ap, char*);
+			arg->password = va_arg(ap, char*);
+			arg->result = va_arg(ap, Sint32);
+		}
+		break;
+		case SDL_USEREVENT_SCARD_DIALOG:
+		{
+			event->data1 = va_arg(ap, char*);
+			event->data2 = va_arg(ap, char**);
+			event->code = va_arg(ap, Sint32);
+		}
+		break;
+		case SDL_USEREVENT_RETRY_DIALOG:
+			break;
+		case SDL_USEREVENT_SCARD_RESULT:
+		case SDL_USEREVENT_SHOW_RESULT:
+		case SDL_USEREVENT_CERT_RESULT:
+			event->code = va_arg(ap, Sint32);
+			break;
+
+		case SDL_USEREVENT_SHOW_DIALOG:
+			event->data1 = va_arg(ap, char*);
+			event->data2 = va_arg(ap, char*);
+			event->code = va_arg(ap, Sint32);
+			break;
+		case SDL_USEREVENT_CERT_DIALOG:
+			event->data1 = va_arg(ap, char*);
+			event->data2 = va_arg(ap, char*);
+			break;
+		case SDL_USEREVENT_UPDATE:
+			event->data1 = va_arg(ap, void*);
+			break;
+		case SDL_USEREVENT_POINTER_POSITION:
+			event->data1 = reinterpret_cast<void*>(static_cast<uintptr_t>(va_arg(ap, UINT32)));
+			event->data2 = reinterpret_cast<void*>(static_cast<uintptr_t>(va_arg(ap, UINT32)));
+			break;
+		case SDL_USEREVENT_POINTER_SET:
+			event->data1 = va_arg(ap, void*);
+			event->data2 = va_arg(ap, void*);
+			break;
+		case SDL_USEREVENT_CREATE_WINDOWS:
+			event->data1 = va_arg(ap, void*);
+			break;
+		case SDL_USEREVENT_WINDOW_FULLSCREEN:
+		case SDL_USEREVENT_WINDOW_RESIZEABLE:
+			event->data1 = va_arg(ap, void*);
+			event->code = va_arg(ap, int);
+			break;
+		case SDL_USEREVENT_WINDOW_MINIMIZE:
+		case SDL_USEREVENT_QUIT:
+		case SDL_USEREVENT_POINTER_NULL:
+		case SDL_USEREVENT_POINTER_DEFAULT:
+			break;
+		default:
+			va_end(ap);
+			return FALSE;
+	}
+	va_end(ap);
+	return SDL_PushEvent(&ev) == 1;
+}
+
+CriticalSection::CriticalSection()
+{
+	InitializeCriticalSection(&_section);
+}
+
+CriticalSection::~CriticalSection()
+{
+	DeleteCriticalSection(&_section);
+}
+
+void CriticalSection::lock()
+{
+	EnterCriticalSection(&_section);
+}
+
+void CriticalSection::unlock()
+{
+	LeaveCriticalSection(&_section);
+}
+
+WinPREvent::WinPREvent(bool initial) : _handle(CreateEventA(nullptr, TRUE, initial, nullptr))
+{
+}
+
+WinPREvent::~WinPREvent()
+{
+	(void)CloseHandle(_handle);
+}
+
+void WinPREvent::set()
+{
+	(void)SetEvent(_handle);
+}
+
+void WinPREvent::clear()
+{
+	(void)ResetEvent(_handle);
+}
+
+bool WinPREvent::isSet() const
+{
+	return WaitForSingleObject(_handle, 0) == WAIT_OBJECT_0;
+}
+
+HANDLE WinPREvent::handle() const
+{
+	return _handle;
+}
+
+bool sdl_push_quit()
+{
+	SDL_Event ev = {};
+	ev.type = SDL_QUIT;
+	SDL_PushEvent(&ev);
+	return true;
+}
+
+std::string sdl_window_event_str(Uint8 ev)
+{
+	switch (ev)
+	{
+		case SDL_WINDOWEVENT_NONE:
+			return "SDL_WINDOWEVENT_NONE";
+		case SDL_WINDOWEVENT_SHOWN:
+			return "SDL_WINDOWEVENT_SHOWN";
+		case SDL_WINDOWEVENT_HIDDEN:
+			return "SDL_WINDOWEVENT_HIDDEN";
+		case SDL_WINDOWEVENT_EXPOSED:
+			return "SDL_WINDOWEVENT_EXPOSED";
+		case SDL_WINDOWEVENT_MOVED:
+			return "SDL_WINDOWEVENT_MOVED";
+		case SDL_WINDOWEVENT_RESIZED:
+			return "SDL_WINDOWEVENT_RESIZED";
+		case SDL_WINDOWEVENT_SIZE_CHANGED:
+			return "SDL_WINDOWEVENT_SIZE_CHANGED";
+		case SDL_WINDOWEVENT_MINIMIZED:
+			return "SDL_WINDOWEVENT_MINIMIZED";
+		case SDL_WINDOWEVENT_MAXIMIZED:
+			return "SDL_WINDOWEVENT_MAXIMIZED";
+		case SDL_WINDOWEVENT_RESTORED:
+			return "SDL_WINDOWEVENT_RESTORED";
+		case SDL_WINDOWEVENT_ENTER:
+			return "SDL_WINDOWEVENT_ENTER";
+		case SDL_WINDOWEVENT_LEAVE:
+			return "SDL_WINDOWEVENT_LEAVE";
+		case SDL_WINDOWEVENT_FOCUS_GAINED:
+			return "SDL_WINDOWEVENT_FOCUS_GAINED";
+		case SDL_WINDOWEVENT_FOCUS_LOST:
+			return "SDL_WINDOWEVENT_FOCUS_LOST";
+		case SDL_WINDOWEVENT_CLOSE:
+			return "SDL_WINDOWEVENT_CLOSE";
+#if SDL_VERSION_ATLEAST(2, 0, 5)
+		case SDL_WINDOWEVENT_TAKE_FOCUS:
+			return "SDL_WINDOWEVENT_TAKE_FOCUS";
+		case SDL_WINDOWEVENT_HIT_TEST:
+			return "SDL_WINDOWEVENT_HIT_TEST";
+#endif
+#if SDL_VERSION_ATLEAST(2, 0, 18)
+		case SDL_WINDOWEVENT_ICCPROF_CHANGED:
+			return "SDL_WINDOWEVENT_ICCPROF_CHANGED";
+		case SDL_WINDOWEVENT_DISPLAY_CHANGED:
+			return "SDL_WINDOWEVENT_DISPLAY_CHANGED";
+#endif
+		default:
+			return "SDL_WINDOWEVENT_UNKNOWN";
+	}
+}

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

@@ -0,0 +1,83 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client Channels
+ *
+ * Copyright 2022 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 <freerdp/config.h>
+
+#include <winpr/assert.h>
+
+#include <freerdp/client/rail.h>
+#include <freerdp/client/cliprdr.h>
+#include <freerdp/client/disp.h>
+
+#include "sdl_channels.hpp"
+#include "sdl_freerdp.hpp"
+#include "sdl_disp.hpp"
+
+void sdl_OnChannelConnectedEventHandler(void* context, const ChannelConnectedEventArgs* e)
+{
+	auto sdl = get_context(context);
+
+	WINPR_ASSERT(sdl);
+	WINPR_ASSERT(e);
+
+	if (strcmp(e->name, RAIL_SVC_CHANNEL_NAME) == 0)
+	{
+	}
+	else if (strcmp(e->name, CLIPRDR_SVC_CHANNEL_NAME) == 0)
+	{
+		auto clip = reinterpret_cast<CliprdrClientContext*>(e->pInterface);
+		WINPR_ASSERT(clip);
+		sdl->clip.init(clip);
+	}
+	else if (strcmp(e->name, DISP_DVC_CHANNEL_NAME) == 0)
+	{
+		auto disp = reinterpret_cast<DispClientContext*>(e->pInterface);
+		WINPR_ASSERT(disp);
+		sdl->disp.init(disp);
+	}
+	else
+		freerdp_client_OnChannelConnectedEventHandler(context, e);
+}
+
+void sdl_OnChannelDisconnectedEventHandler(void* context, const ChannelDisconnectedEventArgs* e)
+{
+	auto sdl = get_context(context);
+
+	WINPR_ASSERT(sdl);
+	WINPR_ASSERT(e);
+
+	// TODO: Set resizeable depending on disp channel and /dynamic-resolution
+	if (strcmp(e->name, RAIL_SVC_CHANNEL_NAME) == 0)
+	{
+	}
+	else if (strcmp(e->name, CLIPRDR_SVC_CHANNEL_NAME) == 0)
+	{
+		auto clip = reinterpret_cast<CliprdrClientContext*>(e->pInterface);
+		WINPR_ASSERT(clip);
+		clip->custom = nullptr;
+	}
+	else if (strcmp(e->name, DISP_DVC_CHANNEL_NAME) == 0)
+	{
+		auto disp = reinterpret_cast<DispClientContext*>(e->pInterface);
+		WINPR_ASSERT(disp);
+		sdl->disp.uninit(disp);
+	}
+	else
+		freerdp_client_OnChannelDisconnectedEventHandler(context, e);
+}

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

@@ -0,0 +1,29 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client Channels
+ *
+ * Copyright 2022 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 <freerdp/freerdp.h>
+#include <freerdp/client/channels.h>
+
+int sdl_on_channel_connected(freerdp* instance, const char* name, void* pInterface);
+int sdl_on_channel_disconnected(freerdp* instance, const char* name, void* pInterface);
+
+void sdl_OnChannelConnectedEventHandler(void* context, const ChannelConnectedEventArgs* e);
+void sdl_OnChannelDisconnectedEventHandler(void* context, const ChannelDisconnectedEventArgs* e);

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

@@ -0,0 +1,157 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client keyboard helper
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <utility>
+#include <vector>
+#include <atomic>
+#include <queue>
+#include <map>
+
+#include <winpr/wtypes.h>
+#include <freerdp/freerdp.h>
+#include <freerdp/client/client_cliprdr_file.h>
+#include <SDL3/SDL.h>
+
+#include "sdl_types.hpp"
+#include "sdl_utils.hpp"
+
+/** @brief a clipboard format request */
+class ClipRequest
+{
+  public:
+	ClipRequest(UINT32 format, const std::string& mime);
+	ClipRequest(const ClipRequest& other) = default;
+	ClipRequest(ClipRequest&& other) = default;
+	~ClipRequest() = default;
+
+	ClipRequest& operator=(const ClipRequest& other) = delete;
+	ClipRequest& operator=(ClipRequest&& other) = delete;
+
+	[[nodiscard]] uint32_t format() const;
+	[[nodiscard]] std::string formatstr() const;
+	[[nodiscard]] std::string mime() const;
+	[[nodiscard]] bool success() const;
+	void setSuccess(bool status);
+
+  private:
+	uint32_t _format;
+	std::string _mime;
+	bool _success;
+};
+
+class CliprdrFormat
+{
+  public:
+	CliprdrFormat(uint32_t formatID, const char* formatName) : _formatID(formatID)
+	{
+		if (formatName)
+			_formatName = formatName;
+	}
+
+	[[nodiscard]] uint32_t formatId() const
+	{
+		return _formatID;
+	}
+
+	[[nodiscard]] const char* formatName() const
+	{
+		if (_formatName.empty())
+			return nullptr;
+		return _formatName.c_str();
+	}
+
+  private:
+	uint32_t _formatID;
+	std::string _formatName;
+};
+
+/** @brief object that handles clipboard context for the SDL3 client */
+class sdlClip
+{
+  public:
+	explicit sdlClip(SdlContext* sdl);
+	virtual ~sdlClip();
+
+	BOOL init(CliprdrClientContext* clip);
+	BOOL uninit(CliprdrClientContext* clip);
+
+	bool handle_update(const SDL_ClipboardEvent& ev);
+
+  private:
+	UINT SendClientCapabilities();
+	void clearServerFormats();
+	UINT SendFormatListResponse(BOOL status);
+	UINT SendDataResponse(const BYTE* data, size_t size);
+	UINT SendDataRequest(uint32_t formatID, const std::string& mime);
+
+	std::string getServerFormat(uint32_t id);
+	uint32_t serverIdForMime(const std::string& mime);
+
+	static UINT MonitorReady(CliprdrClientContext* context,
+	                         const CLIPRDR_MONITOR_READY* monitorReady);
+
+	static UINT ReceiveServerCapabilities(CliprdrClientContext* context,
+	                                      const CLIPRDR_CAPABILITIES* capabilities);
+	static UINT ReceiveServerFormatList(CliprdrClientContext* context,
+	                                    const CLIPRDR_FORMAT_LIST* formatList);
+	static UINT ReceiveFormatListResponse(CliprdrClientContext* context,
+	                                      const CLIPRDR_FORMAT_LIST_RESPONSE* formatListResponse);
+	static std::shared_ptr<BYTE> ReceiveFormatDataRequestHandle(
+	    sdlClip* clipboard, const CLIPRDR_FORMAT_DATA_REQUEST* formatDataRequest, uint32_t& len);
+	static UINT ReceiveFormatDataRequest(CliprdrClientContext* context,
+	                                     const CLIPRDR_FORMAT_DATA_REQUEST* formatDataRequest);
+	static UINT ReceiveFormatDataResponse(CliprdrClientContext* context,
+	                                      const CLIPRDR_FORMAT_DATA_RESPONSE* formatDataResponse);
+
+	static const void* SDLCALL ClipDataCb(void* userdata, const char* mime_type, size_t* size);
+	static void SDLCALL ClipCleanCb(void* userdata);
+
+	static bool mime_is_file(const std::string& mime);
+	static bool mime_is_text(const std::string& mime);
+	static bool mime_is_image(const std::string& mime);
+	static bool mime_is_html(const std::string& mime);
+
+	SdlContext* _sdl = nullptr;
+	CliprdrFileContext* _file = nullptr;
+	CliprdrClientContext* _ctx = nullptr;
+	wLog* _log = nullptr;
+	wClipboard* _system = nullptr;
+	std::atomic<bool> _sync = false;
+	HANDLE _event;
+
+	std::vector<CliprdrFormat> _serverFormats;
+	CriticalSection _lock;
+
+	std::queue<ClipRequest> _request_queue;
+
+	struct cache_entry
+	{
+		cache_entry(size_t len, std::shared_ptr<void> p) : size(len), ptr(std::move(p))
+		{
+		}
+
+		size_t size;
+		std::shared_ptr<void> ptr;
+	};
+	std::map<std::string, cache_entry> _cache_data;
+	std::vector<const char*> _current_mimetypes;
+};

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

@@ -0,0 +1,473 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Display Control Channel
+ *
+ * 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 <winpr/sysinfo.h>
+#include <winpr/assert.h>
+
+#include <freerdp/gdi/gdi.h>
+
+#include <SDL3/SDL.h>
+
+#include "sdl_disp.hpp"
+#include "sdl_kbd.hpp"
+#include "sdl_utils.hpp"
+#include "sdl_freerdp.hpp"
+
+#include <freerdp/log.h>
+#define TAG CLIENT_TAG("sdl.disp")
+
+static constexpr UINT64 RESIZE_MIN_DELAY = 200; /* minimum delay in ms between two resizes */
+static constexpr unsigned MAX_RETRIES = 5;
+
+BOOL sdlDispContext::settings_changed()
+{
+	auto settings = _sdl->context()->settings;
+	WINPR_ASSERT(settings);
+
+	if (_lastSentWidth != _targetWidth)
+		return TRUE;
+
+	if (_lastSentHeight != _targetHeight)
+		return TRUE;
+
+	if (_lastSentDesktopOrientation !=
+	    freerdp_settings_get_uint16(settings, FreeRDP_DesktopOrientation))
+		return TRUE;
+
+	if (_lastSentDesktopScaleFactor !=
+	    freerdp_settings_get_uint32(settings, FreeRDP_DesktopScaleFactor))
+		return TRUE;
+
+	if (_lastSentDeviceScaleFactor !=
+	    freerdp_settings_get_uint32(settings, FreeRDP_DeviceScaleFactor))
+		return TRUE;
+	/* TODO
+	    if (_fullscreen != _sdl->fullscreen)
+	        return TRUE;
+	*/
+	return FALSE;
+}
+
+BOOL sdlDispContext::update_last_sent()
+{
+	WINPR_ASSERT(_sdl);
+
+	auto settings = _sdl->context()->settings;
+	WINPR_ASSERT(settings);
+
+	_lastSentWidth = _targetWidth;
+	_lastSentHeight = _targetHeight;
+	_lastSentDesktopOrientation = freerdp_settings_get_uint16(settings, FreeRDP_DesktopOrientation);
+	_lastSentDesktopScaleFactor = freerdp_settings_get_uint32(settings, FreeRDP_DesktopScaleFactor);
+	_lastSentDeviceScaleFactor = freerdp_settings_get_uint32(settings, FreeRDP_DeviceScaleFactor);
+	// TODO _fullscreen = _sdl->fullscreen;
+	return TRUE;
+}
+
+BOOL sdlDispContext::sendResize()
+{
+	DISPLAY_CONTROL_MONITOR_LAYOUT layout = {};
+	auto settings = _sdl->context()->settings;
+
+	if (!settings)
+		return FALSE;
+
+	if (!_activated || !_disp)
+		return TRUE;
+
+	if (GetTickCount64() - _lastSentDate < RESIZE_MIN_DELAY)
+		return TRUE;
+
+	_lastSentDate = GetTickCount64();
+
+	if (!settings_changed())
+		return TRUE;
+
+	const UINT32 mcount = freerdp_settings_get_uint32(settings, FreeRDP_MonitorCount);
+	if (_sdl->fullscreen && (mcount > 0))
+	{
+		auto monitors = static_cast<const rdpMonitor*>(
+		    freerdp_settings_get_pointer(settings, FreeRDP_MonitorDefArray));
+		if (sendLayout(monitors, mcount) != CHANNEL_RC_OK)
+			return FALSE;
+	}
+	else
+	{
+		_waitingResize = TRUE;
+		layout.Flags = DISPLAY_CONTROL_MONITOR_PRIMARY;
+		layout.Top = layout.Left = 0;
+		layout.Width = WINPR_ASSERTING_INT_CAST(uint32_t, _targetWidth);
+		layout.Height = WINPR_ASSERTING_INT_CAST(uint32_t, _targetHeight);
+		layout.Orientation = freerdp_settings_get_uint16(settings, FreeRDP_DesktopOrientation);
+		layout.DesktopScaleFactor =
+		    freerdp_settings_get_uint32(settings, FreeRDP_DesktopScaleFactor);
+		layout.DeviceScaleFactor = freerdp_settings_get_uint32(settings, FreeRDP_DeviceScaleFactor);
+		layout.PhysicalWidth = WINPR_ASSERTING_INT_CAST(uint32_t, _targetWidth);
+		layout.PhysicalHeight = WINPR_ASSERTING_INT_CAST(uint32_t, _targetHeight);
+
+		if (IFCALLRESULT(CHANNEL_RC_OK, _disp->SendMonitorLayout, _disp, 1, &layout) !=
+		    CHANNEL_RC_OK)
+			return FALSE;
+	}
+	return update_last_sent();
+}
+
+BOOL sdlDispContext::set_window_resizable()
+{
+	_sdl->update_resizeable(TRUE);
+	return TRUE;
+}
+
+static BOOL sdl_disp_check_context(void* context, SdlContext** ppsdl, sdlDispContext** ppsdlDisp,
+                                   rdpSettings** ppSettings)
+{
+	if (!context)
+		return FALSE;
+
+	auto sdl = get_context(context);
+	if (!sdl)
+		return FALSE;
+
+	if (!sdl->context()->settings)
+		return FALSE;
+
+	*ppsdl = sdl;
+	*ppsdlDisp = &sdl->disp;
+	*ppSettings = sdl->context()->settings;
+	return TRUE;
+}
+
+void sdlDispContext::OnActivated(void* context, const ActivatedEventArgs* e)
+{
+	SdlContext* sdl = nullptr;
+	sdlDispContext* sdlDisp = nullptr;
+	rdpSettings* settings = nullptr;
+
+	if (!sdl_disp_check_context(context, &sdl, &sdlDisp, &settings))
+		return;
+
+	sdlDisp->_waitingResize = FALSE;
+
+	if (sdlDisp->_activated && !freerdp_settings_get_bool(settings, FreeRDP_Fullscreen))
+	{
+		sdlDisp->set_window_resizable();
+
+		if (e->firstActivation)
+			return;
+
+		sdlDisp->addTimer();
+	}
+}
+
+void sdlDispContext::OnGraphicsReset(void* context, const GraphicsResetEventArgs* e)
+{
+	SdlContext* sdl = nullptr;
+	sdlDispContext* sdlDisp = nullptr;
+	rdpSettings* settings = nullptr;
+
+	WINPR_UNUSED(e);
+	if (!sdl_disp_check_context(context, &sdl, &sdlDisp, &settings))
+		return;
+
+	sdlDisp->_waitingResize = FALSE;
+
+	if (sdlDisp->_activated && !freerdp_settings_get_bool(settings, FreeRDP_Fullscreen))
+	{
+		sdlDisp->set_window_resizable();
+		sdlDisp->addTimer();
+	}
+}
+
+Uint32 sdlDispContext::OnTimer(void* param, SDL_TimerID timerID, Uint32 interval)
+{
+	auto ctx = static_cast<sdlDispContext*>(param);
+	if (!ctx)
+		return 0;
+
+	SdlContext* sdl = ctx->_sdl;
+	if (!sdl)
+		return 0;
+
+	sdlDispContext* sdlDisp = nullptr;
+	rdpSettings* settings = nullptr;
+
+	if (!sdl_disp_check_context(sdl->context(), &sdl, &sdlDisp, &settings))
+		return 0;
+
+	WLog_Print(sdl->log, WLOG_TRACE, "checking for display changes...");
+	if (!sdlDisp->_activated || freerdp_settings_get_bool(settings, FreeRDP_Fullscreen))
+		return 0;
+	else
+	{
+		auto rc = sdlDisp->sendResize();
+		if (!rc)
+			WLog_Print(sdl->log, WLOG_TRACE, "sent new display layout, result %d", rc);
+	}
+	if (sdlDisp->_timer_retries++ >= MAX_RETRIES)
+	{
+		WLog_Print(sdl->log, WLOG_TRACE, "deactivate timer, retries exceeded");
+		return 0;
+	}
+
+	WLog_Print(sdl->log, WLOG_TRACE, "fire timer one more time");
+	return interval;
+}
+
+UINT sdlDispContext::sendLayout(const rdpMonitor* monitors, size_t nmonitors)
+{
+	UINT ret = CHANNEL_RC_OK;
+
+	WINPR_ASSERT(monitors);
+	WINPR_ASSERT(nmonitors > 0);
+
+	auto settings = _sdl->context()->settings;
+	WINPR_ASSERT(settings);
+
+	std::vector<DISPLAY_CONTROL_MONITOR_LAYOUT> layouts;
+	layouts.resize(nmonitors);
+
+	for (size_t i = 0; i < nmonitors; i++)
+	{
+		auto monitor = &monitors[i];
+		auto layout = &layouts[i];
+
+		layout->Flags = (monitor->is_primary ? DISPLAY_CONTROL_MONITOR_PRIMARY : 0);
+		layout->Left = monitor->x;
+		layout->Top = monitor->y;
+		layout->Width = WINPR_ASSERTING_INT_CAST(uint32_t, monitor->width);
+		layout->Height = WINPR_ASSERTING_INT_CAST(uint32_t, monitor->height);
+		layout->Orientation = ORIENTATION_LANDSCAPE;
+		layout->PhysicalWidth = monitor->attributes.physicalWidth;
+		layout->PhysicalHeight = monitor->attributes.physicalHeight;
+
+		switch (monitor->attributes.orientation)
+		{
+			case 90:
+				layout->Orientation = ORIENTATION_PORTRAIT;
+				break;
+
+			case 180:
+				layout->Orientation = ORIENTATION_LANDSCAPE_FLIPPED;
+				break;
+
+			case 270:
+				layout->Orientation = ORIENTATION_PORTRAIT_FLIPPED;
+				break;
+
+			case 0:
+			default:
+				/* MS-RDPEDISP - 2.2.2.2.1:
+				 * Orientation (4 bytes): A 32-bit unsigned integer that specifies the
+				 * orientation of the monitor in degrees. Valid values are 0, 90, 180
+				 * or 270
+				 *
+				 * So we default to ORIENTATION_LANDSCAPE
+				 */
+				layout->Orientation = ORIENTATION_LANDSCAPE;
+				break;
+		}
+
+		layout->DesktopScaleFactor =
+		    freerdp_settings_get_uint32(settings, FreeRDP_DesktopScaleFactor);
+		layout->DeviceScaleFactor =
+		    freerdp_settings_get_uint32(settings, FreeRDP_DeviceScaleFactor);
+	}
+
+	WINPR_ASSERT(_disp);
+	const size_t len = layouts.size();
+	WINPR_ASSERT(len <= UINT32_MAX);
+	ret = IFCALLRESULT(CHANNEL_RC_OK, _disp->SendMonitorLayout, _disp, static_cast<UINT32>(len),
+	                   layouts.data());
+	return ret;
+}
+
+BOOL sdlDispContext::addTimer()
+{
+	if (SDL_WasInit(SDL_INIT_EVENTS) == 0)
+		return FALSE;
+
+	SDL_RemoveTimer(_timer);
+	WLog_Print(_sdl->log, WLOG_TRACE, "adding new display check timer");
+
+	_timer_retries = 0;
+	sendResize();
+	_timer = SDL_AddTimer(1000, sdlDispContext::OnTimer, this);
+	return TRUE;
+}
+
+BOOL sdlDispContext::handle_display_event(const SDL_DisplayEvent* ev)
+{
+	WINPR_ASSERT(ev);
+
+	switch (ev->type)
+	{
+		case SDL_EVENT_DISPLAY_ADDED:
+			SDL_Log("A new display with id %u was connected", ev->displayID);
+			return TRUE;
+		case SDL_EVENT_DISPLAY_REMOVED:
+			SDL_Log("The display with id %u was disconnected", ev->displayID);
+			return TRUE;
+		case SDL_EVENT_DISPLAY_ORIENTATION:
+			SDL_Log("The orientation of display with id %u was changed", ev->displayID);
+			return TRUE;
+		default:
+			return TRUE;
+	}
+}
+
+BOOL sdlDispContext::handle_window_event(const SDL_WindowEvent* ev)
+{
+	WINPR_ASSERT(ev);
+
+	auto bordered = freerdp_settings_get_bool(_sdl->context()->settings, FreeRDP_Decorations);
+
+	auto it = _sdl->windows.find(ev->windowID);
+	if (it != _sdl->windows.end())
+		it->second.setBordered(bordered);
+
+	switch (ev->type)
+	{
+		case SDL_EVENT_WINDOW_HIDDEN:
+		case SDL_EVENT_WINDOW_MINIMIZED:
+			gdi_send_suppress_output(_sdl->context()->gdi, TRUE);
+
+			return TRUE;
+
+		case SDL_EVENT_WINDOW_EXPOSED:
+		case SDL_EVENT_WINDOW_SHOWN:
+		case SDL_EVENT_WINDOW_MAXIMIZED:
+		case SDL_EVENT_WINDOW_RESTORED:
+			gdi_send_suppress_output(_sdl->context()->gdi, FALSE);
+			return TRUE;
+
+		case SDL_EVENT_WINDOW_RESIZED:
+		case SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED:
+			_targetWidth = ev->data1;
+			_targetHeight = ev->data2;
+			return addTimer();
+
+		case SDL_EVENT_WINDOW_MOUSE_LEAVE:
+			WINPR_ASSERT(_sdl);
+			_sdl->input.keyboard_grab(ev->windowID, false);
+			return TRUE;
+		case SDL_EVENT_WINDOW_MOUSE_ENTER:
+			WINPR_ASSERT(_sdl);
+			_sdl->input.keyboard_grab(ev->windowID, true);
+			return _sdl->input.keyboard_focus_in();
+		case SDL_EVENT_WINDOW_FOCUS_GAINED:
+			return _sdl->input.keyboard_focus_in();
+
+		default:
+			return TRUE;
+	}
+}
+
+UINT sdlDispContext::DisplayControlCaps(DispClientContext* disp, UINT32 maxNumMonitors,
+                                        UINT32 maxMonitorAreaFactorA, UINT32 maxMonitorAreaFactorB)
+{
+	/* we're called only if dynamic resolution update is activated */
+	WINPR_ASSERT(disp);
+
+	auto sdlDisp = reinterpret_cast<sdlDispContext*>(disp->custom);
+	return sdlDisp->DisplayControlCaps(maxNumMonitors, maxMonitorAreaFactorA,
+	                                   maxMonitorAreaFactorB);
+}
+
+UINT sdlDispContext::DisplayControlCaps(UINT32 maxNumMonitors, UINT32 maxMonitorAreaFactorA,
+                                        UINT32 maxMonitorAreaFactorB)
+{
+	auto settings = _sdl->context()->settings;
+	WINPR_ASSERT(settings);
+
+	WLog_DBG(TAG,
+	         "DisplayControlCapsPdu: MaxNumMonitors: %" PRIu32 " MaxMonitorAreaFactorA: %" PRIu32
+	         " MaxMonitorAreaFactorB: %" PRIu32 "",
+	         maxNumMonitors, maxMonitorAreaFactorA, maxMonitorAreaFactorB);
+	_activated = TRUE;
+
+	if (freerdp_settings_get_bool(settings, FreeRDP_Fullscreen))
+		return CHANNEL_RC_OK;
+
+	WLog_DBG(TAG, "DisplayControlCapsPdu: setting the window as resizable");
+	return set_window_resizable() ? CHANNEL_RC_OK : CHANNEL_RC_NO_MEMORY;
+}
+
+BOOL sdlDispContext::init(DispClientContext* disp)
+{
+	if (!disp)
+		return FALSE;
+
+	auto settings = _sdl->context()->settings;
+
+	if (!settings)
+		return FALSE;
+
+	_disp = disp;
+	disp->custom = this;
+
+	if (freerdp_settings_get_bool(settings, FreeRDP_DynamicResolutionUpdate))
+	{
+		disp->DisplayControlCaps = sdlDispContext::DisplayControlCaps;
+	}
+
+	_sdl->update_resizeable(TRUE);
+	return TRUE;
+}
+
+BOOL sdlDispContext::uninit(DispClientContext* disp)
+{
+	if (!disp)
+		return FALSE;
+
+	_disp = nullptr;
+	_sdl->update_resizeable(FALSE);
+	return TRUE;
+}
+
+sdlDispContext::sdlDispContext(SdlContext* sdl) : _sdl(sdl)
+{
+	SDL_Init(SDL_INIT_EVENTS | SDL_INIT_VIDEO);
+
+	WINPR_ASSERT(_sdl);
+	WINPR_ASSERT(_sdl->context()->settings);
+	WINPR_ASSERT(_sdl->context()->pubSub);
+
+	auto settings = _sdl->context()->settings;
+	auto pubSub = _sdl->context()->pubSub;
+
+	_lastSentWidth = _targetWidth = WINPR_ASSERTING_INT_CAST(
+	    int32_t, freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth));
+	_lastSentHeight = _targetHeight = WINPR_ASSERTING_INT_CAST(
+	    int32_t, freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight));
+	PubSub_SubscribeActivated(pubSub, sdlDispContext::OnActivated);
+	PubSub_SubscribeGraphicsReset(pubSub, sdlDispContext::OnGraphicsReset);
+	addTimer();
+}
+
+sdlDispContext::~sdlDispContext()
+{
+	wPubSub* pubSub = _sdl->context()->pubSub;
+	WINPR_ASSERT(pubSub);
+
+	PubSub_UnsubscribeActivated(pubSub, sdlDispContext::OnActivated);
+	PubSub_UnsubscribeGraphicsReset(pubSub, sdlDispContext::OnGraphicsReset);
+	SDL_RemoveTimer(_timer);
+	SDL_Quit();
+}

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

@@ -0,0 +1,80 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Display Control Channel
+ *
+ * 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 <freerdp/types.h>
+#include <freerdp/event.h>
+#include <freerdp/client/disp.h>
+
+#include "sdl_types.hpp"
+
+#include <SDL3/SDL.h>
+
+class sdlDispContext
+{
+
+  public:
+	explicit sdlDispContext(SdlContext* sdl);
+	sdlDispContext(const sdlDispContext& other) = delete;
+	sdlDispContext(sdlDispContext&& other) = delete;
+	~sdlDispContext();
+
+	sdlDispContext& operator=(const sdlDispContext& other) = delete;
+	sdlDispContext& operator=(sdlDispContext&& other) = delete;
+
+	BOOL init(DispClientContext* disp);
+	BOOL uninit(DispClientContext* disp);
+
+	BOOL handle_display_event(const SDL_DisplayEvent* ev);
+
+	BOOL handle_window_event(const SDL_WindowEvent* ev);
+
+  private:
+	UINT DisplayControlCaps(UINT32 maxNumMonitors, UINT32 maxMonitorAreaFactorA,
+	                        UINT32 maxMonitorAreaFactorB);
+	BOOL set_window_resizable();
+
+	BOOL sendResize();
+	BOOL settings_changed();
+	BOOL update_last_sent();
+	UINT sendLayout(const rdpMonitor* monitors, size_t nmonitors);
+
+	BOOL addTimer();
+
+	static UINT DisplayControlCaps(DispClientContext* disp, UINT32 maxNumMonitors,
+	                               UINT32 maxMonitorAreaFactorA, UINT32 maxMonitorAreaFactorB);
+	static void OnActivated(void* context, const ActivatedEventArgs* e);
+	static void OnGraphicsReset(void* context, const GraphicsResetEventArgs* e);
+	static Uint32 SDLCALL OnTimer(void* param, SDL_TimerID timerID, Uint32 interval);
+
+	SdlContext* _sdl = nullptr;
+	DispClientContext* _disp = nullptr;
+	int _lastSentWidth = -1;
+	int _lastSentHeight = -1;
+	UINT64 _lastSentDate = 0;
+	int _targetWidth = -1;
+	int _targetHeight = -1;
+	BOOL _activated = FALSE;
+	BOOL _waitingResize = FALSE;
+	UINT16 _lastSentDesktopOrientation = 0;
+	UINT32 _lastSentDesktopScaleFactor = 0;
+	UINT32 _lastSentDeviceScaleFactor = 0;
+	SDL_TimerID _timer = 0;
+	unsigned _timer_retries = 0;
+};

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

@@ -0,0 +1,1744 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP SDL UI
+ *
+ * Copyright 2022 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 <memory>
+#include <mutex>
+#include <iostream>
+
+#include <freerdp/config.h>
+
+#include <cerrno>
+#include <cstdio>
+#include <cstring>
+
+#include <freerdp/freerdp.h>
+#include <freerdp/constants.h>
+#include <freerdp/gdi/gdi.h>
+#include <freerdp/streamdump.h>
+#include <freerdp/utils/signal.h>
+
+#include <freerdp/client/file.h>
+#include <freerdp/client/cmdline.h>
+#include <freerdp/client/cliprdr.h>
+#include <freerdp/client/channels.h>
+#include <freerdp/channels/channels.h>
+
+#include <winpr/crt.h>
+#include <winpr/config.h>
+#include <winpr/assert.h>
+#include <winpr/synch.h>
+#include <freerdp/log.h>
+
+#include <SDL3/SDL.h>
+#include <SDL3/SDL_hints.h>
+#include <SDL3/SDL_video.h>
+#include <SDL3/SDL_oldnames.h>
+
+#include "sdl_channels.hpp"
+#include "sdl_freerdp.hpp"
+#include "sdl_utils.hpp"
+#include "sdl_disp.hpp"
+#include "sdl_monitor.hpp"
+#include "sdl_kbd.hpp"
+#include "sdl_touch.hpp"
+#include "sdl_pointer.hpp"
+#include "sdl_prefs.hpp"
+#include "dialogs/sdl_dialogs.hpp"
+#include "scoped_guard.hpp"
+
+#include <aad/sdl_webview.hpp>
+
+#define SDL_TAG CLIENT_TAG("SDL")
+
+enum SDL_EXIT_CODE
+{
+	/* section 0-15: protocol-independent codes */
+	SDL_EXIT_SUCCESS = 0,
+	SDL_EXIT_DISCONNECT = 1,
+	SDL_EXIT_LOGOFF = 2,
+	SDL_EXIT_IDLE_TIMEOUT = 3,
+	SDL_EXIT_LOGON_TIMEOUT = 4,
+	SDL_EXIT_CONN_REPLACED = 5,
+	SDL_EXIT_OUT_OF_MEMORY = 6,
+	SDL_EXIT_CONN_DENIED = 7,
+	SDL_EXIT_CONN_DENIED_FIPS = 8,
+	SDL_EXIT_USER_PRIVILEGES = 9,
+	SDL_EXIT_FRESH_CREDENTIALS_REQUIRED = 10,
+	SDL_EXIT_DISCONNECT_BY_USER = 11,
+
+	/* section 16-31: license error set */
+	SDL_EXIT_LICENSE_INTERNAL = 16,
+	SDL_EXIT_LICENSE_NO_LICENSE_SERVER = 17,
+	SDL_EXIT_LICENSE_NO_LICENSE = 18,
+	SDL_EXIT_LICENSE_BAD_CLIENT_MSG = 19,
+	SDL_EXIT_LICENSE_HWID_DOESNT_MATCH = 20,
+	SDL_EXIT_LICENSE_BAD_CLIENT = 21,
+	SDL_EXIT_LICENSE_CANT_FINISH_PROTOCOL = 22,
+	SDL_EXIT_LICENSE_CLIENT_ENDED_PROTOCOL = 23,
+	SDL_EXIT_LICENSE_BAD_CLIENT_ENCRYPTION = 24,
+	SDL_EXIT_LICENSE_CANT_UPGRADE = 25,
+	SDL_EXIT_LICENSE_NO_REMOTE_CONNECTIONS = 26,
+
+	/* section 32-127: RDP protocol error set */
+	SDL_EXIT_RDP = 32,
+
+	/* section 128-254: xfreerdp specific exit codes */
+	SDL_EXIT_PARSE_ARGUMENTS = 128,
+	SDL_EXIT_MEMORY = 129,
+	SDL_EXIT_PROTOCOL = 130,
+	SDL_EXIT_CONN_FAILED = 131,
+	SDL_EXIT_AUTH_FAILURE = 132,
+	SDL_EXIT_NEGO_FAILURE = 133,
+	SDL_EXIT_LOGON_FAILURE = 134,
+	SDL_EXIT_ACCOUNT_LOCKED_OUT = 135,
+	SDL_EXIT_PRE_CONNECT_FAILED = 136,
+	SDL_EXIT_CONNECT_UNDEFINED = 137,
+	SDL_EXIT_POST_CONNECT_FAILED = 138,
+	SDL_EXIT_DNS_ERROR = 139,
+	SDL_EXIT_DNS_NAME_NOT_FOUND = 140,
+	SDL_EXIT_CONNECT_FAILED = 141,
+	SDL_EXIT_MCS_CONNECT_INITIAL_ERROR = 142,
+	SDL_EXIT_TLS_CONNECT_FAILED = 143,
+	SDL_EXIT_INSUFFICIENT_PRIVILEGES = 144,
+	SDL_EXIT_CONNECT_CANCELLED = 145,
+
+	SDL_EXIT_CONNECT_TRANSPORT_FAILED = 147,
+	SDL_EXIT_CONNECT_PASSWORD_EXPIRED = 148,
+	SDL_EXIT_CONNECT_PASSWORD_MUST_CHANGE = 149,
+	SDL_EXIT_CONNECT_KDC_UNREACHABLE = 150,
+	SDL_EXIT_CONNECT_ACCOUNT_DISABLED = 151,
+	SDL_EXIT_CONNECT_PASSWORD_CERTAINLY_EXPIRED = 152,
+	SDL_EXIT_CONNECT_CLIENT_REVOKED = 153,
+	SDL_EXIT_CONNECT_WRONG_PASSWORD = 154,
+	SDL_EXIT_CONNECT_ACCESS_DENIED = 155,
+	SDL_EXIT_CONNECT_ACCOUNT_RESTRICTION = 156,
+	SDL_EXIT_CONNECT_ACCOUNT_EXPIRED = 157,
+	SDL_EXIT_CONNECT_LOGON_TYPE_NOT_GRANTED = 158,
+	SDL_EXIT_CONNECT_NO_OR_MISSING_CREDENTIALS = 159,
+
+	SDL_EXIT_UNKNOWN = 255,
+};
+
+struct sdl_exit_code_map_t
+{
+	DWORD error;
+	int code;
+	const char* code_tag;
+};
+
+#define ENTRY(x, y) \
+	{               \
+		x, y, #y    \
+	}
+static const struct sdl_exit_code_map_t sdl_exit_code_map[] = {
+	ENTRY(FREERDP_ERROR_SUCCESS, SDL_EXIT_SUCCESS), ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_DISCONNECT),
+	ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LOGOFF), ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_IDLE_TIMEOUT),
+	ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LOGON_TIMEOUT),
+	ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_CONN_REPLACED),
+	ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_OUT_OF_MEMORY),
+	ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_CONN_DENIED),
+	ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_CONN_DENIED_FIPS),
+	ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_USER_PRIVILEGES),
+	ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_FRESH_CREDENTIALS_REQUIRED),
+	ENTRY(ERRINFO_LOGOFF_BY_USER, SDL_EXIT_DISCONNECT_BY_USER),
+	ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_UNKNOWN),
+
+	/* section 16-31: license error set */
+	ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_INTERNAL),
+	ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_NO_LICENSE_SERVER),
+	ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_NO_LICENSE),
+	ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_BAD_CLIENT_MSG),
+	ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_HWID_DOESNT_MATCH),
+	ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_BAD_CLIENT),
+	ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_CANT_FINISH_PROTOCOL),
+	ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_CLIENT_ENDED_PROTOCOL),
+	ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_BAD_CLIENT_ENCRYPTION),
+	ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_CANT_UPGRADE),
+	ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_NO_REMOTE_CONNECTIONS),
+	ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_LICENSE_CANT_UPGRADE),
+
+	/* section 32-127: RDP protocol error set */
+	ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_RDP),
+
+	/* section 128-254: xfreerdp specific exit codes */
+	ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_PARSE_ARGUMENTS), ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_MEMORY),
+	ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_PROTOCOL), ENTRY(FREERDP_ERROR_NONE, SDL_EXIT_CONN_FAILED),
+
+	ENTRY(FREERDP_ERROR_AUTHENTICATION_FAILED, SDL_EXIT_AUTH_FAILURE),
+	ENTRY(FREERDP_ERROR_SECURITY_NEGO_CONNECT_FAILED, SDL_EXIT_NEGO_FAILURE),
+	ENTRY(FREERDP_ERROR_CONNECT_LOGON_FAILURE, SDL_EXIT_LOGON_FAILURE),
+	ENTRY(FREERDP_ERROR_CONNECT_ACCOUNT_LOCKED_OUT, SDL_EXIT_ACCOUNT_LOCKED_OUT),
+	ENTRY(FREERDP_ERROR_PRE_CONNECT_FAILED, SDL_EXIT_PRE_CONNECT_FAILED),
+	ENTRY(FREERDP_ERROR_CONNECT_UNDEFINED, SDL_EXIT_CONNECT_UNDEFINED),
+	ENTRY(FREERDP_ERROR_POST_CONNECT_FAILED, SDL_EXIT_POST_CONNECT_FAILED),
+	ENTRY(FREERDP_ERROR_DNS_ERROR, SDL_EXIT_DNS_ERROR),
+	ENTRY(FREERDP_ERROR_DNS_NAME_NOT_FOUND, SDL_EXIT_DNS_NAME_NOT_FOUND),
+	ENTRY(FREERDP_ERROR_CONNECT_FAILED, SDL_EXIT_CONNECT_FAILED),
+	ENTRY(FREERDP_ERROR_MCS_CONNECT_INITIAL_ERROR, SDL_EXIT_MCS_CONNECT_INITIAL_ERROR),
+	ENTRY(FREERDP_ERROR_TLS_CONNECT_FAILED, SDL_EXIT_TLS_CONNECT_FAILED),
+	ENTRY(FREERDP_ERROR_INSUFFICIENT_PRIVILEGES, SDL_EXIT_INSUFFICIENT_PRIVILEGES),
+	ENTRY(FREERDP_ERROR_CONNECT_CANCELLED, SDL_EXIT_CONNECT_CANCELLED),
+	ENTRY(FREERDP_ERROR_CONNECT_TRANSPORT_FAILED, SDL_EXIT_CONNECT_TRANSPORT_FAILED),
+	ENTRY(FREERDP_ERROR_CONNECT_PASSWORD_EXPIRED, SDL_EXIT_CONNECT_PASSWORD_EXPIRED),
+	ENTRY(FREERDP_ERROR_CONNECT_PASSWORD_MUST_CHANGE, SDL_EXIT_CONNECT_PASSWORD_MUST_CHANGE),
+	ENTRY(FREERDP_ERROR_CONNECT_KDC_UNREACHABLE, SDL_EXIT_CONNECT_KDC_UNREACHABLE),
+	ENTRY(FREERDP_ERROR_CONNECT_ACCOUNT_DISABLED, SDL_EXIT_CONNECT_ACCOUNT_DISABLED),
+	ENTRY(FREERDP_ERROR_CONNECT_PASSWORD_CERTAINLY_EXPIRED,
+	      SDL_EXIT_CONNECT_PASSWORD_CERTAINLY_EXPIRED),
+	ENTRY(FREERDP_ERROR_CONNECT_CLIENT_REVOKED, SDL_EXIT_CONNECT_CLIENT_REVOKED),
+	ENTRY(FREERDP_ERROR_CONNECT_WRONG_PASSWORD, SDL_EXIT_CONNECT_WRONG_PASSWORD),
+	ENTRY(FREERDP_ERROR_CONNECT_ACCESS_DENIED, SDL_EXIT_CONNECT_ACCESS_DENIED),
+	ENTRY(FREERDP_ERROR_CONNECT_ACCOUNT_RESTRICTION, SDL_EXIT_CONNECT_ACCOUNT_RESTRICTION),
+	ENTRY(FREERDP_ERROR_CONNECT_ACCOUNT_EXPIRED, SDL_EXIT_CONNECT_ACCOUNT_EXPIRED),
+	ENTRY(FREERDP_ERROR_CONNECT_LOGON_TYPE_NOT_GRANTED, SDL_EXIT_CONNECT_LOGON_TYPE_NOT_GRANTED),
+	ENTRY(FREERDP_ERROR_CONNECT_NO_OR_MISSING_CREDENTIALS,
+	      SDL_EXIT_CONNECT_NO_OR_MISSING_CREDENTIALS)
+};
+
+static const struct sdl_exit_code_map_t* sdl_map_entry_by_code(int exit_code)
+{
+	for (const auto& x : sdl_exit_code_map)
+	{
+		const struct sdl_exit_code_map_t* cur = &x;
+		if (cur->code == exit_code)
+			return cur;
+	}
+	return nullptr;
+}
+
+static void sdl_hide_connection_dialog(SdlContext* sdl)
+{
+	WINPR_ASSERT(sdl);
+	std::lock_guard<CriticalSection> lock(sdl->critical);
+	if (sdl->connection_dialog)
+		sdl->connection_dialog->hide();
+}
+
+static const struct sdl_exit_code_map_t* sdl_map_entry_by_error(UINT32 error)
+{
+	for (const auto& x : sdl_exit_code_map)
+	{
+		const struct sdl_exit_code_map_t* cur = &x;
+		if (cur->error == error)
+			return cur;
+	}
+	return nullptr;
+}
+
+static int sdl_map_error_to_exit_code(DWORD error)
+{
+	const struct sdl_exit_code_map_t* entry = sdl_map_entry_by_error(error);
+	if (entry)
+		return entry->code;
+
+	return SDL_EXIT_CONN_FAILED;
+}
+
+static const char* sdl_map_error_to_code_tag(UINT32 error)
+{
+	const struct sdl_exit_code_map_t* entry = sdl_map_entry_by_error(error);
+	if (entry)
+		return entry->code_tag;
+	return nullptr;
+}
+
+static const char* sdl_map_to_code_tag(int code)
+{
+	const struct sdl_exit_code_map_t* entry = sdl_map_entry_by_code(code);
+	if (entry)
+		return entry->code_tag;
+	return nullptr;
+}
+
+static int error_info_to_error(freerdp* instance, DWORD* pcode, char** msg, size_t* len)
+{
+	const DWORD code = freerdp_error_info(instance);
+	const char* name = freerdp_get_error_info_name(code);
+	const char* str = freerdp_get_error_info_string(code);
+	const int exit_code = sdl_map_error_to_exit_code(code);
+
+	winpr_asprintf(msg, len, "Terminate with %s due to ERROR_INFO %s [0x%08" PRIx32 "]: %s",
+	               sdl_map_error_to_code_tag(code), name, code, str);
+	WLog_DBG(SDL_TAG, "%s", *msg);
+	if (pcode)
+		*pcode = code;
+	return exit_code;
+}
+
+/* This function is called whenever a new frame starts.
+ * It can be used to reset invalidated areas. */
+static BOOL sdl_begin_paint(rdpContext* context)
+{
+	rdpGdi* gdi = nullptr;
+	auto sdl = get_context(context);
+
+	WINPR_ASSERT(sdl);
+
+	HANDLE handles[] = { sdl->update_complete.handle(), freerdp_abort_event(context) };
+	const DWORD status = WaitForMultipleObjects(ARRAYSIZE(handles), handles, FALSE, INFINITE);
+	switch (status)
+	{
+		case WAIT_OBJECT_0:
+			break;
+		default:
+			return FALSE;
+	}
+	sdl->update_complete.clear();
+
+	gdi = context->gdi;
+	WINPR_ASSERT(gdi);
+	WINPR_ASSERT(gdi->primary);
+	WINPR_ASSERT(gdi->primary->hdc);
+	WINPR_ASSERT(gdi->primary->hdc->hwnd);
+	WINPR_ASSERT(gdi->primary->hdc->hwnd->invalid);
+	gdi->primary->hdc->hwnd->invalid->null = TRUE;
+	gdi->primary->hdc->hwnd->ninvalid = 0;
+
+	return TRUE;
+}
+
+static BOOL sdl_redraw(SdlContext* sdl)
+{
+	WINPR_ASSERT(sdl);
+
+	auto gdi = sdl->context()->gdi;
+	return gdi_send_suppress_output(gdi, FALSE);
+}
+
+class SdlEventUpdateTriggerGuard
+{
+  private:
+	SdlContext* _sdl;
+
+  public:
+	explicit SdlEventUpdateTriggerGuard(SdlContext* sdl) : _sdl(sdl)
+	{
+	}
+	~SdlEventUpdateTriggerGuard()
+	{
+		_sdl->update_complete.set();
+	}
+	SdlEventUpdateTriggerGuard(const SdlEventUpdateTriggerGuard&) = delete;
+	SdlEventUpdateTriggerGuard(SdlEventUpdateTriggerGuard&&) = delete;
+	SdlEventUpdateTriggerGuard& operator=(const SdlEventUpdateTriggerGuard&) = delete;
+	SdlEventUpdateTriggerGuard& operator=(SdlEventUpdateTriggerGuard&&) = delete;
+};
+
+static bool sdl_draw_to_window_rect(SdlContext* sdl, SdlWindow& window, SDL_Surface* surface,
+                                    SDL_Point offset, const SDL_Rect& srcRect)
+{
+	SDL_Rect dstRect = { offset.x + srcRect.x, offset.y + srcRect.y, srcRect.w, srcRect.h };
+	return window.blit(surface, srcRect, dstRect);
+}
+
+static bool sdl_draw_to_window_rect(SdlContext* sdl, SdlWindow& window, SDL_Surface* surface,
+                                    SDL_Point offset, const std::vector<SDL_Rect>& rects = {})
+{
+	if (rects.empty())
+	{
+		return sdl_draw_to_window_rect(sdl, window, surface, offset,
+		                               { 0, 0, surface->w, surface->h });
+	}
+	for (auto& srcRect : rects)
+	{
+		if (!sdl_draw_to_window_rect(sdl, window, surface, offset, srcRect))
+			return false;
+	}
+	return true;
+}
+
+static bool sdl_draw_to_window_scaled_rect(SdlContext* sdl, SdlWindow& window, SDL_Surface* surface,
+                                           const SDL_Rect& srcRect)
+{
+	SDL_Rect dstRect = srcRect;
+	sdl_scale_coordinates(sdl, window.id(), &dstRect.x, &dstRect.y, FALSE, TRUE);
+	sdl_scale_coordinates(sdl, window.id(), &dstRect.w, &dstRect.h, FALSE, TRUE);
+	return window.blit(surface, srcRect, dstRect);
+}
+
+static BOOL sdl_draw_to_window_scaled_rect(SdlContext* sdl, SdlWindow& window, SDL_Surface* surface,
+                                           const std::vector<SDL_Rect>& rects = {})
+{
+	if (rects.empty())
+	{
+		return sdl_draw_to_window_scaled_rect(sdl, window, surface,
+		                                      { 0, 0, surface->w, surface->h });
+	}
+	for (const auto& srcRect : rects)
+	{
+		if (!sdl_draw_to_window_scaled_rect(sdl, window, surface, srcRect))
+			return FALSE;
+	}
+	return TRUE;
+}
+
+static BOOL sdl_draw_to_window(SdlContext* sdl, SdlWindow& window,
+                               const std::vector<SDL_Rect>& rects = {})
+{
+	WINPR_ASSERT(sdl);
+
+	auto context = sdl->context();
+	auto gdi = context->gdi;
+
+	auto size = window.rect();
+
+	if (!freerdp_settings_get_bool(context->settings, FreeRDP_SmartSizing))
+	{
+		if (gdi->width < size.w)
+		{
+			window.setOffsetX((size.w - gdi->width) / 2);
+		}
+		if (gdi->height < size.h)
+		{
+			window.setOffsetY((size.h - gdi->height) / 2);
+		}
+
+		auto surface = sdl->primary.get();
+		if (!sdl_draw_to_window_rect(sdl, window, surface, { window.offsetX(), window.offsetY() },
+		                             rects))
+			return FALSE;
+	}
+	else
+	{
+		if (!sdl_draw_to_window_scaled_rect(sdl, window, sdl->primary.get(), rects))
+			return FALSE;
+	}
+	window.updateSurface();
+	return TRUE;
+}
+
+static BOOL sdl_draw_to_window(SdlContext* sdl, std::map<Uint32, SdlWindow>& windows,
+                               const std::vector<SDL_Rect>& rects = {})
+{
+	for (auto& window : windows)
+	{
+		if (!sdl_draw_to_window(sdl, window.second, rects))
+			return FALSE;
+	}
+
+	return TRUE;
+}
+
+static BOOL sdl_end_paint_process(rdpContext* context)
+{
+	rdpGdi* gdi = nullptr;
+	auto sdl = get_context(context);
+
+	WINPR_ASSERT(context);
+
+	SdlEventUpdateTriggerGuard guard(sdl);
+
+	gdi = context->gdi;
+	WINPR_ASSERT(gdi);
+	WINPR_ASSERT(gdi->primary);
+	WINPR_ASSERT(gdi->primary->hdc);
+	WINPR_ASSERT(gdi->primary->hdc->hwnd);
+	WINPR_ASSERT(gdi->primary->hdc->hwnd->invalid);
+	if (gdi->suppressOutput || gdi->primary->hdc->hwnd->invalid->null)
+		return TRUE;
+
+	const INT32 ninvalid = gdi->primary->hdc->hwnd->ninvalid;
+	const GDI_RGN* cinvalid = gdi->primary->hdc->hwnd->cinvalid;
+
+	if (ninvalid < 1)
+		return TRUE;
+
+	std::vector<SDL_Rect> rects;
+	for (INT32 x = 0; x < ninvalid; x++)
+	{
+		auto& rgn = cinvalid[x];
+		rects.push_back({ rgn.x, rgn.y, rgn.w, rgn.h });
+	}
+
+	return sdl_draw_to_window(sdl, sdl->windows, rects);
+}
+
+/* This function is called when the library completed composing a new
+ * frame. Read out the changed areas and blit them to your output device.
+ * The image buffer will have the format specified by gdi_init
+ */
+static BOOL sdl_end_paint(rdpContext* context)
+{
+	auto sdl = get_context(context);
+	WINPR_ASSERT(sdl);
+
+	std::lock_guard<CriticalSection> lock(sdl->critical);
+	const BOOL rc = sdl_push_user_event(SDL_EVENT_USER_UPDATE, context);
+
+	return rc;
+}
+
+static void sdl_destroy_primary(SdlContext* sdl)
+{
+	if (!sdl)
+		return;
+	sdl->primary.reset();
+}
+
+/* Create a SDL surface from the GDI buffer */
+static BOOL sdl_create_primary(SdlContext* sdl)
+{
+	rdpGdi* gdi = nullptr;
+
+	WINPR_ASSERT(sdl);
+
+	gdi = sdl->context()->gdi;
+	WINPR_ASSERT(gdi);
+
+	sdl_destroy_primary(sdl);
+	sdl->primary =
+	    SDLSurfacePtr(SDL_CreateSurfaceFrom(static_cast<int>(gdi->width),
+	                                        static_cast<int>(gdi->height), sdl->sdl_pixel_format,
+	                                        gdi->primary_buffer, static_cast<int>(gdi->stride)),
+	                  SDL_DestroySurface);
+	if (!sdl->primary)
+		return FALSE;
+
+	SDL_SetSurfaceBlendMode(sdl->primary.get(), SDL_BLENDMODE_NONE);
+	SDL_Rect surfaceRect = { 0, 0, gdi->width, gdi->height };
+	SDL_FillSurfaceRect(sdl->primary.get(), &surfaceRect,
+	                    SDL_MapSurfaceRGBA(sdl->primary.get(), 0, 0, 0, 0xff));
+
+	return TRUE;
+}
+
+static BOOL sdl_desktop_resize(rdpContext* context)
+{
+	rdpGdi* gdi = nullptr;
+	rdpSettings* settings = nullptr;
+	auto sdl = get_context(context);
+
+	WINPR_ASSERT(sdl);
+	WINPR_ASSERT(context);
+
+	settings = context->settings;
+	WINPR_ASSERT(settings);
+
+	std::lock_guard<CriticalSection> lock(sdl->critical);
+	gdi = context->gdi;
+	if (!gdi_resize(gdi, freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth),
+	                freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight)))
+		return FALSE;
+	return sdl_create_primary(sdl);
+}
+
+/* This function is called to output a System BEEP */
+static BOOL sdl_play_sound(rdpContext* context, const PLAY_SOUND_UPDATE* play_sound)
+{
+	/* TODO: Implement */
+	WINPR_UNUSED(context);
+	WINPR_UNUSED(play_sound);
+	return TRUE;
+}
+
+static BOOL sdl_wait_for_init(SdlContext* sdl)
+{
+	WINPR_ASSERT(sdl);
+	sdl->initialize.set();
+
+	HANDLE handles[] = { sdl->initialized.handle(), freerdp_abort_event(sdl->context()) };
+
+	const DWORD rc = WaitForMultipleObjects(ARRAYSIZE(handles), handles, FALSE, INFINITE);
+	switch (rc)
+	{
+		case WAIT_OBJECT_0:
+			return TRUE;
+		default:
+			return FALSE;
+	}
+}
+
+/* Called before a connection is established.
+ * Set all configuration options to support and load channels here. */
+static BOOL sdl_pre_connect(freerdp* instance)
+{
+	WINPR_ASSERT(instance);
+	WINPR_ASSERT(instance->context);
+
+	auto sdl = get_context(instance->context);
+
+	auto settings = instance->context->settings;
+	WINPR_ASSERT(settings);
+
+	if (!freerdp_settings_set_bool(settings, FreeRDP_CertificateCallbackPreferPEM, TRUE))
+		return FALSE;
+
+	/* Optional OS identifier sent to server */
+	if (!freerdp_settings_set_uint32(settings, FreeRDP_OsMajorType, OSMAJORTYPE_UNIX))
+		return FALSE;
+	if (!freerdp_settings_set_uint32(settings, FreeRDP_OsMinorType, OSMINORTYPE_NATIVE_SDL))
+		return FALSE;
+	/* OrderSupport is initialized at this point.
+	 * Only override it if you plan to implement custom order
+	 * callbacks or deactivate certain features. */
+	/* Register the channel listeners.
+	 * They are required to set up / tear down channels if they are loaded. */
+	PubSub_SubscribeChannelConnected(instance->context->pubSub, sdl_OnChannelConnectedEventHandler);
+	PubSub_SubscribeChannelDisconnected(instance->context->pubSub,
+	                                    sdl_OnChannelDisconnectedEventHandler);
+
+	if (!freerdp_settings_get_bool(settings, FreeRDP_AuthenticationOnly))
+	{
+		UINT32 maxWidth = 0;
+		UINT32 maxHeight = 0;
+
+		if (!sdl_wait_for_init(sdl))
+			return FALSE;
+
+		std::lock_guard<CriticalSection> lock(sdl->critical);
+		if (!freerdp_settings_get_bool(settings, FreeRDP_UseCommonStdioCallbacks))
+			sdl->connection_dialog = std::make_unique<SDLConnectionDialog>(instance->context);
+		if (sdl->connection_dialog)
+		{
+			sdl->connection_dialog->setTitle("Connecting to '%s'",
+			                                 freerdp_settings_get_server_name(settings));
+			sdl->connection_dialog->showInfo(
+			    "The connection is being established\n\nPlease wait...");
+		}
+		if (!sdl_detect_monitors(sdl, &maxWidth, &maxHeight))
+			return FALSE;
+
+		if ((maxWidth != 0) && (maxHeight != 0) &&
+		    !freerdp_settings_get_bool(settings, FreeRDP_SmartSizing))
+		{
+			WLog_Print(sdl->log, WLOG_INFO, "Update size to %ux%u", maxWidth, maxHeight);
+			if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopWidth, maxWidth))
+				return FALSE;
+			if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopHeight, maxHeight))
+				return FALSE;
+		}
+	}
+	else
+	{
+		/* Check +auth-only has a username and password. */
+		if (!freerdp_settings_get_string(settings, FreeRDP_Password))
+		{
+			WLog_Print(sdl->log, WLOG_INFO, "auth-only, but no password set. Please provide one.");
+			return FALSE;
+		}
+
+		if (!freerdp_settings_set_bool(settings, FreeRDP_DeactivateClientDecoding, TRUE))
+			return FALSE;
+
+		WLog_Print(sdl->log, WLOG_INFO, "Authentication only. Don't connect SDL.");
+	}
+
+	/* TODO: Any code your client requires */
+	return TRUE;
+}
+
+static const char* sdl_window_get_title(rdpSettings* settings)
+{
+	const char* windowTitle = nullptr;
+	UINT32 port = 0;
+	BOOL addPort = 0;
+	const char* name = nullptr;
+	const char* prefix = "FreeRDP:";
+
+	if (!settings)
+		return nullptr;
+
+	windowTitle = freerdp_settings_get_string(settings, FreeRDP_WindowTitle);
+	if (windowTitle)
+		return windowTitle;
+
+	name = freerdp_settings_get_server_name(settings);
+	port = freerdp_settings_get_uint32(settings, FreeRDP_ServerPort);
+
+	addPort = (port != 3389);
+
+	char buffer[MAX_PATH + 64] = {};
+
+	if (!addPort)
+		(void)sprintf_s(buffer, sizeof(buffer), "%s %s", prefix, name);
+	else
+		(void)sprintf_s(buffer, sizeof(buffer), "%s %s:%" PRIu32, prefix, name, port);
+
+	if (!freerdp_settings_set_string(settings, FreeRDP_WindowTitle, buffer))
+		return nullptr;
+	return freerdp_settings_get_string(settings, FreeRDP_WindowTitle);
+}
+
+static void sdl_term_handler(int signum, const char* signame, void* context)
+{
+	sdl_push_quit();
+}
+
+static void sdl_cleanup_sdl(SdlContext* sdl)
+{
+	if (!sdl)
+		return;
+
+	std::lock_guard<CriticalSection> lock(sdl->critical);
+	sdl->windows.clear();
+	sdl->connection_dialog.reset();
+
+	sdl_destroy_primary(sdl);
+
+	freerdp_del_signal_cleanup_handler(sdl->context(), sdl_term_handler);
+	TTF_Quit();
+	SDL_Quit();
+}
+
+static BOOL sdl_create_windows(SdlContext* sdl)
+{
+	WINPR_ASSERT(sdl);
+
+	auto settings = sdl->context()->settings;
+	auto title = sdl_window_get_title(settings);
+
+	UINT32 windowCount = freerdp_settings_get_uint32(settings, FreeRDP_MonitorCount);
+
+	for (UINT32 x = 0; x < windowCount; x++)
+	{
+		auto id = sdl_monitor_id_for_index(sdl, x);
+		if (id < 0)
+			return FALSE;
+
+		auto monitor = static_cast<rdpMonitor*>(
+		    freerdp_settings_get_pointer_array_writable(settings, FreeRDP_MonitorDefArray, x));
+
+		auto w = WINPR_ASSERTING_INT_CAST(Uint32, monitor->width);
+		auto h = WINPR_ASSERTING_INT_CAST(Uint32, monitor->height);
+		if (!(freerdp_settings_get_bool(settings, FreeRDP_UseMultimon) ||
+		      freerdp_settings_get_bool(settings, FreeRDP_Fullscreen)))
+		{
+			w = freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
+			h = freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
+		}
+
+		Uint32 flags = 0;
+		auto startupX = SDL_WINDOWPOS_CENTERED_DISPLAY(id);
+		auto startupY = SDL_WINDOWPOS_CENTERED_DISPLAY(id);
+
+		if (monitor->attributes.desktopScaleFactor > 100)
+		{
+			flags |= SDL_WINDOW_HIGH_PIXEL_DENSITY;
+		}
+
+		if (freerdp_settings_get_bool(settings, FreeRDP_Fullscreen) &&
+		    !freerdp_settings_get_bool(settings, FreeRDP_UseMultimon))
+		{
+			flags |= SDL_WINDOW_FULLSCREEN;
+		}
+
+		if (freerdp_settings_get_bool(settings, FreeRDP_UseMultimon))
+		{
+			flags |= SDL_WINDOW_BORDERLESS;
+		}
+
+		if (!freerdp_settings_get_bool(settings, FreeRDP_Decorations))
+			flags |= SDL_WINDOW_BORDERLESS;
+
+		SdlWindow window{ title,
+			              static_cast<int>(startupX),
+			              static_cast<int>(startupY),
+			              static_cast<int>(w),
+			              static_cast<int>(h),
+			              flags };
+		ScopeGuard guard1([&]() { sdl->windows_created.set(); });
+		if (!window.window())
+			return FALSE;
+
+		if (freerdp_settings_get_bool(settings, FreeRDP_UseMultimon))
+		{
+			auto r = window.rect();
+			window.setOffsetX(0 - r.x);
+			window.setOffsetY(0 - r.y);
+		}
+
+		sdl->windows.insert({ window.id(), std::move(window) });
+	}
+
+	return TRUE;
+}
+
+static BOOL sdl_wait_create_windows(SdlContext* sdl)
+{
+	std::lock_guard<CriticalSection> lock(sdl->critical);
+	sdl->windows_created.clear();
+	if (!sdl_push_user_event(SDL_EVENT_USER_CREATE_WINDOWS, sdl))
+		return FALSE;
+
+	HANDLE handles[] = { sdl->initialized.handle(), freerdp_abort_event(sdl->context()) };
+
+	const DWORD rc = WaitForMultipleObjects(ARRAYSIZE(handles), handles, FALSE, INFINITE);
+	switch (rc)
+	{
+		case WAIT_OBJECT_0:
+			return TRUE;
+		default:
+			return FALSE;
+	}
+}
+
+static bool shall_abort(SdlContext* sdl)
+{
+	std::lock_guard<CriticalSection> lock(sdl->critical);
+	if (freerdp_shall_disconnect_context(sdl->context()))
+	{
+		if (sdl->rdp_thread_running)
+			return false;
+		if (!sdl->connection_dialog)
+			return true;
+		return !sdl->connection_dialog->running();
+	}
+	return false;
+}
+
+static int sdl_run(SdlContext* sdl)
+{
+	int rc = -1;
+	WINPR_ASSERT(sdl);
+
+	HANDLE handles[] = { sdl->initialize.handle(), freerdp_abort_event(sdl->context()) };
+	const DWORD status = WaitForMultipleObjects(ARRAYSIZE(handles), handles, FALSE, INFINITE);
+	switch (status)
+	{
+		case WAIT_OBJECT_0:
+			break;
+		default:
+			return -1;
+	}
+
+	SDL_Init(SDL_INIT_VIDEO);
+	TTF_Init();
+	SDL_SetHint(SDL_HINT_ALLOW_ALT_TAB_WHILE_GRABBED, "0");
+	SDL_SetHint(SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR, "0");
+
+	freerdp_add_signal_cleanup_handler(sdl->context(), sdl_term_handler);
+
+	sdl->initialized.set();
+
+	while (!shall_abort(sdl))
+	{
+		SDL_Event windowEvent = {};
+		while (!shall_abort(sdl) && SDL_WaitEventTimeout(nullptr, 1000))
+		{
+			/* Only poll standard SDL events and SDL_EVENT_USERS meant to create dialogs.
+			 * do not process the dialog return value events here.
+			 */
+			const int prc = SDL_PeepEvents(&windowEvent, 1, SDL_GETEVENT, SDL_EVENT_FIRST,
+			                               SDL_EVENT_USER_RETRY_DIALOG);
+			if (prc < 0)
+			{
+				if (sdl_log_error(prc, sdl->log, "SDL_PeepEvents"))
+					continue;
+			}
+
+#if defined(WITH_DEBUG_SDL_EVENTS)
+			SDL_Log("got event %s [0x%08" PRIx32 "]", sdl_event_type_str(windowEvent.type),
+			        windowEvent.type);
+#endif
+			std::lock_guard<CriticalSection> lock(sdl->critical);
+			/* The session might have been disconnected while we were waiting for a new SDL event.
+			 * In that case ignore the SDL event and terminate. */
+			if (freerdp_shall_disconnect_context(sdl->context()))
+				continue;
+
+			if (sdl->connection_dialog)
+			{
+				if (sdl->connection_dialog->handle(windowEvent))
+				{
+					continue;
+				}
+			}
+
+			switch (windowEvent.type)
+			{
+				case SDL_EVENT_QUIT:
+					freerdp_abort_connect_context(sdl->context());
+					break;
+				case SDL_EVENT_KEY_DOWN:
+				case SDL_EVENT_KEY_UP:
+				{
+					const SDL_KeyboardEvent* ev = &windowEvent.key;
+					sdl->input.keyboard_handle_event(ev);
+				}
+				break;
+				case SDL_EVENT_KEYMAP_CHANGED:
+				{
+				}
+				break; // TODO: Switch keyboard layout
+				case SDL_EVENT_MOUSE_MOTION:
+				{
+					const SDL_MouseMotionEvent* ev = &windowEvent.motion;
+					sdl_handle_mouse_motion(sdl, ev);
+				}
+				break;
+				case SDL_EVENT_MOUSE_BUTTON_DOWN:
+				case SDL_EVENT_MOUSE_BUTTON_UP:
+				{
+					const SDL_MouseButtonEvent* ev = &windowEvent.button;
+					sdl_handle_mouse_button(sdl, ev);
+				}
+				break;
+				case SDL_EVENT_MOUSE_WHEEL:
+				{
+					const SDL_MouseWheelEvent* ev = &windowEvent.wheel;
+					sdl_handle_mouse_wheel(sdl, ev);
+				}
+				break;
+				case SDL_EVENT_FINGER_DOWN:
+				{
+					const SDL_TouchFingerEvent* ev = &windowEvent.tfinger;
+					sdl_handle_touch_down(sdl, ev);
+				}
+				break;
+				case SDL_EVENT_FINGER_UP:
+				{
+					const SDL_TouchFingerEvent* ev = &windowEvent.tfinger;
+					sdl_handle_touch_up(sdl, ev);
+				}
+				break;
+				case SDL_EVENT_FINGER_MOTION:
+				{
+					const SDL_TouchFingerEvent* ev = &windowEvent.tfinger;
+					sdl_handle_touch_motion(sdl, ev);
+				}
+				break;
+
+				case SDL_EVENT_RENDER_TARGETS_RESET:
+					sdl_redraw(sdl);
+					break;
+				case SDL_EVENT_RENDER_DEVICE_RESET:
+					sdl_redraw(sdl);
+					break;
+				case SDL_EVENT_WILL_ENTER_FOREGROUND:
+					sdl_redraw(sdl);
+					break;
+				case SDL_EVENT_USER_CERT_DIALOG:
+				{
+					auto title = static_cast<const char*>(windowEvent.user.data1);
+					auto msg = static_cast<const char*>(windowEvent.user.data2);
+					sdl_cert_dialog_show(title, msg);
+				}
+				break;
+				case SDL_EVENT_USER_SHOW_DIALOG:
+				{
+					auto title = static_cast<const char*>(windowEvent.user.data1);
+					auto msg = static_cast<const char*>(windowEvent.user.data2);
+					sdl_message_dialog_show(title, msg, windowEvent.user.code);
+				}
+				break;
+				case SDL_EVENT_USER_SCARD_DIALOG:
+				{
+					auto title = static_cast<const char*>(windowEvent.user.data1);
+					auto msg = static_cast<const char**>(windowEvent.user.data2);
+					sdl_scard_dialog_show(title, windowEvent.user.code, msg);
+				}
+				break;
+				case SDL_EVENT_USER_AUTH_DIALOG:
+					sdl_auth_dialog_show(
+					    reinterpret_cast<const SDL_UserAuthArg*>(windowEvent.padding));
+					break;
+				case SDL_EVENT_USER_UPDATE:
+				{
+					auto context = static_cast<rdpContext*>(windowEvent.user.data1);
+					sdl_end_paint_process(context);
+				}
+				break;
+				case SDL_EVENT_USER_CREATE_WINDOWS:
+				{
+					auto ctx = static_cast<SdlContext*>(windowEvent.user.data1);
+					sdl_create_windows(ctx);
+				}
+				break;
+				case SDL_EVENT_USER_WINDOW_RESIZEABLE:
+				{
+					auto window = static_cast<SdlWindow*>(windowEvent.user.data1);
+					const bool use = windowEvent.user.code != 0;
+					if (window)
+						window->resizeable(use);
+				}
+				break;
+				case SDL_EVENT_USER_WINDOW_FULLSCREEN:
+				{
+					auto window = static_cast<SdlWindow*>(windowEvent.user.data1);
+					const bool enter = windowEvent.user.code != 0;
+					if (window)
+						window->fullscreen(enter);
+				}
+				break;
+				case SDL_EVENT_USER_WINDOW_MINIMIZE:
+					for (auto& window : sdl->windows)
+					{
+						window.second.minimize();
+					}
+					break;
+				case SDL_EVENT_USER_POINTER_NULL:
+					SDL_HideCursor();
+					break;
+				case SDL_EVENT_USER_POINTER_DEFAULT:
+				{
+					SDL_Cursor* def = SDL_GetDefaultCursor();
+					SDL_SetCursor(def);
+					SDL_ShowCursor();
+				}
+				break;
+				case SDL_EVENT_USER_POINTER_POSITION:
+				{
+					const auto x =
+					    static_cast<INT32>(reinterpret_cast<uintptr_t>(windowEvent.user.data1));
+					const auto y =
+					    static_cast<INT32>(reinterpret_cast<uintptr_t>(windowEvent.user.data2));
+
+					SDL_Window* window = SDL_GetMouseFocus();
+					if (window)
+					{
+						const Uint32 id = SDL_GetWindowID(window);
+
+						INT32 sx = x;
+						INT32 sy = y;
+						if (sdl_scale_coordinates(sdl, id, &sx, &sy, FALSE, FALSE))
+							SDL_WarpMouseInWindow(window, static_cast<float>(sx),
+							                      static_cast<float>(sy));
+					}
+				}
+				break;
+				case SDL_EVENT_USER_POINTER_SET:
+					sdl_Pointer_Set_Process(&windowEvent.user);
+					break;
+				case SDL_EVENT_CLIPBOARD_UPDATE:
+					sdl->clip.handle_update(windowEvent.clipboard);
+					break;
+				case SDL_EVENT_USER_QUIT:
+				default:
+					if ((windowEvent.type >= SDL_EVENT_DISPLAY_FIRST) &&
+					    (windowEvent.type <= SDL_EVENT_DISPLAY_LAST))
+					{
+						const SDL_DisplayEvent* ev = &windowEvent.display;
+						sdl->disp.handle_display_event(ev);
+					}
+					else if ((windowEvent.type >= SDL_EVENT_WINDOW_FIRST) &&
+					         (windowEvent.type <= SDL_EVENT_WINDOW_LAST))
+					{
+						const SDL_WindowEvent* ev = &windowEvent.window;
+						auto window = sdl->windows.find(ev->windowID);
+						if (window != sdl->windows.end())
+						{
+							sdl->disp.handle_window_event(ev);
+
+							switch (ev->type)
+							{
+								case SDL_EVENT_WINDOW_RESIZED:
+								case SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED:
+									window->second.fill();
+									window->second.updateSurface();
+									break;
+								case SDL_EVENT_WINDOW_MOVED:
+								{
+									auto r = window->second.rect();
+									auto id = window->second.id();
+									WLog_DBG(SDL_TAG, "%lu: %dx%d-%dx%d", id, r.x, r.y, r.w, r.h);
+								}
+								break;
+								default:
+									break;
+							}
+						}
+					}
+					break;
+			}
+		}
+	}
+
+	rc = 1;
+
+	sdl_cleanup_sdl(sdl);
+	return rc;
+}
+
+/* Called after a RDP connection was successfully established.
+ * Settings might have changed during negotiation of client / server feature
+ * support.
+ *
+ * Set up local framebuffers and paing callbacks.
+ * If required, register pointer callbacks to change the local mouse cursor
+ * when hovering over the RDP window
+ */
+static BOOL sdl_post_connect(freerdp* instance)
+{
+	WINPR_ASSERT(instance);
+
+	auto context = instance->context;
+	WINPR_ASSERT(context);
+
+	auto sdl = get_context(context);
+
+	// Retry was successful, discard dialog
+	sdl_hide_connection_dialog(sdl);
+
+	if (freerdp_settings_get_bool(context->settings, FreeRDP_AuthenticationOnly))
+	{
+		/* Check +auth-only has a username and password. */
+		if (!freerdp_settings_get_string(context->settings, FreeRDP_Password))
+		{
+			WLog_Print(sdl->log, WLOG_INFO, "auth-only, but no password set. Please provide one.");
+			return FALSE;
+		}
+
+		WLog_Print(sdl->log, WLOG_INFO, "Authentication only. Don't connect to X.");
+		return TRUE;
+	}
+
+	if (!sdl_wait_create_windows(sdl))
+		return FALSE;
+
+	sdl->sdl_pixel_format = SDL_PIXELFORMAT_BGRA32;
+	if (!gdi_init(instance, PIXEL_FORMAT_BGRA32))
+		return FALSE;
+
+	if (!sdl_create_primary(sdl))
+		return FALSE;
+
+	if (!sdl_register_pointer(instance->context->graphics))
+		return FALSE;
+
+	WINPR_ASSERT(context->update);
+
+	context->update->BeginPaint = sdl_begin_paint;
+	context->update->EndPaint = sdl_end_paint;
+	context->update->PlaySound = sdl_play_sound;
+	context->update->DesktopResize = sdl_desktop_resize;
+	context->update->SetKeyboardIndicators = sdlInput::keyboard_set_indicators;
+	context->update->SetKeyboardImeStatus = sdlInput::keyboard_set_ime_status;
+
+	sdl->update_resizeable(FALSE);
+	sdl->update_fullscreen(freerdp_settings_get_bool(context->settings, FreeRDP_Fullscreen) ||
+	                       freerdp_settings_get_bool(context->settings, FreeRDP_UseMultimon));
+	return TRUE;
+}
+
+/* This function is called whether a session ends by failure or success.
+ * Clean up everything allocated by pre_connect and post_connect.
+ */
+static void sdl_post_disconnect(freerdp* instance)
+{
+	if (!instance)
+		return;
+
+	if (!instance->context)
+		return;
+
+	PubSub_UnsubscribeChannelConnected(instance->context->pubSub,
+	                                   sdl_OnChannelConnectedEventHandler);
+	PubSub_UnsubscribeChannelDisconnected(instance->context->pubSub,
+	                                      sdl_OnChannelDisconnectedEventHandler);
+	gdi_free(instance);
+}
+
+static void sdl_post_final_disconnect(freerdp* instance)
+{
+	if (!instance)
+		return;
+
+	if (!instance->context)
+		return;
+}
+
+static void sdl_client_cleanup(SdlContext* sdl, int exit_code, const std::string& error_msg)
+{
+	WINPR_ASSERT(sdl);
+
+	rdpContext* context = sdl->context();
+	WINPR_ASSERT(context);
+	rdpSettings* settings = context->settings;
+	WINPR_ASSERT(settings);
+
+	sdl->rdp_thread_running = false;
+	bool showError = false;
+	if (freerdp_settings_get_bool(settings, FreeRDP_AuthenticationOnly))
+		WLog_Print(sdl->log, WLOG_INFO, "Authentication only, exit status %s [%" PRId32 "]",
+		           sdl_map_to_code_tag(exit_code), exit_code);
+	else
+	{
+		switch (exit_code)
+		{
+			case SDL_EXIT_SUCCESS:
+			case SDL_EXIT_DISCONNECT:
+			case SDL_EXIT_LOGOFF:
+			case SDL_EXIT_DISCONNECT_BY_USER:
+			case SDL_EXIT_CONNECT_CANCELLED:
+				break;
+			default:
+			{
+				std::lock_guard<CriticalSection> lock(sdl->critical);
+				if (sdl->connection_dialog && !error_msg.empty())
+				{
+					sdl->connection_dialog->showError(error_msg.c_str());
+					showError = true;
+				}
+			}
+			break;
+		}
+	}
+
+	if (!showError)
+		sdl_hide_connection_dialog(sdl);
+
+	sdl->exit_code = exit_code;
+	sdl_push_user_event(SDL_EVENT_USER_QUIT);
+	SDL_CleanupTLS();
+}
+
+static int sdl_client_thread_connect(SdlContext* sdl, std::string& error_msg)
+{
+	WINPR_ASSERT(sdl);
+
+	auto instance = sdl->context()->instance;
+	WINPR_ASSERT(instance);
+
+	sdl->rdp_thread_running = true;
+	BOOL rc = freerdp_connect(instance);
+
+	rdpContext* context = sdl->context();
+	rdpSettings* settings = context->settings;
+	WINPR_ASSERT(settings);
+
+	int exit_code = SDL_EXIT_SUCCESS;
+	if (!rc)
+	{
+		UINT32 error = freerdp_get_last_error(context);
+		exit_code = sdl_map_error_to_exit_code(error);
+	}
+
+	if (freerdp_settings_get_bool(settings, FreeRDP_AuthenticationOnly))
+	{
+		DWORD code = freerdp_get_last_error(context);
+		freerdp_abort_connect_context(context);
+		WLog_Print(sdl->log, WLOG_ERROR, "Authentication only, %s [0x%08" PRIx32 "] %s",
+		           freerdp_get_last_error_name(code), code, freerdp_get_last_error_string(code));
+		return exit_code;
+	}
+
+	if (!rc)
+	{
+		DWORD code = freerdp_error_info(instance);
+		if (exit_code == SDL_EXIT_SUCCESS)
+		{
+			char* msg = nullptr;
+			size_t len = 0;
+			exit_code = error_info_to_error(instance, &code, &msg, &len);
+			if (msg)
+				error_msg = msg;
+			free(msg);
+		}
+
+		auto last = freerdp_get_last_error(context);
+		if (error_msg.empty())
+		{
+			char* msg = nullptr;
+			size_t len = 0;
+			winpr_asprintf(&msg, &len, "%s [0x%08" PRIx32 "]\n%s",
+			               freerdp_get_last_error_name(last), last,
+			               freerdp_get_last_error_string(last));
+			if (msg)
+				error_msg = msg;
+			free(msg);
+		}
+
+		if (exit_code == SDL_EXIT_SUCCESS)
+		{
+			if (last == FREERDP_ERROR_AUTHENTICATION_FAILED)
+				exit_code = SDL_EXIT_AUTH_FAILURE;
+			else if (code == ERRINFO_SUCCESS)
+				exit_code = SDL_EXIT_CONN_FAILED;
+		}
+
+		sdl_hide_connection_dialog(sdl);
+	}
+
+	return exit_code;
+}
+
+static int sdl_client_thread_run(SdlContext* sdl, std::string& error_msg)
+{
+	WINPR_ASSERT(sdl);
+
+	auto context = sdl->context();
+	WINPR_ASSERT(context);
+
+	auto instance = context->instance;
+	WINPR_ASSERT(instance);
+
+	int exit_code = SDL_EXIT_SUCCESS;
+	while (!freerdp_shall_disconnect_context(context))
+	{
+		HANDLE handles[MAXIMUM_WAIT_OBJECTS] = {};
+		/*
+		 * win8 and server 2k12 seem to have some timing issue/race condition
+		 * when a initial sync request is send to sync the keyboard indicators
+		 * sending the sync event twice fixed this problem
+		 */
+		if (freerdp_focus_required(instance))
+		{
+			auto ctx = get_context(context);
+			WINPR_ASSERT(ctx);
+			if (!ctx->input.keyboard_focus_in())
+				break;
+			if (!ctx->input.keyboard_focus_in())
+				break;
+		}
+
+		const DWORD nCount = freerdp_get_event_handles(context, handles, ARRAYSIZE(handles));
+
+		if (nCount == 0)
+		{
+			WLog_Print(sdl->log, WLOG_ERROR, "freerdp_get_event_handles failed");
+			break;
+		}
+
+		const DWORD status = WaitForMultipleObjects(nCount, handles, FALSE, INFINITE);
+
+		if (status == WAIT_FAILED)
+			break;
+
+		if (!freerdp_check_event_handles(context))
+		{
+			if (client_auto_reconnect(instance))
+			{
+				// Retry was successful, discard dialog
+				sdl_hide_connection_dialog(sdl);
+				continue;
+			}
+			else
+			{
+				/*
+				 * Indicate an unsuccessful connection attempt if reconnect
+				 * did not succeed and no other error was specified.
+				 */
+				if (freerdp_error_info(instance) == 0)
+					exit_code = SDL_EXIT_CONN_FAILED;
+			}
+
+			if (freerdp_get_last_error(context) == FREERDP_ERROR_SUCCESS)
+				WLog_Print(sdl->log, WLOG_ERROR, "WaitForMultipleObjects failed with %" PRIu32 "",
+				           status);
+			if (freerdp_get_last_error(context) == FREERDP_ERROR_SUCCESS)
+				WLog_Print(sdl->log, WLOG_ERROR, "Failed to check FreeRDP event handles");
+			break;
+		}
+	}
+
+	if (exit_code == SDL_EXIT_SUCCESS)
+	{
+		DWORD code = 0;
+		{
+			char* emsg = nullptr;
+			size_t elen = 0;
+			exit_code = error_info_to_error(instance, &code, &emsg, &elen);
+			if (emsg)
+				error_msg = emsg;
+			free(emsg);
+		}
+
+		if ((code == ERRINFO_LOGOFF_BY_USER) &&
+		    (freerdp_get_disconnect_ultimatum(context) == Disconnect_Ultimatum_user_requested))
+		{
+			const char* msg = "Error info says user did not initiate but disconnect ultimatum says "
+			                  "they did; treat this as a user logoff";
+
+			char* emsg = nullptr;
+			size_t elen = 0;
+			winpr_asprintf(&emsg, &elen, "%s", msg);
+			if (emsg)
+				error_msg = emsg;
+			free(emsg);
+
+			/* This situation might be limited to Windows XP. */
+			WLog_Print(sdl->log, WLOG_INFO, "%s", msg);
+			exit_code = SDL_EXIT_LOGOFF;
+		}
+	}
+
+	freerdp_disconnect(instance);
+
+	return exit_code;
+}
+
+/* RDP main loop.
+ * Connects RDP, loops while running and handles event and dispatch, cleans up
+ * after the connection ends. */
+static DWORD WINAPI sdl_client_thread_proc(SdlContext* sdl)
+{
+	WINPR_ASSERT(sdl);
+
+	std::string error_msg;
+	int exit_code = sdl_client_thread_connect(sdl, error_msg);
+	if (exit_code == SDL_EXIT_SUCCESS)
+		exit_code = sdl_client_thread_run(sdl, error_msg);
+	sdl_client_cleanup(sdl, exit_code, error_msg);
+
+	return static_cast<DWORD>(exit_code);
+}
+
+/* Optional global initializer.
+ * Here we just register a signal handler to print out stack traces
+ * if available. */
+static BOOL sdl_client_global_init()
+{
+#if defined(_WIN32)
+	WSADATA wsaData = {};
+	const DWORD wVersionRequested = MAKEWORD(1, 1);
+	const int rc = WSAStartup(wVersionRequested, &wsaData);
+	if (rc != 0)
+	{
+		WLog_ERR(SDL_TAG, "WSAStartup failed with %s [%d]", gai_strerrorA(rc), rc);
+		return FALSE;
+	}
+#endif
+
+	return (freerdp_handle_signals() == 0);
+}
+
+/* Optional global tear down */
+static void sdl_client_global_uninit()
+{
+#if defined(_WIN32)
+	WSACleanup();
+#endif
+}
+
+static BOOL sdl_client_new(freerdp* instance, rdpContext* context)
+{
+	auto sdl = reinterpret_cast<sdl_rdp_context*>(context);
+
+	if (!instance || !context)
+		return FALSE;
+
+	sdl->sdl = new SdlContext(context);
+	if (!sdl->sdl)
+		return FALSE;
+
+	instance->PreConnect = sdl_pre_connect;
+	instance->PostConnect = sdl_post_connect;
+	instance->PostDisconnect = sdl_post_disconnect;
+	instance->PostFinalDisconnect = sdl_post_final_disconnect;
+	instance->AuthenticateEx = sdl_authenticate_ex;
+	instance->VerifyCertificateEx = sdl_verify_certificate_ex;
+	instance->VerifyChangedCertificateEx = sdl_verify_changed_certificate_ex;
+	instance->LogonErrorInfo = sdl_logon_error_info;
+	instance->PresentGatewayMessage = sdl_present_gateway_message;
+	instance->ChooseSmartcard = sdl_choose_smartcard;
+	instance->RetryDialog = sdl_retry_dialog;
+
+#ifdef WITH_WEBVIEW
+	instance->GetAccessToken = sdl_webview_get_access_token;
+#else
+	instance->GetAccessToken = client_cli_get_access_token;
+#endif
+	/* TODO: Client display set up */
+
+	return TRUE;
+}
+
+static void sdl_client_free(freerdp* instance, rdpContext* context)
+{
+	auto sdl = reinterpret_cast<sdl_rdp_context*>(context);
+
+	if (!context)
+		return;
+
+	delete sdl->sdl;
+}
+
+static int sdl_client_start(rdpContext* context)
+{
+	auto sdl = get_context(context);
+	WINPR_ASSERT(sdl);
+
+	sdl->thread = std::thread(sdl_client_thread_proc, sdl);
+	return 0;
+}
+
+static int sdl_client_stop(rdpContext* context)
+{
+	auto sdl = get_context(context);
+	WINPR_ASSERT(sdl);
+
+	/* We do not want to use freerdp_abort_connect_context here.
+	 * It would change the exit code and we do not want that. */
+	HANDLE event = freerdp_abort_event(context);
+	if (!SetEvent(event))
+		return -1;
+
+	sdl->thread.join();
+	return 0;
+}
+
+static int RdpClientEntry(RDP_CLIENT_ENTRY_POINTS* pEntryPoints)
+{
+	WINPR_ASSERT(pEntryPoints);
+
+	ZeroMemory(pEntryPoints, sizeof(RDP_CLIENT_ENTRY_POINTS));
+	pEntryPoints->Version = RDP_CLIENT_INTERFACE_VERSION;
+	pEntryPoints->Size = sizeof(RDP_CLIENT_ENTRY_POINTS_V1);
+	pEntryPoints->GlobalInit = sdl_client_global_init;
+	pEntryPoints->GlobalUninit = sdl_client_global_uninit;
+	pEntryPoints->ContextSize = sizeof(sdl_rdp_context);
+	pEntryPoints->ClientNew = sdl_client_new;
+	pEntryPoints->ClientFree = sdl_client_free;
+	pEntryPoints->ClientStart = sdl_client_start;
+	pEntryPoints->ClientStop = sdl_client_stop;
+	return 0;
+}
+
+static void context_free(sdl_rdp_context* sdl)
+{
+	if (sdl)
+		freerdp_client_context_free(&sdl->common.context);
+}
+
+static const char* category2str(int category)
+{
+	switch (category)
+	{
+		case SDL_LOG_CATEGORY_APPLICATION:
+			return "SDL_LOG_CATEGORY_APPLICATION";
+		case SDL_LOG_CATEGORY_ERROR:
+			return "SDL_LOG_CATEGORY_ERROR";
+		case SDL_LOG_CATEGORY_ASSERT:
+			return "SDL_LOG_CATEGORY_ASSERT";
+		case SDL_LOG_CATEGORY_SYSTEM:
+			return "SDL_LOG_CATEGORY_SYSTEM";
+		case SDL_LOG_CATEGORY_AUDIO:
+			return "SDL_LOG_CATEGORY_AUDIO";
+		case SDL_LOG_CATEGORY_VIDEO:
+			return "SDL_LOG_CATEGORY_VIDEO";
+		case SDL_LOG_CATEGORY_RENDER:
+			return "SDL_LOG_CATEGORY_RENDER";
+		case SDL_LOG_CATEGORY_INPUT:
+			return "SDL_LOG_CATEGORY_INPUT";
+		case SDL_LOG_CATEGORY_TEST:
+			return "SDL_LOG_CATEGORY_TEST";
+		case SDL_LOG_CATEGORY_GPU:
+			return "SDL_LOG_CATEGORY_GPU";
+		case SDL_LOG_CATEGORY_RESERVED2:
+			return "SDL_LOG_CATEGORY_RESERVED2";
+		case SDL_LOG_CATEGORY_RESERVED3:
+			return "SDL_LOG_CATEGORY_RESERVED3";
+		case SDL_LOG_CATEGORY_RESERVED4:
+			return "SDL_LOG_CATEGORY_RESERVED4";
+		case SDL_LOG_CATEGORY_RESERVED5:
+			return "SDL_LOG_CATEGORY_RESERVED5";
+		case SDL_LOG_CATEGORY_RESERVED6:
+			return "SDL_LOG_CATEGORY_RESERVED6";
+		case SDL_LOG_CATEGORY_RESERVED7:
+			return "SDL_LOG_CATEGORY_RESERVED7";
+		case SDL_LOG_CATEGORY_RESERVED8:
+			return "SDL_LOG_CATEGORY_RESERVED8";
+		case SDL_LOG_CATEGORY_RESERVED9:
+			return "SDL_LOG_CATEGORY_RESERVED9";
+		case SDL_LOG_CATEGORY_RESERVED10:
+			return "SDL_LOG_CATEGORY_RESERVED10";
+		case SDL_LOG_CATEGORY_CUSTOM:
+		default:
+			return "SDL_LOG_CATEGORY_CUSTOM";
+	}
+}
+
+static SDL_LogPriority wloglevel2dl(DWORD level)
+{
+	switch (level)
+	{
+		case WLOG_TRACE:
+			return SDL_LOG_PRIORITY_VERBOSE;
+		case WLOG_DEBUG:
+			return SDL_LOG_PRIORITY_DEBUG;
+		case WLOG_INFO:
+			return SDL_LOG_PRIORITY_INFO;
+		case WLOG_WARN:
+			return SDL_LOG_PRIORITY_WARN;
+		case WLOG_ERROR:
+			return SDL_LOG_PRIORITY_ERROR;
+		case WLOG_FATAL:
+			return SDL_LOG_PRIORITY_CRITICAL;
+		case WLOG_OFF:
+		default:
+			return SDL_LOG_PRIORITY_VERBOSE;
+	}
+}
+
+static DWORD sdlpriority2wlog(SDL_LogPriority priority)
+{
+	DWORD level = WLOG_OFF;
+	switch (priority)
+	{
+		case SDL_LOG_PRIORITY_VERBOSE:
+			level = WLOG_TRACE;
+			break;
+		case SDL_LOG_PRIORITY_DEBUG:
+			level = WLOG_DEBUG;
+			break;
+		case SDL_LOG_PRIORITY_INFO:
+			level = WLOG_INFO;
+			break;
+		case SDL_LOG_PRIORITY_WARN:
+			level = WLOG_WARN;
+			break;
+		case SDL_LOG_PRIORITY_ERROR:
+			level = WLOG_ERROR;
+			break;
+		case SDL_LOG_PRIORITY_CRITICAL:
+			level = WLOG_FATAL;
+			break;
+		default:
+			break;
+	}
+
+	return level;
+}
+
+static void SDLCALL winpr_LogOutputFunction(void* userdata, int category, SDL_LogPriority priority,
+                                            const char* message)
+{
+	auto sdl = static_cast<SdlContext*>(userdata);
+	WINPR_ASSERT(sdl);
+
+	const DWORD level = sdlpriority2wlog(priority);
+	auto log = sdl->log;
+	if (!WLog_IsLevelActive(log, level))
+		return;
+
+	WLog_PrintMessage(log, WLOG_MESSAGE_TEXT, level, __LINE__, __FILE__, __func__, "[%s] %s",
+	                  category2str(category), message);
+}
+
+int main(int argc, char* argv[])
+{
+	int rc = -1;
+	int status = 0;
+	RDP_CLIENT_ENTRY_POINTS clientEntryPoints = {};
+
+	freerdp_client_warn_experimental(argc, argv);
+
+	RdpClientEntry(&clientEntryPoints);
+	std::unique_ptr<sdl_rdp_context, void (*)(sdl_rdp_context*)> sdl_rdp(
+	    reinterpret_cast<sdl_rdp_context*>(freerdp_client_context_new(&clientEntryPoints)),
+	    context_free);
+
+	if (!sdl_rdp)
+		return -1;
+	auto sdl = sdl_rdp->sdl;
+
+	auto settings = sdl->context()->settings;
+	WINPR_ASSERT(settings);
+
+	status = freerdp_client_settings_parse_command_line(settings, argc, argv, FALSE);
+	if (status)
+	{
+		rc = freerdp_client_settings_command_line_status_print(settings, status, argc, argv);
+		if (freerdp_settings_get_bool(settings, FreeRDP_ListMonitors))
+			sdl_list_monitors(sdl);
+		else
+		{
+			switch (status)
+			{
+				case COMMAND_LINE_STATUS_PRINT:
+				case COMMAND_LINE_STATUS_PRINT_VERSION:
+				case COMMAND_LINE_STATUS_PRINT_BUILDCONFIG:
+					break;
+				case COMMAND_LINE_STATUS_PRINT_HELP:
+				default:
+					SdlPref::print_config_file_help(3);
+					break;
+			}
+		}
+		return rc;
+	}
+
+	SDL_SetLogOutputFunction(winpr_LogOutputFunction, sdl);
+	auto level = WLog_GetLogLevel(sdl->log);
+	SDL_SetLogPriorities(wloglevel2dl(level));
+
+	auto context = sdl->context();
+	WINPR_ASSERT(context);
+
+	if (!stream_dump_register_handlers(context, CONNECTION_STATE_MCS_CREATE_REQUEST, FALSE))
+		return -1;
+
+	if (freerdp_client_start(context) != 0)
+		return -1;
+
+	rc = sdl_run(sdl);
+
+	if (freerdp_client_stop(context) != 0)
+		return -1;
+
+	if (sdl->exit_code != 0)
+		rc = sdl->exit_code;
+
+	return rc;
+}
+
+BOOL SdlContext::update_fullscreen(BOOL enter)
+{
+	std::lock_guard<CriticalSection> lock(critical);
+	for (const auto& window : windows)
+	{
+		if (!sdl_push_user_event(SDL_EVENT_USER_WINDOW_FULLSCREEN, &window.second, enter))
+			return FALSE;
+	}
+	fullscreen = enter;
+	return TRUE;
+}
+
+BOOL SdlContext::update_minimize()
+{
+	std::lock_guard<CriticalSection> lock(critical);
+	return sdl_push_user_event(SDL_EVENT_USER_WINDOW_MINIMIZE);
+}
+
+BOOL SdlContext::update_resizeable(BOOL enable)
+{
+	std::lock_guard<CriticalSection> lock(critical);
+
+	const auto settings = context()->settings;
+	const BOOL dyn = freerdp_settings_get_bool(settings, FreeRDP_DynamicResolutionUpdate);
+	const BOOL smart = freerdp_settings_get_bool(settings, FreeRDP_SmartSizing);
+	BOOL use = (dyn && enable) || smart;
+
+	for (const auto& window : windows)
+	{
+		if (!sdl_push_user_event(SDL_EVENT_USER_WINDOW_RESIZEABLE, &window.second, use))
+			return FALSE;
+	}
+	resizeable = use;
+
+	return TRUE;
+}
+
+SdlContext::SdlContext(rdpContext* context)
+    : _context(context), log(WLog_Get(SDL_TAG)), update_complete(true), disp(this), input(this),
+      clip(this), primary(nullptr, SDL_DestroySurface), rdp_thread_running(false)
+{
+	WINPR_ASSERT(context);
+	grab_kbd_enabled = freerdp_settings_get_bool(context->settings, FreeRDP_GrabKeyboard);
+}
+
+rdpContext* SdlContext::context() const
+{
+	return _context;
+}
+
+rdpClientContext* SdlContext::common() const
+{
+	return reinterpret_cast<rdpClientContext*>(_context);
+}

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

@@ -0,0 +1,97 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client
+ *
+ * Copyright 2022 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 <thread>
+#include <map>
+#include <atomic>
+
+#include <freerdp/freerdp.h>
+#include <freerdp/client/rdpei.h>
+#include <freerdp/client/rail.h>
+#include <freerdp/client/cliprdr.h>
+#include <freerdp/client/rdpgfx.h>
+
+#include <SDL3/SDL.h>
+#include <SDL3/SDL_video.h>
+
+#include "sdl_types.hpp"
+#include "sdl_disp.hpp"
+#include "sdl_kbd.hpp"
+#include "sdl_clip.hpp"
+#include "sdl_utils.hpp"
+#include "sdl_window.hpp"
+#include "dialogs/sdl_connection_dialog.hpp"
+
+using SDLSurfacePtr = std::unique_ptr<SDL_Surface, decltype(&SDL_DestroySurface)>;
+
+class SdlContext
+{
+  public:
+	explicit SdlContext(rdpContext* context);
+	SdlContext(const SdlContext& other) = delete;
+	SdlContext(SdlContext&& other) = delete;
+
+	SdlContext& operator=(const SdlContext& other) = delete;
+	SdlContext& operator=(SdlContext&& other) = delete;
+
+  private:
+	rdpContext* _context;
+
+  public:
+	wLog* log;
+
+	/* SDL */
+	bool fullscreen = false;
+	bool resizeable = false;
+	bool grab_mouse = false;
+	bool grab_kbd = false;
+	bool grab_kbd_enabled = true;
+
+	std::map<Uint32, SdlWindow> windows;
+
+	CriticalSection critical;
+	std::thread thread;
+	WinPREvent initialize;
+	WinPREvent initialized;
+	WinPREvent update_complete;
+	WinPREvent windows_created;
+	int exit_code = -1;
+
+	sdlDispContext disp;
+	sdlInput input;
+	sdlClip clip;
+
+	SDLSurfacePtr primary;
+
+	SDL_PixelFormat sdl_pixel_format = SDL_PIXELFORMAT_UNKNOWN;
+
+	std::unique_ptr<SDLConnectionDialog> connection_dialog;
+
+	std::atomic<bool> rdp_thread_running;
+
+	BOOL update_resizeable(BOOL enable);
+	BOOL update_fullscreen(BOOL enter);
+	BOOL update_minimize();
+
+	[[nodiscard]] rdpContext* context() const;
+	[[nodiscard]] rdpClientContext* common() const;
+};

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

@@ -0,0 +1,550 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP SDL keyboard helper
+ *
+ * Copyright 2022 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_kbd.hpp"
+#include "sdl_disp.hpp"
+#include "sdl_freerdp.hpp"
+#include "sdl_utils.hpp"
+#include "sdl_prefs.hpp"
+
+#include <SDL3/SDL_oldnames.h>
+
+#include <map>
+
+#include <freerdp/utils/string.h>
+#include <freerdp/scancode.h>
+
+#include <freerdp/log.h>
+#define TAG CLIENT_TAG("SDL.kbd")
+
+typedef struct
+{
+	Uint32 sdl;
+	const char* sdl_name;
+	UINT32 rdp;
+	const char* rdp_name;
+} scancode_entry_t;
+
+#define STR(x) #x
+#define ENTRY(x, y)      \
+	{                    \
+		x, STR(x), y, #y \
+	}
+static const scancode_entry_t map[] = {
+	ENTRY(SDL_SCANCODE_UNKNOWN, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_A, RDP_SCANCODE_KEY_A),
+	ENTRY(SDL_SCANCODE_B, RDP_SCANCODE_KEY_B),
+	ENTRY(SDL_SCANCODE_C, RDP_SCANCODE_KEY_C),
+	ENTRY(SDL_SCANCODE_D, RDP_SCANCODE_KEY_D),
+	ENTRY(SDL_SCANCODE_E, RDP_SCANCODE_KEY_E),
+	ENTRY(SDL_SCANCODE_F, RDP_SCANCODE_KEY_F),
+	ENTRY(SDL_SCANCODE_G, RDP_SCANCODE_KEY_G),
+	ENTRY(SDL_SCANCODE_H, RDP_SCANCODE_KEY_H),
+	ENTRY(SDL_SCANCODE_I, RDP_SCANCODE_KEY_I),
+	ENTRY(SDL_SCANCODE_J, RDP_SCANCODE_KEY_J),
+	ENTRY(SDL_SCANCODE_K, RDP_SCANCODE_KEY_K),
+	ENTRY(SDL_SCANCODE_L, RDP_SCANCODE_KEY_L),
+	ENTRY(SDL_SCANCODE_M, RDP_SCANCODE_KEY_M),
+	ENTRY(SDL_SCANCODE_N, RDP_SCANCODE_KEY_N),
+	ENTRY(SDL_SCANCODE_O, RDP_SCANCODE_KEY_O),
+	ENTRY(SDL_SCANCODE_P, RDP_SCANCODE_KEY_P),
+	ENTRY(SDL_SCANCODE_Q, RDP_SCANCODE_KEY_Q),
+	ENTRY(SDL_SCANCODE_R, RDP_SCANCODE_KEY_R),
+	ENTRY(SDL_SCANCODE_S, RDP_SCANCODE_KEY_S),
+	ENTRY(SDL_SCANCODE_T, RDP_SCANCODE_KEY_T),
+	ENTRY(SDL_SCANCODE_U, RDP_SCANCODE_KEY_U),
+	ENTRY(SDL_SCANCODE_V, RDP_SCANCODE_KEY_V),
+	ENTRY(SDL_SCANCODE_W, RDP_SCANCODE_KEY_W),
+	ENTRY(SDL_SCANCODE_X, RDP_SCANCODE_KEY_X),
+	ENTRY(SDL_SCANCODE_Y, RDP_SCANCODE_KEY_Y),
+	ENTRY(SDL_SCANCODE_Z, RDP_SCANCODE_KEY_Z),
+	ENTRY(SDL_SCANCODE_1, RDP_SCANCODE_KEY_1),
+	ENTRY(SDL_SCANCODE_2, RDP_SCANCODE_KEY_2),
+	ENTRY(SDL_SCANCODE_3, RDP_SCANCODE_KEY_3),
+	ENTRY(SDL_SCANCODE_4, RDP_SCANCODE_KEY_4),
+	ENTRY(SDL_SCANCODE_5, RDP_SCANCODE_KEY_5),
+	ENTRY(SDL_SCANCODE_6, RDP_SCANCODE_KEY_6),
+	ENTRY(SDL_SCANCODE_7, RDP_SCANCODE_KEY_7),
+	ENTRY(SDL_SCANCODE_8, RDP_SCANCODE_KEY_8),
+	ENTRY(SDL_SCANCODE_9, RDP_SCANCODE_KEY_9),
+	ENTRY(SDL_SCANCODE_0, RDP_SCANCODE_KEY_0),
+	ENTRY(SDL_SCANCODE_RETURN, RDP_SCANCODE_RETURN),
+	ENTRY(SDL_SCANCODE_ESCAPE, RDP_SCANCODE_ESCAPE),
+	ENTRY(SDL_SCANCODE_BACKSPACE, RDP_SCANCODE_BACKSPACE),
+	ENTRY(SDL_SCANCODE_TAB, RDP_SCANCODE_TAB),
+	ENTRY(SDL_SCANCODE_SPACE, RDP_SCANCODE_SPACE),
+	ENTRY(SDL_SCANCODE_MINUS, RDP_SCANCODE_OEM_MINUS),
+	ENTRY(SDL_SCANCODE_CAPSLOCK, RDP_SCANCODE_CAPSLOCK),
+	ENTRY(SDL_SCANCODE_F1, RDP_SCANCODE_F1),
+	ENTRY(SDL_SCANCODE_F2, RDP_SCANCODE_F2),
+	ENTRY(SDL_SCANCODE_F3, RDP_SCANCODE_F3),
+	ENTRY(SDL_SCANCODE_F4, RDP_SCANCODE_F4),
+	ENTRY(SDL_SCANCODE_F5, RDP_SCANCODE_F5),
+	ENTRY(SDL_SCANCODE_F6, RDP_SCANCODE_F6),
+	ENTRY(SDL_SCANCODE_F7, RDP_SCANCODE_F7),
+	ENTRY(SDL_SCANCODE_F8, RDP_SCANCODE_F8),
+	ENTRY(SDL_SCANCODE_F9, RDP_SCANCODE_F9),
+	ENTRY(SDL_SCANCODE_F10, RDP_SCANCODE_F10),
+	ENTRY(SDL_SCANCODE_F11, RDP_SCANCODE_F11),
+	ENTRY(SDL_SCANCODE_F12, RDP_SCANCODE_F12),
+	ENTRY(SDL_SCANCODE_F13, RDP_SCANCODE_F13),
+	ENTRY(SDL_SCANCODE_F14, RDP_SCANCODE_F14),
+	ENTRY(SDL_SCANCODE_F15, RDP_SCANCODE_F15),
+	ENTRY(SDL_SCANCODE_F16, RDP_SCANCODE_F16),
+	ENTRY(SDL_SCANCODE_F17, RDP_SCANCODE_F17),
+	ENTRY(SDL_SCANCODE_F18, RDP_SCANCODE_F18),
+	ENTRY(SDL_SCANCODE_F19, RDP_SCANCODE_F19),
+	ENTRY(SDL_SCANCODE_F20, RDP_SCANCODE_F20),
+	ENTRY(SDL_SCANCODE_F21, RDP_SCANCODE_F21),
+	ENTRY(SDL_SCANCODE_F22, RDP_SCANCODE_F22),
+	ENTRY(SDL_SCANCODE_F23, RDP_SCANCODE_F23),
+	ENTRY(SDL_SCANCODE_F24, RDP_SCANCODE_F24),
+	ENTRY(SDL_SCANCODE_NUMLOCKCLEAR, RDP_SCANCODE_NUMLOCK),
+	ENTRY(SDL_SCANCODE_KP_DIVIDE, RDP_SCANCODE_DIVIDE),
+	ENTRY(SDL_SCANCODE_KP_MULTIPLY, RDP_SCANCODE_MULTIPLY),
+	ENTRY(SDL_SCANCODE_KP_MINUS, RDP_SCANCODE_SUBTRACT),
+	ENTRY(SDL_SCANCODE_KP_PLUS, RDP_SCANCODE_ADD),
+	ENTRY(SDL_SCANCODE_KP_ENTER, RDP_SCANCODE_RETURN_KP),
+	ENTRY(SDL_SCANCODE_KP_1, RDP_SCANCODE_NUMPAD1),
+	ENTRY(SDL_SCANCODE_KP_2, RDP_SCANCODE_NUMPAD2),
+	ENTRY(SDL_SCANCODE_KP_3, RDP_SCANCODE_NUMPAD3),
+	ENTRY(SDL_SCANCODE_KP_4, RDP_SCANCODE_NUMPAD4),
+	ENTRY(SDL_SCANCODE_KP_5, RDP_SCANCODE_NUMPAD5),
+	ENTRY(SDL_SCANCODE_KP_6, RDP_SCANCODE_NUMPAD6),
+	ENTRY(SDL_SCANCODE_KP_7, RDP_SCANCODE_NUMPAD7),
+	ENTRY(SDL_SCANCODE_KP_8, RDP_SCANCODE_NUMPAD8),
+	ENTRY(SDL_SCANCODE_KP_9, RDP_SCANCODE_NUMPAD9),
+	ENTRY(SDL_SCANCODE_KP_0, RDP_SCANCODE_NUMPAD0),
+	ENTRY(SDL_SCANCODE_KP_PERIOD, RDP_SCANCODE_OEM_PERIOD),
+	ENTRY(SDL_SCANCODE_LCTRL, RDP_SCANCODE_LCONTROL),
+	ENTRY(SDL_SCANCODE_LSHIFT, RDP_SCANCODE_LSHIFT),
+	ENTRY(SDL_SCANCODE_LALT, RDP_SCANCODE_LMENU),
+	ENTRY(SDL_SCANCODE_LGUI, RDP_SCANCODE_LWIN),
+	ENTRY(SDL_SCANCODE_RCTRL, RDP_SCANCODE_RCONTROL),
+	ENTRY(SDL_SCANCODE_RSHIFT, RDP_SCANCODE_RSHIFT),
+	ENTRY(SDL_SCANCODE_RALT, RDP_SCANCODE_RMENU),
+	ENTRY(SDL_SCANCODE_RGUI, RDP_SCANCODE_RWIN),
+	ENTRY(SDL_SCANCODE_MODE, RDP_SCANCODE_APPS),
+	ENTRY(SDL_SCANCODE_MUTE, RDP_SCANCODE_VOLUME_MUTE),
+	ENTRY(SDL_SCANCODE_VOLUMEUP, RDP_SCANCODE_VOLUME_UP),
+	ENTRY(SDL_SCANCODE_VOLUMEDOWN, RDP_SCANCODE_VOLUME_DOWN),
+	ENTRY(SDL_SCANCODE_GRAVE, RDP_SCANCODE_OEM_3),
+	ENTRY(SDL_SCANCODE_COMMA, RDP_SCANCODE_OEM_COMMA),
+	ENTRY(SDL_SCANCODE_PERIOD, RDP_SCANCODE_OEM_PERIOD),
+	ENTRY(SDL_SCANCODE_SLASH, RDP_SCANCODE_OEM_2),
+	ENTRY(SDL_SCANCODE_BACKSLASH, RDP_SCANCODE_OEM_5),
+	ENTRY(SDL_SCANCODE_SCROLLLOCK, RDP_SCANCODE_SCROLLLOCK),
+	ENTRY(SDL_SCANCODE_INSERT, RDP_SCANCODE_INSERT),
+	ENTRY(SDL_SCANCODE_PRINTSCREEN, RDP_SCANCODE_PRINTSCREEN),
+	ENTRY(SDL_SCANCODE_HOME, RDP_SCANCODE_HOME),
+	ENTRY(SDL_SCANCODE_DELETE, RDP_SCANCODE_DELETE),
+	ENTRY(SDL_SCANCODE_RIGHT, RDP_SCANCODE_RIGHT),
+	ENTRY(SDL_SCANCODE_LEFT, RDP_SCANCODE_LEFT),
+	ENTRY(SDL_SCANCODE_DOWN, RDP_SCANCODE_DOWN),
+	ENTRY(SDL_SCANCODE_UP, RDP_SCANCODE_UP),
+	ENTRY(SDL_SCANCODE_SEMICOLON, RDP_SCANCODE_OEM_1),
+	ENTRY(SDL_SCANCODE_PAUSE, RDP_SCANCODE_PAUSE),
+	ENTRY(SDL_SCANCODE_PAGEUP, RDP_SCANCODE_PRIOR),
+	ENTRY(SDL_SCANCODE_END, RDP_SCANCODE_END),
+	ENTRY(SDL_SCANCODE_PAGEDOWN, RDP_SCANCODE_NEXT),
+	ENTRY(SDL_SCANCODE_MEDIA_NEXT_TRACK, RDP_SCANCODE_MEDIA_NEXT_TRACK),
+	ENTRY(SDL_SCANCODE_MEDIA_PREVIOUS_TRACK, RDP_SCANCODE_MEDIA_PREV_TRACK),
+	ENTRY(SDL_SCANCODE_MEDIA_STOP, RDP_SCANCODE_MEDIA_STOP),
+	ENTRY(SDL_SCANCODE_MEDIA_PLAY, RDP_SCANCODE_MEDIA_PLAY_PAUSE),
+	ENTRY(SDL_SCANCODE_MUTE, RDP_SCANCODE_VOLUME_MUTE),
+	ENTRY(SDL_SCANCODE_MEDIA_SELECT, RDP_SCANCODE_LAUNCH_MEDIA_SELECT),
+	ENTRY(SDL_SCANCODE_SYSREQ, RDP_SCANCODE_SYSREQ),
+	ENTRY(SDL_SCANCODE_LEFTBRACKET, RDP_SCANCODE_OEM_4),
+	ENTRY(SDL_SCANCODE_RIGHTBRACKET, RDP_SCANCODE_OEM_6),
+	ENTRY(SDL_SCANCODE_APOSTROPHE, RDP_SCANCODE_OEM_7),
+	ENTRY(SDL_SCANCODE_NONUSBACKSLASH, RDP_SCANCODE_OEM_102),
+	ENTRY(SDL_SCANCODE_SLEEP, RDP_SCANCODE_SLEEP),
+	ENTRY(SDL_SCANCODE_EQUALS, RDP_SCANCODE_OEM_PLUS),
+	ENTRY(SDL_SCANCODE_KP_COMMA, RDP_SCANCODE_DECIMAL),
+	ENTRY(SDL_SCANCODE_FIND, RDP_SCANCODE_BROWSER_SEARCH),
+	ENTRY(SDL_SCANCODE_RETURN2, RDP_SCANCODE_RETURN_KP),
+	ENTRY(SDL_SCANCODE_AC_SEARCH, RDP_SCANCODE_BROWSER_SEARCH),
+	ENTRY(SDL_SCANCODE_AC_HOME, RDP_SCANCODE_BROWSER_HOME),
+	ENTRY(SDL_SCANCODE_AC_BACK, RDP_SCANCODE_BROWSER_BACK),
+	ENTRY(SDL_SCANCODE_AC_FORWARD, RDP_SCANCODE_BROWSER_FORWARD),
+	ENTRY(SDL_SCANCODE_AC_STOP, RDP_SCANCODE_BROWSER_STOP),
+
+	ENTRY(SDL_SCANCODE_NONUSHASH, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_APPLICATION, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_POWER, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_EQUALS, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_EXECUTE, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_HELP, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_MENU, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_SELECT, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_STOP, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_AGAIN, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_UNDO, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_CUT, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_COPY, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_PASTE, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_EQUALSAS400, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_INTERNATIONAL1, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_INTERNATIONAL2, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_INTERNATIONAL3, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_INTERNATIONAL4, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_INTERNATIONAL5, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_INTERNATIONAL6, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_INTERNATIONAL7, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_INTERNATIONAL8, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_INTERNATIONAL9, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_LANG1, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_LANG2, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_LANG3, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_LANG4, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_LANG5, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_LANG6, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_LANG7, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_LANG8, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_LANG9, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_ALTERASE, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_CANCEL, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_CLEAR, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_PRIOR, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_SEPARATOR, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_OUT, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_OPER, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_CLEARAGAIN, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_CRSEL, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_EXSEL, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_00, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_000, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_THOUSANDSSEPARATOR, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_DECIMALSEPARATOR, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_CURRENCYUNIT, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_CURRENCYSUBUNIT, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_LEFTPAREN, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_RIGHTPAREN, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_LEFTBRACE, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_RIGHTBRACE, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_TAB, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_BACKSPACE, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_A, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_B, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_C, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_D, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_E, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_F, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_XOR, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_POWER, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_PERCENT, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_LESS, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_GREATER, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_AMPERSAND, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_DBLAMPERSAND, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_VERTICALBAR, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_DBLVERTICALBAR, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_COLON, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_HASH, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_SPACE, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_AT, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_EXCLAM, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_MEMSTORE, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_MEMRECALL, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_MEMCLEAR, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_MEMADD, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_MEMSUBTRACT, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_MEMMULTIPLY, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_MEMDIVIDE, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_PLUSMINUS, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_CLEAR, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_CLEARENTRY, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_BINARY, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_OCTAL, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_DECIMAL, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_KP_HEXADECIMAL, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_AC_REFRESH, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_AC_BOOKMARKS, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_MEDIA_EJECT, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_MEDIA_REWIND, RDP_SCANCODE_UNKNOWN),
+	ENTRY(SDL_SCANCODE_MEDIA_FAST_FORWARD, RDP_SCANCODE_UNKNOWN)
+};
+
+static UINT32 sdl_get_kbd_flags()
+{
+	UINT32 flags = 0;
+
+	SDL_Keymod mod = SDL_GetModState();
+	if ((mod & SDL_KMOD_NUM) != 0)
+		flags |= KBD_SYNC_NUM_LOCK;
+	if ((mod & SDL_KMOD_CAPS) != 0)
+		flags |= KBD_SYNC_CAPS_LOCK;
+	if ((mod & SDL_KMOD_SCROLL) != 0)
+		flags |= KBD_SYNC_SCROLL_LOCK;
+
+	// TODO: KBD_SYNC_KANA_LOCK
+
+	return flags;
+}
+
+BOOL sdlInput::keyboard_sync_state()
+{
+	const UINT32 syncFlags = sdl_get_kbd_flags();
+	return freerdp_input_send_synchronize_event(_sdl->context()->input, syncFlags);
+}
+
+BOOL sdlInput::keyboard_focus_in()
+{
+	auto input = _sdl->context()->input;
+	WINPR_ASSERT(input);
+
+	auto syncFlags = sdl_get_kbd_flags();
+	freerdp_input_send_focus_in_event(input, WINPR_ASSERTING_INT_CAST(uint16_t, syncFlags));
+
+	/* finish with a mouse pointer position like mstsc.exe if required */
+#if 0
+    if (xfc->remote_app)
+        return;
+
+    if (XQueryPointer(xfc->display, xfc->window->handle, &w, &w, &d, &d, &x, &y, &state))
+    {
+        if ((x >= 0) && (x < xfc->window->width) && (y >= 0) && (y < xfc->window->height))
+        {
+            xf_event_adjust_coordinates(xfc, &x, &y);
+            freerdp_client_send_button_event(&xfc->common, FALSE, PTR_FLAGS_MOVE, x, y);
+        }
+    }
+#endif
+	return TRUE;
+}
+
+/* This function is called to update the keyboard indicator LED */
+BOOL sdlInput::keyboard_set_indicators(rdpContext* context, UINT16 led_flags)
+{
+	WINPR_UNUSED(context);
+
+	int state = SDL_KMOD_NONE;
+
+	if ((led_flags & KBD_SYNC_NUM_LOCK) != 0)
+		state |= SDL_KMOD_NUM;
+	if ((led_flags & KBD_SYNC_CAPS_LOCK) != 0)
+		state |= SDL_KMOD_CAPS;
+	if ((led_flags & KBD_SYNC_SCROLL_LOCK) != 0)
+		state |= SDL_KMOD_SCROLL;
+
+	// TODO: KBD_SYNC_KANA_LOCK
+
+	SDL_SetModState(static_cast<SDL_Keymod>(state));
+
+	return TRUE;
+}
+
+/* This function is called to set the IME state */
+BOOL sdlInput::keyboard_set_ime_status(rdpContext* context, UINT16 imeId, UINT32 imeState,
+                                       UINT32 imeConvMode)
+{
+	if (!context)
+		return FALSE;
+
+	WLog_WARN(TAG,
+	          "KeyboardSetImeStatus(unitId=%04" PRIx16 ", imeState=%08" PRIx32
+	          ", imeConvMode=%08" PRIx32 ") ignored",
+	          imeId, imeState, imeConvMode);
+	return TRUE;
+}
+
+uint32_t sdlInput::prefToMask()
+{
+	const std::map<std::string, uint32_t> mapping = {
+		{ "KMOD_LSHIFT", SDL_KMOD_LSHIFT }, { "KMOD_RSHIFT", SDL_KMOD_RSHIFT },
+		{ "KMOD_LCTRL", SDL_KMOD_LCTRL },   { "KMOD_RCTRL", SDL_KMOD_RCTRL },
+		{ "KMOD_LALT", SDL_KMOD_LALT },     { "KMOD_RALT", SDL_KMOD_RALT },
+		{ "KMOD_LGUI", SDL_KMOD_LGUI },     { "KMOD_RGUI", SDL_KMOD_RGUI },
+		{ "KMOD_NUM", SDL_KMOD_NUM },       { "KMOD_CAPS", SDL_KMOD_CAPS },
+		{ "KMOD_MODE", SDL_KMOD_MODE },     { "KMOD_SCROLL", SDL_KMOD_SCROLL },
+		{ "KMOD_CTRL", SDL_KMOD_CTRL },     { "KMOD_SHIFT", SDL_KMOD_SHIFT },
+		{ "KMOD_ALT", SDL_KMOD_ALT },       { "KMOD_GUI", SDL_KMOD_GUI }
+	};
+	uint32_t mod = SDL_KMOD_NONE;
+	for (const auto& val : SdlPref::instance()->get_array("SDL_KeyModMask", { "KMOD_RSHIFT" }))
+	{
+		auto it = mapping.find(val);
+		if (it != mapping.end())
+		{
+			mod |= it->second;
+		}
+	}
+	return mod;
+}
+
+static Uint32 sdl_scancode_val(const char* scancodeName)
+{
+	for (const auto& cur : map)
+	{
+		if (strcmp(cur.sdl_name, scancodeName) == 0)
+			return cur.sdl;
+	}
+
+	return SDL_SCANCODE_UNKNOWN;
+}
+
+static UINT32 sdl_scancode_to_rdp(Uint32 scancode)
+{
+	UINT32 rdp = RDP_SCANCODE_UNKNOWN;
+
+	for (const auto& cur : map)
+	{
+		if (cur.sdl == scancode)
+		{
+			rdp = cur.rdp;
+			break;
+		}
+	}
+
+#if defined(WITH_DEBUG_SDL_KBD_EVENTS)
+	auto code = static_cast<SDL_Scancode>(scancode);
+	WLog_DBG(TAG, "got %s [%s] -> [%s]", SDL_GetScancodeName(code), sdl_scancode_name(scancode),
+	         sdl_rdp_scancode_name(rdp));
+#endif
+	return rdp;
+}
+
+uint32_t sdlInput::prefKeyValue(const std::string& key, uint32_t fallback)
+{
+	auto item = SdlPref::instance()->get_string(key);
+	if (item.empty())
+		return fallback;
+	auto val = sdl_scancode_val(item.c_str());
+	if (val == SDL_SCANCODE_UNKNOWN)
+		return fallback;
+	return val;
+}
+
+std::list<std::string> sdlInput::tokenize(const std::string& data, const std::string& delimiter)
+{
+	size_t lastpos = 0;
+	size_t pos = 0;
+	std::list<std::string> list;
+	while ((pos = data.find(delimiter, lastpos)) != std::string::npos)
+	{
+		auto token = data.substr(lastpos, pos);
+		lastpos = pos + 1;
+		list.push_back(std::move(token));
+	}
+	auto token = data.substr(lastpos);
+	list.push_back(std::move(token));
+	return list;
+}
+
+bool sdlInput::extract(const std::string& token, uint32_t& key, uint32_t& value)
+{
+	return freerdp_extract_key_value(token.c_str(), &key, &value);
+}
+
+BOOL sdlInput::keyboard_handle_event(const SDL_KeyboardEvent* ev)
+{
+	WINPR_ASSERT(ev);
+	const UINT32 rdp_scancode = sdl_scancode_to_rdp(ev->scancode);
+	const SDL_Keymod mods = SDL_GetModState();
+
+	if ((mods & _hotkeyModmask) == _hotkeyModmask)
+	{
+		if (ev->type == SDL_EVENT_KEY_DOWN)
+		{
+			if (ev->scancode == _hotkeyFullscreen)
+			{
+				_sdl->update_fullscreen(!_sdl->fullscreen);
+				return TRUE;
+			}
+			if (ev->scancode == _hotkeyResizable)
+			{
+				_sdl->update_resizeable(!_sdl->resizeable);
+				return TRUE;
+			}
+
+			if (ev->scancode == _hotkeyGrab)
+			{
+				_sdl->grab_kbd_enabled = !_sdl->grab_kbd_enabled;
+				keyboard_grab(ev->windowID, _sdl->grab_kbd);
+				return TRUE;
+			}
+			if (ev->scancode == _hotkeyDisconnect)
+			{
+				freerdp_abort_connect_context(_sdl->context());
+				return TRUE;
+			}
+			if (ev->scancode == _hotkeyMinimize)
+			{
+				_sdl->update_minimize();
+				return TRUE;
+			}
+		}
+	}
+
+	auto scancode = freerdp_keyboard_remap_key(_remapTable, rdp_scancode);
+	return freerdp_input_send_keyboard_event_ex(
+	    _sdl->context()->input, ev->type == SDL_EVENT_KEY_DOWN, ev->repeat, scancode);
+}
+
+BOOL sdlInput::keyboard_grab(Uint32 windowID, bool enable)
+{
+	auto it = _sdl->windows.find(windowID);
+	if (it == _sdl->windows.end())
+		return FALSE;
+	auto status = enable && _sdl->grab_kbd_enabled;
+	_sdl->grab_kbd = status;
+	return it->second.grabKeyboard(status);
+}
+
+BOOL sdlInput::mouse_focus(Uint32 windowID)
+{
+	if (_lastWindowID != windowID)
+	{
+		_lastWindowID = windowID;
+		auto it = _sdl->windows.find(windowID);
+		if (it == _sdl->windows.end())
+			return FALSE;
+
+		it->second.raise();
+	}
+	return TRUE;
+}
+
+BOOL sdlInput::mouse_grab(Uint32 windowID, bool enable)
+{
+	auto it = _sdl->windows.find(windowID);
+	if (it == _sdl->windows.end())
+		return FALSE;
+	_sdl->grab_mouse = enable;
+	return it->second.grabMouse(enable);
+}
+
+sdlInput::sdlInput(SdlContext* sdl)
+    : _sdl(sdl), _lastWindowID(UINT32_MAX), _hotkeyModmask(prefToMask())
+{
+	auto list =
+	    freerdp_settings_get_string(_sdl->context()->settings, FreeRDP_KeyboardRemappingList);
+	_remapTable = freerdp_keyboard_remap_string_to_list(list);
+	assert(_remapTable);
+	_hotkeyFullscreen = prefKeyValue("SDL_Fullscreen", SDL_SCANCODE_RETURN);
+	_hotkeyResizable = prefKeyValue("SDL_Resizeable", SDL_SCANCODE_R);
+	_hotkeyGrab = prefKeyValue("SDL_Grab", SDL_SCANCODE_G);
+	_hotkeyDisconnect = prefKeyValue("SDL_Disconnect", SDL_SCANCODE_D);
+	_hotkeyMinimize = prefKeyValue("SDL_Minimize", SDL_SCANCODE_M);
+}
+
+sdlInput::~sdlInput()
+{
+	freerdp_keyboard_remap_free(_remapTable);
+}

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

@@ -0,0 +1,77 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client keyboard helper
+ *
+ * Copyright 2022 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 <list>
+#include <atomic>
+
+#include <winpr/wtypes.h>
+#include <freerdp/freerdp.h>
+#include <freerdp/locale/keyboard.h>
+#include <SDL3/SDL.h>
+
+#include "sdl_types.hpp"
+
+class sdlInput
+{
+  public:
+	explicit sdlInput(SdlContext* sdl);
+	sdlInput(const sdlInput& other) = delete;
+	sdlInput(sdlInput&& other) = delete;
+	~sdlInput();
+
+	sdlInput& operator=(const sdlInput& other) = delete;
+	sdlInput& operator=(sdlInput&& other) = delete;
+
+	BOOL keyboard_sync_state();
+	BOOL keyboard_focus_in();
+
+	BOOL keyboard_handle_event(const SDL_KeyboardEvent* ev);
+
+	BOOL keyboard_grab(Uint32 windowID, bool enable);
+	BOOL mouse_focus(Uint32 windowID);
+	BOOL mouse_grab(Uint32 windowID, bool enable);
+
+	static BOOL keyboard_set_indicators(rdpContext* context, UINT16 led_flags);
+	static BOOL keyboard_set_ime_status(rdpContext* context, UINT16 imeId, UINT32 imeState,
+	                                    UINT32 imeConvMode);
+
+	static uint32_t prefToMask();
+	static uint32_t prefKeyValue(const std::string& key, uint32_t fallback = SDL_SCANCODE_UNKNOWN);
+
+  private:
+	static std::list<std::string> tokenize(const std::string& data,
+	                                       const std::string& delimiter = ",");
+	static bool extract(const std::string& token, uint32_t& key, uint32_t& value);
+
+	SdlContext* _sdl;
+	Uint32 _lastWindowID;
+
+	// hotkey handling
+	uint32_t _hotkeyModmask; // modifier keys mask
+	uint32_t _hotkeyFullscreen;
+	uint32_t _hotkeyResizable;
+	uint32_t _hotkeyGrab;
+	uint32_t _hotkeyDisconnect;
+	uint32_t _hotkeyMinimize;
+	FREERDP_REMAP_TABLE* _remapTable;
+};

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

@@ -0,0 +1,393 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * X11 Monitor Handling
+ *
+ * Copyright 2011 Marc-Andre Moreau <[email protected]>
+ * Copyright 2017 David Fort <[email protected]>
+ * Copyright 2018 Kai Harms <[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 <freerdp/config.h>
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <algorithm>
+
+#include <SDL3/SDL.h>
+
+#include <winpr/assert.h>
+#include <winpr/crt.h>
+
+#include <freerdp/log.h>
+
+#define TAG CLIENT_TAG("sdl")
+
+#include "sdl_monitor.hpp"
+#include "sdl_freerdp.hpp"
+
+typedef struct
+{
+	RECTANGLE_16 area;
+	RECTANGLE_16 workarea;
+	BOOL primary;
+} MONITOR_INFO;
+
+typedef struct
+{
+	int nmonitors;
+	RECTANGLE_16 area;
+	RECTANGLE_16 workarea;
+	MONITOR_INFO* monitors;
+} VIRTUAL_SCREEN;
+
+/* See MSDN Section on Multiple Display Monitors: http://msdn.microsoft.com/en-us/library/dd145071
+ */
+
+int sdl_list_monitors(SdlContext* sdl)
+{
+	SDL_Init(SDL_INIT_VIDEO);
+
+	int nmonitors = 0;
+	auto ids = SDL_GetDisplays(&nmonitors);
+
+	printf("listing %d monitors:\n", nmonitors);
+	for (int i = 0; i < nmonitors; i++)
+	{
+		SDL_Rect rect = {};
+		auto id = ids[i];
+		const auto brc = SDL_GetDisplayBounds(id, &rect);
+		const char* name = SDL_GetDisplayName(id);
+
+		if (!brc)
+			continue;
+		printf("     %s [%u] [%s] %dx%d\t+%d+%d\n", (i == 0) ? "*" : " ", id, name, rect.w, rect.h,
+		       rect.x, rect.y);
+	}
+	SDL_free(ids);
+	SDL_Quit();
+	return 0;
+}
+
+static BOOL sdl_apply_max_size(SdlContext* sdl, UINT32* pMaxWidth, UINT32* pMaxHeight)
+{
+	WINPR_ASSERT(sdl);
+	WINPR_ASSERT(pMaxWidth);
+	WINPR_ASSERT(pMaxHeight);
+
+	auto settings = sdl->context()->settings;
+	WINPR_ASSERT(settings);
+
+	*pMaxWidth = 0;
+	*pMaxHeight = 0;
+
+	for (size_t x = 0; x < freerdp_settings_get_uint32(settings, FreeRDP_MonitorCount); x++)
+	{
+		auto monitor = static_cast<const rdpMonitor*>(
+		    freerdp_settings_get_pointer_array(settings, FreeRDP_MonitorDefArray, x));
+
+		if (freerdp_settings_get_bool(settings, FreeRDP_Fullscreen))
+		{
+			*pMaxWidth = WINPR_ASSERTING_INT_CAST(uint32_t, monitor->width);
+			*pMaxHeight = WINPR_ASSERTING_INT_CAST(uint32_t, monitor->height);
+		}
+		else if (freerdp_settings_get_bool(settings, FreeRDP_Workarea))
+		{
+			SDL_Rect rect = {};
+			SDL_GetDisplayUsableBounds(monitor->orig_screen, &rect);
+			*pMaxWidth = WINPR_ASSERTING_INT_CAST(uint32_t, rect.w);
+			*pMaxHeight = WINPR_ASSERTING_INT_CAST(uint32_t, rect.h);
+		}
+		else if (freerdp_settings_get_uint32(settings, FreeRDP_PercentScreen) > 0)
+		{
+			SDL_Rect rect = {};
+			SDL_GetDisplayUsableBounds(monitor->orig_screen, &rect);
+
+			*pMaxWidth = WINPR_ASSERTING_INT_CAST(uint32_t, rect.w);
+			*pMaxHeight = WINPR_ASSERTING_INT_CAST(uint32_t, rect.h);
+
+			if (freerdp_settings_get_bool(settings, FreeRDP_PercentScreenUseWidth))
+				*pMaxWidth = (WINPR_ASSERTING_INT_CAST(uint32_t, rect.w) *
+				              freerdp_settings_get_uint32(settings, FreeRDP_PercentScreen)) /
+				             100;
+
+			if (freerdp_settings_get_bool(settings, FreeRDP_PercentScreenUseHeight))
+				*pMaxHeight = (WINPR_ASSERTING_INT_CAST(uint32_t, rect.h) *
+				               freerdp_settings_get_uint32(settings, FreeRDP_PercentScreen)) /
+				              100;
+		}
+		else if (freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth) &&
+		         freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight))
+		{
+			*pMaxWidth = freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
+			*pMaxHeight = freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
+		}
+	}
+	return TRUE;
+}
+
+static UINT32 sdl_orientaion_to_rdp(SDL_DisplayOrientation orientation)
+{
+	switch (orientation)
+	{
+		case SDL_ORIENTATION_LANDSCAPE:
+			return ORIENTATION_LANDSCAPE;
+		case SDL_ORIENTATION_LANDSCAPE_FLIPPED:
+			return ORIENTATION_LANDSCAPE_FLIPPED;
+		case SDL_ORIENTATION_PORTRAIT_FLIPPED:
+			return ORIENTATION_PORTRAIT_FLIPPED;
+		case SDL_ORIENTATION_PORTRAIT:
+		default:
+			return ORIENTATION_PORTRAIT;
+	}
+}
+
+static Uint32 scale(Uint32 val, float scale)
+{
+	const auto dval = static_cast<float>(val);
+	const auto sval = dval / scale;
+	return static_cast<Uint32>(sval);
+}
+
+static BOOL sdl_apply_display_properties(SdlContext* sdl)
+{
+	WINPR_ASSERT(sdl);
+
+	rdpSettings* settings = sdl->context()->settings;
+	WINPR_ASSERT(settings);
+	if (!freerdp_settings_get_bool(settings, FreeRDP_Fullscreen) &&
+	    !freerdp_settings_get_bool(settings, FreeRDP_UseMultimon))
+		return TRUE;
+
+	const UINT32 numIds = freerdp_settings_get_uint32(settings, FreeRDP_NumMonitorIds);
+	std::vector<rdpMonitor> monitors;
+
+	for (UINT32 x = 0; x < numIds; x++)
+	{
+		auto id = static_cast<const int*>(
+		    freerdp_settings_get_pointer_array(settings, FreeRDP_MonitorIds, x));
+		WINPR_ASSERT(id);
+
+		float dpi = SDL_GetDisplayContentScale(WINPR_ASSERTING_INT_CAST(uint32_t, *id));
+		float hdpi = dpi;
+		float vdpi = dpi;
+		SDL_Rect rect = {};
+
+		if (!SDL_GetDisplayBounds(WINPR_ASSERTING_INT_CAST(uint32_t, *id), &rect))
+			return FALSE;
+
+		WINPR_ASSERT(rect.w > 0);
+		WINPR_ASSERT(rect.h > 0);
+
+		bool highDpi = dpi > 100;
+
+		if (highDpi)
+		{
+			// HighDPI is problematic with SDL: We can only get native resolution by creating a
+			// window. Work around this by checking the supported resolutions (and keep maximum)
+			// Also scale the DPI
+			const SDL_Rect scaleRect = rect;
+			int count = 0;
+			auto modes = SDL_GetFullscreenDisplayModes(x, &count);
+			for (int i = 0; i < count; i++)
+			{
+				auto mode = modes[i];
+				if (!mode)
+					break;
+
+				if (mode->w > rect.w)
+				{
+					rect.w = mode->w;
+					rect.h = mode->h;
+				}
+				else if (mode->w == rect.w)
+				{
+					if (mode->h > rect.h)
+					{
+						rect.w = mode->w;
+						rect.h = mode->h;
+					}
+				}
+			}
+			SDL_free(static_cast<void*>(modes));
+
+			const float dw = 1.0f * static_cast<float>(rect.w) / static_cast<float>(scaleRect.w);
+			const float dh = 1.0f * static_cast<float>(rect.h) / static_cast<float>(scaleRect.h);
+			hdpi /= dw;
+			vdpi /= dh;
+		}
+
+		const SDL_DisplayOrientation orientation =
+		    SDL_GetCurrentDisplayOrientation(WINPR_ASSERTING_INT_CAST(uint32_t, *id));
+		const UINT32 rdp_orientation = sdl_orientaion_to_rdp(orientation);
+
+		rdpMonitor monitor = {};
+
+		/* windows uses 96 dpi as 'default' and the scale factors are in percent. */
+		const auto factor = dpi / 96.0f * 100.0f;
+		monitor.orig_screen = x;
+		monitor.x = rect.x;
+		monitor.y = rect.y;
+		monitor.width = rect.w;
+		monitor.height = rect.h;
+		monitor.is_primary = x == 0;
+		monitor.attributes.desktopScaleFactor = static_cast<UINT32>(factor);
+		monitor.attributes.deviceScaleFactor = 100;
+		monitor.attributes.orientation = rdp_orientation;
+		monitor.attributes.physicalWidth = scale(WINPR_ASSERTING_INT_CAST(uint32_t, rect.w), hdpi);
+		monitor.attributes.physicalHeight = scale(WINPR_ASSERTING_INT_CAST(uint32_t, rect.h), vdpi);
+		monitors.emplace_back(monitor);
+	}
+	return freerdp_settings_set_monitor_def_array_sorted(settings, monitors.data(),
+	                                                     monitors.size());
+}
+
+static BOOL sdl_detect_single_window(SdlContext* sdl, UINT32* pMaxWidth, UINT32* pMaxHeight)
+{
+	WINPR_ASSERT(sdl);
+	WINPR_ASSERT(pMaxWidth);
+	WINPR_ASSERT(pMaxHeight);
+
+	rdpSettings* settings = sdl->context()->settings;
+	WINPR_ASSERT(settings);
+
+	if ((!freerdp_settings_get_bool(settings, FreeRDP_UseMultimon) &&
+	     !freerdp_settings_get_bool(settings, FreeRDP_SpanMonitors)) ||
+	    (freerdp_settings_get_bool(settings, FreeRDP_Workarea) &&
+	     !freerdp_settings_get_bool(settings, FreeRDP_RemoteApplicationMode)))
+	{
+		/* If no monitors were specified on the command-line then set the current monitor as active
+		 */
+		if (freerdp_settings_get_uint32(settings, FreeRDP_NumMonitorIds) == 0)
+		{
+			const size_t id =
+			    (!sdl->windows.empty())
+			        ? WINPR_ASSERTING_INT_CAST(size_t, sdl->windows.begin()->second.displayIndex())
+			        : 0;
+			if (!freerdp_settings_set_pointer_len(settings, FreeRDP_MonitorIds, &id, 1))
+				return FALSE;
+		}
+		else
+		{
+
+			/* Always sets number of monitors from command-line to just 1.
+			 * If the monitor is invalid then we will default back to current monitor
+			 * later as a fallback. So, there is no need to validate command-line entry here.
+			 */
+			if (!freerdp_settings_set_uint32(settings, FreeRDP_NumMonitorIds, 1))
+				return FALSE;
+		}
+
+		// TODO: Fill monitor struct
+		if (!sdl_apply_display_properties(sdl))
+			return FALSE;
+		return sdl_apply_max_size(sdl, pMaxWidth, pMaxHeight);
+	}
+	return TRUE;
+}
+
+BOOL sdl_detect_monitors(SdlContext* sdl, UINT32* pMaxWidth, UINT32* pMaxHeight)
+{
+	WINPR_ASSERT(sdl);
+	WINPR_ASSERT(pMaxWidth);
+	WINPR_ASSERT(pMaxHeight);
+
+	rdpSettings* settings = sdl->context()->settings;
+	WINPR_ASSERT(settings);
+
+	std::vector<SDL_DisplayID> ids;
+	{
+		int numDisplays = 0;
+		auto sids = SDL_GetDisplays(&numDisplays);
+		if (sids && (numDisplays > 0))
+			ids = std::vector<SDL_DisplayID>(sids, sids + numDisplays);
+		SDL_free(sids);
+		if (numDisplays < 0)
+			return FALSE;
+	}
+
+	auto nr = freerdp_settings_get_uint32(settings, FreeRDP_NumMonitorIds);
+	if (nr == 0)
+	{
+		if (!freerdp_settings_set_pointer_len(settings, FreeRDP_MonitorIds, nullptr, ids.size()))
+			return FALSE;
+
+		for (size_t x = 0; x < ids.size(); x++)
+		{
+			auto id = ids[x];
+			if (!freerdp_settings_set_pointer_array(settings, FreeRDP_MonitorIds, x, &id))
+				return FALSE;
+		}
+	}
+	else
+	{
+		/* There were more IDs supplied than there are monitors */
+		if (nr > ids.size())
+		{
+			WLog_ERR(TAG,
+			         "Found %" PRIu32 " monitor IDs, but only have %" PRIuz " monitors connected",
+			         nr, ids.size());
+			return FALSE;
+		}
+
+		std::vector<UINT32> used;
+		for (size_t x = 0; x < nr; x++)
+		{
+			auto cur = static_cast<const UINT32*>(
+			    freerdp_settings_get_pointer_array(settings, FreeRDP_MonitorIds, x));
+			WINPR_ASSERT(cur);
+
+			auto id = *cur;
+
+			/* the ID is no valid monitor index */
+			if (std::find(ids.begin(), ids.end(), id) == ids.end())
+			{
+				WLog_ERR(TAG, "Supplied monitor ID[%" PRIuz "]=%" PRIu32 " is invalid", x, id);
+				return FALSE;
+			}
+
+			/* The ID is already taken */
+			if (std::find(used.begin(), used.end(), id) != used.end())
+			{
+				WLog_ERR(TAG, "Duplicate monitor ID[%" PRIuz "]=%" PRIu32 " detected", x, id);
+				return FALSE;
+			}
+			used.push_back(*cur);
+		}
+	}
+
+	if (!sdl_apply_display_properties(sdl))
+		return FALSE;
+
+	return sdl_detect_single_window(sdl, pMaxWidth, pMaxHeight);
+}
+
+INT64 sdl_monitor_id_for_index(SdlContext* sdl, UINT32 index)
+{
+	WINPR_ASSERT(sdl);
+	auto settings = sdl->context()->settings;
+
+	auto nr = freerdp_settings_get_uint32(settings, FreeRDP_NumMonitorIds);
+	if (nr == 0)
+		return index;
+
+	if (nr <= index)
+		return -1;
+
+	auto cur = static_cast<const UINT32*>(
+	    freerdp_settings_get_pointer_array(settings, FreeRDP_MonitorIds, index));
+	WINPR_ASSERT(cur);
+	return *cur;
+}

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

@@ -0,0 +1,29 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Monitor Handling
+ *
+ * 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 <freerdp/api.h>
+#include <freerdp/freerdp.h>
+
+#include "sdl_types.hpp"
+
+int sdl_list_monitors(SdlContext* sdl);
+BOOL sdl_detect_monitors(SdlContext* sdl, UINT32* pMaxWidth, UINT32* ppMaxHeight);
+INT64 sdl_monitor_id_for_index(SdlContext* sdl, UINT32 index);

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

@@ -0,0 +1,207 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * Wayland Mouse Pointer
+ *
+ * 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 <freerdp/config.h>
+
+#include <freerdp/gdi/gdi.h>
+
+#include "sdl_pointer.hpp"
+#include "sdl_freerdp.hpp"
+#include "sdl_touch.hpp"
+#include "sdl_utils.hpp"
+
+#include <SDL3/SDL_mouse.h>
+
+typedef struct
+{
+	rdpPointer pointer;
+	SDL_Cursor* cursor;
+	SDL_Surface* image;
+	size_t size;
+	void* data;
+} sdlPointer;
+
+static BOOL sdl_Pointer_New(rdpContext* context, rdpPointer* pointer)
+{
+	auto ptr = reinterpret_cast<sdlPointer*>(pointer);
+
+	WINPR_ASSERT(context);
+	if (!ptr)
+		return FALSE;
+
+	rdpGdi* gdi = context->gdi;
+	WINPR_ASSERT(gdi);
+
+	ptr->size = 4ull * pointer->width * pointer->height;
+	ptr->data = winpr_aligned_malloc(ptr->size, 16);
+
+	if (!ptr->data)
+		return FALSE;
+
+	auto data = static_cast<BYTE*>(ptr->data);
+	if (!freerdp_image_copy_from_pointer_data(
+	        data, gdi->dstFormat, 0, 0, 0, pointer->width, pointer->height, pointer->xorMaskData,
+	        pointer->lengthXorMask, pointer->andMaskData, pointer->lengthAndMask, pointer->xorBpp,
+	        &context->gdi->palette))
+	{
+		winpr_aligned_free(ptr->data);
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+static void sdl_Pointer_Clear(sdlPointer* ptr)
+{
+	WINPR_ASSERT(ptr);
+	SDL_DestroyCursor(ptr->cursor);
+	SDL_DestroySurface(ptr->image);
+	ptr->cursor = nullptr;
+	ptr->image = nullptr;
+}
+
+static void sdl_Pointer_Free(rdpContext* context, rdpPointer* pointer)
+{
+	auto ptr = reinterpret_cast<sdlPointer*>(pointer);
+	WINPR_UNUSED(context);
+
+	if (ptr)
+	{
+		sdl_Pointer_Clear(ptr);
+		winpr_aligned_free(ptr->data);
+		ptr->data = nullptr;
+	}
+}
+
+static BOOL sdl_Pointer_SetDefault(rdpContext* context)
+{
+	WINPR_UNUSED(context);
+
+	return sdl_push_user_event(SDL_EVENT_USER_POINTER_DEFAULT);
+}
+
+static BOOL sdl_Pointer_Set(rdpContext* context, rdpPointer* pointer)
+{
+	auto sdl = get_context(context);
+
+	return sdl_push_user_event(SDL_EVENT_USER_POINTER_SET, pointer, sdl);
+}
+
+BOOL sdl_Pointer_Set_Process(SDL_UserEvent* uptr)
+{
+	INT32 w = 0;
+	INT32 h = 0;
+	INT32 x = 0;
+	INT32 y = 0;
+	INT32 sw = 0;
+	INT32 sh = 0;
+
+	WINPR_ASSERT(uptr);
+
+	auto sdl = static_cast<SdlContext*>(uptr->data2);
+	WINPR_ASSERT(sdl);
+
+	auto context = sdl->context();
+	auto ptr = static_cast<sdlPointer*>(uptr->data1);
+	WINPR_ASSERT(ptr);
+
+	rdpPointer* pointer = &ptr->pointer;
+
+	rdpGdi* gdi = context->gdi;
+	WINPR_ASSERT(gdi);
+
+	x = static_cast<INT32>(pointer->xPos);
+	y = static_cast<INT32>(pointer->yPos);
+	sw = w = static_cast<INT32>(pointer->width);
+	sh = h = static_cast<INT32>(pointer->height);
+
+	SDL_Window* window = SDL_GetMouseFocus();
+	if (!window)
+		return sdl_Pointer_SetDefault(context);
+
+	const Uint32 id = SDL_GetWindowID(window);
+
+	if (!sdl_scale_coordinates(sdl, id, &x, &y, FALSE, FALSE) ||
+	    !sdl_scale_coordinates(sdl, id, &sw, &sh, FALSE, FALSE))
+		return FALSE;
+
+	sdl_Pointer_Clear(ptr);
+
+	ptr->image = SDL_CreateSurface(sw, sh, sdl->sdl_pixel_format);
+	if (!ptr->image)
+		return FALSE;
+
+	SDL_LockSurface(ptr->image);
+	auto pixels = static_cast<BYTE*>(ptr->image->pixels);
+	auto data = static_cast<const BYTE*>(ptr->data);
+	const BOOL rc = freerdp_image_scale(
+	    pixels, gdi->dstFormat, static_cast<UINT32>(ptr->image->pitch), 0, 0,
+	    static_cast<UINT32>(ptr->image->w), static_cast<UINT32>(ptr->image->h), data,
+	    gdi->dstFormat, 0, 0, 0, static_cast<UINT32>(w), static_cast<UINT32>(h));
+	SDL_UnlockSurface(ptr->image);
+	if (!rc)
+		return FALSE;
+
+	ptr->cursor = SDL_CreateColorCursor(ptr->image, x, y);
+	if (!ptr->cursor)
+		return FALSE;
+
+	SDL_SetCursor(ptr->cursor);
+	SDL_ShowCursor();
+	return TRUE;
+}
+
+static BOOL sdl_Pointer_SetNull(rdpContext* context)
+{
+	WINPR_UNUSED(context);
+
+	return sdl_push_user_event(SDL_EVENT_USER_POINTER_NULL);
+}
+
+static BOOL sdl_Pointer_SetPosition(rdpContext* context, UINT32 x, UINT32 y)
+{
+	WINPR_UNUSED(context);
+	WINPR_ASSERT(context);
+
+	return sdl_push_user_event(SDL_EVENT_USER_POINTER_POSITION, x, y);
+}
+
+BOOL sdl_register_pointer(rdpGraphics* graphics)
+{
+	const rdpPointer pointer = { sizeof(sdlPointer),
+		                         sdl_Pointer_New,
+		                         sdl_Pointer_Free,
+		                         sdl_Pointer_Set,
+		                         sdl_Pointer_SetNull,
+		                         sdl_Pointer_SetDefault,
+		                         sdl_Pointer_SetPosition,
+		                         {},
+		                         0,
+		                         0,
+		                         0,
+		                         0,
+		                         0,
+		                         0,
+		                         0,
+		                         nullptr,
+		                         nullptr,
+		                         {} };
+	graphics_register_pointer(graphics, &pointer);
+	return TRUE;
+}

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

@@ -0,0 +1,27 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Mouse Pointer
+ *
+ * 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 <SDL3/SDL.h>
+#include <freerdp/graphics.h>
+
+BOOL sdl_register_pointer(rdpGraphics* graphics);
+
+BOOL sdl_Pointer_Set_Process(SDL_UserEvent* uptr);

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

@@ -0,0 +1,279 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP SDL touch/mouse input
+ *
+ * Copyright 2022 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 <freerdp/config.h>
+
+#include "sdl_touch.hpp"
+#include "sdl_freerdp.hpp"
+
+#include <winpr/wtypes.h>
+#include <winpr/assert.h>
+
+#include <freerdp/freerdp.h>
+#include <freerdp/gdi/gdi.h>
+
+#include <SDL3/SDL.h>
+
+BOOL sdl_scale_coordinates(SdlContext* sdl, Uint32 windowId, INT32* px, INT32* py,
+                           BOOL fromLocalToRDP, BOOL applyOffset)
+{
+	rdpGdi* gdi = nullptr;
+	double sx = 1.0;
+	double sy = 1.0;
+
+	if (!sdl || !px || !py || !sdl->context()->gdi)
+		return FALSE;
+
+	WINPR_ASSERT(sdl->context()->gdi);
+	WINPR_ASSERT(sdl->context()->settings);
+
+	gdi = sdl->context()->gdi;
+
+	// TODO: Make this multimonitor ready!
+	// TODO: Need to find the primary monitor, get the scale
+	// TODO: Need to find the destination monitor, get the scale
+	// TODO: All intermediate monitors, get the scale
+
+	int offset_x = 0;
+	int offset_y = 0;
+	for (const auto& it : sdl->windows)
+	{
+		auto& window = it.second;
+		const auto id = window.id();
+		if (id != windowId)
+		{
+			continue;
+		}
+
+		auto size = window.rect();
+
+		sx = size.w / static_cast<double>(gdi->width);
+		sy = size.h / static_cast<double>(gdi->height);
+		offset_x = window.offsetX();
+		offset_y = window.offsetY();
+		break;
+	}
+
+	if (freerdp_settings_get_bool(sdl->context()->settings, FreeRDP_SmartSizing))
+	{
+		if (!fromLocalToRDP)
+		{
+			*px = static_cast<INT32>(*px * sx);
+			*py = static_cast<INT32>(*py * sy);
+		}
+		else
+		{
+			*px = static_cast<INT32>(*px / sx);
+			*py = static_cast<INT32>(*py / sy);
+		}
+	}
+	else if (applyOffset)
+	{
+		*px -= offset_x;
+		*py -= offset_y;
+	}
+
+	return TRUE;
+}
+
+static BOOL sdl_get_touch_scaled(SdlContext* sdl, const SDL_TouchFingerEvent* ev, INT32* px,
+                                 INT32* py, BOOL local)
+{
+	Uint32 windowID = 0;
+
+	WINPR_ASSERT(sdl);
+	WINPR_ASSERT(ev);
+	WINPR_ASSERT(px);
+	WINPR_ASSERT(py);
+
+	SDL_Window* window = SDL_GetWindowFromID(ev->windowID);
+
+	if (!window)
+		return FALSE;
+
+	windowID = SDL_GetWindowID(window);
+	SDL_Surface* surface = SDL_GetWindowSurface(window);
+	if (!surface)
+		return FALSE;
+
+	// TODO: Add the offset of the surface in the global coordinates
+	*px = static_cast<INT32>(ev->x * static_cast<float>(surface->w));
+	*py = static_cast<INT32>(ev->y * static_cast<float>(surface->h));
+	return sdl_scale_coordinates(sdl, windowID, px, py, local, TRUE);
+}
+
+static BOOL send_mouse_wheel(SdlContext* sdl, UINT16 flags, INT32 avalue)
+{
+	WINPR_ASSERT(sdl);
+	if (avalue < 0)
+	{
+		flags |= PTR_FLAGS_WHEEL_NEGATIVE;
+		avalue = -avalue;
+	}
+
+	while (avalue > 0)
+	{
+		const UINT16 cval = (avalue > 0xFF) ? 0xFF : static_cast<UINT16>(avalue);
+		UINT16 cflags = flags | cval;
+		/* Convert negative values to 9bit twos complement */
+		if (flags & PTR_FLAGS_WHEEL_NEGATIVE)
+			cflags = (flags & 0xFF00) | (0x100 - cval);
+		if (!freerdp_client_send_wheel_event(sdl->common(), cflags))
+			return FALSE;
+
+		avalue -= cval;
+	}
+	return TRUE;
+}
+
+static UINT32 sdl_scale_pressure(const float pressure)
+{
+	const float val = pressure * 0x400; /* [MS-RDPEI] 2.2.3.3.1.1 RDPINPUT_TOUCH_CONTACT */
+	if (val < 0.0f)
+		return 0;
+	if (val > 0x400)
+		return 0x400;
+	return static_cast<UINT32>(val);
+}
+
+BOOL sdl_handle_touch_up(SdlContext* sdl, const SDL_TouchFingerEvent* ev)
+{
+	WINPR_ASSERT(sdl);
+	WINPR_ASSERT(ev);
+
+	INT32 x = 0;
+	INT32 y = 0;
+	if (!sdl_get_touch_scaled(sdl, ev, &x, &y, TRUE))
+		return FALSE;
+	return freerdp_client_handle_touch(sdl->common(), FREERDP_TOUCH_UP | FREERDP_TOUCH_HAS_PRESSURE,
+	                                   static_cast<INT32>(ev->fingerID),
+	                                   sdl_scale_pressure(ev->pressure), x, y);
+}
+
+BOOL sdl_handle_touch_down(SdlContext* sdl, const SDL_TouchFingerEvent* ev)
+{
+	WINPR_ASSERT(sdl);
+	WINPR_ASSERT(ev);
+
+	INT32 x = 0;
+	INT32 y = 0;
+	if (!sdl_get_touch_scaled(sdl, ev, &x, &y, TRUE))
+		return FALSE;
+	return freerdp_client_handle_touch(
+	    sdl->common(), FREERDP_TOUCH_DOWN | FREERDP_TOUCH_HAS_PRESSURE,
+	    static_cast<INT32>(ev->fingerID), sdl_scale_pressure(ev->pressure), x, y);
+}
+
+BOOL sdl_handle_touch_motion(SdlContext* sdl, const SDL_TouchFingerEvent* ev)
+{
+	WINPR_ASSERT(sdl);
+	WINPR_ASSERT(ev);
+
+	INT32 x = 0;
+	INT32 y = 0;
+	if (!sdl_get_touch_scaled(sdl, ev, &x, &y, TRUE))
+		return FALSE;
+	return freerdp_client_handle_touch(
+	    sdl->common(), FREERDP_TOUCH_MOTION | FREERDP_TOUCH_HAS_PRESSURE,
+	    static_cast<INT32>(ev->fingerID), sdl_scale_pressure(ev->pressure), x, y);
+}
+
+BOOL sdl_handle_mouse_motion(SdlContext* sdl, const SDL_MouseMotionEvent* ev)
+{
+	WINPR_ASSERT(sdl);
+	WINPR_ASSERT(ev);
+
+	sdl->input.mouse_focus(ev->windowID);
+	const BOOL relative = freerdp_client_use_relative_mouse_events(sdl->common());
+	auto x = static_cast<INT32>(relative ? ev->xrel : ev->x);
+	auto y = static_cast<INT32>(relative ? ev->yrel : ev->y);
+	sdl_scale_coordinates(sdl, ev->windowID, &x, &y, TRUE, TRUE);
+	return freerdp_client_send_button_event(sdl->common(), relative, PTR_FLAGS_MOVE, x, y);
+}
+
+BOOL sdl_handle_mouse_wheel(SdlContext* sdl, const SDL_MouseWheelEvent* ev)
+{
+	WINPR_ASSERT(sdl);
+	WINPR_ASSERT(ev);
+
+	const BOOL flipped = (ev->direction == SDL_MOUSEWHEEL_FLIPPED);
+	const auto x = static_cast<INT32>(ev->x * (flipped ? -1.0f : 1.0f) * 120.0f);
+	const auto y = static_cast<INT32>(ev->y * (flipped ? -1.0f : 1.0f) * 120.0f);
+	UINT16 flags = 0;
+
+	if (y != 0)
+	{
+		flags |= PTR_FLAGS_WHEEL;
+		send_mouse_wheel(sdl, flags, y);
+	}
+
+	if (x != 0)
+	{
+		flags |= PTR_FLAGS_HWHEEL;
+		send_mouse_wheel(sdl, flags, x);
+	}
+	return TRUE;
+}
+
+BOOL sdl_handle_mouse_button(SdlContext* sdl, const SDL_MouseButtonEvent* ev)
+{
+	UINT16 flags = 0;
+	UINT16 xflags = 0;
+
+	WINPR_ASSERT(sdl);
+	WINPR_ASSERT(ev);
+
+	if (ev->type == SDL_EVENT_MOUSE_BUTTON_DOWN)
+	{
+		flags |= PTR_FLAGS_DOWN;
+		xflags |= PTR_XFLAGS_DOWN;
+	}
+
+	switch (ev->button)
+	{
+		case 1:
+			flags |= PTR_FLAGS_BUTTON1;
+			break;
+		case 2:
+			flags |= PTR_FLAGS_BUTTON3;
+			break;
+		case 3:
+			flags |= PTR_FLAGS_BUTTON2;
+			break;
+		case 4:
+			xflags |= PTR_XFLAGS_BUTTON1;
+			break;
+		case 5:
+			xflags |= PTR_XFLAGS_BUTTON2;
+			break;
+		default:
+			break;
+	}
+
+	const BOOL relative = freerdp_client_use_relative_mouse_events(sdl->common());
+	auto x = static_cast<INT32>(relative ? 0 : ev->x);
+	auto y = static_cast<INT32>(relative ? 0 : ev->y);
+	sdl_scale_coordinates(sdl, ev->windowID, &x, &y, TRUE, TRUE);
+	if ((flags & (~PTR_FLAGS_DOWN)) != 0)
+		return freerdp_client_send_button_event(sdl->common(), relative, flags, x, y);
+	else if ((xflags & (~PTR_XFLAGS_DOWN)) != 0)
+		return freerdp_client_send_extended_button_event(sdl->common(), relative, xflags, x, y);
+	else
+		return FALSE;
+}

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

@@ -0,0 +1,36 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * FreeRDP SDL touch/mouse input
+ *
+ * Copyright 2022 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 <SDL3/SDL.h>
+#include "sdl_types.hpp"
+
+BOOL sdl_scale_coordinates(SdlContext* sdl, Uint32 windowId, INT32* px, INT32* py,
+                           BOOL fromLocalToRDP, BOOL applyOffset);
+
+BOOL sdl_handle_mouse_motion(SdlContext* sdl, const SDL_MouseMotionEvent* ev);
+BOOL sdl_handle_mouse_wheel(SdlContext* sdl, const SDL_MouseWheelEvent* ev);
+BOOL sdl_handle_mouse_button(SdlContext* sdl, const SDL_MouseButtonEvent* ev);
+
+BOOL sdl_handle_touch_down(SdlContext* sdl, const SDL_TouchFingerEvent* ev);
+BOOL sdl_handle_touch_up(SdlContext* sdl, const SDL_TouchFingerEvent* ev);
+BOOL sdl_handle_touch_motion(SdlContext* sdl, const SDL_TouchFingerEvent* ev);

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

@@ -0,0 +1,46 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client
+ *
+ * Copyright 2022 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 <freerdp/freerdp.h>
+
+class SdlContext;
+
+typedef struct
+{
+	rdpClientContext common;
+	SdlContext* sdl;
+} sdl_rdp_context;
+
+static inline SdlContext* get_context(void* ctx)
+{
+	if (!ctx)
+		return nullptr;
+	auto sdl = static_cast<sdl_rdp_context*>(ctx);
+	return sdl->sdl;
+}
+
+static inline SdlContext* get_context(rdpContext* ctx)
+{
+	if (!ctx)
+		return nullptr;
+	auto sdl = reinterpret_cast<sdl_rdp_context*>(ctx);
+	return sdl->sdl;
+}

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

@@ -0,0 +1,346 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client
+ *
+ * Copyright 2022 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 "sdl_utils.hpp"
+
+#include "sdl_freerdp.hpp"
+
+#include <SDL3/SDL.h>
+
+#include <freerdp/version.h>
+
+#define STR(x) #x
+#define EV_CASE_STR(x) \
+	case x:            \
+		return STR(x)
+
+const char* sdl_event_type_str(Uint32 type)
+{
+	switch (type)
+	{
+		EV_CASE_STR(SDL_EVENT_FIRST);
+		EV_CASE_STR(SDL_EVENT_QUIT);
+		EV_CASE_STR(SDL_EVENT_TERMINATING);
+		EV_CASE_STR(SDL_EVENT_LOW_MEMORY);
+		EV_CASE_STR(SDL_EVENT_WILL_ENTER_BACKGROUND);
+		EV_CASE_STR(SDL_EVENT_DID_ENTER_BACKGROUND);
+		EV_CASE_STR(SDL_EVENT_WILL_ENTER_FOREGROUND);
+		EV_CASE_STR(SDL_EVENT_DID_ENTER_FOREGROUND);
+		EV_CASE_STR(SDL_EVENT_LOCALE_CHANGED);
+		EV_CASE_STR(SDL_EVENT_SYSTEM_THEME_CHANGED);
+		EV_CASE_STR(SDL_EVENT_DISPLAY_ORIENTATION);
+		EV_CASE_STR(SDL_EVENT_DISPLAY_ADDED);
+		EV_CASE_STR(SDL_EVENT_DISPLAY_REMOVED);
+		EV_CASE_STR(SDL_EVENT_DISPLAY_MOVED);
+		EV_CASE_STR(SDL_EVENT_DISPLAY_CONTENT_SCALE_CHANGED);
+		EV_CASE_STR(SDL_EVENT_WINDOW_SHOWN);
+		EV_CASE_STR(SDL_EVENT_WINDOW_HIDDEN);
+		EV_CASE_STR(SDL_EVENT_WINDOW_EXPOSED);
+		EV_CASE_STR(SDL_EVENT_WINDOW_MOVED);
+		EV_CASE_STR(SDL_EVENT_WINDOW_RESIZED);
+		EV_CASE_STR(SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED);
+		EV_CASE_STR(SDL_EVENT_WINDOW_MINIMIZED);
+		EV_CASE_STR(SDL_EVENT_WINDOW_MAXIMIZED);
+		EV_CASE_STR(SDL_EVENT_WINDOW_RESTORED);
+		EV_CASE_STR(SDL_EVENT_WINDOW_MOUSE_ENTER);
+		EV_CASE_STR(SDL_EVENT_WINDOW_MOUSE_LEAVE);
+		EV_CASE_STR(SDL_EVENT_WINDOW_FOCUS_GAINED);
+		EV_CASE_STR(SDL_EVENT_WINDOW_FOCUS_LOST);
+		EV_CASE_STR(SDL_EVENT_WINDOW_CLOSE_REQUESTED);
+		EV_CASE_STR(SDL_EVENT_WINDOW_HIT_TEST);
+		EV_CASE_STR(SDL_EVENT_WINDOW_ICCPROF_CHANGED);
+		EV_CASE_STR(SDL_EVENT_WINDOW_DISPLAY_CHANGED);
+		EV_CASE_STR(SDL_EVENT_WINDOW_DISPLAY_SCALE_CHANGED);
+		EV_CASE_STR(SDL_EVENT_WINDOW_OCCLUDED);
+		EV_CASE_STR(SDL_EVENT_WINDOW_ENTER_FULLSCREEN);
+		EV_CASE_STR(SDL_EVENT_WINDOW_LEAVE_FULLSCREEN);
+		EV_CASE_STR(SDL_EVENT_WINDOW_DESTROYED);
+
+		EV_CASE_STR(SDL_EVENT_KEY_DOWN);
+		EV_CASE_STR(SDL_EVENT_KEY_UP);
+		EV_CASE_STR(SDL_EVENT_TEXT_EDITING);
+		EV_CASE_STR(SDL_EVENT_TEXT_INPUT);
+		EV_CASE_STR(SDL_EVENT_KEYMAP_CHANGED);
+		EV_CASE_STR(SDL_EVENT_KEYBOARD_ADDED);
+		EV_CASE_STR(SDL_EVENT_KEYBOARD_REMOVED);
+
+		EV_CASE_STR(SDL_EVENT_MOUSE_MOTION);
+		EV_CASE_STR(SDL_EVENT_MOUSE_BUTTON_DOWN);
+		EV_CASE_STR(SDL_EVENT_MOUSE_BUTTON_UP);
+		EV_CASE_STR(SDL_EVENT_MOUSE_WHEEL);
+		EV_CASE_STR(SDL_EVENT_MOUSE_ADDED);
+		EV_CASE_STR(SDL_EVENT_MOUSE_REMOVED);
+
+		EV_CASE_STR(SDL_EVENT_JOYSTICK_AXIS_MOTION);
+		EV_CASE_STR(SDL_EVENT_JOYSTICK_BALL_MOTION);
+		EV_CASE_STR(SDL_EVENT_JOYSTICK_HAT_MOTION);
+		EV_CASE_STR(SDL_EVENT_JOYSTICK_BUTTON_DOWN);
+		EV_CASE_STR(SDL_EVENT_JOYSTICK_BUTTON_UP);
+		EV_CASE_STR(SDL_EVENT_JOYSTICK_ADDED);
+		EV_CASE_STR(SDL_EVENT_JOYSTICK_REMOVED);
+		EV_CASE_STR(SDL_EVENT_JOYSTICK_BATTERY_UPDATED);
+		EV_CASE_STR(SDL_EVENT_JOYSTICK_UPDATE_COMPLETE);
+
+		EV_CASE_STR(SDL_EVENT_GAMEPAD_AXIS_MOTION);
+		EV_CASE_STR(SDL_EVENT_GAMEPAD_BUTTON_DOWN);
+		EV_CASE_STR(SDL_EVENT_GAMEPAD_BUTTON_UP);
+		EV_CASE_STR(SDL_EVENT_GAMEPAD_ADDED);
+		EV_CASE_STR(SDL_EVENT_GAMEPAD_REMOVED);
+		EV_CASE_STR(SDL_EVENT_GAMEPAD_REMAPPED);
+		EV_CASE_STR(SDL_EVENT_GAMEPAD_TOUCHPAD_DOWN);
+		EV_CASE_STR(SDL_EVENT_GAMEPAD_TOUCHPAD_MOTION);
+		EV_CASE_STR(SDL_EVENT_GAMEPAD_TOUCHPAD_UP);
+		EV_CASE_STR(SDL_EVENT_GAMEPAD_SENSOR_UPDATE);
+		EV_CASE_STR(SDL_EVENT_GAMEPAD_UPDATE_COMPLETE);
+		EV_CASE_STR(SDL_EVENT_GAMEPAD_STEAM_HANDLE_UPDATED);
+
+		EV_CASE_STR(SDL_EVENT_FINGER_DOWN);
+		EV_CASE_STR(SDL_EVENT_FINGER_UP);
+		EV_CASE_STR(SDL_EVENT_FINGER_MOTION);
+
+		EV_CASE_STR(SDL_EVENT_CLIPBOARD_UPDATE);
+
+		EV_CASE_STR(SDL_EVENT_DROP_FILE);
+		EV_CASE_STR(SDL_EVENT_DROP_TEXT);
+		EV_CASE_STR(SDL_EVENT_DROP_BEGIN);
+		EV_CASE_STR(SDL_EVENT_DROP_COMPLETE);
+		EV_CASE_STR(SDL_EVENT_DROP_POSITION);
+
+		EV_CASE_STR(SDL_EVENT_AUDIO_DEVICE_ADDED);
+		EV_CASE_STR(SDL_EVENT_AUDIO_DEVICE_REMOVED);
+		EV_CASE_STR(SDL_EVENT_AUDIO_DEVICE_FORMAT_CHANGED);
+
+		EV_CASE_STR(SDL_EVENT_SENSOR_UPDATE);
+
+		EV_CASE_STR(SDL_EVENT_PEN_DOWN);
+		EV_CASE_STR(SDL_EVENT_PEN_UP);
+		EV_CASE_STR(SDL_EVENT_PEN_MOTION);
+		EV_CASE_STR(SDL_EVENT_PEN_BUTTON_DOWN);
+		EV_CASE_STR(SDL_EVENT_PEN_BUTTON_UP);
+		EV_CASE_STR(SDL_EVENT_CAMERA_DEVICE_ADDED);
+		EV_CASE_STR(SDL_EVENT_CAMERA_DEVICE_REMOVED);
+		EV_CASE_STR(SDL_EVENT_CAMERA_DEVICE_APPROVED);
+		EV_CASE_STR(SDL_EVENT_CAMERA_DEVICE_DENIED);
+
+		EV_CASE_STR(SDL_EVENT_RENDER_TARGETS_RESET);
+		EV_CASE_STR(SDL_EVENT_RENDER_DEVICE_RESET);
+		EV_CASE_STR(SDL_EVENT_POLL_SENTINEL);
+
+		EV_CASE_STR(SDL_EVENT_USER);
+
+		EV_CASE_STR(SDL_EVENT_USER_CERT_DIALOG);
+		EV_CASE_STR(SDL_EVENT_USER_CERT_RESULT);
+		EV_CASE_STR(SDL_EVENT_USER_SHOW_DIALOG);
+		EV_CASE_STR(SDL_EVENT_USER_SHOW_RESULT);
+		EV_CASE_STR(SDL_EVENT_USER_AUTH_DIALOG);
+		EV_CASE_STR(SDL_EVENT_USER_AUTH_RESULT);
+		EV_CASE_STR(SDL_EVENT_USER_SCARD_DIALOG);
+		EV_CASE_STR(SDL_EVENT_USER_RETRY_DIALOG);
+		EV_CASE_STR(SDL_EVENT_USER_SCARD_RESULT);
+		EV_CASE_STR(SDL_EVENT_USER_UPDATE);
+		EV_CASE_STR(SDL_EVENT_USER_CREATE_WINDOWS);
+		EV_CASE_STR(SDL_EVENT_USER_WINDOW_RESIZEABLE);
+		EV_CASE_STR(SDL_EVENT_USER_WINDOW_FULLSCREEN);
+		EV_CASE_STR(SDL_EVENT_USER_WINDOW_MINIMIZE);
+		EV_CASE_STR(SDL_EVENT_USER_POINTER_NULL);
+		EV_CASE_STR(SDL_EVENT_USER_POINTER_DEFAULT);
+		EV_CASE_STR(SDL_EVENT_USER_POINTER_POSITION);
+		EV_CASE_STR(SDL_EVENT_USER_POINTER_SET);
+		EV_CASE_STR(SDL_EVENT_USER_QUIT);
+
+		EV_CASE_STR(SDL_EVENT_LAST);
+		default:
+			return "SDL_UNKNOWNEVENT";
+	}
+}
+
+const char* sdl_error_string(Sint32 res)
+{
+	if (res == 0)
+		return nullptr;
+
+	return SDL_GetError();
+}
+
+BOOL sdl_log_error_ex(Sint32 res, wLog* log, const char* what, const char* file, size_t line,
+                      const char* fkt)
+{
+	const char* msg = sdl_error_string(res);
+
+	WINPR_UNUSED(file);
+
+	if (!msg)
+		return FALSE;
+
+	WLog_Print(log, WLOG_ERROR, "[%s:%" PRIuz "][%s]: %s", fkt, line, what, msg);
+	return TRUE;
+}
+
+BOOL sdl_push_user_event(Uint32 type, ...)
+{
+	SDL_Event ev = {};
+	SDL_UserEvent* event = &ev.user;
+
+	va_list ap = {};
+	va_start(ap, type);
+	event->type = type;
+	switch (type)
+	{
+		case SDL_EVENT_USER_AUTH_RESULT:
+		{
+			auto arg = reinterpret_cast<SDL_UserAuthArg*>(ev.padding);
+			arg->user = va_arg(ap, char*);
+			arg->domain = va_arg(ap, char*);
+			arg->password = va_arg(ap, char*);
+			arg->result = va_arg(ap, Sint32);
+		}
+		break;
+		case SDL_EVENT_USER_AUTH_DIALOG:
+		{
+			auto arg = reinterpret_cast<SDL_UserAuthArg*>(ev.padding);
+
+			arg->title = va_arg(ap, char*);
+			arg->user = va_arg(ap, char*);
+			arg->domain = va_arg(ap, char*);
+			arg->password = va_arg(ap, char*);
+			arg->result = va_arg(ap, Sint32);
+		}
+		break;
+		case SDL_EVENT_USER_SCARD_DIALOG:
+		{
+			event->data1 = va_arg(ap, char*);
+			event->data2 = va_arg(ap, char**);
+			event->code = va_arg(ap, Sint32);
+		}
+		break;
+		case SDL_EVENT_USER_RETRY_DIALOG:
+			break;
+		case SDL_EVENT_USER_SCARD_RESULT:
+		case SDL_EVENT_USER_SHOW_RESULT:
+		case SDL_EVENT_USER_CERT_RESULT:
+			event->code = va_arg(ap, Sint32);
+			break;
+
+		case SDL_EVENT_USER_SHOW_DIALOG:
+			event->data1 = va_arg(ap, char*);
+			event->data2 = va_arg(ap, char*);
+			event->code = va_arg(ap, Sint32);
+			break;
+		case SDL_EVENT_USER_CERT_DIALOG:
+			event->data1 = va_arg(ap, char*);
+			event->data2 = va_arg(ap, char*);
+			break;
+		case SDL_EVENT_USER_UPDATE:
+			event->data1 = va_arg(ap, void*);
+			break;
+		case SDL_EVENT_USER_POINTER_POSITION:
+			event->data1 = reinterpret_cast<void*>(static_cast<uintptr_t>(va_arg(ap, UINT32)));
+			event->data2 = reinterpret_cast<void*>(static_cast<uintptr_t>(va_arg(ap, UINT32)));
+			break;
+		case SDL_EVENT_USER_POINTER_SET:
+			event->data1 = va_arg(ap, void*);
+			event->data2 = va_arg(ap, void*);
+			break;
+		case SDL_EVENT_USER_CREATE_WINDOWS:
+			event->data1 = va_arg(ap, void*);
+			break;
+		case SDL_EVENT_USER_WINDOW_FULLSCREEN:
+		case SDL_EVENT_USER_WINDOW_RESIZEABLE:
+			event->data1 = va_arg(ap, void*);
+			event->code = va_arg(ap, int);
+			break;
+		case SDL_EVENT_USER_WINDOW_MINIMIZE:
+		case SDL_EVENT_USER_QUIT:
+		case SDL_EVENT_USER_POINTER_NULL:
+		case SDL_EVENT_USER_POINTER_DEFAULT:
+		case SDL_EVENT_CLIPBOARD_UPDATE:
+			break;
+		default:
+			va_end(ap);
+			return FALSE;
+	}
+	va_end(ap);
+	return SDL_PushEvent(&ev) == 1;
+}
+
+CriticalSection::CriticalSection()
+{
+	InitializeCriticalSection(&_section);
+}
+
+CriticalSection::~CriticalSection()
+{
+	DeleteCriticalSection(&_section);
+}
+
+void CriticalSection::lock()
+{
+	EnterCriticalSection(&_section);
+}
+
+void CriticalSection::unlock()
+{
+	LeaveCriticalSection(&_section);
+}
+
+WinPREvent::WinPREvent(bool initial) : _handle(CreateEventA(nullptr, TRUE, initial, nullptr))
+{
+}
+
+WinPREvent::~WinPREvent()
+{
+	(void)CloseHandle(_handle);
+}
+
+void WinPREvent::set()
+{
+	(void)SetEvent(_handle);
+}
+
+void WinPREvent::clear()
+{
+	(void)ResetEvent(_handle);
+}
+
+bool WinPREvent::isSet() const
+{
+	return WaitForSingleObject(_handle, 0) == WAIT_OBJECT_0;
+}
+
+HANDLE WinPREvent::handle() const
+{
+	return _handle;
+}
+
+bool sdl_push_quit()
+{
+	SDL_Event ev = {};
+	ev.type = SDL_EVENT_QUIT;
+	SDL_PushEvent(&ev);
+	return true;
+}
+
+std::string sdl_window_event_str(Uint32 ev)
+{
+	if ((ev >= SDL_EVENT_WINDOW_FIRST) && (ev <= SDL_EVENT_WINDOW_LAST))
+		return sdl_event_type_str(ev);
+
+	return "SDL_EVENT_WINDOW_UNKNOWN";
+}

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

@@ -0,0 +1,112 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client
+ *
+ * Copyright 2022 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/synch.h>
+#include <winpr/wlog.h>
+
+#include <SDL3/SDL.h>
+#include <string>
+#include <vector>
+#include <memory>
+#include <functional>
+
+template <typename T> using deleted_unique_ptr = std::unique_ptr<T, std::function<void(T*)>>;
+
+class CriticalSection
+{
+  public:
+	CriticalSection();
+	CriticalSection(const CriticalSection& other) = delete;
+	CriticalSection(CriticalSection&& other) = delete;
+	~CriticalSection();
+
+	CriticalSection& operator=(const CriticalSection& other) = delete;
+	CriticalSection& operator=(CriticalSection&& other) = delete;
+
+	void lock();
+	void unlock();
+
+  private:
+	CRITICAL_SECTION _section{};
+};
+
+class WinPREvent
+{
+  public:
+	explicit WinPREvent(bool initial = false);
+	~WinPREvent();
+
+	void set();
+	void clear();
+	[[nodiscard]] bool isSet() const;
+
+	[[nodiscard]] HANDLE handle() const;
+
+  private:
+	HANDLE _handle;
+};
+
+enum
+{
+	SDL_EVENT_USER_UPDATE = SDL_EVENT_USER + 1,
+	SDL_EVENT_USER_CREATE_WINDOWS,
+	SDL_EVENT_USER_WINDOW_RESIZEABLE,
+	SDL_EVENT_USER_WINDOW_FULLSCREEN,
+	SDL_EVENT_USER_WINDOW_MINIMIZE,
+	SDL_EVENT_USER_POINTER_NULL,
+	SDL_EVENT_USER_POINTER_DEFAULT,
+	SDL_EVENT_USER_POINTER_POSITION,
+	SDL_EVENT_USER_POINTER_SET,
+	SDL_EVENT_USER_QUIT,
+	SDL_EVENT_USER_CERT_DIALOG,
+	SDL_EVENT_USER_SHOW_DIALOG,
+	SDL_EVENT_USER_AUTH_DIALOG,
+	SDL_EVENT_USER_SCARD_DIALOG,
+	SDL_EVENT_USER_RETRY_DIALOG,
+
+	SDL_EVENT_USER_CERT_RESULT,
+	SDL_EVENT_USER_SHOW_RESULT,
+	SDL_EVENT_USER_AUTH_RESULT,
+	SDL_EVENT_USER_SCARD_RESULT
+};
+
+typedef struct
+{
+	Uint32 type;
+	Uint32 timestamp;
+	char* title;
+	char* user;
+	char* domain;
+	char* password;
+	Sint32 result;
+} SDL_UserAuthArg;
+
+BOOL sdl_push_user_event(Uint32 type, ...);
+
+bool sdl_push_quit();
+
+std::string sdl_window_event_str(Uint32 ev);
+const char* sdl_event_type_str(Uint32 type);
+const char* sdl_error_string(Sint32 res);
+
+#define sdl_log_error(res, log, what) sdl_log_error_ex(res, log, what, __FILE__, __LINE__, __func__)
+BOOL sdl_log_error_ex(Sint32 res, wLog* log, const char* what, const char* file, size_t line,
+                      const char* fkt);

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

@@ -0,0 +1,64 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ * SDL Client
+ *
+ * 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.
+ */
+#pragma once
+
+#include <string>
+#include <SDL3/SDL.h>
+
+class SdlWindow
+{
+  public:
+	SdlWindow(const std::string& title, Sint32 startupX, Sint32 startupY, Sint32 width,
+	          Sint32 height, Uint32 flags);
+	SdlWindow(SdlWindow&& other) noexcept;
+	SdlWindow(const SdlWindow& other) = delete;
+	~SdlWindow();
+
+	SdlWindow& operator=(const SdlWindow& other) = delete;
+	SdlWindow& operator=(SdlWindow&& other) = delete;
+
+	[[nodiscard]] Uint32 id() const;
+	[[nodiscard]] int displayIndex() const;
+	[[nodiscard]] SDL_Rect rect() const;
+	[[nodiscard]] SDL_Window* window() const;
+
+	[[nodiscard]] Sint32 offsetX() const;
+	void setOffsetX(Sint32 x);
+
+	void setOffsetY(Sint32 y);
+	[[nodiscard]] Sint32 offsetY() const;
+
+	bool grabKeyboard(bool enable);
+	bool grabMouse(bool enable);
+	void setBordered(bool bordered);
+	void raise();
+	void resizeable(bool use);
+	void fullscreen(bool enter);
+	void minimize();
+
+	bool fill(Uint8 r = 0x00, Uint8 g = 0x00, Uint8 b = 0x00, Uint8 a = 0xff);
+	bool blit(SDL_Surface* surface, const SDL_Rect& src, SDL_Rect& dst);
+	void updateSurface();
+
+  private:
+	SDL_Window* _window = nullptr;
+	Sint32 _offset_x = 0;
+	Sint32 _offset_y = 0;
+};

local-test-freerdp-delta-01/afc-freerdp/client/Windows/CMakeLists.txt

@@ -0,0 +1,87 @@
+# FreeRDP: A Remote Desktop Protocol Implementation
+# FreeRDP Windows cmake build script
+#
+# Copyright 2012 Marc-Andre Moreau <[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.
+
+set(MODULE_NAME "wfreerdp-client")
+set(MODULE_PREFIX "FREERDP_CLIENT_WINDOWS_CONTROL")
+
+set(${MODULE_PREFIX}_SRCS
+    wf_gdi.c
+    wf_gdi.h
+    wf_event.c
+    wf_event.h
+    wf_channels.c
+    wf_channels.h
+    wf_graphics.c
+    wf_graphics.h
+    wf_cliprdr.c
+    wf_cliprdr.h
+    wf_rail.c
+    wf_rail.h
+    wf_client.c
+    wf_client.h
+    wf_floatbar.c
+    wf_floatbar.h
+    wf_defaults.h
+    wf_defaults.c
+    resource/wfreerdp.rc
+    resource/resource.h
+)
+
+option(WITH_WINDOWS_CERT_STORE
+       "Build ${MODULE_NAME} with additional certificate validation against windows certificate store" ON
+)
+if(WITH_WINDOWS_CERT_STORE)
+  add_compile_definitions("WITH_WINDOWS_CERT_STORE")
+endif()
+
+option(WITH_WIN_CONSOLE "Build ${MODULE_NAME} with console support" OFF)
+if(WITH_WIN_CONSOLE)
+  add_compile_definitions("WITH_WIN_CONSOLE")
+  set(WIN32_GUI_FLAG "TRUE")
+else()
+  set(WIN32_GUI_FLAG "WIN32")
+endif()
+
+option(WITH_PROGRESS_BAR "Build ${MODULE_NAME} with connect progress bar (Windows 7+ or 2008 R2+)" ON)
+if(WITH_PROGRESS_BAR)
+  add_compile_definitions("WITH_PROGRESS_BAR")
+endif()
+
+if(CLIENT_INTERFACE_SHARED)
+  addtargetwithresourcefile(${MODULE_NAME} "SHARED" "${FREERDP_VERSION}" ${MODULE_PREFIX}_SRCS)
+else()
+  addtargetwithresourcefile(${MODULE_NAME} FALSE "${FREERDP_VERSION}" ${MODULE_PREFIX}_SRCS)
+endif()
+target_include_directories(${MODULE_NAME} INTERFACE $<INSTALL_INTERFACE:include>)
+
+list(APPEND PUB_LIBS freerdp-client)
+list(APPEND PUB_LIBS winpr freerdp)
+
+list(APPEND PRIV_LIBS msimg32.lib credui.lib)
+
+if(MINGW)
+  list(APPEND PRIV_LIBS ntdll.lib) # only required with MINGW
+endif()
+target_link_libraries(${MODULE_NAME} PUBLIC ${PUB_LIBS})
+target_link_libraries(${MODULE_NAME} PRIVATE ${PRIV_LIBS})
+
+if(WITH_CLIENT_INTERFACE)
+  install(TARGETS ${MODULE_NAME} DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT libraries)
+endif()
+add_subdirectory(cli)
+
+set_property(TARGET ${MODULE_NAME} PROPERTY FOLDER "Client/Windows")

local-test-freerdp-delta-01/afc-freerdp/client/Windows/wf_channels.c

@@ -0,0 +1,86 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ *
+ * Copyright 2014 Marc-Andre Moreau <[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 <freerdp/config.h>
+
+#include <winpr/assert.h>
+
+#include "wf_channels.h"
+
+#include "wf_rail.h"
+#include "wf_cliprdr.h"
+
+#include <freerdp/gdi/gfx.h>
+#include <freerdp/gdi/video.h>
+
+#include <freerdp/log.h>
+#define TAG CLIENT_TAG("windows")
+
+void wf_OnChannelConnectedEventHandler(void* context, const ChannelConnectedEventArgs* e)
+{
+	wfContext* wfc = (wfContext*)context;
+	rdpSettings* settings;
+
+	WINPR_ASSERT(wfc);
+	WINPR_ASSERT(e);
+
+	settings = wfc->common.context.settings;
+	WINPR_ASSERT(settings);
+
+	if (strcmp(e->name, RAIL_SVC_CHANNEL_NAME) == 0)
+	{
+		wf_rail_init(wfc, (RailClientContext*)e->pInterface);
+	}
+	else if (strcmp(e->name, CLIPRDR_SVC_CHANNEL_NAME) == 0)
+	{
+		wf_cliprdr_init(wfc, (CliprdrClientContext*)e->pInterface);
+	}
+	else if (strcmp(e->name, DISP_DVC_CHANNEL_NAME) == 0)
+	{
+		wfc->disp = (DispClientContext*)e->pInterface;
+	}
+	else
+		freerdp_client_OnChannelConnectedEventHandler(context, e);
+}
+
+void wf_OnChannelDisconnectedEventHandler(void* context, const ChannelDisconnectedEventArgs* e)
+{
+	wfContext* wfc = (wfContext*)context;
+	rdpSettings* settings;
+
+	WINPR_ASSERT(wfc);
+	WINPR_ASSERT(e);
+
+	settings = wfc->common.context.settings;
+	WINPR_ASSERT(settings);
+
+	if (strcmp(e->name, RAIL_SVC_CHANNEL_NAME) == 0)
+	{
+		wf_rail_uninit(wfc, (RailClientContext*)e->pInterface);
+	}
+	else if (strcmp(e->name, CLIPRDR_SVC_CHANNEL_NAME) == 0)
+	{
+		wf_cliprdr_uninit(wfc, (CliprdrClientContext*)e->pInterface);
+	}
+	else if (strcmp(e->name, DISP_DVC_CHANNEL_NAME) == 0)
+	{
+		wfc->disp = NULL;
+	}
+	else
+		freerdp_client_OnChannelDisconnectedEventHandler(context, e);
+}

local-test-freerdp-delta-01/afc-freerdp/client/Windows/wf_defaults.c

@@ -0,0 +1,161 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ *
+ * Copyright 2022 Stefan Koell
+ *
+ * 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 <windows.h>
+#include <wincred.h>
+#include <stdio.h>
+#include <malloc.h>
+#include <freerdp/settings.h>
+
+#include "wf_defaults.h"
+
+static PCWSTR ValidateString(const BYTE* pb, ULONG cb)
+{
+	if (!pb || !cb)
+		return 0;
+
+	if (cb % sizeof(WCHAR) != 0)
+		return 0;
+
+	return (PCWSTR)pb;
+}
+
+static void AddDefaultSettings_I(rdpSettings* settings, size_t idHostname, size_t idUsername,
+                                 size_t idDomain, size_t idPassword)
+{
+	static const PSTR TERMSRV = "TERMSRV/%s";
+
+	PSTR TargetName = NULL;
+	PSTR UserName = NULL;
+	PWSTR TargetNameW = NULL;
+	PWSTR ServerHostNameW = NULL;
+	PWSTR ParsedUserNameW = NULL;
+	PWSTR ParsedDomainW = NULL;
+	PWSTR PasswordNullTerminatedW = NULL;
+	PCREDENTIALW Credential = { 0 };
+
+	PCSTR ServerHostname = freerdp_settings_get_string(settings, idHostname);
+
+	if (!ServerHostname)
+		return;
+
+	BOOL bExistUserName = freerdp_settings_get_string(settings, idUsername) != 0;
+	BOOL bExistPassword = freerdp_settings_get_string(settings, idPassword) != 0;
+
+	if (bExistUserName && bExistPassword)
+		return;
+
+	int len = _snprintf(TargetName, 0, TERMSRV, ServerHostname);
+	len++;
+	TargetName = (PSTR)malloc(len);
+
+	if (!TargetName)
+		goto fail;
+
+	_snprintf(TargetName, len, TERMSRV, ServerHostname);
+
+	TargetName[len - 1] = 0;
+
+	TargetNameW = ConvertUtf8ToWCharAlloc(TargetName, NULL);
+	if (!TargetNameW)
+		goto fail;
+
+	if (!CredReadW(TargetNameW, CRED_TYPE_GENERIC, 0, &Credential))
+		goto fail;
+
+	if (!bExistPassword)
+	{
+		const WCHAR* PasswordW =
+		    ValidateString(Credential->CredentialBlob, Credential->CredentialBlobSize);
+
+		PasswordNullTerminatedW = (PWSTR)calloc(Credential->CredentialBlobSize + 1, sizeof(WCHAR));
+
+		if (!PasswordNullTerminatedW)
+			goto fail;
+
+		memcpy(PasswordNullTerminatedW, PasswordW, Credential->CredentialBlobSize * sizeof(WCHAR));
+
+		if (PasswordNullTerminatedW)
+		{
+			if (!freerdp_settings_set_string_from_utf16(settings, idPassword,
+			                                            PasswordNullTerminatedW))
+			{
+				goto fail;
+			}
+		}
+	}
+
+	if (!bExistUserName)
+	{
+		const WCHAR* UserNameW = Credential->UserName;
+
+		if (UserNameW)
+		{
+			ParsedUserNameW = calloc(CREDUI_MAX_USERNAME_LENGTH + 1, sizeof(WCHAR));
+			if (!ParsedUserNameW)
+				goto fail;
+
+			ParsedDomainW = calloc(CREDUI_MAX_DOMAIN_TARGET_LENGTH + 1, sizeof(WCHAR));
+			if (!ParsedDomainW)
+				goto fail;
+
+			DWORD ParseResult =
+			    CredUIParseUserNameW(UserNameW, ParsedUserNameW, CREDUI_MAX_USERNAME_LENGTH + 1,
+			                         ParsedDomainW, CREDUI_MAX_DOMAIN_TARGET_LENGTH + 1);
+
+			if (ParseResult == NO_ERROR)
+			{
+				if (!freerdp_settings_set_string_from_utf16(settings, idUsername, ParsedUserNameW))
+					goto fail;
+
+				if (*ParsedDomainW != 0)
+				{
+					if (!freerdp_settings_set_string_from_utf16(settings, idDomain, ParsedDomainW))
+						goto fail;
+				}
+			}
+			else if (ParseResult == ERROR_INVALID_ACCOUNT_NAME)
+			{
+				if (!freerdp_settings_set_string_from_utf16(settings, idUsername, UserNameW))
+					goto fail;
+			}
+		}
+	}
+
+fail:
+	if (Credential)
+	{
+		CredFree(Credential);
+	}
+	free(TargetName);
+	free(UserName);
+	free(TargetNameW);
+	free(ServerHostNameW);
+	free(ParsedUserNameW);
+	free(ParsedDomainW);
+	free(PasswordNullTerminatedW);
+	return;
+}
+
+void WINAPI AddDefaultSettings(rdpSettings* settings)
+{
+	AddDefaultSettings_I(settings, FreeRDP_ServerHostname, FreeRDP_Username, FreeRDP_Domain,
+	                     FreeRDP_Password);
+	AddDefaultSettings_I(settings, FreeRDP_GatewayHostname, FreeRDP_GatewayUsername,
+	                     FreeRDP_GatewayDomain, FreeRDP_GatewayPassword);
+}

local-test-freerdp-delta-01/afc-freerdp/client/Windows/wf_defaults.h

@@ -0,0 +1,28 @@
+/**
+ * FreeRDP: A Remote Desktop Protocol Implementation
+ *
+ * Copyright 2022 Stefan Koell
+ *
+ * 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.
+ */
+
+#ifndef FREERDP_CLIENT_WIN_DEFAULTS_H
+#define FREERDP_CLIENT_WIN_DEFAULTS_H
+
+#include <winpr/wtypes.h>
+#include <freerdp/api.h>
+#include <freerdp/settings.h>
+
+FREERDP_API void WINAPI AddDefaultSettings(_Inout_ rdpSettings* settings);
+
+#endif /* FREERDP_CLIENT_WIN_DEFAULTS_H */