Anzeige automatisch klonen

Hallo STefan, habe hier: Bionic-Client: Bildschirme steuern in v7 im Thread für v7 mal dasselbe versucht und bin nach reichlich probieren mit deinem Skript zufrieden. Vielen Dank! Ich habe die SChleifen etwas angepasst, aber den rescale-mechanismus nicht angefasst und poste es mal hier:

#!/bin/bash                                                                                                                                                                             

# xrandr-video-clone                                                                                                                                                                    
#                                                                                                                                                                                       
# Speicherort: /opt/videosettings/xrandr-video-clone.sh                                                                                                                                 
#                                                                                                                                                                                       
# Stellt die maximale Bildschirmauflösung für 1 Anzeigegerät ein und skaliert die anderen Anzeigegeräte ohne Bildverzerrung.                                                            
# Durch erneutes Starten wird das nächste Anzeigegerät als jenes mit der nativen Bildschirmauflösung ausgewählt                                                                         
#                                                                                                                                                                                       
# Linux Mint 17.0 Xfce 64bit                                                                                                                                                            
# Linux Mint 18.2 Xfce 64bit                                                                                                                                                            
# Ubuntu Bionic 18.04 64bit                                                                                                                                                             
#                                                                                                                                                                                       
# Sen 2017-12-12                                                                                                                                                                        
# T.Küchel 2019-09-30                                                                                                                                                                   
# GPL v3                                                                                                                                                                                

### Shortcut setzen, um Skript per Shortcut aufrufen zu können (NUR FÜR XFCE-Desktop)                                                                                                   
# xfconf-query -c xfce4-keyboard-shortcuts -p "/commands/custom/<Primary><Alt>r" -n -t string -s "/opt/videosettings/xrandr-video-clone.sh"                                             

outputfile=`mktemp`
logger -t "$0[$USER]" "Output in $outputfile"

### Ermitteln der angeschlossenen Anzeigeräte und der jewiligen ersten nativen Auflösung                                                                                                
xrandr --query --verbose > $outputfile
## Fehlerhaftes xrandr (z.B. kein DISPLAY) abfangen                                                                                                                                     
[ $? -ne 0 ] && { echo usage: $0 ;  exit 1;  }
## Zeilenanzahl                                                                                                                                                                         
za=`cat $outputfile | wc -l`
nmbr=0
z=0

# Äußere Schleife über alle Zeilen von $outputfile                                                                                                                                      
while read line1; do
    ((z++))
    ## need the lines with either "connected" or "disconnected"                                                                                                                         
    if echo $line1 | grep -i "connected"  >/dev/null ; then
        vo=$(echo -n $line1 | cut -d " " -f 1)
        vo_state=$(echo -n $line1 | cut -d " " -f 2)
        if [ "$vo_state" = "connected" ] ; then

            ## maximale gemeinsame Auflösung, wenn es mehr als ein Display gibt (Danke, @Sven)                                                                                          
            MAXAUFLOESUNG=$(xrandr --query | awk '/^ *[0-9]*x[0-9]*/{ print $1 }' | sort -n | uniq -d | tail -1)
            if [ -z "$MAXAUFLOESUNG" ]; then
                MAXAUFLOESUNG=$(xrandr --query | awk '/^ *[0-9]*x[0-9]*/{ print $1 }' | sort -n | tail -1)
            fi

            ## Standardauflösung finden                                                                                                                                                 
            preferredfile=`mktemp`
            unset vo_res
            # Innere Schleife, um die nachfolgenden Zeilen nach der bevorzugten Auflösung zu durchsuchen                                                                                
            while [ "$vo_res" = '' ] ; do
                ((z++))
                cat $outputfile | sed -n `echo $z`p > $preferredfile
                line2=$(cat $preferredfile)
                if echo $line2 | grep -i "preferred" >/dev/null; then
                    vo_res=$(echo -n $line2 | cut -d " " -f 1)
                fi
                #vo_res=`cat /tmp/xrandr-video-clone.ln2  | grep -e \+preferred$ -e \+preferred[[:space:]] | awk '{print $1}'`                                                          
                # Endlosschleife bei fehlerhafter Ausgabe von xrandr vermeiden                                                                                                          
                if [ "$z" -gt 1000 ] ; then
                    echo "no preferred resolution found"
                    break
                fi
            done
            rm -f $preferredfile

            ## Bezeichnungen des angeschlossenen Anzeigeräts speichern                                                                                                                  
            disp[nmbr]=$vo
            echo "Angeschlossenes Anzeigegerät Nr.$nmbr: ${disp[nmbr]}"
            logger -t "$0[$USER]" "Angeschlossenes Anzeigegerät Nr.$nmbr: ${disp[nmbr]}"
            # Native Auflösungen des angeschlossenen Anzeigeräts speichern                                                                                                              
            natres[nmbr]=$vo_res
            natresx[nmbr]=$(echo $vo_res | cut -dx -f1)
            natresy[nmbr]=$(echo $vo_res | cut -dx -f2)
            echo "Bevorzugte Auflösung: xres: ${natresx[nmbr]}, yres: ${natresy[nmbr]}"
            echo "Maximale (gemeinsame) Auflösung: $MAXAUFLOESUNG"
            echo "--------------"
            maxres[nmbr]=$MAXAUFLOESUNG
            maxresx[nmbr]=$(echo $MAXAUFLOESUNG | cut -dx -f1)
            maxresy[nmbr]=$(echo $MAXAUFLOESUNG | cut -dx -f2)
            # Höchste Nummer der angeschlossenen Anzeigeräte speichern (beginnend mit 0)                                                                                                
            dispmaxnumb=$nmbr
            # Zähler erhöhen                                                                                                                                                            
            nmbr=$((nmbr + 1))
            # Anzahl der angeschlossenen Anzeigeräte speichern (beginnend mit 1)                                                                                                        
            dispcon=$nmbr
        fi
    fi
