Manjaro hidpi

Manjaro hidpi DEFAULT
The following Linux distributions support different scaling factors on different displays by default: Pop!_OS, Ubuntu (and GNOME-based derivatives), Linux Mint. Arch Linux, Manjaro, and all distributions using GNOME + Wayland can also enable mixed scaling with a quick setting change.

Pop!_OS (developed by System76) created its own HiDPI daemon to handle HiDPI and LoDPI displays on X11 at the same time:

https://github.com/pop-os/hidpi-daemon

https://blog.system76.com/post/174414833678/all-about-the-hi...

It is preinstalled on all System76 computers and enabled by default.

Ubuntu's fork of the Mutter display manager (used by its fork of GNOME) includes a patch to handle different display resolutions for HiDPI and LoDPI displays on X11:

https://bugs.launchpad.net/ubuntu/+source/mutter/+bug/182085...

Ubuntu and all of its GNOME-based derivatives include this patch, unless it is specifically excluded by the maintainers.

Linux Mint implemented fractional display scaling, with different settings for each display, in Cinnamon 4.6:

https://blog.linuxmint.com/?p=3858

Arch Linux and Manjaro users can also choose Cinnamon as the desktop environment for the same features.

If you are using a GNOME on X11 on Manjaro, you can install the mutter-x11-scaling package to replace Mutter with a version that includes Ubuntu's changes:

https://gitlab.manjaro.org/packages/extra/mutter-x11-scaling...

https://github.com/puxplaying/mutter-x11-scaling

Finally, if you are using GNOME on Wayland, mixed scaling is already supported. To enable fractional scaling, activate the "scale-monitor-framebuffer" setting:

https://wiki.archlinux.org/index.php/HiDPI#GNOME

On Wayland, scaled applications that do not use GTK 3+ or Qt 5+ may appear blurry. This affects all Electron applications. X11 does not have the same issue, but Wayland is generally smoother and more stable than X11.

Sours: https://news.ycombinator.com/item?id=25922344

HiDPI

Related articles

HiDPI (High Dots Per Inch) displays, also known by Apple's "Retina Display" marketing name, are screens with a high resolution in a relatively small format. They are mostly found in high-end laptops and monitors.

Not all software behaves well in high-resolution mode yet. Here are listed most common tweaks which make work on a HiDPI screen more pleasant.

Desktop environments

GNOME

To enable HiDPI, navigate to Settings > Devices > Displays > Scale and choose an appropriate value. Or, use gsettings:

$ gsettings set org.gnome.settings-daemon.plugins.xsettings overrides "[{'Gdk/WindowScalingFactor', <2>}]" $ gsettings set org.gnome.desktop.interface scaling-factor 2

Note: GNOME only allows integer scaling numbers to be set. 1 = 100%, 2 = 200%, etc. See #Fractional scaling below.

Fractional scaling

A setting of , which is all you can do with , may not be ideal for certain HiDPI displays and smaller screens (e.g. small tablets). Fractional scaling is possible on both Wayland and Xorg, though the process differs.

Wayland

Enable the experimental fractional scaling feature:

$ gsettings set org.gnome.mutter experimental-features "['scale-monitor-framebuffer']"

then open Settings > Devices > Displays (the new options may only appear after a restart).

To enable the option for all users, create the following three files with the corresponding content

/etc/dconf/profile/useruser-db:user system-db:local /etc/dconf/db/local.d/00-hidpi[org/gnome/mutter] experimental-features=['scale-monitor-framebuffer'] /etc/dconf/db/locks/hidpi/org/gnome/mutter/experimental-features

Then run and restart the machine. This will permanently lock the option.

Xorg

You can achieve any non-integer scale factor by using a combination of GNOME's and xrandr. This combination keeps the TTF fonts properly scaled so that they do not become blurry if using alone. You specify zoom-in factor with and zoom-out factor with xrandr.

First scale GNOME up to the minimum size which is too big. Usually "2" is already too big, otherwise try "3" etc. Then start scaling down by setting zoom-out factor with xrandr. First get the relevant output name, the examples below use . Start e.g. with zoom-out 1.25 times. If the UI is still too big, increase the scale factor; if it is too small decrease the scale factor.

$ xrandr --output eDP1 --scale 1.25x1.25

Note: To allow the mouse to reach the whole screen, you may need to use the option as explained in #Side display.

Tango-inaccurate.pngThe factual accuracy of this article or section is disputed.Tango-inaccurate.png

Reason: The following was initially added under #X Resources. Clarify how it integrates with the info there or that above for GNOME. (Discuss in Talk:HiDPI#GNOME ignores X settings)

GNOME ignores X settings due to its xsettings Plugin in Gnome Settings Daemon, where DPI setting is hard coded. There is blog entry for recompiling Gnome Settings Daemon. In the source documentation there is another way mentioned to set X settings DPI:

You can use the gsettings, just make sure to read previous setting first and merge it. In just simply set it with this command:

gsettings set org.gnome.settings-daemon.plugins.xsettings overrides "{'Xft/DPI': <153600>}"

From README.xsettings

Noting that variants must be specified in the usual way (wrapped in <>).

Note also that DPI in the above example is expressed in 1024ths of an inch.

Text Scaling

Alternatively, or in addition to changing the display scaling, you can separately scale text. This can be done by navigating to Fonts > Scaling Factor in Gnome Tweaks, or using gsettings. Note that the text scaling factor need not be limited to whole integers, for example:

$ gsettings set org.gnome.desktop.interface text-scaling-factor 1.5
GTK+ vs Gnome Shell elements on Xorg

Adjusting the text scaling as per the above only affects GTK+ elements of the GNOME desktop. This should cover everything on Wayland. However, those on an Xorg session may find that they need to make further adjustments on HiDPI environments, since the GNOME Shell UI (including the top bar, dock, application menus, etc.) relies separately on the St toolkit. Note that this is a long-standing issue to which a patch has been merged and available for Gnome Shell 3.35 onward. For older releases, Xorg users can resolve most of the Gnome shell scaling problems by manually editing the shell theme that they are currently using. The relevant CSS files are normally located at . Users should increase all "font-size" elements in this file in proportion to their display scaling (doubling font sizes for 200% scaling, etc.) For example, the top of an edited CSS file for the Adapta shell theme might look like:

