FvwmPerl - Online en la nube

PROGRAMA:

NOMBRE

FvwmPerl - el manipulador y preprocesador perl de fvwm

SINOPSIS

FvwmPerl debería ser generado por fvwm(1) para una funcionalidad normal.

Para ejecutar este módulo, coloque este comando en algún lugar de la configuración:

Módulo FvwmPerl [params]

o bien:

ModuleSynchronize FvwmPerl [parámetros]

si desea comenzar inmediatamente a enviar comandos a FvwmPerl.

DESCRIPCIÓN

Este módulo está diseñado para extender los comandos fvwm con el poder de scripting de Perl. Permite
para incrustar expresiones perl en los archivos de configuración de fvwm y construir comandos fvwm.

INVOCACIÓN

Si desea invocar la instancia única y persistente de FvwmPerl, se sugiere
haz esto desde el función de inicio. Llamarlo desde arriba también es posible, pero implica
algunos temas no discutidos aquí.

AddToFunc StartFunction I Módulo FvwmPerl

Hay varios modificadores de línea de comando:

FvwmPerl [ --evaluar línea ] [ --carga expediente ] [ --preproceso [ --cita char] [ --winid wid] [
--cmd ] [ --no enviar ] [ --no quitar ] [línea | Archivo ] ] [ --exportar [nombres]] [ --permanecer ] [
--sin bloqueo ] [ alias ]

Los conmutadores largos se pueden abreviar como conmutadores cortos de una letra.

-e|--evaluar línea - evalúa el código perl dado

-l|--carga archivo: evalúa el código perl en el archivo dado

-p|--preproceso [archivo] - preprocesa el archivo de configuración fvwm dado

Las siguientes 5 opciones solo son válidas junto con --preproceso .

-c|--cmd línea: un comando fvwm que se procesará previamente en lugar de un archivo

-q|--cita char - cambia la cita '%' predeterminada

-w|--winid wid: establece el contexto de ventana explícito (debe comenzar con un dígito, puede estar en oct o
forma hexadecimal; esta ID de ventana sobrescribe el contexto de ventana implícito, si lo hay)

--no enviar - no envíe el archivo preprocesado a fvwm para Leering, el valor predeterminado es enviar.
Útil para preprocesar archivos de configuración que no sean fvwm.

--no quitar - no elimine el archivo preprocesado después de enviarlo a fvwm para Leering, el
el valor predeterminado es eliminar. Útil para depurar.

-x|--exportar [nombres]: define las funciones de acceso directo de fvwm (por defecto, dos funciones nombradas
"Eval" y "."). Esta opción implica --permanecer.

-s|--permanecer - continúa una ejecución después --evaluar, --carga or --preproceso son procesados. Por
predeterminado, el módulo no es persistente en este caso, es decir --no quedarse se supone.

--sin bloqueo - cuando se da una de las 3 opciones de acción, esta opción provoca el desbloqueo fvwm
inmediatamente. De forma predeterminada, la acción solicitada se ejecuta de forma sincrónica; esto solo hace
diferencia cuando se invoca como:

ModuleSynchronous FvwmPerl --preprocesa someconfig.ppp

If --sin bloqueo se agrega aquí, MóduloSincrónico regresa inmediatamente. Tenga en cuenta que Módulo devoluciones
inmediatamente independientemente de esta opción.

USO ALIAS

Los alias permiten tener varias invocaciones de módulo y trabajar por separado con todas las invocaciones,
Aquí hay un ejemplo:

MóduloSynchronous FvwmPerl FvwmPerl-JustTest
SendToModule FvwmPerl-JustTest eval $ a = 2 + 2; $ b = $ a
SendToModule FvwmPerl-JustTest eval cmd ("Eco 2 + 2 = $ b")
KillModule FvwmPerl FvwmPerl-JustTest

PREPROCESADO EJEMPLO

Una de las soluciones de procesado eficaces es pasar toda la configuración de fvwm con
código perl incrustado en "FvwmPerl --preprocess". Un enfoque alternativo es escribir un perl
script que produce comandos fvwm y los envía para su ejecución, este script puede cargarse
usando "FvwmPerl --load". Hay muchas soluciones intermedias que solo preprocesan
líneas de configuración separadas (o alternativamente, ejecute comandos perl separados que
producir comandos fvwm).

El siguiente fragmento de código agrega la capacidad de aritmética y secuencias de comandos de cadena a ciertos
líneas que necesitan esto. Para usar esto, desea iniciar FvwmPerl como su primer comando, así que
que es posible que se solicite la prospección previa de otros comandos.

