Techniques for fractional scaling

[VimYoung]

Fractional scaling at this point have become a pain to deal with. I am currently opting for the default mechanism. This discussion acts as a note to possible solutions, problems and suggestions from the users. Without scaling, rasterization of components doesn't happen properly, resulting in blurry/slightly pixelated components.

Few terminologies

1. Logical Size: This is the size of a screen (monitor) logically in the pixels.
2. Actual Size: This is the actual number of pixels in your screen length and width wise. This quantity is obtained by the product of logical size with scale factor.

EXAMPLE: Lets consider a monitor of size 100x 100 with Scale factor of 1.5 resulting in the actual size of 150x150 pixels.

Scaling implementations

Slint's platform implementation actually supports an event called ScaleFactorChanged. But that results that the Skia renderer of Slint to expect the buffer(memory space representing pixels, comes from wayland) to be of actual size and not logical size. Philosophy of wayland says that the rendering should always be done in logical size and then the rendering should scale the buffer (via viewporter). Here are the ways fractional scaling can be implemented:

1. From Slint: This approach ignores the recommendations of wayland, and uses a buffer of actual size, sends the ScaleFactorChanged event to slint and renders on this buffer. Here the scaling is done by Slint itself and fractional scaling values are possible.
2. From Wayland: This approach doesn't use any event of slint. Rather it implements two globals of wayland called viewporter and scalemanager(Currently implemented but not used by spell). Here, when a scale factor changes, wayland side of spell changes the size of buffer before pasting it to the screen.
3. By compositors: This is the default method which is currently in use also. If the client doesn't implement the second method of scaling, The window is scaled by compositor itself. The issue is that it doesn't support fractional scaling. The value is scaled in integer terms and then scaled down. Often resulting in poor scaling.

The thing is, if fractional scaling is implemented by a client by 2nd method, compositors should ideally NOT implement scaling from its side( by method 3). The major issue is that after implementing the wayland side of scaling, compositors are still implementing scaling, resulting in the components of Spell being scaled twice. It is either a bug of compositor or my incompetence in implementing it properly(this is more probable :) ). I have checked the WAYLAND_DEBUG log and it mentions the attachment of appropriate wayland side globals responsible for fractional scaling. I have lost my ingenuity in debugging the issue as I have tried almost everything. I ask for opinions and possible help regarding the matter.

As for the time being, method 3 of scaling remains the default method.

[VimYoung]

This issue is resolved, I could really pull off a working implementation after some suggestions from maintainer of Slint himself (shout-out to Simon). So, as per his suggestion, rather than implementing one of the approaches. The new implementation uses a combination of method 1 and 2. So, know the buffer is replaced with a new one of bigger size after the Scale factor is changed. Skia renders on the new bigger buffer which is then attached back. This removes the blurriness in text and icons. As an example, following is the comparison of same window show in live-preview window, default implementation and my Skia implementation(from left to right). Later image show the blurriness being removed.

Before

After

[VimYoung]

The windows panic on changing the scale factor manually but it has a trivial fix that will be added as APIs become stable.