view release on metacpan or  search on metacpan

lib/TeX/AutoTeX/StampPDF.pm  view on Meta::CPAN

  # 6 * 72 - 1/2 * stringlength * 10
  # (10 = approx average char width in 20pt Times-Roman)
  my $yoffset = 432 - 5 * length $stampref->[0];

# minimal arXiv stamp used as a page overlay in grayscale
  my $pdfstamp = <<"EOSTAMP";
q
0.5 G 0.5 g
BT
/arXivStAmP 20 Tf 0 1 -1 0 32 $yoffset Tm

 view release on metacpan or  search on metacpan

lib/TeX/XDV/Parse.pm  view on Meta::CPAN

=for readme continue

=head1 DESCRIPTION

TeX::XDV::Parse is an extension of TeX::DVI::Parse, much as XDV is
an extension of DVI. This module simply overlays the additional XDV
functionality on top of TeX::DVI::Parse and inherits its interface.

To use, you should subclass this module and define functions to handle
each of the XDV/DVI commands. Each command will be passed the appropriate
arguments. For example:

 view release on metacpan or  search on metacpan

lib/Tempest.pm  view on Meta::CPAN

=cut

my %color_file;

=head3 C<overlay>

If true, the heatmap is overlaid onto the input image with a given
opacity before being written to the filesystem.  Defaults to B<True>.

=cut

my %overlay;

=head3 C<opacity>

Indicates with what percentage of opaqueness to overlay the heatmap
onto the input image.  If 0, the heatmap will not be visible; if 100,
the input image will not be visible.  Defaults to b<50>.

=cut

lib/Tempest.pm  view on Meta::CPAN

=cut

my %image_lib;

my @_required = ('input_file', 'output_file', 'coordinates');
my @_optional = ('plot_file', 'color_file', 'overlay', 'opacity', 'image_lib');

=head1 METHODS

=head2 C<new>

lib/Tempest.pm  view on Meta::CPAN

    my $self = bless \(my $dummy), $class;
    
    # set defaults
    $plot_file{$self} = dirname(__FILE__) . '/Tempest/data/plot.png';
    $color_file{$self} = dirname(__FILE__) . '/Tempest/data/clut.png';
    $overlay{$self} = 1;
    $opacity{$self} = 50;
    $image_lib{$self} = $self->_calc_image_lib();
    
    # for all required parameters..
    for my $param_name (@_required) {

lib/Tempest.pm  view on Meta::CPAN

    my $self = shift;
    return $color_file{$self};
}


sub set_overlay {
    my $self = shift;
    my $overlay = shift;
    
    $overlay{$self} = $overlay ? 1 : 0;
    return $self;
}

sub get_overlay {
    my $self = shift;
    return $overlay{$self};
}


