urxvt-background - En ligne dans le Cloud

PROGRAMME:

Nom

background - gérer l'arrière-plan du terminal

SYNOPSIS

urxvt --background-expr 'expression d'arrière-plan'
--background-border
--background-interval secondes

RAPIDE ET SALE TRICHER DRAP

Il suffit de charger une image jpeg aléatoire et de mosaïquer l'arrière-plan sans mise à l'échelle ou quoi que ce soit
autre:

charger "/chemin/vers/img.jpg"

La même chose, mais utilisez la mise en miroir/réflexion au lieu de la mosaïque :

chargement miroir "/chemin/vers/img.jpg"

Chargez une image et redimensionnez-la pour remplir exactement la fenêtre du terminal :

scale keep { load "/path/to/img.jpg" loading="lazy" }

Implémentez la pseudo-transparence en utilisant un pixmap racine correctement aligné comme fenêtre
fond:

rootalign racine

De même, mais gardez une copie floue :

rootalign garder { blur 10, root }

DESCRIPTION

Cette extension gère l'arrière-plan du terminal en créant une image qui se trouve derrière le
texte, remplaçant la couleur de fond normale.

Il le fait en évaluant une expression Perl qui calcule l'image à la volée, pour
par exemple, en saisissant l'arrière-plan racine ou en chargeant un fichier.

Alors que toute la puissance de Perl est disponible, les opérateurs ont été conçus pour être aussi simples
que possible.

Par exemple, pour charger une image et la mettre à l'échelle à la taille de la fenêtre, vous utiliseriez :

urxvt --background-expr 'scale keep { load "/path/to/mybg.png" loading="lazy" }'

Ou spécifié en tant que ressource X :

URxvt.background-expr : scale keep { load "/path/to/mybg.png" loading="lazy" }

THÉORIE OF FONCTIONNEMENT

Au démarrage, juste avant que la fenêtre ne soit mappée pour la première fois, l'expression est
évalué et doit donner une image. L'image est ensuite étendue autant que nécessaire pour couvrir le
l'ensemble de la fenêtre du terminal et est défini comme image d'arrière-plan.

Si l'image contient un canal alpha, elle sera utilisée telle quelle dans les visuels prenant en charge
canaux alpha (par exemple, pour un gestionnaire de composition). Dans d'autres visuels, le terminal
la couleur d'arrière-plan sera utilisée pour remplacer toute transparence.

Lorsque l'expression repose, directement ou indirectement, sur la taille de la fenêtre, la position, la racine
pixmap, ou une minuterie, alors il sera mémorisé. Sinon, il sera supprimé.

Si l'un des paramètres sur lesquels repose l'expression change (lorsque la fenêtre est déplacée
ou redimensionné, sa position ou sa taille change ; quand le pixmap racine est remplacé par un autre
l'arrière-plan racine change ; ou lorsque la minuterie s'écoule), alors l'expression sera
évalué à nouveau.

Par exemple, une expression telle que "scale keep { load "$HOME/mybg.png" loading="lazy" }" redimensionne l'image
à la taille de la fenêtre, il dépend donc de la taille de la fenêtre et sera réévalué à chaque fois qu'il
est modifié, mais pas lorsqu'il bouge par exemple. Cela garantit que l'image se remplit toujours
le terminal, même après que sa taille ait changé.

EXPRESSIONS
Les expressions sont des expressions Perl normales, en fait, ce sont des blocs Perl - ce qui signifie que vous
peut utiliser plusieurs lignes et instructions :

garder à l'échelle {
encore 3600 ;
if (heure locale maintenant)[6]) {
charge de retour "$HOME/weekday.png" ;
} Else {
charge de retour "$HOME/sunday.png" ;
}
}

Cette expression interne est évaluée une fois par heure (et chaque fois que la fenêtre du terminal est
redimensionné). il fixe dimanche.png comme toile de fond le dimanche, et jour de la semaine.png tous les autres jours.

Heureusement, nous nous attendons à ce que la plupart des expressions soient beaucoup plus simples, avec peu de Perl
connaissances nécessaires.

