view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
view release on metacpan or search on metacpan
lib/HTML/Dojo/src.pm view on Meta::CPAN
message += " -- will be removed in version: " + removal;
}
dojo.debug(message);
};
dojo.render = (function () {
function vscaffold(prefs, names) {
var tmp = {capable:false, support:{builtin:false, plugin:false}, prefixes:prefs};
for (var i = 0; i < names.length; i++) {
tmp[names[i]] = false;
}
return tmp;
}
lib/HTML/Dojo/src.pm view on Meta::CPAN
message += " -- will be removed in version: " + removal;
}
dojo.debug(message);
};
dojo.render = (function () {
function vscaffold(prefs, names) {
var tmp = {capable:false, support:{builtin:false, plugin:false}, prefixes:prefs};
for (var i = 0; i < names.length; i++) {
tmp[names[i]] = false;
}
return tmp;
}
view release on metacpan or search on metacpan
lib/HTML/EP/Explorer.pm view on Meta::CPAN
my $session = $self->{$attr->{'var'} || 'session'};
if ($self->{debug}) {
require Data::Dumper;
$self->print("Session = ", Data::Dumper::Dumper($session), "\n");
}
if (!$attr->{'noprefs'} and
($@ or !exists($session->{'prefs'}))) {
# First time run, open the prefs page.
my $prefs = $attr->{'prefs_page'} || "prefs.ep";
my $return_to = $attr->{'return_to'} || $self->{'env'}->{'PATH_INFO'};
$self->print("_ep_explorer_init: Redirecting to $prefs, returning to $return_to\n")
if $self->{'debug'};
$cgi->param('return_to', $return_to);
$self->{'_ep_output'} .= $self->_ep_include({file => $prefs});
$self->_ep_exit({});
}
'';
}
lib/HTML/EP/Explorer.pm view on Meta::CPAN
$self->{'num_directories'} = @{$self->{'directories'}};
'';
}
sub ReadPrefs {
my $self = shift; my $prefs = shift;
my $cgi = $self->{'cgi'};
foreach my $var ($cgi->param()) {
next unless $var =~ /^explorer_prefs_(.*)/;
my $vr = $1;
my $val = $cgi->param($var);
$prefs->{$vr} = $val;
}
$prefs;
}
sub _ep_explorer_prefs {
my $self = shift; my $attr = shift;
my $debug = $self->{'debug'};
$attr->{'noprefs'} = 1;
$self->_ep_explorer_init($attr);
my $session = $self->{$attr->{'var'} ||= 'session'};
my $cgi = $self->{'cgi'};
my $return;
if (($return = $cgi->param('save_and_return')) ||
$cgi->param('save')) {
$self->print("_ep_explorer_prefs: Saving.\n") if $debug;
$session->{'prefs'} = $self->ReadPrefs($session->{'prefs'});
if ($debug) {
require Data::Dumper;
$self->print("_ep_explorer_save: Got\n",
Data::Dumper->new([$session->{'prefs'}])
->Indent(1)->Terse(1)->Dump(), "\n");
}
$attr->{'locked'} = 1;
$self->_ep_session_store($attr);
}
lib/HTML/EP/Explorer.pm view on Meta::CPAN
Besides the questions you already answered when installing the explorer,
the system is configurable via any Web browser. Assuming the Explorer
is reachable below http://localhost/explorer/, Point your browser to
http://localhost/explorer/admin/prefs.ep
=head2 Security considerations
The first thing you probably notice is that you need not supply a password
lib/HTML/EP/Explorer.pm view on Meta::CPAN
Probably any HTML page using the explorer system should contain
the following:
<ep-package name=HTML::EP::Explorer accept="de,en">
<ep-explorer-init noprefs=0>
The I<_ep_explorer_init> method is initializing the users cookie.
First it verifies, whether the user already has an explorer cookie
set. If not, the user will be redirected to the I<prefs.ep> page,
unless the attribute I<noprefs> is set. This page will allow him
to fix his personal settings and return to the calling page.
The explorer class is a subclass of both I<HTML::EP::Locale> and
I<HTML::EP::Session>. That means that the locale settings are
still valid in the I<ep-package> call (in particular the I<accept>
lib/HTML/EP/Explorer.pm view on Meta::CPAN
L<HTML::EP::Session(3)>.
=head2 Reading and/or writing the admin settings
Within F<admin/prefs.ep> and some other pages, you find the following
call:
<ep-explorer-config file="config.pm" maysafe=0>
which read the admin settings from an external file, by default
lib/HTML/EP/Explorer.pm view on Meta::CPAN
=head2 Reading and/or writing the users settings
The users settings can be read and/or written by calling
<ep-explorer-prefs>
This will call I<_ep_explorer_init> internally, by setting the
I<noprefs> attribute to true. If either of the CGI variables
I<save> or I<save_and_return> is set, it will read the users
new settings from the CGI environment by running
B<$self-E<gt>ReadPrefs> and store the session (that is, return
a cookie) by calling I<ep-session-store>.
view release on metacpan or search on metacpan
lib/HTML/EP/Glimpse.pm view on Meta::CPAN
$HTML::EP::Glimpse::VERSION = '0.05';
@HTML::EP::Glimpse::ISA = qw(HTML::EP::Locale HTML::EP);
sub _prefs {
my $self = shift; my $attr = shift; my $prefs = shift;
$self->{'glimpse_config'} ||= $HTML::EP::Glimpse::Config::config;
my $config = $self->{'glimpse_config'};
my $vardir = $config->{'vardir'};
die "A directory $vardir does not exist. Please create it, with write "
. " permissions for the web server, or modify the value of "
. " vardir in $INC{'HTML/EP/Glimpse/Config.pm'}."
unless -d $vardir;
my $prefs_file = "$vardir/prefs";
if (!$prefs) {
# Load Prefs
require Safe;
my $cpt = Safe->new();
$prefs = $self->{'prefs'} = $cpt->rdo($prefs_file) || {};
$prefs->{'rootdir'} = $ENV{'DOCUMENT_ROOT'}
unless exists($prefs->{'rootdir'});
$prefs->{'dirs'} = "/"
unless exists($prefs->{'dirs'});
$prefs->{'dirs_ignored'} =
(($ENV{'PATH_INFO'} =~ /(.*)\//) ? $1 : "")
unless exists($prefs->{'dirs_ignored'});
$prefs->{'suffix'} = ".html .htm"
unless exists($prefs->{'suffix'});
} else {
# Save Prefs
require Data::Dumper;
my $d = Data::Dumper->new([$prefs])->Indent(1)->Terse(1)->Dump();
require Symbol;
my $fh = Symbol::gensym();
if ($self->{'debug'}) {
print "Saving Preferences to $prefs_file.\n";
$self->print("Saving data:\n$d\n");
}
die "Could not save data into $prefs_file: $!. Please verify whether"
. " the web server has write permissions in $vardir and on"
. " $prefs_file."
unless open($fh, ">$prefs_file") and (print $fh "$d\n")
and close($fh);
}
$self->{'glimpse_prefs'} = $prefs;
}
sub _ep_glimpse_load {
my $self = shift; my $attr = shift;
my $cgi = $self->{'cgi'};
my $prefs = $self->_prefs($attr);
if ($cgi->param('modify')) {
my $modified = 0;
foreach my $p ($cgi->param()) {
if ($p =~ /^glimpse_prefs_(.*)/) {
my $sp = $1;
my $old = $prefs->{$sp};
my $new = $cgi->param($p);
if (!defined($old)) {
if (defined($new)) {
$modified = 1;
$prefs->{$sp} = $new;
}
} elsif (!defined($new)) {
$modified = 1;
$prefs->{$sp} = $new;
} else {
$modified = ($new ne $old);
$prefs->{$sp} = $new;
}
}
}
if ($self->{'debug'}) {
$self->print("Modifications detected.\n");
}
$self->_prefs($attr, $prefs);
}
'';
}
sub _ep_glimpse_create {
my $self = shift; my $attr = shift;
my $prefs = $self->_prefs($attr);
my $vardir = $self->{'glimpse_config'}->{'vardir'};
my $debug = $self->{'debug'};
my $cfg = $self->{'glimpse_config'};
my $rootdir = $prefs->{'rootdir'};
my $dirlist = $prefs->{'dirs'};
$dirlist =~ s/\s+/ /sg;
$dirlist =~ s/^\s+//;
$dirlist =~ s/\s+$//;
my @dirs = map { "$rootdir/$_" } split(/ /, $dirlist);
$dirlist = $prefs->{'dirs_ignored'};
$dirlist =~ s/\s+/ /sg;
$dirlist =~ s/^\s+//;
$dirlist =~ s/\s+$//;
my @dirs_ignored = map { "$rootdir/$_" } split(/ /, $dirlist);
lib/HTML/EP/Glimpse.pm view on Meta::CPAN
$self->print("Making function for directory match: $func",
" ($matchesDirsIgnored))\n") if $debug;
} else {
$matchesDirsIgnored = sub { 0 }
}
my $suffixList = $prefs->{'suffix'};
$suffixList =~ s/\s+/ /sg;
$suffixList =~ s/^\s+//;
$suffixList =~ s/\s+$//;
my @suffix = split(/ /, $suffixList);
my $matchesSuffix;
lib/HTML/EP/Glimpse.pm view on Meta::CPAN
$output;
}
sub _ep_glimpse_search {
my $self = shift; my $attr = shift;
my $prefs = $self->_prefs($attr);
my $vardir = $self->{'glimpse_config'}->{'vardir'};
my $cgi = $self->{'cgi'};
my $debug = $self->{'debug'};
my $start = ($cgi->param('start') or 0);
my $max = ($cgi->param('max') or $attr->{'max'} or 20);
lib/HTML/EP/Glimpse.pm view on Meta::CPAN
}
}
$self->print("Found " . scalar(@files) . " files\n") if $debug;
foreach my $file (@files) {
my $url = $file->{'file'};
$url =~ s/^\Q$prefs->{'rootdir'}\E//;
$url =~ s/^\/+/\//;
$file->{'url'} = $url;
}
$self->{'files'} = \@files;
if (@files == $max) {
view release on metacpan or search on metacpan
lib/HTML/EP/Examples/Admin.pm view on Meta::CPAN
$self->{'admin_config'}->{'vardir'} ||= '/home/httpd/html/admin/var';
}
}
sub _prefs {
my $self = shift; my $prefs = shift;
my $vardir = $self->{'admin_config'}->{'vardir'};
my $prefs_file = "$vardir/prefs";
if (!$prefs) {
# Load Prefs
$self->{'prefs'} = (do $prefs_file) || {};
} else {
# Save Prefs
require Data::Dumper;
my $dump = Data::Dumper->new([$prefs], ['PREFS']);
$dump->Indent(1);
require Symbol;
my $fh = Symbol::gensym();
my $d = $dump->Dump();
if ($self->{'debug'}) {
print "Saving Preferences to $prefs_file.\n";
$self->print("Saving data:\n$d\n");
}
if (!open($fh, ">$prefs_file")
or !(print $fh "$d\n")
or !close($fh)) {
die "Couldn't save data: $!";
}
$self->{'prefs'} = $prefs;
}
}
sub _ep_html_ep_examples_admin_squid {
my $self = shift; my $attr = shift;
my $cgi = $self->{'cgi'};
my $prefs = $self->_prefs();
my $debug = $self->{'debug'};
my $verify_squid_range = sub {
my($from, $to, $active, $name) = @_;
lib/HTML/EP/Examples/Admin.pm view on Meta::CPAN
$modified = 1;
}
if ($modified) {
$self->print("Modifications detected.\n") if $debug;
$prefs->{'squid_ranges'} = \@range;
$self->_prefs($prefs);
my $path_users_modified =
($attr->{'users-modified-path'} ||
$self->{'admin_config'}->{'users_modified_path'})
or die "Path of usersModified binary not set";
if ($path_users_modified ne 'none') {
lib/HTML/EP/Examples/Admin.pm view on Meta::CPAN
if $debug;
system @command;
}
} else {
$self->print("No modifications detected.\n") if $debug;
$prefs->{'squid_ranges'} ||= [];
}
@range = sort { $a->{name} cmp $b->{name}} @{$prefs->{'squid_ranges'}};
$self->{'ranges'} = \@range;
if ($debug) {
$self->print("Squid IP ranges:\n");
foreach my $r (@{$prefs->{'squid_ranges'}}) {
$self->printf(" Name %s, From %s, To %s, Active %s\n",
$r->{'name'}, $r->{'from'}, $r->{'to'},
$r->{'active'});
}
}
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
view release on metacpan or search on metacpan
t/mime.types view on Meta::CPAN
# application/vnd.oma.bcast.stkm
# application/vnd.oma.cab-address-book+xml
# application/vnd.oma.cab-feature-handler+xml
# application/vnd.oma.cab-pcc+xml
# application/vnd.oma.cab-subs-invite+xml
# application/vnd.oma.cab-user-prefs+xml
# application/vnd.oma.dcd
# application/vnd.oma.dcdc
application/vnd.oma.dd2+xml dd2
# application/vnd.oma.drm.risd+xml
# application/vnd.oma.group-usage-list+xml
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
view release on metacpan or search on metacpan
lib/Handel/Checkout.pm view on Meta::CPAN
throw Handel::Exception::Checkout( -details =>
translate('HANDLER_EXISTS_IN_PHASE', $phase, $preference, $plugin)
);
};
} else {
my @prefs = sort {$a <=> $b} keys %{$self->{'handlers'}->{$phase}};
$preference = scalar @prefs ? $#prefs++ : 101;
};
$self->{'handlers'}->{$phase}->{$preference} = [$_, $ref];
last;
};
};
lib/Handel/Checkout.pm view on Meta::CPAN
$self->order->result->txn_begin;
foreach my $phase (@{$phases}) {
next unless $phase;
my @handlerprefs = sort {$a <=> $b} keys %{$self->{'handlers'}->{$phase}};
foreach my $handlerpref (@handlerprefs) {
my $handler = $self->{'handlers'}->{$phase}->{$handlerpref};
my $status = $handler->[1]->($handler->[0], $self);
if ($status != CHECKOUT_HANDLER_OK && $status != CHECKOUT_HANDLER_DECLINE) {
$self->_teardown($self);
view release on metacpan or search on metacpan
resources/extensions.json view on Meta::CPAN
"name":"INI",
"type":"data",
"extensions":[
".ini",
".cfg",
".prefs",
".pro",
".properties"
]
},
{
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
view release on metacpan or search on metacpan
lib/Image/DS9/Grammar/V8_5.pm view on Meta::CPAN
],
],
#------------------------------------------------------>
prefs => TODO,
#------------------------------------------------------
preserve => [ [ [ ENUM( 'pan', 'regions' ) ], { args => [BOOL] }, ], ],
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
view release on metacpan or search on metacpan
lib/Image/ExifTool/TagLookup.pm view on Meta::CPAN
'poweruptime' => { 258 => 0xb6 },
'preaf' => { 134 => '0.2' },
'precaptureframes' => { 352 => 0x300 },
'predictor' => { 127 => 0x13d },
'preflashreturnstrength' => { 296 => 0x28a },
'prefs' => { 150 => 0xdd, 423 => 'Prefs' },
'prereadfastresetcount' => { 157 => 0x187e },
'prereleaseburstlength' => { 268 => 0x712, 269 => 0x782, 342 => 0x287 },
'preservedfilename' => { 567 => 'PreservedFileName' },
'preservedspecimen' => { 126 => 'PreservedSpecimen' },
'preservedspecimenmaterialsampleid' => { 126 => [\'PreservedSpecimen','PreservedSpecimenMaterialSampleID'] },