+ dotnet-version: 6.0.x

+ run: dotnet publish -c "${{ matrix.configuration }}" -r "${{ matrix.DOTNET_RUNTIME_IDENTIFIER }}" -o ./publish /p:Version="1.0.0" /p:DebugType=embedded /p:SourceRevisionId="${{ steps.git_short_hash.outputs.result }}" /p:ExtraDefineConstants=DISABLE_UPDATER Ryujinx --self-contained

+ run: dotnet publish -c "${{ matrix.configuration }}" -r "${{ matrix.DOTNET_RUNTIME_IDENTIFIER }}" -o ./publish_sdl2_headless /p:Version="1.0.0" /p:DebugType=embedded /p:SourceRevisionId="${{ steps.git_short_hash.outputs.result }}" /p:ExtraDefineConstants=DISABLE_UPDATER Ryujinx.Headless.SDL2 --self-contained

+ <TargetFramework>net6.0</TargetFramework>

+ <PackageReference Include="Mono.Posix.NETStandard" Version="5.20.1-preview" />

+**Step one:** Install the X64 version of [.NET 6.0 (or higher) SDK](https://dotnet.microsoft.com/download/dotnet/6.0).

+ <TargetFramework>net6.0</TargetFramework>

+ <TargetFramework>net6.0</TargetFramework>

+ <TargetFramework>net6.0</TargetFramework>

+ <TargetFramework>net6.0</TargetFramework>

+ <TargetFramework>net6.0</TargetFramework>

+ <TargetFramework>net6.0</TargetFramework>

+ <PackageReference Include="System.Drawing.Common" Version="6.0.0" />

+ <PackageReference Include="System.Management" Version="6.0.0" />

+using System.Runtime.Versioning;

+ if (OperatingSystem.IsWindowsVersionAtLeast(6))

+ double userDpiScale = 96.0;

+ if (OperatingSystem.IsWindows())

+ {

+ userDpiScale = Graphics.FromHwnd(IntPtr.Zero).DpiX;

+ }

+ else

+ {

+ // TODO: Linux support

+ }

+ <TargetFramework>net6.0</TargetFramework>

+ <TargetFramework>net6.0</TargetFramework>

+ <TargetFramework>net6.0</TargetFramework>

+ <TargetFramework>net6.0</TargetFramework>

+ <ItemGroup>

+ <PackageReference Include="SharpZipLib" Version="1.3.3" />

+ </ItemGroup>

+

+using ICSharpCode.SharpZipLib.Zip;

+using Ryujinx.Common;

+ private ZipFile _cacheArchive;

+ _cacheArchive = new ZipFile(File.OpenRead(GetArchivePath()));

+ _cacheArchive.Close();

+ if (!File.Exists(archivePath))

+ {

+ using (ZipFile newZip = ZipFile.Create(archivePath))

+ {

+ // Workaround for SharpZipLib issue #395

+ newZip.BeginUpdate();

+ newZip.CommitUpdate();

+ }

+ }

+

+ _cacheArchive = new ZipFile(File.Open(archivePath, FileMode.Open, FileAccess.ReadWrite, FileShare.None));

+ _cacheArchive.Close();

+using ICSharpCode.SharpZipLib.Zip;

+using Ryujinx.Common;

+ public static byte[] ReadFromArchive(ZipFile archive, Hash128 entry)

+ ZipEntry archiveEntry = archive.GetEntry($"{entry}");

+ byte[] result = new byte[archiveEntry.Size];

+ using (Stream archiveStream = archive.GetInputStream(archiveEntry))

+ public static void EnsureArchiveUpToDate(string baseCacheDirectory, ZipFile archive, HashSet<Hash128> entries)

+ List<string> filesToDelete = new List<string>();

+

+ archive.BeginUpdate();

+

+ ZipEntry entry = archive.GetEntry(cacheHash);

+ if (entry != null)

+ {

+ archive.Delete(entry);

+ }

+ // We enforce deflate compression here to avoid possible incompatibilities on older version of Ryujinx that use System.IO.Compression.

+ archive.Add(new StaticDiskDataSource(cacheTempFilePath), cacheHash, CompressionMethod.Deflated);

+ filesToDelete.Add(cacheTempFilePath);

+

+ archive.CommitUpdate();

+

+ foreach (string filePath in filesToDelete)

+ {

+ File.Delete(filePath);

+ }

+using ICSharpCode.SharpZipLib.Zip;

+using Ryujinx.Common;

+ private class StreamZipEntryDataSource : IStaticDataSource

+ {

+ private readonly ZipFile Archive;

+ private readonly ZipEntry Entry;

+ public StreamZipEntryDataSource(ZipFile archive, ZipEntry entry)

+ {

+ Archive = archive;

+ Entry = entry;

+ }

+

+ public Stream GetSource()

+ {

+ return Archive.GetInputStream(Entry);

+ }

+ }

+

+ private static void MoveEntry(ZipFile archive, Hash128 oldKey, Hash128 newKey)

+ ZipEntry oldGuestEntry = archive.GetEntry($"{oldKey}");

+ archive.Add(new StreamZipEntryDataSource(archive, oldGuestEntry), $"{newKey}", CompressionMethod.Deflated);

+ archive.Delete(oldGuestEntry);

+ ZipFile guestArchive = new ZipFile(File.Open(guestArchivePath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None));

+ ZipFile hostArchive = new ZipFile(File.Open(hostArchivePath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None));

+ guestArchive.CommitUpdate();

+ hostArchive.CommitUpdate();

+

+ guestArchive.Close();

+ hostArchive.Close();

+ <TargetFramework>net6.0</TargetFramework>

+ <TargetFramework>net6.0</TargetFramework>

+ <TargetFramework>net6.0</TargetFramework>

+ <TargetFramework>net6.0</TargetFramework>

+ <TargetFramework>net6.0</TargetFramework>

+ <TargetFramework>net6.0</TargetFramework>

+ <TargetFramework>net6.0</TargetFramework>

+ <TargetFramework>net6.0</TargetFramework>

+ <TargetFramework>net6.0</TargetFramework>

+ _keyboardRenderer?.SetSurfaceInfo(surfaceInfo);

+

+ return _keyboardRenderer?.DrawTo(destination, position) ?? false;

+ /// Class that manages the renderer base class and its state in a multithreaded context.

+ private const int TextBoxBlinkSleepMilliseconds = 100;

+ private const int RendererWaitTimeoutMilliseconds = 100;

+ private readonly object _stateLock = new object();

+ private SoftwareKeyboardUiState _state = new SoftwareKeyboardUiState();

+ private SoftwareKeyboardRendererBase _renderer;

+ private TimedAction _renderAction = new TimedAction();

+ _renderer = new SoftwareKeyboardRendererBase(uiTheme);

+ StartTextBoxBlinker(_textBoxBlinkTimedAction, _state, _stateLock);

+ StartRenderer(_renderAction, _renderer, _state, _stateLock);

+ private static void StartTextBoxBlinker(TimedAction timedAction, SoftwareKeyboardUiState state, object stateLock)

+ lock (stateLock)

+ // The blinker is on half of the time and events such as input

+ // changes can reset the blinker.

+ state.TextBoxBlinkCounter = (state.TextBoxBlinkCounter + 1) % (2 * SoftwareKeyboardRendererBase.TextBoxBlinkThreshold);

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

+ Monitor.PulseAll(stateLock);

+ }

