view release on metacpan or  search on metacpan

lib/Web/Library/jQueryUI.pm  view on Meta::CPAN

=over 4

=item Version 1.10.2
=item Version 1.10.3 (the default)

      css/images/animated-overlay.gif
      css/images/ui-bg_flat_0_aaaaaa_40x100.png
      css/images/ui-bg_flat_75_ffffff_40x100.png
      css/images/ui-bg_glass_55_fbf9ee_1x400.png
      css/images/ui-bg_glass_65_ffffff_1x400.png
      css/images/ui-bg_glass_75_dadada_1x400.png

 view release on metacpan or  search on metacpan

lib/Web/MREST.pm  view on Meta::CPAN

status. RFC2616 does not stipulate exactly what constitutes a bad request.
We already (in allowed_methods) took care of the case when the URI 
fails to match a known resource, and that includes applying any C<validations> 
properties from the resource definition. 

So, in this method (or your overlay) we take the "next step" (whatever that is)
in vetting the request. Keep in mind that this method is called before 
the resource handler. If you have any sanity checks you wish to apply _after_
the URI is matched to a resource but _before_ the resource handler fires, this
is the place to put them.

lib/Web/MREST.pm  view on Meta::CPAN

file C<dispatch_MetaConfig.pm>.  Inside that file, the application puts its own
resource definitions in the C<MREST_RESOURCE_DEFINITIONS> and
C<MREST_ROOT_RESOURCE> parameters (refer to C<config/dispatch_MetaConfig.pm> in
the L<Web::MREST> distribution for syntax and semantics).

The application's definitions will overlay (i.e. replace) those of
L<Web::MREST>.  Even in this scenario, some or all of L<Web::MREST>'s resources
could be used in the application, but only by copy-pasting the definitions and
their respective handlers into the application's source code.

=back

lib/Web/MREST.pm  view on Meta::CPAN

not desired the application developer can parse URIs herself by simply
substituting her own C<init_router> and C<match> methods for the ones provided
by L<Path::Router> and L<Path::Router::Route::Match>, respectively.

When request processing enters C<resource_exists>, 
Alternatively, the application developer can overlay the C<init_router> routine
with one that returns an arbitrary object (stored in C<$router>) that has a
C<match> method. After that, L<Web::MREST> does

    my $match = $router->match( $path );

 view release on metacpan or  search on metacpan

lib/WebService/Avalara/AvaTax/Service/Tax.pm  view on Meta::CPAN

#pod =head1 WORKAROUNDS FOR INCORRECT AVALARA RESPONSES
#pod
#pod As of this writing the Avalara SOAP API returns responses that are
#pod inconsistent with the WSDL document provided. Specifically, the C<TaxIncluded>
#pod and C<GeocodeType> fields in the C<GetTaxResponse> are wrongly placed in their
#pod sequences of fields. This module adds an overlay to the Avalara tax service
#pod WSDL file that attempts to work around these problems so that the responses
#pod may be successfully parsed.
#pod
#pod =cut

lib/WebService/Avalara/AvaTax/Service/Tax.pm  view on Meta::CPAN

=head1 WORKAROUNDS FOR INCORRECT AVALARA RESPONSES

As of this writing the Avalara SOAP API returns responses that are
inconsistent with the WSDL document provided. Specifically, the C<TaxIncluded>
and C<GeocodeType> fields in the C<GetTaxResponse> are wrongly placed in their
sequences of fields. This module adds an overlay to the Avalara tax service
WSDL file that attempts to work around these problems so that the responses
may be successfully parsed.

=for Pod::Coverage BUILDARGS

 view release on metacpan or  search on metacpan

lib/WebService/DataDog/Event.pm  view on Meta::CPAN

}


=head2 create()

Post event to DataDog event stream. This will overlay red areas on all dashboards,
corresponding to each event.  Example uses: code pushes, server/service restarts, etc.

Per DataDog: "This end point allows you to post events to the stream. You can
tag them, set priority and event aggregate them with other events."

 view release on metacpan or  search on metacpan

t/02_api.t  view on Meta::CPAN

is $api->status, 1;
diag $response;
};
is $response, '';

