view release on metacpan or  search on metacpan

lib/Chart/Plot/Canvas.pm  view on Meta::CPAN

  $self->{'_black'} = $self->{'_im'}->colorAllocate(0,0,0);
  $self->{'_red'} = $self->{'_im'}->colorAllocate(255,0,0);
  $self->{'_blue'} = $self->{'_im'}->colorAllocate(0,0,255);
  $self->{'_green'} = $self->{'_im'}->colorAllocate(0,255,0);

  # make the background transparent and interlaced
  $self->{'_im'}->transparent($self->{'_white'});
  $self->{'_im'}->interlaced('true');

  # Put a black frame around the picture
  $self->{'_im'}->rectangle( 0, 0,
                             $self->{'_imx'}-1, $self->{'_imy'}-1,

 view release on metacpan or  search on metacpan

lib/Chart/Plotly/Trace/Bar/Marker/Pattern.pm  view on Meta::CPAN

has bgcolor => (
    is            => "rw",
    isa           => "Str|ArrayRef[Str]",
    documentation =>
      "When there is no colorscale sets the color of background pattern fill. Defaults to a `marker.color` background when `fillmode` is *overlay*. Otherwise, defaults to a transparent background.",
);

has bgcolorsrc => ( is            => "rw",
                    isa           => "Str",
                    documentation => "Sets the source reference on Chart Studio Cloud for `bgcolor`.",

lib/Chart/Plotly/Trace/Bar/Marker/Pattern.pm  view on Meta::CPAN

=over

=item * bgcolor

When there is no colorscale sets the color of background pattern fill. Defaults to a `marker.color` background when `fillmode` is *overlay*. Otherwise, defaults to a transparent background.

=item * bgcolorsrc

Sets the source reference on Chart Studio Cloud for `bgcolor`.

 view release on metacpan or  search on metacpan

Strip.pm  view on Meta::CPAN

=item C<draw_data_labels>

Should each data set be labeled?

=item C<transparent>

Should the background be transparent?

=item C<grid_on_top>

Should the grid be drawn over the data (1) or below the data (0)?

Strip.pm  view on Meta::CPAN

	margin_bottom => 8,
	margin_right  => 8,
	margin_top    => 8,
	n_y_tics      => 4, # aprox.

	transparent      => 1,
	grid_on_top      => 1,
	draw_grid        => 1,
	draw_border      => 1,
	draw_tic_labels  => 1,
	draw_data_labels => 1,

Strip.pm  view on Meta::CPAN

    # style for grid lines
    $im->setStyle(gdTransparent, $me->{color}{gray}, gdTransparent, gdTransparent);

    $im->interlaced('true');
    $im->transparent($me->{color}{white})
	if $me->{transparent};

    $im->filledRectangle( 0, 0, $me->{width}-1, $me->{height}-1, ($bkg || $me->{color}{white}));

    my $bc = $me->{border_color} ? $me->img_color($me->{border_color}) : $me->{color}{black};

 view release on metacpan or  search on metacpan

lib/Chart/ThreeD/Pie.pm  view on Meta::CPAN

  $self->{title} = shift || '';
  $self->{data}  = [];
  $self->{bgcolor} = '#FFFFFF';
  $self->{fgcolor} = '#000000';
  $self->{limit} = [ 7, '#FF0000', 'others' ];
  $self->{transparent} = 0;
  $self->{interlaced} = 0;
  $self->{thickness} = 30; # pixels
  $self->{radius} = $self->{xmax} / 3;
  $self->{want_sort} = 0;
  $self->{border} = 0;

lib/Chart/ThreeD/Pie.pm  view on Meta::CPAN

  my $arg  = shift;
  $self->{want_sort} = $arg if defined $arg;
  return $self->{want_sort};
}

=item C<transparent>

C<Chart::ThreeD::Pie::transparent(bool)> I<object method>

This will allow you to make the background of the final picture transparent
if bool is non-null. The current value is returned. Default is null;

Example:

      # Background will be transparent.
      $pie->transparent(1);

=cut

sub transparent {
  my $self = shift;
  my $arg  = shift;
  $self->{transparent} = $arg if defined $arg;
  return $self->{transparent};
}

=item C<interlaced>

C<Chart::ThreeD::Pie::interlaced(bool)> I<object method>

lib/Chart/ThreeD/Pie.pm  view on Meta::CPAN

  my $fontw = gdSmallFont->width;
  my $fonth = gdSmallFont->height;

  my $bgcolor = $pie->colorAllocate (&cvtcolor ($self->bgcolor));
  $pie->transparent ($bgcolor) if $self->transparent;
  $pie->fill (0, 0, $bgcolor);
  my $total = 0;
  map { $total += $$_[0] } @{$self->{data}};

  my $fgcolor = $pie->colorAllocate (&cvtcolor ($self->fgcolor));

 view release on metacpan or  search on metacpan

public/themes/dark/dark.css  view on Meta::CPAN

  line-height: 22px;
  margin: 0;
  padding: 3px 0 3px 8px; 
}
#drupalchat .subpanel li a:hover {
	background: transparent;
	text-decoration: none;
}
#drupalchat .subpanel li.status-1 a {
	background: url(images/online.png) no-repeat 95% center;
}

 view release on metacpan or  search on metacpan