done < $outputfile
rm -f $outputfile
echo "Höchste Nr. der angeschlossenen Anzeigegeräte: $dispmaxnumb"
logger -t "$0[$USER]" "Höchste Nr. der angeschlossenen Anzeigegeräte: $dispmaxnumb"
echo "Anzahl der angeschlossenen Anzeigegeräte: $dispcon"
logger -t "$0[$USER]" "Anzahl der angeschlossenen Anzeigegeräte: $dispcon"

### Fallunterscheidung falls nur 1 Anzeigegerät angeschlossen ist                                                                                                                       
case $dispcon in
    1)
        ### Ein Anzeigegerät angeschlossen                                                                                                                                              
        # Standardauflösung einstellen                                                                                                                                                  
        #xrandr --output ${disp[0]} --mode ${natres[0]} --scale 1x1                                                                                                                     
        # Maximalauflösung einstellen                                                                                                                                                   
        xrandr --output ${disp[0]} --mode ${maxres[0]} --scale 1x1
        ;;
    2-9)
        ### Mehrere Anzeigegeräte angeschlossen                                                                                                                                         
        # Zähler für natives Anzeigegerät                                                                                                                                               
        numb=$(head -n 1 /tmp/xrandr-video-clone.log)
        # Zähler erhöhen                        
        numb=$((numb + 1))
        # Zähler überprüfen und gegebenenfalls zurücksetzen                                                                                                                             
        [[ ! $numb = [0-$dispmaxnumb] ]] && numb=0
        # Zähler in Datei schreiben                                                                                                                                                     
        echo $numb > /tmp/xrandr-video-clone.log
        # Zähler für anzupassende Anzeigegeräte                                                                                                                                         
        for ((i=0; i<$dispcon; i++)) ; do
            if [ ! $i = $numb ] ; then
                # Anzupassenden Anzeigemodus berechnen                                                                                                                                  
                quotx=$(echo "scale=8; ${natresx[$numb]} / ${natresx[$i]}" | bc -l)
                echo "xopt: ${natresx[$numb]}"
                echo "xtofit: ${natresx[$i]}"
                echo "xquot: $quotx"
                quoty=$(echo "scale=8; ${natresy[$numb]} / ${natresy[$i]}" | bc -l)
                echo "yopt: ${natresy[$numb]}"
                echo "ytofit: ${natresy[$i]}"
                echo "yquot: $quoty"
                if ( expr $quotx \> $quoty >/dev/null ) ; then
                    echo "xquot>yquot"
                    fitresx[$i]=${natresx[$i]}
                    fitresy[$i]=$(echo "scale=0; ${natresx[$i]} * ${natresy[$numb]} / ${natresx[$numb]}" | bc -l)
                    echo "xfit: ${fitresx[$i]}"
                    echo "yfit: ${fitresy[$i]}"
                else
                    echo "yquot>xquot"
                    fitresy[$i]=${natresy[$i]}
                    fitresx[$i]=$(echo "scale=0; ${natresy[$i]} * ${natresx[$numb]} / ${natresy[$numb]}" | bc -l)
                    echo "xfit: ${fitresx[$i]}"
                    echo "yfit: ${fitresy[$i]}"
                fi
                fitmodeline[$i]=$(cvt ${fitresx[$i]} ${fitresy[$i]} | grep Modeline | cut -d\" -f2,3 | sed 's/\"//g')
                fitmode[$i]=$(cvt ${fitresx[$i]} ${fitresy[$i]} | grep Modeline | cut -d\" -f2)
                echo "fitmodeline: ${fitmodeline[$i]}"
                echo "fitmode: ${fitmode[$i]}"
                # Berechneten Anzeigemodus registrieren                                                                                                                                 
                echo "Befehlszeile: xrandr --newmode ${fitmodeline[$i]}"
                xrandr --newmode ${fitmodeline[$i]}
                echo "Befehlszeile: xrandr --addmode ${disp[$i]} ${fitmode[$i]}"
                xrandr --addmode ${disp[$i]} ${fitmode[$i]}
                # Anzeige klonen                                                                                                                                                        
                echo "Befehlszeile: xrandr --output ${disp[$numb]} --mode ${natres[$numb]} --scale 1x1 --output ${disp[$i]} --same-as ${disp[$numb]} --mode ${fitmode[$i]} --scale-from\
 ${natres[$numb]}"
                xrandr --output ${disp[$numb]} --mode ${natres[$numb]} --scale 1x1 --output ${disp[$i]} --same-as ${disp[$numb]} --mode ${fitmode[$i]} --scale-from ${natres[$numb]}
            fi
        done
        ;;
    *)
        echo "Mehr als 9 Anzeigegeräte vorsichtshalber nicht unterstützt. Kann man sicher machen..."
        ;;
esac

### Benachrichtigung anzeigen                                                                                                                                                           
notify-send -t 8700 "Optimiert für Anzeige ${disp[$numb]}"
logger -t "$0[$USER]" "Optimiert für Anzeige ${disp[$numb]}"

exit 0

VG, Tobias

2 „Gefällt mir“