callisto-debian/gtk2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Make GTK+ build against an external gdk-pixbuf

Browse Source
This commit is contained in:
Matthias Clasen
2010-06-26 02:29:29 -04:00
parent 946c1ca136
commit cb29d27707
158 changed files with 110 additions and 54213 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
INSTALL.in
View File

@ -3,9 +3,9 @@ Prerequisites
GTK+ requires the following packages:
- The GLib, Pango, ATK and cairo libraries, available at the same
- The GLib, Pango, GdkPixbuf, ATK and cairo libraries, available at the same
location as GTK+. GTK+ @GTK_VERSION@ requires at least GLib 2.23.6,
Pango 1.20, ATK 1.29.2 and cairo 1.6.0.
Pango 1.20, GdkPixbuf 2.21.0, ATK 1.29.2 and cairo 1.6.0.
- gobject-introspection 0.6.7 or newer.

4
Makefile.am
View File

@ -1,7 +1,7 @@
## Makefile.am for GTK+
include $(top_srcdir)/Makefile.decl
SRC_SUBDIRS = gdk-pixbuf gdk gtk modules demos tests perf contrib
SRC_SUBDIRS = gdk gtk modules demos tests perf
SUBDIRS = po po-properties $(SRC_SUBDIRS) docs m4macros build
# require automake 1.4
@ -160,7 +160,7 @@ gdk-$(GDKTARGET)-2.0-uninstalled.pc: gdk-2.0-uninstalled.pc
cp gdk-2.0-uninstalled.pc gdk-$(GDKTARGET)-2.0-uninstalled.pc
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA= gdk-pixbuf-2.0.pc gdk-$(GDKTARGET)-2.0.pc gtk+-$(GDKTARGET)-2.0.pc gail.pc
pkgconfig_DATA= gdk-$(GDKTARGET)-2.0.pc gtk+-$(GDKTARGET)-2.0.pc gail.pc
if OS_UNIX
pkgconfig_DATA += gtk+-unix-print-2.0.pc

479
configure.in
View File

