FvwmPerl - Online sa Cloud

PROGRAMA:

NAME

FvwmPerl - ang fvwm perl manipulator at preprocessor

SINOPSIS

FvwmPerl ay dapat na spawned sa pamamagitan ng fvwm(1) para sa normal na paggana.

Upang patakbuhin ang module na ito, ilagay ang command na ito sa isang lugar sa configuration:

Module FvwmPerl [params]

o:

ModuleSynchronize FvwmPerl [params]

kung gusto mong simulan agad na magpadala ng mga utos sa FvwmPerl.

DESCRIPTION

Ang modyul na ito ay nilayon na palawigin ang mga utos ng fvwm gamit ang perl scripting power. Ito ay nagbibigay-daan
upang i-embed ang mga perl expression sa mga fvwm config file at bumuo ng mga fvwm command.

INVOKASYON

Kung gusto mong gamitin ang natatangi at paulit-ulit na instance ng FvwmPerl, iminumungkahi na
gawin ito mula sa StartFunction. Ang pagtawag dito mula sa itaas ay posible rin, ngunit nagsasangkot
ilang mga isyu na hindi tinalakay dito.

AddToFunc StartFunction I Module FvwmPerl

Mayroong ilang mga switch ng command line:

FvwmPerl [ --eval linya ] [ —-load file ] [ --preprocess [ --quote char ] [ --winid wid ] [
--cmd ] [ --ilong ] [ --hindi alisin ] [ linya | file ] ] [ --export [mga pangalan] ] [ --manatili ] [
--nolock ] [ alias ]

Ang mga mahahabang switch ay maaaring paikliin ng mga switch na may isang titik.

-e|--eval linya - suriin ang ibinigay na perl code

-l|—-load file - suriin ang perl code sa ibinigay na file

-p|--preprocess [ file ] - iproseso ang ibinigay na fvwm config file

Ang sumusunod na 5 opsyon ay may bisa lamang kasama ng --preprocess pagpipilian.

-c|--cmd linya - isang fvwm na utos na paunang iproseso sa halip na file

-q|--quote char - baguhin ang default na '%' na quote

-w|--winid wid - itakda ang tahasang konteksto ng window (dapat magsimula sa digit, maaaring nasa oct o
hex na anyo; ino-overwrite ng window id na ito ang implicit window context kung mayroon)

--ilong - huwag ipadala ang na-preprocess na file sa fvwm para Basahining, ang default ay ipadala.
Kapaki-pakinabang para sa preprocessing non fvwm config file.

--hindi alisin - huwag tanggalin ang na-preprocess na file pagkatapos itong ipadala fvwm para Basahining, ang
ang default ay alisin. Kapaki-pakinabang para sa pag-debug.

-x|--export [mga pangalan] - tukuyin ang mga function ng fvwm shortcut (bilang default, dalawang function na pinangalanan
"Eval" at "."). Ang pagpipiliang ito ay nagpapahiwatig --manatili.

-s|--manatili - nagpapatuloy sa isang pagpapatupad pagkatapos --eval, —-load or --preprocess ay pinoproseso. Sa pamamagitan ng
default, ang module ay hindi paulit-ulit sa kasong ito, ibig sabihin --nostay ay ipinapalagay.

--nolock - kapag ang isa sa 3 opsyon sa pagkilos ay ibinigay, ang opsyon na ito ay nagdudulot ng pag-unlock fvwm
kaagad. Bilang default, ang hiniling na aksyon ay isinasagawa nang sabay-sabay; ito lamang ang gumagawa
pagkakaiba kapag tinawag tulad ng:

ModuleSynchronous FvwmPerl --preprocess someconfig.ppp

If --nolock idinagdag dito, ModuleSynchronous bumabalik kaagad. Tandaan na Module Babalik
kaagad anuman ang pagpipiliang ito.

GAMIT Bansag

Nagbibigay-daan ang mga alias na magkaroon ng ilang module na invocation at gumana nang hiwalay sa lahat ng invocation,
narito ang isang halimbawa:

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

PREPROCESSING Halimbawa