usr/share/themes/Adapta/gnome-shell/gnome-shell.cssstage { font-size: 20pt; font-family: Roboto, Noto Sans, Sans-Serif; color: #263238; }

Once these changes have been saved, activate them by switching to another theme (for example, using gnome-tweaks) and then reverting back again. The top bar, application menus, calendar, and other shell elements should now be correctly scaled.

In addition to editing the relevant shell theme's CSS file, users on Xorg may also wish to increase the title bar font at the top of open applications. This can be done through the dconf editor (). Note that the option should also be turned off. Alternatively, use gsettings:

$ gsettings set org.gnome.desktop.wm.preferences titlebar-font 'Cantarell Bold 22' ## Change as needed $ gsettings set org.gnome.desktop.wm.preferences titlebar-uses-system-font false

KDE Plasma

You can use Plasma's settings to fine tune font, icon, and widget scaling. This solution affects both Qt and GTK applications.

To adjust font, widget, and icon scaling together:

  1. System Settings > Display and Monitor > Display Configuration > Global Scale
  2. Drag the slider to the desired size
  3. Restart for the settings to take effect

To adjust only font scaling:

  1. System Settings > Fonts
  2. Check "Force fonts DPI" and adjust the DPI level to the desired value. This setting should take effect immediately for newly started applications. You will have to logout and login for it to take effect on Plasma desktop.

To adjust only icon scaling:

  1. System Settings > Icons > Advanced
  2. Choose the desired icon size for each category listed. This should take effect immediately.

Tray icons with fixed size

The tray icons are not scaled with the rest of the desktop, since Plasma ignores the Qt scaling settings by default. To make Plasma respect the Qt settings, set to .

Xfce

Xfce supports HiDPI scaling which can be enabled using the settings manager:

  1. Go to Settings Manager > Appearance > Settings > Window Scaling and select 2 as the scaling factor.
  2. Go to Settings Manager > Window Manager > Style and select theme.

Alternatively, it is possible to do the same from command line using :

xfconf-query -c xsettings -p /Gdk/WindowScalingFactor -s 2 xfconf-query -c xfwm4 -p /general/theme -s Default-xhdpi

After either of the above changes, fonts in some GTK applications may still not be scaled; you may additionally do the following (see #GDK 3 (GTK 3)):

  1. Go to Settings Manager > Appearance > Fonts > Custom DPI setting and change from 96 to 192
  2. Set the environment variable (e.g. in ) to un-scale some fonts that would be scaled twice

The steps above would set 2x scaled resolution for Xfce and other GTK 3 apps.

Scaling for Qt 5 apps should be set manually, see #Qt 5. Note that if you set a Custom DPI for fonts above, you likely need to set to avoid double-scaling of fonts in Qt applications.

Cinnamon

Has good support out of the box.

Enlightenment

For E18, go to the E Setting panel. In Look > Scaling, you can control the UI scaling ratios. A ratio of 1.2 seems to work well for the native resolution of the MBPr 15" screen.

X Resources

If you are not using a desktop environment such as KDE, Xfce, or other that manipulates the X settings for you, you can set the desired DPI setting manually via the variable in Xresources:

~/.XresourcesXft.dpi: 192 ! These might also be useful depending on your monitor and personal preference: Xft.autohint: 0 Xft.lcdfilter: lcddefault Xft.hintstyle: hintfull Xft.hinting: 1 Xft.antialias: 1 Xft.rgba: rgb

For , using integer multiples of 96 usually works best, e.g. 192 for 200% scaling.

Make sure the settings are loaded properly when X starts, for instance in your with (see Xresources for more information).

This will make the font render properly in most toolkits and applications, it will however not affect things such as icon size! Setting at the same time as toolkit scale (e.g. ) may cause interface elements to be much larger than intended in some programs like firefox.

X Server

Tango-inaccurate.pngThe factual accuracy of this article or section is disputed.Tango-inaccurate.png

Reason:libxft is a font rendering interface library, the setting was not intended to be abused by other applications. On the other hand, the value should affect everything. (Discuss in Talk:HiDPI)

Some programs may still interpret the DPI given by the X server (most interpret X Resources, though, directly or indirectly). Older versions of i3 (before 2017) and Chromium (before 2017) used to do this.

To verify that the X Server has properly detected the physical dimensions of your monitor, use the xdpyinfo utility from the xorg-xdpyinfo package:

$ xdpyinfo | grep -B 2 resolutionscreen #0: dimensions: 3200x1800 pixels (423x238 millimeters) resolution: 192x192 dots per inch

This example uses inaccurate dimensions (423mm x 328mm, even though the Dell XPS 9530 has 346mm x 194mm) to have a clean multiple of 96 dpi, in this case 192 dpi. This tends to work better than using the correct DPI — Pango renders fonts crisper in i3 for example.

If the DPI displayed by xdpyinfo is not correct, see Xorg#Display size and DPI for how to fix it.

GUI toolkits

Qt 5

Since Qt 5.6, Qt 5 applications can be instructed to honor screen DPI by setting the environment variable:

export QT_AUTO_SCREEN_SCALE_FACTOR=1

If automatic detection of DPI does not produce the desired effect, scaling can be set manually per-screen () or globally (). For more details see the Qt blog post or Qt developer documentation.

Note:
  • If you manually set the screen factor, it is important to set otherwise some applications which explicitly force high DPI enabling get scaled twice.
  • scales fonts, but does not scale fonts.
  • If you also set the font DPI manually in xrdb to support other toolkits, will give you huge fonts.
  • If you have multiple screens of differing DPI ie: #Side display you may need to do

An alternative is e.g.:

QT_FONT_DPI=96 vym

GDK 3 (GTK 3)

Note: As stated in the #X Resources section, if you have xft.dpi set to a larger dpi, it will make other scales larger than usual, including GDK.

Setting the GDK scale will scale the UI, however it will not scale icons. If you are using a minimal window manager where you are setting the dpi via Xft.dpi, GDK should scale perfectly fine with it. In other cases, do the following:

To scale UI elements by an integer factor:

$ export GDK_SCALE=2

To undo scaling of text, fractional scale can be used:

$ export GDK_DPI_SCALE=0.5

GTK 2

Scaling of UI elements is not supported by the toolkit itself, however it's possible to generate a theme with elements pre-scaled for HiDPI display using themix-full-gitAUR.

Electron

Electron applications (e.g. slack-desktopAUR, signal-desktop, etc.) can be configured to use a custom scaling value by adding a flag to the .desktop file. This is normally located at , and can normally be overridden on a per-user basis by copying it to . The flag should be added to the line beginning with "Exec=". For example:

/usr/share/applications/slack.desktopExec=env LD_PRELOAD=/usr/lib/libcurl.so.3 /usr/bin/slack --force-device-scale-factor=1.5 %U

Elementary (EFL)

To scale UI elements by a factor of 1.5:

export ELM_SCALE=1.5

For more details see https://phab.enlightenment.org/w/elementary/

GNUstep

GNUstep applications that use its gui (AppKit) library accept a property in their defaults (STEP preferences). To define a scaling factor of 1.5 for all apps:

defaults write NSGlobalDomain GSScaleFactor 1.5

Some automatic detection was possible back in 2011, but the code responsible for the X11 backend was commented out thereafter.

Boot managers

GRUB

Lower the framebuffer resolution

Set a lower resolution for the framebuffer as explained in GRUB/Tips and tricks#Setting the framebuffer resolution.

Change GRUB font size

Find a ttf font that you like in .

Convert the font to a format that GRUB can utilize:

# grub-mkfont -s 30 -o /boot/grubfont.pf2 /usr/share/fonts/FontFamily/FontName.ttf

Note: Change the parameter to modify the font size

Edit to set the new font as shown in GRUB/Tips and tricks#Background image and bitmap fonts:

GRUB_FONT="/boot/grubfont.pf2"

Note: overrides if it is used.

Finally regenerate the main configuration file.

Tip: The font size can also be changed with the GUI tool grub-customizer.

systemd-boot

Adding the following line and running increases font-size in the systemd-boot menu:

/boot/loader/loader.confconsole-mode 1

Applications

If you are running a Wayland session, but application is running via Xwayland (either because it does not support Wayland natively or because it uses X11 by default), you could still get blurry fonts and interface, even if the application supports HiDPI. See this bug report.

To determine if application is running via Xwayland, you can run extramaus and move a mouse over window of application. If red mouse moves, application is running via Xwayland. Alternatively, use xorg-xeyes and see if eyes are moving when moving mouse over application.

Atom

Add as a flag to the atom.desktop file:

/usr/share/applications/atom.desktopExec=/usr/bin/atom --force-device-scale-factor=2 %F

Browsers

Firefox

Firefox should use the #GDK 3 (GTK 3) settings. However, the suggested suggestion does not consistently scale the entirety of Firefox, and does not work for fractional values (e.g., a factor of 158DPI/96DPI = 1.65 for a 1080p 14" laptop). You may want to use instead. Another option, which will avoid Firefox-specific settings in many setups is to use the settings in #X Resources as Firefox should respect the value defined there.

To override those, open Firefox advanced preferences page () and set parameter to (or find the one that suits you better; is a good choice for Retina screens), but it also does not consistently scale the entirety of Firefox.

If Firefox is not scaling fonts, you may want to create and add appropriate styles to it. More information about at mozillaZine. Starting from Firefox 69 the and files are not loaded by default unless preference is set by the user. Open Firefox advanced preferences page () and set parameter to , then restart Firefox to apply the changes.

~/.mozilla/firefox/<profile>/chrome/[email protected] url("https://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"); /* #tabbrowser-tabs, #navigator-toolbox, menuitem, menu, ... */ * { font-size: 15px !important; } /* exception for badge on adblocker */ .toolbarbutton-badge { font-size: 8px !important; }

Warning: The AutoHiDPI extension is not compatible with Firefox Quantum (version 57 and above).

If you use a HiDPI monitor such as Retina display together with another monitor, you can use AutoHiDPI add-on in order to automatically adjust setting for the active screen. Also, since Firefox version 49, it auto-scales based on your screen resolution, making it easier to deal with 2 or more screens. For users of Firefox version 57 and above, the ffreszoom add-on will adjust the page zoom if it detects you are using a large monitor (zoom level and threshold are configurable). Modifying the internal CSS DPI setting from an extension is currently unsupported [1].

If you use Wayland, see Firefox#Wayland for instructions to enable the optional Wayland backend on firefox. This is also appicable to thunderbird.

Chromium / Google Chrome

Chromium should use the #GDK 3 (GTK 3) settings.

To override those, use the flag with a scaling value. This will scale all content and ui, including tab and font size. For example .

Using this option, a scaling factor of 1 would be normal scaling. Floating point values can be used. To make the change permanent, for Chromium, you can add it to :

~/.config/chromium-flags.conf--force-device-scale-factor=2

To make this work for Chrome, add the same option to instead.

If you use a HiDPI monitor such as Retina display together with another monitor, you can use the reszoom extension in order to automatically adjust the zoom level for the active screen.

If using Wayland session, you should enable native wayland support to avoid blurriness. See also Chromium#Incorrect HiDPI rendering.

Opera

Opera should use the #GDK 3 (GTK 3) settings.

To override those, use the command line option, where X is the desired DPI. For example, with Opera will assume that DPI is 144. Newer versions of opera will auto detect the DPI using the font DPI setting (in KDE: the force font DPI setting.)

Gimp 2.10

To fix toolbar icon sizes, update to or other value.

If menu fonts are still too small you can update an existing theme by copying it from into and changing and in into something bigger like . Then select the new theme from Preferences > Interface > Theme. When copying make sure to rename the new directory into something different from the original name (example Dark > DarkHighDPI).

You can also try using gimp-hidpi (installation instructions are outdated and refer to version 2.8, in Gimp 2.10 the theme should be installed into )

Inkscape

To scale the icons to a "usable" size go to Preferences > Interface and set the icon size to Large or Larger[2][3].

Java applications

AWT/Swing

Java applications using the AWT/Swing framework can be scaled by defining the VM property when invoking . The value can be an integer percentage value, or a float value. For example,

java -Dsun.java2d.uiScale=2 -jar some_swing_application.jar java -Dsun.java2d.uiScale=300% -jar some_swing_application.jar

Since Java 9 the environment variable is used to scale Swing applications accordingly.

Note that at this point, Java AWT/Swing (up to including OpenJDK 13) only effectively supports integer values. A setting of or will be treated as if it were set to resp. .

JavaFX

Java applications using JavaFX can be scaled by defining the VM property when invoking . The value can be an integer percentage value, an integer DPI value (where represents a scale factor of , and for example represents a scale factor of ), or a float value. For example,

java -Dglass.gtk.uiScale=200% -jar some_jfx_application.jar java -Dglass.gtk.uiScale=192dpi -jar some_jfx_application.jar java -Dglass.gtk.uiScale=2.0 -jar some_jfx_application.jar

JavaFX perfectly well supports fractions. Using values like or will deliver the expected result.

Mixed AWT/Swing and JavaFX

Some Java applications mix JavaFX and AWT/Swing (via ). In that case, the settings for AWT/Swing will also affect JavaFX, and setting will have no effect.

IntelliJ IDEA

IntelliJ IDEA supports two HiDPI modes (JRE-managed and IDE-managed). The sequence for determining system scale factor is well documented at [4]:

  1. Java property –
  2. gsettings(1) – or
  3. and
  4. Xresources –
  5. 1.0

For troubleshooting, consult the "Show HiDPI Info" dialog via search everywhere "Shift Shift".

When using per-monitor scaling, an issue might occur where IntelliJ fails to recognize the real, original monitor resolution. To remediate this problem some people have success by adding the option to the file (Help > Edit custom VM options).

If this does not work, the experimental GTK option might be enabled on Wayland (see above). Currently JetBrains products run on xwayland and thus have no native wayland support yet. This makes the rendering in JetBrains products incompatible with the monitor scaling framebuffer. Disabling the framebuffer thus might solve blurry font/rendering issues for JB products, but alas results in disabled fractional scaling.

LibreOffice

LibreOffice on all VCL backends take setting from there respective toolkits. There is a bug where the backend on Wayland does not scale [5]. Use the VCL backend instead.

MATLAB

Recent versions (R2017b) of MATLAB allow to set the scale factor[6]:

>> s = settings;s.matlab.desktop.DisplayScaleFactor >> s.matlab.desktop.DisplayScaleFactor.PersonalValue = 2

The settings take effect after MATLAB is restarted.

This can become tedious if you need to change the scaling frequently. To simplify this, consider using the following script:

~/bin/matlab-scale#!/bin/sh exec matlab -r "s = settings;s.matlab.desktop.DisplayScaleFactor.PersonalValue=$1;quit"

To change the display scaling to 3:

$ matlab-scale 3

Mono applications

According to [7], Mono applications should be scalable like GTK 3 applications. The precise method depends on the GUI library: GtkSharp obviouslys points back to Gtk, while the usual Windows Forms (libgdiplus) simply detects Xft settings.

NetBeans

NetBeans allows the font size of its interface to be controlled using the parameter during startup. To make this change permanent edit the file and append the parameter to the property.[8]

The editor fontsize can be controlled from Tools > Option > Fonts & Colors.

The output window fontsize can be controlled from Tools > Options > Miscelaneous > Output

OBS Studio

Start obs with the environment variable to disable Qt’s hi-dpi migration mode. It is partially buggy (preview window can disappear after first start, depending on window position) and prevents OBS Studio from capturing at native resolution.

The downside of this option is that the UI elements will now be messed up. To mitigate this, install the Yami theme, which works well on hi-dpi displays:

Tango-inaccurate.pngThe factual accuracy of this article or section is disputed.Tango-inaccurate.png

Reason: Installation from archive other than the source of the obs-studio package is not supported. (Discuss in Talk:HiDPI)

$ wget https://github.com/obsproject/obs-studio/archive/fd256a46837033b9a4632327ece3c572bcb3b9b1.tar.gz -O /tmp/yami.tar.gz $ cd ~/.config/obs-studio $ tar xf /tmp/yami.tar.gz --strip-components=3 --wildcards '*/UI/data/themes/Yami*'

Then, open File → Settings → General → Theme and chose Yami.

Skype

Skype for Linux (skypeforlinux-stable-binAUR package) uses #GDK 3 (GTK 3).

Spotify

You can change scale factor by simple for zoom in, for zoom out and for default scale. Scaling setting will be saved in , you may have to create this file by yourself:

~/.config/spotify/Users/YOUR-SPOTIFY-USER-NAME/prefsapp.browser.zoom-level=100

Also Spotify can be launched with a custom scaling factor which will be multiplied with setting specified in , for example

$ spotify --force-device-scale-factor=1.5

Steam

Official HiDPI support

  • Starting on 25 of January 2018 in the beta program there is actual support for HiDPI and it should be automatically detected.
  • Steam > Settings > Interface, check "Enlarge text and icons based on monitor size" (restart required)
  • If it is not automatically detected, use to set the desired scale factor.

Unofficial

The HiDPI-Steam-Skin can be installed to increase the font size of the interface. While not perfect, it does improve usability.

Note: The README for the HiDPI skin lists several possible locations for where to place the skin. The correct folder out of these can be identified by the presence of a file named .

MetroSkin Unofficial Patch also helps with HiDPI on Steam with Linux.

Sublime Text 3

Sublime Text 3 has full support for display scaling. Go to Preferences > Settings > User Settings and add to your settings.

Thunderbird

See #Firefox. To access , go to Edit > Preferences > Advanced >Config editor.

VirtualBox

Note: This only applies to KDE with scaling enabled.

VirtualBox also applies the system-wide scaling to the virtual monitor, which reduces the maximum resolution inside VMs by your scaling factor (see [9]).

This can be worked around by calculating the inverse of your scaling factor and manually setting this new scaling factor for the VirtualBox execution, e.g.

$ QT_SCALE_FACTOR=0.5 VirtualBox --startvm vm-name

Wine applications

Run

$ winecfg

and change the "dpi" setting found in the "Graphics" tab. This only affects the font size.

Zathura document viewer

No modifications required for document viewing.

UI text scaling is specified via configuration file (note that "font" is a girara option):

set font "monospace normal 20"

Zoom

Set the variable in .

For the Flatpak version, set the environment variable (e.g. to 0.5 [10]). This can be easily done with Flatseal, if using a GUI tool is preferred.

Gazebo

Gazebo only renders an upper left of a view instead of the whole view. To fix this a Qt enviorment variable must be set. To run Gazebo:

$ QT_SCREEN_SCALE_FACTORS=[1.0] gazebo

To run a ROS simulation:

$ TURTLEBOT3_MODEL=burger QT_SCREEN_SCALE_FACTORS=[1.0] roslaunch turtlebot3_gazebo turtlebot3_world.launch

Making an alias such as gazebo="QT_SCREEN_SCALE_FACTORS=[1.0] gazebo" works for the first case but not for the second.

Fcitx

Fcitx preedit can be changed in .

Unsupported applications

run_scaled-gitAUR can be used to scale applications (which uses xpra internally).

Another approach is to run the application full screen and without decoration in its own VNC desktop. Then scale the viewer. With Vncdesk (vncdesk-gitAUR from the AUR) you can set up a desktop per application, then start server and client with a simple command such as .

x11vnc has an experimental option , which opens one viewer per application window. Perhaps something could be hacked up with that.

Multiple displays

The HiDPI setting applies to the whole desktop, so non-HiDPI external displays show everything too large. However, note that setting different scaling factors for different monitors is already supported in Wayland.

One workaround is to use xrandr's scale option. To have a non-HiDPI monitor (on DP1) right of an internal HiDPI display (eDP1), one could run:

$ xrandr --output eDP-1 --auto --output DP-1 --auto --scale 2x2 --right-of eDP-1

When extending above the internal display, you may see part of the internal display on the external monitor. In that case, specify the position manually.

You may adjust the "sharpness" parameter on your monitor settings to adjust the blur level introduced with scaling.

Note: Above solution with does not work on some Nvidia cards. No solution is currently available. [11] A potential workaround exists with configuring on the via . For more info see [12].

Note: If you are using the driver you will get mouse flickering. This can be solved by scaling your non-scaled screen by 0.9999x0.9999.

Multiple external monitors

There might be some problems in scaling more than one external monitors which have lower dpi than the built-in HiDPI display. In that case, you may want to try downscaling the HiDPI display instead, with e.g.

$ xrandr --output eDP1 --scale 0.5x0.5 --output DP2 --right-of eDP1 --output HDMI1 --right-of DP2

In addition, when you downscale the HiDPI display, the font on the HiDPI display will be slightly blurry, but it's a different kind of bluriness compared with the one introduced by upscaling the external displays. You may compare and see which kind of bluriness is less problematic for you.

Mirroring

If all you want is to mirror ("unify") displays, this is easy as well:

With AxB your native HiDPI resolution (for ex 3200x1800) and CxD your external screen resolution (e.g. 1920x1200)

$ xrandr --output HDMI --scale [A/C]x[B/D]

In this example which is QHD (3200/1920 = 1.66 and 1800/1200 = 1.5)

$ xrandr --output HDMI --scale 1.66x1.5

For UHD to 1080p (3840/1920=2 2160/1080=2)

$ xrandr --output HDMI --scale 2x2

You may adjust the "sharpness" parameter on your monitor settings to adjust the blur level introduced with scaling.

Tools

There are several tools which automate the commands described above.

Linux console

The Linux console changes the font to (based on from terminus-font[13]) accordingly based on the resolution of the display. If your monitor is not recognised as HiDPI, the default font can be changed. In that case, specify in the kernel command line.

The largest fonts present in the kbd package are and . Other packages like terminus-font contain further alternatives, such as (normal) and (bold). See Linux console#Fonts for configuration details and Linux console#Persistent configuration in particular for applying the font setting during the early userspace boot sequence.

After changing the font, it is often garbled and unreadable when changing to other virtual consoles (). To fix this you can force specific mode for KMS, such as (substitute in the native resolution of your HiDPI display), and reboot.

Users booting though UEFI may experience the console and boot loader being constrained to a low resolution despite correct KMS settings being set. This can be caused by legacy/BIOS boot being enabled in UEFI settings. Disabling legacy boot to bypass the compatibility layer should allow the system to boot at the correct resolution.

See also

Sours: https://wiki.archlinux.org/title/HiDPI
  1. Devexpress for asp net
  2. Steven universe movie promo
  3. Solar outdoor tabletop lanterns

HiDPI support in Manjaro

Linux HiDPI support is in an evolving state with some applications and environments providing seamless support while others provide close to none. I wanted to share both my findings about the state of HiDPI in each DE and some tips for how to improve usability in each environment on a high resolution screen.

The instructions for Gnome, KDE/Plasma and XFCE assume an up to date environment installed from the official ISOs. For all the other Desktop Environments installation instructions are included for each. The instructions were tested coming from the XFCE edition but it should be the same regardless of where you start.

When it comes to scaling there are a few things to consider:

  1. The ability automatically scale meet the desktop to different resolutions
  2. The uniformity of the scaling. For example does it scale all aspects of the DE or just certain ones.
  3. The scaling increment. Some desktops only scale in whole increments such as 2x or 3x while others support fractional increments such as 1.25x. This can be important, especially at lower resolutions such as 1440p where 1x might be too small but 2x is too large.

A few notes:

  • Everything below assumes your system is up to date. You can ensure it is up to date by running
  • Specific settings for DPI, pixel counts and scale factors are not specified because it is a matter of personal preference. As a rule of thumb, if you want a 4K screen to have normal size elements for a 1080p screen then you should use a scale factor of 2 and double the DPI and pixel amounts
  • An attempt has been made to make this as beginner friendly as possible so you will find things like "Open the file .Xresources in your home folder" as opposed to "edit ~/.Xresources"

Budgie
Budgie is a simple and intuitive desktop. It is currently a derivative of Gnome and as a result Budgie's scaling is very good. Budgie scales in 1x increments up to 3x.

  • To install Budgie reference the appropriate Wiki page
  • Budgie autoscales the interface by default. If it doesn't you can run the run the "dconf Editor" and go under org->gnome->desktop->interface->scaling-factor and change it manually
  • To change the cursor size run the "dconf Editor" and go under org->gnome->desktop->interface->cursor-size

Cinnamon
Cinnamon has top notch support for HiDPI. It autoscales everything by default and pretty much "just works". Cinnamon scales in 1x increments up to 3x.

  • To install Cinnamon reference the appropriate Wiki page
  • The interface autoscales but if you want to change it manually you can in System Settings->General
  • If you want to change the cursor size you can use dconf-editor
    • If dconf-editor is not installed, you can install it with:
    • Then run dconf-editor and browse to org->cinnamon->desktop->interface->cursor-size

Deepin
Deepin has added support for hidpi displays in recent versions. The scaling is manual but it is simple to use. Deepin scales in .25x increments up to 2x.

  • To enable scaling adjust the slider in display settings

Enlightenment
HiDPI support in Enlightenment is usable but there are some definite issues. The window borders are very difficult to target and some UI elements do not scale.

  • To install Enlightenment reference the appropriate Wiki page
  • Open the file .Xresources in your home folder. Find the line that reads "Xft.dpi=" and change it to something suitable. This will adjust the font sizes in applications
  • Logout and login to Enlightenment
  • Enlightenment walks you through an initial setup process and one of the steps is to select the scaling factor. If you miss it you can find it later in the "Settings Panel" on the "Look" tab under "Scaling"
  • Open the "Settings Panel". Under the "Input" tab, select the "Mouse" item and adjust the cursor size

Gnome
HiDPI Support in Gnome is excellent. It auto-scales by default and is completely usable out of the box

  • To install gnome reference the appropriate Wiki page
  • Gnome autoscales the interface by default. If it doesn't you can run the run the "dconf Editor" and go under org->gnome->desktop->interface->scaling-factor and change it manually
  • To change the cursor size run the "dconf Editor" and go under org->gnome->desktop->interface->cursor-size

KDE/Plasma
Support for HiDPI in plasma is very good after a few adjustments. Sometimes gtk application will not scale quite as well on plasma as they do on other DEs but that is relatively rare.

  • To install kde/plasma reference the appropriate Wiki page
  • Go into "System Settings". Under "Display and Monitor" click "Scale Display". Drag the "Scale" slider to an appropriate amount. Log out and then back in
  • If your cursor needs resizing you can do so in "System Settings". Under "Workspace Theme", select "Cursor Theme" and then adjust the size on the bottom right hand side
  • Right click on the panel and go to panel options and then unlock widgets. Click on the handle for the panel and drag the "Height" box until the panel is an appropriate size
  • If you would like to resize the items in the systray you do so by following these steps:
    • In your "Home" directory there is a hidden directory called ".config"
    • Edit the file "plasma-org.kde.plasma.desktop-appletsrc"
    • Search the file for "SystrayContainmentId" there will be a number after the "=" sign
    • Scroll down to "[Containments][8][General]" replacing "8" with your number from the previous step
    • If iconSize is not already in that section add a line that reads "iconSize=2". Replace 2 with your desired scale factor
    • Logout for the changes to take effect

LXDE
HiDPI support in LXDE is usable after some tweaking.

  • To install LXDE reference the appropriate Wiki page
  • Open the file .Xresources in your home folder. Find the line that reads "Xft.dpi=" and change it to something suitable. This will adjust the font sizes
  • Logout and login to LXDE
  • Right click on the panel and select "Panel Preferences"
    • In the "Geometry" tab, adjust the "Height" and "Icon Size" to your liking
    • In the "Panel Applets" tab select "Task Bar" and click "Preferences" to adjust the width of the task buttons
  • Open the "PCManFM File Manager". Open the Edit->Preferences menu item. Under "Display" set all the sizes appropriately
  • Openbox, the default LXDE window manager in Manjaro does not support HiDPI very well so you will need to download a specific HiDPI theme or use something else. Manjaro includes HiDPI themes for the xfce window manager or you could install kwin
  • Option 1 - Install an Opnbox HiDPI theme. This is the easiest solution but Openbox themes are fixed pixels so you need to find one with your dimensions in mind
    • If the theme is packages as an Openbox Theme Archive(obt) then open the "LXQT Configuration Center", go into "Openbox Settings" and select "Install a new theme"
    • If not, you will need to uncompress it and then place it in the ".themes" folder in your Home folder. If that folder does not exist then you need to create it. mkdir ~/.themes Then open the "LXQT Configuration Center", go into "Openbox Settings" and select the theme from the list
  • Option 2 - Install xfwm4, the window manager from XFCE. Manjaro includes some HiDPI themes for XFCE and these themes are often a good match for the default LXDE theme
    • Install the following packages:
      • - The window manager
      • - Themes for xfwm
      • - The settings manager so you can adjust the themes and other window manager settings
      • To install these all at once you can use:
    • Open the "Desktop Session Settings" application. On the "Advanced Options" tab, change the "Window Manager" to be xfwm4
    • Logout and back in again to activate xfwm4 as the window manager
    • Run xfce4-settings-manager from a terminal or the "Run" box. Select "Window Manager" and choose a HiDPI theme from the list
  • Option 3 - Install kwin, the window manager from KDE
    • Use to install kwin and the "KDE System Settings" application used to configure it
    • Open the "Desktop Session Settings" application. On the "Advanced Options" tab, change the "Window Manager" to be kwin_x11
    • Logout and back in again to activate kwin as the window manager

LXQT
LXQT is the next generation of LXDE and in its current state is actually capable of decent support for HiDPI but it takes some work to get there.

  • To install LXQT you need the following packages/groups:
    • - The lxqt install lxqt
    • - This installs a Manjaro LXQT theme and it is important because it is one of the few themes that handles font scaling without overlapping the icons and text in the application menu
    • To install both of the above from a terminal use:
  • Open the file .Xresources in your home folder. Find the line that reads "Xft.dpi=" and change it to something suitable. This will adjust the font sizes Logout and login to LXQT
  • After installation, LXQT has no icon theme selected by default so first we should fix that. Open the "LXQT Configuration Center". Open "Appearance" and select an "Icon Theme". While you are in there choose the Menda LXQT theme
  • Right-click on the panel and select "Configure Panel". Change "Size" and "Icon Size" appropriately
  • Open the "PCManFM File Manager". Under the Edit->Preferences menu item. Select "Display" and set all the sizes appropriately
  • Openbox, the default LXQT window manager does not support HiDPI very well so you will need to download a specific HiDPI theme or use something else. kwin is a good alternative for LXQT.
  • Option 1 - Install an Opnbox HiDPI theme. This is the easier solution but Openbox themes are fixed pixels so you need to find one with your dimensions in mind
    • If the theme is packages as an Openbox Theme Archive(obt) then open the "LXQT Configuration Center", go into "Openbox Settings" and select "Install a new theme"
    • If not, you will need to uncompress it and then place it in the ".themes" folder in your Home folder. If that folder does not exist then you need to create it. mkdir ~/.themes Then open the "LXQT Configuration Center", go into "Openbox Settings" and select the theme from the list
  • Option 2 - Install kwin, the window manager from KDE
    • Use to install kwin and the "KDE System Settings" application used to configure it
    • Open the "LXQT Configuration Center" again and this time look under "Session Settings". Change the "Window Manager" to be kwin_x11
    • Logout and back in again to activate kwin as the window manager

MATE
MATE has added some support for hidpi displays. Scaling is automatic. hidpi is basically an on/off switch where it doesn't scale or scales at 2x. Application scaling works pretty well but I noticed a lot of layout issues with MATE panels and widgets when scaling was enabled.

  • To enable scaling go into the "MATE Tweak" settings under "Window" set the "HIDPI" setting as desired.
  • If 2x is too big or too small for your application some fine tuning can be achieved by changing the font resolution. In "Appearance Preferences" select the "Fonts" tab and then click "Details". You can then adjust the DPI to suit your preference.

XFCE
With a decent amount of tweaking XFCE is usable on HiDPI screens. A few elements won't be scaled properly and some things don't layout ideally such as the settings menu but overall it is workable

  • To install XFCE reference the appropriate Wiki page
  • Under "Settings", open "Appearance". Select the "Fonts" tab and set an appropriate DPI setting
  • Under "Settings", open "Window Manager". Select the "Style" tab and choose a HiDPI style. There is one called "Default-hidpi" if you are having trouble finding one
  • Open "File Manager"(Thunar) and change the zoom to an appropriate level in the "View" menu
  • Under "Settings", open "Panel"
    • On the "Display" tab, drag the "Row Size" slider to an appropriate value
    • On the "Items" tab select "Whisker Menu" and then click on the edit button. Set the icon sizes on the "Appearance" tab to your liking
    • Stay on the "Items" tab and select "Notifications Area" and then click on the edit button. Change "Maximum Icon Size" to an appropriate value
    • If you end up with two rows of window buttons and you find them too difficult to see or target there are two different workarounds
      1. You can reduce the "Row Size" until it falls to a single row
      2. Alternatively, on the "Items" tab select "Window Buttons" and then click on the edit button. Uncheck "Show Button Labels". This will give you full size icons
  • Under "Settings", open "Desktop" and select the "Icons" tab. Change the "Icon Size" to something suitable

Window Managers

SDDM
SDDM has support for hidpi via manual or automatic scaling

To set SDDM to auto scale:

  • Check for the presence of the file
  • If you have an sddm.conf file then edit both the section and the section to include the following line:
  • If not, add a config file to with the following contents(create the directory if it does not exist):




To set SDDM to use a manual DPI setting:

  • Check for the presence of the file
  • If you have an sddm.conf file then look in the for the line that starts and add to the end of that line where X is your target DPI. For example, mine looks like this:
  • If you don't have sddm.conf then check the directory /etc/sddm.conf.d for any files that have the line starts and add to the end of that line where X is your target DPI. For example, mine looks like this:
  • If the /etc/sddm.conf.d doesn't exist or doesn't contain a file with the line then create it and add a file with the following contents:


    Replace '192' with an appropriate target DPI for your configuration

It is worth noting that in my testing enable auto-scaling scaled a 15.6" 4K display by a very small amount and I was forced to use the manual configuration to get good results.

GDM
Like Gnome, GDM auto-scales by default


Out of date information below this point

22 Likes

Sours: https://archived.forum.manjaro.org/t/hidpi-support-in-manjaro/26088

20.1rc4 HiDPI issues - how to fix them? Same with KDE

No change, as issue is both in XFCE & KDE it ought to be some common component or config.

Extract of sudo inxi -F on fresh boot

System:
Host: manjaro Kernel: 5.8.0-2-MANJARO x86_64 bits: 64 Desktop: Xfce 4.14.2
Distro: Manjaro Linux
Graphics:
Device-1: Intel Iris Graphics 550 driver: i915 v: kernel
Display: server: X.Org 1.20.8 driver: intel unloaded: modesetting
resolution: 3840x2160~30Hz
OpenGL: renderer: Mesa Intel Iris Graphics 550 (SKL GT3)
v: 4.6 Mesa 20.1.5
Drives:
Local Storage: total: 1.03 TiB used: 348.56 GiB (33.1%)
ID-1: /dev/sda vendor: Toshiba model: MQ01ABD100 size: 931.51 GiB
ID-2: /dev/sdb vendor: Phison model: SSD 128GB PS3109-S9 size: 119.24 GiB
ID-3: /dev/sdc type: USB vendor: Kingston model: DataTraveler 2.0
size: 3.73 GiB
Partition:
ID-1: / size: 4.29 GiB used: 69.2 MiB (1.6%) fs: overlay source: ERR-102
[[email protected] Bureau]$

[[email protected] Bureau]$ xrandr
Screen 0: minimum 8 x 8, current 3840 x 2160, maximum 32767 x 32767
DP1 disconnected (normal left inverted right x axis y axis)
HDMI1 connected 3840x2160+0+0 (normal left inverted right x axis y axis) 620mm x 340mm
3840x2160 30.00* 30.00 25.00 24.00 29.97 23.98 29.98
1920x2160 59.99
1920x1080 60.00 60.00 50.00 59.94
1680x1050 59.88
1280x1024 75.02 60.02
1440x900 74.98 59.90
1280x960 60.00
1280x720 60.00 50.00 59.94
1024x768 75.03 60.00
800x600 75.00 60.32
720x576 50.00
720x480 60.00 59.94
640x480 75.00 72.81 66.67 60.00 59.94
720x400 70.08
VIRTUAL1 disconnected (normal left inverted right x axis y axis)
[[email protected] Bureau]$ xrandr --dpi 144
[[email protected] Bureau]$

Sours: https://forum.manjaro.org/t/20-1rc4-hidpi-issues-how-to-fix-them-same-with-kde/7827

Hidpi manjaro

alacritty / alacritty Public

I use an external monitor w/ a HiDPI resolution on Manjaro Gnome Linux. On the external monitor, I've set the display to 200% scaling. On the regular DPI laptop display, I use no scaling. So the font is either enormous (when I switch from monitor to laptop) or it is tiny (when I switch from laptop to monitor). When I plug in/out, every Gnome application automatically scales appropriately, except Alacritty.

Restarting Alacritty fixes this. Because I use , this makes it pretty easy to fix - detach tmux, restart Alacritty, re-attach tmux. Still, would be nice for it to just work.

I saw a few similar sounding issues about upstream dependencies w/ event notification, but wasn't sure if they were the exact same issue. If so, please let me know.

I'm willing to look into the upstream issues if it's a simple enough thing, but I'm not well-versed in Rust. I could probably dig something up with a little help.

System

OS: Linux (Manjaro)
Version:
Linux/BSD: X11, Gnome

Logs

What this log shows:

  • I start out plugged into the monitor (it correctly detects 2x scaling)
  • I pull the plug and open the laptop, it goes to regular DPI and everything but Alacritty scales
  • I close Alacritty with Ctrl-D (you can see the event in the following logs)

It seems to me that absolutely nothing is logged in after the initial second until I quit that Alacritty instance.

Here's the same sequence of events with :

Sours: https://github.com/alacritty/alacritty/issues/5229
Scaling KDE Plasma Perfectly for High DPI Displays

KDE

KDE is a software project currently comprised of a desktop environment known as Plasma, a collection of libraries and frameworks and several applications.

KDE-de-18.jpg

HiDPI

If your screen has a relatively large resolution some portions of your desktop may appear abnormally small.
While KDE Plasma offers a way to 'scale' the appearance this feature does not always give good results, especially with fractional scaling (1.25x instead of 2x).
The best results hinge on applying font DPI settings. It is advisable to keep your configuration to 'quarter steps'. Example:

| 1.00x=96dpi | 1.25x=120dpi | 1.50x=144dpi | 1.75x=168dpi | 2.00x=192dpi |

In order to set the DPI for GTK applications as well you can use an Environment Variable. Such as at .
This variable will use the 'fractional' scale number instead of DPI, as shown above. For example if you are using 144dpi then that is a 'fractional scale' of 1.5. Example:

If you feel that icons need some resizing as well then you can use System Settings:

Lockscreen

As of now there is no easy way to configure the appearance of the lockscreen. It is provided by your look-and-feel theme, or lacking that, by the the default breeze.

Desktop Settings

To reach desktop settings right click on the desktop and select Configure Desktop. If that option isn't available(it is configurable), you can use the keyboard shortcut


Desktop Toolbox
To toggle the appearance of the 'toolbox' navigate to the Tweaks tab.


Layout
Under the Wallpaper tab there is a 'Layout' option.
"Folder View" will allow you to place and interact with items on the desktop.
If you do not use desktop icons (or if you need encouragement for better organization) you can use "Desktop".
"Desktop" layout will not allow items on the desktop and results in almost 20 MiB of memory savings in plasmashell.

kwin-lowlatency

If you feel that plasma, or more precisely the window manager isnt as 'snappy' as it could be (lag, stuttering, etc) when you have obviously capable hardware then there is one workaround to try. Some users report significant increases in speed and responsiveness when replacing the default window manager with a slightly modified and patched version - .
The package is available in the AUR and should automatically replace when installed. For more information see here.

Single Click vs Double Click

In order to select between single and double click for opening files and folders you can use System Settings.

KDE.org
Archwiki:KDE
Wikipedia:KDE

Sours: https://wiki.manjaro.org/index.php/KDE

You will also be interested:

On their heads were knitted masks with slits for the eyes and mouth. On her deck, Jim nodded toward Blanka. The soldiers grabbed the prisoner by the arms and dragged her to the upper tier. A bustle reigned around: the guards were running, in some places the screams of slaves being beaten and raped were heard.



1617 1618 1619 1620 1621