sub set_opacity {
    my $self = shift;

 view release on metacpan or  search on metacpan

lib/Template/Declare/TagSet/XUL.pm  view on Meta::CPAN

  iframe  image  implementation  key
  keyset  label  listbox  listcell
  listcol  listcols  listhead  listheader
  listitem  member  menu  menubar
  menuitem  menulist  menupopup  menuseparator
  method  observes  overlay  page
  parameter  popup  popupset  progressmeter
  property  radio  radiogroup  rdf
  resizer  resources  richlistbox row  rows
  rule  script  scrollbar  scrollbox
  separator  setter  spacer  splitter

lib/Template/Declare/TagSet/XUL.pm  view on Meta::CPAN

=item C<method>

=item C<observes>

=item C<overlay>

=item C<page>

=item C<parameter>

 view release on metacpan or  search on metacpan

lib/Template/Lace.pm  view on Meta::CPAN

specification, you would prepend a '@' to the front of it (think in Perl @variable means an
array variable). In the given example "css=\'@link'" we want the attribute 'css' to be a
collection of all the linked stylesheets in the current DOM.

You will use this type of value when you are making components that do complex layout
and overlays of the current DOM (such as when you are creating a master layout page for
your website).

=back

In addition to any attributes you pass to a component via a declaration as described above

lib/Template/Lace.pm  view on Meta::CPAN

So four attributes, all coming from the DOM associated with the 'content' area of this component.  We
grab the content of the title tag and the content of the HTML body tag, as well as the collection (if
any) of the link takes (for css style sheets) and any template specific meta tags.

If you are looking carefully you have noticed instead of a 'process_dom' method we have a 'on_component_add' method.  We could do this with 'process_dom' but that method runs for every request and since this overlay contains no dynamic request bound ...

Here's a sample of the actual result, rendering all the components (you can peek at the repository which has all the code for these examples to see how it all works)

    <html>
      <head>

 view release on metacpan or  search on metacpan

lib/Template/Multipass.pm  view on Meta::CPAN

    my $opts = $config->{MULTIPASS};
    $self->{_multipass}{config} = $opts;

    $self->{_multipass}{vars} = $opts->{VARS} || {};

    my $overlay = {
        $self->default_meta_options,
        %$opts,
    };

    delete $overlay->{VARS};

    $self->{_multipass}{config_overlay} = $overlay;

    $self->SUPER::_init( $config, @args );

    Data::Visitor::Callback->new(
        ignore_return_values => 1,

lib/Template/Multipass.pm  view on Meta::CPAN

    # process( ...., { meta_opts => { blah } } )  causes { blah } to be given to the inner process used on the meta template
    my $opts = $self->{_multipass}{captured_process_opts}{meta_opts} || {};

    # calculate the configuration and variables for the meta pass
    my $overlay = $self->{_multipass}{config_overlay}; # constructed at _init
    local @{ $self->{_multipass}{captured_config} }{ keys %$overlay } = values %$overlay; # START_TAG, END_TAG etc
    my $vars = $self->{_multipass}{merged_meta_vars}; # merged by process at the top of the call chain

    local $@;

    # dispatch the original method on the provider, getting the original result

lib/Template/Multipass.pm  view on Meta::CPAN

unless the variables have been changed.

=head1 CONFIGURATION

The configuration values inside C<MULTIPASS> in the top level config will be
overlayed on top of the normal config during meta template processing. This
works for values such as C<START_TAG> and C<END_TAG> (which default to C<{%>
and C<%}>), and may work for other values.

Additionallly the C<MULTIPASS> hash can take a C<VARS> hash to be used as the
meta vars in all runs.

 view release on metacpan or  search on metacpan

examples/MessagePreview.js  view on Meta::CPAN

                var pWidth          = obj.user_input.clientWidth,
                    pHeight         = obj.user_input.clientHeight,
                    pLeft           = obj.user_input.offsetLeft,
                    pTop            = obj.user_input.offsetTop;

                obj.preview_overlay = new YAHOO.widget.Overlay(
                    obj.previewElId,
                    {
                        context:        [obj.config.user_input, 'tl', 'tl'],
                        visible:        true,
                        width:          obj.user_input.clientWidth  + 'px',
                        height:         obj.user_input.clientHeight + 'px',
                        class:          'message-preview-overlay'
                    }
                );

                obj.preview_overlay.setBody(data.formatted);
                obj.preview_overlay.render(document.body);
                //Dom.get('preview_overlay').style.overflow = 'auto';
                Dom.get(obj.previewElId).style.overflow = 'auto';
                // I'm sure there's a better way to do this!
                Dom.get(obj.previewElId).className = Dom.get(obj.previewElId).className + ' message-preview-overlay';

                // update the button
                obj.setClicker(
                    {
                        icon:  obj.config.icon_edit,

examples/MessagePreview.js  view on Meta::CPAN

                    label: this.config.label_preview
                }
            );

            this.user_input.style.visibility     = 'visible';
            this.preview_overlay.destroy();

            YU.Event.removeListener( this.trigger, 'click' );
            YU.Event.addListener(
                this.trigger,
                this.config.trigger_evt,

 view release on metacpan or  search on metacpan

lib/Template/Pure.pm  view on Meta::CPAN

          $t->data_at_path($data, $src)->($dom);
        },
        "*[data-pure-filter-id=filter-$params{cnt}]\@data-pure-filter-id", sub { undef },
      );
    }
  } elsif($target eq 'pure-overlay') {
    $params{node}->following('*')->first->attr('data-pure-overlay-id'=>"overlay-$params{cnt}");
    $params{node}->remove;

    push @{$params{directives}}, (
      "^*[data-pure-overlay-id=overlay-$params{cnt}]", [ +{%attrs, src=>$src }, '^.' => 'src'],
      #  "*[data-pure-overlay-id=overlay-$params{cnt}]\@data-pure-overlay-id", sub { undef },
    );
  } else {
    warn "Encountering processing instruction $target that I can't process";
  }
  $params{cnt}++;