$response = $api->call_method('riya.photos.overlays.AddOverlay', {
    image_id => $image_id,
    x => '0',
    y => '0',
    w => '50',
    h => '50',
});
is $api->status, 1;

$response = $api->call_method('riya.photos.overlays.GetOverlayList', {
    image_id => $image_id,
});
is $api->status, 1;

$doc = $xml->parse_string($response);
my @nodes = $doc->findnodes("//*[local-name()='overlay']");

$response = $api->call_method('riya.photos.overlays.EditOverlay', {
    image_id => $image_id,
    overlay_id => $nodes[0]->findvalue("\@id"),
    tag        => 'DogTag',
});
SKIP: {
skip 'Does riya.photos.overlays.EditOverlay work fine?';
is $api->status, 1;
diag $response;
};
is $response, '';

$response = $api->call_method('riya.photos.overlays.RemoveOverlay', {
    image_id => $image_id,
    overlay_id => $nodes[0]->findvalue("\@id"),
});
SKIP: {
skip 'Does riya.photos.overlays.RemoveOverlay work fine?';
is $api->status, 1;
diag $response;
};
is $response, '';

 view release on metacpan or  search on metacpan

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)) {

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;

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;
    }

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;

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;

 view release on metacpan or  search on metacpan

Combobox.xs  view on Meta::CPAN

        XST_mIV(3, cb_item.iImage);
        XST_mPV(4, "-selectedimage");
        XST_mIV(5, cb_item.iSelectedImage);
        XST_mPV(6, "-item");
        XST_mIV(7, cb_item.iItem);
        XST_mPV(8, "-overlay");
        XST_mIV(9, cb_item.iOverlay);
        XST_mPV(10, "-indent");
        XST_mIV(11, cb_item.iIndent);
        XST_mPV(12, "-lparam");
        XST_mIV(13, cb_item.lParam);

 view release on metacpan or  search on metacpan

DB.pm  view on Meta::CPAN

This doesn't open the file read-only, but changes will not be written
to disk.

A transform is a specification of changed values.  So you get a MSI
database from your favorite vendor, make a transform to overlay your
own settings (the target installation directory, the features to be
installed, etc.) and upon installation you can use these settings via
a commandline similar to

  msiexec /i TRANSFORMS = F<your transform file> F<the msi database> /qb

 view release on metacpan or  search on metacpan

