{

static class AppletManager

{

static AppletManager()

{

{ AppletId.SoftwareKeyboard, typeof(SoftwareKeyboardApplet) },

{ AppletId.LibAppletWeb, typeof(BrowserApplet) },

{ AppletId.LibAppletShop, typeof(BrowserApplet) },

};

}

Offline,

Black,

Share,

}

}

public event EventHandler AppletStateChanged;

private AppletSession _normalSession;

private CommonArguments _commonArguments;

private List<BrowserArgument> _arguments;

private ShimKind _shimKind;

public ResultCode GetResult()

{

public ResultCode Start(AppletSession normalSession, AppletSession interactiveSession)

{

_normalSession = normalSession;

_commonArguments = IApplet.ReadStruct<CommonArguments>(_normalSession.Pop());

if ((_commonArguments.AppletVersion >= 0x80000 && _shimKind == ShimKind.Web) || (_commonArguments.AppletVersion >= 0x30000 && _shimKind == ShimKind.Share))

{

_normalSession.Push(BuildResponseNew(result));

}

else

{

{

};

_normalSession.Push(BuildResponseOld(result));

return ResultCode.Success;

}

{

}

private byte[] BuildResponseNew(List<BrowserOutput> outputArguments)

{

{

}

}

}

{

class BrowserArgument

{

public BrowserArgument(WebArgTLVType type, byte[] value)

{

Value = value;

}

{

{ WebArgTLVType.InitialURL, typeof(string) },

{ WebArgTLVType.CallbackUrl, typeof(string) },

public static (ShimKind, List<BrowserArgument>) ParseArguments(ReadOnlySpan<byte> data)

{

for (int i = 0; i < header.Count; i++)

{

browserArguments.Add(new BrowserArgument((WebArgTLVType)tlv.Type, tlvData.ToArray()));

}

return (header.ShimKind, browserArguments);

public BrowserOutput(BrowserOutputType type, byte[] value)

{

Value = value;

}

public BrowserOutput(BrowserOutputType type, uint value)

{

}

public BrowserOutput(BrowserOutputType type, ulong value)

{

Value = BitConverter.GetBytes(value);

}

public BrowserOutput(BrowserOutputType type, bool value)

{

Value = BitConverter.GetBytes(value);

}

writer.WriteStruct(new WebArgTLV

{

Type = (ushort)Type,

});

writer.Write(Value);

{

enum BrowserOutputType : ushort

{

}

}

{

OfflineHtmlPage = 1,

ApplicationLegalInformation,

}

}

enum LeftStickMode

{

Pointer = 0,

}

}

Share,

Web,

Wifi,

}

}

{

public struct WebArgHeader

{

public ShimKind ShimKind;

}

}

{

public ushort Type;

public ushort Size;

}

}

{

enum WebArgTLVType : ushort

{

MediaCreatorApplicationRatingAge = 0x34,

}

}

public struct WebCommonReturnValue

{

public WebExitReason ExitReason;

public ByteArray4096 LastUrl;

}

}

BackButton,

Requested,

LastUrl,

}

}

[StructLayout(LayoutKind.Sequential, Pack = 8)]

struct CommonArguments

{

[MarshalAs(UnmanagedType.I1)]

public ulong SystemTicks;

}

}

{

internal class ControllerApplet : IApplet

{

private AppletSession _normalSession;

}

else

{

argHeader = IApplet.ReadStruct<ControllerSupportArgHeader>(controllerSupportArg); // Read just the header

}

playerMin = playerMax = 1;

}

while (!_system.Device.Hid.Npads.Validate(playerMin, playerMax, (ControllerType)privateArg.NpadStyleSet, out configuredCount, out primaryIndex))

{

{

PlayerCountMin = playerMin,

PlayerCountMax = playerMax,

SupportedStyles = (ControllerType)privateArg.NpadStyleSet,

SupportedPlayers = _system.Device.Hid.Npads.GetSupportedPlayers(),

};

if (!_system.Device.UiHandler.DisplayMessageDialog(uiArgs))

}

}

{

PlayerCount = (sbyte)configuredCount,

};

Logger.Stub?.PrintStub(LogClass.ServiceHid, $"ControllerApplet ReturnResult {result.PlayerCount} {result.SelectedId}");

return ResultCode.Success;

}

{

}

{

}

}

}

public IEnumerable<PlayerIndex> SupportedPlayers;

public bool IsDocked;

}

namespace Ryujinx.HLE.HOS.Applets

