Corrigir o dimensionamento de aplicativos baseados em java para uma tela de alto DPI

24

Existem alguns aplicativos (principalmente baseados em java) que não seguem a escala 2x global que eu defini nas configurações de tela. Portanto, esses aplicativos são realmente pequenos na minha tela de alto DPI com 3200x1800px.

Como posso executar esses aplicativos em uma resolução de tela menor?

rubo77
fonte
O Idea / Android Studio abriu um bug e, possivelmente, uma solução aqui: code.google.com/p/android/issues/detail?id=68781
Anton
isso é exatamente o mesmo problema, mas eu também não encontrei uma solução lá.
rubo77
Você já tentou executar o AS / Idea com -Dis.hidpi = true key na linha de comando? De qualquer maneira, não é uma solução geral, mas espero que ajude.
Anton
Eu mudei isso no final, em data/bin/studio.sh: eval "$JDK/bin/java" $ALL_JVM_ARGS -Djb.restart.code=88 -Dis.hidpi=true $MAIN_CLASS_NAME "$@"- mas nenhum efeito
rubo77
Eu adicionei uma versão "dinâmica", alterando a resolução por janela. Também deve funcionar bem com alt-tab.
Jacob Vlijm

Respostas:

15

Uma grande atualização de conveniência seria usar um script em segundo plano, definindo automaticamente a resolução por aplicativo , enquanto você pode definir resoluções diferentes para aplicativos diferentes (múltiplos) de uma só vez.

É exatamente isso que o script abaixo faz.

Um exemplo de uma resolução padrão de 1680x1050:

insira a descrição da imagem aqui

Em execução gedit, mudando automaticamente para 640x480:

insira a descrição da imagem aqui

Em execução gnome-terminal, mudando automaticamente para 1280x1024:

insira a descrição da imagem aqui

Quando o aplicativo é fechado, a resolução é automaticamente ajustada para 1680x1050

Como usar

  1. Copie o script abaixo em um arquivo vazio, salve-o como set_resolution.py
  2. No cabeçalho do script, defina sua resolução padrão, na linha:

    #--- set the default resolution below
    default = "1680x1050"
    #---
  3. Em muito o mesmo diretório (pasta), crie um arquivo de texto, exatamente chamado: procsdata.txt. Nesse arquivo de texto, defina o aplicativo ou processo desejado, seguido de um espaço, seguido da resolução desejada. Um aplicativo ou script por linha, parecido com:

    gedit 640x480
    gnome-terminal 1280x1024
    java 1280x1024

    insira a descrição da imagem aqui

  4. Execute o script pelo comando:

    python3 /path/to/set_resolution.py

Nota

O uso do script pgrep -f <process>, que captura todas as correspondências, incluindo scripts. A possível desvantagem é que isso pode causar conflitos de nome ao abrir um arquivo com o mesmo nome que o processo.
Se você enfrentar problemas como esse, altere:

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

para dentro:

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

O script

#!/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)

Explicação

Quando o script é iniciado, ele lê o arquivo no qual você definiu seus aplicativos e as respectivas resoluções de tela desejadas correspondentes.

Ele fica de olho nos processos em execução (em execução pgrep -f <process>para cada um dos aplicativos) e define a resolução se o aplicativo iniciar.

Quando pgrep -f <process>não produz saída para nenhum dos aplicativos listados, define a resolução como "padrão".


Editar:

Versão "dinâmica" (conforme solicitado)

Embora a versão acima funcione com vários aplicativos listados, ela define a resolução apenas para um aplicativo por vez .

A versão abaixo pode lidar com aplicativos diferentes com uma resolução diferente (necessária), executando ao mesmo tempo. O script de plano de fundo acompanhará qual é o aplicativo mais avançado e definirá a resolução de acordo. Também funciona bem com Alt+ Tab.

Observe que esse comportamento pode ser irritante se você alternar muito entre a área de trabalho e os aplicativos listados; a opção de resolução frequente pode ser demais.

diferenças em como configurar

A configuração é praticamente a mesma, além do fato de que este usa wmctrle xdotool:

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

O script

#!/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

Notas

  • Embora eu esteja em execução por várias horas sem erro agora, faça um teste completo. Se um erro ocorrer, deixe um comentário.
  • O script, como funciona, funciona em uma única configuração de monitor.
Jacob Vlijm
fonte
@ rubo77 O script, como é, assume que apenas um dos aplicativos é executado por vez. Se vários aplicativos listados forem executados, ele escolherá um, para evitar muitas opções de resolução de uma vez, pois a mudança para a área de trabalho causaria uma troca de resolução. Eu posso mudar isso no entanto. Vou definir como uma opção.
Jacob Vlijm
Você pode usar este comando para descobrir o nome de um aplicativo que deseja adicionar ao arquivo de configuração: sleep 5 && cat "/proc/$(xdotool getwindowpid "$(xdotool getwindowfocus)")/comm"concentre o aplicativo em 5 segundos e obterá o nome desejado (fonte: askubuntu.com/a/508539/34298 )
rubo77
Discussão adicional no issuetracker em github.com/rubo77/set_resolution.py
rubo77 4/15/15
1
Este script tem uma atualização, que resolve um questões muito em github.com/rubo77/set_resolution.py
rubo77
você poderia, por favor, olhar para isso e me dizer se acha que está relacionado? askubuntu.com/questions/742897/...
Kalamalka Kid
3

Teste a adição à sua linha de comando java:, -Dsun.java2d.uiScale=2.0ou defina-a como o fator de escala desejado.

epineda
fonte
2

Como solução alternativa

Criei um script bash que altera a resolução para fullHD antes de iniciar o aplicativo (neste exemplo, o Android Studio) e o altera novamente para 3200x1800 quando o aplicativo é encerrado:

sudo nano /usr/local/bin/studio

Digite este 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 conceda direitos executáveis:

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

Então você pode iniciá-lo com Alt+F1 studio


Para outros fatores de redimensionamento que 2.0, consulte /ubuntu//a/486611/34298


Para ativar e desativar o zoom facilmente no Firefox, use a extensão Zoom Menu Elements

rubo77
fonte