view release on metacpan or  search on metacpan

lib/Catalyst/Plugin/PickComponents.pm  view on Meta::CPAN

    my @comps = sort { length $a <=> length $b } @plugins;
    my %comps = map { $_ => 1 } @comps;
    
    for my $component ( @comps ) {

        # We pass ignore_loaded here so that overlay files for (e.g.)
        # Model::DBI::Schema sub-classes are loaded - if it's in @comps
        # we know M::P::O found a file on disk so this is safe

        Catalyst::Utils::ensure_class_loaded( $component, { ignore_loaded => 1 } );

 view release on metacpan or  search on metacpan

lib/Catalyst/Plugin/ServeFile.pm  view on Meta::CPAN

This method will return true (the $fh actually) if it is successful in locating and serving
a file.  False otherwise.  It doesn't automatically set any 'not found' response, you need to
handle that yourself.

If the last argument is a HashRef, we will use it as an overlay on any configuration options.

See the L<\SYNOPSIS> for a longer example.

=head1 CONFIGURATION

 view release on metacpan or  search on metacpan

lib/Catalyst/Plugin/Static/Simple/ButMaintained.pm  view on Meta::CPAN

use C<MyApp-E<gt>config-E<gt>{root}> to add it.

	MyApp->config(
		static => {
			include_path => [
				'/path/to/overlay',
				\&incpath_generator,
				MyApp->config->{root},
			],
		},
	);

With the above setting, a request for the file C</images/logo.jpg> will search
for the following files, returning the first one found:

	/path/to/overlay/images/logo.jpg
	/dynamic/path/images/logo.jpg
	/your/app/home/root/images/logo.jpg

The include path can contain a subroutine reference to dynamically return a
list of available directories.  This method will receive the C<$c> object as a

lib/Catalyst/Plugin/Static/Simple/ButMaintained.pm  view on Meta::CPAN

	);

For example, if combined with the above C<include_path> setting, this
C<ignore_dirs> value will ignore the following directories if they exist:

	/path/to/overlay/tmpl
	/path/to/overlay/css
	/dynamic/path/tmpl
	/dynamic/path/css
	/your/app/home/root/tmpl
	/your/app/home/root/css

 view release on metacpan or  search on metacpan

lib/Catalyst/Plugin/Static/Simple.pm  view on Meta::CPAN

use C<MyApp-E<gt>config-E<gt>{root}> to add it.

    MyApp->config(
        'Plugin::Static::Simple' => {
            include_path => [
                '/path/to/overlay',
                \&incpath_generator,
                MyApp->config->{root},
            ],
        },
    );

With the above setting, a request for the file C</images/logo.jpg> will search
for the following files, returning the first one found:

    /path/to/overlay/images/logo.jpg
    /dynamic/path/images/logo.jpg
    /your/app/home/root/images/logo.jpg

The include path can contain a subroutine reference to dynamically return a
list of available directories.  This method will receive the C<$c> object as a

lib/Catalyst/Plugin/Static/Simple.pm  view on Meta::CPAN

    );

For example, if combined with the above C<include_path> setting, this
C<ignore_dirs> value will ignore the following directories if they exist:

    /path/to/overlay/tmpl
    /path/to/overlay/css
    /dynamic/path/tmpl
    /dynamic/path/css
    /your/app/home/root/tmpl
    /your/app/home/root/css

 view release on metacpan or  search on metacpan

lib/Catalyst.pm  view on Meta::CPAN

        qq{Please switch your class names to ::Model::, ::View:: and ::Controller: as appropriate.\n}
    ) if $deprecatedcatalyst_component_names;

    for my $component ( @comps ) {

        # We pass ignore_loaded here so that overlay files for (e.g.)
        # Model::DBI::Schema sub-classes are loaded - if it's in @comps
        # we know M::P::O found a file on disk so this is safe

        Catalyst::Utils::ensure_class_loaded( $component, { ignore_loaded => 1 } );
    }

 view release on metacpan or  search on metacpan