{

[StructLayout(LayoutKind.Sequential, Pack = 1)]

struct ControllerSupportArgHeader

{

public byte EnableIdentificationColor;

}

#pragma warning restore CS0649

namespace Ryujinx.HLE.HOS.Applets

{

struct ControllerSupportArgPrivate

{

public uint PrivateSize;

public uint NpadJoyHoldType;

}

#pragma warning restore CS0649

namespace Ryujinx.HLE.HOS.Applets

{

// (8.0.0+ version)

[StructLayout(LayoutKind.Sequential, Pack = 1)]

struct ControllerSupportArgV7

}

}

#pragma warning restore CS0649

namespace Ryujinx.HLE.HOS.Applets

{

// (1.0.0+ version)

[StructLayout(LayoutKind.Sequential, Pack = 1)]

struct ControllerSupportArgVPre7

}

}

#pragma warning restore CS0649

{

ShowControllerSupport = 0,

ShowControllerStrapGuide = 1,

}

namespace Ryujinx.HLE.HOS.Applets

{

[StructLayout(LayoutKind.Sequential, Pack = 1)]

struct ControllerSupportResultInfo

{

public uint Result;

}

#pragma warning restore CS0649

[StructLayout(LayoutKind.Sequential, Pack = 1)]

struct ApplicationErrorArg

{

public ByteArray2048 MessageText;

public ByteArray2048 DetailsText;

}

{

private const long ErrorMessageBinaryTitleId = 0x0100000000000801;

private ErrorCommonHeader _errorCommonHeader;

public event EventHandler AppletStateChanged;

public ResultCode Start(AppletSession normalSession, AppletSession interactiveSession)

{

_commonArguments = IApplet.ReadStruct<CommonArguments>(_normalSession.Pop());

Logger.Info?.PrintMsg(LogClass.ServiceAm, $"ErrorApplet version: 0x{_commonArguments.AppletVersion:x8}");

_errorCommonHeader = IApplet.ReadStruct<ErrorCommonHeader>(_errorStorage);

switch (_errorCommonHeader.Type)

{

break;

}

}

AppletStateChanged?.Invoke(this, null);

return ResultCode.Success;

}

{

return ((resultCode & 0x1FF) + 2000, (resultCode >> 9) & 0x3FFF);

}

{

return systemLanguage switch

{

SystemLanguage.Japanese => "ja",

SystemLanguage.AmericanEnglish => "en-US",

SystemLanguage.French => "fr",

SystemLanguage.SimplifiedChinese => "zh-Hans",

SystemLanguage.TraditionalChinese => "zh-Hant",

SystemLanguage.BrazilianPortuguese => "pt-BR",

};

}

{

string binaryTitleContentPath = _horizon.ContentManager.GetInstalledContentPath(ErrorMessageBinaryTitleId, StorageId.BuiltInSystem, NcaContentType.Data);

{

}

}

{

ErrorCommonArg errorCommonArg = IApplet.ReadStruct<ErrorCommonArg>(_errorStorage);

uint description = errorCommonArg.Description;

if (_errorCommonHeader.MessageFlag == 0)

string messageText = Encoding.ASCII.GetString(messageTextBuffer.TakeWhile(b => !b.Equals(0)).ToArray());

string detailsText = Encoding.ASCII.GetString(detailsTextBuffer.TakeWhile(b => !b.Equals(0)).ToArray());

// TODO: Handle the LanguageCode to return the translated "OK" and "Details".

return ResultCode.Success;

}

}

public uint Description;

public uint ResultCode;

}

struct ErrorCommonHeader

{

public ErrorType Type;

}

ErrorEulaArg,

ErrorPctlArg,

ErrorRecordArg,

}

{

internal class PlayerSelectApplet : IApplet

{

private AppletSession _normalSession;

private AppletSession _interactiveSession;

public event EventHandler AppletStateChanged;

public ResultCode Start(AppletSession normalSession, AppletSession interactiveSession)

{

_interactiveSession = interactiveSession;

// TODO(jduncanator): Parse PlayerSelectConfig from input data

{

UserProfile currentUser = _system.AccountManager.LastOpenedUser;

}

}

}

enum PlayerSelectResult : ulong

{

Success = 0,

}

}

[GeneratedRegex("\\p{IsHangulJamo}|\\p{IsCJKRadicalsSupplement}|\\p{IsCJKSymbolsandPunctuation}|\\p{IsEnclosedCJKLettersandMonths}|\\p{IsCJKCompatibility}|\\p{IsCJKUnifiedIdeographsExtensionA}|\\p{IsCJKUnifiedIdeographs}|\\p{IsHangulSyllables}|\\p{IsCJKCompatibilityForms}")]