lib/Template/Pure.pm  view on Meta::CPAN

effort to learn off the top compared to more simple systems like Mustache or even L<Template::Toolkit>.

Although inspired by pure.js L<http://beebole.com/pure/> this module attempts to help mitigate some
of the listed possible downsides with additional features that are a superset of the original 
pure.js specification. For example you may include templates inside of templates as includes or even
overlays that provide much of the same benefit that template inheritance offers in many other
popular template frameworks.  These additional features are intended to make it more suitable as a general
purpose server side templating system.

=head1 CREATING TEMPLATE OBJECTS

lib/Template/Pure.pm  view on Meta::CPAN

    </div>

Lastly you can mimic a type of inheritance using data mapping and
node aliasing:

   my $overlay_html = q[
      <html>
        <head>
          <title>Example Title</title>
          <link rel="stylesheet" href="/css/pure-min.css"/>
            <link rel="stylesheet" href="/css/grids-responsive-min.css"/>

lib/Template/Pure.pm  view on Meta::CPAN

          <p id="foot">Here's the footer</p>
        </body>
      </html>
    ];

    my $overlay = Template::Pure->new(
      template=>$overlay_html,
      directives=> [
        'title' => 'title',
        '^title+' => 'scripts',
        'body section#content' => 'content',
      ]);

lib/Template/Pure.pm  view on Meta::CPAN

          {
            title => \'title',
            scripts => \'^head script',
            content => \'body',
          },
          '^.' => $overlay,
        ]
      ]);

    my $data = +{
      meta => {

lib/Template/Pure.pm  view on Meta::CPAN

      ]
    );

=head2 Overlay

An overlay replaces the selected node with the results on another template.  Typically
you will pass selected nodes of the original template as directives to the new template.
This can be used to minic features like template inheritance, that exist in other templating
systems.  One example:

    my $overlay_html = q[
      <html>
        <head>
          <title>Example Title</title>
          <link rel="stylesheet" href="/css/pure-min.css"/>
            <link rel="stylesheet" href="/css/grids-responsive-min.css"/>

lib/Template/Pure.pm  view on Meta::CPAN

        <body>
        </body>
      </html>
    ];

    my $overlay = Template::Pure->new(
      template=>$overlay_html,
      directives=> [
        'title' => 'title',
        'head+' => 'scripts',
        'body' => 'content',
      ]);

    my $base_html = q[
      <?pure-overlay src='layout'
        title=\'title'
        scripts=\'^head script' 
        content=\'body'?>
      <html>
        <head>

lib/Template/Pure.pm  view on Meta::CPAN

        '#story' => 'story,
      ]
    );

    print $base->render({
      layout => $overlay,
      story => 'Once Upon a Time...',
      meta => {
        title=>'Once',
        author=>'jnap',
      },

lib/Template/Pure.pm  view on Meta::CPAN

      </body>
    </html>

The syntax of the processing instruction is:

    <?pure-overlay src='' @args ?>

Where 'src' is a data path to the template you want to use as the overlay, and @args is
a list of key values which populate the data context of the overlay when you process it.
Often these values will be references to existing nodes in the base template (as in the
examples \'title' and \'body' above) but they can also be used to map values from your
data context in the same way we do so for L</Include> and L</Wrapper>.

If you were to write this as 'directives only' it would look like:

lib/Template/Pure.pm  view on Meta::CPAN

          '^.' => 'layout',
        ],
      ]
    );

