FvwmPerl - En ligne dans le Cloud

PROGRAMME:

Nom

FvwmPerl - le manipulateur et préprocesseur fvwm perl

SYNOPSIS

FvwmPerl devrait être généré par fvwm(1) pour une fonctionnalité normale.

Pour exécuter ce module, placez cette commande quelque part dans la configuration :

Module FvwmPerl [paramètres]

ou:

ModuleSynchroniser FvwmPerl [params]

si vous voulez commencer immédiatement à envoyer des commandes à FvwmPerl.

DESCRIPTION

Ce module est destiné à étendre les commandes fvwm avec la puissance de script perl. Il permet
pour intégrer des expressions perl dans les fichiers de configuration fvwm et construire des commandes fvwm.

INVOCATION

Si vous souhaitez invoquer l'instance unique et persistante de FvwmPerl, il est suggéré de
faire cela à partir du Fonction de démarrage. L'appeler par le haut est également possible, mais implique
certaines questions non abordées ici.

Module AddToFunc StartFunction I FvwmPerl

Il existe plusieurs commutateurs de ligne de commande :

FvwmPerl [ --évaluation ligne ] [ --charge déposer ] [ --prétraiter [ --citation caractère ] [ --winid largeur ] [
--cmd ] [ --pas d'envoi ] [ --noremove ] [ ligne | déposer ] ] [ --exportation [noms] ] [ --rester ] [
--aucun verrou ] [ pseudo ]

Les commutateurs longs peuvent être abrégés en commutateurs courts à une lettre.

-e|--évaluation line - évalue le code perl donné

-l|--charge file - évalue le code perl dans le fichier donné

-p|--prétraiter [ fichier ] - prétraite le fichier de configuration fvwm donné

Les 5 options suivantes ne sont valables qu'avec --prétraiter option.

-c|--cmd line - une commande fvwm à prétraiter à la place du fichier

-q|--citation char - modifie la citation par défaut '%'

-w|--winid wid - définit le contexte explicite de la fenêtre (doit commencer par un chiffre, peut être en oct ou
forme hexadécimale ; cet identifiant de fenêtre écrase le contexte de fenêtre implicite le cas échéant)

--pas d'envoi - ne pas envoyer le fichier prétraité à fvwm en Lireing, la valeur par défaut est envoyer.
Utile pour le prétraitement des fichiers de configuration non fvwm.

--noremove - ne pas supprimer le fichier prétraité après l'avoir envoyé à fvwm en Lireing, le
la valeur par défaut est supprimer. Utile pour le débogage.

-x|--exportation [noms] - définit les fonctions de raccourci fvwm (par défaut, deux fonctions nommées
"Eval" et "."). Cette option implique --rester.

-s|--rester - continue une exécution après --évaluation, --charge or --prétraiter sont traités. Par
par défaut, le module n'est pas persistant dans ce cas, c'est à dire --non reste est assumé.

--aucun verrou - lorsqu'une des 3 options d'action est donnée, cette option provoque le déverrouillage fvwm
immédiatement. Par défaut, l'action demandée est exécutée de manière synchrone ; cela ne fait que
différence lorsqu'il est invoqué comme :

ModuleSynchronous FvwmPerl --preprocess someconfig.ppp

If --aucun verrou est ajouté ici, ModuleSynchrone revient immédiatement. Noter que Module Retours
immédiatement indépendamment de cette option.

EN UTILISANT ALIAS

Les alias permettent d'avoir plusieurs invocations de module et de travailler séparément avec toutes les invocations,
Voici un exemple:

ModuleSynchronous FvwmPerl FvwmPerl-JustTest
SendToModule FvwmPerl-JustTest eval $a = 2 + 2 ; $b = $a
SendToModule FvwmPerl-JustTest eval cmd("Echo 2 + 2 = $b")
KillModule FvwmPerl FvwmPerl-JustTest

PRÉTRAITEMENT EXEMPLE

L'une des solutions de proprocessing efficaces consiste à passer l'ensemble de la configuration fvwm avec
code perl intégré à "FvwmPerl --preprocess". Une approche alternative consiste à écrire un perl
script qui produit des commandes fvwm et les envoie pour exécution, ce script peut être chargé
en utilisant "FvwmPerl --load". Cependant, il existe des solutions intermédiaires qui ne prétraitent que
lignes de configuration séparées (ou alternativement, exécutez des commandes perl séparées qui
produire des commandes fvwm).

L'extrait de code suivant ajoute la capacité d'arithmétique et de script de chaîne à certains
lignes qui en ont besoin. Pour l'utiliser, vous voulez démarrer FvwmPerl comme première commande donc
qu'on peut demander à d'autres commandes d'être préparées.

ModuleSynchroniser FvwmPerl

AddToFunc .
+ I SendToModule FvwmPerl prétraite -c -- $*

. Exec exec xterm -name xterm-%{++$i}% # utilise un nom unique

. GotoDesk 0 %{ $[desk.n] + 1 }% # aller au bureau suivant

. Exec exec %{ -x "/usr/bin/X11/aterm" ? "aterm" : "xterm" }% -sb

# centrer une fenêtre
Suivant (MaFenêtre) . Se déplacer \
%{($LARGEUR - $[l.largeur]) / 2}%p %{($HAUTEUR - $[l.hauteur]) / 2}%p

. Exec exec xmessage %{2 + 2}% # calculatrice simple

. %{main::show_message(2 + 2, "Encore une autre calculatrice"); ""} %

ACTIONS

Il y a plusieurs actions que FvwmPerl peut effectuer :

eval code-perl
Évaluez une ligne de code perl.

Une fonction spéciale cmd("commander") peut être utilisé dans le code perl pour renvoyer des commandes à
fvwm.

Si le code perl contient une erreur, il est imprimé dans le flux d'erreur standard avec le
[FvwmPerl][eval] : en-tête préfixé.

charge nom de fichier
Chargez un fichier de code perl. Si le fichier n'est pas entièrement qualifié, il est recherché dans le
répertoire utilisateur $FVWM_USERDIR (généralement ~/.fvwm) et le répertoire de données à l'échelle du système
$FVWM_DATADIR.

Une fonction spéciale cmd("commander") peut être utilisé dans le code perl pour renvoyer des commandes à
fvwm.

Si le code perl contient une erreur, il est imprimé dans le flux d'erreur standard avec le
[FvwmPerl][charger] : en-tête préfixé.

prétraiter [-q|--quote char] [-c|--cmd] [en ligne | filet]
Prétraiter la configuration fvwm filet ou (si --cmd est donné) en ligne. Ce fichier contient des lignes qui
ne sont pas touchés (généralement des commandes fvwm) et du code perl spécialement préformaté qui est
traité et remplacé. Texte enfermé dans %{ }% délimiteurs, qui peuvent commencer n'importe où
sur la ligne et se termine n'importe où sur la même ligne ou sur une autre, est le code perl.

La Devis le paramètre change les délimiteurs de code perl. Si un seul caractère est donné, comme
'@', les délimiteurs sont @{ }@. Si la citation donnée est de 2 caractères, comme <>, les citations
<{ }>

Le code perl se substitue au résultat de son évaluation. C'est-à-dire %{$a = "c" ; ++$a}%
est remplacé par "d".

L'évaluation est différente eval et charge se fait sous le package PreprocessNamespace
Et sans utilisé strict, vous êtes donc libre d'utiliser n'importe quel nom de variable sans crainte de
conflits. N'utilisez simplement pas de variables non initialisées pour signifier undef ou une liste vide (elles
peut en fait être initialisé par l'action de prétraitement précédente), et effectuer un nettoyage si
nécessaire. Les variables et la fonction dans le principal package sont toujours disponibles, comme
::cmd() ou ::sauter(), mais ce n'est tout simplement pas une bonne idée d'y accéder pendant que
prétraitement.

Il y a une fonction spéciale comprendre(filet) qui charge un fichier, le prétraite et
renvoie le résultat prétraité. Évitez la récursivité.

Si un code perl intégré contient une erreur, il est imprimé avec l'erreur standard
stream et précédé du [FvwmPerl][prétraiter] : entête. Le résultat de
substitution est vide dans ce cas.

Les variables suivantes peuvent être utilisées dans le code perl :

$USER, $DISPLAY, $WIDTH, $HEIGHT, $FVWM_VERSION, $FVWM_MODULEDIR, $FVWM_DATADIR,
$FVWM_USERDIR

Les directives basées sur les lignes suivantes sont reconnues lors du prétraitement. Elles sont
traité après le remplacement du code perl (le cas échéant).

%Répéter compter
Provoque la répétition des lignes suivantes compter fois.

%Configuration du module nom-module [ détruire ]
Provoque l'interprétation des lignes suivantes comme la configuration de module donnée. Si
"destroy" est spécifié, la configuration précédente du module est détruite en premier.

%Préfixe préfixe
Préfixe les lignes suivantes avec les guillemets préfixe.

%Fin commentaire-facultatif
Les extrémités de l'une des directives décrites ci-dessus peuvent être imbriquées.

Exemples :

%Préfixe "AddToFunc SwitchToWindow I"
Désactiver l'iconification
Ombrage de fenêtre désactivé
Augmenter
DéformationVersFenêtre 50 50
%Finir

%ModuleConfig FvwmPager détruire
Jeu de couleurs 0
Police lucidasans-10
Échelle de bureau 28
Mini-icônes
%Fin ModuleConfig FvwmPager

%Préfixe "Tous (MyWindowToAnimate) ResizeMove"
100 100 %{($LARGEUR - 100) / 2}% %{($HAUTEUR - 100) / 2}%
%Répéter %{$count}%
br w+2c w+2c w-1c w-1c
%Finir
%Répéter %{$count}%
br w-2c w-2c w+1c w+1c
%Finir
% Préfixe de fin

Des paramètres de prétraitement supplémentaires --nosend et --noremove peuvent également être fournis. Voir leur
description en haut.

Exporter [noms de fonction]
Envoyer à fvwm la définition de fonctions raccourcies qui permettent d'activer différents
actions du module (c'est-à-dire eval, charge et prétraiter).

Noms de fonction (noms de fonction) peuvent être séparés par des virgules ou/et des espaces. Par défaut,
deux fonctions "Eval" et "." sont supposées.

L'action réelle définie dans une fonction est devinée à partir du nom de la fonction si possible,
où le nom de la fonction "." est réservé à prétraiter l'action.

Par exemple, l'une de ces deux commandes fvwm

SendToModule Exportation MyPerl PerlEval,PP
FvwmPerl --export PerlEval, PP MyPerl

définir les deux fonctions de raccourci suivantes :

DestroyFunc PerlEval
AddToFunc I SendToModule MyPerl évaluation $*
DétruireFunc PP
AddToFunc I SendToModule Prétraitement MyPerl -c -- $*

Ces 4 actions peuvent être demandées de l'une des 3 manières suivantes : 1) en ligne de commande lorsque FvwmPerl est
invoqué (dans ce cas, FvwmPerl est de courte durée à moins que --rester or --exportation est également donné), 2)
en envoyant le message correspondant dans fvwm config en utilisant SendToModule, 3) en appelant le
fonction perl correspondante dans le code perl.