private static partial Regex CJKRegex();

}

/// <summary>

/// Position the cursor at the end of the text

/// </summary>

}

}

/// <summary>

/// [8.0.0+] Request the keyboard applet to use the MovedCursorV2 response when notifying changes in cursor position.

/// </summary>

}

}

/// <summary>

/// Same as MovedCursorUtf8, but with additional fields.

/// </summary>

}

}

/// <summary>

/// software keyboard is transitioning to a hidden state because the user pressed either OK or Cancel.

/// </summary>

}

}

{

uint resSize = 2 * sizeof(uint) + 0x1;

}

public static byte[] Default(InlineKeyboardState state)

{

uint resSize = 2 * sizeof(uint);

}

public static byte[] ChangedString(string text, uint cursor, InlineKeyboardState state)

{

uint resSize = 6 * sizeof(uint) + MaxStrLenUTF16;

}

public static byte[] MovedCursor(string text, uint cursor, InlineKeyboardState state)

{

uint resSize = 4 * sizeof(uint) + MaxStrLenUTF16;

}

public static byte[] MovedTab(string text, uint cursor, InlineKeyboardState state)

uint resSize = 4 * sizeof(uint) + MaxStrLenUTF16;

}

public static byte[] DecidedEnter(string text, InlineKeyboardState state)

{

uint resSize = 3 * sizeof(uint) + MaxStrLenUTF16;

}

public static byte[] DecidedCancel(InlineKeyboardState state)

{

uint resSize = 2 * sizeof(uint);

}

public static byte[] ChangedStringUtf8(string text, uint cursor, InlineKeyboardState state)

{

uint resSize = 6 * sizeof(uint) + MaxStrLenUTF8;

}

public static byte[] MovedCursorUtf8(string text, uint cursor, InlineKeyboardState state)

{

uint resSize = 4 * sizeof(uint) + MaxStrLenUTF8;

}

public static byte[] DecidedEnterUtf8(string text, InlineKeyboardState state)

{

uint resSize = 3 * sizeof(uint) + MaxStrLenUTF8;

}

public static byte[] UnsetCustomizeDic(InlineKeyboardState state)

{

uint resSize = 2 * sizeof(uint);

}

public static byte[] ReleasedUserWordInfo(InlineKeyboardState state)

{

uint resSize = 2 * sizeof(uint);

}

public static byte[] UnsetCustomizedDictionaries(InlineKeyboardState state)

{

uint resSize = 2 * sizeof(uint);

}

public static byte[] ChangedStringV2(string text, uint cursor, InlineKeyboardState state)

{

uint resSize = 6 * sizeof(uint) + MaxStrLenUTF16 + 0x1;

}

public static byte[] MovedCursorV2(string text, uint cursor, InlineKeyboardState state)

{

uint resSize = 4 * sizeof(uint) + MaxStrLenUTF16 + 0x1;

}

public static byte[] ChangedStringUtf8V2(string text, uint cursor, InlineKeyboardState state)

{

uint resSize = 6 * sizeof(uint) + MaxStrLenUTF8 + 0x1;

}

public static byte[] MovedCursorUtf8V2(string text, uint cursor, InlineKeyboardState state)

{

uint resSize = 4 * sizeof(uint) + MaxStrLenUTF8 + 0x1;

}

}

}

/// <summary>

/// Displays the text entry area as a multi-line field.

/// </summary>

}

}

[Flags]

enum InvalidButtonFlags : uint

{

AnalogStickL = 1 << 1,

AnalogStickR = 1 << 2,

}

}

/// <summary>

/// Prohibits characters outside of those allowed in Mii Nicknames.

/// </summary>

}

}

[Flags]

enum KeyboardCalcFlags : ulong

{

SetKeyboardBackground = 0x100,

}

}

/// </summary>

enum KeyboardMiniaturizationMode : byte

{

}

}

/// Synonymous with default.

/// </summary>

FullLatin = 3,

/// <summary>

/// All UTF-16 characters except CJK characters allowed.

/// </summary>

Alphabet = 4,

TraditionalChinese = 6,

}

}

Accept = 1,

Cancel = 2,

}

/// <summary>

/// Hide input characters.

/// </summary>

}

}

[MarshalAs(UnmanagedType.I1)]

public bool UseSaveData;