Mci/Consts.pm  view on Meta::CPAN

      MCI_ANIM_WINDOW_HWND MCI_ANIM_WINDOW_STATE MCI_ANIM_WINDOW_TEXT MCI_ANIM_WINDOW_ENABLE_STRETCH 
      MCI_ANIM_WINDOW_DISABLE_STRETCH MCI_ANIM_WINDOW_DEFAULT MCI_ANIM_RECT MCI_ANIM_PUT_SOURCE MCI_ANIM_PUT_DESTINATION 
      MCI_ANIM_WHERE_SOURCE MCI_ANIM_WHERE_DESTINATION MCI_ANIM_UPDATE_HDC 
   )],

   #overlay device
   OVERLAYFLAGS => [ qw (
      MCI_OVLY_OPEN_WS MCI_OVLY_OPEN_PARENT MCI_OVLY_STATUS_HWND MCI_OVLY_STATUS_STRETCH MCI_OVLY_INFO_TEXT 
      MCI_OVLY_GETDEVCAPS_CAN_STRETCH MCI_OVLY_GETDEVCAPS_CAN_FREEZE MCI_OVLY_GETDEVCAPS_MAX_WINDOWS 
      MCI_OVLY_WINDOW_HWND MCI_OVLY_WINDOW_STATE MCI_OVLY_WINDOW_TEXT MCI_OVLY_WINDOW_ENABLE_STRETCH 
      MCI_OVLY_WINDOW_DISABLE_STRETCH MCI_OVLY_WINDOW_DEFAULT MCI_OVLY_RECT MCI_OVLY_PUT_SOURCE 

Mci/Consts.pm  view on Meta::CPAN

   use constant MCI_ANIM_PUT_DESTINATION        => 0x00040000;
   use constant MCI_ANIM_WHERE_SOURCE           => 0x00020000;
   use constant MCI_ANIM_WHERE_DESTINATION      => 0x00040000;
   use constant MCI_ANIM_UPDATE_HDC             => 0x00020000;

#overlay device
   use constant MCI_OVLY_OPEN_WS                => 0x00010000;
   use constant MCI_OVLY_OPEN_PARENT            => 0x00020000;
   use constant MCI_OVLY_STATUS_HWND            => 0x00004001;
   use constant MCI_OVLY_STATUS_STRETCH         => 0x00004002;
   use constant MCI_OVLY_INFO_TEXT              => 0x00010000;

 view release on metacpan or  search on metacpan

samples/text  view on Meta::CPAN

 anarchism originated as a term of abuse first used against early working class radicals including the diggers of the english revolution and the sans culottes of the french revolution whilst the term is still used in a pejorative way to describe any ...

 view release on metacpan or  search on metacpan

lib/WordList/EN/Corncob.pm  view on Meta::CPAN

overland
overlap
overlapped
overlapping
overlaps
overlay
overlaying
overlays
overleaf
overlie
overlies
overload
overloaded

 view release on metacpan or  search on metacpan

lib/WordList/EN/Enable.pm  view on Meta::CPAN

overlaps
overlarge
overlate
overlavish
overlax
overlay
overlaying
overlays
overleaf
overleap
overleaped
overleaping
overleaps

 view release on metacpan or  search on metacpan

lib/Wrangler/FileSystem/Layers.pm  view on Meta::CPAN

yet another shot at tackling the problem, the initial concept is still not fully
realised, and the implementation logic is only halfway there. The current implementation
relies far too often on regular expressions. And it's internal hierarchy of figuring
out which system call should handle getting/setting a certain attribute is quite
simplistic. Also, an intended pluggable structure, in combination with the ability to
overlay same-level mounts in a unionfs/merged transparent way, is not yet there.
In sum, the efficiency of all this could be better, but at least for now, with some
of the GUI widgets compensating for or knowing about some of Layer's shortcomings,
it works. But for the record: it's a work-in-progress.

=head1 COPYRIGHT & LICENSE

 view release on metacpan or  search on metacpan

lib/Wx/DemoModules/wxOverlay.pm  view on Meta::CPAN

  my $this = $class->SUPER::new( $parent, -1 );
  $this->SetVirtualSize(  $x_size, $y_size  );
  $this->SetScrollRate( 1, 1 );
  $this->SetBackgroundColour( wxWHITE );
  $this->SetCursor( Wx::Cursor->new( wxCURSOR_PENCIL ) );
  $this->{overlay} = Wx::Overlay->new;
  
  EVT_MOTION( $this, \&OnMouseMove );
  EVT_LEFT_DOWN( $this, \&OnButton );
  EVT_LEFT_UP( $this, \&OnButton );
  EVT_PAINT( $this, \&OnPaint );

lib/Wx/DemoModules/wxOverlay.pm  view on Meta::CPAN

  return unless $event->Dragging;
  return unless($this->{START_POINT});
  
  my $dc = Wx::ClientDC->new( $this );
  my $overlaydc = Wx::DCOverlay->new($this->{overlay}, $dc);
  $overlaydc->Clear;
  
  $this->PrepareDC( $dc ); # as this is a ScrolledWindow
  
  my $pen   = Wx::Pen->new( wxBLACK, 1, wxSHORT_DASH );
  my $brush = wxTRANSPARENT_BRUSH;

lib/Wx/DemoModules/wxOverlay.pm  view on Meta::CPAN

    
      $this->Refresh(1, $clip ); # rewdraws the necessary part of underlying window
    }
    
    $this->ReleaseMouse();
    $this->{overlay}->Reset; # drops internally held pointers/refs
    
  } elsif( $event->LeftDown) {
    $this->{START_POINT} = [ $x, $y ];
    $this->CaptureMouse();
  }

 view release on metacpan or  search on metacpan

wx/msw_myglcanvas.h  view on Meta::CPAN