MóduloSynchronize FvwmPerl

AddToFunc.
+ I SendToModule FvwmPerl preproceso -c - $ *

. Exec exec xterm -name xterm -% {++ $ i}% # use un nombre único

. Ir al escritorio 0% {$ [desk.n] + 1}% # ir al siguiente escritorio

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

# centrar una ventana
Siguiente (MyWindow). Muevete \
% {($ WIDTH - $ [w.width]) / 2}% p% {($ HEIGHT - $ [w.height]) / 2}% p

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

. % {main :: show_message (2 + 2, "Otra calculadora más"); ""}%

ACCIONES

Hay varias acciones que puede realizar FvwmPerl:

eval código perl
Evalúe una línea de código perl.

Una función especial cmd"mando") puede usarse en código perl para enviar comandos a
fvwm.

Si el código de Perl contiene un error, se imprime en el flujo de error estándar con el
[FvwmPerl] [eval]: encabezado antepuesto.

carga nombre del archivo
Cargue un archivo de código perl. Si el archivo no está completamente calificado, se busca en el
directorio de usuario $ FVWM_USERDIR (normalmente ~ / .fvwm) y el directorio de datos de todo el sistema
$ FVWM_DATADIR.

Una función especial cmd"mando") puede usarse en código perl para enviar comandos a
fvwm.

Si el código de Perl contiene un error, se imprime en el flujo de error estándar con el
[FvwmPerl] [cargar]: encabezado antepuesto.

preprocesar [-q | --quote char] [-c | --cmd] [línea | presentar]
Preprocesar la configuración de fvwm presentar o (si se da --cmd) línea. Este archivo contiene líneas que
no se tocan (generalmente comandos fvwm) y código perl especialmente preformateado que es
procesado y reemplazado. Texto incluido en %{ ... }% delimitadores, que pueden comenzar en cualquier lugar
en la línea y termina en cualquier lugar de la misma línea o de otra línea, está el código perl.

La cotización inicial los parámetros cambian los delimitadores de código perl. Si se da un solo carácter, como
'@', los delimitadores son @{ ... }@. Si la cita dada tiene 2 caracteres, como <>, Las citas
en <{ ... }>

El código perl sustituye al resultado de su evaluación. Es decir,% {$ a = "c"; ++ $ a}%
se reemplaza por "d".

La evaluación es diferente eval y carga se realiza bajo el paquete PreprocessNamespace
y sin utilizan el estricto, por lo que puede utilizar cualquier nombre de variable sin temor a
conflictos. Simplemente no use variables no inicializadas para significar indef o lista vacía (ellos
de hecho puede ser inicializado por la acción de preproceso anterior), y hacer una limpieza si
necesario. Las variables y la función en el principal el paquete todavía está disponible, como
::cmd () o ::saltar(), pero no es una buena idea acceder a ellos mientras
preprocesamiento.

Hay una función especial incluir(presentar) que carga un archivo, lo preprocesa y
devuelve el resultado preprocesado. Evite la recursividad.

Si algún código perl incrustado contiene un error, se imprime con el error estándar
corriente y precedido con el [FvwmPerl] [preproceso]: encabezamiento. El resultado de
la sustitución está vacía en este caso.

Las siguientes variables pueden usarse en el código perl:

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

Las siguientes directivas basadas en líneas se reconocen durante el preprocesamiento. Ellos son
procesado después de que se sustituya el código perl (si lo hay).

%Repetición: contar
Provoca la repetición de las siguientes líneas contar veces.

%Configuración del módulo Nombre del módulo [destruir]
Hace que las siguientes líneas se interpreten como la configuración del módulo dada. Si
"Destruir" se especifica, la configuración del módulo anterior se destruye primero.

%Prefijo prefijo
Prefija las siguientes líneas con el citado prefijo.

%Fin cualquier comentario opcional
Finaliza cualquiera de las directivas descritas anteriormente, puede estar anidada.

Ejemplos:

% Prefijo "AddToFunc SwitchToWindow I"
Iconify apagado
Ventana
Para aumentar
Deformar a ventana 50 50
%Fin

% ModuleConfig FvwmPager destruir
Conjunto de colores 0
Fuente lucidasans-10
EscritorioTopScale 28
MiniIconos
% Finalizar ModuleConfig FvwmPager

% Prefijo "Todo (MyWindowToAnimate) ResizeMove"
100 100% {($ WIDTH - 100) / 2}%% {($ HEIGHT - 100) / 2}%
% Repetir% {$ count}%
br w + 2c w + 2c w-1c w-1c
%Fin
% Repetir% {$ count}%
br w-2c w-2c w + 1c w + 1c
%Fin
% Prefijo final