@ -35,6 +35,7 @@ m4_define([glib_required_version], [2.25.8])
m4_define([pango_required_version], [1.20])
m4_define([atk_required_version], [1.29.2])
m4_define([cairo_required_version], [1.6])
+m4_define([gdk_pixbuf_required_version], [2.21.0])
AC_INIT([gtk+], [gtk_version],
@ -108,19 +109,6 @@ m4_define([gail_lt_current_minus_age],[m4_eval(gail_lt_current - gail_lt_age)])
AC_SUBST([GAIL_LT_VERSION_INFO],[gail_lt_version_info])
AC_SUBST([GAIL_LT_CURRENT_MINUS_AGE],[gail_lt_current_minus_age])
#
# gdk-pixbuf gets versioned separately, and for now, using standard
# libtool versioning, not GTK+-style versioning
#
GDK_PIXBUF_MAJOR=gtk_major_version
GDK_PIXBUF_MINOR=gtk_minor_version
GDK_PIXBUF_MICRO=gtk_micro_version
GDK_PIXBUF_VERSION="${GDK_PIXBUF_MAJOR}.${GDK_PIXBUF_MINOR}.${GDK_PIXBUF_MICRO}"
AC_SUBST(GDK_PIXBUF_MAJOR)
AC_SUBST(GDK_PIXBUF_MINOR)
AC_SUBST(GDK_PIXBUF_MICRO)
AC_SUBST(GDK_PIXBUF_VERSION)
GETTEXT_PACKAGE=gtk20
AC_SUBST(GETTEXT_PACKAGE)
AC_DEFINE_UNQUOTED(GETTEXT_PACKAGE, "$GETTEXT_PACKAGE",
@ -387,7 +375,8 @@ PKG_CHECK_MODULES(BASE_DEPENDENCIES,
[glib-2.0 >= glib_required_version dnl
atk >= atk_required_version dnl
pango >= pango_required_version dnl
cairo >= cairo_required_version])
cairo >= cairo_required_version dnl
gdk-pixbuf-2.0 >= gdk_pixbuf_required_version])
## In addition to checking that cairo is present, we also need to
## check that the correct cairo backend is there. E.g. if the GDK
@ -407,7 +396,7 @@ if test "$os_win32" != yes; then
# right now, symbols starting with _ are not exported
LIBTOOL_EXPORT_OPTIONS='-export-symbols-regex "^[[^_]].*"'
else
# We currently use .def files on Windows (for gdk-pixbuf, gdk and gtk)
# We currently use .def files on Windows (for gdk and gtk)
LIBTOOL_EXPORT_OPTIONS=
fi
AC_SUBST(LIBTOOL_EXPORT_OPTIONS)
@ -616,7 +605,7 @@ AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
# Run AM_PATH_GLIB_2_0 to make sure that GLib is installed and working
#
GLIB_PACKAGES="gobject-2.0 gmodule-no-export-2.0"
GLIB_PACKAGES="gobject-2.0 gio-2.0 gmodule-no-export-2.0"
AM_PATH_GLIB_2_0(glib_required_version, :,
AC_MSG_ERROR([
@ -763,27 +752,6 @@ AC_CHECK_HEADERS(crt_externs.h)
AC_CHECK_FUNCS(_NSGetEnviron)
##################################################
# Checks for gdk-pixbuf
##################################################
dnl ********************************************************
dnl * See whether we need to load our modules as .la files *
dnl ********************************************************
use_la_modules=false
case $host in
*-aix*) use_la_modules=true
esac
if $use_la_modules ; then
AC_DEFINE(USE_LA_MODULES, 1,
[Whether to load modules via .la files rather than directly])
fi
AC_MSG_CHECKING(whether to build gmodulized gdk-pixbuf)
AC_ARG_ENABLE(modules,
[AC_HELP_STRING([--disable-modules],
[disable dynamic module loading])])
@ -804,13 +772,13 @@ else
dnl Now we check to see if our libtool supports shared lib deps
dnl (in a rather ugly way even)
if $dynworks; then
pixbuf_libtool_config="${CONFIG_SHELL-/bin/sh} ./libtool --config"
pixbuf_deplibs_check=`$pixbuf_libtool_config | \
module_libtool_config="${CONFIG_SHELL-/bin/sh} ./libtool --config"
module_deplibs_check=`$pixbuf_libtool_config | \
grep '^[[a-z_]]*check[[a-z_]]*_method=[['\''"]]' | \
sed 's/.*[['\''"]]\(.*\)[['\''"]]$/\1/'`
if test "x$pixbuf_deplibs_check" = "xnone" || \
test "x$pixbuf_deplibs_check" = "xunknown" || \
test "x$pixbuf_deplibs_check" = "x"; then
if test "x$module_deplibs_check" = "xnone" || \
test "x$module_deplibs_check" = "xunknown" || \
test "x$module_deplibs_check" = "x"; then
dynworks=false
fi
fi
@ -824,297 +792,8 @@ else
fi
fi
dnl We allow people to disable image loaders explicitely, but if they don't we error
dnl out so that people don't accidentally build without them.
AC_ARG_WITH(libpng,
[AC_HELP_STRING([--without-libpng],
[disable PNG loader for gdk-pixbuf])])
AC_ARG_WITH(libjpeg,
[AC_HELP_STRING([--without-libjpeg],
[disable JPEG loader for gdk-pixbuf])])
AC_ARG_WITH(libtiff,
[AC_HELP_STRING([--without-libtiff],
[disable TIFF loader for gdk-pixbuf])])
AC_ARG_WITH(libjasper,
[AC_HELP_STRING([--with-libjasper],
[enable JPEG2000 loader for gdk-pixbuf])])
AC_ARG_ENABLE(gdiplus,
[AC_HELP_STRING([--enable-gdiplus],
[enble GDI+ loaders for gdk-pixbuf (currently known to be broken)])],,
[enable_gdiplus=no])
AM_CONDITIONAL(BUILD_GDIPLUS_LOADERS, [ test x$os_win32 = xyes && test x$enable_gdiplus != xno ])
dnl Test for libtiff
if test x$os_win32 = xno || test x$enable_gdiplus = xno; then
if test x$with_libtiff != xno && test -z "$LIBTIFF"; then
AC_CHECK_LIB(tiff, TIFFReadRGBAImageOriented,
[AC_CHECK_HEADER(tiffio.h,
TIFF='tiff'; LIBTIFF='-ltiff',
AC_MSG_WARN(*** TIFF loader will not be built (TIFF header files not found) ***))],
[AC_CHECK_LIB(tiff, TIFFWriteScanline,
[AC_CHECK_HEADER(tiffio.h,
TIFF='tiff'; LIBTIFF='-ltiff -ljpeg -lz',
AC_MSG_WARN(*** TIFF loader will not be built (TIFF header files not found) ***))],
[AC_CHECK_LIB(tiff34, TIFFFlushData,
[AC_CHECK_HEADER(tiffio.h,
TIFF='tiff'; LIBTIFF='-ltiff34 -ljpeg -lz',
AC_MSG_WARN(*** TIFF loader will not be built (TIFF header files not found) ***))],
AC_MSG_WARN(*** TIFF loader will not be built (TIFF library not found) ***), -ljpeg -lz -lm)], -ljpeg -lz -lm)], -lm)
fi
if test x$with_libtiff != xno && test -z "$LIBTIFF"; then
AC_MSG_ERROR([
*** Checks for TIFF loader failed. You can build without it by passing
*** --without-libtiff to configure but some programs using GTK+ may
*** not work properly])
fi
fi
dnl Test for libjpeg
if test x$os_win32 = xno || test x$enable_gdiplus = xno; then
if test x$with_libjpeg != xno && test -z "$LIBJPEG"; then
AC_CHECK_LIB(jpeg, jpeg_destroy_decompress,
jpeg_ok=yes,
jpeg_ok=no
AC_MSG_WARN(*** JPEG loader will not be built (JPEG library not found) ***))
if test "$jpeg_ok" = yes; then
AC_MSG_CHECKING([for jpeglib.h])
AC_TRY_CPP(
[#include <stdio.h>
#undef PACKAGE
#undef VERSION
#undef HAVE_STDLIB_H
#include <jpeglib.h>],
jpeg_ok=yes,
jpeg_ok=no)
AC_MSG_RESULT($jpeg_ok)
if test "$jpeg_ok" = yes; then
LIBJPEG='-ljpeg'
AC_CHECK_LIB(jpeg, jpeg_simple_progression,
AC_DEFINE(HAVE_PROGRESSIVE_JPEG, 1,
[Define to 1 is libjpeg supports progressive JPEG]),
AC_MSG_WARN(JPEG library does not support progressive saving.))
else
AC_MSG_WARN(*** JPEG loader will not be built (JPEG header file not found) ***)
fi
fi
fi
if test x$with_libjpeg != xno && test -z "$LIBJPEG"; then
AC_MSG_ERROR([
*** Checks for JPEG loader failed. You can build without it by passing
*** --without-libjpeg to configure but some programs using GTK+ may
*** not work properly])
fi
fi
dnl Test for libpng
if test x$with_libpng != xno && test -z "$LIBPNG"; then
AC_MSG_CHECKING(for libpng12)
if $PKG_CONFIG --exists libpng12 ; then
AC_MSG_RESULT(yes)
PNG='png'
PNG_DEP_CFLAGS_PACKAGES=libpng12
LIBPNG=`$PKG_CONFIG --libs libpng12`
else
AC_MSG_RESULT(no)
AC_CHECK_LIB(png, png_read_info,
[AC_CHECK_HEADER(png.h,
png_ok=yes,
png_ok=no)],
AC_MSG_WARN(*** PNG loader will not be built (PNG library not found) ***), -lz -lm)
if test "$png_ok" = yes; then
AC_MSG_CHECKING([for png_structp in png.h])
AC_TRY_COMPILE([#include <png.h>],
[png_structp pp; png_infop info; png_colorp cmap; png_create_read_struct;],
png_ok=yes,
png_ok=no)
AC_MSG_RESULT($png_ok)
if test "$png_ok" = yes; then
PNG='png'; LIBPNG='-lpng -lz'
else
AC_MSG_WARN(*** PNG loader will not be built (PNG library is too old) ***)
fi
else
AC_MSG_WARN(*** PNG loader will not be built (PNG header file not found) ***)
fi
fi
fi
if test x$with_libpng != xno && test -z "$LIBPNG"; then
AC_MSG_ERROR([
*** Checks for PNG loader failed. You can build without it by passing
*** --without-libpng to configure but many programs using GTK+ will
*** not work properly. The PNG loader is also needed if you are compiling
*** from CVS.])
fi
dnl Test for libjasper
if test x$with_libjasper = xyes && test -z "$LIBJASPER"; then
AC_CHECK_LIB(jasper, jas_init, LIBJASPER=-ljasper, [], -ljpeg -lm)
fi
if test x$with_libjasper = xyes && test -z "$LIBJASPER"; then
AC_MSG_ERROR([
*** Checks for JPEG2000 loader failed. You can build without it by passing
*** --without-libjasper to configure])
fi
AC_SUBST(LIBTIFF)
AC_SUBST(LIBJPEG)
AC_SUBST(LIBPNG)
AC_SUBST(LIBJASPER)
AM_CONDITIONAL(BUILD_DYNAMIC_MODULES, $dynworks)
#
# Allow building some or all gdk-pixbuf loaders included
#
AC_MSG_CHECKING(pixbuf loaders to build)
dnl due to an autoconf bug, commas in the first arg to
dnl AC_HELP_STRING cause problems.
dnl AC_HELP_STRING([--with-included-loaders=LOADER1 LOADER2 ...],
dnl [build the specified loaders into gdk-pixbuf])
AC_ARG_WITH(included_loaders,
[ --with-included-loaders=LOADER1,LOADER2,...
build the specified loaders into gdk-pixbuf])
if $dynworks; then
:
else
## if the option was specified, leave it; otherwise disable included loaders
if test x$with_included_loaders = xno; then
with_included_loaders=yes
fi
fi
# Use the traditional png loader instead of the GDI+ one on Windows,
# because some important apps like GIMP need to read and write
# arbitrary tEXt chunks which doesn't seem to be possible through GDI+
all_loaders="ani,icns,pcx,ras,tga,png,pnm,wbmp,xbm,xpm,qtif"
if test x$with_libjasper != xno; then
all_loaders="$all_loaders,jasper"
fi
if test x$os_win32 = xyes && test x$enable_gdiplus != xno; then
# Skip PNG, see comment above
gdip_formats="bmp emf gif ico jpeg tiff wmf"
for f in $gdip_formats; do
all_loaders="$all_loaders,gdip-$f"
done
else
all_loaders="$all_loaders,bmp,gif,ico,jpeg,tiff"
fi
included_loaders=""
# If no loaders specified, include all
if test "x$with_included_loaders" = xyes ; then
included_loaders="$all_loaders"
else
included_loaders="$with_included_loaders"
fi
AC_MSG_RESULT($included_loaders)
INCLUDED_LOADER_OBJ=
INCLUDED_LOADER_DEFINE=
IFS="${IFS= }"; gtk_save_ifs="$IFS"; IFS=","
for loader in $included_loaders; do
if echo "$all_loaders" | egrep "(^|,)$loader(\$|,)" > /dev/null; then
:
else
AC_MSG_ERROR([the specified loader $loader does not exist])
fi
loader_underscores=`echo $loader | sed -e 's/-/_/g'`
INCLUDED_LOADER_OBJ="$INCLUDED_LOADER_OBJ libstatic-pixbufloader-$loader.la"
# Don't bother defining separate -DINCLUDE_gdip_foo for each gdip-foo loader
case $loader in
gdip-*) ;;
*) INCLUDED_LOADER_DEFINE="$INCLUDED_LOADER_DEFINE -DINCLUDE_$loader_underscores";;
esac
eval INCLUDE_$loader_underscores=yes
done
# Just define one -DINCLUDE_gdiplus for all the gdip-foo loaders
# (except gdip-png, which isn't built at all)
if test x"$INCLUDE_gdip_ico" = xyes; then
INCLUDED_LOADER_DEFINE="$INCLUDED_LOADER_DEFINE -DINCLUDE_gdiplus"
fi
IFS="$gtk_save_ifs"
AC_SUBST(INCLUDED_LOADER_OBJ)
AC_SUBST(INCLUDED_LOADER_DEFINE)
AM_CONDITIONAL(INCLUDE_PNG, [test x"$INCLUDE_png" = xyes])
AM_CONDITIONAL(INCLUDE_BMP, [test x"$INCLUDE_bmp" = xyes])
AM_CONDITIONAL(INCLUDE_WBMP, [test x"$INCLUDE_wbmp" = xyes])
AM_CONDITIONAL(INCLUDE_GIF, [test x"$INCLUDE_gif" = xyes])
AM_CONDITIONAL(INCLUDE_ICO, [test x"$INCLUDE_ico" = xyes])
AM_CONDITIONAL(INCLUDE_ANI, [test x"$INCLUDE_ani" = xyes])
AM_CONDITIONAL(INCLUDE_JPEG, [test x"$INCLUDE_jpeg" = xyes])
AM_CONDITIONAL(INCLUDE_PNM, [test x"$INCLUDE_pnm" = xyes])
AM_CONDITIONAL(INCLUDE_RAS, [test x"$INCLUDE_ras" = xyes])
AM_CONDITIONAL(INCLUDE_TIFF, [test x"$INCLUDE_tiff" = xyes])
AM_CONDITIONAL(INCLUDE_XPM, [test x"$INCLUDE_xpm" = xyes])
AM_CONDITIONAL(INCLUDE_XBM, [test x"$INCLUDE_xbm" = xyes])
AM_CONDITIONAL(INCLUDE_TGA, [test x"$INCLUDE_tga" = xyes])
AM_CONDITIONAL(INCLUDE_PCX, [test x"$INCLUDE_pcx" = xyes])
AM_CONDITIONAL(INCLUDE_ICNS, [test x"$INCLUDE_icns" = xyes])
AM_CONDITIONAL(INCLUDE_JASPER, [test x"$INCLUDE_jasper" = xyes])
AM_CONDITIONAL(INCLUDE_QTIF, [test x"$INCLUDE_qtif" = xyes])
# As all GDI+ loaders are either built-in or not, arbitrarily just
# check one of the variables here
AM_CONDITIONAL(INCLUDE_GDIPLUS, [test x"$INCLUDE_gdip_ico" = xyes])
if test x$gio_can_sniff = x; then
AC_MSG_CHECKING([if gio can sniff png])
gtk_save_LIBS="$LIBS"
gtk_save_CFLAGS="$CFLAGS"
LIBS="`$PKG_CONFIG --libs gio-2.0`"
CFLAGS="`$PKG_CONFIG --cflags gio-2.0`"
AC_RUN_IFELSE([AC_LANG_SOURCE([[
#include <gio/gio.h>
static const gsize data_size = 159;
static const guint8 data[] =
{
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d,
0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
0x08, 0x02, 0x00, 0x00, 0x00, 0x90, 0x77, 0x53, 0xde, 0x00, 0x00, 0x00,
0x01, 0x73, 0x52, 0x47, 0x42, 0x00, 0xae, 0xce, 0x1c, 0xe9, 0x00, 0x00,
0x00, 0x09, 0x70, 0x48, 0x59, 0x73, 0x00, 0x00, 0x0b, 0x13, 0x00, 0x00,
0x0b, 0x13, 0x01, 0x00, 0x9a, 0x9c, 0x18, 0x00, 0x00, 0x00, 0x07, 0x74,
0x49, 0x4d, 0x45, 0x07, 0xd8, 0x07, 0x0f, 0x10, 0x08, 0x15, 0x61, 0xd8,
0x35, 0x37, 0x00, 0x00, 0x00, 0x19, 0x74, 0x45, 0x58, 0x74, 0x43, 0x6f,
0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x00, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65,
0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x47, 0x49, 0x4d, 0x50, 0x57,
0x81, 0x0e, 0x17, 0x00, 0x00, 0x00, 0x0c, 0x49, 0x44, 0x41, 0x54, 0x08,
0xd7, 0x63, 0xf8, 0xff, 0xff, 0x3f, 0x00, 0x05, 0xfe, 0x02, 0xfe, 0xdc,
0xcc, 0x59, 0xe7, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae,
0x42, 0x60, 0x82
};
int
main (int argc, char **argv)
{
char *content_type;
char *image_png;
content_type = g_content_type_guess (NULL, data, data_size, NULL);
image_png = g_content_type_from_mime_type ("image/png");
return !!strcmp (content_type, image_png);
}]])],
[gio_can_sniff=yes
AC_DEFINE(GDK_PIXBUF_USE_GIO_MIME, 1, [Define if gio can sniff image data])],
[gio_can_sniff=no])
AC_MSG_RESULT($gio_can_sniff)
LIBS="$gtk_save_LIBS"
CFLAGS="$gtk_save_CFLAGS"
fi
#
# Allow building some or all immodules included
#
@ -1194,29 +873,6 @@ AC_HEADER_SYS_WAIT
AC_TYPE_SIGNAL
AM_CONDITIONAL(HAVE_TIFF, test "x$LIBTIFF" != x)
AM_CONDITIONAL(HAVE_PNG, test "x$LIBPNG" != x)
AM_CONDITIONAL(HAVE_JPEG, test "x$LIBJPEG" != x)
AM_CONDITIONAL(HAVE_JASPER, test "x$LIBJASPER" != x)
if $dynworks ; then
STATIC_LIB_DEPS=
if echo "$included_loaders" | egrep '(^|,)tiff($|,)' > /dev/null; then
STATIC_LIB_DEPS="$STATIC_LIB_DEPS $LIBTIFF"
fi
if echo "$included_loaders" | egrep '(^|,)jpeg($|,)' > /dev/null; then
STATIC_LIB_DEPS="$STATIC_LIB_DEPS $LIBJPEG"
fi
if echo "$included_loaders" | egrep '(^|,)png($|,)' > /dev/null; then
STATIC_LIB_DEPS="$STATIC_LIB_DEPS $LIBPNG"
fi
if echo "$included_loaders" | egrep '(^|,)jasper($|,)' > /dev/null; then
STATIC_LIB_DEPS="$STATIC_LIB_DEPS $LIBJASPER"
fi
else
STATIC_LIB_DEPS="$LIBTIFF $LIBJPEG $LIBPNG $LIBJASPER"
fi
# Checks to see whether we should include mediaLib
# support.
#
@ -1249,64 +905,19 @@ fi
AM_CONDITIONAL(USE_MEDIALIB, test $use_mlib = yes)
AM_CONDITIONAL(USE_MEDIALIB25, test $use_mlib25 = yes)
# Checks to see if we should compile in MMX support (there will be
# a runtime test when the code is actually run to see if it should
# be used - this just checks if we can compile it.)
#
# This code is partially taken from Mesa
#
AC_MSG_CHECKING(for x86 platform)
case $host_cpu in
i386|i486|i586|i686|i786|k6|k7)
use_x86_asm=yes
;;
*)
use_x86_asm=no
esac
AC_MSG_RESULT($use_x86_asm)
use_mmx_asm=no
if test $use_x86_asm = yes; then
save_ac_ext=$ac_ext
ac_ext=S
AC_MSG_CHECKING(compiler support for MMX)
cp $srcdir/gdk-pixbuf/pixops/scale_line_22_33_mmx.S conftest.S
if AC_TRY_EVAL(ac_compile); then
use_mmx_asm=yes
fi
rm -rf conftest*
ac_ext=$save_ac_ext
if test $use_mmx_asm = yes; then
AC_DEFINE(USE_MMX, 1,
[Define to 1 if XXM is available and should be used])
AC_MSG_RESULT(yes)
else
AC_MSG_RESULT(no)
fi
fi
AM_CONDITIONAL(USE_MMX, test x$use_mmx_asm = xyes)
REBUILD_PNGS=
if test -z "$LIBPNG" && test x"$os_win32" = xno -o x$enable_gdiplus = xno; then
REBUILD_PNGS=#
fi
dnl Look for a host system's gdk-pixbuf-csource if we are cross-compiling
AM_CONDITIONAL(CROSS_COMPILING, test $cross_compiling = yes)
if test $cross_compiling = yes; then
AC_PATH_PROG(GDK_PIXBUF_CSOURCE, gdk-pixbuf-csource, no)
AC_PATH_PROG(GTK_UPDATE_ICON_CACHE, gtk-update-icon-cache, no)
if test x$GTK_UPDATE_ICON_CACHE = xno; then
REBUILD_PNGS=#
fi
fi
AC_PATH_PROG(GDK_PIXBUF_CSOURCE, gdk-pixbuf-csource, no)
if test ! -f $srcdir/gtk/gtkbuiltincache.h &&
test "x$REBUILD_PNGS" = "x#" ; then
AC_MSG_ERROR([
@ -1315,22 +926,10 @@ if test ! -f $srcdir/gtk/gtkbuiltincache.h &&
*** don't have a prebuilt gtk-update-icon-cache on the build system.])
fi
AC_SUBST(REBUILD_PNGS)
GDK_PIXBUF_PACKAGES="gmodule-no-export-2.0 gobject-2.0 gio-2.0"
GDK_PIXBUF_EXTRA_LIBS="$STATIC_LIB_DEPS $MATH_LIB $MEDIA_LIB"
GDK_PIXBUF_EXTRA_CFLAGS=
GDK_PIXBUF_DEP_LIBS="`$PKG_CONFIG --libs $GDK_PIXBUF_PACKAGES` $GDK_PIXBUF_EXTRA_LIBS"
GDK_PIXBUF_DEP_CFLAGS="`$PKG_CONFIG --cflags gthread-2.0 $GDK_PIXBUF_PACKAGES $PNG_DEP_CFLAGS_PACKAGES` $GDK_PIXBUF_EXTRA_CFLAGS"
########################################
# Windowing system checks
########################################
GDK_PIXBUF_XLIB_PACKAGES=
GDK_PIXBUF_XLIB_EXTRA_CFLAGS=
GDK_PIXBUF_XLIB_EXTRA_LIBS=
GDK_EXTRA_LIBS="$GDK_WLIBS"
GDK_EXTRA_CFLAGS=
@ -1368,8 +967,7 @@ if test "x$gdktarget" = "xx11"; then
*) x_libs_for_checks="$x_libs_for_checks $I" ;;
esac
done
GDK_PIXBUF_XLIB_PACKAGES="x11"
GTK_PACKAGES_FOR_X="x11"
else
have_base_x_pc=false
@ -1381,8 +979,6 @@ if test "x$gdktarget" = "xx11"; then
x_cflags="$X_CFLAGS"
x_libs_for_checks="$X_LIBS -lXext -lXrender -lX11 $X_EXTRA_LIBS"
GDK_PIXBUF_XLIB_EXTRA_CFLAGS="$x_cflags"
GDK_PIXBUF_XLIB_EXTRA_LIBS="$X_LIBS -lX11 $X_EXTRA_LIBS"
GTK_DEP_LIBS_FOR_X="$X_LIBS -lXrender -lX11 $X_EXTRA_LIBS"
fi
@ -1662,15 +1258,6 @@ else
AM_CONDITIONAL(USE_QUARTZ, false)
fi
GDK_PIXBUF_XLIB_DEP_LIBS="`$PKG_CONFIG --libs $GDK_PIXBUF_PACKAGES $GDK_PIXBUF_XLIB_PACKAGES` $GDK_PIXBUF_XLIB_EXTRA_LIBS $GDK_PIXBUF_EXTRA_LIBS"
GDK_PIXBUF_XLIB_DEP_CFLAGS="`$PKG_CONFIG --cflags gthread-2.0 $GDK_PIXBUF_PACKAGES $GDK_PIXBUF_XLIB_PACKAGES` $GDK_PIXBUF_EXTRA_CFLAGS $GDK_PIXBUF_XLIB_EXTRA_CFLAGS"
AC_SUBST(GDK_PIXBUF_XLIB_PACKAGES)
AC_SUBST(GDK_PIXBUF_XLIB_EXTRA_LIBS)
AC_SUBST(GDK_PIXBUF_XLIB_EXTRA_CFLAGS)
AC_SUBST(GDK_PIXBUF_XLIB_DEP_LIBS)
AC_SUBST(GDK_PIXBUF_XLIB_DEP_CFLAGS)
if test "x$gdktarget" = "xdirectfb"; then
DIRECTFB_REQUIRED_VERSION=1.0.0
AC_MSG_CHECKING(for DirectFB)
@ -1721,13 +1308,13 @@ LDFLAGS="$saved_ldflags"
# Pull in gio-unix for GDesktopAppInfo usage, see at least gdkapplaunchcontext-x11.c
if test "x$gdktarget" = "xx11"; then
GDK_PACKAGES="$PANGO_PACKAGES gio-unix-2.0 $X_PACKAGES cairo-$cairo_backend"
GDK_PACKAGES="$PANGO_PACKAGES gio-unix-2.0 $X_PACKAGES gdk-pixbuf-2.0 cairo-$cairo_backend"
else
GDK_PACKAGES="$PANGO_PACKAGES $X_PACKAGES cairo-$cairo_backend"
GDK_PACKAGES="$PANGO_PACKAGES $X_PACKAGES gdk-pixbuf-2.0 cairo-$cairo_backend"
fi
GDK_DEP_LIBS="$GDK_EXTRA_LIBS `$PKG_CONFIG --libs $GDK_PIXBUF_PACKAGES $GDK_PACKAGES` $GDK_PIXBUF_EXTRA_LIBS"
GDK_DEP_CFLAGS="`$PKG_CONFIG --cflags gthread-2.0 $GDK_PIXBUF_PACKAGES $GDK_PACKAGES` $GDK_PIXBUF_EXTRA_CFLAGS $GDK_EXTRA_CFLAGS"
GDK_DEP_LIBS="$GDK_EXTRA_LIBS `$PKG_CONFIG --libs $GDK_PACKAGES`"
GDK_DEP_CFLAGS="`$PKG_CONFIG --cflags gthread-2.0 $GDK_PACKAGES` $GDK_EXTRA_CFLAGS"
#
# If we aren't writing explicit dependencies, then don't put the extra libraries we need
# into the pkg-config files
@ -1773,14 +1360,14 @@ else
LIBS="$gtk_save_LIBS"
fi
GTK_PACKAGES="atk cairo gio-2.0"
GTK_PACKAGES="atk cairo gdk-pixbuf-2.0 gio-2.0"
if test "x$gdktarget" = "xx11"; then
GTK_PACKAGES="$GTK_PACKAGES pangoft2"
fi
GTK_EXTRA_LIBS=
GTK_EXTRA_CFLAGS=
GTK_DEP_LIBS="$GDK_EXTRA_LIBS $GTK_DEP_LIBS_FOR_X `$PKG_CONFIG --libs $GDK_PIXBUF_PACKAGES $PANGO_PACKAGES $GTK_PACKAGES_FOR_X $GTK_PACKAGES` $GTK_EXTRA_LIBS $GDK_PIXBUF_EXTRA_LIBS"
GTK_DEP_CFLAGS="`$PKG_CONFIG --cflags gthread-2.0 $GDK_PIXBUF_PACKAGES $GDK_PACKAGES $GTK_PACKAGES` $GDK_PIXBUF_EXTRA_CFLAGS $GDK_EXTRA_CFLAGS $GTK_EXTRA_CFLAGS"
GTK_DEP_LIBS="$GDK_EXTRA_LIBS $GTK_DEP_LIBS_FOR_X `$PKG_CONFIG --libs $PANGO_PACKAGES $GTK_PACKAGES_FOR_X $GTK_PACKAGES` $GTK_EXTRA_LIBS"
GTK_DEP_CFLAGS="`$PKG_CONFIG --cflags gthread-2.0 $GDK_PACKAGES $GTK_PACKAGES` $GDK_EXTRA_CFLAGS $GTK_EXTRA_CFLAGS"
if test x"$os_win32" = xyes; then
GTK_EXTRA_CFLAGS="$msnative_struct"
@ -1791,16 +1378,6 @@ ATK_PREFIX="`$PKG_CONFIG --variable=prefix atk`"
PANGO_PREFIX="`$PKG_CONFIG --variable=prefix pango`"
CAIRO_PREFIX="`pkg-config --variable=prefix cairo`"
if test $enable_explicit_deps != yes ; then
GDK_PIXBUF_EXTRA_LIBS=
fi
AC_SUBST(GDK_PIXBUF_PACKAGES)
AC_SUBST(GDK_PIXBUF_EXTRA_LIBS)
AC_SUBST(GDK_PIXBUF_EXTRA_CFLAGS)
AC_SUBST(GDK_PIXBUF_DEP_LIBS)
AC_SUBST(GDK_PIXBUF_DEP_CFLAGS)
AC_SUBST(GTK_PACKAGES)
AC_SUBST(GTK_EXTRA_LIBS)
AC_SUBST(GTK_EXTRA_CFLAGS)
@ -1815,6 +1392,9 @@ AC_SUBST(CAIRO_PREFIX)
AC_SUBST(GTK_DEBUG_FLAGS)
AC_SUBST(GTK_XIM_FLAGS)
GDK_PIXBUF_LIBS=`$PKG_CONFIG --libs gdk-pixbuf-2.0`
AC_SUBST(GDK_PIXBUF_LIBS)
########################
# Checks needed for gail
########################
@ -1976,8 +1556,6 @@ AM_CONDITIONAL(TEST_PRINT_BACKEND, test "x$enable_test_print_backend" != "xno")
export SED
export_dynamic=`(./libtool --config; echo eval echo \\$export_dynamic_flag_spec) | sh`
if test -n "$export_dynamic"; then
GDK_PIXBUF_DEP_LIBS=`echo $GDK_PIXBUF_DEP_LIBS | sed -e "s/$export_dynamic//"`
GDK_PIXBUF_XLIB_DEP_LIBS=`echo $GDK_PIXBUF_XLIB_DEP_LIBS | sed -e "s/$export_dynamic//"`
GDK_DEP_LIBS=`echo $GDK_DEP_LIBS | sed -e "s/$export_dynamic//"`
GTK_DEP_LIBS=`echo $GTK_DEP_LIBS | sed -e "s/$export_dynamic//"`
fi
@ -2109,12 +1687,10 @@ AC_CONFIG_FILES([
config.h.win32
gtk-zip.sh
Makefile
gdk-pixbuf-2.0.pc
gdk-2.0.pc
gtk+-2.0.pc
gtk+-unix-print-2.0.pc
gail.pc
gdk-pixbuf-2.0-uninstalled.pc
gdk-2.0-uninstalled.pc
gtk+-2.0-uninstalled.pc
gail-uninstalled.pc
@ -2127,8 +1703,6 @@ demos/gtk-demo/geninclude.pl
tests/Makefile
docs/Makefile
docs/reference/Makefile
docs/reference/gdk-pixbuf/Makefile
docs/reference/gdk-pixbuf/version.xml
docs/reference/gdk/Makefile
docs/reference/gdk/version.xml
docs/reference/gtk/Makefile
@ -2140,10 +1714,6 @@ docs/tutorial/Makefile
build/Makefile
build/win32/Makefile
build/win32/vs9/Makefile
gdk-pixbuf/Makefile
gdk-pixbuf/gdk_pixbuf.rc
gdk-pixbuf/gdk-pixbuf-features.h
gdk-pixbuf/pixops/Makefile
gdk/Makefile
gdk/x11/Makefile
gdk/win32/Makefile
@ -2176,9 +1746,6 @@ modules/printbackends/file/Makefile
modules/printbackends/papi/Makefile
modules/printbackends/test/Makefile
perf/Makefile
contrib/Makefile
contrib/gdk-pixbuf-xlib/Makefile
contrib/gdk-pixbuf-xlib/gdk-pixbuf-xlib-2.0.pc
])
AC_OUTPUT

8
contrib/Makefile.am
View File

@ -1,8 +0,0 @@
include $(top_srcdir)/Makefile.decl
SUBDIRS =
if USE_X11
SUBDIRS += gdk-pixbuf-xlib
endif
-include $(top_srcdir)/git.mk

354
contrib/gdk-pixbuf-xlib/ChangeLog
View File

@ -1,354 +0,0 @@
=== ChangeLog discontinued ===
With the move to git, GTK+ is switching from a ChangeLog file
to relying on commit messages to provide change history. Please
see README.commits for guidance on the expected message format.
2009-03-13 Matthias Clasen <mclasen@redhat.com>
* === Released 2.16.0 ===
2009-03-02 Matthias Clasen <mclasen@redhat.com>
* === Released 2.15.5 ===
2009-02-17 Matthias Clasen <mclasen@redhat.com>
* === Released 2.15.4 ===
2009-02-02 Matthias Clasen <mclasen@redhat.com>
* === Released 2.15.3 ===
2009-01-27 Matthias Clasen <mclasen@redhat.com>
* === Released 2.15.2 ===
2009-01-23 Matthias Clasen <mclasen@redhat.com>
* === Released 2.15.1 ===
2009-01-01 Matthias Clasen <mclasen@redhat.com>
* === Released 2.15.0 ===
2008-09-17 Matthias Clasen <mclasen@redhat.com>
* === Released 2.14.2 ===
2008-09-04 Matthias Clasen <mclasen@redhat.com>
* === Released 2.14.1 ===
2008-09-04 Matthias Clasen <mclasen@redhat.com>
* === Released 2.14.0 ===
2008-08-18 Matthias Clasen <mclasen@redhat.com>
* ==== Released 2.13.7 ===
2008-08-05 Matthias Clasen <mclasen@redhat.com>
* === Released 2.13.6 ===
2008-07-21 Matthias Clasen <mclasen@redhat.com>
* === Released 2.13.5 ===
2008-07-05 Matthias Clasen <mclasen@redhat.com>
* === Released 2.13.4 ===
2008-06-13 Matthias Clasen <mclasen@redhat.com>
* === Released 2.13.3 ===
2008-06-03 Matthias Clasen <mclasen@redhat.com>
* === Released 2.13.2 ===
2008-05-29 Matthias Clasen <mclasen@redhat.com>
* === Released 2.13.1 ===
2008-05-26 Michael Natterer <mitch@imendio.com>
* gdk-pixbuf-xlib.h
* gdk-pixbuf-xlibrgb.h: use G_BEGIN/END_DECLS.
2008-02-16 Matthias Clasen <mclasen@redhat.com>
* === Released 2.13.0 ===
2007-10-16 Matthias Clasen <mclasen@redhat.com>
* === Released 2.12.1 ===
2007-09-13 Matthias Clasen <mclasen@redhat.com>
* === Released 2.12.0 ===
2007-07-21 Matthias Clasen <mclasen@redhat.com>
* === Released 2.11.6 ===
2007-07-02 Matthias Clasen <mclasen@redhat.com>
* === Released 2.11.5 ===
2007-06-19 Matthias Clasen <mclasen@redhat.com>
* === Released 2.11.4 ===
2007-06-15 Matthias Clasen <mclasen@redhat.com>
* === Released 2.11.3 ===
2007-06-06 Matthias Clasen <mclasen@redhat.com>
* === Released 2.11.2 ===
2007-06-04 Matthias Clasen <mclasen@redhat.com>
* === Released 2.11.1 ===
2007-05-24 Matthias Clasen <mclasen@redhat.com>
* === Released 2.11.0 ===
2006-10-08 Matthias Clasen <mclasen@redhat.com>
* gdk-pixbuf-xlib.c: Apply a cleanup patch by
Kjartan Maraas (#341812)
2006-08-17 Matthias Clasen <mclasen@redhat.com>
* === Released 2.10.2 ===
2006-07-23 Matthias Clasen <mclasen@redhat.com>
* === Released 2.10.1 ===
2006-07-02 Matthias Clasen <mclasen@redhat.com>
* === Released 2.10.0 ===
2006-06-21 Matthias Clasen <mclasen@redhat.com>
* === Released 2.9.4 ===
2006-06-12 Matthias Clasen <mclasen@redhat.com>
* === Released 2.9.3 ===
2006-06-05 Matthias Clasen <mclasen@redhat.com>
* === Released 2.9.2 ===
2006-05-16 Matthias Clasen <mclasen@redhat.com>
* === Released 2.9.1 ====
2006-05-04 Matthias Clasen <mclasen@redhat.com>
* === Released 2.9.0 ===
2005-11-17 Matthias Clasen <mclasen@redhat.com>
* gdk-pixbuf-xlib-drawable.c:
* gdk-pixbuf-xlibrgb.c: const correctness fixes
found by Arjan van de Ven and gcc.
2005-10-05 Matthias Clasen <mclasen@redhat.com>
* gdk-pixbuf-xlib-2.0.pc.in (Requires): Require
gmodule-no-export-2.0 instead of gmodule-2.0
2005-08-24 Matthias Clasen <mclasen@redhat.com>
* === Released 2.8.2 ===
* === Released 2.8.1 ===
2005-08-13 Matthias Clasen <mclasen@redhat.com>
* === Released 2.8.0 ===
2005-08-02 Matthias Clasen <mclasen@redhat.com>
* === Released 2.7.5 ===
2005-07-22 Matthias Clasen <mclasen@redhat.com>
* === Released 2.7.4 ===
2005-07-15 Matthias Clasen <mclasen@redhat.com>
* === Released 2.7.3 ===
2005-07-08 Matthias Clasen <mclasen@redhat.com>
* === Released 2.7.2 ===
2005-07-01 Matthias Clasen <mclasen@redhat.com>
* === Released 2.7.1 ===
2005-06-20 Matthias Clasen <mclasen@redhat.com>
* === Released 2.7.0 ===
2005-01-08 Matthias Clasen <mclasen@redhat.com>
* === Released 2.6.1 ===
2004-12-16 Matthias Clasen <mclasen@redhat.com>
* === Released 2.6.0 ===
2004-12-02 Matthias Clasen <mclasen@redhat.com>
* === Released 2.5.6 ===
2004-11-12 Matthias Clasen <mclasen@redhat.com>
* === Released 2.5.5 ===
2004-10-27 Matthias Clasen <mclasen@redhat.com>
* === Released 2.5.4 ===
2004-09-19 Matthias Clasen <mclasen@redhat.com>
* === Released 2.5.3 ===
2004-08-25 Matthias Clasen <mclasen@redhat.com>
* === Released 2.5.2 ===
2004-08-01 Matthias Clasen <mclasen@redhat.com>
* === Released 2.5.1 ===
Tue Jul 20 23:26:10 2004 Matthias Clasen <maclas@gmx.de>
* gdk-pixbuf-xlibrgb.c: Include config.h first. (#148034)
Sun Jul 18 20:17:41 2004 Soeren Sandmann <sandmann@daimi.au.dk>
* === released 2.5.0 ==
Tue Mar 9 09:33:54 2004 Owen Taylor <otaylor@redhat.com>
* === Released 2.3.6 ===
Wed Mar 3 15:50:28 2004 Owen Taylor <otaylor@redhat.com>
* Makefile.am (libgdk_pixbuf_xlib_2_0_la_LIBADD): Add
a shared library dependency on libgdk-pixbuf (#124687)
Tue Feb 24 14:45:03 2004 Owen Taylor <otaylor@redhat.com>
* === Released 2.3.3 ===
Fri Feb 13 10:32:09 2004 Owen Taylor <otaylor@redhat.com>
* gdk-pixbuf-xlibrgb.h: Remove a couple of unneeded
#includes. Isn't unsupported code fun?
(133833, Gregory Merchan)
Tue Oct 7 23:30:00 2003 Matthias Clasen <maclas@gmx.de>
* gdk-pixbuf-xlib.h: Add C++ guards. (123955, Harring Figueiredo)
2002-08-06 jacob berkman <jacob@ximian.com>
* Makefile.am (lib_LTLIBRARIES): link against xlibs
2002-01-25 Federico Mena Quintero <federico@ximian.com>
Merge from gdk-pixbuf stable.
* gdk-pixbuf-xlib-drawable.c (rgb565msb): Fixed the endianness
conversion --- swap the individual 16 bit values instead of taking
everying as a 32 bit value.
(rgb565lsb): Likewise.
(rgb555lsb): Likewise.
(rgb555msb): Likewise.
2001-11-26 Akira TAGOH <tagoh@redhat.com>
* Makefile.am (libgdk_pixbuf_xlib_1_3_la_LDFLAGS):
Added -version-info.
2001-05-19 Havoc Pennington <hp@pobox.com>
* gdk-pixbuf-xlibrgb.c: docs
2001-06-04 Havoc Pennington <hp@redhat.com>
* gdk-pixbuf-xlibrgb.c (xlib_rgb_init): remove C++ comment,
reported by Dan McNichol
Mon Jan 8 11:41:41 2001 Owen Taylor <otaylor@redhat.com>
* Makefile.am (INCLUDES): Add @x_cflags@ (#36310)
2001-01-02 Havoc Pennington <hp@redhat.com>
* gdk-pixbuf-xlib-2.0.pc.in (Description): fix up description a bit.
2000-10-06 Havoc Pennington <hp@redhat.com>
* gdk-pixbuf-xlib.c: Put display/screen here, instead of in
the main gdk-pixbuf library as it was in 1.0; since the io-xpm
loader doesn't use these variables anymore it should be OK
2000-09-26 Federico Mena Quintero <federico@helixcode.com>
* gdk-pixbuf/gdk-pixbuf-xlib-drawable.c
(gdk_pixbuf_xlib_get_from_drawable): Do not use
gdk_screen_{width,height}(). Thanks to John Harper for pointing
this out.
2000-08-26 Federico Mena Quintero <federico@helixcode.com>
* gdk-pixbuf/gdk-pixbuf-xlibrgb.c: Added API reference docs.
2000-08-25 Federico Mena Quintero <federico@helixcode.com>
* gdk-pixbuf/gdk-pixbuf-xlib-drawable.c (handle_x_error): Return
0.
(xlib_window_is_viewable): Return FALSE in the last case.
* gdk-pixbuf/gdk-pixbuf-xlib-render.c: Updated the inline docs.
* gdk-pixbuf/gdk-pixbuf-xlib.c: Added API docs.
2000-08-25 John Harper <john@dcs.warwick.ac.uk>
Work to create an Xlib version of gdk-pixbuf (with the Xlib
port of GdkRGB for rendering):
* configure.in: check for X libraries, set and substitute
GDK_PIXBUF_XLIB_{LIBDIR,INCLUDEDIR,LIBS} variables
* gdk_pixbuf_xlibConf.sh.in: new file -- gnome-config details
for the gdk-pixbuf-xlib library
* Makefile.am: build and install gdk_pixbuf_xlibConf.sh
* gdk-pixbuf/gdk-pixbuf-xlib-render.c,
gdk-pixbuf/gdk-pixbuf-xlib.c, gdk-pixbuf/gdk-pixbuf-xlib.h,
gdk-pixbuf/gdk-pixbuf-xlib-private.h,
gdk-pixbuf/gdk-pixbuf-xlib-drawable.c: new files, ported the
GDK dependent parts of gdk-pixbuf to use Xlib. Functions that
were called gdk_pixbuf_FOO are now gdk_pixbuf_xlib_FOO
* gdk-pixbuf/gdk-pixbuf-xlibrgb.c,
gdk-pixbuf/gdk-pixbuf-xlibrgb.h: added Chris Blizzard's Xlib
port of GdkRGB (from Mozilla CVS)
* gdk-pixbuf/Makefile.am: build a library libgdk_pixbuf_xlib.la
including the non-GDK dependent objects from libgdk_pixbuf.la
plus the Xlib ports and xlibrgb

42
contrib/gdk-pixbuf-xlib/Makefile.am
View File

@ -1,42 +0,0 @@
include $(top_srcdir)/Makefile.decl
if PLATFORM_WIN32
no_undefined = -no-undefined
endif
lib_LTLIBRARIES=libgdk_pixbuf_xlib-2.0.la
INCLUDES = \
-I$(top_srcdir) -I$(top_builddir) \
-I$(top_srcdir)/gdk-pixbuf \
-I$(top_srcdir)/contrib \
$(GDK_PIXBUF_XLIB_DEP_CFLAGS)
libgdk_pixbuf_xlib_2_0_la_LDFLAGS = \
-export-dynamic \
$(no_undefined) \
-version-info $(LT_VERSION_INFO)
libgdk_pixbuf_xlib_2_0_la_LIBADD = \
$(top_builddir)/gdk-pixbuf/libgdk_pixbuf-$(GTK_API_VERSION).la \
$(GDK_PIXBUF_XLIB_DEP_LIBS)
libgdk_pixbuf_xlib_2_0_la_SOURCES = \
gdk-pixbuf-xlib-private.h \
gdk-pixbuf-xlib.c \
gdk-pixbuf-xlib-render.c \
gdk-pixbuf-xlib-drawable.c \
gdk-pixbuf-xlibrgb.c
libgdk_pixbuf_xlibincludedir=$(includedir)/gtk-2.0/gdk-pixbuf-xlib
libgdk_pixbuf_xlibinclude_HEADERS = \
gdk-pixbuf-xlib.h \
gdk-pixbuf-xlibrgb.h
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = gdk-pixbuf-xlib-2.0.pc
EXTRA_DIST += gdk-pixbuf-xlib-2.0.pc.in
-include $(top_srcdir)/git.mk

11
contrib/gdk-pixbuf-xlib/gdk-pixbuf-xlib-2.0.pc.in
View File

@ -1,11 +0,0 @@
prefix=@prefix@
exec_prefix=@exec_prefix@
libdir=@libdir@
includedir=@includedir@
Name: GdkPixbuf Xlib
Description: GdkPixbuf rendering for Xlib
Version: @VERSION@
Requires: gobject-2.0,gmodule-no-export-2.0,gdk-pixbuf-2.0
Libs: -L${libdir} -lgdk_pixbuf_xlib-@GTK_API_VERSION@
Cflags: -I${includedir}

1338
contrib/gdk-pixbuf-xlib/gdk-pixbuf-xlib-drawable.c
View File

File diff suppressed because it is too large Load Diff

30
contrib/gdk-pixbuf-xlib/gdk-pixbuf-xlib-private.h
View File

@ -1,30 +0,0 @@
/* GdkPixbuf library - Xlib header file
*
* Authors: John Harper <john@dcs.warwick.ac.uk>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef GDK_PIXBUF_XLIB_PRIVATE_H
#define GDK_PIXBUF_XLIB_PRIVATE_H
#include "gdk-pixbuf-xlib.h"
#include <X11/Xlib.h>
extern Display *gdk_pixbuf_dpy;
extern int gdk_pixbuf_screen;
#endif

398
contrib/gdk-pixbuf-xlib/gdk-pixbuf-xlib-render.c
View File

@ -1,398 +0,0 @@
/* GdkPixbuf library - Rendering functions
*
* Copyright (C) 1999 The Free Software Foundation
*
* Author: Federico Mena-Quintero <federico@gimp.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
/* Trivially ported to Xlib(RGB) by John Harper. */
#include "config.h"
#include "gdk-pixbuf-private.h"
#include "gdk-pixbuf-xlib-private.h"
/**
* gdk_pixbuf_xlib_render_threshold_alpha:
* @pixbuf: A pixbuf.
* @bitmap: Bitmap where the bilevel mask will be painted to.
* @src_x: Source X coordinate.
* @src_y: source Y coordinate.
* @dest_x: Destination X coordinate.
* @dest_y: Destination Y coordinate.
* @width: Width of region to threshold.
* @height: Height of region to threshold.
* @alpha_threshold: Opacity values below this will be painted as zero; all
* other values will be painted as one.
*
* Takes the opacity values in a rectangular portion of a pixbuf and thresholds
* them to produce a bi-level alpha mask that can be used as a clipping mask for
* a drawable.
*
**/
void
gdk_pixbuf_xlib_render_threshold_alpha (GdkPixbuf *pixbuf, Pixmap bitmap,
int src_x, int src_y,
int dest_x, int dest_y,
int width, int height,
int alpha_threshold)
{
GC gc;
XColor color;
int x, y;
guchar *p;
int start, start_status;
int status;
XGCValues gcv;
g_return_if_fail (pixbuf != NULL);
g_return_if_fail (pixbuf->colorspace == GDK_COLORSPACE_RGB);
g_return_if_fail (pixbuf->n_channels == 3 || pixbuf->n_channels == 4);
g_return_if_fail (pixbuf->bits_per_sample == 8);
g_return_if_fail (bitmap != 0);
g_return_if_fail (width >= 0 && height >= 0);
g_return_if_fail (src_x >= 0 && src_x + width <= pixbuf->width);
g_return_if_fail (src_y >= 0 && src_y + height <= pixbuf->height);
g_return_if_fail (alpha_threshold >= 0 && alpha_threshold <= 255);
if (width == 0 || height == 0)
return;
gc = XCreateGC (gdk_pixbuf_dpy, bitmap, 0, &gcv);
if (!pixbuf->has_alpha) {
color.pixel = (alpha_threshold == 255) ? 0 : 1;
XSetForeground (gdk_pixbuf_dpy, gc, color.pixel);
XFillRectangle (gdk_pixbuf_dpy, bitmap, gc,
dest_x, dest_y, width, height);
XFreeGC (gdk_pixbuf_dpy, gc);
return;
}
color.pixel = 0;
XSetForeground (gdk_pixbuf_dpy, gc, color.pixel);
XFillRectangle (gdk_pixbuf_dpy, bitmap, gc,
dest_x, dest_y, width, height);
color.pixel = 1;
XSetForeground (gdk_pixbuf_dpy, gc, color.pixel);
for (y = 0; y < height; y++) {
p = (pixbuf->pixels + (y + src_y) * pixbuf->rowstride + src_x * pixbuf->n_channels
+ pixbuf->n_channels - 1);
start = 0;
start_status = *p < alpha_threshold;
for (x = 0; x < width; x++) {
status = *p < alpha_threshold;
if (status != start_status) {
if (!start_status)
XDrawLine (gdk_pixbuf_dpy, bitmap, gc,
start + dest_x, y + dest_y,
x - 1 + dest_x, y + dest_y);
start = x;
start_status = status;
}
p += pixbuf->n_channels;
}
if (!start_status)
XDrawLine (gdk_pixbuf_dpy, bitmap, gc,
start + dest_x, y + dest_y,
x - 1 + dest_x, y + dest_y);
}
XFreeGC (gdk_pixbuf_dpy, gc);
}
/* Creates a buffer by stripping the alpha channel of a pixbuf */
static guchar *
remove_alpha (GdkPixbuf *pixbuf, int x, int y, int width, int height, int *rowstride)
{
guchar *buf;
int xx, yy;
guchar *src, *dest;
g_assert (pixbuf->n_channels == 4);
g_assert (pixbuf->has_alpha);
g_assert (width > 0 && height > 0);
g_assert (x >= 0 && x + width <= pixbuf->width);
g_assert (y >= 0 && y + height <= pixbuf->height);
*rowstride = 4 * ((width * 3 + 3) / 4);
buf = g_new (guchar, *rowstride * height);
for (yy = 0; yy < height; yy++) {
src = pixbuf->pixels + pixbuf->rowstride * (yy + y) + x * pixbuf->n_channels;
dest = buf + *rowstride * yy;
for (xx = 0; xx < width; xx++) {
*dest++ = *src++;
*dest++ = *src++;
*dest++ = *src++;
src++;
}
}
return buf;
}
/**
* gdk_pixbuf_xlib_render_to_drawable:
* @pixbuf: A pixbuf.
* @drawable: Destination drawable.
* @gc: GC used for rendering.
* @src_x: Source X coordinate within pixbuf.
* @src_y: Source Y coordinate within pixbuf.
* @dest_x: Destination X coordinate within drawable.
* @dest_y: Destination Y coordinate within drawable.
* @width: Width of region to render, in pixels.
* @height: Height of region to render, in pixels.
* @dither: Dithering mode for XlibRGB.
* @x_dither: X offset for dither.
* @y_dither: Y offset for dither.
*
* Renders a rectangular portion of a pixbuf to a drawable while using the
* specified GC. This is done using XlibRGB, so the specified drawable must
* have the XlibRGB visual and colormap. Note that this function will ignore
* the opacity information for images with an alpha channel; the GC must already
* have the clipping mask set if you want transparent regions to show through.
*
* For an explanation of dither offsets, see the XlibRGB documentation. In
* brief, the dither offset is important when re-rendering partial regions of an
* image to a rendered version of the full image, or for when the offsets to a
* base position change, as in scrolling. The dither matrix has to be shifted
* for consistent visual results. If you do not have any of these cases, the
* dither offsets can be both zero.
**/
void
gdk_pixbuf_xlib_render_to_drawable (GdkPixbuf *pixbuf,
Drawable drawable, GC gc,
int src_x, int src_y,
int dest_x, int dest_y,
int width, int height,
XlibRgbDither dither,
int x_dither, int y_dither)
{
guchar *buf;
int rowstride;
g_return_if_fail (pixbuf != NULL);
g_return_if_fail (pixbuf->colorspace == GDK_COLORSPACE_RGB);
g_return_if_fail (pixbuf->n_channels == 3 || pixbuf->n_channels == 4);
g_return_if_fail (pixbuf->bits_per_sample == 8);
g_return_if_fail (drawable != 0);
g_return_if_fail (gc != 0);
g_return_if_fail (width >= 0 && height >= 0);
g_return_if_fail (src_x >= 0 && src_x + width <= pixbuf->width);
g_return_if_fail (src_y >= 0 && src_y + height <= pixbuf->height);
if (width == 0 || height == 0)
return;
/* This will have to be modified once we support other image types.
* Also, GdkRGB does not have gdk_draw_rgb_32_image_dithalign(), so we
* have to pack the buffer first. Sigh.
*/
if (pixbuf->has_alpha)
buf = remove_alpha (pixbuf, src_x, src_y, width, height, &rowstride);
else {
buf = pixbuf->pixels + src_y * pixbuf->rowstride + src_x * 3;
rowstride = pixbuf->rowstride;
}
xlib_draw_rgb_image_dithalign (drawable, gc,
dest_x, dest_y,
width, height,
dither,
buf, rowstride,
x_dither, y_dither);
if (pixbuf->has_alpha)
g_free (buf);
}
/**
* gdk_pixbuf_xlib_render_to_drawable_alpha:
* @pixbuf: A pixbuf.
* @drawable: Destination drawable.
* @src_x: Source X coordinate within pixbuf.
* @src_y: Source Y coordinates within pixbuf.
* @dest_x: Destination X coordinate within drawable.
* @dest_y: Destination Y coordinate within drawable.
* @width: Width of region to render, in pixels.
* @height: Height of region to render, in pixels.
* @alpha_mode: If the image does not have opacity information, this is ignored.
* Otherwise, specifies how to handle transparency when rendering.
* @alpha_threshold: If the image does have opacity information and @alpha_mode
* is GDK_PIXBUF_ALPHA_BILEVEL, specifies the threshold value for opacity
* values.
* @dither: Dithering mode for XlibRGB.
* @x_dither: X offset for dither.
* @y_dither: Y offset for dither.
*
* Renders a rectangular portion of a pixbuf to a drawable. This is done using
* XlibRGB, so the specified drawable must have the XlibRGB visual and colormap.
*
* When used with #GDK_PIXBUF_ALPHA_BILEVEL, this function has to create a bitmap
* out of the thresholded alpha channel of the image and, it has to set this
* bitmap as the clipping mask for the GC used for drawing. This can be a
* significant performance penalty depending on the size and the complexity of
* the alpha channel of the image. If performance is crucial, consider handling
* the alpha channel yourself (possibly by caching it in your application) and
* using gdk_pixbuf_xlib_render_to_drawable() or GdkRGB directly instead.
**/
void
gdk_pixbuf_xlib_render_to_drawable_alpha (GdkPixbuf *pixbuf, Drawable drawable,
int src_x, int src_y,
int dest_x, int dest_y,
int width, int height,
GdkPixbufAlphaMode alpha_mode,
int alpha_threshold,
XlibRgbDither dither,
int x_dither, int y_dither)
{
Pixmap bitmap = 0;
GC gc;
XGCValues gcv;
g_return_if_fail (pixbuf != NULL);
g_return_if_fail (pixbuf->colorspace == GDK_COLORSPACE_RGB);
g_return_if_fail (pixbuf->n_channels == 3 || pixbuf->n_channels == 4);
g_return_if_fail (pixbuf->bits_per_sample == 8);
g_return_if_fail (drawable != 0);
g_return_if_fail (width >= 0 && height >= 0);
g_return_if_fail (src_x >= 0 && src_x + width <= pixbuf->width);
g_return_if_fail (src_y >= 0 && src_y + height <= pixbuf->height);
if (width == 0 || height == 0)
return;
gc = XCreateGC (gdk_pixbuf_dpy, drawable, 0, &gcv);
if (pixbuf->has_alpha) {
/* Right now we only support GDK_PIXBUF_ALPHA_BILEVEL, so we
* unconditionally create the clipping mask.
*/
bitmap = XCreatePixmap (gdk_pixbuf_dpy,
RootWindow (gdk_pixbuf_dpy,
gdk_pixbuf_screen),
width, height, 1);
gdk_pixbuf_xlib_render_threshold_alpha (pixbuf, bitmap,
src_x, src_y,
0, 0,
width, height,
alpha_threshold);
XSetClipMask (gdk_pixbuf_dpy, gc, bitmap);
XSetClipOrigin (gdk_pixbuf_dpy, gc, dest_x, dest_y);
}
gdk_pixbuf_xlib_render_to_drawable (pixbuf, drawable, gc,
src_x, src_y,
dest_x, dest_y,
width, height,
dither,
x_dither, y_dither);
if (bitmap)
XFreePixmap (gdk_pixbuf_dpy, bitmap);
XFreeGC (gdk_pixbuf_dpy, gc);
}
/**
* gdk_pixbuf_xlib_render_pixmap_and_mask:
* @pixbuf: A pixbuf.
* @pixmap_return: Return value for the created pixmap.
* @mask_return: Return value for the created mask.
* @alpha_threshold: Threshold value for opacity values.
*
* Creates a pixmap and a mask bitmap which are returned in the @pixmap_return
* and @mask_return arguments, respectively, and renders a pixbuf and its
* corresponding tresholded alpha mask to them. This is merely a convenience
* function; applications that need to render pixbufs with dither offsets or to
* given drawables should use gdk_pixbuf_xlib_render_to_drawable_alpha() or
* gdk_pixbuf_xlib_render_to_drawable(), and
* gdk_pixbuf_xlib_render_threshold_alpha().
*
* If the pixbuf does not have an alpha channel, then *@mask_return will be set
* to None.
**/
void
gdk_pixbuf_xlib_render_pixmap_and_mask (GdkPixbuf *pixbuf,
Pixmap *pixmap_return,
Pixmap *mask_return,
int alpha_threshold)
{
g_return_if_fail (pixbuf != NULL);
if (pixmap_return) {
GC gc;
XGCValues gcv;
*pixmap_return = XCreatePixmap (gdk_pixbuf_dpy,
RootWindow (gdk_pixbuf_dpy,
gdk_pixbuf_screen),
pixbuf->width,
pixbuf->height,
xlib_rgb_get_depth ());
gc = XCreateGC (gdk_pixbuf_dpy, *pixmap_return, 0, &gcv);
gdk_pixbuf_xlib_render_to_drawable (pixbuf, *pixmap_return, gc,
0, 0, 0, 0,
pixbuf->width,
pixbuf->height,
XLIB_RGB_DITHER_NORMAL,
0, 0);
XFreeGC (gdk_pixbuf_dpy, gc);
}
if (mask_return) {
if (pixbuf->has_alpha) {
*mask_return = XCreatePixmap (gdk_pixbuf_dpy,
RootWindow (gdk_pixbuf_dpy,
gdk_pixbuf_screen),
pixbuf->width,
pixbuf->height, 1);
gdk_pixbuf_xlib_render_threshold_alpha (pixbuf,
*mask_return,
0, 0, 0, 0,
pixbuf->width,
pixbuf->height,
alpha_threshold);
} else
*mask_return = 0;
}
}

63
contrib/gdk-pixbuf-xlib/gdk-pixbuf-xlib.c
View File

@ -1,63 +0,0 @@
/* GdkPixbuf library - Initialization functions
*
* Author: John Harper <john@dcs.warwick.ac.uk>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <X11/Xlib.h>
#include <gdk-pixbuf/gdk-pixbuf-private.h>
#include "gdk-pixbuf-xlib-private.h"
Display *gdk_pixbuf_dpy = NULL;
int gdk_pixbuf_screen = -1;
/**
* gdk_pixbuf_xlib_init:
* @display: X display to use.
* @screen_num: Screen number.
*
* Initializes the gdk-pixbuf Xlib machinery by calling xlib_rgb_init(). This
* function should be called near the beginning of your program, or before using
* any of the gdk-pixbuf-xlib functions.
**/
void
gdk_pixbuf_xlib_init (Display *display, int screen_num)
{
xlib_rgb_init (display, ScreenOfDisplay (display, screen_num));
gdk_pixbuf_dpy = display;
gdk_pixbuf_screen = screen_num;
}
/**
* gdk_pixbuf_xlib_init_with_depth:
* @display: X display to use.
* @screen_num: Screen number.
* @prefDepth: Preferred depth for XlibRGB.
*
* Similar to gdk_pixbuf_xlib_init(), but also lets you specify the preferred
* depth for XlibRGB if you do not want it to use the default depth it picks.
**/
void
gdk_pixbuf_xlib_init_with_depth (Display *display,
int screen_num, int prefDepth)
{
xlib_rgb_init_with_depth (display, ScreenOfDisplay (display, screen_num),
prefDepth);
gdk_pixbuf_dpy = display;
gdk_pixbuf_screen = screen_num;
}

87
contrib/gdk-pixbuf-xlib/gdk-pixbuf-xlib.h
View File

@ -1,87 +0,0 @@
/* GdkPixbuf library - Xlib header file
*
* Authors: John Harper <john@dcs.warwick.ac.uk>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef GDK_PIXBUF_XLIB_H
#define GDK_PIXBUF_XLIB_H
#include <gdk-pixbuf/gdk-pixbuf.h>
#include <gdk-pixbuf-xlib/gdk-pixbuf-xlibrgb.h>
G_BEGIN_DECLS
#include <X11/Xlib.h>
/* init */
void gdk_pixbuf_xlib_init (Display *display, int screen_num);
void gdk_pixbuf_xlib_init_with_depth (Display *display, int screen_num,
int prefDepth);
/* render */
void gdk_pixbuf_xlib_render_threshold_alpha (GdkPixbuf *pixbuf, Pixmap bitmap,
int src_x, int src_y,
int dest_x, int dest_y,
int width, int height,
int alpha_threshold);
void gdk_pixbuf_xlib_render_to_drawable (GdkPixbuf *pixbuf,
Drawable drawable, GC gc,
int src_x, int src_y,
int dest_x, int dest_y,
int width, int height,
XlibRgbDither dither,
int x_dither, int y_dither);
void gdk_pixbuf_xlib_render_to_drawable_alpha (GdkPixbuf *pixbuf,
Drawable drawable,
int src_x, int src_y,
int dest_x, int dest_y,
int width, int height,
GdkPixbufAlphaMode alpha_mode,
int alpha_threshold,
XlibRgbDither dither,
int x_dither, int y_dither);
void gdk_pixbuf_xlib_render_pixmap_and_mask (GdkPixbuf *pixbuf,
Pixmap *pixmap_return,
Pixmap *mask_return,
int alpha_threshold);
/* drawable */
GdkPixbuf *gdk_pixbuf_xlib_get_from_drawable (GdkPixbuf *dest,
Drawable src,
Colormap cmap, Visual *visual,
int src_x, int src_y,
int dest_x, int dest_y,
int width, int height);
G_END_DECLS
#endif /* GDK_PIXBUF_XLIB_H */

3724
contrib/gdk-pixbuf-xlib/gdk-pixbuf-xlibrgb.c
View File

File diff suppressed because it is too large Load Diff

188
contrib/gdk-pixbuf-xlib/gdk-pixbuf-xlibrgb.h
View File

@ -1,188 +0,0 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* The contents of this file are subject to the Mozilla Public License
* Version 1.1 (the "MPL"); you may not use this file except in
* compliance with the MPL. You may obtain a copy of the MPL at
* http://www.mozilla.org/MPL/
*
* Software distributed under the MPL is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the MPL
* for the specific language governing rights and limitations under the
* MPL.
*
* Alternatively, the contents of this file may be used under the
* terms of the GNU Library General Public License (the "LGPL"), in
* which case the provisions of the LGPL are applicable instead of
* those above. If you wish to allow use of your version of this file
* only under the terms of the LGPL and not to allow others to use
* your version of this file under the MPL, indicate your decision by
* deleting the provisions above and replace them with the notice and
* other provisions required by the LGPL. If you do not delete the
* provisions above, a recipient may use your version of this file
* under either the MPL or the LGPL.
*/
/*
* This code is derived from GdkRgb.
* For more information on GdkRgb, see http://www.levien.com/gdkrgb/
* Raph Levien <raph@acm.org>
*/
/* Ported by Christopher Blizzard to Xlib. With permission from the
* original authors of this file, the contents of this file are also
* redistributable under the terms of the Mozilla Public license. For
* information about the Mozilla Public License, please see the
* license information at http://www.mozilla.org/MPL/
*/
/* This code is copyright the following authors:
* Raph Levien <raph@acm.org>
* Manish Singh <manish@gtk.org>
* Tim Janik <timj@gtk.org>
* Peter Mattis <petm@xcf.berkeley.edu>
* Spencer Kimball <spencer@xcf.berkeley.edu>
* Josh MacDonald <jmacd@xcf.berkeley.edu>
* Christopher Blizzard <blizzard@redhat.com>
* Owen Taylor <otaylor@redhat.com>
* Shawn T. Amundson <amundson@gtk.org>
*/
#ifndef __XLIB_RGB_H__
#define __XLIB_RGB_H__
#include <glib.h>
G_BEGIN_DECLS
#include <X11/Xlib.h>
#include <X11/Xutil.h>
typedef struct _XlibRgbCmap XlibRgbCmap;
struct _XlibRgbCmap {
unsigned int colors[256];
unsigned char lut[256]; /* for 8-bit modes */
};
void
xlib_rgb_init (Display *display, Screen *screen);
void
xlib_rgb_init_with_depth (Display *display, Screen *screen, int prefDepth);
unsigned long
xlib_rgb_xpixel_from_rgb (guint32 rgb);
void
xlib_rgb_gc_set_foreground (GC gc, guint32 rgb);
void
xlib_rgb_gc_set_background (GC gc, guint32 rgb);
typedef enum
{
XLIB_RGB_DITHER_NONE,
XLIB_RGB_DITHER_NORMAL,
XLIB_RGB_DITHER_MAX
} XlibRgbDither;
void
xlib_draw_rgb_image (Drawable drawable,
GC gc,
int x,
int y,
int width,
int height,
XlibRgbDither dith,
unsigned char *rgb_buf,
int rowstride);
void
xlib_draw_rgb_image_dithalign (Drawable drawable,
GC gc,
int x,
int y,
int width,
int height,
XlibRgbDither dith,
unsigned char *rgb_buf,
int rowstride,
int xdith,
int ydith);
void
xlib_draw_rgb_32_image (Drawable drawable,
GC gc,
int x,
int y,
int width,
int height,
XlibRgbDither dith,
unsigned char *buf,
int rowstride);
void
xlib_draw_gray_image (Drawable drawable,
GC gc,
int x,
int y,
int width,
int height,
XlibRgbDither dith,
unsigned char *buf,
int rowstride);
XlibRgbCmap *
xlib_rgb_cmap_new (guint32 *colors, int n_colors);
void
xlib_rgb_cmap_free (XlibRgbCmap *cmap);
void
xlib_draw_indexed_image (Drawable drawable,
GC gc,
int x,
int y,
int width,
int height,
XlibRgbDither dith,
unsigned char *buf,
int rowstride,
XlibRgbCmap *cmap);
/* Below are some functions which are primarily useful for debugging
and experimentation. */
Bool
xlib_rgb_ditherable (void);
void
xlib_rgb_set_verbose (Bool verbose);
/* experimental colormap stuff */
void
xlib_rgb_set_install (Bool install);
void
xlib_rgb_set_min_colors (int min_colors);
Colormap
xlib_rgb_get_cmap (void);
Visual *
xlib_rgb_get_visual (void);
XVisualInfo *
xlib_rgb_get_visual_info (void);
int
xlib_rgb_get_depth (void);
Display *
xlib_rgb_get_display (void);
Screen *
xlib_rgb_get_screen (void);
G_END_DECLS
#endif /* __XLIB_RGB_H__ */

16
demos/Makefile.am
View File

@ -12,12 +12,10 @@ INCLUDES = \
$(GTK_DEP_CFLAGS)
DEPS = \
$(top_builddir)/gdk-pixbuf/libgdk_pixbuf-$(GTK_API_VERSION).la \
$(top_builddir)/gdk/$(gdktargetlib) \
$(top_builddir)/gtk/$(gtktargetlib)
LDADDS = \
$(top_builddir)/gdk-pixbuf/libgdk_pixbuf-$(GTK_API_VERSION).la \
$(top_builddir)/gdk/$(gdktargetlib) \
$(top_builddir)/gtk/$(gtktargetlib) \
$(GTK_DEP_LIBS) \
@ -32,21 +30,11 @@ noinst_PROGRAMS = \
pixbuf-demo
# Need to build test-inline-pixbufs.h for testpixbuf
if HAVE_PNG
noinst_PROGRAMS += testpixbuf
BUILT_SOURCES = test-inline-pixbufs.h
endif
if CROSS_COMPILING
pixbuf_csource=$(GDK_PIXBUF_CSOURCE)
pixbuf_csource_deps=
else
pixbuf_csource=GDK_PIXBUF_MODULE_FILE=$(top_builddir)/gdk-pixbuf/gdk-pixbuf.loaders $(top_builddir)/gdk-pixbuf/gdk-pixbuf-csource
pixbuf_csource_deps=$(top_builddir)/gdk-pixbuf/gdk-pixbuf-csource $(top_builddir)/gdk-pixbuf/gdk-pixbuf.loaders
endif
test-inline-pixbufs.h: $(pixbuf_csource_deps) apple-red.png gnome-foot.png
$(pixbuf_csource) --raw --build-list \
test-inline-pixbufs.h: apple-red.png gnome-foot.png
$(GDK_PIXBUF_CSOURCE) --raw --build-list \
apple_red $(srcdir)/apple-red.png \
gnome_foot $(srcdir)/gnome-foot.png \
> test-inline-pixbufs.h \

5
demos/gtk-demo/Makefile.am
View File

@ -55,15 +55,14 @@ INCLUDES = \
$(GTK_DEP_CFLAGS)
DEPS = \
$(top_builddir)/gdk-pixbuf/libgdk_pixbuf-$(GTK_API_VERSION).la \
$(top_builddir)/gdk/$(gdktargetlib) \
$(top_builddir)/gtk/$(gtktargetlib)
LDADDS = \
$(top_builddir)/gdk-pixbuf/libgdk_pixbuf-$(GTK_API_VERSION).la \
$(top_builddir)/gdk/$(gdktargetlib) \
$(top_builddir)/gtk/$(gtktargetlib) \
$(GTK_DEP_LIBS)
$(GTK_DEP_LIBS) \
-lm
bin_PROGRAMS = gtk-demo

2
docs/reference/Makefile.am
View File

@ -1,7 +1,7 @@
## Process this file with automake to produce Makefile.in
include $(top_srcdir)/Makefile.decl
SUBDIRS = gdk-pixbuf gdk gtk libgail-util
SUBDIRS = gdk gtk libgail-util
GITIGNOREFILES = */*.1

99
docs/reference/gdk-pixbuf/Makefile.am
View File

@ -1,99 +0,0 @@
## Process this file with automake to produce Makefile.in
include $(top_srcdir)/Makefile.decl
AUTOMAKE_OPTIONS = 1.6
# The name of the module.
DOC_MODULE=gdk-pixbuf
# The top-level SGML file.
DOC_MAIN_SGML_FILE=gdk-pixbuf.sgml
# Extra options to supply to gtkdoc-scan
SCAN_OPTIONS=--source-dir=../../../contrib/gdk-pixbuf-xlib --deprecated-guards="GDK_PIXBUF_ENABLE_BROKEN|GDK_PIXBUF_DISABLE_DEPRECATED"
# The directory containing the source code. Relative to $(srcdir)
DOC_SOURCE_DIR=../../../gdk-pixbuf
# Used for dependencies
HFILE_GLOB=$(top_srcdir)/gdk-pixbuf/*.h $(top_srcdir)/contrib/gdk-pixbuf-xlib/*.h
CFILE_GLOB=$(top_srcdir)/gdk-pixbuf/*.c $(top_srcdir)/contrib/gdk-pixbuf-xlib/*.c
# Header files to ignore when scanning
IGNORE_HFILES= \
pixops \
gdk-pixbuf-alias.h \
gdk-pixbuf-marshal.h \
gdk-pixbuf-xlib-private.h \
gdk-pixbuf-i18n.h \
gdk-pixbuf-private.h \
io-gif-animation.h \
io-ani-animation.h \
xpm-color-table.h \
test-images.h
INCLUDES = \
-I$(top_srcdir) \
-I$(top_builddir) \
-I$(top_builddir)/gdk \
$(GTK_DEBUG_FLAGS) \
$(GTK_DEP_CFLAGS)
GTKDOC_LIBS = \
$(top_builddir)/gdk-pixbuf/libgdk_pixbuf-$(GTK_API_VERSION).la \
$(top_builddir)/gdk/$(gdktargetlib) \
$(top_builddir)/gtk/$(gtktargetlib) \
$(GTK_DEP_LIBS)
# Extra options to supply to gtkdoc-mkdb
MKDB_OPTIONS=--main-sgml-file=$(DOC_MAIN_SGML_FILE) --sgml-mode --source-dir=../../../contrib/gdk-pixbuf-xlib --output-format=xml --name-space=gdk_pixbuf
# Extra SGML files that are included by DOC_MAIN_SGML_FILE
content_files = \
version.xml \
gdk-pixbuf-from-drawables.sgml \
gdk-pixbuf-rendering.sgml \
gdk-pixbuf.sgml \
porting-from-imlib.sgml \
gdk-pixbuf-csource.xml \
gdk-pixbuf-query-loaders.xml
# Images to copy into HTML directory
HTML_IMAGES = composite.png
# Extra options to supply to gtkdoc-fixref
FIXXREF_OPTIONS= --extra-dir=$(GLIB_PREFIX)/share/gtk-doc/html/gobject \
--extra-dir=$(GLIB_PREFIX)/share/gtk-doc/html/glib
include $(top_srcdir)/gtk-doc.make
# Other files to distribute
EXTRA_DIST += version.xml.in \
composite.png \
composite.dia \
apple-red-1a.png \
apple-red-2c.png \
gnome-gmush-1.png
########################################################################
if ENABLE_MAN
man_MANS = gdk-pixbuf-csource.1 gdk-pixbuf-query-loaders.1
%.1 : %.xml
@XSLTPROC@ -nonet http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl $<
BUILT_EXTRA_DIST = $(man_MANS)
endif
dist-hook-local: $(BUILT_EXTRA_DIST)
files='$(BUILT_EXTRA_DIST)'; \
for f in $$files; do \
if test -f $$f; then d=.; else d=$(srcdir); fi; \
cp $$d/$$f $(distdir) || exit 1; done
-include $(top_srcdir)/git.mk

BIN
docs/reference/gdk-pixbuf/apple-red-1a.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 29 KiB

BIN
docs/reference/gdk-pixbuf/apple-red-2c.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 19 KiB

BIN
docs/reference/gdk-pixbuf/composite.dia
View File

Binary file not shown.

BIN
docs/reference/gdk-pixbuf/composite.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 104 KiB

177
docs/reference/gdk-pixbuf/gdk-pixbuf-csource.xml
View File

@ -1,177 +0,0 @@
<?xml version="1.0"?>
<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
"http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd" [
]>
<refentry id="gdk-pixbuf-csource">
<refmeta>
<refentrytitle>gdk-pixbuf-csource</refentrytitle>
<manvolnum>1</manvolnum>
</refmeta>
<refnamediv>
<refname>gdk-pixbuf-csource</refname>
<refpurpose>C code generation utility for GdkPixbuf images</refpurpose>
</refnamediv>
<refsynopsisdiv>
<cmdsynopsis>
<command>gdk-pixbuf-csource</command>
<arg choice="opt">options</arg>
<arg choice="opt">image</arg>
</cmdsynopsis>
<cmdsynopsis>
<command>gdk-pixbuf-csource</command>
<arg choice="opt">options</arg>
<arg choice="plain">--build-list</arg>
<arg rep="repeat">
<arg>name</arg>
<arg>image</arg>
</arg>
</cmdsynopsis>
</refsynopsisdiv>
<refsect1><title>Description</title>
<para>
<command>gdk-pixbuf-csource</command> is a small utility that generates C code
containing images, useful for compiling images directly into programs.
</para>
</refsect1>
<refsect1><title>Invocation</title>
<para>
<command>gdk-pixbuf-csource</command> either takes as input one image file name
to generate code for, or, using the <option>--build-list</option> option, a
list of (<replaceable>name</replaceable>, <replaceable>image</replaceable>)
pairs to generate code for a list of images into named variables.
</para>
<refsect2><title>Options</title>
<variablelist>
<varlistentry>
<term><option>--stream</option></term>
<listitem><para>
Generate pixbuf data stream (a single string containing a serialized
<structname>GdkPixdata</structname> structure in network byte order).
</para></listitem>
</varlistentry>
<varlistentry>
<term><option>--struct</option></term>
<listitem><para>
Generate GdkPixdata structure (needs the <structname>GdkPixdata</structname>
structure definition from <filename>gdk-pixdata.h</filename>).
</para></listitem>
</varlistentry>
<varlistentry>
<term><option>--macros</option></term>
<listitem><para>
Generate *_ROWSTRIDE, *_WIDTH, *_HEIGHT, *_BYTES_PER_PIXEL and
*_RLE_PIXEL_DATA or *_PIXEL_DATA macro definitions for the image.
</para></listitem>
</varlistentry>
<varlistentry>
<term><option>--rle</option></term>
<listitem><para>
Enables run-length encoding for the generated pixel data (default).
</para></listitem>
</varlistentry>
<varlistentry>
<term><option>--raw</option></term>
<listitem><para>
Disables run-length encoding for the generated pixel data.
</para></listitem>
</varlistentry>
<varlistentry>
<term><option>--extern</option></term>
<listitem><para>
Generate extern symbols.
</para></listitem>
</varlistentry>
<varlistentry>
<term><option>--static</option></term>
<listitem><para>
Generate static symbols (default).
</para></listitem>
</varlistentry>
<varlistentry>
<term><option>--decoder</option></term>
<listitem><para>
Provide a *_RUN_LENGTH_DECODE(image_buf, rle_data, size, bpp) macro definition
to decode run-length encoded image data.
</para></listitem>
</varlistentry>
<varlistentry>
<term><option>--name=identifier</option></term>
<listitem><para>
Specifies the identifier name (prefix) for the generated variables or
macros (useful only if <option>--build-list</option> was not specified).
</para></listitem>
</varlistentry>
<varlistentry>
<term><option>--build-list</option></term>
<listitem><para>
Enables (<replaceable>name</replaceable>, <replaceable>image</replaceable>)
pair parsing mode.
</para></listitem>
</varlistentry>
<varlistentry>
<term><option>-h</option>, <option>--help</option></term>
<listitem><para>
Print brief help and exit.
</para></listitem>
</varlistentry>
<varlistentry>
<term><option>-v</option>, <option>--version</option></term>
<listitem><para>
Print version and exit.
</para></listitem>
</varlistentry>
<varlistentry>
<term><option>--g-fatal-warnings</option></term>
<listitem><para>
Make warnings fatal (causes the program to abort).
</para></listitem>
</varlistentry>
</variablelist>
</refsect2>
</refsect1>
<refsect1><title>See also</title>
<para>
The <structname>GdkPixbuf</structname> documentation, shipped with the
Gtk+ distribution, available from <ulink url="http://www.gtk.org">www.gtk.org</ulink>.
</para>
</refsect1>
<refsect1><title>Bugs</title>
<para>
The runlength encoder gets out of sync with the pixel boundaries, since
it includes the rowstride padding in the encoded stream. Furthermore, it
generates pixbufs with suboptimal rowstride in some cases.
</para>
</refsect1>
<refsect1><title>Author</title>
<para>
<command>gdk-pixbuf-csource</command> was written by Tim Janik
<email>timj@gtk.org</email>.
</para>
<para>
This manual page was provided by Tim Janik <email>timj@gtk.org</email>.
</para>
</refsect1>
</refentry>

29
docs/reference/gdk-pixbuf/gdk-pixbuf-from-drawables.sgml
View File

@ -1,29 +0,0 @@
<?xml version="1.0"?>
<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
"http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd" [
]>
<refentry id="gdk-pixbuf-gdk-pixbuf-from-drawables">
<refmeta>
<refentrytitle>Drawables to Pixbufs</refentrytitle>
<manvolnum>3</manvolnum>
<refmiscinfo>GDK-PIXBUF Library</refmiscinfo>
</refmeta>
<refnamediv>
<refname>Drawables to Pixbufs</refname><refpurpose>Getting parts of a GDK drawable's image data into a pixbuf.</refpurpose>
</refnamediv>
<refsect1>
<title>Description</title>
<para>
The functions to take the image data from a GDK drawable and dump it
into a pixbuf are contained in GDK, see the
<link linkend="gdk-Pixbufs">Pixbufs</link> section of the GDK
documentation.
</para>
</refsect1>
</refentry>

0
docs/reference/gdk-pixbuf/gdk-pixbuf-overrides.txt
View File

55
docs/reference/gdk-pixbuf/gdk-pixbuf-query-loaders.xml
View File

@ -1,55 +0,0 @@
<?xml version="1.0"?>
<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
"http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd" [
]>
<refentry id="gdk-pixbuf-query-loaders">
<refmeta>
<refentrytitle>gdk-pixbuf-query-loaders</refentrytitle>
<manvolnum>1</manvolnum>
</refmeta>
<refnamediv>
<refname>gdk-pixbuf-query-loaders</refname>
<refpurpose>GdkPixbuf loader registration utility</refpurpose>
</refnamediv>
<refsynopsisdiv>
<cmdsynopsis>
<command>gdk-pixbuf-query-loaders</command>
<arg choice="opt" rep="repeat">module</arg>
</cmdsynopsis>
</refsynopsisdiv>
<refsect1><title>Description</title>
<para>
<command>gdk-pixbuf-query-loaders</command> collects information about loadable
modules for <application>gdk-pixbuf</application> and writes it to <filename>stdout</filename>.
</para>
<para>
If called without arguments, it looks for modules in the
<application>gdk-pixbuf</application> loader directory.
</para>
<para>
If called with arguments, it looks for the specified modules. The arguments
may be absolute or relative paths.
</para>
</refsect1>
<refsect1><title>Environment</title>
<para>
The environment variable <envar>GDK_PIXBUF_MODULEDIR</envar> can be used
to specify a different loader directory. The default <application>gdk-pixbuf</application> loader
directory is <filename><replaceable>libdir</replaceable>/gtk-2.0/<replaceable>version</replaceable>/loaders</filename>.
</para>
</refsect1>
<refsect1><title>Bugs</title>
<para>
None known yet.
</para>
</refsect1>
</refentry>

32
docs/reference/gdk-pixbuf/gdk-pixbuf-rendering.sgml
View File

@ -1,32 +0,0 @@
<?xml version="1.0"?>
<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
"http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd" [
]>
<refentry id="gdk-pixbuf-gdk-pixbuf-rendering">
<refmeta>
<refentrytitle>Rendering</refentrytitle>
<manvolnum>3</manvolnum>
<refmiscinfo>GDK-PIXBUF Library</refmiscinfo>
</refmeta>
<refnamediv>
<refname>Rendering</refname><refpurpose>Rendering a pixbuf to a GDK drawable.</refpurpose>
</refnamediv>
<refsect1>
<title>Description</title>
<para>
The functions to render pixbufs to GDK drawables are contained in
GDK, see the <link linkend="gdk-Pixbufs">Pixbufs</link> section
of the GDK documentation.
</para>
</refsect1>
</refentry>

302
docs/reference/gdk-pixbuf/gdk-pixbuf-sections.txt
View File

@ -1,302 +0,0 @@
<INCLUDE>gdk-pixbuf/gdk-pixbuf.h</INCLUDE>
<SECTION>
<TITLE>Versioning</TITLE>
<FILE>initialization_versions</FILE>
<SUBSECTION>
gdk_pixbuf_version
gdk_pixbuf_major_version
gdk_pixbuf_minor_version
gdk_pixbuf_micro_version
GDK_PIXBUF_VERSION
GDK_PIXBUF_MAJOR
GDK_PIXBUF_MINOR
GDK_PIXBUF_MICRO
<SUBSECTION Private>
GDK_PIXBUF_VAR
</SECTION>
<SECTION>
<FILE>gdk-pixbuf</FILE>
GdkPixbufError
GDK_PIXBUF_ERROR
GdkColorspace
GdkPixbufAlphaMode
GdkPixbuf
gdk_pixbuf_get_colorspace
gdk_pixbuf_get_n_channels
gdk_pixbuf_get_has_alpha
gdk_pixbuf_get_bits_per_sample
gdk_pixbuf_get_pixels
gdk_pixbuf_get_width
gdk_pixbuf_get_height
gdk_pixbuf_get_rowstride
gdk_pixbuf_get_option
<SUBSECTION Standard>
GDK_TYPE_PIXBUF_ERROR
GDK_TYPE_COLORSPACE
GDK_TYPE_PIXBUF_ALPHA_MODE
GDK_PIXBUF
GDK_TYPE_PIXBUF
GDK_IS_PIXBUF
<SUBSECTION Private>
gdk_pixbuf_get_type
gdk_pixbuf_error_quark
gdk_colorspace_get_type
gdk_pixbuf_alpha_mode_get_type
gdk_pixbuf_error_get_type
</SECTION>
<SECTION>
<FILE>refcounting</FILE>
gdk_pixbuf_ref
gdk_pixbuf_unref
GdkPixbufDestroyNotify
</SECTION>
<SECTION>
<FILE>file-loading</FILE>
gdk_pixbuf_new_from_file
gdk_pixbuf_new_from_file_at_size
gdk_pixbuf_new_from_file_at_scale
gdk_pixbuf_get_file_info
gdk_pixbuf_new_from_stream
gdk_pixbuf_new_from_stream_at_scale
</SECTION>
<SECTION>
<FILE>file-saving</FILE>
gdk_pixbuf_savev
gdk_pixbuf_save
GdkPixbufSaveFunc
gdk_pixbuf_save_to_callback
gdk_pixbuf_save_to_callbackv
gdk_pixbuf_save_to_buffer
gdk_pixbuf_save_to_bufferv
gdk_pixbuf_save_to_stream
</SECTION>
<SECTION>
<FILE>creating</FILE>
gdk_pixbuf_new
gdk_pixbuf_new_from_data
gdk_pixbuf_new_from_xpm_data
gdk_pixbuf_new_from_inline
gdk_pixbuf_new_subpixbuf
gdk_pixbuf_copy
</SECTION>
<SECTION>
<INCLUDE>gdk-pixbuf/gdk-pixdata.h</INCLUDE>
<FILE>inline</FILE>
GdkPixdata
GdkPixdataType
GdkPixdataDumpType
GDK_PIXBUF_MAGIC_NUMBER
GDK_PIXDATA_HEADER_LENGTH
gdk_pixdata_from_pixbuf
gdk_pixbuf_from_pixdata
gdk_pixdata_serialize
gdk_pixdata_deserialize
gdk_pixdata_to_csource
</SECTION>
<SECTION>
<FILE>util</FILE>
gdk_pixbuf_add_alpha
gdk_pixbuf_copy_area
gdk_pixbuf_saturate_and_pixelate
gdk_pixbuf_apply_embedded_orientation
gdk_pixbuf_fill
</SECTION>
<SECTION>
<FILE>animation</FILE>
GdkPixbufAnimation
GdkPixbufAnimationIter
gdk_pixbuf_animation_new_from_file
gdk_pixbuf_animation_ref
gdk_pixbuf_animation_unref
gdk_pixbuf_animation_get_width
gdk_pixbuf_animation_get_height
gdk_pixbuf_animation_get_iter
gdk_pixbuf_animation_is_static_image
gdk_pixbuf_animation_get_static_image
gdk_pixbuf_animation_iter_advance
gdk_pixbuf_animation_iter_get_delay_time
gdk_pixbuf_animation_iter_on_currently_loading_frame
gdk_pixbuf_animation_iter_get_pixbuf
<SUBSECTION>
GdkPixbufSimpleAnim
gdk_pixbuf_simple_anim_new
gdk_pixbuf_simple_anim_add_frame
gdk_pixbuf_simple_anim_set_loop
gdk_pixbuf_simple_anim_get_loop
<SUBSECTION Standard>
GDK_PIXBUF_ANIMATION
GDK_TYPE_PIXBUF_ANIMATION
GDK_IS_PIXBUF_ANIMATION
GDK_IS_PIXBUF_ANIMATION_ITER
GDK_PIXBUF_ANIMATION_ITER
GDK_TYPE_PIXBUF_ANIMATION_ITER
GDK_PIXBUF_SIMPLE_ANIM_GET_CLASS
GDK_IS_PIXBUF_SIMPLE_ANIM
GDK_PIXBUF_SIMPLE_ANIM_CLASS
GDK_IS_PIXBUF_SIMPLE_ANIM_CLASS
GDK_TYPE_PIXBUF_SIMPLE_ANIM
GDK_PIXBUF_SIMPLE_ANIM
GDK_TYPE_PIXBUF_SCALED_ANIM
GDK_TYPE_PIXBUF_SCALED_ANIM_ITER
<SUBSECTION Private>
gdk_pixbuf_non_anim_new
gdk_pixbuf_animation_get_type
gdk_pixbuf_animation_iter_get_type
gdk_pixbuf_simple_anim_get_type
gdk_pixbuf_simple_anim_iter_get_type
GdkPixbufSimpleAnimClass
gdk_pixbuf_scaled_anim_get_type
gdk_pixbuf_scaled_anim_iter_get_type
GdkPixbufScaledAnimClass
GdkPixbufScaledAnim
</SECTION>
<SECTION>
<FILE>scaling</FILE>
GdkInterpType
gdk_pixbuf_scale_simple
gdk_pixbuf_scale
gdk_pixbuf_composite_color_simple
gdk_pixbuf_composite
gdk_pixbuf_composite_color
GdkPixbufRotation
gdk_pixbuf_rotate_simple
gdk_pixbuf_flip
<SUBSECTION Standard>
GDK_TYPE_INTERP_TYPE
GDK_TYPE_PIXBUF_ROTATION
<SUBSECTION Private>
gdk_interp_type_get_type
gdk_pixbuf_rotation_get_type
</SECTION>
<SECTION>
<FILE>gdk-pixbuf-loader</FILE>
<TITLE>GdkPixbufLoader</TITLE>
GdkPixbufLoader
gdk_pixbuf_loader_new
gdk_pixbuf_loader_new_with_type
gdk_pixbuf_loader_new_with_mime_type
gdk_pixbuf_loader_get_format
gdk_pixbuf_loader_write
gdk_pixbuf_loader_set_size
gdk_pixbuf_loader_get_pixbuf
gdk_pixbuf_loader_get_animation
gdk_pixbuf_loader_close
<SUBSECTION Standard>
GDK_PIXBUF_LOADER
GDK_PIXBUF_LOADER_GET_CLASS
GDK_TYPE_PIXBUF_LOADER
GDK_IS_PIXBUF_LOADER
GDK_PIXBUF_LOADER_CLASS
GDK_IS_PIXBUF_LOADER_CLASS
<SUBSECTION Private>
GdkPixbufLoaderClass
gdk_pixbuf_loader_get_type
</SECTION>
<SECTION>
<TITLE>Module Interface</TITLE>
<FILE>module_interface</FILE>
gdk_pixbuf_set_option
gdk_pixbuf_get_formats
gdk_pixbuf_format_get_name
gdk_pixbuf_format_get_description
gdk_pixbuf_format_get_mime_types
gdk_pixbuf_format_get_extensions
gdk_pixbuf_format_is_writable
gdk_pixbuf_format_is_scalable
gdk_pixbuf_format_is_disabled
gdk_pixbuf_format_set_disabled
gdk_pixbuf_format_get_license
GdkPixbufFormat
GdkPixbufFormatFlags
GdkPixbufModulePattern
GdkPixbufModuleFillVtableFunc
GdkPixbufModuleFillInfoFunc
GdkPixbufModuleSizeFunc
GdkPixbufModulePreparedFunc
GdkPixbufModuleUpdatedFunc
GdkPixbufModule
<SUBSECTION Animation>
GdkPixbufAnimationClass
GdkPixbufAnimationIterClass
<SUBSECTION Standard>
GDK_PIXBUF_ANIMATION_GET_CLASS
GDK_IS_PIXBUF_ANIMATION_ITER_CLASS
GDK_PIXBUF_ANIMATION_ITER_CLASS
GDK_IS_PIXBUF_ANIMATION_CLASS
GDK_PIXBUF_ANIMATION_ITER_GET_CLASS
GDK_PIXBUF_ANIMATION_CLASS
</SECTION>
<SECTION>
<FILE>gdk-pixbuf-xlib-init</FILE>
gdk_pixbuf_xlib_init
gdk_pixbuf_xlib_init_with_depth
</SECTION>
<SECTION>
<FILE>gdk-pixbuf-xlib-rendering</FILE>
gdk_pixbuf_xlib_render_threshold_alpha
gdk_pixbuf_xlib_render_to_drawable
gdk_pixbuf_xlib_render_to_drawable_alpha
gdk_pixbuf_xlib_render_pixmap_and_mask
</SECTION>
<SECTION>
<FILE>gdk-pixbuf-xlib-from-drawables</FILE>
gdk_pixbuf_xlib_get_from_drawable
</SECTION>
<SECTION>
<FILE>gdk-pixbuf-xlib-rgb</FILE>
XlibRgbCmap
XlibRgbDither
xlib_rgb_init
xlib_rgb_init_with_depth
xlib_rgb_xpixel_from_rgb
xlib_rgb_gc_set_foreground
xlib_rgb_gc_set_background
xlib_draw_rgb_image
xlib_draw_rgb_image_dithalign
xlib_draw_rgb_32_image
xlib_draw_gray_image
xlib_rgb_cmap_new
xlib_rgb_cmap_free
xlib_draw_indexed_image
xlib_rgb_ditherable
xlib_rgb_set_verbose
xlib_rgb_set_install
xlib_rgb_set_min_colors
xlib_rgb_get_cmap
xlib_rgb_get_visual
xlib_rgb_get_visual_info
xlib_rgb_get_depth
xlib_rgb_get_display
xlib_rgb_get_screen
</SECTION>

192
docs/reference/gdk-pixbuf/gdk-pixbuf.sgml
View File

@ -1,192 +0,0 @@
<?xml version="1.0"?>
<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
"http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd" [
<!ENTITY % local.common.attrib "xmlns:xi CDATA #FIXED 'http://www.w3.org/2003/XInclude'">
<!ENTITY version SYSTEM "version.xml">
<!ENTITY gdk-pixbuf "<application>gdk-pixbuf</application>">
<!ENTITY Imlib "<application>Imlib</application>">
]>
<book id="index" xmlns:xi="http://www.w3.org/2003/XInclude">
<bookinfo>
<title>GDK-PixBuf Reference Manual</title>
<releaseinfo>
Version &version;
The latest version of this documentation can be found on-line at
<ulink role="online-location" url="http://library.gnome.org/devel/gdk-pixbuf/unstable/">http://library.gnome.org/devel/gdk-pixbuf/unstable/</ulink>.
</releaseinfo>
<authorgroup>
<author>
<firstname>Federico</firstname>
<surname>Mena Quintero</surname>
<affiliation>
<address>
<email>federico@gimp.org</email>
</address>
</affiliation>
</author>
</authorgroup>
<copyright>
<year>2000</year>
<holder>The Free Software Foundation</holder>
</copyright>
<legalnotice>
<para>
Permission is granted to copy, distribute and/or modify this
document under the terms of the <citetitle>GNU Free
Documentation License</citetitle>, Version 1.1 or any later
version published by the Free Software Foundation with no
Invariant Sections, no Front-Cover Texts, and no Back-Cover
Texts. You may obtain a copy of the <citetitle>GNU Free
Documentation License</citetitle> from the Free Software
Foundation by visiting <ulink type="http"
url="http://www.fsf.org">their Web site</ulink> or by writing
to:
<address>
The Free Software Foundation, Inc.,
<street>59 Temple Place</street> - Suite 330,
<city>Boston</city>, <state>MA</state> <postcode>02111-1307</postcode>,
<country>USA</country>
</address>
</para>
<para>
Many of the names used by companies to distinguish their
products and services are claimed as trademarks. Where those
names appear in any GNOME documentation, and those trademarks
are made aware to the members of the GNOME Documentation
Project, the names have been printed in caps or initial caps.
</para>
</legalnotice>
</bookinfo>
<reference>
<title>API Reference</title>
<partintro>
<para>
This part presents the class and function reference for the
&gdk-pixbuf; library. Classes are described together with
their methods; individual functions are grouped by functional
group.
</para>
</partintro>
<xi:include href="xml/initialization_versions.xml" />
<xi:include href="xml/gdk-pixbuf.xml" />
<xi:include href="xml/refcounting.xml" />
<xi:include href="xml/file-loading.xml" />
<xi:include href="xml/file-saving.xml" />
<xi:include href="xml/creating.xml" />
<xi:include href="xml/inline.xml" />
<xi:include href="xml/scaling.xml" />
<xi:include href="gdk-pixbuf-rendering.sgml" />
<xi:include href="gdk-pixbuf-from-drawables.sgml" />
<xi:include href="xml/util.xml" />
<xi:include href="xml/animation.xml" />
<xi:include href="xml/gdk-pixbuf-loader.xml" />
<xi:include href="xml/module_interface.xml" />
<xi:include href="xml/gdk-pixbuf-xlib-init.xml" />
<xi:include href="xml/gdk-pixbuf-xlib-rendering.xml" />
<xi:include href="xml/gdk-pixbuf-xlib-from-drawables.xml" />
<xi:include href="xml/gdk-pixbuf-xlib-rgb.xml" />
</reference>
<reference>
<title>Tools Reference</title>
<partintro>
<para>
This part presents the tools which are shipped with the
&gdk-pixbuf; library.
</para>
</partintro>
<xi:include href="gdk-pixbuf-csource.xml" />
<xi:include href="gdk-pixbuf-query-loaders.xml" />
</reference>
<index id="api-index-full">
<title>Index of all symbols</title>
<xi:include href="xml/api-index-full.xml"><xi:fallback /></xi:include>
</index>
<index id="api-index-deprecated" role="deprecated">
<title>Index of deprecated symbols</title>
<xi:include href="xml/api-index-deprecated.xml"><xi:fallback /></xi:include>
</index>
<index id="api-index-2-2" role="2.2">
<title>Index of new symbols in 2.2</title>
<xi:include href="xml/api-index-2.2.xml"><xi:fallback /></xi:include>
</index>
<index id="api-index-2-4" role="2.4">
<title>Index of new symbols in 2.4</title>
<xi:include href="xml/api-index-2.4.xml"><xi:fallback /></xi:include>
</index>
<index id="api-index-2-6" role="2.6">
<title>Index of new symbols in 2.6</title>
<xi:include href="xml/api-index-2.6.xml"><xi:fallback /></xi:include>
</index>
<index id="api-index-2-8" role="2.8">
<title>Index of new symbols in 2.8</title>
<xi:include href="xml/api-index-2.8.xml"><xi:fallback /></xi:include>
</index>
<index id="api-index-2-10" role="2.10">
<title>Index of new symbols in 2.10</title>
<xi:include href="xml/api-index-2.10.xml"><xi:fallback /></xi:include>
</index>
<index id="api-index-2-12" role="2.12">
<title>Index of new symbols in 2.12</title>
<xi:include href="xml/api-index-2.12.xml"><xi:fallback /></xi:include>
</index>
<index id="api-index-2-14" role="2.14">
<title>Index of new symbols in 2.14</title>
<xi:include href="xml/api-index-2.14.xml"><xi:fallback /></xi:include>
</index>
<xi:include href="porting-from-imlib.sgml" />
<!-- License -->
<appendix id="license">
<title>License</title>
<para>
This library is free software; you can redistribute it and/or
modify it under the terms of the <citetitle>GNU Library General
Public License</citetitle> as published by the Free Software
Foundation; either version 2 of the License, or (at your option)
any later version.
</para>
<para>
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
<citetitle>GNU Library General Public License</citetitle> for
more details.
</para>
<para>
You may obtain a copy of the <citetitle>GNU Library General
Public License</citetitle> from the Free Software Foundation by
visiting <ulink type="http" url="http://www.fsf.org">their Web
site</ulink> or by writing to:
<address>
Free Software Foundation, Inc.
<street>59 Temple Place</street> - Suite 330
<city>Boston</city>, <state>MA</state> <postcode>02111-1307</postcode>
<country>USA</country>
</address>
</para>
</appendix>
<xi:include href="xml/annotation-glossary.xml"><xi:fallback /></xi:include>
</book>

8
docs/reference/gdk-pixbuf/gdk-pixbuf.types
View File

@ -1,8 +0,0 @@
#include <gdk-pixbuf/gdk-pixbuf.h>
gdk_pixbuf_get_type
gdk_pixbuf_loader_get_type
gdk_pixbuf_animation_get_type
gdk_pixbuf_animation_iter_get_type
gdk_pixbuf_simple_anim_get_type

BIN
docs/reference/gdk-pixbuf/gnome-gmush-1.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 23 KiB

358
docs/reference/gdk-pixbuf/porting-from-imlib.sgml
View File

@ -1,358 +0,0 @@
<?xml version="1.0"?>
<!DOCTYPE appendix PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
"http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd" [
<!ENTITY gdk-pixbuf "<application>gdk-pixbuf</application>">
<!ENTITY Imlib "<application>Imlib</application>">
]>
<appendix>
<title>Porting applications from &Imlib; to &gdk-pixbuf;</title>
<para>
This appendix contains the basic steps needed to port an
application that uses the &Imlib; library to use &gdk-pixbuf;
instead.
</para>
<note>
<para>
This appendix refers to version 1 of the &Imlib; library; this
discussion is not relevant to Imlib 2. Also, we discuss the
gdk_imlib API instead of the Xlib-based API.
</para>
</note>
<!-- Introduction -->
<sect1>
<title>Introduction</title>
<para>
Prior to the GNOME 1.2 platform, the &Imlib; library was the
preferred way of loading and rendering images in GNOME
applications. Unfortunately, &Imlib; has important design
limitations that make it hard to write efficient and highly
modular applications.
</para>
<para>
The &gdk-pixbuf; library was designed as a solution to
&Imlib;'s shortcomings. It provides a simple, orthogonal API
and convenience functions for the most common operations. In
addition, it supports full transparency information for
images, or alpha channel. More importantly, it has
well-defined semantics for memory management through the use
of reference counting; &Imlib; has an intractably complex
memory management mechanism and cache that will make your head
spin.
</para>
</sect1>
<!-- Differences between Imlib and gdk-pixbuf -->
<sect1>
<title>Differences between &Imlib; and &gdk-pixbuf;</title>
<para>
Generally, applications that use &Imlib; do not have to be
changed extensively to use &gdk-pixbuf;; its simple and
flexible API makes things easy. This section describes the
differences between &Imlib; and &gdk-pixbuf;; you should take
these into account when modifying your applications to use
&gdk-pixbuf;.
</para>
<!-- Initialization -->
<sect2>
<title>Initialization</title>
<para>
The &gdk-pixbuf; library does not need to be initialized.
</para>
<note>
<para>
In GNOME applications you normally don't need to
initialize &Imlib;, as <function>gnome_init()</function>
calls <function>gdk_imlib_init()</function> automatically.
</para>
</note>
</sect2>
<!-- Memory management -->
<sect2>
<title>Memory management</title>
<para>
The &gdk-pixbuf; library provides a simple, well-defined
memory management mechanism for images in the form of
reference counting. This makes it very convenient to use
for large-scale applications that need to share images
between different parts of the program. In stark contrast,
&Imlib; has a terribly complex mechanism of an image and
pixmap cache which makes it very hard for applications to
share image structures between different parts of the
program. Unfortunately this mechanism makes things very
prone to memory leaks and tricky bugs.
</para>
<para>
The basic principle in &gdk-pixbuf; is that when you obtain
a new <link linkend="GdkPixbuf">GdkPixbuf</link> structure,
it is created with an initial reference count of 1. When
another part of the program wants to keep a reference to the
pixbuf, it should call <function>g_object_ref()</function>;
this will increase the reference count by 1. When some part
of the program does not need to keep a reference to a pixbuf
anymore and wants to release the pixbuf, it should call
<function>g_object_unref()</function>; this will decrease
the reference count by 1. When the reference count drops to
zero, the pixbuf gets destroyed or
<emphasis>finalized</emphasis> and its memory is freed.
</para>
<para>
For applications that need to implement a cache of loaded
images, &gdk-pixbuf; provides a way to hook to the last
unreference operation of a pixbuf; instead of finalizing the
pixbuf, the user-installed hook can decide to keep it around
in a cache instead.
</para>
<para>
Finally, &gdk-pixbuf; does not provide a cache of rendered
pixmaps. This is unnecessary for most applications, since
the scaling and rendering functions are quite fast and
applications may need to use subtly different values each
time they call these functions, for example, to take into
account dithering and zooming offsets.
</para>
<para>
Most applications will simply need to call
<function>g_object_ref()</function> when they want to keep
an extra reference to a pixbuf, and then
<function>g_object_unref()</function> when they are done
with it.
</para>
</sect2>
<!-- The Rendering Process -->
<sect2>
<title>The Rendering Process</title>
<para>
The &gdk-pixbuf; library has the policy of always rendering
pixbufs to GDK drawables you provide; it will not create
them for you. This is in general more flexible than
&Imlib;'s policy of always creating a pixmap and making you
use that instead.
</para>
<para>
The disadvantage of always having a pixmap created for you
is that it wastes memory in the X server if you intend to
copy that rendered data onto another drawable, for example,
the final destination window or a temporary pixmap for
drawing. This is the most common case, unfortunately, so
the &Imlib; policy introduces unnecessary copying.
</para>
<para>
Also, &Imlib; can only render pixmaps that are the whole
size of the source image; you cannot render just a subset
region of the image. This is inconvenient for applications
that need to render small portions at a time, such as
applications that do scrolling. Since the whole image must
be rendered at a time, this can lead to performance and
memory usage problems.
</para>
<para>
The &gdk-pixbuf; library lets you render any rectangular
region from an image onto any drawable that you provide.
This lets the application have fine control the way images
are rendered.
</para>
</sect2>
</sect1>
<!-- Converting Applications to gdk-pixbuf -->
<sect1>
<title>Converting Applications to &gdk-pixbuf;</title>
<para>
This sections describes the actual changes you need to make in
an &Imlib; program to make it use &gdk-pixbuf; instead.
</para>
<!-- Image loading and creation -->
<sect2>
<title>Image loading and creation</title>
<para>
The &gdk-pixbuf; library can load image files synchronously
(i.e. with a single function call), create images from RGB
data in memory, and as a convenience, it can also create
images from inline XPM data.
</para>
<para>
To load an image file in a single function call, simply use
<function>gdk_pixbuf_new_from_file()</function>. Note that
this will make the program block until the whole file has
been read. This function effectively replaces
<function>gdk_imlib_load_image()</function>.
</para>
<para>
If you have RGB data in memory, you can use
<function>gdk_pixbuf_new_from_data()</function> to create a
pixbuf out of it; this is a replacement for
<function>gdk_imlib_create_image_from_data()</function>.
&gdk-pixbuf; does not copy the image data; it is up to you
to define the ownership policy by providing a destroy
notification function that will be called when the image
data needs to be freed. The function you provide can then
free the data or do something else, as appropriate.
</para>
<para>
As a convenience, you can use the
<function>gdk_pixbuf_new_from_xpm_data()</function> function
to create a pixbuf out of inline XPM data that was compiled
into your C program. This is a replacement for
<function>gdk_imlib_create_image_from_xpm_data()</function>.
</para>
<para>
After you have created a pixbuf, you can manipulate it in
any way you please and then finally call
<function>g_object_unref()</function> when you are done
with it. This can be thought of as a replacement for
<function>gdk_imlib_destroy_image()</function> but with much
cleaner semantics.
</para>
</sect2>
<!-- Rendering Images -->
<sect2>
<title>Rendering Images</title>
<para>
Applications that use &Imlib; must first call
<function>gdk_imlib_render()</function> to render the whole
image data onto a pixmap that &Imlib; creates. Then they
must copy that pixmap's data into the final destination for
the image.
</para>
<para>
In contrast, &gdk-pixbuf; provides convenience functions to
render arbitrary rectangular regions of an image onto a
drawable that your application provides. You can use
<function>gdk_draw_pixbuf()</function> to do this; having
your application provide the destination drawable and
specify an arbitrary region means your application has
complete control over the way images are rendered.
</para>
<para>
As a convenience, &gdk-pixbuf; also provides the
<function>gdk_pixbuf_render_pixmap_and_mask()</function>
function; this will create new pixmap and mask drawables for
a whole pixbuf and render the image data onto them. Only
trivially simple applications should find a use for this
function, since usually you want finer control of how things
are rendered.
</para>
</sect2>
<!-- Scaling Images -->
<sect2>
<title>Scaling Images</title>
<para>
&Imlib; lets you render scaled image data at the time you
call <function>gdk_imlib_render()</function>. Again, this
unfortunately scales and renders the whole image onto a new
pixmap.
</para>
<para>
&gdk-pixbuf; provides a number of functions that do scaling
of arbitrary regions of a source pixbuf onto a destination
one. These functions can also perform compositing
operations against the data in the destination pixbuf or
against a solid color or a colored checkerboard.
<footnote>
<para>
You can use a colored checkerboard as the background for
compositing when you want to provide a visual indication
that the image has partially opaque areas. This is
normally used in image editing and viewing programs.
</para>
<para>
Compositing against a single solid color is actually a
special case of a checkerboard; it simply uses checks of
the same color.
</para>
</footnote>
</para>
<para>
Very simple applications may find it sufficient to use
<function>gdk_pixbuf_scale_simple()</function> or
<function>gdk_pixbuf_composite_color_simple()</function>.
These functions scale the whole source image at a time and
create a new pixbuf with the result.
</para>
<para>
More sophisticated applications will need to use
<function>gdk_pixbuf_scale()</function>,
<function>gdk_pixbuf_composite()</function>, or
<function>gdk_pixbuf_composite_color()</function> instead.
These functions let you scale and composite an arbitrary
region of the source pixbuf onto a destination pixbuf that
you provide.
</para>
</sect2>
<!-- Getting Image Data from a Drawable -->
<sect2>
<title>Getting Image Data from a Drawable</title>
<para>
&Imlib; lets you create an image by fetching a drawable's
contents from the X server and converting those into RGB
data. This is done with the
<function>gdk_imlib_create_image_from_drawable()</function>
function.
</para>
<para>
&gdk-pixbuf; provides the
<function>gdk_pixbuf_get_from_drawable()</function> function
instead. It lets you specify a destination pixbuf instead
of always creating a new one for you.
</para>
</sect2>
</sect1>
</appendix>
<!--
Local variables:
mode: sgml
sgml-parent-document: ("gdk-pixbuf.sgml" "book" "book" "")
End:
-->

200
docs/reference/gdk-pixbuf/tmpl/animation.sgml
View File

@ -1,200 +0,0 @@
<!-- ##### SECTION Title ##### -->
Animations
<!-- ##### SECTION Short_Description ##### -->
Animated images.
<!-- ##### SECTION Long_Description ##### -->
<para>
The &gdk-pixbuf; library provides a simple mechanism to load and represent
animations. An animation is conceptually a series of frames to be displayed
over time. Each frame is the same size. The animation may not be represented
as a series of frames internally; for example, it may be stored as a
sprite and instructions for moving the sprite around a background. To display
an animation you don't need to understand its representation, however; you just
ask &gdk-pixbuf; what should be displayed at a given point in time.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
#GdkPixbufLoader
</para>
<!-- ##### SECTION Stability_Level ##### -->
<!-- ##### SECTION Image ##### -->
<!-- ##### STRUCT GdkPixbufAnimation ##### -->
<para>
An opaque struct representing an animation.
</para>
<!-- ##### STRUCT GdkPixbufAnimationIter ##### -->
<para>
An opaque struct representing an iterator which points to a
certain position in an animation.
</para>
<!-- ##### FUNCTION gdk_pixbuf_animation_new_from_file ##### -->
<para>
</para>
@filename:
@error:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_animation_ref ##### -->
<para>
</para>
@animation:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_animation_unref ##### -->
<para>
</para>
@animation:
<!-- ##### FUNCTION gdk_pixbuf_animation_get_width ##### -->
<para>
</para>
@animation:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_animation_get_height ##### -->
<para>
</para>
@animation:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_animation_get_iter ##### -->
<para>
</para>
@animation:
@start_time:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_animation_is_static_image ##### -->
<para>
</para>
@animation:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_animation_get_static_image ##### -->
<para>
</para>
@animation:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_animation_iter_advance ##### -->
<para>
</para>
@iter:
@current_time:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_animation_iter_get_delay_time ##### -->
<para>
</para>
@iter:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_animation_iter_on_currently_loading_frame ##### -->
<para>
</para>
@iter:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_animation_iter_get_pixbuf ##### -->
<para>
</para>
@iter:
@Returns:
<!-- ##### STRUCT GdkPixbufSimpleAnim ##### -->
<para>
An opaque struct representing a simple animation.
</para>
<!-- ##### ARG GdkPixbufSimpleAnim:loop ##### -->
<para>
</para>
<!-- ##### FUNCTION gdk_pixbuf_simple_anim_new ##### -->
<para>
</para>
@width:
@height:
@rate:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_simple_anim_add_frame ##### -->
<para>
</para>
@animation:
@pixbuf:
<!-- ##### FUNCTION gdk_pixbuf_simple_anim_set_loop ##### -->
<para>
</para>
@animation:
@loop:
<!-- ##### FUNCTION gdk_pixbuf_simple_anim_get_loop ##### -->
<para>
</para>
@animation:
@Returns:

129
docs/reference/gdk-pixbuf/tmpl/creating.sgml
View File

@ -1,129 +0,0 @@
<!-- ##### SECTION Title ##### -->
Image Data in Memory
<!-- ##### SECTION Short_Description ##### -->
Creating a pixbuf from image data that is already in memory.
<!-- ##### SECTION Long_Description ##### -->
<para>
The most basic way to create a pixbuf is to wrap an existing pixel
buffer with a #GdkPixbuf structure. You can use the
gdk_pixbuf_new_from_data() function to do this You need to specify
the destroy notification function that will be called when the
data buffer needs to be freed; this will happen when a #GdkPixbuf
is finalized by the reference counting functions If you have a
chunk of static data compiled into your application, you can pass
in %NULL as the destroy notification function so that the data
will not be freed.
</para>
<para>
The gdk_pixbuf_new() function can be used as a convenience to
create a pixbuf with an empty buffer. This is equivalent to
allocating a data buffer using <function>malloc()</function> and
then wrapping it with gdk_pixbuf_new_from_data(). The gdk_pixbuf_new()
function will compute an optimal rowstride so that rendering can be
performed with an efficient algorithm.
</para>
<para>
As a special case, you can use the gdk_pixbuf_new_from_xpm_data()
function to create a pixbuf from inline XPM image data.
</para>
<para>
You can also copy an existing pixbuf with the gdk_pixbuf_copy()
function. This is not the same as just doing a g_object_ref()
on the old pixbuf; the copy function will actually duplicate the
pixel data in memory and create a new #GdkPixbuf structure for it.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
gdk_pixbuf_finalize().
</para>
<!-- ##### SECTION Stability_Level ##### -->
<!-- ##### SECTION Image ##### -->
<!-- ##### FUNCTION gdk_pixbuf_new ##### -->
<para>
</para>
@colorspace:
@has_alpha:
@bits_per_sample:
@width:
@height:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_new_from_data ##### -->
<para>
</para>
@data:
@colorspace:
@has_alpha:
@bits_per_sample:
@width:
@height:
@rowstride:
@destroy_fn:
@destroy_fn_data:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_new_from_xpm_data ##### -->
<para>
</para>
@data:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_new_from_inline ##### -->
<para>
</para>
@data_length:
@data:
@copy_pixels:
@error:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_new_subpixbuf ##### -->
<para>
</para>
@src_pixbuf:
@src_x:
@src_y:
@width:
@height:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_copy ##### -->
<para>
</para>
@pixbuf:
@Returns: <!--
Local variables:
mode: sgml
sgml-parent-document: ("../gdk-pixbuf.sgml" "book" "refsect2" "")
End:
-->

109
docs/reference/gdk-pixbuf/tmpl/file-loading.sgml
View File

@ -1,109 +0,0 @@
<!-- ##### SECTION Title ##### -->
File Loading
<!-- ##### SECTION Short_Description ##### -->
Loading a pixbuf from a file.
<!-- ##### SECTION Long_Description ##### -->
<para>
The &gdk-pixbuf; library provides a simple mechanism for loading
an image from a file in synchronous fashion. This means that the
library takes control of the application while the file is being
loaded; from the user's point of view, the application will block
until the image is done loading.
</para>
<para>
This interface can be used by applications in which blocking is
acceptable while an image is being loaded. It can also be used to
load small images in general. Applications that need progressive
loading can use the #GdkPixbufLoader functionality instead.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
#GdkPixbufLoader.
</para>
<!-- ##### SECTION Stability_Level ##### -->
<!-- ##### SECTION Image ##### -->
<!-- ##### FUNCTION gdk_pixbuf_new_from_file ##### -->
<para>
</para>
@filename:
@error:
@Returns: <!--
Local variables:
mode: sgml
sgml-parent-document: ("../gdk-pixbuf.sgml" "book" "refsect2" "")
End:
-->
<!-- ##### FUNCTION gdk_pixbuf_new_from_file_at_size ##### -->
<para>
</para>
@filename:
@width:
@height:
@error:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_new_from_file_at_scale ##### -->
<para>
</para>
@filename:
@width:
@height:
@preserve_aspect_ratio:
@error:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_get_file_info ##### -->
<para>
</para>
@filename:
@width:
@height:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_new_from_stream ##### -->
<para>
</para>
@stream:
@cancellable:
@error:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_new_from_stream_at_scale ##### -->
<para>
</para>
@stream:
@width:
@height:
@preserve_aspect_ratio:
@cancellable:
@error:
@Returns:

143
docs/reference/gdk-pixbuf/tmpl/file-saving.sgml
View File

@ -1,143 +0,0 @@
<!-- ##### SECTION Title ##### -->
File saving
<!-- ##### SECTION Short_Description ##### -->
Saving a pixbuf to a file.
<!-- ##### SECTION Long_Description ##### -->
<para>
These functions allow to save a #GdkPixbuf in a number of
file formats. The formatted data can be written to a file
or to a memory buffer. &gdk-pixbuf; can also call a user-defined
callback on the data, which allows to e.g. write the image
to a socket or store it in a database.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### SECTION Stability_Level ##### -->
<!-- ##### SECTION Image ##### -->
<!-- ##### FUNCTION gdk_pixbuf_savev ##### -->
<para>
</para>
@pixbuf:
@filename:
@type:
@option_keys:
@option_values:
@error:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_save ##### -->
<para>
</para>
@pixbuf:
@filename:
@type:
@error:
@Varargs:
@Returns:
<!-- ##### USER_FUNCTION GdkPixbufSaveFunc ##### -->
<para>
Specifies the type of the function passed to
gdk_pixbuf_save_to_callback(). It is called once for each block of
bytes that is "written" by gdk_pixbuf_save_to_callback(). If
successful it should return %TRUE. If an error occurs it should set
@error and return %FALSE, in which case gdk_pixbuf_save_to_callback()
will fail with the same error.
</para>
@buf: bytes to be written.
@count: number of bytes in @buf.
@error: A location to return an error.
@data: user data passed to gdk_pixbuf_save_to_callback().
@Returns: %TRUE if successful, %FALSE (with @error set) if failed.
@Since: 2.4
<!-- ##### FUNCTION gdk_pixbuf_save_to_callback ##### -->
<para>
</para>
@pixbuf:
@save_func:
@user_data:
@type:
@error:
@Varargs:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_save_to_callbackv ##### -->
<para>
</para>
@pixbuf:
@save_func:
@user_data:
@type:
@option_keys:
@option_values:
@error:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_save_to_buffer ##### -->
<para>
</para>
@pixbuf:
@buffer:
@buffer_size:
@type:
@error:
@Varargs:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_save_to_bufferv ##### -->
<para>
</para>
@pixbuf:
@buffer:
@buffer_size:
@type:
@option_keys:
@option_values:
@error:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_save_to_stream ##### -->
<para>
</para>
@pixbuf:
@stream:
@type:
@cancellable:
@error:
@Varargs:
@Returns:

209
docs/reference/gdk-pixbuf/tmpl/gdk-pixbuf-loader.sgml
View File

@ -1,209 +0,0 @@
<!-- ##### SECTION Title ##### -->
GdkPixbufLoader
<!-- ##### SECTION Short_Description ##### -->
Application-driven progressive image loading.
<!-- ##### SECTION Long_Description ##### -->
<para>
#GdkPixbufLoader provides a way for applications to drive the
process of loading an image, by letting them send the image data
directly to the loader instead of having the loader read the data
from a file. Applications can use this functionality instead of
gdk_pixbuf_new_from_file() or gdk_pixbuf_animation_new_from_file()
when they need to parse image data in
small chunks. For example, it should be used when reading an
image from a (potentially) slow network connection, or when
loading an extremely large file.
</para>
<para>
To use #GdkPixbufLoader to load an image, just create a new one,
and call gdk_pixbuf_loader_write() to send the data to it. When
done, gdk_pixbuf_loader_close() should be called to end the stream
and finalize everything. The loader will emit three important
signals throughout the process. The first, "<link
linkend="GdkPixbufLoader-size-prepared">size_prepared</link>",
will be called as soon as the image has enough information to
determine the size of the image to be used. If you want to scale
the image while loading it, you can call gdk_pixbuf_loader_set_size()
in response to this signal.
</para>
<para>The second signal, "<link
linkend="GdkPixbufLoader-area-prepared">area_prepared</link>",
will be called as soon as the pixbuf of the desired has been
allocated. You can obtain it by calling gdk_pixbuf_loader_get_pixbuf().
If you want to use it, simply ref it.
In addition, no actual information will be passed in yet, so the
pixbuf can be safely filled with any temporary graphics (or an
initial color) as needed. You can also call
gdk_pixbuf_loader_get_pixbuf() later and get the same pixbuf.
</para>
<para>
The last signal, "<link
linkend="GdkPixbufLoader-area-updated">area_updated</link>" gets
called every time a region is updated. This way you can update a
partially completed image. Note that you do not know anything
about the completeness of an image from the area updated. For
example, in an interlaced image, you need to make several passes
before the image is done loading.
</para>
<refsect2>
<title>Loading an animation</title>
<para>
Loading an animation is almost as easy as loading an
image. Once the first "<link
linkend="GdkPixbufLoader-area-prepared">area_prepared</link>" signal
has been emitted, you can call gdk_pixbuf_loader_get_animation()
to get the #GdkPixbufAnimation struct and gdk_pixbuf_animation_get_iter()
to get an #GdkPixbufAnimationIter for displaying it.
</para>
</refsect2>
<!-- ##### SECTION See_Also ##### -->
<para>
gdk_pixbuf_new_from_file(), gdk_pixbuf_animation_new_from_file()
</para>
<!-- ##### SECTION Stability_Level ##### -->
<!-- ##### SECTION Image ##### -->
<!-- ##### STRUCT GdkPixbufLoader ##### -->
<para>
The <structname>GdkPixbufLoader</structname> struct contains only private
fields.
</para>
<!-- ##### SIGNAL GdkPixbufLoader::area-prepared ##### -->
<para>
</para>
@gdkpixbufloader:
<!-- ##### SIGNAL GdkPixbufLoader::area-updated ##### -->
<para>
</para>
@gdkpixbufloader:
@arg1:
@arg2:
@arg3:
@arg4:
<!-- ##### SIGNAL GdkPixbufLoader::closed ##### -->
<para>
</para>
@gdkpixbufloader:
<!-- ##### SIGNAL GdkPixbufLoader::size-prepared ##### -->
<para>
</para>
@gdkpixbufloader:
@arg1:
@arg2:
<!-- ##### FUNCTION gdk_pixbuf_loader_new ##### -->
<para>
</para>
@void:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_loader_new_with_type ##### -->
<para>
</para>
@image_type:
@error:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_loader_new_with_mime_type ##### -->
<para>
</para>
@mime_type:
@error:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_loader_get_format ##### -->
<para>
</para>
@loader:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_loader_write ##### -->
<para>
</para>
@loader:
@buf:
@count:
@error:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_loader_set_size ##### -->
<para>
</para>
@loader:
@width:
@height:
<!-- ##### FUNCTION gdk_pixbuf_loader_get_pixbuf ##### -->
<para>
</para>
@loader:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_loader_get_animation ##### -->
<para>
</para>
@loader:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_loader_close ##### -->
<para>
</para>
@loader:
@error:
@Returns:
<!--
Local variables:
mode: sgml
sgml-parent-document: ("../gdk-pixbuf.sgml" "book" "refsect2" "")
End:
-->

569
docs/reference/gdk-pixbuf/tmpl/gdk-pixbuf-unused.sgml
View File

@ -1,569 +0,0 @@
<!-- ##### SECTION ./tmpl/from-drawables.sgml:Long_Description ##### -->
<para>
The functions in this section allow you to take the image data
from a GDK drawable and dump it into a #GdkPixbuf. This can be
used for screenshots and other special effects. Note that these
operations can be expensive, since the image data has to be
transferred from the X server to the client program and converted.
</para>
<!-- ##### SECTION ./tmpl/from-drawables.sgml:See_Also ##### -->
<para>
gdk_image_get().
</para>
<!-- ##### SECTION ./tmpl/from-drawables.sgml:Short_Description ##### -->
Getting parts of a drawable's image data into a pixbuf.
<!-- ##### SECTION ./tmpl/from-drawables.sgml:Title ##### -->
Drawables to Pixbufs
<!-- ##### SECTION ./tmpl/gnome-canvas-pixbuf.sgml:Long_Description ##### -->
<para>
This canvas item displays #GdkPixbuf images. It handles full
affine transformations in both GDK and antialiased modes, and also
supports the <ulink url="http://www.w3.org">W3C</ulink>'s <ulink
url="http://www.w3.org/Graphics/SVG/">SVG</ulink>-like scaling and
translation semantics for absolute pixel values.
</para>
<para>
#GdkPixbuf structures may be shared among different pixbuf canvas
items; the pixbuf item uses #GdkPixbuf's reference counting
functions for this.
</para>
<refsect2>
<title>Custom Scaling and Translation</title>
<para>
In addition to the normal affine transformations supported by
canvas items, the #GnomeCanvasPixbuf item supports independent
object arguments for scaling and translation. This is useful
for explicitly setting a size to which the pixbuf's image will
be scaled, and for specifying translation offsets that take
place in the item's local coordinate system.
</para>
<para>
By default, the pixbuf canvas item will attain the size in units
of the #GdkPixbuf it contains. If a #GnomeCanvasPixbuf is
configured to use a #GdkPixbuf that has a size of 300 by 200
pixels, then the pixbuf item will automatically obtain a size of
300 by 200 units in the item's local coordinate system. If the
item is transformed with a scaling transformation of (0.5, 2.0),
then the final image size will be of 150 by 400 pixels.
</para>
<para>
To set custom width and height values, you must set the <link
linkend="GnomeCanvasPixbuf--width-set">width_set</link> or <link
linkend="GnomeCanvasPixbuf--height-set">height_set</link>
arguments to %TRUE, and then set the <link
linkend="GnomeCanvasPixbuf--width">width</link> or <link
linkend="GnomeCanvasPixbuf--height">height</link> arguments to
the desired values. The former two arguments control whether
the latter two are used when computing the final image's size;
they are both %FALSE by default so that the pixbuf item will
attain a size in units equal to the size in pixels of the
#GdkPixbuf that the item contains.
</para>
<para>
The custom translation offsets are controlled by the <link
linkend="GnomeCanvasPixbuf--x">x</link> and <link
linkend="GnomeCanvasPixbuf--y">y</link> arguments. The logical
upper-left vertex of the image will be translated by the
specified distance, aligned with the item's local coordinate
system.
</para>
</refsect2>
<refsect2>
<title>Absolute Pixel Scaling and Translation</title>
<para>
The <ulink url="http://www.w3.org/Graphics/SVG/">Scalable Vector
Graphics</ulink> specification (SVG) of the <ulink
url="http://www.w3.org">World Wide Web Consortium</ulink> also
allows images to be translated and scaled by absolute pixel
values that are independent of an item's normal affine
transformation.
</para>
<para>
Normally, the pixbuf item's translation and scaling arguments
are interpreted in units, so they will be modified by the item's
affine transformation. The <link
linkend="GnomeCanvasPixbuf--width-in-pixels">width_in_pixels</link>,
<link
linkend="GnomeCanvasPixbuf--height-in-pixels">height_in_pixels</link>,
<link
linkend="GnomeCanvasPixbuf--x-in-pixels">x_in_pixels</link>, and
<link
linkend="GnomeCanvasPixbuf--y-in-pixels">y_in_pixels</link>
object arguments can be used to modify this behavior. If one of
these arguments is %TRUE, then the corresponding scaling or
translation value will not be affected lengthwise by the pixbuf
item's affine transformation.
</para>
<para>
For example, consider a pixbuf item whose size is (300, 200).
If the item is modified with a scaling transformation of (0.5,
2.0) but the <link
linkend="GnomeCanvasPixbuf--width-in-pixels">width_in_pixels</link>
is set to %TRUE, then the item will appear to be (300, 400)
pixels in size. This means that in this case the item's affine
transformation only applies to the height value, while the width
value is kept in absolute pixels.
</para>
<para>
Likewise, consider a pixbuf item whose (<link
linkend="GnomeCanvasPixbuf--x">x</link>, <link
linkend="GnomeCanvasPixbuf--y">y</link>) arguments are set to
(30, 40). If the item is then modified by the same scaling
transformation of (0.5, 2.0) but the <link
linkend="GnomeCanvasPixbuf--y-in-pixels">y_in_pixels</link>
argument is set to %TRUE, then the image's upper-left corner
will appear to be at position (15, 40). In this case, the
affine transformation is applied only to the x offset, while the
y offset is kept in absolute pixels.
</para>
<para>
In short, these arguments control whether a particular dimension
of a pixbuf item is scaled or not in the normal way by the
item's affine transformation.
</para>
</refsect2>
<refsect2>
<title>Resource Management</title>
<para>
When you set the #GdkPixbuf structure that a #GnomeCanvasPixbuf
item will use by setting the <link
linkend="GnomeCanvasPixbuf--pixbuf">pixbuf</link> argument, a
reference count will be added to that #GdkPixbuf structure.
When the pixbuf item no longer needs the #GdkPixbuf structure,
such as when the item is destroyed or when a new pixbuf
structure is passed to it, then the old #GdkPixbuf structure
will be automatically unreferenced.
</para>
<para>
This means that if an application just needs to load a pixbuf
image and set it into a pixbuf canvas item, it can do the
following to &lsquo;forget&rsquo; about the pixbuf structure:
<programlisting>
GdkPixbuf *pixbuf;
GnomeCanvasItem *item;
pixbuf = gdk_pixbuf_new_from_file ("foo.png");
g_assert (pixbuf != NULL);
item = gnome_canvas_item_new (gnome_canvas_root (my_canvas),
gnome_canvas_pixbuf_get_type (),
"pixbuf", pixbuf,
NULL);
gdk_pixbuf_unref (pixbuf);
</programlisting>
</para>
<para>
After this happens, the reference count of the pixbuf structure
will be 1: the gdk_pixbuf_new_from_file() function creates it
with a reference count of 1, then setting the <link
linkend="GnomeCanvasPixbuf--pixbuf">pixbuf</link> argument of
the #GnomeCanvasPixbuf item increases it to 2, and then it is
decremented to 1 by the call to gdk_pixbuf_unref(). When the
canvas item is destroyed, it will automatically unreference the
pixbuf structure again, causing its reference count to drop to
zero and thus be freed.
</para>
</refsect2>
<!-- ##### SECTION ./tmpl/gnome-canvas-pixbuf.sgml:See_Also ##### -->
<para>
#GnomeCanvas, #GdkPixbuf
</para>
<!-- ##### SECTION ./tmpl/gnome-canvas-pixbuf.sgml:Short_Description ##### -->
Canvas item to display #GdkPixbuf images.
<!-- ##### SECTION ./tmpl/gnome-canvas-pixbuf.sgml:Title ##### -->
GnomeCanvasPixbuf
<!-- ##### SECTION ./tmpl/rendering.sgml:Long_Description ##### -->
<para>
The &gdk-pixbuf; library provides several convenience functions to
render pixbufs to GDK drawables. It uses the GdkRGB to render the
image data.
</para>
<para>
At this point there is not a standard alpha channel extension for
the X Window System, so it is not possible to use full opacity
information when painting images to arbitrary drawables. The
&gdk-pixbuf; convenience functions will threshold the opacity
information to create a bi-level clipping mask (black and white),
and use that to draw the image onto a drawable.
</para>
<important>
<para>
Since these functions use GdkRGB for rendering, you must
initialize GdkRGB before using any of them. You can do this by
calling gdk_rgb_init() near the beginning of your program.
</para>
</important>
<!-- ##### SECTION ./tmpl/rendering.sgml:See_Also ##### -->
<para>
GdkRGB
</para>
<!-- ##### SECTION ./tmpl/rendering.sgml:Short_Description ##### -->
Rendering a pixbuf to a GDK drawable.
<!-- ##### SECTION ./tmpl/rendering.sgml:Title ##### -->
Rendering
<!-- ##### SECTION ./tmpl/xlib-from-drawables.sgml:Long_Description ##### -->
<para>
The functions in this section allow you to take the image data
from an X drawable and dump it into a #GdkPixbuf. This can be
used for screenshots and other special effects. Note that these
operations can be expensive, since the image data has to be
transferred from the X server to the client program and converted.
</para>
<para>
These functions are analogous to those for the Gdk version of
&gdk-pixbuf;.
</para>
<!-- ##### SECTION ./tmpl/xlib-from-drawables.sgml:See_Also ##### -->
<para>
</para>
<!-- ##### SECTION ./tmpl/xlib-from-drawables.sgml:Short_Description ##### -->
Getting parts of an X drawable's image data into a pixbuf.
<!-- ##### SECTION ./tmpl/xlib-from-drawables.sgml:Title ##### -->
X Drawables to Pixbufs
<!-- ##### SECTION ./tmpl/xlib-init.sgml:Long_Description ##### -->
<para>
In addition to the normal Gdk-specific functions, the &gdk-pixbuf;
package provides a small library that lets Xlib-only applications
use #GdkPixbuf structures and render them to X drawables. The
functions in this section are used to initialize the &gdk-pixbuf;
Xlib library. This library must be initialized near the beginning
or the program or before calling any of the other &gdk-pixbuf;
Xlib functions; it cannot be initialized automatically since
Xlib-only applications do not call gdk_rgb_init() like GNOME
applications do.
</para>
<!-- ##### SECTION ./tmpl/xlib-init.sgml:See_Also ##### -->
<para>
XlibRGB
</para>
<!-- ##### SECTION ./tmpl/xlib-init.sgml:Short_Description ##### -->
Initializing the &gdk-pixbuf; Xlib library.
<!-- ##### SECTION ./tmpl/xlib-init.sgml:Title ##### -->
&gdk-pixbuf; Xlib initialization
<!-- ##### SECTION ./tmpl/xlib-rendering.sgml:Long_Description ##### -->
<para>
The &gdk-pixbuf; Xlib library provides several convenience
functions to render pixbufs to X drawables. It uses XlibRGB to
render the image data.
</para>
<para>
These functions are analogous to those for the Gdk version of
&gdk-pixbuf;.
</para>
<!-- ##### SECTION ./tmpl/xlib-rendering.sgml:See_Also ##### -->
<para>
</para>
<!-- ##### SECTION ./tmpl/xlib-rendering.sgml:Short_Description ##### -->
Rendering a pixbuf to an X drawable.
<!-- ##### SECTION ./tmpl/xlib-rendering.sgml:Title ##### -->
Xlib Rendering
<!-- ##### SECTION ./tmpl/xlib-rgb.sgml:Long_Description ##### -->
<para>
The XlibRGB set of functions is a port of the GdkRGB library to
use plain Xlib and X drawables. You can use these functions to
render RGB buffers into drawables very quickly with high-quality
dithering.
</para>
<!-- ##### SECTION ./tmpl/xlib-rgb.sgml:See_Also ##### -->
<para>
GdkRGB
</para>
<!-- ##### SECTION ./tmpl/xlib-rgb.sgml:Short_Description ##### -->
Functions for rendering RGB buffers to X drawables.
<!-- ##### SECTION ./tmpl/xlib-rgb.sgml:Title ##### -->
XlibRGB
<!-- ##### MACRO GDK_PIXBUF_LOADER ##### -->
<para>
Casts a #GtkObject to a #GdkPixbufLoader.
</para>
@obj: A GTK+ object.
<!-- ##### MACRO GNOME_CANVAS_PIXBUF ##### -->
<para>
Casts a #GtkOjbect to a #GnomeCanvasPixbuf.
</para>
@obj: A GTK+ object.
<!-- ##### STRUCT GdkPixbufFrame ##### -->
<para>
This object describes an individual frame of an animation.
</para>
<!-- ##### ENUM GdkPixbufFrameAction ##### -->
<para>
</para>
@GDK_PIXBUF_FRAME_RETAIN:
@GDK_PIXBUF_FRAME_DISPOSE:
@GDK_PIXBUF_FRAME_REVERT:
<!-- ##### USER_FUNCTION GdkPixbufLastUnref ##### -->
<para>
A function of this type can be used to override the default
operation when a pixbuf loses its last reference, i.e. when
gdk_pixbuf_unref() is called on a #GdkPixbuf structure that has a
reference count of 1. This function should determine whether to
finalize the pixbuf by calling gdk_pixbuf_finalize(), or whether
to just resume normal execution. The last unref handler for a
#GdkPixbuf can be set using the
gdk_pixbuf_set_last_unref_handler() function. By default, pixbufs
will be finalized automatically if no last unref handler has been
defined.
</para>
@pixbuf: The pixbuf that is losing its last reference.
@data: User closure data.
<!-- ##### ARG GnomeCanvasPixbuf:height ##### -->
<para>
Indicates the height the pixbuf will be scaled to. This argument
will only be used if the <link
linkend="GnomeCanvasPixbuf--height-set">height_set</link> argument
is %TRUE. Works in the same way as the <link
linkend="GnomeCanvasPixbuf--width">width</link> argument.
</para>
<!-- ##### ARG GnomeCanvasPixbuf:height-in-pixels ##### -->
<para>
Works in the same way as the <link
linkend="GnomeCanvasPixbuf--width-in-pixels">width_in_pixels</link>
argument. The default is %FALSE.
</para>
<!-- ##### ARG GnomeCanvasPixbuf:height-pixels ##### -->
<para>
</para>
<!-- ##### ARG GnomeCanvasPixbuf:height-set ##### -->
<para>
Determines whether the <link
linkend="GnomeCanvasPixbuf--height">height</link> argument is
taken into account when scaling the pixbuf item. Works in the
same way as the <link
linkend="GnomeCanvasPixbuf--width-set">width_set</link> argument.
The default is %FALSE.
</para>
<!-- ##### ARG GnomeCanvasPixbuf:pixbuf ##### -->
<para>
Contains a pointer to a #GdkPixbuf structure that will be used by
the pixbuf canvas item as an image source. When a pixbuf is set
its reference count is incremented; if the pixbuf item kept a
pointer to another #GdkPixbuf structure, the reference count of
this structure will be decremented. Also, the GdkPixbuf's
reference count will automatically be decremented when the
#GnomeCanvasPixbuf item is destroyed. When a pixbuf is queried, a
reference count will not be added to the return value; you must do
this yourself if you intend to keep the pixbuf structure around.
</para>
<!-- ##### ARG GnomeCanvasPixbuf:width ##### -->
<para>
Indicates the width the pixbuf will be scaled to. This argument
will only be used if the <link
linkend="GnomeCanvasPixbuf--width-set">width_set</link> argument
is %TRUE. If the <link
linkend="GnomeCanvasPixbuf--width-in-pixels">width_in_pixels</link>
argument is %FALSE, the width will be taken to be in canvas units,
and thus will be scaled along with the canvas item's affine
transformation. If width_in_pixels is %TRUE, the width will be
taken to be in pixels, and will visually remain a constant size
even if the item's affine transformation changes.
</para>
<!-- ##### ARG GnomeCanvasPixbuf:width-in-pixels ##### -->
<para>
If this argument is %TRUE, then the width of the pixbuf will be
considered to be in pixels, that is, it will not be visually
scaled even if the item's affine transformation changes. If this
is %FALSE, then the width of the pixbuf will be considered to be
in canvas units, and so will be scaled normally by affine
transformations. The default is %FALSE.
</para>
<!-- ##### ARG GnomeCanvasPixbuf:width-pixels ##### -->
<para>
</para>
<!-- ##### ARG GnomeCanvasPixbuf:width-set ##### -->
<para>
Determines whether the <link
linkend="GnomeCanvasPixbuf--width">width</link> argument is taken
into account when scaling the pixbuf item. If this argument is
%FALSE, then the width value of the pixbuf will be used instead.
This argument is %FALSE by default.
</para>
<!-- ##### ARG GnomeCanvasPixbuf:x ##### -->
<para>
Indicates the horizontal translation offset of the pixbuf item's
image. This offset may not actually appear horizontal, since it
will be affected by the item's affine transformation. The default
is 0.0.
</para>
<!-- ##### ARG GnomeCanvasPixbuf:x-in-pixels ##### -->
<para>
If this argument is %TRUE, the pixbuf's translation with respect
to its logical origin in item-relative coordinates will be in
pixels, that is, the visible offset will not change even if the
item's affine transformation changes. If it is %FALSE, the
pixbuf's translation will be taken to be in canvas units, and thus
will change along with the item's affine transformation. The
default is %FALSE.
</para>
<!-- ##### ARG GnomeCanvasPixbuf:x-pixels ##### -->
<para>
</para>
<!-- ##### ARG GnomeCanvasPixbuf:x-set ##### -->
<para>
Determines whether the <link
linkend="GnomeCanvasPixbuf--x">x</link> argument is used to
translate the pixbuf from its logical origin in item-relative
coordinates.
</para>
<!-- ##### ARG GnomeCanvasPixbuf:y ##### -->
<para>
Indicates the vertical translation offset of the pixbuf item's
image. Works in the same way as the <link
linkend="GnomeCanvasPixbuf--x">x</link> argument. The default is
0.0.
</para>
<!-- ##### ARG GnomeCanvasPixbuf:y-in-pixels ##### -->
<para>
Works in the same way as the <link
linkend="GnomeCanvasPixbuf--x-in-pixels">x_in_pixels</link>
argument, but controls whether the <link
linkend="GnomeCanvasPixbuf--y">y</link> translation offset is
scaled or not. The default is %FALSE.
</para>
<!--
Local variables:
mode: sgml
sgml-parent-document: ("../gdk-pixbuf.sgml" "book" "refsect2" "")
End:
-->
<!-- ##### ARG GnomeCanvasPixbuf:y-pixels ##### -->
<para>
</para>
<!-- ##### ARG GnomeCanvasPixbuf:y-set ##### -->
<para>
Determines whether the <link
linkend="GnomeCanvasPixbuf--y">y</link> argument is used to
translate the pixbuf from its logical origin in item-relative
coordinates. Works in the same way as the <link
linkend="GnomeCanvasPixbuf--x-set">x_set</link> argument. The
default is %FALSE.
</para>

54
docs/reference/gdk-pixbuf/tmpl/gdk-pixbuf-xlib-from-drawables.sgml
View File

@ -1,54 +0,0 @@
<!-- ##### SECTION Title ##### -->
X Drawables to Pixbufs
<!-- ##### SECTION Short_Description ##### -->
Getting parts of an X drawable's image data into a pixbuf.
<!-- ##### SECTION Long_Description ##### -->
<para>
The functions in this section allow you to take the image data
from an X drawable and dump it into a #GdkPixbuf. This can be
used for screenshots and other special effects. Note that these
operations can be expensive, since the image data has to be
transferred from the X server to the client program and converted.
</para>
<para>
These functions are analogous to those for the GDK version of
&gdk-pixbuf;.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### SECTION Stability_Level ##### -->
<!-- ##### SECTION Image ##### -->
<!-- ##### FUNCTION gdk_pixbuf_xlib_get_from_drawable ##### -->
<para>
</para>
@dest:
@src:
@cmap:
@visual:
@src_x:
@src_y:
@dest_x:
@dest_y:
@width:
@height:
@Returns: <!--
Local variables:
mode: sgml
sgml-parent-document: ("../gdk-pixbuf.sgml" "book" "refsect2" "")
End:
-->

52
docs/reference/gdk-pixbuf/tmpl/gdk-pixbuf-xlib-init.sgml
View File

@ -1,52 +0,0 @@
<!-- ##### SECTION Title ##### -->
&gdk-pixbuf; Xlib initialization
<!-- ##### SECTION Short_Description ##### -->
Initializing the &gdk-pixbuf; Xlib library.
<!-- ##### SECTION Long_Description ##### -->
<para>
In addition to the normal Gdk-specific functions, the &gdk-pixbuf;
package provides a small library that lets Xlib-only applications
use #GdkPixbuf structures and render them to X drawables. The
functions in this section are used to initialize the &gdk-pixbuf;
Xlib library. This library must be initialized near the beginning
of the program or before calling any of the other &gdk-pixbuf;
Xlib functions.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
XlibRGB
</para>
<!-- ##### SECTION Stability_Level ##### -->
<!-- ##### SECTION Image ##### -->
<!-- ##### FUNCTION gdk_pixbuf_xlib_init ##### -->
<para>
</para>
@display:
@screen_num:
<!-- ##### FUNCTION gdk_pixbuf_xlib_init_with_depth ##### -->
<para>
</para>
@display:
@screen_num:
@prefDepth: <!--
Local variables:
mode: sgml
sgml-parent-document: ("../gdk-pixbuf.sgml" "book" "refsect2" "")
End:
-->

100
docs/reference/gdk-pixbuf/tmpl/gdk-pixbuf-xlib-rendering.sgml
View File

@ -1,100 +0,0 @@
<!-- ##### SECTION Title ##### -->
Xlib Rendering
<!-- ##### SECTION Short_Description ##### -->
Rendering a pixbuf to an X drawable.
<!-- ##### SECTION Long_Description ##### -->
<para>
The &gdk-pixbuf; Xlib library provides several convenience
functions to render pixbufs to X drawables. It uses XlibRGB to
render the image data.
</para>
<para>
These functions are analogous to those for the GDK version of
&gdk-pixbuf;.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### SECTION Stability_Level ##### -->
<!-- ##### SECTION Image ##### -->
<!-- ##### FUNCTION gdk_pixbuf_xlib_render_threshold_alpha ##### -->
<para>
</para>
@pixbuf:
@bitmap:
@src_x:
@src_y:
@dest_x:
@dest_y:
@width:
@height:
@alpha_threshold:
<!-- ##### FUNCTION gdk_pixbuf_xlib_render_to_drawable ##### -->
<para>
</para>
@pixbuf:
@drawable:
@gc:
@src_x:
@src_y:
@dest_x:
@dest_y:
@width:
@height:
@dither:
@x_dither:
@y_dither:
<!-- ##### FUNCTION gdk_pixbuf_xlib_render_to_drawable_alpha ##### -->
<para>
</para>
@pixbuf:
@drawable:
@src_x:
@src_y:
@dest_x:
@dest_y:
@width:
@height:
@alpha_mode:
@alpha_threshold:
@dither:
@x_dither:
@y_dither:
<!-- ##### FUNCTION gdk_pixbuf_xlib_render_pixmap_and_mask ##### -->
<para>
</para>
@pixbuf:
@pixmap_return:
@mask_return:
@alpha_threshold: <!--
Local variables:
Kode: sgml
sgml-parent-document: ("../gdk-pixbuf.sgml" "book" "refsect2" "")
End:
-->

290
docs/reference/gdk-pixbuf/tmpl/gdk-pixbuf-xlib-rgb.sgml
View File

@ -1,290 +0,0 @@
<!-- ##### SECTION Title ##### -->
XlibRGB
<!-- ##### SECTION Short_Description ##### -->
Rendering RGB buffers to X drawables.
<!-- ##### SECTION Long_Description ##### -->
<para>
The XlibRGB set of functions is a port of the #GdkRGB library to
use plain Xlib and X drawables. You can use these functions to
render RGB buffers into drawables very quickly with high-quality
dithering.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
GdkRGB
</para>
<!-- ##### SECTION Stability_Level ##### -->
<!-- ##### SECTION Image ##### -->
<!-- ##### STRUCT XlibRgbCmap ##### -->
<para>
FIXME: Describe this.
</para>
@colors: FIXME.
@lut: FIXME.
<!-- ##### ENUM XlibRgbDither ##### -->
<para>
These values are used to specify which dithering method should be
used. <symbol>XLIB_RGB_DITHER_NONE</symbol> will use no dithering
and simply map the colors in an RGB buffer to the closest colors
that the display can provide.
<symbol>XLIB_RGB_DITHER_NORMAL</symbol> will provide dithering
only on pseudocolor displays.
<symbol>XLIB_RGB_DITHER_MAX</symbol> will provide dithering on
pseudocolor and 16-bit truecolor or &ldquo;high color&rdquo;
displays.
</para>
@XLIB_RGB_DITHER_NONE: Specifies no dithering.
@XLIB_RGB_DITHER_NORMAL: Specifies dithering only on pseudocolor
displays.
@XLIB_RGB_DITHER_MAX: Specifies dithering on high color displays.
<!-- ##### FUNCTION xlib_rgb_init ##### -->
<para>
</para>
@display:
@screen:
<!-- ##### FUNCTION xlib_rgb_init_with_depth ##### -->
<para>
</para>
@display:
@screen:
@prefDepth:
<!-- ##### FUNCTION xlib_rgb_xpixel_from_rgb ##### -->
<para>
</para>
@rgb:
@Returns:
<!-- ##### FUNCTION xlib_rgb_gc_set_foreground ##### -->
<para>
</para>
@gc:
@rgb:
<!-- ##### FUNCTION xlib_rgb_gc_set_background ##### -->
<para>
</para>
@gc:
@rgb:
<!-- ##### FUNCTION xlib_draw_rgb_image ##### -->
<para>
</para>
@drawable:
@gc:
@x:
@y:
@width:
@height:
@dith:
@rgb_buf:
@rowstride:
<!-- ##### FUNCTION xlib_draw_rgb_image_dithalign ##### -->
<para>
</para>
@drawable:
@gc:
@x:
@y:
@width:
@height:
@dith:
@rgb_buf:
@rowstride:
@xdith:
@ydith:
<!-- ##### FUNCTION xlib_draw_rgb_32_image ##### -->
<para>
</para>
@drawable:
@gc:
@x:
@y:
@width:
@height:
@dith:
@buf:
@rowstride:
<!-- ##### FUNCTION xlib_draw_gray_image ##### -->
<para>
</para>
@drawable:
@gc:
@x:
@y:
@width:
@height:
@dith:
@buf:
@rowstride:
<!-- ##### FUNCTION xlib_rgb_cmap_new ##### -->
<para>
</para>
@colors:
@n_colors:
@Returns:
<!-- ##### FUNCTION xlib_rgb_cmap_free ##### -->
<para>
</para>
@cmap:
<!-- ##### FUNCTION xlib_draw_indexed_image ##### -->
<para>
</para>
@drawable:
@gc:
@x:
@y:
@width:
@height:
@dith:
@buf:
@rowstride:
@cmap:
<!-- ##### FUNCTION xlib_rgb_ditherable ##### -->
<para>
</para>
@void:
@Returns:
<!-- ##### FUNCTION xlib_rgb_set_verbose ##### -->
<para>
</para>
@verbose:
<!-- ##### FUNCTION xlib_rgb_set_install ##### -->
<para>
</para>
@install:
<!-- ##### FUNCTION xlib_rgb_set_min_colors ##### -->
<para>
</para>
@min_colors:
<!-- ##### FUNCTION xlib_rgb_get_cmap ##### -->
<para>
</para>
@void:
@Returns:
<!-- ##### FUNCTION xlib_rgb_get_visual ##### -->
<para>
</para>
@void:
@Returns:
<!-- ##### FUNCTION xlib_rgb_get_visual_info ##### -->
<para>
</para>
@void:
@Returns:
<!-- ##### FUNCTION xlib_rgb_get_depth ##### -->
<para>
</para>
@void:
@Returns:
<!-- ##### FUNCTION xlib_rgb_get_display ##### -->
<para>
</para>
@void:
@Returns:
<!-- ##### FUNCTION xlib_rgb_get_screen ##### -->
<para>
</para>
@void:
@Returns: <!--
Local variables:
mode: sgml
sgml-parent-document: ("../gdk-pixbuf.sgml" "book" "refsect2" "")
End:
-->

294
docs/reference/gdk-pixbuf/tmpl/gdk-pixbuf.sgml
View File

@ -1,294 +0,0 @@
<!-- ##### SECTION Title ##### -->
The GdkPixbuf Structure
<!-- ##### SECTION Short_Description ##### -->
Information that describes an image.
<!-- ##### SECTION Long_Description ##### -->
<para>
The <structname>GdkPixbuf</structname> structure contains
information that describes an image in memory.
</para>
<section id="image-data">
<title>Image Data</title>
<para>
Image data in a pixbuf is stored in memory in uncompressed,
packed format. Rows in the image are stored top to bottom, and
in each row pixels are stored from left to right. There may be
padding at the end of a row. The "rowstride" value of a pixbuf,
as returned by gdk_pixbuf_get_rowstride(), indicates the number
of bytes between rows.
</para>
<example id="put-pixel">
<title>put_pixel(<!-- -->) example</title>
<para>
The following code illustrates a simple put_pixel(<!-- -->)
function for RGB pixbufs with 8 bits per channel with an alpha
channel. It is not included in the gdk-pixbuf library for
performance reasons; rather than making several function calls
for each pixel, your own code can take shortcuts.
</para>
<programlisting>
static void
put_pixel (GdkPixbuf *pixbuf, int x, int y, guchar red, guchar green, guchar blue, guchar alpha)
{
int width, height, rowstride, n_channels;
guchar *pixels, *p;
n_channels = gdk_pixbuf_get_n_channels (pixbuf);
g_assert (gdk_pixbuf_get_colorspace (pixbuf) == GDK_COLORSPACE_RGB);
g_assert (gdk_pixbuf_get_bits_per_sample (pixbuf) == 8);
g_assert (gdk_pixbuf_get_has_alpha (pixbuf));
g_assert (n_channels == 4);
width = gdk_pixbuf_get_width (pixbuf);
height = gdk_pixbuf_get_height (pixbuf);
g_assert (x &gt;= 0 &amp;&amp; x &lt; width);
g_assert (y &gt;= 0 &amp;&amp; y &lt; height);
rowstride = gdk_pixbuf_get_rowstride (pixbuf);
pixels = gdk_pixbuf_get_pixels (pixbuf);
p = pixels + y * rowstride + x * n_channels;
p[0] = red;
p[1] = green;
p[2] = blue;
p[3] = alpha;
}
</programlisting>
<para>
This function will not work for pixbufs with images that are
other than 8 bits per sample or channel, but it will work for
most of the pixbufs that GTK+ uses.
</para>
</example>
<note>
<para>
If you are doing memcpy() of raw pixbuf data, note that the
last row in the pixbuf may not be as wide as the full
rowstride, but rather just as wide as the pixel data needs to
be. That is, it is unsafe to do <literal>memcpy (dest,
pixels, rowstride * height)</literal> to copy a whole pixbuf.
Use gdk_pixbuf_copy() instead, or compute the width in bytes
of the last row as <literal>width * ((n_channels *
bits_per_sample + 7) / 8)</literal>.
</para>
</note>
</section>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### SECTION Stability_Level ##### -->
<!-- ##### SECTION Image ##### -->
<!-- ##### ENUM GdkPixbufError ##### -->
<para>
An error code in the #GDK_PIXBUF_ERROR domain. Many &gdk-pixbuf;
operations can cause errors in this domain, or in the #G_FILE_ERROR
domain.
</para>
@GDK_PIXBUF_ERROR_CORRUPT_IMAGE: An image file was broken somehow.
@GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY: Not enough memory.
@GDK_PIXBUF_ERROR_BAD_OPTION: A bad option was passed to a pixbuf save module.
@GDK_PIXBUF_ERROR_UNKNOWN_TYPE: Unknown image type.
@GDK_PIXBUF_ERROR_UNSUPPORTED_OPERATION: Don't know how to perform the
given operation on the type of image at hand.
@GDK_PIXBUF_ERROR_FAILED: Generic failure code, something went wrong.
<!-- ##### MACRO GDK_PIXBUF_ERROR ##### -->
<para>
Error domain used for pixbuf operations. Indicates that the error code
will be in the #GdkPixbufError enumeration. See #GError for
information on error domains and error codes.
</para>
<!-- ##### ENUM GdkColorspace ##### -->
<para>
This enumeration defines the color spaces that are supported by
the &gdk-pixbuf; library. Currently only RGB is supported.
</para>
@GDK_COLORSPACE_RGB: Indicates a red/green/blue additive color space.
<!-- ##### ENUM GdkPixbufAlphaMode ##### -->
<para>
These values can be passed to
gdk_pixbuf_render_to_drawable_alpha() to control how the alpha
channel of an image should be handled. This function can create a
bilevel clipping mask (black and white) and use it while painting
the image. In the future, when the X Window System gets an alpha
channel extension, it will be possible to do full alpha
compositing onto arbitrary drawables. For now both cases fall
back to a bilevel clipping mask.
</para>
@GDK_PIXBUF_ALPHA_BILEVEL: A bilevel clipping mask (black and white)
will be created and used to draw the image. Pixels below 0.5 opacity
will be considered fully transparent, and all others will be
considered fully opaque.
@GDK_PIXBUF_ALPHA_FULL: For now falls back to #GDK_PIXBUF_ALPHA_BILEVEL.
In the future it will do full alpha compositing.
<!-- ##### STRUCT GdkPixbuf ##### -->
<para>
This is the main structure in the &gdk-pixbuf; library. It is
used to represent images. It contains information about the
image's pixel data, its color space, bits per sample, width and
height, and the rowstride (the number of bytes between the start of
one row and the start of the next).
</para>
<!-- ##### ARG GdkPixbuf:bits-per-sample ##### -->
<para>
</para>
<!-- ##### ARG GdkPixbuf:colorspace ##### -->
<para>
</para>
<!-- ##### ARG GdkPixbuf:has-alpha ##### -->
<para>
</para>
<!-- ##### ARG GdkPixbuf:height ##### -->
<para>
</para>
<!-- ##### ARG GdkPixbuf:n-channels ##### -->
<para>
</para>
<!-- ##### ARG GdkPixbuf:pixels ##### -->
<para>
</para>
<!-- ##### ARG GdkPixbuf:rowstride ##### -->
<para>
</para>
<!-- ##### ARG GdkPixbuf:width ##### -->
<para>
</para>
<!-- ##### FUNCTION gdk_pixbuf_get_colorspace ##### -->
<para>
</para>
@pixbuf:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_get_n_channels ##### -->
<para>
</para>
@pixbuf:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_get_has_alpha ##### -->
<para>
</para>
@pixbuf:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_get_bits_per_sample ##### -->
<para>
</para>
@pixbuf:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_get_pixels ##### -->
<para>
</para>
@pixbuf:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_get_width ##### -->
<para>
</para>
@pixbuf:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_get_height ##### -->
<para>
</para>
@pixbuf:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_get_rowstride ##### -->
<para>
</para>
@pixbuf:
@Returns: <!--
Local variables:
mode: sgml
sgml-parent-document: ("../gdk-pixbuf.sgml" "book" "refsect2" "")
End:
-->
<!-- ##### FUNCTION gdk_pixbuf_get_option ##### -->
<para>
</para>
@pixbuf:
@key:
@Returns:
<!--
Local variables:
mode: sgml
sgml-parent-document: ("../gdk-pixbuf.sgml" "book" "refsect2")
End:
-->

106
docs/reference/gdk-pixbuf/tmpl/initialization_versions.sgml
View File

@ -1,106 +0,0 @@
<!-- ##### SECTION Title ##### -->
Initialization and Versions
<!-- ##### SECTION Short_Description ##### -->
Library version numbers.
<!-- ##### SECTION Long_Description ##### -->
<para>
These macros and variables let you check the version of &gdk-pixbuf;
you're linking against.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### SECTION Stability_Level ##### -->
<!-- ##### SECTION Image ##### -->
<!-- ##### VARIABLE gdk_pixbuf_version ##### -->
<para>
Contains the full version of the &gdk-pixbuf; library as a string.
This is the version currently in use by a running program.
</para>
<!-- ##### VARIABLE gdk_pixbuf_major_version ##### -->
<para>
The major version number of the &gdk-pixbuf; library. (e.g. in
&gdk-pixbuf; version 1.2.5 this is 1.)
</para>
<para>
This variable is in the library, so represents the
&gdk-pixbuf; library you have linked against. Contrast with the
#GDK_PIXBUF_MAJOR macro, which represents the major version of the
&gdk-pixbuf; headers you have included.
</para>
<!-- ##### VARIABLE gdk_pixbuf_minor_version ##### -->
<para>
The minor version number of the &gdk-pixbuf; library. (e.g. in
&gdk-pixbuf; version 1.2.5 this is 2.)
</para>
<para>
This variable is in the library, so represents the
&gdk-pixbuf; library you have linked against. Contrast with the
#GDK_PIXBUF_MINOR macro, which represents the minor version of the
&gdk-pixbuf; headers you have included.
</para>
<!-- ##### VARIABLE gdk_pixbuf_micro_version ##### -->
<para>
The micro version number of the &gdk-pixbuf; library. (e.g. in
&gdk-pixbuf; version 1.2.5 this is 5.)
</para>
<para>
This variable is in the library, so represents the
&gdk-pixbuf; library you have linked against. Contrast with the
#GDK_PIXBUF_MICRO macro, which represents the micro version of the
&gdk-pixbuf; headers you have included.
</para>
<!-- ##### MACRO GDK_PIXBUF_VERSION ##### -->
<para>
Contains the full version of the &gdk-pixbuf; header as a string.
This is the version being compiled against; contrast with
#gdk_pixbuf_version.
</para>
<!-- ##### MACRO GDK_PIXBUF_MAJOR ##### -->
<para>
Major version of &gdk-pixbuf; library, that is the first "0" in
"0.8.0" for example.
</para>
<!-- ##### MACRO GDK_PIXBUF_MINOR ##### -->
<para>
Minor version of &gdk-pixbuf; library, that is the "8" in
"0.8.0" for example.
</para>
<!-- ##### MACRO GDK_PIXBUF_MICRO ##### -->
<para>
Micro version of &gdk-pixbuf; library, that is the last "0" in
"0.8.0" for example.
</para>

137
docs/reference/gdk-pixbuf/tmpl/inline.sgml
View File

@ -1,137 +0,0 @@
<!-- ##### SECTION Title ##### -->
Inline data
<!-- ##### SECTION Short_Description ##### -->
Functions for inlined pixbuf handling.
<!-- ##### SECTION Long_Description ##### -->
<para>
Using #GdkPixdata, images can be compiled into an application,
making it unnecessary to refer to external image files at runtime.
&gdk-pixbuf; includes a utility named gdk-pixbuf-csource, which
can be used to convert image files into #GdkPixdata structures suitable
for inclusion in C sources. To convert the #GdkPixdata structures back
into #GdkPixbuf<!-- -->s, use gdk_pixbuf_from_pixdata.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### SECTION Stability_Level ##### -->
<!-- ##### SECTION Image ##### -->
<!-- ##### STRUCT GdkPixdata ##### -->
<para>
</para>
@magic:
@length:
@pixdata_type:
@rowstride:
@width:
@height:
@pixel_data:
<!-- ##### ENUM GdkPixdataType ##### -->
<para>
</para>
@GDK_PIXDATA_COLOR_TYPE_RGB:
@GDK_PIXDATA_COLOR_TYPE_RGBA:
@GDK_PIXDATA_COLOR_TYPE_MASK:
@GDK_PIXDATA_SAMPLE_WIDTH_8:
@GDK_PIXDATA_SAMPLE_WIDTH_MASK:
@GDK_PIXDATA_ENCODING_RAW:
@GDK_PIXDATA_ENCODING_RLE:
@GDK_PIXDATA_ENCODING_MASK:
<!-- ##### ENUM GdkPixdataDumpType ##### -->
<para>
</para>
@GDK_PIXDATA_DUMP_PIXDATA_STREAM:
@GDK_PIXDATA_DUMP_PIXDATA_STRUCT:
@GDK_PIXDATA_DUMP_MACROS:
@GDK_PIXDATA_DUMP_GTYPES:
@GDK_PIXDATA_DUMP_CTYPES:
@GDK_PIXDATA_DUMP_STATIC:
@GDK_PIXDATA_DUMP_CONST:
@GDK_PIXDATA_DUMP_RLE_DECODER:
<!-- ##### MACRO GDK_PIXBUF_MAGIC_NUMBER ##### -->
<para>
</para>
<!-- ##### MACRO GDK_PIXDATA_HEADER_LENGTH ##### -->
<para>
</para>
<!-- ##### FUNCTION gdk_pixdata_from_pixbuf ##### -->
<para>
</para>
@pixdata:
@pixbuf:
@use_rle:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_from_pixdata ##### -->
<para>
</para>
@pixdata:
@copy_pixels:
@error:
@Returns:
<!-- ##### FUNCTION gdk_pixdata_serialize ##### -->
<para>
</para>
@pixdata:
@stream_length_p:
@Returns:
<!-- ##### FUNCTION gdk_pixdata_deserialize ##### -->
<para>
</para>
@pixdata:
@stream_length:
@stream:
@error:
@Returns:
<!-- ##### FUNCTION gdk_pixdata_to_csource ##### -->
<para>
</para>
@pixdata:
@name:
@dump_type:
@Returns:

382
docs/reference/gdk-pixbuf/tmpl/module_interface.sgml
View File

@ -1,382 +0,0 @@
<!-- ##### SECTION Title ##### -->
Module Interface
<!-- ##### SECTION Short_Description ##### -->
Extending &gdk-pixbuf;
<!-- ##### SECTION Long_Description ##### -->
<para>
If &gdk-pixbuf; has been compiled with GModule support, it can be extended by
modules which can load (and perhaps also save) new image and animation
formats. Each loadable module must export a
#GdkPixbufModuleFillInfoFunc function named <function>fill_info</function> and
a #GdkPixbufModuleFillVtableFunc function named
<function>fill_vtable</function>.
</para>
<para>
In order to make format-checking work before actually loading the modules
(which may require dlopening image libraries), modules export their
signatures (and other information) via the <function>fill_info</function>
function. An external utility, <command>gdk-pixbuf-query-loaders</command>,
uses this to create a text file containing a list of all available loaders and
their signatures. This file is then read at runtime by &gdk-pixbuf; to obtain
the list of available loaders and their signatures.
</para>
<para>
Modules may only implement a subset of the functionality available via
#GdkPixbufModule. If a particular functionality is not implemented, the
<function>fill_vtable</function> function will simply not set the corresponding
function pointers of the #GdkPixbufModule structure. If a module supports
incremental loading (i.e. provides #begin_load, #stop_load and
#load_increment), it doesn't have to implement #load, since &gdk-pixbuf; can
supply a generic #load implementation wrapping the incremental loading.
</para>
<para>
Installing a module is a two-step process:
<itemizedlist>
<listitem><para>copy the module file(s) to the loader directory (normally
<filename><replaceable>libdir</replaceable>/gtk-2.0/<replaceable>version</replaceable>/loaders</filename>,
unless overridden by the environment variable
<envar>GDK_PIXBUF_MODULEDIR</envar>)
</para></listitem>
<listitem><para>call <command>gdk-pixbuf-query-loaders</command> to update the
module file (normally
<filename><replaceable>sysconfdir</replaceable>/gtk-2.0/gdk-pixbuf.loaders</filename>,
unless overridden by the environment variable
<envar>GDK_PIXBUF_MODULE_FILE</envar>)
</para></listitem>
</itemizedlist>
</para>
<para>
The &gdk-pixbuf; interfaces needed for implementing modules are contained in
<filename>gdk-pixbuf-io.h</filename> (and
<filename>gdk-pixbuf-animation.h</filename> if the module supports animations).
They are not covered by the same stability guarantees as the regular
&gdk-pixbuf; API. To underline this fact, they are protected by
<literal>#ifdef GDK_PIXBUF_ENABLE_BACKEND</literal>.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### SECTION Stability_Level ##### -->
<!-- ##### SECTION Image ##### -->
<!-- ##### FUNCTION gdk_pixbuf_set_option ##### -->
<para>
</para>
@pixbuf:
@key:
@value:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_get_formats ##### -->
<para>
</para>
@void:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_format_get_name ##### -->
<para>
</para>
@format:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_format_get_description ##### -->
<para>
</para>
@format:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_format_get_mime_types ##### -->
<para>
</para>
@format:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_format_get_extensions ##### -->
<para>
</para>
@format:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_format_is_writable ##### -->
<para>
</para>
@format:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_format_is_scalable ##### -->
<para>
</para>
@format:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_format_is_disabled ##### -->
<para>
</para>
@format:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_format_set_disabled ##### -->
<para>
</para>
@format:
@disabled:
<!-- ##### FUNCTION gdk_pixbuf_format_get_license ##### -->
<para>
</para>
@format:
@Returns:
<!-- ##### STRUCT GdkPixbufFormat ##### -->
<para>
A #GdkPixbufFormat contains information about the image format accepted by a
module. Only modules should access the fields directly, applications should
use the <function>gdk_pixbuf_format_*</function> functions.
</para>
@name: the name of the image format.
@signature: the signature of the module.
@domain: the message domain for the @description.
@description: a description of the image format.
@mime_types: a %NULL-terminated array of MIME types for the image format.
@extensions: a %NULL-terminated array of typical filename extensions for the
image format.
@flags: a combination of #GdkPixbufFormatFlags.
@disabled: a boolean determining whether the loader is disabled.
@license: a string containing license information, typically set to
shorthands like "GPL", "LGPL", etc.
@Since: 2.2
<!-- ##### ENUM GdkPixbufFormatFlags ##### -->
<para>
Flags which allow a module to specify further details about the supported
operations.
</para>
@GDK_PIXBUF_FORMAT_WRITABLE: the module can write out images in the format.
@GDK_PIXBUF_FORMAT_SCALABLE: the image format is scalable
@GDK_PIXBUF_FORMAT_THREADSAFE: the module is threadsafe. If this flag is not
set, &gdk-pixbuf; will use a lock to prevent multiple threads from using
this module at the same time. (Since 2.6)
@Since: 2.2
<!-- ##### STRUCT GdkPixbufModulePattern ##### -->
<para>
The signature of a module is a set of prefixes. Prefixes are encoded as
pairs of ordinary strings, where the second string, called the mask, if
not %NULL, must be of the same length as the first one and may contain
' ', '!', 'x', 'z', and 'n' to indicate bytes that must be matched,
not matched, "don't-care"-bytes, zeros and non-zeros.
Each prefix has an associated integer that describes the relevance of
the prefix, with 0 meaning a mismatch and 100 a "perfect match".
</para>
<para>
Starting with &gdk-pixbuf; 2.8, the first byte of the mask may be '*',
indicating an unanchored pattern that matches not only at the beginning,
but also in the middle. Versions prior to 2.8 will interpret the '*'
like an 'x'.
</para>
<para>
The signature of a module is stored as an array of
#GdkPixbufModulePattern<!-- -->s. The array is terminated by a pattern
where the @prefix is %NULL.
</para>
<informalexample><programlisting>
GdkPixbufModulePattern *signature[] = {
{ "abcdx", " !x z", 100 },
{ "bla", NULL, 90 },
{ NULL, NULL, 0 }
};
</programlisting>
The example matches e.g. "auud\0" with relevance 100, and "blau" with
relevance 90.</informalexample>
@prefix: the prefix for this pattern
@mask: mask containing bytes which modify how the prefix is matched against
test data
@relevance: relevance of this pattern
@Since: 2.2
<!-- ##### USER_FUNCTION GdkPixbufModuleFillVtableFunc ##### -->
<para>
Defines the type of the function used to set the vtable of a
#GdkPixbufModule when it is loaded.
</para>
@module: a #GdkPixbufModule.
@Since: 2.2
<!-- ##### USER_FUNCTION GdkPixbufModuleFillInfoFunc ##### -->
<para>
Defines the type of the function used to fill a
#GdkPixbufFormat structure with information about a module.
</para>
@info: a #GdkPixbufFormat.
@Since: 2.2
<!-- ##### USER_FUNCTION GdkPixbufModuleSizeFunc ##### -->
<para>
Defines the type of the function that gets called once the size
of the loaded image is known.
</para>
<para>
The function is expected to set @width and @height to the desired
size to which the image should be scaled. If a module has no efficient
way to achieve the desired scaling during the loading of the image, it may
either ignore the size request, or only approximate it -- &gdk-pixbuf; will
then perform the required scaling on the completely loaded image.
</para>
<para>
If the function sets @width or @height to zero, the module should interpret
this as a hint that it will be closed soon and shouldn't allocate further
resources. This convention is used to implement gdk_pixbuf_get_file_info()
efficiently.
</para>
@width: pointer to a location containing the current image width
@height: pointer to a location containing the current image height
@user_data: the loader.
@Since: 2.2
<!-- ##### USER_FUNCTION GdkPixbufModulePreparedFunc ##### -->
<para>
Defines the type of the function that gets called once the initial
setup of @pixbuf is done.
</para>
<para>
#GdkPixbufLoader uses a function of this type to emit the
"<link linkend="GdkPixbufLoader-area-prepared">area_prepared</link>"
signal.
</para>
@pixbuf: the #GdkPixbuf that is currently being loaded.
@anim: if an animation is being loaded, the #GdkPixbufAnimation, else %NULL.
@user_data: the loader.
@Since: 2.2
<!-- ##### USER_FUNCTION GdkPixbufModuleUpdatedFunc ##### -->
<para>
Defines the type of the function that gets called every time a region
of @pixbuf is updated.
</para>
<para>
#GdkPixbufLoader uses a function of this type to emit the
"<link linkend="GdkPixbufLoader-area-updated">area_updated</link>"
signal.
</para>
@pixbuf: the #GdkPixbuf that is currently being loaded.
@x: the X origin of the updated area.
@y: the Y origin of the updated area.
@width: the width of the updated area.
@height: the height of the updated area.
@user_data: the loader.
@Since: 2.2
<!-- ##### STRUCT GdkPixbufModule ##### -->
<para>
A #GdkPixbufModule contains the necessary functions to load and save
images in a certain file format.
</para>
<para>
A #GdkPixbufModule can be loaded dynamically from a #GModule.
Each loadable module must contain a #GdkPixbufModuleFillVtableFunc function
named <function>fill_vtable</function>, which will get called when the module
is loaded and must set the function pointers of the #GdkPixbufModule.
</para>
@module_name: the name of the module, usually the same as the
usual file extension for images of this type, eg. "xpm", "jpeg" or "png".
@module_path: the path from which the module is loaded.
@module: the loaded #GModule.
@info: a #GdkPixbufFormat holding information about the module.
@load: loads an image from a file.
@load_xpm_data: loads an image from data in memory.
@begin_load: begins an incremental load.
@stop_load: stops an incremental load.
@load_increment: continues an incremental load.
@load_animation: loads an animation from a file.
@save: saves a #GdkPixbuf to a file.
@save_to_callback: saves a #GdkPixbuf by calling the given #GdkPixbufSaveFunc.
<!-- ##### STRUCT GdkPixbufAnimationClass ##### -->
<para>
Modules supporting animations must derive a type from
#GdkPixbufAnimation, providing suitable implementations of the
virtual functions.
</para>
@parent_class: the parent class
@is_static_image: returns whether the given animation is just a static image.
@get_static_image: returns a static image representing the given animation.
@get_size: fills @width and @height with the frame size of the animation.
@get_iter: returns an iterator for the given animation.
<!-- ##### STRUCT GdkPixbufAnimationIterClass ##### -->
<para>
Modules supporting animations must derive a type from
#GdkPixbufAnimationIter, providing suitable implementations of the
virtual functions.
</para>
@parent_class: the parent class
@get_delay_time: returns the time in milliseconds that the current frame
should be shown.
@get_pixbuf: returns the current frame.
@on_currently_loading_frame: returns whether the current frame of @iter is
being loaded.
@advance: advances the iterator to @current_time, possibly changing the
current frame.

84
docs/reference/gdk-pixbuf/tmpl/refcounting.sgml
View File

@ -1,84 +0,0 @@
<!-- ##### SECTION Title ##### -->
Reference Counting and Memory Mangement
<!-- ##### SECTION Short_Description ##### -->
Functions for reference counting and memory management on pixbufs.
<!-- ##### SECTION Long_Description ##### -->
<para>
#GdkPixbuf structures are reference counted. This means that an
application can share a single pixbuf among many parts of the
code. When a piece of the program needs to keep a pointer to a
pixbuf, it should add a reference to it by calling g_object_ref().
When it no longer needs the pixbuf, it should subtract a reference
by calling g_object_unref(). The pixbuf will be destroyed when
its reference count drops to zero. Newly-created #GdkPixbuf
structures start with a reference count of one.
</para>
<note>
<para>
As #GdkPixbuf is derived from #GObject now, gdk_pixbuf_ref() and
gdk_pixbuf_unref() are deprecated in favour of g_object_ref()
and g_object_unref () resp.
</para>
</note>
<para>
<emphasis>Finalizing</emphasis> a pixbuf means to free its pixel
data and to free the #GdkPixbuf structure itself. Most of the
library functions that create #GdkPixbuf structures create the
pixel data by themselves and define the way it should be freed;
you do not need to worry about those. The only function that lets
you specify how to free the pixel data is
gdk_pixbuf_new_from_data(). Since you pass it a pre-allocated
pixel buffer, you must also specify a way to free that data. This
is done with a function of type #GdkPixbufDestroyNotify. When a
pixbuf created with gdk_pixbuf_new_from_data() is finalized, your
destroy notification function will be called, and it is its
responsibility to free the pixel array.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
#GdkPixbuf, gdk_pixbuf_new_from_data().
</para>
<!-- ##### SECTION Stability_Level ##### -->
<!-- ##### SECTION Image ##### -->
<!-- ##### FUNCTION gdk_pixbuf_ref ##### -->
<para>
</para>
@pixbuf:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_unref ##### -->
<para>
</para>
@pixbuf:
<!-- ##### USER_FUNCTION GdkPixbufDestroyNotify ##### -->
<para>
A function of this type is responsible for freeing the pixel array
of a pixbuf. The gdk_pixbuf_new_from_data() function lets you
pass in a pre-allocated pixel array so that a pixbuf can be
created from it; in this case you will need to pass in a function
of #GdkPixbufDestroyNotify so that the pixel data can be freed
when the pixbuf is finalized.
</para>
@pixels: The pixel array of the pixbuf that is being finalized.
@data: User closure data.

246
docs/reference/gdk-pixbuf/tmpl/scaling.sgml
View File

@ -1,246 +0,0 @@
<!-- ##### SECTION Title ##### -->
Scaling
<!-- ##### SECTION Short_Description ##### -->
Scaling pixbufs and scaling and compositing pixbufs
<!-- ##### SECTION Long_Description ##### -->
<para>
The &gdk-pixbuf; contains functions to scale pixbufs, to scale
pixbufs and composite against an existing image, and to scale
pixbufs and composite against a solid color or checkerboard.
Compositing a checkerboard is a common way to show an image with
an alpha channel in image-viewing and editing software.
</para>
<para>
Since the full-featured functions (gdk_pixbuf_scale(),
gdk_pixbuf_composite(), and gdk_pixbuf_composite_color()) are
rather complex to use and have many arguments, two simple
convenience functions are provided, gdk_pixbuf_scale_simple() and
gdk_pixbuf_composite_color_simple() which create a new pixbuf of a
given size, scale an original image to fit, and then return the
new pixbuf.
</para>
<para>
Scaling and compositing functions take advantage of MMX hardware
acceleration on systems where MMX is supported. If gdk-pixbuf is built
with the Sun mediaLib library, these functions are instead accelerated
using mediaLib, which provides hardware acceleration on Intel, AMD,
and Sparc chipsets. If desired, mediaLib support can be turned off by
setting the GDK_DISABLE_MEDIALIB environment variable.
</para>
<para>
The following example demonstrates handling an expose event by
rendering the appropriate area of a source image (which is scaled
to fit the widget) onto the widget's window. The source image is
rendered against a checkerboard, which provides a visual
representation of the alpha channel if the image has one. If the
image doesn't have an alpha channel, calling
gdk_pixbuf_composite_color() function has exactly the same effect
as calling gdk_pixbuf_scale().
</para>
<example>
<title>Handling an expose event.</title>
<programlisting>
gboolean
expose_cb (GtkWidget *widget, GdkEventExpose *event, gpointer data)
{
GdkPixbuf *dest;
dest = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, event->area.width, event->area.height);
gdk_pixbuf_composite_color (pixbuf, dest,
0, 0, event->area.width, event->area.height,
-event->area.x, -event->area.y,
(double) widget->allocation.width / gdk_pixbuf_get_width (pixbuf),
(double) widget->allocation.height / gdk_pixbuf_get_height (pixbuf),
GDK_INTERP_BILINEAR, 255,
event->area.x, event->area.y, 16, 0xaaaaaa, 0x555555);
gdk_draw_pixbuf (widget->window, widget->style->fg_gc[GTK_STATE_NORMAL], dest,
0, 0, event->area.x, event->area.y,
event->area.width, event->area.height,
GDK_RGB_DITHER_NORMAL, event->area.x, event->area.y);
gdk_pixbuf_unref (dest);
return TRUE;
}
</programlisting>
</example>
<!-- ##### SECTION See_Also ##### -->
<para>
<link linkend="gdk-GdkRGB">GdkRGB</link>.
</para>
<!-- ##### SECTION Stability_Level ##### -->
<!-- ##### SECTION Image ##### -->
<!-- ##### ENUM GdkInterpType ##### -->
<para>
This enumeration describes the different interpolation modes that
can be used with the scaling functions. @GDK_INTERP_NEAREST is
the fastest scaling method, but has horrible quality when
scaling down. @GDK_INTERP_BILINEAR is the best choice if you
aren't sure what to choose, it has a good speed/quality balance.
<note>
<para>
Cubic filtering is missing from the list; hyperbolic
interpolation is just as fast and results in higher quality.
</para>
</note>
</para>
@GDK_INTERP_NEAREST: Nearest neighbor sampling; this is the fastest
and lowest quality mode. Quality is normally unacceptable when scaling
down, but may be OK when scaling up.
@GDK_INTERP_TILES: This is an accurate simulation of the PostScript
image operator without any interpolation enabled. Each pixel is
rendered as a tiny parallelogram of solid color, the edges of which
are implemented with antialiasing. It resembles nearest neighbor for
enlargement, and bilinear for reduction.
@GDK_INTERP_BILINEAR: Best quality/speed balance; use this mode by
default. Bilinear interpolation. For enlargement, it is
equivalent to point-sampling the ideal bilinear-interpolated image.
For reduction, it is equivalent to laying down small tiles and
integrating over the coverage area.
@GDK_INTERP_HYPER: This is the slowest and highest quality
reconstruction function. It is derived from the hyperbolic filters in
Wolberg's "Digital Image Warping", and is formally defined as the
hyperbolic-filter sampling the ideal hyperbolic-filter interpolated
image (the filter is designed to be idempotent for 1:1 pixel mapping).
<!-- ##### FUNCTION gdk_pixbuf_scale_simple ##### -->
<para>
</para>
@src:
@dest_width:
@dest_height:
@interp_type:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_scale ##### -->
<para>
</para>
@src:
@dest:
@dest_x:
@dest_y:
@dest_width:
@dest_height:
@offset_x:
@offset_y:
@scale_x:
@scale_y:
@interp_type:
<!-- ##### FUNCTION gdk_pixbuf_composite_color_simple ##### -->
<para>
</para>
@src:
@dest_width:
@dest_height:
@interp_type:
@overall_alpha:
@check_size:
@color1:
@color2:
@Returns: <!--
Local variables:
mode: sgml
sgml-parent-document: ("../gdk-pixbuf.sgml" "book" "refsect2" "")
End:
-->
<!-- ##### FUNCTION gdk_pixbuf_composite ##### -->
<para>
</para>
@src:
@dest:
@dest_x:
@dest_y:
@dest_width:
@dest_height:
@offset_x:
@offset_y:
@scale_x:
@scale_y:
@interp_type:
@overall_alpha:
<!-- ##### FUNCTION gdk_pixbuf_composite_color ##### -->
<para>
</para>
@src:
@dest:
@dest_x:
@dest_y:
@dest_width:
@dest_height:
@offset_x:
@offset_y:
@scale_x:
@scale_y:
@interp_type:
@overall_alpha:
@check_x:
@check_y:
@check_size:
@color1:
@color2:
<!-- ##### ENUM GdkPixbufRotation ##### -->
<para>
The possible rotations which can be passed to gdk_pixbuf_rotate_simple().
To make them easier to use, their numerical values are the actual degrees.
</para>
@GDK_PIXBUF_ROTATE_NONE: No rotation.
@GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE: Rotate by 90 degrees.
@GDK_PIXBUF_ROTATE_UPSIDEDOWN: Rotate by 180 degrees.
@GDK_PIXBUF_ROTATE_CLOCKWISE: Rotate by 270 degrees.
<!-- ##### FUNCTION gdk_pixbuf_rotate_simple ##### -->
<para>
</para>
@src:
@angle:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_flip ##### -->
<para>
</para>
@src:
@horizontal:
@Returns:

87
docs/reference/gdk-pixbuf/tmpl/util.sgml
View File

@ -1,87 +0,0 @@
<!-- ##### SECTION Title ##### -->
Utilities
<!-- ##### SECTION Short_Description ##### -->
Utility and miscellaneous convenience functions.
<!-- ##### SECTION Long_Description ##### -->
<para>
These functions provide miscellaneous utilities for manipulating
pixbufs. The pixel data in pixbufs may of course be manipulated
directly by applications, but several common operations can be
performed by these functions instead.
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
#GdkPixbuf
</para>
<!-- ##### SECTION Stability_Level ##### -->
<!-- ##### SECTION Image ##### -->
<!-- ##### FUNCTION gdk_pixbuf_add_alpha ##### -->
<para>
</para>
@pixbuf:
@substitute_color:
@r:
@g:
@b:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_copy_area ##### -->
<para>
</para>
@src_pixbuf:
@src_x:
@src_y:
@width:
@height:
@dest_pixbuf:
@dest_x:
@dest_y: <!--
Local variables:
mode: sgml
sgml-parent-document: ("../gdk-pixbuf.sgml" "book" "refsect2" "")
End:
-->
<!-- ##### FUNCTION gdk_pixbuf_saturate_and_pixelate ##### -->
<para>
</para>
@src:
@dest:
@saturation:
@pixelate:
<!-- ##### FUNCTION gdk_pixbuf_apply_embedded_orientation ##### -->
<para>
</para>
@src:
@Returns:
<!-- ##### FUNCTION gdk_pixbuf_fill ##### -->
<para>
</para>
@pixbuf:
@pixel:

1
docs/reference/gdk-pixbuf/version.xml.in
View File

@ -1 +0,0 @@
@GTK_VERSION@

2
docs/reference/gdk/Makefile.am
View File

@ -142,7 +142,7 @@ HTML_IMAGES = \
images/xterm.png
# Extra options to supply to gtkdoc-fixref
FIXXREF_OPTIONS=--extra-dir=../gdk-pixbuf/html \
FIXXREF_OPTIONS= \
--extra-dir=$(GLIB_PREFIX)/share/gtk-doc/html/gobject \
--extra-dir=$(GLIB_PREFIX)/share/gtk-doc/html/glib \
--extra-dir=$(CAIRO_PREFIX)/share/gtk-doc/html/cairo

4
docs/reference/gtk/Makefile.am
View File

@ -26,7 +26,6 @@ CFILE_GLOB=$(top_srcdir)/gtk/*.c
IGNORE_HFILES= \
gtkalias.h \
fnmatch.h \
gdk-pixbuf-loader.h \
gtkdebug.h \
gtkbuilderprivate.h \
gtkdndcursors.h \
@ -110,7 +109,6 @@ CPPFLAGS += \
-UGTK_DISABLE_SINGLE_INCLUDES
GTKDOC_LIBS = \
$(top_builddir)/gdk-pixbuf/libgdk_pixbuf-$(GTK_API_VERSION).la \
$(top_builddir)/gdk/$(gdktargetlib) \
$(top_builddir)/gtk/$(gtktargetlib)
@ -354,7 +352,7 @@ HTML_IMAGES = \
$(srcdir)/images/layout-tbrl.png
# Extra options to supply to gtkdoc-fixref
FIXXREF_OPTIONS=--extra-dir=../gdk-pixbuf/html --extra-dir=../gdk/html \
FIXXREF_OPTIONS=--extra-dir=../gdk/html \
--extra-dir=$(GLIB_PREFIX)/share/gtk-doc/html/gobject \
--extra-dir=$(GLIB_PREFIX)/share/gtk-doc/html/glib \
--extra-dir=$(ATK_PREFIX)/share/gtk-doc/html/atk \

21
docs/reference/gtk/building.sgml
View File

@ -165,8 +165,8 @@ How to compile GTK+ itself
</itemizedlist>
<para>
Three of the libraries that GTK+ depends on are maintained by
by the GTK+ team: GLib, Pango, and ATK. Other libraries are
maintained separately.
by the GTK+ team: GLib, GdkPixbuf, Pango, and ATK. Other libraries
are maintained separately.
</para>
<itemizedlist>
<listitem>
@ -328,9 +328,6 @@ How to compile GTK+ itself
<arg>--disable-modules</arg>
<arg>--enable-modules</arg>
</group>
<group>
<arg>--with-included-loaders==LOADER1,LOADER2,...</arg>
</group>
<group>
<arg>--with-included-immodules=MODULE1,MODULE2,...</arg>
</group>
@ -386,8 +383,8 @@ How to compile GTK+ itself
<systemitem>--enable-modules</systemitem></title>
<para>
Normally GTK+ will try to build the GdkPixbuf image file
format loaders as little shared libraries that are loaded on
Normally GTK+ will try to build the input method modules
as little shared libraries that are loaded on
demand. The <systemitem>--disable-modules</systemitem>
argument indicates that they should all be built statically
into the GTK+ library instead. This is useful for
@ -399,16 +396,6 @@ How to compile GTK+ itself
</para>
</formalpara>
<formalpara>
<title><systemitem>--with-included-loaders</systemitem></title>
<para>
This option allows you to specify which image loaders you
want to include; for example, you might include only the PNG
loader to create a smaller GdkPixbuf binary.
</para>
</formalpara>
<formalpara>
<title><systemitem>--with-included-immodules</systemitem></title>

9
docs/tools/Makefile.am
View File

@ -9,16 +9,15 @@ INCLUDES = \
$(GTK_DEP_CFLAGS)
DEPS = \
$(top_builddir)/gdk-pixbuf/libgdk_pixbuf-$(GTK_API_VERSION).la \
$(top_builddir)/gdk/$(gdktargetlib) \
$(top_builddir)/gtk/$(gtktargetlib)
LDADDS = \
$(top_builddir)/gdk-pixbuf/libgdk_pixbuf-$(GTK_API_VERSION).la \
$(top_builddir)/gdk/$(gdktargetlib) \
$(top_builddir)/gdk/$(gdktargetlib) \
$(top_builddir)/gtk/$(gtktargetlib) \
$(GTK_DEP_LIBS) \
$(GDK_DEP_LIBS)
$(GTK_DEP_LIBS) \
$(GDK_DEP_LIBS) \
-lm
if USE_X11
noinst_PROGRAMS = \

6289
gdk-pixbuf/ChangeLog
View File

File diff suppressed because it is too large Load Diff

748
gdk-pixbuf/Makefile.am
View File

@ -1,748 +0,0 @@
include $(top_srcdir)/Makefile.decl
-include $(INTROSPECTION_MAKEFILE)
INTROSPECTION_GIRS =
SUBDIRS = pixops
if PLATFORM_WIN32
no_undefined = -no-undefined
endif
if OS_WIN32
gdk_pixbuf_def = gdk_pixbuf.def
gdk_pixbuf_symbols = -export-symbols $(srcdir)/gdk_pixbuf.def
gdk_pixbuf_win32_res = gdk_pixbuf-win32-res.o
gdk_pixbuf_win32_res_ldflag = -Wl,gdk_pixbuf-win32-res.o
libole32 = -lole32
gdk_pixbuf-win32-res.o : gdk_pixbuf.rc
$(WINDRES) gdk_pixbuf.rc $@
install-def-file:
$(INSTALL) $(srcdir)/gdk_pixbuf.def $(DESTDIR)$(libdir)/gdk_pixbuf-$(GTK_API_VERSION).def
uninstall-def-file:
-rm $(DESTDIR)$(libdir)/gdk_pixbuf-$(GTK_API_VERSION).def
else
install-def-file:
uninstall-def-file:
endif
if MS_LIB_AVAILABLE
noinst_DATA = gdk_pixbuf-$(GTK_API_VERSION).lib
gdk_pixbuf-$(GTK_API_VERSION).lib: libgdk_pixbuf-$(GTK_API_VERSION).la gdk_pixbuf.def
lib -machine:@LIB_EXE_MACHINE_FLAG@ -name:libgdk_pixbuf-$(GTK_API_VERSION)-@LT_CURRENT_MINUS_AGE@.dll -def:gdk_pixbuf.def -out:$@
install-ms-lib:
$(INSTALL) gdk_pixbuf-$(GTK_API_VERSION).lib $(DESTDIR)$(libdir)
uninstall-ms-lib:
-rm $(DESTDIR)$(libdir)/gdk_pixbuf-$(GTK_API_VERSION).lib
else
install-ms-lib:
uninstall-ms-lib:
endif
# This places the generated .def file in srcdir, since it is expected to be there.
# (The one from a tarball is)
gdk_pixbuf.def: gdk-pixbuf.symbols
(echo -e EXPORTS; $(CPP) -P -DINCLUDE_VARIABLES -DG_OS_WIN32 -DALL_FILES - <$(srcdir)/gdk-pixbuf.symbols | sed -e '/^$$/d' -e 's/^/ /' -e 's/G_GNUC_[^ ]*//g') > $(srcdir)/gdk_pixbuf.def
gdk-pixbuf-alias.h: gdk-pixbuf.symbols
$(PERL) $(srcdir)/makegdkpixbufalias.pl < $(srcdir)/gdk-pixbuf.symbols > gdk-pixbuf-alias.h
gdk-pixbuf-aliasdef.c: gdk-pixbuf.symbols
$(PERL) $(srcdir)/makegdkpixbufalias.pl -def < $(srcdir)/gdk-pixbuf.symbols > gdk-pixbuf-aliasdef.c
if OS_LINUX
TESTS = abicheck.sh pltcheck.sh
endif
lib_LTLIBRARIES = \
libgdk_pixbuf-2.0.la
loaderdir = $(libdir)/gtk-2.0/$(GTK_BINARY_VERSION)/loaders
module_libs = libgdk_pixbuf-$(GTK_API_VERSION).la $(GDK_PIXBUF_DEP_LIBS)
#
# The PNG loader
#
libstatic_pixbufloader_png_la_SOURCES = io-png.c
libpixbufloader_png_la_SOURCES = io-png.c
libpixbufloader_png_la_LDFLAGS = -avoid-version -module $(no_undefined)
libpixbufloader_png_la_LIBADD = $(LIBPNG) $(module_libs)
#
# The BMP loader
#
libstatic_pixbufloader_bmp_la_SOURCES = io-bmp.c
libpixbufloader_bmp_la_SOURCES = io-bmp.c
libpixbufloader_bmp_la_LDFLAGS = -avoid-version -module $(no_undefined)
libpixbufloader_bmp_la_LIBADD = $(module_libs)
#
# The WBMP loader
#
libstatic_pixbufloader_wbmp_la_SOURCES = io-wbmp.c
libpixbufloader_wbmp_la_SOURCES = io-wbmp.c
libpixbufloader_wbmp_la_LDFLAGS = -avoid-version -module $(no_undefined)
libpixbufloader_wbmp_la_LIBADD = $(module_libs)
#
# The GIF loader
#
libstatic_pixbufloader_gif_la_SOURCES = io-gif.c io-gif-animation.c io-gif-animation.h
libpixbufloader_gif_la_SOURCES = io-gif.c io-gif-animation.c io-gif-animation.h
libpixbufloader_gif_la_LDFLAGS = -avoid-version -module $(no_undefined)
libpixbufloader_gif_la_LIBADD = $(module_libs)
#
# The ICO loader
#
libstatic_pixbufloader_ico_la_SOURCES = io-ico.c
libpixbufloader_ico_la_SOURCES = io-ico.c
libpixbufloader_ico_la_LDFLAGS = -avoid-version -module $(no_undefined)
libpixbufloader_ico_la_LIBADD = $(module_libs)
#
# The ANI loader
#
libstatic_pixbufloader_ani_la_SOURCES = io-ani.c io-ani-animation.c io-ani-animation.h
libpixbufloader_ani_la_SOURCES = io-ani.c io-ani-animation.c io-ani-animation.h
libpixbufloader_ani_la_LDFLAGS = -avoid-version -module $(no_undefined)
libpixbufloader_ani_la_LIBADD = $(module_libs)
#
# The JPEG loader
#
libstatic_pixbufloader_jpeg_la_SOURCES = io-jpeg.c
libpixbufloader_jpeg_la_SOURCES = io-jpeg.c
libpixbufloader_jpeg_la_LDFLAGS = -avoid-version -module $(no_undefined)
libpixbufloader_jpeg_la_LIBADD = $(LIBJPEG) $(module_libs)
#
# The PNM loader
#
libstatic_pixbufloader_pnm_la_SOURCES = io-pnm.c
libpixbufloader_pnm_la_SOURCES = io-pnm.c
libpixbufloader_pnm_la_LDFLAGS = -avoid-version -module $(no_undefined)
libpixbufloader_pnm_la_LIBADD = $(module_libs)
#
# The RAS loader
#
libstatic_pixbufloader_ras_la_SOURCES = io-ras.c
libpixbufloader_ras_la_SOURCES = io-ras.c
libpixbufloader_ras_la_LDFLAGS = -avoid-version -module $(no_undefined)
libpixbufloader_ras_la_LIBADD = $(module_libs)
#
# The TIFF loader
#
libstatic_pixbufloader_tiff_la_SOURCES = io-tiff.c
libpixbufloader_tiff_la_SOURCES = io-tiff.c
libpixbufloader_tiff_la_LDFLAGS = -avoid-version -module $(no_undefined)
libpixbufloader_tiff_la_LIBADD = $(LIBTIFF) $(module_libs)
#
# The XPM loader
#
libstatic_pixbufloader_xpm_la_SOURCES = io-xpm.c
libpixbufloader_xpm_la_SOURCES = io-xpm.c
libpixbufloader_xpm_la_LDFLAGS = -avoid-version -module $(no_undefined)
libpixbufloader_xpm_la_LIBADD = $(module_libs)
#
# The XBM loader
#
libstatic_pixbufloader_xbm_la_SOURCES = io-xbm.c
libpixbufloader_xbm_la_SOURCES = io-xbm.c
libpixbufloader_xbm_la_LDFLAGS = -avoid-version -module $(no_undefined)
libpixbufloader_xbm_la_LIBADD = $(module_libs)
#
# The TGA loader
#
libstatic_pixbufloader_tga_la_SOURCES = io-tga.c
libpixbufloader_tga_la_SOURCES = io-tga.c
libpixbufloader_tga_la_LDFLAGS = -avoid-version -module $(no_undefined)
libpixbufloader_tga_la_LIBADD = $(module_libs)
#
# The .icns loader
#
libstatic_pixbufloader_icns_la_SOURCES = io-icns.c
libpixbufloader_icns_la_SOURCES = io-icns.c
libpixbufloader_icns_la_LDFLAGS = -avoid-version -module $(no_undefined)
libpixbufloader_icns_la_LIBADD = $(module_libs)
#
# The PCX loader
#
libstatic_pixbufloader_pcx_la_SOURCES = io-pcx.c
libpixbufloader_pcx_la_SOURCES = io-pcx.c
libpixbufloader_pcx_la_LDFLAGS = -avoid-version -module $(no_undefined)
libpixbufloader_pcx_la_LIBADD = $(module_libs)
#
# The JPEG2000 loader
#
libstatic_pixbufloader_jasper_la_SOURCES = io-jasper.c
libpixbufloader_jasper_la_SOURCES = io-jasper.c
libpixbufloader_jasper_la_LDFLAGS = -avoid-version -module $(no_undefined)
libpixbufloader_jasper_la_LIBADD = $(LIBJASPER) $(module_libs)
#
# The QTIF loader
#
libstatic_pixbufloader_qtif_la_SOURCES = io-qtif.c
libpixbufloader_qtif_la_SOURCES = io-qtif.c
libpixbufloader_qtif_la_LDFLAGS = -avoid-version -module $(no_undefined)
libpixbufloader_qtif_la_LIBADD = $(module_libs)
if BUILD_GDIPLUS_LOADERS
if INCLUDE_GDIPLUS
# When building the GDI+ loader statically, we put the "common" objects
# only in one of the archives to avoid duplicate definitions
STATIC_GDIPLUS_LIBS = \
libstatic-pixbufloader-gdip-ico.la \
libstatic-pixbufloader-gdip-wmf.la \
libstatic-pixbufloader-gdip-emf.la \
libstatic-pixbufloader-gdip-bmp.la \
libstatic-pixbufloader-gdip-gif.la \
libstatic-pixbufloader-gdip-jpeg.la \
libstatic-pixbufloader-gdip-tiff.la
libstatic_pixbufloader_gdip_ico_la_SOURCES = \
io-gdip-native.h \
io-gdip-propertytags.h \
io-gdip-utils.h \
io-gdip-utils.c \
io-gdip-animation.c \
io-gdip-animation.h \
io-gdip-ico.c
libstatic_pixbufloader_gdip_wmf_la_SOURCES = \
io-gdip-wmf.c
libstatic_pixbufloader_gdip_emf_la_SOURCES = \
io-gdip-emf.c
libstatic_pixbufloader_gdip_bmp_la_SOURCES = \
io-gdip-bmp.c
libstatic_pixbufloader_gdip_gif_la_SOURCES = \
io-gdip-gif.c
libstatic_pixbufloader_gdip_jpeg_la_SOURCES = \
io-gdip-jpeg.c
libstatic_pixbufloader_gdip_tiff_la_SOURCES = \
io-gdip-tiff.c
else
GDIPLUS_LIBS = \
libpixbufloader-gdip-ico.la \
libpixbufloader-gdip-wmf.la \
libpixbufloader-gdip-emf.la \
libpixbufloader-gdip-bmp.la \
libpixbufloader-gdip-gif.la \
libpixbufloader-gdip-jpeg.la \
libpixbufloader-gdip-tiff.la
libpixbufloader_gdip_ico_la_LDFLAGS = -avoid-version -module -no-undefined
libpixbufloader_gdip_ico_la_SOURCES = \
io-gdip-native.h \
io-gdip-propertytags.h \
io-gdip-utils.h \
io-gdip-utils.c \
io-gdip-animation.c \
io-gdip-animation.h \
io-gdip-ico.c
libpixbufloader_gdip_ico_la_LIBADD = $(module_libs) $(libole32)
libpixbufloader_gdip_wmf_la_LDFLAGS = -avoid-version -module -no-undefined
libpixbufloader_gdip_wmf_la_SOURCES = \
io-gdip-native.h \
io-gdip-propertytags.h \
io-gdip-utils.h \
io-gdip-utils.c \
io-gdip-animation.c \
io-gdip-animation.h \
io-gdip-wmf.c
libpixbufloader_gdip_wmf_la_LIBADD = $(module_libs) $(libole32)
libpixbufloader_gdip_emf_la_LDFLAGS = -avoid-version -module -no-undefined
libpixbufloader_gdip_emf_la_SOURCES = \
io-gdip-native.h \
io-gdip-propertytags.h \
io-gdip-utils.h \
io-gdip-utils.c \
io-gdip-animation.c \
io-gdip-animation.h \
io-gdip-emf.c
libpixbufloader_gdip_emf_la_LIBADD = $(module_libs) $(libole32)
libpixbufloader_gdip_bmp_la_LDFLAGS = -avoid-version -module -no-undefined
libpixbufloader_gdip_bmp_la_SOURCES = \
io-gdip-native.h \
io-gdip-propertytags.h \
io-gdip-utils.h \
io-gdip-utils.c \
io-gdip-animation.c \
io-gdip-animation.h \
io-gdip-bmp.c
libpixbufloader_gdip_bmp_la_LIBADD = $(module_libs) $(libole32)
libpixbufloader_gdip_gif_la_LDFLAGS = -avoid-version -module -no-undefined
libpixbufloader_gdip_gif_la_SOURCES = \
io-gdip-native.h \
io-gdip-propertytags.h \
io-gdip-utils.h \
io-gdip-utils.c \
io-gdip-animation.c \
io-gdip-animation.h \
io-gdip-gif.c
libpixbufloader_gdip_gif_la_LIBADD = $(module_libs) $(libole32)
libpixbufloader_gdip_jpeg_la_LDFLAGS = -avoid-version -module -no-undefined
libpixbufloader_gdip_jpeg_la_SOURCES = \
io-gdip-native.h \
io-gdip-propertytags.h \
io-gdip-utils.h \
io-gdip-utils.c \
io-gdip-animation.c \
io-gdip-animation.h \
io-gdip-jpeg.c
libpixbufloader_gdip_jpeg_la_LIBADD = $(module_libs) $(libole32)
libpixbufloader_gdip_tiff_la_LDFLAGS = -avoid-version -module -no-undefined
libpixbufloader_gdip_tiff_la_SOURCES = \
io-gdip-native.h \
io-gdip-propertytags.h \
io-gdip-utils.h \
io-gdip-utils.c \
io-gdip-animation.c \
io-gdip-animation.h \
io-gdip-tiff.c
libpixbufloader_gdip_tiff_la_LIBADD = $(module_libs) $(libole32)
endif
else
# Loaders that aren't built if we build the GDI+ loader
if INCLUDE_BMP
STATIC_BMP_LIB = libstatic-pixbufloader-bmp.la
else
BMP_LIB = libpixbufloader-bmp.la
endif
if INCLUDE_GIF
STATIC_GIF_LIB = libstatic-pixbufloader-gif.la
else
GIF_LIB = libpixbufloader-gif.la
endif
if INCLUDE_ICO
STATIC_ICO_LIB = libstatic-pixbufloader-ico.la
else
ICO_LIB = libpixbufloader-ico.la
endif
if HAVE_JPEG
if INCLUDE_JPEG
STATIC_JPEG_LIB = libstatic-pixbufloader-jpeg.la
else
JPEG_LIB = libpixbufloader-jpeg.la
endif
endif
if HAVE_TIFF
if INCLUDE_TIFF
STATIC_TIFF_LIB = libstatic-pixbufloader-tiff.la
else
TIFF_LIB = libpixbufloader-tiff.la
endif
endif
# End of loaders not built if building GDI+ loader
endif
if HAVE_PNG
if INCLUDE_PNG
STATIC_PNG_LIB = libstatic-pixbufloader-png.la
else
PNG_LIB = libpixbufloader-png.la
endif
endif
if INCLUDE_WBMP
STATIC_WBMP_LIB = libstatic-pixbufloader-wbmp.la
else
WBMP_LIB = libpixbufloader-wbmp.la
endif
if INCLUDE_ANI
STATIC_ANI_LIB = libstatic-pixbufloader-ani.la
else
ANI_LIB = libpixbufloader-ani.la
endif
if INCLUDE_PNM
STATIC_PNM_LIB = libstatic-pixbufloader-pnm.la
else
PNM_LIB = libpixbufloader-pnm.la
endif
if INCLUDE_RAS
STATIC_RAS_LIB = libstatic-pixbufloader-ras.la
else
RAS_LIB = libpixbufloader-ras.la
endif
if INCLUDE_XPM
STATIC_XPM_LIB = libstatic-pixbufloader-xpm.la
else
XPM_LIB = libpixbufloader-xpm.la
endif
if INCLUDE_XBM
STATIC_XBM_LIB = libstatic-pixbufloader-xbm.la
else
XBM_LIB = libpixbufloader-xbm.la
endif
if INCLUDE_TGA
STATIC_TGA_LIB = libstatic-pixbufloader-tga.la
else
TGA_LIB = libpixbufloader-tga.la
endif
if INCLUDE_PCX
STATIC_PCX_LIB = libstatic-pixbufloader-pcx.la
else
PCX_LIB = libpixbufloader-pcx.la
endif
if INCLUDE_ICNS
STATIC_ICNS_LIB = libstatic-pixbufloader-icns.la
else
ICNS_LIB = libpixbufloader-icns.la
endif
if HAVE_JASPER
if INCLUDE_JASPER
STATIC_JASPER_LIB = libstatic-pixbufloader-jasper.la
else
JASPER_LIB = libpixbufloader-jasper.la
endif
endif
if INCLUDE_QTIF
STATIC_QTIF_LIB = libstatic-pixbufloader-qtif.la
else
QTIF_LIB = libpixbufloader-qtif.la
endif
if BUILD_DYNAMIC_MODULES
loader_LTLIBRARIES = \
$(PNG_LIB) \
$(BMP_LIB) \
$(WBMP_LIB) \
$(GIF_LIB) \
$(ICO_LIB) \
$(ANI_LIB) \
$(JPEG_LIB) \
$(PNM_LIB) \
$(RAS_LIB) \
$(TIFF_LIB) \
$(XPM_LIB) \
$(XBM_LIB) \
$(TGA_LIB) \
$(ICNS_LIB) \
$(PCX_LIB) \
$(JASPER_LIB) \
$(QTIF_LIB) \
$(GDIPLUS_LIBS)
endif
noinst_LTLIBRARIES = \
$(STATIC_PNG_LIB) \
$(STATIC_BMP_LIB) \
$(STATIC_WBMP_LIB) \
$(STATIC_GIF_LIB) \
$(STATIC_ICO_LIB) \
$(STATIC_ANI_LIB) \
$(STATIC_JPEG_LIB) \
$(STATIC_PNM_LIB) \
$(STATIC_RAS_LIB) \
$(STATIC_TIFF_LIB) \
$(STATIC_XPM_LIB) \
$(STATIC_XBM_LIB) \
$(STATIC_TGA_LIB) \
$(STATIC_ICNS_LIB) \
$(STATIC_PCX_LIB) \
$(STATIC_JASPER_LIB) \
$(STATIC_QTIF_LIB) \
$(STATIC_GDIPLUS_LIBS)
builtin_objs = @INCLUDED_LOADER_OBJ@
DEPS = libgdk_pixbuf-$(GTK_API_VERSION).la
INCLUDES = \
-DG_LOG_DOMAIN=\"GdkPixbuf\" \
-DGDK_PIXBUF_COMPILATION \
-I$(top_srcdir) -I$(top_builddir) \
-I$(top_srcdir)/gdk-pixbuf \
-I$(top_builddir)/gdk-pixbuf \
-DGTK_SYSCONFDIR=\"$(sysconfdir)\" \
-DGTK_VERSION=\"$(GTK_VERSION)\" \
-DGTK_BINARY_VERSION=\"$(GTK_BINARY_VERSION)\" \
-DGTK_PREFIX=\"$(prefix)\" \
$(INCLUDED_LOADER_DEFINE) \
$(GTK_DEBUG_FLAGS) \
$(GDK_PIXBUF_DEP_CFLAGS) \
-DGDK_PIXBUF_ENABLE_BACKEND
AM_CPPFLAGS = "-DPIXBUF_LIBDIR=\"$(loaderdir)\"" "-DBUILT_MODULES_DIR=\"$(srcdir)/.libs\""
LDADDS = libgdk_pixbuf-$(GTK_API_VERSION).la $(GDK_PIXBUF_DEP_LIBS)
noinst_PROGRAMS = test-gdk-pixbuf
test_gdk_pixbuf_LDADD = $(LDADDS)
bin_PROGRAMS = gdk-pixbuf-csource gdk-pixbuf-query-loaders
gdk_pixbuf_csource_SOURCES = gdk-pixbuf-csource.c
gdk_pixbuf_csource_LDADD = $(LDADDS)
gdk_pixbuf_query_loaders_DEPENDENCIES = $(DEPS)
gdk_pixbuf_query_loaders_LDADD = $(LDADDS)
gdk_pixbuf_query_loaders_SOURCES = queryloaders.c
#
# The GdkPixBuf library
#
libgdk_pixbufincludedir = $(includedir)/gtk-2.0/gdk-pixbuf
libgdk_pixbuf_2_0_la_SOURCES = \
gdk-pixbuf-i18n.h \
gdk-pixbuf.c \
gdk-pixbuf-animation.c \
gdk-pixbuf-data.c \
gdk-pixbuf-io.c \
gdk-pixbuf-loader.c \
gdk-pixbuf-scale.c \
gdk-pixbuf-simple-anim.c \
gdk-pixbuf-scaled-anim.c \
gdk-pixbuf-util.c \
gdk-pixdata.c \
gdk-pixbuf-enum-types.c
libgdk_pixbuf_2_0_la_LDFLAGS = \
$(gdk_pixbuf_win32_res_ldflag) \
-version-info $(LT_VERSION_INFO) \
$(LIBTOOL_EXPORT_OPTIONS) \
$(no_undefined) \
$(gdk_pixbuf_symbols)
libgdk_pixbuf_2_0_la_LIBADD = pixops/libpixops.la $(builtin_objs) $(GDK_PIXBUF_DEP_LIBS) $(libole32)
libgdk_pixbuf_2_0_la_DEPENDENCIES = pixops/libpixops.la $(builtin_objs) $(gdk_pixbuf_def) $(gdk_pixbuf_win32_res)
gdk_pixbuf_headers = \
gdk-pixbuf.h \
gdk-pixbuf-core.h \
gdk-pixbuf-transform.h \
gdk-pixbuf-io.h \
gdk-pixbuf-animation.h \
gdk-pixbuf-simple-anim.h \
gdk-pixbuf-loader.h
libgdk_pixbufinclude_HEADERS = \
$(gdk_pixbuf_headers) \
gdk-pixbuf-enum-types.h \
gdk-pixbuf-marshal.h \
gdk-pixbuf-features.h \
gdk-pixdata.h
noinst_HEADERS = \
gdk-pixbuf-alias.h \
gdk-pixbuf-private.h \
gdk-pixbuf-scaled-anim.h \
xpm-color-table.h
BUILT_SOURCES = \
gdk-pixbuf-alias.h \
gdk-pixbuf-aliasdef.c \
gdk-pixbuf-enum-types.h \
gdk-pixbuf-enum-types.c \
gdk-pixbuf-marshal.h \
gdk-pixbuf-marshal.c \
gdk-pixbuf-features.h
CLEANFILES =
MAINTAINERCLEANFILES = \
gdk-pixbuf-aliasdef.c \
gdk-pixbuf-enum-types.h \
gdk-pixbuf-enum-types.c \
gdk-pixbuf-marshal.h \
gdk-pixbuf-marshal.c \
gdk-pixbuf.loaders
#
# gdk-pixbuf-enum-types.h
#
gdk-pixbuf-enum-types.h: s-enum-types-h
@true
s-enum-types-h: @REBUILD@ $(gdk_pixbuf_headers) gdk-pixbuf-enum-types.h.template
( cd $(srcdir) && $(GLIB_MKENUMS) --template gdk-pixbuf-enum-types.h.template \
$(gdk_pixbuf_headers) ) > tmp-gdk-pixbuf-enum-types.h \
&& (cmp -s tmp-gdk-pixbuf-enum-types.h gdk-pixbuf-enum-types.h || cp tmp-gdk-pixbuf-enum-types.h gdk-pixbuf-enum-types.h ) \
&& rm -f tmp-gdk-pixbuf-enum-types.h \
&& echo timestamp > $(@F)
CLEANFILES += tmp-gdk-pixbuf-enum-types.h
MAINTAINERCLEANFILES += s-enum-types-h
#
# gdk-pixbuf-enum-types.c
#
gdk-pixbuf-enum-types.c: @REBUILD@ $(gdk_pixbuf_headers) gdk-pixbuf-enum-types.c.template
(cd $(srcdir) && $(GLIB_MKENUMS) --template gdk-pixbuf-enum-types.c.template \
$(gdk_pixbuf_headers)) > gdk-pixbuf-enum-types.c
#
# gdk-pixbuf-marshal.h
#
gdk-pixbuf-marshal.h: @REBUILD@ stamp-gdk-pixbuf-marshal.h
@true
stamp-gdk-pixbuf-marshal.h: @REBUILD@ $(srcdir)/gdk-pixbuf-marshal.list
echo "#if !defined(GDK_PIXBUF_DISABLE_DEPRECATED) || defined(GDK_PIXBUF_COMPILATION)" > xgen-gmh \
&& $(GLIB_GENMARSHAL) --prefix=_gdk_pixbuf_marshal $(srcdir)/gdk-pixbuf-marshal.list --header >> xgen-gmh \
&& echo "#endif /* !GDK_PIXBUF_DISABLE_DEPRECATED || GDK_PIXBUF_COMPILATION */" >> xgen-gmh \
&& (cmp -s xgen-gmh gdk-pixbuf-marshal.h || cp xgen-gmh gdk-pixbuf-marshal.h) \
&& rm -f xgen-gmh xgen-gmh~ \
&& echo timestamp > $(@F)
CLEANFILES += xgen-gmh
MAINTAINERCLEANFILES += stamp-gdk-pixbuf-marshal.h
#
# gdk-pixbuf-marshal.c
#
$(srcdir)/gdk-pixbuf-marshal.c: @REBUILD@ $(srcdir)/gdk-pixbuf-marshal.list
(echo -e "#include <gdk-pixbuf/gdk-pixbuf.h>\n#include \"gdk-pixbuf-alias.h\"" | $(GLIB_GENMARSHAL) --prefix=_gdk_pixbuf_marshal $(srcdir)/gdk-pixbuf-marshal.list --body ) >> xgen-gmc \
&& cp xgen-gmc gdk-pixbuf-marshal.c \
&& rm -f xgen-gmc xgen-gmc~
CLEANFILES += xgen-gmc
# if srcdir!=builddir, clean out maintainer-clean files from builddir
# this allows dist to pass.
distclean-local:
if test $(srcdir) != .; then \
rm -f $(MAINTAINERCLEANFILES); \
fi
EXTRA_DIST += \
gdk-pixbuf-csource.1 \
makefile.msc \
gdk-pixbuf.symbols \
makegdkpixbufalias.pl \
abicheck.sh \
pltcheck.sh \
gdk_pixbuf.def \
gdk_pixbuf.rc \
gdk-pixbuf-marshal.c \
gdk-pixbuf-marshal.list \
gdk-pixbuf-enum-types.c.template \
gdk-pixbuf-enum-types.h.template \
gen-color-table.pl
if HAVE_INTROSPECTION
GdkPixbuf-2.0.gir: libgdk_pixbuf-2.0.la Makefile
GdkPixbuf_2_0_gir_SCANNERFLAGS = --strip-prefix=Gdk
GdkPixbuf_2_0_gir_INCLUDES = GModule-2.0 Gio-2.0
GdkPixbuf_2_0_gir_LIBS = libgdk_pixbuf-2.0.la
GdkPixbuf_2_0_gir_CFLAGS = $(INCLUDES)
GdkPixbuf_2_0_gir_FILES = \
$(addprefix $(srcdir)/,$(libgdk_pixbufinclude_HEADERS)) \
$(addprefix $(srcdir)/,$(libgdk_pixbuf_2_0_la_SOURCES))
INTROSPECTION_GIRS += GdkPixbuf-2.0.gir
girdir = $(datadir)/gir-1.0
gir_DATA = $(INTROSPECTION_GIRS)
typelibsdir = $(libdir)/girepository-1.0
typelibs_DATA = $(INTROSPECTION_GIRS:.gir=.typelib)
CLEANFILES += $(gir_DATA) $(typelibs_DATA)
endif
if CROSS_COMPILING
RUN_QUERY_LOADER_TEST=false
else
RUN_QUERY_LOADER_TEST=test -z "$(DESTDIR)"
endif
# Running this if cross compiling or if DESTDIR is set is going to
# not work at all, so skip it
# We use install-data-hook here to workaround a bug in automake and/or libtool
# that makes the install target for the loader libraries a dependency on
# install-data-am, and not install-exec-am. We need to ensure this gets run
# after the libraries are installed in their final locations.
install-data-hook: install-ms-lib install-def-file
@if $(RUN_QUERY_LOADER_TEST) ; then \
$(mkinstalldirs) $(DESTDIR)$(sysconfdir)/gtk-2.0 ; \
$(top_builddir)/gdk-pixbuf/gdk-pixbuf-query-loaders > $(DESTDIR)$(sysconfdir)/gtk-2.0/gdk-pixbuf.loaders ; \
else \
echo "***" ; \
echo "*** Warning: gdk-pixbuf.loaders not built" ; \
echo "***" ; \
echo "*** Generate this file manually on host" ; \
echo "*** system using gdk-pixbuf-query-loaders" ; \
echo "***" ; \
fi
uninstall-local: uninstall-ms-lib uninstall-def-file
rm -f $(DESTDIR)$(sysconfdir)/gtk-2.0/gdk-pixbuf.loaders
if CROSS_COMPILING
else
all-local: gdk-pixbuf.loaders
endif
if BUILD_DYNAMIC_MODULES
gdk-pixbuf.loaders: $(loader_LTLIBRARIES) gdk-pixbuf-query-loaders$(EXEEXT)
LOADERS=`echo libpixbufloader-*.la` ; \
if test "x$$LOADERS" != 'xlibpixbufloader-*.la' ; then \
echo "Writing a gdk-pixbuf.loader file to use when running examples before installing gdk-pixbuf."; \
$(top_builddir)/gdk-pixbuf/gdk-pixbuf-query-loaders $$LOADERS > ./gdk-pixbuf.loaders ;\
else \
echo "No dynamic modules found; will use only static modules for uninstalled example programs."; \
touch gdk-pixbuf.loaders; \
fi
else
gdk-pixbuf.loaders:
echo "No dynamic modules found; will use only static modules for uninstalled example programs."; \
touch gdk-pixbuf.loaders;
endif
-include $(top_srcdir)/git.mk

5
gdk-pixbuf/abicheck.sh
View File

@ -1,5 +0,0 @@
#! /bin/sh
cpp -DINCLUDE_VARIABLES -P -DALL_FILES ${srcdir:-.}/gdk-pixbuf.symbols | sed -e '/^$/d' -e 's/ G_GNUC.*$//' -e 's/ PRIVATE$//' | sort > expected-abi
nm -D -g --defined-only .libs/libgdk_pixbuf-2.0.so | cut -d ' ' -f 3 | egrep -v '^(__bss_start|_edata|_end)' | sort > actual-abi
diff -u expected-abi actual-abi && rm -f expected-abi actual-abi

734
gdk-pixbuf/gdk-pixbuf-animation.c
View File

@ -1,734 +0,0 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- */
/* GdkPixbuf library - Simple animation support
*
* Copyright (C) 1999 The Free Software Foundation
*
* Authors: Jonathan Blandford <jrb@redhat.com>
* Havoc Pennington <hp@redhat.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <errno.h>
#include "gdk-pixbuf-private.h"
#include "gdk-pixbuf-io.h"
#include "gdk-pixbuf-i18n.h"
#include "gdk-pixbuf-animation.h"
#include "gdk-pixbuf-alias.h"
#include <glib/gstdio.h>
typedef struct _GdkPixbufNonAnim GdkPixbufNonAnim;
typedef struct _GdkPixbufNonAnimClass GdkPixbufNonAnimClass;
#define GDK_TYPE_PIXBUF_NON_ANIM (gdk_pixbuf_non_anim_get_type ())
#define GDK_PIXBUF_NON_ANIM(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_PIXBUF_NON_ANIM, GdkPixbufNonAnim))
#define GDK_IS_PIXBUF_NON_ANIM(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_PIXBUF_NON_ANIM))
#define GDK_PIXBUF_NON_ANIM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_PIXBUF_NON_ANIM, GdkPixbufNonAnimClass))
#define GDK_IS_PIXBUF_NON_ANIM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_PIXBUF_NON_ANIM))
#define GDK_PIXBUF_NON_ANIM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_PIXBUF_NON_ANIM, GdkPixbufNonAnimClass))
/* Private part of the GdkPixbufNonAnim structure */
struct _GdkPixbufNonAnim {
GdkPixbufAnimation parent_instance;
GdkPixbuf *pixbuf;
};
struct _GdkPixbufNonAnimClass {
GdkPixbufAnimationClass parent_class;
};
typedef struct _GdkPixbufNonAnimIter GdkPixbufNonAnimIter;
typedef struct _GdkPixbufNonAnimIterClass GdkPixbufNonAnimIterClass;
#define GDK_TYPE_PIXBUF_NON_ANIM_ITER (gdk_pixbuf_non_anim_iter_get_type ())
#define GDK_PIXBUF_NON_ANIM_ITER(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_PIXBUF_NON_ANIM_ITER, GdkPixbufNonAnimIter))
#define GDK_IS_PIXBUF_NON_ANIM_ITER(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_PIXBUF_NON_ANIM_ITER))
#define GDK_PIXBUF_NON_ANIM_ITER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_PIXBUF_NON_ANIM_ITER, GdkPixbufNonAnimIterClass))
#define GDK_IS_PIXBUF_NON_ANIM_ITER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_PIXBUF_NON_ANIM_ITER))
#define GDK_PIXBUF_NON_ANIM_ITER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_PIXBUF_NON_ANIM_ITER, GdkPixbufNonAnimIterClass))
struct _GdkPixbufNonAnimIter {
GdkPixbufAnimationIter parent_instance;
GdkPixbufNonAnim *non_anim;
};
struct _GdkPixbufNonAnimIterClass {
GdkPixbufAnimationIterClass parent_class;
};
static GType gdk_pixbuf_non_anim_iter_get_type (void) G_GNUC_CONST;
G_DEFINE_TYPE (GdkPixbufAnimation, gdk_pixbuf_animation, G_TYPE_OBJECT);
static void
gdk_pixbuf_animation_class_init (GdkPixbufAnimationClass *klass)
{
}
static void
gdk_pixbuf_animation_init (GdkPixbufAnimation *animation)
{
}
/**
* gdk_pixbuf_animation_new_from_file:
* @filename: Name of file to load, in the GLib file name encoding
* @error: return location for error
*
* Creates a new animation by loading it from a file. The file format is
* detected automatically. If the file's format does not support multi-frame
* images, then an animation with a single frame will be created. Possible errors
* are in the #GDK_PIXBUF_ERROR and #G_FILE_ERROR domains.
*
* Return value: A newly-created animation with a reference count of 1, or %NULL
* if any of several error conditions ocurred: the file could not be opened,
* there was no loader for the file's format, there was not enough memory to
* allocate the image buffer, or the image file contained invalid data.
**/
GdkPixbufAnimation *
gdk_pixbuf_animation_new_from_file (const char *filename,
GError **error)
{
GdkPixbufAnimation *animation;
int size;
FILE *f;
guchar buffer [1024];
GdkPixbufModule *image_module;
gchar *display_name;
gboolean locked = FALSE;
g_return_val_if_fail (filename != NULL, NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
display_name = g_filename_display_name (filename);
f = g_fopen (filename, "rb");
if (!f) {
gint save_errno = errno;
g_set_error (error,
G_FILE_ERROR,
g_file_error_from_errno (save_errno),
_("Failed to open file '%s': %s"),
display_name,
g_strerror (save_errno));
g_free (display_name);
return NULL;
}
size = fread (&buffer, 1, sizeof (buffer), f);
if (size == 0) {
g_set_error (error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
_("Image file '%s' contains no data"),
display_name);
g_free (display_name);
fclose (f);
return NULL;
}
image_module = _gdk_pixbuf_get_module (buffer, size, filename, error);
if (!image_module) {
g_free (display_name);
fclose (f);
return NULL;
}
if (image_module->module == NULL)
if (!_gdk_pixbuf_load_module (image_module, error)) {
g_free (display_name);
fclose (f);
return NULL;
}
if (image_module->load_animation == NULL) {
GdkPixbuf *pixbuf;
/* Keep this logic in sync with gdk_pixbuf_new_from_file() */
fseek (f, 0, SEEK_SET);
pixbuf = _gdk_pixbuf_generic_image_load (image_module, f, error);
fclose (f);
if (pixbuf == NULL && error != NULL && *error == NULL) {
/* I don't trust these crufty longjmp()'ing image libs
* to maintain proper error invariants, and I don't
* want user code to segfault as a result. We need to maintain
* the invariant that error gets set if NULL is returned.
*/
g_warning ("Bug! gdk-pixbuf loader '%s' didn't set an error on failure.",
image_module->module_name);
g_set_error (error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_FAILED,
_("Failed to load image '%s': reason not known, probably a corrupt image file"),
display_name);
}
if (pixbuf == NULL) {
g_free (display_name);
animation = NULL;
goto out_unlock;
}
animation = gdk_pixbuf_non_anim_new (pixbuf);
g_object_unref (pixbuf);
} else {
locked = _gdk_pixbuf_lock (image_module);
fseek (f, 0, SEEK_SET);
animation = (* image_module->load_animation) (f, error);
if (animation == NULL && error != NULL && *error == NULL) {
/* I don't trust these crufty longjmp()'ing
* image libs to maintain proper error
* invariants, and I don't want user code to
* segfault as a result. We need to maintain
* the invariant that error gets set if NULL
* is returned.
*/
g_warning ("Bug! gdk-pixbuf loader '%s' didn't set an error on failure.",
image_module->module_name);
g_set_error (error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_FAILED,
_("Failed to load animation '%s': reason not known, probably a corrupt animation file"),
display_name);
}
fclose (f);
}
g_free (display_name);
out_unlock:
if (locked)
_gdk_pixbuf_unlock (image_module);
return animation;
}
#ifdef G_OS_WIN32
#undef gdk_pixbuf_animation_new_from_file
GdkPixbufAnimation *
gdk_pixbuf_animation_new_from_file (const char *filename,
GError **error)
{
gchar *utf8_filename =
g_locale_to_utf8 (filename, -1, NULL, NULL, error);
GdkPixbufAnimation *retval;
if (utf8_filename == NULL)
return NULL;
retval = gdk_pixbuf_animation_new_from_file_utf8 (utf8_filename, error);
g_free (utf8_filename);
return retval;
}
#endif
/**
* gdk_pixbuf_animation_ref:
* @animation: An animation.
*
* Adds a reference to an animation.
*
* Return value: The same as the @animation argument.
*
* Deprecated: 2.0: Use g_object_ref().
**/
GdkPixbufAnimation *
gdk_pixbuf_animation_ref (GdkPixbufAnimation *animation)
{
return (GdkPixbufAnimation*) g_object_ref (animation);
}
/**
* gdk_pixbuf_animation_unref:
* @animation: An animation.
*
* Removes a reference from an animation.
*
* Deprecated: 2.0: Use g_object_unref().
**/
void
gdk_pixbuf_animation_unref (GdkPixbufAnimation *animation)
{
g_object_unref (animation);
}
/**
* gdk_pixbuf_animation_is_static_image:
* @animation: a #GdkPixbufAnimation
*
* If you load a file with gdk_pixbuf_animation_new_from_file() and it turns
* out to be a plain, unanimated image, then this function will return
* %TRUE. Use gdk_pixbuf_animation_get_static_image() to retrieve
* the image.
*
* Return value: %TRUE if the "animation" was really just an image
**/
gboolean
gdk_pixbuf_animation_is_static_image (GdkPixbufAnimation *animation)
{
g_return_val_if_fail (GDK_IS_PIXBUF_ANIMATION (animation), FALSE);
return GDK_PIXBUF_ANIMATION_GET_CLASS (animation)->is_static_image (animation);
}
/**
* gdk_pixbuf_animation_get_static_image:
* @animation: a #GdkPixbufAnimation
*
* If an animation is really just a plain image (has only one frame),
* this function returns that image. If the animation is an animation,
* this function returns a reasonable thing to display as a static
* unanimated image, which might be the first frame, or something more
* sophisticated. If an animation hasn't loaded any frames yet, this
* function will return %NULL.
*
* Return value: unanimated image representing the animation
**/
GdkPixbuf*
gdk_pixbuf_animation_get_static_image (GdkPixbufAnimation *animation)
{
g_return_val_if_fail (GDK_IS_PIXBUF_ANIMATION (animation), NULL);
return GDK_PIXBUF_ANIMATION_GET_CLASS (animation)->get_static_image (animation);
}
/**
* gdk_pixbuf_animation_get_width:
* @animation: An animation.
*
* Queries the width of the bounding box of a pixbuf animation.
*
* Return value: Width of the bounding box of the animation.
**/
int
gdk_pixbuf_animation_get_width (GdkPixbufAnimation *animation)
{
int width;
g_return_val_if_fail (GDK_IS_PIXBUF_ANIMATION (animation), 0);
width = 0;
GDK_PIXBUF_ANIMATION_GET_CLASS (animation)->get_size (animation,
&width, NULL);
return width;
}
/**
* gdk_pixbuf_animation_get_height:
* @animation: An animation.
*
* Queries the height of the bounding box of a pixbuf animation.
*
* Return value: Height of the bounding box of the animation.
**/
int
gdk_pixbuf_animation_get_height (GdkPixbufAnimation *animation)
{
int height;
g_return_val_if_fail (GDK_IS_PIXBUF_ANIMATION (animation), 0);
height = 0;
GDK_PIXBUF_ANIMATION_GET_CLASS (animation)->get_size (animation,
NULL, &height);
return height;
}
/**
* gdk_pixbuf_animation_get_iter:
* @animation: a #GdkPixbufAnimation
* @start_time: time when the animation starts playing
*
* Get an iterator for displaying an animation. The iterator provides
* the frames that should be displayed at a given time.
* It should be freed after use with g_object_unref().
*
* @start_time would normally come from g_get_current_time(), and
* marks the beginning of animation playback. After creating an
* iterator, you should immediately display the pixbuf returned by
* gdk_pixbuf_animation_iter_get_pixbuf(). Then, you should install a
* timeout (with g_timeout_add()) or by some other mechanism ensure
* that you'll update the image after
* gdk_pixbuf_animation_iter_get_delay_time() milliseconds. Each time
* the image is updated, you should reinstall the timeout with the new,
* possibly-changed delay time.
*
* As a shortcut, if @start_time is %NULL, the result of
* g_get_current_time() will be used automatically.
*
* To update the image (i.e. possibly change the result of
* gdk_pixbuf_animation_iter_get_pixbuf() to a new frame of the animation),
* call gdk_pixbuf_animation_iter_advance().
*
* If you're using #GdkPixbufLoader, in addition to updating the image
* after the delay time, you should also update it whenever you
* receive the area_updated signal and
* gdk_pixbuf_animation_iter_on_currently_loading_frame() returns
* %TRUE. In this case, the frame currently being fed into the loader
* has received new data, so needs to be refreshed. The delay time for
* a frame may also be modified after an area_updated signal, for
* example if the delay time for a frame is encoded in the data after
* the frame itself. So your timeout should be reinstalled after any
* area_updated signal.
*
* A delay time of -1 is possible, indicating "infinite."
*
* Return value: an iterator to move over the animation
**/
GdkPixbufAnimationIter*
gdk_pixbuf_animation_get_iter (GdkPixbufAnimation *animation,
const GTimeVal *start_time)
{
GTimeVal val;
g_return_val_if_fail (GDK_IS_PIXBUF_ANIMATION (animation), NULL);
if (start_time)
val = *start_time;
else
g_get_current_time (&val);
return GDK_PIXBUF_ANIMATION_GET_CLASS (animation)->get_iter (animation, &val);
}
G_DEFINE_TYPE (GdkPixbufAnimationIter, gdk_pixbuf_animation_iter, G_TYPE_OBJECT);
static void
gdk_pixbuf_animation_iter_class_init (GdkPixbufAnimationIterClass *klass)
{
}
static void
gdk_pixbuf_animation_iter_init (GdkPixbufAnimationIter *iter)
{
}
/**
* gdk_pixbuf_animation_iter_get_delay_time:
* @iter: an animation iterator
*
* Gets the number of milliseconds the current pixbuf should be displayed,
* or -1 if the current pixbuf should be displayed forever. g_timeout_add()
* conveniently takes a timeout in milliseconds, so you can use a timeout
* to schedule the next update.
*
* Return value: delay time in milliseconds (thousandths of a second)
**/
int
gdk_pixbuf_animation_iter_get_delay_time (GdkPixbufAnimationIter *iter)
{
g_return_val_if_fail (GDK_IS_PIXBUF_ANIMATION_ITER (iter), -1);
g_return_val_if_fail (GDK_PIXBUF_ANIMATION_ITER_GET_CLASS (iter)->get_delay_time, -1);
return GDK_PIXBUF_ANIMATION_ITER_GET_CLASS (iter)->get_delay_time (iter);
}
/**
* gdk_pixbuf_animation_iter_get_pixbuf:
* @iter: an animation iterator
*
* Gets the current pixbuf which should be displayed; the pixbuf will
* be the same size as the animation itself
* (gdk_pixbuf_animation_get_width(), gdk_pixbuf_animation_get_height()).
* This pixbuf should be displayed for
* gdk_pixbuf_animation_iter_get_delay_time() milliseconds. The caller
* of this function does not own a reference to the returned pixbuf;
* the returned pixbuf will become invalid when the iterator advances
* to the next frame, which may happen anytime you call
* gdk_pixbuf_animation_iter_advance(). Copy the pixbuf to keep it
* (don't just add a reference), as it may get recycled as you advance
* the iterator.
*
* Return value: the pixbuf to be displayed
**/
GdkPixbuf*
gdk_pixbuf_animation_iter_get_pixbuf (GdkPixbufAnimationIter *iter)
{
g_return_val_if_fail (GDK_IS_PIXBUF_ANIMATION_ITER (iter), NULL);
g_return_val_if_fail (GDK_PIXBUF_ANIMATION_ITER_GET_CLASS (iter)->get_pixbuf, NULL);
return GDK_PIXBUF_ANIMATION_ITER_GET_CLASS (iter)->get_pixbuf (iter);
}
/**
* gdk_pixbuf_animation_iter_on_currently_loading_frame:
* @iter: a #GdkPixbufAnimationIter
*
* Used to determine how to respond to the area_updated signal on
* #GdkPixbufLoader when loading an animation. area_updated is emitted
* for an area of the frame currently streaming in to the loader. So if
* you're on the currently loading frame, you need to redraw the screen for
* the updated area.
*
* Return value: %TRUE if the frame we're on is partially loaded, or the last frame
**/
gboolean
gdk_pixbuf_animation_iter_on_currently_loading_frame (GdkPixbufAnimationIter *iter)
{
g_return_val_if_fail (GDK_IS_PIXBUF_ANIMATION_ITER (iter), FALSE);
g_return_val_if_fail (GDK_PIXBUF_ANIMATION_ITER_GET_CLASS (iter)->on_currently_loading_frame, FALSE);
return GDK_PIXBUF_ANIMATION_ITER_GET_CLASS (iter)->on_currently_loading_frame (iter);
}
/**
* gdk_pixbuf_animation_iter_advance:
* @iter: a #GdkPixbufAnimationIter
* @current_time: current time
*
* Possibly advances an animation to a new frame. Chooses the frame based
* on the start time passed to gdk_pixbuf_animation_get_iter().
*
* @current_time would normally come from g_get_current_time(), and
* must be greater than or equal to the time passed to
* gdk_pixbuf_animation_get_iter(), and must increase or remain
* unchanged each time gdk_pixbuf_animation_iter_get_pixbuf() is
* called. That is, you can't go backward in time; animations only
* play forward.
*
* As a shortcut, pass %NULL for the current time and g_get_current_time()
* will be invoked on your behalf. So you only need to explicitly pass
* @current_time if you're doing something odd like playing the animation
* at double speed.
*
* If this function returns %FALSE, there's no need to update the animation
* display, assuming the display had been rendered prior to advancing;
* if %TRUE, you need to call gdk_animation_iter_get_pixbuf() and update the
* display with the new pixbuf.
*
* Returns: %TRUE if the image may need updating
*
**/
gboolean
gdk_pixbuf_animation_iter_advance (GdkPixbufAnimationIter *iter,
const GTimeVal *current_time)
{
GTimeVal val;
g_return_val_if_fail (GDK_IS_PIXBUF_ANIMATION_ITER (iter), FALSE);
g_return_val_if_fail (GDK_PIXBUF_ANIMATION_ITER_GET_CLASS (iter)->advance, FALSE);
if (current_time)
val = *current_time;
else
g_get_current_time (&val);
return GDK_PIXBUF_ANIMATION_ITER_GET_CLASS (iter)->advance (iter, &val);
}
static void gdk_pixbuf_non_anim_finalize (GObject *object);
static gboolean gdk_pixbuf_non_anim_is_static_image (GdkPixbufAnimation *animation);
static GdkPixbuf* gdk_pixbuf_non_anim_get_static_image (GdkPixbufAnimation *animation);
static void gdk_pixbuf_non_anim_get_size (GdkPixbufAnimation *anim,
int *width,
int *height);
static GdkPixbufAnimationIter* gdk_pixbuf_non_anim_get_iter (GdkPixbufAnimation *anim,
const GTimeVal *start_time);
G_DEFINE_TYPE (GdkPixbufNonAnim, gdk_pixbuf_non_anim, GDK_TYPE_PIXBUF_ANIMATION);
static void
gdk_pixbuf_non_anim_class_init (GdkPixbufNonAnimClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GdkPixbufAnimationClass *anim_class = GDK_PIXBUF_ANIMATION_CLASS (klass);
object_class->finalize = gdk_pixbuf_non_anim_finalize;
anim_class->is_static_image = gdk_pixbuf_non_anim_is_static_image;
anim_class->get_static_image = gdk_pixbuf_non_anim_get_static_image;
anim_class->get_size = gdk_pixbuf_non_anim_get_size;
anim_class->get_iter = gdk_pixbuf_non_anim_get_iter;
}
static void
gdk_pixbuf_non_anim_init (GdkPixbufNonAnim *non_anim)
{
}
static void
gdk_pixbuf_non_anim_finalize (GObject *object)
{
GdkPixbufNonAnim *non_anim = GDK_PIXBUF_NON_ANIM (object);
if (non_anim->pixbuf)
g_object_unref (non_anim->pixbuf);
G_OBJECT_CLASS (gdk_pixbuf_non_anim_parent_class)->finalize (object);
}
GdkPixbufAnimation*
gdk_pixbuf_non_anim_new (GdkPixbuf *pixbuf)
{
GdkPixbufNonAnim *non_anim;
non_anim = g_object_new (GDK_TYPE_PIXBUF_NON_ANIM, NULL);
non_anim->pixbuf = pixbuf;
if (pixbuf)
g_object_ref (pixbuf);
return GDK_PIXBUF_ANIMATION (non_anim);
}
static gboolean
gdk_pixbuf_non_anim_is_static_image (GdkPixbufAnimation *animation)
{
return TRUE;
}
static GdkPixbuf*
gdk_pixbuf_non_anim_get_static_image (GdkPixbufAnimation *animation)
{
GdkPixbufNonAnim *non_anim;
non_anim = GDK_PIXBUF_NON_ANIM (animation);
return non_anim->pixbuf;
}
static void
gdk_pixbuf_non_anim_get_size (GdkPixbufAnimation *anim,
int *width,
int *height)
{
GdkPixbufNonAnim *non_anim;
non_anim = GDK_PIXBUF_NON_ANIM (anim);
if (width)
*width = gdk_pixbuf_get_width (non_anim->pixbuf);
if (height)
*height = gdk_pixbuf_get_height (non_anim->pixbuf);
}
static GdkPixbufAnimationIter*
gdk_pixbuf_non_anim_get_iter (GdkPixbufAnimation *anim,
const GTimeVal *start_time)
{
GdkPixbufNonAnimIter *iter;
iter = g_object_new (GDK_TYPE_PIXBUF_NON_ANIM_ITER, NULL);
iter->non_anim = GDK_PIXBUF_NON_ANIM (anim);
g_object_ref (iter->non_anim);
return GDK_PIXBUF_ANIMATION_ITER (iter);
}
static void gdk_pixbuf_non_anim_iter_finalize (GObject *object);
static int gdk_pixbuf_non_anim_iter_get_delay_time (GdkPixbufAnimationIter *iter);
static GdkPixbuf* gdk_pixbuf_non_anim_iter_get_pixbuf (GdkPixbufAnimationIter *iter);
static gboolean gdk_pixbuf_non_anim_iter_on_currently_loading_frame (GdkPixbufAnimationIter *iter);
static gboolean gdk_pixbuf_non_anim_iter_advance (GdkPixbufAnimationIter *iter,
const GTimeVal *current_time);
G_DEFINE_TYPE (GdkPixbufNonAnimIter,
gdk_pixbuf_non_anim_iter,
GDK_TYPE_PIXBUF_ANIMATION_ITER);
static void
gdk_pixbuf_non_anim_iter_class_init (GdkPixbufNonAnimIterClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GdkPixbufAnimationIterClass *anim_iter_class =
GDK_PIXBUF_ANIMATION_ITER_CLASS (klass);
object_class->finalize = gdk_pixbuf_non_anim_iter_finalize;
anim_iter_class->get_delay_time = gdk_pixbuf_non_anim_iter_get_delay_time;
anim_iter_class->get_pixbuf = gdk_pixbuf_non_anim_iter_get_pixbuf;
anim_iter_class->on_currently_loading_frame = gdk_pixbuf_non_anim_iter_on_currently_loading_frame;
anim_iter_class->advance = gdk_pixbuf_non_anim_iter_advance;
}
static void
gdk_pixbuf_non_anim_iter_init (GdkPixbufNonAnimIter *non_iter)
{
}
static void
gdk_pixbuf_non_anim_iter_finalize (GObject *object)
{
GdkPixbufNonAnimIter *iter = GDK_PIXBUF_NON_ANIM_ITER (object);
g_object_unref (iter->non_anim);
G_OBJECT_CLASS (gdk_pixbuf_non_anim_iter_parent_class)->finalize (object);
}
static int
gdk_pixbuf_non_anim_iter_get_delay_time (GdkPixbufAnimationIter *iter)
{
return -1; /* show only frame forever */
}
static GdkPixbuf*
gdk_pixbuf_non_anim_iter_get_pixbuf (GdkPixbufAnimationIter *iter)
{
return GDK_PIXBUF_NON_ANIM_ITER (iter)->non_anim->pixbuf;
}
static gboolean
gdk_pixbuf_non_anim_iter_on_currently_loading_frame (GdkPixbufAnimationIter *iter)
{
return TRUE;
}
static gboolean
gdk_pixbuf_non_anim_iter_advance (GdkPixbufAnimationIter *iter,
const GTimeVal *current_time)
{
/* Advancing never requires a refresh */
return FALSE;
}
#define __GDK_PIXBUF_ANIMATION_C__
#include "gdk-pixbuf-aliasdef.c"

151
gdk-pixbuf/gdk-pixbuf-animation.h
View File

@ -1,151 +0,0 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- */
/* GdkPixbuf library - Animation support
*
* Copyright (C) 1999 The Free Software Foundation
*
* Authors: Mark Crichton <crichton@gimp.org>
* Miguel de Icaza <miguel@gnu.org>
* Federico Mena-Quintero <federico@gimp.org>
* Havoc Pennington <hp@redhat.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#if defined(GDK_PIXBUF_DISABLE_SINGLE_INCLUDES) && !defined (GDK_PIXBUF_H_INSIDE) && !defined (GDK_PIXBUF_COMPILATION)
#error "Only <gdk-pixbuf/gdk-pixbuf.h> can be included directly."
#endif
#ifndef GDK_PIXBUF_ANIMATION_H
#define GDK_PIXBUF_ANIMATION_H
#include <glib-object.h>
#include <gdk-pixbuf/gdk-pixbuf-core.h>
G_BEGIN_DECLS
/* Animation support */
typedef struct _GdkPixbufAnimation GdkPixbufAnimation;
typedef struct _GdkPixbufAnimationIter GdkPixbufAnimationIter;
#define GDK_TYPE_PIXBUF_ANIMATION (gdk_pixbuf_animation_get_type ())
#define GDK_PIXBUF_ANIMATION(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_PIXBUF_ANIMATION, GdkPixbufAnimation))
#define GDK_IS_PIXBUF_ANIMATION(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_PIXBUF_ANIMATION))
#define GDK_TYPE_PIXBUF_ANIMATION_ITER (gdk_pixbuf_animation_iter_get_type ())
#define GDK_PIXBUF_ANIMATION_ITER(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_PIXBUF_ANIMATION_ITER, GdkPixbufAnimationIter))
#define GDK_IS_PIXBUF_ANIMATION_ITER(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_PIXBUF_ANIMATION_ITER))
GType gdk_pixbuf_animation_get_type (void) G_GNUC_CONST;
#ifdef G_OS_WIN32
#define gdk_pixbuf_animation_new_from_file gdk_pixbuf_animation_new_from_file_utf8
#endif
GdkPixbufAnimation *gdk_pixbuf_animation_new_from_file (const char *filename,
GError **error);
#ifndef GDK_PIXBUF_DISABLE_DEPRECATED
GdkPixbufAnimation *gdk_pixbuf_animation_ref (GdkPixbufAnimation *animation);
void gdk_pixbuf_animation_unref (GdkPixbufAnimation *animation);
#endif
int gdk_pixbuf_animation_get_width (GdkPixbufAnimation *animation);
int gdk_pixbuf_animation_get_height (GdkPixbufAnimation *animation);
gboolean gdk_pixbuf_animation_is_static_image (GdkPixbufAnimation *animation);
GdkPixbuf *gdk_pixbuf_animation_get_static_image (GdkPixbufAnimation *animation);
GdkPixbufAnimationIter *gdk_pixbuf_animation_get_iter (GdkPixbufAnimation *animation,
const GTimeVal *start_time);
GType gdk_pixbuf_animation_iter_get_type (void) G_GNUC_CONST;
int gdk_pixbuf_animation_iter_get_delay_time (GdkPixbufAnimationIter *iter);
GdkPixbuf *gdk_pixbuf_animation_iter_get_pixbuf (GdkPixbufAnimationIter *iter);
gboolean gdk_pixbuf_animation_iter_on_currently_loading_frame (GdkPixbufAnimationIter *iter);
gboolean gdk_pixbuf_animation_iter_advance (GdkPixbufAnimationIter *iter,
const GTimeVal *current_time);
#ifdef GDK_PIXBUF_ENABLE_BACKEND
typedef struct _GdkPixbufAnimationClass GdkPixbufAnimationClass;
#define GDK_PIXBUF_ANIMATION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_PIXBUF_ANIMATION, GdkPixbufAnimationClass))
#define GDK_IS_PIXBUF_ANIMATION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_PIXBUF_ANIMATION))
#define GDK_PIXBUF_ANIMATION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_PIXBUF_ANIMATION, GdkPixbufAnimationClass))
/* Private part of the GdkPixbufAnimation structure */
struct _GdkPixbufAnimation {
GObject parent_instance;
};
struct _GdkPixbufAnimationClass {
GObjectClass parent_class;
/*< public >*/
gboolean (*is_static_image) (GdkPixbufAnimation *anim);
GdkPixbuf* (*get_static_image) (GdkPixbufAnimation *anim);
void (*get_size) (GdkPixbufAnimation *anim,
int *width,
int *height);
GdkPixbufAnimationIter* (*get_iter) (GdkPixbufAnimation *anim,
const GTimeVal *start_time);
};
typedef struct _GdkPixbufAnimationIterClass GdkPixbufAnimationIterClass;
#define GDK_PIXBUF_ANIMATION_ITER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_PIXBUF_ANIMATION_ITER, GdkPixbufAnimationIterClass))
#define GDK_IS_PIXBUF_ANIMATION_ITER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_PIXBUF_ANIMATION_ITER))
#define GDK_PIXBUF_ANIMATION_ITER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_PIXBUF_ANIMATION_ITER, GdkPixbufAnimationIterClass))
struct _GdkPixbufAnimationIter {
GObject parent_instance;
};
struct _GdkPixbufAnimationIterClass {
GObjectClass parent_class;
/*< public >*/
int (*get_delay_time) (GdkPixbufAnimationIter *iter);
GdkPixbuf* (*get_pixbuf) (GdkPixbufAnimationIter *iter);
gboolean (*on_currently_loading_frame) (GdkPixbufAnimationIter *iter);
gboolean (*advance) (GdkPixbufAnimationIter *iter,
const GTimeVal *current_time);
};
GType gdk_pixbuf_non_anim_get_type (void) G_GNUC_CONST;
GdkPixbufAnimation* gdk_pixbuf_non_anim_new (GdkPixbuf *pixbuf);
#endif /* GDK_PIXBUF_ENABLE_BACKEND */
G_END_DECLS
#endif /* GDK_PIXBUF_ANIMATION_H */

267
gdk-pixbuf/gdk-pixbuf-core.h
View File

@ -1,267 +0,0 @@
/* GdkPixbuf library - GdkPixbuf data structure
*
* Copyright (C) 2003 The Free Software Foundation
*
* Authors: Mark Crichton <crichton@gimp.org>
* Miguel de Icaza <miguel@gnu.org>
* Federico Mena-Quintero <federico@gimp.org>
* Havoc Pennington <hp@redhat.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#if defined(GDK_PIXBUF_DISABLE_SINGLE_INCLUDES) && !defined (GDK_PIXBUF_H_INSIDE) && !defined (GDK_PIXBUF_COMPILATION)
#error "Only <gdk-pixbuf/gdk-pixbuf.h> can be included directly."
#endif
#ifndef GDK_PIXBUF_CORE_H
#define GDK_PIXBUF_CORE_H
#include <glib.h>
#include <glib-object.h>
#include <gio/gio.h>
G_BEGIN_DECLS
/* Alpha compositing mode */
typedef enum
{
GDK_PIXBUF_ALPHA_BILEVEL,
GDK_PIXBUF_ALPHA_FULL
} GdkPixbufAlphaMode;
/* Color spaces; right now only RGB is supported.
* Note that these values are encoded in inline pixbufs
* as ints, so don't reorder them
*/
typedef enum {
GDK_COLORSPACE_RGB
} GdkColorspace;
/* All of these are opaque structures */
typedef struct _GdkPixbuf GdkPixbuf;
#define GDK_TYPE_PIXBUF (gdk_pixbuf_get_type ())
#define GDK_PIXBUF(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_PIXBUF, GdkPixbuf))
#define GDK_IS_PIXBUF(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_PIXBUF))
/* Handler that must free the pixel array */
typedef void (* GdkPixbufDestroyNotify) (guchar *pixels, gpointer data);
#define GDK_PIXBUF_ERROR gdk_pixbuf_error_quark ()
typedef enum {
/* image data hosed */
GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
/* no mem to load image */
GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
/* bad option passed to save routine */
GDK_PIXBUF_ERROR_BAD_OPTION,
/* unsupported image type (sort of an ENOSYS) */
GDK_PIXBUF_ERROR_UNKNOWN_TYPE,
/* unsupported operation (load, save) for image type */
GDK_PIXBUF_ERROR_UNSUPPORTED_OPERATION,
GDK_PIXBUF_ERROR_FAILED
} GdkPixbufError;
GQuark gdk_pixbuf_error_quark (void);
GType gdk_pixbuf_get_type (void) G_GNUC_CONST;
/* Reference counting */
#ifndef GDK_PIXBUF_DISABLE_DEPRECATED
GdkPixbuf *gdk_pixbuf_ref (GdkPixbuf *pixbuf);
void gdk_pixbuf_unref (GdkPixbuf *pixbuf);
#endif
/* GdkPixbuf accessors */
GdkColorspace gdk_pixbuf_get_colorspace (const GdkPixbuf *pixbuf);
int gdk_pixbuf_get_n_channels (const GdkPixbuf *pixbuf);
gboolean gdk_pixbuf_get_has_alpha (const GdkPixbuf *pixbuf);
int gdk_pixbuf_get_bits_per_sample (const GdkPixbuf *pixbuf);
guchar *gdk_pixbuf_get_pixels (const GdkPixbuf *pixbuf);
int gdk_pixbuf_get_width (const GdkPixbuf *pixbuf);
int gdk_pixbuf_get_height (const GdkPixbuf *pixbuf);
int gdk_pixbuf_get_rowstride (const GdkPixbuf *pixbuf);
/* Create a blank pixbuf with an optimal rowstride and a new buffer */
GdkPixbuf *gdk_pixbuf_new (GdkColorspace colorspace, gboolean has_alpha, int bits_per_sample,
int width, int height);
/* Copy a pixbuf */
GdkPixbuf *gdk_pixbuf_copy (const GdkPixbuf *pixbuf);
/* Create a pixbuf which points to the pixels of another pixbuf */
GdkPixbuf *gdk_pixbuf_new_subpixbuf (GdkPixbuf *src_pixbuf,
int src_x,
int src_y,
int width,
int height);
/* Simple loading */
#ifdef G_OS_WIN32
/* DLL ABI stability hack. */
#define gdk_pixbuf_new_from_file gdk_pixbuf_new_from_file_utf8
#define gdk_pixbuf_new_from_file_at_size gdk_pixbuf_new_from_file_at_size_utf8
#define gdk_pixbuf_new_from_file_at_scale gdk_pixbuf_new_from_file_at_scale_utf8
#endif
GdkPixbuf *gdk_pixbuf_new_from_file (const char *filename,
GError **error);
GdkPixbuf *gdk_pixbuf_new_from_file_at_size (const char *filename,
int width,
int height,
GError **error);
GdkPixbuf *gdk_pixbuf_new_from_file_at_scale (const char *filename,
int width,
int height,
gboolean preserve_aspect_ratio,
GError **error);
GdkPixbuf *gdk_pixbuf_new_from_data (const guchar *data,
GdkColorspace colorspace,
gboolean has_alpha,
int bits_per_sample,
int width, int height,
int rowstride,
GdkPixbufDestroyNotify destroy_fn,
gpointer destroy_fn_data);
GdkPixbuf *gdk_pixbuf_new_from_xpm_data (const char **data);
GdkPixbuf* gdk_pixbuf_new_from_inline (gint data_length,
const guint8 *data,
gboolean copy_pixels,
GError **error);
/* Mutations */
void gdk_pixbuf_fill (GdkPixbuf *pixbuf,
guint32 pixel);
/* Saving */
#ifdef G_OS_WIN32
/* DLL ABI stability hack. */
#define gdk_pixbuf_save gdk_pixbuf_save_utf8
#define gdk_pixbuf_savev gdk_pixbuf_savev_utf8
#endif
gboolean gdk_pixbuf_save (GdkPixbuf *pixbuf,
const char *filename,
const char *type,
GError **error,
...) G_GNUC_NULL_TERMINATED;
gboolean gdk_pixbuf_savev (GdkPixbuf *pixbuf,
const char *filename,
const char *type,
char **option_keys,
char **option_values,
GError **error);
/* Saving to a callback function */
typedef gboolean (*GdkPixbufSaveFunc) (const gchar *buf,
gsize count,
GError **error,
gpointer data);
gboolean gdk_pixbuf_save_to_callback (GdkPixbuf *pixbuf,
GdkPixbufSaveFunc save_func,
gpointer user_data,
const char *type,
GError **error,
...) G_GNUC_NULL_TERMINATED;
gboolean gdk_pixbuf_save_to_callbackv (GdkPixbuf *pixbuf,
GdkPixbufSaveFunc save_func,
gpointer user_data,
const char *type,
char **option_keys,
char **option_values,
GError **error);
/* Saving into a newly allocated char array */
gboolean gdk_pixbuf_save_to_buffer (GdkPixbuf *pixbuf,
gchar **buffer,
gsize *buffer_size,
const char *type,
GError **error,
...) G_GNUC_NULL_TERMINATED;
gboolean gdk_pixbuf_save_to_bufferv (GdkPixbuf *pixbuf,
gchar **buffer,
gsize *buffer_size,
const char *type,
char **option_keys,
char **option_values,
GError **error);
GdkPixbuf *gdk_pixbuf_new_from_stream (GInputStream *stream,
GCancellable *cancellable,
GError **error);
GdkPixbuf *gdk_pixbuf_new_from_stream_at_scale (GInputStream *stream,
gint width,
gint height,
gboolean preserve_aspect_ratio,
GCancellable *cancellable,
GError **error);
gboolean gdk_pixbuf_save_to_stream (GdkPixbuf *pixbuf,
GOutputStream *stream,
const char *type,
GCancellable *cancellable,
GError **error,
...);
/* Adding an alpha channel */
GdkPixbuf *gdk_pixbuf_add_alpha (const GdkPixbuf *pixbuf, gboolean substitute_color,
guchar r, guchar g, guchar b);
/* Copy an area of a pixbuf onto another one */
void gdk_pixbuf_copy_area (const GdkPixbuf *src_pixbuf,
int src_x, int src_y,
int width, int height,
GdkPixbuf *dest_pixbuf,
int dest_x, int dest_y);
/* Brighten/darken and optionally make it pixelated-looking */
void gdk_pixbuf_saturate_and_pixelate (const GdkPixbuf *src,
GdkPixbuf *dest,
gfloat saturation,
gboolean pixelate);
/* Transform an image to agree with its embedded orientation option / tag */
GdkPixbuf *gdk_pixbuf_apply_embedded_orientation (GdkPixbuf *src);