enum
{
  WX_GL_RGBA=1,          /* use true color palette */
  WX_GL_BUFFER_SIZE,     /* bits for buffer if not WX_GL_RGBA */
  WX_GL_LEVEL,           /* 0 for main buffer, >0 for overlay, <0 for underlay */
  WX_GL_DOUBLEBUFFER,    /* use doublebuffer */
  WX_GL_STEREO,          /* use stereoscopic display */
  WX_GL_AUX_BUFFERS,     /* number of auxiliary buffers */
  WX_GL_MIN_RED,         /* use red buffer with most bits (> MIN_RED bits) */
  WX_GL_MIN_GREEN,       /* use green buffer with most bits (> MIN_GREEN bits) */

 view release on metacpan or  search on metacpan

demo/throbber.pl  view on Meta::CPAN

    my %ctrl = (
        gauge           => $self -> find_window ('main_gauge'),
        txt_tlabel      => $self -> find_window ('main_txt_tlabel'),
        spin_framedelay => $self -> find_window ('main_spin_framedelay'),
        chk_tlabel      => $self -> find_window ('main_chk_tlabel'),
        chk_overlay     => $self -> find_window ('main_chk_overlay'),
        chk_reverse     => $self -> find_window ('main_chk_reverse'),
        btn_tlabel      => $self -> find_window ('main_btn_tlabel'),
        btn_start       => $self -> find_window ('main_btn_start'),
        btn_pause       => $self -> find_window ('main_btn_pause'),
        btn_stop        => $self -> find_window ('main_btn_stop'),

demo/throbber.pl  view on Meta::CPAN

    # Load the defaults from the controls
    foreach my $throbber ($throbber_f, $throbber_c) {
        $throbber -> SetFrameDelay  ($ctrl {spin_framedelay} -> GetValue);
        $throbber -> SetLabel       ($ctrl {txt_tlabel} -> GetValue);
        $throbber -> ShowLabel      ($ctrl {chk_tlabel} -> IsChecked);
        $throbber -> SetOverlay     (throbber_overlay());
        $throbber -> ShowOverlay    ($ctrl {chk_overlay} -> IsChecked);
        $throbber -> SetAutoReverse ($ctrl {chk_reverse} -> IsChecked);
    }

    # Button Actions
    EVT_BUTTON($self, $ctrl {btn_start},

demo/throbber.pl  view on Meta::CPAN

    EVT_CHECKBOX($self, $ctrl {chk_tlabel},
        sub {
            $throbber_f -> ShowLabel($_[1]->IsChecked);
            $throbber_c -> ShowLabel($_[1]->IsChecked);
        });
    EVT_CHECKBOX($self, $ctrl {chk_overlay},
        sub {
            $throbber_f -> ShowOverlay($_[1]->IsChecked);
            $throbber_c -> ShowOverlay($_[1]->IsChecked);
        });

demo/throbber.pl  view on Meta::CPAN

                                wxBITMAP_TYPE_PNG);
    return new Wx::Perl::Throbber($parent, -1, $bitmap, wxDefaultPosition,
                                  $size, undef, 12, 48);
}

sub throbber_overlay {
    my $bitmap_path = catfile($FindBin::RealBin, 'images');
    my $bitmap = new Wx::Bitmap(catfile($bitmap_path, 'logo.png'),
                                wxBITMAP_TYPE_PNG);
}

 view release on metacpan or  search on metacpan

wx-scintilla/src/scintilla/src/LexTeX.cxx  view on Meta::CPAN

			strcmp(s,"Topic")==0||strcmp(s,"topic")==0||
			strcmp(s,"subject")==0||strcmp(s,"subsubject")==0||
			strcmp(s,"def")==0||strcmp(s,"gdef")==0||strcmp(s,"edef")==0||
			strcmp(s,"xdef")==0||strcmp(s,"framed")==0||
			strcmp(s,"frame")==0||
			strcmp(s,"foilhead")==0||strcmp(s,"overlays")==0||strcmp(s,"slide")==0
			){
			    lev=1;
			}
	}
	return lev;

 view release on metacpan or  search on metacpan