Fondamentalement, vous commencez toujours par une fonction qui "génére" un objet image, comme
"load", qui charge une image depuis le disque, ou "root", qui renvoie la fenêtre racine
image de fond:

charger "$HOME/mypic.png"

Le chemin est généralement spécifié sous la forme d'une chaîne entre guillemets (les règles exactes peuvent être trouvées dans le
page de manuel perlop). Les $ ACCUEIL au début de la chaîne est étendu à la maison
répertoire.

Ensuite, vous ajoutez un ou plusieurs modificateurs ou expressions de filtrage, tels que "scale":

charge à l'échelle "$HOME/mypic.png"

Tout comme une expression mathématique avec des fonctions, vous devriez lire ces expressions à partir de
de droite à gauche, car la "charge" est évaluée en premier, et son résultat devient l'argument pour
la fonction "échelle".

De nombreux opérateurs autorisent également certains paramètres précédant l'image d'entrée qui modifient son
comportement. Par exemple, "scale" sans aucun argument supplémentaire redimensionne l'image à la taille
de la fenêtre du terminal. Si vous spécifiez un argument supplémentaire, il l'utilise comme échelle
facteur (multipliez par 100 pour obtenir un pourcentage) :

échelle 2, chargez "$HOME/mypic.png"

Cela agrandit l'image d'un facteur 2 (200%). Comme vous pouvez le voir, "scale" a maintenant deux
arguments, le 200 et l'expression "load", tandis que "load" n'a qu'un seul argument.
Les arguments sont séparés les uns des autres par des virgules.

L'échelle accepte également deux arguments, qui sont alors des facteurs séparés pour les deux
dimensions verticales. Par exemple, cela réduit de moitié la largeur de l'image et double l'image
la taille:

échelle 0.5, 2, charge "$HOME/mypic.png"

SI vous essayez ces expressions, vous pourriez souffrir d'une certaine lenteur, car chaque
fois que le terminal est redimensionné, il charge à nouveau l'image PNG et la redimensionne. La mise à l'échelle est
généralement rapide (et inévitable), mais le chargement de l'image peut prendre beaucoup de temps. C'est
où « garder » est utile :

échelle 0.5, 2, garder { load "$HOME/mypic.png" loading="lazy" }

L'opérateur "keep" exécute toutes les instructions à l'intérieur des accolades une seule fois, ou lorsqu'il
pense que le résultat pourrait changer. Dans d'autres cas, il renvoie la dernière valeur calculée par le
bloc de renfort.

Cela signifie que le "load" n'est exécuté qu'une seule fois, ce qui le rend beaucoup plus rapide, mais aussi
signifie que plus de mémoire est utilisée, car l'image chargée doit être conservée en mémoire à
chaque fois. Dans cette expression, le compromis en vaut probablement la peine.

Mais revenons aux effets : d'autres effets que la mise à l'échelle sont également facilement disponibles, par exemple,
vous pouvez mosaïquer l'image pour remplir toute la fenêtre, au lieu de la redimensionner :

tuile garder { charger "$HOME/mypic.png" loading="lazy" }

En fait, les images renvoyées par "load" sont en mode "tile" par défaut, donc l'opérateur "tile"
est un peu superflu.

Un autre effet courant consiste à refléter l'image, de sorte que les mêmes bords se touchent :

mirror keep { load "$HOME/mypic.png" loading="lazy" }

Une autre expression d'arrière-plan courante est :

rootalign racine

Celui-ci prend d'abord un instantané de l'image d'arrière-plan de l'écran, puis le déplace vers le
coin supérieur gauche de l'écran (par opposition au coin supérieur gauche du terminal
window)- le résultat est une pseudo-transparence : l'image semble statique alors que la fenêtre
est déplacé.

COULEUR DONNÉES TECHNIQUES
Chaque fois qu'un opérateur attend une "couleur", celle-ci peut être spécifiée de l'une des deux manières suivantes :
Soit sous forme de chaîne avec une spécification de couleur X11, telle que :

"rouge" # couleur nommée
"#f00" # simple RVB
"[50]rouge" # rouge avec 50% alpha
"TekHVC:300/50/50" # tout est permis