+ }, TextBoxBlinkSleepMilliseconds);

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

+ SoftwareKeyboardUiState internalState = new SoftwareKeyboardUiState();

+ bool canCreateSurface = false;

+ bool needsUpdate = true;

+ timedAction.Reset(() =>

+ lock (stateLock)

+ if (!Monitor.Wait(stateLock, RendererWaitTimeoutMilliseconds))

+ 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.AcceptPressed, ref internalState.AcceptPressed);

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

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

+ 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;

+ if (canCreateSurface)

+ internalState.SurfaceInfo = state.SurfaceInfo;

+ if (canCreateSurface)

+ renderer.CreateSurface(internalState.SurfaceInfo);

+ if (needsUpdate)

+ {

+ renderer.DrawMutableElements(internalState);

+ renderer.CopyImageToBuffer();

+ needsUpdate = false;

+ });

+ private static bool UpdateStateField<T>(ref T source, ref T destination) where T : IEquatable<T>

+ if (!source.Equals(destination))

+ destination = source;

+ return true;

+ return false;

+#pragma warning disable CS8632

+ public void UpdateTextState(string? inputText, int? cursorBegin, int? cursorEnd, bool? overwriteMode, bool? typingEnabled)

+#pragma warning restore CS8632

+ lock (_stateLock)

+ // Update the parameters that were provided.

+ _state.InputText = inputText != null ? inputText : _state.InputText;

+ _state.CursorBegin = cursorBegin.GetValueOrDefault(_state.CursorBegin);