MANIFEST  view on Meta::CPAN

t/14_eh_die.t
t/15_threads.t
t/16_stream.t
t/17_thread_evt.t
t/18_unicode.t
t/19_overlay.t
t/20_ctx_threads.t
t/21_locale.t
t/22_interface.t
t/Tests_Helper.pm
t/zz_distrib.t

 view release on metacpan or  search on metacpan

t/70-compositor.t  view on Meta::CPAN

plan skip_all => 'GLX_EXT_texture_from_pixmap not supported by server'
	unless $ext =~ /GLX_EXT_texture_from_pixmap/;

sub err(&) { my $code= shift; my $ret; { local $@= ''; eval { $code->() }; $client->flush_sync; $ret= $@; } $ret }

my ($root, $overlay, $region);
note "local Xc ver = ".X11::Xlib::XCompositeVersion." server Xc ver = ".join('.', $client->XCompositeQueryVersion);
is( err{ $root= $client->root_window }, '', 'get root window' );
note "root = ".$root->summarize;
is( err{ $client->XCompositeRedirectSubwindows($root, CompositeRedirectAutomatic) }, '', 'XCompositeRedirectSubwindows' );
is( err{ $root->event_mask_include(SubstructureNotifyMask) }, '', 'listen SubstructureNotifyMask' );
is( err{ $overlay= $client->XCompositeGetOverlayWindow($root) }, '', 'XCompositeGetOverlayWindow' );
note "overlay = ".$overlay->summarize;

#sub nullify_window_region
{
	my $rgn= $client->XFixesCreateRegion([ { x => 100, y => 100, width => 150, height => 150 } ]);
	$overlay->set_bounding_region($rgn);
	$overlay->set_input_region($rgn);
}

my @glx_fbconfig= (
	GLX_RENDER_TYPE, GLX_RGBA_BIT,
	GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,

t/70-compositor.t  view on Meta::CPAN

	GLX_DEPTH_SIZE, 16,
);
my $dwim= X11::GLX::DWIM->new(
	display => $client,
	fbconfig => \@glx_fbconfig,
	target => { window => { x => 290, y => 90, width => 32, height => 32, parent => $overlay } },
	gl_projection => {}
);
#$client->XReparentWindow($dwim->target, $overlay, 0, 0);
$dwim->target->event_mask_include(ExposureMask);
$dwim->target->set_bounding_region();
#$dwim->target->show;

my $client2;

t/70-compositor.t  view on Meta::CPAN

	my $e= $client->wait_event(timeout => 1);
	if ($e) {
		note 'event '.$e->summarize;
		if ($e->type == CreateNotify) {
			my $w= $client->get_cached_window($e->window);
			next if $w == $overlay;
			note "Window created: ".$w->summarize.sprintf(' (%X)', $w->xid);
		}
		elsif ($e->type == MapNotify) {
			my $w= $client->get_cached_window($e->window);
			next if $w == $overlay;
			note "Window mapped: ".$w->summarize.sprintf(' (%X)', $w->xid);
			$w->event_mask_include(ExposureMask);
		}
	} else {
		note int(time - $start);

 view release on metacpan or  search on metacpan

Motif/XpLinedArea.h  view on Meta::CPAN

    Dimension horizontalLineWidth;		/* row divider line width (0 = no divider) */
    Dimension verticalLineWidth;		/* column divider line width (0 = no divider) */

    Pixel foreground;				/* default foreground for column */
    Pixel background;				/* column background overlays row background */
    XFontStruct *font;				/* default font for column */

    XpLinedAreaExposeCallback doExpose;		/* user's column (cell) expose handler */
    void *doExposeClientData;			/* extra user data to pass to expose handler */
    XpLinedAreaEventCallback doEvent;		/* user's column (cell) event handler */

 view release on metacpan or  search on metacpan

devel/composite.pl  view on Meta::CPAN

    my $pixmap = $X2->new_rsrc;
    $X2->CompositeNameWindowPixmap ($window, $pixmap);
    $X2->QueryPointer($X->{'root'}); # sync
  }

  my $overlay_window = $X->CompositeGetOverlayWindow ($window);
  $X->QueryPointer($X->{'root'}); # sync
  ### overlay_window: sprintf '%X', $overlay_window

  {
    my $overlay_window = $X2->CompositeGetOverlayWindow ($window);
    $X2->QueryPointer($X2->{'root'}); # sync
    ### overlay_window: sprintf '%X', $overlay_window
  }

  $X->CompositeReleaseOverlayWindow ($overlay_window);
  $X->QueryPointer($X->{'root'}); # sync


  exit 0;
}

 view release on metacpan or  search on metacpan

