Tk
view release on metacpan or search on metacpan
PNG/libpng/pngread.c view on Meta::CPAN
png_bytep dptr = *dp;
png_read_row(png_ptr, png_bytep_NULL, dptr);
dp++;
}
}
#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */
#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED
/* Read the entire image. If the image has an alpha channel or a tRNS
* chunk, and you have called png_handle_alpha()[*], you will need to
* initialize the image to the current image that PNG will be overlaying.
* We set the num_rows again here, in case it was incorrectly set in
* png_read_start_row() by a call to png_read_update_info() or
* png_start_read_image() if png_set_interlace_handling() wasn't called
* prior to either of these functions like it should have been. You can
* only call this function once. If you desire to have an image for
* each pass of a interlaced image, use png_read_rows() instead.
*
* [*] png_handle_alpha() does not exist yet, as of this version of libpng
*/
void PNGAPI
PNG/zlib/ChangeLog view on Meta::CPAN
- added Windows DLL support
- added a function zlibVersion (for the DLL support)
- fixed declarations using Bytef in infutil.c (pb with MSDOS medium model)
- Bytef is define's instead of typedef'd only for Borland C
- avoid reading uninitialized memory in example.c
- mention in README that the zlib format is now RFC1950
- updated Makefile.dj2
- added algorithm.doc
Changes in 1.0.1 (20 May 96) [1.0 skipped to avoid confusion]
- fix array overlay in deflate.c which sometimes caused bad compressed data
- fix inflate bug with empty stored block
- fix MSDOS medium model which was broken in 0.99
- fix deflateParams() which could generated bad compressed data.
- Bytef is define'd instead of typedef'ed (work around Borland bug)
- added an INDEX file
- new makefiles for DJGPP (Makefile.dj2), 32-bit Borland (Makefile.b32),
Watcom (Makefile.wat), Amiga SAS/C (Makefile.sas)
- speed up adler32 for modern machines without auto-increment
- added -ansi for IRIX in configure
- static_init_done in trees.c is an int
PNG/zlib/deflate.c view on Meta::CPAN
int windowBits;
int memLevel;
int strategy;
const char *version;
int stream_size;
{
deflate_state *s;
int wrap = 1;
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)) {
return Z_VERSION_ERROR;
}
if (strm == Z_NULL) return Z_STREAM_ERROR;
strm->msg = Z_NULL;
PNG/zlib/deflate.c view on Meta::CPAN
s->hash_size = 1 << s->hash_bits;
s->hash_mask = s->hash_size - 1;
s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH);
s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte));
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) {
s->status = FINISH_STATE;
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;
return deflateReset(strm);
}
/* ========================================================================= */
PNG/zlib/deflate.c view on Meta::CPAN
*/
int ZEXPORT deflateCopy (dest, source)
z_streamp dest;
z_streamp source;
{
#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;
}
ss = source->state;
zmemcpy(dest, source, sizeof(z_stream));
ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state));
if (ds == Z_NULL) return Z_MEM_ERROR;
dest->state = (struct internal_state FAR *) ds;
zmemcpy(ds, ss, sizeof(deflate_state));
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;
}
/* following zmemcpy do not work for 16-bit MSDOS */
zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte));
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;
return Z_OK;
#endif /* MAXSEG_64K */
}
PNG/zlib/trees.c view on Meta::CPAN
Assert (code < D_CODES, "bad d_code");
send_code(s, code, dtree); /* send the distance code */
extra = extra_dbits[code];
if (extra != 0) {
dist -= base_dist[code];
send_bits(s, dist, extra); /* send the extra distance bits */
}
} /* literal or match pair ? */
/* Check that the overlay between pending_buf and d_buf+l_buf is ok: */
Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,
"pendingBuf overflow");
} while (lx < s->last_lit);
send_code(s, END_BLOCK, ltree);
s->last_eob_len = ltree[END_BLOCK].Len;
}
/* ===========================================================================
demos/demos/widget_lib/transtile.pl view on Meta::CPAN
use vars qw/$TOP/;
sub transtile {
# Create a top-level window that demonstrates tiles
# and transparent stuff.
my($demo) = @_;
$TOP = $MW->WidgetDemo(
-name => $demo,
-text => ['This window demonstrates tiles and transparent images. The Canvas has a yellow background, which displays for one second before it\'s overlayed with a tile of tiny camels. On top of the tile layer are three non-transparent imag...
-title => 'Tile and Transparent Demonstration',
-iconname => 'transtile',
);
my $tile = $TOP->Photo(-file =>Tk->findINC('Camel.xpm'));
# A tiled Canvas - the tile overlays the background color.
my $c = $TOP->Canvas(
-background => 'yellow',
-width => 300,
-height => 250,
-relief => 'raised',
-borderwidth => 3,
)->grid;
$c->update;
$c->after(1000);
demos/demos/widget_lib/transtile.pl view on Meta::CPAN
# Transparently filled, with events.
my $o3 = $c->createOval(25, 120, 100, 195,
-outline => 'red',
-fill => 'blue',
-stipple => 'transparent',
);
$c->bind($o3, '<Motion>' => $cb);
# A transparent GIF overlaying everything.
$c->createImage(300, 300,
-image => $TOP->Photo(-data => &encoded_gif, -format => 'gif'),
-anchor => 'se',
);
} # end transtile
sub encoded_gif {
pTk/mTk/generic/tkImgPhoto.c view on Meta::CPAN
* The -compositingrule option takes a single value from
* a well-known set.
*/
if (index + 1 < objc) {
/*
* Note that these must match the TK_PHOTO_COMPOSITE_*
* constants.
*/
static CONST char *compositingRules[] = {
"overlay", "set",
NULL
};
index++;
if (Tcl_GetIndexFromObj(interp, objv[index], compositingRules,
"compositing rule", 0, &optPtr->compositingRule)
!= TCL_OK) {
return TCL_ERROR;
}
*optIndexPtr = index;
pTk/mTk/tclGeneric/tclAlloc.c view on Meta::CPAN
typedef unsigned long caddr_t;
#endif
/*
* The overhead on a block is at least 8 bytes. When free, this space
* contains a pointer to the next free block, and the bottom two bits must
* be zero. When in use, the first byte is set to MAGIC, and the second
* byte is the size index. The remaining bytes are for alignment.
* If range checking is enabled then a second word holds the size of the
* requested block, less 1, rounded up to a multiple of sizeof(RMAGIC).
* The order of elements is critical: ov_magic must overlay the low order
* bits of ov_next, and ov_magic can not be a valid ov_next bit pattern.
*/
union overhead {
union overhead *ov_next; /* when free */
unsigned char ov_padding[8]; /* Ensure the structure is 8-byte aligned. */
struct {
unsigned char ovu_magic0; /* magic number */
unsigned char ovu_index; /* bucket # */
unsigned char ovu_unused; /* unused */
pTk/mTk/tclWin/tclWinInit.c view on Meta::CPAN
*/
#include "tclWinInt.h"
#include <winnt.h>
#include <winbase.h>
#include <lmcons.h>
/*
* The following declaration is a workaround for some Microsoft brain damage.
* The SYSTEM_INFO structure is different in various releases, even though the
* layout is the same. So we overlay our own structure on top of it so we
* can access the interesting slots in a uniform way.
*/
typedef struct {
WORD wProcessorArchitecture;
WORD wReserved;
} OemId;
/*
* The following macros are missing from some versions of winnt.h.
pod/Animation.pod view on Meta::CPAN
given in the C<start_animation> method.
=head1 NOTES
C<set_disposal_method> was formerly known as C<blank> method, but the
naming of this method was a mistake.
If the disposal method is not set correctly, either by
C<set_disposal_method> or by determining from the GIF metadata, then
the following may happen: By default Animation leaves the previous
movie frame in the animation photo. Many times overlaying subsequent
frames produces a composite that looks blurred.
=head1 BUGS
This module should not depend on a module which is not declared as a
dependency (Image::Info).
The delays between images may vary in a GIF animation. This cannot be
handled by this module yet.
pod/Photo.pod view on Meta::CPAN
Specifies that the source image should be reduced in size by using
only every I<x>th pixel in the X direction and I<y>th pixel in
the Y direction. Negative values will cause the image to be flipped
about the Y or X axes, respectively. If I<y> is not given, the
default value is the same as I<x>.
=item B<-compositingrule> =E<gt> I<rule>
Specifies how transparent pixels in the source image are combined with
the destination image. When a compositing rule of I<overlay> is
set, the old contents of the destination image are visible, as if the
source image were printed on a piece of transparent film and placed
over the top of the destination. When a compositing rule of I<set>
is set, the old contents of the destination image are discarded and
the source image is used as-is. The default compositing rule is
I<overlay>.
=back
=item I<$image>-E<gt>B<data>(?I<option value(s), ...>?)
Returns image data in the form of a string.
The following options may be specified:
=over 8
( run in 1.391 second using v1.01-cache-2.11-cpan-49f99fa48dc )