Correzione del ridimensionamento delle applicazioni basate su Java per uno schermo DPI elevato


24

Ci sono alcune applicazioni (principalmente basate su Java) che non seguono la scala globale 2x che ho impostato nelle impostazioni dello schermo. Quindi queste app sono davvero minuscole sul mio schermo DPI alto con 3200x1800px.

Come posso far funzionare queste app con una risoluzione dello schermo più piccola?


Idea / Android Studio ha aperto un bug e probabilmente una soluzione qui: code.google.com/p/android/issues/detail?id=68781
Anton

questo è esattamente lo stesso problema, ma neanche io ho trovato una soluzione.
rubo77,

Hai provato a eseguire AS / Idea con -Dis.hidpi = chiave vera nella riga di comando? Non è una soluzione generale, comunque, ma spero che sia di aiuto.
Anton,

Ho cambiato questo alla fine in data/bin/studio.sh: eval "$JDK/bin/java" $ALL_JVM_ARGS -Djb.restart.code=88 -Dis.hidpi=true $MAIN_CLASS_NAME "$@"- ma nessun effetto
rubo77

Ho aggiunto una versione "dinamica", cambiando la risoluzione per finestra. Dovrebbe anche funzionare bene con alt-tab.
Jacob Vlijm,

Risposte:


15

Un importante aggiornamento di convenienza sarebbe quello di utilizzare uno script in background, impostando automaticamente la risoluzione per applicazione , mentre è possibile impostare risoluzioni diverse per diverse (più) applicazioni contemporaneamente.

Questo è esattamente ciò che fa lo script qui sotto.

Un esempio di una risoluzione predefinita di 1680x1050:

inserisci qui la descrizione dell'immagine

In esecuzione gedit, passando automaticamente a 640x480:

inserisci qui la descrizione dell'immagine

In esecuzione gnome-terminal, passando automaticamente a 1280x1024:

inserisci qui la descrizione dell'immagine

Quando l'applicazione viene chiusa, la risoluzione viene automaticamente ripristinata su 1680x1050

Come usare

  1. Copia lo script qui sotto in un file vuoto, salvalo come set_resolution.py
  2. Nell'intestazione dello script, imposta la risoluzione predefinita, nella riga:

    #--- set the default resolution below
    default = "1680x1050"
    #---
  3. In quello stesso directory (cartella), creare un file di testo, esattamente denominata: procsdata.txt. In questo file di testo, impostare l'applicazione o il processo desiderato, seguito da uno spazio, seguito dalla risoluzione desiderata. Un'applicazione o uno script per riga, simile a:

    gedit 640x480
    gnome-terminal 1280x1024
    java 1280x1024

    inserisci qui la descrizione dell'immagine

  4. Esegui lo script con il comando:

    python3 /path/to/set_resolution.py

Nota

Uso dello script pgrep -f <process>, che rileva tutte le corrispondenze, inclusi gli script. Il possibile svantaggio è che può causare conflitti di nomi quando si apre un file con lo stesso nome del processo.
Se riscontri problemi del genere, modifica:

matches.append([p, subprocess.check_output(["pgrep", "-f", p]).decode("utf-8")])

in:

matches.append([p, subprocess.check_output(["pgrep", p]).decode("utf-8")])

Il copione

#!/usr/bin/env python3
import subprocess
import os
import time

#--- set the default resolution below
default = "1680x1050"
#---

# read the datafile
curr_dir = os.path.dirname(os.path.abspath(__file__))
datafile = curr_dir+"/procsdata.txt"
procs_data = [l.split() for l in open(datafile).read().splitlines() if not l == "\n"]
procs = [pdata[0] for pdata in procs_data]

def check_matches():
    # function to find possible running (listed) applications
    matches = []
    for p in procs:
        try:
            matches.append([p, subprocess.check_output(["pgrep", "-f", p]).decode("utf-8")])
        except subprocess.CalledProcessError:
            pass
    match = matches[-1][0] if len(matches) != 0 else None
    return match

matches1 = check_matches()

while True:
    time.sleep(2)
    matches2 = check_matches()
    if matches2 == matches1:
        pass
    else:
        if matches2 != None:
            # a listed application started up since two seconds ago
            resdata = [("x").join(item[1].split("x")) for item in \
                       procs_data if item[0] == matches2][0]
        elif matches2 == None:
            # none of the listed applications is running any more
            resdata = default
        subprocess.Popen(["xrandr", "-s", resdata])
    matches1 = matches2
    time.sleep(1)

Spiegazione

All'avvio dello script, legge il file in cui sono state definite le applicazioni e le corrispondenti risoluzioni dello schermo desiderate.

Quindi tiene d'occhio i processi in esecuzione (in esecuzione pgrep -f <process>per ciascuna delle applicazioni) e imposta la risoluzione se l'applicazione viene avviata.

Quando pgrep -f <process>non produce output per nessuna delle applicazioni elencate, imposta la risoluzione su "predefinita".


Modificare:

Versione "dinamica" (come richiesto)

Mentre la versione precedente funziona con più applicazioni elencate, imposta solo la risoluzione per un'applicazione alla volta .