+ _state.CursorEnd = cursorEnd.GetValueOrDefault(_state.CursorEnd);

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

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

+ // Reset the cursor blink.

+ _state.TextBoxBlinkCounter = 0;

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

+ Monitor.PulseAll(_stateLock);

+ }

+ public void UpdateCommandState(bool? acceptPressed, bool? cancelPressed, bool? controllerEnabled)

+ {

+ lock (_stateLock)

+ // Update the parameters that were provided.

+ _state.AcceptPressed = acceptPressed.GetValueOrDefault(_state.AcceptPressed);

+ _state.CancelPressed = cancelPressed.GetValueOrDefault(_state.CancelPressed);

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

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

+ Monitor.PulseAll(_stateLock);

+ }

+ public void SetSurfaceInfo(RenderingSurfaceInfo surfaceInfo)

+ lock (_stateLock)

+ _state.SurfaceInfo = surfaceInfo;

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

+ Monitor.PulseAll(_stateLock);

+ internal bool DrawTo(IVirtualMemoryManager destination, ulong position)

+ {

+ return _renderer.WriteBufferToMemory(destination, position);

+ }

+

+ _renderAction.RequestCancel();

+using Ryujinx.HLE.Ui;

+using Ryujinx.Memory;

+using SixLabors.ImageSharp;

+using SixLabors.ImageSharp.Processing;

+using SixLabors.ImageSharp.Drawing.Processing;

+using SixLabors.Fonts;

+using System;

+using System.Diagnostics;

+using System.IO;

+using System.Numerics;

+using System.Reflection;

+using System.Runtime.InteropServices;

+using SixLabors.ImageSharp.PixelFormats;

+

+namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard

+{

+ /// <summary>

+ /// Base class that generates the graphics for the software keyboard applet during inline mode.

+ /// </summary>

+ internal class SoftwareKeyboardRendererBase

+ {

+ public const int TextBoxBlinkThreshold = 8;

+

+ const string MessageText = "Please use the keyboard to input text";

+ const string AcceptText = "Accept";

+ const string CancelText = "Cancel";

+ const string ControllerToggleText = "Toggle input";

+

+ private readonly object _bufferLock = new object();

+

+ private RenderingSurfaceInfo _surfaceInfo = null;

+ private Image<Argb32> _surface = null;

+ private byte[] _bufferData = null;

+

+ private Image _ryujinxLogo = null;

+ private Image _padAcceptIcon = null;

+ private Image _padCancelIcon = null;

+ private Image _keyModeIcon = null;

+

+ private float _textBoxOutlineWidth;

+ private float _padPressedPenWidth;

+

+ private Color _textNormalColor;

+ private Color _textSelectedColor;

+ private Color _textOverCursorColor;

+

+ private IBrush _panelBrush;

+ private IBrush _disabledBrush;

+ private IBrush _cursorBrush;

+ private IBrush _selectionBoxBrush;

+

+ private Pen _textBoxOutlinePen;

+ private Pen _cursorPen;

+ private Pen _selectionBoxPen;

+ private Pen _padPressedPen;

+

+ private int _inputTextFontSize;

+ private Font _messageFont;

+ private Font _inputTextFont;

+ private Font _labelsTextFont;

+

+ private RectangleF _panelRectangle;

+ private Point _logoPosition;

+ private float _messagePositionY;

+

+ public SoftwareKeyboardRendererBase(IHostUiTheme uiTheme)

+ {

+ string ryujinxLogoPath = "Ryujinx.Ui.Resources.Logo_Ryujinx.png";

+ int ryujinxLogoSize = 32;

+

+ _ryujinxLogo = LoadResource(Assembly.GetEntryAssembly(), ryujinxLogoPath, ryujinxLogoSize, ryujinxLogoSize);

+

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

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

+ string keyModeIconPath = "Ryujinx.HLE.HOS.Applets.SoftwareKeyboard.Resources.Icon_KeyF6.png";

+

+ _padAcceptIcon = LoadResource(Assembly.GetExecutingAssembly(), padAcceptIconPath , 0, 0);

+ _padCancelIcon = LoadResource(Assembly.GetExecutingAssembly(), padCancelIconPath , 0, 0);

+ _keyModeIcon = LoadResource(Assembly.GetExecutingAssembly(), keyModeIconPath , 0, 0);

+

+ Color panelColor = ToColor(uiTheme.DefaultBackgroundColor, 255);

+ Color panelTransparentColor = ToColor(uiTheme.DefaultBackgroundColor, 150);

+ Color borderColor = ToColor(uiTheme.DefaultBorderColor);

+ Color selectionBackgroundColor = ToColor(uiTheme.SelectionBackgroundColor);

+

+ _textNormalColor = ToColor(uiTheme.DefaultForegroundColor);

+ _textSelectedColor = ToColor(uiTheme.SelectionForegroundColor);

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

+

+ float cursorWidth = 2;

+

+ _textBoxOutlineWidth = 2;

+ _padPressedPenWidth = 2;

+

+ _panelBrush = new SolidBrush(panelColor);

+ _disabledBrush = new SolidBrush(panelTransparentColor);

+ _cursorBrush = new SolidBrush(_textNormalColor);

+ _selectionBoxBrush = new SolidBrush(selectionBackgroundColor);

+

+ _textBoxOutlinePen = new Pen(borderColor, _textBoxOutlineWidth);

+ _cursorPen = new Pen(_textNormalColor, cursorWidth);

+ _selectionBoxPen = new Pen(selectionBackgroundColor, cursorWidth);

+ _padPressedPen = new Pen(borderColor, _padPressedPenWidth);

+

+ _inputTextFontSize = 20;

+

+ CreateFonts(uiTheme.FontFamily);

+ }

+

+ private void CreateFonts(string uiThemeFontFamily)

+ {

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

+

+ string[] availableFonts = new string[]

+ {

+ uiThemeFontFamily,

+ "Liberation Sans",

+ "FreeSans",

+ "DejaVu Sans"

+ };

+

+ foreach (string fontFamily in availableFonts)

+ {

+ try

+ {

+ _messageFont = SystemFonts.CreateFont(fontFamily, 26, FontStyle.Regular);

+ _inputTextFont = SystemFonts.CreateFont(fontFamily, _inputTextFontSize, FontStyle.Regular);

+ _labelsTextFont = SystemFonts.CreateFont(fontFamily, 24, FontStyle.Regular);

+

+ return;

+ }

+ catch

+ {

+ }

+ }

+

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

+ }

+

+ private Color ToColor(ThemeColor color, byte? overrideAlpha = null, bool flipRgb = false)

+ {

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

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

+ var g = (byte)(color.G * 255);

+ var b = (byte)(color.B * 255);

+

+ if (flipRgb)

+ {

+ r = (byte)(255 - r);

+ g = (byte)(255 - g);

+ b = (byte)(255 - b);

+ }

+

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

+ }

+

+ private Image LoadResource(Assembly assembly, string resourcePath, int newWidth, int newHeight)

+ {

+ Stream resourceStream = assembly.GetManifestResourceStream(resourcePath);

+

+ Debug.Assert(resourceStream != null);

+

+ var image = Image.Load(resourceStream);

+

+ if (newHeight != 0 && newWidth != 0)

+ {

+ image.Mutate(x => x.Resize(newWidth, newHeight, KnownResamplers.Lanczos3));

+ }

+

+ return image;

+ }

+

+ private void SetGraphicsOptions(IImageProcessingContext context)

+ {

+ context.GetGraphicsOptions().Antialias = true;

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

+ }

+

+ private void DrawImmutableElements()

+ {

+ if (_surface == null)

+ {

+ return;

+ }

+

+ _surface.Mutate(context =>

+ {

+ SetGraphicsOptions(context);

+

+ context.Clear(Color.Transparent);

+ context.Fill(_panelBrush, _panelRectangle);

+ context.DrawImage(_ryujinxLogo, _logoPosition, 1);

+

+ float halfWidth = _panelRectangle.Width / 2;

+ float buttonsY = _panelRectangle.Y + 185;

+

+ PointF disableButtonPosition = new PointF(halfWidth + 180, buttonsY);

+

+ DrawControllerToggle(context, disableButtonPosition);

+ });

+ }

+

+ public void DrawMutableElements(SoftwareKeyboardUiState state)

+ {

+ if (_surface == null)

+ {

+ return;

+ }

+

+ _surface.Mutate(context =>

+ {

+ var messageRectangle = MeasureString(MessageText, _messageFont);

+ float messagePositionX = (_panelRectangle.Width - messageRectangle.Width) / 2 - messageRectangle.X;

+ float messagePositionY = _messagePositionY - messageRectangle.Y;

+ var messagePosition = new PointF(messagePositionX, messagePositionY);

+ var messageBoundRectangle = new RectangleF(messagePositionX, messagePositionY, messageRectangle.Width, messageRectangle.Height);

+

+ SetGraphicsOptions(context);

+

+ context.Fill(_panelBrush, messageBoundRectangle);

+

+ context.DrawText(MessageText, _messageFont, _textNormalColor, messagePosition);

+

+ if (!state.TypingEnabled)

+ {

+ // Just draw a semi-transparent rectangle on top to fade the component with the background.

+ // TODO (caian): This will not work if one decides to add make background semi-transparent as well.

+

+ context.Fill(_disabledBrush, messageBoundRectangle);

+ }

+

+ DrawTextBox(context, state);

+

+ float halfWidth = _panelRectangle.Width / 2;

+ float buttonsY = _panelRectangle.Y + 185;

+

+ PointF acceptButtonPosition = new PointF(halfWidth - 180, buttonsY);

+ PointF cancelButtonPosition = new PointF(halfWidth , buttonsY);

+ PointF disableButtonPosition = new PointF(halfWidth + 180, buttonsY);

+

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

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

+ });

+ }

+

+ public void CreateSurface(RenderingSurfaceInfo surfaceInfo)

+ {

+ if (_surfaceInfo != null)

+ {

+ return;

+ }

+

+ _surfaceInfo = surfaceInfo;

+

+ Debug.Assert(_surfaceInfo.ColorFormat == Services.SurfaceFlinger.ColorFormat.A8B8G8R8);

+

+ // 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 totalWidth = _surfaceInfo.Pitch / 4;

+ uint totalHeight = _surfaceInfo.Size / _surfaceInfo.Pitch;

+

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

+ Debug.Assert(_surfaceInfo.Height <= totalHeight);

+ Debug.Assert(_surfaceInfo.Pitch * _surfaceInfo.Height <= _surfaceInfo.Size);

+

+ _surface = new Image<Argb32>((int)totalWidth, (int)totalHeight);

+

+ ComputeConstants();

+ DrawImmutableElements();

+ }

+

+ private void ComputeConstants()

+ {

+ int totalWidth = (int)_surfaceInfo.Width;

+ int totalHeight = (int)_surfaceInfo.Height;

+

+ int panelHeight = 240;

+ int panelPositionY = totalHeight - panelHeight;

+

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

+

+ _messagePositionY = panelPositionY + 60;

+

+ int logoPositionX = (totalWidth - _ryujinxLogo.Width) / 2;

+ int logoPositionY = panelPositionY + 18;

+

+ _logoPosition = new Point(logoPositionX, logoPositionY);

+ }

+

+ private RectangleF MeasureString(string text, Font font)

+ {

+ RendererOptions options = new RendererOptions(font);

+ FontRectangle rectangle = TextMeasurer.Measure(text == "" ? " " : text, options);

+

+ if (text == "")

+ {

+ return new RectangleF(0, rectangle.Y, 0, rectangle.Height);

+ }

+ else

+ {

+ return new RectangleF(rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height);

+ }

+ }

+

+ private void DrawTextBox(IImageProcessingContext context, SoftwareKeyboardUiState state)

+ {

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

+

+ float boxWidth = (int)(Math.Max(300, inputTextRectangle.Width + inputTextRectangle.X + 8));

+ float boxHeight = 32;

+ float boxY = _panelRectangle.Y + 110;

+ float boxX = (int)((_panelRectangle.Width - boxWidth) / 2);

+

+ RectangleF boxRectangle = new RectangleF(boxX, boxY, boxWidth, boxHeight);

+

+ RectangleF boundRectangle = new RectangleF(_panelRectangle.X, boxY - _textBoxOutlineWidth,

+ _panelRectangle.Width, boxHeight + 2 * _textBoxOutlineWidth);

+

+ context.Fill(_panelBrush, boundRectangle);

+

+ context.Draw(_textBoxOutlinePen, boxRectangle);

+

+ float inputTextX = (_panelRectangle.Width - inputTextRectangle.Width) / 2 - inputTextRectangle.X;

+ float inputTextY = boxY + 5;

+

+ var inputTextPosition = new PointF(inputTextX, inputTextY);

+

+ context.DrawText(state.InputText, _inputTextFont, _textNormalColor, inputTextPosition);

+

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

+

+ Color cursorTextColor;

+ IBrush cursorBrush;

+ Pen cursorPen;

+

+ float cursorPositionYTop = inputTextY + 1;

+ float cursorPositionYBottom = cursorPositionYTop + _inputTextFontSize + 1;

+ float cursorPositionXLeft;

+ float cursorPositionXRight;

+

+ bool cursorVisible = false;

+

+ if (state.CursorBegin != state.CursorEnd)

+ {

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

+

+ cursorTextColor = _textSelectedColor;

+ cursorBrush = _selectionBoxBrush;

+ cursorPen = _selectionBoxPen;

+

+ string textUntilBegin = state.InputText.Substring(0, state.CursorBegin);

+ string textUntilEnd = state.InputText.Substring(0, state.CursorEnd);

+

+ var selectionBeginRectangle = MeasureString(textUntilBegin, _inputTextFont);

+ var selectionEndRectangle = MeasureString(textUntilEnd , _inputTextFont);

+

+ cursorVisible = true;

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

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

+ }

+ else

+ {

+ cursorTextColor = _textOverCursorColor;

+ cursorBrush = _cursorBrush;

+ cursorPen = _cursorPen;

+

+ if (state.TextBoxBlinkCounter < TextBoxBlinkThreshold)

+ {

+ // Show the blinking cursor.

+

+ int cursorBegin = Math.Min(state.InputText.Length, state.CursorBegin);

+ string textUntilCursor = state.InputText.Substring(0, cursorBegin);

+ var cursorTextRectangle = MeasureString(textUntilCursor, _inputTextFont);

+

+ cursorVisible = true;

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

+

+ if (state.OverwriteMode)

+ {

+ // The blinking cursor is in overwrite mode so it takes the size of a character.

+

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

+ {

+ textUntilCursor = state.InputText.Substring(0, cursorBegin + 1);

+ cursorTextRectangle = MeasureString(textUntilCursor, _inputTextFont);

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

+ }

+ else

+ {

+ cursorPositionXRight = cursorPositionXLeft + _inputTextFontSize / 2;

+ }

+ }

+ else

+ {

+ // The blinking cursor is in insert mode so it is only a line.

+ cursorPositionXRight = cursorPositionXLeft;

+ }

+ }

+ else

+ {

+ cursorPositionXLeft = inputTextX;

+ cursorPositionXRight = inputTextX;

+ }

+ }

+

+ if (state.TypingEnabled && cursorVisible)

+ {

+ float cursorWidth = cursorPositionXRight - cursorPositionXLeft;

+ float cursorHeight = cursorPositionYBottom - cursorPositionYTop;

+

+ if (cursorWidth == 0)

+ {

+ PointF[] points = new PointF[]

+ {

+ new PointF(cursorPositionXLeft, cursorPositionYTop),

+ new PointF(cursorPositionXLeft, cursorPositionYBottom),

+ };

+

+ context.DrawLines(cursorPen, points);

+ }

+ else

+ {

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

+

+ context.Draw(cursorPen , cursorRectangle);

+ context.Fill(cursorBrush, cursorRectangle);

+

+ Image<Argb32> textOverCursor = new Image<Argb32>((int)cursorRectangle.Width, (int)cursorRectangle.Height);

+ textOverCursor.Mutate(context =>

+ {

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

+ context.DrawText(state.InputText, _inputTextFont, cursorTextColor, textRelativePosition);

+ });

+

+ var cursorPosition = new Point((int)cursorRectangle.X, (int)cursorRectangle.Y);

+ context.DrawImage(textOverCursor, cursorPosition, 1);

+ }

+ }

+ else if (!state.TypingEnabled)

+ {

+ // Just draw a semi-transparent rectangle on top to fade the component with the background.

+ // TODO (caian): This will not work if one decides to add make background semi-transparent as well.

+

+ context.Fill(_disabledBrush, boundRectangle);

+ }

+ }

+

+ private void DrawPadButton(IImageProcessingContext context, PointF point, Image icon, string label, bool pressed, bool enabled)

+ {

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

+

+ float iconX = 0;

+ float iconY = 0;

+ float iconWidth = icon.Width;

+ float iconHeight = icon.Height;

+

+ var labelRectangle = MeasureString(label, _labelsTextFont);

+

+ float labelPositionX = iconWidth + 8 - labelRectangle.X;

+ float labelPositionY = 3;

+

+ float fullWidth = labelPositionX + labelRectangle.Width + labelRectangle.X;

+ float fullHeight = iconHeight;

+

+ // Convert all relative positions into absolute.

+

+ float originX = (int)(point.X - fullWidth / 2);

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

+

+ iconX += originX;

+ iconY += originY;

+

+ var iconPosition = new Point((int)iconX, (int)iconY);

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

+

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

+ fullWidth + 4 * _padPressedPenWidth, fullHeight + 4 * _padPressedPenWidth);

+

+ var boundRectangle = new RectangleF(originX, originY, fullWidth, fullHeight);

+ boundRectangle.Inflate(4 * _padPressedPenWidth, 4 * _padPressedPenWidth);

+

+ context.Fill(_panelBrush, boundRectangle);

+ context.DrawImage(icon, iconPosition, 1);

+ context.DrawText(label, _labelsTextFont, _textNormalColor, labelPosition);

+

+ if (enabled)

+ {

+ if (pressed)

+ {

+ context.Draw(_padPressedPen, selectedRectangle);

+ }

+ }

+ else

+ {

+ // Just draw a semi-transparent rectangle on top to fade the component with the background.

+ // TODO (caian): This will not work if one decides to add make background semi-transparent as well.

+

+ context.Fill(_disabledBrush, boundRectangle);

+ }

+ }

+

+ private void DrawControllerToggle(IImageProcessingContext context, PointF point)

+ {

+ var labelRectangle = MeasureString(ControllerToggleText, _labelsTextFont);

+

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

+

+ float keyWidth = _keyModeIcon.Width;

+ float keyHeight = _keyModeIcon.Height;

+

+ float labelPositionX = keyWidth + 8 - labelRectangle.X;

+ float labelPositionY = -labelRectangle.Y - 1;

+

+ float keyX = 0;

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

+

+ float fullWidth = labelPositionX + labelRectangle.Width;

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

+

+ // Convert all relative positions into absolute.

+

+ float originX = (int)(point.X - fullWidth / 2);

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

+

+ keyX += originX;

+ keyY += originY;

+

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

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

+

+ context.DrawImage(_keyModeIcon, overlayPosition, 1);

+ context.DrawText(ControllerToggleText, _labelsTextFont, _textNormalColor, labelPosition);

+ }

+

+ public void CopyImageToBuffer()

+ {

+ lock (_bufferLock)

+ {

+ if (_surface == null)

+ {

+ return;

+ }

+

+ // Convert the pixel format used in the image to the one used in the Switch surface.

+

+ if (!_surface.TryGetSinglePixelSpan(out Span<Argb32> pixels))

+ {

+ return;

+ }

+

+ _bufferData = MemoryMarshal.AsBytes(pixels).ToArray();

+ Span<uint> dataConvert = MemoryMarshal.Cast<byte, uint>(_bufferData);

+

+ Debug.Assert(_bufferData.Length == _surfaceInfo.Size);

+

+ for (int i = 0; i < dataConvert.Length; i++)

+ {

+ dataConvert[i] = BitOperations.RotateRight(dataConvert[i], 8);

+ }

+ }

+ }

+

+ public bool WriteBufferToMemory(IVirtualMemoryManager destination, ulong position)

+ {

+ lock (_bufferLock)

+ {

+ if (_bufferData == null)

+ {

+ return false;

+ }

+

+ try

+ {

+ destination.Write(position, _bufferData);

+ }

+ catch

+ {

+ return false;

+ }

+

+ return true;

+ }

+ }

+ }