t/70-xcomposite.t  view on Meta::CPAN

plan skip_all => 'Xcomposite not supported by server'
    unless $display->XCompositeQueryVersion;

sub err(&) { my $code= shift; my $ret; { local $@= ''; eval { $code->() }; $display->flush_sync; $ret= $@; } $ret }

my ($root, $overlay, $region);
note "local Xc ver = ".X11::Xlib::XCompositeVersion()." server Xc ver = ".join('.', $display->XCompositeQueryVersion);
is( err{ $root= $display->root_window }, '', 'get root window' );
note "root = $root";
is( err{ $display->XCompositeRedirectSubwindows($root, CompositeRedirectAutomatic) }, '', 'XCompositeRedirectSubwindows' );
is( err{ $display->XSelectInput($root, SubstructureNotifyMask) }, '', 'XSelectInput' );
is( err{ $overlay= $display->XCompositeGetOverlayWindow($root) }, '', 'XCompositeGetOverlayWindow' );
note "overlay = $overlay";

SKIP: {
    skip "XFixes not available", 4
        unless X11::Xlib->can('XFixesCreateRegion');
    is( err{ $region= $display->XFixesCreateRegion([]) }, '', 'XFixesCreateRegion' );
    note "region = $region";
    is( err{ $display->XFixesSetWindowShapeRegion($overlay, ShapeBounding, 0, 0, 0) }, '', 'XFixesSetWindowShapeRegion' );
    is( err{ $display->XFixesSetWindowShapeRegion($overlay, ShapeInput, 0, 0, $region) }, '', 'XFixesSetWindowShapeRegion' );
    $region->autofree(0);
    is( err{ $display->XFixesDestroyRegion($region) }, '', 'XFixesDestroyRegion' );
}

done_testing;

 view release on metacpan or  search on metacpan

lib/XAS/Docs/Collector/Installation.pm  view on Meta::CPAN

    # ./Build dist
    # rpmbuild -ta XAS-Collector-0.01.tar.gz
    # cd ~/rpmbuild/RPMS/noarch
    # yum --nogpgcheck localinstall perl-XAS-Collector-0.01-1.noarch.rpm

Each of these installation methods will overlay the local file system and
tries to follow Debian standards for file layout and package installation. 

On Windows, do the following:

    > perl Build.PL

 view release on metacpan or  search on metacpan

lib/XAS/Docs/Logmon/Installation.pm  view on Meta::CPAN

    # ./Build dist
    # rpmbuild -ta XAS-Logmon-0.01.tar.gz
    # cd ~/rpmbuild/RPMS/noarch
    # yum --nogpgcheck localinstall perl-XAS-Logmon-0.01-1.noarch.rpm

Each of these installation methods will overlay the local file system and
tries to follow Debian standards for file layout and package installation. 

On Windows, do the following:

    > perl Build.PL

 view release on metacpan or  search on metacpan

lib/XAS/Docs/Model/Installation.pm  view on Meta::CPAN

    # ./Build dist
    # rpmbuild -ta XAS-Model-0.01.tar.gz
    # cd ~/rpmbuild/RPMS/noarch
    # yum --nogpgcheck localinstall perl-XAS-Model-0.01-1.noarch.rpm

Each of these installation methods will overlay the local file system and
tries to follow Debian standards for file layout and package installation. 

On Windows, do the following:

    > perl Build.PL

 view release on metacpan or  search on metacpan

lib/XAS/Docs/Service/Installation.pm  view on Meta::CPAN

    # ./Build dist
    # rpmbuild -ta XAS-Service-0.01.tar.gz
    # cd ~/rpmbuild/RPMS/noarch
    # yum --nogpgcheck localinstall perl-XAS-Service-0.01-1.noarch.rpm