public ushort Reserved4;

public SoftwareKeyboardAppearEx ToExtended()

{

return appear;

}

[MarshalAs(UnmanagedType.I1)]

public bool UseSaveData;

public ushort Reserved4;

/// <summary>

/// The id of the user associated with the appear request.

{

private const string DefaultInputText = "Ryujinx";

private const int InteractiveBufferSize = 0x7D4;

private const Key CycleInputModesKey = Key.F6;

private readonly Switch _device;

private volatile InlineKeyboardState _backgroundState = InlineKeyboardState.Uninitialized;

private bool _isBackground = false;

private SoftwareKeyboardConfig _keyboardForegroundConfig;

// Configuration for background (inline) mode.

private SoftwareKeyboardCustomizeDic _keyboardBackgroundDic;

private byte[] _transferMemory;

private IDynamicTextInputHandler _dynamicTextInputHandler = null;

private readonly object _lock = new();

{

lock (_lock)

{

_interactiveSession = interactiveSession;

_interactiveSession.DataAvailable += OnInteractiveData;

var keyboardConfig = _normalSession.Pop();

_isBackground = keyboardConfig.Length == Unsafe.SizeOf<SoftwareKeyboardInitialize>();

// Initialize the keyboard applet in background mode.

_keyboardBackgroundInitialize = MemoryMarshal.Read<SoftwareKeyboardInitialize>(keyboardConfig);

if (_device.UiHandler == null)

{

// Create a text handler that converts keyboard strokes to strings.

_dynamicTextInputHandler = _device.UiHandler.CreateDynamicTextInputHandler();

_dynamicTextInputHandler.TextChangedEvent += HandleTextChangedEvent;

_npads = new NpadReader(_device);

_npads.NpadButtonDownEvent += HandleNpadButtonDownEvent;

_keyboardRenderer = new SoftwareKeyboardRenderer(_device.UiHandler.HostUiTheme);

}

_keyboardForegroundConfig.SubmitText : "OK"),

StringLengthMin = _keyboardForegroundConfig.StringLengthMin,

StringLengthMax = _keyboardForegroundConfig.StringLengthMax,

};

_lastResult = _device.UiHandler.DisplayInputDialog(args, out _textValue) ? KeyboardResult.Accept : KeyboardResult.Cancel;

// we truncate it.

if (_textValue.Length > _keyboardForegroundConfig.StringLengthMax)

{

}

// Does the application want to validate the text itself?

// request from the game, this is because the inline keyboard is expected to

// keep running in the background sending data by itself.

remaining = stream.Length - stream.Position;

{

}

{

}

else

{

}

}

}

private void ActivateFrontend()