También se pueden proporcionar parámetros de preproceso adicionales --nosend y --noremove. Ver su
descripción en la parte superior.

exportar [nombres-func]
Envíe a fvwm la definición de funciones de atajos que ayudan a activar diferentes
acciones del módulo (es decir eval, carga y preprocesar).

Nombres de funciones (nombres-func) pueden estar separados por comas y / o espacios en blanco. Por defecto,
dos funciones "Eval" y "." se asumen.

La acción real definida en una función se adivina a partir del nombre de la función si es posible,
donde el nombre de la función "." está reservado para preprocesar acción.

Por ejemplo, cualquiera de estos dos comandos fvwm

SendToModule MyPerl exportar PerlEval, PP
FvwmPerl --exportar PerlEval, PP MyPerl

definir las siguientes dos funciones de atajo:

DestroyFunc PerlEval
AddToFunc I SendToModule MyPerl eval $ *
DestroyFunc PP
AddToFunc I SendToModule MyPerl preproceso -c - $ *

Estas 4 acciones pueden solicitarse de una de las 3 formas siguientes: 1) en la línea de comando cuando FvwmPerl está
invocado (en este caso, FvwmPerl es de corta duración a menos que --permanecer or --exportar también se da), 2)
enviando el mensaje correspondiente en la configuración de fvwm usando SendToModule, 3) llamando al
función de perl correspondiente en el código de perl.

Las funciones

Hay varias funciones que el código perl puede llamar:

cmd$ fvwm_command)
En caso de eval or carga - enviar de vuelta a fvwm una cadena $ fvwm_command. En caso de
preprocesar - añadir una cadena $ fvwm_command a la salida del código perl incrustado.

do_eval ($ código_perl)
Esta función es equivalente a la eval funcionalidad en la cuerda $ código_perl,
descrito arriba.

carga($ nombre de archivo)
Esta función es equivalente a la carga funcionalidad en el archivo $ nombre de archivo, descrito
anterior.

preprocesar@params, ["-C $ comando "] [$ nombre de archivo])
Esta función es equivalente a la preprocesar funcionalidad con los parámetros dados
y el archivo $ nombre de archivo descrito anteriormente.

exportar($ func_names, [$ do_unexport])
Esta función es equivalente a la exportar funcionalidad con los $ func_names dados,
descrito arriba. También puede no exportar los nombres de las funciones si el segundo parámetro es verdadero.

Los nombres de las funciones deben estar separados por comas y / o espacios en blanco. Si $ func_names is
vacío entonces funciones "Eval" y "." se asumen.

detener()
Termina el módulo.

saltar()
Omite el resto del código de devolución de llamada del evento, es decir, el módulo vuelve a escuchar el nuevo
eventos del módulo.

desbloquear()
Desincroniza la devolución de llamada del evento de fvwm. Esto puede resultar útil para evitar interbloqueos,
es decir, normalmente fvwm mata el módulo que no responde si la devolución de llamada del evento no es
terminado en Tiempo de espera del módulo segundos. Esto lo previene.

Este ejemplo hace que FvwmPerl suspenda su ejecución durante un minuto:

SendModule FvwmPerl eval unlock (); sueño(60);

Sin embargo, verifique que no haya forma de que fvwm envíe un mensaje nuevo mientras el módulo está
ocupado y fvwm permanece bloqueado en este nuevo mensaje durante demasiado tiempo. Ver también el despegar
solución si necesita operaciones de larga duración.

despegar()
Bifurca y separa el resto del código de devolución de llamada del evento del proceso principal. Esto puede
ser útil para evitar matar el módulo si su devolución de llamada de evento debe llevar mucho tiempo
para completar y se puede hacer en el niño desprendido. El niño desapegado todavía puede
enviar comandos a fvwm (no confíe en esto), pero no recibir los eventos, por supuesto,
sale inmediatamente después de que finaliza la ejecución de la devolución de llamada.

Si utiliza despegar(), mejor solo envíe comandos a fvwm en un proceso (el principal o
el desapegado), hacerlo de otra manera a menudo puede causar conflictos.

Mostrar mensaje($ msg, $ title [, $ use_stderr_too = 1])
Muestra una ventana de diálogo con el mensaje dado, usando cualquier herramienta X que se encuentre en el
.

See FVWM :: Módulo :: Kit de herramientas::Mostrar mensaje para obtener más información.

VARIABLES

Hay varias variables globales en el principal espacio de nombres que se puede utilizar en el perl
código:

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