Isa sa mga epektibong solusyon sa pagproseso ay ang pagpasa sa buong pagsasaayos ng fvwm gamit ang
naka-embed na perl code sa "FvwmPerl --preprocess". Ang isang alternatibong diskarte ay ang pagsulat ng isang perl
script na gumagawa ng mga utos ng fvwm at ipinapadala ang mga ito para sa pagpapatupad, maaaring ma-load ang script na ito
gamit ang "FvwmPerl --load". May mga hovewer intermediate na solusyon na paunang proseso lamang
magkahiwalay na mga linya ng pagsasaayos (o bilang kahalili, magsagawa ng hiwalay na mga utos ng perl na
gumawa ng mga utos ng fvwm).

Ang sumusunod na code snippet ay nagdaragdag ng kakayahan ng arithmetics at string scripting sa ilang partikular
mga linyang nangangailangan nito. Upang gamitin ito, gusto mong simulan ang FvwmPerl bilang iyong unang command kaya
na ang iba pang mga utos ay maaaring hilingin na ma-preproseso.

ModuleSynchronize FvwmPerl

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

. Exec exec xterm -name xterm-%{++$i}% # gumamit ng natatanging pangalan

. GotoDesk 0 %{ $[desk.n] + 1 }% # pumunta sa susunod na desk

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

# igitna ang isang bintana
Susunod (MyWindow) . Ilipat \
%{($WIDTH - $[w.width]) / 2}%p %{($HEIGHT - $[w.height]) / 2}%p

. Exec exec xmessage %{2 + 2}% # simpleng calculator

. %{main::show_message(2 + 2, "Yet another Calculator"); ""}%

MGA PAGKILOS

Mayroong ilang mga aksyon na maaaring gawin ng FvwmPerl:

eval perl-code
Suriin ang isang linya ng perl code.

Isang espesyal na function cmd("utos") maaaring gamitin sa perl code upang magpadala ng mga command pabalik sa
fvwm.

Kung ang perl code ay naglalaman ng isang error, ito ay naka-print sa karaniwang error stream na may
[FvwmPerl][eval]: inihanda ang header.

magkarga pangalan ng file
Mag-load ng file ng perl code. Kung ang file ay hindi ganap na kwalipikado, ito ay hahanapin sa
direktoryo ng gumagamit $FVWM_USERDIR (karaniwan ay ~/.fvwm) at ang direktoryo ng data sa malawak na sistema
$FVWM_DATADIR.

Isang espesyal na function cmd("utos") maaaring gamitin sa perl code upang magpadala ng mga command pabalik sa
fvwm.

Kung ang perl code ay naglalaman ng isang error, ito ay naka-print sa karaniwang error stream na may
[FvwmPerl][load]: inihanda ang header.

paunang proseso [-q|--quote char] [-c|--cmd] [linya | file]
Preprocess fvwm config file o (kung --cmd ay ibinigay) linya. Ang file na ito ay naglalaman ng mga linya na
ay hindi ginalaw (karaniwan ay mga fvwm command) at espesyal na preformatted perl code iyon
naproseso at pinalitan. Nakalagay ang text %{ ... }% mga delimiter, na maaaring magsimula kahit saan
sa linya at nagtatapos saanman sa pareho o ibang linya, ay perl code.

Ang sipi nagbabago ang parameter ng mga delimiter ng perl code. Kung ang isang solong char ay ibinigay, tulad ng
'@', ang mga delimiter ay @{ ... }@. Kung ang binigay na quote ay 2 chars, like <>, ang mga quotes
ay <{ ... }>

Ang perl code ay pinapalitan para sa resulta ng pagsusuri nito. Ibig sabihin %{$a = "c"; ++$a}%
ay pinalitan ng "d".

Ang pagsusuri ay hindi katulad eval at magkarga ay ginagawa sa ilalim ng package na PreprocessNamespace
at wala gamitin mahigpit, kaya malaya kang gumamit ng anumang mga variable na pangalan nang walang takot
mga salungatan. Huwag lamang gumamit ng mga hindi nasimulang variable upang mangahulugan ng undef o walang laman na listahan (sila
maaaring sa katunayan ay sinimulan ng nakaraang pagkilos na preprocess), at gumawa ng paglilinis kung
kailangan. Ang mga variable at function sa pangunahin available pa ang package, like
::cmd() o ::laktawan(), ngunit hindi magandang ideya na i-access ang mga ito habang
preprocessing.