lib/Chemistry/File.pm  view on Meta::CPAN

assumed to be compressed; otherwise it is possible to force decompression by
passing the gzip => 1 option (or no decompression with gzip => 0).

=cut

# slurp a file into a scalar, with transparent decompression
sub slurp {
    my ($self) = @_;

    my $fh = $self->fh;
    local $/; 

lib/Chemistry/File.pm  view on Meta::CPAN

=over 

=item $self->open($mode) 

Opens the file (held in $self->file) for reading by default, or for writing if
$mode eq '>'. This method sets $self->fh transparently regardless of whether
$self->file is a filename (compressed or not), a scalar reference, or a
filehandle.

=cut

 view release on metacpan or  search on metacpan

lib/Cisco/UCS.pm  view on Meta::CPAN

Creates a connection to the XML API interface of a USCM management instance.  
If sucessful, the attributes of the UCSM management instance are inherited by 
the object.  Most important of these parameters is 'cookie' representing the 
authetication token that uniquely identifies the connection and which is 
subsequently passed transparently on all further communications.

The default time-out value for a token is 10 minutes, therefore if you intend 
to create a long-running session you should periodically call refresh.

=head3 refresh ()

 view release on metacpan or  search on metacpan

lib/Clarion.pm  view on Meta::CPAN

=head1 DESCRIPTION

This is a perl module to access CLARION 2.1 files.
At the moment only read access to the files is implemented.
"Encrypted" (owned) files are processed transparently,
there is no need to specify the password of a file.

=head1 SYNOPSIS

	use Clarion;

lib/Clarion.pm  view on Meta::CPAN

=item $h=new Clarion ["file.dat" [, 1]]

Create object for reading Clarion file. If file name is specified then
associate the DAT file with the object. "Encrypted" files are processed 
transparently, you do not need to specify the password of a file.

If the third argument (skipMemo) specified, memo field will not be 
processed at all.

=cut

 view release on metacpan or  search on metacpan

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

=head1 DESCRIPTION

This class works closely with L<Class::AutoClass> to provide almost
transparent object persistence that can coexist with a
human-engineered database. The auto-persistence mechanism provides
hooks for connecting the two parts of the database together.

B<Caveat>: The current version only works with MySQL.

 view release on metacpan or  search on metacpan

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

}

use Carp;

# The create_contained_objects() method lets one object
# (e.g. Compiler) transparently create another (e.g. Lexer) by passing
# creator parameters through to the created object.
#
# Any auto-created objects should be declared in a class's
# %CONTAINED_OBJECTS hash.  The keys of this hash are objects which
# can be created and the values are the default classes to use.

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

__END__

=head1 NAME

Class::Container - Glues object frameworks together transparently

=head1 VERSION

version 0.13

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

=head1 DESCRIPTION