Todos se inicializan con el valor vacío y se pueden usar para almacenar un estado entre
diferentes llamadas a acciones FvwmPerl (eval y carga).

Si necesita nombres de variables más legibles, escriba "no 'vars' estrictas;" al inicio de
cada código perl o use un hash para esto, como:

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

o use un nombre de paquete, como:

@MyMenu :: terminales = qw (xterm rxvt);
$ MyMenu :: item_num = @MyMenu :: terminales;

Puede haber una opción de configuración para activar y desactivar el rigor.

MENSAJES

FvwmPerl puede recibir mensajes usando el comando fvwm SendToModule. Los nombres, significados y
Los parámetros de los mensajes son los mismos que los de las acciones correspondientes, descritas anteriormente.

Además, un mensaje detener hace que un módulo se cierre.

Un mensaje no exportar [nombres-func] deshace el efecto de exportar, descrito en las ACCIONES
.

Un mensaje arrojar vuelca el contenido de las variables modificadas (todavía no).

EJEMPLOS

Una simple prueba:

SendToModule FvwmPerl eval $ h {dir} = $ ENV {HOME}
SendToModule FvwmPerl eval load ($ h {dir}. "/Test.fpl")
SendToModule FvwmPerl cargar $ [INICIO] /test.fpl
SendToModule FvwmPerl preproceso config.ppp
SendToModule FvwmPerl exportar Eval, PerlEval, PerlLoad, PerlPP
SendToModule FvwmPerl sin exportar PerlEval, PerlLoad, PerlPP
SendToModule FvwmPerl detener

El siguiente ejemplo maneja fondos raíz en fvwmrc. Todos estos comandos se pueden agregar
a StartFunction.

Módulo FvwmPerl --exportar PerlEval

# buscar todos los mapas de píxeles de fondo para un uso posterior
PerlEval $ a = $ ENV {INICIO}. "/ bg"; \
opendir DIR, $ a; @b = grep {/ xpm $ /} readdir (DIR); cerradoir DIR

# crear un menú de mapas de píxeles de fondo
AddToMenu MyBackgrounds Título "Mis fondos"
PerlEval foreach $ b (@b) \
{cmd ("AddToMenu MyBackgrounds '$ b' Exec fvwm-root $ a / $ b")}

# elija un fondo aleatorio para cargar en el inicio
PerlEval cmd ("AddToFunc \
InitFunction + I Exec exec fvwm-root $ a / ". $ B [int (aleatorio (@b))])

ESCAPAR

Enviar a módulo al igual que cualquier otro comando fvwm, expande varias variables con prefijo de dólar.
Esto puede chocar con los dólares que utiliza perl. Puede evitar esto colocando el prefijo SendToModule
con un guión inicial. Las siguientes 2 líneas de cada par son equivalentes:

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

SendToModule FvwmPerl evaluación \
cmd ("Echo desk = $ d, display = $$ d")
SendToModule FvwmPerl preproceso -c \
Echo desk =% ("$ d")%, display =% {$$ d}%

Otra solución para evitar el escape de símbolos especiales como dólares y barras invertidas es
crear un archivo perl en ~ / .fvwm y luego cárguelo:

SendToModule FvwmPerl cargar build-menus.fpl

Si necesita preprocesar un comando que comienza con un guión, debe precederlo usando
"-".

# esto imprime el escritorio actual, es decir, "0"
SendToModule FvwmPerl preprocess -c Echo "$% {$ a =" c "; ++ $ a}%"
# esto imprime "$ d"
SendToModule FvwmPerl preprocess -c - -Echo "$% {" d "}%"
# esto imprime "$ d" (SendToModule expande $$ a $)
SendToModule FvwmPerl preprocess -c - -Echo "$$% {" d "}%"
# esto imprime "$$ d"
-SendToModule FvwmPerl preprocess -c - -Echo "$$% {" d "}%"

Nuevamente, se sugiere poner su (s) comando (s) en un archivo y preprocesar el archivo en su lugar.

AVISOS

FvwmPerl, escrito en perl y relacionado con perl, sigue el famoso lema de perl:
"Hay más de una forma de hacerlo", así que la elección es tuya.

Aquí hay más pares de líneas equivalentes:

Módulo FvwmPerl --load "my.fpl" --stay
Módulo FvwmPerl -e 'load ("my.fpl")' -s

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

Advertencia, puede afectar la forma en que funciona FvwmPerl evaluando el código de Perl apropiado, esto
se considera una característica, no un error. Pero no hagas esto, escribe tu propio módulo fvwm
en perl en su lugar.

Use FvwmPerl en línea usando los servicios de onworks.net