Each of these installation methods will overlay the local file system and
tries to follow Debian standards for file layout and package installation. 

On Windows, do the following:

    > perl Build.PL

 view release on metacpan or  search on metacpan

lib/XAS/Docs/Spooler/Installation.pm  view on Meta::CPAN

    # ./Build dist
    # rpmbuild -ta XAS-Spooler-0.01.tar.gz
    # cd ~/rpmbuild/RPMS/noarch
    # yum --nogpgcheck localinstall perl-XAS-Spooler-0.01-1.noarch.rpm

Each of these installation methods will overlay the local file system and
tries to follow Debian standards for file layout and package installation. 

On Windows, do the following:

    > perl Build.PL

 view release on metacpan or  search on metacpan

lib/XAS/Docs/Installation.pm  view on Meta::CPAN

    # ./Build dist
    # rpmbuild -ta XAS-0.08.tar.gz
    # cd ~/rpmbuild/RPMS/noarch
    # yum --nogpgcheck localinstall perl-XAS-0.08-1.noarch.rpm

Each of these installation methods will overlay the local file system and
tries to follow Debian standards for file layout and package installation. 

On Windows, do the following:

    > perl Build.PL

 view release on metacpan or  search on metacpan

lib/XML/LibXML/Overlay.pm  view on Meta::CPAN

  #     <title>XML in a Nutshell: A Desktop Quick Reference</title>
  #     <isbn>9780596007645</isbn>
  #   </book>
  # </catalog>

  # overlay.xml
  ####
  # <overlay>
  #   <target xpath="/catalog/book[@id='book0']/author[text()='Delete Me!']">
  #     <action type="delete" />
  #   </target>
  #   <target xpath="/catalog/book[@id='book2']">
  #     <action type="insertBefore">

lib/XML/LibXML/Overlay.pm  view on Meta::CPAN

  #           <title>Higher-Order Perl. Transforming Programs with Programs</title>
  #           <isbn>9781558607019</isbn>
  #       </book>
  #     </action>
  #   </target>
  # </overlay>

  use XML::LibXML;
  use XML::LibXML::Overlay;

  my $overlay = XML::LibXML::Overlay->load_xml(
    'location' => '/path/to/overlay.xml',
  );
  my $target = XML::LibXML->load_xml(
    'location' => '/path/to/target.xml',
  );

  $overlay->apply_to($target);

  # do whatever you want with $target

=head1 DESCRIPTION

XML::LibXML::Overlay allowes to apply overlay files to XML files. This modul is
a rewirte of XML::Overlay, but it uses plain XML::LibXML instead of the Class::XML
thru XML::Parser stack.

=head1 DETAILS

lib/XML/LibXML/Overlay.pm  view on Meta::CPAN

like XML::LibXML. The only difference is, that L</load_xml> returns a
XML::LibXML::Overlay::Document instead of a XML::LibXML::Document.

=head2 Tags

Following Tags can be used in a overlay document.

=head3 overlay

Specifies the root element, and contains any target element.

=head3 target

 view release on metacpan or  search on metacpan

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

  }
}

=head1 NAME

XML::Overlay - Apply overlays to XML documents

=head1 SYNOPSIS

  # Original XML document:
  <blub>

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

      </action>
      <action type="delete" />
    </target>
  </Overlay>

  my $o_tree = XML::Overlay->new(xml => $o_source); # Load overlay doc

  my $d_tree = Class::XML->new(xml => $d_source); # Load initial doc

  $o_tree->process($d_tree);

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

=head1 DESCRIPTION

XML::Overlay is a simple collection of Class::XML modules that provide a
mechanism somewhat inspired by Mozilla's XUL Overlays, but designed for
manipulating general XML documents. The overlay document contains one or more
B<target> elements, each with an B<xpath> attribute which specifies what nodes
of the source document should be captured and transformed; each B<target>
element contains one or more B<action> elements which specifies the action(s)
to perform on each XPath node captured by the parent.