This class facilitates building frameworks of several classes that
inter-operate.  It was first designed and built for C<HTML::Mason>, in
which the Compiler, Lexer, Interpreter, Resolver, Component, Buffer,
and several other objects must create each other transparently,
passing the appropriate parameters to the right class, possibly
substituting other subclasses for any of these objects.

The main features of C<Class::Container> are:

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

that needs them

=item *

Ability to create one (automatic) or many (manual) contained
objects automatically and transparently

=back

=head2 Scenario

 view release on metacpan or  search on metacpan

lib/Class/DBI/Cacheable.pm  view on Meta::CPAN

    use base 'Class::DBI::Cacheable';
    __PACKAGE__->set_db( Main => 'dbi:Pg:dbname=database', 'username', 'password' );

=head1 DESCRIPTION

Class::DBI::Cacheable transparently acts as a cacheing wrapper around L<Class::DBI>, storing
retrieved and created data in a local object cache, and returning data out of the cache
wherever possible.

Intended for better performance of L<Class::DBI>-based applications, this can prevent unnecessary
database queries by using previously-retrieved object data rather than having to go to the

 view release on metacpan or  search on metacpan

Todo  view on Meta::CPAN

to do list for Perl extension Class::DBI::Factory.

* Handler base class that works transparently with mod_perls 1 and 2

* Authentication base class

* Independence from libapreq

 view release on metacpan or  search on metacpan

lib/Class/DBI/FormBuilder.pm  view on Meta::CPAN

                          'LIKE', 'NOT LIKE', 'REGEXP', 'NOT REGEXP',
                          'REGEXP BINARY', 'NOT REGEXP BINARY',
                          ) ]
    

Or, transparently set the search operator in a hidden field:

    search_opt_cmp => 'LIKE'
    
=item search_opt_order_by

 view release on metacpan or  search on metacpan

README  view on Meta::CPAN

Class-DBI-Relationship-IsA version 0.05
=======================================

Class::DBI::Relationship::IsA Provides an Is A relationship between Class::DBI classes.
This should DTRT when you specify an IsA relationship between classes transparently.
For more information See Class::DBI and Class::DBI::Relationship. 

This module is currently a proof of concept and may not work as intended, we would warn you
to treat it as experimental.

 view release on metacpan or  search on metacpan

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

single object you'd need. So, might_have() does this work for you. It
creates an accessor to fetch the single object back if it exists, and
it also allows you import any of its methods into your namespace. So,
in the example above, the LinerNotes class can be mostly invisible -
you can just call $cd->notes and it will call the notes method on the
correct LinerNotes object transparently for you.

Making sure you don't have namespace clashes is up to you, as is correctly
creating the objects, but this may be made simpler in later versions.
(Particularly if someone asks for this!)

 view release on metacpan or  search on metacpan

Delegate.pm  view on Meta::CPAN

    $self->do_something_that_b_knows_how_to_do();
    $self->do_something_that_a_knows_how_to_do();

=head1 DESCRIPTION

This class provides transparent support for object delegation.  For more
information on delegation, see B<Design Patterns> by Erich Gamma, et al.

=cut

use strict;

 view release on metacpan or  search on metacpan

contrib/vim/syntax/perl.vim  view on Meta::CPAN

endif

" File Descriptors
syn match  perlFiledescRead	"[<]\h\w\+[>]"

syn match  perlFiledescStatementComma	"(\=\s*\u\w*\s*,"me=e-1 transparent contained contains=perlFiledescStatement
syn match  perlFiledescStatementNocomma "(\=\s*\u\w*\s*[^, \t]"me=e-1 transparent contained contains=perlFiledescStatement

syn match  perlFiledescStatement	"\u\w*" contained

" Special characters in strings and matches
syn match  perlSpecialString	"\\\(\d\+\|[xX]\x\+\|c\u\|.\)" contained

contrib/vim/syntax/perl.vim  view on Meta::CPAN

syn match  perlString "\<\I\i*\s*=>"me=e-2

" Strings and q, qq, qw and qr expressions

" Brackets in qq()
syn region perlBrackets	start=+(+ end=+)+ contained transparent contains=perlBrackets,@perlStringSQ