Mayroong isang espesyal na function isama(file) na naglo-load ng isang file, pinoproseso ito at
ibinabalik ang preprocessed na resulta. Iwasan ang recursion.

Kung ang anumang naka-embed na perl code ay naglalaman ng isang error, ito ay naka-print sa karaniwang error
stream at prepended sa [FvwmPerl][preprocess]: header. Ang resulta ng
walang laman ang pagpapalit sa kasong ito.

Ang mga sumusunod na variable ay maaaring gamitin sa perl code:

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

Ang mga sumusunod na line based na mga direktiba ay kinikilala kapag preprocessing. Sila ay
naproseso pagkatapos mapalitan ang perl code (kung mayroon man).

%Ulitin bilangin
Nagiging sanhi ng pag-ulit ng mga sumusunod na linya bilangin beses.

%ModuleConfig pangalan ng module [ sirain ]
Nagiging sanhi ng pagbibigay-kahulugan sa mga sumusunod na linya bilang ibinigay na configuration ng module. Kung
"sirain" ay tinukoy ang nakaraang module configuration ay nawasak muna.

%Prefix unlapi
Prefix ang mga sumusunod na linya na may sinipi unlapi.

%katapusan anumang-opsyonal na komento
Tinatapos ang alinman sa mga direktiba na inilarawan sa itaas, maaaring naka-nest.

Halimbawa:

%Pfix "AddToFunc SwitchToWindow I"
I-off ang iconify
Naka-off ang WindowShade
Taasan
WarpToWindow 50 50
%End

%ModuleConfig FvwmPager sirain
Colorset 0
Font lucidasans-10
DeskTopScale 28
Mga MiniIcon
%End ModuleConfig FvwmPager

%Pfix "Lahat (MyWindowToAnimate) ResizeMove "
100 100 %{($WIDTH - 100) / 2}% %{($HEIGHT - 100) / 2}%
%Repeat %{$count}%
br w+2c w+2c w-1c w-1c
%End
%Repeat %{$count}%
br w-2c w-2c w+1c w+1c
%End
%End Prefix

Maaaring magbigay din ng mga karagdagang preprocess na parameter --nosend at --noremove. Tingnan ang kanilang
paglalarawan sa itaas.

i-export [mga func-name]
Ipadala sa fvwm ang kahulugan ng mga function ng shortcut na tumutulong upang maisaaktibo ang iba
mga aksyon ng modyul (hal eval, magkarga at paunang proseso).

Mga pangalan ng function (mga func-name) ay maaaring paghiwalayin ng mga kuwit o/at whitespace. Bilang default,
dalawang function na "Eval" at "." ay ipinapalagay.

Ang aktwal na pagkilos na tinukoy sa isang function ay hinuhulaan mula sa pangalan ng function kung maaari,
kung saan ang pangalan ng function na "." ay nakalaan para sa paunang proseso pagkilos.

Halimbawa, alinman sa dalawang utos ng fvwm na ito

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

tukuyin ang sumusunod na dalawang shortcut function:

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

Ang 4 na pagkilos na ito ay maaaring hilingin sa isa sa 3 paraan: 1) sa command line kapag ang FvwmPerl ay
invoked (sa kasong ito ang FvwmPerl ay maikli ang buhay maliban kung --manatili or --export ay ibinigay din), 2)
sa pamamagitan ng pagpapadala ng kaukulang mensahe sa fvwm config gamit ang SendToModule, 3) sa pamamagitan ng pagtawag sa
kaukulang perl function sa perl code.

Mga function

Mayroong ilang mga function na maaaring tawagan ng perl code:

cmd($fvwm_command)
Kung sakali eval or magkarga - magpadala pabalik sa fvwm ng isang string $fvwm_command. Kung sakali
paunang proseso - magdagdag ng string $fvwm_command sa output ng naka-embed na perl code.

do_eval($perl_code)
Ang function na ito ay katumbas ng eval functionality sa string $perl_code,
inilarawan sa itaas.

load($filename)
Ang function na ito ay katumbas ng magkarga functionality sa file na $filename, inilarawan
sa itaas.