La versione seguente può gestire diverse applicazioni con una diversa risoluzione (richiesta), in esecuzione contemporaneamente. Lo script in background terrà traccia di qual è l'applicazione principale e imposterà la risoluzione di conseguenza. Funziona bene anche con Alt+ Tab.

Si noti che questo comportamento potrebbe essere fastidioso se si passa molto tra il desktop e le applicazioni elencate; l'interruttore di risoluzione frequente potrebbe essere troppo.

differenze nelle modalità di installazione

L'installazione è praticamente la stessa, a parte il fatto che questo usa wmctrle xdotool:

sudo apt-get install wmctrl
sudo apt-get install xdotool

Il copione

#!/usr/bin/env python3
import subprocess
import os
import sys
import time

#--- set default resolution below
resolution = "1680x1050"
#---

curr_dir = os.path.dirname(os.path.abspath(__file__))
datafile = curr_dir+"/procsdata.txt"
applist = [l.split() for l in open(datafile).read().splitlines()]
apps = [item[0] for item in applist]

def get(cmd):
    try:
        return subprocess.check_output(["/bin/bash", "-c", cmd]).decode("utf-8")
    except subprocess.CalledProcessError:
        pass

def get_pids():
    # returns pids of listed applications; seems ok
    runs = []
    for item in apps:
        pid = get("pgrep -f "+item)
        if pid != None:
            runs.append((item, pid.strip()))    
    return runs

def check_frontmost():
    # returns data on the frontmost window; seems ok
    frontmost = str(hex(int(get("xdotool getwindowfocus").strip())))
    frontmost = frontmost[:2]+"0"+frontmost[2:]
    try:
        wlist = get("wmctrl -lpG").splitlines()
        return [l for l in wlist if frontmost in l]
    except subprocess.CalledProcessError:
        pass

def front_pid():
    # returns the frontmost pid, seems ok
    return check_frontmost()[0].split()[2]

def matching():
    # nakijken
    running = get_pids(); frontmost = check_frontmost()
    if all([frontmost != None, len(running) != 0]):
        matches = [item[0] for item in running if item[1] == frontmost[0].split()[2]]
        if len(matches) != 0:
            return matches[0]
    else:
        pass

trigger1 = matching()

while True:
    time.sleep(1)
    trigger2 = matching()
    if trigger2 != trigger1:
        if trigger2 == None:
            command = "xrandr -s "+resolution
        else:
            command = "xrandr -s "+[it[1] for it in applist if it[0] == trigger2][0]
        subprocess.Popen(["/bin/bash", "-c", command])
        print(trigger2, command)
    trigger1 = trigger2

Gli appunti

  • Anche se l'ho in esecuzione per diverse ore senza errori ora, ti preghiamo di testarlo accuratamente. In caso di errore, si prega di lasciare un commento.
  • Lo script, così com'è, funziona su un singolo monitor.

@ rubo77 Lo script, così com'è, presuppone che venga eseguita solo una delle applicazioni alla volta. Se vengono eseguite più applicazioni elencate, ne sceglie una per impedire troppi switch di risoluzione in una riga, poiché anche il passaggio al desktop provocherebbe uno switch di risoluzione. Posso cambiarlo comunque. Imposterò come opzione.
Jacob Vlijm,

È possibile utilizzare questo comando per capire il nome di un'app che si desidera aggiungere al file di configurazione: sleep 5 && cat "/proc/$(xdotool getwindowpid "$(xdotool getwindowfocus)")/comm"focalizzare l'app entro 5 secondi e si ottiene il nome desiderato (fonte: askubuntu.com/a/508539/34298 )
rubo77

ulteriore discussione presso issuetracker in github.com/rubo77/set_resolution.py
rubo77

1
Questo script ha un aggiornamento che risolve molti problemi su github.com/rubo77/set_resolution.py
rubo77

potresti per favore guardare questo e dirmi se pensi che sia correlato? askubuntu.com/questions/742897/…
Kalamalka Kid

3

Prova ad aggiungere alla tua riga di comando java: -Dsun.java2d.uiScale=2.0oppure impostalo sul fattore di scala che desideri.


2

Come soluzione alternativa

Ho creato uno script bash che modifica la risoluzione in fullHD prima che avvii l'applicazione (in questo esempio Android Studio) e la ritorni a 3200x1800 quando l'applicazione si chiude:

sudo nano /usr/local/bin/studio

Inserisci questo script:

#!/bin/bash
# set scaling to x1.0
gsettings set org.gnome.desktop.interface scaling-factor 1
gsettings set com.ubuntu.user-interface scale-factor "{'HDMI1': 8, 'eDP1': 8}"
xrandr -s 1920x1080
# call your program
/usr/share/android-studio/data/bin/studio.sh
# set scaling to x2.0
gsettings set org.gnome.desktop.interface scaling-factor 2
gsettings set com.ubuntu.user-interface scale-factor "{'HDMI1': 8, 'eDP1': 16}"
xrandr -s 3200x1800

e assegnargli diritti eseguibili:

sudo chmod +x /usr/local/bin/studio

Quindi puoi avviarlo con Alt+F1 studio


Per altri fattori di ridimensionamento che 2.0 vedere /ubuntu//a/486611/34298


Per attivare e disattivare facilmente lo zoom in Firefox, usa l'estensione Zoom Menu Elements

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.