{

_inputMode = KeyboardInputMode.ControllerAndKeyboard;

private void DeactivateFrontend()

{

_canAcceptController = false;

_dynamicTextInputHandler.TextProcessingEnabled = false;

private void DestroyFrontend()

{

_keyboardRenderer?.Dispose();

_keyboardRenderer = null;

if (_dynamicTextInputHandler != null)

{

_dynamicTextInputHandler.TextChangedEvent -= HandleTextChangedEvent;

_dynamicTextInputHandler.Dispose();

_dynamicTextInputHandler = null;

}

if (_npads != null)

{

_npads.NpadButtonDownEvent -= HandleNpadButtonDownEvent;

_npads = null;

}

}

{

AdvanceInputMode();

bool controllerEnabled = InputModeControllerEnabled();

_dynamicTextInputHandler.TextProcessingEnabled = typingEnabled;

if (text.Length > MaxUiTextSize)

{

// Limit the text size and change it back.

cursorBegin = Math.Min(cursorBegin, MaxUiTextSize);

_dynamicTextInputHandler.SetText(text, cursorBegin, cursorEnd);

}

_cursorBegin = cursorBegin;

_keyboardRenderer.UpdateTextState(text, cursorBegin, cursorEnd, overwriteMode, null);

private void PushUpdatedState(string text, int cursorBegin, KeyboardResult result)

{

_lastResult = result;

bool cancel = result == KeyboardResult.Cancel;

bool accept = result == KeyboardResult.Accept;

{

int bufferSize = interactive ? InteractiveBufferSize : StandardBufferSize;

}

}

return string.Empty;

}

foreach (char c in input)

{

if (!char.IsControl(c))

public SoftwareKeyboardCalcEx ToExtended()

{

return calc;

}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]

struct SoftwareKeyboardConfig

{

private const int SubtitleTextLength = 128;

/// <summary>

/// Type of keyboard.

/// </summary>

internal class SoftwareKeyboardRenderer : IDisposable

{

private const int RendererWaitTimeoutMilliseconds = 100;

public SoftwareKeyboardRenderer(IHostUiTheme uiTheme)

{

private static void StartRenderer(TimedAction timedAction, SoftwareKeyboardRendererBase renderer, SoftwareKeyboardUiState state, object stateLock)

{

bool canCreateSurface = false;

timedAction.Reset(() =>

{

return;

}

needsUpdate = UpdateStateField(ref state.InputText, ref internalState.InputText);

needsUpdate |= UpdateStateField(ref state.CursorBegin, ref internalState.CursorBegin);

needsUpdate |= UpdateStateField(ref state.CursorEnd, ref internalState.CursorEnd);

needsUpdate |= UpdateStateField(ref state.TypingEnabled, ref internalState.TypingEnabled);

needsUpdate |= UpdateStateField(ref state.ControllerEnabled, ref internalState.ControllerEnabled);

needsUpdate |= UpdateStateField(ref state.TextBoxBlinkCounter, ref internalState.TextBoxBlinkCounter);

canCreateSurface = state.SurfaceInfo != null && internalState.SurfaceInfo == null;

return false;

}

{

lock (_stateLock)

{

// Update the parameters that were provided.

_state.OverwriteMode = overwriteMode.GetValueOrDefault(_state.OverwriteMode);

_state.TypingEnabled = typingEnabled.GetValueOrDefault(_state.TypingEnabled);

lock (_stateLock)

{

// Update the parameters that were provided.

_state.ControllerEnabled = controllerEnabled.GetValueOrDefault(_state.ControllerEnabled);

// Tell the render thread there is something new to render.

{

public const int TextBoxBlinkThreshold = 8;

const string ControllerToggleText = "Toggle input";

private readonly object _bufferLock = new();

private RenderingSurfaceInfo _surfaceInfo = null;

private Font _messageFont;

private Font _inputTextFont;

private Font _labelsTextFont;

private RectangleF _panelRectangle;

public SoftwareKeyboardRendererBase(IHostUiTheme uiTheme)

{

string padAcceptIconPath = "Ryujinx.HLE.HOS.Applets.SoftwareKeyboard.Resources.Icon_BtnA.png";

string padCancelIconPath = "Ryujinx.HLE.HOS.Applets.SoftwareKeyboard.Resources.Icon_BtnB.png";

Color selectionBackgroundColor = ToColor(uiTheme.SelectionBackgroundColor);

_textOverCursorColor = ToColor(uiTheme.DefaultForegroundColor, null, true);

float cursorWidth = 2;

_textBoxOutlineWidth = 2;

_selectionBoxBrush = new SolidBrush(selectionBackgroundColor);

_textBoxOutlinePen = new Pen(borderColor, _textBoxOutlineWidth);

_inputTextFontSize = 20;

{

// Try a list of fonts in case any of them is not available in the system.

uiThemeFontFamily,

"Liberation Sans",

"FreeSans",

"DejaVu Sans",

};

foreach (string fontFamily in availableFonts)

{

try

{

return;

}

throw new Exception($"None of these fonts were found in the system: {String.Join(", ", availableFonts)}!");

}

{

var a = (byte)(color.A * 255);

var r = (byte)(color.R * 255);

return Color.FromRgba(r, g, b, overrideAlpha.GetValueOrDefault(a));

}

{

Stream resourceStream = assembly.GetManifestResourceStream(resourcePath);

return LoadResource(resourceStream, newWidth, newHeight);

}

{

Debug.Assert(resourceStream != null);

return image;

}

{

context.GetGraphicsOptions().Antialias = true;

context.GetShapeGraphicsOptions().GraphicsOptions.Antialias = true;

context.DrawImage(_ryujinxLogo, _logoPosition, 1);

float halfWidth = _panelRectangle.Width / 2;

DrawControllerToggle(context, disableButtonPosition);

});

_surface.Mutate(context =>

{

SetGraphicsOptions(context);

DrawTextBox(context, state);

float halfWidth = _panelRectangle.Width / 2;

DrawPadButton(context, acceptButtonPosition, _padAcceptIcon, AcceptText, state.AcceptPressed, state.ControllerEnabled);

DrawPadButton(context, cancelButtonPosition, _padCancelIcon, CancelText, state.CancelPressed, state.ControllerEnabled);

// Use the whole area of the image to draw, even the alignment, otherwise it may shear the final

// image if the pitch is different.

uint totalHeight = _surfaceInfo.Size / _surfaceInfo.Pitch;

Debug.Assert(_surfaceInfo.Width <= totalWidth);

private void ComputeConstants()

{

int totalHeight = (int)_surfaceInfo.Height;

int panelPositionY = totalHeight - panelHeight;

_panelRectangle = new RectangleF(0, panelPositionY, totalWidth, panelHeight);

}

private static RectangleF MeasureString(string text, Font font)

{

if (text == "")

{

private static RectangleF MeasureString(ReadOnlySpan<char> text, Font font)

{

if (text == "")

{

{

var inputTextRectangle = MeasureString(state.InputText, _inputTextFont);

float boxHeight = 32;

_panelRectangle.Width, boxHeight + 2 * _textBoxOutlineWidth);

context.Fill(_panelBrush, boundRectangle);

// Draw the cursor on top of the text and redraw the text with a different color if necessary.

IBrush cursorBrush;

float cursorPositionYBottom = cursorPositionYTop + _inputTextFontSize + 1;

float cursorPositionXLeft;

float cursorPositionXRight;

Debug.Assert(state.InputText.Length > 0);

cursorTextColor = _textSelectedColor;

ReadOnlySpan<char> textUntilBegin = state.InputText.AsSpan(0, state.CursorBegin);

var selectionBeginRectangle = MeasureString(textUntilBegin, _inputTextFont);

}

else

{

cursorTextColor = _textOverCursorColor;

if (state.TextBoxBlinkCounter < TextBoxBlinkThreshold)

{

// Show the blinking cursor.

cursorPositionXLeft = inputTextX + cursorTextRectangle.Width + cursorTextRectangle.X;

if (state.OverwriteMode)

if (state.CursorBegin < state.InputText.Length)

{

cursorPositionXRight = inputTextX + cursorTextRectangle.Width + cursorTextRectangle.X;

}

else

}

else

{

cursorPositionXRight = inputTextX;

}

}

if (state.TypingEnabled && cursorVisible)

{

float cursorHeight = cursorPositionYBottom - cursorPositionYTop;

if (cursorWidth == 0)

{

new PointF(cursorPositionXLeft, cursorPositionYTop),

new PointF(cursorPositionXLeft, cursorPositionYBottom),

};

{

var cursorRectangle = new RectangleF(cursorPositionXLeft, cursorPositionYTop, cursorWidth, cursorHeight);

context.Fill(cursorBrush, cursorRectangle);

textOverCursor.Mutate(context =>

{

var textRelativePosition = new PointF(inputTextPosition.X - cursorRectangle.X, inputTextPosition.Y - cursorRectangle.Y);

{

// Use relative positions so we can center the the entire drawing later.

float iconHeight = icon.Height;

var labelRectangle = MeasureString(label, _labelsTextFont);

float labelPositionX = iconWidth + 8 - labelRectangle.X;

float labelPositionY = 3;

float fullHeight = iconHeight;

// Convert all relative positions into absolute.

float originY = (int)(point.Y - fullHeight / 2);

iconX += originX;

iconY += originY;

var labelPosition = new PointF(labelPositionX + originX, labelPositionY + originY);

var selectedRectangle = new RectangleF(originX - 2 * _padPressedPenWidth, originY - 2 * _padPressedPenWidth,

// Use relative positions so we can center the the entire drawing later.

float keyHeight = _keyModeIcon.Height;

float labelPositionX = keyWidth + 8 - labelRectangle.X;

float keyX = 0;

float keyY = (int)((labelPositionY + labelRectangle.Height - keyHeight) / 2);

float fullHeight = Math.Max(labelPositionY + labelRectangle.Height, keyHeight);

// Convert all relative positions into absolute.

float originY = (int)(point.Y - fullHeight / 2);

keyX += originX;

keyY += originY;

var overlayPosition = new Point((int)keyX, (int)keyY);

context.DrawImage(_keyModeIcon, overlayPosition, 1);

/// <summary>

/// swkbd has completed.

/// </summary>

}

public int StringLengthMin;

public int StringLengthMax;

}

/// </summary>

internal class SoftwareKeyboardUiState

{

public RenderingSurfaceInfo SurfaceInfo = null;

}

public SleepSubstepData(int sleepMilliseconds)

{

SleepRemainderMilliseconds = sleepMilliseconds - SleepCount * SleepMilliseconds;

}

}