paunang proseso(@params, ["-c $command"] [$filename])
Ang function na ito ay katumbas ng paunang proseso functionality na may ibinigay na mga parameter
at ang file na $filename na inilarawan sa itaas.

i-export($func_names, [$do_unexport])
Ang function na ito ay katumbas ng i-export functionality na may ibinigay na $func_names,
inilarawan sa itaas. May din i-unexport ang mga pangalan ng function kung ang pangalawang parameter ay totoo.

Ang mga pangalan ng function ay dapat na pinaghihiwalay ng mga kuwit o/at whitespace. Kung $func_names is
walang laman pagkatapos ay gumagana ang "Eval" at "." ay ipinapalagay.

huminto ()
Tinatapos ang modyul.

laktawan()
Nilalaktawan ang natitirang code ng callback ng kaganapan, ibig sabihin, bumalik ang module upang makinig sa bago
mga kaganapan sa module.

i-unlock()
Ina-unsynchronize ang callback ng kaganapan mula sa fvwm. Ito ay maaaring maging kapaki-pakinabang upang maiwasan ang mga deadlock,
ie karaniwang pinapatay ng fvwm ang hindi tumutugon na module kung ang callback ng kaganapan ay hindi
natapos sa ModuleTimeout segundo. Pinipigilan ito nito.

Ang halimbawang ito ay nagiging sanhi ng FvwmPerl na suspindihin ang pagpapatupad nito ng isang minuto:

SendModule FvwmPerl eval unlock(); matulog(60);

Gayunpaman, i-verify na walang paraan ang isang bagong mensahe na ipinadala ng fvwm habang ang module ay
abala, at ang fvwm ay nananatiling naka-lock sa bagong mensaheng ito nang napakatagal. Tingnan din ang tanggalin
solusyon kung kailangan mo ng pangmatagalang operasyon.

ihiwalay ()
Tinidor at tinatanggal ang natitirang code ng callback ng kaganapan mula sa pangunahing proseso. Ito ay maaaring
maging kapaki-pakinabang upang maiwasan ang pagpatay sa module kung ang callback ng kaganapan nito ay dapat tumagal ng mahabang panahon
upang makumpleto at ito ay maaaring gawin sa hiwalay na bata. Maaaring pa rin ang hiwalay na bata
magpadala ng mga utos sa fvwm (huwag umasa dito), ngunit hindi tumanggap ng mga kaganapan siyempre, ito
lalabas kaagad pagkatapos makumpleto ang callback execution.

Kung gumagamit ka ng ihiwalay (), mas mahusay na magpadala lamang ng mga utos sa fvwm sa isang proseso (ang pangunahing o
ang hiwalay), kung hindi man ay maaaring maging sanhi ng mga salungatan.

show_message($msg, $title[, $use_stderr_too=1])
Nagpapakita ng dialog window na may ibinigay na mensahe, gamit ang alinmang X tool na makikita sa
system.

Tingnan FVWM::Module::Toolkit::show_message para sa karagdagang impormasyon.

MGA VARIABLE

Mayroong ilang mga pandaigdigang variable sa pangunahin namespace na maaaring gamitin sa perl
code:

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

Lahat sila ay sinisimulan sa walang laman na halaga at maaaring gamitin upang mag-imbak ng isang estado sa pagitan
iba't ibang mga tawag sa mga pagkilos ng FvwmPerl (eval at magkarga).

Kung kailangan mo ng mas maraming nababasang variable na pangalan, isulat ang "walang mahigpit na 'vars';" sa simula ng
bawat perl code o gumamit ng hash para dito, tulad ng:

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

o gumamit ng pangalan ng package, tulad ng:

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

Maaaring may opsyon sa pagsasaayos upang i-on at i-off ang pagiging mahigpit.

MENSAHE

Ang FvwmPerl ay maaaring makatanggap ng mga mensahe gamit ang fvwm command na SendToModule. Ang mga pangalan, kahulugan at
ang mga parameter ng mga mensahe ay pareho sa mga kaukulang aksyon, na inilarawan sa itaas.

Bilang karagdagan, isang mensahe itigil nagiging sanhi ng paghinto ng isang module.

Isang mensahe i-unexport [mga func-name] inaalis ang epekto ng i-export, na inilarawan sa ACTIONS
seksyon.