Please note that although in this example the overlay wrapped over the entire template, it is
not limited to that, rather like the L</Wrapper> processing instruction it just takes the next
tag node following as its overlay target.  So you could have more than one overlap in a document
and can overlay sections for those cases where a L</Wrapper> is not sufficently complex.

=head2 Filter

A Filter will process the following node on a L<Template::Pure> instance as if that node was the
source for its template.  This means that the target source template must be a coderef that builds

 view release on metacpan or  search on metacpan

lib/Template/Overlay.pm  view on Meta::CPAN

    $self->{base}     = File::Spec->rel2abs($base);
    $self->{resolver} = $resolver;
    $self->{key}      = $options{key};

    $logger->debug( 'new overlay [', $self->{base}, ']' );

    return $self;
}

sub _overlay_files {
    my ( $self, $overlays ) = @_;

    my %overlay_files = ();
    foreach my $overlay ( ref($overlays) eq 'ARRAY' ? @$overlays : ($overlays) ) {
        $overlay = File::Spec->rel2abs($overlay);
        my $base_path_length = length($overlay);
        find(
            sub {
                if ( -f $File::Find::name && $_ !~ /~$/ && $_ !~ /^\..+\.swp$/ ) {
                    my $relative = _relative_path( $File::Find::name, $base_path_length );
                    $overlay_files{$relative} = $File::Find::name;
                }
            },
            $overlay
        );
    }

    return %overlay_files;
}

sub overlay {
    my ( $self, $overlays, %options ) = @_;

    my %overlay_files = $self->_overlay_files($overlays);
    my $destination   = $self->{base};
    if ( $options{to} && $options{to} ne $self->{base} ) {
        $destination = File::Spec->rel2abs( $options{to} );
        my $base_path_length = length( File::Spec->rel2abs( $self->{base} ) );
        find(

lib/Template/Overlay.pm  view on Meta::CPAN

                my $relative = _relative_path( $File::Find::name, $base_path_length );
                if ( -d $File::Find::name ) {
                    make_path( File::Spec->catdir( $destination, $relative ) );
                }
                if ( -f $File::Find::name ) {
                    my $template = delete( $overlay_files{$relative} );
                    my $file = File::Spec->catfile( $destination, $relative );
                    if ($template) {
                        $self->_resolve( $template, $file, $options{resolver} );
                    }
                    else {

lib/Template/Overlay.pm  view on Meta::CPAN

                }
            },
            $self->{base}
        );
    }
    foreach my $relative ( keys(%overlay_files) ) {
        my $file = File::Spec->catfile( $destination, $relative );
        make_path( ( File::Spec->splitpath($file) )[1] );
        $self->_resolve( $overlay_files{$relative}, $file, $options{resolver} );
    }
}