OU en tant que référence de tableau avec un, trois ou quatre composants :

[0.5] # 50% gris, 100% alpha
[0.5, 0, 0] # rouge foncé, pas de vert ni de flou, 100% alpha
[0.5, 0, 0, 0.7] # idem avec 70% alpha explicite

MISE EN CACHE ET SENSIBILITÉ
Étant donné que certaines opérations (telles que « charger » et « flou ») peuvent prendre du temps, la mise en cache des résultats
peut être très important pour un bon fonctionnement. La mise en cache peut également être utile pour réduire la mémoire
utilisation, cependant, par exemple, lorsqu'une image est mise en cache par "load", elle peut être partagée par
plusieurs fenêtres de terminal s'exécutant dans urxvtd.

"garder { ... }" la mise en cache

Le moyen le plus important de mettre en cache des opérations coûteuses est d'utiliser "keep { ... }". Le donjon"
l'opérateur prend un bloc de plusieurs instructions entouré par "{}" et conserve la valeur de retour
en mémoire.

Une expression peut être « sensible » à divers événements externes, tels que la mise à l'échelle ou le déplacement du
fenêtre, changements d'arrière-plan racine et minuteries. En utilisant simplement une expression (telle que "échelle"
sans paramètres) qui dépend de certaines valeurs changeantes (appelées "variables"), ou en utilisant
ces variables directement, rendra une expression sensible à ces événements - par exemple,
utiliser "scale" ou "TW" rendra l'expression sensible à la taille du terminal, et donc à
redimensionner les événements.

Lorsqu'un tel événement se produit, « garder » déclenchera automatiquement une réévaluation de l'ensemble
expression avec la nouvelle valeur de l'expression.

"keep" est le plus utile pour les opérations coûteuses, telles que "blur":

rootalign garder { blur 20, root }

Cela crée une copie floue de l'arrière-plan racine une fois, et lors des appels suivants, il suffit de root-
l'aligne. Étant donné que "flou" est généralement assez lent et "rootalign" est assez rapide, cela change
mémoire supplémentaire (pour la pixmap floue en cache) avec vitesse (le flou n'a besoin d'être refait que lorsque
changements de racine).

"charge" la mise en cache

L'opérateur "load" lui-même ne garde pas les images en mémoire, mais tant que l'image est
toujours en mémoire, "load" utilisera l'image en mémoire au lieu de la charger fraîchement depuis
disque.

Cela signifie que cette expression :

garder { charger "$HOME/chemin..." }

Non seulement met en cache l'image en mémoire, mais d'autres instances de terminal qui essaient de la "charger" peuvent
réutiliser cette copie en mémoire.

RÉFÉRENCE

COMMAND LINE INTERRUPTEURS
--background-expr expression-perl
Spécifie l'expression Perl à évaluer.

--background-border
Par défaut, l'expression crée une image qui remplit toute la fenêtre, écrasant
bordures et toute autre zone, telle que la barre de défilement.

Spécifier ce drapeau change le comportement, de sorte que l'image ne remplace que le
fond de la zone de caractère.

--background-interval secondes
Étant donné que certaines opérations dans l'extension XRender sous-jacente peuvent effectivement geler votre
X-server pour une durée prolongée, cette extension impose un délai minimum entre les mises à jour,
qui est normalement d'environ 0.1 seconde.

Si vous souhaitez effectuer des mises à jour plus souvent, vous pouvez diminuer cet intervalle de sécurité avec cette
interrupteur.

FOURNISSEURS/GÉNÉRATEURS
Ces fonctions fournissent une image, en la chargeant à partir du disque, en la saisissant à la racine
screen ou en le générant simplement. Ils sont utilisés comme points de départ pour obtenir une image que vous
peut jouer avec.

charger $path
Charge l'image au $path donné. L'image est définie en mode mosaïque plane.

Si l'image est déjà en mémoire (par exemple parce qu'une autre instance de terminal l'utilise),
alors la copie en mémoire est renvoyée à la place.