Isang mensahe tambakan ng basura itinatapon ang mga nilalaman ng mga nabagong variable (hindi pa).

HALIMBAWA

Isang simpleng pagsubok:

SendToModule FvwmPerl eval $h{dir} = $ENV{HOME}
SendToModule FvwmPerl eval load($h{dir} . "/test.fpl")
SendToModule FvwmPerl load $[HOME]/test.fpl
SendToModule FvwmPerl preprocess config.ppp
SendToModule FvwmPerl export Eval, PerlEval, PerlLoad, PerlPP
SendToModule FvwmPerl i-unexport ang PerlEval,PerlLoad,PerlPP
SendToModule FvwmPerl stop

Ang sumusunod na halimbawa ay humahawak sa root background sa fvwmrc. Ang lahat ng mga utos na ito ay maaaring idagdag
sa StartFunction.

Module FvwmPerl --export PerlEval

# hanapin ang lahat ng mga pixmap sa background para sa paggamit sa ibang pagkakataon
PerlEval $a = $ENV{HOME} . "/bg"; \
opendir DIR, $a; @b = grep { /xpm$/ } readdir(DIR); closedir DIR

# bumuo ng isang menu ng background pixmaps
AddToMenu MyBackgrounds "My Backgrounds" Pamagat
PerlEval foreach $b (@b) \
{ cmd("AddToMenu MyBackgrounds '$b' Exec fvwm-root $a/$b") }

# pumili ng random na background na ilo-load sa start-up
PerlEval cmd("AddToFunc \
InitFunction + I Exec exec fvwm-root $a/" . $b[int(random(@b))])

TUMAKAS

SendToModule tulad ng iba pang mga utos ng fvwm ay nagpapalawak ng ilang mga variable na may prefix na dolyar.
Ito ay maaaring sumalungat sa mga dolyar na ginagamit ng perl. Maaari mong maiwasan ito sa pamamagitan ng paglalagay ng prefix sa SendToModule
na may nangungunang gitling. Ang sumusunod na 2 linya sa bawat pares ay katumbas:

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

SendToModule FvwmPerl eval \
cmd("Echo desk=$d, display=$$d")
SendToModule FvwmPerl preprocess -c \
Echo desk=%("$d")%, display=%{$$d}%

Ang isa pang solusyon upang maiwasan ang pagtakas ng mga espesyal na simbolo tulad ng mga dolyar at backslashes ay ang
lumikha ng isang perl file sa ~/.fvwm at pagkatapos ay i-load ito:

SendToModule FvwmPerl i-load ang build-menus.fpl

Kung kailangan mong iproseso ang isang utos na nagsisimula sa isang gitling, dapat mong unahan ito gamit
"--".

# ito ay nagpi-print ng kasalukuyang desk, ibig sabihin, "0"
SendToModule FvwmPerl preprocess -c Echo "$%{$a = "c"; ++$a}%"
# ito ay nagpi-print ng "$d"
SendToModule FvwmPerl preprocess -c -- -Echo "$%{"d"}%"
# ito ay nagpi-print ng "$d" (SendToModule ay nagpapalawak ng $$ hanggang $)
SendToModule FvwmPerl preprocess -c -- -Echo "$$%{"d"}%"
# ito ay nagpi-print ng "$$d"
-SendToModule FvwmPerl preprocess -c -- -Echo "$$%{"d"}%"

Muli, iminumungkahi na ilagay ang iyong (mga) command sa file at sa halip ay iproseso ang file.

MGA CAVEATS

Ang FvwmPerl na isinusulat sa perl at nakikitungo sa perl, ay sumusunod sa sikat na perl motto:
"Mayroong higit sa isang paraan upang gawin ito", kaya ang pagpipilian ay sa iyo.

Narito ang higit pang mga pares ng katumbas na linya:

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

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

Babala, maaari mong maapektuhan ang paraan ng paggana ng FvwmPerl sa pamamagitan ng pagsusuri ng naaangkop na perl code, ito
ay itinuturing na isang tampok na hindi isang bug. Ngunit mangyaring huwag gawin ito, sumulat ng iyong sariling fvwm module
sa perl sa halip.

Gamitin ang FvwmPerl online gamit ang mga serbisyo ng onworks.net