sub _relative_path {
    my ( $path, $base_path_length ) = @_;

lib/Template/Overlay.pm  view on Meta::CPAN

=head1 SYNOPSIS

  use Template::Overlay;
  use Template::Resolver;

  my $overlay_me = Template::Overlay->new(
      '/path/to/base/folder',
      Template->Resolver->new($entity),
      key => 'REPLACEME');
  $overlay_me->overlay(
      ['/path/to/template/base','/path/to/another/template/base'],
      to => '/path/to/processed');

=head1 DESCRIPTION

This provides the ability ot overlay a set of files with a set of resolved templates.
It uses L<Template::Resolver> to resolve each file.

=head1 CONSTRUCTORS

=head2 new($base, $resolver, [%options])

Creates a new overlay processor for the files in C<$base> using C<$resolver> to process
the template files. The available options are:

=over 4

=item key

lib/Template/Overlay.pm  view on Meta::CPAN

=back

=head1 METHODS

=head2 overlay($overlays, [%options])

Overlays the C<$base> directory (specified in the constructor) with the resolved
templates from the directories in C<$overlays>.  C<$overlays> can be either a path,
or an array reference containing paths.  If multiple C<$overlays> contain the same
template, the last one in the array will take precedence.  The available options are:

=over 4

=item resolver

lib/Template/Overlay.pm  view on Meta::CPAN

handled processing of the file, so the default processing will be skipped.

=item to

If specified, the files in C<$base> will not be not be modified.  Rather, they will
be copied to the path specified by C<$to> and the overlays will be processed on top
of that directory.

=back

=head1 AUTHOR

 view release on metacpan or  search on metacpan

benchmarks/wordlist-en.txt  view on Meta::CPAN

overlaunched
overlaunches
overlaunching
overlavish
overlax
overlay
overlaying
overlayings
overlays
overleaf
overleap
overleaped
overleaping
overleaps

 view release on metacpan or  search on metacpan

Gnuplot.pm  view on Meta::CPAN

1) in order move the support for the terminal drivers outside of the
   support for the main program, thereby encouraging a library of
   contributed drivers
2) To make it easy for users to add contributed drivers, by adding
   a single #include line to term.h
3) To allow individual compilation on DOS, to save the overlay
   manager from having to load _all_ drivers together.

CORRECTION - scale() interface is no longer supported, since it
is incompatible with multiplot.

 view release on metacpan or  search on metacpan

tags  view on Meta::CPAN

