#Fichier ". conkyrc " placé dans /home/utilisateur/
Testé sur UbuntuMate & AntiX. peut-être que cela fonctionne sur tout les dérivé de Debian
ce qui suis
Example: l'ancienne version avec les dièse(# H tag en anglais) pour commenter.
Lua: la nouvelle façon que j’ai testé & donc qui fonctionnai a ce moment la. entre 2023-11-05 2024-01-08
lors qu'il y a: ???????????????????? cela signifie que j’ai échouer a le faire fonctionner, voir que je n'ai même pas essayé. :-/
Source : http://www.ifxgroup.net/conky.htm#p1
Traduction : par reverso pour le plus gros.
&: cette lettre "l'esperluette" est une ligature d'un '"e" et d'un "t" elle signifie "et puis". Présent dans Unicode depuis : 1.1
ȣ: cette lettre le "ou" Du bloc latin est une ligature d'un '"o" et d'un "u" je l'emploie pour "ou bien".Présent dans Unicode depuis : 3.0
Commandes du fichier de configuration Conky:
#~ Le ȣ les fichiers de configuration Conky peuvent être placés n’importe où. La valeur par défaut est "$HOME/. config/conky/conky.conf"
#~ (dans votre répertoire personnel) ȣ "${sysconfdir}/conky/conky.conf" (sur la plupart des systèmes, sysconfdir est /etc).
#~ La configuration est définie dans un fichier texte avec deux parties principales divisées par une ligne avec le mot "TEXT".
#~ En Lua la nouvelle syntaxe est ainsi.
conky.config = {
les trucks avant text = machin,
ȣ les trucks avant text = 'machin',
-- les trucks avant text = machin commentés,
}
conky.text = [[
${les truk aprés text} avec ȣ sans les accolades ({})
$les truk aprés text
#~ ${les truk aprés text commenté}
]]
alignment:
#~ Position alignée sur l’écran, peut être:
#~ top_left, top_right, top_middle, bottom_left, bottom_right, bottom_middle, middle_left, middle_middle, middle_right, ȣ aucun
#~ (peut également être abrévié en tl, tr, tm, bl, br, bm, ml, mm, mr). Voir aussi gap_x & gap_y.
Example: #alignment top_left
alignment top_right
#alignment bottom_left
#alignment bottom_right
#alignment none
Lua: alignment = top_left,
alignment = top_right,
alignment = bottom_left,
alignment = bottom_right,
alignment = none,
append_file:
#~ Ajoutez le fichier donné en argument.
Example: append_file /home/user/.config/conky/common.conf
Lua: append_file = /home/user/.config/conky/common.conf,
background:
#~ Valeur booléenne. Si vrai, Conky est dérivé vers un processus d'arrière-plan lorsqu'il est démarré.
Example: background yes
Lua: background = true,
#~ true ȣ false
border_inner_margin:
#~ La marge de bordure intérieure en pixels est la marge entre la bordure & le texte.
Example: border_inner_margin 0
Lua: border_inner_margin = 10,
border_outer_margin:
#~ Bordure extérieure en pixels (la marge entre la bordure & le bord de la fenêtre).
Example: border_outer_margin 10
Lua: border_outer_margin = 10,
border_width:
#~ Largeur de bordure en pixels.
Example: border_width 0
Lua: border_width = 2,
colorN:
#~ Prédéfinir une couleur à utiliser dans les segments TEXT. Remplacer N par un chiffre compris entre 0 & 9.
#~ Lorsque vous spécifiez la valeur de couleur en hexadécimal, omettez le hachage principal (#).
Example: color8 3c3b37
Lua: color8 = 3c3b37,
TEXT
Example: ${color8}tatata $color
Lua: ${color8}tatata $color
cpu_avg_samples:
#~ Nombre moyen d’échantillons pour la surveillance du CPU.
Example: cpu_avg_samples 2
Lua: cpu_avg_samples = 2,
default_bar_size:
#~ Spécifiez une largeur & une hauteur par défaut pour les barres.
#~ L'exemple suivant est particulièrement utile pour execbar & execibar car ils ne prennent pas d'arguments de taille.
Example: default_bar_size 100 8
Lua: ?????
default_color:
#~ Couleur & couleur de bordure par défaut
Example: default_color FFFFFFF
Lua: default_color = 'white',
default_gauge_size:
#~ Spécifiez une largeur & une hauteur par défaut pour les jauges en pixels.
#~ Ceci est particulièrement utile pour execgauge & execigauge car ils ne prennent pas d'arguments de taille.
Example: default_gauge_size 25 8
Lua: ????
default_graph_size:
#~ Spécifiez une largeur & une hauteur par défaut pour les graphiques.
#~ Ceci est particulièrement utile pour execgraph & execigraph car ils ne prennent pas d'arguments de taille.
Example: default_graph_size 100 8
Lua: ????????
default_outline_color:
#~ Couleur de contour par défaut
Example: default_outline_color green
Lua: default_outline_color = '000000',
default_shade_color:
#~ Couleur d’ombrage par défaut & couleur d’ombrage de la bordure
Example: default_shade_color red
Lua: default_shade_color = '3C3B37',
disable_auto_reload:
#~ Activer pour désactiver la fonction de rechargement automatique de la configuration basée sur l’inotify.
Example: disable_auto_reload yes
Lua: disable_auto_reload = true,
diskio_avg_samples:
#~ Nombre moyen d’échantillons pour la surveillance des Entrées/Sorties disque.
Example: diskio_avg_samples 2
Lua: diskio_avg_samples = 4,
display:
#~ Spécifiez un écran X à connecter.
Example: display 1
Lua: ??????????????
double_buffer:
#~ Utiliser l’extension Xdbe ? (élimine le scintillement) Il est fortement recommandé
#~ d’utiliser sa propre fenêtre avec celle-ci pour que le double tampon ne soit pas trop gros.
Example: double_buffer yes
Lua: double_buffer = true,
draw_borders:
#~ Tracer des frontières autour du texte ?
Example: draw_borders no
Lua: draw_borders = true,
draw_graph_borders:
#~ Tracer des frontières autour des graphiques ?
Example: draw_graph_borders yes
Lua: draw_graph_borders = true,
draw_outline:
# afficher des contours au texte ȣ Dessiner des nuances au texte
Example: draw_outline yes
Lua: draw_outline = true,
draw_shades:
# Permet d'afficher les ombres au texte ȣ non
Example: draw_shades yes
Lua: draw_shades = true,
extra_newline:
#~ Mettez une nouvelle ligne supplémentaire à la fin lorsque vous écrivez à stdout, utile pour écrire à impressionnant wiboxes.
Example: extra_newline no
Lua: extra_newline = false,
font:
#~ Définissez le nom de police par défaut à utiliser dans X. Il y a trois parties.
#~ Nom de la police - Le nom de la police tel qu'il apparaît dans votre système.
#~ Le programme xfontsel peut être utilisé pour trouver une belle police installée sur votre système.
#~ [size=] - [optionnel] La taille souhaitée de la police en pixels.
#~ [weight] - [optionnel] Le poids de la police. Par exemple : gras, normal
#~ Si une ȣ les deux parties facultatives sont données, un caractère deux-points doit être utilisé pour séparer les parties.
Example: font Z003:size=11:bold
Lua: font = 'Ubuntu Mono:size=9:bold',
format_human_readable:
#~ Si cette option est activée, les valeurs qui sont en octets seront imprimées en format lisible par l’homme (c.-à-d. KiB, MiB, etc.).
#~ Si désactivé, le nombre d’octets est imprimé à la place.
Example: format_human_readable yes
Lua: format_human_readable = true,
gap_x:
#~ Écart, en pixels, entre la bordure droite ȣ gauche de l’écran, comme passer -x en ligne de commande, p.ex. gap_x 10.
#~ Pour d’autres informations relatives à la position, voir 'alignement'.
Example: gap_x 10
Lua: gap_x = 10,
gap_y:
#~ Écart, en pixels, entre la bordure supérieure ȣ inférieure de l’écran, comme si on passait -y en ligne de commande, p.ex. gap_y 10.
#~ Pour d’autres informations relatives à la position, voir 'alignement'.
Example: gap_y 10
Lua: gap_y = 70,
hddtemp_host:
#~ Nom d’hôte auquel se connecter pour les objets hddtemp. Par défaut "127.0.0.1".
Example: hddtemp_host 127.0.0.1
Lua: hddtemp_host = 127.0.0.1,
hddtemp_port:
#~ Port à utiliser pour les connexions hddtemp. Par défaut : 7634.
Example: hddtemp_port 7634
Lua: hddtemp_port = 7634,
if_up_strictness:
#~ Dans quelle mesure if_up doit-il être strict lors du test d’une interface pour être en place ?
#~ La valeur est une de haut, lien ȣ adresse, pour vérifier que l’interface est uniquement en haut,
#~ être en haut & avoir un lien ȣ être en haut, avoir un lien & une adresse IP attribuée.
#~ up = l'interface est connectée
#~ link = l'interface a un lien (vers hub, switch, modem, etc.)
#~ adresse = l'interface a une adresse IP assignée
Example: if_up_strictness address
Lua: if_up_strictness = address,
imap:
#~ Serveur IMAP global par défaut. Les arguments sont :
#~ "host user pass [-i interval (in seconds)] [-f 'folder'] [-p port] [-e 'command'] [-r retries]".
#~ Le port par défaut est 143, le dossier par défaut est 'INBOX', l’intervalle par défaut est de 5 minutes,
#~ & le nombre de tentatives par défaut avant l’abandon est de 5.
#~ Si le mot de passe est '*', vous serez invité à entrer le mot de passe lorsque Conky démarre.
Example: imap mailserver.example.com user password -i 60 -f "home" -r 5
Lua: ?????????
le mot de passe doit être en clair ȣ il faut le tape incessamment.
imlib_cache_flush_interval:
#~ Intervalle (en secondes) pour vider le cache Imlib2.
# Mettre à jour l'image toutes les 5 minutes
Example: imlib_cache_flush_interval 300
Lua: ?????????????
imlib_cache_size:
#~ Taille du cache d’image Imlib2, en octets. Par défaut 4MiB = 4096 o. Augmentez cette valeur si vous utilisez $image lots.
#~ Définissez à 0 pour désactiver le cache d’image.
Example: imlib_cache_size 4096
Lua:?????
lua_draw_hook_post:
#~ Cette fonction, si elle est définie, sera appelée par Conky à chaque itération après le dessin à la fenêtre.
#~ Nécessite le support de X. Prend n’importe quel nombre d’arguments optionnels.
#~ Utilisez ce crochet pour dessiner des choses sur ce que Conky dessine.
#~ Conky place 'conky_' devant function_name pour éviter les appels accidentels à la mauvaise fonction, sauf si vous placez vous-même 'conky_'.
Example: lua_draw_hook_post conky_my_overlay
Lua:????????????
lua_draw_hook_pre:
#~ Cette fonction, si elle est définie, sera appelée par Conky à chaque itération avant de dessiner dans la fenêtre.
#~ Nécessite le support de X. Prend n’importe quel nombre d’arguments optionnels.
#~ Utilisez ce crochet pour dessiner des choses sur ce que Conky dessine.
#~ Conky place 'conky_' devant function_name pour éviter les appels accidentels à la mauvaise fonction, sauf si vous placez vous-même 'conky_'.
Example: lua_draw_hook_pre conky_my_background
Lua:???????????
lua_load:
#~ Charge les scripts Lua séparés par des espaces.
Example: lua_load ~/.config/conky/scripts/example.lua ~/.config/conky/scripts/example2.lua
Lua:?????????????
lua_shutdown_hook:
#~ Cette fonction, si elle est définie, sera appelée par Conky à l’arrêt ȣ lorsque la configuration est rechargée.
#~ Utilisez ce crochet pour nettoyer après vous-même, comme libérer la mémoire qui a été allouée par les bibliothèques externes via Lua.
#~ Conky place 'conky_' devant function_name pour éviter les appels accidentels à la mauvaise fonction, sauf si vous placez vous-même 'conky_'.
Example: lua_shutdown_hook conky_my_cleanup
Lua:???????????
lua_startup_hook:
#~ Cette fonction, si elle est définie, sera appelée par Conky au démarrage ȣ lorsque la configuration est rechargée.
#~ Utilisez ce crochet pour initialiser les valeurs ȣ pour n’importe quelle application.
#~ Conky place 'conky_' devant function_name pour éviter les appels accidentels à la mauvaise fonction, sauf si vous placez vous-même 'conky_'.
Example:
lua_startup_hook conky_my_wakeup
# Idem à
lua_startup_hook my_wakeup
Lua:???????????
mail_spool:
#~ Bobine de courrier pour la vérification du courrier
Example: mail_spool $MAIL
Lua:??????????
max_port_monitor_connections:
#~ Permettre à chaque moniteur de port de suivre au maximum ces nombreuses connexions (si 0 ȣ non défini, la valeur par défaut est 256)
Example: max_port_monitor_connections 256
Lua:??????????????
max_specials:
#~ Nombre maximal de choses spéciales, p. ex., polices, décalages, alignements, etc. (la valeur par défaut est 512)
Example: max_specials 512
Lua: ????????????????
max_text_width:
#~ Lorsqu’une ligne de la sortie contient des caractères 'width' & que la fin n’est pas atteinte, le caractère suivant commence sur une nouvelle ligne.
#~ Si vous voulez vous assurer que les lignes ne sont pas brisées, réglez 'width' à 0
Example: max_text_width 0
Lua: max_text_width = 100,
max_user_text:
#~ Taille maximale du tampon de texte de l’utilisateur, c.-à-d. disposition sous la ligne TEXT dans le fichier de configuration (par défaut, 16384 octets)
Example: max_user_text 16384
Lua: max_user_text = 26384,
# Taille minimale de la zone de texte (hauteur=height & largeur=width)
minimum_height:
#~ hauteur minimale
Example: minimum_height 200
Lua: minimum_height = 100,
minimum_width:
#~ largeur minimale
Example: minimum_width 200
Lua: minimum_width = 200,
minimum_size:
#~ Taille minimale de la fenêtre Permet de fixer la taille minimum de Conky (1ere valeur : largeur, 2eme valeur : hauteur)
Example: minimum_size 400 800
Lua: ???????????
mpd_host:
#~ Hôte du serveur MPD (Music Player Daemon)
Example: mpd_host 127.0.0.1
Lua: ??????????????
mpd_password:
#~ Mot de passe du serveur MPD (Music Player Daemon)
Example: mpd_password pass
Lua: ????????
mpd_port:
#~ Port du serveur MPD (Music Player Daemon)
Example: mpd_port 6600
Lua: ?????????????
music_player_interval:
#~ Intervalle de mise à jour du thread du lecteur de musique (par défaut à l’intervalle de mise à jour de Conky)
Example: music_player_interval 1
Lua: ???????????
net_avg_samples:
#~ Le nombre d’échantillons à faire la moyenne pour les données nettes
Example: net_avg_samples 2
Lua: net_avg_samples = 2,
no_buffers:
# Soustraire les tampons du système de fichiers de la mémoire utilisée ?
Example: no_buffers yes
Lua: no_buffers = true,
nvidia_display:
#~ L’affichage que la variable nvidia utilisera (par défaut la valeur de la variable d’affichage)
Example: nvidia true
Lua: nvidia = yes,
on_bottom: ??????
#~ Permet de laisser conky toujours derrière les fenêtres ȣ non
Example: on_bottom yes
Lua: on_bottom = yes,
out_to_console:
#~ Imprimer le texte sur stdout. ???
Example: out_to_console no
Lua: ?????????????
out_to_ncurses:
#~ Imprimez du texte dans la console, mais utilisez ncurses pour que conky puisse imprimer le texte d’une nouvelle mise à jour sur l’ancien texte.
#~ (À l’avenir, cela fournira des choses plus utiles)
Example: out_to_ncurses no
Lua: ???????????????
out_to_stderr:
#~ Imprimer le texte sur stderr.
Example: out_to_stderr no
Lua: ????????????
out_to_x:
#~ Si la valeur est non, il n’y aura pas de sortie dans X (utile lorsque vous utilisez aussi des choses comme out_to_console).
#~ Si vous le définissez à non, assurez-vous qu’il est placé avant tous les autres paramètres X
#~ (prenez la première ligne de votre configfile pour être sûr). La valeur par défaut est oui
Example: out_to_x yes
Lua: out_to_x = false,
override_utf8_locale:
# Force UTF8? nécessite XFT
Example: override_utf8_locale yes
Lua: override_utf8_locale = true,
overwrite_file:
#~ Écraser le fichier donné en argument.
Example: overwrite_file ~/example.log
Lua: ?????????
own_window:
#~ Booléen, créer sa propre fenêtre pour dessiner ?
Example: own_window yes
Lua: own_window = true,
own_window_class:
#~ Définissez manuellement le nom WM_CLASS. Par défaut à "Conky".
Example: own_window_class Conky
Lua: own_window_class = 'ConKii',
own_window_colour:
#~ Si own_window_transparent no, définissez une couleur d’arrière-plan spécifiée (par défaut en noir).
#~ Prend une valeur hexadécimale (par ex. ffffff, notez l’absence de dièse'#') ȣ un nom RVB valide (voir /usr/lib/X11/rgb.txt)
Example: own_window_colour 3c3b37
Lua: own_window_colour = '3c3b37',
Lua: own_window_colour = 'brown',
own_window_hints:
#~ Si own_window est oui, vous pouvez utiliser ces conseils de gestionnaire de fenêtres pour affecter l’affichage de Conky.
#~ Notes : Utilisez own_window_type desktop comme autre moyen d’implémenter plusieurs de ces conseils implicitement.
#~ Si vous utilisez own_window_type override, les conseils du gestionnaire de fenêtres n’ont aucun sens & sont ignorés.
#~ 'undecorated', 'below', 'above', 'sticky', 'skip_taskbar', 'skip_pager'
Example: own_window_hints undecorated,below,above,sticky,skip_taskbar,skip_pager
Lua: own_window_hints = 'undecorated', 'below', 'above', 'sticky', 'skip_taskbar', 'skip_pager',
own_window_title:
#~ Définir manuellement le nom de la fenêtre. Par défaut à "<hostname> - conky".
Example: own_window_title Conky
Lua: own_window_title = ConKii,
own_window_argb_visual:
#~ Booléen, utiliser ARGB visual? ARGB peut être utilisé pour une transparence réelle,
#~ notez qu’un gestionnaire composite est nécessaire pour une transparence réelle.
#~ Cette option ne fonctionnera pas comme désiré (dans la plupart des cas) en conjonction avec 'own_window_type override'.
Example: own_window_argb_visual no
Lua: own_window_argb_visual = false,
own_window_argb_value:
#~ Lorsque les visuels ARGB sont activés, ceci permet de modifier la valeur alpha utilisée.
#~ La plage valide est 0-255, où 0 est 0% opacité, & 255 est 100% opacité.
Example: own_window_argb_value 128
Lua: own_window_argb_value = 32,
own_window_transparent:
#~ Booléen, définir la transparence? Si ARGB visuel est activé, définit l’opacité d’arrière-plan à 0%.
Example: own_window_transparent yes
Lua: own_window_transparent = false,
own_window_type:
#~ si own_window est oui, vous pouvez spécifier le type normal, desktop, dock, panel ȣ override (par défaut : normal).
#~ Les fenêtres de bureau sont des fenêtres spéciales qui n’ont pas de décorations;
#~ sont toujours visibles sur votre bureau;
#~ n’apparaissent pas dans votre pager ȣ votre barre des tâches;
#~ & sont collantes dans tous les espaces de travail.
#~ Les fenêtres de panneau réservent de l’espace le long d’un bord de bureau, tout comme les panneaux & les barres de tâches,
#~ empêchant les fenêtres maximisées de se chevaucher. Le bord est choisi en fonction de l’option d’alignement.
#~ Les fenêtres Override ne sont pas sous le contrôle du gestionnaire de fenêtres.
#~ Les indices sont ignorés. Ce type de fenêtre peut être utile dans certaines situations.
#~ "normal" avec décoration,
#~ "desktop" sans décoration,
#~ "dock" reste au dessus des autre,
#~ "panel" se réserve une zone du bureau,
#~ "override" ne dépend plus d'un gestionnaire de bureau
Example: own_window_type normal
own_window_type desktop
own_window_type dock
own_window_type panel
own_window_type override
Lua: own_window_type = 'normal',
own_window_type = 'desktop',
own_window_type = 'dock',
own_window_type = 'panel',
own_window_type = 'override',
pad_percents:
#~ Pourcentages de pad à autant de décimales (0 = pas de remplissage) rempli le bureau mais pas en %
Example: pad_percents 50
Lua: pad_percents = 50,
pop3:
#~ Serveur POP3 global par défaut. Les arguments sont :
#~ "host user pass [-i interval (in seconds)] [-p port] [-e 'command'] [-r retries]". Le port par défaut est 110,
#~ l’intervalle par défaut est de 5 minutes, & le nombre par défaut de tentatives avant la renonciation est de 5.
#~ Si le mot de passe est '*', vous serez invité à entrer le mot de passe lorsque Conky démarrera.
Example: pop3 pop3.example.com user password -i 300 -p 110 -r 5
Lua:?????????????
short_units:
#~ Réduit les unités à un seul caractère (kiB->k, GiB->G, etc.). La valeur par défaut est désactivée.
Example: short_units yes
Lua: short_units = true,
show_graph_range:
#~ Affiche la plage de temps couverte par un graphique.
Example: show_graph_range yes
Lua: show_graph_range = true,
show_graph_scale:
#~ Affiche la valeur maximale dans les graphiques à l’échelle.
Example: show_graph_scale yes
Lua: show_graph_scale = true,
stippled_borders:
#~ Pointillés de bordure (effilochés) en pixels
Example: stippled_borders 2
Lua: stippled_borders = 12,
temperature_unit:
#~ Unité de sortie souhaitée de tous les objets affichant une température. Les paramètres sont soit "fahrenheit" ȣ "celsius".
#~ L’unité par défaut est degré Celsius.
Example: temperature_unit celsius
temperature_unit fahrenheit
Lua: temperature_unit = celsius,
temperature_unit = fahrenheit,
templateN:
#~ Définir un modèle pour une utilisation ultérieure dans les segments TEXT. Remplacer N par un chiffre compris entre 0 & 9.
#~ La valeur de la variable est insérée dans la substance sous TEXT à la position correspondante, mais avant quelques substitutions sont appliquées:
#~ '\n' -> Nouvelle ligne. Cela permet au modèle à une ligne de s'étendre à une sortie multiligne.
#~ '\\' -> Un seul caractère barre oblique inverse.
#~ "\ " = Un caractère d'espace (guillemets utilisés pour montrer l'espace de fin).
#~ Les variables avec des espaces doivent utiliser la barre oblique inverse avant chaque caractère d'espace.
#~ \N = Argument de modèle N (e.g. \1, \2, \3, \4, \5, \6, \7, \8, \9)
Example: template0 ${\1\2}
template1 \1: ${fs_used \2} / ${fs_size \2}
template2 \1 \2
Lua:??????????????????????????????
TEXT
#~ Les lignes suivantes montrent ce que chaque modèle développe.
Example: ${template0 node name} = ${nodename}
${template1 root /} = root: ${fs_used /} / ${fs_size /}
#~ Vous pouvez même passer un modèle à un autre modèle.
${template1 ${template2\ disk\ root} /} = disk root: ${fs_used /} / ${fs_size /}
Lua:??????????????????????????????
text_buffer_size:
#~ Taille du tampon de texte standard (256 octets par défaut).
#~ Ce tampon est utilisé pour le texte intermédiaire, comme les lignes individuelles, la sortie de $exec vars, & diverses autres variables.
#~ L’augmentation de la taille de ce tampon peut considérablement réduire les performances de Conky,
#~ mais permettra d’afficher plus de texte par variable.
#~ La taille de ce tampon ne peut pas être inférieure à la valeur par défaut de 256 octets, c'est le minimum.
Example: text_buffer_size 256
Lua: text_buffer_size = 512,
times_in_seconds:
#~ Si vrai, les variables qui produisent des temps produisent un nombre qui représente des secondes. Cela n’affecte pas $time, $tztime & $utime
Example: times_in_seconds yes
Lua: times_in_seconds = true,
top_cpu_separate:
#~ Si vrai, cpu en haut montrera l’utilisation de la puissance d’un processeur.
#~ Si faux, cpu en haut montrera l’utilisation de la puissance de tous les processeurs combinés.
Example: top_cpu_separate no
Lua: top_cpu_separate = false,
top_name_width:
#~ Largeur pour $top name value (par défaut à 15 caractères).
Example: top_name_width 20
Lua: top_name_width = 20,
total_run_times:
#~ Nombre total de fois où Conky doit faire une mise à jour avant de quitter. Zéro fait tourner Conky pour toujours
Example: total_run_times 0
Lua: total_run_times = 0,
update_interval:
#~ intervalle de mise à jour
Example: update_interval 0.5
Lua: update_interval = 1.0,
update_interval_on_battery:
#~ Intervalle de mise à jour lors de l’exécution sur la batterie
Example: update_interval_on_battery 5
Lua: update_interval_on_battery = 5,
uppercase no:
#~ Valeur booléenne, si vrai, le texte est rendu en majuscules
Example: uppercase no
Lua: uppercase = true,
use_spacer:
#~ Ajoute des espaces autour de certains objets pour les empêcher de déplacer d’autres choses.
#~ Les arguments sont à gauche, à droite & aucun (par défaut).
#~ Les anciennes valeurs true/false sont dépréciées & par défaut à right/none respectivement.
#~ Notez que cela n’est utile que si vous utilisez une police mono, comme Bitstream Vera Sans Mono.
Example: use_spacer left
use_spacer right
use_spacer none
Lua: use_spacer = left,
use_spacer = right,
use_spacer = none,
use_xft:
#~ Utiliser Xft (police anti-aliasée & autres)
Example: use_xft yes
Lua: use_xft = true,
xftalpha:
#~ Alpha de la police Xft. Doit être une valeur entre 1 & 0.
Example: xftalpha 0.7
Lua: xftalpha = 0.7,
xftfont:
#~ Police Xft à utiliser.
Example: xftfont Ubuntu
Lua: xftfont = Ubuntu,
#~ __________________________________________________________________________________________________________________________________________
TEXT:
#~ Après cela commence le texte à formater à l’écran. Backslash ( / ) échappe nouvelles lignes dans la section de texte.
#~ Cela peut être utile pour nettoyer les fichiers de configuration où conky est utilisé pour transférer l’entrée à dzen2.
Example: TEXT
Lua: conky.text = [[
${acpiacadapter (adapter)}:
#~ État de l’adaptateur CA ACPI.
#~ Sur linux, l’option adaptateur spécifie le sous-dossier de /sys/class/power_supply contenant les informations d’état
#~ (essaie "AC" & "ADP1" s’il n’y a pas d’argument donné). Les systèmes Non-Linux l’ignorent.
Arguments: [adapter]
Example: ${acpiacadapter adp1}
Lua: ??????????
${acpifan}:
#~ État du ventilateur ACPI
Example: ${acpifan}
Lua: ${acpifan}
${acpitemp} °C ȣ °F:
#~ Température ACPI en Celsius sauf ci 'temperature_unit fahrenheit'
Example: ${acpitemp}
Lua: ${acpitemp}
${addr }:
#~ Adresse IP pour une interface, ȣ "Pas d’adresse" si aucune adresse n’est attribuée. ${addr eth0, eno1, &c} ȣ ${addr ${gw_iface}}
Arguments: [interface]
Example: ${addr eth0} ȣ ${addrs ${gw_iface}}
Lua: ${addr eth0}
${addrs ${gw_iface}}:
#~ Adresses IP pour une interface (si on - fonctionne comme addr). Linux seulement.
Arguments: [interface]
Example: ${addr eth0} ȣ ${addrs ${gw_iface}}
Lua: ??????????
${adt746xcpu}:
#~ Température CPU de therm_adt746x il ce peu que cela soit un capteur sur certain mac :-/
Example: ${adt746xcpu}
Lua:
${adt746xfan}:
#~ Vitesse du ventilateur à partir de therm_adt746x. il ce peu que cela soit un capteur sur certain mac :-/
Example: ${adt746xfan}
Lua:
${alignc}:
#~ Alignez le texte au centre. Le nombre facultatif ajoute des espaces à droite (positif) ȣ à gauche (négatif) pour ajuster le placement.
Arguments: [number]
Example: ${alignc -5}
Lua: ${alignc -5}
${alignr}:
#~ Texte justifié à droite. Le nombre facultatif complète le côté droit avec N espaces.
Arguments: [number]
Example: ${alignr 2}
Lua: ${alignr 2}
${apcupsd}:
#~ Configure la connexion au démon APC UPS (apcupsd). N'imprime rien, par défaut "localhost:3551"
Arguments: host
Lua:,,????????????????????
${apcupsd_cable}:
#~ Affiche le type de connexion UPS.
Example: ${apcupsd_cable}
Lua:??????????????
${apcupsd_charge}:
#~ Capacité actuelle de la batterie en pourcentage.
Example: ${apcupsd_charge}
Lua:?????????????????
${apcupsd_lastxfer}:
#~ Raison du dernier transfert de la ligne à la batterie.
Example: ${apcupsd_lastxfer}
Lua:??????????????????
${apcupsd_linev}:
#~ Tension d'entrée nominale.
Example: ${apcupsd_linev}
Lua:???????????????????
${apcupsd_load}:
#~ Charge actuelle en pourcentage.
Example: ${apcupsd_load}
Lua:????????????????
${apcupsd_loadgauge}:
#~ Jauge indiquant la charge actuelle.
Arguments: [height][,width]
Example: ${apcupsd_loadgauge 10,20}
Lua:??????????????????
${apcupsd_loadgraph}:
#~ Graphique historique de la charge actuelle.
Arguments: [height][,width] [gradient color 1] [gradient color 2] [scale] [-t] [-l]
Example: ${apcupsd_loadgraph 20,120 FFFF00 FFCC00 -l}
Lua:???????????????????
${apcupsd_model}:
#~ Imprime le modèle de l'UPS.
Example: ${apcupsd_model}
Lua:?????????????????
${apcupsd_name}:
#~ Imprime le nom défini par l'utilisateur de l'onduleur.
Example: ${apcupsd_name}
Lua:????????????????
${apcupsd_status}:
#~ Imprime l'état actuel "en ligne" ȣ "sur batterie".
Example: ${apcupsd_status}
Lua:????????????????
${apcupsd_temp}:
#~ Température interne actuelle.
Example: ${apcupsd_temp}
Lua:??????????????
${apcupsd_timeleft}:
#~ Temps restant pour fonctionner sur batterie.
Example: ${apcupsd_timeleft}
Lua:??????????????????
${apcupsd_upsmode}:
#~ Imprime le mode UPS comme "autonome".
Example: ${apcupsd_upsmode}
Lua:???????????????
${apm_adapter}:
#~ Affiche l'état de l'adaptateur secteur APM. FreeBSD uniquement.
Example: ${apm_adapter}
Lua:???????????????
${apm_battery_life}:
#~ Affiche la durée de vie de la batterie APM en pourcentage. FreeBSD uniquement.
Example: ${apm_battery_life}
Lua:?????????????
${apm_battery_time}:
#~ Affiche l'autonomie restante de la batterie APM en "hh:mm:ss" ȣ "inconnu" si l'état de l'adaptateur secteur est en ligne ȣ en charge.
#~ FreeBSD uniquement.
Example: ${apm_battery_time}
Lua:??????????????????
${audacious_bar}:
#~ Barre de progression pour la chanson en cours.
Arguments: [height][,width]
Example: ${audacious_bar 10,20}
Lua:???????????????
${audacious_bitrate}:
#~ Bitrate de la mélodie actuelle.
Example: ${audacious_bitrate}
Lua:?????????????
${audacious_channels}:
#~ Nombre de canaux audio de la mélodie actuelle.
Example: ${audacious_channels}
Lua::?????????????
${audacious_filename}:
#~ Chemin complet & nom de fichier du morceau en cours.
Example: ${audacious_filename}
Lua::?????????????
${audacious_frequency}:
#~ Fréquence d'échantillonnage de la mélodie actuelle.
Example: ${audacious_frequency}
Lua::?????????????
${audacious_length}:
#~ Longueur totale de la mélodie actuelle en MM:SS.
Example: ${audacious_length}
Lua::?????????????
${audacious_length_seconds}:
#~ Durée totale de la mélodie en cours en secondes.
Example: ${audacious_length_seconds}
Lua::?????????????
${audacious_main_volume}:
#~ Le volume actuel extrait d'Audacious.
Example: ${audacious_main_volume}
Lua::?????????????
${audacious_playlist_length}:
#~ Nombre de morceaux dans la liste de lecture.
Example: ${audacious_playlist_length}
Lua::?????????????
${audacious_playlist_position}:
#~ Position de la liste de lecture du morceau en cours.
Example: ${audacious_playlist_position}
Lua::?????????????
${audacious_position}:
#~ Position of current tune in "MM:SS" format.
Example: ${audacious_position}
Lua::?????????????
${audacious_position_seconds}:
#~ Position de la mélodie actuelle en secondes.
Example: ${audacious_position_seconds}
Lua::?????????????
${audacious_status}:
#~ Statut du joueur. Les choix possibles sont "Playing", "Paused", "Stopped", "Not running".
Example: ${audacious_status}
Lua::?????????????
${audacious_title}:
#~ Title of current tune with optional maximum length specifier.
Arguments: [max length]
Example: ${audacious_title 30}
Lua::?????????????
${battery BAT1}:
#~ État de la batterie & pourcentage de capacité restante de la batterie ACPI ȣ APM.
#~ Le numéro de batterie ACPI peut être donné en argument & pointe vers "/proc/acpi/battery/BAT0/state".
#~ La batterie par défaut est "BAT0".
Arguments: [battery_number]
Example: ${battery BAT1}
Lua: ${battery BAT1}
${battery_bar}:
#~ Pourcentage de batterie restant de la batterie ACPI dans une barre.
#~ Le numéro de batterie ACPI peut être donné en argument.
#~ La batterie par défaut est "BAT0".
Arguments: [height][,width] [battery_number]
Example: ${battery_bar 10,20 BAT1}
Lua: ${battery_bar 10,20 BAT1}
${battery_percent}:
#~ Pourcentage de batterie restant pour la batterie ACPI.
#~ Le numéro de la batterie ACPI peut être donné en argument.
#~ Par défaut, la batterie est "0".
Arguments: [battery_number]
Example: ${battery_percent BAT1}
Lua: ${battery_percent BAT1}
${battery_short}:
#~ État de la batterie & pourcentage de capacité restante de la batterie ACPI ȣ APM.
#~ Le numéro de batterie ACPI peut être donné en argument.
#~ La batterie par défaut est "BAT0".
#~ Ce mode affiche un état court, ce qui signifie que
#~ C est affiché au lieu de charger, D pour décharger, F pour plein, N pour absent, E pour vide & U pour inconnu.
Arguments: [battery_number]
Example: ${battery_short BAT1}
Lua: ${battery_short BAT1}
${battery_time}:
#~ Temps de charge/décharge restant de la batterie ACPI.
#~ Le numéro de batterie ACPI peut être donné comme argument.
#~ La valeur par défaut est la batterie "BAT0".
Arguments: [battery_number]
Example: ${battery_time BAT1}
Lua: ${battery_time BAT1}
${blink}:
#~ Faire "texte_&_autres_variables_conky" clignotent & s'éteignent.
Arguments: texte_&_autres_variables_conky
Example: ${blink "Warning: ${battery_percent BAT1} depleted!"}
Lua: ${blink "Warning: ${battery_percent BAT1} depleted!"}
${bmpx_album}:
#~ Album dans la piste BMPx actuelle.
Example: ${bmpx_album}
Lua:?????????????????
${bmpx_artist}:
#~ Artiste dans la piste BMPx actuelle.
Example: ${bmpx_artist}
Lua::?????????????????
${bmpx_bitrate}:
#~ Bitrate de la piste BMPx actuelle.
Example: ${bmpx_bitrate}
Lua::?????????????????
${bmpx_title}:
#~ Titre de la piste BMPx actuelle.
Example: ${bmpx_title}
Lua::?????????????????
${bmpx_track}:
#~ Numéro de piste de la piste BMPx actuelle.
Example: ${bmpx_track}
Lua::?????????????????
${bmpx_uri}:
#~ URI de la piste BMPx actuelle.
Example: ${bmpx_uri}
Lua::?????????????????
${buffers}:
#~ Quantité de mémoire tamponnée.
Example: ${buffers}
Lua: ${buffers}
${cached}:
#~ Quantité de mémoire mise en cache.
Example: ${cached}
Lua: ${cached}
${cmdline_to_pid "demo"}:
#~ PID du premier processus qui a "chaîne" dans sa ligne de commande.
Arguments: "chaîne"
Example: ${cmdline_to_pid "demo"}
Lua:??????????????
${color}:
#~ Remplacez la couleur de dessin par "couleur" qui est le nom d'une couleur ȣ un code hexadécimal précédé du "#", par exemple #0A1B2C.
#~ Si vous utilisez ncurses, seules les couleurs suivantes sont prises en charge :
#~ "red" "green" "yellow" "blue" "magenta" "cyan" "black" "white"
Arguments: [color]
Example: ${color red} c'est rouge
${color green} c'est vert
${color blue} c'est bleu
${color #FFA500} c'est Orange
Lua: ${color red} c'est rouge
${color green} c'est vert
${color blue} c'est bleu
${color FFA500} c'est Orange
${colorN}:
#~ Changez la couleur de dessin en option de configuration de couleur prédéfinie
#~ "N", où N est un chiffre compris entre 0 & 9 inclus ;
#~ couleur0, couleur1, couleur2, couleur3, couleur4, couleur5, couleur6, couleur7, couleur8, couleur9.
Example: color8 f9cc00
TEXT
${color8}
Lua: color8 = 'ff0000',
conky.text = [[
${color8}
${combine}:
#~ Combine deux listes en colonnes.
#~ Les lignes de var2 sont ajoutées à droite des lignes de var1 séparées par le(s) caractère(s) placé(s) entre var1 & var2.
Arguments: var1 var2
Example: ${combine ${head /proc/cpuinfo 2} - ${head /proc/meminfo 1}}
#~ Cela donne en sortie "cpuinfo_line1 - meminfo_line1" sur la ligne 1 & "cpuinfo_line2 -" sur la ligne 2.
#~ Les variables combinées peuvent également être imbriquées pour placer plus de variables les unes à côté des autres.
Lua: ${combine ${head /proc/cpuinfo 2} - ${head /proc/meminfo 1}}
${conky_build_arch}:
#~ Architecture CPU pour laquelle Conky a été conçu.
Example: ${conky_build_arch}
Lua: ${conky_build_arch}
${conky_build_date}:
#~ Date de construction de Conky.
Example: ${conky_build_date}
Lua: ${conky_build_date}
${conky_version}:
#~ Numéro de version de Conky.
Example: ${conky_version}
Lua: ${conky_version}
${cpu}:
#~ Utilisation du processeur en pourcentage. Pour les machines SMP, le numéro de CPU facultatif peut être fourni comme argument.
#~ "${cpu cpu0}" est l'utilisation totale combinée & "${cpu cpuN}" où N est un nombre entier positif pour les processeurs individuels.
Arguments: [cpu_Number]
Example: ${cpu cpu0}% Total
${cpu cpu1}% Cœur 1
${cpu cpu2}% Cœur 2
Lua: ${cpu cpu0}% Total
${cpu cpu1}% Cœur 1
${cpu cpu20}% Cœur 20
${cpubar}:
#~ Barre indiquant l'utilisation du processeur. La hauteur & la largeur sont en pixels. Voir ${cpu} pour plus d'informations sur le matériel SMP.
Arguments: [cpu_Number] [height][,width]
Example: ${cpubar cpu0 10,60}
Lua: ${cpubar cpu0 10,60}
${cpugauge}:
#~ Jauge elliptique qui montre l'utilisation du processeur, la hauteur & la largeur sont respectivement l'axe vertical & horizontal de la jauge.
#~ Voir CPU pour plus d'informations sur SMP.
Arguments: [cpu_Number] [height][,width]
Example: ${cpugauge cpu0 20,40}
Lua: ${cpugauge cpu0 20,40}
${cpugraph}:
#~ Graphique d'utilisation du processeur avec couleurs facultatives en hexadécimal RVB. Voir ${cpu} pour plus d'informations sur le matériel SMP.
#~ Le commutateur L "-l" minuscule utilise une échelle logarithmique pour rendre les petits nombres plus visibles.
#~ Le commutateur T "-t" minuscule permet au gradient de température de faire changer les valeurs de couleur
#~ en fonction de l'amplitude de la charge du processeur.
Arguments: [cpu_Number] [height][,width] [gradient color 1] [gradient color 2] [scale] [-t] [-l]
Example: ${cpugraph cpu0 10,120 555555 AAAAAA -l}
Lua: ${cpugraph cpu0 10,120 FF0000 00FF00 -l}
${cpugraph cpu1 10,120 FF0000 00FF00 -t}
${cpugraph cpu2 10,120 FF0000 00FF00 -t}
${curl}:
#~ Téléchargez les données de l'URI en utilisant Curl à l'intervalle spécifié.
#~ L'intervalle peut être une valeur à virgule flottante supérieure à 0, sinon la valeur par défaut est de 15 minutes.
#~ Plus utile lorsqu'il est utilisé en conjonction avec Lua & l'API Lua.
#~ Cet objet est threadé, & une fois qu'un thread est créé, il ne peut pas être explicitement détruit.
#~ Un thread s'exécutera pour chaque URI spécifié. Vous pouvez utiliser n'importe quel protocole pris en charge par Curl.
Arguments: url [interval_in_minutes]
Example: ${curl http://www.ifxgroup.net/conky.htm 1440}
Lua: ??????????????
${desktop}:
#~ Numéro du bureau virtuel X-windows ȣ le message "Not running in X" si c'est le cas.
Example: ${desktop}
Lua: ${desktop}
${desktop_name}:
#~ Nom du bureau sur lequel Conky tourne ȣ le message "Not running in X" si c'est le cas.
Example: ${desktop_name}
Lua: ${desktop_name}
${desktop_number}:
#~ Nombre de postes de travail ȣ message "Ne fonctionne pas sous X" si c'est le cas.
Example: ${desktop_number}
Lua: ${desktop_number}
${disk_protect}:
#~ État de la protection du disque, si pris en charge. Cela peut nécessiter un patch du noyau.
#~ Imprime "gelé" ȣ "libre", notez le rembourrage après le mot libre.
Arguments: [device]
Example: ${disk_protect sda}
Lua: ${disk_protect sda}
${diskio}:
#~ Affiche les E/S du disque actuel. Le périphérique est facultatif & prend la forme de sda pour "/dev/sda".
#~ Les partitions individuelles sont prises en charge.
Arguments: [device]
Example: ${diskio /dev/sda}
Lua: ${diskio /dev/sda}
${diskio_read}:
#~ Affiche les E/S du disque actuel pour les lectures.
Arguments: [device]
Example: ${diskio_read /dev/sda}
Lua: ${diskio_read /dev/sda}
${diskio_write}:
#~ Affiche les E/S de disque actuelles pour les écritures.
Arguments: [device]
Example: ${diskio_write /dev/sda}
Lua: ${diskio_write /dev/sda}
${diskiograph}:
#~ Graphique d’activité IO disque. Couleurs définies en hexadécimal RVB. Si l’échelle est différente de zéro, elle devient l’échelle du graphique.
#~ Le commutateur L "-l" en minuscules utilise une échelle logarithmique pour rendre les petits nombres plus visibles.
#~ Le commutateur T "-t" en minuscules permet au gradient de température de faire changer les valeurs de couleur
#~ en fonction de l’amplitude de l’activité.
Arguments: [device] [height][,width] [gradient color 1] [gradient color 2] [scale] [-t] [-l]
Example: ${diskiograph /dev/sda 10,120 555555 AAAAAA -l}
Lua: ${diskiograph /dev/sda 10,120 00FF00 FF0000 -t}
${diskiograph_read}:
#~ Graphique d'E/S de disque pour les lectures. Les couleurs sont définies en RVB hexadécimal.
#~ Si l'échelle est différente de zéro, elle devient l'échelle du graphique.
#~ Le commutateur L "-l" minuscule utilise une échelle logarithmique pour rendre les petits nombres plus visibles.
#~ Le commutateur T "-t" minuscule permet au gradient de température de faire changer les valeurs de couleur
#~ en fonction de l'amplitude de l'activité.
Arguments: [device] [height][,width] [gradient color 1] [gradient color 2] [scale] [-t] [-l]
Example:${diskiograph_read /dev/sda 10,120 555555 AAAAAA -l}
Lua: ${diskiograph read/dev/sda 10,120 00FF00 FF0000 -t}
${diskiograph_write}:
#~ Graphique d'E/S de disque pour les écritures. Les couleurs sont définies en RVB hexadécimal.
#~ Si l'échelle est différente de zéro, elle devient l'échelle du graphique.
#~ Le commutateur L "-l" minuscule utilise une échelle logarithmique pour rendre les petits nombres plus visibles.
#~ Le commutateur T "-t" minuscule permet au gradient de température de faire changer les valeurs de couleur
#~ en fonction de l'amplitude de l'activité.
Arguments: [device] [height][,width] [gradient color 1] [gradient color 2] [scale] [-t] [-l]
Example: ${diskiograph_write /dev/sda 10,120 555555 AAAAAA -l}
Lua: ${diskiograph write/dev/sda 10,120 00FF00 FF0000 -l}
${downspeed}:
#~ Vitesse de téléchargement dans les unités CEI (Commission électrotechnique internationale) appropriées.
Arguments: [network_interface]
Example: ${downspeed eth0}
Lua: ${downspeed eth0}
${downspeedgraph}:
#~ Télécharger le graphique de vitesse. Les couleurs sont définies en RVB hexadécimal.
#~ Si l'échelle est différente de zéro, elle devient l'échelle du graphique.
#~ Utilise une échelle logarithmique (pour voir les petits nombres) lorsque vous utilisez le commutateur -l.
#~ Prend le commutateur -t pour utiliser un gradient de température, ce qui fait que les valeurs du gradient changent
#~ en fonction de l'amplitude d'une valeur graphique particulière.
Arguments: [network_interface] [height][,width] [gradient color 1] [gradient color 2] [scale] [-t] [-l]
Example: ${downspeedgraph eth0 20,120 -t -l}
Lua: ${downspeedgraph wlp2s0 7,100 00FF00 FF0000 -t -l}
${draft_mails}:
#~ Nombre d'e-mails marqués comme brouillon dans la boîte aux lettres ȣ le spool d'e-mails spécifié, sinon.
#~ Seules les boîtes aux lettres de type maildir sont prises en charge, le type mbox renverra -1.
Arguments: [mail_directory]
Example:???????????
Lua:?????????????
${else}:
#~ Texte à afficher uniquement lorsque le "${if_*}" précédent n'est pas vrai. Tout ce qui se trouve entre "${else}" & "${endif}" est affiché.
${endif}:
#~ Termine un bloc "${if_*}".
Example: ${if_existing /home/utilisateur/example.log} le fichier existe!
${else} le fichier example.log n'existe pas!
${endif}
Lua: ${if_existing /home/utilisateur/example.log} le fichier existe!
${else} le fichier example.log n'existe pas!
${endif}
${entropy_avail}:
#~ Entropie actuelle disponible pour les mordus de crypto.
Example: ${entropy_avail}
Lua: ${entropy_avail}
${entropy_bar}:
#~ Barre normalisée d'entropie disponible pour les passionnés de crypto.
Arguments: [height][,width]
Example: ${entropy_bar 10,20}
Lua: ${entropy_bar 10,20}
${entropy_perc}:
#~ Pourcentage d'entropie disponible par rapport à la taille du pool.
Example: ${entropy_perc}
Lua: ${entropy_perc}
${entropy_poolsize}:
#~ Taille totale du pool d'entropie du système pour les monstres de crypto.
Example: ${entropy_poolsize}
Lua: ${entropy_poolsize}
${eval}:
#~ Évalue la chaîne donnée selon les règles de l'interprétation TEXT, c'est-à-dire en analysant toutes
#~ les spécifications d'objet texte contenues dans leur sortie, tout '$$' en un seul '$' & ainsi de suite.
#~ La sortie est ensuite à nouveau analysée.
Arguments: "chaîne"
Example: ${eval "Local time is $${time %a, %d %b %Y %T %z}"}
Lua: ${eval "Local time is $${time %a, %d %b %Y %T %z}"}
${eve}:
#~ Récupère votre compétence en cours d'entraînement à partir des serveurs de l'API Eve Online (http://www.eve-online.com/)
#~ & affiche la compétence ainsi que le temps d'entraînement restant.
Arguments: api_ID_utilisateur_clé_API identifiant_de_personnage
Example:?????????
Lua:????????????
${exec}:
#~ Exécute une commande shell & affiche la sortie dans Conky.
Arguments: command
Example: ${exec cat /etc/debian_version}
#~ Peut ralentir le fonctionnement de conky.
Lua: ${exec cat /etc/debian_version}
${execbar}:
#~ Identique à ${exec} sauf si la première valeur renvoyée est un nombre compris entre 0 & 100, il utilisera ce nombre pour une barre.
#~ La taille des barres peut être contrôlée via le paramètre de configuration default_bar_size.
Arguments: command
Example: ${execbar echo 55}
#~ Peut ralentir le fonctionnement de conky.
Lua: ${execbar echo 55}
${execgauge}:
#~ Identique à ${exec} sauf si la première valeur renvoyée est un nombre compris entre 0 & 100, il utilisera ce nombre pour une jauge.
#~ La taille des jauges peut être contrôlée via le paramètre de configuration default_gauge_size.
Arguments: command
Example: ${execgauge echo 33}
#~ Peut ralentir le fonctionnement de conky.
Lua: ${execgauge echo 33}
${execgraph}:
#~ Identique à ${execbar} mais représente graphiquement les valeurs.
#~ Utilise une échelle logarithmique lorsque l'option log, le commutateur L minuscule "-l" est donné.
#~ Cela rend les petits nombres plus visibles. Les valeurs doivent toujours être comprises entre 0 & 100.
#~ La taille des graphiques peut être contrôlée via le paramètre de configuration "default_graph_size".
#~ Prend le commutateur "-t" pour utiliser un gradient de température, ce qui fait que les valeurs du gradient changent
#~ en fonction de l'amplitude d'une valeur graphique particulière. Essayez-le & voyez.
#~ Si -t ȣ -l est votre premier argument, vous devrez peut-être le faire précéder d'un espace (" ").
Arguments: [-t] [-l] command
Example: ${execgraph "echo 75"}
#~ Peut ralentir le fonctionnement de conky.
Lua: ${execgraph -t -l "echo 75"}
${execi}:
#~ Identique à ${exec} mais avec un intervalle spécifique.
#~ L'intervalle ne peut pas être inférieur à update_interval dans la configuration. Voir aussi ${texeci}.
Arguments: interval command
Example: ${execi 300 cat /proc/swaps}
#~ Peut ralentir le fonctionnement de conky.
Lua: ${execi 300 cat /proc/swaps}
${execigauge}:
#~ Identique à execbar sauf avec un intervalle.
Arguments: interval command
Example: ${execigauge 10 echo 55}
#~ Peut ralentir le fonctionnement de conky.
Lua: ${execigauge 10 echo 55}
${execigraph}:
#~ Identique à execgraph mais prend un intervalle arg & trace les valeurs.
#~ Si -t ȣ -l est votre premier argument, vous devrez peut-être le faire précéder d'un espace (" ").
Arguments: interval [-t] [-l] command
Example: ${execigraph -t -l "echo 75"}
#~ Peut ralentir le fonctionnement de conky.
Lua: ????????????
${execp}:
#~ Exécute une commande shell & affiche la sortie dans Conky.
#~ Cela diffère de ${exec} en ce qu'il analyse la sortie de la commande, vous pouvez donc insérer des choses comme
#~ "${color red}hi!${color}" dans votre script & le faire analyser correctement par Conky.
#~ Avertissements : Conky analyse & évalue la sortie de ${execp} à chaque boucle de Conky, puis détruit tous les objets.
#~ Si vous essayez d'utiliser quelque chose comme ${execi} dans l'instruction ${execp},
#~ il s'exécutera fonctionnellement au même intervalle que l'instruction ${execp}, car il est créé & détruit à chaque intervalle.
Arguments: command
Example:${execp cat /proc/version}
#~ Peut ralentir le fonctionnement de conky.
Lua: ${execp cat /proc/version}
${execpi}:
#~ Identique à execp mais avec un intervalle spécifique.
#~ L'intervalle ne peut pas être inférieur à update_interval dans la configuration.
#~ Notez que la sortie de la commande execpi est toujours analysée & évaluée à chaque intervalle de mise à jour.
Arguments: interval command
Example: ${execpi 300 cat /etc/version}
#~ Peut ralentir le fonctionnement de conky.
Lua: ???????????????????
${flagged_mails}:
#~ Nombre d'e-mails marqués comme marqués dans la boîte aux lettres ȣ le spool d'e-mails spécifié si ce n'est pas le cas.
#~ Seules les boîtes aux lettres de type maildir sont prises en charge, le type mbox renverra -1.
Arguments: [mail_directory]
Example:??????????
Lua:???????????
${font}:
#~ Spécifiez une police avec une épaisseur & une taille facultatives. Cette police s'applique à la ligne courante & à tout ce qui suit.
#~ Vous pouvez utiliser "${font}" sans arguments pour revenir à la police par défaut un peu comme avec "${color}"
Arguments: [font][:weight][:size]
Example: ${font Ubuntu:bold:size=12}
Lua: ${font Ubuntu:bold:size=12} Blabla tatitata ${font}
${format_time}:
#~ Temps de format donné en secondes. Cette variable ne fonctionne que lorsque le paramètre de configuration times_in_seconds est activé.
#~ Format est une chaîne qui doit commencer & se terminer par un guillemet double (").
#~ Les guillemets doubles ne font pas partie de la sortie.
#~ \w = Semaines
#~ \d = Jours
#~ \h = Heures
#~ \m = minutes
#~ \s = secondes
#~ \( = Parenthèses ouvertes
#~ \) = Fermer les parenthèses
#~ \\ = barre oblique inverse unique
#~ () = Le texte entre parenthèses n'est pas visible si une unité remplacée dans le texte est 0.
#~ \SN = Afficher les nombres derrière le point si les secondes sont un nombre décimal. N est un nombre de chiffres derrière le point à afficher.
#~ Le maximum est 9. Utilisez "x" (par exemple "\Sx") pour afficher tous les chiffres derrière le point sans zéros à droite jusqu'à un maximum de 9 chiffres.
#~ Si une unité n'est pas donnée, sa valeur est exprimée dans l'unité la plus élevée inférieure à celle omise.
Arguments: seconds format
Example: ${format_time "\h:\m:\s"}
Lua: ?????????????????
${forwarded_mails}:
#~ Nombre d'e-mails marqués comme transférés dans la boîte aux lettres spécifiée ȣ le spouleur d'e-mails si ce n'est pas le cas.
#~ Seules les boîtes aux lettres de type maildir sont prises en charge, le type mbox renverra -1.
Arguments: [mail_directory]
Example:?????????????
Lua:???????????????
${freq}:
#~ Renvoie la fréquence du CPU #n en MHz. Les processeurs sont comptés à partir de 1. S'il est omis, le paramètre prend par défaut la valeur 1.
Arguments: [cpu_number]
Example: ${freq}MHz
Lua: ${freq}MHz
${freq_g}:
#~ Renvoie la fréquence du CPU #n en GHz. Les processeurs sont comptés à partir de 1. S'il est omis, le paramètre prend par défaut la valeur 1.
Arguments: [cpu_number]
Example: ${freq_g}Ghz
Lua: ${freq_g}Ghz
${fs_bar}:
#~ Barre indiquant la quantité d'espace utilisée sur un système de fichiers.
#~ Hauteur & Largeur sont la hauteur & la largeur en pixels. "File_system" est n'importe quel fichier ȣ dossier sur ce système de fichiers.
Arguments: [height][,width] file_system
Example: ${fs_bar /home}
Lua: ${fs_bar /home}
${fs_bar_free}:
#~ Barre indiquant la quantité d'espace libre sur un système de fichiers.
#~ hauteur est la hauteur en pixels. fs est n'importe quel fichier sur ce système de fichiers.
Arguments: [height][,width] fs
Example: ${fs_bar_free /home}
Lua: ${fs_bar_free /home}
${fs_free}:
#~ Espace libre sur un système de fichiers disponible pour les utilisateurs.
Arguments: [file_system]
Example: ${fs_free /home}
Lua: ${fs_free /home}
${fs_free_perc}:
#~ Pourcentage d'espace libre sur un système de fichiers disponible pour les utilisateurs.
Arguments: [file_system]
Example: ${fs_free_perc /home}
Lua: ${fs_free_perc /home}
${fs_size}:
#~ Taille du système de fichiers.
Arguments: [file_system]
Example: ${fs_size /home}
Lua:
${fs_type}:
#~ Type de système de fichiers.
Arguments: [file_system]
Example: ${fs_type /home}
Lua: ${fs_type /home}
${fs_used}:
#~ Le système de fichiers a utilisé de l'espace.
Arguments: [file_system]
Example: ${fs_used /home}
Lua: ${fs_used /home}
${fs_used_perc}:
#~ Pourcentage d'espace utilisé par le système de fichiers.
Arguments: [file_system]
Example: ${fs_used_perc /home}
Lua: ${fs_used_perc /home}
${goto}:
#~ L'élément suivant est imprimé à la position "numéro" à partir du côté gauche de la fenêtre Conky.
#~ Ceci est mesuré en caractères & est utile pour créer des retraits uniformes & l'illusion de colonnes. Voir aussi ${offset}.
Arguments: number
Example: ${goto 10}
Lua: ${goto 10}
${gw_iface}:
#~ Affiche l'interface de l'itinéraire par défaut ȣ "multiple" ȣ "aucun" en conséquence.
Example: ${gw_iface}
Lua: ${gw_iface}
${gw_ip}:
#~ Affiche l'IP de la passerelle par défaut ȣ "multiple" ȣ "aucune" en conséquence.
Example: ${gw_ip}
Lua: ${gw_ip}
${hddtemp}: obsolète sur UbuntuMATE
#~ Affiche la température d'un disque dur sélectionné telle que rapportée par le démon hddtemp.
#~ Utilisez hddtemp_host & hddtemp_port pour spécifier un hôte & un port pour tous les objets hddtemp.
#~ Si le paramètre "device" n'est pas donné, le premier disque renvoyé par le démon hddtemp est utilisé.
Arguments: [device]
Example: ??????????????
Lua: ???????????????????
${head}:
#~ Affiche les N premières lignes du fichier texte fourni. Le fichier est vérifié à chaque mise à jour "next_check".
#~ Si next_check n'est pas fourni, Conky par défaut est 2.
#~ Un maximum de 30 lignes peut être affiché, ȣ jusqu'à ce que text_buffer_size soit rempli. Voir ${tail} pour la fin du fichier.
Arguments: logfile lines [next_check]
Example: ${head ~/sample.log 5 3}
Lua: ${head ~/sample.log 5 3}
${hr}:
#~ Ligne horizontale, la hauteur est la hauteur en pixels.
Arguments: [height]
Example: ${hr 3}
Lua: ${hr 3}
${hwmon}:
#~ Capteur Hwmon de sysfs (Linux 2.6 ȣ supérieur).
#~ Le paramètre "device" est le nom du périphérique & peut être omis si vous n'avez qu'un seul périphérique hwmon.
#~ Le type de paramètre est l'un des suivants.
#~ in = Tension (identique à "vol")
#~ vol = tension (identique à "in")
#~ fan = Vitesse du ventilateur
#~ temp = température du système
#~ Le paramètre n est le numéro du capteur. Voir "/sys/class/hwmon/" sur votre ordinateur local.
#~ Les arguments facultatifs "facteur" & "décalage" permettent le pré-calcul de l'entrée brute, qui est calculée comme suit :
#~ "input = input * factor + offset". Notez qu'ils doivent être donnés sous forme de valeurs décimales avec au moins une décimale.
Arguments: [device] type n [factor offset]
Example: ${hwmon temp 1}°C
Lua: ${hwmon temp 1}°C
${i2c}:
#~ Capteur I2C de sysfs (Linux 2.6). Le paramètre dev peut être omis si vous n'avez qu'un seul périphérique I2C.
#~ Le type de paramètre est soit « in » soit « vol » signifiant tension ; 'fan' signifiant ventilateur; 'temp' signifiant température.
#~ Le paramètre n est le numéro du capteur.
#~ Voir /sys/bus/i2c/devices/ sur votre ordinateur local.
#~ Les arguments optionnels 'factor' & 'offset' permettent le pré-calcul de l'entrée brute, qui est modifiée comme suit :
#~ 'input = input * factor + offset'. Notez qu'ils doivent être donnés sous forme de valeurs décimales avec au moins une décimale.
Arguments: [device] type n [factor offset]
Example: ?????????????????
Lua: ???????????
${i8k_ac_status}:
#~ Si vous exécutez le pilote du noyau i8k pour les ordinateurs portables Dell Inspiron,
#~ cela indique si l'alimentation secteur est activée, comme indiqué dans "/proc/i8k" traduit au format lisible.
#~ Ceci n'est pas activé par défaut par i8k lui-même.
Arguments:
Example: ${i8k_ac_status}
Lua: ${i8k_ac_status}
${i8k_bios}:
#~ Si vous exécutez le pilote du noyau i8k pour les ordinateurs portables Inspiron, affiche la version du bios comme indiqué dans /proc/i8k.
Arguments:
Example: ${i8k_bios}
Lua: ${i8k_bios}
${i8k_buttons_status}:
#~ Si vous exécutez le pilote du noyau i8k pour les ordinateurs portables Inspiron, affiche l'état des boutons de volume comme indiqué dans /proc/i8k.
Arguments:
Example: ${i8k_buttons_status}
Lua: ${i8k_buttons_status}
${i8k_cpu_temp}:
#~ Si vous exécutez le pilote du noyau i8k pour les ordinateurs portables Inspiron,
#~ affiche la température du processeur en degrés Celsius, comme indiqué par /proc/i8k.
Arguments:
Example: ${i8k_cpu_temp}
Lua: ${i8k_cpu_temp}
${i8k_left_fan_rpm}:
#~ Si vous exécutez le pilote du noyau i8k pour les ordinateurs portables Inspiron,
#~ affiche le taux de rotation du ventilateur gauche, en tours par minute, comme indiqué dans /proc/i8k.
#~ Dans certains ordinateurs portables, i8k signale ces ventilateurs dans l'ordre inverse.
Arguments:
Example: ${i8k_left_fan_rpm}
Lua: ${i8k_left_fan_rpm}
${i8k_left_fan_status}:
#~ Si vous exécutez le pilote du noyau i8k pour les ordinateurs portables Inspiron,
#~ affiche l'état du ventilateur gauche tel qu'indiqué dans "/proc/i8k" traduit au format lisible par l'homme.
#~ Attention, certains portables i8k signalent ces ventilateurs dans l'ordre inverse.
Arguments:
Example: ${i8k_left_fan_status}
Lua: ${i8k_left_fan_status}
${i8k_right_fan_rpm}:
#~ Si vous exécutez le pilote du noyau i8k pour les ordinateurs portables Inspiron, affiche le bon taux de rotation du ventilateur,
#~ en tours par minute, comme indiqué dans /proc/i8k. Attention, certains portables i8k signalent ces ventilateurs dans l'ordre inverse.
Arguments:
Example: ${i8k_right_fan_rpm}
Lua: ${i8k_right_fan_rpm}
${i8k_right_fan_status}:
#~ Si vous exécutez le pilote du noyau i8k pour les ordinateurs portables Inspiron,
#~ affiche le bon état du ventilateur tel qu'indiqué dans "/proc/i8k" traduit au format lisible par l'homme.
#~ Attention, certains portables i8k signalent ces ventilateurs dans l'ordre inverse.
Arguments:
Example: ${i8k_right_fan_status}
Lua:
${i8k_version}:
#~ Si vous exécutez le pilote du noyau i8k pour les ordinateurs portables Inspiron, affiche le formatage de la version de /proc/i8k.
Arguments:
Example: ${i8k_version}
Lua: ${i8k_version}
${ibm_brightness}:
#~ Si vous exécutez l'IBM ACPI, affiche la luminosité de l'écran LCD des ordinateurs portables. La plage est de 0 à 7.
Arguments:
Example: ${ibm_brightness}
Lua: ${ibm_brightness}
${ibm_fan}:
#~ Si vous exécutez IBM ACPI, affiche la vitesse du ventilateur.
Arguments:
Example: ${ibm_fan}
Lua: ${ibm_fan}
${ibm_temps}:
#~ Si vous exécutez l'IBM ACPI, affiche les températures des capteurs de température IBM.
#~ "Numéro" est compris entre 0 & 7 inclus. Le capteur 0 est sur le CPU, le 3 est sur le GPU.
Arguments:
Example: ${ibm_temps 0}
Lua: ${ibm_temps 0}
${ibm_volume}:
#~ Si vous exécutez IBM ACPI, affiche le volume "maître", contrôlé par les touches de volume (0-14).
Arguments:
Example: ${ibm_volume}
Lua: ${ibm_volume}
${iconv_start}:
#~ Convertissez du texte d'un jeu de codes à un autre à l'aide de GNU iconv. Doit être arrêté avec "iconv_stop".
#~ Tous les caractères entre "start" & "stop" sont convertis.
Arguments:
Example: ${iconv_start UTF-8 ISO_8859-1}
Lua: ???????????????????
${iconv_stop}:
#~ Arrêtez la conversion du jeu de codes iconv.
Arguments:
Example: ${iconv_stop}
Lua: ????????????????
${if_empty}:
#~ Si la variable Conky VAR est vide, affiche tout ce qui se trouve entre ${if_empty} & le ${endif} correspondant.
Arguments: [var]
Example: ${if_empty var} ${else} ${endif}
Lua: ${if_empty var} pré else ${else} post else ${endif}
${if_existing}:
#~ Si le fichier nommé existe, affichez tout entre "${if_existing}" & le "${endif}" correspondant.
#~ Le deuxième paramètre facultatif vérifie le fichier contenant la chaîne spécifiée & imprime tout entre "${if_existing}" & le "${endif}" correspondant.
Arguments: file_name [chaîne]
Example: ${if_existing /etc/results.log "fail"} prés else ${else} post else ${endif}
Lua: ${if_existing /home/utilisateur/results.log "fail"} prés else ${else} post else ${endif}
${if_gw}:
#~ S'il y a au moins une passerelle par défaut, affichez tout entre ${if_gw} & le ${endif} correspondant.
Arguments:
Example: ${if_gw} il y a une passerelle ${else} il n y a pas une passerelle ${endif}
Lua: ${if_gw} il y a une passerelle ${else} il n y a pas une passerelle ${endif}
${if_match}:
#~ Évalue l'expression booléenne donnée, en affichant tout ce qui se trouve entre "${if_match}" & le "${endif}" correspondant selon que l'évaluation renvoie vrai ȣ non.
#~ Les expressions valides se composent d'un côté gauche, d'un opérateur & d'un côté droit.
#~ Les côtés gauche & droit sont analysés pour les objets texte contenus avant l'évaluation.
#~ Les types de côtés gauche & droit reconnus sont :
#~ double - L'argument se compose uniquement de chiffres & d'un seul point.
#~ long - L'argument se compose uniquement de chiffres.
#~ string - L'argument est entouré de guillemets doubles (").
#~ Les opérandes valides sont :
#~ > - Supérieur à
#~ < - Inférieur à
#~ >= - Supérieur ȣ égal
#~ <= - Inférieur ȣ égal
#~ == - Égal
#~ != - Non égal
Arguments: expression
Example: ${if_match "${tcp_portmon 1 65534 rip eth0}">""} prés else ${else} post else${endif}
Lua: ${if_match "${tcp_portmon 1 65534 rip eno1}">""} prés else ${else} post else${endif}
${if_mixer_mute}:
#~ Si le mixeur existe, affichez tout entre "${if_mixer_mute}" & le "${endif}" correspondant. Si aucun mélangeur n'est spécifié, "Vol" est utilisé.
Arguments: [mixer]
Example:${if_mixer_mute} ${endif}
Lua:???????????????
${if_mounted}:
#~ Si MOUNTPOINT est monté, affiche tout ce qui se trouve entre "${if_mount}" & le "${endif}" correspondant.
Arguments: [mountpoint]
Example: ${if_mounted /media/Mondisk} ${else} ${endif}
Lua:????????????????
${if_mpd_playing}:
#~ Si mpd est en cours de lecture ȣ en pause, affiche tout entre "${if_mpd_playing}" & le "${endif}" correspondant.
Arguments:
Example: ${if_mpd_playing} ${else} ${endif}
Lua:?????????????????????
${if_running}:
#~ Si PROCESS est en cours d'exécution, affiche tout ce qui se trouve entre "${if_running}" & le "${endif}" correspondant.
#~ Cela utilise la commande "pidof", donc le commutateur -x est également pris en charge.
#~ -x = Inclut les identifiants de processus des shells exécutant les scripts nommés.
Arguments: [-x] process_name
Example: ${if_running firefox} ... ${endif}
Lua:????????????????????????
${if_smapi_bat_installed}:
#~ Lors de l'utilisation de SMAPI, si la batterie avec l'index "battery_number" (nombre entier uniquement) est installée,
#~ affichez tout entre "${if_smapi_bat_installed}" & le "${endif}" correspondant. Le numéro de batterie par défaut est "0".
Arguments: [battery_number]
Example:
${if_smapi_bat_installed 1} ... ${endif}
Lua:??????????????????????
${if_up}:
#~ Si "l'interface" nommée existe & est active (selon le paramètre if_up_strictness), affichez tout entre "${if_up}" & le "${endif}" correspondant.
Arguments: [interface]
Example: ${if_up eth0} ... ${else} ... ${endif}
Lua: ${if_up eth0} ... ${else} ... ${endif}
${if_updatenr}:
#~ Si c'est la UPDATENR-ième mise à jour de Conky, affichez tout entre "${if_updatenr}" & le "${endif}" correspondant.
#~ Le compteur se réinitialise lorsque le UPDATENR le plus élevé est atteint.
#~ L'exemple suivant définit le UPDATENR le plus élevé sur "4".
Arguments: [update_number]
Example: ${if_updatenr 1}foo${endif} ${if_updatenr 2}bar${endif} ${if_updatenr 4}${endif}
#~ Cela montre "foo" 25% du temps suivi de "bar" 25% du temps suivi de rien l'autre moitié du temps.
Lua:${if_updatenr 1}°T ambiante: ${i8k_cpu_temp}°C${endif}${if_updatenr 7}CM: ${i8k_left_fan_rpm}rpm${endif}${if_updatenr 13}CPU: ${i8k_right_fan_rpm}rpm${endif}
${if_xmms2_connected}:
#~ Affiche tout entre "${if_xmms2_connected}" & le "${endif}" correspondant si xmms2 est en cours d'exécution.
Arguments:
Example: ${if_xmms2_connected} ... ${else} ... ${endif}
Lua:?????????????????????????
${image}:
#~ Rend une image à partir du chemin spécifié à l'aide d'Imlib2. Prend 4 arguments facultatifs :
#~ une position (-p x, y), une taille (-s largeur x hauteur), un commutateur sans cache (-n) & un intervalle de vidage du cache (-f #) en secondes.
#~ Voir aussi imlib_cache_flush_interval.
#~ Changer la position x,y déplace la position de l'image dans la fenêtre Conky, & changer la largeur x hauteur de l'image à partir du point central x,y.
#~ Si vous spécifiez l'indicateur de non-cache (-n), l'image ne sera pas mise en cache en mémoire, forçant son chargement à chaque actualisation de Conky.
#~ Alternativement, vous pouvez spécifier le commutateur -f N pour spécifier un intervalle de vidage du cache pour une image particulière en secondes.
Arguments: <path to image> [-p x,y] [-s WxH] [-n] [-f interval]
Example: ${image ~/cheeseburger.jpg -p 20,20 -s 200x200 -f 300}
#~ Cela rend "cheeseburger.jpg" centré sur (20,20) mis à l'échelle à 200x200 pixels mis à jour une fois toutes les 5 minutes.
#~ Conky ne fait aucune tentative pour ajuster la position ȣ tout autre formatage des images, elles sont simplement rendues selon les arguments passés.
#~ La seule raison pour laquelle ${image} fait partie de la section TEXT est de permettre des modifications d'exécution du fichier image
#~ directement via "execp", "lua_parse" ȣ via une autre méthode.
#~ Les images qui ne changent pas doivent faire partie de l'arrière-plan ȣ du papier peint pour de meilleures performances.
Lua: ${image /home/utilisateur/.face.png -p 20,20 -s 200x200 -f 300}
${imap_messages}:
#~ Affiche le nombre de messages dans votre boîte de réception IMAP globale par défaut.
#~ Vous pouvez définir des boîtes de réception IMAP individuelles séparément en transmettant le nom du dossier avec l'argument "-f". Les arguments sont :
#~ host = L'URL du serveur de messagerie IMAP
#~ username = Le nom d'utilisateur pour accéder au compte
#~ password = Utilisez "*" pour que Conky demande le mot de passe.
#~ -i intervalle = fréquence d'interrogation en secondes. La valeur par défaut est 300 (5 minutes)
#~ -f "dossier" = le dossier par défaut est "INBOX"
#~ -p port = le port par défaut est 143
#~ -e "commande" = Commande IMAP facultative à envoyer.
#~ -r retries = La valeur par défaut est 5 avant d'abandonner.
Arguments: host username password [-i interval (in seconds)] [-f "folder"] [-p port] [-e "command"] [-r retries]
Example: ${imap_messages imap.example.com user *}
Lua: ${imap_messages imap.example.com user *}
${imap_unseen}:
#~ Affiche le nombre de messages non lut de votre boîte de réception IMAP globale par défaut.
#~ Vous pouvez définir des boîtes de réception IMAP individuelles séparément en transmettant le nom du dossier avec l'argument "-f". Les arguments sont :
#~ host = L'URL du serveur de messagerie IMAP
#~ username = Le nom d'utilisateur pour accéder au compte
#~ password = Utilisez "*" pour que Conky demande le mot de passe.
#~ -i intervalle = fréquence d'interrogation en secondes. La valeur par défaut est 300 (5 minutes)
#~ -f "dossier" = le dossier par défaut est "INBOX"
#~ -p port = le port par défaut est 143
#~ -e "commande" = Commande IMAP facultative à envoyer.
#~ -r retries = La valeur par défaut est 5 avant d'abandonner.
Arguments: host username password [-i interval (in seconds)] [-f "folder"] [-p port] [-e "command"] [-r retries]
Example: ${imap_unseen imap.example.com user *}
Lua: ${imap_unseen imap.example.com user *}
${include}:
#~ Charge le fichier de configuration spécifié, applique en interne les paramètres de configuration comme s'ils apparaissaient au-dessus
#~ de la ligne TEXT dans le fichier d'origine & place les vars là où la variable d'inclusion apparaissait. Cela ne modifie pas le fichier source.
Arguments: filename
Example: ${include /etc/conky/common.cfg}
Lua:???????????????????
${ioscheduler}:
#~ Imprime l'ioscheduler actuel utilisé pour le nom de disque donné. Le nom du disque ressemble à "hda" ȣ "sdb".
Arguments: disk
Example: ${ioscheduler sda}
Lua: ${ioscheduler sda}
${kernel}:
#~ Affiche la version actuelle du noyau en cours d'exécution.
Arguments:
Example: ${kernel}
Lua: ${kernel}
${laptop_mode}:
#~ La valeur de "/proc/sys/vm/laptop_mode"
Arguments:
Example: ${laptop_mode}
Lua: ${laptop_mode}
${lines}:
#~ Affiche le nombre de lignes dans le fichier donné. Voir les mots.
Arguments: textfile
Example: ${lines ~/example.txt}
Lua: ${lines ~/example.txt}
${loadavg}:
#~ Moyenne de la charge du système, "1" correspond à la dernière minute, "2" aux 5 dernières minutes & "3" aux 15 dernières minutes.
#~ Sans argument, imprime les trois valeurs séparées par des espaces.
Arguments: [1|2|3]
Example: ${loadavg 1}
Lua: Charge: à 1 minute ${loadavg 1}, à 5 minutes ${loadavg 2}, & à 15 minutes ${loadavg 3}.
${loadgraph}:
#~ Graphique moyen Load1, similaire à xload, avec des couleurs facultatives en hexadécimal RVB.
#~ Utilise une échelle logarithmique (pour voir les petits nombres) lorsque vous utilisez le commutateur "-l".
#~ Prend le commutateur "-t" pour utiliser un gradient de température, ce qui fait que les valeurs du gradient changent
#~ en fonction de l'amplitude d'une valeur graphique particulière (essayez & voyez).
Arguments: [height][,width] [gradient color 1] [gradient color 2] [scale] [-t] [-l]
Example: ${loadgraph 20,120 888888 FFFFFF -t}
Lua: ${loadgraph 20,120 888888 FFFFFF -t}
${lua}:
#~ Exécute une fonction Lua avec des paramètres donnés, puis imprime la chaîne renvoyée.
#~ Voir aussi lua_load pour savoir comment charger des scripts.
#~ Conky place "conky_" devant function_name pour éviter les appels accidentels à la mauvaise fonction à moins que vous ne placiez vous-même "conky_" devant.
Arguments: function_name [function_parameters]
Example: ?????????????????????
Lua: ?????????????????????
${lua_bar}:
#~ Exécute une fonction Lua avec des paramètres donnés & dessine une barre.
#~ Attend que la valeur du résultat soit un entier compris entre 0 & 100.
#~ Voir aussi lua_load pour savoir comment charger des scripts.
#~ Conky place "conky_" devant le nom de la fonction pour éviter les appels accidentels à la mauvaise fonction à moins que vous ne placiez vous-même "conky_" devant.
Arguments: [height, width] function_name [function_parameters]
Example: ?????????????????????
Lua: ?????????????????????
${lua_gauge}:
#~ Exécute une fonction Lua avec des paramètres donnés & dessine une jauge.
#~ Attend que la valeur du résultat soit un entier compris entre 0 & 100.
#~ Voir aussi lua_load pour savoir comment charger des scripts.
#~ Conky place "conky_" devant le nom de la fonction pour éviter les appels accidentels à la mauvaise fonction à moins que vous ne placiez vous-même "conky_" devant.
Arguments: [height, width] function_name [function_parameters]
Example: ?????????????????????
Lua: ?????????????????????
${lua_graph}:
#~ Exécute une fonction Lua avec & dessine un graphe.
#~ S'attend à ce que la valeur du résultat soit n'importe quel nombre et, par défaut, elle sera mise à l'échelle pour afficher la plage complète.
#~ Voir aussi lua_load pour savoir comment charger des scripts.
#~ Prend le commutateur '-t' pour utiliser un gradient de température, ce qui fait que les valeurs de gradient changent
#~ en fonction de l'amplitude d'une valeur graphique particulière (essayez & voyez).
#~ Conky place "conky_" devant le nom de la fonction pour éviter les appels accidentels à la mauvaise fonction à moins que vous ne placiez vous-même "conky_" devant.
Arguments: function_name [height][,width] [gradient color 1] [gradient color 2] [scale] [-t] [-l]
Example: ?????????????????????
Lua: ?????????????????????
${lua_parse}:
#~ Exécute une fonction Lua avec des paramètres donnés selon "$lua", puis analyse & imprime la valeur du résultat selon la syntaxe de la section TEXT de Conky.
#~ Voir aussi lua_load pour savoir comment charger des scripts.
#~ Conky place "conky_" devant le nom de la fonction pour éviter les appels accidentels à la mauvaise fonction à moins que vous ne placiez vous-même "conky_" devant.
Arguments: function_name [function_parameters]
Example: ?????????????????????
Lua: ?????????????????????
${machine}:
#~ Affiche les informations sur la classe CPU de la machine. Par exemple, "x86_64" ȣ "i686".
Arguments:
Example: ${machine}
Lua: ${machine}
${mails}:
#~ Compte de courrier dans la boîte aux lettres spécifiée ȣ votre spool de courrier si ce n'est pas le cas.
#~ Les boîtes aux lettres de type mbox & maildir sont prises en charge.
#~ Vous pouvez utiliser un programme comme fetchmail pour récupérer les mails d'un serveur en utilisant votre protocole préféré. Voir aussi new_mails.
Arguments: [mailbox]
Example:???????????????
Lua:??????????????
${mboxscan}:
#~ Imprimer un résumé des messages récents dans un fichier de boîte aux lettres au format mbox.
#~ -n # = nombre de messages à afficher
#~ -fw # = largeur en caractères du champ FROM
#~ -sw # = largeur en caractères du champ SUBJECT
#~ mbox = nom de fichier de la boîte aux lettres entre guillemets doubles ("")
Arguments: [-n #] [-fw #] [-sw #] mbox
Example: ${mboxscan -n 10 "/home/user/some box"}
Lua:?????????????????????
${mem}:
#~ Quantité de mémoire utilisée.
Arguments:
Example: ${mem}
Lua: ${mem}
${membar}:
#~ Barre indiquant la quantité de mémoire utilisée.
Arguments: [height][,width]
Example: ${membar 10,60}
Lua: ${membar 10,60}
${memeasyfree}:
#~ Quantité de mémoire libre incluant la mémoire qui se libère très facilement comme "buffers/cache".
Arguments:
Example: ${memeasyfree}
Lua: ${memeasyfree}
${memfree}:
#~ Quantité de mémoire libre.
Arguments:
Example: ${memfree}
Lua: ${memfree}
${memgauge}:
#~ Jauge indiquant la quantité de mémoire utilisée. Voir ${cpugauge} pour des informations de formatage supplémentaires.
Arguments: [height][,width]
Example: ${memgauge 10,120}
Lua: ${memgauge 10,120}
${memgraph}:
#~ Graphique d'utilisation de la mémoire. Utilise une échelle logarithmique pour rendre les petits nombres plus visibles lorsque vous utilisez le commutateur -l.
#~ Prend le commutateur '-t' pour utiliser un gradient de température, ce qui fait que les valeurs du gradient changent
#~ en fonction de l'amplitude d'une valeur graphique particulière.
Arguments: [height][,width] [gradient color 1] [gradient color 2] [scale] [-t] [-l]
Example: ${memgraph 10,120 555555 AAAAAA -l}
Lua: ${memgraph 10,120 555555 AAAAAA -l}
${memmax}:
#~ Quantité totale de mémoire disponible pour le système d'exploitation hôte.
#~ Dans les systèmes dotés d'un matériel d'affichage vidéo qui utilise la RAM système au lieu de la mémoire vidéo discrète,
#~ ce nombre est toujours inférieur à la quantité physique de RAM installée.
Arguments:
Example: ${memmax}
Lua: ${memmax}
${memperc}:
#~ Pourcentage de mémoire utilisée.
Arguments:
Example: ${memperc}
Lua: ${memperc}
${mixer}:
#~ Imprime la valeur du mélangeur telle que rapportée par le système d'exploitation.
#~ Sous Linux, cette variable utilise l'émulation OSS qui nécessite le chargement du module de noyau approprié.
#~ Le mélangeur par défaut est "Vol", mais vous pouvez spécifier l'un des contrôles OSS disponibles :
#~ Bass CD Digital1 Digital2 Digital3 IGain Line Line1 Line2 Line3 Mic Mix Monitor
#~ OGain Pcm Pcm2 PhoneIn PhoneOut Radio Rec Spkr Synth Trebl Video Vol
Arguments: [device]
Example: ${mixer vol}
Lua:???????????????
${mixerbar}:
#~ Affiche la valeur du mélangeur dans une barre telle que rapportée par le système d'exploitation.
#~ Voir mélangeur pour plus de détails sur les arguments.
Arguments: <device> [size_x[,size_y]]
Example: ${mixerbar vol 10,20}
Lua:????????????????????????
${mixerl}:
#~ Imprime la valeur du mélangeur du canal gauche telle que rapportée par le système d'exploitation.
#~ Voir mélangeur pour plus de détails sur les arguments.
Arguments: [device]
Example: ${mixerl vol}
Lua:????????????????????????????
${mixerlbar}:
#~ Affiche la valeur du mélangeur du canal gauche dans une barre telle que rapportée par le système d'exploitation.
#~ Voir mélangeur pour plus de détails sur les arguments.
Arguments: <device> [size_x[,size_y]]
Example:${mixerlbar vol 10,20}
Lua:???????????????????
${mixerr}:
#~ Imprime la valeur du mélangeur du canal droit telle que rapportée par le système d'exploitation.
#~ Voir mélangeur pour plus de détails sur les arguments.
Arguments: [device]
Example: ${mixerr vol}
Lua:???????????????????
${mixerrbar}:
#~ Affiche la valeur du mélangeur du canal droit dans une barre telle que rapportée par le système d'exploitation.
#~ Voir mélangeur pour plus de détails sur les arguments.
Arguments: <device> [size_x[,size_y]]
Example: ${mixerrbar vol 10,20}
Lua:?????????????????????
${moc_album}:
#~ Album de la chanson actuelle du MOC.
Arguments:
Example: ${moc_album}
Lua:??????????????????????
${moc_artist}:
#~ Artiste de la chanson actuelle du MOC.
Arguments:
Example: ${moc_artist}
Lua:?????????????????????????
${moc_bitrate}:
#~ Bitrate dans la chanson MOC actuelle.
Arguments:
Example: ${moc_bitrate}
Lua:????????????????????????
${moc_curtime}:
#~ Heure actuelle de la chanson MOC actuelle.
Arguments:
Example: ${moc_curtime}
Lua:???????????????????????
${moc_file}:
#~ Nom de fichier du morceau MOC actuel.
Arguments:
Example: ${moc_file}
Lua:???????????????????
${moc_rate}:
#~ Taux de la chanson MOC actuelle.
Arguments:
Example: ${moc_rate}
Lua:???????????????
${moc_song}:
#~ Le nom de la chanson en cours de lecture dans MOC.
Arguments:
Example: ${moc_song}
Lua:????????????????????????????
${moc_state}:
#~ État actuel du MOC ; jouer, s'arrêter, etc.
Arguments:
Example: ${moc_state}
Lua:????????????????????????
${moc_timeleft}:
#~ Temps restant dans la chanson MOC actuelle.
Arguments:
Example: ${moc_timeleft}
Lua:?????????????????
${moc_title}:
#~ Titre de la chanson MOC actuelle.
Arguments:
Example: ${moc_title}
Lua:???????????????????
${moc_totaltime}:
#~ Longueur totale de la chanson MOC actuelle.
Arguments:
Example: ${moc_totaltime}
Lua:???????????????????????
${monitor}:
#~ Numéro du moniteur sur lequel Conky tourne ȣ le message "Not running in X" si c'est le cas.
Arguments:
Example: ${monitor}
Lua: ${monitor}
${monitor_number}:
#~ Nombre de moniteurs ȣ le message "Ne fonctionne pas dans X" si c'est le cas.
Arguments:
Example: ${monitor_number}
Lua: ${monitor_number}
${mpd_album}:
#~ Album dans la chanson MPD actuelle.
Arguments:
Example: ${mpd_album}
Lua:???????????????????????????
${mpd_artist}:
#~ L'artiste dans la chanson MPD actuelle doit être activé à la compilation.
Arguments:
Example: ${mpd_artist}
Lua::???????????????????????????
${mpd_bar}:
#~ Barre de progression de mpd.
Arguments: [height][,width]
Example: ${mpd_bar 10,20}
Lua:
${mpd_bitrate}:
#~ Bitrate de la chanson en cours.
Arguments:
Example:${mpd_bitrate}
Lua::???????????????????????????
${mpd_date}:
#~ Date de la chanson en cours.
Arguments:
Example: ${mpd_date}
Lua:
${mpd_elapsed}:
#~ Temps écoulé de la chanson.
Arguments:
Example: ${mpd_elapsed}
Lua::???????????????????????????
${mpd_file}:
#~ Imprime le nom de fichier du morceau MPD actuel.
Arguments:
Example:${mpd_file}
Lua::???????????????????????????
${mpd_length}:
#~ Durée de la chanson.
Arguments:
Example: ${mpd_length}
Lua::???????????????????????????
${mpd_name}:
#~ Imprime le champ du nom MPD.
Arguments:
Example: ${mpd_name}
Lua::???????????????????????????
${mpd_percent}:
#~ Pourcentage de progression de la chanson.
Arguments:
Example: ${mpd_percent}
Lua:
${mpd_random}:
#~ Affiche l'état aléatoire actuel "On" ȣ "Off".
Arguments:
Example: ${mpd_random}
Lua::???????????????????????????
${mpd_repeat}:
#~ Statut de répétition "On" ȣ "Off".
Arguments:
Example: ${mpd_repeat}
Lua::???????????????????????????
${mpd_smart}:
#~ Affiche le nom de la chanson sous la forme "artiste - titre" ȣ nom de fichier, selon ce qui est disponible.
Arguments: [max_length]
Example: ${mpd_smart 30}
Lua::???????????????????????????
${mpd_status}:
#~ Jouer, s'arrêter, etc.
Arguments:
Example: ${mpd_status}
Lua::???????????????????????????
${mpd_title}:
#~ Titre de la chanson MPD actuelle.
Arguments: [max_length]
Example: ${mpd_title 30}
Lua::???????????????????????????
${mpd_track}:
#~ Imprime le champ de piste MPD.
Arguments:
Example: ${mpd_track}
Lua::???????????????????????????
${mpd_vol}:
#~ Le volume du MPD.
Arguments:
Example: ${mpd_vol}
Lua:
${nameserver}:
#~ Imprimez un serveur de noms DNS à partir de "/etc/resolv.conf". L'index commence à & est par défaut à 0.
Arguments: [index]
Example: ${nameserver 0}
Lua::???????????????????????????
${new_mails}:
#~ Si ce n'est pas le cas, le nombre de messages non lus dans la boîte aux lettres ȣ le spouleur de courrier spécifié.
#~ Les boîtes aux lettres de type mbox & maildir sont prises en charge.
Arguments: [mailbox]
Example: ??????????????????????
Lua:??????????????????????
${nodename}:
#~ Nom d'hôte du système local.
Arguments:
Example: ${nodename}
Lua: ${nodename}
${nodename_short}:
#~ Nom d'hôte court. Identique à la commande shell "hostname -s".
Arguments:
Example: ${nodename_short}
Lua: ${nodename_short}
${nvidia}:
#~ Prise en charge des cartes graphiques Nvidia à l'aide de la bibliothèque XNVCtrl.
#~ Chaque option "élément" peut être raccourcie à la partie la moins significative, comme indiqué ci-dessous.
#~ Les températures sont affichées sous forme flottante, toutes les autres valeurs sous forme d'entiers.
#~ threshold - La température seuil à laquelle le GPU ralentit
#~ temp - Donne la température actuelle du GPU
#~ ambient - Donne la température actuelle de l'air près du boîtier du GPU
#~ gpufreq - Donne la fréquence actuelle du GPU
#~ memfreq - Donne la fréquence actuelle de la mémoire
#~ imagequality - Quelle qualité d'image doit être choisie par les applications OpenGL
Arguments: item
Example: ${nvidia threshold}
Lua:??????????????????????
${offset}:
#~ Déplacez le texte du nombre de pixels donné vers la droite. Les valeurs négatives se déplacent vers la gauche. Voir aussi ${goto} ${voffset}.
Arguments: [pixels]
Example: ${offset 10}
Lua: ${offset 10}
${outlinecolor}:
#~ Changer la couleur du contour. Mêmes règles que default_outline_color.
Arguments: [color]
Example: ${outlinecolor 3c3b37}
Lua: ${outlinecolor 3c3b37}
${pb_battery}:
#~ Si vous utilisez Apple Powerbook/iBook, affichez des informations sur l'état de la batterie.
#~ Le paramètre item spécifie les informations à afficher. Un seul élément doit être spécifié. Les éléments valides sont :
#~ statut - Affichage si la batterie est complètement chargée, en charge, en décharge ȣ absente lorsqu'elle fonctionne sur secteur
#~ percent - Affiche la charge de la batterie en pourcentage, si elle est en charge ȣ en décharge.
#~ Rien ne s'affiche si la batterie est complètement chargée ȣ absente.
#~ time - Affiche le temps restant jusqu'à ce que la batterie soit complètement chargée ȣ déchargée au rythme actuel.
#~ Rien ne s'affiche si la batterie est absente ȣ si elle est présente mais complètement chargée & ne se décharge pas.
Arguments: item
Example: ${pb_battery status}
Lua: ,???????????????
${pid_chroot}:
#~ Répertoire utilisé comme répertoire racine par le processus.
#~ Ce sera toujours "/" sauf si le processus a fait un "appel système chroot".
Arguments: pid
Example: ${pid_chroot 238341}
Lua: ,???????????????
${pid_cmdline}:
#~ Ligne de commande avec laquelle ce processus a été invoqué.
Arguments: pid
Example: ${pid_cmdline 238341}
Lua:,???????????????
${pid_cwd}:
#~ Répertoire de travail actuel du processus.
Arguments: pid
Example: ${pid_cwd 238341}
Lua:,???????????????
${pid_environ}:
#~ Contenu d'une variable d'environnement du processus.
Arguments: pid varname
Example: ${pid_environ 238341}
Lua:,???????????????
${pid_environ_list}:
#~ Liste des variables d'environnement que le processus peut voir.
Arguments: pid
Example: ${pid_environ_list 238341}
Lua: ?????????????????????
${pid_exe}:
#~ Chemin d'accès à la commande exécutée qui a démarré le processus.
Arguments: pid
Example: ${pid_exe 238341}
Lua:,???????????????
${pid_nice}:
#~ La belle valeur du processus.
Arguments: pid
Example: ${pid_nice 238341}
Lua:,???????????????
${pid_openfiles 2649}:
#~ Liste des fichiers ouverts par le processus.
Arguments: pid
Example: ${pid_openfiles 238341}
Lua:,???????????????
${pid_parent}:
#~ Le pid du parent du processus.
Arguments: pid
Example: ${pid_parent 238341}
Lua:
${pid_priority}:
#~ La priorité du processus. Voir "priorité" dans "man 5 proc".
Arguments: pid
Example: ${pid_priority 238341}
Lua:,???????????????
${pid_read}:
#~ Nombre total d'octets lus par le processus.
Arguments: pid
Example: ${pid_read 238341}
Lua:
${pid_state}:
#~ État du processus. Courir, dormir, attendre, zombie, tracé, arrêté, pagination.
Arguments: pid
Example: ${pid_state 238341}
Lua:,???????????????
${pid_state_short}:
#~ L'un des caractères de "RSDZTW" représentant l'état du processus où
#~ R = courir
#~ S = dormir dans une attente interruptible
#~ D = attente en veille de disque sans interruption
#~ Z = zombi
#~ T = tracé ȣ arrêté (sur un signal)
#~ W = pagination
Arguments: pid
Example: ${pid_state_short 238341}
Lua:,???????????????
${pid_stderr}:
#~ Descripteur de fichier lié au STDERR du processus.
Arguments: pid
Example: ${pid_stderr 238341}
Lua:,???????????????
${pid_stdin}:
#~ Descripteur de fichier lié au STDIN du processus.
Arguments: pid
Example: ${pid_stdin 238341}
Lua:,???????????????
${pid_stdout}:
#~ Descripteur de fichier lié au STDOUT du processus.
Arguments: pid
Example: ${pid_stdout 238341}
Lua:,???????????????
${pid_threads}:
#~ Nombre de threads en cours contenant ce thread.
Arguments: pid
Example: ${pid_threads 238341}
Lua:,???????????????
${pid_thread_list}:
#~ Liste avec les pid des threads de ce processus.
Arguments: pid
Example: ${pid_thread_list 238341}
Lua:,???????????????
${pid_time_kernelmode}:
#~ Durée pendant laquelle le processus a été planifié en mode noyau en secondes.
Arguments: pid
Example: ${pid_time_kernelmode 2649}
Lua:,???????????????
${pid_time_usermode}:
#~ Durée pendant laquelle le processus a été planifié en mode utilisateur en secondes.
Arguments: pid
Example: ${pid_time_usermode 238341}
Lua:,???????????????
${pid_time}:
#~ Somme de $pid_time_kernelmode & $pid_time_usermode.
Arguments: pid
Example:${pid_time 238341}
Lua:,???????????????
${pid_uid}:
#~ L'uid réel du processus.
Arguments: pid
Example: ${pid_uid 238341}
Lua:,???????????????
${pid_euid}:
#~ L'uid effectif du processus.
Arguments: pid
Example: ${pid_euid 238341}
Lua:,???????????????
${pid_suid}:
#~ L'uid de l'ensemble enregistré du processus.
Arguments: pid
Example: ${pid_suid 238341}
Lua:
${pid_fsuid}:
#~ L'UID du système de fichiers du processus.
Arguments: pid
Example: ${pid_fsuid 238341}
Lua: ?????????????????????
${pid_gid}: pid
#~ Le vrai gid du processus.
Arguments:
Example: ${pid_gid 238341}
Lua:,???????????????
${pid_egid}: pid
#~ Le gid effectif du processus.
Arguments:
Example: ${pid_egid 238341}
Lua:,???????????????
${pid_sgid}: pid
#~ GID de l'ensemble enregistré du processus.
Arguments:
Example: ${pid_sgid 238341}
Lua:,???????????????
${pid_fsgid}:
#~ GID du système de fichiers du processus.
Arguments: pid
Example: ${pid_fsgid 238341}
Lua:,???????????????
${pid_vmpeak}:
#~ Taille maximale de la mémoire virtuelle du processus.
Arguments: pid
Example: ${pid_vmpeak 238341}
Lua:,???????????????
${pid_vmsize}:
#~ Taille de la mémoire virtuelle du processus.
Arguments: pid
Example: ${pid_vmsize 238341}
Lua:,???????????????
${pid_vmlck}:
#~ Taille de la mémoire verrouillée du processus.
Arguments: pid
Example: ${pid_vmlck 238341}
Lua:,???????????????
${pid_vmhwm}:
#~ Taille maximale de l'ensemble résident ȣ "point d'eau haut" du processus.
Arguments: pid
Example: ${pid_vmhwm 238341}
Lua:,???????????????
${pid_vmrss}:
#~ Taille de l'ensemble résident du processus.
Arguments: pid
Example:${pid_vmrss 238341}
Lua:,???????????????
${pid_vmdata}:
#~ Taille du segment de données du processus.
Arguments: pid
Example: ${pid_vmdata 238341}
Lua:,???????????????
${pid_vmstk}:
#~ Taille de segment de pile du processus.
Arguments: pid
Example: ${pid_vmstk 238341}
Lua:,???????????????
${pid_vmexe}:
#~ Taille du segment de texte du processus.
Arguments: pid
Example: ${pid_vmexe 238341}
Lua:,???????????????
${pid_vmlib}:
#~ Taille du code de la bibliothèque partagée du processus.
Arguments: pid
Example: ${pid_vmlib 238341}
Lua:
${pid_vmpte}:
#~ Taille des entrées de la table des pages du processus.
Arguments: pid
Example: ${pid_vmpte 238341}
Lua:,???????????????
${pid_write}:
#~ Nombre total d'octets écrits par le processus.
Arguments: pid
Example: ${pid_write 238341}
Lua:,???????????????
${platform}:
#~ Capteur de plate-forme de sysfs sur le noyau Linux 2.6 & supérieur.
#~ Le paramètre dev peut être omis si vous n'avez qu'un seul périphérique de plate-forme.
#~ Options de type de plate-forme :
#~ in ȣ vol = tension
#~ fan = ventilateur
#~ temp = température
#~ Le paramètre n est le numéro du capteur. Voir /sys/bus/platform/devices/ sur votre ordinateur local.
#~ Les arguments optionnels "factor" & "offset" permettent le précalcul de l'entrée brute, qui est modifiée comme suit :
#~ "input = input * factor + offset". Notez qu'ils doivent être donnés sous forme de valeurs décimales (c'est-à-dire contenir au moins une décimale).
Arguments: [dev] type n [factor offset]
Example: ${platform in} ${platform vol} ${platform fan} ${platform temp}
Lua: ?????????????????????
${pop3_unseen}:
#~ Affiche le nombre de messages non vus dans votre boîte de réception POP3 globale par défaut.
#~ Vous pouvez définir des boîtes de réception POP3 individuelles séparément en transmettant des arguments à cet objet.
#~ Les arguments sont :
#~ hôte = adresse du serveur POP3
#~ nom d'utilisateur = nom d'utilisateur POP3
#~ password = Utilisez un astérisque "*" pour être invité à entrer le mot de passe
#~ -i intervalle = Intervalle d'interrogation en secondes. La valeur par défaut est 300 (5 minutes)
#~ -p port = la valeur par défaut est 110
#~ -e "commande" = commande POP3 facultative
#~ -r retries = Le nombre de tentatives par défaut avant d'abandonner est de 5
Arguments: host username password [-i interval] [-p port] [-e "command"] [-r retries]
Example: ?????????????????????
Lua:?????????????????????
${pop3_used}:
#~ Si aucun argument n'est fourni, cela indique la quantité d'espace (en Mio, 2^20) utilisée dans votre boîte de réception POP3 globale.
#~ Vous pouvez définir des boîtes de réception POP3 individuelles séparément en fournissant les informations sur le serveur & le compte.
#~ hôte = adresse du serveur POP3
#~ nom d'utilisateur = nom d'utilisateur POP3
#~ password = Utilisez un astérisque "*" pour être invité à entrer le mot de passe
#~ -i intervalle = Intervalle d'interrogation en secondes. La valeur par défaut est 300 (5 minutes)
#~ -p port = la valeur par défaut est 110
#~ -e "commande" = commande POP3 facultative
#~ -r retries = Le nombre de tentatives par défaut avant d'abandonner est de 5
Arguments: host username password [-i interval] [-p port] [-e "command"] [-r retries]
Example: ?????????????????????
Lua:?????????????????????
${pre_exec}:
#~ Exécute une commande shell une seule fois avant que Conky n'affiche quoi que ce soit & affiche la sortie sous forme de texte.
Arguments: shell command
Example: ${pre_exec env | grep '^DESKTOP_SESSION' | cut -d'=' -f2-}
#~ Remarque : Cette commande peut ne pas fonctionner comme indiqué dans les versions de Conky postérieures à la version 1.0.
#~ Utilisez ${execi} avec un intervalle long (par exemple, 86400) pour approximer cette fonction.
Lua::?????????????????????
${processes}:
#~ Nombre total de processus, y compris les états "en veille" & "en cours d'exécution".
Arguments:
Example: ${processes}
Lua: ${processes}
${replied_mails}:
#~ Se connecte à un port TCP sur un hôte. L'hôte par défaut "localhost" lit tous les caractères disponibles pour le moment & les affiche.
Arguments: [mail_directory]
Example: ?????????????????????
Lua: ?????????????????????
${rss}:
#~ Télécharger & analyser les flux RSS.
#~ uri = L'adresse du flux RSS. Peut utiliser n'importe quel support de boucle de protocole.
#~ interval_in_minutes = Une valeur à virgule flottante de minutes entre la vérification des mises à jour. Doit être supérieur à 0. La valeur par défaut est 15.
#~ action = L'une des actions suivantes :
#~ feed_title
#~ item_title <numéro de paramètre>
#~ item_desc <numéro de paramètre>
#~ item_titles <nombre maximum d'éléments à afficher> = Afficher jusqu'à ce nombre de titres.
#~ Remarque : Conky se souvient des espaces devant cet élément & utilise autant d'espaces devant chaque élément affiché si "spaces_in_front" n'est pas spécifié.
#~ spaces_in_front = Le nombre d'espaces à mettre devant item_titles.
#~ Cet objet est threadé, & une fois qu'un thread est créé, il ne peut pas être explicitement détruit. Un thread s'exécutera pour chaque URI spécifié.
Arguments: uri interval_in_minutes action [num_par [spaces_in_front]]
Example:
${rss http://user:pass@example.com/news.rss 60 feed_title}
${rss http://user:pass@example.com/news.rss 60 item_title 1}
${rss http://user:pass@example.com/news.rss 60 item_title 2}
Lua: ?????????????????????
${running_processes}:
#~ Processus en cours d'exécution (ne dormant pas) sur le noyau Linux 2.6 ȣ supérieur.
Arguments:
Example: ${running_processes}
Lua: ${running_processes}
${running_threads}:
#~ Nombre de fils(threads) en cours d'exécution (exécutables). Linux uniquement.
Arguments:
Example: ${running_threads}
Lua: ${running_threads}
${scroll}:
#~ Faites défiler "texte" par "étape" caractères montrant "longueur" nombre de caractères en même temps.
#~ Le texte peut également contenir des variables Conky. "Step" est facultatif & par défaut sur "1" s'il n'est pas défini.
#~ Si une variable crée une sortie sur plusieurs lignes, les lignes sont placées les unes derrière les autres séparées par un "|" signe.
#~ Si vous modifiez le textcolor à l'intérieur de ${scroll}, il revient automatiquement à l'ancienne valeur à la fin.
#~ La fin & le début du texte sont séparés par "longueur" nombre d'espaces.
Arguments: length [step] text
Example: ${scroll 30 ${audacious_title}}
Lua: ${scroll 100 texte affiché}
${seen_mails}:
#~ Nombre d'e-mails marqués comme vus dans la boîte aux lettres spécifiée ȣ le spouleur d'e-mails si ce n'est pas le cas.
#~ Seules les boîtes aux lettres de type maildir sont prises en charge, le type mbox renverra -1.
Arguments: [mail_directory]
Example:?????????????????????
Lua:? ????????????????????
${shadecolor}:
#~ Changez la couleur de l'ombrage. Utilise les mêmes règles que default_shade_color.
Arguments: [color]
Example: ${shadecolor 3c3b37}
Lua: ${shadecolor ff0000}
${smapi}:
#~ Lorsque vous utilisez smapi, affichez le contenu du répertoire /sys/devices/platform/smapi. ARGS sont l'un des éléments suivants :
#~ (NOM DE FICHIER)
#~ bat [index] (NOM DU FICHIER)
#~ Il s'agit d'une méthode très brute d'accès aux valeurs smapi. Lorsqu'elles sont disponibles, mieux vaut utiliser l'une des variables smapi_* à la place.
Arguments: (FILENAME) or bat [index] (FILENAME)
Example: ????????????????????
Lua: ????????????????????
${smapi_bat_bar}:
#~ Lors de l'utilisation de smapi, affichez la capacité restante de la batterie avec l'indice INDEX sous forme de barre.
Arguments: [index][,height][,width]
Example: ????????????????????
Lua: ????????????????????
${smapi_bat_perc}:
#~ Lorsque vous utilisez smapi, affichez la capacité restante en pourcentage de la batterie avec l'index INDEX.
#~ Il s'agit d'une variable distincte car elle prend en charge l'option de configuration "use_spacer".
Arguments: [index]
Example: ????????????????????
Lua: ????????????????????
${smapi_bat_power}:
#~ Lors de l'utilisation de smapi, affichez la puissance actuelle de la batterie avec l'indice INDEX en watt.
#~ Il s'agit d'une variable distincte car la valeur lue d'origine est convertie à partir de mW.
#~ Le signe de la sortie reflète l'état de charge (positif) ȣ de décharge (négatif).
Arguments: index
Example: ????????????????????
Lua: ????????????????????
${smapi_bat_temp}:
#~ Lors de l'utilisation de smapi, affichez la température actuelle de la batterie avec l'indice INDEX en degrés Celsius.
#~ Il s'agit d'une variable distincte car la valeur lue d'origine est convertie en millidegré Celsius.
Arguments: index
Example: ????????????????????
Lua: ????????????????????
${sony_fanspeed}:
#~ Affiche les informations sur la vitesse du ventilateur Sony VAIO si la prise en charge du noyau de l'ordinateur portable Sony est activée.
#~ Linux uniquement.
Arguments:
Example: ${sony_fanspeed}
Lua: ????????????????????
${stippled_hr}:
#~ Ligne horizontale pointillée ȣ pointillée. Le nombre "espace" est le nombre de pixels pour les lacunes.
Arguments: [space]
Example: ${stippled_hr 5}
Lua: ${stippled_hr 12}
${swap}:
#~ Quantité d'échange en cours d'utilisation.
Arguments:
Example: ${swap}
Lua: ${swap}
${swapbar}:
#~ Barre qui montre la quantité d'échange en cours d'utilisation.
Arguments: [height][,width]
Example: ${swapbar 10,60}
Lua: ${swapbar 10,60}
${swapfree}:
#~ Montant de l'échange gratuit.
Arguments:
Example: ${swapfree}
Lua: ${swapfree}
${swapmax}:
#~ Montant total de l'échange.
Arguments:
Example: ${swapmax}
Lua: ${swapmax}
${swapperc}:
#~ Pourcentage de swap utilisé.
Arguments:
Example: ${swapperc}
Lua: ${swapperc}%
${sysname}:
#~ Nom du système, "Linux" par exemple.
Arguments:
Example: ${sysname}
Lua: ${sysname}
${tail ~/example.txt 5 3}:
#~ Affiche le nombre de dernières "lignes" de lignes du fichier texte fourni.
#~ Le fichier est vérifié à chaque "next_check" fois les mises à jour de Conky.
#~ Si next_check n'est pas fourni, Conky par défaut est 2.
#~ Un maximum de 30 lignes peut être affiché ȣ jusqu'à ce que text_buffer_size soit rempli.
#~ Voir ${head} pour le haut du fichier.
Arguments: logfile lines [next_check]
Example: ${tail ~/example.txt 5 3}
Lua: ${tail /home/utilisateur/.conkyrc 2 10}
${tcp_portmon}:
#~ Port TCP pour IPv6 & IPv4 pour surveiller l'activité du port local spécifié. Les numéros de port doivent être compris entre 1 & 65535.
#~ Les noms "d'éléments" suivants peuvent être utilisés pour la surveillance.
#~ count - Nombre total de connexions dans la plage. Cet élément ne permet pas de donner un "index". Le numéro d'index est requis pour tous les autres articles.
#~ rip - Adresse IP distante
#~ rhost - Nom d'hôte distant
#~ rport - Numéro de port distant
#~ rservice - Nom du service distant de /etc/services
#~ lèvre - Adresse IP locale
#~ lhost - Nom d'hôte local
#~ lport - Numéro de port local
#~ lservice - Nom du service local de /etc/services
#~ L'index de connexion vous permet d'accéder à chaque connexion dans le moniteur de port.
#~ Le moniteur renvoie des informations pour les valeurs d'index de 0 à n-1 connexions. Les valeurs supérieures à n-1 sont simplement ignorées.
#~ Voici quelques exemples montrant comment cela fonctionne.
Arguments: port_begin port_end item <index>
Example: ${tcp_portmon 6881 6999 count} #~ Affiche le nombre de connexions dans la plage de ports bittorrent.
${tcp_portmon 22 22 rip 0} #~ Affiche l'adresse IP de l'hôte distant de la première connexion sshd.
${tcp_portmon 22 22 rip 9} #~ Affiche l'adresse IP de l'hôte distant de la dixième connexion sshd.
${tcp_portmon 1 1024 rhost 0} #~ Affiche le nom d'hôte distant de la première connexion sur un port privilégié.
${tcp_portmon 1 1024 rport 4} #~ Affiche le port de l'hôte distant de la cinquième connexion sur un port privilégié.
${tcp_portmon 1 65535 lservice 14} #~ Affiche le nom du service local de la quinzième connexion dans la plage de tous les ports.
#~ Notez que les variables de moniteur de port qui partagent la même plage de ports font en fait référence au même moniteur,
#~ de sorte que de nombreuses références à une seule plage de ports pour différents éléments & différents index utilisent toutes le même moniteur en interne.
#~ En d'autres termes, le programme évite de créer des moniteurs redondants.
Lua: Nbr connections: ${tcp_portmon 1 65535 count}
Ip: ${tcp_portmon 1 65535 rip 0}
Hôte: ${tcp_portmon 1 65535 rhost 0}
№ de port: ${tcp_portmon 1 65535 rport 0}
Service: ${tcp_portmon 1 65535 lservice 0}
${templateN}:
#~ Évaluez le contenu de la variable de configuration templateN où N est une valeur comprise entre 0 & 9 inclus,
#~ en appliquant les substitutions comme décrit dans la documentation de la variable de configuration correspondante.
#~ Les arguments sont facultatifs, mais s'il y en a, tous doivent être donnés pour correspondre à l'index référencé le plus élevé dans le modèle.
#~ Vous pouvez utiliser les mêmes séquences spéciales dans chaque argument que celles valides pour une définition de modèle,
#~ par ex. pour permettre à un argument de contenir un espace blanc, chaque espace doit être échappé.
#~ L'imbrication simple des modèles est également possible de cette façon.
#~ Voici quelques exemples montrant les définitions & l'utilisation des modèles.
#~ Notez que la partie sous la ligne TEXTE montre comment chaque modèle est développé.
Arguments: [arg1] [arg2] [arg3] ...
Example: template0 ${\1\2}
template1 \1: ${fs_used \2} of ${fs_size \2}
template2 \1 \
Lua: ????????????????????
TEXT
# Après que le signe égal indique à quoi le modèle se développe.
Example: ${template0 node name} # result = ${nodename}
${template1 root /} # result = root: ${fs_used /} of ${fs_size /}
#~ Vous pouvez même passer un modèle à un autre modèle.
${template1 ${template2\ disk\ root} /} # result = disk root: ${fs_used /} of ${fs_size /}
Lua: ????????????????????
${texeci}:
#~ Exécute une commande à un intervalle dans un thread & affiche la sortie. Identique à ${execi} sauf que la commande est exécutée dans un thread.
#~ Utilisez ceci si vous avez un script lent pour maintenir la mise à jour de Conky.
#~ Vous devez allonger légèrement l'intervalle par rapport au temps d'exécution de votre script.
#~ Par exemple, si vous avez un script qui prend 5 secondes pour s'exécuter, vous devez faire en sorte que l'intervalle soit d'au moins 6 secondes.
#~ Voir aussi ${execi}.
#~ Cet objet nettoiera le thread lorsqu'il sera détruit, de sorte qu'il peut être utilisé en toute sécurité de manière imbriquée,
#~ bien qu'il puisse ne pas produire le comportement souhaité s'il est utilisé de cette manière.
Arguments: interval command
Example: ${texeci 6000 /home/utilisateur/Proprietaire.sh}
Lua: ${texeci 6000 /home/utilisateur/Proprietaire.sh}
${threads}:
#~ Nombre total de fils.
Arguments:
Example: ${threads}
Lua: ${threads}
${time}:
#~ Informations sur l'heure locale personnalisées avec une chaîne de format.
#~ Voir Variables de chaîne de format d'heure ci-dessous pour plus d'informations sur les codes de format.
Arguments: [format]
Example: ${time %T}
Lua: ${time %T}
${to_bytes}:
#~ Si "size" est un nombre suivi d'une unité de taille (kilobyte,mb,GiB,...) il est converti en octets, sinon le paramètre "size" est affiché inchangé.
Arguments: size
Example: ${to_bytes ${mem}}
Lua: Mémoire: ${to_bytes ${mem}} Octets
${top}:
#~ Cela affiche les informations de la commande supérieure où les processus sont classés du plus haut au plus bas en termes d'utilisation du processeur. Les genres sont :
#~ nom - nom du processus
#~ pid - identifiant de processus
#~ cpu - pourcentage d'utilisation actuelle du processeur
#~ mem - pourcentage d'utilisation de la mémoire actuelle
#~ mem_res - pourcentage d'utilisation de la mémoire physique
#~ mem_vsize - taille de la mémoire virtuelle
#~ temps - temps total d'activité
#~ uid - ID utilisateur du propriétaire du processus
#~ user - nom d'utilisateur du propriétaire du processus
#~ io_perc - pourcentage d'E/S
#~ io_read - entrée d'e/s
#~ io_write - sortie d'E/S
#~ Le paramètre "num" identifie le processus tel qu'il est répertorié par la commande top où 1 est le plus élevé.
#~ Un maximum de 10 processus (numérotés de 1 à 10) sont pris en charge.
Arguments: type num
Example: ${top name 1} ${top cpu 1} ${top mem 1}
${top name 2} ${top cpu 2} ${top mem 2}
Lua: ${top name 1} ${top cpu 1} ${top mem 1}
${top name 2} ${top cpu 2} ${top mem 2}
${top_io}:
#~ Identique à ${top} sauf trié par la quantité d'E/S que le processus a effectuées pendant l'intervalle de mise à jour.
Arguments: type num
Example: ${top_io name 1} ${top_io cpu 1} ${top_io io_perc 1}
${top_io name 2} ${top_io cpu 2} ${top_io io_perc 2}
Lua: ${top_io name 1} ${top_io cpu 1} ${top_io io_perc 1}
${top_io name 2} ${top_io cpu 2} ${top_io io_perc 2}
${top_mem}:
#~ Identique à ${top} sauf trié par utilisation de la mémoire au lieu de l'utilisation du processeur.
Arguments: type num
Example: ${top_mem name 1} ${top_mem cpu 1} ${top_mem mem 1}
${top_mem name 2} ${top_mem cpu 2} ${top_mem mem 2}
Lua: ${top_mem name 1} ${top_mem cpu 1} ${top_mem mem 1}
${top_mem name 2} ${top_mem cpu 2} ${top_mem mem 2}
${top_time}:
#~ Same as ${top} except sorted by total CPU time instead of current CPU usage.
Arguments: type num
Example: ${top_time name 1} ${top_time cpu 1} ${top_time time 1}
${top_time name 2} ${top_time cpu 2} ${top_time time 2}
Lua: ${top_time name 1} ${top_time cpu 1} ${top_time time 1}
${top_time name 2} ${top_time cpu 2} ${top_time time 2}
${totaldown}:
#~ Volume total de téléchargement après le démarrage de Conky. Peut déborder à 4 Go sur Linux avec une architecture 32 bits.
Arguments: [network_interface]
Example: ${totaldown eth0}
Lua: Téléchargé au total: ${totaldown eno1}
${totalup}:
#~ Volume de téléchargement total après le démarrage de Conky. Peut déborder à 4 Go sur Linux avec une architecture 32 bits.
Arguments: [network_interface]
Example: ${totalup eth0}
Lua: Envoyer au total: ${totalup eno1}
${trashed_mails}:
#~ Nombre d'e-mails marqués comme supprimés dans la boîte aux lettres spécifiée ȣ le spouleur d'e-mails si ce n'est pas le cas.
#~ Seules les boîtes aux lettres de type maildir sont prises en charge, le type mbox renverra -1.
Arguments: [mail_directory]
Example: ????????????????????
Lua: ????????????????????
${tztime}:
#~ Heure locale pour le fuseau horaire spécifié. L'argument fuseau horaire est spécifié de la même manière que la variable d'environnement TZ.
#~ Pour des conseils, regardez dans /usr/share/zoneinfo. Voir Variables de chaîne de format d'heure ci-dessous pour plus d'informations sur les codes de format facultatifs.
Arguments: [timezone [format]]
Example: ${tztime America/Los_Angeles} Los Angeles
Heure Universelle Coordonner ${tztime UTC %T}
${tztime Europe/Zurich %T} Zurich
${tztime Hongkong %T} Hong Kong
Lua: ${tztime America/Los_Angeles} Los Angeles
Heure Universelle Coordonner ${tztime UTC %T}
${tztime Europe/Zurich %T} Zurich
${tztime Hongkong %T} Hong Kong
${gid_name}:
#~ Nom du groupe avec ce gid.
Arguments: gid_number
Example: ${gid_name 1000}
Lua: ${gid_name 1000}
${uid_name}:
#~ Nom d'utilisateur de l'utilisateur avec cet uid.
Arguments: uid_number
Example: ${uid_name 1000}
Lua: ${uid_name 1000}
${unflagged_mails}:
#~ Nombre d'e-mails non marqués comme marqués dans la boîte aux lettres spécifiée ȣ le spool d'e-mails si ce n'est pas le cas.
#~ Seules les boîtes aux lettres de type maildir sont prises en charge, le type mbox renverra -1.
Arguments: [mail_directory]
Example: ?????????????????????
Lua: ?????????????????????
${unforwarded_mails}:
#~ Nombre d'e-mails non marqués comme transférés dans la boîte aux lettres désactivée ȣ le spool d'e-mails si ce n'est pas le cas.
#~ Seules les boîtes aux lettres de type maildir sont prises en charge, le type mbox renverra -1.
Arguments: [mail_directory]
Example: ?????????????????????
Lua: ?????????????????????
${unreplied_mails}:
#~ Nombre d'e-mails non marqués comme répondus dans la boîte aux lettres spécifiée ȣ le spool d'e-mails si ce n'est pas le cas.
#~ Seules les boîtes aux lettres de type maildir sont prises en charge, le type mbox renverra -1.
Arguments: [mail_directory]
Example: ?????????????????????
Lua: ?????????????????????
${unseen_mails}:
#~ Nombre d'e-mails nouveaux ȣ non vus dans la boîte aux lettres ȣ le spool d'e-mails spécifié, sinon.
#~ Seules les boîtes aux lettres de type maildir sont prises en charge, le type mbox renverra -1.
Arguments: [mail_directory]
Example: ?????????????????????
Lua: ?????????????????????
${updates}:
#~ Affiche le nombre de fois que Conky a mis à jour l'affichage depuis son démarrage. Principalement utilisé pour le débogage.
Arguments:
Example: ${updates}
Lua: ${updates}
${upspeed}:
#~ Vitesse de téléchargement dans les unités CEI (Commission électrotechnique internationale) appropriées.
Arguments: [network_interface]
Example: ${upspeed eth0}
Lua: ${upspeed eno1}o/s
${upspeedf}:
#~ Vitesse de téléchargement en KiB avec une décimale.
Arguments: [network_interface]
Example: ${upspeedf eth0}
Lua: ${upspeedf enp4s0}
${upspeedgraph}:
#~ Graphique de vitesse de téléchargement. Les couleurs sont définies en RVB hexadécimal.
#~ Si l'échelle est différente de zéro, elle devient l'échelle du graphique.
#~ Utilise une échelle logarithmique (pour voir les petits nombres) lorsque vous utilisez le commutateur -l.
#~ Prend le commutateur '-t' pour utiliser un gradient de température, ce qui fait que les valeurs de gradient changent
#~ en fonction de l'amplitude d'une valeur graphique particulière (essayez & voyez).
Arguments: [network_interface] [height][,width] [gradient color 1] [gradient color 2] [scale] [-t] [-l]
Example: ${upspeedgraph eth0 20,120 888888 FFFFFF -l}
Lua: ${upspeedgraph enp4s0 20,120 888888 FFFFFF -t}
${uptime}:
#~ La disponibilité est le temps écoulé depuis le démarrage, y compris les secondes.
Arguments:
Example: ${uptime}
Lua: ${uptime}
${uptime_short}:
#~ Disponibilité dans un format plus court sans secondes.
Arguments:
Example: ${uptime_short}
Lua: ${uptime_short}
${user_names}:
#~ Répertorie les noms des utilisateurs connectés.
Arguments:
Example: ${user_names}
Lua: ${user_names}
${user_number}:
#~ Nombre d'utilisateurs connectés.
Arguments:
Example: ${user_number}
Lua: ${user_number}
${user_terms}:
#~ Répertorie les consoles en cours d'utilisation.
Arguments:
Example: ${user_terms}
Lua: ${user_terms}
${user_times}:
#~ Indique depuis combien de temps les utilisateurs sont connectés.
Arguments:
Example: ${user_times}
Lua: ${user_times}
${user_time}:
#~ Indique depuis combien de temps l'utilisateur de la console donnée est connecté.
Arguments: console
Example: ${user_time 2}
Lua: ${user_time 2}
${utime}:
#~ Afficher l’heure en UTC (temps de coordonnées universel). Voir Time Format String Variables ci-dessous pour plus d’informations sur les codes de format optionnels.
Arguments: [format]
Example: ${utime %T}
Lua: ${utime %T}
${voffset}:
#~ Modifiez le décalage vertical de N pixels. Les valeurs négatives entraînent un chevauchement du texte. Voir aussi ${offset}.
Arguments: [pixels]
Example: ${voffset -16}
Lua: ${voffset -16}
${voltage_mv}:
#~ Renvoie la tension du CPU #n en mV. Les processeurs sont comptés à partir de 1. S'il est omis, le paramètre prend par défaut la valeur 1.
Arguments: [cpu_number]
Example: ${voltage_mv 1}
Lua: ${voltage_mv 1} ??????
${voltage_v}:
#~ Renvoie la tension du CPU #n en V. Les CPU sont comptés à partir de 1. S'il est omis, le paramètre prend par défaut la valeur 1.
Arguments: [cpu_number]
Example: ${voltage_v 1}
Lua: ${voltage_v 1} ??????
${weather}:
#~ Télécharger, analyser & afficher les données METAR. Pour l'URI. Il y a deux possibilités :
#~ http://weather.noaa.gov/pub/data/observations/metar/stations/
#~ http://xoap.weather.com/weather/local/
#~ Le premier est gratuit, mais le second vous oblige à vous inscrire & à obtenir votre identifiant de partenaire & votre clé de licence.
#~ Ces deux éléments doivent être écrits, séparés par un espace, dans un fichier appelé .xoaprc qui doit être placé dans votre répertoire personnel.
#~ 'locID' doit être un identifiant d'emplacement valide pour l'URI requis.
#~ Pour le site NOAA, il doit s'agir d'un OACI valide (voir par exemple https://pilotweb.nas.faa.gov/qryhtml/icao/).
#~ Pour le site weather.com, il doit s'agir d'un identifiant de localisation valide (voir par exemple http://aspnetresources.com/tools/locid.aspx).
#~ 'data_type' doit être l'un des suivants :
#~ last_update - La date & l'heure des données.
#~ Le résultat dépend de l'URI utilisé. Pour le site NOAA, il s'agit de la date "aaaa/mm/jj" & de l'heure UTC.
#~ Pour celui de weather.com, il s'agit de la date ([m]m/[d]d/yy) & de l'heure locale de la station.
#~ temperature - Température de l'air. Vous pouvez utiliser le paramètre de configuration "temperature_unit" pour changer les unités.
#~ cloud_cover - Le statut de couverture nuageuse le plus élevé
#~ pressure - Pression atmosphérique en millibar
#~ wind_speed - Vitesse du vent en km/h
#~ wind_dir - Direction du vent
#~ wind_dir_DEG - Direction du vent de la boussole
#~ humidity - Humidité relative en %
#~ weather - Tout événement météorologique pertinent (pluie, neige, etc.).
#~ Ceci n'est pas utilisé si vous interrogez le site weather.com car ces données sont agrégées dans celle de cloud_cover
#~ icon - L'icône Météo ne fonctionne que pour www.weather.com. Peut être utilisé avec le kit d'icônes fourni lors de l'inscription à leur service.
#~ 'delay_in_minutes' (facultatif, 30 par défaut) ne peut pas être inférieur à 30 minutes.
#~ Cet objet est threadé, & une fois qu'un thread est créé, il ne peut pas être explicitement détruit. Un thread s'exécutera pour chaque URI spécifié.
#~ Notez que ces variables sont encore EXPÉRIMENTALES & peuvent être sujettes à de nombreux changements futurs.
Arguments: URI locID data_type [interval_in_minutes]
Example: ?????????????????????
Lua: ?????????????????????
${weather_forecast}:
#~ Téléchargez, analysez & affichez les données de prévisions météorologiques pour un jour donné. En journée uniquement.
#~ Pour l'URI, pour le moment, seul "http://xoap.weather.com/weather/local/" est pris en charge. Voir la météo ci-dessus pour les détails d'utilisation
#~ locID, voir "weather" ci-dessus.
#~ jour est un nombre compris entre 0 (aujourd'hui) & 4 (3 jours après demain).
#~ data_type doit être l'un des suivants :
#~ day - Jour de la semaine
#~ date - Date, sous la forme "Lun JJ" (c'est-à-dire le 14 juillet)
#~ low - Température minimale. Utilisez le paramètre de configuration "temperature_unit" pour changer les unités
#~ hi - Température maximale. Utilisez le paramètre de configuration "temperature_unit" pour changer les unités
#~ icon - Icône météo. Peut être utilisé avec le kit d'icônes fourni lors de l'inscription au service weather.com
#~ forecast - Prévisions météo (ensoleillé, pluvieux, etc.)
#~ wind_speed - Vitesse du vent en km/h
#~ wind_dir - Direction du vent
#~ wind_dir_DEG - Direction du vent de la boussole
#~ humidity - Pourcentage d'humidité relative
#~ precipitation - Probabilité d'avoir une précipitation en pourcentage
#~ 'delay_in_minutes' (optionnel, par défaut 210) ne peut pas être inférieur à 210 min.
#~ Cet objet est threadé, & une fois qu'un thread est créé, il ne peut pas être explicitement détruit.
#~ Un thread s'exécutera pour chaque URI spécifié. Vous pouvez utiliser n'importe quel protocole pris en charge par Curl.
#~ Notez que ces variables sont encore EXPÉRIMENTALES & peuvent être sujettes à de nombreux changements futurs.
Arguments: URI locID day data_type [interval_in_minutes]
Example: ${weather_forecast http://xoap.weather.com/weather/local/ LFMN forecast}
Lua: ?????????????????????
${wireless_ap}:
#~ Adresse MAC du point d'accès sans fil. Linux uniquement.
Arguments: [network_interface]
Example: ${wireless_ap wlan0}
Lua: ${wireless_ap wlan0}
${wireless_bitrate}:
#~ Débit sans fil (c'est-à-dire 11 Mb/s). Linux uniquement.
Arguments: [network_interface]
Example: ${wireless_bitrate wlan0}
Lua: ${wireless_bitrate wlan0}
${wireless_essid}:
#~ Point d'accès sans fil ESSID. Linux uniquement.
Arguments: [network_interface]
Example: ${wireless_essid wlan0}
Lua: ${wireless_essid wlan0}
${wireless_link_bar}:
#~ Barre de qualité de la liaison sans fil. Linux uniquement.
Arguments: [height][,width] [network_interface]
Example: ${wireless_link_bar 10,60 wlan0}
Lua: ${wireless_link_bar 10,60 wlan0}
${wireless_link_qual}:
#~ Qualité de la liaison sans fil. Linux uniquement.
Arguments: [network_interface]
Example: ${wireless_link_qual wlan0}
Lua: ${wireless_link_qual wlan0}
${wireless_link_qual_max}:
#~ Valeur maximale de la qualité de la liaison sans fil. Linux uniquement.
Arguments: [network_interface]
Example: ${wireless_link_qual_max wlan0}
Lua: ${wireless_link_qual_max wlan0}
${wireless_link_qual_perc}:
#~ Qualité de la liaison sans fil en pourcentage. Linux uniquement.
Arguments: [network_interface]
Example: ${wireless_link_qual_perc wlan0}%
Lua: ${wireless_link_qual_perc wlan0}%
${wireless_mode}:
#~ Mode sans fil. "Géré", "Ad-Hoc", "Maître". Linux uniquement.
Arguments: [network_interface]
Example: ${wireless_mode wlan0}
Lua: ${wireless_mode wlan0}
${words}:
#~ Affiche le nombre de mots dans le fichier donné. Voir lignes.
Arguments: textfile
Example: ${words ~/example.txt}
Lua: ${words /home/utilisateur/example.txt}
${xmms2_album}:
#~ Album dans la chanson XMMS2 actuelle.
Arguments:
Example: ${xmms2_album}
Lua: ?????????????????????
${xmms2_artist}:
#~ Artiste de la chanson XMMS2 actuelle.
Arguments:
Example: ${xmms2_artist}
Lua: ?????????????????????
${xmms2_bar}:
#~ Barre de progression de XMMS2.
Arguments: [height][,width]
Example: ${xmms2_bar 10,20}
Lua: ?????????????????????
${xmms2_bitrate}:
#~ Bitrate de la chanson en cours.
Arguments:
Example: ${xmms2_bitrate}
Lua: ?????????????????????
${xmms2_comment}:
#~ Commentaire dans la chanson XMMS2 actuelle.
Arguments:
Example: ${xmms2_comment}
Lua: ?????????????????????
${xmms2_date}:
#~ Renvoie la date de la chanson.
Arguments:
Example: ${xmms2_date}
Lua:
${xmms2_duration}:
#~ Durée de la chanson en cours.
Arguments:
Example: ${xmms2_duration}
Lua:
${xmms2_elapsed}:
#~ Temps écoulé de la chanson.
Arguments:
Example: ${xmms2_elapsed}
Lua: ?????????????????????
${xmms2_genre}:
#~ Genre de la chanson XMMS2 actuelle.
Arguments:
Example: ${xmms2_genre}
Lua: ?????????????????????
${xmms2_id}:
#~ ID XMMS2 de la chanson en cours.
Arguments:
Example: ${xmms2_id}
Lua: ?????????????????????
${xmms2_percent}:
#~ Pourcentage de progression de la chanson.
Arguments:
Example: ${xmms2_percent}
Lua: ?????????????????????
${xmms2_playlist}:
#~ Returns the XMMS2 playlist.
Arguments:
Example: ${xmms2_playlist}
Lua: ?????????????????????
${xmms2_size}:
#~ Taille de la chanson en cours.
Arguments:
Example: ${xmms2_size}
Lua: ?????????????????????
${xmms2_smart}:
#~ Imprime le nom de la chanson sous la forme "artiste - titre" ȣ nom de fichier, selon ce qui est disponible.
Arguments:
Example: ${xmms2_smart}
Lua: ?????????????????????
${xmms2_status}:
#~ État XMMS2. "Lecture", "En pause", "Arrêté" ȣ "Déconnecté".
Arguments:
Example: ${xmms2_status}
Lua: ?????????????????????
${xmms2_timesplayed}:
#~ Nombre de fois qu'une chanson a été jouée (vraisemblablement).
Arguments:
Example: ${xmms2_timesplayed}
Lua: ?????????????????????
${xmms2_title}:
#~ Titre de la chanson XMMS2 actuelle.
Arguments:
Example: ${xmms2_title}
Lua:
${xmms2_tracknr}:
#~ Numéro de piste dans la chanson XMMS2 actuelle.
Arguments:
Example: ${xmms2_tracknr}
Lua: ?????????????????????
${xmms2_url}:
#~ Chemin complet vers la chanson en cours.
Arguments:
Example: ${xmms2_url}
Lua: ?????????????????????
#~ Variables de chaîne de format d'heure
#~ La chaîne de format d'heure peut contenir des séquences de caractères spéciales appelées spécifications de conversion,
#~ dont chacune est introduite par un caractère de pourcentage "%" & terminée par un autre caractère appelé caractère spécificateur de conversion.
#~ Toutes les autres séquences de caractères sont des séquences de caractères ordinaires.
#~ Les caractères des spécifications de conversion sont SENSIBLES À LA CASSE & sont remplacés à l'aide des variables suivantes.
#~ Tout ce qui dans la chaîne de format ne correspond pas à l'une de ces variables est affiché tel quel.
%a
#~ Le nom abrégé du jour de la semaine selon les paramètres régionaux actuels.
Lun, mar, mer, jeu, ven, sam, dim
Lua: ${time %a}
%A
#~ Le nom complet du jour de la semaine selon les paramètres régionaux actuels.
Lundi Mardi Mercredi Jeudi Vendredi Samedi Dimanche
Lua: ${time %A}
%b
#~ Le nom abrégé du mois selon les paramètres régionaux actuels.
Jan, Fév, Mar, Avr, Mai, Juin, Juil, Août, Sep, Oct, Nov, Déc
Lua: ${time %b}
%B
#~ Le nom complet du mois selon les paramètres régionaux actuels.
janvier, février, mars, avril, mai, juin, juillet, août, septembre, octobre, novembre, décembre
Lua: ${time %B}
%c
#~ Représentation préférée de la date & de l'heure pour les paramètres régionaux actuels.
Lua: ${time %c}
%C
#~ Le numéro du siècle sous la forme d'un nombre entier à 2 chiffres. [Note SU]
#~ Année/100.
Lua: ${time %C}
%d
#~ Le jour du mois sous forme de nombre décimal.
#~ Plage 01 à 31.
Lua: ${time %d}
%D
#~ Équivalent à %m/%d/%y. Pour les nord-américains seulement.
#~ Pour éviter toute confusion dans un contexte international, n'utilisez pas ce format. [Note SU]
Lua: ${time %D}
%e
#~ Comme %d le jour du mois sous forme de nombre décimal mais un zéro non significatif est remplacé par un espace. [Note SU]
Lua: ${time %e}
%E
#~ Modificateur : utilisez un format alternatif, voir ci-dessous. [Note SU]
Lua: ${time %E}
%F
#~ Équivalent à %Y-%m-%d également connu sous le nom de format de date ISO 8601.
Lua: ${time %F}
%g
#~ Comme %G, mais sans siècle, c'est-à-dire avec une année à 2 chiffres. [Note TZ]
#~ Plage 00-99.
Lua: ${time %g}
%G
#~ L'année basée sur la semaine ISO 8601 [voir Notes sur la semaine] avec le siècle comme nombre décimal.
#~ L'année à 4 chiffres correspondant au numéro de semaine ISO. Voir %V.
#~ Il a le même format & la même valeur que %Y, sauf que si le numéro de semaine ISO appartient à l'année précédente ȣ suivante,
#~ cette année est utilisée à la place. [Note TZ]
Lua: ${time %G}
%h
#~ Équivalent à %b. [Note SU]
Lua: ${time %h}
%H
#~ L'heure sous forme de nombre décimal en utilisant une horloge de 24 heures.
#~ Plage de 00 à 23.
Lua: ${time %H}
%I
#~ L'heure sous forme de nombre décimal en utilisant une horloge de 12 heures.
#~ Plage 01 à 12.
Lua: ${time %I}
%j
#~ Le jour de l'année sous forme de nombre décimal.
#~ Plage 001 à 366.
Lua: ${time %j}
%k
#~ L'heure, au format 24 heures, sous forme de nombre décimal. Les chiffres simples sont précédés d'un blanc. Voir aussi %H. [Note TZ]
#~ Plage de 0 à 23.
Lua: ${time %k}
%l
#~ L'heure, au format 12 heures, sous forme de nombre décimal. Les chiffres simples sont précédés d'un blanc. Voir aussi %I. [Note TZ]
#~ Gamme 1 à 12.
Lua: ${time %l}
%m
#~ Le mois sous forme de nombre décimal
#~ Plage 01 à 12
Lua: ${time %m}
%M
#~ The minute as a decimal number
#~ Range 00 to 59.
Lua: ${time %M}
%n
#~ Un caractère de nouvelle ligne. [Note SU]
Lua: ${time %n}
%O
#~ Modificateur : utilisez un format alternatif, voir ci-dessous. [Note SU]
Lua: ${time %O}
%p
#~ Soit "AM" (Ante Meridiem) ȣ "PM" (Post Meridiem) selon la valeur de temps donnée, ȣ les chaînes correspondantes pour les paramètres régionaux actuels.
#~ 12h00 est "PM" & 12h00 minuit est "AM".
Lua: ${time %p}
%P
#~ Comme %p mais en minuscules : "am" ȣ "pm" ȣ une chaîne correspondante pour la locale actuelle.
Lua: ${time %P}
%r
#~ L'heure en notation "AM" ȣ "PM". Dans les paramètres régionaux POSIX, cela équivaut à %I:%M:%S %p. [Note SU]
Lua: ${time %r}
%R
#~ L'heure au format 24 heures, identique à %H:%M. [Note SU] Pour une version incluant les secondes, voir "%T" ci-dessous.
Lua: ${time %R}
%s
#~ Le nombre de secondes depuis l'Epoch, 1970-01-01 00:00:00 +0000 (UTC). [Note TZ]
Lua: ${time %s}
%S
#~ La seconde sous forme de nombre décimal avec une valeur maximale de 61.
#~ La plage de 62 secondes permet la possibilité théorique d'une minute incluant une seconde intercalaire double.
#~ Il n'y a jamais eu une telle minute.
#~ Plage de 00 à 61.
Lua: ${time %S}
%t
#~ Le caractère de tabulation. [Note SU]
Lua: ${time %t}
%T
#~ L'heure au format 24 heures, %H:%M:%S. [Note SU]
Lua: ${time %T}
%u
#~ Le jour de la semaine sous forme décimale, compris entre 1 & 7, lundi étant 1. Voir aussi %w. [Note SU]
Lua: ${time %u}
%U
#~ Numéro de semaine de l'année en cours sous forme de nombre décimal, compris entre 00 & 53,
#~ en commençant par le premier dimanche comme premier jour de la semaine 01. Voir aussi %V & %W.
Lua: ${time %U}
%V
#~ Le numéro de semaine ISO 8601 [voir Notes sur la semaine] de l'année en cours sous forme de nombre décimal. Voir aussi %U & %W. [Note SU]
#~ Plage 01 à 53.
Lua: ${time %V}
%w
#~ Le jour de la semaine sous forme décimale, compris entre 0 & 6, dimanche étant 0. Voir aussi %u.
Lua: ${time %w}
%W
#~ Numéro de semaine de l'année en cours sous forme de nombre décimal, compris entre 00 & 53,
#~ en commençant par le premier lundi comme premier jour de la semaine 01.
Lua: ${time %W}
%x
#~ La représentation de date préférée pour les paramètres régionaux actuels sans l'heure.
Lua: ${time %x}
%X
#~ La représentation temporelle préférée pour les paramètres régionaux actuels sans la date.
Lua: ${time %X}
%y
#~ L'année sous forme de nombre décimal à deux chiffres sans siècle.
#~ Plage de 00 à 99.
Lua: ${time %y}
%Y
#~ L'année sous la forme d'un nombre décimal à quatre chiffres incluant le siècle.
#~ Plage 0000 à 9999
Lua: ${time %Y}
%z
#~ Le fuseau horaire numérique +hhmm ȣ -hhmm indiquant le décalage des heures & des minutes par rapport à l'UTC. [Note SU]
Lua: ${time %z}
%Z
#~ Le fuseau horaire ȣ le nom ȣ l'abréviation.
Lua: ${time %Z}
%+
#~ La date & l'heure au format date(1). [Note TZ]
#~ "%a, %d %b %Y %T %z" - Format de date conforme à la RFC 2822 (avec une locale anglaise pour %a & %b)
#~ "%a, %d %b %y %T %z" - Format de date conforme à la RFC 822 (avec une locale anglaise pour %a & %b)
Lua: ${time %+}
%%
#~ Le caractère de pourcentage littéral "%".
Lua: ${time %%}
Remarques:
Spécification UNIX unique
#~ Certaines spécifications de conversion peuvent être modifiées en faisant précéder le caractère spécificateur de conversion par le modificateur E ȣ O (zéro)
#~ pour indiquer qu'un autre format doit être utilisé. Si le format ȣ la spécification alternatifs n'existent pas pour les paramètres régionaux actuels,
#~ le comportement est comme si la spécification de conversion non modifiée était utilisée.
#~ La spécification Single UNIX (SU) mentionne %Ec, %EC, %Ex, %EX, %Ey, %EY, %Od, %Oe, %OH, %OI, %Om, %OM, %OS, %Ou, %OU, %OV, %Ow, %OW, %Oy,
#~ où l'effet du modificateur "O" est d'utiliser des symboles numériques alternatifs (par exemple, des chiffres romains),
#~ & celui du modificateur "E" est d'utiliser un paramètre régional -représentation alternative dépendante.
Dates de semaine ISO 8601:
#~ Valeurs de rendement %G, %g & %V calculées à partir de l'année hebdomadaire définie par la norme ISO 8601.
#~ Dans ce système, les semaines commencent un lundi & sont numérotées de 01, pour la première semaine, jusqu'à 52 ȣ 53, pour la dernière semaine.
#~ La semaine 01 est la première semaine où
#~ Quatre jours ȣ plus tombent dans la nouvelle année ȣ
#~ La première semaine de l'année qui contient un jeudi ȣ
#~ La semaine qui contient le 4 janvier
#~ Lorsque trois jours ȣ moins de la première semaine civile de la nouvelle année tombent dans cette année,
#~ le système ISO 8601 basé sur la semaine compte ces jours comme faisant partie de la semaine 53 de l'année précédente.
#~ Par exemple, le 1er janvier 2010 était un vendredi, ce qui signifie que seuls trois jours de cette semaine civile tombent en 2010.
#~ Ainsi, le système ISO 8601 basé sur la semaine considère ces jours comme faisant partie de la semaine 53 (%V) de l'année 2009 ( %G) ;
#~ la semaine 01 de l'ISO 8601 année 2010 a débuté le lundi 4 janvier 2010.
Fuseau horaire:
#~ Toutes les valeurs d'heure sont basées sur le fuseau horaire de la machine locale, sauf indication contraire.
#~ Le fuseau horaire local peut changer si des changements d'heure d'été ȣ d'heure d'été sont observés sur la machine locale.
#~ Les heures qui font spécifiquement référence à l'UTC ne sont pas affectées par le fuseau horaire local.
Trucs & astuces Conky:
#~ Afficher le nom de la variante de bureau Ubuntu actuelle.
#~ Les versions d'Ubuntu avec plusieurs mots n'affichent que le dernier mot.
#~ Par exemple, "Ubuntu MATE" & "Ubuntu GNOME" n'affichent que "MATE" ȣ "GNOME" de manière réceptive.
# Montre Kubuntu, Lubuntu, Ubuntu, Xubuntu, etc.
Exemple: ${execi 60000 env | grep '^DESKTOP_SESSION' | cut -d'=' -f2-}
Lua: ${execi 60000 env | grep '^DESKTOP_SESSION' | cut -d'=' -f2-}
Afficher dynamiquement tous les périphériques de stockage montés:
#~ Un outil très utile pour les choses connectées à chaud comme le stockage USB.
#~ Cela utilise un modèle à la fois pour rendre l'appel execpi plus facile à comprendre
#~ & pour rendre l'affichage de chaque appareil plus cohérent avec l'édition d'un point unique pour les modifications nécessaires.
#~ Le modèle doit apparaître avant la ligne TEXT dans votre fichier de configuration.
# Formatez les informations de stockage de la même manière pour chaque appareil. Paramètres : [nom humain] [chemin]
Exemple: template3 \1 [${fs_size \2} ${fs_type \2}]${alignr}${fs_used \2} used ${fs_bar 10,60 \2}\n${alignr}${voffset -15}${fs_used_perc \2}%\nMount=${color2}\2
Lua: ????????????????????
TEXT
# afficher des informations sur les lecteurs connectés
Exemple: ${execpi 60 df -h --output=source,target | grep '^/dev/' | cut --characters=6- | sed 's/^/\$\{template3 /;s/$/\}/'}
Lua: ????????????????????
Afficher dynamiquement les périphériques USB connectés.:
#~ Affichez les périphériques USB actuellement connectés (pas les concentrateurs) & le nom que chaque périphérique signale au système.
#~ C'est très pratique pour voir si un périphérique USB nouvellement connecté prétend être quelque chose d'inattendu,
#~ comme une clé USB apparaissant comme une souris, un clavier ȣ une interface réseau.
#~ Mis à jour une fois toutes les 5 secondes pour réduire la charge du processeur.
# Afficher le nombre d'éléments connectés par USB qui ne sont pas des concentrateurs
USB Devices Attached ${execpi 5 lsusb | grep -iv 'hub' | cut --fields=7- --delimiter=' ' | wc -l}
# Obtenir le nom de chaque élément
${execpi 5 lsusb | grep -iv 'hub' | cut --fields=7- --delimiter=' '}
Lua: ????????????????????
Afficher dynamiquement toutes les interfaces réseau Ethernet disponibles.:
#~ Cela utilise un modèle pour rendre l'appel execpi plus facile à comprendre & pour rendre chaque affichage d'interface plus cohérent
#~ avec l'édition d'un seul point pour les modifications nécessaires.
#~ Le modèle doit apparaître avant la ligne TEXT dans votre fichier de configuration.
#~ Fonctionne bien pour les interfaces réseau Ethernet connectées par USB qui ne sont pas connectées tout le temps.
#~ Fonctionne pour les noms d'interface "et*" & "en*".
# Informations sur l'interface Ethernet
Exemple: template7 ${if_up \1}Ethernet (\1) ${alignr}IP ${addr \1}\nUp [${totalup}]${alignr}${upspeedgraph \1 10,120 884400 995500 -l}\n${voffset -15}
${alignr}${upspeed \1} \nDn [${totaldown}]${alignr}${downspeedgraph \1 10,120 884400 995500 -l}\n${voffset -15}${alignr}${downspeed \1}
${else}Ethernet (\1)${alignr}not connected${endif}
Lua: ????????????????????
TEXT
# Afficher les interfaces Ethernet disponibles
${execpi 60 cat /proc/net/dev | grep 'et' | cut --fields=-1 --delimiter=':' | sed 's/^/\$\{template7 /;s/$/\}/'}
${execpi 60 cat /proc/net/dev | grep 'en' | cut --fields=-1 --delimiter=':' | sed 's/^/\$\{template7 /;s/$/\}/'}
# La ligne suivante est la même que les deux précédentes si les deux sont nécessaires sur votre système.
#${execpi 60 cat /proc/net/dev | grep -e 'eth' -e 'enp' | cut --fields=-1 --delimiter=':' | sed 's/^/\$\{template7 /;s/$/\}/'}
Lua: ????????????????????
Afficher dynamiquement toutes les interfaces réseau sans fil disponibles. :
#~ Cela utilise un modèle pour rendre l'appel execpi plus facile à comprendre & pour rendre chaque affichage d'interface
#~ plus cohérent avec l'édition d'un seul point pour les modifications nécessaires.
#~ Le modèle doit apparaître avant la ligne TEXT dans votre fichier de configuration.
#~ Fonctionne bien pour les interfaces réseau sans fil connectées par USB qui ne sont pas connectées tout le temps.
# Informations sur l'interface Wi-Fi
Exemple: template8 ${if_up \1}IP ${addr \1} ${alignr}Gateway ${gw_iface}\nEssid ${wireless_essid \1}\nSignal
${wireless_link_qual \1}: ${wireless_link_qual_perc \1}% ${alignr}${wireless_mode \1} Rate ${wireless_bitrate \1}\nUp [${totalup \1}]
${alignr}${upspeedgraph \1 10,120 884400 995500 -l}\n${voffset -15}${alignr}${upspeed \1} \nDn [${totaldown \1}]
${alignr}${downspeedgraph \1 10,120 884400 995500 -l}\n${voffset -15}${alignr}${downspeed \1} ${else}WiFi (\1)${alignr}not connected${endif}
Lua: ????????????????????
TEXT
# Afficher les interfaces sans fil disponibles
Exemple: ${execpi 60 cat /proc/net/dev | grep 'wlan' | cut --fields=-1 --delimiter=':' | sed 's/^/\$\{template8 /;s/$/\}/'}
Lua: ????????????????????
Fond Conky transparent.:
#~ Voici une courte liste de choses à vérifier lorsque Conky s'affiche sur le bureau avec un arrière-plan de boîte noire.
#~ 1. Activez la composition du bureau.
#~ Conky est capable d'afficher un arrière-plan transparent faux ȣ réel sur certains gestionnaires d'affichage même lorsque la composition est désactivée,
#~ mais en général, c'est une bonne idée d'activer la composition.
#~ Paramètres -> Gestionnaire de paramètres -> Réglages du gestionnaire de fenêtres -> Compositeur -> Activer la composition d'affichage
#~ 2. Commencez avec les paramètres Conky suivants. (Cliquez sur les liens pour les options.)
own_window yes
own_window_class Conky
own_window_type desktop
own_window_hints undecorated,sticky,skip_taskbar,skip_pager,below
own_window_argb_visual yes
own_window_argb_value 255
own_window_transparent yes
Lua: own_window = true,
#~ 3. Assurez-vous que X11 autorise la double mise en mémoire tampon en éditant /etc/X11/xorg.conf pour mettre à jour ȣ inclure la section suivante.
Section "Module"
Load "dbe"
EndSection