Result:
found more than 662 distributions - search limited to the first 2001 files matching your query
( run in 1.005 )
JQuery-Mobile
view release on metacpan or search on metacpan
lib/JQuery/Mobile.pm view on Meta::CPAN
'navbar-data-attribute' => ['disable-page-zoom', 'enhance', 'fullscreen', 'iconpos', 'tap-toggle', 'theme', 'transition', 'update-page-padding', 'visible-on-page-show'],
'navbar-item-html-attribute' => ['id', 'class', 'target'],
'navbar-item-data-attribute' => ['ajax', 'icon', 'iconpos', 'iconshadow','prefetch', 'theme'],
'page-html-attribute' => ['id', 'class'],
# combine data-attributes for page and dialog
'page-data-attribute' => ['add-back-btn', 'back-btn-text', 'back-btn-theme', 'close-btn', 'close-btn-text', 'corners', 'dom-cache', 'enhance', 'overlay-theme', 'role', 'shadow','theme', 'title', 'tolerance', 'url'],
'table-html-attribute' => ['id', 'class'],
'table-data-attribute' => ['mode'],
'table-head-html-attribute' => ['id', 'class'],
'table-head-data-attribute' => ['priority'],
'panel-html-attribute' => ['id', 'class'],
'panel-data-attribute' => ['corners', 'overlay-theme', 'shadow', 'theme', 'tolerance', 'position-to', 'rel', 'role', 'transition'],
'popup-html-attribute' => ['id', 'class'],
'popup-data-attribute' => ['animate', 'dismissible', 'display', 'position', 'position-fixed', 'swipe-close', 'role', 'theme'],
'listview-html-attribute' => ['id', 'class'],
'listview-data-attribute' => ['autodividers', 'count-theme', 'divider-theme', 'enhance', 'filter', 'filter-placeholder', 'filter-reveal', 'filter-theme', 'filtertext', 'header-theme', 'inset', 'split-icon', 'split-theme', 'theme'],
'listview-item-html-attribute' => ['id', 'class'],
lib/JQuery/Mobile.pm view on Meta::CPAN
'input-html-attribute' => ['id', 'class', 'disabled', 'max', 'maxlength', 'min', 'name', 'pattern', 'placeholder', 'readonly', 'required', 'size', 'type', 'value', 'accept', 'capture'],
'input-data-attribute' => ['clear-btn', 'clear-btn-text', 'corners', 'highlight', 'icon', 'iconpos', 'iconshadow', 'inline', 'mini', 'shadow', 'theme', 'track-theme'],
'textarea-html-attribute' => ['id', 'name', 'class', 'rows', 'cols', 'readonly', 'disabled', 'title', 'required', 'placeholder', 'title', 'pattern'],
'textarea-data-attribute' => ['clear-btn', 'clear-btn-text', 'mini', 'theme'],
'select-html-attribute' => ['id', 'class', 'size', 'maxlength', 'readonly', 'disabled', 'title', 'required', 'placeholder', 'title', 'pattern', 'multiple'],
'select-data-attribute' => ['icon', 'iconpos', 'inline', 'mini', 'native-menu', 'overlay-theme', 'theme', 'role'],
'radio-checkbox-html-attribute' => ['id', 'class', 'readonly', 'disabled', 'title', 'required', 'placeholder', 'title', 'pattern', 'value'],
'radio-checkbox-data-attribute' => ['mini', 'theme'],
'rangeslider-html-attribute' => ['id', 'name', 'class'],
'rangeslider-data-attribute' => ['highlight', 'mini', 'theme', 'track-theme'],
'label' => sub {
lib/JQuery/Mobile.pm view on Meta::CPAN
'navbar-data-attribute' => ['disable-page-zoom', 'enhance', 'fullscreen', 'iconpos', 'tap-toggle', 'theme', 'transition', 'update-page-padding', 'visible-on-page-show'],
'navbar-item-html-attribute' => ['id', 'class', 'target'],
'navbar-item-data-attribute' => ['ajax', 'icon', 'iconpos', 'iconshadow','prefetch', 'theme'],
'page-html-attribute' => ['id', 'class'],
# combine data-attributes for page and dialog
'page-data-attribute' => ['add-back-btn', 'back-btn-text', 'back-btn-theme', 'close-btn', 'close-btn-text', 'corners', 'dom-cache', 'enhance', 'overlay-theme', 'role', 'shadow','theme', 'title', 'tolerance', 'url'],
'popup-html-attribute' => ['id', 'class'],
'popup-data-attribute' => ['corners', 'overlay-theme', 'shadow', 'theme', 'tolerance', 'position-to', 'rel', 'role', 'transition'],
'listview-html-attribute' => ['id', 'class'],
'listview-data-attribute' => ['autodividers', 'count-theme', 'divider-theme', 'enhance', 'filter', 'filter-placeholder', 'filter-theme', 'filtertext', 'header-theme', 'inset', 'split-icon', 'split-theme', 'theme'],
'listview-item-html-attribute' => ['id', 'class'],
'listview-item-data-attribute' => ['ajax', 'mini', 'rel', 'theme', 'transition'],
'collapsible-html-attribute' => ['id', 'class'],
lib/JQuery/Mobile.pm view on Meta::CPAN
'input-html-attribute' => ['id', 'class', 'disabled', 'max', 'maxlength', 'min', 'name', 'pattern', 'placeholder', 'readonly', 'required', 'size', 'type', 'value', 'accept', 'capture'],
'input-data-attribute' => ['clear-btn', 'clear-btn-text', 'corners', 'highlight', 'icon', 'iconpos', 'iconshadow', 'inline', 'mini', 'shadow', 'theme', 'track-theme'],
'textarea-html-attribute' => ['id', 'name', 'class', 'rows', 'cols', 'readonly', 'disabled', 'title', 'required', 'placeholder', 'title', 'pattern'],
'textarea-data-attribute' => ['clear-btn', 'clear-btn-text', 'mini', 'theme'],
'select-html-attribute' => ['id', 'class', 'size', 'maxlength', 'readonly', 'disabled', 'title', 'required', 'placeholder', 'title', 'pattern'],
'select-data-attribute' => ['icon', 'iconpos', 'inline', 'mini', 'native-menu', 'overlay-theme', 'placeholder', 'theme'],
'radio-checkbox-html-attribute' => ['id', 'class', 'readonly', 'disabled', 'title', 'required', 'placeholder', 'title', 'pattern', 'value'],
'radio-checkbox-data-attribute' => ['mini', 'theme']
}
);
JQuery
view release on metacpan or search on metacpan
lib/JQuery/jquery_js/plugins/blockUI/jquery.block.js view on Meta::CPAN
$.blockUI.defaults = {
// the message displayed when blocking the entire page
pageMessage: '<h1>Please wait...</h1>',
// the message displayed when blocking an element
elementMessage: '', // none
// styles for the overlay iframe
overlayCSS: { backgroundColor: '#fff', opacity: '0.5' },
// styles for the message when blocking the entire page
pageMessageCSS: { width:'250px', margin:'-50px 0 0 -125px', top:'50%', left:'50%', textAlign:'center', color:'#000', backgroundColor:'#fff', border:'3px solid #aaa' },
// styles for the message when blocking an element
elementMessageCSS: { width:'250px', padding:'10px', textAlign:'center', backgroundColor:'#fff'}
};
lib/JQuery/jquery_js/plugins/blockUI/jquery.block.js view on Meta::CPAN
var w = $('<div class="blockUI" style="z-index:1001;cursor:wait;border:none;margin:0;padding:0;width:100%;height:100%;top:0;left:0"></div>');
var m = full ? $('<div class="blockUI blockMsg" style="z-index:1002;cursor:wait;padding:0;position:fixed"></div>')
: $('<div class="blockUI" style="display:none;z-index:1002;cursor:wait;position:absolute"></div>');
w.css('position', full ? 'fixed' : 'absolute');
if (msg) m.css(css);
if (!noalpha) w.css($.blockUI.defaults.overlayCSS);
if (this.op8) w.css({ width:''+el.clientWidth,height:''+el.clientHeight }); // lame
if ($.browser.msie) f.css('opacity','0.0');
$([f[0],w[0],m[0]]).appendTo(full ? 'body' : el);
if (full) this.pageBlock = m[0];
JSONAPI-Document
view release on metacpan or search on metacpan
lib/JSONAPI/Document/Builder/Compound.pm view on Meta::CPAN
my $result_ref =
$self->build_relationship($relation_source, $fields->{$relation_source}, { with_attributes => 1 })->{data};
if (ref($result_ref) eq 'ARRAY') { # The source relation is a has_many, link the nested resources for each one.
my $source_row = $self->row->$relation_source;
if ($source_row->can('all')) { # Check if any overlaying dbix resultset class can do "all"
my $includes =
$self->build_nested_from_resultset($source_row, $result_ref, $nested->{$relation_source}, $fields);
push @included, $_ for @$includes;
}
} else {
JavaScript-ExtJS-V3
view release on metacpan or search on metacpan
share/ext-3.4.1/docs/extjs/ext-all.js view on Meta::CPAN
--
This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT OF THIRD-PARTY INTELLECTUAL PROPERTY RIGHTS. See t...
*/
var Ext=Ext||{};Ext._startTime=new Date().getTime();(function(){var h=this,a=Object.prototype,j=a.toString,b=true,g={toString:1},e=function(){},d=function(){var i=d.caller.caller;return i.$owner.prototype[i.$name].apply(this,arguments)},c;Ext.global=...
JavaScript-Packer
view release on metacpan or search on metacpan
t/scripts/s12-expected.js view on Meta::CPAN
eval(function(p,a,c,k,e,r){e=function(c){return(c<62?'':e(parseInt(c/62)))+((c=c%62)>35?String.fromCharCode(c+29):c.toString(36))};if('0'.replace(0,e)==0){while(c--)r[e(c)]=k[c];k=[function(e){return r[e]||e}];e=function(){return'([wEHLQV-Z]|[0-9a-zA...
Jifty
view release on metacpan or search on metacpan
share/web/static/css/facebox.css view on Meta::CPAN
width: 10px;
overflow: hidden;
padding: 0;
}
#facebox_overlay {
position: fixed;
top: 0px;
left: 0px;
height:100%;
width:100%;
share/web/static/css/facebox.css view on Meta::CPAN
.facebox_hide {
z-index:-100;
}
.facebox_overlayBG {
background-color: #000;
z-index: 99;
}
* html #facebox_overlay { /* ie6 hack */
position: absolute;
height: expression(document.body.scrollHeight > document.body.offsetHeight ? document.body.scrollHeight : document.body.offsetHeight + 'px');
}
KML-PolyMap
view release on metacpan or search on metacpan
lib/Geo/KML/PolyMap.pm view on Meta::CPAN
push(@kml_file,"<description>$placename $datadesc</description>");
push(@kml_file,"<name>Legend</name>");
push(@kml_file,"<Icon>");
push(@kml_file,"<href>$legend_file_name</href>");
push(@kml_file,"</Icon>");
push(@kml_file,"<overlayXY x=\"0\" y=\"1\" xunits=\"fraction\" yunits=\"fraction\"/>");
push(@kml_file,"<screenXY x=\"0\" y=\"1\" xunits=\"fraction\" yunits=\"fraction\"/>");
push(@kml_file,"<rotationXY x=\"0\" y=\"0\" xunits=\"fraction\" yunits=\"fraction\"/>");
push(@kml_file,"<size x=\"0\" y=\"0\" xunits=\"pixels\" yunits=\"pixels\"/>");
push(@kml_file,"<rotation>0</rotation>");
push(@kml_file,"</ScreenOverlay>");
KiokuDB
view release on metacpan or search on metacpan
lib/KiokuDB/TypeMap/Shadow.pm view on Meta::CPAN
=head1 DESCRIPTION
This class is useful for performing mixin inheritance like merging of typemaps,
by shadowing an ordered list.
This is used internally to overlay the user typemap on top of the
L<KiokuDB::TypeMap::Default> instance provided by the backend.
This differs from using C<includes> in L<KiokuDB::TypeMap> because that
inclusion is computed symmetrically, like roles.
LINE-Bot-API
view release on metacpan or search on metacpan
lib/LINE/Bot/API.pm view on Meta::CPAN
my $messages = LINE::Bot::API::Builder::SendMessage->new(
)->add_imagemap($imagemap->build);
$bot->reply_message($reply_token, $messages->build);
An Imagemap message can contain a video area inside. Here is an example of one withe upper half being a video overlay:
my $imagemap_message = LINE::Bot::API::Builder::ImagemapMessage->new(
base_url => 'https://example.com/bot/images/rm001',
alt_text => 'this is an imagemap',
base_width => 1040,
LaBrea-Tarpit
view release on metacpan or search on metacpan
Report/examples/localTrojans.pl view on Meta::CPAN
}
return($line);
};
# overlay above with below in order
@_ = split('\n',q|
#
# my additions + user contributions
1 Sockets des Troie
LaTeXML-Plugin-LtxMojo
view release on metacpan or search on metacpan
lib/LaTeXML/Plugin/LtxMojo/public/css/external/jquery-ui.css view on Meta::CPAN
/* Misc visuals
----------------------------------*/
/* Overlays */
.ui-widget-overlay { position: absolute; top: 0; left: 0; width: 100%; height: 100%; }
/*!
* jQuery UI CSS Framework 1.8.24
*
lib/LaTeXML/Plugin/LtxMojo/public/css/external/jquery-ui.css view on Meta::CPAN
.ui-corner-all, .ui-corner-top, .ui-corner-right, .ui-corner-tr { -moz-border-radius-topright: 4px; -webkit-border-top-right-radius: 4px; -khtml-border-top-right-radius: 4px; border-top-right-radius: 4px; }
.ui-corner-all, .ui-corner-bottom, .ui-corner-left, .ui-corner-bl { -moz-border-radius-bottomleft: 4px; -webkit-border-bottom-left-radius: 4px; -khtml-border-bottom-left-radius: 4px; border-bottom-left-radius: 4px; }
.ui-corner-all, .ui-corner-bottom, .ui-corner-right, .ui-corner-br { -moz-border-radius-bottomright: 4px; -webkit-border-bottom-right-radius: 4px; -khtml-border-bottom-right-radius: 4px; border-bottom-right-radius: 4px; }
/* Overlays */
.ui-widget-overlay { background: #666666 url(images/ui-bg_diagonals-thick_20_666666_40x40.png) 50% 50% repeat; opacity: .50;filter:Alpha(Opacity=50); }
.ui-widget-shadow { margin: -5px 0 0 -5px; padding: 5px; background: #000000 url(images/ui-bg_flat_10_000000_40x100.png) 50% 50% repeat-x; opacity: .20;filter:Alpha(Opacity=20); -moz-border-radius: 5px; -khtml-border-radius: 5px; -webkit-border-radiu...
* jQuery UI Resizable 1.8.24
*
* Copyright 2012, AUTHORS.txt (http://jqueryui.com/about)
* Dual licensed under the MIT or GPL Version 2 licenses.
LaTeXML
view release on metacpan or search on metacpan
lib/LaTeXML/Package/beamer.cls.ltxml view on Meta::CPAN
#**********************************************************************
# The decoding macro does decoding using tex, we do it with perl!
# Doesn't have a user-facing interface.
# this grammar defines what an (alert|overlay|mode) specification is!
our $BEAMER_SPECIFICATION = Parse::RecDescent->new(<<'EOGRAMMAR');
# a mode specification
mode_spec:
MODE(s /|/)
# an overlay specification
overlay_spec:
mode_and_frame(s /\|/)
# an action specification
action_spec:
mode_and_action_and_frame(s /\|/)
lib/LaTeXML/Package/beamer.cls.ltxml view on Meta::CPAN
MODIFIER : '.' | '+'
STAR : '*'
EOGRAMMAR
# processBeamerSpec is the main function for processing alert and overlay specifications.
# This takes place in three steps:
#
# 1. Process the AST
# 2. Filter out non-matching modes
# 3. Evaluate '+'s and perform actions
#
# This function takes the following arguments:
# $spec - The specification to parse (a string)
# $mode - The current (actual) mode to process the specification in.
# $allowActions - when true, process an action specification, else an overlay specification.
# $beamerPauses - The value of plus that was encountered. This is used to process relative frame numbers.
#
# The function returns a pair ([@actions], $newBeamerPauses).
# $newBeamerPauses - The new last plus encountered.
# @actions - an array containing a list of frames and the corresponding actions to perform.
#
# When parsing fails, returns (undef, $beamerPauses).
#
# Each $action in @actions is a hash with the following keys:
# 'action' => The action to perform (in the case of an overlay specification this is undef, in alert specifications, this might be undef or the action itself).
# 'frames' => an array of hashes with the following keys:
#
# 'from' => The absolute slide number this action should start at, may be undef to indiciate the first slide.
# 'to' => The absolute slide number this action should end at (inclusive), may be undef to indiciate the last slide.
sub processBeamerSpec {
my ($spec, $allowActions, $mode, $beamerPauses) = @_;
# process the specification into an ast!
$spec =~ s/\s+//g;
# process an overlay or alert, depending on if $allowActions is true
# FIXME: action_spec only parses first one
my ($ast);
if ($allowActions) {
$ast = $BEAMER_SPECIFICATION->action_spec($spec); }
else {
$ast = $BEAMER_SPECIFICATION->overlay_spec($spec); }
return $beamerPauses, undef unless defined($ast);
# prepare the returned list of actions
my (@actions) = ();
my ($action, $start, $end) = ();
my (@frames, %actionspec, %framespec);
lib/LaTeXML/Package/beamer.cls.ltxml view on Meta::CPAN
$beamerPauses = $beamerPauses + $offset;
return $oldBeamerPauses, $beamerPauses; } }
# getSlideActions processes $actions, and returns an ordered list with the following items:
# $action: the action to be performed, or undef if none provided.
# $overlay: a string describing the overlay specification for the provided action.
sub getSlideActions {
my ($actions) = @_;
my (@actions, @spec) = ();
my (%action, %frame);
my ($from, $to);
lib/LaTeXML/Package/beamer.cls.ltxml view on Meta::CPAN
#**********************************************************************
# Digesting Beamer Specifications
#**********************************************************************
NewCounter('beamer@slideinframe'); # the current slide number in the frame
NewCounter('beamerpauses'); # overlay we are on, i.e. the last '+' value encounted.
NewCounter('beamer@lastslideinframe'); # the last known slide in a frame
# digestBeamerSpec digests an alert or overlay specification.
# It returns the actions contained in it.
sub digestBeamerSpec {
my ($spec, $allowActions) = @_;
my ($actions);
# get current state
lib/LaTeXML/Package/beamer.cls.ltxml view on Meta::CPAN
my $theSlide = CounterValue('beamer@slideinframe')->valueOf;
AssignValue('beamer@anotherslide' => $theSlide < $theMaxSlide, 'global') unless ($theSlide == 0);
# return the parsed actions!
$actions; }
# digestOverlaySpec digests an overlay specification.
# It returns where the current slide is located temporally to the overlay.
# See getTemporalSlide for return values.
sub digestOverlaySpec {
my ($spec) = @_;
return undef unless defined($spec);
$spec = ToString(Expand($spec)); # TODO: Should this be done ealier? Perhaps in the argument type?
# get the action
my $action = digestBeamerSpec($spec, 0);
unless (defined($action)) {
Warn('unexpected', '<overlay>', $spec, 'Missing overlay specification, treated as matching');
return 0; }
return undef unless defined($action);
# check if we need to do anything
my $theSlide = CounterValue('beamer@slideinframe')->valueOf;
# for debugging!
# Info('expected', 'overlay', $spec, "spec = <$spec> slide = $theSlide value = " . getTemporalSlide($action, $theSlide));
getTemporalSlide($action, $theSlide); }
# digestActionSpec digests an overlay specification.
# It returns the processed actions.
# See getSlideActions for return values.
sub digestActionSpec {
my ($spec) = @_;
return undef unless defined($spec);
$spec = ToString(Expand($spec)); # TODO: Should this be done ealier? Perhaps in the argument type?
# get the action
my $action = digestBeamerSpec($spec, 1);
unless (defined($action)) {
Warn('unexpected', '<overlay>', $spec, 'Missing overlay specification, treated as matching');
return 0; }
return undef unless defined($action);
# check if we need to do anything
getSlideActions($action); }
lib/LaTeXML/Package/beamer.cls.ltxml view on Meta::CPAN
\space\number\day, \number\year}
EoTeX
#**********************************************************************
# beamerbaseoverlay.sty
#**********************************************************************
RawTeX(<<'EoTeX');
% This variant based on \@ifnextchar does not skip spaces
% (So like amsmath's \new@ifnextchar). It is used where beamer allows
% an overlay at the end of a command, and would thus otherwise result in
% space gobbling.
\long\def\beamer@ifnextcharospec#1#2{%
\def\reserved@a{#1}%
\def\reserved@b{#2}%
\futurelet\@let@token\beamer@ifnch}
lib/LaTeXML/Package/beamer.cls.ltxml view on Meta::CPAN
\def\newenvironment{\@ifnextchar<{\beamer@newenv}{\beamer@orignewenvironment}}
\def\beamer@newenv<>{\@star@or@long\beamer@new@environment}
\def\beamer@new@environment#1{\@ifnextchar[{\beamer@@newenv{#1}}{\beamer@newenvnoopt{#1}{0}}}
\def\beamer@@newenv#1[#2]{\@ifnextchar[{\beamer@newenvopt{#1}{#2}}{\beamer@newenvnoopt{#1}{#2}}}
% The beamer syntax for \newenvironment<> follows the pattern for \newcommand<>
% and allows the overlay spec anywhere: the same code path is therefore used for
% both.
\long\def\beamer@newenvnoopt#1#2#3#4{%
\expandafter\newcommand\expandafter<\expandafter>\csname#1\endcsname[#2]{#3}%
\expandafter\long\expandafter\def\csname end#1\endcsname{#4}%
}
lib/LaTeXML/Package/beamer.cls.ltxml view on Meta::CPAN
{\cslet{@orig\string#1}#1}%
{}%
\csundef{beamerx@\string#1}%
\newcommand<>#1}
% The class allows overlays specs at any position in a command.
% To handle that, beamer first collects up material potentially
% including overlay info before passing to the 'real' definition.
\long\def\beamer@presort#1#2#3{%
\def\beamer@todo{#1}%
\def\beamer@ospec{}%
\beamer@argscount=#2\relax
\beamer@prechecka{#3}}
lib/LaTeXML/Package/beamer.cls.ltxml view on Meta::CPAN
# only shows text only on specified slides - but only one specficiation may be present
DefMacro('\only', '\beamer@ifnextcharospec{\beamer@only@before}{\beamer@only}');
DefMacro('\beamer@only {}', '\beamer@ifnextcharospec{\beamer@only@after{#1}}{\beamer@only@plain{#1}}');
DefMacro('\beamer@only@after {} BeamerAngled', '\beamer@only@before<#2>{#1}');
DefMacro('\beamer@only@before BeamerAngled {}', sub {
my ($gullet, $overlay, $argument) = @_;
if (digestOverlaySpec($overlay) == 0) {
$argument; }
else {
(); } });
DefMacro('\beamer@only@plain {}', '#1'); # the empty only always matches
lib/LaTeXML/Package/beamer.cls.ltxml view on Meta::CPAN
DefMacro('\alt', '\beamer@ifnextcharospec{\beamer@alt@before}{\beamer@alt}');
DefMacro('\beamer@alt {}{}', '\beamer@ifnextcharospec{\beamer@alt@after{#1}{#2}}{\beamer@alt@plain{#1}{#2}}');
DefMacro('\beamer@alt@after {}{} BeamerAngled', '\beamer@alt@before<#3>{#1}{#2}');
DefMacro('\beamer@alt@before BeamerAngled {}{}', sub {
my ($gullet, $overlay, $text, $altText) = @_;
if (digestOverlaySpec($overlay) == 0) {
$text; }
else {
$altText; } });
DefMacro('\beamer@alt@plain {}{}', '#1'); # the empty spec always matches
lib/LaTeXML/Package/beamer.cls.ltxml view on Meta::CPAN
DefMacro('\beamer@altenv@ BeamerAngled {}{}{}{}', '\beamer@altenv{#2}{#3}{#4}{#5}<#1>'); # put the <> at the end!
DefMacro('\beamer@altenv {}{}{}{}', '\alt{#1\def\beamer@eoenv{#2}}{#3\def\beamer@eoenv{#4}}');
DefMacro('\endaltenv', '\beamer@eoenv');
DefMacro('\temporal BeamerAngled {}{}{}', sub {
my ($gullet, $overlay, $beforeText, $text, $afterText) = @_;
my $temporal = digestOverlaySpec($overlay);
if ($temporal == 0) {
$text; }
elsif ($temporal == -1) {
$beforeText; }
else {
lib/LaTeXML/Package/beamer.cls.ltxml view on Meta::CPAN
# beamerbaseframe.sty
#**********************************************************************
DefKeyVal('beamerframe', 'fragile', '', '');
# To render a frame, we need to render all the overlay(s) contained in it.
# To achieve this, we first record the content of the frame environment into a macro - so we can replace it multiple times.
DefMacro(T_CS('\begin{frame}'), '\frame@');
DefMacro('\frame@ OptionalBeamerAngled BeamerSquared OptionalKeyVals:beamerframe LiteralBalanced LiteralBalanced', sub {
my ($gullet, $overlay, $defaultOverlay, $opts, $title, $subtitle) = @_;
# store the default overlay (which may be undef)
AssignValue('beamer@action@default@local' => $defaultOverlay);
# store title and subtitle
prepareFrameTitles($title, $subtitle);
# ensure we have an overlay
$overlay = '*' unless defined($overlay);
$overlay = ToString($overlay);
# execute overlay with a blank context, discarding any changed state.
($overlay) = digestBeamerSpec($overlay, 0);
Error('unexpected', '<overlay>', $overlay, 'Unable to parse slide overlay') unless defined($overlay);
AssignValue('beamer@frame@overlay' => $overlay);
# figure out the first slide to render
my $first = getNextSlide($overlay, undef);
# read the body of the frame!
my $fragile = defined($opts) && defined(GetKeyVal($opts, 'fragile'));
unless (readFrameBody($gullet, $fragile, 'frame')) {
Fatal('unexpected', '<eof>', $gullet, 'Unexpected end of input while looking for \end{frame}'); }
# and do the frame now!
lib/LaTeXML/Package/beamer.cls.ltxml view on Meta::CPAN
DefMacro('\beamer@slides@do {}', '\beamer@slides@iter{#1}\beamer@slides@while{#1}');
DefMacro('\beamer@slides@iter {}', '\begin{beamer@frame@slide}#1\beamer@slide\end{beamer@frame@slide}');
DefMacro('\beamer@slides@while {}', sub {
my ($gullet, $current) = @_;
return () unless LookupValue('beamer@anotherslide');
my $overlay = LookupValue('beamer@frame@overlay');
my $next = getNextSlide($overlay, ToString($current) + 0);
return () unless defined($next); # overlay spec for the slide
(T_CS('\beamer@slides@do'), T_BEGIN, ExplodeText(ToString($next)), T_END); });
NewCounter('framenumber'); # public counter for the current frame.
NewCounter('beamer@pagenumber'); # fake page number counter, in real tex this uses pdf pages
NewCounter('beamer@slidenumber'); # fake slide number counter, in real tex this uses math
lib/LaTeXML/Package/beamer.cls.ltxml view on Meta::CPAN
beforeDigest => sub {
StepCounter('framenumber');
ResetCounter('beamer@slidenumber'); });
Tag('ltx:slidesequence', afterOpen => sub { GenerateID(@_, 'frame'); });
DefEnvironment('{beamer@frame@slide} Number', "<ltx:slide overlay='#overlay'>#body</ltx:slide>",
# HACK: we use properties to be able to access $overlayno.
properties => sub {
my ($gullet, $overlayno) = @_;
SetCounter('beamer@slideinframe' => $overlayno);
StepCounter('beamer@pagenumber');
StepCounter('beamer@slidenumber');
(overlay => ToString($overlayno)); });
Tag('ltx:slide', afterOpen => sub { GenerateID(@_, 'slide'); });
# TODO: Ignore \setbeamersize for now
DefMacro('\setbeamersize {}', '');
lib/LaTeXML/Package/beamer.cls.ltxml view on Meta::CPAN
DefMacro('\insertdocumentendpage', sub { beamerTODO('insertdocumentendpage'); });
DefMacro('\insertpagenumber', '\@arabic\c@beamer@pagenumber');
DefMacro('\insertframenumber', '\@arabic\c@framenumber');
DefMacro('\insertslidenumber', '\@arabic\c@beamer@slidenumber');
DefMacro('\insertoverlaynumber', '\@arabic\c@beamer@slideinframe');
#**********************************************************************
# beamerbasecolor.sty
#**********************************************************************
lib/LaTeXML/Package/beamer.cls.ltxml view on Meta::CPAN
# store the stuff for the end, and return the beginning
AssignValue('beamer@todoend' => Tokens(@ends));
Tokens(@begins); });
DefMacro('\endactionenv', sub { LookupValue('beamer@todoend'); });
# a beamer variant of beginItemize, that additionally takes a default overlay.
sub beginBeamerItemize {
my ($defaultOverlay, @rest) = @_;
AssignValue('beamer@action@default@local' => $defaultOverlay) if defined($defaultOverlay);
my @result = beginItemize(@rest);
# create a hook to wrap items in
lib/LaTeXML/Package/beamer.cls.ltxml view on Meta::CPAN
if (defined($defaultOverlay)) {
(T_CS('\beamer@item@before'), Tokenize('<' . ToString($defaultOverlay) . '>')); }
else {
(T_CS('\beamer@closeitem'), T_CS('\beamer@item@org')); } });
DefMacro('\beamer@item@before BeamerAngled []', sub {
my ($stomach, $overlay, $key) = @_;
my @return = ();
push(@return, T_CS('\beamer@closeitem'), T_CS('\beamer@item@org'));
push(@return, T_OTHER('['), Revert($key), T_OTHER(']')) if defined($key);
push(@return, T_CS('\beamer@item@action'), revertBeamerAngled($overlay));
@return; });
# Hook into all the {enumerate} {itemize} {description}
# from LaTeX.Pool
lib/LaTeXML/Package/beamer.cls.ltxml view on Meta::CPAN
#**********************************************************************
# All the extra commands with <> arguments
#**********************************************************************
# AddBeamerWrapper adds a beamer overlay argument to a command.
sub AddBeamerWrapper {
my ($command, $args, $wrapper) = @_;
$wrapper = '\only' unless defined($wrapper);
# build tex code to pass the arguments!
my ($count) = 0;
Language-Befunge
view release on metacpan or search on metacpan
lib/Language/Befunge/doc/bf98-specs.html view on Meta::CPAN
<p>Befunge-93 source files are plain text files containing only printable
ASCII characters and the end-of-line controls described below.
<p>Funge-98 source files are made up of Funge characters. The
Funge-98 character set overlays the ASCII subset used by Befunge-93
and may have characters greater than 127 present in it (and greater
than 255 on systems where characters are stored in multiple bytes;
but no greater than 2,147,483,647.) The Funge character set is 'display-independent.'
That is to say, character #417 may look like a squiggle on system
Foo and a happy face on system Bar, but the meaning is always the
lib/Language/Befunge/doc/bf98-specs.html view on Meta::CPAN
completely wipes the stack (popping and discarding elements
until it is empty.)
<hr><a name="Stack_Stack_Manipulation"><h3>Stack Stack Manipulation</h3>
<p>The stack stack transparently overlays
the stack - that is to say, the top stack of
Funge-98's stack stack is treated the same as
Befunge-93's sole stack. The Funge programmer
will never notice the difference unless they
use the <code>{</code>, <code>}</code>, or <code>u</code>
Language-FormulaEngine
view release on metacpan or search on metacpan
lib/Language/FormulaEngine/Compiler.pm view on Meta::CPAN
The Compiler object takes a parse tree and generates perl code from it, and also evals
that perl code into a compiled coderef. However, most of the code generation is handled
by the L<Language::FormulaEngine::Namespace> object. The namespace object must be
available during compilation. In the default scenario, the namespace object will be
consulted for default constants and "global" variables, and then the generated coderef
will accept additional variables to overlay on those global variables, but the Namespace
will still get to determine how to access that pool of combined variables at execution.
For alternative strategies, see the C<output_api> attribute below.
=head1 ATTRIBUTES
Language-Haskell
view release on metacpan or search on metacpan
hugs98-Nov2003/fptools/libraries/GLUT/Graphics/UI/GLUT.hs view on Meta::CPAN
--
-- * Utility routines to generate various solid and wire frame objects.
--
-- * Support for bitmap and stroke fonts.
--
-- * Miscellaneous window management functions, including managing overlays.
--
-- This documentation serves as both a specification and a programming guide.
-- If you are interested in a brief introduction to programming with GLUT,
-- have a look at the relevant parts of <http://www.opengl.org/> and the vast
-- amount of books on OpenGL, most of them use GLUT.
hugs98-Nov2003/fptools/libraries/GLUT/Graphics/UI/GLUT.hs view on Meta::CPAN
-- the @tk@ and @aux@ toolkits. The @aux@ toolkit is used in the examples found
-- in the /OpenGL Programming Guide/. Unfortunately, @aux@ has numerous
-- limitations and its utility is largely limited to toy programs. The @tk@
-- library has more functionality than @aux@ but was developed in an /ad hoc/
-- fashion and still lacks much important functionality that IRIS GL programmers
-- expect, like pop-up menus and overlays.
--
-- GLUT is designed to fill the need for a window system independent programming
-- interface for OpenGL programs. The interface is designed to be simple yet
-- still meet the needs of useful OpenGL programs. Features from the IRIS GL,
-- @aux@, and @tk@ interfaces are included to make it easy for programmers used
hugs98-Nov2003/fptools/libraries/GLUT/Graphics/UI/GLUT.hs view on Meta::CPAN
-- loop. This routine never returns, and it continuously calls GLUT callbacks
-- as necessary.
--
-- * /Window Management:/ These routines create and control windows.
--
-- * /Overlay Management:/ These routines establish and manage overlays for
-- windows.
--
-- * /Menu Management:/ These routines create and control pop-up menus.
--
-- * /Callback Registration:/ These routines register callbacks to be called by
hugs98-Nov2003/fptools/libraries/GLUT/Graphics/UI/GLUT.hs view on Meta::CPAN
-- attributed to a window.
--
-- * /Idle:/ A state when no window system events are received for processing
-- as callbacks and the idle callback, if one is registered, is called.
--
-- * /Layer in use:/ Either the normal plane or overlay. This per-window state
-- determines what frame buffer layer OpenGL commands affect.
--
-- * /Menu entry:/ A menu item that the user can select to trigger the menu
-- callback for the menu entry\'s value.
--
hugs98-Nov2003/fptools/libraries/GLUT/Graphics/UI/GLUT.hs view on Meta::CPAN
-- of samples (each containing color and depth information). The samples are
-- averaged to determine the displayed pixel color value. Multisampling is
-- supported as an extension to OpenGL.
--
-- * /Normal plane:/ The default frame buffer layer where GLUT window state
-- resides; as opposed to the /overlay/.
--
-- * /Overlay:/ A frame buffer layer that can be displayed preferentially to
-- the /normal plane/ and supports transparency to display through to the
-- /normal plane/. Overlays are useful for rubber-banding effects, text
-- annotation, and other operations, to avoid damaging the normal plane frame
Lemonldap-Handlers-Generic
view release on metacpan or search on metacpan
doc/AuthorizationHeader.html.en view on Meta::CPAN
<li><a href="#name">NAME</a></li>
<li><a href="#description">DESCRIPTION</a></li>
<ul>
<li><a href="#overlay">Overlay</a></li>
</ul>
<li><a href="#see_also">SEE ALSO</a></li>
<li><a href="#copyright_and_license">COPYRIGHT AND LICENSE</a></li>
</ul>
doc/AuthorizationHeader.html.en view on Meta::CPAN
<pre>
see <a href="http://lemonldap.sf.net">http://lemonldap.sf.net</a> for more infos .</pre>
<p>
</p>
<h2><a name="overlay">Overlay</a></h2>
<p>If you want use your own header method you must use PLUGINHEADER parameter like this :
in httpd.conf : perlsetvar lemonldappluginheader MyModule</p>
<pre>
Your module must accept 3 parameters : config (all the hash of config ) , dn and sting of role (profil) .</pre>
<pre>
Lemonldap-NG-Common
view release on metacpan or search on metacpan
lib/Lemonldap/NG/Common/Conf/Backends/Overlay.pm view on Meta::CPAN
if ($@) {
$Lemonldap::NG::Common::Conf::msg .= $@;
return undef;
}
my $conf =
&{"Lemonldap::NG::Common::Conf::Backends::$self->{overlayRealtype}::load"}
(@_);
my @errors;
foreach my $file (@files) {
if ( open my $f, '<', "$self->{overlayDirectory}/$file" ) {
local $/ = undef;
my $content = <$f>;
close $f;
if ( $file =~ $hashParameters ) {
eval { $content = JSON::from_json($content) };
lib/Lemonldap/NG/Common/Conf/Backends/Overlay.pm view on Meta::CPAN
my @files = eval { overList($self) };
my @errors;
foreach my $file (@files) {
my $data = delete $fields->{$file};
if ( $self->{overlayWrite} ) {
if ( open my $f, '>', "$self->{overlayDirectory}/$file" ) {
print $f (
$file =~ $hashParameters ? JSON::to_json($data) : $data );
close $f;
}
lib/Lemonldap/NG/Common/Conf/Backends/Overlay.pm view on Meta::CPAN
}
die join( "\n", @errors ) if $@;
return &{
"Lemonldap::NG::Common::Conf::Backends::$self->{overlayRealtype}::store"
}( $self, $fields );
}
sub overList {
my ($self) = @_;
my $overDir = $self->{overlayDirectory} or die 'Missing overlayDirectory';
die "$overDir directory doesn't exist" unless -d $overDir and -r $overDir;
opendir my $dir, $overDir or die $!;
my @files = grep /^[^\.]/, readdir $dir;
closedir $dir;
my @errors;
lib/Lemonldap/NG/Common/Conf/Backends/Overlay.pm view on Meta::CPAN
return @files;
}
sub AUTOLOAD {
my ($self) = @_;
die 'Missing overlayRealtype'
unless $self->{overlayRealtype};
eval
"require Lemonldap::NG::Common::Conf::Backends::$self->{overlayRealtype}";
die $@ if $@;
$AUTOLOAD =~ s/::Overlay::/::$self->{overlayRealtype}::/;
my @res = &{$AUTOLOAD}(@_);
return wantarray ? (@res) : $res;
}
1;
Lemonldap-NG-Manager
view release on metacpan or search on metacpan
site/htdocs/static/bwr/angular-bootstrap/ui-bootstrap-tpls.js view on Meta::CPAN
* Used by scrollbarWidth() function to cache scrollbar's width.
* Do not access this variable directly, use scrollbarWidth() instead.
*/
var SCROLLBAR_WIDTH;
/**
* scrollbar on body and html element in IE and Edge overlay
* content and should be considered 0 width.
*/
var BODY_SCROLLBAR_WIDTH;
var OVERFLOW_REGEX = {
normal: /(auto|scroll)/,
site/htdocs/static/bwr/angular-bootstrap/ui-bootstrap-tpls.js view on Meta::CPAN
},
/**
* Provides the scrollbar width, concept from TWBS measureScrollbar()
* function in https://github.com/twbs/bootstrap/blob/master/js/modal.js
* In IE and Edge, scollbar on body and html element overlay and should
* return a width of 0.
*
* @returns {number} The width of the browser scollbar.
*/
scrollbarWidth: function(isBody) {
Lemonldap-NG-Portal
view release on metacpan or search on metacpan
site/htdocs/static/bwr/bootstrap/dist/css/bootstrap-grid.css.map view on Meta::CPAN
{"version":3,"sources":["../../scss/bootstrap-grid.scss","bootstrap-grid.css","../../scss/_grid.scss","../../scss/mixins/_grid.scss","../../scss/mixins/_breakpoints.scss","../../scss/_variables.scss","../../scss/mixins/_grid-framework.scss","../../sc...
Lemonldap-Portal-Standard
view release on metacpan or search on metacpan
examples/accueil.pl view on Meta::CPAN
$session{uid} = $entry->get_value('uid');
# $session{cn} = $entry->get_value('cn');
# $session{personaltitle} = $entry->get_value('personaltitle');
# $session{mail} = $entry->get_value('mail');
# $session{title} = $entry->get_value('title');
## my overlay
# $session{departement} = $entry->get_value('departement');
# $session{codique} = $entry->get_value('codique');
# $session{boitier} = "lemonintimpots";
# $session{grade} = $entry->get_value('grade');
# $session{fonction} = $entry->get_value('fonction');
LibZip
view release on metacpan or search on metacpan
myldr/zlib-src/deflate.c view on Meta::CPAN
{
deflate_state *s;
int noheader = 0;
static const char* my_version = ZLIB_VERSION;
ushf *overlay;
/* We overlay pending_buf and d_buf+l_buf. This works since the average
* output size for (length,distance) codes is <= 24 bits.
*/
if (version == Z_NULL || version[0] != my_version[0] ||
stream_size != sizeof(z_stream)) {
myldr/zlib-src/deflate.c view on Meta::CPAN
s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos));
s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos));
s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */
overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2);
s->pending_buf = (uchf *) overlay;
s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L);
if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL ||
s->pending_buf == Z_NULL) {
strm->msg = (char*)ERR_MSG(Z_MEM_ERROR);
deflateEnd (strm);
return Z_MEM_ERROR;
}
s->d_buf = overlay + s->lit_bufsize/sizeof(ush);
s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize;
s->level = level;
s->strategy = strategy;
s->method = (Byte)method;
myldr/zlib-src/deflate.c view on Meta::CPAN
#ifdef MAXSEG_64K
return Z_STREAM_ERROR;
#else
deflate_state *ds;
deflate_state *ss;
ushf *overlay;
if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) {
return Z_STREAM_ERROR;
}
myldr/zlib-src/deflate.c view on Meta::CPAN
ds->strm = dest;
ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte));
ds->prev = (Posf *) ZALLOC(dest, ds->w_size, sizeof(Pos));
ds->head = (Posf *) ZALLOC(dest, ds->hash_size, sizeof(Pos));
overlay = (ushf *) ZALLOC(dest, ds->lit_bufsize, sizeof(ush)+2);
ds->pending_buf = (uchf *) overlay;
if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL ||
ds->pending_buf == Z_NULL) {
deflateEnd (dest);
return Z_MEM_ERROR;
myldr/zlib-src/deflate.c view on Meta::CPAN
zmemcpy(ds->prev, ss->prev, ds->w_size * sizeof(Pos));
zmemcpy(ds->head, ss->head, ds->hash_size * sizeof(Pos));
zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size);
ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf);
ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush);
ds->l_buf = ds->pending_buf + (1+sizeof(ush))*ds->lit_bufsize;
ds->l_desc.dyn_tree = ds->dyn_ltree;
ds->d_desc.dyn_tree = ds->dyn_dtree;
ds->bl_desc.dyn_tree = ds->bl_tree;
Lingua-EN-Infinitive
view release on metacpan or search on metacpan
lib/Lingua/EN/Infinitive.pm view on Meta::CPAN
overhanged => 'overhang',
overheard => 'overhear',
overhung => 'overhang',
overladed => 'overlade',
overladen => 'overlade',
overlaid => 'overlay',
overlain => 'overlie',
overlay => 'overlie',
overleaped => 'overleap',
overleapt => 'overleap',
overpaid => 'overpay',
overran => 'overrun',
overridden => 'override',
Lingua-EN-Opinion
view release on metacpan or search on metacpan
lib/Lingua/EN/Opinion/Emotion.pm view on Meta::CPAN
overhaul => { anger => 0, anticipation => 0, disgust => 0, fear => 0, joy => 0, negative => 0, positive => 0, sadness => 0, surprise => 0, trust => 0 },
overhead => { anger => 0, anticipation => 0, disgust => 0, fear => 0, joy => 0, negative => 0, positive => 0, sadness => 0, surprise => 0, trust => 0 },
overjoyed => { anger => 0, anticipation => 0, disgust => 0, fear => 0, joy => 1, negative => 0, positive => 1, sadness => 0, surprise => 0, trust => 0 },
overlaid => { anger => 0, anticipation => 0, disgust => 0, fear => 0, joy => 0, negative => 0, positive => 0, sadness => 0, surprise => 0, trust => 0 },
overlap => { anger => 0, anticipation => 0, disgust => 0, fear => 0, joy => 0, negative => 0, positive => 0, sadness => 0, surprise => 0, trust => 0 },
overlay => { anger => 0, anticipation => 0, disgust => 0, fear => 0, joy => 0, negative => 0, positive => 0, sadness => 0, surprise => 0, trust => 0 },
overload => { anger => 0, anticipation => 0, disgust => 0, fear => 0, joy => 0, negative => 1, positive => 0, sadness => 1, surprise => 0, trust => 0 },
overlying => { anger => 0, anticipation => 0, disgust => 0, fear => 0, joy => 0, negative => 0, positive => 0, sadness => 0, surprise => 0, trust => 0 },
overpaid => { anger => 0, anticipation => 0, disgust => 0, fear => 0, joy => 0, negative => 1, positive => 0, sadness => 0, surprise => 0, trust => 0 },
overpass => { anger => 0, anticipation => 0, disgust => 0, fear => 0, joy => 0, negative => 0, positive => 0, sadness => 0, surprise => 0, trust => 0 },
overpower => { anger => 0, anticipation => 0, disgust => 0, fear => 0, joy => 0, negative => 1, positive => 0, sadness => 0, surprise => 0, trust => 0 },
Lingua-EN-SENNA
view release on metacpan or search on metacpan
lib/Lingua/EN/SENNA/third-party/senna/hash/words.lst view on Meta::CPAN
overlander
overlap
overlapped
overlapping
overlaps
overlay
overlayed
overlaying
overlays
overlies
overliquid
overload
overloaded
overloading
Lingua-EN-Segment
view release on metacpan or search on metacpan
share/count_1w.txt view on Meta::CPAN
scaled 2786253
contingency 2784609
photon 2784392
wiltshire 2784041
vague 2783775
overlay 2783154
wraps 2781569
constituents 2780907
rusty 2780895
pharma 2779510
herd 2779216
share/count_1w.txt view on Meta::CPAN
ond 759448
twenties 759419
tantra 759417
codified 759394
ncs 759387
overlays 759289
thingy 759227
monstrous 759187
comforters 759111
conservatories 759096
ruskin 759090
share/count_1w.txt view on Meta::CPAN
frizzell 135570
subgrade 135568
phosphatases 135567
crr 135565
raph 135564
overlaying 135563
ontogeny 135562
elonex 135562
blustery 135560
courtier 135559
prescot 135552
share/count_1w.txt view on Meta::CPAN
pmas 53017
explorative 53017
wehave 53016
trills 53015
surfcam 53015
overlayed 53015
spanne 53014
radioworks 53014
plamondon 53014
inputsource 53014
dihydrocodeine 53014
share/count_1w.txt view on Meta::CPAN
fieser 21262
cisternae 21262
atuo 21262
ustoa 21261
partyline 21261
overlayer 21261
nji 21261
murra 21261
forder 21261
burgundians 21261
artisticness 21261
Lingua-EN-Tagger
view release on metacpan or search on metacpan
Tagger/words.yml view on Meta::CPAN
overheating: { vbg: 1 }
overinclusion: { nn: 1 }
overlaid: { vbn: 1 }
overlap: { vbp: 1, vb: 1 }
overlapping: { jj: 1, vbg: 1 }
overlay: { nn: 1 }
overlays: { vbz: 1 }
overleveraged: { jj: 1 }
overload: { nn: 2 }
overlook: { vbp: 2, vb: 1 }
overlooked: { vbn: 1, vbd: 1 }
overlooking: { vbg: 3 }
Lingua-Stem
view release on metacpan or search on metacpan
examples/collected_works_poe.txt view on Meta::CPAN
the _character _of the room. The carpet - of Saxony material - is quite
half an inch thick, and is of the same crimson ground, relieved simply by
the appearance of a gold cord (like that festooning the curtains) slightly
relieved above the surface of the _ground, _and thrown upon it in such a
manner as to form a succession of short irregular curves - one
occasionally overlaying the other. The walls are prepared with a glossy
paper of a silver gray tint, spotted with small Arabesque devices of a
fainter hue of the prevalent crimson. Many paintings relieve the expanse
of paper. These are chiefly landscapes of an imaginative cast-such as the
fairy grottoes of Stanfield, or the lake of the Dismal Swamp of Chapman.
There are, nevertheless, three or four female heads, of an ethereal
Link_Controller
view release on metacpan or search on metacpan
times larger than the CDB files and so unmanagable.
At the time I started writing this, none of the free SQL databases
could satisfy the needs of this project. Now they've improved
considerably. It would be nice to have an implementation of the Link
class which was overlayed over SQL storage.
Some of the techniques used in this set of programs seem a little
brutal (e.g. the fixlink program doesn't really understand html and
just guesses where to make substitutions..). Comparative testing
against other programs would be nice.
It might be nice if people could keep personal information about links
in their own database. For example, someone might have a link which
only exists for six months a year and want to record that it should
only be worried about at that time. This would be kept in a DB file
as hashes which were then overlayed over the original Link, but
otherwise treated the same.
Possibly give extract-links a robot agent option in case someone wants
to use it for downloading from the www. I'm not sure if this is
encouraging people to do things they shouldn't do or is something that
List-Gen
view release on metacpan or search on metacpan
lib/List/Gen.pm view on Meta::CPAN
:utility mapn by every apply min max reduce mapab
mapkey d deref slide curse remove
:source range glob makegen list array vecgen repeat file
:modify gen cache expand contract collect slice flip overlay
test recursive sequence scan scan_stream == scanS
cartesian transpose stream strict
:zip zip zipgen tuples zipwith zipwithab unzip unzipn
zipmax zipgenmax zipwithmax
lib/List/Gen.pm view on Meta::CPAN
:utility mapn by every apply min max reduce mapab
mapkey d deref slide curse remove
:source range glob makegen list array vecgen repeat file
:modify gen cache expand contract collect slice flip overlay
test recursive sequence scan scan_stream == scanS
cartesian transpose stream strict
:zip zip zipgen tuples zipwith zipwithab unzip unzipn
zipmax zipgenmax zipwithmax
lib/List/Gen.pm view on Meta::CPAN
=item * B<functions as methods>:
most of the functions in this package are also methods of generators, including
by, every, mapn, gen, map (alias of gen), filter, grep (alias of filter), test,
cache, flip, reverse (alias of flip), expand, collect, overlay, mutable, while,
until, recursive, rec (alias of recursive).
my $gen = (range 0, 1_000_000)->gen(sub{$_**2})->filter(sub{$_ % 2});
#same as: filter {$_ % 2} gen {$_**2} 0, 1_000_000;
lib/List/Gen.pm view on Meta::CPAN
else {Carp::croak "no method '$method' on '".ref($self)."'"}
}
}
}
sub reverse {goto &List::Gen::flip}
sub overlay {goto &List::Gen::overlay}
sub zipmax {goto &List::Gen::zipgenmax}
sub zipwithmax {
my $code = splice @_, 1, 1;
$code->$sv2cv;
unshift @_, $code;
lib/List/Gen.pm view on Meta::CPAN
&scan
}
BEGIN {*scanS = *scan_stream}
=item overlay C< GENERATOR PAIRS >
overlay allows you to replace the values of specific generator cells. to set
the values, either pass the overlay constructor a list of pairs in the form
C<< index => value, ... >>, or assign values to the returned generator using
normal array ref syntax
my $fib; $fib = overlay gen {$$fib[$_ - 1] + $$fib[$_ - 2]};
@$fib[0, 1] = (0, 1);
# or
my $fib; $fib = gen {$$fib[$_ - 1] + $$fib[$_ - 2]}
->overlay( 0 => 0, 1 => 1 );
print "@$fib[0 .. 15]"; # '0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610'
=cut
sub overlay ($%) {
isagen (my $source = shift)
or croak '$_[0] to overlay must be a generator';
tiegen Overlay => tied @$source, @_
}
generator Overlay => sub {
my ($class, $source, %overlay) = @_;
my ($fetch, $fsize) = $source->closures;
curse {
FETCH => sub {
exists $overlay{$_[1]}
? $overlay{$_[1]}
: $fetch->(undef, $_[1])
},
STORE => sub {$overlay{$_[1]} = $_[2]},
fsize => $fsize,
source => sub {$source}
} => $class
};
lib/List/Gen.pm view on Meta::CPAN
indices from the generator. when called with a generator, it returns a lazy
slice from the source generator. since the subroutine created by C< recursive >
is installed at runtime, you must call the subroutine with parenthesis.
my $fib = gen {self($_ - 1) + self($_ - 2)}
->overlay( 0 => 0, 1 => 1 )
->cache
->recursive;
print "@$fib[0 .. 15]"; # '0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610'
LocalOverride
view release on metacpan or search on metacpan
lib/LocalOverride.pm view on Meta::CPAN
# We only want to check overrides in $base_namespace
return unless $filename =~ /^$base_namespace/;
# OK, that all passed, so we can load up the actual files
# Get the original version first, then overlay the local version
require $filename;
my $local_file = $filename;
if ($base_namespace) {
$local_file =~ s[^$base_namespace][${base_namespace}/$local_prefix];
( run in 1.005 second using v1.01-cache-2.11-cpan-49f99fa48dc )