view release on metacpan or  search on metacpan

lib/Bio/Graphics/Browser2/Plugin.pm  view on Meta::CPAN

and allows the user to select among them. Example: BLAST search.

=item 3) annotators 

These plugins receive the genomic segment object and either 1) return 
a list of features which are overlayed on top of the detailed view 
(Example: restriction site annotator) or 2) update the database with 
new or modified features and return nothing (Example: basic editor)

=item 4) trackfilters

 view release on metacpan or  search on metacpan

lib/GD/Thumbnail.pm  view on Meta::CPAN

        FRAME                => FALSE,        # add frame?
        FRAME_COLOR          => BLACK,
        GD_FONT              => GD_FONT,      # info text color
        INFO_COLOR           => WHITE,
        MIME                 => EMPTY_STRING,
        OVERLAY              => FALSE,        # overlay info strips?
        SQUARE               => FALSE,        # make square thumb?
        STRIP_COLOR          => BLACK,
        STRIP_HEIGHT_BUFFER  => STRIP_HEIGHT_BUFFER,
        TTF_FONT             => undef,
        TTF_PTSIZE           => DEFAULT_TTF_PTSIZE,
    };

    $self->{FRAME}   = $o{frame}  ? 1          : 0;
    $self->{SQUARE}  = $o{square} ? $o{square} : 0;
    $self->{OVERLAY} = ($o{overlay} || $self->{SQUARE}) ? 1 : 0;

    for my $name ( qw(
        DEFAULT_TEXT
        DIMENSION_CONSTRAINT
        FORCE_MIME

lib/GD/Thumbnail.pm  view on Meta::CPAN

    if ( ! $opt->{square} || ( $opt->{square} && $opt->{xsmall} ) ) {
        # does not work if square & y_is_small, 
        # since we may have info bars which eat y space
        ${$ty_ref} = 0; # TODO. test this more and remove from below
        ${$y_ref}  = ${$y_ref} - ${$ty_ref} - $self->{STRIP_HEIGHT_BUFFER}/2 if $opt->{overlay};
    }
    return;
}

sub create {

lib/GD/Thumbnail.pm  view on Meta::CPAN

        {
            xsmall  => $xsmall,
            square  => $square,
            width   => $w,
            height  => $h,
            overlay => $o,
        },
        \$x, \$y, \$dx, \$dy, \$ty
    );

    $self->_alter_for_crop( $xsmall, \$x, \$y, \$dx, \$dy ) if $crop;

lib/GD/Thumbnail.pm  view on Meta::CPAN

    $thumb = GD::Thumbnail->new(
      info_color => [255, 255, 255]
    );

=head3 overlay

If you want information strips (see L</create>), but you don't
want to get a longer image, set this to a true value, and
the information strips will not affect the image height
(but the actual thumbnail image will be smaller).

lib/GD/Thumbnail.pm  view on Meta::CPAN

stretching the image in C<x> or C<y> dimension or clipping
it. If, however, C<square> is set to C<crop>, you'll get a
cropped square thumbnail.

Beware that enabling this option will also B<auto-enable> the 
C<overlay> option, since it is needed for a square image.

=head3 strip_height_buffer

The y buffer for the strips in pixels.

lib/GD/Thumbnail.pm  view on Meta::CPAN

    | 20x20 JPEG  |
     -------------

As you can see from the examples above, with the default options,
thumbnail image dimension is constant when adding information strips 
(i.e.: strips don't overlay, but attached to upper and lower parts of
thumbnail). Each info strip increases thumbnail height by 8 pixels 
(if the default tiny C<GD> font C<Tiny> is used).

But see the C<overlay> and C<square> options in L</new> to alter this
behavior. You may also need to increase C<max> value if C<square> is
enabled.

=head2 mime

 view release on metacpan or  search on metacpan

lib/GStreamer/Interfaces.pm  view on Meta::CPAN

  my @devices = $sink -> get_probe_values($pspec);

  # GStreamer::XOverlay

  my $overlay = GStreamer::ElementFactory -> make(xvimagesink => "overlay");
  $overlay -> set_xwindow_id($xid);

=head1 ABSTRACT

B<DEPRECATED> GStreamer::Interfaces provides access to some of the interfaces
in the GStreamer Interfaces library.  Currently, that's

lib/GStreamer/Interfaces.pm  view on Meta::CPAN

=head2 GStreamer::XOverlay

=over

=item $overlay->set_xwindow_id (xwindow_id)

=item $overlay->expose

=item $overlay->got_xwindow_id (xwindow_id)

=item $overlay->prepare_xwindow_id

=item $overlay->handle_events (bool) (since 0.10.12)

=back

=head1 AUTHOR

 view release on metacpan or  search on metacpan

share/README.md  view on Meta::CPAN

* [empty.png](empty.png) is the background when
  [debugging faces](https://campaignwiki.org/face/debug/alex/eyes) or
  when you're
  [appending the debug parameter](https://campaignwiki.org/face/gallery/alex/man?debug=1).

* [edit.png](edit.png) is the overlay used when
  [editing an element](https://campaignwiki.org/face/edit/alex/eyes_all_59.png).

* [dwarf.png](dwarf.png) and [elf.png](elf.png) are alternative empty
  elements to use when debugging faces with different proportions
  (such as

 view release on metacpan or  search on metacpan

share/traveller-example.txt  view on Meta::CPAN

0609-0607 communication
0707-0605 communication
0707-0607 communication
0804-0605 communication

# trade routes are thinner and can overlay communication routes
0102-0103 trade
0105-0205 trade
0106-0105 trade
0106-0107 trade
0409-0408 trade

 view release on metacpan or  search on metacpan

lib/Game/TextPatterns.pm  view on Meta::CPAN

        $self->pattern([ ($self->pattern->@*) x $rows ]);
    }
    return $self;
}

sub overlay {
    my ($self, $p, $overlay, $mask) = @_;
    my ($cols, $rows) = $self->dimensions;
    $p->[0] += $cols - 1 if $p->[0] < 0;
    $p->[1] += $rows - 1 if $p->[1] < 0;
    if ($p->[0] < 0 or $p->[0] >= $cols or $p->[1] < 0 or $p->[1] >= $rows) {
        local $" = ',';
        croak "point @$p out of bounds";
    }
    my ($colnum, $rownum) = map { $_ - 1 } $overlay->dimensions;
    my $subpat =
      $self->clone->crop($p,
        [ min($p->[0] + $colnum, $cols - 1), min($p->[1] + $rownum, $rows - 1) ]);
    my $to_draw = $overlay->clone->mask($mask, $subpat);
    $self->draw_in($p, $to_draw);
    return $self;
}

sub randomly {

lib/Game/TextPatterns.pm  view on Meta::CPAN

dimensions of the object if the I<pattern> exceeds that (hence the lower
right bound being optional). Should the I<pattern> be smaller than the
given bounds nothing will be changed at those subsequent points (this
differs from other methods that accept a I<fill> argument).

See also the more complicated B<overlay>.

=item B<fill_4way> I<point> I<char>

Replaces the character found at I<point> with I<char> and repeats this
fill for all similar characters found by 4-way motion from the

lib/Game/TextPatterns.pm  view on Meta::CPAN

Multiplies the existing data in the columns or rows, unless I<cols> or
I<rows> is C<1>. With no I<rows> set multiplies both the columns and
rows by the given value.

=item B<overlay> I<point> I<pattern> I<mask>

Draws the I<pattern> into the object at the given I<point> though
preserving anything from the original object that match the I<mask>
character in the I<pattern>.

 view release on metacpan or  search on metacpan

lib/Game/WordBrain/WordList.pm  view on Meta::CPAN

clove
cloven
clovene
clover
clovered
cloverlay
cloverleaf
cloverleafs
cloverleaves
cloverley
cloveroot

lib/Game/WordBrain/WordList.pm  view on Meta::CPAN

overlavishness
overlax
overlaxative
overlaxly
overlaxness
overlay
overlayed
overlayer
overlaying
overlays
overlead
overleaf
overlean
overleap
overleaped

 view release on metacpan or  search on metacpan

examples/opengl.pl  view on Meta::CPAN

#!/usr/bin/perl -w

# spinning cube in OpenGL with overlayed console

use strict;

BEGIN
  {

 view release on metacpan or  search on metacpan

t/patterns.txt  view on Meta::CPAN

1|2|3|4|5|6|6|8|9|7|11|12:unclassified|
1|2|3|4|5|6|6|8|9|7|2|12:reclassified|
1|2|3|4|5|6|6|8|9|7|2|6:reclassifies|
1|2|3|4|5|6|6|8|9|7|3|5|13|7|15|16:reclassification|
1|2|3|4|5|6|6|8|9|8|11|9|1:subcommittees|
1|2|3|4|5|6|7:Abelian|Abelson|Abidjan|Actaeon|Adamson|Afghans|African|Alberta|Alberto|Alcmena|Aldrich|Alfredo|Algenib|Algeria|Algiers|Almaden|Alvarez|Amadeus|Amazons|America|Amharic|Amherst|Anaheim|Anatole|Andover|Andrews|Anselmo|Antaeus|Antares|Anti...
1|2|3|4|5|6|7|1:absentia|anorexia|antisera|asphyxia|carbolic|carbonic|cosmetic|disabled|disarmed|dismayed|disowned|disputed|divorced|divulged|dockyard|drumhead|earphone|educable|emigrate|envisage|epilogue|equalize|exchange|exposure|gambling|gleaming|...
1|2|3|4|5|6|7|1|1:saltiness|shadiness|shakiness|sharpness|shortness|slackness|smartness|solidness|stainless|sulkiness|surliness|swiftness|
1|2|3|4|5|6|7|1|1|10|11:transmitted|
1|2|3|4|5|6|7|1|1|10|2:transmitter|
1|2|3|4|5|6|7|1|1|10|2|5:transmitters|

t/patterns.txt  view on Meta::CPAN

1|2|3|4|5|6|7|7|9|6|3:congressmen|
1|2|3|4|5|6|7|7|9|6|7|7:harmlessness|ruthlessness|
1|2|3|4|5|6|7|7|9|7|11:volunteered|
1|2|3|4|5|6|7|7|9|7|11|12:disagreement|
1|2|3|4|5|6|7|7|9|7|11|12|3:disagreements|
1|2|3|4|5|6|7|8:Abramson|Ackerman|Adlerian|Adolphus|Africans|Agricola|Alberich|Albrecht|Albright|Aleutian|Algerian|Alphonse|American|Americas|Analects|Angelica|Arequipa|Argonaut|Asilomar|Atchison|Auckland|Auerbach|Austrian|Bancroft|Bayreuth|Beaumont|...
1|2|3|4|5|6|7|8|1:cryogenic|diagnosed|disgraced|displaced|displayed|disproved|disrupted|disturbed|dominated|dynamited|elucidate|emphasize|enclosure|encourage|endurable|enjoyable|equitable|espionage|excitable|exclusive|excusable|expansive|explosive|ex...
1|2|3|4|5|6|7|8|1|1:slightness|storminess|sturdiness|
1|2|3|4|5|6|7|8|1|10:asteroidal|compliance|conspiracy|elucidates|emphasized|encouraged|encourages|gatherings|networking|octahedron|overshadow|regulators|regulatory|ungrateful|unmerciful|
1|2|3|4|5|6|7|8|1|10|11:archipelago|incredulity|informality|informative|obfuscatory|
1|2|3|4|5|6|7|8|1|10|11|12:incompatible|incompatibly|

t/patterns.txt  view on Meta::CPAN

1|2|3|4|5|6|7|8|8|7|1:silhouettes|
1|2|3|4|5|6|7|8|8|7|11:silhouetted|
1|2|3|4|5|6|7|8|8|7|11|12:earsplitting|
1|2|3|4|5|6|7|8|9:Abernathy|Alpheratz|Americans|Apetalous|Aphrodite|Archibald|Ashmolean|Auschwitz|Baltimore|Berkowitz|Bialystok|Blackburn|Blomquist|Bolshevik|Bromfield|Brunhilde|Brunswick|Bucharest|Bundestag|Byronizes|Byzantium|Cambridge|Catholics|Ca...
1|2|3|4|5|6|7|8|9|1:discharged|discounted|dislocated|dismounted|dispatched|downplayed|duplicated|exhaustive|expansible|metabolism|monetarism|sandwiches|scoundrels|searchings|shipwrecks|signatures|simulators|slanderous|slaughters|spreadings|subdomains...
1|2|3|4|5|6|7|8|9|10:Andromache|Babylonize|Blackstone|Bridgetown|Buchenwald|Burlingame|Candlewick|Charleston|Copernicus|Culbertson|Cumberland|Ektachrome|Fauntleroy|Fitzgerald|Fleischman|Fulbrights|Gatlinburg|Gilbertson|Heraclitus|Hieronymus|Kenilwort...
1|2|3|4|5|6|7|8|9|10|1:discouraged|disgruntled|speculators|subnetworks|subtrahends|sympathizes|thunderbolt|
1|2|3|4|5|6|7|8|9|10|10:harmfulness|typicalness|uprightness|
1|2|3|4|5|6|7|8|9|10|10|12:Jacksonville|Raymondville|domestically|impersonally|methodically|
1|2|3|4|5|6|7|8|9|10|10|2:hysterically|
1|2|3|4|5|6|7|8|9|10|10|6:Squaresville|

 view release on metacpan or  search on metacpan

bin/frozen-bubble  view on Meta::CPAN

                    update_malus(\&put_image_to_background, $::p);
                }
            };
        } elsif ($command eq 'm') {
            #- we may receive new malus bubbles after a distant player is dead already
            #- ignore them instead of wrongly overlaying frozen bubbles
            if ($pdata{$player}{state} eq 'ingame') {
                my ($num, $cx, $cy, $sticky) = $params =~ /(.+):(.+):(.+):(.+)/;
                my $b = create_bubble_given_img_num($num);
                $b->{cx} = $cx;
                $b->{cy} = $cy;

bin/frozen-bubble  view on Meta::CPAN

            }
            print_($action->{readonly} ? 'netdialogs_servermsg' : 'netdialogs', $app, $smg_startx, $y, $action->{name}, 520);
            $y += $smg_lineheight;
        }

        #- selfspot will need to properly erase selection overlay
        if ($mylatitude && !$private) {
            save_back_spot($mylatitude, $mylongitude, $imgbin{netspot_self}[0], \$back_selfspot);
            if ($index_selfspot >= 0) {
                print_spot($mylatitude, $mylongitude, 'free', $imgbin{netspot_self}[$index_selfspot], \$back_selfspot);
            }

 view release on metacpan or  search on metacpan

lib/Games/Go/Sgf2Dg/Diagram.pm  view on Meta::CPAN

The intersection has been labeled.  The value indicates the text of the
label.

=item 'overstones'

If this hash entry exists it means that one or more stones were overlayed
on the stone that is currently displayed on this intersection of the
B<Diagram>.

The hash value is a reference to an array of color/number pairs.
The colors and numbers were passed to the B<put> method which

 view release on metacpan or  search on metacpan

lib/Games/Irrlicht.pm  view on Meta::CPAN

=item freeze_time()

        $app->freeze_time();

Sets the time warp factor to 0, effectively stopping the warped clock. Note
that the real clock still ticks and frames are still drawn, so you can overlay
some menu/animation over a static (froozen in time) background. Of course it
might be more efficient to save the current drawn frame as image and stop
the drawing if the not-changing background altogether.

=item thaw_time()

 view release on metacpan or  search on metacpan

examples/font.pl  view on Meta::CPAN

#!/usr/bin/perl -w

# spinning cube in OpenGL with overlayed 2D font

use strict;

BEGIN
  {

 view release on metacpan or  search on metacpan

lib/Games/Sudoku/PatternSolver/Generator.pm  view on Meta::CPAN

 $grid_builder = get_grid_builder();
 $solution_string = &$grid_builder( <shuffle_symbols> ); 

The iterator returned from get_grid_builder() can produce fully filled sudoku grids at a fairly high rate. 
Like the solver, it also uses plain overlay of random patterns (POM) and no biased methods. (As the Latin Squares would.) 
The grids are spread absolutely randomly across the Sudoku space.

=head1 EXPORTS

The module optionally exports get_sudoku_builder(), get_grid_builder() and provides the import tag ':all'.

 view release on metacpan or  search on metacpan

lib/Games/Word/Wordlist/Enable.pm  view on Meta::CPAN

overinvestment overinvestments overissuance overissuances overissue overissued
overissues overissuing overjoy overjoyed overjoying overjoys overjust overkeen
overkill overkilled overkilling overkills overkind overlabor overlabored
overlaboring overlabors overlade overladed overladen overlades overlading
overlaid overlain overland overlands overlap overlapped overlapping overlaps
overlarge overlate overlavish overlax overlay overlaying overlays overleaf
overleap overleaped overleaping overleaps overleapt overlearn overlearned
overlearning overlearns overlend overlending overlends overlength overlengthen
overlengthened overlengthening overlengthens overlent overlet overlets
overletting overlewd overlie overlies overlight overlighted overlighting
overlights overlit overliteral overliterary overlive overlived overlives

 view release on metacpan or  search on metacpan

lib/Gantry/Plugins/AjaxCRUD.pm  view on Meta::CPAN

    # Form has errors
    if ( $show_form ) {
        # order matters, get form data first...
        $your_self->stash->view->form( $form );

        # ... then overlay with results
        if ( $your_self->method eq 'POST' ) {
            $your_self->stash->view->form->results( $results );
        }
    
    }

 view release on metacpan or  search on metacpan

lib/Gentoo/Overlay/Group/INI.pm  view on Meta::CPAN

}
{
  $Gentoo::Overlay::Group::INI::VERSION = '0.2.2';
}

# ABSTRACT: Load a list of overlays defined in a configuration file.

use Moose;
use Path::Tiny;
use File::HomeDir;
use Gentoo::Overlay::Exceptions qw( :all );

lib/Gentoo/Overlay/Group/INI.pm  view on Meta::CPAN

sub load {
  my ($self) = @_;

  my $seq = $self->_parse();

  return $seq->section_named('Overlays')->construct->overlay_group;

}


sub load_named {

lib/Gentoo/Overlay/Group/INI.pm  view on Meta::CPAN

=encoding utf-8

=head1 NAME

Gentoo::Overlay::Group::INI - Load a list of overlays defined in a configuration file.

=head1 VERSION

version 0.2.2

lib/Gentoo/Overlay/Group/INI.pm  view on Meta::CPAN

=head2 load_named

Return an inflated arbitrary section:

  # A "self-named" overlay section
  my $section = Gentoo::Overlay::Group::INI->load_named('Overlay');
  # A 'custom named overlay section, ie:
  # [ Overlay / foo ]
  my $section = Gentoo::Overlay::Group::INI->load_named('foo');

=head2 load_all_does

 view release on metacpan or  search on metacpan

lib/Gentoo/Overlay/Group.pm  view on Meta::CPAN

has '_overlays' => (
  ro, lazy,
  isa => HashRef [Gentoo__Overlay_Overlay],
  default     => sub { return {} },
  handles_via => 'Hash',
  handles     => {
    _has_overlay  => exists   =>,
    overlay_names => keys     =>,
    overlays      => elements =>,
    get_overlay   => get      =>,
    _set_overlay  => set      =>,
  },
);

my $_str = Str();

lib/Gentoo/Overlay/Group.pm  view on Meta::CPAN

sub add_overlay {
  my ( $self, @args ) = @_;
  if ( 1 == @args and blessed $args[0] ) {
    goto $self->can('_add_overlay_object');
  }
  if ( $_str->check( $args[0] ) ) {
    goto $self->can('_add_overlay_string_path');
  }
  return exception(
    ident   => 'bad overlay type',
    message => <<'EOF',
Unrecognised parameter types passed to add_overlay.
  Expected: \n%{signatures}s.
  Got: [%{type}s]}.
EOF
    payload => {
      signatures => ( join q{},  map { qq{    \$group->add_overlay( $_ );\n} } qw( Str Path::Tiny Gentoo::Overlay ) ),
      type       => ( join q{,}, map { _type_print } @args ),
    },
  );
}

lib/Gentoo/Overlay/Group.pm  view on Meta::CPAN

  my ( $self, $what, $callback ) = @_;    ## no critic (Variables::ProhibitUnusedVarsStricter)
  my %method_map = (
    ebuilds    => _iterate_ebuilds    =>,
    categories => _iterate_categories =>,
    packages   => _iterate_packages   =>,
    overlays   => _iterate_overlays   =>,
  );
  if ( exists $method_map{$what} ) {
    goto $self->can( $method_map{$what} );
  }
  return exception(

lib/Gentoo/Overlay/Group.pm  view on Meta::CPAN

# categories = { /overlays/categories

sub _iterate_categories {
  my ( $self, undef, $callback ) = @_;
  my $real_callback = sub {
    my (%overlay_config) = %{ $_[1] };
    my $inner_callback = sub {
      my (%category_config) = %{ $_[1] };
      $self->$callback( { ( %overlay_config, %category_config ) } );
    };
    $overlay_config{overlay}->_iterate_categories( categories => $inner_callback );
  };
  $self->_iterate_overlays( overlays => $real_callback );
  return;
}

lib/Gentoo/Overlay/Group.pm  view on Meta::CPAN

# overlays = { /overlays }
sub _iterate_overlays {
  my ( $self, undef, $callback ) = @_;
  my %overlays     = $self->overlays;
  my $num_overlays = scalar keys %overlays;
  my $last_overlay = $num_overlays - 1;
  my $offset       = 0;
  for my $overlay_name ( sort keys %overlays ) {
    local $_ = $overlays{$overlay_name};
    $self->$callback(
      {
        overlay_name => $overlay_name,
        overlay      => $overlays{$overlay_name},
        num_overlays => $num_overlays,
        last_overlay => $last_overlay,
        overlay_num  => $offset,
      }
    );
    $offset++;
  }
  return;
}

my $_gentoo_overlay = Gentoo__Overlay_Overlay();
my $_path_class_dir = Dir();

# This would be better in M:M:TypeCoercion







sub _add_overlay_object {
  my ( $self, $overlay, @rest ) = @_;

  if ( $_gentoo_overlay->check($overlay) ) {
    goto $self->can('_add_overlay_gentoo_object');
  }
  if ( $_path_class_dir->check($overlay) ) {
    goto $self->can('_add_overlay_path_class');
  }
  return exception(
    ident   => 'bad overlay object type',
    message => <<'EOF',
Unrecognised parameter object types passed to add_overlay.
  Expected: \n%{signatures}s.
  Got: [%{type}s]}.
EOF
    payload => {
      signatures => ( join q{}, map { qq{    \$group->add_overlay( $_ );\n} } qw( Str Path::Tiny Gentoo::Overlay ) ),
      type => ( join q{,}, blessed $overlay, map { _type_print } @rest ),
    },
  );
}







sub _add_overlay_gentoo_object {
  my ( $self, $overlay, ) = @_;
  $_gentoo_overlay->assert_valid($overlay);
  if ( $self->_has_overlay( $overlay->name ) ) {
    return exception(
      ident   => 'overlay exists',
      message => 'The overlay named %{overlay_name}s is already added to this group.',
      payload => { overlay_name => $overlay->name },
    );
  }
  $self->_set_overlay( $overlay->name, $overlay );
  return;
}







sub _add_overlay_path_class {    ## no critic ( RequireArgUnpacking )
  my ( $self, $path, ) = @_;
  $_path_class_dir->assert_valid($path);
  my $go = Gentoo::Overlay->new( path => $path, );
  @_ = ( $self, $go );
  goto $self->can('_add_overlay_gentoo_object');
}







sub _add_overlay_string_path {    ## no critic ( RequireArgUnpacking )
  my ( $self, $path_str, ) = @_;
  $_str->assert_valid($path_str);
  my $path = $_path_class_dir->coerce($path_str);
  @_ = ( $self, $path );
  goto $self->can('_add_overlay_path_class');
}

1;

__END__

lib/Gentoo/Overlay/Group.pm  view on Meta::CPAN

version 1.000001

=head1 SYNOPSIS

This is a wrapper around L<< C<Gentoo::Overlay>|Gentoo::Overlay >> that makes it easier to perform actions on a group of overlays.

  my $group = Gentoo::Overlay::Group->new();
  $group->add_overlay('/usr/portage');
  $group->add_overlay('/usr/local/portage/');
  $group->iterate( packages => sub {
    my ( $self, $context ) = @_;
    # Traverse-Order:
    # ::gentoo
    #   category_a

lib/Gentoo/Overlay/Group.pm  view on Meta::CPAN

    #     package_b
  });

=head1 METHODS

=head2 add_overlay

  $object->add_overlay( '/path/to/overlay' );
  $object->add_overlay( Path::Tiny::path( '/path/to/overlay' ) );
  $object->add_overlay( Gentoo::Overlay->new( path => '/path/to/overlay' ) );

=head2 iterate

  $object->iterate( ebuilds => sub {


  });

=head1 ATTRIBUTE ACCESSORS

=head2 overlay_names

  my @names = $object->overlay_names

=head2 overlays

  my @overlays = $object->overlays;

=head2 get_overlay

  my $overlay = $object->get_overlay('gentoo');

=head1 PRIVATE ATTRIBUTES

=head2 _overlays

  isa => HashRef[ Gentoo__Overlay_Overlay ], ro, lazy

=head1 PRIVATE ATTRIBUTE ACCESSORS

=head2 _has_overlay

  if( $object->_has_overlay('gentoo') ){
    Carp::croak('waah');
  }

=head2 _set_overlay

  $object->_set_overlay( 'gentoo' => $overlay_object );

=head1 PRIVATE FUNCTIONS

=head2 _type_print

lib/Gentoo/Overlay/Group.pm  view on Meta::CPAN

=head2 _iterate_packages

  $object->_iterate_packages( ignored => sub { } );

=head2 _iterate_overlays

  $object->_iterate_overlays( ignored => sub { } );

=head2 _add_overlay_object

  $groupobject->_add_overlay_object( $object );

=head2 _add_overlay_gentoo_object

  $groupobject->_add_overlay_gentoo_object( $gentoo_object );

=head2 _add_overlay_path_class

  $groupobject->_add_overlay_path_class( $path_class_object );

=head2 _add_overlay_string_path

  $groupobject->_add_overlay_string_path( $path_string );

=head1 AUTHOR

Kent Fredric <kentnl@cpan.org>

 view release on metacpan or  search on metacpan

examples/portage.pl  view on Meta::CPAN

use strict;
use warnings;

use Gentoo::Overlay;

my $overlay = Gentoo::Overlay->new( path => '/usr/portage' );

my %categories = $overlay->categories;

for my $category ( sort keys %categories ) {
  print $categories{$category}->pretty_name, "\n";

  my %packages = $categories{$category}->packages;

 view release on metacpan or  search on metacpan

lib/Gentoo/Perl/Distmap/FromOverlay.pm  view on Meta::CPAN

Moose::Util::TypeConstraints::coerce(
  $gog, $go,
  sub {
    require Gentoo::Overlay::Group;
    my $tree = Gentoo::Overlay::Group->new();
    $tree->add_overlay($_);
    $tree;
  }
);

has overlay => ( isa => $gog, ro, required, coerce );
has distmap => ( isa => 'Gentoo::Perl::Distmap', ro, lazy_build );

sub _warn {
  shift;
  require Carp;

lib/Gentoo/Perl/Distmap/FromOverlay.pm  view on Meta::CPAN

  my $upstream = $remote->content();

  my $distmapargs = {
    category     => $stash->{category_name},
    package      => $stash->{package_name},
    repository   => $stash->{overlay_name},
    distribution => $upstream,
  };
  my $on_ebuild = $self->_on_ebuild( $distmapargs, $stash, $distmap );
  $stash->{package}->iterate( ebuilds => $on_ebuild );
  return;

lib/Gentoo/Perl/Distmap/FromOverlay.pm  view on Meta::CPAN

sub _build_distmap {
  my ($self) = @_;
  require Gentoo::Perl::Distmap;
  my $distmap  = Gentoo::Perl::Distmap->new();
  my $callback = $self->_on_package($distmap);
  $self->overlay->iterate( packages => $callback );
  return $distmap;
}

__PACKAGE__->meta->make_immutable;
no Moose;

lib/Gentoo/Perl/Distmap/FromOverlay.pm  view on Meta::CPAN

=head1 SYNOPSIS

    use Gentoo::Perl::Distmap::FromOverlay;

    my $translator = Gentoo::Perl::Distmap::FromOverlay->new( overlay => Gentoo::Overlay->new( '/path/to/overlay' ) )
    # or
    my $og = Gentoo::Overlay::Group->new();
    $og->add_overlay('/path/to/overlay');
    my $translator = Gentoo::Perl::Distmap::FromOverlay->new( overlay => $og )
    # or
    my $translator = Gentoo::Perl::Distmap::FromOverlay->new( overlay => Gentoo::Overlay::Group::INI->load_named('foo')->overlay_group );

and then

    my $result = $translator->distmap;

 view release on metacpan or  search on metacpan

t/sandbox/usr/portage/app-portage/gentoolkit/files/scripts/dep-clean  view on Meta::CPAN

PROG=`basename ${0}`

tmp="/tmp/$$"

#Get PORTDIR and PORTDIR_OVERLAY from portage
PORTDIR_OVERLAY="$(/usr/lib/portage/bin/portageq portdir_overlay)"
PORTDIR="$(/usr/lib/portage/bin/portageq portdir)"

rm -rf ${tmp} > /dev/null 2>&1
mkdir ${tmp} > /dev/null 2>&1

 view release on metacpan or  search on metacpan

maint/check-gentoo-names.pl  view on Meta::CPAN

while ( my $line = <$fh> ) {
  chomp $line;
  my (@fields) = split /,/, $line;
  my ( $out, $err, $exit ) = capture {
    system( 'eix', '--in-overlay', 'gentoo', '-c', '-e', $fields[1] )
  };
  if ( $exit != 0 and $exit != 1 and $exit != 256 ) {
    die "Halt: $err $exit";
  }
  next if $exit == 0;

 view release on metacpan or  search on metacpan

lib/Geo/Coordinates/OSGB/Background.pod  view on Meta::CPAN

heading `The National Grid Reference System':

=over 4

=item * Base map constructed on Transverse Mercator Projection, Airy Ellipsoid, OSGB (1936) Datum.
Vertical datum mean sea level. The latitude, longitude graticule overlay is on the ETRS89 datum 
and is compatible with the WGS84 datum used by satellite navigation devices.

=back

If your map does not have the last sentence you can assume that it shows OSGB36

 view release on metacpan or  search on metacpan

lib/Geo/GML/xsd/gml-3.1.1/profiles/gmlJP2Profile/1.0.0/annotation/annotation.xml  view on Meta::CPAN

            <certainty>medium</certainty>
            <rationale>shape of polygons and proximity are a close match to that of known regions of interest</rationale>
        </AnnotationMetaData>
    </gml:metaDataProperty>
    <gml:defaultStyle>
        <!--Style will overlay some arrow or line symbol on top of Annotation/pointer value-->
    </gml:defaultStyle>
    <gml:defaultStyle>
        <!--Style will overlay some other arrow or line symbol on top of the other Annotation/pointer value-->
    </gml:defaultStyle>
    <gml:defaultStyle>
        <!--Style will fill in member Polygons in annotates MultiPolygon property value-->
    </gml:defaultStyle>
    <pointer>

 view release on metacpan or  search on metacpan

lib/Geo/GNUPlot.pm  view on Meta::CPAN

=item plot_radius_function(CONTOUR_OUTPUT_FILE, SURFACE_OUTPUT_FILE, OPTION_HASH_REF)

Creates a 2D contour and 3D surface plot of the radius function.  This
enables the user to better visualize the radius function and how it is
being interpolated from the provided node values.  The 2D contour plot overlays
the world map provided by the map_file during construction of the
C<Geo::GNUPlot> object.

The CONTOUR_OUTPUT_FILE is the full path of the filename to use for the contour plot.

 view release on metacpan or  search on metacpan

Geos.xs  view on Meta::CPAN

using namespace geos::index::chain;
using namespace geos::index;
using namespace geos::precision;
using namespace geos::operation::buffer;
using namespace geos::operation::distance;
using namespace geos::operation::overlay;
using namespace geos::operation::valid;
using namespace geos::operation::relate;
using namespace geos::operation::linemerge;
using namespace geos::triangulate;
using namespace xs;

 view release on metacpan or  search on metacpan

t/js_reference/polyline.js  view on Meta::CPAN

  }

  document.getElementById('encodedLevels').value = encoded_levels;
  document.getElementById('encodedPolyline').value = encoded_points;

  if (document.overlay) {
    document.map.removeOverlay(document.overlay);
  }

  if (points.length > 1) {
    document.overlay = GPolyline.fromEncoded({color: "#0000FF",
                                              weight: 10,
                                              points: encoded_points,
                                              zoomFactor: 32,
                                              levels: encoded_levels,
                                              numLevels: 4
                                             });

    document.map.addOverlay(document.overlay);
  }
}

function centerMap() {
  var address = document.getElementById('txtAddress').value;

t/js_reference/polyline.js  view on Meta::CPAN

  document.map = new GMap2(document.getElementById("map_canvas"));
  document.map.setCenter(new GLatLng(37.4419, -122.1419), 13);
  document.map.addControl(new GSmallMapControl());
  document.map.addControl(new GMapTypeControl());

  GEvent.addListener(document.map, "click", function(overlay, point) {
    document.getElementById('txtLatitude').value = point.y;
    document.getElementById('txtLongitude').value = point.x;

    if (marker == null) {
      marker = createMarker(point, "green");

 view release on metacpan or  search on metacpan

lib/Geo/Google/StaticMaps/V2.pm  view on Meta::CPAN

=head2 path

Creates a L<Geo::Google::StaticMaps::V2::Path> object and adds the object to the internal Paths array.

path (optional) defines a single path of two or more connected points to overlay on the image at specified locations. Note that if you supply a path for a map, you do not need to specify the (normally required) center and zoom parameters.

=cut

sub path {
  my $self=shift;

 view release on metacpan or  search on metacpan

lib/Geo/Google.pm  view on Meta::CPAN

      # attempt to locate the JSON formatted data block
      if ($page =~ m#loadVPage\((.+), "\w+"\);}//]]>#is) { $response_json = $json->jsonToObj($1); }
      else {
	$self->error( "Unable to locate the JSON format data in google's response.") and return undef;
      }
      if ( scalar(@{$response_json->{"overlays"}->{"markers"}}) > 0 ) {	
        foreach my $marker (@{$response_json->{"overlays"}->{"markers"}}) {
	  my $loc = $self->_obj2location($marker, %arg);
	  push @result, $loc;
        }		
      }
      else {

lib/Geo/Google.pm  view on Meta::CPAN

  }
  else {
    $self->error( "Unable to locate the JSON format data in Google's response.") and return undef;
  }

  if ( scalar(@{$response_json->{"overlays"}->{"markers"}}) > 0 ) {
    my @result = ();
    foreach my $marker (@{$response_json->{"overlays"}->{"markers"}}) {
      my $loc = $self->_obj2location($marker);
      push @result, $loc;
    }		
    return @result;
  }

lib/Geo/Google.pm  view on Meta::CPAN

    $self->error( "Unable to locate the JSON format data in Google's response.") and return undef;
  }

  my @points;
  my @enc_points;
  for (my $i = 0; $i<=$#{$response_json->{"overlays"}->{"polylines"}}; $i++) {
    $enc_points[$i] = $response_json->{"overlays"}->{"polylines"}->[$i]->{"points"};
    $points[$i] = [ _decode($enc_points[$i]) ];
  }

  # extract a series of directions from HTML inside the panel 
  # portion of the JSON data response, stuffing them in @html_segs

lib/Geo/Google.pm  view on Meta::CPAN

      distance  => $1 . " " . $2,
      time      => $3,
      polyline  => [ @enc_points ],
      locations => [ @locations ],
      panel     => $response_json->{"panel"},
      levels    => $response_json->{"overlays"}->{"polylines"}->[0]->{"levels"} );
  } else {
      $self->error("Could not extract the total route distance and time from google's directions") and return undef;
  }

#$Data::Dumper::Maxdepth=6;

lib/Geo/Google.pm  view on Meta::CPAN

 Usage    : my $loc = _obj2location($obj);
 Function : converts a perl object generated from a Google Maps 
		JSON response to a Geo::Google::Location object
 Returns  : a Geo::Google::Location object
 Args     : a member of the $obj->{overlays}->{markers}->[] 
		anonymous array that you get when you read google's 
		JSON response and parse it using JSON::jsonToObj()

=cut

lib/Geo/Google.pm  view on Meta::CPAN

                               'daddr' => '',
                               'dfaddr' => ''
                             },
                      'selected' => ''
                    },
          'overlays' => {
                          'polylines' => [],
                          'markers' => [],
                          'polygons' => []
                        },
          'printheader' => '',