outside	../perl/lib/B/Deparse.pm	/^	my $outside = !$lexical && $cv && $cv->OUTSIDE;$/;"	v	file:	class:Deparse
outstanding	../Object-Remote/lib/Object/Remote/Connection.pm	/^  my $outstanding = $self->outstanding_futures;$/;"	v	file:	class:Connection
outstanding	../Object-Remote/lib/Object/Remote/Connection.pm	/^  my $outstanding = $self->outstanding_futures;$/;"	v	file:	class:Connection
ov_method	../perl/lib/overload.pm	/^sub ov_method {$/;"	s	class:overload
over_level	../perl/lib/diagnostics.pm	/^my $over_level = 0;     # We look only at =item lines at the first =over level$/;"	v	file:	class:diagnostics
overlay	../perl/lib/B/Deparse.pm	/^	local $B::overlay = {};$/;"	v	file:	class:Deparse
overlay	../perl/lib/B/Deparse.pm	/^    local $B::overlay = {};$/;"	v	file:	class:Deparse
overlay	../perl/lib/B/Deparse.pm	/^    local $B::overlay = {};$/;"	v	file:	class:Deparse
overlay	../perl/lib/B/Deparse.pm	/^    local $B::overlay = {};$/;"	v	file:	class:Deparse
overload	../perl/lib/overload.pm	/^package overload;$/;"	p	class:overload
overloading	../perl/lib/overloading.pm	/^package overloading;$/;"	p	class:overloading
overrides	../perl/lib/Unicode/UCD.pm	/^    my $overrides;$/;"	v	file:	class:UCD
p	../Catalyst-Controller-HTML-FormFu/lib/HTML/FormFu/Element/RequestToken.pm	/^  my $p = $form->element( { plugin => 'Token' } );$/;"	v	file:	class:RequestToken
p	../Catalyst-Runtime/lib/Catalyst.pm	/^    my %p = ( _log => $self->log );$/;"	v	file:	class:Catalyst

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

0.30  Tue Jan  8 14:33:02 PST 2008
    Forgot to make it install into the core directory and overlay the
    existing module [spotted by imcat]

0.29  Wed Oct 17 18:42:23 EDT 2007
    Forgot to update the MANIFEST to contain the testing copy of if.pm

 view release on metacpan or  search on metacpan

lib/Test/OpenLDAP.pm  view on Meta::CPAN

olcAttributeTypes: ( 1.3.6.1.4.1.4203.666.1.55.10 NAME 'monitorTimestamp' DESC
  'monitor timestamp' EQUALITY generalizedTimeMatch ORDERING generalizedTimeOr
 deringMatch SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 SINGLE-VALUE NO-USER-MODIFIC
 ATION USAGE dSAOperation )
olcAttributeTypes: ( 1.3.6.1.4.1.4203.666.1.55.11 NAME 'monitorOverlay' DESC '
 name of overlays defined for a given database' SUP monitoredInfo NO-USER-MODI
 FICATION USAGE dSAOperation )
olcAttributeTypes: ( 1.3.6.1.4.1.4203.666.1.55.12 NAME 'readOnly' DESC 'read/w
 rite status of a given database' EQUALITY booleanMatch SYNTAX 1.3.6.1.4.1.146
 6.115.121.1.7 SINGLE-VALUE USAGE dSAOperation )
olcAttributeTypes: ( 1.3.6.1.4.1.4203.666.1.55.13 NAME 'restrictedOperation' D

 view release on metacpan or  search on metacpan

inc/inc_Module-Build/Module/Build/Base.pm  view on Meta::CPAN

    }

    return $ph->{features}->access($key, @_);
  }

  # No args - get the auto_features & overlay the regular features
  my %features;
  my %auto_features = $ph->{auto_features}->access();
  while (my ($name, $info) = each %auto_features) {
    my $failures = $self->prereq_failures($info);
    my $disabled = grep( /^(?:\w+_)?(?:requires|conflicts)$/,

 view release on metacpan or  search on metacpan

share/en/us/en_US.dic  view on Meta::CPAN

overland
overlap/SM
overlapped
overlapping
overlarge
overlay/GSM
overleaf
overlie
overload/GMDS
overlong
overlook/GMDS

 view release on metacpan or  search on metacpan

data/en_US.dic  view on Meta::CPAN

overland/S
overlap/MS
overlapped
overlapping
overlarge
overlay/GS
overleaf
overlie
overload/SDG
overlong
overlook/DSG

 view release on metacpan or  search on metacpan

share/css/jquery-ui.css  view on Meta::CPAN

/* Misc visuals
----------------------------------*/

/* Overlays */
.ui-widget-overlay {
	position: fixed;
	top: 0;
	left: 0;
	width: 100%;
	height: 100%;

share/css/jquery-ui.css  view on Meta::CPAN

}
.ui-progressbar .ui-progressbar-value {
	margin: -1px;
	height: 100%;
}
.ui-progressbar .ui-progressbar-overlay {
	background: url("data:image/gif;base64,R0lGODlhKAAoAIABAAAAAP///yH/C05FVFNDQVBFMi4wAwEAAAAh+QQJAQABACwAAAAAKAAoAAACkYwNqXrdC52DS06a7MFZI+4FHBCKoDeWKXqymPqGqxvJrXZbMx7Ttc+w9XgU2FB3lOyQRWET2IFGiU9m1frDVpxZZc6bfHwv4c1YXP6k1Vdy292Fb6UkuvFtXpvWSzA+HycXJH...
	height: 100%;
	-ms-filter: "alpha(opacity=25)"; /* support: IE8 */
	opacity: 0.25;
}

share/css/jquery-ui.css  view on Meta::CPAN

.ui-corner-br {
	border-bottom-right-radius: 3px;
}

/* Overlays */
.ui-widget-overlay {
	background: #aaaaaa;
	opacity: .3;
	-ms-filter: Alpha(Opacity=30); /* support: IE8 */
}
.ui-widget-shadow {