FONCTIONS

Il y a plusieurs fonctions que le code perl peut appeler :

cmd($fvwm_commande)
En cas de eval or charge - renvoyer à fvwm une chaîne $fvwm_commande. En cas de
prétraiter - ajouter une chaîne $fvwm_commande à la sortie du code perl intégré.

faire_eval($perl_code)
Cette fonction est équivalente à la eval fonctionnalité sur la chaîne $perl_code,
décrit ci-dessus.

charge($nom de fichier)
Cette fonction est équivalente à la charge fonctionnalité sur le fichier $filename, décrite
au dessus.

prétraitement(@params, ["-c $commande"] [$nom de fichier])
Cette fonction est équivalente à la prétraiter fonctionnalité avec les paramètres donnés
et le fichier $filename décrit ci-dessus.

exportation($func_names, [$do_unexport])
Cette fonction est équivalente à la Exporter fonctionnalité avec les $func_names donnés,
décrit ci-dessus. Peut-être aussi désexporter les noms de fonction si le deuxième paramètre est vrai.

Les noms de fonction doivent être séparés par des virgules ou/et des espaces. Si $fonc_names is
vide puis les fonctions "Eval" et "." sont supposées.

Arrêtez()
Termine le module.

sauter()
Ignore le reste du code de rappel d'événement, c'est-à-dire que le module revient pour écouter le nouveau
événements du module.

