view release on metacpan or  search on metacpan

lib/CGI/Builder/TT2.pm  view on Meta::CPAN

    qw| CGI::Builder::TT2
      |;

=head1 DESCRIPTION

This module transparently integrates C<CGI::Builder> and C<Template> in
a very handy, powerful and flexible framework that can save you a lot of
coding, time and resources.

With this module, you don't need to produce the C<page_content> within
your page handlers anymore (unless you want to); you don't even need to

lib/CGI/Builder/TT2.pm  view on Meta::CPAN

output

=back

You can save all that by just including this module in your build,
because it implements an internal transparent and automatic template
system that even without your explicit intervention is capable of
finding the correct template and the correct runtime values to fill it,
and generates the page_content automagically. With this module you can
even eliminate the page handlers that are just setting the page_content,
because the page is automatically sent by the template system.

 view release on metacpan or  search on metacpan

CHANGES  view on Meta::CPAN

1.01  Mon Oct  2 18:18:25 EDT 2000
- Maintenance handed over to David Coppit <david@coppit.org>. All
  changes in this version are made by him.
- Underlying caching is now handled by File::Cache. This allows for extra
  features such as cache maximum sizes, transparent cache entry expiration,
  etc.
- The cache key can now be any data structure instead of just a simple
  string. This means that one can just hand the CGI parameters directly to
  CGI::Cache and it will figure out a suitable stringified cache key.
- Because File::Cache now does most of the cache management automatically,

 view release on metacpan or  search on metacpan

lib/CGI/Compress/Gzip.pm  view on Meta::CPAN

chooses HTML output, apply gzip compression on any content header for
STDOUT.  This module is intended to be a drop-in replacement for
CGI.pm.

Apache mod_perl users may wish to consider the Apache::Compress or
Apache::GzipChain modules, which allow more transparent output
compression than this module can provide.  However, as of this writing
those modules are more aggressive about compressing, regardless of
Content-Type.

=head2 Headers

 view release on metacpan or  search on metacpan