syn region perlStringUnexpanded	matchgroup=perlStringStartEnd start="'" end="'" contains=@perlInterpSQ
syn region perlString		matchgroup=perlStringStartEnd start=+"+  end=+"+ contains=@perlInterpDQ
syn region perlQQ		matchgroup=perlStringStartEnd start=+\<q#+ end=+#+ contains=@perlInterpSQ
syn region perlQQ		matchgroup=perlStringStartEnd start=+\<q|+ end=+|+ contains=@perlInterpSQ

contrib/vim/syntax/perl.vim  view on Meta::CPAN

    syn region perlHereDoc	matchgroup=perlStringStartEnd start=+<<\s*""+           end=+^$+    contains=@perlInterpDQ,perlNotEmptyLine
    syn region perlHereDoc	matchgroup=perlStringStartEnd start=+<<\s*''+           end=+^$+    contains=@perlInterpSQ,perlNotEmptyLine
    syn region perlAutoload	matchgroup=perlStringStartEnd start=+<<\(['"]\|\)\z(END_\(SUB\|OF_FUNC\|OF_AUTOLOAD\)\)\1+ end=+^\z1$+ contains=ALL
  endif
else
  syn match perlUntilEOFStart	"<<EOF.*"lc=5 nextgroup=perlUntilEOFDQ skipnl transparent
  syn match perlUntilEOFStart	"<<\s*\"EOF\".*" nextgroup=perlUntilEOFDQ skipnl transparent
  syn match perlUntilEOFStart	"<<\s*'EOF'.*" nextgroup=perlUntilEOFSQ skipnl transparent
  syn match perlUntilEOFStart	"<<\s*\"\".*" nextgroup=perlUntilEmptyDQ skipnl transparent
  syn match perlUntilEOFStart	"<<\s*''.*" nextgroup=perlUntilEmptySQ skipnl transparent
  syn region perlUntilEOFDQ	matchgroup=perlStringStartEnd start=++ end="^EOF$" contains=@perlInterpDQ contained
  syn region perlUntilEOFSQ	matchgroup=perlStringStartEnd start=++ end="^EOF$" contains=@perlInterpSQ contained
  syn region perlUntilEmptySQ	matchgroup=perlStringStartEnd start=++ end="^$" contains=@perlInterpDQ,perlNotEmptyLine contained
  syn region perlUntilEmptyDQ	matchgroup=perlStringStartEnd start=++ end="^$" contains=@perlInterpSQ,perlNotEmptyLine contained
  syn match perlHereIdentifier	"<<EOF"

contrib/vim/syntax/perl.vim  view on Meta::CPAN

"
" Folding

if exists("perl_fold")
  if !exists("perl_nofold_packages")
    syn region perlPackageFold start="^package \S\+;\s*\(#.*\)\=$" end="^1;\s*\(#.*\)\=$" end="\n\+package"me=s-1 transparent fold keepend
  endif
  if !exists("perl_nofold_subs")
    syn region perlSubFold     start="^\z(\s*\)\<sub\>.*[^};]$" end="^\z1}\s*\(#.*\)\=$" transparent fold keepend
    syn region perlSubFold start="^\z(\s*\)\<\(BEGIN\|END\|CHECK\|INIT\)\>.*[^};]$" end="^\z1}\s*$" transparent fold keepend
  endif

  if exists("perl_fold_blocks")
    syn region perlBlockFold start="^\z(\s*\)\(if\|elsif\|unless\|for\|while\|until\)\s*(.*)\(\s*{\)\=\s*\(#.*\)\=$" start="^\z(\s*\)foreach\s*\(\(my\|our\)\=\s*\S\+\s*\)\=(.*)\(\s*{\)\=\s*\(#.*\)\=$" end="^\z1}\s*;\=\(#.*\)\=$" transparent fold keep...
    syn region perlBlockFold start="^\z(\s*\)\(do\|else\)\(\s*{\)\=\s*\(#.*\)\=$" end="^\z1}\s*while" end="^\z1}\s*;\=\(#.*\)\=$" transparent fold keepend
  endif

  setlocal foldmethod=syntax
  syn sync fromstart
else

 view release on metacpan or  search on metacpan

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

Ever ran into the problem that you want to subclass an existing class B<and>
add extra attributes to that class?  And run into the problem of having to
know the internal representation of that class in order to be able to do so?
Look no further, this module is (at least a large part) of the solution.

This module makes it possible to transparently add attributes to an existing
class (usually a subclass of a standard class) without interfering with the
functionality of that class.  This functionality is based on the L<OOB> class
which allows attributes to be added to any Perl data-structure.

Of course, this only applies to extra attributes on instantiated objects.

 view release on metacpan or  search on metacpan

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

package Class::Generate::Class_Holder;    # This package encapsulates functions
$Class::Generate::Class_Holder::VERSION = '1.18';
use strict;    # related to storing and retrieving
               # information on classes.  It lets classes
               # saved in files be reused transparently.
my %classes;

sub store($)
{    # Given a class, store it so it's
    my $class = $_[0];                    # accessible in future invocations of

 view release on metacpan or  search on metacpan

MakeMethods/Emulator/AccessorFast.pm  view on Meta::CPAN

You may use it directly, as shown in the SYNOPSIS above, 

Furthermore, you may call  C<use Class::MakeMethods::Emulator::AccessorFast
'-take_namespace';> to alias the Class::Accessor::Fast namespace
to this package, and subsequent calls to the original package will
be transparently handled by this emulator. To remove the emulation
aliasing, call C<use Class::MakeMethods::Emulator::AccessorFast
'-release_namespace'>.

B<Caution:> This affects B<all> subsequent uses of Class::Accessor::Fast
in your program, including those in other modules, and might cause

 view release on metacpan or  search on metacpan

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

=head1 DESCRIPTION

This package is for everybody who wants to program oo-perl and does not really feel comfortable with the common way. Class::Maker introduces the concept of classes via a "class" function. It automatically creates packages, ISA, new and attribute-hand...

Reflection is transparently implemented and allows one to inspect the class properties and methods during runtime. This is  helpfull for implementing persistance and serialization. A Tangram (see cpan) schema generator is included to the package, so ...

=head1 INTRODUCTION

When you want to program oo-perl, mostly you suffer under the flexibility of perl. It is so flexibel, you have to do alot by hand. Here an example (slightly modified) from perltoot perl documentation for demonstration:

 view release on metacpan or  search on metacpan

lib/Class/Persist/Proxy.pm  view on Meta::CPAN

  
=head1 DESCRIPTION

  Framework to replace objects in the DB by Proxy objects.
  This allows delayed loading of objects.
  A proxy acts as the real object itself, it should be transparent.
  When a method is called on the proxy, the real object is loaded in place of the proxy.
  If owner() is defined, it will autoload the object based on owner id, 
  otherwise it will load the object based on real_id.

=head1 INHERITANCE

 view release on metacpan or  search on metacpan

docs/class-stl-containers.pdf  view on Meta::CPAN

/F22 10 Tf
0.5106 Tw
(glue) Tj
/F20 10 Tf
0.5106 Tw
( to transparently generate common functions, and will enable you to put your Perl) Tj
1 0 0 1 76.0 280.2 Tm
0.0000 Tw
(application together very quickly. 
 ) Tj
/F20 10 Tf
1 0 0 1 76.0 256.2 Tm

 view release on metacpan or  search on metacpan

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

    return bless $self , $class ;
}

=head2 isa

Overrides the UNIVERSAL::isa method to allow client code to transparently call isa method
on balanced resources.

Usage:
    if ( $this->isa('Class::TLB::Dummy')){
        ...

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

    return UNIVERSAL::isa($o , @_ );
}

=head2 can

Overrides the UNIVERSAL::can method to allow client code to transparently call can method
on balanced resources.

Usage:
    if ( $this->can('doSomething')){
        ...

 view release on metacpan or  search on metacpan

lib/Tie/InsideOut.pm  view on Meta::CPAN

An alternative namespace can be specified, if needed:

  tie %hash, 'Tie::InsideOut', 'Other::Class';

This gives a convenient way to restrict valid hash keys, as well as provide a
transparent implementation of inside-out objects, as with L<Class::Tie::InsideOut>.

This package also tracks which keys were set, and attempts to delete keys when an
object is destroyed so as to conserve resources. (Whether the overhead in tracking
used keys outweighs the savings is yet to be determined.)

 view release on metacpan or  search on metacpan

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

L<Moose> and L<Moo> are both excellent OO frameworks.  Moose offers a powerful
meta-object protocol (MOP), but is slow to start up and has about 30 non-core
dependencies including XS modules.  Moo is faster to start up and has about 10
pure Perl dependencies but provides no true MOP, relying instead on its ability
to transparently upgrade Moo to Moose when Moose's full feature set is
required.

By contrast, Class::Tiny has no MOP and has B<zero> non-core dependencies for
Perls in the L<support window|perlpolicy>.  It has far less code, less
complexity and no learning curve. If you don't need or can't afford what Moo or

 view release on metacpan or  search on metacpan

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

Its name is not important to Class::TransparentFactory, but let's call
it C<ProviderOne> here. The old namespace by which the implementation
was known we will call C<Facade>.

=item Declare C<Facade> as a transparent factory.

See I<import> below for details. For a typical OOPish module with no
special class methods, this will suffice:

  package Facade;

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

=head1 FUNCTIONS

=head2 import

The import directive is your declarative way of specifying which class
methods belong to the transparently facaded API. Supply a simple list of
names. Instance methods need not be specified here, since subsequent
method dispatches on objects created by provider classes will presumably
go to the correct place directly.

=cut

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

Gaal Yahas, C<< <gaal at forum2.org> >>

=head1 BUGS

Please report any bugs or feature requests to
C<bug-class-transparentfactory at rt.cpan.org>, or through the web interface at
L<http://rt.cpan.org/NoAuth/ReportBug.html?Queue=Class-TransparentFactory>.
I will be notified, and then you'll automatically be notified of progress on
your bug as I make changes.

=head1 SUPPORT

 view release on metacpan or  search on metacpan

SUMMARY.T0045  view on Meta::CPAN

<html><body> This Perl module makes the use of clearprompt(1) both
simpler and more portable between UNIX and Windows.  It handles UNIX/NT
quoting and path issues transparently, manages creation, reading, and
deletion of temp files in text/list/file modes, manages trigger series
prompting, allows capture of messages to dialog boxes and/or email, and
adds a clearprompt_dir() function to prompt for a directory.  Note: a
newer version may be present at
<a href="http://www.perl.com/CPAN-local/modules/by-module/IPC/DSB/">

 view release on metacpan or  search on metacpan

MGi.pm  view on Meta::CPAN

    return 1;
  }
  $CT = ClearCase::Argv->new({autochomp=>0});
  my $lsv = $CT->lsview([qw(-l -prop -full)], $mkv->flagWRAPPER('clone'))->qx;
  return 1 unless $lsv;
  my %tm = (unix=>'transparent', msdos=>'insert_cr', strip_cr=>'strip_cr');
  my ($tmo, @prop) = ($tm{$1}, split /\s+/, $2)
    if $lsv =~ /Text mode: (.*?)\n.*Properties: (.*?)\n/s;
  die Msg('E', 'Snapshot views not supported for cloning!')
    if grep /^snapshot$/, @prop or $mkv->flagCC('snapshot');
  my @nsup = grep !/(dynamic|shareable_dos|readwrite|readonly)$/, @prop;

 view release on metacpan or  search on metacpan

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

  clear: both;
}

.hide-text {
  font: 0/0 a;
  color: transparent;
  text-shadow: none;
  background-color: transparent;
  border: 0;
}

.input-block-level {
  display: block;

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

    display: none;
    float: none;
    max-width: none;
    padding: 0;
    margin: 0 15px;
    background-color: transparent;
    border: none;
    -webkit-border-radius: 0;
       -moz-border-radius: 0;
            border-radius: 0;
    -webkit-box-shadow: none;