examples/TestApp/root/static/css/theme/jquery-ui.custom.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
* Copyright (c) 2009 AUTHORS.txt (http://jqueryui.com/about)
* Dual licensed under the MIT (MIT-LICENSE.txt) and GPL (GPL-LICENSE.txt) licenses.

examples/TestApp/root/static/css/theme/jquery-ui.custom.css  view on Meta::CPAN

.ui-corner-right {  -moz-border-radius-topright: .4em; -webkit-border-top-right-radius: .4em; -moz-border-radius-bottomright: .4em; -webkit-border-bottom-right-radius: .4em; }
.ui-corner-left { -moz-border-radius-topleft: .4em; -webkit-border-top-left-radius: .4em; -moz-border-radius-bottomleft: .4em; -webkit-border-bottom-left-radius: .4em; }
.ui-corner-all { -moz-border-radius: .4em; -webkit-border-radius: .4em; }

/* Overlays */
.ui-widget-overlay { background: #a6a6a6 url(images/ui-bg_dots-small_65_a6a6a6_2x2.png) 50% 50% repeat; opacity: .40;filter:Alpha(Opacity=40); }
.ui-widget-shadow { margin: -8px 0 0 -8px; padding: 8px; background: #333333 url(images/ui-bg_flat_0_333333_40x100.png) 50% 50% repeat-x; opacity: .10;filter:Alpha(Opacity=10); -moz-border-radius: 8px; -webkit-border-radius: 8px; }/* Accordion
----------------------------------*/
.ui-accordion .ui-accordion-header { cursor: pointer; position: relative; margin-top: 1px; zoom: 1; }
.ui-accordion .ui-accordion-li-fix { display: inline; }
.ui-accordion .ui-accordion-header-active { border-bottom: 0 !important; }

 view release on metacpan or  search on metacpan

lib/Catalyst/View/Template/Lace/Renderer.pm  view on Meta::CPAN

  $self->response(200, @args);
}

# helper methods

sub overlay_view {
  my ($self, $view_name, $dom_proto, @args) = @_;
  if( (ref($dom_proto)||'') eq 'CODE') {
    local $_ = $self->dom;
    @args = ($dom_proto->($self->dom), @args);
    $self->dom->overlay(sub {
      my $new =  $self->view($view_name, @args, content=>$_)
        ->get_processed_dom;
      return $new;
    });
  } elsif($dom_proto->can('each')) {
    $dom_proto->each(sub {
      return $self->overlay_view($view_name, $_, @args);
    });
  } else {
    $dom_proto->overlay(sub {
      return $self->view($view_name, @args, content=>$_)
        ->get_processed_dom;
    });
  }
  return $self;

lib/Catalyst/View/Template/Lace/Renderer.pm  view on Meta::CPAN

 
Used to setup a response.  Calling this method will setup an http status, finalize
headers and set a body response for the HTML.  Content type will be set to
'text/html' automatically.  Status is 200 unless you specify otherwise.

=head2 overlay_view

Helper method to allow you to wrap or overlay the current view with another
view (like a master page view or some other transformation that you prefer
to have under the control of the controller).  Example:

  $c->view('User',
    name => 'John',
    age => 42,
    motto => 'Why Not?')
  ->overlay_view(
    'Master', sub {
      my $user_dom = shift; # also $_ is localised to this for ease of use
      title => $_->at('title')->content,
      css => $_->find('link'),
      meta => $_->find('meta'),

 view release on metacpan or  search on metacpan

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

=head1 CHAINING TEMPLATE TRANFORMATIONS

There are several ways to decompose your repeated or options template transforms
into reusable chunks, at the View level.  Please see L<Template::Pure> for more
abour includes, wrappers and overlays.  However there are often cases when the
decision to use or apply changes to your template best occur at the controller
level.  For example you may wish to add some messaging to your template if a form
has incorrect data.  In those cases you may apply additional Views.  Applied views
will use as its starting template the results of the previous view.  For example:

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

In this example we set the C<src> attribute for the include processing
instruction to a path off 'Views' which is a special method on the view that
returns access to all the other views that are loaded.  So essentially any
view could serve as a source.

The same approach would be used to set overlays and wrappers via processing
instructions.

If using the C<Views> helper seems too flimsy an interface, you may instead
specify a view via an accessor, just like any other data.

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

    __PACKAGE__->meta->make_immutable;

Just remember if your include expects arguments (and most will) you should pass
them in the view call.

In fact you could allow one to pass the view C<src> include (or wrapper, or overlay)
from the controller, if you need more dynamic control:

    package  MyApp::View::Hello;

    use Moose;

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

configuration.  This is so that you can use the same view as standalone or as
part of a chain of transformations.

Useful when you are building up a view over a number of actions in a chain or
when you need to programmatically control how a view is created from the
controller.  You may also consider the use of includes and overlays inside your
view, or custom directive actions for more complex view building.

=head2 wrap

Used to pass the response on a template to another template, via a 'content'

 view release on metacpan or  search on metacpan

lib/CatalystX/CRUD/YUI/TT/crud/add_row_panel.tt  view on Meta::CPAN

        </div>
        
        <script type="text/javascript">
        /* <![CDATA[ */
        
        // create a overlay panel that uses the div
        YAHOO.crud.addRowMatrix = new YAHOO.widget.ResizePanel(
                'addListPanel', 
                { 
        // modal will deactivate the rest of the page while panel is active
        // but page size calculation is broken under FF for OSX (at least)

 view release on metacpan or  search on metacpan

lib/CatalystX/Crudite/Util/Random.pm  view on Meta::CPAN

overland
overlap
overlapped
overlapping
overlaps
overlay
overlaying
overlays
overload
overloaded
overloading
overloads
overlook

 view release on metacpan or  search on metacpan

root/static/js/yui/build/assets/skins/sam/container.css  view on Meta::CPAN

Copyright (c) 2008, Yahoo! Inc. All rights reserved.
Code licensed under the BSD License:
http://developer.yahoo.net/yui/license.txt
version: 2.5.0
*/
.yui-overlay,.yui-panel-container{visibility:hidden;position:absolute;z-index:2;}.yui-panel-container form{margin:0;}.mask{z-index:1;display:none;position:absolute;top:0;left:0;right:0;bottom:0;}.mask.block-scrollbars{overflow:auto;}.masked select,.d...

 view release on metacpan or  search on metacpan

Chandra.xs  view on Meta::CPAN

"})();";

static const char *CHANDRA_MODAL_JS =
"(function(){"
"if(window.__chandraModal)return;"
"var overlay,activeModal;"
"function create(id,opts){"
"overlay=document.createElement('div');"
"overlay.id=id+'_overlay';"
"overlay.style.cssText='position:fixed;top:0;left:0;width:100%;height:100%;background:rgba(0,0,0,0.5);z-index:99990;display:flex;align-items:center;justify-content:center;';"
"if(opts.backdrop!==false)overlay.onclick=function(e){if(e.target===overlay)close(id);};"
"var modal=document.createElement('div');"
"modal.id=id;"
"modal.style.cssText='background:var(--chandra-bg,#fff);border:1px solid var(--chandra-border,#e0e0e0);border-radius:var(--chandra-radius,6px);box-shadow:var(--chandra-shadow,0 4px 16px rgba(0,0,0,0.2));padding:0;min-width:320px;max-width:'+(opts.wid...
/* Title bar */
"if(opts.title){"

Chandra.xs  view on Meta::CPAN

"window.chandra.invoke(b.handler,[val]).then(function(){close(id);});"
"}"
"};"
"ftr.appendChild(btn);});"
"modal.appendChild(ftr);}"
"overlay.appendChild(modal);"
"document.body.appendChild(overlay);"
"activeModal=id;"
"requestAnimationFrame(function(){modal.style.opacity='1';modal.style.transform='scale(1)';});"
"var inp=document.getElementById(id+'_input');if(inp)setTimeout(function(){inp.focus();inp.select();},100);"
"}"
"function close(id){"
"var ov=document.getElementById(id+'_overlay');"
"if(!ov)return;"
"var m=document.getElementById(id);"
"if(m){m.style.opacity='0';m.style.transform='scale(0.95)';}"
"setTimeout(function(){if(ov.parentNode)ov.parentNode.removeChild(ov);},200);"
"activeModal=null;}"

 view release on metacpan or  search on metacpan

lib/Chart/Clicker.pm  view on Meta::CPAN

    isa => 'Str',
    default => 's'
);


has 'marker_overlay' => (
    is => 'rw',
    isa => 'Chart::Clicker::Decoration::MarkerOverlay',
    lazy => 1,
    default => sub {
        Chart::Clicker::Decoration::MarkerOverlay->new

lib/Chart/Clicker.pm  view on Meta::CPAN

    if($plot->grid->visible && !$self->grid_over) {
        $plot->render_area->add_component($plot->grid, 'c');
    }

    $plot->render_area->add_component(
        $self->marker_overlay
    );

    # Sentinels to control the side that the axes will be drawn on.
    my $dcount = 0;
    my $rcount = 0;

lib/Chart/Clicker.pm  view on Meta::CPAN

=head2 legend_position

The position the legend will be added.  Should be one of north, south, east,
west or center as required by L<Layout::Manager::Compass>.

=head2 marker_overlay

Set/Get the L<marker overlay|Chart::Clicker::Decoration::MarkerOverlay> object that will be used if this chart
has markers.  This is lazily constructed to save time.

=head2 over_decorations

Set/Get an arrayref of "over decorations", or things that are drawn OVER the

 view release on metacpan or  search on metacpan

lib/Chart/GGPlot/Geom/Boxplot.pm  view on Meta::CPAN

    Default aesthetics for outliers. Set to C<undef> to inherit from the
    aesthetics used for the box.

    Sometimes it can be useful to hide the outliers, for example when
    overlaying the raw data points on top of the boxplot. Hiding the
    outliers can be achieved by setting C<outlier_shape =E<gt> ''>.
    Importantly, this does not remove the outliers, it only hides them, so
    the range calculated for the y-axis will be the same with outliers
    shown and outliers hidden.

 view release on metacpan or  search on metacpan

examples/traces/barpolar.pl  view on Meta::CPAN

        title  => 'Wind Speed Distribution in Laurel, NE',
        font   => { size => 16 },
        legend => { font => { size => 16 } },
        polar  => {
            radialaxis => { ticksuffix => '%', angle => 45, dtick => 20 },
            barmode    => "overlay",
            angularaxis => { direction => "clockwise" },
            bargap      => 0
        }
      }

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

    - Add SYNOPSIS
    - Add examples for methods that get used most often

0.10002 Sun Dec 19 05:23:44 2010
    - Fix grave bug of XS-enabled simple accessors clobbering an
      existing 'around' overlay installed in the same method slot
    - Require bugfixed XSAccessor, remove Win32 caveat

0.10001 Sun Dec 12 03:17:05 2010
    - Fix an ActiveState Win32 incompatibility
    - Fix spurious method re-invocation warnings after Class::Unload

 view release on metacpan or  search on metacpan

lib/Class/Debug.pm  view on Meta::CPAN

   [My::Module]

   logger.file = /var/log/mymodule.log

The C<setup()> function will read this file,
overlay it onto your default parameters,
and initialize the logger accordingly.

If the file is not readable and no config_dirs are provided,
the module will throw an error.

 view release on metacpan or  search on metacpan

lib/Class/GAPI.pm  view on Meta::CPAN

		return 1 ; 
	} 
	return 0 ; 
}  

sub overlay {  # Convert a hash into a series of function calls.
	my $self = shift 		          ;
	return undef if  scalar(@_) % 2   ;
	my %pairs = @_ 			    ;
 
	while(my ($k, $v) = each %pairs) {

lib/Class/GAPI.pm  view on Meta::CPAN

or that Inherit Class::GAPI. This includes Class::List objects. This is function is eval()d, so it 
will not crash if you have other stuff in their, just don't expect that other stuff copy. 

	my $twin = $pet->clone(); # Make the FDA nervous 

The overlay() function allows one to execute a block of functions by passing hash.  This is equivilant 
to what happens when constructed with new(). This is typically usefull when you want to copy a hash 
into several objects as you might in a record table:

	package Guppy::School	; 
	use Guppy		; 

lib/Class/GAPI.pm  view on Meta::CPAN

	}

	sub fishGrow { # Add a block of options like so: fishGrow(2, foo => 'bar') ;  
		my $self = shift		; 
		my $n = shift			; 
		$self->School->[$n]->overlay(@_); 
		return($fish)			;   
	}
	1 ;

The warn_self() function is pretty much what it sounds like. You can call it at any level with 

 view release on metacpan or  search on metacpan

slides/classloader.tex  view on Meta::CPAN

\usepackage{wasysym}

\usepackage{beamerthemeWarsaw}

% Aufzählungen generell schrittweise anzeigen
\beamerdefaultoverlayspecification{<+->}

% nächsten Punkt in Aufzählungsliste hellgrau darstellen
\beamersetuncovermixins{\opaqueness<1>{5}}{\opaqueness<2->{5}}

% Abschalten der Navigationsleiste

 view release on metacpan or  search on metacpan

SYNCTREE.html  view on Meta::CPAN

<p>Synctree brings a VOB area into alignment with a specified set of files
from a source area. It's analogous in various ways to <em>clearfsimport</em>,
<em>citree</em>, and <em>clearexport/clearimport</em>; see the COMPARISONS section
below.  Synctree is useful if you have a ClearCase tree that must be
kept in sync with a CVS tree during a transition period, or for
overlaying releases of third-party products upon previous ones, or
exporting deliverable DO's from a nightly build to a release VOB while
preserving config records (CR's) and labels, or similar.</p>
<p>The default operation is to mkelem all files which exist in
<em>&lt;src&gt;</em> but not in <em>&lt;dest&gt;</em>, modify any files which
exist in both but differ, but <strong>not</strong> to remove files which are present

 view release on metacpan or  search on metacpan

DSB.pm  view on Meta::CPAN

ClearCase::Wrapper::DSB - David Boyce's contributed cleartool wrapper functions

=head1 SYNOPSIS

This is an C<overlay module> for B<ClearCase::Wrapper> containing David
Boyce's non-standard extensions. See C<perldoc ClearCase::Wrapper> for
more details.

=head1 CLEARTOOL ENHANCEMENTS

 view release on metacpan or  search on metacpan

MGi.pm  view on Meta::CPAN

ClearCase::Wrapper::MGi - Support for an alternative to UCM.

=head1 SYNOPSIS

This is an C<overlay module> for B<ClearCase::Wrapper> containing Marc
Girod's non-standard extensions. See C<perldoc ClearCase::Wrapper> (by
David Boyce) for more details.

The alternative to UCM consists in a novel branching model, and a concept
of incremental types.

 view release on metacpan or  search on metacpan

Wrapper.pm  view on Meta::CPAN

use warnings;

use vars qw(%Packages %ExtMap $libdir $prog $dieexit $dieexec $diemexec);

# Inherit some symbols from the main package. We will later "donate"
# these to all overlay packages as well.
BEGIN {
    *prog = \$::prog;
    *dieexit = \$::dieexit;
    *dieexec = \$::dieexec;
    *diemexec = \$::diemexec;
}

# For some reason this can't be handled the same as $prog above ...
use constant MSWIN => $^O =~ /MSWin|Windows_NT/i ? 1 : 0;

# This is the list of functions we want to export to overlay pkgs.
my @exports = qw(MSWIN GetOptions Assert Burrow Msg Pred ViewTag
                AutoCheckedOut AutoNotCheckedOut AutoViewPrivate);

# Hacks for portability with Windows env vars.
BEGIN {

Wrapper.pm  view on Meta::CPAN

      $pm =~ s%^$dirQuoted/(.*)\.pm$%$1%;
      (my $pkg = $pm) =~ s%[/\\]+%::%g;
      eval "*${pkg}::exit = \$dieexit";
      eval "*${pkg}::exec = \$dieexec";

      # In this block we temporarily enter the overlay's package
      # just in case the overlay module forgot its package stmt.
      # We then require the overlay file and also, if it's
      # an autoloaded module (which is recommended), we drag
      # in the index file too. This is because we need to
      # derive a list of all functions defined in the overlay
      # in order to import them to our own namespace.
      {
          eval qq(package $pkg); # default the pkg correctly
          no warnings qw(redefine);
          eval {

Wrapper.pm  view on Meta::CPAN

            eval { require $ix };
            warn $@ if $@;
          }
      }

      # Now the overlay module is read in. We need to examine its
      # newly-created symbol table, determine which functions
      # it defined, and import them here. The same basic thing is
      # done for the base package later.
      no strict 'refs';
      my %names = %{"${pkg}::"};

Wrapper.pm  view on Meta::CPAN

          # msg extensions (in the form $foo) to come over too.
          eval qq(*$_ = *$tglob);
      }

      # The base module defines a few functions which the
      # overlay's code might want to use. Make aliases
      # for those in the overlay's symbol table.
      for (@exports) {
          eval "*${pkg}::$_ = \\&$_";
      }
      eval "*${pkg}::prog = \\\$prog";

Wrapper.pm  view on Meta::CPAN

=over 4

=item * EXTENSIONS

A pseudo-command which lists the currently-defined extensions. Use with
B<-long> to see which overlay module defines each extension. Note that
both extensions and their aliases (e.g. I<checkin> and I<ci>) are
shown.

=cut

Wrapper.pm  view on Meta::CPAN

re-run 'make install'. However, these changes wcould be lost when a new
version of ClearCase::Wrapper is released, and you'd have to take
responsibility for merging your changes with mine.

Therefore, the preferred way to make site-wide customizations or
additions is to make an I<overlay> module. ClearCase::Wrapper will
automatically include ('require') all modules in the
ClearCase::Wrapper::* subclass. Thus, if you work for C<TLA
Corporation> you should put your enhancement subroutines in a module
called ClearCase::Wrapper::TLA and they'll automatically become
available.

A sample overlay module is provided in the C<./examples> subdir. To
make your own you need only take this sample, change all uses of the
word 'MySite' to a string of your choice, replace the sample subroutine
C<mysite()> with your own, and install. It's a good idea to document
your extension in POD format right above the sub and make the
appropriate addition to the "Usage Message Extensions" section.  Also,
if the command has an abbreviation (e.g. checkout/co) you should add
that to the "Command Aliases" section. See ClearCase::Wrapper::DSB
for examples.

Two separate namespaces are recognized for overlays:
I<ClearCase::Wrapper::*> and I<ClearCase::Wrapper::Site::*>. The intent
is that if your extension is site-specific it should go in the latter
area, if of general use in the former. These may be combined.  For
instance, imagine TLA Corporation is a giant international company with
many sites using ClearCase, and your site is known as R85G. There could
be a I<ClearCase::Wrapper::TLA> overlay with enhancements that apply
anywhere within TLA and/or a I<ClearCase::Wrapper::Site::R85G> for
your people only. Note that since overlay modules in the Site namespace
are not expected to be published on CPAN the naming rules can be less
strict, which is why C<TLA> was left out of the latter module name.

Overlays in the general I<ClearCase::Wrapper::*> namespace are
traversed before I<ClearCase::Wrapper::Site::*>. This allows

 view release on metacpan or  search on metacpan

Cloudinary-0.16/Cloudinary-0.16/lib/Cloudinary.pm  view on Meta::CPAN

    d => 'default_image',
    e => 'effect',
    f => 'fetch_format',
    g => 'gravity',
    h => 'height',
    l => 'overlay',
    p => 'prefix',
    q => 'quality',
    r => 'radius',
    t => 'named_transformation',
    w => 'width',

Cloudinary-0.16/Cloudinary-0.16/lib/Cloudinary.pm  view on Meta::CPAN

  d = default_image
  e = effect
  f = fetch_format
  g = gravity
  h = height
  l = overlay
  p = prefix
  q = quality
  r = radius
  t = named_transformation
  w = width

 view release on metacpan or  search on metacpan

examples/helloworld/htdocs/dwarf/bootstrap/css/bootstrap.css.map  view on Meta::CPAN

{"version":3,"sources":["bootstrap.css","less/normalize.less","less/print.less","less/glyphicons.less","less/scaffolding.less","less/mixins/vendor-prefixes.less","less/mixins/tab-focus.less","less/mixins/image.less","less/type.less","less/mixins/text...

 view release on metacpan or  search on metacpan

doc/Cmenu.tex  view on Meta::CPAN

This will show what Cmenu is returning from a particular call.

\subsection{menu\_popup}
This is an extra routine which you may never need. It provides a way of displaying information while a process is being performed rather than the script stalling silently. It is called in two forms; first to display the popup and then to remove it;
\begin{description}
\item [menu\_popup(\$header,\$message)] This creates a popup which overlays the current menu. A very small window is opened with a drawn border and \textbf{\$header} displayed in the centre of the top line. The \textbf{\$message} is displayed in the ...

After calling this, your script should go off and busy itself until ready to talk to the user again
\item [menu\_popup()] call the same routine with no parameters and the Popup menu will be removed.
\end{description}
Please remember to close the popup as dangling windows can trash your display.

 view release on metacpan or  search on metacpan

share/js/jquery-ui-1.11.4.js  view on Meta::CPAN

		this._size();
		this._position();
		this._createOverlay();
		this._moveToTop( null, true );

		// Ensure the overlay is moved to the top with the dialog, but only when
		// opening. The overlay shouldn't move after the dialog is open so that
		// modeless dialogs opened after the modal dialog stack properly.
		if ( this.overlay ) {
			this.overlay.css( "z-index", this.uiDialog.css( "z-index" ) - 1 );
		}

		this._show( this.uiDialog, this.options.show, function() {
			that._focusTabbable();
			that._trigger( "focus" );

share/js/jquery-ui-1.11.4.js  view on Meta::CPAN

	_createOverlay: function() {
		if ( !this.options.modal ) {
			return;
		}

		// We use a delay in case the overlay is created from an
		// event that we're going to be cancelling (#2804)
		var isOpening = true;
		this._delay(function() {
			isOpening = false;
		});

		if ( !this.document.data( "ui-dialog-overlays" ) ) {

			// Prevent use of anchors and inputs
			// Using _on() for an event handler shared across many instances is
			// safe because the dialogs stack and must be closed in reverse order
			this._on( this.document, {

share/js/jquery-ui-1.11.4.js  view on Meta::CPAN

					}
				}
			});
		}

		this.overlay = $( "<div>" )
			.addClass( "ui-widget-overlay ui-front" )
			.appendTo( this._appendTo() );
		this._on( this.overlay, {
			mousedown: "_keepFocus"
		});
		this.document.data( "ui-dialog-overlays",
			(this.document.data( "ui-dialog-overlays" ) || 0) + 1 );
	},

	_destroyOverlay: function() {
		if ( !this.options.modal ) {
			return;
		}

		if ( this.overlay ) {
			var overlays = this.document.data( "ui-dialog-overlays" ) - 1;

			if ( !overlays ) {
				this.document
					.unbind( "focusin" )
					.removeData( "ui-dialog-overlays" );
			} else {
				this.document.data( "ui-dialog-overlays", overlays );
			}

			this.overlay.remove();
			this.overlay = null;
		}
	}
});

share/js/jquery-ui-1.11.4.js  view on Meta::CPAN

		this.element.toggleClass( "ui-progressbar-indeterminate", this.indeterminate );

		if ( this.indeterminate ) {
			this.element.removeAttr( "aria-valuenow" );
			if ( !this.overlayDiv ) {
				this.overlayDiv = $( "<div class='ui-progressbar-overlay'></div>" ).appendTo( this.valueDiv );
			}
		} else {
			this.element.attr({
				"aria-valuemax": this.options.max,
				"aria-valuenow": value
			});
			if ( this.overlayDiv ) {
				this.overlayDiv.remove();
				this.overlayDiv = null;
			}
		}

		if ( this.oldValue !== value ) {
			this.oldValue = value;

 view release on metacpan or  search on metacpan

zlib-src/deflate.c  view on Meta::CPAN

    s->high_water = 0;      /* nothing written to s->window yet */

    s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */

    /* We overlay pending_buf and sym_buf. This works since the average size
     * for length/distance pairs over any compressed block is assured to be 31
     * bits or less.
     *
     * Analysis: The longest fixed codes are a length code of 8 bits plus 5
     * extra bits, for lengths 131 to 257. The longest fixed distance codes are

 view release on metacpan or  search on metacpan

ext/zstd/lib/common/xxhash.h  view on Meta::CPAN

 *   [ a & 0xFFFFFFFF | b & 0xFFFFFFFF ],[    a >> 32     |     b >> 32    ]
 *
 * Due to significant changes in aarch64, the fastest method for aarch64 is
 * completely different than the fastest method for ARMv7-A.
 *
 * ARMv7-A treats D registers as unions overlaying Q registers, so modifying
 * D11 will modify the high half of Q5. This is similar to how modifying AH
 * will only affect bits 8-15 of AX on x86.
 *
 * VZIP takes two registers, and puts even lanes in one register and odd lanes
 * in the other.

 view release on metacpan or  search on metacpan

lib/Config/IniFiles.pm  view on Meta::CPAN

stacked in turn and so on recursively, but this is beyond the
point). The effect, as briefly explained in L</new>, is that the
fields appearing in the composite object will be a superposition of
those coming from the ``original'' one and the lines coming from the
file, the latter taking precedence. For example, let's say that
C<$master> and C<overlay> were created like this:

   my $master  = Config::IniFiles->new(-file => "master.ini");
   my $overlay = Config::IniFiles->new(-file => "overlay.ini",
            -import => $master);

If the contents of C<master.ini> and C<overlay.ini> are respectively

   ; master.ini
   [section1]
   arg0=unchanged from master.ini
   arg1=val1

lib/Config/IniFiles.pm  view on Meta::CPAN

   [section2]
   arg2=val2

and

   ; overlay.ini
   [section1]
   arg1=overridden

Then C<< $overlay->val("section1", "arg1") >> is "overridden", while
C<< $overlay->val("section1", "arg0") >> is "unchanged from
master.ini".

This feature may be used to ship a ``global defaults'' configuration
file for a Perl application, that can be overridden piecewise by a
much shorter, per-site configuration file. Assuming UNIX-style path

lib/Config/IniFiles.pm  view on Meta::CPAN

Starting with version 2.39, I<Config::IniFiles> also provides features
to keep the importing / per-site configuration file small, by only
saving those options that were modified by the running program. That
is, if one calls

   $overlay->setval("section1", "arg1", "anotherval");
   $overlay->newval("section3", "arg3", "val3");
   $overlay->WriteConfig('overlay.ini', -delta=>1);

C<overlay.ini> would now contain

   ; overlay.ini
   [section1]
   arg1=anotherval

   [section3]
   arg3=val3

This is called a I<delta file> (see L</WriteConfig>). The untouched
[section2] and arg0 do not appear, and the config file is therefore
shorter; while of course, reloading the configuration into C<$master>
and C<$overlay>, either through C<< $overlay->ReadConfig() >> or through
the same code as above (e.g. when application restarts), would yield
exactly the same result had the overlay object been saved in whole to
the file system.

The only problem with this delta technique is one cannot delete the
default values in the overlay configuration file, only change
them. This is solved by a file format extension, enabled by the
I<-negativedeltas> option to L</new>: if, say, one would delete
parameters like this,

   $overlay->DeleteSection("section2");
   $overlay->delval("section1", "arg0");
   $overlay->WriteConfig('overlay.ini', -delta=>1);

The I<overlay.ini> file would now read:

   ; overlay.ini
   [section1]
   ; arg0 is deleted
   arg1=anotherval

   ; [section2] is deleted

   [section3]
   arg3=val3

Assuming C<$overlay> was later re-read with C<< -negativedeltas => 1 >>,
the parser would interpret the deletion comments to yield the correct
result, that is, [section2] and arg0 would cease to exist in the
C<$overlay> object.

=head1 DIAGNOSTICS

=head2 @Config::IniFiles::errors