lib/CGI/FormBuilder.pm  view on Meta::CPAN

        # and storing them into a temp hash, and then going thru
        # the fields and picking up the values and attributes.
        local $" = ',';
        debug 1, "\$form->{values} = ($self->{values})";

        # Using isa() allows objects to transparently fit in here
        if (UNIVERSAL::isa($self->{values}, 'CODE')) {
            # it's a sub; lookup each value in turn
            for my $key (&{$self->{values}}) {
                # always assume an arrayref of values...
                $val{$key} = [ &{$self->{values}}($key) ];

 view release on metacpan or  search on metacpan

scripts/generate_index.pl  view on Meta::CPAN

    margin-bottom: 4px;
}

/* Ensure the test code block inherits readable colors */
.suggested-test pre {
    background: transparent;   /* Prevent nested dark blocks */
    color: inherit;            /* Match theme text color */
    margin: 0;
    font-family: monospace;
}

 view release on metacpan or  search on metacpan

lib/CGI/Inspect/htdocs/js/jquery.ui.all.js  view on Meta::CPAN

 * Copyright (c) 2009 AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT (MIT-LICENSE.txt)
 * and GPL (GPL-LICENSE.txt) licenses.
 *
 * http://docs.jquery.com/UI/Effects/
 */
jQuery.effects||(function(d){d.effects={version:"1.7.1",save:function(g,h){for(var f=0;f<h.length;f++){if(h[f]!==null){g.data("ec.storage."+h[f],g[0].style[h[f]])}}},restore:function(g,h){for(var f=0;f<h.length;f++){if(h[f]!==null){g.css(h[f],g.d...
 * jQuery UI Effects Blind 1.7.1
 *
 * Copyright (c) 2009 AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT (MIT-LICENSE.txt)
 * and GPL (GPL-LICENSE.txt) licenses.

 view release on metacpan or  search on metacpan

lib/CGI/Lazy.pm  view on Meta::CPAN

Lazy has also been written to be useful in a mod_perl environment if that is your pleasure.  The wonders of persistence and namespaces have been (again, hopefully) all accounted for.  It should plug into your mod_perl environment with little or no fu...

For the most part, CGI::Lazy is simply a subclass of CGI::Pretty, which is an easier to read version of CGI.pm. 

We need to use CGI::Pretty due to a css issue in IE where the style definitions aren't always followed unless there is the appropriate amount of whitespace between html tags.  Luckilly, CGI::Pretty takes care of this pretty transparently, and its out...

CGI::Lazy adds a bunch of hooks in the interest of not working any harder than we need to, otherwise it's a CGI::Pretty object.

Probably 80% of the apps the author has been asked to write have been front ends to some sort of database, so that's definitely the angle Lazy is coming from.  It works just fine with no db, but most of the fancy work is unavailable.

Output to the web is intended to be through templates via HTML::Template.  However, if you want to write your content into the code manually, we won't stop you.  Again, the whole point was to be flexible and reusable, and to spend our time writing ne...

The CGI::Lazy::Widget::Dataset module especially was written to bring spreadsheet-like access to a database table to the web in a fairly transparent manner- after all, most of the time you're doing one of 4 operations on a database: select, insert, u...

In any event, it is my hope that this is useful to you.  It has saved me quite alot of work.  I hope that it can do the same for you.  Bug reports and comments are always welcome.

=head1 METHODS

 view release on metacpan or  search on metacpan

MxScreen/Serializer/Storable.pm  view on Meta::CPAN

Whether to compress the serialized form before returning it.
Data will be uncompressed on-the-fly by the C<deserialize> routine.
It is I<false> by default.

This makes compression transparent once configured.

=item C<-shared> => I<flag>

Whether serialized data are expected to be shared across different
architectures.  When I<true>, C<Storable> will use its portable format

 view release on metacpan or  search on metacpan

lib/CGI/OptimalQuery/InteractiveQuery.pm  view on Meta::CPAN

.OQaddColButton, .OQsortAscButton, .OQsortDescButton, .OQfilterCol, .OQcloseButton{
  width: 15px; height: 16px; margin: 0; margin-right: 8px !important; padding: 0;
  border: 0 !important; text-indent: -1000em;
} 

.OQaddColButton { background: transparent url(/OptimalQuery/add.gif) no-repeat center top; }
.OQsortAscButton { background: transparent url(/OptimalQuery/sortDown.gif) no-repeat center top; }
.OQsortDescButton { background: transparent url(/OptimalQuery/sortUp.gif) no-repeat center top; }
.OQfilterCol { background: transparent url(/OptimalQuery/filter.gif) no-repeat center top; }
.OQcloseButton { background: transparent url(/OptimalQuery/close.gif) no-repeat center top; }

#cmdOptions {
  margin-top: 10px;
  position: absolute;
  width: 20em;

 view release on metacpan or  search on metacpan

lib/CGI/Persistent.pm  view on Meta::CPAN

CGI::Persistent solves this problem by introducing persistent CGI sessions
that store their state data on the server side. When a new session starts,
CGI::Persistent automatically generates a unique state identification string
and associates it with a persistent object on the server. The identification
string is used in URLs or forms to refer to the particular session. Request
attributes are transparently committed to the associated object and the
object data is bound to the query.

CGI::Persistent is derived from CGI.pm. CGI.pm methods have been overridden
as appropriate. Very few new methods have been added.  

 view release on metacpan or  search on metacpan

demos/image/DemoDrawImage.pm  view on Meta::CPAN

		my $white = $im->colorAllocate(255,255,255);
		my $black = $im->colorAllocate(0,0,0);   
		my $red = $im->colorAllocate(255,0,0);  
		my $blue = $im->colorAllocate(0,0,255);

		# make the background transparent and interlaced
		$im->transparent($white);
		$im->interlaced('true');

		# Put a black frame around the picture
		$im->rectangle(0,0,99,99,$black);

 view release on metacpan or  search on metacpan

lib/CGI/PrintWrapper.pm  view on Meta::CPAN

above).  As the caller invokes B<CGI> methods, C<AUTOLOAD> creates
anonymous subroutines to perform the actual B<CGI> method call
indirection and print the results with the print handle object.  It
also updates the symbol table for B<CGI::PrintWrapper> so that future
calls can bypass C<AUTOLOAD>.  This makes a B<CGI::PrintWrapper>
object transparently a B<CGI> object, usable as a drop-in replacement.

=back

=head1 SEE ALSO

 view release on metacpan or  search on metacpan

lib/CGI/ProgressBar.pm  view on Meta::CPAN

	.pblib_block_on  { border:1px solid blue;  background: navy; }
	";
	if ($self->{progress_bar}->{label}){
		$CSS .=".pblib_number {
		text-align: right;
		border: 1px solid transparent;
		}";
	}
	$self->{progress_bar}->{css} = $CSS;
}

 view release on metacpan or  search on metacpan

lib/CGI/Screen.pm  view on Meta::CPAN

    my $h     = GD::Font->$font()->height;
    my $im    = GD::Image->new((length($query->param('foo'))+2)*$w,$h);
    my $white = $im->colorAllocate(255,255,255);
    my $red   = $im->colorAllocate(255,0,0);
    my $black = $im->colorAllocate(0,0,0);
    $im->transparent($white);
    $im->arc(8,8,5,5,0,360,$red);
    $im->string(GD::Font->$font(),10,0,$query->param('foo'),$black);
    print $im->gif;
  }

 view release on metacpan or  search on metacpan

README  view on Meta::CPAN

realize that all your scripts have nasty warnings at the top.  Perhaps yours
are more relaxed than that, but now that I have your attention, read the
documentation anyway as it contains important updates.


CGI::SecureState is a module that provides a transparent and secure way to
maintain state between HTTP requests.  It was originally written to resemble
CGI::Persistent as closely as possible.  To install CGI::SecureState, all you
should have to do is the standard

% perl Makefile.PL

 view release on metacpan or  search on metacpan

lib/CGI/Session/Tutorial.pm  view on Meta::CPAN

User will not have sensitive data stored in his/her computer in unsecured file (which is a cookie file).

=item *

It's possible to handle very big and even complex data structures transparently (which I<HTTP Cookies> do not handle).

=back

That's what CGI::Session is all about - implementing server side session management. Now is a good time to get feet wet.

=head1 PROGRAMMING STYLE

Server side session management system might be seeming awfully convoluted if you have never dealt with it. Fortunately, with L<CGI::Session|CGI::Session> all the complexity is handled by the library transparently. This section of the manual can be tr...

All applications making use of server side session management rely on the following pattern of operation regardless of the way the system is implemented:

=over 4

 view release on metacpan or  search on metacpan

lib/CGI/Uploader/Transform/ImageMagick.pm  view on Meta::CPAN

        $orig_filename = $p{filename};
    }
    # we have the old ugly style API
    else {
        ($orig_filename, $params) = validate_pos(@_,1,{ type => ARRAYREF });
        # validate handles a hash or hashref transparently
        %p = validate(@$params,{
                w => { type => SCALAR | UNDEF, regex => qr/^\d*$/, optional => 1, },
                h => { type => SCALAR | UNDEF, regex => qr/^\d*$/, optional => 1 },
            });
    }

 view release on metacpan or  search on metacpan

WebOut.pm  view on Meta::CPAN

    if (!$Redirected) {
      push(@Headers, "Content-type: $ContType");
      my $headers = join("\n",@Headers)."\n\n";
      # Prepend the output buffer with headers data.
      # So we output the buffer and headers in ONE print call (it is 
      # more transparent for calling code if it ties STDOUT by himself).
      $$rRootBuf = $headers.$$rRootBuf;
    } else {
      # Only headers should be sent. 
      my $headers = join("\n",@Headers)."\n\n";
      _RealPrint($headers);

WebOut.pm  view on Meta::CPAN

  #CGI::WebOut::Flush();
  $this->parentCall(sub { return fileno(*{$this->{handle}}) });
  return 0;
}

# Untie process is fully transparent for parent. For example, code:
#   tie(*STDOUT, "T1");
#   eval "use CGI::WebOut"; #***
#   print "OK!";
#   untie(*STDOUT);
# generates EXACTLY the same sequence of call to T1 class, as this 

 view release on metacpan or  search on metacpan

t/private/styles/reset.css  view on Meta::CPAN

html,body,div,span,applet,object,iframe,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abbr,acronym,address,big,cite,code,del,dfn,em,font,img,ins,kbd,q,s,samp,small,strike,strong,sub,sup,tt,var,b,u,i,center,dl,dt,dd,ol,ul,li,fieldset,form,label,legend,table,ca...

 view release on metacpan or  search on metacpan

lib/CGI/Widget/Tabs/Heading.pm  view on Meta::CPAN

In contrast to the use of key/value pairs, CGI::Widget::Tabs knows that this
is a key and not a value. After all, you are using the key() method, right?
Consequently you don't need the prepend the key with a hyphen ("-"). You may
consider using a hyphen for your keys nevertheless. It will lead to more
transparent code. Observe how the snippet from above with a prepended "-"
will later on result in the following check:

    if ( $tab->active eq "-rc" ) {  # clearly we are using keys ....

Consider this a mild suggestion.

 view release on metacpan or  search on metacpan

lib/CGI/Wiki/Store/Mediawiki.pm  view on Meta::CPAN

Implementation of L<CGI::Wiki::Store::Database> which reads and writes to a
Mediawiki 1.6 database running in MySQL.

All date and time values are returned as L<Time::Piece::Adaptive> objects.
This should be transparent for most uses.

See L<CGI::Wiki::Store::Database> for more.

=cut

 view release on metacpan or  search on metacpan

XMLApplication.pm  view on Meta::CPAN

such as I<param()>.

CGI::XMLApplication, intended to be an application class should make
writing of XML enabled CGI scripts more easy. Especially because of
the use of object orientated concepts, this class enables much more
transparent implemententations with complex functionality compared to
what is possible with standard CGI-scripts.

The main difference with common perl CGI implementation is the fact,
that the client-output is not done from perl functions, but generated
by an internally build XML DOM that gets processed with an XSLT

XMLApplication.pm  view on Meta::CPAN

=item method run

Being the main routine this should be the only method called by the
script apart from the constructor. All events are handled inside the
method B<run()>.  Since this method is extremly simple and transparent
to any kind of display type, there should be no need to override this
function. One can pass a context hash or context object, to pass external
or prefetched information to the application. This context will be
available and accessible in all events and most extra functions.

 view release on metacpan or  search on metacpan

Session/CVS/Base/LDAPSession.pm  view on Meta::CPAN

  The state information is maintained in a combination of a cookie, a database,
  and a magic passkey which is sent in the contents of the web page.  Acquiring
  the login thus requires stealing both the cookie and a current copy of the
  web page.

  CGI::LDAPSession also contains a subclass of CGI which transparently injects
  the passkey into forms.  It is strongly suggested that you use this class.

=head1 SYNOPSIS

=head2 Setting Things Up

Session/CVS/Base/LDAPSession.pm  view on Meta::CPAN

      }
  }

##############################################################
#
# Wrapper for CGI.pm's header function which transparently
# handles creation of the cookie.
#

sub header_args_with_cookie($@)
  {

 view release on metacpan or  search on metacpan

lib/CHI/Driver/Redis/SortedSet.pm  view on Meta::CPAN

Extends L<CHI::Driver::Redis> to address memory leak issues from an unbound
C<set> holding the namespace members. This module implements the fix as
suggested in a feature request by Pieter Noordhuis as outlined
L<here|https://github.com/antirez/redis/issues/135>.

The expiration mechanism is implemented as a lazy cleanup, transparently
invoked everytime C<store> is called via C<CHI::set()>.

Please note that this is B<not> backwards compatible with existing Redis
datasets that have already been populated with entries via the
L<CHI::Driver::Redis> module due to the underlying change in the data type

lib/CHI/Driver/Redis/SortedSet.pm  view on Meta::CPAN

and so is a destructive procedure.

=head3 Why not make the driver backwards compatible with L<CHI::Driver::Redis>?

Yes, that's very much possible. And should likewise not be too costly as
it will only have to involve a one-time transparently-invoked migration to
migrate all previously-defined namespace members from the original C<set>
to a C<sorted set>, with expiration values set from each key's
L<TTL|http://redis.io/commands/TTL>.

However, it would be prudent that the memory leak is an actual issue being

 view release on metacpan or  search on metacpan

Param.xs  view on Meta::CPAN

/* no choice here; these aren't prototyped anywhere from pfile.c */
typedef void (*vector)();
vector paramerract( void (*newact)() );

/* this is definitely overkill, as this could (and was) handled
   transparently by the XS typemap code. At one point it
   was thought that per-object data was required and the code
   was converted to use this structure as the basis for the
   object, rather than simply blessing the pointer to the paramfile
   structure
*/

 view release on metacpan or  search on metacpan

lib/CLI/Startup.pm  view on Meta::CPAN

use Readonly;
Readonly my $V_FOR_VERBOSE => 'ALIAS OF VERBOSE';
Readonly my $V_OPTSPEC     => 'v+';

# Simple command-line processing with transparent
# support for config files.
sub startup
{
    my $optspec = shift;

lib/CLI/Startup.pm  view on Meta::CPAN

Version 0.29

=head1 SYNOPSIS

C<CLI::Startup> can export a single method, C<startup()>, into the
caller's namespace. It transparently handles config files, defaults,
and command-line options.

  use CLI::Startup 'startup';

  # Returns the merged results of defaults, config file

 view release on metacpan or  search on metacpan

ChangeLog.owen  view on Meta::CPAN

Sun Apr 11 02:02:20 1999  Owen Taylor  <otaylor@redhat.com>

        * tictactoe: Update to POA.
	
	* tictactoe (make_ui): Add hack to get around bug
	in current Gtk/Perl where transparent color can't
	be left undef.

Fri Apr  9 03:26:37 1999  Owen Taylor  <otaylor@redhat.com>

	* types.cc: Updates for MICO-2.2.6

 view release on metacpan or  search on metacpan

ORBit/mapping.pod  view on Meta::CPAN

The POA supports modes of operation where a single servant
may incarnate multiple object references. For this reason,
it is not, in general, permissible to supply a servant
where an object reference is required. However,  in
situations where it is valid to call the _this() method of 
the servant, an ORB may transparently do this when
a servant is used in place of an object reference.

=head2 Implementing interfaces

The implementation of an interfaces is defined by deriving from the

 view release on metacpan or  search on metacpan

omniORB/mapping.pod  view on Meta::CPAN

The POA supports modes of operation where a single servant
may incarnate multiple object references. For this reason,
it is not, in general, permissible to supply a servant
where an object reference is required. However,  in
situations where it is valid to call the _this() method of 
the servant, an ORB may do this transparently when
a servant is used in place of an object reference.

=head2 Implementing interfaces

Interface are implemented by deriving from the package corresponding 

 view release on metacpan or  search on metacpan

lib/CPAN/FirstTime.pm  view on Meta::CPAN

=item urllist_ping_external

When automatic selection of the nearest cpan mirrors is performed,
turn on the use of the external ping via Net::Ping::External. This is
recommended in the case the local network has a transparent proxy.

Do you want to use the external ping command when autoselecting
mirrors?

=item urllist_ping_verbose