+}

+using Ryujinx.HLE.Ui;

+

+namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard

+{

+ /// <summary>

+ /// TODO

+ /// </summary>

+ internal class SoftwareKeyboardUiState

+ {

+ public string InputText = "";

+ public int CursorBegin = 0;

+ public int CursorEnd = 0;

+ public bool AcceptPressed = false;

+ public bool CancelPressed = false;

+ public bool OverwriteMode = false;

+ public bool TypingEnabled = true;

+ public bool ControllerEnabled = true;

+ public int TextBoxBlinkCounter = 0;

+

+ public RenderingSurfaceInfo SurfaceInfo = null;

+ }

+}

+ public void Reset(Action action)

+ {

+ // Create a dedicated cancel token for each task.

+ var cancelled = new TRef<bool>(false);

+

+ Reset(new Thread(() =>

+ {

+ while (!Volatile.Read(ref cancelled.Value))

+ {

+ action();

+ }

+ }), cancelled);

+ }

+

+using Ryujinx.Common.Utilities;

+ virtualAmiiboFile = JsonHelper.DeserializeFromFile<VirtualAmiiboFile>(filePath);

+using System.Security.Cryptography;

+ private RandomNumberGenerator _rng;

+ _rng = RandomNumberGenerator.Create();

+ Logger.Warning?.Print(LogClass.ServiceVi, $"Applet did not draw on indirect layer handle {layerHandle}");