ouvrir()
Désynchronise le rappel d'événement de fvwm. Cela peut être utile pour éviter les blocages,
c'est-à-dire que généralement fvwm tue le module qui ne répond pas si le rappel d'événement n'est pas
fini en Délai d'expiration du module secondes. Cela l'empêche.

Cet exemple oblige FvwmPerl à suspendre son exécution pendant une minute :

SendModule FvwmPerl eval déverrouiller(); sleep(60);

Cependant, vérifiez qu'il n'y a aucun moyen qu'un nouveau message soit envoyé par fvwm pendant que le module est
occupé, et fvwm reste verrouillé sur ce nouveau message trop longtemps. Voir aussi le détacher
solution si vous avez besoin d'opérations de longue durée.

détacher()
Fourche et détache le reste du code de rappel d'événement du processus principal. Ceci peut
être utile pour éviter de tuer le module si son rappel d'événement devait prendre un certain temps
à compléter et cela peut être fait chez l'enfant détaché. L'enfant détaché peut encore
envoyer des commandes à fvwm (ne vous fiez pas à cela), mais ne recevez pas les événements bien sûr, il
se ferme immédiatement après la fin de l'exécution du rappel.

Si vous utilisez détacher(), mieux vaut n'envoyer des commandes à fvwm que dans un seul processus (le principal ou
celui qui est détaché), faire autrement peut souvent provoquer des conflits.