load_uc $chemin
Load uncached - identique à load, mais ne met pas en cache l'image, ce qui signifie qu'elle est toujours
chargé à nouveau à partir du système de fichiers, même si une autre copie est en mémoire à ce moment-là.

racine
Renvoie le pixmap de la fenêtre racine, c'est-à-dire, espérons-le, l'image de fond de votre
avec l'écran du tableau des commandes prêtes.

Cette fonction rend votre expression sensible à la racine, cela signifie qu'elle sera réévaluée
lorsque l'image bg change.

couleur unie $
solide $largeur, $hauteur, $couleur
Crée une nouvelle image et la remplit complètement avec la couleur donnée. L'image est réglée sur
mode carrelage.

Si $width et $height sont omis, cela crée une image 1x1, ce qui est utile pour les solides
arrière-plans ou pour une utilisation dans les effets de filtrage.

cloner $img
Renvoie une copie exacte de l'image. Ceci est utile si vous souhaitez avoir plusieurs copies
de la même image pour appliquer différents effets.

fusionner $img ...
Prend n'importe quel nombre d'images et les fusionne, créant une seule image
les contenant tous. Le mode de mosaïque de la première image est utilisé comme mode de mosaïque de
l'image résultante.

Cette fonction est appelée automatiquement lorsqu'une expression renvoie plusieurs images.

CARRELAGE MODES
Les opérateurs suivants modifient le mode de mosaïque d'une image, c'est-à-dire la façon dont les pixels
en dehors de la zone de l'image sont peints lorsque l'image est utilisée.

tuile $img
Mose tout le plan avec l'image et renvoie cette nouvelle image - ou en d'autres termes,
il renvoie une copie de l'image en mode mosaïque plane.

Exemple : chargez une image et placez-la en mosaïque sur l'arrière-plan, sans redimensionner. Le "tuile"
l'appel est superflu car "load" est déjà par défaut en mode mosaïque.

charge de la tuile "mybg.png"

miroir $img
Similaire au carreau, mais reflète l'image chaque fois qu'il utilise une nouvelle copie, de sorte que le haut
les bords touchent toujours les bords supérieurs, les bords droits touchent toujours les bords droits et ainsi de suite (avec
carrelage normal, les bords gauches touchent toujours les bords droits et le haut touche toujours les bords inférieurs).

Exemple : chargez une image et mettez-la en miroir sur l'arrière-plan, en évitant les bords
frontières de l'image au détriment de la mise en miroir de l'image elle-même

chargement miroir "mybg.png"

tampon $img
Prend une image et la modifie de sorte que tous les pixels en dehors de la zone d'image deviennent
transparent. Ce mode est particulièrement utile lorsque vous souhaitez placer une image sur une autre
l'image ou la couleur d'arrière-plan tout en laissant tous les pixels d'arrière-plan en dehors de l'image
inchangé.

