tolikpylypchuk/keyboardswitch

An application which switches typed text as if it were typed with another keyboard layout

keyboardswitch's Issues

Save and restore the clipboard state in instant mode

When the app switches text in instant mode, it overwrites the clipboard. This is not a problem if clipboard history is enabled, but even then it's a nuisance. The previous clipboard state (if any) shoud be saved before putting the text into the clipboard and then restored after switching the text.

Implement keyboard hooks on Linux

Use libuiohook instead of native Windows hooks to make the hooks cross-platform.

Enable the converter on Linux and macOS

Show the converter on Linux and macOS and hide just the auto-configuration of converter since I don't want to spend time on that. The converter itself is platform-agnostic, so there's no reason it should be completely disabled.

Package the app for Linux

Investigate whether packaging the app as a deb package is doable, in addition to the simple tar.gz. Also, an RPM package would be nice.

Simulate pressing Ctrl+C/Ctrl+V on Linux

In order for instant switching to work, the app should simulate pressing Ctrl+C and Ctrl+V. The solution used on Windows is not cross-platform, so a new one should be implemented here.

Enhance the switching configuration

Enable a more versatile configuration of the switching triggers: the app should discern left/right ctrl/shift/alt keys etc.

Sometimes a keyboard layout disappears from the system

I'm not 100% sure that this has anything to do with KeyboardSwitch, but after implementing auto-configuration for the converter (which loads and unloads keyboard layouts), one of my installed layouts started randomly disappearing, even though it's listed as one of the layouts in Settings.

Write docs for version 4.0 (for Windows and Linux)

Even though version 4.0 is not released yet, the Linux version is basically ready, and so its usage should be documented, especially installation and bootstrapping steps.

Create a new installer

Use WixSharp to create the new installer.

Update UI

The UI needs to be updated. For example, the list of languages and the hot keys window. Possibly, something else, too.

Implement settings configuration

Implement a separate converter with custom input languages

The program only switches between the input languages that are currently installed in the system. This is usually what is needed, but sometimes it is also needed to switch to a language that isn't installed in the system.

Create an installer for the application

At the moment the application is portable which is not really good, because it uses low-level keyboard hooks that are deemed dangerous by anti-viruses and therefore it may get blocked.

Implement starting on system startup

Restructure the project

All source files are currently in a single directory. They should be grouped into folders.

Create a portable version of the app

A portable version will not require installation and will store settings in the same folder as the app itself, not in the app data folder.

Auto-configure layouts on Linux

Auto-configuring should be available on Linux in addition to Windows.

Add auto-setting character mappings

Configuring character mappings is tiring and error-prone even if it's done once and is quite easy. Still, it would be much better if the app converted each virtual key into a character for each layout, removed the duplicates somehow (e.g. by replacing all duplicate characters with spaces), and the user took from there, only slightly tweaking the settings if need be.

Create taskbar actions

The switch actions are in the context menu of the tray icon. It would be nice if they were in the taskbar, too.

Add systemd integration for Linux

Since the service app can now run as a systemd service (and this is also how starting at login is implemented), the settings app should communicate with the settings app through systemd if possible.

Add automatic settings version migration

Migrate settings from version 3 to version 4 if version 3 was installed previously.

Add installation and usage instructions to README.md

Hello @TolikPylypchuk and thanks for the great open-source application! Just tested on my Windows PC, so far works well. Browsing the source code here was a real pleasure, noticed a few curious patterns, including ReactiveForm and localization pattern for ReactiveUI.Validation. However, worth adding a bit more verbose getting started documentation to README.md, which a user could easily follow to get KeyboardSwitch up and running on their machine.

By the way, it would be really nice to have your application listed on the Samples page on the ReactiveUI website. Please consider opening a PR to our website repository (Avalonia samples section) linking the source code of the application, once you feel the app is ready to get listed there 🥰
Thank you!

Detect current keyboard layout on Linux

Implement getting the current keyboard layout on Linux (via X11) so that the app knows how to switch the text.

Implement checking for updates

Auto-updating is probably too advanced for me at the moment, but at least checking for updates can be done simply by putting a file with the latest version on GitHub and the settings app checking this file out.

Change the layout to the next one when switching text on Linux

Recreate the whole thing from scratch

Create the project on .NET Core. Use separate projects for the UI and the actual switch.

Show the current caret position inside character mapping text boxes

The correct configuration of character mappings depends on positions of characters. So it matters a lot that the user sees which character corresponds to which ones in different layouts. A monosapced font helps, but showing the actual position of the caret would be much better.

Implement configuring the character mappings

Upgrade to .NET 5 and Avalonia 0.10 and change the UI theme

Now that Avalonia 0.10 is out, the app can be restyled to use the Fluent Design.

Store mappings in local app data

It would be better to store mappings separately in case the app gets reinstalled. The most logical place would be the local app data.

Add keyboard hooks

Remove the hot key switch mode

Hot key switch mode is obsolete now that there is the modifier key switch mode and the latter is superior.

Add tray icon

Implement the actual switching

Create the UI for the switching settings

Create a window which will have the same functionality as the settings window in the previous version, but use ReactiveUI.

Update readme

It would be better to have readme as an HTML document instead of plain text.

Implement logging to rolling files

Implement logging into a file for both the background service and the settings app. Since the servcie is expected to run indefinitely, consider rolling files for logging.

Add FluentAvalonia

FluentAvalonia adds Fluent UI 2.0 which looks cooler.

Create the UI for the mapping settings

Create a window which will have the same functionality as the main window in the previous version, but use ReactiveUI.

Update tab indices when moving mappings

The the user moves a mapping left or right, the tab indices of the corresponding letter boxes are not updated, which results in focus jumping back and forth on tab press.

Create a worker which switches the text

Create a headless background worker which will have the switching functionality. Investigate the possibility of this worker being implemented as a Windows service.

Implement storing the local data

Use Akavache for the data store.

Make the app start at login on Linux

The service app should start when the user logs in on Linux.

Add unit tests for existing features

The project is currently absolutely untested.

Hide the converter by default

The converter is needed extremely rarely, so it should be hidden most of the time. Add yet another check-box to preferences to hide it.

Implement switching between the available input languages

Get/set the clipboard data when switching text on other platforms

Make the app cross-platform

.NET Core is cross-platform, so the service app can work on Linux. The settings UI should be implemented in Avalonia, and the ReactiveUI view models should be extracted into a separate project.

Implement switching without manual copy/paste

It would be much simpler to swith the text without having to manually copy the text and paste the result.

The switching doesn't work properly

The program sometimes doesn't switch the text. Sometimes not all characters are switched.