+ <TargetFramework>net6.0</TargetFramework>

+ <PackageReference Include="SixLabors.ImageSharp" Version="1.0.4" />

+using System;

+ class RenderingSurfaceInfo : IEquatable<RenderingSurfaceInfo>

+ <TargetFramework>net6.0</TargetFramework>

+ <TargetFramework>net6.0</TargetFramework>

+ <TargetFramework>net6.0</TargetFramework>

+ <TargetFramework>net6.0</TargetFramework>

+ <TargetFramework>net6.0</TargetFramework>

+ <PackageReference Include="Mono.Posix.NETStandard" Version="5.20.1-preview" />

+ <TargetFramework>net6.0</TargetFramework>

+ <TargetFramework>net6.0</TargetFramework>

+ <TargetFramework>net6.0</TargetFramework>

+ <TargetFramework>net6.0</TargetFramework>

+using System.Net.Http;

+ using (HttpClient jsonClient = new HttpClient())

+ string fetchedJson = await jsonClient.GetStringAsync($"{AppveyorApiUrl}/projects/gdkchan/ryujinx/branch/master");

+ using (HttpClient buildSizeClient = new HttpClient())

+ {

+ buildSizeClient.DefaultRequestHeaders.Add("Range", "bytes=0-0");

+

+ HttpResponseMessage message = await buildSizeClient.GetAsync(new Uri(_buildUrl), HttpCompletionOption.ResponseHeadersRead);

+ _buildSize = message.Content.Headers.ContentRange.Length.Value;

+#pragma warning disable SYSLIB0014

+ // TODO: WebClient is obsolete and need to be replaced with a more complex logic using HttpClient.

+#pragma warning restore SYSLIB0014

+ private static void DoUpdateWithSingleThreadWorker(UpdateDialog updateDialog, string downloadUrl, string updateFile)

+ using (HttpClient client = new HttpClient())

+ // We do not want to timeout while downloading

+ client.Timeout = TimeSpan.FromDays(1);

+ using (HttpResponseMessage response = client.GetAsync(downloadUrl, HttpCompletionOption.ResponseHeadersRead).Result)

+ using (Stream remoteFileStream = response.Content.ReadAsStreamAsync().Result)

+ using (Stream updateFileStream = File.Open(updateFile, FileMode.Create))

+ {

+ long totalBytes = response.Content.Headers.ContentLength.Value;

+ long byteWritten = 0;

+

+ byte[] buffer = new byte[32 * 1024];

+

+ while (true)

+ {

+ int readSize = remoteFileStream.Read(buffer);

+

+ if (readSize == 0)

+ {

+ break;

+ }

+ byteWritten += readSize;

+

+ updateDialog.ProgressBar.Value = ((double)byteWritten / totalBytes) * 100;

+ updateFileStream.Write(buffer, 0, readSize);

+ }

+ }

+ }