Exemple : chargez une image et affichez-la dans le coin supérieur gauche. Le reste de l'espace
est laissé "vide" (transparent ou quoi que votre compositeur fasse en mode alpha, sinon
la couleur d'arrière-plan).

pad charger "mybg.png"

étendre $img
Étend l'image sur tout le plan, en utilisant le pixel le plus proche dans la zone à l'extérieur
l'image. Ce mode est surtout utile lorsque vous utilisez des opérations de filtrage plus complexes
et voulez que les pixels à l'extérieur de l'image aient les mêmes valeurs que les pixels près du
bord.

Exemple : juste par curiosité, comment fonctionne cette extension de pixel ?

étendre le mouvement 50, 50, charger "mybg.png"

VARIABLE VALEURS
Les fonctions suivantes fournissent des données variables telles que les dimensions de la fenêtre du terminal. Ils
ne sont pas des variables (Perl-), elles renvoient simplement des éléments qui varient. La plupart d'entre eux font de votre
expression sensible à certains événements, par exemple l'utilisation de "TW" (largeur de borne) signifie que votre
expression est à nouveau évaluée lorsque le terminal est redimensionné.

TX
TY Renvoie les coordonnées X et Y de la fenêtre du terminal (la fenêtre du terminal est la pleine
fenêtre par défaut, et la zone de caractères uniquement en mode de respect des bordures).

L'utilisation de ces fonctions rend votre expression sensible aux mouvements de fenêtre.

Ces fonctions sont principalement utiles pour aligner les images sur la fenêtre racine.

Exemple : chargez une image et alignez-la pour qu'elle semble ancrée à l'arrière-plan
(c'est exactement ce que "rootalign" fait d'ailleurs):

déplacer -TX, -TY, garder { charger "mybg.png" loading="lazy" }

TW
TH Renvoie la largeur ("TW") et la hauteur ("TH") de la fenêtre du terminal (la fenêtre du terminal
est la fenêtre complète par défaut, et la zone de caractère uniquement en cas de respect des frontières
mode).

L'utilisation de ces fonctions rend votre expression sensible aux redimensionnements de fenêtre.

Ces fonctions sont principalement utiles pour redimensionner des images, ou pour découper des images dans la fenêtre
taille pour conserver la mémoire.

Exemple : prendre le fond d'écran, le découper à la taille de la fenêtre, le flouter un peu, aligner
à la position de la fenêtre et l'utiliser comme arrière-plan.

clip déplacer -TX, -TY, garder { blur 5, root }

FOCUS
Renvoie un booléen indiquant si la fenêtre du terminal a le focus clavier, dans lequel
cas, il retourne vrai.

L'utilisation de cette fonction rend votre expression sensible aux changements de mise au point.

Un cas d'utilisation courant consiste à estomper l'image d'arrière-plan lorsque le terminal perd la mise au point, souvent
avec l'option de ligne de commande "-fade". En fait, il y a une fonction spéciale
pour ce cas d'utilisation uniquement : "focus_fade".

Exemple : utilisez deux images d'arrière-plan entièrement différentes, selon que la fenêtre
a le focus.

SE CONCENTRER ? keep { load "has_focus.jpg" loading="lazy" } : keep { load "no_focus.jpg" loading="lazy" }

now Renvoie l'heure actuelle en secondes (fractionnelles) depuis l'époque.

L'utilisation de cette expression ne pas rendre votre expression sensible au temps, mais la prochaine
deux fonctions font.

encore $ secondes
Lorsque cette fonction est utilisée, l'expression sera réévaluée à nouveau en $ secondes
secondes.

Exemple : chargez une image et faites-la pivoter selon l'heure de la journée (comme si c'était la
aiguille d'une horloge). Mettez à jour cette image toutes les minutes.

encore 60 ;
rotation 50, 50, (maintenant % 86400) * -72 / 8640, scale keep { load "myclock.png" loading="lazy" }

compteur $secondes
Comme "à nouveau", mais renvoie également une valeur de compteur croissante, commençant à 0, qui pourrait
être utile pour certains effets d'animation simples.

FORME EN CHANGEANT LES OPÉRATEURS
Les opérateurs suivants modifient la forme, la taille ou la position de l'image.

clip $ img
clip $largeur, $hauteur, $img
clip $x, $y, $largeur, $hauteur, $img
Découpe une image sur le rectangle donné. Si le rectangle est en dehors de la zone d'image
(par exemple lorsque $x ou $y sont négatifs) ou que le rectangle est plus grand que l'image, alors le
le mode mosaïque définit comment les pixels supplémentaires seront remplis.

Si $x et $y sont manquants, alors 0 est supposé pour les deux.

Si $width et $height sont manquants, la taille de la fenêtre sera prise en compte.

Exemple : chargez une image, floutez-la et coupez-la à la taille de la fenêtre pour économiser de la mémoire.

clip keep { blur 10, load "mybg.png" loading="lazy" }

échelle $img
échelle $size_factor, $img
échelle $width_factor, $height_factor, $img
Met l'image à l'échelle selon les facteurs donnés en horizontal ($largeur) et vertical ($hauteur)
direction.

Si un seul facteur est donné, il est utilisé dans les deux sens.

Si aucun facteur n'est donné, redimensionne l'image à la taille de la fenêtre sans conserver l'aspect.

redimensionner $largeur, $hauteur, $img
Redimensionne l'image à exactement $largeur fois $hauteur pixels.

adapter $img
adapter $largeur, $hauteur, $img
Ajuste l'image dans la largeur $ et la hauteur $ sans changer d'aspect, ou le
taille des bornes. Cela signifie qu'elle sera réduite ou agrandie jusqu'à ce que l'image entière s'intègre dans
la zone donnée, en laissant éventuellement des frontières.

couvrir $img
couvrir $largeur, $hauteur, $img
Similaire à "fit", mais se rétrécit ou s'agrandit jusqu'à ce que toute la zone soit couverte par l'image,
donc au lieu de potentiellement laisser des bordures, il coupera les données d'image qui ne
en forme.

déplacer $dx, $dy, $img
Déplace l'image de $dx pixels horizontalement et de $dy pixels verticalement.

Exemple : déplacez l'image vers la droite de 20 pixels et vers le bas de 30 pixels.

déplacer 20, 30, ...

aligner $xalign, $yalign, $img
Aligne l'image selon un facteur - 0 signifie que l'image est déplacée vers la gauche ou le haut
edge (pour $xalign ou $yalign), 0.5 signifie qu'il est exactement centré et 1 signifie qu'il touche
le bord droit ou inférieur.

Exemple : supprimer toute bordure visible autour d'une image, la centrer verticalement mais la déplacer
vers le côté droit.

aligner 1, 0.5, tamponner $img

centre $img
centre $largeur, $hauteur, $img
Centre l'image, c'est-à-dire que le centre de l'image est déplacé vers le centre du terminal
window (ou la boîte spécifiée par $width et $height si elle est donnée).

Exemple : chargez une image et centrez-la.

center keep { pad load "mybg.png" loading="lazy" }

aligner la racine $ img
Déplace l'image pour qu'elle apparaisse collée à l'écran par opposition à la fenêtre. Cette
donne l'illusion d'une plus grande surface derrière la fenêtre. C'est exactement équivalent à
"move -TX, -TY", c'est-à-dire qu'il déplace l'image en haut à gauche de l'écran.

Exemple : chargez une image de fond, mettez-la en mode miroir et alignez-la à la racine.

rootalign keep { mirror load "mybg.png" loading="lazy" }

Exemple : prendre le fond d'écran et l'aligner, donnant l'illusion de la transparence
tant que la fenêtre n'est pas devant d'autres fenêtres.

rootalign racine

faire pivoter $center_x, $center_y, $degrés, $img
Fait pivoter l'image dans le sens des aiguilles d'une montre de $ degrés degrés, autour du point à $center_x et
$center_y (spécifié comme facteur de largeur/hauteur de l'image).

Exemple : faites pivoter l'image de 90 degrés autour de son centre.

faire pivoter 0.5, 0.5, 90, garder { load "$HOME/mybg.png" loading="lazy" }

COULEUR MODIFICATIONS
Les opérateurs suivants modifient les pixels de l'image.

teinte $couleur, $img
Teinte l'image dans la couleur donnée.

Exemple : teinter l'image en rouge.

teinte "rouge", charge "rgb.png"

Exemple : idem, mais précisez la couleur par composant.

teinte [1, 0, 0], charge "rgb.png"

ombre $facteur, $img
Ombrez l'image par le facteur donné.

contraste $factor, $img
contraste $r, $g, $b, $img
contraste $r, $g, $b, $a, $img
Ajuste le contraste d'une image.

La première forme applique un seul facteur $ au rouge, au vert et au bleu, la seconde forme
applique des facteurs séparés à chaque canal de couleur, et la dernière forme inclut l'alpha
canal.

Les valeurs de 0 à 1 diminuent le contraste, les valeurs supérieures à 1 augmentent le contraste.

En raison des limitations de l'extension XRender sous-jacente, la réduction du contraste réduit également
luminosité, tandis que l'augmentation du contraste augmente actuellement également la luminosité.

luminosité $bias, $img
luminosité $r, $g, $b, $img
luminosité $r, $g, $b, $a, $img
Ajuste la luminosité d'une image.

La première forme applique un seul $bias au rouge, vert et bleu, la deuxième forme s'applique
des biais séparés pour chaque canal de couleur, et la dernière forme inclut le canal alpha.

Les valeurs inférieures à 0 réduisent la luminosité, tandis que les valeurs supérieures à 0 l'augmentent. Utile
la plage est de -1 à 1 - la première donne une image noire, la seconde une image blanche.

En raison des particularités de l'extension XRender sous-jacente, des biais inférieurs à zéro peuvent
be très lent.

Vous pouvez également essayer l'opérateur expérimental (!) "muladd".

muladd $mul, $add, $img # EXPÉRIMENTAL
Multiplie d'abord les pixels par $mul, puis ajoute $add. Cela peut être utilisé pour mettre en œuvre
luminosité et contraste en même temps, avec une plage de valeurs plus large que le contraste et
opérateurs de luminosité.

En raison de nombreux bogues dans les implémentations de XRender, il peut également introduire un certain nombre de
artefacts visuels.

Exemple : augmenter le contraste d'un facteur de $c sans modifier également la luminosité de l'image
beaucoup.

muladd $c, (1 - $c) * 0.5, $img

flou $rayon, $img
flou $radius_horz, $radius_vert, $img
Un flou gaussien de l'image avec (approximativement) un rayon de pixel de $radius. Les rayons peuvent aussi être
spécifiés séparément.

Le flou est souvent très opérateurs lents, au moins comparés ou autres. Rayons de flou plus grands
sont aussi plus lents que les plus petits, donc si vous ne voulez pas geler votre écran pendant longtemps
fois, commencez à expérimenter avec des valeurs faibles pour le rayon (<5).

focus_fade $ img
focus_fade $facteur, $img
focus_fade $facteur, $couleur, $img
Estompe l'image du facteur (et de la couleur) donné lorsque la mise au point est perdue (le même que le
Options de ligne de commande "-fade"/"-fadecolor", qui fournissent également les valeurs par défaut pour
"facteur" et $color. Contrairement à "-fade", le facteur $ est une valeur réelle, pas un
valeur en pourcentage (c'est-à-dire 0..1, pas 0..100).

Exemple : faites ce qu'il faut lorsque le fondu de mise au point est demandé.

focus_fade charger "mybg.jpg" ;

AUTRES STUFF
Tout ce qui ne correspond à aucune des autres catégories, même après avoir appliqué la force et
fermant les yeux.

garder { ... }
Cet opérateur prend un bloc de code comme argument, c'est-à-dire une ou plusieurs instructions incluses
par des accolades.

L'astuce est que ce bloc de code n'est évalué que lorsque le résultat change - sur
other appelle le "keep" renvoie simplement l'image qu'il a calculée précédemment (oui, il devrait
être utilisé uniquement avec des images). Ou en d'autres termes, "garder" caches le résultat du code
bloc afin qu'il n'ait pas besoin d'être recalculé.

Cela peut être extrêmement utile pour éviter de refaire des opérations lentes - par exemple, si votre
l'expression d'arrière-plan prend l'arrière-plan racine, le brouille puis l'aligne à la racine
devrait brouiller l'arrière-plan de la racine à chaque déplacement ou redimensionnement de la fenêtre.

Un autre exemple est "load", qui peut être assez lent.

En fait, urxvt lui-même enferme l'expression entière dans une sorte de bloc « garder » afin qu'il
seulement est réévalué au besoin.

Mettre le flou dans un bloc "garder" garantira que le flou n'est fait qu'une seule fois, tandis que
le "rootalign" est toujours fait à chaque déplacement de la fenêtre.

rootalign garder { blur 10, root }

Reste la question de savoir comment forcer la réévaluation du bloc, au cas où la racine
changements d'arrière-plan : si l'expression à l'intérieur du bloc est sensible à un événement (root
changements d'arrière-plan, changements de géométrie de la fenêtre), puis il sera réévalué
automatiquement selon les besoins.

Utilisez urxvt-background en ligne en utilisant les services onworks.net