voir le message($msg, $titre[, $use_stderr_too=1])
Affiche une fenêtre de dialogue avec le message donné, en utilisant l'outil X trouvé dans le
système.

See FVWM::Module::Boîte à outils::voir le message pour plus d'information.

VARIABLES

Il existe plusieurs variables globales dans le principal espace de nom qui peut être utilisé dans le perl
code:

$a, $b, ... $h
@a, @b, ... @h
%a, %b, ... %h

Ils sont tous initialisés à la valeur vide et peuvent être utilisés pour stocker un état entre
différents appels aux actions FvwmPerl (eval et charge).

Si vous avez besoin de noms de variables plus lisibles, écrivez "no strict 'vars';" au début de
chaque code perl ou utilisez un hachage pour cela, comme :

$h{id} = $h{first_name} . " " . $h{second_name}

ou utilisez un nom de package, comme :

@MonMenu::terminaux = qw( xterm rxvt );
$MyMenu::item_num = @MyMenu::terminals ;

Il peut y avoir une option de configuration pour activer et désactiver la rigueur.

MESSAGES

FvwmPerl peut recevoir des messages en utilisant la commande fvwm SendToModule. Les noms, significations et
les paramètres des messages sont les mêmes que les actions correspondantes, décrites ci-dessus.

De plus, un message Arrêtez provoque la fermeture d'un module.

Un message désexporter [noms de fonction] annule l'effet de Exporter, décrit dans les ACTIONS
.

Un message déverser vide le contenu des variables modifiées (pas encore).

EXEMPLES

Un test simple :