+

+ InstallUpdate(updateDialog, updateFile);

+

+ private static void DoUpdateWithSingleThread(UpdateDialog updateDialog, string downloadUrl, string updateFile)

+ {

+ Thread worker = new Thread(() => DoUpdateWithSingleThreadWorker(updateDialog, downloadUrl, updateFile));

+ worker.Name = "Updater.SingleThreadWorker";

+ worker.Start();

+ }

+

+ string ryuBin = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Ryujinx");

+ if (!OperatingSystem.IsWindows())

+ // Enforce loading of Mono.Posix.NETStandard to avoid .NET runtime lazy loading it during an update.

+ Assembly.Load("Mono.Posix.NETStandard");

+

+ <TargetFramework>net6.0</TargetFramework>

+ <PackageReference Include="SharpZipLib" Version="1.3.3" />

+ <PackageReference Include="Mono.Posix.NETStandard" Version="5.20.1-preview" />

+using Ryujinx.Common.Utilities;

+ if (await NeedsUpdate(JsonHelper.Deserialize<AmiiboJson>(amiiboJsonString).LastUpdated))

+ _amiiboList = JsonHelper.Deserialize<AmiiboJson>(amiiboJsonString).Amiibo;

+image: Visual Studio 2022

+ appveyor_dotnet_runtime: net6.0

+ dotnet publish -c $env:config -r win-x64 /p:Version=$env:APPVEYOR_BUILD_VERSION /p:DebugType=embedded --self-contained

+ dotnet publish -c $env:config -r linux-x64 /p:Version=$env:APPVEYOR_BUILD_VERSION /p:DebugType=embedded --self-contained

+ "version": "6.0.100",

+ "rollForward": "latestFeature"