SendToModule FvwmPerl évaluation $h{dir} = $ENV{HOME}
SendToModule FvwmPerl eval load($h{dir} . "/test.fpl")
SendToModule FvwmPerl charge $[HOME]/test.fpl
SendToModule FvwmPerl prétraiter config.ppp
SendToModule Exportation FvwmPerl Eval,PerlEval,PerlLoad,PerlPP
SendToModule FvwmPerl désexporter PerlEval,PerlLoad,PerlPP
Arrêt SendToModule FvwmPerl

L'exemple suivant gère les arrière-plans racine dans fvwmrc. Toutes ces commandes peuvent être ajoutées
à StartFunction.

Module FvwmPerl --export PerlEval

# trouver toutes les pixmaps d'arrière-plan pour une utilisation ultérieure
PerlEval $a = $ENV{HOME} . "/bg" ; \
opendir DIR, $a; @b = grep { /xpm$/ } readdir(DIR); DIR fermé

# construire un menu de pixmaps en arrière-plan
AddToMenu MyBackgrounds Titre "Mes arrière-plans"
PerlEval pour chaque $b (@b) \
{ cmd("AddToMenu MyBackgrounds '$b' Exec fvwm-root $a/$b") }

# choisissez un arrière-plan aléatoire à charger au démarrage
PerlEval cmd("AddToFunc \
InitFunction + I Exec exec fvwm-root $a/" . $b[int(random(@b))])

ÉVASION

EnvoyerVersModule tout comme n'importe quelle autre commande fvwm étend plusieurs variables préfixées en dollars.
Cela peut entrer en conflit avec les dollars utilisés par Perl. Vous pouvez éviter cela en préfixant SendToModule
avec un tiret de tête. Les 2 lignes suivantes de chaque paire sont équivalentes :

SendToModule FvwmPerl eval $$d = "$[DISPLAY]"
-SendToModule FvwmPerl eval $d = "$ENV{DISPLAY}"

SendToModule FvwmPerl évaluation \
cmd("Echo desk=$d, display=$$d")
Prétraitement SendToModule FvwmPerl -c \
Bureau d'écho=%("$d")%, affichage=%{$$d}%

Une autre solution pour éviter d'échapper aux symboles spéciaux comme les dollars et les barres obliques inverses consiste à
créer un fichier perl dans ~/.fvwm puis chargez-le :

SendToModule FvwmPerl charge build-menus.fpl

Si vous devez prétraiter une commande commençant par un tiret, vous devez la précéder en utilisant
"--".

# ceci imprime le bureau actuel, c'est-à-dire "0"
Prétraitement SendToModule FvwmPerl -c Echo "$%{$a = "c"; ++$a}%"
# ceci affiche "$d"
Prétraitement SendToModule FvwmPerl -c -- -Echo "$%{"d"}%"
# ceci affiche "$d" (SendToModule développe $$ en $)
Prétraitement SendToModule FvwmPerl -c -- -Echo "$$%{"d"}%"
# ceci affiche "$$d"
-SendToModule FvwmPerl prétraitement -c -- -Echo "$$%{"d"}%"

Encore une fois, il est suggéré de mettre vos commandes dans un fichier et de prétraiter le fichier à la place.

MISES EN GARDE

FvwmPerl étant écrit en perl et traitant de perl, suit la célèbre devise de perl :
"Il y a plus d'une façon de le faire", alors le choix vous appartient.

Voici d'autres paires de lignes équivalentes :

Module FvwmPerl --load "my.fpl" --stay
Module FvwmPerl -e 'load("my.fpl")' -s

Prétraitement SendToModule FvwmPerl --quote '@' my.ppp
SendToModule FvwmPerl eval preprocess({quote => '@'}, "my.ppp");

Attention, vous pouvez affecter le fonctionnement de FvwmPerl en évaluant le code perl approprié, ceci
est considéré comme une fonctionnalité et non comme un bogue. Mais s'il vous plaît ne faites pas ça, écrivez votre propre module fvwm
en perl à la place.

Utilisez FvwmPerl en ligne en utilisant les services onworks.net