From 04082f7315d7ada5c039725d8bed3fcc1a60e479 Mon Sep 17 00:00:00 2001 From: Didier Raboud Date: Mon, 17 Jul 2017 22:28:26 +0200 Subject: Import gutenprint_5.2.13-1.debian.tar.xz [dgit import tarball gutenprint 5.2.13-1 gutenprint_5.2.13-1.debian.tar.xz] --- .git-dpm | 8 + README.Debian | 19 + README.building | 46 + changelog | 1347 +++ compat | 1 + control | 233 + copyright | 34 + escputil.install | 2 + escputil.maintscript | 1 + gbp.conf | 4 + gimp-gutenprint.docs | 3 + gimp-gutenprint.install | 2 + gutenprint-doc.doc-base | 11 + gutenprint-doc.install | 2 + gutenprint-locales.install | 1 + libgutenprint-dev.docs | 2 + libgutenprint-dev.install | 3 + libgutenprint-doc.doc-base.developer | 15 + libgutenprint-doc.doc-base.reference | 14 + libgutenprint-doc.install | 2 + libgutenprint-doc.links | 1 + libgutenprint2.docs | 1 + libgutenprint2.install | 3 + libgutenprintui2-1.install | 1 + libgutenprintui2-dev.install | 3 + libgutenprintui2-dev.maintscript | 1 + missing-sources/jquery.js | 9266 ++++++++++++++++++++ ...the-insanely-long-test-rastertogutenprint.patch | 23 + patches/series | 1 + printer-driver-gutenprint.NEWS | 34 + printer-driver-gutenprint.dirs | 1 + printer-driver-gutenprint.docs | 3 + printer-driver-gutenprint.install | 7 + printer-driver-gutenprint.install.linux | 1 + printer-driver-gutenprint.lintian-overrides | 1 + printer-driver-gutenprint.postrm | 28 + printer-driver-gutenprint.ppd-updater | 2 + rules | 73 + source/format | 1 + source/patch-header | 3 + tests/control | 3 + tests/printer-driver-gutenprint | 9 + watch | 3 + 43 files changed, 11219 insertions(+) create mode 100644 .git-dpm create mode 100644 README.Debian create mode 100644 README.building create mode 100644 changelog create mode 100644 compat create mode 100644 control create mode 100644 copyright create mode 100644 escputil.install create mode 100644 escputil.maintscript create mode 100644 gbp.conf create mode 100644 gimp-gutenprint.docs create mode 100644 gimp-gutenprint.install create mode 100644 gutenprint-doc.doc-base create mode 100644 gutenprint-doc.install create mode 100644 gutenprint-locales.install create mode 100644 libgutenprint-dev.docs create mode 100644 libgutenprint-dev.install create mode 100644 libgutenprint-doc.doc-base.developer create mode 100644 libgutenprint-doc.doc-base.reference create mode 100644 libgutenprint-doc.install create mode 100644 libgutenprint-doc.links create mode 100644 libgutenprint2.docs create mode 100644 libgutenprint2.install create mode 100644 libgutenprintui2-1.install create mode 100644 libgutenprintui2-dev.install create mode 100644 libgutenprintui2-dev.maintscript create mode 100644 missing-sources/jquery.js create mode 100644 patches/0001-Don-t-run-the-insanely-long-test-rastertogutenprint.patch create mode 100644 patches/series create mode 100644 printer-driver-gutenprint.NEWS create mode 100644 printer-driver-gutenprint.dirs create mode 100644 printer-driver-gutenprint.docs create mode 100644 printer-driver-gutenprint.install create mode 100644 printer-driver-gutenprint.install.linux create mode 100644 printer-driver-gutenprint.lintian-overrides create mode 100644 printer-driver-gutenprint.postrm create mode 100644 printer-driver-gutenprint.ppd-updater create mode 100755 rules create mode 100644 source/format create mode 100644 source/patch-header create mode 100644 tests/control create mode 100755 tests/printer-driver-gutenprint create mode 100644 watch diff --git a/.git-dpm b/.git-dpm new file mode 100644 index 0000000..f635f87 --- /dev/null +++ b/.git-dpm @@ -0,0 +1,8 @@ +# see git-dpm(1) from git-dpm package +4addaa1fea6e183355d2e37ed62c833c9f361602 +4addaa1fea6e183355d2e37ed62c833c9f361602 +337ffefc0bdf252749c81ebb9255556d54c3e632 +337ffefc0bdf252749c81ebb9255556d54c3e632 +gutenprint_5.2.13.orig.tar.bz2 +b277ae58af0de0f0e9e1884d5dde8f1673528c4f +6995005 diff --git a/README.Debian b/README.Debian new file mode 100644 index 0000000..77d1206 --- /dev/null +++ b/README.Debian @@ -0,0 +1,19 @@ +Gutenprint for Debian +--------------------- + +This is Gutenprint version 5.2. Gutenprint is the print facility for +the GIMP, and in addition a suite of drivers that may be used with +common UNIX spooling systems using Ghostscript or CUPS. These drivers +provide printing quality for UNIX/Linux on a par with proprietary +vendor-supplied drivers in many cases, and can be used for many of the +most demanding printing tasks. + +A complete list of supported printers may be found in the NEWS file. +On Debian GNU/Linux, the NEWS file is called `changelog.gz'. + +Documentation can be found in the gutenprint-doc package, which covers +the use of libgutenprint-based programs, and the libgutenprint-doc +package, which covers developing programs using libgutenprint. + + + -- Roger Leigh , Fri, 09 May 2008 17:02:10 +0100 diff --git a/README.building b/README.building new file mode 100644 index 0000000..3781850 --- /dev/null +++ b/README.building @@ -0,0 +1,46 @@ +Building the gutenprint Debian packages -*- mode: text -*- +======================================= + +Upgrading to a new upstream release +----------------------------------- + +1. Make sure that you clone the git repository, and then check out the + master, debian and pristine-tar branches. Also check out the + patches branch if you need to drop or add and additional patches + against upstream. + +2. Import upstream sources: + + git-import-orig --upstream-version=$version --sign-tags --pristine-tar $tar + +3. Update debian changelog on the master branch: + + dch -v $version + + and commit. + +4. Drop or add any patches from the patches branch. This is used to + create the quilt patch series. You'll want to rebase this branch + against the new upstream release first: + + git rebase -i upstream/$version + + to remove any patches incorporated upstream. Then add any new + patches needed. Finally, run: + + debian/rules update-patch-series + + to regenerate the patches. Commit the changes to the master + branch. + +5. Push all branches and tags. + + +Building +-------- + +Run + + git-buildpackage --git-tag --git-sign-tags --git-pristine-tar + + -- Roger Leigh , Thu, 21 Jun 2012 23:36:42 +0100 diff --git a/changelog b/changelog new file mode 100644 index 0000000..6a9f382 --- /dev/null +++ b/changelog @@ -0,0 +1,1347 @@ +gutenprint (5.2.13-1) unstable; urgency=medium + + * New upstream version 5.2.13 + * Bump S-V to 4.0 without changes needed + * Delete obsolete update-patch-series target from debian/rules + * Drop all postinst code managing versions before the current oldstable + (jessie, 5.2.10-3) + * Migrate to debhelper compat 10 + + -- Didier Raboud Mon, 17 Jul 2017 22:28:26 +0200 + +gutenprint (5.2.13~pre1-1) experimental; urgency=low + + * New upstream version 5.2.13~pre1 + + -- Didier Raboud Mon, 19 Jun 2017 08:48:18 +0200 + +gutenprint (5.2.12-2) unstable; urgency=low + + * Migrate 5.2.12 to unstable + + -- Didier Raboud Sun, 18 Jun 2017 17:07:20 +0200 + +gutenprint (5.2.12-1) experimental; urgency=medium + + * New upstream version 5.2.12 + + -- Didier Raboud Sun, 22 Jan 2017 10:42:51 +0100 + +gutenprint (5.2.12~pre4-1) experimental; urgency=medium + + * New upstream version 5.2.12~pre4 + + -- Didier Raboud Tue, 01 Nov 2016 18:52:21 +0100 + +gutenprint (5.2.12~pre3-1) experimental; urgency=medium + + * New upstream version 5.2.12~pre3 + * Drop cherry-picks from upstream + * Fix libgutenprint-doc developer's doc-base + + -- Didier Raboud Wed, 05 Oct 2016 09:21:45 +0200 + +gutenprint (5.2.12~pre2-2) experimental; urgency=medium + + * Upstream removed ijsgutenprint driver, drop corresponding packaging + infrastructure + * Upstream removed the foomatic data generator, drop corresponding packaging + infrastructure + * Cherry-pick two upstream commits to fix dynamic modules' compilation: + - Fix inverted tests that broke module loads. + - We shouldn't enable modules when --with-modules=no or =static + + -- Didier Raboud Mon, 26 Sep 2016 15:25:30 +0200 + +gutenprint (5.2.12~pre2-1) experimental; urgency=medium + + * New upstream version 5.2.12~pre2 + + * Initialize git-dpm + * Bump Standards-Version to 3.9.8 without changes needed + + -- Didier Raboud Tue, 20 Sep 2016 12:14:36 +0200 + +gutenprint (5.2.11-1) unstable; urgency=medium + + * New 5.2.11 upstream release + * Update uversionmangle in debian/watch to take -pre* account numbers + * Bump Standards-Version to 3.9.7 without changes needed + + -- Didier Raboud Tue, 16 Feb 2016 15:18:51 +0100 + +gutenprint (5.2.11~pre2-1) experimental; urgency=medium + + * New 5.2.11~pre2 upstream release + * Bump Standards-Version to 3.9.6 without changes needed + * Drop cups-driver-gutenprint transitional package, that was transitional in + oldstable + * Fix 'find' call to use the new '-perm /xxx' syntax (Closes: #803025) + + -- Didier Raboud Tue, 27 Oct 2015 18:43:03 +0100 + +gutenprint (5.2.11~pre1-1) experimental; urgency=low + + * New 5.2.11~pre1 upstream release + * In autopkgtest, only test the first printer listed in Gutenprint's + Supported printers page (Closes: #785648) + * Add gbp.conf to cope with the new branch names + + -- Didier Raboud Sun, 09 Aug 2015 14:43:08 +0200 + +gutenprint (5.2.10-3) unstable; urgency=medium + + * Add autopkgtest suite that tests all drivers using cups-client's + test-drivers utility + * On upgrade, remove driver update timestamp in cups' trigger cache to + ensure all earlier printers are refreshed (Closes: #749600) + + -- Didier Raboud Mon, 23 Jun 2014 19:31:46 +0200 + +gutenprint (5.2.10-2) unstable; urgency=medium + + * Add Pre-Depends against dpkg-dev for dir_to_symlink support + (Closes: #749931) + + -- Didier Raboud Sun, 01 Jun 2014 15:29:31 +0200 + +gutenprint (5.2.10-1) unstable; urgency=medium + + * New 5.2.10 final upstream release + + * Fix drivers listing by re-introduction --libdir as well as the specific + dh_makeshlibs and dh_shlibdeps calls, unfortunately dropped in the + packaging cleanup + * Fix ppd-updater trigger installation + * Drop the upstream patch to fix the usb backend crash; was from upstream + * Rework the /doc/ directories symlinks + + -- Didier Raboud Wed, 28 May 2014 13:45:00 +0200 + +gutenprint (5.2.10~pre2-2) unstable; urgency=medium + + * Fix printer-driver-gutenprint installation of common files on Linux + (Closes: #748761) + * Adopt package from Roger, replace him as Uploader, with many thanks for his + past work! (Closes: #479397) + + -- Didier Raboud Thu, 22 May 2014 08:08:54 +0200 + +gutenprint (5.2.10~pre2-1) unstable; urgency=low + + * Team upload + + * New upstream release + o Added a unified CUPS backend to support selected dye sublimation + printers. + o Added support for many new Epson and Canon inkjets and for many dye + sublimation printers. Support for new Canon inkjets mostly experimental. + o Improved support for many already supported dye sublimation printers. + o Corrected page dimensions for borderless printing with Canon + printers. + o Added duplex support for the EPSON WorkForce 645. + o Expanded printable area at the bottom of the page for the Epson + Stylus Pro 3800 and 3880. + o Added IEEE1284 device IDs for many Epson and Canon inkjets + (LP: #1248303), monochrome laser printers of all manufacturers, and dye + sublimation printers of all manufacturers. + o Added Catalan, Turkish, and Vietnamese translations. + + [ Didier Raboud ] + * Simplify buildsystem to make use of recent debhelper features + * Let printer-driver-gutenprint only depend on perl-base through dh_perl -p + * Only build-depend on libusb-1.0-dev on !hurd-any as it's not available there + * Add patch to avoid running the insanely long test-rastertogutenprint + build-test that makes sbuild timeout + * Build-depend and use dh_autoreconf to make the latest patches useful + * Drop Section redundancy in printer-driver-gutenprint + * Correct the lintian warning and the dh_fixperms call around gutenprint52+usb + * Import a bunch of Ubuntu changes, thanks to Till Kamppeter. + + [ Till Kamppeter ] + * Replace the printer-driver-gutenprint postinst with a ppd-updater trigger. + Update the PPD files of all already existing print queues using this driver + when updating this package. In contrary to Gutenprint's own + cups-genppdupdate, the script of the cups package can also migrate PPD + files. In our case we migrate Foomatic/IJS PPD files to the equivalent PPDs + using the CUPS Raster driver of Gutenprint and we replace simplified PPD + files by the corresponding standard PPDs, as we discontinue the simplified + PPDs in Ubuntu to reduce the delta to Debian and to make printer + model/driver listings in printer setup tools less cluttered. + * Replaced dependency of printer-driver-gutenprint on ghostscript-cups by + "cups-filters (>= 1.0.36) | ghostscript-cups (<< 9.08)" as Ghostscript's + CUPS filters moved to cups-filters from cups-filters 1.0.36/Ghostscript + 9.08 on. + * Add two configure flags to avoid depending on the CUPS version detection + code to enable CUPS 1.2 enhancements and disable the CUPS PPD files. + * Build-depend on libusb-1.0-0-dev for the new CUPS backend for dye + sublimation printers on USB + * Install new USB printer blacklist file for the CUPS USB backend (for dye + sublimation printers using Gutenprint's own backend) + * Add upstream patch to fix the gutenprint52+usb CUPS backend crashing on + failure of USB access via libusb (LP: #1297326) + * Set gutenprint52+usb CUPS backend to 700 permissions so that CUPS runs it + as root (LP: #1297326) + * Build, install and fix the permissions of the usb backend only on + linux-any as kfreebsd's libusb doesn't have the matching API yet + + -- Didier Raboud Thu, 15 May 2014 21:12:31 +0200 + +gutenprint (5.2.9-2) unstable; urgency=low + + * Team upload + + [ Didier Raboud ] + * Move the repository from collab-maint to printing; update the VCS-* fields + accordingly + * Bump Standards-Version to 3.9.5 without changes needed + * Add the non-minified jquery 1.7.1 source to debian/missing-sources + * Let {lib,}gutenprint-doc depend on libjs-jquery and symlink the jquery.js + to the packaged version + * Add homepage URL + * Stop installing .po files in gutenprint-locales (Closes: #650758) + + [ Bart Martens ] + * Add debian/watch + + -- Didier Raboud Tue, 15 Apr 2014 14:16:04 +0200 + +gutenprint (5.2.9-1) unstable; urgency=low + + * New upstream stable release. + * Drop patches against 5.2.8-1 to correct library versioning and + linking, which have been incorporated upstream. + + -- Roger Leigh Mon, 09 Jul 2012 23:16:31 +0100 + +gutenprint (5.2.8-1) unstable; urgency=low + + * New upstream stable release. + * debian/README.building: Document git workflow. + * debian/control: + - Upgrade Standards-Version to 3.9.3 + - Require debhelper >= 9. + * debian/rules: + - Re-enable NLS with --enable-nls. + * printer-driver-gutenprint no longer installs profile.jpg. + * Re-enable NLS with --enable-nls. + + -- Roger Leigh Thu, 21 Jun 2012 23:31:35 +0100 + +gutenprint (5.2.7-5) unstable; urgency=low + + * Apply patch to fix cups-genppd on Linux (and all non-Apple) + platforms by not using Apple-specific paths for ICC profiles. + The patch removes all ICC profile information from the + generated PPDs (Closes: #625925). Thanks to Julien Cristau + for the patch. + + -- Roger Leigh Sat, 04 Feb 2012 10:57:44 +0000 + +gutenprint (5.2.7-4) unstable; urgency=low + + * printer-driver-gutenprint has versioned Conflicts and Replaces + on cups-driver-gutenprint (Closes: 651507). + * Remove printer-driver-gutenprint preinst, and remove parts of the + postinst and postrm; the migration and cleanup tasks were done for + oldstable upgrades, and are no longer required. + * printer-driver-gutenprint Description matches the printing team + template. + + -- Roger Leigh Thu, 29 Dec 2011 12:06:59 +0000 + +gutenprint (5.2.7-3) unstable; urgency=low + + * Add printer-driver-gutenprint package to replace + cups-driver-gutenprint. cups-driver-gutenprint is a + transitional package. + * debian/control: Use multiline dependencies. + + -- Roger Leigh Sat, 26 Nov 2011 17:51:58 +0000 + +gutenprint (5.2.7-2) unstable; urgency=low + + * Set libdir correctly. + + -- Roger Leigh Sat, 23 Jul 2011 20:01:21 +0100 + +gutenprint (5.2.7-1) unstable; urgency=low + + * New upstream stable release. + * Upgrade to Standards Version 3.9.2 (no changes). + * Drop inactive maintainers from Uploaders. + * Use dh from debhelper for building. + * Use multiarch paths. + + -- Roger Leigh Sat, 23 Jul 2011 13:03:48 +0100 + +gutenprint (5.2.6-1) unstable; urgency=low + + * New upstream stable release. + * Use source format 3.0 (quilt), drop dpatch support. + * Upgrade to Standards Version 3.9.1 (no changes). + * Drop unused --with-ijs configure argument. + * debian/rules install-stamp rule depends on build-stamp + rather than build (which is phony). + + -- Roger Leigh Sun, 15 Aug 2010 14:15:09 +0100 + +gutenprint (5.2.5-1) unstable; urgency=low + + * New upstream stable release. + * debian/control: + - Update to standards version 3.8.4. + - Build-Depend on libreadline-dev. + - Use ${misc:Depends}. + + -- Roger Leigh Thu, 18 Feb 2010 21:32:05 +0000 + +gutenprint (5.2.4-1) unstable; urgency=low + + [ Roger Leigh ] + * New upstream stable release. + * cups-driver-gutenprint: Depend on ghostscript-cups, required for + Postscript/PDF printing. + + -- Roger Leigh Sun, 02 Aug 2009 11:50:51 +0100 + +gutenprint (5.2.3-3) unstable; urgency=low + + * debian/control: cups-driver-gutenprint: Depend on cups-client since + lpadmin and lpstat are used during postinst (Closes: #532880). + + -- Roger Leigh Sat, 13 Jun 2009 10:43:09 +0100 + +gutenprint (5.2.3-2) unstable; urgency=low + + * debian/rules: Update build and build-stamp dependencies (it doesn't + matter if debian/control is changed when build is called). This + is already taken care of through the autoconfigure-stamp dependency. + + -- Roger Leigh Sat, 21 Feb 2009 12:49:23 +0000 + +gutenprint (5.2.3-1) experimental; urgency=low + + [ Roger Leigh ] + * New upstream stable release. + * debian/control: + - Use ${source:Version} in place of ${binary:Version} for all + dependencies except for shared library dependencies in library + -dev packages. This relaxes the dependencies so that a specific + debian revision of a package is not strictly required. Thanks to + Amaya Rodrigo Sastre. + - ijsgutenprint no longer depends on obsolete ghostscript packages + (Closes: #447533). + - Build-Depend on debhelper v7. + * debian/cups-driver-gutenprint.postinst: Don't use full path + when running cups-genppdupdate (fix Lintian warning). + * debian/rules: + - update-patch-series: Use xargs -r to cope with null input. + - Use dh_prep in place of dh_clean -k. + - Split install into install-arch and install-indep with common + install-common rule. + - For binary-arch, use -s in place of -a. + + -- Roger Leigh Sun, 04 Jan 2009 18:19:28 +0000 + +gutenprint (5.2.2-1) experimental; urgency=low + + [ Roger Leigh ] + * New upstream stable release. + + -- Roger Leigh Sun, 04 Jan 2009 13:05:13 +0000 + +gutenprint (5.2.1-2) experimental; urgency=low + + [ Roger Leigh ] + * debian/compat: Update to debhelper v7 compatibility. + * debian/control: + - Add W. van den Akker to Uploaders. + - ijsgutenprint: Recommend foomatic-db-gutenprint. + - Update description of GIMP Print plugin. + - Build-Depend upon quilt instead of dpatch. + * debian/rules: + - autoconfigure-stamp: Update configure options to create globalised + CUPS PPDs, and remove obsolete options. + - realclean: + + Remove redundant removal of -stamp files. + + Save and restore config.sub and config.guess. Thanks to + Till Kamppeter. + + Move copying of new config.sub and config.guess to + autoconfigure-stamp, or else saving and restoring has no effect. + - install: Replace use of pwd with $(CURDIR). + - Use quilt in place of dpatch, and add rule to generate quilt patch + series from patches branch in git. + - Create -stamp files in the debian/ directory, so no new files are + created outside the debian directory. + * debian/cups-driver-gutenprint.*: Replace use of cupsys with cups. + * debian/cups-driver-gutenprint.postinst: + - Automatically upgrade print queues using the obsolete canon and epson + backends. Attempt to determine the most appropriate alternative + backend from the device name. + - Document USB backend device ID upgrade problems. + * debian/cups-driver-gutenprint.NEWS: New file. + - Document automatic upgrade of print queue backends. + - Document USB backend device ID upgrade problems. + * debian/patches/10_cups_modeldir.dpatch: Remove. + * debian/patches/20_fix_gimpprint_menu_entry.dpatch: Remove. Not needed, + and no longer compiled with GIMP >= 2.4. + * debian/patches/21_gutenprintui_plist_localefix.dpatch: Remove. Since + PPD files are no longer generated, we don't need to patch the source + to use /usr/share/ppd. + + -- Roger Leigh Sat, 01 Nov 2008 18:47:26 +0000 + +gutenprint (5.2.1-1) experimental; urgency=low + + [ W. van den Akker ] + * Upgraded to Standards version 3.8.0. + * debian/*: Update version from 5.1 to 5.2. + + [ Roger Leigh ] + * New upstream stable release. + * debian/control.in: Add Vcs-Browser and Vcs-Git fields. + * debian/control.in: Remove, leaving debian/control. + * debian/control: Remove unnecessary version information in package + descriptions. + * debian/control: Rename cupsys-driver-gutenprint to + cups-driver-gutenprint (already done in 5.0 branch). + * debian/control: Remove dependencies prior to Lenny, including + unneeded versioning and old transitional dependencies. + * debian/rules: Remove library soname substitution in package names. + * debian/README.building: Remove old outdated instructions. + * debian/patches/20_fix_gimpprint_menu_entry.dpatch: Make executable. + + -- Roger Leigh Thu, 30 Oct 2008 00:27:41 +0000 + +gutenprint (5.1.98.2-2) experimental; urgency=low + + * debian/cupsys-driver-gutenprint.postinst: Remove version suffix from + cups-genppdupdate. + * debian/rules, debian/cupsys-driver-gutenprint.install: Remove + cups-genppd; this is no longer needed with CUPS 1.2.x + (Closes: #474994). + * debian/control: Remove debian revision in Build-Depends package + versions. + + -- Roger Leigh Sat, 10 May 2008 12:32:39 +0100 + +gutenprint (5.1.98.2-1) unstable; urgency=low + + * New upstream stable beta release (Closes: #439961, #480113). + * debian/rules: + - Remove debian/libgutenprint2.install from GENERATED_FILES, and + remove the rule to generate it. + - Rename versioned binaries to 5.1. + - Remove commands for programs and manpages removed in this release. + * debian/control.in: + - Bump version from 5.0 to 5.1. + - cupsys-driver-gutenprint dependency on older ghostscript versions has + been restored, to allow migration to testing. + * debian/cupsys-driver-gutenprint.install: + - Rename versioned binaries to 5.1. + - Remove cups-genppdconfig. + * debian/cupsys-driver-gutenprint.postinst, + debian/cupsys-driver-gutenprint.postrm, + debian/cupsys-driver-gutenprint.preinst: Rename versioned binaries to + 5.1. + * debian/gutenprint-doc.doc-base: Update version, section is now Graphics. + * debian/ijsgutenprint.install: Rename versioned binaries to 5.1. + * debian/libgutenprint2.install.in: Rename to + debian/libgutenprint2.install and hard-code version. + * debian/libgutenprint-doc.doc-base.developer, + debian/libgutenprint-doc.doc-base.reference: Section is now + Programming/C. + * debian/README.Debian: Bump version from 5.0 to 5.2. + * + + -- Roger Leigh Fri, 09 May 2008 17:04:37 +0100 + +gutenprint (5.0.2-2) unstable; urgency=low + + * debian/control: + - ijsgutenprint only needs to Depend upon ghostscript. The older + gs-* variants are no longer needed (Closes: #447533). + * debian/cupsys-driver-gutenprint.preinst: + - Remove /etc/cups/command.types if the version is <- 5.0.2-2 + (Closes: #455016). Thanks to Kumar Appaiah for finding this. + * debian/patches/21_gutenprintui_plist_localefix.dpatch: Set locale + to C before executing lpr to get non-localised output. Patches + src/gutenprintui/plist.c and src/gutenprintui2/plist.c to fix + querying of available printers in a non-C locale (Closes: #456281). + + -- Roger Leigh Sun, 06 Jan 2008 00:25:17 +0000 + +gutenprint (5.0.2-1) unstable; urgency=low + + * New upstream release. + * debian/control: + - Update to Standards-Version 3.7.3. + - libgutenprintui2-dev is in Section libdevel. + * debian/compat: Update to version 6. + * debian/changelog: + - Provide link to full GFDL licence text, rather than the + entire licence verbatim. + - Update copyright dates. + + -- Roger Leigh Fri, 04 Jan 2008 23:14:24 +0000 + +gutenprint (5.0.1-4) unstable; urgency=low + + * debian/control: Rename gimp-print to gimp-gutenprint. + * Rename debian/gimp-print.* to debian/gimp-gutenprint.*. + * debian/gimp-gutenprint.preinst, debian/gimp-gutenprint.postrm: Remove, + since diversions are no longer used. + * debian/gimp-gutenprint.install: Install gutenprint plug-in + (Closes: #439500). + + -- Roger Leigh Thu, 27 Sep 2007 20:03:33 +0100 + +gutenprint (5.0.1-3) unstable; urgency=low + + * debian/control: Remove libgutenprintui1-1 and libgutenprintui-dev, + * debian/rules: Disable libgutenprintui when running configure. Remove + libgutenprintui1-1 from search path for dh_shlibdeps. + as well as libgtk1.2-dev build dependency. + * debian/libgutenprintui1-1.install: Remove. + * debian/libgutenprintui1-dev.install: Remove. + + -- Roger Leigh Sun, 22 Jul 2007 18:46:29 +0100 + +gutenprint (5.0.1-2) unstable; urgency=low + + * debian/control.in: Use ${binary:Version} and ${source:Version} in + place of deprecated ${Source-Version} substvar (Closes: #431391). + Thanks to Vincent Fourmond. + * debian/rules: + - Don't ignore clean target errors. + - Remove duplicate distclean command in the clean target. + + -- Roger Leigh Tue, 03 Jul 2007 23:21:40 +0100 + +gutenprint (5.0.1-1) unstable; urgency=low + + * New upstream stable release. + * debian/control.in: + - Remove cupsys-driver-gimpprint (cupsys-driver-gutenprint now + Conflicts and Replaces this transitional package from Etch). + - Remove foomatic-db-gimp-print (foomatic-db-gutenprint now + Conflicts and Replaces this transitional package from Etch). + - Remove ijsgimpprint (ijsgutenprint now Conflicts and Replaces this + transitional package from Etch). + - Replace linuxprinting.org with OpenPrinting in package descriptions + (merge from Ubuntu). + * debian/cupsys-driver-gutenprint.install: Move /etc/cups/command.types + to /usr/share/cups/mime. + * debian/cupsys-driver-gutenprint.preinst: + - If upgrading from a version less than or equal to 5.0.0-2, remove + /usr/share/cups/model/gutenprint/5.0. + - If upgrading from a version less than or equal to 5.0.1-1, remove + /usr/share/ppd/gutenprint/5.0. + * debian/cupsys-driver-gutenprint.postinst: + - Don't call cups-genppdconfig.5.0 now that PPD files are generated on + the fly. + - cups-genppdupdate.5.0 no longer needs any arguments. + * debian/cupsys-driver-gutenprint.postrm: + - No longer remove PPD files on purge, since PPD files are no longer provided. + * debian/patches/10_cups_modeldir.dpatch: Patch from Ubuntu. Fix up PPD + directory location. (Not actually used yet--the patch needs some + work.) + * debian/patches/20_fix_gimpprint_menu_entry.dpatch: Patch from Ubuntu. + Place the Print option in a better position in the GIMP File menu. + + -- Roger Leigh Sun, 24 Jun 2007 23:22:03 +0100 + +gutenprint (5.0.0-3) unstable; urgency=low + + * cupsys-driver-gutenprint: Move PPD files from + /usr/share/cups/model/gutenprint/5.0 to /usr/share/ppd/gutenprint/5.0, to + comply with the Debian PPD File Structure Specification + (http://wiki.debian.org/PpdFileStructureSpecification). The postinst and + postrm scripts have been updated to remove the old PPDs, generate new PPDs + in the new location, and to upgrade PPDs using the new location. + Closes: #396642. + * debian/control: cupsys-driver-gutenprint Depends upon cupsys or cups >= + 1.2.5, so CUPS is guaranteed to find the PPDs in the new location. + + -- Roger Leigh Thu, 2 Nov 2006 22:42:04 +0000 + +gutenprint (5.0.0-2) unstable; urgency=low + + * debian/control.in: cupsys-driver-gutenprint does not recommend + gnome-gv | postscript-viewer (Closes: #384232). It is doubtful this + was of any useful value. Thanks to Christian Hammers. + + -- Roger Leigh Tue, 22 Aug 2006 23:00:04 +0100 + +gutenprint (5.0.0-1) unstable; urgency=low + + * New upstream stable release. + * debian/compat: Switch to debhelper compatibility level 5. + * debian/control.in: + - Replace "beta" with "stable" in package descriptions. + - Add gutenprint-doc package now that GFDL licensed material with no + invariant sections is allowed in main. + - Build-Depend on debhelper >= 5.0.0. + * debian/copyright: Include full GFDL text. + * debian/rules: + - Update upstream version; compute from changelog revision number. + - Don't compress .pdf and .odt files. + * debian/gutenprint-doc.doc-base.in: Use new PDF manual rather than old + (removed) HTML user's guide. + * debian/gutenprint-doc.install: Install new PDF manual (and ODT source) + instead of old (removed) HTML user's guide. + * debian/patches: Drop patches applied upstream: + - 05_genppdconfig_remove_perlmenu.dpatch + - 06_genppdupdate_egrep_stdin_freeze.dpatch + - 07_print_ps_imageable_area_rounding.dpatch + - 08_escputil_raw_device_open.dpatch + * configure.ac: Teach PACKAGE_DATA_DIR about $datarootdir. + * doc/Makefile.am: install-data-local: Install files from $(srcdir), to + fix VPATH build. + + -- Roger Leigh Sat, 12 Aug 2006 18:31:14 +0100 + +gutenprint (4.3.99+cvs20060521-4) unstable; urgency=low + + * src/escputil/escputil.c: When a raw device cannot be opened, display + a more informative error message. Patch installed as + debian/patches/08_escputil_raw_device_open.dpatch (Closes: #352106). + + -- Roger Leigh Tue, 6 Jun 2006 21:06:56 +0100 + +gutenprint (4.3.99+cvs20060521-3) unstable; urgency=low + + * src/main/print-ps.c: Round ImageableArea dimensions towards the centre + of the page, and preserve locales recursively. Patch installed as + debian/07_print_ps_imageable_area_rounding.dpatch (Closes: #329027). + + -- Roger Leigh Mon, 5 Jun 2006 10:43:30 +0100 + +gutenprint (4.3.99+cvs20060521-2) unstable; urgency=low + + * debian/rules: Unconditionally set DIALOG when running configure. + * src/cups/cups-genppdupdate.in: Don't freeze waiting on stdin when + running egrep. Patch installed as + debian/patches/06_genppdupdate_egrep_stdin_freeze.dpatch; thanks to + Felix C. Stegerman for identifying the fault and providing the patch + (Closes: #368446). + + -- Roger Leigh Mon, 22 May 2006 19:21:50 +0100 + +gutenprint (4.3.99+cvs20060521-1) unstable; urgency=low + + * New upstream release candidate. + * doc/Makefile.am, doc/Makefile.in: Drop patches from the .diff.gz which + have been dropped upstream. + * debian/cupsys-driver-gutenprint.docs, debian/gimp-print.docs, + debian/ijsgutenprint.docs: Drop doc/gutenprint-options, which is no + longer present. + * debian/libgutenprint-doc.doc-base.developer: Use book1.html, rather + than index.html, which is no longer present in the upstream release + (Closes: #367412). + * debian/control: + - Update to Standards-Version 3.7.2. + - escputil: Recommend cupsys-bsd|lprng|lpr to advise that an lpr + command is available (Closes: #352102). + * debian/copyright: Update with current CVS repository location + (Closes: #361120). + + -- Roger Leigh Sun, 21 May 2006 12:40:54 +0100 + +gutenprint (4.3.99+cvs20060121.dfsg.1-1) unstable; urgency=low + + * New upstream release candidate (5.0.0-rc2). + * The many options provided by Gutenprint are now documented, and this + documentation (gutenprint-options) is now provided for the + cupsys-driver-gutenprint, ijsgimpprint and gimp-print packages in their + documentation directories (Closes: #323172). + * Revert accidental conversion to a debian-native source package in the last + release. + * debian/cupsys-driver-gimpprint.postinst, + debian/cupsys-driver-gimpprint.postrm: Use invoke-rc.d when reloading + cupsys, and don't fail if cupsys fails to reload. Patches pulled from + the Ubuntu patch repository for gimp-print. + + -- Roger Leigh Sun, 22 Jan 2006 14:21:19 +0000 + +gutenprint (4.3.99+cvs20051122.dfsg.1-2) unstable; urgency=low + + * debian/control.in: Remove xlibs-dev from Build-Depends, in + anticipation of its removal from unstable. + + -- Roger Leigh Fri, 16 Dec 2005 10:53:04 +0000 + +gutenprint (4.3.99+cvs20051122.dfsg.1-1) unstable; urgency=low + + * New upstream CVS snapshot (Closes: #340155). + * The GFDL licensed user's guide has been removed from the + upstream tarball to create a DFSG-free .orig.tar.gz. + * Several Epson Stylus Photo printers have been retuned since the + last version (Closes: #335789). + * The Epson Stylus C88 is now supported (Closes: #338961). + * debian/control.in: + - Improve the ijsgutenprint package description (Closes: #337845). + - Remove 'Suggests: gutenprint-doc (>= ${Source-Version})' from + gimp-print and cupsys-driver-gutenprint. + - Remove the gutenprint-doc package, which was GFDL licensed. + The control data is kept in debian/control.gfdl. + * debian/rules: Update UPSTREAM_VERSION to 5.0.0-rc2. + * debian/copyright: Remove the GFDL manual paragraph, and document + its removal due to DFSG incompatibility. + + -- Roger Leigh Tue, 22 Nov 2005 15:44:02 +0000 + +gutenprint (4.3.99+cvs20050901-1) unstable; urgency=low + + * New upstream release candidate. + * Drop patches which have been incorporated upstream: + - 01_cups_genppdupdate_filename_metacharacters.dpatch + - 02_escp2_r800_papers.dpatch + - 03_escp2_colour_adjust_segfault.dpatch + - 04_print_settings_corruption.dpatch + * debian/control: + - cupsys-driver-gutenprint: Drop libperlmenu-perl dependency. + - gimp-print: Add an "Enhances: gimp" to reinforce the fact this is a + useful part of gimp (Closes: #322066). This does not entirely fix the + upgrade issues, but without a strict dependency in gimp (which the + author does not want), this is the best that can be done. + * src/cups/cups-genppdconfig.in: Remove support for perlmenu in favour + of dialog(1). This prevents a number of warnings on startup, and also + removes a lot of dead code (Closes: #323450). Applied as + 05_genppdconfig_remove_perlmenu.dpatch. + + -- Roger Leigh Sat, 3 Sep 2005 20:46:06 +0100 + +gutenprint (4.3.99+cvs20050813-2) unstable; urgency=low + + * src/main/print-canon.c: Change "Plain PIXMA" paper name to + "PlainPIXMA" in order to avoid illegal whitespace in + generated PPD files (Closes: #322397). + + -- Roger Leigh Wed, 31 Aug 2005 21:16:10 +0100 + +gutenprint (4.3.99+cvs20050813-1) unstable; urgency=low + + * New upstream release candidate. + * src/cups/cups-genppdconfig.in: drop Locale::gettext patch, + which is now incorporated upstream. + * debian/control.in, debian/rules: Use dpatch. + * Added cups-genppdupdate patch as + 01_cups_genppdupdate_filename_metacharacters.dpatch + * Don't segfault when using certain paper types with an Epson R800. + Applied patch from Dan Torop as 02_escp2_r800_papers.dpatch + and 03_escp2_colour_adjust_segfault.dpatch (Closes: #321603). + * Don't corrupt print settings under certain conditions, due to + using uninitialised global variables. Applied patch from upstream + based on a patch contributed by Dan Torop as + 04_print_settings_corruption.dpatch (Closes: #321599). + * debian/debian/cupsys-driver-gutenprint.postinst: Remove bashisms. + + -- Roger Leigh Sun, 14 Aug 2005 22:20:52 +0100 + +gutenprint (4.3.99+cvs20050801-1) unstable; urgency=low + + * New upstream release candidate. + * src/cups/cups-genppdconfig.in: Remove "use Locale::gettext" to + drop missing dependency on liblocale-gettext-perl + (Closes: #320745). + + -- Roger Leigh Tue, 2 Aug 2005 21:06:08 +0100 + +gutenprint (4.3.99+cvs20050715-4) unstable; urgency=low + + * debian/rules: Correct the names of the ijsgutenprint + symlinks. + + -- Roger Leigh Thu, 28 Jul 2005 23:19:35 +0100 + +gutenprint (4.3.99+cvs20050715-3) unstable; urgency=low + + * src/cups/cups-genppdupdate.in: Apply patch to handle shell + metacharacters in PPD filenames, to fix a regression from + cupsys-driver-gimpprint (Closes: #319109). + * debian/control.in: Add foomatic-db-gimp-print as a + transitional package to ease upgrades. + * debian/rules: ijsgutenprint symlinks should not be relative + to the build directory (Closes: #319416). + + -- Roger Leigh Thu, 28 Jul 2005 21:14:31 +0100 + +gutenprint (4.3.99+cvs20050715-2) unstable; urgency=low + + * debian/control.in: + - ijsgimpprint depends on ijsgutenprint, not + cupsys-driver-gutenprint (Closes: #318911). + - ijsgimpprint is in section text, not graphics + (correction of override disparity). + + -- Roger Leigh Mon, 18 Jul 2005 18:39:47 +0100 + +gutenprint (4.3.99+cvs20050715-1) unstable; urgency=low + + * New upstream release candidate. + * debian/control.in: Change Maintainer to Debian Printing Group + . + * debian/rules: Don't build translated PPDs. They may be generated + after installation by the user. + + -- Roger Leigh Sat, 16 Jul 2005 22:45:28 +0100 + +gutenprint (4.3.99+cvs20050702-1) experimental; urgency=low + + * New upstream release candidate (Closes: #293890). + * Renamed package to gutenprint. The following packages were + renamed in consequence: + - cupsys-driver-gimpprint renamed to cupsys-driver-gutenprint + - foomatic-db-gimp-print renamed to foomatic-db-gutenprint + - gimpprint-doc renamed to gutenprint-doc + - gimpprint-locales renamed to gutenprint-locales + - ijsgimpprint renamed to ijsgutenprint + - libgimpprint renamed to libgutenprint + - libgimpprint-dev renamed to libgutenprint-dev + - libgimpprint-doc renamed to libgutenprint-doc + * New packages: + - libgimpprintui1-1 (GTK+ 1.2 UI library) + - libgimpprintui1-dev (GTK+ 1.2 UI library headers) + - libgimpprintui2-1 (GTK+ 2.0 UI library) + - libgimpprintui2-dev (GTK+ 2.0 UI library headers) + * Upgrade to Standards-Version 3.6.2 + * Build-Depends: + - replace libreadline4-dev with libreadline5-dev + - add libcupsimage2-dev + - remove libtool + * debian/rules: add LIBRARYUI_VERSION, required to support + separate sonames for libgutenprint and libgutenprintui*. + * cupsys-driver-gutenprint: + - add cups-genppdupdate + - generates the PPDs in postinst, and removes them in prerm + - use new versioned CUPS executables + * libgutenprint: add modules and XML data. + * libgutenprint-doc: + - fix documentation installation for new API reference and + developer's reference. + - distribute gutenprint.pdf; gutenprint.ps is no longer created. + * Remove old and outdated manual pages. + * Provide versioned ijsgutenprint manual page, and unversioned + symlinks for the binary and manpage. + * Create a dummy cupsys-driver-gimpprint package to enable + upgrades from stable. + * Create a dummy ijsgimpprint package to enable upgrades from stable. + * Remove symlinks in debian directory. + * Don't autogenerate files in debian directory for anything but the + libgutenprintui package. + + -- Roger Leigh Sat, 2 Jul 2005 10:12:46 +0100 + +gimp-print (4.2.7-10) unstable; urgency=high + + * cupsys-driver-gimpprint: Depend on a perl >= 5.8.0, otherwise + upgrades from woody may fail due to /usr/bin/cups-genppdupdate + using features only available in perl 5.8 (Closes: #307286). + * Build-Depend on libreadline5-dev, rather than the old + libreadline4-dev. + + -- Roger Leigh Mon, 2 May 2005 14:58:39 +0100 + +gimp-print (4.2.7-9) unstable; urgency=low + + * debian/cups-genppdupdate: Fix grepping of PPDs to work with PPD + file names with shell metacharacters in them. Patch from Martin + Pitt (Closes: #302434). + + -- Roger Leigh Thu, 31 Mar 2005 22:10:41 +0100 + +gimp-print (4.2.7-8) unstable; urgency=low + + * cupsys-driver-gimpprint: Depend on cupsys >= 1.1.23 to ensure + that /etc/init.d/cupsys supports the force-reload option. + Some older versions of cupsys did not, and this causes + package configuration to fail when restarting cupsys. + (Closes: #300966) + + -- Roger Leigh Wed, 23 Mar 2005 18:06:35 +0000 + +gimp-print (4.2.7-7) unstable; urgency=low + + * debian/control.in: + - Prefer gs-esp as gs interpreter. Patch from Colin Watson. + - Recommend gnome-gv as default postscript-viewer. Patch + from Sebastien Bacher. + + -- Roger Leigh Tue, 22 Mar 2005 00:20:09 +0000 + +gimp-print (4.2.7-6) unstable; urgency=low + + * Allow A4 printing on HP DesignJet printers. Patch from + Klaus Singvogel. + + -- Roger Leigh Sat, 19 Mar 2005 09:58:18 +0000 + +gimp-print (4.2.7-5) unstable; urgency=low + + * Patch src/cups/Makefile.in so that genppd will use the "C" + locale when generating PPDs, not the locale of the build + system. This will prevent wrongly UTF-8 encoded "ISOLatin1" + PPDs being generated (Closes: #293178). + * ijsgimpprint: Conditionally depend upon gs-afpl instead of + gs-aladdin, which it replaces (Closes: #293384). + + -- Roger Leigh Wed, 2 Feb 2005 21:45:16 +0000 + +gimp-print (4.2.7-4) unstable; urgency=low + + * cupsys-driver-gimpprint: Use "force-reload" rather than + "reload" in postinst and postrm (Closes: #274820). Reported + by Martin Pitt. + * Applied GNU/k*BSD patch from Robert Millan (Closes: #263763). + + -- Roger Leigh Tue, 5 Oct 2004 19:46:08 +0100 + +gimp-print (4.2.7-3) unstable; urgency=low + + * foomatic-db-gimp-print: ensure all files are UTF-8 encoded + by building the package in a UTF-8 locale (en_GB.UTF-8). + Thanks to Chris Lawrence for finding this problem. + + -- Roger Leigh Tue, 21 Sep 2004 21:37:38 +0100 + +gimp-print (4.2.7-2) unstable; urgency=medium + + * Medium urgency to facilitate the libtiff transition. + * cupsys-driver-gimpprint: + - Link explicitly with -lcupsimage, rather than + `cups-config --image --libs`. This prevents unnecessary + libpng, libjpeg and libtiff dependencies. The cups-config + logic in configure is overridden. Thanks to Steve Langasek + for this patch (Closes: #262852). + - Backport some PPD generation logic from current Gimp-Print + CVS, and use the new PPD keywords in cups-genppdupdate. + The PPD PCFileName keyword was made compliant with the PPD + standard with version 4.2.6 (read: crippled to an 8.3 DOS + filename) which broke the upgrade script since the full PPD + name could no longer be encoded. The new Gimp-Print specific + keywords *StpDriverName, *StpPPDLocation and *StpLocale have + been added to the PPDs, and this information is now used to + correctly upgrade PPDs (Closes: #260072). + * debian/rules: Don't enable maintainer-mode when running + configure. + + -- Roger Leigh Tue, 3 Aug 2004 19:23:19 +0100 + +gimp-print (4.2.7-1) unstable; urgency=low + + * New upstream stable release. + * Dropped patches for: + - missing strdup prototype in AM_PATH_GIMPPRINT (#233971). + - fixing garbage output when files generated with psnup are + printed (#175970). + - correct margin definitions for Epson Stylus C63, C64, C83 + and C84. + All of these patches have been incorporated into the new + release. + * Update to Standards-Version 3.6.1. + * cupsys-driver-gimpprint: update Recommends to depend upon the + current gs package names, and put the virtual package + postscript-viewer as the last alternative, rather than the + first. + * cupsys-driver-gimpprint: patched src/cups/Makefile.am to + disable linking rastertoprinter with a static libgimpprint. + + -- Roger Leigh Sat, 17 Jul 2004 17:38:35 +0100 + +gimp-print (4.2.6-7) unstable; urgency=high + + * Reupload with high urgency to shorten libcupsys2-gnutls10 + transition waiting time. + + -- Roger Leigh Fri, 9 Jul 2004 11:56:34 +0100 + +gimp-print (4.2.6-6) unstable; urgency=low + + * cupsys-driver-gimpprint-data depends on cupsys-driver-gimpprint. + + -- Roger Leigh Wed, 7 Jul 2004 13:26:51 +0100 + +gimp-print (4.2.6-5) unstable; urgency=medium + + * NMU. + * Rebuild against libcupsys2-gnutls10. + + -- Kenshi Muto Thu, 27 May 2004 16:39:55 +0000 + +gimp-print (4.2.6-4) unstable; urgency=low + + * Split architecture-independent data in cupsys-driver-gimpprint + into a separate arch-all cupsys-driver-gimpprint-data package + which cupsys-driver-gimpprint depends upon (Closes: #233338). + * Add missing strdup prototype in AM_PATH_GIMPPRINT in + gimpprint.m4. This prevents configure scripts using this macro + from segfaulting on ia64 (Closes: #233971). + * Correct margin definitions for Epson Stylus C63, C64, C83 and + C84. This is a temporary fix until the margins have been + correctly computed. + * Build-Depend upon libijs-dev (>= 0.35-1) to ensure that + ijsgimpprint is built against the current libijs + (Closes: #237561). + + -- Roger Leigh Fri, 12 Mar 2004 20:32:51 +0000 + +gimp-print (4.2.6-3) unstable; urgency=low + + * Rebuild against new Foomatic packages. This should hopefully + fix autobuilding problems with older Foomatic releases (which + wouldn't autoconfigure on the buildd). + + -- Roger Leigh Mon, 1 Mar 2004 13:07:07 +0000 + +gimp-print (4.2.6-2) unstable; urgency=low + + * Fix garbage output when files generated with psnup are printed. + The output quality will be degraded, and warnings will be + logged, since the job options have been broken. This is + because psnup generates non-ADSC compliant PostScript which + makes pstops output incorrect job options. Patch from + Martin Kögler (Closes: #175970). + + -- Roger Leigh Tue, 10 Feb 2004 19:39:17 +0000 + +gimp-print (4.2.6-1) unstable; urgency=low + + * New upstream stable release. + * cupsys-driver-gimpprint: cups-genppdupdate should escape + metacharacters in queue names. quotemeta fix from David + Beaumont (Closes: #223081). + * A locale issue which resulted in buggy PostScript output + with some locales has been fixed (Closes: #221662). + * CUPS PPD files moved from /usr/share/cups/model/gimp-print + to /usr/share/cups/model/gimp-print/4.2. This is the + 5.0 naming scheme, and will allow 4.2 and 5.0 to + coexist. cups-genppdupdate uses the new scheme. + + -- Roger Leigh Tue, 13 Jan 2004 23:42:02 +0000 + +gimp-print (4.2.5-6) unstable; urgency=low + + * Change Recommends on gimpprint-locales to Suggests (Closes: #212302). + * cupsys-driver-gimpprint postrm should not reload cupsys if it + has already been removed (Closes: #217295). + + -- Roger Leigh Sun, 26 Oct 2003 23:10:31 +0000 + +gimp-print (4.2.5-5) unstable; urgency=low + + * Clean up package descriptions in debian/control.in. + * Don't depend on essential package gzip. + + -- Roger Leigh Sun, 7 Sep 2003 23:04:56 +0100 + +gimp-print (4.2.5-4) unstable; urgency=low + + * Fix the use of an unintialised value in cups-genppdupdate + (Closes: #193501). + * cups-genppdupdate no longer prints an error when there are no PPD files + available (use Perl glob() instead of shell globbing). + * Update cups-genppdupdate using the latest upstream CVS version. + * Replace cupsys-driver-gimpprint dependency on libcompress-zlib-perl, with + a gzip dependency (gunzip replaces Compress::Zlib in cups-genppdupdate). + * Update for Foomatic 3.0: + - Update foomatic-db-gimp-print description (sync with foomatic-db). + - Build-Depend on foomatic-db-engine (foomatic-bin is deprecated). + - Update foomatic-db-gimp-print dependencies (correctly depend on the + new foomatic packages and conflict with the old packages). + - Run configure with --with-foomatic3 + * Include escputil fix from 4.2.6 prerelease to fix intermittent hanging + reads from printer (Closes: #156228). + * Audit all manual pages to ensure correct use of hyphens and minus signs, + required for copy and paste in a unicode locale (Closes: #203930). + * gimp1.2-print has been removed now the gimp package provides an up-to-date + version of the Print plugin. + * Updated debian/copyright to include the GFDL-licensed User's Guide. + + -- Roger Leigh Mon, 25 Aug 2003 19:12:24 +0100 + +gimp-print (4.2.5-3) unstable; urgency=low + + * Build-Depend on libcupsimage2-dev (Closes: #189093). + * Remove automake, autoconf, libtool, and bison from + Build-Depends, since they are not strictly required. + * Remove docbook-utils, texi2html and imagemagick from Build-Depends, + since the documentation is pre-generated in the upstream tarball. + * Change my maintainer email address to . + * Move libgimpprint1-dev to section libdevel. + + -- Roger Leigh Wed, 23 Apr 2003 12:57:58 +0100 + +gimp-print (4.2.5-2) unstable; urgency=low + + * cupsys-driver-gimpprint: cups-genppdupdate will not die if grep exits with + a nonzero status (for example, there are no Gimp-Print PPDs in use). + (Closes: #179137) + * cupsys-driver-gimpprint: Depend on libcompress-zlib-perl, since dh_perl + doesn't compute module dependencies. + (Closes: #179120, #179170, #179171, #179203) + + -- Roger Leigh Fri, 31 Jan 2003 23:26:51 +0000 + +gimp-print (4.2.5-1) unstable; urgency=low + + * New stable release + * Update for Standards-Version 3.5.7 + * Use debian/build and debian/install instead of debian/gimp-print-build + and debian/gimp-print-install, respectively. + * Use dh_install rather than dh_movefiles. This makes debian/rules + slightly cleaner, and debian/install is unchanged after install. + * Create symlinks for HTML manuals, since different versions + of texi2html and db2html create different names. + * Make the dependencies sane (remove incorrect dependencies, and correct + dubious ones). foomatic-db-gimp-print now depends only upon foomatic-db + and ijsgimpprint. + * escputil has been changed to section "utils", and the override changed + (Closes: #145094). + * Gimp-Print PPDs are automatically upgraded using a new tool, + cups-genppdupdate, which will prevent the in-use PPDs mismatching with + the libgimpprint version in use (Closes: #172116). + * The Epson stc640 will now print in greyscale and black and white at + resolutions >= 720 DPI (Closes: #170473). + * The CUPS epson backend uses non-blocking I/O, and so will not hang with + some models when no status readback data is sent. + + -- Roger Leigh Wed, 29 Jan 2003 11:37:49 +0000 + +gimp-print (4.2.4-1) unstable; urgency=low + + * New stable release. + * foomatic-db-gimp-print: removed "stp" data, to start the transition + to using ijsgimpprint only. + * The escputil manual page documents the needed kernel configuration + options (Closes: #139000). + * The gimpprint-doc package includes the following manual pages: + gimpprint-color.7, gimpprint-dithers.7, gimpprint-imagetypes.7 + gimpprint-inktypes.7, gimpprint-mediasizes.7 + gimpprint-mediasources.7, gimpprint-mediatypes.7 + gimpprint-models.7, gimpprint-resolutions.7 + This documents all the features of gimp-print, in particular all of the + details from src/ghost/README (Closes: #113075). + * Magenta and cyan are no longer swapped on some Lexmark printers + (Closes: #166815). + + -- Roger Leigh Tue, 26 Nov 2002 20:54:30 +0000 + +gimp-print (4.2.3-2) unstable; urgency=low + + * Use libtool 1.4.3 instead of the release version, to correctly support + shared libraries on some architectures. Closes #168901 + * escputil is now in section "utils". Closes #145094 + + -- Roger Leigh Tue, 19 Nov 2002 20:55:01 +0000 + +gimp-print (4.2.3-1) unstable; urgency=low + + * New stable release. + * Fixed doc-base problems in libgimpprint-doc. The doc-base file is + generated with sed to insert the version number, Closes #149847 + * libgimpprint$(VERSION)-doc provides and conflicts with a virtual + package libgimpprint-doc to prevent clashes with gimpprint.info + docs. + * New package ijsgimpprint. This provides an IJS server for use + with ghostscript. + * Remove the autotools, texi2html, imagemagick and docbook-utils from the + Build-Depends. + * Put config.sub and config.guess into scripts/ and clean + libgimpprint-doc.doc-base + * I am the new maintainer of gimp-print for Debian. + + -- Roger Leigh Sun, 20 Oct 2002 22:10:17 +0100 + +gimp-print (4.2.2-pre2-1) unstable; urgency=low + + * New stable release, Closes: #148737 + * Upgrade to debhelper version 4 (RL) + * Automate library versioning to work for stable and unstable series. + LIBRARY_VERSION is the library major version or -UPSTREAM_VERSION (RL) + * Update configure regeneration to work with configure.ac (RL) + * libgimpprint$(VERSION)-dev provides and conflicts with a virtual + package `libgimpprint-dev' (RL) + * Remove libgimpprint.postinst as ldconfig is called by debhelper (RL) + * Update package descriptions (RL) + + -- Eric Sharkey Thu, 6 Jun 2002 15:35:28 -0400 + +gimp-print (4.2.2-pre1-1) unstable; urgency=low + + * New upstream release, Closes: #147404, #139218 + * Move escputil to section utils (RL) + * Add postscript-viewer virtual package as an alternative to gs Recommends + for cupsys-driver-gimpprint (RL) + * Reinitialise cupsys after installation or removal of + cupsys-driver-gimpprint (RL) + * Correctly version libgimpprint1 shlibs with -V dh_makeshlibs option + * Fix libgimpprint.postinst to use 'if' instead of 'case', removing a + lintian warning. (RL) + * Split out the message catalogues from the libgimpprint package into + a new gimpprint-locales package to avoid filename conflicts when + multiple libgimpprint versions are installed concurrently. (RL) + * Add libgimpprint-doc.doc-base (existed for six months, but was never + added to CVS!) (RL) + * New package foomatic-db-gimpprint. Contains foomatic data (RL) + + -- Eric Sharkey Sat, 25 May 2002 14:20:17 -0400 + +gimp-print (4.2.0-4) unstable; urgency=low + + * Apply Roger's user's guide Makefile.am patch, Closes: #128421 + * Work around bug #130756 by building docs with EPS1 figures. + + -- Eric Sharkey Sat, 16 Feb 2002 22:46:29 -0500 + +gimp-print (4.2.0-3) unstable; urgency=low + + * Fix locales package description, Closes: #123796 + * Change conflicts to replaces, Closes: #123811 + + -- Eric Sharkey Mon, 31 Dec 2001 12:02:42 -0500 + +gimp-print (4.2.0-2) unstable; urgency=low + + * Fix build dependencies, Closes: #121597 + * Fix broken gimpprint-doc.doc-base pointing to old index filename + * Fix libgimpprint.postinst to use 'if' instead of 'case', removing a + lintian warning. (Roger Leigh) + * Split out the message catalogues from the libgimpprint package into + a new gimpprint-locales package to avoid filename conflicts when + multiple libgimpprint versions are installed concurrently. (RL) + * Add libgimpprint-doc.doc-base (existed for six months, but was never + added to CVS!) (RL) + + -- Eric Sharkey Sun, 9 Dec 2001 09:47:05 -0500 + +gimp-print (4.2.0-1) unstable; urgency=low + + * New upstream release + * cupsys-driver-gimpprint only includes the basic `C' POSIX locale + ppd files due to the size of the ppd files (Roger Leigh) + * New package gimpprint-doc contains the new user guide. (RL) + * Enable i18n (RL) + * Add Build-Depends for gettext (>= 0.10.36-1), because + 'make install' fails with earlier versions due to absent + DESTDIR support. (RL) + * libgimpprint-doc uses ps instead of dvi manual, due to inclusion + of graphics (RL) + * gimp1.2-print no longer registers documentation with doc-base, as + the manual is provided in libgimpprint-doc (RL) + * Disable building of translated PPD files (RL) + + -- Eric Sharkey Sun, 25 Nov 2001 22:20:33 -0500 + +gimp-print (4.1.99-b1-1) unstable; urgency=low + + * New upstream release, Closes: #110066 + * Remove README.dither from libgimpprint-dev.docs (Roger Leigh) + * Add image samples to gimp1.2-print and cupsys-driver-gimpprint (RL) + * Change rules and control to use ABI library versioning (RL) + * Changed library version names to reflect upstream library + versioning change to ABI versioning. (RL) + + -- Eric Sharkey Mon, 23 Jul 2001 10:49:04 -0400 + +gimp-print (4.1.99-a2-1) unstable; urgency=low + + * New upstream release + + -- Eric Sharkey Mon, 23 Jul 2001 10:49:04 -0400 + +gimp-print (4.1.99-a1-1) unstable; urgency=low + + * New upstream release (first 4.2 pre-release) + + -- Eric Sharkey Tue, 10 Jul 2001 16:19:03 -0400 + +gimp-print (4.1.10-1) unstable; urgency=low + + * New upstream release (4.1.8 and 4.1.9 were buggy) + + -- Eric Sharkey Fri, 29 Jun 2001 23:08:27 -0400 + +gimp-print (4.1.7-1) unstable; urgency=low + + * New package libgimpprint-doc for Info and dvi docs. (Roger Leigh) + * Change debian/rules to use separate binary-arch and binary-indep + targets (Roger Leigh) + * New upstream release + + -- Eric Sharkey Wed, 9 May 2001 12:19:43 -0400 + +gimp-print (4.1.6-2) unstable; urgency=low + + * Fix build dependencies to include flex, Closes: #96401 + + -- Eric Sharkey Tue, 8 May 2001 20:09:30 -0400 + +gimp-print (4.1.6-1) unstable; urgency=low + + * New upstream release + + -- Eric Sharkey Mon, 30 Apr 2001 13:45:56 -0400 + +gimp-print (4.1.5-2.01) unstable; urgency=low + + * Recompile 4.1.5-2 with updated debhelper to fix dependencies + * Closes #90741 + + -- Eric Sharkey Fri, 6 Apr 2001 21:11:15 -0400 + +gimp-print (4.1.5-2) unstable; urgency=low + + * Clean up build process so that things work even if some scripts + don't have execute permissions, complicate things a bit by using + funky building script, Closes #89283, I hope... + + -- Eric Sharkey Thu, 15 Mar 2001 21:54:52 -0500 + +gimp-print (4.1.5-1) unstable; urgency=low + + * New upstream release + * First Official version uploaded to Debian + * Close ITP bug for wnpp, Closes #85563 + + -- Eric Sharkey Fri, 2 Mar 2001 19:59:11 -0500 + +gimp-print (4.1.4-2) unstable; urgency=low + + * Repackage gimp-print after forking the Debian branch from 4.1.4 + * Add version numbers to the libgimpprint package name + * Move documentation files from libgimpprint to libgimpprint-dev + + -- Eric Sharkey Tue, 27 Feb 2001 11:22:18 -0500 + +gimp-print (4.1.4-1) unstable; urgency=low + + * New upstream release + * Debian package rewritten from scratch. + * Added diversion of the print plugin that is part of the GIMP + package to /usr/lib/gimp/1.2/print + * Fixed shared library dependencies for programs linked with + libgimpprint + * Added /etc/cups/command.types as a conffile for package cupsys- + driver-gimpprint + * Added gimp1.2-print html and sgml docs to doc-base + * Remove /etc/cups in postrm for cupsys-driver-gimprint (but + won't if not empty) + * Added versioned debhelper Build-Depends + + -- Roger Leigh Fri, 16 Feb 2001 00:16:10 +0000 + +gimp-print (4.0.2-1) unstable; urgency=low + + * Debian packages of the latest GP + + -- Eric Sharkey Sun, 12 Nov 2000 04:46:54 +0900 + +gimp-print (3.1.4-1) unstable; urgency=low + + * Debianised gimp-print built from gimp-print CVS at sourceforge. + + -- Charles Briscoe-Smith Wed, 24 May 2000 00:39:54 +0100 + + diff --git a/compat b/compat new file mode 100644 index 0000000..f599e28 --- /dev/null +++ b/compat @@ -0,0 +1 @@ +10 diff --git a/control b/control new file mode 100644 index 0000000..ff3d888 --- /dev/null +++ b/control @@ -0,0 +1,233 @@ +Source: gutenprint +Homepage: http://gimp-print.sourceforge.net/ +Section: graphics +Priority: optional +Maintainer: Debian Printing Group +Uploaders: Didier Raboud +Standards-Version: 4.0.0 +Build-Depends: + debhelper (>= 10.2.5~), + dh-autoreconf, + autotools-dev, + libcups2-dev, + libcupsimage2-dev, + libgimp2.0-dev, + libreadline-dev, + libijs-dev, + libusb-1.0-0-dev [linux-any], + zlib1g-dev, + flex, + gettext, + chrpath, +XS-Testsuite: autopkgtest +Vcs-Browser: http://anonscm.debian.org/gitweb/?p=printing/gutenprint.git +Vcs-Git: https://alioth.debian.org/anonscm/git/printing/gutenprint.git + +Package: gimp-gutenprint +Architecture: any +Depends: + ${misc:Depends}, ${shlibs:Depends}, + gimp (>= 2.4.0~rc1-1) +Suggests: + gutenprint-doc (>= ${source:Version}), + gutenprint-locales (>= ${source:Version}) +Enhances: gimp +Description: print plugin for the GIMP + This package includes the Gutenprint Print plugin for the GIMP. + . + Gutenprint is the print facility for the GIMP, and in addition a + suite of drivers that may be used with common UNIX spooling systems + using GhostScript or CUPS. These drivers provide printing quality + for UNIX/Linux on a par with proprietary vendor-supplied drivers in + many cases, and can be used for many of the most demanding printing + tasks. Gutenprint was formerly known as Gimp-Print. + +Package: printer-driver-gutenprint +Architecture: any +Depends: + ${misc:Depends}, + ${perl:Depends}, + ${shlibs:Depends}, + cups (>= 1.3.0), + cups-client (>= 1.3.0), + cups-filters (>= 1.0.36) | ghostscript-cups (<< 9.08) +Suggests: + gutenprint-doc (>= ${source:Version}), + gutenprint-locales (>= ${source:Version}) +Description: printer drivers for CUPS + This package includes a CUPS driver based on Gutenprint. + . + The CUPS drivers contain all of the files needed to support + photo-quality printing on any printer supported by Gutenprint. You + can find out more about the Common UNIX Printing System ("CUPS"), an + IPP-based printing system for UNIX/Linux, at: + . + http://www.cups.org + . + Gutenprint is the print facility for the GIMP, and in addition a + suite of drivers that may be used with common UNIX spooling systems + using GhostScript or CUPS. These drivers provide printing quality + for UNIX/Linux on a par with proprietary vendor-supplied drivers in + many cases, and can be used for many of the most demanding printing + tasks. Gutenprint was formerly known as Gimp-Print. + +Package: libgutenprint-dev +Architecture: any +Section: libdevel +Depends: + ${misc:Depends}, + libgutenprint2 (= ${binary:Version}), + pkg-config +Suggests: libgutenprint-doc (= ${source:Version}) +Description: development files for the Gutenprint printer driver library + This package contains the header files for the Gutenprint library, + along with a static version of libgutenprint. + . + Install this package if you wish to develop programs that use + libgutenprint. + . + Gutenprint is the print facility for the GIMP, and in addition a + suite of drivers that may be used with common UNIX spooling systems + using GhostScript or CUPS. These drivers provide printing quality + for UNIX/Linux on a par with proprietary vendor-supplied drivers in + many cases, and can be used for many of the most demanding printing + tasks. Gutenprint was formerly known as Gimp-Print. + +Package: libgutenprint-doc +Architecture: all +Section: doc +Depends: ${misc:Depends}, libjs-jquery (>= 1.7.1) +Suggests: libgutenprint-dev (= ${source:Version}) +Description: documentation for the Gutenprint printer driver library + This package contains lots of info-files, DVI docs and other + documentation about the Gutenprint library for photo-quality + printing. + . + Install this package if you want to have lots of info about the + Gutenprint library when you're programming. + . + Gutenprint is the print facility for the GIMP, and in addition a + suite of drivers that may be used with common UNIX spooling systems + using GhostScript or CUPS. These drivers provide printing quality + for UNIX/Linux on a par with proprietary vendor-supplied drivers in + many cases, and can be used for many of the most demanding printing + tasks. Gutenprint was formerly known as Gimp-Print. + +Package: libgutenprint2 +Architecture: any +Section: libs +Pre-Depends: ${misc:Pre-Depends} +Depends: ${misc:Depends}, ${shlibs:Depends} +Suggests: gutenprint-locales (>= ${source:Version}) +Description: runtime for the Gutenprint printer driver library + This package includes the Gutenprint shared library, needed to + run programs using Gutenprint drivers. + . + Gutenprint is the print facility for the GIMP, and in addition a + suite of drivers that may be used with common UNIX spooling systems + using GhostScript or CUPS. These drivers provide printing quality + for UNIX/Linux on a par with proprietary vendor-supplied drivers in + many cases, and can be used for many of the most demanding printing + tasks. Gutenprint was formerly known as Gimp-Print. + +Package: libgutenprintui2-dev +Architecture: any +Section: libdevel +Depends: + ${misc:Depends}, + libgutenprintui2-1 (= ${binary:Version}), + pkg-config +Pre-Depends: dpkg (>= 1.17.5) +Suggests: libgutenprint-doc (= ${source:Version}) +Description: development files for the Gutenprint printer driver user interface library + This package contains the header files for the libgutenprintui + library, along with a static version of libgutenprintui. + libgutenprintui contains GTK+ widgets which may be used for print + dialogs etc. for use with libgutenprint. + . + Install this package if you wish to develop packages that use + libgutenprintui. + . + Gutenprint is the print facility for the GIMP, and in addition a + suite of drivers that may be used with common UNIX spooling systems + using GhostScript or CUPS. These drivers provide printing quality + for UNIX/Linux on a par with proprietary vendor-supplied drivers in + many cases, and can be used for many of the most demanding printing + tasks. Gutenprint was formerly known as Gimp-Print. + +Package: libgutenprintui2-1 +Architecture: any +Section: libs +Pre-Depends: ${misc:Pre-Depends} +Depends: ${misc:Depends}, ${shlibs:Depends} +Recommends: gutenprint-locales (>= ${source:Version}) +Description: runtime for the Gutenprint printer driver user interface library + This package includes the libgutenprintui library, necessary to run + gimp-gutenprint. libgutenprintui contains GTK+ widgets which may be + used for print dialogs etc. for use with libgutenprint. + . + Gutenprint is the print facility for the GIMP, and in addition a + suite of drivers that may be used with common UNIX spooling systems + using GhostScript or CUPS. These drivers provide printing quality + for UNIX/Linux on a par with proprietary vendor-supplied drivers in + many cases, and can be used for many of the most demanding printing + tasks. Gutenprint was formerly known as Gimp-Print. + +Package: gutenprint-locales +Architecture: all +Section: libs +Depends: ${misc:Depends} +Description: locale data files for Gutenprint + This package contains the i18n files of Gutenprint, used by + libgutenprint2, printer-driver-gutenprint and escputil. It is also + used by the Print plugin for the GIMP, gimp-gutenprint. + . + They are needed when you want the programs in Gutenprint to print + their messages in other languages than US English. + . + Gutenprint is the print facility for the GIMP, and in addition a + suite of drivers that may be used with common UNIX spooling systems + using GhostScript or CUPS. These drivers provide printing quality + for UNIX/Linux on a par with proprietary vendor-supplied drivers in + many cases, and can be used for many of the most demanding printing + tasks. Gutenprint was formerly known as Gimp-Print. + +Package: escputil +Architecture: any +Section: utils +Depends: ${misc:Depends}, + ${shlibs:Depends}, + libgutenprint2 (= ${binary:Version}), +Pre-Depends: dpkg (>= 1.17.5) +Suggests: gutenprint-locales (>= ${source:Version}) +Description: maintenance utility for Epson Stylus printers + escputil is a utility to clean and align the heads of Epson Stylus + printers. It can also check the current ink levels in the printer. + . + Gutenprint is the print facility for the GIMP, and in addition a + suite of drivers that may be used with common UNIX spooling systems + using GhostScript or CUPS. These drivers provide printing quality + for UNIX/Linux on a par with proprietary vendor-supplied drivers in + many cases, and can be used for many of the most demanding printing + tasks. Gutenprint was formerly known as Gimp-Print. + +Package: gutenprint-doc +Architecture: all +Section: doc +Depends: ${misc:Depends} +Suggests: + printer-driver-gutenprint (>= ${source:Version}), + gimp-gutenprint (>= ${source:Version}), + libjs-jquery (>= 1.7.1) +Description: users' guide for Gutenprint and CUPS + This package contains a user guide for programs using the + Gutenprint library for photographic quality printing. Currently + this covers using the Print plugin for the GIMP and the Common Unix + Printing System (CUPS). + . + Gutenprint is the print facility for the GIMP, and in addition a + suite of drivers that may be used with common UNIX spooling systems + using GhostScript or CUPS. These drivers provide printing quality + for UNIX/Linux on a par with proprietary vendor-supplied drivers in + many cases, and can be used for many of the most demanding printing + tasks. Gutenprint was formerly known as Gimp-Print. diff --git a/copyright b/copyright new file mode 100644 index 0000000..ebb9c33 --- /dev/null +++ b/copyright @@ -0,0 +1,34 @@ +This package was debianized by Roger Leigh on +Fri, 26 Jan 2001 17:42:06 +0000. + +It was downloaded from CVS: + gimp-print.cvs.sourceforge.net:/cvsroot/gimp-print (module print) +See http://sourceforge.net/cvs/?group_id=1537 for full instructions. + +The official release tarballs are available from: + http://sourceforge.net/project/showfiles.php?group_id=1537 + +See also http://gimp-print.sourceforge.net/. + + +Upstream Authors: Michael Sweet (mike@easysw.com) + Robert Krawitz (rlk@alum.mit.edu) + and the rest of the Gutenprint development team. + + +Copyright: + +This software is Copyright © 1997-2008 Michael Sweet and Robert Krawitz + +You are free to distribute this software under the terms of +the GNU General Public License. +On Debian systems, the complete text of the GNU General Public +License can be found in /usr/share/common-licenses/GPL file. + +The user manual, in the gutenprint-doc package, is licensed under the +terms of the GNU Free Documentation License. +On Debian systems, the complete text of the GNU Free Documentation +License can be found in /usr/share/common-licenses/GFDL-1.2 + + + -- Roger Leigh Fri, 04 Jan 2008 23:14:01 +0000 diff --git a/escputil.install b/escputil.install new file mode 100644 index 0000000..64cf87c --- /dev/null +++ b/escputil.install @@ -0,0 +1,2 @@ +usr/bin/escputil +usr/share/man/man1/escputil.1 diff --git a/escputil.maintscript b/escputil.maintscript new file mode 100644 index 0000000..ac80b47 --- /dev/null +++ b/escputil.maintscript @@ -0,0 +1 @@ +dir_to_symlink /usr/share/doc/escputil /usr/share/doc/libgutenprint2 5.2.10-1~ diff --git a/gbp.conf b/gbp.conf new file mode 100644 index 0000000..47e7402 --- /dev/null +++ b/gbp.conf @@ -0,0 +1,4 @@ +[DEFAULT] +debian-branch = debian/master +upstream-branch = upstream/latest +pristine-tar = True diff --git a/gimp-gutenprint.docs b/gimp-gutenprint.docs new file mode 100644 index 0000000..7610b61 --- /dev/null +++ b/gimp-gutenprint.docs @@ -0,0 +1,3 @@ +README +doc/*.html +doc/*.png diff --git a/gimp-gutenprint.install b/gimp-gutenprint.install new file mode 100644 index 0000000..935c55d --- /dev/null +++ b/gimp-gutenprint.install @@ -0,0 +1,2 @@ +usr/lib/gimp/2.0/plug-ins/gutenprint +samples/*.png usr/share/doc/gutenprint/samples diff --git a/gutenprint-doc.doc-base b/gutenprint-doc.doc-base new file mode 100644 index 0000000..19738f2 --- /dev/null +++ b/gutenprint-doc.doc-base @@ -0,0 +1,11 @@ +Document: gutenprint-doc +Title: Gutenprint 5.2 User's Manual +Author: Robert Krawitz +Abstract: Gutenprint is a set of printer drivers written to take + advantage of the full capabilities of a wide range of printers. This + document explaina how to configure and use the Gutenprint software to + achieve high quality printouts. +Section: Graphics + +Format: PDF +Files: /usr/share/doc/gutenprint-doc/gutenprint-users-manual.pdf diff --git a/gutenprint-doc.install b/gutenprint-doc.install new file mode 100644 index 0000000..1950f64 --- /dev/null +++ b/gutenprint-doc.install @@ -0,0 +1,2 @@ +usr/share/gutenprint/doc/gutenprint-users-manual.pdf usr/share/doc/gutenprint-doc +usr/share/gutenprint/doc/gutenprint-users-manual.odt usr/share/doc/gutenprint-doc diff --git a/gutenprint-locales.install b/gutenprint-locales.install new file mode 100644 index 0000000..3635480 --- /dev/null +++ b/gutenprint-locales.install @@ -0,0 +1 @@ +usr/share/locale diff --git a/libgutenprint-dev.docs b/libgutenprint-dev.docs new file mode 100644 index 0000000..0b55f7f --- /dev/null +++ b/libgutenprint-dev.docs @@ -0,0 +1,2 @@ +README +doc/FAQ.html diff --git a/libgutenprint-dev.install b/libgutenprint-dev.install new file mode 100644 index 0000000..cce42ee --- /dev/null +++ b/libgutenprint-dev.install @@ -0,0 +1,3 @@ +usr/lib/*/libgutenprint.so +usr/lib/*/pkgconfig/gutenprint.pc +usr/include/gutenprint diff --git a/libgutenprint-doc.doc-base.developer b/libgutenprint-doc.doc-base.developer new file mode 100644 index 0000000..9b968ad --- /dev/null +++ b/libgutenprint-doc.doc-base.developer @@ -0,0 +1,15 @@ +Document: libgutenprint-doc-developer +Title: The libgutenprint Reference Manual +Author: The Gutenprint Project +Abstract: The gutenprint library routines give programmers an interface to + print high quality bitmap images on most modern printers. It includes drivers + which provide printing quality for UNIX/Linux on a par with proprietary + vendor-supplied drivers in many cases, and can be used for many of the most + demanding printing tasks. This manual covers developing programs that use + libgutenprint for printing, as well as the concepts and internals of the + library. +Section: Programming/C + +Format: HTML +Index: /usr/share/doc/libgutenprint-doc/developer/html/index.html +Files: /usr/share/doc/libgutenprint-doc/developer/html/*.html diff --git a/libgutenprint-doc.doc-base.reference b/libgutenprint-doc.doc-base.reference new file mode 100644 index 0000000..99c43cf --- /dev/null +++ b/libgutenprint-doc.doc-base.reference @@ -0,0 +1,14 @@ +Document: libgutenprint-doc-reference +Title: The libgutenprint API Reference Manual +Author: The Gutenprint Project +Abstract: The gutenprint library routines give programmers an interface to + print high quality bitmap images on most modern printers. It includes drivers + which provide printing quality for UNIX/Linux on a par with proprietary + vendor-supplied drivers in many cases, and can be used for many of the most + demanding printing tasks. This manual is a reference to the libgutenprint + library. +Section: Programming/C + +Format: HTML +Index: /usr/share/doc/libgutenprint-doc/reference/html/index.html +Files: /usr/share/doc/libgutenprint-doc/reference/html/*.html diff --git a/libgutenprint-doc.install b/libgutenprint-doc.install new file mode 100644 index 0000000..2864212 --- /dev/null +++ b/libgutenprint-doc.install @@ -0,0 +1,2 @@ +doc/developer/reference-html/* usr/share/doc/libgutenprint-doc/developer/html +doc/gutenprint/* usr/share/doc/libgutenprint-doc/reference diff --git a/libgutenprint-doc.links b/libgutenprint-doc.links new file mode 100644 index 0000000..58415bd --- /dev/null +++ b/libgutenprint-doc.links @@ -0,0 +1 @@ +/usr/share/javascript/jquery/jquery.min.js usr/share/doc/libgutenprint-doc/reference/html/jquery.js diff --git a/libgutenprint2.docs b/libgutenprint2.docs new file mode 100644 index 0000000..e845566 --- /dev/null +++ b/libgutenprint2.docs @@ -0,0 +1 @@ +README diff --git a/libgutenprint2.install b/libgutenprint2.install new file mode 100644 index 0000000..4e7fa63 --- /dev/null +++ b/libgutenprint2.install @@ -0,0 +1,3 @@ +usr/lib/*/libgutenprint.so.* +usr/lib/*/gutenprint +usr/share/gutenprint/5.2 diff --git a/libgutenprintui2-1.install b/libgutenprintui2-1.install new file mode 100644 index 0000000..e2a1354 --- /dev/null +++ b/libgutenprintui2-1.install @@ -0,0 +1 @@ +usr/lib/*/libgutenprintui2.so.* diff --git a/libgutenprintui2-dev.install b/libgutenprintui2-dev.install new file mode 100644 index 0000000..f0df560 --- /dev/null +++ b/libgutenprintui2-dev.install @@ -0,0 +1,3 @@ +usr/lib/*/libgutenprintui2.so +usr/lib/*/pkgconfig/gutenprintui2.pc +usr/include/gutenprintui2 diff --git a/libgutenprintui2-dev.maintscript b/libgutenprintui2-dev.maintscript new file mode 100644 index 0000000..215eafc --- /dev/null +++ b/libgutenprintui2-dev.maintscript @@ -0,0 +1 @@ +dir_to_symlink /usr/share/doc/libgutenprintui2-dev /usr/share/doc/libgutenprintui2-1 5.2.10-1~ diff --git a/missing-sources/jquery.js b/missing-sources/jquery.js new file mode 100644 index 0000000..8ccd0ea --- /dev/null +++ b/missing-sources/jquery.js @@ -0,0 +1,9266 @@ +/*! + * jQuery JavaScript Library v1.7.1 + * http://jquery.com/ + * + * Copyright 2011, John Resig + * Dual licensed under the MIT or GPL Version 2 licenses. + * http://jquery.org/license + * + * Includes Sizzle.js + * http://sizzlejs.com/ + * Copyright 2011, The Dojo Foundation + * Released under the MIT, BSD, and GPL Licenses. + * + * Date: Mon Nov 21 21:11:03 2011 -0500 + */ +(function( window, undefined ) { + +// Use the correct document accordingly with window argument (sandbox) +var document = window.document, + navigator = window.navigator, + location = window.location; +var jQuery = (function() { + +// Define a local copy of jQuery +var jQuery = function( selector, context ) { + // The jQuery object is actually just the init constructor 'enhanced' + return new jQuery.fn.init( selector, context, rootjQuery ); + }, + + // Map over jQuery in case of overwrite + _jQuery = window.jQuery, + + // Map over the $ in case of overwrite + _$ = window.$, + + // A central reference to the root jQuery(document) + rootjQuery, + + // A simple way to check for HTML strings or ID strings + // Prioritize #id over to avoid XSS via location.hash (#9521) + quickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/, + + // Check if a string has a non-whitespace character in it + rnotwhite = /\S/, + + // Used for trimming whitespace + trimLeft = /^\s+/, + trimRight = /\s+$/, + + // Match a standalone tag + rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/, + + // JSON RegExp + rvalidchars = /^[\],:{}\s]*$/, + rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, + rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, + rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g, + + // Useragent RegExp + rwebkit = /(webkit)[ \/]([\w.]+)/, + ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/, + rmsie = /(msie) ([\w.]+)/, + rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/, + + // Matches dashed string for camelizing + rdashAlpha = /-([a-z]|[0-9])/ig, + rmsPrefix = /^-ms-/, + + // Used by jQuery.camelCase as callback to replace() + fcamelCase = function( all, letter ) { + return ( letter + "" ).toUpperCase(); + }, + + // Keep a UserAgent string for use with jQuery.browser + userAgent = navigator.userAgent, + + // For matching the engine and version of the browser + browserMatch, + + // The deferred used on DOM ready + readyList, + + // The ready event handler + DOMContentLoaded, + + // Save a reference to some core methods + toString = Object.prototype.toString, + hasOwn = Object.prototype.hasOwnProperty, + push = Array.prototype.push, + slice = Array.prototype.slice, + trim = String.prototype.trim, + indexOf = Array.prototype.indexOf, + + // [[Class]] -> type pairs + class2type = {}; + +jQuery.fn = jQuery.prototype = { + constructor: jQuery, + init: function( selector, context, rootjQuery ) { + var match, elem, ret, doc; + + // Handle $(""), $(null), or $(undefined) + if ( !selector ) { + return this; + } + + // Handle $(DOMElement) + if ( selector.nodeType ) { + this.context = this[0] = selector; + this.length = 1; + return this; + } + + // The body element only exists once, optimize finding it + if ( selector === "body" && !context && document.body ) { + this.context = document; + this[0] = document.body; + this.selector = selector; + this.length = 1; + return this; + } + + // Handle HTML strings + if ( typeof selector === "string" ) { + // Are we dealing with HTML string or an ID? + if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) { + // Assume that strings that start and end with <> are HTML and skip the regex check + match = [ null, selector, null ]; + + } else { + match = quickExpr.exec( selector ); + } + + // Verify a match, and that no context was specified for #id + if ( match && (match[1] || !context) ) { + + // HANDLE: $(html) -> $(array) + if ( match[1] ) { + context = context instanceof jQuery ? context[0] : context; + doc = ( context ? context.ownerDocument || context : document ); + + // If a single string is passed in and it's a single tag + // just do a createElement and skip the rest + ret = rsingleTag.exec( selector ); + + if ( ret ) { + if ( jQuery.isPlainObject( context ) ) { + selector = [ document.createElement( ret[1] ) ]; + jQuery.fn.attr.call( selector, context, true ); + + } else { + selector = [ doc.createElement( ret[1] ) ]; + } + + } else { + ret = jQuery.buildFragment( [ match[1] ], [ doc ] ); + selector = ( ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment ).childNodes; + } + + return jQuery.merge( this, selector ); + + // HANDLE: $("#id") + } else { + elem = document.getElementById( match[2] ); + + // Check parentNode to catch when Blackberry 4.6 returns + // nodes that are no longer in the document #6963 + if ( elem && elem.parentNode ) { + // Handle the case where IE and Opera return items + // by name instead of ID + if ( elem.id !== match[2] ) { + return rootjQuery.find( selector ); + } + + // Otherwise, we inject the element directly into the jQuery object + this.length = 1; + this[0] = elem; + } + + this.context = document; + this.selector = selector; + return this; + } + + // HANDLE: $(expr, $(...)) + } else if ( !context || context.jquery ) { + return ( context || rootjQuery ).find( selector ); + + // HANDLE: $(expr, context) + // (which is just equivalent to: $(context).find(expr) + } else { + return this.constructor( context ).find( selector ); + } + + // HANDLE: $(function) + // Shortcut for document ready + } else if ( jQuery.isFunction( selector ) ) { + return rootjQuery.ready( selector ); + } + + if ( selector.selector !== undefined ) { + this.selector = selector.selector; + this.context = selector.context; + } + + return jQuery.makeArray( selector, this ); + }, + + // Start with an empty selector + selector: "", + + // The current version of jQuery being used + jquery: "1.7.1", + + // The default length of a jQuery object is 0 + length: 0, + + // The number of elements contained in the matched element set + size: function() { + return this.length; + }, + + toArray: function() { + return slice.call( this, 0 ); + }, + + // Get the Nth element in the matched element set OR + // Get the whole matched element set as a clean array + get: function( num ) { + return num == null ? + + // Return a 'clean' array + this.toArray() : + + // Return just the object + ( num < 0 ? this[ this.length + num ] : this[ num ] ); + }, + + // Take an array of elements and push it onto the stack + // (returning the new matched element set) + pushStack: function( elems, name, selector ) { + // Build a new jQuery matched element set + var ret = this.constructor(); + + if ( jQuery.isArray( elems ) ) { + push.apply( ret, elems ); + + } else { + jQuery.merge( ret, elems ); + } + + // Add the old object onto the stack (as a reference) + ret.prevObject = this; + + ret.context = this.context; + + if ( name === "find" ) { + ret.selector = this.selector + ( this.selector ? " " : "" ) + selector; + } else if ( name ) { + ret.selector = this.selector + "." + name + "(" + selector + ")"; + } + + // Return the newly-formed element set + return ret; + }, + + // Execute a callback for every element in the matched set. + // (You can seed the arguments with an array of args, but this is + // only used internally.) + each: function( callback, args ) { + return jQuery.each( this, callback, args ); + }, + + ready: function( fn ) { + // Attach the listeners + jQuery.bindReady(); + + // Add the callback + readyList.add( fn ); + + return this; + }, + + eq: function( i ) { + i = +i; + return i === -1 ? + this.slice( i ) : + this.slice( i, i + 1 ); + }, + + first: function() { + return this.eq( 0 ); + }, + + last: function() { + return this.eq( -1 ); + }, + + slice: function() { + return this.pushStack( slice.apply( this, arguments ), + "slice", slice.call(arguments).join(",") ); + }, + + map: function( callback ) { + return this.pushStack( jQuery.map(this, function( elem, i ) { + return callback.call( elem, i, elem ); + })); + }, + + end: function() { + return this.prevObject || this.constructor(null); + }, + + // For internal use only. + // Behaves like an Array's method, not like a jQuery method. + push: push, + sort: [].sort, + splice: [].splice +}; + +// Give the init function the jQuery prototype for later instantiation +jQuery.fn.init.prototype = jQuery.fn; + +jQuery.extend = jQuery.fn.extend = function() { + var options, name, src, copy, copyIsArray, clone, + target = arguments[0] || {}, + i = 1, + length = arguments.length, + deep = false; + + // Handle a deep copy situation + if ( typeof target === "boolean" ) { + deep = target; + target = arguments[1] || {}; + // skip the boolean and the target + i = 2; + } + + // Handle case when target is a string or something (possible in deep copy) + if ( typeof target !== "object" && !jQuery.isFunction(target) ) { + target = {}; + } + + // extend jQuery itself if only one argument is passed + if ( length === i ) { + target = this; + --i; + } + + for ( ; i < length; i++ ) { + // Only deal with non-null/undefined values + if ( (options = arguments[ i ]) != null ) { + // Extend the base object + for ( name in options ) { + src = target[ name ]; + copy = options[ name ]; + + // Prevent never-ending loop + if ( target === copy ) { + continue; + } + + // Recurse if we're merging plain objects or arrays + if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) { + if ( copyIsArray ) { + copyIsArray = false; + clone = src && jQuery.isArray(src) ? src : []; + + } else { + clone = src && jQuery.isPlainObject(src) ? src : {}; + } + + // Never move original objects, clone them + target[ name ] = jQuery.extend( deep, clone, copy ); + + // Don't bring in undefined values + } else if ( copy !== undefined ) { + target[ name ] = copy; + } + } + } + } + + // Return the modified object + return target; +}; + +jQuery.extend({ + noConflict: function( deep ) { + if ( window.$ === jQuery ) { + window.$ = _$; + } + + if ( deep && window.jQuery === jQuery ) { + window.jQuery = _jQuery; + } + + return jQuery; + }, + + // Is the DOM ready to be used? Set to true once it occurs. + isReady: false, + + // A counter to track how many items to wait for before + // the ready event fires. See #6781 + readyWait: 1, + + // Hold (or release) the ready event + holdReady: function( hold ) { + if ( hold ) { + jQuery.readyWait++; + } else { + jQuery.ready( true ); + } + }, + + // Handle when the DOM is ready + ready: function( wait ) { + // Either a released hold or an DOMready/load event and not yet ready + if ( (wait === true && !--jQuery.readyWait) || (wait !== true && !jQuery.isReady) ) { + // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443). + if ( !document.body ) { + return setTimeout( jQuery.ready, 1 ); + } + + // Remember that the DOM is ready + jQuery.isReady = true; + + // If a normal DOM Ready event fired, decrement, and wait if need be + if ( wait !== true && --jQuery.readyWait > 0 ) { + return; + } + + // If there are functions bound, to execute + readyList.fireWith( document, [ jQuery ] ); + + // Trigger any bound ready events + if ( jQuery.fn.trigger ) { + jQuery( document ).trigger( "ready" ).off( "ready" ); + } + } + }, + + bindReady: function() { + if ( readyList ) { + return; + } + + readyList = jQuery.Callbacks( "once memory" ); + + // Catch cases where $(document).ready() is called after the + // browser event has already occurred. + if ( document.readyState === "complete" ) { + // Handle it asynchronously to allow scripts the opportunity to delay ready + return setTimeout( jQuery.ready, 1 ); + } + + // Mozilla, Opera and webkit nightlies currently support this event + if ( document.addEventListener ) { + // Use the handy event callback + document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false ); + + // A fallback to window.onload, that will always work + window.addEventListener( "load", jQuery.ready, false ); + + // If IE event model is used + } else if ( document.attachEvent ) { + // ensure firing before onload, + // maybe late but safe also for iframes + document.attachEvent( "onreadystatechange", DOMContentLoaded ); + + // A fallback to window.onload, that will always work + window.attachEvent( "onload", jQuery.ready ); + + // If IE and not a frame + // continually check to see if the document is ready + var toplevel = false; + + try { + toplevel = window.frameElement == null; + } catch(e) {} + + if ( document.documentElement.doScroll && toplevel ) { + doScrollCheck(); + } + } + }, + + // See test/unit/core.js for details concerning isFunction. + // Since version 1.3, DOM methods and functions like alert + // aren't supported. They return false on IE (#2968). + isFunction: function( obj ) { + return jQuery.type(obj) === "function"; + }, + + isArray: Array.isArray || function( obj ) { + return jQuery.type(obj) === "array"; + }, + + // A crude way of determining if an object is a window + isWindow: function( obj ) { + return obj && typeof obj === "object" && "setInterval" in obj; + }, + + isNumeric: function( obj ) { + return !isNaN( parseFloat(obj) ) && isFinite( obj ); + }, + + type: function( obj ) { + return obj == null ? + String( obj ) : + class2type[ toString.call(obj) ] || "object"; + }, + + isPlainObject: function( obj ) { + // Must be an Object. + // Because of IE, we also have to check the presence of the constructor property. + // Make sure that DOM nodes and window objects don't pass through, as well + if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) { + return false; + } + + try { + // Not own constructor property must be Object + if ( obj.constructor && + !hasOwn.call(obj, "constructor") && + !hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) { + return false; + } + } catch ( e ) { + // IE8,9 Will throw exceptions on certain host objects #9897 + return false; + } + + // Own properties are enumerated firstly, so to speed up, + // if last one is own, then all properties are own. + + var key; + for ( key in obj ) {} + + return key === undefined || hasOwn.call( obj, key ); + }, + + isEmptyObject: function( obj ) { + for ( var name in obj ) { + return false; + } + return true; + }, + + error: function( msg ) { + throw new Error( msg ); + }, + + parseJSON: function( data ) { + if ( typeof data !== "string" || !data ) { + return null; + } + + // Make sure leading/trailing whitespace is removed (IE can't handle it) + data = jQuery.trim( data ); + + // Attempt to parse using the native JSON parser first + if ( window.JSON && window.JSON.parse ) { + return window.JSON.parse( data ); + } + + // Make sure the incoming data is actual JSON + // Logic borrowed from http://json.org/json2.js + if ( rvalidchars.test( data.replace( rvalidescape, "@" ) + .replace( rvalidtokens, "]" ) + .replace( rvalidbraces, "")) ) { + + return ( new Function( "return " + data ) )(); + + } + jQuery.error( "Invalid JSON: " + data ); + }, + + // Cross-browser xml parsing + parseXML: function( data ) { + var xml, tmp; + try { + if ( window.DOMParser ) { // Standard + tmp = new DOMParser(); + xml = tmp.parseFromString( data , "text/xml" ); + } else { // IE + xml = new ActiveXObject( "Microsoft.XMLDOM" ); + xml.async = "false"; + xml.loadXML( data ); + } + } catch( e ) { + xml = undefined; + } + if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) { + jQuery.error( "Invalid XML: " + data ); + } + return xml; + }, + + noop: function() {}, + + // Evaluates a script in a global context + // Workarounds based on findings by Jim Driscoll + // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context + globalEval: function( data ) { + if ( data && rnotwhite.test( data ) ) { + // We use execScript on Internet Explorer + // We use an anonymous function so that context is window + // rather than jQuery in Firefox + ( window.execScript || function( data ) { + window[ "eval" ].call( window, data ); + } )( data ); + } + }, + + // Convert dashed to camelCase; used by the css and data modules + // Microsoft forgot to hump their vendor prefix (#9572) + camelCase: function( string ) { + return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase ); + }, + + nodeName: function( elem, name ) { + return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase(); + }, + + // args is for internal usage only + each: function( object, callback, args ) { + var name, i = 0, + length = object.length, + isObj = length === undefined || jQuery.isFunction( object ); + + if ( args ) { + if ( isObj ) { + for ( name in object ) { + if ( callback.apply( object[ name ], args ) === false ) { + break; + } + } + } else { + for ( ; i < length; ) { + if ( callback.apply( object[ i++ ], args ) === false ) { + break; + } + } + } + + // A special, fast, case for the most common use of each + } else { + if ( isObj ) { + for ( name in object ) { + if ( callback.call( object[ name ], name, object[ name ] ) === false ) { + break; + } + } + } else { + for ( ; i < length; ) { + if ( callback.call( object[ i ], i, object[ i++ ] ) === false ) { + break; + } + } + } + } + + return object; + }, + + // Use native String.trim function wherever possible + trim: trim ? + function( text ) { + return text == null ? + "" : + trim.call( text ); + } : + + // Otherwise use our own trimming functionality + function( text ) { + return text == null ? + "" : + text.toString().replace( trimLeft, "" ).replace( trimRight, "" ); + }, + + // results is for internal usage only + makeArray: function( array, results ) { + var ret = results || []; + + if ( array != null ) { + // The window, strings (and functions) also have 'length' + // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930 + var type = jQuery.type( array ); + + if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) { + push.call( ret, array ); + } else { + jQuery.merge( ret, array ); + } + } + + return ret; + }, + + inArray: function( elem, array, i ) { + var len; + + if ( array ) { + if ( indexOf ) { + return indexOf.call( array, elem, i ); + } + + len = array.length; + i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0; + + for ( ; i < len; i++ ) { + // Skip accessing in sparse arrays + if ( i in array && array[ i ] === elem ) { + return i; + } + } + } + + return -1; + }, + + merge: function( first, second ) { + var i = first.length, + j = 0; + + if ( typeof second.length === "number" ) { + for ( var l = second.length; j < l; j++ ) { + first[ i++ ] = second[ j ]; + } + + } else { + while ( second[j] !== undefined ) { + first[ i++ ] = second[ j++ ]; + } + } + + first.length = i; + + return first; + }, + + grep: function( elems, callback, inv ) { + var ret = [], retVal; + inv = !!inv; + + // Go through the array, only saving the items + // that pass the validator function + for ( var i = 0, length = elems.length; i < length; i++ ) { + retVal = !!callback( elems[ i ], i ); + if ( inv !== retVal ) { + ret.push( elems[ i ] ); + } + } + + return ret; + }, + + // arg is for internal usage only + map: function( elems, callback, arg ) { + var value, key, ret = [], + i = 0, + length = elems.length, + // jquery objects are treated as arrays + isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ; + + // Go through the array, translating each of the items to their + if ( isArray ) { + for ( ; i < length; i++ ) { + value = callback( elems[ i ], i, arg ); + + if ( value != null ) { + ret[ ret.length ] = value; + } + } + + // Go through every key on the object, + } else { + for ( key in elems ) { + value = callback( elems[ key ], key, arg ); + + if ( value != null ) { + ret[ ret.length ] = value; + } + } + } + + // Flatten any nested arrays + return ret.concat.apply( [], ret ); + }, + + // A global GUID counter for objects + guid: 1, + + // Bind a function to a context, optionally partially applying any + // arguments. + proxy: function( fn, context ) { + if ( typeof context === "string" ) { + var tmp = fn[ context ]; + context = fn; + fn = tmp; + } + + // Quick check to determine if target is callable, in the spec + // this throws a TypeError, but we will just return undefined. + if ( !jQuery.isFunction( fn ) ) { + return undefined; + } + + // Simulated bind + var args = slice.call( arguments, 2 ), + proxy = function() { + return fn.apply( context, args.concat( slice.call( arguments ) ) ); + }; + + // Set the guid of unique handler to the same of original handler, so it can be removed + proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++; + + return proxy; + }, + + // Mutifunctional method to get and set values to a collection + // The value/s can optionally be executed if it's a function + access: function( elems, key, value, exec, fn, pass ) { + var length = elems.length; + + // Setting many attributes + if ( typeof key === "object" ) { + for ( var k in key ) { + jQuery.access( elems, k, key[k], exec, fn, value ); + } + return elems; + } + + // Setting one attribute + if ( value !== undefined ) { + // Optionally, function values get executed if exec is true + exec = !pass && exec && jQuery.isFunction(value); + + for ( var i = 0; i < length; i++ ) { + fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass ); + } + + return elems; + } + + // Getting an attribute + return length ? fn( elems[0], key ) : undefined; + }, + + now: function() { + return ( new Date() ).getTime(); + }, + + // Use of jQuery.browser is frowned upon. + // More details: http://docs.jquery.com/Utilities/jQuery.browser + uaMatch: function( ua ) { + ua = ua.toLowerCase(); + + var match = rwebkit.exec( ua ) || + ropera.exec( ua ) || + rmsie.exec( ua ) || + ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) || + []; + + return { browser: match[1] || "", version: match[2] || "0" }; + }, + + sub: function() { + function jQuerySub( selector, context ) { + return new jQuerySub.fn.init( selector, context ); + } + jQuery.extend( true, jQuerySub, this ); + jQuerySub.superclass = this; + jQuerySub.fn = jQuerySub.prototype = this(); + jQuerySub.fn.constructor = jQuerySub; + jQuerySub.sub = this.sub; + jQuerySub.fn.init = function init( selector, context ) { + if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) { + context = jQuerySub( context ); + } + + return jQuery.fn.init.call( this, selector, context, rootjQuerySub ); + }; + jQuerySub.fn.init.prototype = jQuerySub.fn; + var rootjQuerySub = jQuerySub(document); + return jQuerySub; + }, + + browser: {} +}); + +// Populate the class2type map +jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) { + class2type[ "[object " + name + "]" ] = name.toLowerCase(); +}); + +browserMatch = jQuery.uaMatch( userAgent ); +if ( browserMatch.browser ) { + jQuery.browser[ browserMatch.browser ] = true; + jQuery.browser.version = browserMatch.version; +} + +// Deprecated, use jQuery.browser.webkit instead +if ( jQuery.browser.webkit ) { + jQuery.browser.safari = true; +} + +// IE doesn't match non-breaking spaces with \s +if ( rnotwhite.test( "\xA0" ) ) { + trimLeft = /^[\s\xA0]+/; + trimRight = /[\s\xA0]+$/; +} + +// All jQuery objects should point back to these +rootjQuery = jQuery(document); + +// Cleanup functions for the document ready method +if ( document.addEventListener ) { + DOMContentLoaded = function() { + document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false ); + jQuery.ready(); + }; + +} else if ( document.attachEvent ) { + DOMContentLoaded = function() { + // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443). + if ( document.readyState === "complete" ) { + document.detachEvent( "onreadystatechange", DOMContentLoaded ); + jQuery.ready(); + } + }; +} + +// The DOM ready check for Internet Explorer +function doScrollCheck() { + if ( jQuery.isReady ) { + return; + } + + try { + // If IE is used, use the trick by Diego Perini + // http://javascript.nwbox.com/IEContentLoaded/ + document.documentElement.doScroll("left"); + } catch(e) { + setTimeout( doScrollCheck, 1 ); + return; + } + + // and execute any waiting functions + jQuery.ready(); +} + +return jQuery; + +})(); + + +// String to Object flags format cache +var flagsCache = {}; + +// Convert String-formatted flags into Object-formatted ones and store in cache +function createFlags( flags ) { + var object = flagsCache[ flags ] = {}, + i, length; + flags = flags.split( /\s+/ ); + for ( i = 0, length = flags.length; i < length; i++ ) { + object[ flags[i] ] = true; + } + return object; +} + +/* + * Create a callback list using the following parameters: + * + * flags: an optional list of space-separated flags that will change how + * the callback list behaves + * + * By default a callback list will act like an event callback list and can be + * "fired" multiple times. + * + * Possible flags: + * + * once: will ensure the callback list can only be fired once (like a Deferred) + * + * memory: will keep track of previous values and will call any callback added + * after the list has been fired right away with the latest "memorized" + * values (like a Deferred) + * + * unique: will ensure a callback can only be added once (no duplicate in the list) + * + * stopOnFalse: interrupt callings when a callback returns false + * + */ +jQuery.Callbacks = function( flags ) { + + // Convert flags from String-formatted to Object-formatted + // (we check in cache first) + flags = flags ? ( flagsCache[ flags ] || createFlags( flags ) ) : {}; + + var // Actual callback list + list = [], + // Stack of fire calls for repeatable lists + stack = [], + // Last fire value (for non-forgettable lists) + memory, + // Flag to know if list is currently firing + firing, + // First callback to fire (used internally by add and fireWith) + firingStart, + // End of the loop when firing + firingLength, + // Index of currently firing callback (modified by remove if needed) + firingIndex, + // Add one or several callbacks to the list + add = function( args ) { + var i, + length, + elem, + type, + actual; + for ( i = 0, length = args.length; i < length; i++ ) { + elem = args[ i ]; + type = jQuery.type( elem ); + if ( type === "array" ) { + // Inspect recursively + add( elem ); + } else if ( type === "function" ) { + // Add if not in unique mode and callback is not in + if ( !flags.unique || !self.has( elem ) ) { + list.push( elem ); + } + } + } + }, + // Fire callbacks + fire = function( context, args ) { + args = args || []; + memory = !flags.memory || [ context, args ]; + firing = true; + firingIndex = firingStart || 0; + firingStart = 0; + firingLength = list.length; + for ( ; list && firingIndex < firingLength; firingIndex++ ) { + if ( list[ firingIndex ].apply( context, args ) === false && flags.stopOnFalse ) { + memory = true; // Mark as halted + break; + } + } + firing = false; + if ( list ) { + if ( !flags.once ) { + if ( stack && stack.length ) { + memory = stack.shift(); + self.fireWith( memory[ 0 ], memory[ 1 ] ); + } + } else if ( memory === true ) { + self.disable(); + } else { + list = []; + } + } + }, + // Actual Callbacks object + self = { + // Add a callback or a collection of callbacks to the list + add: function() { + if ( list ) { + var length = list.length; + add( arguments ); + // Do we need to add the callbacks to the + // current firing batch? + if ( firing ) { + firingLength = list.length; + // With memory, if we're not firing then + // we should call right away, unless previous + // firing was halted (stopOnFalse) + } else if ( memory && memory !== true ) { + firingStart = length; + fire( memory[ 0 ], memory[ 1 ] ); + } + } + return this; + }, + // Remove a callback from the list + remove: function() { + if ( list ) { + var args = arguments, + argIndex = 0, + argLength = args.length; + for ( ; argIndex < argLength ; argIndex++ ) { + for ( var i = 0; i < list.length; i++ ) { + if ( args[ argIndex ] === list[ i ] ) { + // Handle firingIndex and firingLength + if ( firing ) { + if ( i <= firingLength ) { + firingLength--; + if ( i <= firingIndex ) { + firingIndex--; + } + } + } + // Remove the element + list.splice( i--, 1 ); + // If we have some unicity property then + // we only need to do this once + if ( flags.unique ) { + break; + } + } + } + } + } + return this; + }, + // Control if a given callback is in the list + has: function( fn ) { + if ( list ) { + var i = 0, + length = list.length; + for ( ; i < length; i++ ) { + if ( fn === list[ i ] ) { + return true; + } + } + } + return false; + }, + // Remove all callbacks from the list + empty: function() { + list = []; + return this; + }, + // Have the list do nothing anymore + disable: function() { + list = stack = memory = undefined; + return this; + }, + // Is it disabled? + disabled: function() { + return !list; + }, + // Lock the list in its current state + lock: function() { + stack = undefined; + if ( !memory || memory === true ) { + self.disable(); + } + return this; + }, + // Is it locked? + locked: function() { + return !stack; + }, + // Call all callbacks with the given context and arguments + fireWith: function( context, args ) { + if ( stack ) { + if ( firing ) { + if ( !flags.once ) { + stack.push( [ context, args ] ); + } + } else if ( !( flags.once && memory ) ) { + fire( context, args ); + } + } + return this; + }, + // Call all the callbacks with the given arguments + fire: function() { + self.fireWith( this, arguments ); + return this; + }, + // To know if the callbacks have already been called at least once + fired: function() { + return !!memory; + } + }; + + return self; +}; + + + + +var // Static reference to slice + sliceDeferred = [].slice; + +jQuery.extend({ + + Deferred: function( func ) { + var doneList = jQuery.Callbacks( "once memory" ), + failList = jQuery.Callbacks( "once memory" ), + progressList = jQuery.Callbacks( "memory" ), + state = "pending", + lists = { + resolve: doneList, + reject: failList, + notify: progressList + }, + promise = { + done: doneList.add, + fail: failList.add, + progress: progressList.add, + + state: function() { + return state; + }, + + // Deprecated + isResolved: doneList.fired, + isRejected: failList.fired, + + then: function( doneCallbacks, failCallbacks, progressCallbacks ) { + deferred.done( doneCallbacks ).fail( failCallbacks ).progress( progressCallbacks ); + return this; + }, + always: function() { + deferred.done.apply( deferred, arguments ).fail.apply( deferred, arguments ); + return this; + }, + pipe: function( fnDone, fnFail, fnProgress ) { + return jQuery.Deferred(function( newDefer ) { + jQuery.each( { + done: [ fnDone, "resolve" ], + fail: [ fnFail, "reject" ], + progress: [ fnProgress, "notify" ] + }, function( handler, data ) { + var fn = data[ 0 ], + action = data[ 1 ], + returned; + if ( jQuery.isFunction( fn ) ) { + deferred[ handler ](function() { + returned = fn.apply( this, arguments ); + if ( returned && jQuery.isFunction( returned.promise ) ) { + returned.promise().then( newDefer.resolve, newDefer.reject, newDefer.notify ); + } else { + newDefer[ action + "With" ]( this === deferred ? newDefer : this, [ returned ] ); + } + }); + } else { + deferred[ handler ]( newDefer[ action ] ); + } + }); + }).promise(); + }, + // Get a promise for this deferred + // If obj is provided, the promise aspect is added to the object + promise: function( obj ) { + if ( obj == null ) { + obj = promise; + } else { + for ( var key in promise ) { + obj[ key ] = promise[ key ]; + } + } + return obj; + } + }, + deferred = promise.promise({}), + key; + + for ( key in lists ) { + deferred[ key ] = lists[ key ].fire; + deferred[ key + "With" ] = lists[ key ].fireWith; + } + + // Handle state + deferred.done( function() { + state = "resolved"; + }, failList.disable, progressList.lock ).fail( function() { + state = "rejected"; + }, doneList.disable, progressList.lock ); + + // Call given func if any + if ( func ) { + func.call( deferred, deferred ); + } + + // All done! + return deferred; + }, + + // Deferred helper + when: function( firstParam ) { + var args = sliceDeferred.call( arguments, 0 ), + i = 0, + length = args.length, + pValues = new Array( length ), + count = length, + pCount = length, + deferred = length <= 1 && firstParam && jQuery.isFunction( firstParam.promise ) ? + firstParam : + jQuery.Deferred(), + promise = deferred.promise(); + function resolveFunc( i ) { + return function( value ) { + args[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value; + if ( !( --count ) ) { + deferred.resolveWith( deferred, args ); + } + }; + } + function progressFunc( i ) { + return function( value ) { + pValues[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value; + deferred.notifyWith( promise, pValues ); + }; + } + if ( length > 1 ) { + for ( ; i < length; i++ ) { + if ( args[ i ] && args[ i ].promise && jQuery.isFunction( args[ i ].promise ) ) { + args[ i ].promise().then( resolveFunc(i), deferred.reject, progressFunc(i) ); + } else { + --count; + } + } + if ( !count ) { + deferred.resolveWith( deferred, args ); + } + } else if ( deferred !== firstParam ) { + deferred.resolveWith( deferred, length ? [ firstParam ] : [] ); + } + return promise; + } +}); + + + + +jQuery.support = (function() { + + var support, + all, + a, + select, + opt, + input, + marginDiv, + fragment, + tds, + events, + eventName, + i, + isSupported, + div = document.createElement( "div" ), + documentElement = document.documentElement; + + // Preliminary tests + div.setAttribute("className", "t"); + div.innerHTML = "
a"; + + all = div.getElementsByTagName( "*" ); + a = div.getElementsByTagName( "a" )[ 0 ]; + + // Can't get basic test support + if ( !all || !all.length || !a ) { + return {}; + } + + // First batch of supports tests + select = document.createElement( "select" ); + opt = select.appendChild( document.createElement("option") ); + input = div.getElementsByTagName( "input" )[ 0 ]; + + support = { + // IE strips leading whitespace when .innerHTML is used + leadingWhitespace: ( div.firstChild.nodeType === 3 ), + + // Make sure that tbody elements aren't automatically inserted + // IE will insert them into empty tables + tbody: !div.getElementsByTagName("tbody").length, + + // Make sure that link elements get serialized correctly by innerHTML + // This requires a wrapper element in IE + htmlSerialize: !!div.getElementsByTagName("link").length, + + // Get the style information from getAttribute + // (IE uses .cssText instead) + style: /top/.test( a.getAttribute("style") ), + + // Make sure that URLs aren't manipulated + // (IE normalizes it by default) + hrefNormalized: ( a.getAttribute("href") === "/a" ), + + // Make sure that element opacity exists + // (IE uses filter instead) + // Use a regex to work around a WebKit issue. See #5145 + opacity: /^0.55/.test( a.style.opacity ), + + // Verify style float existence + // (IE uses styleFloat instead of cssFloat) + cssFloat: !!a.style.cssFloat, + + // Make sure that if no value is specified for a checkbox + // that it defaults to "on". + // (WebKit defaults to "" instead) + checkOn: ( input.value === "on" ), + + // Make sure that a selected-by-default option has a working selected property. + // (WebKit defaults to false instead of true, IE too, if it's in an optgroup) + optSelected: opt.selected, + + // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7) + getSetAttribute: div.className !== "t", + + // Tests for enctype support on a form(#6743) + enctype: !!document.createElement("form").enctype, + + // Makes sure cloning an html5 element does not cause problems + // Where outerHTML is undefined, this still works + html5Clone: document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav>", + + // Will be defined later + submitBubbles: true, + changeBubbles: true, + focusinBubbles: false, + deleteExpando: true, + noCloneEvent: true, + inlineBlockNeedsLayout: false, + shrinkWrapBlocks: false, + reliableMarginRight: true + }; + + // Make sure checked status is properly cloned + input.checked = true; + support.noCloneChecked = input.cloneNode( true ).checked; + + // Make sure that the options inside disabled selects aren't marked as disabled + // (WebKit marks them as disabled) + select.disabled = true; + support.optDisabled = !opt.disabled; + + // Test to see if it's possible to delete an expando from an element + // Fails in Internet Explorer + try { + delete div.test; + } catch( e ) { + support.deleteExpando = false; + } + + if ( !div.addEventListener && div.attachEvent && div.fireEvent ) { + div.attachEvent( "onclick", function() { + // Cloning a node shouldn't copy over any + // bound event handlers (IE does this) + support.noCloneEvent = false; + }); + div.cloneNode( true ).fireEvent( "onclick" ); + } + + // Check if a radio maintains its value + // after being appended to the DOM + input = document.createElement("input"); + input.value = "t"; + input.setAttribute("type", "radio"); + support.radioValue = input.value === "t"; + + input.setAttribute("checked", "checked"); + div.appendChild( input ); + fragment = document.createDocumentFragment(); + fragment.appendChild( div.lastChild ); + + // WebKit doesn't clone checked state correctly in fragments + support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked; + + // Check if a disconnected checkbox will retain its checked + // value of true after appended to the DOM (IE6/7) + support.appendChecked = input.checked; + + fragment.removeChild( input ); + fragment.appendChild( div ); + + div.innerHTML = ""; + + // Check if div with explicit width and no margin-right incorrectly + // gets computed margin-right based on width of container. For more + // info see bug #3333 + // Fails in WebKit before Feb 2011 nightlies + // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right + if ( window.getComputedStyle ) { + marginDiv = document.createElement( "div" ); + marginDiv.style.width = "0"; + marginDiv.style.marginRight = "0"; + div.style.width = "2px"; + div.appendChild( marginDiv ); + support.reliableMarginRight = + ( parseInt( ( window.getComputedStyle( marginDiv, null ) || { marginRight: 0 } ).marginRight, 10 ) || 0 ) === 0; + } + + // Technique from Juriy Zaytsev + // http://perfectionkills.com/detecting-event-support-without-browser-sniffing/ + // We only care about the case where non-standard event systems + // are used, namely in IE. Short-circuiting here helps us to + // avoid an eval call (in setAttribute) which can cause CSP + // to go haywire. See: https://developer.mozilla.org/en/Security/CSP + if ( div.attachEvent ) { + for( i in { + submit: 1, + change: 1, + focusin: 1 + }) { + eventName = "on" + i; + isSupported = ( eventName in div ); + if ( !isSupported ) { + div.setAttribute( eventName, "return;" ); + isSupported = ( typeof div[ eventName ] === "function" ); + } + support[ i + "Bubbles" ] = isSupported; + } + } + + fragment.removeChild( div ); + + // Null elements to avoid leaks in IE + fragment = select = opt = marginDiv = div = input = null; + + // Run tests that need a body at doc ready + jQuery(function() { + var container, outer, inner, table, td, offsetSupport, + conMarginTop, ptlm, vb, style, html, + body = document.getElementsByTagName("body")[0]; + + if ( !body ) { + // Return for frameset docs that don't have a body + return; + } + + conMarginTop = 1; + ptlm = "position:absolute;top:0;left:0;width:1px;height:1px;margin:0;"; + vb = "visibility:hidden;border:0;"; + style = "style='" + ptlm + "border:5px solid #000;padding:0;'"; + html = "
" + + "" + + "
"; + + container = document.createElement("div"); + container.style.cssText = vb + "width:0;height:0;position:static;top:0;margin-top:" + conMarginTop + "px"; + body.insertBefore( container, body.firstChild ); + + // Construct the test element + div = document.createElement("div"); + container.appendChild( div ); + + // Check if table cells still have offsetWidth/Height when they are set + // to display:none and there are still other visible table cells in a + // table row; if so, offsetWidth/Height are not reliable for use when + // determining if an element has been hidden directly using + // display:none (it is still safe to use offsets if a parent element is + // hidden; don safety goggles and see bug #4512 for more information). + // (only IE 8 fails this test) + div.innerHTML = "
t
"; + tds = div.getElementsByTagName( "td" ); + isSupported = ( tds[ 0 ].offsetHeight === 0 ); + + tds[ 0 ].style.display = ""; + tds[ 1 ].style.display = "none"; + + // Check if empty table cells still have offsetWidth/Height + // (IE <= 8 fail this test) + support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 ); + + // Figure out if the W3C box model works as expected + div.innerHTML = ""; + div.style.width = div.style.paddingLeft = "1px"; + jQuery.boxModel = support.boxModel = div.offsetWidth === 2; + + if ( typeof div.style.zoom !== "undefined" ) { + // Check if natively block-level elements act like inline-block + // elements when setting their display to 'inline' and giving + // them layout + // (IE < 8 does this) + div.style.display = "inline"; + div.style.zoom = 1; + support.inlineBlockNeedsLayout = ( div.offsetWidth === 2 ); + + // Check if elements with layout shrink-wrap their children + // (IE 6 does this) + div.style.display = ""; + div.innerHTML = "
"; + support.shrinkWrapBlocks = ( div.offsetWidth !== 2 ); + } + + div.style.cssText = ptlm + vb; + div.innerHTML = html; + + outer = div.firstChild; + inner = outer.firstChild; + td = outer.nextSibling.firstChild.firstChild; + + offsetSupport = { + doesNotAddBorder: ( inner.offsetTop !== 5 ), + doesAddBorderForTableAndCells: ( td.offsetTop === 5 ) + }; + + inner.style.position = "fixed"; + inner.style.top = "20px"; + + // safari subtracts parent border width here which is 5px + offsetSupport.fixedPosition = ( inner.offsetTop === 20 || inner.offsetTop === 15 ); + inner.style.position = inner.style.top = ""; + + outer.style.overflow = "hidden"; + outer.style.position = "relative"; + + offsetSupport.subtractsBorderForOverflowNotVisible = ( inner.offsetTop === -5 ); + offsetSupport.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== conMarginTop ); + + body.removeChild( container ); + div = container = null; + + jQuery.extend( support, offsetSupport ); + }); + + return support; +})(); + + + + +var rbrace = /^(?:\{.*\}|\[.*\])$/, + rmultiDash = /([A-Z])/g; + +jQuery.extend({ + cache: {}, + + // Please use with caution + uuid: 0, + + // Unique for each copy of jQuery on the page + // Non-digits removed to match rinlinejQuery + expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ), + + // The following elements throw uncatchable exceptions if you + // attempt to add expando properties to them. + noData: { + "embed": true, + // Ban all objects except for Flash (which handle expandos) + "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000", + "applet": true + }, + + hasData: function( elem ) { + elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ]; + return !!elem && !isEmptyDataObject( elem ); + }, + + data: function( elem, name, data, pvt /* Internal Use Only */ ) { + if ( !jQuery.acceptData( elem ) ) { + return; + } + + var privateCache, thisCache, ret, + internalKey = jQuery.expando, + getByName = typeof name === "string", + + // We have to handle DOM nodes and JS objects differently because IE6-7 + // can't GC object references properly across the DOM-JS boundary + isNode = elem.nodeType, + + // Only DOM nodes need the global jQuery cache; JS object data is + // attached directly to the object so GC can occur automatically + cache = isNode ? jQuery.cache : elem, + + // Only defining an ID for JS objects if its cache already exists allows + // the code to shortcut on the same path as a DOM node with no cache + id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey, + isEvents = name === "events"; + + // Avoid doing any more work than we need to when trying to get data on an + // object that has no data at all + if ( (!id || !cache[id] || (!isEvents && !pvt && !cache[id].data)) && getByName && data === undefined ) { + return; + } + + if ( !id ) { + // Only DOM nodes need a new unique ID for each element since their data + // ends up in the global cache + if ( isNode ) { + elem[ internalKey ] = id = ++jQuery.uuid; + } else { + id = internalKey; + } + } + + if ( !cache[ id ] ) { + cache[ id ] = {}; + + // Avoids exposing jQuery metadata on plain JS objects when the object + // is serialized using JSON.stringify + if ( !isNode ) { + cache[ id ].toJSON = jQuery.noop; + } + } + + // An object can be passed to jQuery.data instead of a key/value pair; this gets + // shallow copied over onto the existing cache + if ( typeof name === "object" || typeof name === "function" ) { + if ( pvt ) { + cache[ id ] = jQuery.extend( cache[ id ], name ); + } else { + cache[ id ].data = jQuery.extend( cache[ id ].data, name ); + } + } + + privateCache = thisCache = cache[ id ]; + + // jQuery data() is stored in a separate object inside the object's internal data + // cache in order to avoid key collisions between internal data and user-defined + // data. + if ( !pvt ) { + if ( !thisCache.data ) { + thisCache.data = {}; + } + + thisCache = thisCache.data; + } + + if ( data !== undefined ) { + thisCache[ jQuery.camelCase( name ) ] = data; + } + + // Users should not attempt to inspect the internal events object using jQuery.data, + // it is undocumented and subject to change. But does anyone listen? No. + if ( isEvents && !thisCache[ name ] ) { + return privateCache.events; + } + + // Check for both converted-to-camel and non-converted data property names + // If a data property was specified + if ( getByName ) { + + // First Try to find as-is property data + ret = thisCache[ name ]; + + // Test for null|undefined property data + if ( ret == null ) { + + // Try to find the camelCased property + ret = thisCache[ jQuery.camelCase( name ) ]; + } + } else { + ret = thisCache; + } + + return ret; + }, + + removeData: function( elem, name, pvt /* Internal Use Only */ ) { + if ( !jQuery.acceptData( elem ) ) { + return; + } + + var thisCache, i, l, + + // Reference to internal data cache key + internalKey = jQuery.expando, + + isNode = elem.nodeType, + + // See jQuery.data for more information + cache = isNode ? jQuery.cache : elem, + + // See jQuery.data for more information + id = isNode ? elem[ internalKey ] : internalKey; + + // If there is already no cache entry for this object, there is no + // purpose in continuing + if ( !cache[ id ] ) { + return; + } + + if ( name ) { + + thisCache = pvt ? cache[ id ] : cache[ id ].data; + + if ( thisCache ) { + + // Support array or space separated string names for data keys + if ( !jQuery.isArray( name ) ) { + + // try the string as a key before any manipulation + if ( name in thisCache ) { + name = [ name ]; + } else { + + // split the camel cased version by spaces unless a key with the spaces exists + name = jQuery.camelCase( name ); + if ( name in thisCache ) { + name = [ name ]; + } else { + name = name.split( " " ); + } + } + } + + for ( i = 0, l = name.length; i < l; i++ ) { + delete thisCache[ name[i] ]; + } + + // If there is no data left in the cache, we want to continue + // and let the cache object itself get destroyed + if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) { + return; + } + } + } + + // See jQuery.data for more information + if ( !pvt ) { + delete cache[ id ].data; + + // Don't destroy the parent cache unless the internal data object + // had been the only thing left in it + if ( !isEmptyDataObject(cache[ id ]) ) { + return; + } + } + + // Browsers that fail expando deletion also refuse to delete expandos on + // the window, but it will allow it on all other JS objects; other browsers + // don't care + // Ensure that `cache` is not a window object #10080 + if ( jQuery.support.deleteExpando || !cache.setInterval ) { + delete cache[ id ]; + } else { + cache[ id ] = null; + } + + // We destroyed the cache and need to eliminate the expando on the node to avoid + // false lookups in the cache for entries that no longer exist + if ( isNode ) { + // IE does not allow us to delete expando properties from nodes, + // nor does it have a removeAttribute function on Document nodes; + // we must handle all of these cases + if ( jQuery.support.deleteExpando ) { + delete elem[ internalKey ]; + } else if ( elem.removeAttribute ) { + elem.removeAttribute( internalKey ); + } else { + elem[ internalKey ] = null; + } + } + }, + + // For internal use only. + _data: function( elem, name, data ) { + return jQuery.data( elem, name, data, true ); + }, + + // A method for determining if a DOM node can handle the data expando + acceptData: function( elem ) { + if ( elem.nodeName ) { + var match = jQuery.noData[ elem.nodeName.toLowerCase() ]; + + if ( match ) { + return !(match === true || elem.getAttribute("classid") !== match); + } + } + + return true; + } +}); + +jQuery.fn.extend({ + data: function( key, value ) { + var parts, attr, name, + data = null; + + if ( typeof key === "undefined" ) { + if ( this.length ) { + data = jQuery.data( this[0] ); + + if ( this[0].nodeType === 1 && !jQuery._data( this[0], "parsedAttrs" ) ) { + attr = this[0].attributes; + for ( var i = 0, l = attr.length; i < l; i++ ) { + name = attr[i].name; + + if ( name.indexOf( "data-" ) === 0 ) { + name = jQuery.camelCase( name.substring(5) ); + + dataAttr( this[0], name, data[ name ] ); + } + } + jQuery._data( this[0], "parsedAttrs", true ); + } + } + + return data; + + } else if ( typeof key === "object" ) { + return this.each(function() { + jQuery.data( this, key ); + }); + } + + parts = key.split("."); + parts[1] = parts[1] ? "." + parts[1] : ""; + + if ( value === undefined ) { + data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]); + + // Try to fetch any internally stored data first + if ( data === undefined && this.length ) { + data = jQuery.data( this[0], key ); + data = dataAttr( this[0], key, data ); + } + + return data === undefined && parts[1] ? + this.data( parts[0] ) : + data; + + } else { + return this.each(function() { + var self = jQuery( this ), + args = [ parts[0], value ]; + + self.triggerHandler( "setData" + parts[1] + "!", args ); + jQuery.data( this, key, value ); + self.triggerHandler( "changeData" + parts[1] + "!", args ); + }); + } + }, + + removeData: function( key ) { + return this.each(function() { + jQuery.removeData( this, key ); + }); + } +}); + +function dataAttr( elem, key, data ) { + // If nothing was found internally, try to fetch any + // data from the HTML5 data-* attribute + if ( data === undefined && elem.nodeType === 1 ) { + + var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase(); + + data = elem.getAttribute( name ); + + if ( typeof data === "string" ) { + try { + data = data === "true" ? true : + data === "false" ? false : + data === "null" ? null : + jQuery.isNumeric( data ) ? parseFloat( data ) : + rbrace.test( data ) ? jQuery.parseJSON( data ) : + data; + } catch( e ) {} + + // Make sure we set the data so it isn't changed later + jQuery.data( elem, key, data ); + + } else { + data = undefined; + } + } + + return data; +} + +// checks a cache object for emptiness +function isEmptyDataObject( obj ) { + for ( var name in obj ) { + + // if the public data object is empty, the private is still empty + if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) { + continue; + } + if ( name !== "toJSON" ) { + return false; + } + } + + return true; +} + + + + +function handleQueueMarkDefer( elem, type, src ) { + var deferDataKey = type + "defer", + queueDataKey = type + "queue", + markDataKey = type + "mark", + defer = jQuery._data( elem, deferDataKey ); + if ( defer && + ( src === "queue" || !jQuery._data(elem, queueDataKey) ) && + ( src === "mark" || !jQuery._data(elem, markDataKey) ) ) { + // Give room for hard-coded callbacks to fire first + // and eventually mark/queue something else on the element + setTimeout( function() { + if ( !jQuery._data( elem, queueDataKey ) && + !jQuery._data( elem, markDataKey ) ) { + jQuery.removeData( elem, deferDataKey, true ); + defer.fire(); + } + }, 0 ); + } +} + +jQuery.extend({ + + _mark: function( elem, type ) { + if ( elem ) { + type = ( type || "fx" ) + "mark"; + jQuery._data( elem, type, (jQuery._data( elem, type ) || 0) + 1 ); + } + }, + + _unmark: function( force, elem, type ) { + if ( force !== true ) { + type = elem; + elem = force; + force = false; + } + if ( elem ) { + type = type || "fx"; + var key = type + "mark", + count = force ? 0 : ( (jQuery._data( elem, key ) || 1) - 1 ); + if ( count ) { + jQuery._data( elem, key, count ); + } else { + jQuery.removeData( elem, key, true ); + handleQueueMarkDefer( elem, type, "mark" ); + } + } + }, + + queue: function( elem, type, data ) { + var q; + if ( elem ) { + type = ( type || "fx" ) + "queue"; + q = jQuery._data( elem, type ); + + // Speed up dequeue by getting out quickly if this is just a lookup + if ( data ) { + if ( !q || jQuery.isArray(data) ) { + q = jQuery._data( elem, type, jQuery.makeArray(data) ); + } else { + q.push( data ); + } + } + return q || []; + } + }, + + dequeue: function( elem, type ) { + type = type || "fx"; + + var queue = jQuery.queue( elem, type ), + fn = queue.shift(), + hooks = {}; + + // If the fx queue is dequeued, always remove the progress sentinel + if ( fn === "inprogress" ) { + fn = queue.shift(); + } + + if ( fn ) { + // Add a progress sentinel to prevent the fx queue from being + // automatically dequeued + if ( type === "fx" ) { + queue.unshift( "inprogress" ); + } + + jQuery._data( elem, type + ".run", hooks ); + fn.call( elem, function() { + jQuery.dequeue( elem, type ); + }, hooks ); + } + + if ( !queue.length ) { + jQuery.removeData( elem, type + "queue " + type + ".run", true ); + handleQueueMarkDefer( elem, type, "queue" ); + } + } +}); + +jQuery.fn.extend({ + queue: function( type, data ) { + if ( typeof type !== "string" ) { + data = type; + type = "fx"; + } + + if ( data === undefined ) { + return jQuery.queue( this[0], type ); + } + return this.each(function() { + var queue = jQuery.queue( this, type, data ); + + if ( type === "fx" && queue[0] !== "inprogress" ) { + jQuery.dequeue( this, type ); + } + }); + }, + dequeue: function( type ) { + return this.each(function() { + jQuery.dequeue( this, type ); + }); + }, + // Based off of the plugin by Clint Helfers, with permission. + // http://blindsignals.com/index.php/2009/07/jquery-delay/ + delay: function( time, type ) { + time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time; + type = type || "fx"; + + return this.queue( type, function( next, hooks ) { + var timeout = setTimeout( next, time ); + hooks.stop = function() { + clearTimeout( timeout ); + }; + }); + }, + clearQueue: function( type ) { + return this.queue( type || "fx", [] ); + }, + // Get a promise resolved when queues of a certain type + // are emptied (fx is the type by default) + promise: function( type, object ) { + if ( typeof type !== "string" ) { + object = type; + type = undefined; + } + type = type || "fx"; + var defer = jQuery.Deferred(), + elements = this, + i = elements.length, + count = 1, + deferDataKey = type + "defer", + queueDataKey = type + "queue", + markDataKey = type + "mark", + tmp; + function resolve() { + if ( !( --count ) ) { + defer.resolveWith( elements, [ elements ] ); + } + } + while( i-- ) { + if (( tmp = jQuery.data( elements[ i ], deferDataKey, undefined, true ) || + ( jQuery.data( elements[ i ], queueDataKey, undefined, true ) || + jQuery.data( elements[ i ], markDataKey, undefined, true ) ) && + jQuery.data( elements[ i ], deferDataKey, jQuery.Callbacks( "once memory" ), true ) )) { + count++; + tmp.add( resolve ); + } + } + resolve(); + return defer.promise(); + } +}); + + + + +var rclass = /[\n\t\r]/g, + rspace = /\s+/, + rreturn = /\r/g, + rtype = /^(?:button|input)$/i, + rfocusable = /^(?:button|input|object|select|textarea)$/i, + rclickable = /^a(?:rea)?$/i, + rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i, + getSetAttribute = jQuery.support.getSetAttribute, + nodeHook, boolHook, fixSpecified; + +jQuery.fn.extend({ + attr: function( name, value ) { + return jQuery.access( this, name, value, true, jQuery.attr ); + }, + + removeAttr: function( name ) { + return this.each(function() { + jQuery.removeAttr( this, name ); + }); + }, + + prop: function( name, value ) { + return jQuery.access( this, name, value, true, jQuery.prop ); + }, + + removeProp: function( name ) { + name = jQuery.propFix[ name ] || name; + return this.each(function() { + // try/catch handles cases where IE balks (such as removing a property on window) + try { + this[ name ] = undefined; + delete this[ name ]; + } catch( e ) {} + }); + }, + + addClass: function( value ) { + var classNames, i, l, elem, + setClass, c, cl; + + if ( jQuery.isFunction( value ) ) { + return this.each(function( j ) { + jQuery( this ).addClass( value.call(this, j, this.className) ); + }); + } + + if ( value && typeof value === "string" ) { + classNames = value.split( rspace ); + + for ( i = 0, l = this.length; i < l; i++ ) { + elem = this[ i ]; + + if ( elem.nodeType === 1 ) { + if ( !elem.className && classNames.length === 1 ) { + elem.className = value; + + } else { + setClass = " " + elem.className + " "; + + for ( c = 0, cl = classNames.length; c < cl; c++ ) { + if ( !~setClass.indexOf( " " + classNames[ c ] + " " ) ) { + setClass += classNames[ c ] + " "; + } + } + elem.className = jQuery.trim( setClass ); + } + } + } + } + + return this; + }, + + removeClass: function( value ) { + var classNames, i, l, elem, className, c, cl; + + if ( jQuery.isFunction( value ) ) { + return this.each(function( j ) { + jQuery( this ).removeClass( value.call(this, j, this.className) ); + }); + } + + if ( (value && typeof value === "string") || value === undefined ) { + classNames = ( value || "" ).split( rspace ); + + for ( i = 0, l = this.length; i < l; i++ ) { + elem = this[ i ]; + + if ( elem.nodeType === 1 && elem.className ) { + if ( value ) { + className = (" " + elem.className + " ").replace( rclass, " " ); + for ( c = 0, cl = classNames.length; c < cl; c++ ) { + className = className.replace(" " + classNames[ c ] + " ", " "); + } + elem.className = jQuery.trim( className ); + + } else { + elem.className = ""; + } + } + } + } + + return this; + }, + + toggleClass: function( value, stateVal ) { + var type = typeof value, + isBool = typeof stateVal === "boolean"; + + if ( jQuery.isFunction( value ) ) { + return this.each(function( i ) { + jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal ); + }); + } + + return this.each(function() { + if ( type === "string" ) { + // toggle individual class names + var className, + i = 0, + self = jQuery( this ), + state = stateVal, + classNames = value.split( rspace ); + + while ( (className = classNames[ i++ ]) ) { + // check each className given, space seperated list + state = isBool ? state : !self.hasClass( className ); + self[ state ? "addClass" : "removeClass" ]( className ); + } + + } else if ( type === "undefined" || type === "boolean" ) { + if ( this.className ) { + // store className if set + jQuery._data( this, "__className__", this.className ); + } + + // toggle whole className + this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || ""; + } + }); + }, + + hasClass: function( selector ) { + var className = " " + selector + " ", + i = 0, + l = this.length; + for ( ; i < l; i++ ) { + if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) { + return true; + } + } + + return false; + }, + + val: function( value ) { + var hooks, ret, isFunction, + elem = this[0]; + + if ( !arguments.length ) { + if ( elem ) { + hooks = jQuery.valHooks[ elem.nodeName.toLowerCase() ] || jQuery.valHooks[ elem.type ]; + + if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) { + return ret; + } + + ret = elem.value; + + return typeof ret === "string" ? + // handle most common string cases + ret.replace(rreturn, "") : + // handle cases where value is null/undef or number + ret == null ? "" : ret; + } + + return; + } + + isFunction = jQuery.isFunction( value ); + + return this.each(function( i ) { + var self = jQuery(this), val; + + if ( this.nodeType !== 1 ) { + return; + } + + if ( isFunction ) { + val = value.call( this, i, self.val() ); + } else { + val = value; + } + + // Treat null/undefined as ""; convert numbers to string + if ( val == null ) { + val = ""; + } else if ( typeof val === "number" ) { + val += ""; + } else if ( jQuery.isArray( val ) ) { + val = jQuery.map(val, function ( value ) { + return value == null ? "" : value + ""; + }); + } + + hooks = jQuery.valHooks[ this.nodeName.toLowerCase() ] || jQuery.valHooks[ this.type ]; + + // If set returns undefined, fall back to normal setting + if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) { + this.value = val; + } + }); + } +}); + +jQuery.extend({ + valHooks: { + option: { + get: function( elem ) { + // attributes.value is undefined in Blackberry 4.7 but + // uses .value. See #6932 + var val = elem.attributes.value; + return !val || val.specified ? elem.value : elem.text; + } + }, + select: { + get: function( elem ) { + var value, i, max, option, + index = elem.selectedIndex, + values = [], + options = elem.options, + one = elem.type === "select-one"; + + // Nothing was selected + if ( index < 0 ) { + return null; + } + + // Loop through all the selected options + i = one ? index : 0; + max = one ? index + 1 : options.length; + for ( ; i < max; i++ ) { + option = options[ i ]; + + // Don't return options that are disabled or in a disabled optgroup + if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) && + (!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) { + + // Get the specific value for the option + value = jQuery( option ).val(); + + // We don't need an array for one selects + if ( one ) { + return value; + } + + // Multi-Selects return an array + values.push( value ); + } + } + + // Fixes Bug #2551 -- select.val() broken in IE after form.reset() + if ( one && !values.length && options.length ) { + return jQuery( options[ index ] ).val(); + } + + return values; + }, + + set: function( elem, value ) { + var values = jQuery.makeArray( value ); + + jQuery(elem).find("option").each(function() { + this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0; + }); + + if ( !values.length ) { + elem.selectedIndex = -1; + } + return values; + } + } + }, + + attrFn: { + val: true, + css: true, + html: true, + text: true, + data: true, + width: true, + height: true, + offset: true + }, + + attr: function( elem, name, value, pass ) { + var ret, hooks, notxml, + nType = elem.nodeType; + + // don't get/set attributes on text, comment and attribute nodes + if ( !elem || nType === 3 || nType === 8 || nType === 2 ) { + return; + } + + if ( pass && name in jQuery.attrFn ) { + return jQuery( elem )[ name ]( value ); + } + + // Fallback to prop when attributes are not supported + if ( typeof elem.getAttribute === "undefined" ) { + return jQuery.prop( elem, name, value ); + } + + notxml = nType !== 1 || !jQuery.isXMLDoc( elem ); + + // All attributes are lowercase + // Grab necessary hook if one is defined + if ( notxml ) { + name = name.toLowerCase(); + hooks = jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook ); + } + + if ( value !== undefined ) { + + if ( value === null ) { + jQuery.removeAttr( elem, name ); + return; + + } else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) { + return ret; + + } else { + elem.setAttribute( name, "" + value ); + return value; + } + + } else if ( hooks && "get" in hooks && notxml && (ret = hooks.get( elem, name )) !== null ) { + return ret; + + } else { + + ret = elem.getAttribute( name ); + + // Non-existent attributes return null, we normalize to undefined + return ret === null ? + undefined : + ret; + } + }, + + removeAttr: function( elem, value ) { + var propName, attrNames, name, l, + i = 0; + + if ( value && elem.nodeType === 1 ) { + attrNames = value.toLowerCase().split( rspace ); + l = attrNames.length; + + for ( ; i < l; i++ ) { + name = attrNames[ i ]; + + if ( name ) { + propName = jQuery.propFix[ name ] || name; + + // See #9699 for explanation of this approach (setting first, then removal) + jQuery.attr( elem, name, "" ); + elem.removeAttribute( getSetAttribute ? name : propName ); + + // Set corresponding property to false for boolean attributes + if ( rboolean.test( name ) && propName in elem ) { + elem[ propName ] = false; + } + } + } + } + }, + + attrHooks: { + type: { + set: function( elem, value ) { + // We can't allow the type property to be changed (since it causes problems in IE) + if ( rtype.test( elem.nodeName ) && elem.parentNode ) { + jQuery.error( "type property can't be changed" ); + } else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) { + // Setting the type on a radio button after the value resets the value in IE6-9 + // Reset value to it's default in case type is set after value + // This is for element creation + var val = elem.value; + elem.setAttribute( "type", value ); + if ( val ) { + elem.value = val; + } + return value; + } + } + }, + // Use the value property for back compat + // Use the nodeHook for button elements in IE6/7 (#1954) + value: { + get: function( elem, name ) { + if ( nodeHook && jQuery.nodeName( elem, "button" ) ) { + return nodeHook.get( elem, name ); + } + return name in elem ? + elem.value : + null; + }, + set: function( elem, value, name ) { + if ( nodeHook && jQuery.nodeName( elem, "button" ) ) { + return nodeHook.set( elem, value, name ); + } + // Does not return so that setAttribute is also used + elem.value = value; + } + } + }, + + propFix: { + tabindex: "tabIndex", + readonly: "readOnly", + "for": "htmlFor", + "class": "className", + maxlength: "maxLength", + cellspacing: "cellSpacing", + cellpadding: "cellPadding", + rowspan: "rowSpan", + colspan: "colSpan", + usemap: "useMap", + frameborder: "frameBorder", + contenteditable: "contentEditable" + }, + + prop: function( elem, name, value ) { + var ret, hooks, notxml, + nType = elem.nodeType; + + // don't get/set properties on text, comment and attribute nodes + if ( !elem || nType === 3 || nType === 8 || nType === 2 ) { + return; + } + + notxml = nType !== 1 || !jQuery.isXMLDoc( elem ); + + if ( notxml ) { + // Fix name and attach hooks + name = jQuery.propFix[ name ] || name; + hooks = jQuery.propHooks[ name ]; + } + + if ( value !== undefined ) { + if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) { + return ret; + + } else { + return ( elem[ name ] = value ); + } + + } else { + if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) { + return ret; + + } else { + return elem[ name ]; + } + } + }, + + propHooks: { + tabIndex: { + get: function( elem ) { + // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set + // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/ + var attributeNode = elem.getAttributeNode("tabindex"); + + return attributeNode && attributeNode.specified ? + parseInt( attributeNode.value, 10 ) : + rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ? + 0 : + undefined; + } + } + } +}); + +// Add the tabIndex propHook to attrHooks for back-compat (different case is intentional) +jQuery.attrHooks.tabindex = jQuery.propHooks.tabIndex; + +// Hook for boolean attributes +boolHook = { + get: function( elem, name ) { + // Align boolean attributes with corresponding properties + // Fall back to attribute presence where some booleans are not supported + var attrNode, + property = jQuery.prop( elem, name ); + return property === true || typeof property !== "boolean" && ( attrNode = elem.getAttributeNode(name) ) && attrNode.nodeValue !== false ? + name.toLowerCase() : + undefined; + }, + set: function( elem, value, name ) { + var propName; + if ( value === false ) { + // Remove boolean attributes when set to false + jQuery.removeAttr( elem, name ); + } else { + // value is true since we know at this point it's type boolean and not false + // Set boolean attributes to the same name and set the DOM property + propName = jQuery.propFix[ name ] || name; + if ( propName in elem ) { + // Only set the IDL specifically if it already exists on the element + elem[ propName ] = true; + } + + elem.setAttribute( name, name.toLowerCase() ); + } + return name; + } +}; + +// IE6/7 do not support getting/setting some attributes with get/setAttribute +if ( !getSetAttribute ) { + + fixSpecified = { + name: true, + id: true + }; + + // Use this for any attribute in IE6/7 + // This fixes almost every IE6/7 issue + nodeHook = jQuery.valHooks.button = { + get: function( elem, name ) { + var ret; + ret = elem.getAttributeNode( name ); + return ret && ( fixSpecified[ name ] ? ret.nodeValue !== "" : ret.specified ) ? + ret.nodeValue : + undefined; + }, + set: function( elem, value, name ) { + // Set the existing or create a new attribute node + var ret = elem.getAttributeNode( name ); + if ( !ret ) { + ret = document.createAttribute( name ); + elem.setAttributeNode( ret ); + } + return ( ret.nodeValue = value + "" ); + } + }; + + // Apply the nodeHook to tabindex + jQuery.attrHooks.tabindex.set = nodeHook.set; + + // Set width and height to auto instead of 0 on empty string( Bug #8150 ) + // This is for removals + jQuery.each([ "width", "height" ], function( i, name ) { + jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], { + set: function( elem, value ) { + if ( value === "" ) { + elem.setAttribute( name, "auto" ); + return value; + } + } + }); + }); + + // Set contenteditable to false on removals(#10429) + // Setting to empty string throws an error as an invalid value + jQuery.attrHooks.contenteditable = { + get: nodeHook.get, + set: function( elem, value, name ) { + if ( value === "" ) { + value = "false"; + } + nodeHook.set( elem, value, name ); + } + }; +} + + +// Some attributes require a special call on IE +if ( !jQuery.support.hrefNormalized ) { + jQuery.each([ "href", "src", "width", "height" ], function( i, name ) { + jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], { + get: function( elem ) { + var ret = elem.getAttribute( name, 2 ); + return ret === null ? undefined : ret; + } + }); + }); +} + +if ( !jQuery.support.style ) { + jQuery.attrHooks.style = { + get: function( elem ) { + // Return undefined in the case of empty string + // Normalize to lowercase since IE uppercases css property names + return elem.style.cssText.toLowerCase() || undefined; + }, + set: function( elem, value ) { + return ( elem.style.cssText = "" + value ); + } + }; +} + +// Safari mis-reports the default selected property of an option +// Accessing the parent's selectedIndex property fixes it +if ( !jQuery.support.optSelected ) { + jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, { + get: function( elem ) { + var parent = elem.parentNode; + + if ( parent ) { + parent.selectedIndex; + + // Make sure that it also works with optgroups, see #5701 + if ( parent.parentNode ) { + parent.parentNode.selectedIndex; + } + } + return null; + } + }); +} + +// IE6/7 call enctype encoding +if ( !jQuery.support.enctype ) { + jQuery.propFix.enctype = "encoding"; +} + +// Radios and checkboxes getter/setter +if ( !jQuery.support.checkOn ) { + jQuery.each([ "radio", "checkbox" ], function() { + jQuery.valHooks[ this ] = { + get: function( elem ) { + // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified + return elem.getAttribute("value") === null ? "on" : elem.value; + } + }; + }); +} +jQuery.each([ "radio", "checkbox" ], function() { + jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], { + set: function( elem, value ) { + if ( jQuery.isArray( value ) ) { + return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 ); + } + } + }); +}); + + + + +var rformElems = /^(?:textarea|input|select)$/i, + rtypenamespace = /^([^\.]*)?(?:\.(.+))?$/, + rhoverHack = /\bhover(\.\S+)?\b/, + rkeyEvent = /^key/, + rmouseEvent = /^(?:mouse|contextmenu)|click/, + rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, + rquickIs = /^(\w*)(?:#([\w\-]+))?(?:\.([\w\-]+))?$/, + quickParse = function( selector ) { + var quick = rquickIs.exec( selector ); + if ( quick ) { + // 0 1 2 3 + // [ _, tag, id, class ] + quick[1] = ( quick[1] || "" ).toLowerCase(); + quick[3] = quick[3] && new RegExp( "(?:^|\\s)" + quick[3] + "(?:\\s|$)" ); + } + return quick; + }, + quickIs = function( elem, m ) { + var attrs = elem.attributes || {}; + return ( + (!m[1] || elem.nodeName.toLowerCase() === m[1]) && + (!m[2] || (attrs.id || {}).value === m[2]) && + (!m[3] || m[3].test( (attrs[ "class" ] || {}).value )) + ); + }, + hoverHack = function( events ) { + return jQuery.event.special.hover ? events : events.replace( rhoverHack, "mouseenter$1 mouseleave$1" ); + }; + +/* + * Helper functions for managing events -- not part of the public interface. + * Props to Dean Edwards' addEvent library for many of the ideas. + */ +jQuery.event = { + + add: function( elem, types, handler, data, selector ) { + + var elemData, eventHandle, events, + t, tns, type, namespaces, handleObj, + handleObjIn, quick, handlers, special; + + // Don't attach events to noData or text/comment nodes (allow plain objects tho) + if ( elem.nodeType === 3 || elem.nodeType === 8 || !types || !handler || !(elemData = jQuery._data( elem )) ) { + return; + } + + // Caller can pass in an object of custom data in lieu of the handler + if ( handler.handler ) { + handleObjIn = handler; + handler = handleObjIn.handler; + } + + // Make sure that the handler has a unique ID, used to find/remove it later + if ( !handler.guid ) { + handler.guid = jQuery.guid++; + } + + // Init the element's event structure and main handler, if this is the first + events = elemData.events; + if ( !events ) { + elemData.events = events = {}; + } + eventHandle = elemData.handle; + if ( !eventHandle ) { + elemData.handle = eventHandle = function( e ) { + // Discard the second event of a jQuery.event.trigger() and + // when an event is called after a page has unloaded + return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ? + jQuery.event.dispatch.apply( eventHandle.elem, arguments ) : + undefined; + }; + // Add elem as a property of the handle fn to prevent a memory leak with IE non-native events + eventHandle.elem = elem; + } + + // Handle multiple events separated by a space + // jQuery(...).bind("mouseover mouseout", fn); + types = jQuery.trim( hoverHack(types) ).split( " " ); + for ( t = 0; t < types.length; t++ ) { + + tns = rtypenamespace.exec( types[t] ) || []; + type = tns[1]; + namespaces = ( tns[2] || "" ).split( "." ).sort(); + + // If event changes its type, use the special event handlers for the changed type + special = jQuery.event.special[ type ] || {}; + + // If selector defined, determine special event api type, otherwise given type + type = ( selector ? special.delegateType : special.bindType ) || type; + + // Update special based on newly reset type + special = jQuery.event.special[ type ] || {}; + + // handleObj is passed to all event handlers + handleObj = jQuery.extend({ + type: type, + origType: tns[1], + data: data, + handler: handler, + guid: handler.guid, + selector: selector, + quick: quickParse( selector ), + namespace: namespaces.join(".") + }, handleObjIn ); + + // Init the event handler queue if we're the first + handlers = events[ type ]; + if ( !handlers ) { + handlers = events[ type ] = []; + handlers.delegateCount = 0; + + // Only use addEventListener/attachEvent if the special events handler returns false + if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) { + // Bind the global event handler to the element + if ( elem.addEventListener ) { + elem.addEventListener( type, eventHandle, false ); + + } else if ( elem.attachEvent ) { + elem.attachEvent( "on" + type, eventHandle ); + } + } + } + + if ( special.add ) { + special.add.call( elem, handleObj ); + + if ( !handleObj.handler.guid ) { + handleObj.handler.guid = handler.guid; + } + } + + // Add to the element's handler list, delegates in front + if ( selector ) { + handlers.splice( handlers.delegateCount++, 0, handleObj ); + } else { + handlers.push( handleObj ); + } + + // Keep track of which events have ever been used, for event optimization + jQuery.event.global[ type ] = true; + } + + // Nullify elem to prevent memory leaks in IE + elem = null; + }, + + global: {}, + + // Detach an event or set of events from an element + remove: function( elem, types, handler, selector, mappedTypes ) { + + var elemData = jQuery.hasData( elem ) && jQuery._data( elem ), + t, tns, type, origType, namespaces, origCount, + j, events, special, handle, eventType, handleObj; + + if ( !elemData || !(events = elemData.events) ) { + return; + } + + // Once for each type.namespace in types; type may be omitted + types = jQuery.trim( hoverHack( types || "" ) ).split(" "); + for ( t = 0; t < types.length; t++ ) { + tns = rtypenamespace.exec( types[t] ) || []; + type = origType = tns[1]; + namespaces = tns[2]; + + // Unbind all events (on this namespace, if provided) for the element + if ( !type ) { + for ( type in events ) { + jQuery.event.remove( elem, type + types[ t ], handler, selector, true ); + } + continue; + } + + special = jQuery.event.special[ type ] || {}; + type = ( selector? special.delegateType : special.bindType ) || type; + eventType = events[ type ] || []; + origCount = eventType.length; + namespaces = namespaces ? new RegExp("(^|\\.)" + namespaces.split(".").sort().join("\\.(?:.*\\.)?") + "(\\.|$)") : null; + + // Remove matching events + for ( j = 0; j < eventType.length; j++ ) { + handleObj = eventType[ j ]; + + if ( ( mappedTypes || origType === handleObj.origType ) && + ( !handler || handler.guid === handleObj.guid ) && + ( !namespaces || namespaces.test( handleObj.namespace ) ) && + ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) { + eventType.splice( j--, 1 ); + + if ( handleObj.selector ) { + eventType.delegateCount--; + } + if ( special.remove ) { + special.remove.call( elem, handleObj ); + } + } + } + + // Remove generic event handler if we removed something and no more handlers exist + // (avoids potential for endless recursion during removal of special event handlers) + if ( eventType.length === 0 && origCount !== eventType.length ) { + if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) { + jQuery.removeEvent( elem, type, elemData.handle ); + } + + delete events[ type ]; + } + } + + // Remove the expando if it's no longer used + if ( jQuery.isEmptyObject( events ) ) { + handle = elemData.handle; + if ( handle ) { + handle.elem = null; + } + + // removeData also checks for emptiness and clears the expando if empty + // so use it instead of delete + jQuery.removeData( elem, [ "events", "handle" ], true ); + } + }, + + // Events that are safe to short-circuit if no handlers are attached. + // Native DOM events should not be added, they may have inline handlers. + customEvent: { + "getData": true, + "setData": true, + "changeData": true + }, + + trigger: function( event, data, elem, onlyHandlers ) { + // Don't do events on text and comment nodes + if ( elem && (elem.nodeType === 3 || elem.nodeType === 8) ) { + return; + } + + // Event object or event type + var type = event.type || event, + namespaces = [], + cache, exclusive, i, cur, old, ontype, special, handle, eventPath, bubbleType; + + // focus/blur morphs to focusin/out; ensure we're not firing them right now + if ( rfocusMorph.test( type + jQuery.event.triggered ) ) { + return; + } + + if ( type.indexOf( "!" ) >= 0 ) { + // Exclusive events trigger only for the exact event (no namespaces) + type = type.slice(0, -1); + exclusive = true; + } + + if ( type.indexOf( "." ) >= 0 ) { + // Namespaced trigger; create a regexp to match event type in handle() + namespaces = type.split("."); + type = namespaces.shift(); + namespaces.sort(); + } + + if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) { + // No jQuery handlers for this event type, and it can't have inline handlers + return; + } + + // Caller can pass in an Event, Object, or just an event type string + event = typeof event === "object" ? + // jQuery.Event object + event[ jQuery.expando ] ? event : + // Object literal + new jQuery.Event( type, event ) : + // Just the event type (string) + new jQuery.Event( type ); + + event.type = type; + event.isTrigger = true; + event.exclusive = exclusive; + event.namespace = namespaces.join( "." ); + event.namespace_re = event.namespace? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)") : null; + ontype = type.indexOf( ":" ) < 0 ? "on" + type : ""; + + // Handle a global trigger + if ( !elem ) { + + // TODO: Stop taunting the data cache; remove global events and always attach to document + cache = jQuery.cache; + for ( i in cache ) { + if ( cache[ i ].events && cache[ i ].events[ type ] ) { + jQuery.event.trigger( event, data, cache[ i ].handle.elem, true ); + } + } + return; + } + + // Clean up the event in case it is being reused + event.result = undefined; + if ( !event.target ) { + event.target = elem; + } + + // Clone any incoming data and prepend the event, creating the handler arg list + data = data != null ? jQuery.makeArray( data ) : []; + data.unshift( event ); + + // Allow special events to draw outside the lines + special = jQuery.event.special[ type ] || {}; + if ( special.trigger && special.trigger.apply( elem, data ) === false ) { + return; + } + + // Determine event propagation path in advance, per W3C events spec (#9951) + // Bubble up to document, then to window; watch for a global ownerDocument var (#9724) + eventPath = [[ elem, special.bindType || type ]]; + if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) { + + bubbleType = special.delegateType || type; + cur = rfocusMorph.test( bubbleType + type ) ? elem : elem.parentNode; + old = null; + for ( ; cur; cur = cur.parentNode ) { + eventPath.push([ cur, bubbleType ]); + old = cur; + } + + // Only add window if we got to document (e.g., not plain obj or detached DOM) + if ( old && old === elem.ownerDocument ) { + eventPath.push([ old.defaultView || old.parentWindow || window, bubbleType ]); + } + } + + // Fire handlers on the event path + for ( i = 0; i < eventPath.length && !event.isPropagationStopped(); i++ ) { + + cur = eventPath[i][0]; + event.type = eventPath[i][1]; + + handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" ); + if ( handle ) { + handle.apply( cur, data ); + } + // Note that this is a bare JS function and not a jQuery handler + handle = ontype && cur[ ontype ]; + if ( handle && jQuery.acceptData( cur ) && handle.apply( cur, data ) === false ) { + event.preventDefault(); + } + } + event.type = type; + + // If nobody prevented the default action, do it now + if ( !onlyHandlers && !event.isDefaultPrevented() ) { + + if ( (!special._default || special._default.apply( elem.ownerDocument, data ) === false) && + !(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) { + + // Call a native DOM method on the target with the same name name as the event. + // Can't use an .isFunction() check here because IE6/7 fails that test. + // Don't do default actions on window, that's where global variables be (#6170) + // IE<9 dies on focus/blur to hidden element (#1486) + if ( ontype && elem[ type ] && ((type !== "focus" && type !== "blur") || event.target.offsetWidth !== 0) && !jQuery.isWindow( elem ) ) { + + // Don't re-trigger an onFOO event when we call its FOO() method + old = elem[ ontype ]; + + if ( old ) { + elem[ ontype ] = null; + } + + // Prevent re-triggering of the same event, since we already bubbled it above + jQuery.event.triggered = type; + elem[ type ](); + jQuery.event.triggered = undefined; + + if ( old ) { + elem[ ontype ] = old; + } + } + } + } + + return event.result; + }, + + dispatch: function( event ) { + + // Make a writable jQuery.Event from the native event object + event = jQuery.event.fix( event || window.event ); + + var handlers = ( (jQuery._data( this, "events" ) || {} )[ event.type ] || []), + delegateCount = handlers.delegateCount, + args = [].slice.call( arguments, 0 ), + run_all = !event.exclusive && !event.namespace, + handlerQueue = [], + i, j, cur, jqcur, ret, selMatch, matched, matches, handleObj, sel, related; + + // Use the fix-ed jQuery.Event rather than the (read-only) native event + args[0] = event; + event.delegateTarget = this; + + // Determine handlers that should run if there are delegated events + // Avoid disabled elements in IE (#6911) and non-left-click bubbling in Firefox (#3861) + if ( delegateCount && !event.target.disabled && !(event.button && event.type === "click") ) { + + // Pregenerate a single jQuery object for reuse with .is() + jqcur = jQuery(this); + jqcur.context = this.ownerDocument || this; + + for ( cur = event.target; cur != this; cur = cur.parentNode || this ) { + selMatch = {}; + matches = []; + jqcur[0] = cur; + for ( i = 0; i < delegateCount; i++ ) { + handleObj = handlers[ i ]; + sel = handleObj.selector; + + if ( selMatch[ sel ] === undefined ) { + selMatch[ sel ] = ( + handleObj.quick ? quickIs( cur, handleObj.quick ) : jqcur.is( sel ) + ); + } + if ( selMatch[ sel ] ) { + matches.push( handleObj ); + } + } + if ( matches.length ) { + handlerQueue.push({ elem: cur, matches: matches }); + } + } + } + + // Add the remaining (directly-bound) handlers + if ( handlers.length > delegateCount ) { + handlerQueue.push({ elem: this, matches: handlers.slice( delegateCount ) }); + } + + // Run delegates first; they may want to stop propagation beneath us + for ( i = 0; i < handlerQueue.length && !event.isPropagationStopped(); i++ ) { + matched = handlerQueue[ i ]; + event.currentTarget = matched.elem; + + for ( j = 0; j < matched.matches.length && !event.isImmediatePropagationStopped(); j++ ) { + handleObj = matched.matches[ j ]; + + // Triggered event must either 1) be non-exclusive and have no namespace, or + // 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace). + if ( run_all || (!event.namespace && !handleObj.namespace) || event.namespace_re && event.namespace_re.test( handleObj.namespace ) ) { + + event.data = handleObj.data; + event.handleObj = handleObj; + + ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler ) + .apply( matched.elem, args ); + + if ( ret !== undefined ) { + event.result = ret; + if ( ret === false ) { + event.preventDefault(); + event.stopPropagation(); + } + } + } + } + } + + return event.result; + }, + + // Includes some event props shared by KeyEvent and MouseEvent + // *** attrChange attrName relatedNode srcElement are not normalized, non-W3C, deprecated, will be removed in 1.8 *** + props: "attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "), + + fixHooks: {}, + + keyHooks: { + props: "char charCode key keyCode".split(" "), + filter: function( event, original ) { + + // Add which for key events + if ( event.which == null ) { + event.which = original.charCode != null ? original.charCode : original.keyCode; + } + + return event; + } + }, + + mouseHooks: { + props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "), + filter: function( event, original ) { + var eventDoc, doc, body, + button = original.button, + fromElement = original.fromElement; + + // Calculate pageX/Y if missing and clientX/Y available + if ( event.pageX == null && original.clientX != null ) { + eventDoc = event.target.ownerDocument || document; + doc = eventDoc.documentElement; + body = eventDoc.body; + + event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 ); + event.pageY = original.clientY + ( doc && doc.scrollTop || body && body.scrollTop || 0 ) - ( doc && doc.clientTop || body && body.clientTop || 0 ); + } + + // Add relatedTarget, if necessary + if ( !event.relatedTarget && fromElement ) { + event.relatedTarget = fromElement === event.target ? original.toElement : fromElement; + } + + // Add which for click: 1 === left; 2 === middle; 3 === right + // Note: button is not normalized, so don't use it + if ( !event.which && button !== undefined ) { + event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) ); + } + + return event; + } + }, + + fix: function( event ) { + if ( event[ jQuery.expando ] ) { + return event; + } + + // Create a writable copy of the event object and normalize some properties + var i, prop, + originalEvent = event, + fixHook = jQuery.event.fixHooks[ event.type ] || {}, + copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props; + + event = jQuery.Event( originalEvent ); + + for ( i = copy.length; i; ) { + prop = copy[ --i ]; + event[ prop ] = originalEvent[ prop ]; + } + + // Fix target property, if necessary (#1925, IE 6/7/8 & Safari2) + if ( !event.target ) { + event.target = originalEvent.srcElement || document; + } + + // Target should not be a text node (#504, Safari) + if ( event.target.nodeType === 3 ) { + event.target = event.target.parentNode; + } + + // For mouse/key events; add metaKey if it's not there (#3368, IE6/7/8) + if ( event.metaKey === undefined ) { + event.metaKey = event.ctrlKey; + } + + return fixHook.filter? fixHook.filter( event, originalEvent ) : event; + }, + + special: { + ready: { + // Make sure the ready event is setup + setup: jQuery.bindReady + }, + + load: { + // Prevent triggered image.load events from bubbling to window.load + noBubble: true + }, + + focus: { + delegateType: "focusin" + }, + blur: { + delegateType: "focusout" + }, + + beforeunload: { + setup: function( data, namespaces, eventHandle ) { + // We only want to do this special case on windows + if ( jQuery.isWindow( this ) ) { + this.onbeforeunload = eventHandle; + } + }, + + teardown: function( namespaces, eventHandle ) { + if ( this.onbeforeunload === eventHandle ) { + this.onbeforeunload = null; + } + } + } + }, + + simulate: function( type, elem, event, bubble ) { + // Piggyback on a donor event to simulate a different one. + // Fake originalEvent to avoid donor's stopPropagation, but if the + // simulated event prevents default then we do the same on the donor. + var e = jQuery.extend( + new jQuery.Event(), + event, + { type: type, + isSimulated: true, + originalEvent: {} + } + ); + if ( bubble ) { + jQuery.event.trigger( e, null, elem ); + } else { + jQuery.event.dispatch.call( elem, e ); + } + if ( e.isDefaultPrevented() ) { + event.preventDefault(); + } + } +}; + +// Some plugins are using, but it's undocumented/deprecated and will be removed. +// The 1.7 special event interface should provide all the hooks needed now. +jQuery.event.handle = jQuery.event.dispatch; + +jQuery.removeEvent = document.removeEventListener ? + function( elem, type, handle ) { + if ( elem.removeEventListener ) { + elem.removeEventListener( type, handle, false ); + } + } : + function( elem, type, handle ) { + if ( elem.detachEvent ) { + elem.detachEvent( "on" + type, handle ); + } + }; + +jQuery.Event = function( src, props ) { + // Allow instantiation without the 'new' keyword + if ( !(this instanceof jQuery.Event) ) { + return new jQuery.Event( src, props ); + } + + // Event object + if ( src && src.type ) { + this.originalEvent = src; + this.type = src.type; + + // Events bubbling up the document may have been marked as prevented + // by a handler lower down the tree; reflect the correct value. + this.isDefaultPrevented = ( src.defaultPrevented || src.returnValue === false || + src.getPreventDefault && src.getPreventDefault() ) ? returnTrue : returnFalse; + + // Event type + } else { + this.type = src; + } + + // Put explicitly provided properties onto the event object + if ( props ) { + jQuery.extend( this, props ); + } + + // Create a timestamp if incoming event doesn't have one + this.timeStamp = src && src.timeStamp || jQuery.now(); + + // Mark it as fixed + this[ jQuery.expando ] = true; +}; + +function returnFalse() { + return false; +} +function returnTrue() { + return true; +} + +// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding +// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html +jQuery.Event.prototype = { + preventDefault: function() { + this.isDefaultPrevented = returnTrue; + + var e = this.originalEvent; + if ( !e ) { + return; + } + + // if preventDefault exists run it on the original event + if ( e.preventDefault ) { + e.preventDefault(); + + // otherwise set the returnValue property of the original event to false (IE) + } else { + e.returnValue = false; + } + }, + stopPropagation: function() { + this.isPropagationStopped = returnTrue; + + var e = this.originalEvent; + if ( !e ) { + return; + } + // if stopPropagation exists run it on the original event + if ( e.stopPropagation ) { + e.stopPropagation(); + } + // otherwise set the cancelBubble property of the original event to true (IE) + e.cancelBubble = true; + }, + stopImmediatePropagation: function() { + this.isImmediatePropagationStopped = returnTrue; + this.stopPropagation(); + }, + isDefaultPrevented: returnFalse, + isPropagationStopped: returnFalse, + isImmediatePropagationStopped: returnFalse +}; + +// Create mouseenter/leave events using mouseover/out and event-time checks +jQuery.each({ + mouseenter: "mouseover", + mouseleave: "mouseout" +}, function( orig, fix ) { + jQuery.event.special[ orig ] = { + delegateType: fix, + bindType: fix, + + handle: function( event ) { + var target = this, + related = event.relatedTarget, + handleObj = event.handleObj, + selector = handleObj.selector, + ret; + + // For mousenter/leave call the handler if related is outside the target. + // NB: No relatedTarget if the mouse left/entered the browser window + if ( !related || (related !== target && !jQuery.contains( target, related )) ) { + event.type = handleObj.origType; + ret = handleObj.handler.apply( this, arguments ); + event.type = fix; + } + return ret; + } + }; +}); + +// IE submit delegation +if ( !jQuery.support.submitBubbles ) { + + jQuery.event.special.submit = { + setup: function() { + // Only need this for delegated form submit events + if ( jQuery.nodeName( this, "form" ) ) { + return false; + } + + // Lazy-add a submit handler when a descendant form may potentially be submitted + jQuery.event.add( this, "click._submit keypress._submit", function( e ) { + // Node name check avoids a VML-related crash in IE (#9807) + var elem = e.target, + form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.form : undefined; + if ( form && !form._submit_attached ) { + jQuery.event.add( form, "submit._submit", function( event ) { + // If form was submitted by the user, bubble the event up the tree + if ( this.parentNode && !event.isTrigger ) { + jQuery.event.simulate( "submit", this.parentNode, event, true ); + } + }); + form._submit_attached = true; + } + }); + // return undefined since we don't need an event listener + }, + + teardown: function() { + // Only need this for delegated form submit events + if ( jQuery.nodeName( this, "form" ) ) { + return false; + } + + // Remove delegated handlers; cleanData eventually reaps submit handlers attached above + jQuery.event.remove( this, "._submit" ); + } + }; +} + +// IE change delegation and checkbox/radio fix +if ( !jQuery.support.changeBubbles ) { + + jQuery.event.special.change = { + + setup: function() { + + if ( rformElems.test( this.nodeName ) ) { + // IE doesn't fire change on a check/radio until blur; trigger it on click + // after a propertychange. Eat the blur-change in special.change.handle. + // This still fires onchange a second time for check/radio after blur. + if ( this.type === "checkbox" || this.type === "radio" ) { + jQuery.event.add( this, "propertychange._change", function( event ) { + if ( event.originalEvent.propertyName === "checked" ) { + this._just_changed = true; + } + }); + jQuery.event.add( this, "click._change", function( event ) { + if ( this._just_changed && !event.isTrigger ) { + this._just_changed = false; + jQuery.event.simulate( "change", this, event, true ); + } + }); + } + return false; + } + // Delegated event; lazy-add a change handler on descendant inputs + jQuery.event.add( this, "beforeactivate._change", function( e ) { + var elem = e.target; + + if ( rformElems.test( elem.nodeName ) && !elem._change_attached ) { + jQuery.event.add( elem, "change._change", function( event ) { + if ( this.parentNode && !event.isSimulated && !event.isTrigger ) { + jQuery.event.simulate( "change", this.parentNode, event, true ); + } + }); + elem._change_attached = true; + } + }); + }, + + handle: function( event ) { + var elem = event.target; + + // Swallow native change events from checkbox/radio, we already triggered them above + if ( this !== elem || event.isSimulated || event.isTrigger || (elem.type !== "radio" && elem.type !== "checkbox") ) { + return event.handleObj.handler.apply( this, arguments ); + } + }, + + teardown: function() { + jQuery.event.remove( this, "._change" ); + + return rformElems.test( this.nodeName ); + } + }; +} + +// Create "bubbling" focus and blur events +if ( !jQuery.support.focusinBubbles ) { + jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) { + + // Attach a single capturing handler while someone wants focusin/focusout + var attaches = 0, + handler = function( event ) { + jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true ); + }; + + jQuery.event.special[ fix ] = { + setup: function() { + if ( attaches++ === 0 ) { + document.addEventListener( orig, handler, true ); + } + }, + teardown: function() { + if ( --attaches === 0 ) { + document.removeEventListener( orig, handler, true ); + } + } + }; + }); +} + +jQuery.fn.extend({ + + on: function( types, selector, data, fn, /*INTERNAL*/ one ) { + var origFn, type; + + // Types can be a map of types/handlers + if ( typeof types === "object" ) { + // ( types-Object, selector, data ) + if ( typeof selector !== "string" ) { + // ( types-Object, data ) + data = selector; + selector = undefined; + } + for ( type in types ) { + this.on( type, selector, data, types[ type ], one ); + } + return this; + } + + if ( data == null && fn == null ) { + // ( types, fn ) + fn = selector; + data = selector = undefined; + } else if ( fn == null ) { + if ( typeof selector === "string" ) { + // ( types, selector, fn ) + fn = data; + data = undefined; + } else { + // ( types, data, fn ) + fn = data; + data = selector; + selector = undefined; + } + } + if ( fn === false ) { + fn = returnFalse; + } else if ( !fn ) { + return this; + } + + if ( one === 1 ) { + origFn = fn; + fn = function( event ) { + // Can use an empty set, since event contains the info + jQuery().off( event ); + return origFn.apply( this, arguments ); + }; + // Use same guid so caller can remove using origFn + fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ ); + } + return this.each( function() { + jQuery.event.add( this, types, fn, data, selector ); + }); + }, + one: function( types, selector, data, fn ) { + return this.on.call( this, types, selector, data, fn, 1 ); + }, + off: function( types, selector, fn ) { + if ( types && types.preventDefault && types.handleObj ) { + // ( event ) dispatched jQuery.Event + var handleObj = types.handleObj; + jQuery( types.delegateTarget ).off( + handleObj.namespace? handleObj.type + "." + handleObj.namespace : handleObj.type, + handleObj.selector, + handleObj.handler + ); + return this; + } + if ( typeof types === "object" ) { + // ( types-object [, selector] ) + for ( var type in types ) { + this.off( type, selector, types[ type ] ); + } + return this; + } + if ( selector === false || typeof selector === "function" ) { + // ( types [, fn] ) + fn = selector; + selector = undefined; + } + if ( fn === false ) { + fn = returnFalse; + } + return this.each(function() { + jQuery.event.remove( this, types, fn, selector ); + }); + }, + + bind: function( types, data, fn ) { + return this.on( types, null, data, fn ); + }, + unbind: function( types, fn ) { + return this.off( types, null, fn ); + }, + + live: function( types, data, fn ) { + jQuery( this.context ).on( types, this.selector, data, fn ); + return this; + }, + die: function( types, fn ) { + jQuery( this.context ).off( types, this.selector || "**", fn ); + return this; + }, + + delegate: function( selector, types, data, fn ) { + return this.on( types, selector, data, fn ); + }, + undelegate: function( selector, types, fn ) { + // ( namespace ) or ( selector, types [, fn] ) + return arguments.length == 1? this.off( selector, "**" ) : this.off( types, selector, fn ); + }, + + trigger: function( type, data ) { + return this.each(function() { + jQuery.event.trigger( type, data, this ); + }); + }, + triggerHandler: function( type, data ) { + if ( this[0] ) { + return jQuery.event.trigger( type, data, this[0], true ); + } + }, + + toggle: function( fn ) { + // Save reference to arguments for access in closure + var args = arguments, + guid = fn.guid || jQuery.guid++, + i = 0, + toggler = function( event ) { + // Figure out which function to execute + var lastToggle = ( jQuery._data( this, "lastToggle" + fn.guid ) || 0 ) % i; + jQuery._data( this, "lastToggle" + fn.guid, lastToggle + 1 ); + + // Make sure that clicks stop + event.preventDefault(); + + // and execute the function + return args[ lastToggle ].apply( this, arguments ) || false; + }; + + // link all the functions, so any of them can unbind this click handler + toggler.guid = guid; + while ( i < args.length ) { + args[ i++ ].guid = guid; + } + + return this.click( toggler ); + }, + + hover: function( fnOver, fnOut ) { + return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver ); + } +}); + +jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " + + "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " + + "change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) { + + // Handle event binding + jQuery.fn[ name ] = function( data, fn ) { + if ( fn == null ) { + fn = data; + data = null; + } + + return arguments.length > 0 ? + this.on( name, null, data, fn ) : + this.trigger( name ); + }; + + if ( jQuery.attrFn ) { + jQuery.attrFn[ name ] = true; + } + + if ( rkeyEvent.test( name ) ) { + jQuery.event.fixHooks[ name ] = jQuery.event.keyHooks; + } + + if ( rmouseEvent.test( name ) ) { + jQuery.event.fixHooks[ name ] = jQuery.event.mouseHooks; + } +}); + + + +/*! + * Sizzle CSS Selector Engine + * Copyright 2011, The Dojo Foundation + * Released under the MIT, BSD, and GPL Licenses. + * More information: http://sizzlejs.com/ + */ +(function(){ + +var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g, + expando = "sizcache" + (Math.random() + '').replace('.', ''), + done = 0, + toString = Object.prototype.toString, + hasDuplicate = false, + baseHasDuplicate = true, + rBackslash = /\\/g, + rReturn = /\r\n/g, + rNonWord = /\W/; + +// Here we check if the JavaScript engine is using some sort of +// optimization where it does not always call our comparision +// function. If that is the case, discard the hasDuplicate value. +// Thus far that includes Google Chrome. +[0, 0].sort(function() { + baseHasDuplicate = false; + return 0; +}); + +var Sizzle = function( selector, context, results, seed ) { + results = results || []; + context = context || document; + + var origContext = context; + + if ( context.nodeType !== 1 && context.nodeType !== 9 ) { + return []; + } + + if ( !selector || typeof selector !== "string" ) { + return results; + } + + var m, set, checkSet, extra, ret, cur, pop, i, + prune = true, + contextXML = Sizzle.isXML( context ), + parts = [], + soFar = selector; + + // Reset the position of the chunker regexp (start from head) + do { + chunker.exec( "" ); + m = chunker.exec( soFar ); + + if ( m ) { + soFar = m[3]; + + parts.push( m[1] ); + + if ( m[2] ) { + extra = m[3]; + break; + } + } + } while ( m ); + + if ( parts.length > 1 && origPOS.exec( selector ) ) { + + if ( parts.length === 2 && Expr.relative[ parts[0] ] ) { + set = posProcess( parts[0] + parts[1], context, seed ); + + } else { + set = Expr.relative[ parts[0] ] ? + [ context ] : + Sizzle( parts.shift(), context ); + + while ( parts.length ) { + selector = parts.shift(); + + if ( Expr.relative[ selector ] ) { + selector += parts.shift(); + } + + set = posProcess( selector, set, seed ); + } + } + + } else { + // Take a shortcut and set the context if the root selector is an ID + // (but not if it'll be faster if the inner selector is an ID) + if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML && + Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) { + + ret = Sizzle.find( parts.shift(), context, contextXML ); + context = ret.expr ? + Sizzle.filter( ret.expr, ret.set )[0] : + ret.set[0]; + } + + if ( context ) { + ret = seed ? + { expr: parts.pop(), set: makeArray(seed) } : + Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML ); + + set = ret.expr ? + Sizzle.filter( ret.expr, ret.set ) : + ret.set; + + if ( parts.length > 0 ) { + checkSet = makeArray( set ); + + } else { + prune = false; + } + + while ( parts.length ) { + cur = parts.pop(); + pop = cur; + + if ( !Expr.relative[ cur ] ) { + cur = ""; + } else { + pop = parts.pop(); + } + + if ( pop == null ) { + pop = context; + } + + Expr.relative[ cur ]( checkSet, pop, contextXML ); + } + + } else { + checkSet = parts = []; + } + } + + if ( !checkSet ) { + checkSet = set; + } + + if ( !checkSet ) { + Sizzle.error( cur || selector ); + } + + if ( toString.call(checkSet) === "[object Array]" ) { + if ( !prune ) { + results.push.apply( results, checkSet ); + + } else if ( context && context.nodeType === 1 ) { + for ( i = 0; checkSet[i] != null; i++ ) { + if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) { + results.push( set[i] ); + } + } + + } else { + for ( i = 0; checkSet[i] != null; i++ ) { + if ( checkSet[i] && checkSet[i].nodeType === 1 ) { + results.push( set[i] ); + } + } + } + + } else { + makeArray( checkSet, results ); + } + + if ( extra ) { + Sizzle( extra, origContext, results, seed ); + Sizzle.uniqueSort( results ); + } + + return results; +}; + +Sizzle.uniqueSort = function( results ) { + if ( sortOrder ) { + hasDuplicate = baseHasDuplicate; + results.sort( sortOrder ); + + if ( hasDuplicate ) { + for ( var i = 1; i < results.length; i++ ) { + if ( results[i] === results[ i - 1 ] ) { + results.splice( i--, 1 ); + } + } + } + } + + return results; +}; + +Sizzle.matches = function( expr, set ) { + return Sizzle( expr, null, null, set ); +}; + +Sizzle.matchesSelector = function( node, expr ) { + return Sizzle( expr, null, null, [node] ).length > 0; +}; + +Sizzle.find = function( expr, context, isXML ) { + var set, i, len, match, type, left; + + if ( !expr ) { + return []; + } + + for ( i = 0, len = Expr.order.length; i < len; i++ ) { + type = Expr.order[i]; + + if ( (match = Expr.leftMatch[ type ].exec( expr )) ) { + left = match[1]; + match.splice( 1, 1 ); + + if ( left.substr( left.length - 1 ) !== "\\" ) { + match[1] = (match[1] || "").replace( rBackslash, "" ); + set = Expr.find[ type ]( match, context, isXML ); + + if ( set != null ) { + expr = expr.replace( Expr.match[ type ], "" ); + break; + } + } + } + } + + if ( !set ) { + set = typeof context.getElementsByTagName !== "undefined" ? + context.getElementsByTagName( "*" ) : + []; + } + + return { set: set, expr: expr }; +}; + +Sizzle.filter = function( expr, set, inplace, not ) { + var match, anyFound, + type, found, item, filter, left, + i, pass, + old = expr, + result = [], + curLoop = set, + isXMLFilter = set && set[0] && Sizzle.isXML( set[0] ); + + while ( expr && set.length ) { + for ( type in Expr.filter ) { + if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) { + filter = Expr.filter[ type ]; + left = match[1]; + + anyFound = false; + + match.splice(1,1); + + if ( left.substr( left.length - 1 ) === "\\" ) { + continue; + } + + if ( curLoop === result ) { + result = []; + } + + if ( Expr.preFilter[ type ] ) { + match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter ); + + if ( !match ) { + anyFound = found = true; + + } else if ( match === true ) { + continue; + } + } + + if ( match ) { + for ( i = 0; (item = curLoop[i]) != null; i++ ) { + if ( item ) { + found = filter( item, match, i, curLoop ); + pass = not ^ found; + + if ( inplace && found != null ) { + if ( pass ) { + anyFound = true; + + } else { + curLoop[i] = false; + } + + } else if ( pass ) { + result.push( item ); + anyFound = true; + } + } + } + } + + if ( found !== undefined ) { + if ( !inplace ) { + curLoop = result; + } + + expr = expr.replace( Expr.match[ type ], "" ); + + if ( !anyFound ) { + return []; + } + + break; + } + } + } + + // Improper expression + if ( expr === old ) { + if ( anyFound == null ) { + Sizzle.error( expr ); + + } else { + break; + } + } + + old = expr; + } + + return curLoop; +}; + +Sizzle.error = function( msg ) { + throw new Error( "Syntax error, unrecognized expression: " + msg ); +}; + +/** + * Utility function for retreiving the text value of an array of DOM nodes + * @param {Array|Element} elem + */ +var getText = Sizzle.getText = function( elem ) { + var i, node, + nodeType = elem.nodeType, + ret = ""; + + if ( nodeType ) { + if ( nodeType === 1 || nodeType === 9 ) { + // Use textContent || innerText for elements + if ( typeof elem.textContent === 'string' ) { + return elem.textContent; + } else if ( typeof elem.innerText === 'string' ) { + // Replace IE's carriage returns + return elem.innerText.replace( rReturn, '' ); + } else { + // Traverse it's children + for ( elem = elem.firstChild; elem; elem = elem.nextSibling) { + ret += getText( elem ); + } + } + } else if ( nodeType === 3 || nodeType === 4 ) { + return elem.nodeValue; + } + } else { + + // If no nodeType, this is expected to be an array + for ( i = 0; (node = elem[i]); i++ ) { + // Do not traverse comment nodes + if ( node.nodeType !== 8 ) { + ret += getText( node ); + } + } + } + return ret; +}; + +var Expr = Sizzle.selectors = { + order: [ "ID", "NAME", "TAG" ], + + match: { + ID: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/, + CLASS: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/, + NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/, + ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/, + TAG: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/, + CHILD: /:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/, + POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/, + PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/ + }, + + leftMatch: {}, + + attrMap: { + "class": "className", + "for": "htmlFor" + }, + + attrHandle: { + href: function( elem ) { + return elem.getAttribute( "href" ); + }, + type: function( elem ) { + return elem.getAttribute( "type" ); + } + }, + + relative: { + "+": function(checkSet, part){ + var isPartStr = typeof part === "string", + isTag = isPartStr && !rNonWord.test( part ), + isPartStrNotTag = isPartStr && !isTag; + + if ( isTag ) { + part = part.toLowerCase(); + } + + for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) { + if ( (elem = checkSet[i]) ) { + while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {} + + checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ? + elem || false : + elem === part; + } + } + + if ( isPartStrNotTag ) { + Sizzle.filter( part, checkSet, true ); + } + }, + + ">": function( checkSet, part ) { + var elem, + isPartStr = typeof part === "string", + i = 0, + l = checkSet.length; + + if ( isPartStr && !rNonWord.test( part ) ) { + part = part.toLowerCase(); + + for ( ; i < l; i++ ) { + elem = checkSet[i]; + + if ( elem ) { + var parent = elem.parentNode; + checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false; + } + } + + } else { + for ( ; i < l; i++ ) { + elem = checkSet[i]; + + if ( elem ) { + checkSet[i] = isPartStr ? + elem.parentNode : + elem.parentNode === part; + } + } + + if ( isPartStr ) { + Sizzle.filter( part, checkSet, true ); + } + } + }, + + "": function(checkSet, part, isXML){ + var nodeCheck, + doneName = done++, + checkFn = dirCheck; + + if ( typeof part === "string" && !rNonWord.test( part ) ) { + part = part.toLowerCase(); + nodeCheck = part; + checkFn = dirNodeCheck; + } + + checkFn( "parentNode", part, doneName, checkSet, nodeCheck, isXML ); + }, + + "~": function( checkSet, part, isXML ) { + var nodeCheck, + doneName = done++, + checkFn = dirCheck; + + if ( typeof part === "string" && !rNonWord.test( part ) ) { + part = part.toLowerCase(); + nodeCheck = part; + checkFn = dirNodeCheck; + } + + checkFn( "previousSibling", part, doneName, checkSet, nodeCheck, isXML ); + } + }, + + find: { + ID: function( match, context, isXML ) { + if ( typeof context.getElementById !== "undefined" && !isXML ) { + var m = context.getElementById(match[1]); + // Check parentNode to catch when Blackberry 4.6 returns + // nodes that are no longer in the document #6963 + return m && m.parentNode ? [m] : []; + } + }, + + NAME: function( match, context ) { + if ( typeof context.getElementsByName !== "undefined" ) { + var ret = [], + results = context.getElementsByName( match[1] ); + + for ( var i = 0, l = results.length; i < l; i++ ) { + if ( results[i].getAttribute("name") === match[1] ) { + ret.push( results[i] ); + } + } + + return ret.length === 0 ? null : ret; + } + }, + + TAG: function( match, context ) { + if ( typeof context.getElementsByTagName !== "undefined" ) { + return context.getElementsByTagName( match[1] ); + } + } + }, + preFilter: { + CLASS: function( match, curLoop, inplace, result, not, isXML ) { + match = " " + match[1].replace( rBackslash, "" ) + " "; + + if ( isXML ) { + return match; + } + + for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) { + if ( elem ) { + if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n\r]/g, " ").indexOf(match) >= 0) ) { + if ( !inplace ) { + result.push( elem ); + } + + } else if ( inplace ) { + curLoop[i] = false; + } + } + } + + return false; + }, + + ID: function( match ) { + return match[1].replace( rBackslash, "" ); + }, + + TAG: function( match, curLoop ) { + return match[1].replace( rBackslash, "" ).toLowerCase(); + }, + + CHILD: function( match ) { + if ( match[1] === "nth" ) { + if ( !match[2] ) { + Sizzle.error( match[0] ); + } + + match[2] = match[2].replace(/^\+|\s*/g, ''); + + // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6' + var test = /(-?)(\d*)(?:n([+\-]?\d*))?/.exec( + match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" || + !/\D/.test( match[2] ) && "0n+" + match[2] || match[2]); + + // calculate the numbers (first)n+(last) including if they are negative + match[2] = (test[1] + (test[2] || 1)) - 0; + match[3] = test[3] - 0; + } + else if ( match[2] ) { + Sizzle.error( match[0] ); + } + + // TODO: Move to normal caching system + match[0] = done++; + + return match; + }, + + ATTR: function( match, curLoop, inplace, result, not, isXML ) { + var name = match[1] = match[1].replace( rBackslash, "" ); + + if ( !isXML && Expr.attrMap[name] ) { + match[1] = Expr.attrMap[name]; + } + + // Handle if an un-quoted value was used + match[4] = ( match[4] || match[5] || "" ).replace( rBackslash, "" ); + + if ( match[2] === "~=" ) { + match[4] = " " + match[4] + " "; + } + + return match; + }, + + PSEUDO: function( match, curLoop, inplace, result, not ) { + if ( match[1] === "not" ) { + // If we're dealing with a complex expression, or a simple one + if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) { + match[3] = Sizzle(match[3], null, null, curLoop); + + } else { + var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not); + + if ( !inplace ) { + result.push.apply( result, ret ); + } + + return false; + } + + } else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) { + return true; + } + + return match; + }, + + POS: function( match ) { + match.unshift( true ); + + return match; + } + }, + + filters: { + enabled: function( elem ) { + return elem.disabled === false && elem.type !== "hidden"; + }, + + disabled: function( elem ) { + return elem.disabled === true; + }, + + checked: function( elem ) { + return elem.checked === true; + }, + + selected: function( elem ) { + // Accessing this property makes selected-by-default + // options in Safari work properly + if ( elem.parentNode ) { + elem.parentNode.selectedIndex; + } + + return elem.selected === true; + }, + + parent: function( elem ) { + return !!elem.firstChild; + }, + + empty: function( elem ) { + return !elem.firstChild; + }, + + has: function( elem, i, match ) { + return !!Sizzle( match[3], elem ).length; + }, + + header: function( elem ) { + return (/h\d/i).test( elem.nodeName ); + }, + + text: function( elem ) { + var attr = elem.getAttribute( "type" ), type = elem.type; + // IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc) + // use getAttribute instead to test this case + return elem.nodeName.toLowerCase() === "input" && "text" === type && ( attr === type || attr === null ); + }, + + radio: function( elem ) { + return elem.nodeName.toLowerCase() === "input" && "radio" === elem.type; + }, + + checkbox: function( elem ) { + return elem.nodeName.toLowerCase() === "input" && "checkbox" === elem.type; + }, + + file: function( elem ) { + return elem.nodeName.toLowerCase() === "input" && "file" === elem.type; + }, + + password: function( elem ) { + return elem.nodeName.toLowerCase() === "input" && "password" === elem.type; + }, + + submit: function( elem ) { + var name = elem.nodeName.toLowerCase(); + return (name === "input" || name === "button") && "submit" === elem.type; + }, + + image: function( elem ) { + return elem.nodeName.toLowerCase() === "input" && "image" === elem.type; + }, + + reset: function( elem ) { + var name = elem.nodeName.toLowerCase(); + return (name === "input" || name === "button") && "reset" === elem.type; + }, + + button: function( elem ) { + var name = elem.nodeName.toLowerCase(); + return name === "input" && "button" === elem.type || name === "button"; + }, + + input: function( elem ) { + return (/input|select|textarea|button/i).test( elem.nodeName ); + }, + + focus: function( elem ) { + return elem === elem.ownerDocument.activeElement; + } + }, + setFilters: { + first: function( elem, i ) { + return i === 0; + }, + + last: function( elem, i, match, array ) { + return i === array.length - 1; + }, + + even: function( elem, i ) { + return i % 2 === 0; + }, + + odd: function( elem, i ) { + return i % 2 === 1; + }, + + lt: function( elem, i, match ) { + return i < match[3] - 0; + }, + + gt: function( elem, i, match ) { + return i > match[3] - 0; + }, + + nth: function( elem, i, match ) { + return match[3] - 0 === i; + }, + + eq: function( elem, i, match ) { + return match[3] - 0 === i; + } + }, + filter: { + PSEUDO: function( elem, match, i, array ) { + var name = match[1], + filter = Expr.filters[ name ]; + + if ( filter ) { + return filter( elem, i, match, array ); + + } else if ( name === "contains" ) { + return (elem.textContent || elem.innerText || getText([ elem ]) || "").indexOf(match[3]) >= 0; + + } else if ( name === "not" ) { + var not = match[3]; + + for ( var j = 0, l = not.length; j < l; j++ ) { + if ( not[j] === elem ) { + return false; + } + } + + return true; + + } else { + Sizzle.error( name ); + } + }, + + CHILD: function( elem, match ) { + var first, last, + doneName, parent, cache, + count, diff, + type = match[1], + node = elem; + + switch ( type ) { + case "only": + case "first": + while ( (node = node.previousSibling) ) { + if ( node.nodeType === 1 ) { + return false; + } + } + + if ( type === "first" ) { + return true; + } + + node = elem; + + case "last": + while ( (node = node.nextSibling) ) { + if ( node.nodeType === 1 ) { + return false; + } + } + + return true; + + case "nth": + first = match[2]; + last = match[3]; + + if ( first === 1 && last === 0 ) { + return true; + } + + doneName = match[0]; + parent = elem.parentNode; + + if ( parent && (parent[ expando ] !== doneName || !elem.nodeIndex) ) { + count = 0; + + for ( node = parent.firstChild; node; node = node.nextSibling ) { + if ( node.nodeType === 1 ) { + node.nodeIndex = ++count; + } + } + + parent[ expando ] = doneName; + } + + diff = elem.nodeIndex - last; + + if ( first === 0 ) { + return diff === 0; + + } else { + return ( diff % first === 0 && diff / first >= 0 ); + } + } + }, + + ID: function( elem, match ) { + return elem.nodeType === 1 && elem.getAttribute("id") === match; + }, + + TAG: function( elem, match ) { + return (match === "*" && elem.nodeType === 1) || !!elem.nodeName && elem.nodeName.toLowerCase() === match; + }, + + CLASS: function( elem, match ) { + return (" " + (elem.className || elem.getAttribute("class")) + " ") + .indexOf( match ) > -1; + }, + + ATTR: function( elem, match ) { + var name = match[1], + result = Sizzle.attr ? + Sizzle.attr( elem, name ) : + Expr.attrHandle[ name ] ? + Expr.attrHandle[ name ]( elem ) : + elem[ name ] != null ? + elem[ name ] : + elem.getAttribute( name ), + value = result + "", + type = match[2], + check = match[4]; + + return result == null ? + type === "!=" : + !type && Sizzle.attr ? + result != null : + type === "=" ? + value === check : + type === "*=" ? + value.indexOf(check) >= 0 : + type === "~=" ? + (" " + value + " ").indexOf(check) >= 0 : + !check ? + value && result !== false : + type === "!=" ? + value !== check : + type === "^=" ? + value.indexOf(check) === 0 : + type === "$=" ? + value.substr(value.length - check.length) === check : + type === "|=" ? + value === check || value.substr(0, check.length + 1) === check + "-" : + false; + }, + + POS: function( elem, match, i, array ) { + var name = match[2], + filter = Expr.setFilters[ name ]; + + if ( filter ) { + return filter( elem, i, match, array ); + } + } + } +}; + +var origPOS = Expr.match.POS, + fescape = function(all, num){ + return "\\" + (num - 0 + 1); + }; + +for ( var type in Expr.match ) { + Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]*\])(?![^\(]*\))/.source) ); + Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) ); +} + +var makeArray = function( array, results ) { + array = Array.prototype.slice.call( array, 0 ); + + if ( results ) { + results.push.apply( results, array ); + return results; + } + + return array; +}; + +// Perform a simple check to determine if the browser is capable of +// converting a NodeList to an array using builtin methods. +// Also verifies that the returned array holds DOM nodes +// (which is not the case in the Blackberry browser) +try { + Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType; + +// Provide a fallback method if it does not work +} catch( e ) { + makeArray = function( array, results ) { + var i = 0, + ret = results || []; + + if ( toString.call(array) === "[object Array]" ) { + Array.prototype.push.apply( ret, array ); + + } else { + if ( typeof array.length === "number" ) { + for ( var l = array.length; i < l; i++ ) { + ret.push( array[i] ); + } + + } else { + for ( ; array[i]; i++ ) { + ret.push( array[i] ); + } + } + } + + return ret; + }; +} + +var sortOrder, siblingCheck; + +if ( document.documentElement.compareDocumentPosition ) { + sortOrder = function( a, b ) { + if ( a === b ) { + hasDuplicate = true; + return 0; + } + + if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) { + return a.compareDocumentPosition ? -1 : 1; + } + + return a.compareDocumentPosition(b) & 4 ? -1 : 1; + }; + +} else { + sortOrder = function( a, b ) { + // The nodes are identical, we can exit early + if ( a === b ) { + hasDuplicate = true; + return 0; + + // Fallback to using sourceIndex (in IE) if it's available on both nodes + } else if ( a.sourceIndex && b.sourceIndex ) { + return a.sourceIndex - b.sourceIndex; + } + + var al, bl, + ap = [], + bp = [], + aup = a.parentNode, + bup = b.parentNode, + cur = aup; + + // If the nodes are siblings (or identical) we can do a quick check + if ( aup === bup ) { + return siblingCheck( a, b ); + + // If no parents were found then the nodes are disconnected + } else if ( !aup ) { + return -1; + + } else if ( !bup ) { + return 1; + } + + // Otherwise they're somewhere else in the tree so we need + // to build up a full list of the parentNodes for comparison + while ( cur ) { + ap.unshift( cur ); + cur = cur.parentNode; + } + + cur = bup; + + while ( cur ) { + bp.unshift( cur ); + cur = cur.parentNode; + } + + al = ap.length; + bl = bp.length; + + // Start walking down the tree looking for a discrepancy + for ( var i = 0; i < al && i < bl; i++ ) { + if ( ap[i] !== bp[i] ) { + return siblingCheck( ap[i], bp[i] ); + } + } + + // We ended someplace up the tree so do a sibling check + return i === al ? + siblingCheck( a, bp[i], -1 ) : + siblingCheck( ap[i], b, 1 ); + }; + + siblingCheck = function( a, b, ret ) { + if ( a === b ) { + return ret; + } + + var cur = a.nextSibling; + + while ( cur ) { + if ( cur === b ) { + return -1; + } + + cur = cur.nextSibling; + } + + return 1; + }; +} + +// Check to see if the browser returns elements by name when +// querying by getElementById (and provide a workaround) +(function(){ + // We're going to inject a fake input element with a specified name + var form = document.createElement("div"), + id = "script" + (new Date()).getTime(), + root = document.documentElement; + + form.innerHTML = ""; + + // Inject it into the root element, check its status, and remove it quickly + root.insertBefore( form, root.firstChild ); + + // The workaround has to do additional checks after a getElementById + // Which slows things down for other browsers (hence the branching) + if ( document.getElementById( id ) ) { + Expr.find.ID = function( match, context, isXML ) { + if ( typeof context.getElementById !== "undefined" && !isXML ) { + var m = context.getElementById(match[1]); + + return m ? + m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ? + [m] : + undefined : + []; + } + }; + + Expr.filter.ID = function( elem, match ) { + var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id"); + + return elem.nodeType === 1 && node && node.nodeValue === match; + }; + } + + root.removeChild( form ); + + // release memory in IE + root = form = null; +})(); + +(function(){ + // Check to see if the browser returns only elements + // when doing getElementsByTagName("*") + + // Create a fake element + var div = document.createElement("div"); + div.appendChild( document.createComment("") ); + + // Make sure no comments are found + if ( div.getElementsByTagName("*").length > 0 ) { + Expr.find.TAG = function( match, context ) { + var results = context.getElementsByTagName( match[1] ); + + // Filter out possible comments + if ( match[1] === "*" ) { + var tmp = []; + + for ( var i = 0; results[i]; i++ ) { + if ( results[i].nodeType === 1 ) { + tmp.push( results[i] ); + } + } + + results = tmp; + } + + return results; + }; + } + + // Check to see if an attribute returns normalized href attributes + div.innerHTML = ""; + + if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" && + div.firstChild.getAttribute("href") !== "#" ) { + + Expr.attrHandle.href = function( elem ) { + return elem.getAttribute( "href", 2 ); + }; + } + + // release memory in IE + div = null; +})(); + +if ( document.querySelectorAll ) { + (function(){ + var oldSizzle = Sizzle, + div = document.createElement("div"), + id = "__sizzle__"; + + div.innerHTML = "

"; + + // Safari can't handle uppercase or unicode characters when + // in quirks mode. + if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) { + return; + } + + Sizzle = function( query, context, extra, seed ) { + context = context || document; + + // Only use querySelectorAll on non-XML documents + // (ID selectors don't work in non-HTML documents) + if ( !seed && !Sizzle.isXML(context) ) { + // See if we find a selector to speed up + var match = /^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec( query ); + + if ( match && (context.nodeType === 1 || context.nodeType === 9) ) { + // Speed-up: Sizzle("TAG") + if ( match[1] ) { + return makeArray( context.getElementsByTagName( query ), extra ); + + // Speed-up: Sizzle(".CLASS") + } else if ( match[2] && Expr.find.CLASS && context.getElementsByClassName ) { + return makeArray( context.getElementsByClassName( match[2] ), extra ); + } + } + + if ( context.nodeType === 9 ) { + // Speed-up: Sizzle("body") + // The body element only exists once, optimize finding it + if ( query === "body" && context.body ) { + return makeArray( [ context.body ], extra ); + + // Speed-up: Sizzle("#ID") + } else if ( match && match[3] ) { + var elem = context.getElementById( match[3] ); + + // Check parentNode to catch when Blackberry 4.6 returns + // nodes that are no longer in the document #6963 + if ( elem && elem.parentNode ) { + // Handle the case where IE and Opera return items + // by name instead of ID + if ( elem.id === match[3] ) { + return makeArray( [ elem ], extra ); + } + + } else { + return makeArray( [], extra ); + } + } + + try { + return makeArray( context.querySelectorAll(query), extra ); + } catch(qsaError) {} + + // qSA works strangely on Element-rooted queries + // We can work around this by specifying an extra ID on the root + // and working up from there (Thanks to Andrew Dupont for the technique) + // IE 8 doesn't work on object elements + } else if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) { + var oldContext = context, + old = context.getAttribute( "id" ), + nid = old || id, + hasParent = context.parentNode, + relativeHierarchySelector = /^\s*[+~]/.test( query ); + + if ( !old ) { + context.setAttribute( "id", nid ); + } else { + nid = nid.replace( /'/g, "\\$&" ); + } + if ( relativeHierarchySelector && hasParent ) { + context = context.parentNode; + } + + try { + if ( !relativeHierarchySelector || hasParent ) { + return makeArray( context.querySelectorAll( "[id='" + nid + "'] " + query ), extra ); + } + + } catch(pseudoError) { + } finally { + if ( !old ) { + oldContext.removeAttribute( "id" ); + } + } + } + } + + return oldSizzle(query, context, extra, seed); + }; + + for ( var prop in oldSizzle ) { + Sizzle[ prop ] = oldSizzle[ prop ]; + } + + // release memory in IE + div = null; + })(); +} + +(function(){ + var html = document.documentElement, + matches = html.matchesSelector || html.mozMatchesSelector || html.webkitMatchesSelector || html.msMatchesSelector; + + if ( matches ) { + // Check to see if it's possible to do matchesSelector + // on a disconnected node (IE 9 fails this) + var disconnectedMatch = !matches.call( document.createElement( "div" ), "div" ), + pseudoWorks = false; + + try { + // This should fail with an exception + // Gecko does not error, returns false instead + matches.call( document.documentElement, "[test!='']:sizzle" ); + + } catch( pseudoError ) { + pseudoWorks = true; + } + + Sizzle.matchesSelector = function( node, expr ) { + // Make sure that attribute selectors are quoted + expr = expr.replace(/\=\s*([^'"\]]*)\s*\]/g, "='$1']"); + + if ( !Sizzle.isXML( node ) ) { + try { + if ( pseudoWorks || !Expr.match.PSEUDO.test( expr ) && !/!=/.test( expr ) ) { + var ret = matches.call( node, expr ); + + // IE 9's matchesSelector returns false on disconnected nodes + if ( ret || !disconnectedMatch || + // As well, disconnected nodes are said to be in a document + // fragment in IE 9, so check for that + node.document && node.document.nodeType !== 11 ) { + return ret; + } + } + } catch(e) {} + } + + return Sizzle(expr, null, null, [node]).length > 0; + }; + } +})(); + +(function(){ + var div = document.createElement("div"); + + div.innerHTML = "
"; + + // Opera can't find a second classname (in 9.6) + // Also, make sure that getElementsByClassName actually exists + if ( !div.getElementsByClassName || div.getElementsByClassName("e").length === 0 ) { + return; + } + + // Safari caches class attributes, doesn't catch changes (in 3.2) + div.lastChild.className = "e"; + + if ( div.getElementsByClassName("e").length === 1 ) { + return; + } + + Expr.order.splice(1, 0, "CLASS"); + Expr.find.CLASS = function( match, context, isXML ) { + if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) { + return context.getElementsByClassName(match[1]); + } + }; + + // release memory in IE + div = null; +})(); + +function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) { + for ( var i = 0, l = checkSet.length; i < l; i++ ) { + var elem = checkSet[i]; + + if ( elem ) { + var match = false; + + elem = elem[dir]; + + while ( elem ) { + if ( elem[ expando ] === doneName ) { + match = checkSet[elem.sizset]; + break; + } + + if ( elem.nodeType === 1 && !isXML ){ + elem[ expando ] = doneName; + elem.sizset = i; + } + + if ( elem.nodeName.toLowerCase() === cur ) { + match = elem; + break; + } + + elem = elem[dir]; + } + + checkSet[i] = match; + } + } +} + +function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) { + for ( var i = 0, l = checkSet.length; i < l; i++ ) { + var elem = checkSet[i]; + + if ( elem ) { + var match = false; + + elem = elem[dir]; + + while ( elem ) { + if ( elem[ expando ] === doneName ) { + match = checkSet[elem.sizset]; + break; + } + + if ( elem.nodeType === 1 ) { + if ( !isXML ) { + elem[ expando ] = doneName; + elem.sizset = i; + } + + if ( typeof cur !== "string" ) { + if ( elem === cur ) { + match = true; + break; + } + + } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) { + match = elem; + break; + } + } + + elem = elem[dir]; + } + + checkSet[i] = match; + } + } +} + +if ( document.documentElement.contains ) { + Sizzle.contains = function( a, b ) { + return a !== b && (a.contains ? a.contains(b) : true); + }; + +} else if ( document.documentElement.compareDocumentPosition ) { + Sizzle.contains = function( a, b ) { + return !!(a.compareDocumentPosition(b) & 16); + }; + +} else { + Sizzle.contains = function() { + return false; + }; +} + +Sizzle.isXML = function( elem ) { + // documentElement is verified for cases where it doesn't yet exist + // (such as loading iframes in IE - #4833) + var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement; + + return documentElement ? documentElement.nodeName !== "HTML" : false; +}; + +var posProcess = function( selector, context, seed ) { + var match, + tmpSet = [], + later = "", + root = context.nodeType ? [context] : context; + + // Position selectors must be done after the filter + // And so must :not(positional) so we move all PSEUDOs to the end + while ( (match = Expr.match.PSEUDO.exec( selector )) ) { + later += match[0]; + selector = selector.replace( Expr.match.PSEUDO, "" ); + } + + selector = Expr.relative[selector] ? selector + "*" : selector; + + for ( var i = 0, l = root.length; i < l; i++ ) { + Sizzle( selector, root[i], tmpSet, seed ); + } + + return Sizzle.filter( later, tmpSet ); +}; + +// EXPOSE +// Override sizzle attribute retrieval +Sizzle.attr = jQuery.attr; +Sizzle.selectors.attrMap = {}; +jQuery.find = Sizzle; +jQuery.expr = Sizzle.selectors; +jQuery.expr[":"] = jQuery.expr.filters; +jQuery.unique = Sizzle.uniqueSort; +jQuery.text = Sizzle.getText; +jQuery.isXMLDoc = Sizzle.isXML; +jQuery.contains = Sizzle.contains; + + +})(); + + +var runtil = /Until$/, + rparentsprev = /^(?:parents|prevUntil|prevAll)/, + // Note: This RegExp should be improved, or likely pulled from Sizzle + rmultiselector = /,/, + isSimple = /^.[^:#\[\.,]*$/, + slice = Array.prototype.slice, + POS = jQuery.expr.match.POS, + // methods guaranteed to produce a unique set when starting from a unique set + guaranteedUnique = { + children: true, + contents: true, + next: true, + prev: true + }; + +jQuery.fn.extend({ + find: function( selector ) { + var self = this, + i, l; + + if ( typeof selector !== "string" ) { + return jQuery( selector ).filter(function() { + for ( i = 0, l = self.length; i < l; i++ ) { + if ( jQuery.contains( self[ i ], this ) ) { + return true; + } + } + }); + } + + var ret = this.pushStack( "", "find", selector ), + length, n, r; + + for ( i = 0, l = this.length; i < l; i++ ) { + length = ret.length; + jQuery.find( selector, this[i], ret ); + + if ( i > 0 ) { + // Make sure that the results are unique + for ( n = length; n < ret.length; n++ ) { + for ( r = 0; r < length; r++ ) { + if ( ret[r] === ret[n] ) { + ret.splice(n--, 1); + break; + } + } + } + } + } + + return ret; + }, + + has: function( target ) { + var targets = jQuery( target ); + return this.filter(function() { + for ( var i = 0, l = targets.length; i < l; i++ ) { + if ( jQuery.contains( this, targets[i] ) ) { + return true; + } + } + }); + }, + + not: function( selector ) { + return this.pushStack( winnow(this, selector, false), "not", selector); + }, + + filter: function( selector ) { + return this.pushStack( winnow(this, selector, true), "filter", selector ); + }, + + is: function( selector ) { + return !!selector && ( + typeof selector === "string" ? + // If this is a positional selector, check membership in the returned set + // so $("p:first").is("p:last") won't return true for a doc with two "p". + POS.test( selector ) ? + jQuery( selector, this.context ).index( this[0] ) >= 0 : + jQuery.filter( selector, this ).length > 0 : + this.filter( selector ).length > 0 ); + }, + + closest: function( selectors, context ) { + var ret = [], i, l, cur = this[0]; + + // Array (deprecated as of jQuery 1.7) + if ( jQuery.isArray( selectors ) ) { + var level = 1; + + while ( cur && cur.ownerDocument && cur !== context ) { + for ( i = 0; i < selectors.length; i++ ) { + + if ( jQuery( cur ).is( selectors[ i ] ) ) { + ret.push({ selector: selectors[ i ], elem: cur, level: level }); + } + } + + cur = cur.parentNode; + level++; + } + + return ret; + } + + // String + var pos = POS.test( selectors ) || typeof selectors !== "string" ? + jQuery( selectors, context || this.context ) : + 0; + + for ( i = 0, l = this.length; i < l; i++ ) { + cur = this[i]; + + while ( cur ) { + if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) { + ret.push( cur ); + break; + + } else { + cur = cur.parentNode; + if ( !cur || !cur.ownerDocument || cur === context || cur.nodeType === 11 ) { + break; + } + } + } + } + + ret = ret.length > 1 ? jQuery.unique( ret ) : ret; + + return this.pushStack( ret, "closest", selectors ); + }, + + // Determine the position of an element within + // the matched set of elements + index: function( elem ) { + + // No argument, return index in parent + if ( !elem ) { + return ( this[0] && this[0].parentNode ) ? this.prevAll().length : -1; + } + + // index in selector + if ( typeof elem === "string" ) { + return jQuery.inArray( this[0], jQuery( elem ) ); + } + + // Locate the position of the desired element + return jQuery.inArray( + // If it receives a jQuery object, the first element is used + elem.jquery ? elem[0] : elem, this ); + }, + + add: function( selector, context ) { + var set = typeof selector === "string" ? + jQuery( selector, context ) : + jQuery.makeArray( selector && selector.nodeType ? [ selector ] : selector ), + all = jQuery.merge( this.get(), set ); + + return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ? + all : + jQuery.unique( all ) ); + }, + + andSelf: function() { + return this.add( this.prevObject ); + } +}); + +// A painfully simple check to see if an element is disconnected +// from a document (should be improved, where feasible). +function isDisconnected( node ) { + return !node || !node.parentNode || node.parentNode.nodeType === 11; +} + +jQuery.each({ + parent: function( elem ) { + var parent = elem.parentNode; + return parent && parent.nodeType !== 11 ? parent : null; + }, + parents: function( elem ) { + return jQuery.dir( elem, "parentNode" ); + }, + parentsUntil: function( elem, i, until ) { + return jQuery.dir( elem, "parentNode", until ); + }, + next: function( elem ) { + return jQuery.nth( elem, 2, "nextSibling" ); + }, + prev: function( elem ) { + return jQuery.nth( elem, 2, "previousSibling" ); + }, + nextAll: function( elem ) { + return jQuery.dir( elem, "nextSibling" ); + }, + prevAll: function( elem ) { + return jQuery.dir( elem, "previousSibling" ); + }, + nextUntil: function( elem, i, until ) { + return jQuery.dir( elem, "nextSibling", until ); + }, + prevUntil: function( elem, i, until ) { + return jQuery.dir( elem, "previousSibling", until ); + }, + siblings: function( elem ) { + return jQuery.sibling( elem.parentNode.firstChild, elem ); + }, + children: function( elem ) { + return jQuery.sibling( elem.firstChild ); + }, + contents: function( elem ) { + return jQuery.nodeName( elem, "iframe" ) ? + elem.contentDocument || elem.contentWindow.document : + jQuery.makeArray( elem.childNodes ); + } +}, function( name, fn ) { + jQuery.fn[ name ] = function( until, selector ) { + var ret = jQuery.map( this, fn, until ); + + if ( !runtil.test( name ) ) { + selector = until; + } + + if ( selector && typeof selector === "string" ) { + ret = jQuery.filter( selector, ret ); + } + + ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret; + + if ( (this.length > 1 || rmultiselector.test( selector )) && rparentsprev.test( name ) ) { + ret = ret.reverse(); + } + + return this.pushStack( ret, name, slice.call( arguments ).join(",") ); + }; +}); + +jQuery.extend({ + filter: function( expr, elems, not ) { + if ( not ) { + expr = ":not(" + expr + ")"; + } + + return elems.length === 1 ? + jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] : + jQuery.find.matches(expr, elems); + }, + + dir: function( elem, dir, until ) { + var matched = [], + cur = elem[ dir ]; + + while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) { + if ( cur.nodeType === 1 ) { + matched.push( cur ); + } + cur = cur[dir]; + } + return matched; + }, + + nth: function( cur, result, dir, elem ) { + result = result || 1; + var num = 0; + + for ( ; cur; cur = cur[dir] ) { + if ( cur.nodeType === 1 && ++num === result ) { + break; + } + } + + return cur; + }, + + sibling: function( n, elem ) { + var r = []; + + for ( ; n; n = n.nextSibling ) { + if ( n.nodeType === 1 && n !== elem ) { + r.push( n ); + } + } + + return r; + } +}); + +// Implement the identical functionality for filter and not +function winnow( elements, qualifier, keep ) { + + // Can't pass null or undefined to indexOf in Firefox 4 + // Set to 0 to skip string check + qualifier = qualifier || 0; + + if ( jQuery.isFunction( qualifier ) ) { + return jQuery.grep(elements, function( elem, i ) { + var retVal = !!qualifier.call( elem, i, elem ); + return retVal === keep; + }); + + } else if ( qualifier.nodeType ) { + return jQuery.grep(elements, function( elem, i ) { + return ( elem === qualifier ) === keep; + }); + + } else if ( typeof qualifier === "string" ) { + var filtered = jQuery.grep(elements, function( elem ) { + return elem.nodeType === 1; + }); + + if ( isSimple.test( qualifier ) ) { + return jQuery.filter(qualifier, filtered, !keep); + } else { + qualifier = jQuery.filter( qualifier, filtered ); + } + } + + return jQuery.grep(elements, function( elem, i ) { + return ( jQuery.inArray( elem, qualifier ) >= 0 ) === keep; + }); +} + + + + +function createSafeFragment( document ) { + var list = nodeNames.split( "|" ), + safeFrag = document.createDocumentFragment(); + + if ( safeFrag.createElement ) { + while ( list.length ) { + safeFrag.createElement( + list.pop() + ); + } + } + return safeFrag; +} + +var nodeNames = "abbr|article|aside|audio|canvas|datalist|details|figcaption|figure|footer|" + + "header|hgroup|mark|meter|nav|output|progress|section|summary|time|video", + rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g, + rleadingWhitespace = /^\s+/, + rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig, + rtagName = /<([\w:]+)/, + rtbody = /", "" ], + legend: [ 1, "
", "
" ], + thead: [ 1, "", "
" ], + tr: [ 2, "", "
" ], + td: [ 3, "", "
" ], + col: [ 2, "", "
" ], + area: [ 1, "", "" ], + _default: [ 0, "", "" ] + }, + safeFragment = createSafeFragment( document ); + +wrapMap.optgroup = wrapMap.option; +wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; +wrapMap.th = wrapMap.td; + +// IE can't serialize and + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+
+
Data Structures
+
+
+
Here are the data structures with brief descriptions:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
 Cdither_matrix_impl
 Cstp_cached_curve_t
 Cstp_color
 Cstp_colorfuncs_t
 Cstp_curve_point_tPoint (x,y) for piecewise curve
 Cstp_dither_matrix_generic
 Cstp_dither_matrix_normal
 Cstp_dither_matrix_short
 Cstp_dotsize
 Cstp_double_bound_tDouble_bound (range) parameter
 Cstp_family
 Cstp_imageThe image type is an abstract data type for interfacing with the image creation program
 Cstp_int_bound_tInt_bound (range) parameter
 Cstp_lineactive_t
 Cstp_linebounds_t
 Cstp_linebufs_t
 Cstp_linecount_t
 Cstp_lineoff_t
 Cstp_module
 Cstp_module_version
 Cstp_mxml_attr_s
 Cstp_mxml_node_s
 Cstp_mxml_text_s
 Cstp_mxml_value_s
 Cstp_mxml_value_u
 Cstp_papersize_tThe papersize data type
 Cstp_param_string_tString parameter
 Cstp_parameter_tParameter description
 Cstp_pass_t
 Cstp_printfuncs_t
 Cstp_raw_tRaw parameter
 Cstp_shade
 Cstp_weave_t
+
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/array_8h.html b/doc/gutenprint/html/array_8h.html new file mode 100644 index 0000000..3ee4879 --- /dev/null +++ b/doc/gutenprint/html/array_8h.html @@ -0,0 +1,109 @@ + + + + + + + +libgutenprint API Reference: include/gutenprint/array.h File Reference + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + + +
+
+
+Typedefs | +Functions
+
+
array.h File Reference
+
+
+ +

Array functions. +More...

+
#include <gutenprint/sequence.h>
+
+ + + + +

+Typedefs

typedef struct stp_array stp_array_t
 The array opaque data type. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

stp_array_t * stp_array_create (int x_size, int y_size)
 Create a new array. More...
 
void stp_array_destroy (stp_array_t *array)
 Destroy an array. More...
 
void stp_array_copy (stp_array_t *dest, const stp_array_t *source)
 Copy an array. More...
 
stp_array_t * stp_array_create_copy (const stp_array_t *array)
 Copy and allocate an array. More...
 
void stp_array_set_size (stp_array_t *array, int x_size, int y_size)
 Resize an array. More...
 
void stp_array_get_size (const stp_array_t *array, int *x_size, int *y_size)
 Get the size of an array. More...
 
void stp_array_set_data (stp_array_t *array, const double *data)
 Set the data in an array. More...
 
void stp_array_get_data (const stp_array_t *array, size_t *size, const double **data)
 Get the data in an array. More...
 
int stp_array_set_point (stp_array_t *array, int x, int y, double data)
 Set the data at a single point in the array. More...
 
int stp_array_get_point (const stp_array_t *array, int x, int y, double *data)
 Get the data at a single point in the array. More...
 
const stp_sequence_t * stp_array_get_sequence (const stp_array_t *array)
 Get the underlying stp_sequence_t. More...
 
+

Detailed Description

+

Array functions.

+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/bc_s.png b/doc/gutenprint/html/bc_s.png new file mode 100644 index 0000000..224b29a Binary files /dev/null and b/doc/gutenprint/html/bc_s.png differ diff --git a/doc/gutenprint/html/bdwn.png b/doc/gutenprint/html/bdwn.png new file mode 100644 index 0000000..940a0b9 Binary files /dev/null and b/doc/gutenprint/html/bdwn.png differ diff --git a/doc/gutenprint/html/bit-ops_8h.html b/doc/gutenprint/html/bit-ops_8h.html new file mode 100644 index 0000000..ac211b5 --- /dev/null +++ b/doc/gutenprint/html/bit-ops_8h.html @@ -0,0 +1,885 @@ + + + + + + + +libgutenprint API Reference: include/gutenprint/bit-ops.h File Reference + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + + +
+
+
+Functions
+
+
bit-ops.h File Reference
+
+
+ +

Bit operations. +More...

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

void stp_fold (const unsigned char *line, int single_length, unsigned char *outbuf)
 Interleave a buffer consisting of two bit strings of length single_length into one string of packed two-bit ints. More...
 
void stp_fold_3bit (const unsigned char *line, int single_length, unsigned char *outbuf)
 Interleave a buffer consisting of three bit strings of length single_length into one string of packed three-bit ints. More...
 
void stp_fold_3bit_323 (const unsigned char *line, int single_length, unsigned char *outbuf)
 Interleave a buffer consisting of three bit strings of length single_length into one string of packed three-bit ints. More...
 
void stp_fold_4bit (const unsigned char *line, int single_length, unsigned char *outbuf)
 Interleave a buffer consisting of four bit strings of length single_length into one string of packed four-bit ints. More...
 
void stp_fold_8bit (const unsigned char *line, int single_length, unsigned char *outbuf)
 Interleave a buffer consisting of eight bit strings of length single_length into one string of packed eight-bit ints. More...
 
void stp_split (int height, int bits, int n, const unsigned char *in, int stride, unsigned char **outs)
 Split an input sequence of packed 1 or 2 bit integers into two or more outputs of equal length, distributing non-zero integers round robin into each output. More...
 
void stp_split_2 (int height, int bits, const unsigned char *in, unsigned char *outhi, unsigned char *outlo)
 Deprecated – use stp_split. More...
 
void stp_split_4 (int height, int bits, const unsigned char *in, unsigned char *out0, unsigned char *out1, unsigned char *out2, unsigned char *out3)
 Deprecated – use stp_split. More...
 
void stp_unpack (int height, int bits, int n, const unsigned char *in, unsigned char **outs)
 Unpack an input sequence of packed 1 or 2 bit integers into two or more outputs of equal length. More...
 
void stp_unpack_2 (int height, int bits, const unsigned char *in, unsigned char *outlo, unsigned char *outhi)
 Deprecated – use stp_unpack. More...
 
void stp_unpack_4 (int height, int bits, const unsigned char *in, unsigned char *out0, unsigned char *out1, unsigned char *out2, unsigned char *out3)
 Deprecated – use stp_unpack. More...
 
void stp_unpack_8 (int height, int bits, const unsigned char *in, unsigned char *out0, unsigned char *out1, unsigned char *out2, unsigned char *out3, unsigned char *out4, unsigned char *out5, unsigned char *out6, unsigned char *out7)
 Deprecated – use stp_unpack. More...
 
void stp_unpack_16 (int height, int bits, const unsigned char *in, unsigned char *out0, unsigned char *out1, unsigned char *out2, unsigned char *out3, unsigned char *out4, unsigned char *out5, unsigned char *out6, unsigned char *out7, unsigned char *out8, unsigned char *out9, unsigned char *out10, unsigned char *out11, unsigned char *out12, unsigned char *out13, unsigned char *out14, unsigned char *out15)
 Deprecated – use stp_unpack. More...
 
+

Detailed Description

+

Bit operations.

+

Function Documentation

+ +

◆ stp_fold()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_fold (const unsigned char * line,
int single_length,
unsigned char * outbuf 
)
+
+ +

Interleave a buffer consisting of two bit strings of length single_length into one string of packed two-bit ints.

+
Parameters
+ + + + +
linethe input bit string
single_lengththe length (in bytes) of the input
outbufthe output.
+
+
+ +
+
+ +

◆ stp_fold_3bit()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_fold_3bit (const unsigned char * line,
int single_length,
unsigned char * outbuf 
)
+
+ +

Interleave a buffer consisting of three bit strings of length single_length into one string of packed three-bit ints.

+
Parameters
+ + + + +
linethe input bit string
single_lengththe length (in bytes) of the input
outbufthe output.
+
+
+ +
+
+ +

◆ stp_fold_3bit_323()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_fold_3bit_323 (const unsigned char * line,
int single_length,
unsigned char * outbuf 
)
+
+ +

Interleave a buffer consisting of three bit strings of length single_length into one string of packed three-bit ints.

+
Parameters
+ + + + +
linethe input bit string
single_lengththe length (in bytes) of the input
outbufthe output.
+
+
+ +
+
+ +

◆ stp_fold_4bit()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_fold_4bit (const unsigned char * line,
int single_length,
unsigned char * outbuf 
)
+
+ +

Interleave a buffer consisting of four bit strings of length single_length into one string of packed four-bit ints.

+
Parameters
+ + + + +
linethe input bit string
single_lengththe length (in bytes) of the input
outbufthe output.
+
+
+ +
+
+ +

◆ stp_fold_8bit()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_fold_8bit (const unsigned char * line,
int single_length,
unsigned char * outbuf 
)
+
+ +

Interleave a buffer consisting of eight bit strings of length single_length into one string of packed eight-bit ints.

+
Parameters
+ + + + +
linethe input bit string
single_lengththe length (in bytes) of the input
outbufthe output.
+
+
+ +
+
+ +

◆ stp_split()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_split (int height,
int bits,
int n,
const unsigned char * in,
int stride,
unsigned char ** outs 
)
+
+ +

Split an input sequence of packed 1 or 2 bit integers into two or more outputs of equal length, distributing non-zero integers round robin into each output.

+

Used in "high quality" modes when extra passes are made, to ensure that each pass gets an equal number of ink drops. Each output is as long as the input.

+
Parameters
+ + + + + + + +
heightthe number of integers in the input divided by 8
bitsthe bit depth (1 or 2)
nthe number of outputs into which the input should be distributed
inthe input bit string
stridethe stride across the outputs (if it's necessary to distribute the input over non-contiguous members of the array of outputs)
outsthe array of output bit strings
+
+
+ +
+
+ +

◆ stp_split_2()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_split_2 (int height,
int bits,
const unsigned char * in,
unsigned char * outhi,
unsigned char * outlo 
)
+
+ +

Deprecated – use stp_split.

+ +
+
+ +

◆ stp_split_4()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_split_4 (int height,
int bits,
const unsigned char * in,
unsigned char * out0,
unsigned char * out1,
unsigned char * out2,
unsigned char * out3 
)
+
+ +

Deprecated – use stp_split.

+ +
+
+ +

◆ stp_unpack()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_unpack (int height,
int bits,
int n,
const unsigned char * in,
unsigned char ** outs 
)
+
+ +

Unpack an input sequence of packed 1 or 2 bit integers into two or more outputs of equal length.

+

The input is round robined into the outputs. Each output is 1/n as long as the input.

+
Parameters
+ + + + + + +
heightthe number of integers in the input divided by 8
bitsthe bit depth (1 or 2)
nthe number of outputs into which the input should be distributed
inthe input bit string
outsthe array of output bit strings
+
+
+ +
+
+ +

◆ stp_unpack_16()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_unpack_16 (int height,
int bits,
const unsigned char * in,
unsigned char * out0,
unsigned char * out1,
unsigned char * out2,
unsigned char * out3,
unsigned char * out4,
unsigned char * out5,
unsigned char * out6,
unsigned char * out7,
unsigned char * out8,
unsigned char * out9,
unsigned char * out10,
unsigned char * out11,
unsigned char * out12,
unsigned char * out13,
unsigned char * out14,
unsigned char * out15 
)
+
+ +

Deprecated – use stp_unpack.

+ +
+
+ +

◆ stp_unpack_2()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_unpack_2 (int height,
int bits,
const unsigned char * in,
unsigned char * outlo,
unsigned char * outhi 
)
+
+ +

Deprecated – use stp_unpack.

+ +
+
+ +

◆ stp_unpack_4()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_unpack_4 (int height,
int bits,
const unsigned char * in,
unsigned char * out0,
unsigned char * out1,
unsigned char * out2,
unsigned char * out3 
)
+
+ +

Deprecated – use stp_unpack.

+ +
+
+ +

◆ stp_unpack_8()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_unpack_8 (int height,
int bits,
const unsigned char * in,
unsigned char * out0,
unsigned char * out1,
unsigned char * out2,
unsigned char * out3,
unsigned char * out4,
unsigned char * out5,
unsigned char * out6,
unsigned char * out7 
)
+
+ +

Deprecated – use stp_unpack.

+ +
+
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/channel_8h.html b/doc/gutenprint/html/channel_8h.html new file mode 100644 index 0000000..73c4f2b --- /dev/null +++ b/doc/gutenprint/html/channel_8h.html @@ -0,0 +1,775 @@ + + + + + + + +libgutenprint API Reference: include/gutenprint/channel.h File Reference + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + + +
+
+
+Functions
+
+
channel.h File Reference
+
+
+ +

Channel functions. +More...

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

void stp_channel_reset (stp_vars_t *v)
 
void stp_channel_reset_channel (stp_vars_t *v, int channel)
 
void stp_channel_add (stp_vars_t *v, unsigned channel, unsigned subchannel, double value)
 
double stp_channel_get_value (stp_vars_t *v, unsigned channel, unsigned subchannel)
 
void stp_channel_set_density_adjustment (stp_vars_t *v, int color, int subchannel, double adjustment)
 
double stp_channel_get_density_adjustment (stp_vars_t *v, int color, int subchannel)
 
void stp_channel_set_ink_limit (stp_vars_t *v, double limit)
 
double stp_channel_get_ink_limit (stp_vars_t *v)
 
void stp_channel_set_cutoff_adjustment (stp_vars_t *v, int color, int subchannel, double adjustment)
 
double stp_channel_get_cutoff_adjustment (stp_vars_t *v, int color, int subchannel)
 
void stp_channel_set_black_channel (stp_vars_t *v, int channel)
 
int stp_channel_get_black_channel (stp_vars_t *v)
 
void stp_channel_set_gloss_channel (stp_vars_t *v, int channel)
 
int stp_channel_get_gloss_channel (stp_vars_t *v)
 
void stp_channel_set_gloss_limit (stp_vars_t *v, double limit)
 
double stp_channel_get_gloss_limit (stp_vars_t *v)
 
void stp_channel_set_curve (stp_vars_t *v, int channel, const stp_curve_t *curve)
 
const stp_curve_t * stp_channel_get_curve (stp_vars_t *v, int channel)
 
void stp_channel_set_gcr_curve (stp_vars_t *v, const stp_curve_t *curve)
 
const stp_curve_t * stp_channel_get_gcr_curve (stp_vars_t *v)
 
void stp_channel_initialize (stp_vars_t *v, stp_image_t *image, int input_channel_count)
 
void stp_channel_convert (const stp_vars_t *v, unsigned *zero_mask)
 
unsigned short * stp_channel_get_input (const stp_vars_t *v)
 
unsigned short * stp_channel_get_output (const stp_vars_t *v)
 
+

Detailed Description

+

Channel functions.

+

Function Documentation

+ +

◆ stp_channel_add()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_channel_add (stp_vars_t * v,
unsigned channel,
unsigned subchannel,
double value 
)
+
+ +
+
+ +

◆ stp_channel_convert()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_channel_convert (const stp_vars_t * v,
unsigned * zero_mask 
)
+
+ +
+
+ +

◆ stp_channel_get_black_channel()

+ +
+
+ + + + + + + + +
int stp_channel_get_black_channel (stp_vars_t * v)
+
+ +
+
+ +

◆ stp_channel_get_curve()

+ +
+
+ + + + + + + + + + + + + + + + + + +
const stp_curve_t* stp_channel_get_curve (stp_vars_t * v,
int channel 
)
+
+ +
+
+ +

◆ stp_channel_get_cutoff_adjustment()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
double stp_channel_get_cutoff_adjustment (stp_vars_t * v,
int color,
int subchannel 
)
+
+ +
+
+ +

◆ stp_channel_get_density_adjustment()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
double stp_channel_get_density_adjustment (stp_vars_t * v,
int color,
int subchannel 
)
+
+ +
+
+ +

◆ stp_channel_get_gcr_curve()

+ +
+
+ + + + + + + + +
const stp_curve_t* stp_channel_get_gcr_curve (stp_vars_t * v)
+
+ +
+
+ +

◆ stp_channel_get_gloss_channel()

+ +
+
+ + + + + + + + +
int stp_channel_get_gloss_channel (stp_vars_t * v)
+
+ +
+
+ +

◆ stp_channel_get_gloss_limit()

+ +
+
+ + + + + + + + +
double stp_channel_get_gloss_limit (stp_vars_t * v)
+
+ +
+
+ +

◆ stp_channel_get_ink_limit()

+ +
+
+ + + + + + + + +
double stp_channel_get_ink_limit (stp_vars_t * v)
+
+ +
+
+ +

◆ stp_channel_get_input()

+ +
+
+ + + + + + + + +
unsigned short* stp_channel_get_input (const stp_vars_t * v)
+
+ +
+
+ +

◆ stp_channel_get_output()

+ +
+
+ + + + + + + + +
unsigned short* stp_channel_get_output (const stp_vars_t * v)
+
+ +
+
+ +

◆ stp_channel_get_value()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
double stp_channel_get_value (stp_vars_t * v,
unsigned channel,
unsigned subchannel 
)
+
+ +
+
+ +

◆ stp_channel_initialize()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_channel_initialize (stp_vars_t * v,
stp_image_t * image,
int input_channel_count 
)
+
+ +
+
+ +

◆ stp_channel_reset()

+ +
+
+ + + + + + + + +
void stp_channel_reset (stp_vars_t * v)
+
+ +
+
+ +

◆ stp_channel_reset_channel()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_channel_reset_channel (stp_vars_t * v,
int channel 
)
+
+ +
+
+ +

◆ stp_channel_set_black_channel()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_channel_set_black_channel (stp_vars_t * v,
int channel 
)
+
+ +
+
+ +

◆ stp_channel_set_curve()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_channel_set_curve (stp_vars_t * v,
int channel,
const stp_curve_t * curve 
)
+
+ +
+
+ +

◆ stp_channel_set_cutoff_adjustment()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_channel_set_cutoff_adjustment (stp_vars_t * v,
int color,
int subchannel,
double adjustment 
)
+
+ +
+
+ +

◆ stp_channel_set_density_adjustment()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_channel_set_density_adjustment (stp_vars_t * v,
int color,
int subchannel,
double adjustment 
)
+
+ +
+
+ +

◆ stp_channel_set_gcr_curve()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_channel_set_gcr_curve (stp_vars_t * v,
const stp_curve_t * curve 
)
+
+ +
+
+ +

◆ stp_channel_set_gloss_channel()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_channel_set_gloss_channel (stp_vars_t * v,
int channel 
)
+
+ +
+
+ +

◆ stp_channel_set_gloss_limit()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_channel_set_gloss_limit (stp_vars_t * v,
double limit 
)
+
+ +
+
+ +

◆ stp_channel_set_ink_limit()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_channel_set_ink_limit (stp_vars_t * v,
double limit 
)
+
+ +
+
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/classes.html b/doc/gutenprint/html/classes.html new file mode 100644 index 0000000..4bfa9c1 --- /dev/null +++ b/doc/gutenprint/html/classes.html @@ -0,0 +1,68 @@ + + + + + + + +libgutenprint API Reference: Data Structure Index + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+
+
Data Structure Index
+
+
+
d | s
+ + + + + + + + + + +
  d  
+		stp_curve_point_t   stp_int_bound_t   stp_mxml_attr_s   stp_pass_t   
stp_dither_matrix_generic   stp_lineactive_t   stp_mxml_node_s   stp_printfuncs_t   
dither_matrix_impl   stp_dither_matrix_normal   stp_linebounds_t   stp_mxml_text_s   stp_raw_t   
  s  
+		stp_dither_matrix_short   stp_linebufs_t   stp_mxml_value_s   stp_shade   
stp_dotsize   stp_linecount_t   stp_mxml_value_u   stp_weave_t   
stp_cached_curve_t   stp_double_bound_t   stp_lineoff_t   stp_papersize_t   
stp_color   stp_family   stp_module   stp_param_string_t   
stp_colorfuncs_t   stp_image   stp_module_version   stp_parameter_t   
+
d | s
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/closed.png b/doc/gutenprint/html/closed.png new file mode 100644 index 0000000..98cc2c9 Binary files /dev/null and b/doc/gutenprint/html/closed.png differ diff --git a/doc/gutenprint/html/color_8h.html b/doc/gutenprint/html/color_8h.html new file mode 100644 index 0000000..4a57d55 --- /dev/null +++ b/doc/gutenprint/html/color_8h.html @@ -0,0 +1,111 @@ + + + + + + + +libgutenprint API Reference: include/gutenprint/color.h File Reference + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + + +
+
+
+Data Structures | +Typedefs | +Functions
+
+
color.h File Reference
+
+
+ +

Color functions. +More...

+ + + + + + +

+Data Structures

struct  stp_colorfuncs_t
 
struct  stp_color
 
+ + + +

+Typedefs

typedef struct stp_color stp_color_t
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

int stp_color_init (stp_vars_t *v, stp_image_t *image, size_t steps)
 
int stp_color_get_row (stp_vars_t *v, stp_image_t *image, int row, unsigned *zero_mask)
 
stp_parameter_list_t stp_color_list_parameters (const stp_vars_t *v)
 
void stp_color_describe_parameter (const stp_vars_t *v, const char *name, stp_parameter_t *description)
 
int stp_color_register (const stp_color_t *color)
 
int stp_color_unregister (const stp_color_t *color)
 
int stp_color_count (void)
 Get the number of available color modules. More...
 
const stp_color_t * stp_get_color_by_name (const char *name)
 Get a color module by its name. More...
 
const stp_color_t * stp_get_color_by_index (int idx)
 Get a color module by its index number. More...
 
const stp_color_t * stp_get_color_by_colorfuncs (stp_colorfuncs_t *colorfuncs)
 
const char * stp_color_get_name (const stp_color_t *c)
 Get the short (untranslated) name of a color module. More...
 
const char * stp_color_get_long_name (const stp_color_t *c)
 Get the long (translated) name of a color module. More...
 
+

Detailed Description

+

Color functions.

+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/curve-cache_8h.html b/doc/gutenprint/html/curve-cache_8h.html new file mode 100644 index 0000000..9f9504e --- /dev/null +++ b/doc/gutenprint/html/curve-cache_8h.html @@ -0,0 +1,371 @@ + + + + + + + +libgutenprint API Reference: include/gutenprint/curve-cache.h File Reference + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + + +
+
+
+Data Structures | +Macros | +Functions
+
+
curve-cache.h File Reference
+
+
+ +

Curve caching functions. +More...

+
#include <gutenprint/curve.h>
+
+ + + +

+Data Structures

struct  stp_cached_curve_t
 
+ + + + + + + +

+Macros

#define CURVE_CACHE_FAST_USHORT(cache)   ((cache)->s_cache)
 
#define CURVE_CACHE_FAST_DOUBLE(cache)   ((cache)->d_cache)
 
#define CURVE_CACHE_FAST_COUNT(cache)   ((cache)->count)
 
+ + + + + + + + + + + + + + + + + + + + + +

+Functions

void stp_curve_free_curve_cache (stp_cached_curve_t *cache)
 
void stp_curve_cache_curve_data (stp_cached_curve_t *cache)
 
stp_curve_t * stp_curve_cache_get_curve (stp_cached_curve_t *cache)
 
void stp_curve_cache_curve_invalidate (stp_cached_curve_t *cache)
 
void stp_curve_cache_set_curve (stp_cached_curve_t *cache, stp_curve_t *curve)
 
void stp_curve_cache_set_curve_copy (stp_cached_curve_t *cache, const stp_curve_t *curve)
 
size_t stp_curve_cache_get_count (stp_cached_curve_t *cache)
 
const unsigned short * stp_curve_cache_get_ushort_data (stp_cached_curve_t *cache)
 
const double * stp_curve_cache_get_double_data (stp_cached_curve_t *cache)
 
void stp_curve_cache_copy (stp_cached_curve_t *dest, const stp_cached_curve_t *src)
 
+

Detailed Description

+

Curve caching functions.

+

Macro Definition Documentation

+ +

◆ CURVE_CACHE_FAST_COUNT

+ +
+
+ + + + + + + + +
#define CURVE_CACHE_FAST_COUNT( cache)   ((cache)->count)
+
+ +
+
+ +

◆ CURVE_CACHE_FAST_DOUBLE

+ +
+
+ + + + + + + + +
#define CURVE_CACHE_FAST_DOUBLE( cache)   ((cache)->d_cache)
+
+ +
+
+ +

◆ CURVE_CACHE_FAST_USHORT

+ +
+
+ + + + + + + + +
#define CURVE_CACHE_FAST_USHORT( cache)   ((cache)->s_cache)
+
+ +
+
+

Function Documentation

+ +

◆ stp_curve_cache_copy()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_curve_cache_copy (stp_cached_curve_t * dest,
const stp_cached_curve_t * src 
)
+
+ +
+
+ +

◆ stp_curve_cache_curve_data()

+ +
+
+ + + + + + + + +
void stp_curve_cache_curve_data (stp_cached_curve_t * cache)
+
+ +
+
+ +

◆ stp_curve_cache_curve_invalidate()

+ +
+
+ + + + + + + + +
void stp_curve_cache_curve_invalidate (stp_cached_curve_t * cache)
+
+ +
+
+ +

◆ stp_curve_cache_get_count()

+ +
+
+ + + + + + + + +
size_t stp_curve_cache_get_count (stp_cached_curve_t * cache)
+
+ +
+
+ +

◆ stp_curve_cache_get_curve()

+ +
+
+ + + + + + + + +
stp_curve_t* stp_curve_cache_get_curve (stp_cached_curve_t * cache)
+
+ +
+
+ +

◆ stp_curve_cache_get_double_data()

+ +
+
+ + + + + + + + +
const double* stp_curve_cache_get_double_data (stp_cached_curve_t * cache)
+
+ +
+
+ +

◆ stp_curve_cache_get_ushort_data()

+ +
+
+ + + + + + + + +
const unsigned short* stp_curve_cache_get_ushort_data (stp_cached_curve_t * cache)
+
+ +
+
+ +

◆ stp_curve_cache_set_curve()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_curve_cache_set_curve (stp_cached_curve_t * cache,
stp_curve_t * curve 
)
+
+ +
+
+ +

◆ stp_curve_cache_set_curve_copy()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_curve_cache_set_curve_copy (stp_cached_curve_t * cache,
const stp_curve_t * curve 
)
+
+ +
+
+ +

◆ stp_curve_free_curve_cache()

+ +
+
+ + + + + + + + +
void stp_curve_free_curve_cache (stp_cached_curve_t * cache)
+
+ +
+
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/curve_8h.html b/doc/gutenprint/html/curve_8h.html new file mode 100644 index 0000000..5de02bd --- /dev/null +++ b/doc/gutenprint/html/curve_8h.html @@ -0,0 +1,253 @@ + + + + + + + +libgutenprint API Reference: include/gutenprint/curve.h File Reference + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + + +
+
+
+Data Structures | +Typedefs | +Enumerations | +Functions
+
+
curve.h File Reference
+
+
+ +

Curve functions. +More...

+
#include <stdio.h>
+#include <stdlib.h>
+#include <gutenprint/sequence.h>
+
+ + + + +

+Data Structures

struct  stp_curve_point_t
 Point (x,y) for piecewise curve. More...
 
+ + + + +

+Typedefs

typedef struct stp_curve stp_curve_t
 The curve opaque data type. More...
 
+ + + + + + + + + + + + + +

+Enumerations

enum  stp_curve_type_t { STP_CURVE_TYPE_LINEAR, +STP_CURVE_TYPE_SPLINE + }
 Curve types. More...
 
enum  stp_curve_wrap_mode_t { STP_CURVE_WRAP_NONE, +STP_CURVE_WRAP_AROUND + }
 Wrapping mode. More...
 
enum  stp_curve_compose_t { STP_CURVE_COMPOSE_ADD, +STP_CURVE_COMPOSE_MULTIPLY, +STP_CURVE_COMPOSE_EXPONENTIATE + }
 Composition types. More...
 
enum  stp_curve_bounds_t { STP_CURVE_BOUNDS_RESCALE, +STP_CURVE_BOUNDS_CLIP, +STP_CURVE_BOUNDS_ERROR + }
 Behaviour when curve exceeds bounds. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

stp_curve_t * stp_curve_create (stp_curve_wrap_mode_t wrap)
 Create a new curve. More...
 
stp_curve_t * stp_curve_create_copy (const stp_curve_t *curve)
 Copy and allocate a curve. More...
 
void stp_curve_copy (stp_curve_t *dest, const stp_curve_t *source)
 Copy a curve. More...
 
stp_curve_t * stp_curve_create_reverse (const stp_curve_t *curve)
 Reverse and allocate a curve. More...
 
void stp_curve_reverse (stp_curve_t *dest, const stp_curve_t *source)
 Reverse a curve. More...
 
void stp_curve_destroy (stp_curve_t *curve)
 Destroy an curve. More...
 
int stp_curve_set_bounds (stp_curve_t *curve, double low, double high)
 Set the lower and upper bounds on a curve. More...
 
void stp_curve_get_bounds (const stp_curve_t *curve, double *low, double *high)
 Get the lower and upper bounds on a curve. More...
 
stp_curve_wrap_mode_t stp_curve_get_wrap (const stp_curve_t *curve)
 Get the wrapping mode. More...
 
int stp_curve_is_piecewise (const stp_curve_t *curve)
 Determine whether the curve is piecewise. More...
 
void stp_curve_get_range (const stp_curve_t *curve, double *low, double *high)
 
size_t stp_curve_count_points (const stp_curve_t *curve)
 Get the number of allocated points in the curve. More...
 
int stp_curve_set_interpolation_type (stp_curve_t *curve, stp_curve_type_t itype)
 Set the curve interpolation type. More...
 
stp_curve_type_t stp_curve_get_interpolation_type (const stp_curve_t *curve)
 Get the curve interpolation type. More...
 
int stp_curve_set_data (stp_curve_t *curve, size_t count, const double *data)
 Set all data points of the curve. More...
 
int stp_curve_set_data_points (stp_curve_t *curve, size_t count, const stp_curve_point_t *data)
 Set all data points of the curve. More...
 
int stp_curve_set_float_data (stp_curve_t *curve, size_t count, const float *data)
 Set the data points in a curve from float values. More...
 
int stp_curve_set_long_data (stp_curve_t *curve, size_t count, const long *data)
 Set the data points in a curve from long values. More...
 
int stp_curve_set_ulong_data (stp_curve_t *curve, size_t count, const unsigned long *data)
 Set the data points in a curve from unsigned long values. More...
 
int stp_curve_set_int_data (stp_curve_t *curve, size_t count, const int *data)
 Set the data points in a curve from integer values. More...
 
int stp_curve_set_uint_data (stp_curve_t *curve, size_t count, const unsigned int *data)
 Set the data points in a curve from unsigned integer values. More...
 
int stp_curve_set_short_data (stp_curve_t *curve, size_t count, const short *data)
 Set the data points in a curve from short values. More...
 
int stp_curve_set_ushort_data (stp_curve_t *curve, size_t count, const unsigned short *data)
 Set the data points in a curve from unsigned short values. More...
 
stp_curve_t * stp_curve_get_subrange (const stp_curve_t *curve, size_t start, size_t count)
 Get a curve containing a subrange of data. More...
 
int stp_curve_set_subrange (stp_curve_t *curve, const stp_curve_t *range, size_t start)
 
const double * stp_curve_get_data (const stp_curve_t *curve, size_t *count)
 Get a pointer to the curve's raw data. More...
 
const stp_curve_point_t * stp_curve_get_data_points (const stp_curve_t *curve, size_t *count)
 Get a pointer to the curve's raw data as points. More...
 
const float * stp_curve_get_float_data (const stp_curve_t *curve, size_t *count)
 Get pointer to the curve's raw data as floats. More...
 
const long * stp_curve_get_long_data (const stp_curve_t *curve, size_t *count)
 Get pointer to the curve's raw data as longs. More...
 
const unsigned long * stp_curve_get_ulong_data (const stp_curve_t *curve, size_t *count)
 Get pointer to the curve's raw data as unsigned longs. More...
 
const int * stp_curve_get_int_data (const stp_curve_t *curve, size_t *count)
 Get pointer to the curve's raw data as integers. More...
 
const unsigned int * stp_curve_get_uint_data (const stp_curve_t *curve, size_t *count)
 Get pointer to the curve's raw data as unsigned integers. More...
 
const short * stp_curve_get_short_data (const stp_curve_t *curve, size_t *count)
 Get pointer to the curve's raw data as shorts. More...
 
const unsigned short * stp_curve_get_ushort_data (const stp_curve_t *curve, size_t *count)
 Get pointer to the curve's raw data as unsigned shorts. More...
 
const stp_sequence_t * stp_curve_get_sequence (const stp_curve_t *curve)
 Get the underlying stp_sequence_t data structure which stp_curve_t is derived from. More...
 
int stp_curve_set_gamma (stp_curve_t *curve, double f_gamma)
 Set the gamma of a curve. More...
 
double stp_curve_get_gamma (const stp_curve_t *curve)
 Get the gamma value of the curve. More...
 
int stp_curve_set_point (stp_curve_t *curve, size_t where, double data)
 Set a point along the curve. More...
 
int stp_curve_get_point (const stp_curve_t *curve, size_t where, double *data)
 Get a point along the curve. More...
 
int stp_curve_interpolate_value (const stp_curve_t *curve, double where, double *result)
 Interpolate a point along the curve. More...
 
int stp_curve_resample (stp_curve_t *curve, size_t points)
 Resample a curve (change the number of points). More...
 
int stp_curve_rescale (stp_curve_t *curve, double scale, stp_curve_compose_t mode, stp_curve_bounds_t bounds_mode)
 Rescale a curve (multiply all points by a scaling constant). More...
 
int stp_curve_write (FILE *file, const stp_curve_t *curve)
 Write a curve to a file. More...
 
char * stp_curve_write_string (const stp_curve_t *curve)
 Write a curve to a string. More...
 
stp_curve_t * stp_curve_create_from_stream (FILE *fp)
 Create a curve from a stream. More...
 
stp_curve_t * stp_curve_create_from_file (const char *file)
 Create a curve from a stream. More...
 
stp_curve_t * stp_curve_create_from_string (const char *string)
 Create a curve from a string. More...
 
int stp_curve_compose (stp_curve_t **retval, stp_curve_t *a, stp_curve_t *b, stp_curve_compose_t mode, int points)
 Compose two curves, creating a third curve. More...
 
+

Detailed Description

+

Curve functions.

+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/deprecated.html b/doc/gutenprint/html/deprecated.html new file mode 100644 index 0000000..f9f718d --- /dev/null +++ b/doc/gutenprint/html/deprecated.html @@ -0,0 +1,59 @@ + + + + + + + +libgutenprint API Reference: Deprecated List + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+
+
Deprecated List
+
+
+
+
Global stp_get_printer_index_by_driver (const char *driver)
+
There should never be any need to use this function.
+
Global stp_merge_printvars (stp_vars_t *user, const stp_vars_t *print)
+
This is likely to go away.
+
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/dir_1aca62f7c2d1ca2bd7aa79274e259f3c.html b/doc/gutenprint/html/dir_1aca62f7c2d1ca2bd7aa79274e259f3c.html new file mode 100644 index 0000000..236d502 --- /dev/null +++ b/doc/gutenprint/html/dir_1aca62f7c2d1ca2bd7aa79274e259f3c.html @@ -0,0 +1,136 @@ + + + + + + + +libgutenprint API Reference: include/gutenprint Directory Reference + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + + +
+
+
+
gutenprint Directory Reference
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Files

file  array.h
 Array functions.
 
file  bit-ops.h
 Bit operations.
 
file  channel.h
 Channel functions.
 
file  color.h
 Color functions.
 
file  curve-cache.h
 Curve caching functions.
 
file  curve.h
 Curve functions.
 
file  dither.h
 Dither functions.
 
file  gutenprint-intl-internal.h
 Internationalisation functions.
 
file  gutenprint-intl.h
 Internationalisation functions.
 
file  gutenprint-module.h
 Gutenprint module header.
 
file  gutenprint-version.h
 Version functions.
 
file  gutenprint.h
 Gutenprint master header.
 
file  image.h
 Image functions.
 
file  list.h
 Generic list functions.
 
file  module.h
 Module functions.
 
file  mxml.h
 Mini-XML XML parsing functions.
 
file  paper.h
 Paper size functions.
 
file  path.h
 Simple directory path functions.
 
file  printers.h
 Printer functions.
 
file  sequence.h
 Sequence functions.
 
file  string-list.h
 String list functions.
 
file  util.h
 Utility functions.
 
file  vars.h
 Print job functions.
 
file  weave.h
 Softweave functions.
 
file  xml.h
 XML tree functions.
 
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/dir_d44c64559bbebec7f509842c48db8b23.html b/doc/gutenprint/html/dir_d44c64559bbebec7f509842c48db8b23.html new file mode 100644 index 0000000..faaa003 --- /dev/null +++ b/doc/gutenprint/html/dir_d44c64559bbebec7f509842c48db8b23.html @@ -0,0 +1,63 @@ + + + + + + + +libgutenprint API Reference: include Directory Reference + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + + +
+
+
+
include Directory Reference
+
+
+ + + + +

+Directories

directory  gutenprint
 
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/dither_8h.html b/doc/gutenprint/html/dither_8h.html new file mode 100644 index 0000000..efb12f5 --- /dev/null +++ b/doc/gutenprint/html/dither_8h.html @@ -0,0 +1,1495 @@ + + + + + + + +libgutenprint API Reference: include/gutenprint/dither.h File Reference + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + + +
+
+
+Data Structures | +Macros | +Typedefs | +Functions
+
+
dither.h File Reference
+
+
+ +

Dither functions. +More...

+ + + + + + + + + + + + + + +

+Data Structures

struct  stp_dither_matrix_short
 
struct  stp_dither_matrix_normal
 
struct  stp_dither_matrix_generic
 
struct  dither_matrix_impl
 
struct  stp_dotsize
 
struct  stp_shade
 
+ + + + + + + + + + + +

+Macros

#define STP_ECOLOR_K   0
 
#define STP_ECOLOR_C   1
 
#define STP_ECOLOR_M   2
 
#define STP_ECOLOR_Y   3
 
#define STP_NCOLORS   (4)
 
+ + + + + + + + + + + + + +

+Typedefs

typedef struct stp_dither_matrix_short stp_dither_matrix_short_t
 
typedef struct stp_dither_matrix_normal stp_dither_matrix_normal_t
 
typedef struct stp_dither_matrix_generic stp_dither_matrix_generic_t
 
typedef struct dither_matrix_impl stp_dither_matrix_impl_t
 
typedef struct stp_dotsize stp_dotsize_t
 
typedef struct stp_shade stp_shade_t
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

void stp_dither_matrix_iterated_init (stp_dither_matrix_impl_t *mat, size_t size, size_t exponent, const unsigned *array)
 
void stp_dither_matrix_shear (stp_dither_matrix_impl_t *mat, int x_shear, int y_shear)
 
void stp_dither_matrix_init (stp_dither_matrix_impl_t *mat, int x_size, int y_size, const unsigned int *array, int transpose, int prescaled)
 
void stp_dither_matrix_init_short (stp_dither_matrix_impl_t *mat, int x_size, int y_size, const unsigned short *array, int transpose, int prescaled)
 
int stp_dither_matrix_validate_array (const stp_array_t *array)
 
void stp_dither_matrix_init_from_dither_array (stp_dither_matrix_impl_t *mat, const stp_array_t *array, int transpose)
 
void stp_dither_matrix_destroy (stp_dither_matrix_impl_t *mat)
 
void stp_dither_matrix_clone (const stp_dither_matrix_impl_t *src, stp_dither_matrix_impl_t *dest, int x_offset, int y_offset)
 
void stp_dither_matrix_copy (const stp_dither_matrix_impl_t *src, stp_dither_matrix_impl_t *dest)
 
void stp_dither_matrix_scale_exponentially (stp_dither_matrix_impl_t *mat, double exponent)
 
void stp_dither_matrix_set_row (stp_dither_matrix_impl_t *mat, int y)
 
stp_array_t * stp_find_standard_dither_array (int x_aspect, int y_aspect)
 
stp_parameter_list_t stp_dither_list_parameters (const stp_vars_t *v)
 
void stp_dither_describe_parameter (const stp_vars_t *v, const char *name, stp_parameter_t *description)
 
void stp_dither_init (stp_vars_t *v, stp_image_t *image, int out_width, int xdpi, int ydpi)
 
void stp_dither_set_iterated_matrix (stp_vars_t *v, size_t edge, size_t iterations, const unsigned *data, int prescaled, int x_shear, int y_shear)
 
void stp_dither_set_matrix (stp_vars_t *v, const stp_dither_matrix_generic_t *mat, int transpose, int x_shear, int y_shear)
 
void stp_dither_set_matrix_from_dither_array (stp_vars_t *v, const stp_array_t *array, int transpose)
 
void stp_dither_set_transition (stp_vars_t *v, double)
 
void stp_dither_set_randomizer (stp_vars_t *v, int color, double)
 
void stp_dither_set_ink_spread (stp_vars_t *v, int spread)
 
void stp_dither_set_adaptive_limit (stp_vars_t *v, double limit)
 
int stp_dither_get_first_position (stp_vars_t *v, int color, int subchan)
 
int stp_dither_get_last_position (stp_vars_t *v, int color, int subchan)
 
void stp_dither_set_inks_simple (stp_vars_t *v, int color, int nlevels, const double *levels, double density, double darkness)
 
void stp_dither_set_inks_full (stp_vars_t *v, int color, int nshades, const stp_shade_t *shades, double density, double darkness)
 
void stp_dither_set_inks (stp_vars_t *v, int color, double density, double darkness, int nshades, const double *svalues, int ndotsizes, const double *dvalues)
 
void stp_dither_add_channel (stp_vars_t *v, unsigned char *data, unsigned channel, unsigned subchannel)
 
unsigned char * stp_dither_get_channel (stp_vars_t *v, unsigned channel, unsigned subchannel)
 
void stp_dither (stp_vars_t *v, int row, int duplicate_line, int zero_mask, const unsigned char *mask)
 
void stp_dither_internal (stp_vars_t *v, int row, const unsigned short *input, int duplicate_line, int zero_mask, const unsigned char *mask)
 
+

Detailed Description

+

Dither functions.

+

Macro Definition Documentation

+ +

◆ STP_ECOLOR_C

+ +
+
+ + + + +
#define STP_ECOLOR_C   1
+
+ +
+
+ +

◆ STP_ECOLOR_K

+ +
+
+ + + + +
#define STP_ECOLOR_K   0
+
+ +
+
+ +

◆ STP_ECOLOR_M

+ +
+
+ + + + +
#define STP_ECOLOR_M   2
+
+ +
+
+ +

◆ STP_ECOLOR_Y

+ +
+
+ + + + +
#define STP_ECOLOR_Y   3
+
+ +
+
+ +

◆ STP_NCOLORS

+ +
+
+ + + + +
#define STP_NCOLORS   (4)
+
+ +
+
+

Typedef Documentation

+ +

◆ stp_dither_matrix_generic_t

+ +
+
+ + + + +
typedef struct stp_dither_matrix_generic stp_dither_matrix_generic_t
+
+ +
+
+ +

◆ stp_dither_matrix_impl_t

+ +
+
+ + + + +
typedef struct dither_matrix_impl stp_dither_matrix_impl_t
+
+ +
+
+ +

◆ stp_dither_matrix_normal_t

+ +
+
+ + + + +
typedef struct stp_dither_matrix_normal stp_dither_matrix_normal_t
+
+ +
+
+ +

◆ stp_dither_matrix_short_t

+ +
+
+ + + + +
typedef struct stp_dither_matrix_short stp_dither_matrix_short_t
+
+ +
+
+ +

◆ stp_dotsize_t

+ +
+
+ + + + +
typedef struct stp_dotsize stp_dotsize_t
+
+ +
+
+ +

◆ stp_shade_t

+ +
+
+ + + + +
typedef struct stp_shade stp_shade_t
+
+ +
+
+

Function Documentation

+ +

◆ stp_dither()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_dither (stp_vars_t * v,
int row,
int duplicate_line,
int zero_mask,
const unsigned char * mask 
)
+
+ +
+
+ +

◆ stp_dither_add_channel()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_dither_add_channel (stp_vars_t * v,
unsigned char * data,
unsigned channel,
unsigned subchannel 
)
+
+ +
+
+ +

◆ stp_dither_describe_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_dither_describe_parameter (const stp_vars_t * v,
const char * name,
stp_parameter_t * description 
)
+
+ +
+
+ +

◆ stp_dither_get_channel()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
unsigned char* stp_dither_get_channel (stp_vars_t * v,
unsigned channel,
unsigned subchannel 
)
+
+ +
+
+ +

◆ stp_dither_get_first_position()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_dither_get_first_position (stp_vars_t * v,
int color,
int subchan 
)
+
+ +
+
+ +

◆ stp_dither_get_last_position()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_dither_get_last_position (stp_vars_t * v,
int color,
int subchan 
)
+
+ +
+
+ +

◆ stp_dither_init()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_dither_init (stp_vars_t * v,
stp_image_t * image,
int out_width,
int xdpi,
int ydpi 
)
+
+ +
+
+ +

◆ stp_dither_internal()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_dither_internal (stp_vars_t * v,
int row,
const unsigned short * input,
int duplicate_line,
int zero_mask,
const unsigned char * mask 
)
+
+ +
+
+ +

◆ stp_dither_list_parameters()

+ +
+
+ + + + + + + + +
stp_parameter_list_t stp_dither_list_parameters (const stp_vars_t * v)
+
+ +
+
+ +

◆ stp_dither_matrix_clone()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_dither_matrix_clone (const stp_dither_matrix_impl_t * src,
stp_dither_matrix_impl_t * dest,
int x_offset,
int y_offset 
)
+
+ +
+
+ +

◆ stp_dither_matrix_copy()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_dither_matrix_copy (const stp_dither_matrix_impl_t * src,
stp_dither_matrix_impl_t * dest 
)
+
+ +
+
+ +

◆ stp_dither_matrix_destroy()

+ +
+
+ + + + + + + + +
void stp_dither_matrix_destroy (stp_dither_matrix_impl_t * mat)
+
+ +
+
+ +

◆ stp_dither_matrix_init()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_dither_matrix_init (stp_dither_matrix_impl_t * mat,
int x_size,
int y_size,
const unsigned int * array,
int transpose,
int prescaled 
)
+
+ +
+
+ +

◆ stp_dither_matrix_init_from_dither_array()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_dither_matrix_init_from_dither_array (stp_dither_matrix_impl_t * mat,
const stp_array_t * array,
int transpose 
)
+
+ +
+
+ +

◆ stp_dither_matrix_init_short()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_dither_matrix_init_short (stp_dither_matrix_impl_t * mat,
int x_size,
int y_size,
const unsigned short * array,
int transpose,
int prescaled 
)
+
+ +
+
+ +

◆ stp_dither_matrix_iterated_init()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_dither_matrix_iterated_init (stp_dither_matrix_impl_t * mat,
size_t size,
size_t exponent,
const unsigned * array 
)
+
+ +
+
+ +

◆ stp_dither_matrix_scale_exponentially()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_dither_matrix_scale_exponentially (stp_dither_matrix_impl_t * mat,
double exponent 
)
+
+ +
+
+ +

◆ stp_dither_matrix_set_row()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_dither_matrix_set_row (stp_dither_matrix_impl_t * mat,
int y 
)
+
+ +
+
+ +

◆ stp_dither_matrix_shear()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_dither_matrix_shear (stp_dither_matrix_impl_t * mat,
int x_shear,
int y_shear 
)
+
+ +
+
+ +

◆ stp_dither_matrix_validate_array()

+ +
+
+ + + + + + + + +
int stp_dither_matrix_validate_array (const stp_array_t * array)
+
+ +
+
+ +

◆ stp_dither_set_adaptive_limit()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_dither_set_adaptive_limit (stp_vars_t * v,
double limit 
)
+
+ +
+
+ +

◆ stp_dither_set_ink_spread()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_dither_set_ink_spread (stp_vars_t * v,
int spread 
)
+
+ +
+
+ +

◆ stp_dither_set_inks()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_dither_set_inks (stp_vars_t * v,
int color,
double density,
double darkness,
int nshades,
const double * svalues,
int ndotsizes,
const double * dvalues 
)
+
+ +
+
+ +

◆ stp_dither_set_inks_full()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_dither_set_inks_full (stp_vars_t * v,
int color,
int nshades,
const stp_shade_t * shades,
double density,
double darkness 
)
+
+ +
+
+ +

◆ stp_dither_set_inks_simple()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_dither_set_inks_simple (stp_vars_t * v,
int color,
int nlevels,
const double * levels,
double density,
double darkness 
)
+
+ +
+
+ +

◆ stp_dither_set_iterated_matrix()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_dither_set_iterated_matrix (stp_vars_t * v,
size_t edge,
size_t iterations,
const unsigned * data,
int prescaled,
int x_shear,
int y_shear 
)
+
+ +
+
+ +

◆ stp_dither_set_matrix()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_dither_set_matrix (stp_vars_t * v,
const stp_dither_matrix_generic_t * mat,
int transpose,
int x_shear,
int y_shear 
)
+
+ +
+
+ +

◆ stp_dither_set_matrix_from_dither_array()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_dither_set_matrix_from_dither_array (stp_vars_t * v,
const stp_array_t * array,
int transpose 
)
+
+ +
+
+ +

◆ stp_dither_set_randomizer()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_dither_set_randomizer (stp_vars_t * v,
int color,
double  
)
+
+ +
+
+ +

◆ stp_dither_set_transition()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_dither_set_transition (stp_vars_t * v,
double  
)
+
+ +
+
+ +

◆ stp_find_standard_dither_array()

+ +
+
+ + + + + + + + + + + + + + + + + + +
stp_array_t* stp_find_standard_dither_array (int x_aspect,
int y_aspect 
)
+
+ +
+
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/doc.png b/doc/gutenprint/html/doc.png new file mode 100644 index 0000000..17edabf Binary files /dev/null and b/doc/gutenprint/html/doc.png differ diff --git a/doc/gutenprint/html/doxygen.css b/doc/gutenprint/html/doxygen.css new file mode 100644 index 0000000..4f1ab91 --- /dev/null +++ b/doc/gutenprint/html/doxygen.css @@ -0,0 +1,1596 @@ +/* The standard CSS for doxygen 1.8.13 */ + +body, table, div, p, dl { + font: 400 14px/22px Roboto,sans-serif; +} + +p.reference, p.definition { + font: 400 14px/22px Roboto,sans-serif; +} + +/* @group Heading Levels */ + +h1.groupheader { + font-size: 150%; +} + +.title { + font: 400 14px/28px Roboto,sans-serif; + font-size: 150%; + font-weight: bold; + margin: 10px 2px; +} + +h2.groupheader { + border-bottom: 1px solid #879ECB; + color: #354C7B; + font-size: 150%; + font-weight: normal; + margin-top: 1.75em; + padding-top: 8px; + padding-bottom: 4px; + width: 100%; +} + +h3.groupheader { + font-size: 100%; +} + +h1, h2, h3, h4, h5, h6 { + -webkit-transition: text-shadow 0.5s linear; + -moz-transition: text-shadow 0.5s linear; + -ms-transition: text-shadow 0.5s linear; + -o-transition: text-shadow 0.5s linear; + transition: text-shadow 0.5s linear; + margin-right: 15px; +} + +h1.glow, h2.glow, h3.glow, h4.glow, h5.glow, h6.glow { + text-shadow: 0 0 15px cyan; +} + +dt { + font-weight: bold; +} + +div.multicol { + -moz-column-gap: 1em; + -webkit-column-gap: 1em; + -moz-column-count: 3; + -webkit-column-count: 3; +} + +p.startli, p.startdd { + margin-top: 2px; +} + +p.starttd { + margin-top: 0px; +} + +p.endli { + margin-bottom: 0px; +} + +p.enddd { + margin-bottom: 4px; +} + +p.endtd { + margin-bottom: 2px; +} + +/* @end */ + +caption { + font-weight: bold; +} + +span.legend { + font-size: 70%; + text-align: center; +} + +h3.version { + font-size: 90%; + text-align: center; +} + +div.qindex, div.navtab{ + background-color: #EBEFF6; + border: 1px solid #A3B4D7; + text-align: center; +} + +div.qindex, div.navpath { + width: 100%; + line-height: 140%; +} + +div.navtab { + margin-right: 15px; +} + +/* @group Link Styling */ + +a { + color: #3D578C; + font-weight: normal; + text-decoration: none; +} + +.contents a:visited { + color: #4665A2; +} + +a:hover { + text-decoration: underline; +} + +a.qindex { + font-weight: bold; +} + +a.qindexHL { + font-weight: bold; + background-color: #9CAFD4; + color: #ffffff; + border: 1px double #869DCA; +} + +.contents a.qindexHL:visited { + color: #ffffff; +} + +a.el { + font-weight: bold; +} + +a.elRef { +} + +a.code, a.code:visited, a.line, a.line:visited { + color: #4665A2; +} + +a.codeRef, a.codeRef:visited, a.lineRef, a.lineRef:visited { + color: #4665A2; +} + +/* @end */ + +dl.el { + margin-left: -1cm; +} + +pre.fragment { + border: 1px solid #C4CFE5; + background-color: #FBFCFD; + padding: 4px 6px; + margin: 4px 8px 4px 2px; + overflow: auto; + word-wrap: break-word; + font-size: 9pt; + line-height: 125%; + font-family: monospace, fixed; + font-size: 105%; +} + +div.fragment { + padding: 0px; + margin: 4px 8px 4px 2px; + background-color: #FBFCFD; + border: 1px solid #C4CFE5; +} + +div.line { + font-family: monospace, fixed; + font-size: 13px; + min-height: 13px; + line-height: 1.0; + text-wrap: unrestricted; + white-space: -moz-pre-wrap; /* Moz */ + white-space: -pre-wrap; /* Opera 4-6 */ + white-space: -o-pre-wrap; /* Opera 7 */ + white-space: pre-wrap; /* CSS3 */ + word-wrap: break-word; /* IE 5.5+ */ + text-indent: -53px; + padding-left: 53px; + padding-bottom: 0px; + margin: 0px; + -webkit-transition-property: background-color, box-shadow; + -webkit-transition-duration: 0.5s; + -moz-transition-property: background-color, box-shadow; + -moz-transition-duration: 0.5s; + -ms-transition-property: background-color, box-shadow; + -ms-transition-duration: 0.5s; + -o-transition-property: background-color, box-shadow; + -o-transition-duration: 0.5s; + transition-property: background-color, box-shadow; + transition-duration: 0.5s; +} + +div.line:after { + content:"\000A"; + white-space: pre; +} + +div.line.glow { + background-color: cyan; + box-shadow: 0 0 10px cyan; +} + + +span.lineno { + padding-right: 4px; + text-align: right; + border-right: 2px solid #0F0; + background-color: #E8E8E8; + white-space: pre; +} +span.lineno a { + background-color: #D8D8D8; +} + +span.lineno a:hover { + background-color: #C8C8C8; +} + +.lineno { + -webkit-touch-callout: none; + -webkit-user-select: none; + -khtml-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; +} + +div.ah, span.ah { + background-color: black; + font-weight: bold; + color: #ffffff; + margin-bottom: 3px; + margin-top: 3px; + padding: 0.2em; + border: solid thin #333; + border-radius: 0.5em; + -webkit-border-radius: .5em; + -moz-border-radius: .5em; + box-shadow: 2px 2px 3px #999; + -webkit-box-shadow: 2px 2px 3px #999; + -moz-box-shadow: rgba(0, 0, 0, 0.15) 2px 2px 2px; + background-image: -webkit-gradient(linear, left top, left bottom, from(#eee), to(#000),color-stop(0.3, #444)); + background-image: -moz-linear-gradient(center top, #eee 0%, #444 40%, #000 110%); +} + +div.classindex ul { + list-style: none; + padding-left: 0; +} + +div.classindex span.ai { + display: inline-block; +} + +div.groupHeader { + margin-left: 16px; + margin-top: 12px; + font-weight: bold; +} + +div.groupText { + margin-left: 16px; + font-style: italic; +} + +body { + background-color: white; + color: black; + margin: 0; +} + +div.contents { + margin-top: 10px; + margin-left: 12px; + margin-right: 8px; +} + +td.indexkey { + background-color: #EBEFF6; + font-weight: bold; + border: 1px solid #C4CFE5; + margin: 2px 0px 2px 0; + padding: 2px 10px; + white-space: nowrap; + vertical-align: top; +} + +td.indexvalue { + background-color: #EBEFF6; + border: 1px solid #C4CFE5; + padding: 2px 10px; + margin: 2px 0px; +} + +tr.memlist { + background-color: #EEF1F7; +} + +p.formulaDsp { + text-align: center; +} + +img.formulaDsp { + +} + +img.formulaInl { + vertical-align: middle; +} + +div.center { + text-align: center; + margin-top: 0px; + margin-bottom: 0px; + padding: 0px; +} + +div.center img { + border: 0px; +} + +address.footer { + text-align: right; + padding-right: 12px; +} + +img.footer { + border: 0px; + vertical-align: middle; +} + +/* @group Code Colorization */ + +span.keyword { + color: #008000 +} + +span.keywordtype { + color: #604020 +} + +span.keywordflow { + color: #e08000 +} + +span.comment { + color: #800000 +} + +span.preprocessor { + color: #806020 +} + +span.stringliteral { + color: #002080 +} + +span.charliteral { + color: #008080 +} + +span.vhdldigit { + color: #ff00ff +} + +span.vhdlchar { + color: #000000 +} + +span.vhdlkeyword { + color: #700070 +} + +span.vhdllogic { + color: #ff0000 +} + +blockquote { + background-color: #F7F8FB; + border-left: 2px solid #9CAFD4; + margin: 0 24px 0 4px; + padding: 0 12px 0 16px; +} + +/* @end */ + +/* +.search { + color: #003399; + font-weight: bold; +} + +form.search { + margin-bottom: 0px; + margin-top: 0px; +} + +input.search { + font-size: 75%; + color: #000080; + font-weight: normal; + background-color: #e8eef2; +} +*/ + +td.tiny { + font-size: 75%; +} + +.dirtab { + padding: 4px; + border-collapse: collapse; + border: 1px solid #A3B4D7; +} + +th.dirtab { + background: #EBEFF6; + font-weight: bold; +} + +hr { + height: 0px; + border: none; + border-top: 1px solid #4A6AAA; +} + +hr.footer { + height: 1px; +} + +/* @group Member Descriptions */ + +table.memberdecls { + border-spacing: 0px; + padding: 0px; +} + +.memberdecls td, .fieldtable tr { + -webkit-transition-property: background-color, box-shadow; + -webkit-transition-duration: 0.5s; + -moz-transition-property: background-color, box-shadow; + -moz-transition-duration: 0.5s; + -ms-transition-property: background-color, box-shadow; + -ms-transition-duration: 0.5s; + -o-transition-property: background-color, box-shadow; + -o-transition-duration: 0.5s; + transition-property: background-color, box-shadow; + transition-duration: 0.5s; +} + +.memberdecls td.glow, .fieldtable tr.glow { + background-color: cyan; + box-shadow: 0 0 15px cyan; +} + +.mdescLeft, .mdescRight, +.memItemLeft, .memItemRight, +.memTemplItemLeft, .memTemplItemRight, .memTemplParams { + background-color: #F9FAFC; + border: none; + margin: 4px; + padding: 1px 0 0 8px; +} + +.mdescLeft, .mdescRight { + padding: 0px 8px 4px 8px; + color: #555; +} + +.memSeparator { + border-bottom: 1px solid #DEE4F0; + line-height: 1px; + margin: 0px; + padding: 0px; +} + +.memItemLeft, .memTemplItemLeft { + white-space: nowrap; +} + +.memItemRight { + width: 100%; +} + +.memTemplParams { + color: #4665A2; + white-space: nowrap; + font-size: 80%; +} + +/* @end */ + +/* @group Member Details */ + +/* Styles for detailed member documentation */ + +.memtitle { + padding: 8px; + border-top: 1px solid #A8B8D9; + border-left: 1px solid #A8B8D9; + border-right: 1px solid #A8B8D9; + border-top-right-radius: 4px; + border-top-left-radius: 4px; + margin-bottom: -1px; + background-image: url('nav_f.png'); + background-repeat: repeat-x; + background-color: #E2E8F2; + line-height: 1.25; + font-weight: 300; + float:left; +} + +.permalink +{ + font-size: 65%; + display: inline-block; + vertical-align: middle; +} + +.memtemplate { + font-size: 80%; + color: #4665A2; + font-weight: normal; + margin-left: 9px; +} + +.memnav { + background-color: #EBEFF6; + border: 1px solid #A3B4D7; + text-align: center; + margin: 2px; + margin-right: 15px; + padding: 2px; +} + +.mempage { + width: 100%; +} + +.memitem { + padding: 0; + margin-bottom: 10px; + margin-right: 5px; + -webkit-transition: box-shadow 0.5s linear; + -moz-transition: box-shadow 0.5s linear; + -ms-transition: box-shadow 0.5s linear; + -o-transition: box-shadow 0.5s linear; + transition: box-shadow 0.5s linear; + display: table !important; + width: 100%; +} + +.memitem.glow { + box-shadow: 0 0 15px cyan; +} + +.memname { + font-weight: 400; + margin-left: 6px; +} + +.memname td { + vertical-align: bottom; +} + +.memproto, dl.reflist dt { + border-top: 1px solid #A8B8D9; + border-left: 1px solid #A8B8D9; + border-right: 1px solid #A8B8D9; + padding: 6px 0px 6px 0px; + color: #253555; + font-weight: bold; + text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9); + background-color: #DFE5F1; + /* opera specific markup */ + box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15); + border-top-right-radius: 4px; + /* firefox specific markup */ + -moz-box-shadow: rgba(0, 0, 0, 0.15) 5px 5px 5px; + -moz-border-radius-topright: 4px; + /* webkit specific markup */ + -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15); + -webkit-border-top-right-radius: 4px; + +} + +.overload { + font-family: "courier new",courier,monospace; + font-size: 65%; +} + +.memdoc, dl.reflist dd { + border-bottom: 1px solid #A8B8D9; + border-left: 1px solid #A8B8D9; + border-right: 1px solid #A8B8D9; + padding: 6px 10px 2px 10px; + background-color: #FBFCFD; + border-top-width: 0; + background-image:url('nav_g.png'); + background-repeat:repeat-x; + background-color: #FFFFFF; + /* opera specific markup */ + border-bottom-left-radius: 4px; + border-bottom-right-radius: 4px; + box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15); + /* firefox specific markup */ + -moz-border-radius-bottomleft: 4px; + -moz-border-radius-bottomright: 4px; + -moz-box-shadow: rgba(0, 0, 0, 0.15) 5px 5px 5px; + /* webkit specific markup */ + -webkit-border-bottom-left-radius: 4px; + -webkit-border-bottom-right-radius: 4px; + -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15); +} + +dl.reflist dt { + padding: 5px; +} + +dl.reflist dd { + margin: 0px 0px 10px 0px; + padding: 5px; +} + +.paramkey { + text-align: right; +} + +.paramtype { + white-space: nowrap; +} + +.paramname { + color: #602020; + white-space: nowrap; +} +.paramname em { + font-style: normal; +} +.paramname code { + line-height: 14px; +} + +.params, .retval, .exception, .tparams { + margin-left: 0px; + padding-left: 0px; +} + +.params .paramname, .retval .paramname { + font-weight: bold; + vertical-align: top; +} + +.params .paramtype { + font-style: italic; + vertical-align: top; +} + +.params .paramdir { + font-family: "courier new",courier,monospace; + vertical-align: top; +} + +table.mlabels { + border-spacing: 0px; +} + +td.mlabels-left { + width: 100%; + padding: 0px; +} + +td.mlabels-right { + vertical-align: bottom; + padding: 0px; + white-space: nowrap; +} + +span.mlabels { + margin-left: 8px; +} + +span.mlabel { + background-color: #728DC1; + border-top:1px solid #5373B4; + border-left:1px solid #5373B4; + border-right:1px solid #C4CFE5; + border-bottom:1px solid #C4CFE5; + text-shadow: none; + color: white; + margin-right: 4px; + padding: 2px 3px; + border-radius: 3px; + font-size: 7pt; + white-space: nowrap; + vertical-align: middle; +} + + + +/* @end */ + +/* these are for tree view inside a (index) page */ + +div.directory { + margin: 10px 0px; + border-top: 1px solid #9CAFD4; + border-bottom: 1px solid #9CAFD4; + width: 100%; +} + +.directory table { + border-collapse:collapse; +} + +.directory td { + margin: 0px; + padding: 0px; + vertical-align: top; +} + +.directory td.entry { + white-space: nowrap; + padding-right: 6px; + padding-top: 3px; +} + +.directory td.entry a { + outline:none; +} + +.directory td.entry a img { + border: none; +} + +.directory td.desc { + width: 100%; + padding-left: 6px; + padding-right: 6px; + padding-top: 3px; + border-left: 1px solid rgba(0,0,0,0.05); +} + +.directory tr.even { + padding-left: 6px; + background-color: #F7F8FB; +} + +.directory img { + vertical-align: -30%; +} + +.directory .levels { + white-space: nowrap; + width: 100%; + text-align: right; + font-size: 9pt; +} + +.directory .levels span { + cursor: pointer; + padding-left: 2px; + padding-right: 2px; + color: #3D578C; +} + +.arrow { + color: #9CAFD4; + -webkit-user-select: none; + -khtml-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; + cursor: pointer; + font-size: 80%; + display: inline-block; + width: 16px; + height: 22px; +} + +.icon { + font-family: Arial, Helvetica; + font-weight: bold; + font-size: 12px; + height: 14px; + width: 16px; + display: inline-block; + background-color: #728DC1; + color: white; + text-align: center; + border-radius: 4px; + margin-left: 2px; + margin-right: 2px; +} + +.icona { + width: 24px; + height: 22px; + display: inline-block; +} + +.iconfopen { + width: 24px; + height: 18px; + margin-bottom: 4px; + background-image:url('folderopen.png'); + background-position: 0px -4px; + background-repeat: repeat-y; + vertical-align:top; + display: inline-block; +} + +.iconfclosed { + width: 24px; + height: 18px; + margin-bottom: 4px; + background-image:url('folderclosed.png'); + background-position: 0px -4px; + background-repeat: repeat-y; + vertical-align:top; + display: inline-block; +} + +.icondoc { + width: 24px; + height: 18px; + margin-bottom: 4px; + background-image:url('doc.png'); + background-position: 0px -4px; + background-repeat: repeat-y; + vertical-align:top; + display: inline-block; +} + +table.directory { + font: 400 14px Roboto,sans-serif; +} + +/* @end */ + +div.dynheader { + margin-top: 8px; + -webkit-touch-callout: none; + -webkit-user-select: none; + -khtml-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; +} + +address { + font-style: normal; + color: #2A3D61; +} + +table.doxtable caption { + caption-side: top; +} + +table.doxtable { + border-collapse:collapse; + margin-top: 4px; + margin-bottom: 4px; +} + +table.doxtable td, table.doxtable th { + border: 1px solid #2D4068; + padding: 3px 7px 2px; +} + +table.doxtable th { + background-color: #374F7F; + color: #FFFFFF; + font-size: 110%; + padding-bottom: 4px; + padding-top: 5px; +} + +table.fieldtable { + /*width: 100%;*/ + margin-bottom: 10px; + border: 1px solid #A8B8D9; + border-spacing: 0px; + -moz-border-radius: 4px; + -webkit-border-radius: 4px; + border-radius: 4px; + -moz-box-shadow: rgba(0, 0, 0, 0.15) 2px 2px 2px; + -webkit-box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.15); + box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.15); +} + +.fieldtable td, .fieldtable th { + padding: 3px 7px 2px; +} + +.fieldtable td.fieldtype, .fieldtable td.fieldname { + white-space: nowrap; + border-right: 1px solid #A8B8D9; + border-bottom: 1px solid #A8B8D9; + vertical-align: top; +} + +.fieldtable td.fieldname { + padding-top: 3px; +} + +.fieldtable td.fielddoc { + border-bottom: 1px solid #A8B8D9; + /*width: 100%;*/ +} + +.fieldtable td.fielddoc p:first-child { + margin-top: 0px; +} + +.fieldtable td.fielddoc p:last-child { + margin-bottom: 2px; +} + +.fieldtable tr:last-child td { + border-bottom: none; +} + +.fieldtable th { + background-image:url('nav_f.png'); + background-repeat:repeat-x; + background-color: #E2E8F2; + font-size: 90%; + color: #253555; + padding-bottom: 4px; + padding-top: 5px; + text-align:left; + font-weight: 400; + -moz-border-radius-topleft: 4px; + -moz-border-radius-topright: 4px; + -webkit-border-top-left-radius: 4px; + -webkit-border-top-right-radius: 4px; + border-top-left-radius: 4px; + border-top-right-radius: 4px; + border-bottom: 1px solid #A8B8D9; +} + + +.tabsearch { + top: 0px; + left: 10px; + height: 36px; + background-image: url('tab_b.png'); + z-index: 101; + overflow: hidden; + font-size: 13px; +} + +.navpath ul +{ + font-size: 11px; + background-image:url('tab_b.png'); + background-repeat:repeat-x; + background-position: 0 -5px; + height:30px; + line-height:30px; + color:#8AA0CC; + border:solid 1px #C2CDE4; + overflow:hidden; + margin:0px; + padding:0px; +} + +.navpath li +{ + list-style-type:none; + float:left; + padding-left:10px; + padding-right:15px; + background-image:url('bc_s.png'); + background-repeat:no-repeat; + background-position:right; + color:#364D7C; +} + +.navpath li.navelem a +{ + height:32px; + display:block; + text-decoration: none; + outline: none; + color: #283A5D; + font-family: 'Lucida Grande',Geneva,Helvetica,Arial,sans-serif; + text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9); + text-decoration: none; +} + +.navpath li.navelem a:hover +{ + color:#6884BD; +} + +.navpath li.footer +{ + list-style-type:none; + float:right; + padding-left:10px; + padding-right:15px; + background-image:none; + background-repeat:no-repeat; + background-position:right; + color:#364D7C; + font-size: 8pt; +} + + +div.summary +{ + float: right; + font-size: 8pt; + padding-right: 5px; + width: 50%; + text-align: right; +} + +div.summary a +{ + white-space: nowrap; +} + +table.classindex +{ + margin: 10px; + white-space: nowrap; + margin-left: 3%; + margin-right: 3%; + width: 94%; + border: 0; + border-spacing: 0; + padding: 0; +} + +div.ingroups +{ + font-size: 8pt; + width: 50%; + text-align: left; +} + +div.ingroups a +{ + white-space: nowrap; +} + +div.header +{ + background-image:url('nav_h.png'); + background-repeat:repeat-x; + background-color: #F9FAFC; + margin: 0px; + border-bottom: 1px solid #C4CFE5; +} + +div.headertitle +{ + padding: 5px 5px 5px 10px; +} + +dl +{ + padding: 0 0 0 10px; +} + +/* dl.note, dl.warning, dl.attention, dl.pre, dl.post, dl.invariant, dl.deprecated, dl.todo, dl.test, dl.bug */ +dl.section +{ + margin-left: 0px; + padding-left: 0px; +} + +dl.note +{ + margin-left:-7px; + padding-left: 3px; + border-left:4px solid; + border-color: #D0C000; +} + +dl.warning, dl.attention +{ + margin-left:-7px; + padding-left: 3px; + border-left:4px solid; + border-color: #FF0000; +} + +dl.pre, dl.post, dl.invariant +{ + margin-left:-7px; + padding-left: 3px; + border-left:4px solid; + border-color: #00D000; +} + +dl.deprecated +{ + margin-left:-7px; + padding-left: 3px; + border-left:4px solid; + border-color: #505050; +} + +dl.todo +{ + margin-left:-7px; + padding-left: 3px; + border-left:4px solid; + border-color: #00C0E0; +} + +dl.test +{ + margin-left:-7px; + padding-left: 3px; + border-left:4px solid; + border-color: #3030E0; +} + +dl.bug +{ + margin-left:-7px; + padding-left: 3px; + border-left:4px solid; + border-color: #C08050; +} + +dl.section dd { + margin-bottom: 6px; +} + + +#projectlogo +{ + text-align: center; + vertical-align: bottom; + border-collapse: separate; +} + +#projectlogo img +{ + border: 0px none; +} + +#projectalign +{ + vertical-align: middle; +} + +#projectname +{ + font: 300% Tahoma, Arial,sans-serif; + margin: 0px; + padding: 2px 0px; +} + +#projectbrief +{ + font: 120% Tahoma, Arial,sans-serif; + margin: 0px; + padding: 0px; +} + +#projectnumber +{ + font: 50% Tahoma, Arial,sans-serif; + margin: 0px; + padding: 0px; +} + +#titlearea +{ + padding: 0px; + margin: 0px; + width: 100%; + border-bottom: 1px solid #5373B4; +} + +.image +{ + text-align: center; +} + +.dotgraph +{ + text-align: center; +} + +.mscgraph +{ + text-align: center; +} + +.plantumlgraph +{ + text-align: center; +} + +.diagraph +{ + text-align: center; +} + +.caption +{ + font-weight: bold; +} + +div.zoom +{ + border: 1px solid #90A5CE; +} + +dl.citelist { + margin-bottom:50px; +} + +dl.citelist dt { + color:#334975; + float:left; + font-weight:bold; + margin-right:10px; + padding:5px; +} + +dl.citelist dd { + margin:2px 0; + padding:5px 0; +} + +div.toc { + padding: 14px 25px; + background-color: #F4F6FA; + border: 1px solid #D8DFEE; + border-radius: 7px 7px 7px 7px; + float: right; + height: auto; + margin: 0 8px 10px 10px; + width: 200px; +} + +div.toc li { + background: url("bdwn.png") no-repeat scroll 0 5px transparent; + font: 10px/1.2 Verdana,DejaVu Sans,Geneva,sans-serif; + margin-top: 5px; + padding-left: 10px; + padding-top: 2px; +} + +div.toc h3 { + font: bold 12px/1.2 Arial,FreeSans,sans-serif; + color: #4665A2; + border-bottom: 0 none; + margin: 0; +} + +div.toc ul { + list-style: none outside none; + border: medium none; + padding: 0px; +} + +div.toc li.level1 { + margin-left: 0px; +} + +div.toc li.level2 { + margin-left: 15px; +} + +div.toc li.level3 { + margin-left: 30px; +} + +div.toc li.level4 { + margin-left: 45px; +} + +.inherit_header { + font-weight: bold; + color: gray; + cursor: pointer; + -webkit-touch-callout: none; + -webkit-user-select: none; + -khtml-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; +} + +.inherit_header td { + padding: 6px 0px 2px 5px; +} + +.inherit { + display: none; +} + +tr.heading h2 { + margin-top: 12px; + margin-bottom: 4px; +} + +/* tooltip related style info */ + +.ttc { + position: absolute; + display: none; +} + +#powerTip { + cursor: default; + white-space: nowrap; + background-color: white; + border: 1px solid gray; + border-radius: 4px 4px 4px 4px; + box-shadow: 1px 1px 7px gray; + display: none; + font-size: smaller; + max-width: 80%; + opacity: 0.9; + padding: 1ex 1em 1em; + position: absolute; + z-index: 2147483647; +} + +#powerTip div.ttdoc { + color: grey; + font-style: italic; +} + +#powerTip div.ttname a { + font-weight: bold; +} + +#powerTip div.ttname { + font-weight: bold; +} + +#powerTip div.ttdeci { + color: #006318; +} + +#powerTip div { + margin: 0px; + padding: 0px; + font: 12px/16px Roboto,sans-serif; +} + +#powerTip:before, #powerTip:after { + content: ""; + position: absolute; + margin: 0px; +} + +#powerTip.n:after, #powerTip.n:before, +#powerTip.s:after, #powerTip.s:before, +#powerTip.w:after, #powerTip.w:before, +#powerTip.e:after, #powerTip.e:before, +#powerTip.ne:after, #powerTip.ne:before, +#powerTip.se:after, #powerTip.se:before, +#powerTip.nw:after, #powerTip.nw:before, +#powerTip.sw:after, #powerTip.sw:before { + border: solid transparent; + content: " "; + height: 0; + width: 0; + position: absolute; +} + +#powerTip.n:after, #powerTip.s:after, +#powerTip.w:after, #powerTip.e:after, +#powerTip.nw:after, #powerTip.ne:after, +#powerTip.sw:after, #powerTip.se:after { + border-color: rgba(255, 255, 255, 0); +} + +#powerTip.n:before, #powerTip.s:before, +#powerTip.w:before, #powerTip.e:before, +#powerTip.nw:before, #powerTip.ne:before, +#powerTip.sw:before, #powerTip.se:before { + border-color: rgba(128, 128, 128, 0); +} + +#powerTip.n:after, #powerTip.n:before, +#powerTip.ne:after, #powerTip.ne:before, +#powerTip.nw:after, #powerTip.nw:before { + top: 100%; +} + +#powerTip.n:after, #powerTip.ne:after, #powerTip.nw:after { + border-top-color: #ffffff; + border-width: 10px; + margin: 0px -10px; +} +#powerTip.n:before { + border-top-color: #808080; + border-width: 11px; + margin: 0px -11px; +} +#powerTip.n:after, #powerTip.n:before { + left: 50%; +} + +#powerTip.nw:after, #powerTip.nw:before { + right: 14px; +} + +#powerTip.ne:after, #powerTip.ne:before { + left: 14px; +} + +#powerTip.s:after, #powerTip.s:before, +#powerTip.se:after, #powerTip.se:before, +#powerTip.sw:after, #powerTip.sw:before { + bottom: 100%; +} + +#powerTip.s:after, #powerTip.se:after, #powerTip.sw:after { + border-bottom-color: #ffffff; + border-width: 10px; + margin: 0px -10px; +} + +#powerTip.s:before, #powerTip.se:before, #powerTip.sw:before { + border-bottom-color: #808080; + border-width: 11px; + margin: 0px -11px; +} + +#powerTip.s:after, #powerTip.s:before { + left: 50%; +} + +#powerTip.sw:after, #powerTip.sw:before { + right: 14px; +} + +#powerTip.se:after, #powerTip.se:before { + left: 14px; +} + +#powerTip.e:after, #powerTip.e:before { + left: 100%; +} +#powerTip.e:after { + border-left-color: #ffffff; + border-width: 10px; + top: 50%; + margin-top: -10px; +} +#powerTip.e:before { + border-left-color: #808080; + border-width: 11px; + top: 50%; + margin-top: -11px; +} + +#powerTip.w:after, #powerTip.w:before { + right: 100%; +} +#powerTip.w:after { + border-right-color: #ffffff; + border-width: 10px; + top: 50%; + margin-top: -10px; +} +#powerTip.w:before { + border-right-color: #808080; + border-width: 11px; + top: 50%; + margin-top: -11px; +} + +@media print +{ + #top { display: none; } + #side-nav { display: none; } + #nav-path { display: none; } + body { overflow:visible; } + h1, h2, h3, h4, h5, h6 { page-break-after: avoid; } + .summary { display: none; } + .memitem { page-break-inside: avoid; } + #doc-content + { + margin-left:0 !important; + height:auto !important; + width:auto !important; + overflow:inherit; + display:inline; + } +} + +/* @group Markdown */ + +/* +table.markdownTable { + border-collapse:collapse; + margin-top: 4px; + margin-bottom: 4px; +} + +table.markdownTable td, table.markdownTable th { + border: 1px solid #2D4068; + padding: 3px 7px 2px; +} + +table.markdownTableHead tr { +} + +table.markdownTableBodyLeft td, table.markdownTable th { + border: 1px solid #2D4068; + padding: 3px 7px 2px; +} + +th.markdownTableHeadLeft th.markdownTableHeadRight th.markdownTableHeadCenter th.markdownTableHeadNone { + background-color: #374F7F; + color: #FFFFFF; + font-size: 110%; + padding-bottom: 4px; + padding-top: 5px; +} + +th.markdownTableHeadLeft { + text-align: left +} + +th.markdownTableHeadRight { + text-align: right +} + +th.markdownTableHeadCenter { + text-align: center +} +*/ + +table.markdownTable { + border-collapse:collapse; + margin-top: 4px; + margin-bottom: 4px; +} + +table.markdownTable td, table.markdownTable th { + border: 1px solid #2D4068; + padding: 3px 7px 2px; +} + +table.markdownTable tr { +} + +th.markdownTableHeadLeft, th.markdownTableHeadRight, th.markdownTableHeadCenter, th.markdownTableHeadNone { + background-color: #374F7F; + color: #FFFFFF; + font-size: 110%; + padding-bottom: 4px; + padding-top: 5px; +} + +th.markdownTableHeadLeft, td.markdownTableBodyLeft { + text-align: left +} + +th.markdownTableHeadRight, td.markdownTableBodyRight { + text-align: right +} + +th.markdownTableHeadCenter, td.markdownTableBodyCenter { + text-align: center +} + + +/* @end */ diff --git a/doc/gutenprint/html/doxygen.png b/doc/gutenprint/html/doxygen.png new file mode 100644 index 0000000..3ff17d8 Binary files /dev/null and b/doc/gutenprint/html/doxygen.png differ diff --git a/doc/gutenprint/html/dynsections.js b/doc/gutenprint/html/dynsections.js new file mode 100644 index 0000000..85e1836 --- /dev/null +++ b/doc/gutenprint/html/dynsections.js @@ -0,0 +1,97 @@ +function toggleVisibility(linkObj) +{ + var base = $(linkObj).attr('id'); + var summary = $('#'+base+'-summary'); + var content = $('#'+base+'-content'); + var trigger = $('#'+base+'-trigger'); + var src=$(trigger).attr('src'); + if (content.is(':visible')===true) { + content.hide(); + summary.show(); + $(linkObj).addClass('closed').removeClass('opened'); + $(trigger).attr('src',src.substring(0,src.length-8)+'closed.png'); + } else { + content.show(); + summary.hide(); + $(linkObj).removeClass('closed').addClass('opened'); + $(trigger).attr('src',src.substring(0,src.length-10)+'open.png'); + } + return false; +} + +function updateStripes() +{ + $('table.directory tr'). + removeClass('even').filter(':visible:even').addClass('even'); +} + +function toggleLevel(level) +{ + $('table.directory tr').each(function() { + var l = this.id.split('_').length-1; + var i = $('#img'+this.id.substring(3)); + var a = $('#arr'+this.id.substring(3)); + if (l + + + + + + +libgutenprint API Reference: File List + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+
+
File List
+
+
+
Here is a list of all files with brief descriptions:
+
[detail level 123]
+ + + + + + + + + + + + + + + + + + + + + + + + + + + +
 ▼ include
 ▼ gutenprint
 array.hArray functions
 bit-ops.hBit operations
 channel.hChannel functions
 color.hColor functions
 curve-cache.hCurve caching functions
 curve.hCurve functions
 dither.hDither functions
 gutenprint-intl-internal.hInternationalisation functions
 gutenprint-intl.hInternationalisation functions
 gutenprint-module.hGutenprint module header
 gutenprint-version.hVersion functions
 gutenprint.hGutenprint master header
 image.hImage functions
 list.hGeneric list functions
 module.hModule functions
 mxml.hMini-XML XML parsing functions
 paper.hPaper size functions
 path.hSimple directory path functions
 printers.hPrinter functions
 sequence.hSequence functions
 string-list.hString list functions
 util.hUtility functions
 vars.hPrint job functions
 weave.hSoftweave functions
 xml.hXML tree functions
+
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/folderclosed.png b/doc/gutenprint/html/folderclosed.png new file mode 100644 index 0000000..bb8ab35 Binary files /dev/null and b/doc/gutenprint/html/folderclosed.png differ diff --git a/doc/gutenprint/html/folderopen.png b/doc/gutenprint/html/folderopen.png new file mode 100644 index 0000000..d6c7f67 Binary files /dev/null and b/doc/gutenprint/html/folderopen.png differ diff --git a/doc/gutenprint/html/functions.html b/doc/gutenprint/html/functions.html new file mode 100644 index 0000000..30a8007 --- /dev/null +++ b/doc/gutenprint/html/functions.html @@ -0,0 +1,537 @@ + + + + + + + +libgutenprint API Reference: Data Fields + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+
Here is a list of all struct and union fields with links to the structures/unions they belong to:
+ +

- a -

+ + +

- b -

+ + +

- c -

+ + +

- d -

+ + +

- e -

+ + +

- f -

+ + +

- g -

+ + +

- h -

+ + +

- i -

+ + +

- j -

+ + +

- l -

+ + +

- m -

+ + +

- n -

+ + +

- o -

+ + +

- p -

+ + +

- r -

+ + +

- s -

+ + +

- t -

+ + +

- u -

+ + +

- v -

+ + +

- w -

+ + +

- x -

+ + +

- y -

+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/functions_vars.html b/doc/gutenprint/html/functions_vars.html new file mode 100644 index 0000000..3352ffe --- /dev/null +++ b/doc/gutenprint/html/functions_vars.html @@ -0,0 +1,537 @@ + + + + + + + +libgutenprint API Reference: Data Fields - Variables + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+  + +

- a -

+ + +

- b -

+ + +

- c -

+ + +

- d -

+ + +

- e -

+ + +

- f -

+ + +

- g -

+ + +

- h -

+ + +

- i -

+ + +

- j -

+ + +

- l -

+ + +

- m -

+ + +

- n -

+ + +

- o -

+ + +

- p -

+ + +

- r -

+ + +

- s -

+ + +

- t -

+ + +

- u -

+ + +

- v -

+ + +

- w -

+ + +

- x -

+ + +

- y -

+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/globals.html b/doc/gutenprint/html/globals.html new file mode 100644 index 0000000..be0ace2 --- /dev/null +++ b/doc/gutenprint/html/globals.html @@ -0,0 +1,60 @@ + + + + + + + +libgutenprint API Reference: Globals + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+
Here is a list of all functions, variables, defines, enums, and typedefs with links to the files they belong to:
+ +

- _ -

+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/globals_b.html b/doc/gutenprint/html/globals_b.html new file mode 100644 index 0000000..9e56e3d --- /dev/null +++ b/doc/gutenprint/html/globals_b.html @@ -0,0 +1,57 @@ + + + + + + + +libgutenprint API Reference: Globals + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+
Here is a list of all functions, variables, defines, enums, and typedefs with links to the files they belong to:
+ +

- b -

+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/globals_c.html b/doc/gutenprint/html/globals_c.html new file mode 100644 index 0000000..737ff19 --- /dev/null +++ b/doc/gutenprint/html/globals_c.html @@ -0,0 +1,65 @@ + + + + + + + +libgutenprint API Reference: Globals + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+
Here is a list of all functions, variables, defines, enums, and typedefs with links to the files they belong to:
+ +

- c -

+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/globals_d.html b/doc/gutenprint/html/globals_d.html new file mode 100644 index 0000000..66bc58a --- /dev/null +++ b/doc/gutenprint/html/globals_d.html @@ -0,0 +1,61 @@ + + + + + + + +libgutenprint API Reference: Globals + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+
Here is a list of all functions, variables, defines, enums, and typedefs with links to the files they belong to:
+ +

- d -

+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/globals_defs.html b/doc/gutenprint/html/globals_defs.html new file mode 100644 index 0000000..78d7153 --- /dev/null +++ b/doc/gutenprint/html/globals_defs.html @@ -0,0 +1,295 @@ + + + + + + + +libgutenprint API Reference: Globals + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+  + +

- _ -

+ + +

- b -

+ + +

- c -

+ + +

- d -

+ + +

- g -

+ + +

- n -

+ + +

- s -

+ + +

- t -

+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/globals_enum.html b/doc/gutenprint/html/globals_enum.html new file mode 100644 index 0000000..1bc7ff2 --- /dev/null +++ b/doc/gutenprint/html/globals_enum.html @@ -0,0 +1,96 @@ + + + + + + + +libgutenprint API Reference: Globals + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+ 
    +
  • stp_curve_bounds_t +: curve.h +
    • +
  • stp_curve_compose_t +: curve.h +
    • +
  • stp_curve_type_t +: curve.h +
    • +
  • stp_curve_wrap_mode_t +: curve.h +
    • +
  • stp_image_status_t +: image.h +
    • +
  • stp_module_class_t +: module.h +
    • +
  • stp_mxml_type_e +: mxml.h +
    • +
  • stp_papersize_type_t +: paper.h +
    • +
  • stp_papersize_unit_t +: paper.h +
    • +
  • stp_parameter_activity_t +: vars.h +
    • +
  • stp_parameter_class_t +: vars.h +
    • +
  • stp_parameter_level_t +: vars.h +
    • +
  • stp_parameter_type_t +: vars.h +
    • +
  • stp_parameter_verify_t +: vars.h +
    • +
  • stp_weave_strategy_t +: weave.h +
    • +
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/globals_eval.html b/doc/gutenprint/html/globals_eval.html new file mode 100644 index 0000000..92f38ca --- /dev/null +++ b/doc/gutenprint/html/globals_eval.html @@ -0,0 +1,249 @@ + + + + + + + +libgutenprint API Reference: Globals + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+  + +

- p -

    +
  • PAPERSIZE_ENGLISH_EXTENDED +: paper.h +
    • +
  • PAPERSIZE_ENGLISH_STANDARD +: paper.h +
    • +
  • PAPERSIZE_METRIC_EXTENDED +: paper.h +
    • +
  • PAPERSIZE_METRIC_STANDARD +: paper.h +
    • +
  • PAPERSIZE_TYPE_ENVELOPE +: paper.h +
    • +
  • PAPERSIZE_TYPE_SPECIAL +: paper.h +
    • +
  • PAPERSIZE_TYPE_STANDARD +: paper.h +
    • +
  • PARAMETER_BAD +: vars.h +
    • +
  • PARAMETER_INACTIVE +: vars.h +
    • +
  • PARAMETER_OK +: vars.h +
    • +
+ + +

- s -

    +
  • STP_CURVE_BOUNDS_CLIP +: curve.h +
    • +
  • STP_CURVE_BOUNDS_ERROR +: curve.h +
    • +
  • STP_CURVE_BOUNDS_RESCALE +: curve.h +
    • +
  • STP_CURVE_COMPOSE_ADD +: curve.h +
    • +
  • STP_CURVE_COMPOSE_EXPONENTIATE +: curve.h +
    • +
  • STP_CURVE_COMPOSE_MULTIPLY +: curve.h +
    • +
  • STP_CURVE_TYPE_LINEAR +: curve.h +
    • +
  • STP_CURVE_TYPE_SPLINE +: curve.h +
    • +
  • STP_CURVE_WRAP_AROUND +: curve.h +
    • +
  • STP_CURVE_WRAP_NONE +: curve.h +
    • +
  • STP_IMAGE_STATUS_ABORT +: image.h +
    • +
  • STP_IMAGE_STATUS_OK +: image.h +
    • +
  • STP_MODULE_CLASS_COLOR +: module.h +
    • +
  • STP_MODULE_CLASS_DITHER +: module.h +
    • +
  • STP_MODULE_CLASS_FAMILY +: module.h +
    • +
  • STP_MODULE_CLASS_INVALID +: module.h +
    • +
  • STP_MODULE_CLASS_MISC +: module.h +
    • +
  • STP_MXML_ELEMENT +: mxml.h +
    • +
  • STP_MXML_INTEGER +: mxml.h +
    • +
  • STP_MXML_OPAQUE +: mxml.h +
    • +
  • STP_MXML_REAL +: mxml.h +
    • +
  • STP_MXML_TEXT +: mxml.h +
    • +
  • STP_PARAMETER_ACTIVE +: vars.h +
    • +
  • STP_PARAMETER_CLASS_CORE +: vars.h +
    • +
  • STP_PARAMETER_CLASS_FEATURE +: vars.h +
    • +
  • STP_PARAMETER_CLASS_INVALID +: vars.h +
    • +
  • STP_PARAMETER_CLASS_OUTPUT +: vars.h +
    • +
  • STP_PARAMETER_DEFAULTED +: vars.h +
    • +
  • STP_PARAMETER_INACTIVE +: vars.h +
    • +
  • STP_PARAMETER_LEVEL_ADVANCED +: vars.h +
    • +
  • STP_PARAMETER_LEVEL_ADVANCED1 +: vars.h +
    • +
  • STP_PARAMETER_LEVEL_ADVANCED2 +: vars.h +
    • +
  • STP_PARAMETER_LEVEL_ADVANCED3 +: vars.h +
    • +
  • STP_PARAMETER_LEVEL_ADVANCED4 +: vars.h +
    • +
  • STP_PARAMETER_LEVEL_BASIC +: vars.h +
    • +
  • STP_PARAMETER_LEVEL_EXTERNAL +: vars.h +
    • +
  • STP_PARAMETER_LEVEL_INTERNAL +: vars.h +
    • +
  • STP_PARAMETER_LEVEL_INVALID +: vars.h +
    • +
  • STP_PARAMETER_TYPE_ARRAY +: vars.h +
    • +
  • STP_PARAMETER_TYPE_BOOLEAN +: vars.h +
    • +
  • STP_PARAMETER_TYPE_CURVE +: vars.h +
    • +
  • STP_PARAMETER_TYPE_DIMENSION +: vars.h +
    • +
  • STP_PARAMETER_TYPE_DOUBLE +: vars.h +
    • +
  • STP_PARAMETER_TYPE_FILE +: vars.h +
    • +
  • STP_PARAMETER_TYPE_INT +: vars.h +
    • +
  • STP_PARAMETER_TYPE_INVALID +: vars.h +
    • +
  • STP_PARAMETER_TYPE_RAW +: vars.h +
    • +
  • STP_PARAMETER_TYPE_STRING_LIST +: vars.h +
    • +
  • STP_WEAVE_ASCENDING +: weave.h +
    • +
  • STP_WEAVE_ASCENDING_2X +: weave.h +
    • +
  • STP_WEAVE_ASCENDING_3X +: weave.h +
    • +
  • STP_WEAVE_DESCENDING +: weave.h +
    • +
  • STP_WEAVE_STAGGERED +: weave.h +
    • +
  • STP_WEAVE_ZIGZAG +: weave.h +
    • +
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/globals_func.html b/doc/gutenprint/html/globals_func.html new file mode 100644 index 0000000..c72c512 --- /dev/null +++ b/doc/gutenprint/html/globals_func.html @@ -0,0 +1,1583 @@ + + + + + + + +libgutenprint API Reference: Globals + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+  + +

- s -

    +
  • stp_abort() +: util.h +
    • +
  • stp_allocate_component_data() +: vars.h +
    • +
  • stp_array_copy() +: array.h +
    • +
  • stp_array_create() +: array.h +
    • +
  • stp_array_create_copy() +: array.h +
    • +
  • stp_array_create_from_xmltree() +: xml.h +
    • +
  • stp_array_destroy() +: array.h +
    • +
  • stp_array_get_data() +: array.h +
    • +
  • stp_array_get_point() +: array.h +
    • +
  • stp_array_get_sequence() +: array.h +
    • +
  • stp_array_get_size() +: array.h +
    • +
  • stp_array_set_data() +: array.h +
    • +
  • stp_array_set_point() +: array.h +
    • +
  • stp_array_set_size() +: array.h +
    • +
  • stp_asprintf() +: util.h +
    • +
  • stp_catprintf() +: util.h +
    • +
  • stp_channel_add() +: channel.h +
    • +
  • stp_channel_convert() +: channel.h +
    • +
  • stp_channel_get_black_channel() +: channel.h +
    • +
  • stp_channel_get_curve() +: channel.h +
    • +
  • stp_channel_get_cutoff_adjustment() +: channel.h +
    • +
  • stp_channel_get_density_adjustment() +: channel.h +
    • +
  • stp_channel_get_gcr_curve() +: channel.h +
    • +
  • stp_channel_get_gloss_channel() +: channel.h +
    • +
  • stp_channel_get_gloss_limit() +: channel.h +
    • +
  • stp_channel_get_ink_limit() +: channel.h +
    • +
  • stp_channel_get_input() +: channel.h +
    • +
  • stp_channel_get_output() +: channel.h +
    • +
  • stp_channel_get_value() +: channel.h +
    • +
  • stp_channel_initialize() +: channel.h +
    • +
  • stp_channel_reset() +: channel.h +
    • +
  • stp_channel_reset_channel() +: channel.h +
    • +
  • stp_channel_set_black_channel() +: channel.h +
    • +
  • stp_channel_set_curve() +: channel.h +
    • +
  • stp_channel_set_cutoff_adjustment() +: channel.h +
    • +
  • stp_channel_set_density_adjustment() +: channel.h +
    • +
  • stp_channel_set_gcr_curve() +: channel.h +
    • +
  • stp_channel_set_gloss_channel() +: channel.h +
    • +
  • stp_channel_set_gloss_limit() +: channel.h +
    • +
  • stp_channel_set_ink_limit() +: channel.h +
    • +
  • stp_check_array_parameter() +: vars.h +
    • +
  • stp_check_boolean_parameter() +: vars.h +
    • +
  • stp_check_curve_parameter() +: vars.h +
    • +
  • stp_check_dimension_parameter() +: vars.h +
    • +
  • stp_check_file_parameter() +: vars.h +
    • +
  • stp_check_float_parameter() +: vars.h +
    • +
  • stp_check_int_parameter() +: vars.h +
    • +
  • stp_check_parameter() +: vars.h +
    • +
  • stp_check_raw_parameter() +: vars.h +
    • +
  • stp_check_string_parameter() +: vars.h +
    • +
  • stp_check_version() +: gutenprint-version.h +
    • +
  • stp_clear_array_parameter() +: vars.h +
    • +
  • stp_clear_boolean_parameter() +: vars.h +
    • +
  • stp_clear_curve_parameter() +: vars.h +
    • +
  • stp_clear_dimension_parameter() +: vars.h +
    • +
  • stp_clear_file_parameter() +: vars.h +
    • +
  • stp_clear_float_parameter() +: vars.h +
    • +
  • stp_clear_int_parameter() +: vars.h +
    • +
  • stp_clear_parameter() +: vars.h +
    • +
  • stp_clear_raw_parameter() +: vars.h +
    • +
  • stp_clear_string_parameter() +: vars.h +
    • +
  • stp_color_count() +: color.h +
    • +
  • stp_color_describe_parameter() +: color.h +
    • +
  • stp_color_get_long_name() +: color.h +
    • +
  • stp_color_get_name() +: color.h +
    • +
  • stp_color_get_row() +: color.h +
    • +
  • stp_color_init() +: color.h +
    • +
  • stp_color_list_parameters() +: color.h +
    • +
  • stp_color_register() +: color.h +
    • +
  • stp_color_unregister() +: color.h +
    • +
  • stp_copy_options() +: vars.h +
    • +
  • stp_copy_vars_from() +: vars.h +
    • +
  • stp_curve_cache_copy() +: curve-cache.h +
    • +
  • stp_curve_cache_curve_data() +: curve-cache.h +
    • +
  • stp_curve_cache_curve_invalidate() +: curve-cache.h +
    • +
  • stp_curve_cache_get_count() +: curve-cache.h +
    • +
  • stp_curve_cache_get_curve() +: curve-cache.h +
    • +
  • stp_curve_cache_get_double_data() +: curve-cache.h +
    • +
  • stp_curve_cache_get_ushort_data() +: curve-cache.h +
    • +
  • stp_curve_cache_set_curve() +: curve-cache.h +
    • +
  • stp_curve_cache_set_curve_copy() +: curve-cache.h +
    • +
  • stp_curve_compose() +: curve.h +
    • +
  • stp_curve_copy() +: curve.h +
    • +
  • stp_curve_count_points() +: curve.h +
    • +
  • stp_curve_create() +: curve.h +
    • +
  • stp_curve_create_copy() +: curve.h +
    • +
  • stp_curve_create_from_file() +: curve.h +
    • +
  • stp_curve_create_from_stream() +: curve.h +
    • +
  • stp_curve_create_from_string() +: curve.h +
    • +
  • stp_curve_create_from_xmltree() +: xml.h +
    • +
  • stp_curve_create_reverse() +: curve.h +
    • +
  • stp_curve_destroy() +: curve.h +
    • +
  • stp_curve_free_curve_cache() +: curve-cache.h +
    • +
  • stp_curve_get_bounds() +: curve.h +
    • +
  • stp_curve_get_data() +: curve.h +
    • +
  • stp_curve_get_data_points() +: curve.h +
    • +
  • stp_curve_get_float_data() +: curve.h +
    • +
  • stp_curve_get_gamma() +: curve.h +
    • +
  • stp_curve_get_int_data() +: curve.h +
    • +
  • stp_curve_get_interpolation_type() +: curve.h +
    • +
  • stp_curve_get_long_data() +: curve.h +
    • +
  • stp_curve_get_point() +: curve.h +
    • +
  • stp_curve_get_range() +: curve.h +
    • +
  • stp_curve_get_sequence() +: curve.h +
    • +
  • stp_curve_get_short_data() +: curve.h +
    • +
  • stp_curve_get_subrange() +: curve.h +
    • +
  • stp_curve_get_uint_data() +: curve.h +
    • +
  • stp_curve_get_ulong_data() +: curve.h +
    • +
  • stp_curve_get_ushort_data() +: curve.h +
    • +
  • stp_curve_get_wrap() +: curve.h +
    • +
  • stp_curve_interpolate_value() +: curve.h +
    • +
  • stp_curve_is_piecewise() +: curve.h +
    • +
  • stp_curve_resample() +: curve.h +
    • +
  • stp_curve_rescale() +: curve.h +
    • +
  • stp_curve_reverse() +: curve.h +
    • +
  • stp_curve_set_bounds() +: curve.h +
    • +
  • stp_curve_set_data() +: curve.h +
    • +
  • stp_curve_set_data_points() +: curve.h +
    • +
  • stp_curve_set_float_data() +: curve.h +
    • +
  • stp_curve_set_gamma() +: curve.h +
    • +
  • stp_curve_set_int_data() +: curve.h +
    • +
  • stp_curve_set_interpolation_type() +: curve.h +
    • +
  • stp_curve_set_long_data() +: curve.h +
    • +
  • stp_curve_set_point() +: curve.h +
    • +
  • stp_curve_set_short_data() +: curve.h +
    • +
  • stp_curve_set_subrange() +: curve.h +
    • +
  • stp_curve_set_uint_data() +: curve.h +
    • +
  • stp_curve_set_ulong_data() +: curve.h +
    • +
  • stp_curve_set_ushort_data() +: curve.h +
    • +
  • stp_curve_write() +: curve.h +
    • +
  • stp_curve_write_string() +: curve.h +
    • +
  • stp_default_media_size() +: paper.h +
    • +
  • stp_default_settings() +: vars.h +
    • +
  • stp_deprintf() +: util.h +
    • +
  • stp_describe_output() +: printers.h +
    • +
  • stp_describe_parameter() +: vars.h +
    • +
  • stp_describe_resolution() +: vars.h +
    • +
  • stp_destroy_component_data() +: vars.h +
    • +
  • stp_dither() +: dither.h +
    • +
  • stp_dither_add_channel() +: dither.h +
    • +
  • stp_dither_describe_parameter() +: dither.h +
    • +
  • stp_dither_get_channel() +: dither.h +
    • +
  • stp_dither_get_first_position() +: dither.h +
    • +
  • stp_dither_get_last_position() +: dither.h +
    • +
  • stp_dither_init() +: dither.h +
    • +
  • stp_dither_internal() +: dither.h +
    • +
  • stp_dither_list_parameters() +: dither.h +
    • +
  • stp_dither_matrix_clone() +: dither.h +
    • +
  • stp_dither_matrix_copy() +: dither.h +
    • +
  • stp_dither_matrix_destroy() +: dither.h +
    • +
  • stp_dither_matrix_init() +: dither.h +
    • +
  • stp_dither_matrix_init_from_dither_array() +: dither.h +
    • +
  • stp_dither_matrix_init_short() +: dither.h +
    • +
  • stp_dither_matrix_iterated_init() +: dither.h +
    • +
  • stp_dither_matrix_scale_exponentially() +: dither.h +
    • +
  • stp_dither_matrix_set_row() +: dither.h +
    • +
  • stp_dither_matrix_shear() +: dither.h +
    • +
  • stp_dither_matrix_validate_array() +: dither.h +
    • +
  • stp_dither_set_adaptive_limit() +: dither.h +
    • +
  • stp_dither_set_ink_spread() +: dither.h +
    • +
  • stp_dither_set_inks() +: dither.h +
    • +
  • stp_dither_set_inks_full() +: dither.h +
    • +
  • stp_dither_set_inks_simple() +: dither.h +
    • +
  • stp_dither_set_iterated_matrix() +: dither.h +
    • +
  • stp_dither_set_matrix() +: dither.h +
    • +
  • stp_dither_set_matrix_from_dither_array() +: dither.h +
    • +
  • stp_dither_set_randomizer() +: dither.h +
    • +
  • stp_dither_set_transition() +: dither.h +
    • +
  • stp_dprintf() +: util.h +
    • +
  • stp_end_job() +: printers.h +
    • +
  • stp_eprintf() +: util.h +
    • +
  • stp_erprintf() +: util.h +
    • +
  • stp_erputc() +: util.h +
    • +
  • stp_family_register() +: printers.h +
    • +
  • stp_family_unregister() +: printers.h +
    • +
  • stp_fill_parameter_settings() +: vars.h +
    • +
  • stp_find_standard_dither_array() +: dither.h +
    • +
  • stp_flush_all() +: weave.h +
    • +
  • stp_flush_debug_messages() +: util.h +
    • +
  • stp_fold() +: bit-ops.h +
    • +
  • stp_fold_3bit() +: bit-ops.h +
    • +
  • stp_fold_3bit_323() +: bit-ops.h +
    • +
  • stp_fold_4bit() +: bit-ops.h +
    • +
  • stp_fold_8bit() +: bit-ops.h +
    • +
  • stp_free() +: util.h +
    • +
  • stp_get_array_parameter() +: vars.h +
    • +
  • stp_get_array_parameter_active() +: vars.h +
    • +
  • stp_get_boolean_parameter() +: vars.h +
    • +
  • stp_get_boolean_parameter_active() +: vars.h +
    • +
  • stp_get_color_by_colorfuncs() +: color.h +
    • +
  • stp_get_color_by_index() +: color.h +
    • +
  • stp_get_color_by_name() +: color.h +
    • +
  • stp_get_color_conversion() +: vars.h +
    • +
  • stp_get_component_data() +: vars.h +
    • +
  • stp_get_curve_parameter() +: vars.h +
    • +
  • stp_get_curve_parameter_active() +: vars.h +
    • +
  • stp_get_debug_level() +: util.h +
    • +
  • stp_get_dimension_parameter() +: vars.h +
    • +
  • stp_get_dimension_parameter_active() +: vars.h +
    • +
  • stp_get_driver() +: vars.h +
    • +
  • stp_get_errdata() +: vars.h +
    • +
  • stp_get_errfunc() +: vars.h +
    • +
  • stp_get_external_options() +: printers.h +
    • +
  • stp_get_file_parameter() +: vars.h +
    • +
  • stp_get_file_parameter_active() +: vars.h +
    • +
  • stp_get_float_parameter() +: vars.h +
    • +
  • stp_get_float_parameter_active() +: vars.h +
    • +
  • stp_get_height() +: vars.h +
    • +
  • stp_get_imageable_area() +: vars.h +
    • +
  • stp_get_int_parameter() +: vars.h +
    • +
  • stp_get_int_parameter_active() +: vars.h +
    • +
  • stp_get_left() +: vars.h +
    • +
  • stp_get_lineactive_by_pass() +: weave.h +
    • +
  • stp_get_linebases_by_pass() +: weave.h +
    • +
  • stp_get_linecount_by_pass() +: weave.h +
    • +
  • stp_get_lineoffsets_by_pass() +: weave.h +
    • +
  • stp_get_maximum_imageable_area() +: vars.h +
    • +
  • stp_get_media_size() +: vars.h +
    • +
  • stp_get_model_id() +: printers.h +
    • +
  • stp_get_outdata() +: vars.h +
    • +
  • stp_get_outfunc() +: vars.h +
    • +
  • stp_get_page_height() +: vars.h +
    • +
  • stp_get_page_width() +: vars.h +
    • +
  • stp_get_papersize_by_index() +: paper.h +
    • +
  • stp_get_papersize_by_name() +: paper.h +
    • +
  • stp_get_papersize_by_size() +: paper.h +
    • +
  • stp_get_papersize_by_size_exact() +: paper.h +
    • +
  • stp_get_parameter_active() +: vars.h +
    • +
  • stp_get_parameter_list() +: vars.h +
    • +
  • stp_get_pass_by_pass() +: weave.h +
    • +
  • stp_get_printer() +: printers.h +
    • +
  • stp_get_printer_by_device_id() +: printers.h +
    • +
  • stp_get_printer_by_driver() +: printers.h +
    • +
  • stp_get_printer_by_foomatic_id() +: printers.h +
    • +
  • stp_get_printer_by_index() +: printers.h +
    • +
  • stp_get_printer_by_long_name() +: printers.h +
    • +
  • stp_get_printer_index_by_driver() +: printers.h +
    • +
  • stp_get_raw_parameter() +: vars.h +
    • +
  • stp_get_raw_parameter_active() +: vars.h +
    • +
  • stp_get_release_version() +: util.h +
    • +
  • stp_get_size_limit() +: vars.h +
    • +
  • stp_get_string_parameter() +: vars.h +
    • +
  • stp_get_string_parameter_active() +: vars.h +
    • +
  • stp_get_top() +: vars.h +
    • +
  • stp_get_verified() +: vars.h +
    • +
  • stp_get_version() +: util.h +
    • +
  • stp_get_width() +: vars.h +
    • +
  • stp_image_conclude() +: image.h +
    • +
  • stp_image_get_appname() +: image.h +
    • +
  • stp_image_get_row() +: image.h +
    • +
  • stp_image_height() +: image.h +
    • +
  • stp_image_init() +: image.h +
    • +
  • stp_image_reset() +: image.h +
    • +
  • stp_image_width() +: image.h +
    • +
  • stp_init() +: util.h +
    • +
  • stp_init_debug_messages() +: util.h +
    • +
  • stp_initialize_printer_defaults() +: printers.h +
    • +
  • stp_initialize_weave() +: weave.h +
    • +
  • stp_known_papersizes() +: paper.h +
    • +
  • stp_list_array_parameters() +: vars.h +
    • +
  • stp_list_boolean_parameters() +: vars.h +
    • +
  • stp_list_copy() +: list.h +
    • +
  • stp_list_create() +: list.h +
    • +
  • stp_list_curve_parameters() +: vars.h +
    • +
  • stp_list_destroy() +: list.h +
    • +
  • stp_list_dimension_parameters() +: vars.h +
    • +
  • stp_list_file_parameters() +: vars.h +
    • +
  • stp_list_float_parameters() +: vars.h +
    • +
  • stp_list_get_copyfunc() +: list.h +
    • +
  • stp_list_get_end() +: list.h +
    • +
  • stp_list_get_freefunc() +: list.h +
    • +
  • stp_list_get_item_by_index() +: list.h +
    • +
  • stp_list_get_item_by_long_name() +: list.h +
    • +
  • stp_list_get_item_by_name() +: list.h +
    • +
  • stp_list_get_length() +: list.h +
    • +
  • stp_list_get_long_namefunc() +: list.h +
    • +
  • stp_list_get_namefunc() +: list.h +
    • +
  • stp_list_get_sortfunc() +: list.h +
    • +
  • stp_list_get_start() +: list.h +
    • +
  • stp_list_int_parameters() +: vars.h +
    • +
  • stp_list_item_create() +: list.h +
    • +
  • stp_list_item_destroy() +: list.h +
    • +
  • stp_list_item_get_data() +: list.h +
    • +
  • stp_list_item_next() +: list.h +
    • +
  • stp_list_item_prev() +: list.h +
    • +
  • stp_list_item_set_data() +: list.h +
    • +
  • stp_list_node_free_data() +: list.h +
    • +
  • stp_list_parameters() +: vars.h +
    • +
  • stp_list_raw_parameters() +: vars.h +
    • +
  • stp_list_set_copyfunc() +: list.h +
    • +
  • stp_list_set_freefunc() +: list.h +
    • +
  • stp_list_set_long_namefunc() +: list.h +
    • +
  • stp_list_set_namefunc() +: list.h +
    • +
  • stp_list_set_sortfunc() +: list.h +
    • +
  • stp_list_string_parameters() +: vars.h +
    • +
  • stp_malloc() +: util.h +
    • +
  • stp_merge_printvars() +: vars.h +
    • +
  • stp_module_close() +: module.h +
    • +
  • stp_module_exit() +: module.h +
    • +
  • stp_module_get_class() +: module.h +
    • +
  • stp_module_init() +: module.h +
    • +
  • stp_module_load() +: module.h +
    • +
  • stp_module_open() +: module.h +
    • +
  • stp_mxmlAdd() +: mxml.h +
    • +
  • stp_mxmlDelete() +: mxml.h +
    • +
  • stp_mxmlElementGetAttr() +: mxml.h +
    • +
  • stp_mxmlElementSetAttr() +: mxml.h +
    • +
  • stp_mxmlFindElement() +: mxml.h +
    • +
  • stp_mxmlLoadFile() +: mxml.h +
    • +
  • stp_mxmlLoadFromFile() +: mxml.h +
    • +
  • stp_mxmlLoadString() +: mxml.h +
    • +
  • stp_mxmlNewElement() +: mxml.h +
    • +
  • stp_mxmlNewInteger() +: mxml.h +
    • +
  • stp_mxmlNewOpaque() +: mxml.h +
    • +
  • stp_mxmlNewReal() +: mxml.h +
    • +
  • stp_mxmlNewText() +: mxml.h +
    • +
  • stp_mxmlRemove() +: mxml.h +
    • +
  • stp_mxmlSaveAllocString() +: mxml.h +
    • +
  • stp_mxmlSaveFile() +: mxml.h +
    • +
  • stp_mxmlSaveString() +: mxml.h +
    • +
  • stp_mxmlSaveToFile() +: mxml.h +
    • +
  • stp_mxmlWalkNext() +: mxml.h +
    • +
  • stp_mxmlWalkPrev() +: mxml.h +
    • +
  • stp_parameter_description_destroy() +: vars.h +
    • +
  • stp_parameter_find() +: vars.h +
    • +
  • stp_parameter_find_in_settings() +: vars.h +
    • +
  • stp_parameter_get_categories() +: vars.h +
    • +
  • stp_parameter_get_category() +: vars.h +
    • +
  • stp_parameter_has_category_value() +: vars.h +
    • +
  • stp_parameter_list_add_param() +: vars.h +
    • +
  • stp_parameter_list_append() +: vars.h +
    • +
  • stp_parameter_list_copy() +: vars.h +
    • +
  • stp_parameter_list_count() +: vars.h +
    • +
  • stp_parameter_list_create() +: vars.h +
    • +
  • stp_parameter_list_destroy() +: vars.h +
    • +
  • stp_parameter_list_param() +: vars.h +
    • +
  • stp_path_search() +: path.h +
    • +
  • stp_path_split() +: path.h +
    • +
  • stp_print() +: printers.h +
    • +
  • stp_printer_describe_parameter() +: printers.h +
    • +
  • stp_printer_get_comment() +: printers.h +
    • +
  • stp_printer_get_defaults() +: printers.h +
    • +
  • stp_printer_get_device_id() +: printers.h +
    • +
  • stp_printer_get_driver() +: printers.h +
    • +
  • stp_printer_get_family() +: printers.h +
    • +
  • stp_printer_get_foomatic_id() +: printers.h +
    • +
  • stp_printer_get_long_name() +: printers.h +
    • +
  • stp_printer_get_manufacturer() +: printers.h +
    • +
  • stp_printer_get_model() +: printers.h +
    • +
  • stp_printer_list_parameters() +: printers.h +
    • +
  • stp_printer_model_count() +: printers.h +
    • +
  • stp_prtraw() +: xml.h +
    • +
  • stp_prune_inactive_options() +: util.h +
    • +
  • stp_put16_be() +: util.h +
    • +
  • stp_put16_le() +: util.h +
    • +
  • stp_put32_be() +: util.h +
    • +
  • stp_put32_le() +: util.h +
    • +
  • stp_putc() +: util.h +
    • +
  • stp_putraw() +: util.h +
    • +
  • stp_puts() +: util.h +
    • +
  • stp_rawtoxmlstr() +: xml.h +
    • +
  • stp_read_and_compose_curves() +: util.h +
    • +
  • stp_realloc() +: util.h +
    • +
  • stp_register_xml_parser() +: xml.h +
    • +
  • stp_register_xml_preload() +: xml.h +
    • +
  • stp_scale_float_parameter() +: vars.h +
    • +
  • stp_send_command() +: util.h +
    • +
  • stp_sequence_copy() +: sequence.h +
    • +
  • stp_sequence_create() +: sequence.h +
    • +
  • stp_sequence_create_copy() +: sequence.h +
    • +
  • stp_sequence_create_from_xmltree() +: xml.h +
    • +
  • stp_sequence_create_reverse() +: sequence.h +
    • +
  • stp_sequence_destroy() +: sequence.h +
    • +
  • stp_sequence_get_bounds() +: sequence.h +
    • +
  • stp_sequence_get_data() +: sequence.h +
    • +
  • stp_sequence_get_float_data() +: sequence.h +
    • +
  • stp_sequence_get_int_data() +: sequence.h +
    • +
  • stp_sequence_get_long_data() +: sequence.h +
    • +
  • stp_sequence_get_point() +: sequence.h +
    • +
  • stp_sequence_get_range() +: sequence.h +
    • +
  • stp_sequence_get_short_data() +: sequence.h +
    • +
  • stp_sequence_get_size() +: sequence.h +
    • +
  • stp_sequence_get_uint_data() +: sequence.h +
    • +
  • stp_sequence_get_ulong_data() +: sequence.h +
    • +
  • stp_sequence_get_ushort_data() +: sequence.h +
    • +
  • stp_sequence_reverse() +: sequence.h +
    • +
  • stp_sequence_set_bounds() +: sequence.h +
    • +
  • stp_sequence_set_data() +: sequence.h +
    • +
  • stp_sequence_set_float_data() +: sequence.h +
    • +
  • stp_sequence_set_int_data() +: sequence.h +
    • +
  • stp_sequence_set_long_data() +: sequence.h +
    • +
  • stp_sequence_set_point() +: sequence.h +
    • +
  • stp_sequence_set_short_data() +: sequence.h +
    • +
  • stp_sequence_set_size() +: sequence.h +
    • +
  • stp_sequence_set_subrange() +: sequence.h +
    • +
  • stp_sequence_set_uint_data() +: sequence.h +
    • +
  • stp_sequence_set_ulong_data() +: sequence.h +
    • +
  • stp_sequence_set_ushort_data() +: sequence.h +
    • +
  • stp_set_array_parameter() +: vars.h +
    • +
  • stp_set_array_parameter_active() +: vars.h +
    • +
  • stp_set_boolean_parameter() +: vars.h +
    • +
  • stp_set_boolean_parameter_active() +: vars.h +
    • +
  • stp_set_color_conversion() +: vars.h +
    • +
  • stp_set_color_conversion_n() +: vars.h +
    • +
  • stp_set_curve_parameter() +: vars.h +
    • +
  • stp_set_curve_parameter_active() +: vars.h +
    • +
  • stp_set_default_array_parameter() +: vars.h +
    • +
  • stp_set_default_boolean_parameter() +: vars.h +
    • +
  • stp_set_default_curve_parameter() +: vars.h +
    • +
  • stp_set_default_dimension_parameter() +: vars.h +
    • +
  • stp_set_default_file_parameter() +: vars.h +
    • +
  • stp_set_default_file_parameter_n() +: vars.h +
    • +
  • stp_set_default_float_parameter() +: vars.h +
    • +
  • stp_set_default_int_parameter() +: vars.h +
    • +
  • stp_set_default_raw_parameter() +: vars.h +
    • +
  • stp_set_default_string_parameter() +: vars.h +
    • +
  • stp_set_default_string_parameter_n() +: vars.h +
    • +
  • stp_set_dimension_parameter() +: vars.h +
    • +
  • stp_set_dimension_parameter_active() +: vars.h +
    • +
  • stp_set_driver() +: vars.h +
    • +
  • stp_set_driver_n() +: vars.h +
    • +
  • stp_set_errdata() +: vars.h +
    • +
  • stp_set_errfunc() +: vars.h +
    • +
  • stp_set_file_parameter() +: vars.h +
    • +
  • stp_set_file_parameter_active() +: vars.h +
    • +
  • stp_set_file_parameter_n() +: vars.h +
    • +
  • stp_set_float_parameter() +: vars.h +
    • +
  • stp_set_float_parameter_active() +: vars.h +
    • +
  • stp_set_height() +: vars.h +
    • +
  • stp_set_int_parameter() +: vars.h +
    • +
  • stp_set_int_parameter_active() +: vars.h +
    • +
  • stp_set_left() +: vars.h +
    • +
  • stp_set_outdata() +: vars.h +
    • +
  • stp_set_outfunc() +: vars.h +
    • +
  • stp_set_output_codeset() +: util.h +
    • +
  • stp_set_page_height() +: vars.h +
    • +
  • stp_set_page_width() +: vars.h +
    • +
  • stp_set_parameter_active() +: vars.h +
    • +
  • stp_set_printer_defaults() +: printers.h +
    • +
  • stp_set_printer_defaults_soft() +: printers.h +
    • +
  • stp_set_raw_parameter() +: vars.h +
    • +
  • stp_set_raw_parameter_active() +: vars.h +
    • +
  • stp_set_string_parameter() +: vars.h +
    • +
  • stp_set_string_parameter_active() +: vars.h +
    • +
  • stp_set_string_parameter_n() +: vars.h +
    • +
  • stp_set_top() +: vars.h +
    • +
  • stp_set_verified() +: vars.h +
    • +
  • stp_set_width() +: vars.h +
    • +
  • stp_split() +: bit-ops.h +
    • +
  • stp_split_2() +: bit-ops.h +
    • +
  • stp_split_4() +: bit-ops.h +
    • +
  • stp_start_job() +: printers.h +
    • +
  • stp_strdup() +: util.h +
    • +
  • stp_string_list_add_string() +: string-list.h +
    • +
  • stp_string_list_add_string_unsafe() +: string-list.h +
    • +
  • stp_string_list_count() +: string-list.h +
    • +
  • stp_string_list_create() +: string-list.h +
    • +
  • stp_string_list_create_copy() +: string-list.h +
    • +
  • stp_string_list_create_from_params() +: string-list.h +
    • +
  • stp_string_list_destroy() +: string-list.h +
    • +
  • stp_string_list_find() +: string-list.h +
    • +
  • stp_string_list_is_present() +: string-list.h +
    • +
  • stp_string_list_param() +: string-list.h +
    • +
  • stp_string_list_remove_string() +: string-list.h +
    • +
  • stp_strlen() +: util.h +
    • +
  • stp_strndup() +: util.h +
    • +
  • stp_strtoxmlstr() +: xml.h +
    • +
  • stp_unpack() +: bit-ops.h +
    • +
  • stp_unpack_16() +: bit-ops.h +
    • +
  • stp_unpack_2() +: bit-ops.h +
    • +
  • stp_unpack_4() +: bit-ops.h +
    • +
  • stp_unpack_8() +: bit-ops.h +
    • +
  • stp_unregister_xml_parser() +: xml.h +
    • +
  • stp_unregister_xml_preload() +: xml.h +
    • +
  • stp_vars_copy() +: vars.h +
    • +
  • stp_vars_create() +: vars.h +
    • +
  • stp_vars_create_copy() +: vars.h +
    • +
  • stp_vars_create_from_xmltree() +: xml.h +
    • +
  • stp_vars_create_from_xmltree_ref() +: xml.h +
    • +
  • stp_vars_destroy() +: vars.h +
    • +
  • stp_vars_fill_from_xmltree() +: xml.h +
    • +
  • stp_vars_fill_from_xmltree_ref() +: xml.h +
    • +
  • stp_verify() +: vars.h +
    • +
  • stp_verify_parameter() +: vars.h +
    • +
  • stp_verify_printer_params() +: printers.h +
    • +
  • stp_weave_parameters_by_row() +: weave.h +
    • +
  • stp_write_raw() +: util.h +
    • +
  • stp_write_weave() +: weave.h +
    • +
  • stp_xml_exit() +: xml.h +
    • +
  • stp_xml_get_node() +: xml.h +
    • +
  • stp_xml_init() +: xml.h +
    • +
  • stp_xml_init_defaults() +: xml.h +
    • +
  • stp_xml_parse_file() +: xml.h +
    • +
  • stp_xml_parse_file_named() +: xml.h +
    • +
  • stp_xml_preinit() +: xml.h +
    • +
  • stp_xmldoc_create_generic() +: xml.h +
    • +
  • stp_xmlstrtod() +: xml.h +
    • +
  • stp_xmlstrtol() +: xml.h +
    • +
  • stp_xmlstrtoraw() +: xml.h +
    • +
  • stp_xmlstrtoul() +: xml.h +
    • +
  • stp_xmltree_create_from_array() +: xml.h +
    • +
  • stp_xmltree_create_from_curve() +: xml.h +
    • +
  • stp_xmltree_create_from_sequence() +: xml.h +
    • +
  • stp_xmltree_create_from_vars() +: xml.h +
    • +
  • stp_zalloc() +: util.h +
    • +
  • stp_zfwrite() +: util.h +
    • +
  • stp_zprintf() +: util.h +
    • +
  • stpi_data_path() +: path.h +
    • +
  • stpi_list_files_on_data_path() +: path.h +
    • +
  • stpi_path_merge() +: path.h +
    • +
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/globals_g.html b/doc/gutenprint/html/globals_g.html new file mode 100644 index 0000000..e3f0fec --- /dev/null +++ b/doc/gutenprint/html/globals_g.html @@ -0,0 +1,57 @@ + + + + + + + +libgutenprint API Reference: Globals + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+
Here is a list of all functions, variables, defines, enums, and typedefs with links to the files they belong to:
+ +

- g -

+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/globals_n.html b/doc/gutenprint/html/globals_n.html new file mode 100644 index 0000000..d3e8f3f --- /dev/null +++ b/doc/gutenprint/html/globals_n.html @@ -0,0 +1,57 @@ + + + + + + + +libgutenprint API Reference: Globals + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+
Here is a list of all functions, variables, defines, enums, and typedefs with links to the files they belong to:
+ +

- n -

+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/globals_p.html b/doc/gutenprint/html/globals_p.html new file mode 100644 index 0000000..ce12705 --- /dev/null +++ b/doc/gutenprint/html/globals_p.html @@ -0,0 +1,83 @@ + + + + + + + +libgutenprint API Reference: Globals + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+
Here is a list of all functions, variables, defines, enums, and typedefs with links to the files they belong to:
+ +

- p -

    +
  • PAPERSIZE_ENGLISH_EXTENDED +: paper.h +
    • +
  • PAPERSIZE_ENGLISH_STANDARD +: paper.h +
    • +
  • PAPERSIZE_METRIC_EXTENDED +: paper.h +
    • +
  • PAPERSIZE_METRIC_STANDARD +: paper.h +
    • +
  • PAPERSIZE_TYPE_ENVELOPE +: paper.h +
    • +
  • PAPERSIZE_TYPE_SPECIAL +: paper.h +
    • +
  • PAPERSIZE_TYPE_STANDARD +: paper.h +
    • +
  • PARAMETER_BAD +: vars.h +
    • +
  • PARAMETER_INACTIVE +: vars.h +
    • +
  • PARAMETER_OK +: vars.h +
    • +
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/globals_s.html b/doc/gutenprint/html/globals_s.html new file mode 100644 index 0000000..444bf21 --- /dev/null +++ b/doc/gutenprint/html/globals_s.html @@ -0,0 +1,2117 @@ + + + + + + + +libgutenprint API Reference: Globals + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+
Here is a list of all functions, variables, defines, enums, and typedefs with links to the files they belong to:
+ +

- s -

    +
  • stp_abort() +: util.h +
    • +
  • stp_allocate_component_data() +: vars.h +
    • +
  • stp_array_copy() +: array.h +
    • +
  • stp_array_create() +: array.h +
    • +
  • stp_array_create_copy() +: array.h +
    • +
  • stp_array_create_from_xmltree() +: xml.h +
    • +
  • stp_array_destroy() +: array.h +
    • +
  • stp_array_get_data() +: array.h +
    • +
  • stp_array_get_point() +: array.h +
    • +
  • stp_array_get_sequence() +: array.h +
    • +
  • stp_array_get_size() +: array.h +
    • +
  • stp_array_set_data() +: array.h +
    • +
  • stp_array_set_point() +: array.h +
    • +
  • stp_array_set_size() +: array.h +
    • +
  • stp_array_t +: array.h +
    • +
  • stp_asprintf() +: util.h +
    • +
  • stp_binary_age +: gutenprint-version.h +
    • +
  • STP_BINARY_AGE +: gutenprint-version.h +
    • +
  • stp_catprintf() +: util.h +
    • +
  • stp_channel_add() +: channel.h +
    • +
  • stp_channel_convert() +: channel.h +
    • +
  • stp_channel_get_black_channel() +: channel.h +
    • +
  • stp_channel_get_curve() +: channel.h +
    • +
  • stp_channel_get_cutoff_adjustment() +: channel.h +
    • +
  • stp_channel_get_density_adjustment() +: channel.h +
    • +
  • stp_channel_get_gcr_curve() +: channel.h +
    • +
  • stp_channel_get_gloss_channel() +: channel.h +
    • +
  • stp_channel_get_gloss_limit() +: channel.h +
    • +
  • stp_channel_get_ink_limit() +: channel.h +
    • +
  • stp_channel_get_input() +: channel.h +
    • +
  • stp_channel_get_output() +: channel.h +
    • +
  • stp_channel_get_value() +: channel.h +
    • +
  • stp_channel_initialize() +: channel.h +
    • +
  • STP_CHANNEL_LIMIT +: image.h +
    • +
  • STP_CHANNEL_NONE +: vars.h +
    • +
  • stp_channel_reset() +: channel.h +
    • +
  • stp_channel_reset_channel() +: channel.h +
    • +
  • stp_channel_set_black_channel() +: channel.h +
    • +
  • stp_channel_set_curve() +: channel.h +
    • +
  • stp_channel_set_cutoff_adjustment() +: channel.h +
    • +
  • stp_channel_set_density_adjustment() +: channel.h +
    • +
  • stp_channel_set_gcr_curve() +: channel.h +
    • +
  • stp_channel_set_gloss_channel() +: channel.h +
    • +
  • stp_channel_set_gloss_limit() +: channel.h +
    • +
  • stp_channel_set_ink_limit() +: channel.h +
    • +
  • stp_check_array_parameter() +: vars.h +
    • +
  • stp_check_boolean_parameter() +: vars.h +
    • +
  • stp_check_curve_parameter() +: vars.h +
    • +
  • stp_check_dimension_parameter() +: vars.h +
    • +
  • stp_check_file_parameter() +: vars.h +
    • +
  • stp_check_float_parameter() +: vars.h +
    • +
  • stp_check_int_parameter() +: vars.h +
    • +
  • stp_check_parameter() +: vars.h +
    • +
  • stp_check_raw_parameter() +: vars.h +
    • +
  • stp_check_string_parameter() +: vars.h +
    • +
  • stp_check_version() +: gutenprint-version.h +
    • +
  • STP_CHECK_VERSION +: gutenprint-version.h +
    • +
  • stp_clear_array_parameter() +: vars.h +
    • +
  • stp_clear_boolean_parameter() +: vars.h +
    • +
  • stp_clear_curve_parameter() +: vars.h +
    • +
  • stp_clear_dimension_parameter() +: vars.h +
    • +
  • stp_clear_file_parameter() +: vars.h +
    • +
  • stp_clear_float_parameter() +: vars.h +
    • +
  • stp_clear_int_parameter() +: vars.h +
    • +
  • stp_clear_parameter() +: vars.h +
    • +
  • stp_clear_raw_parameter() +: vars.h +
    • +
  • stp_clear_string_parameter() +: vars.h +
    • +
  • stp_color_count() +: color.h +
    • +
  • stp_color_describe_parameter() +: color.h +
    • +
  • stp_color_get_long_name() +: color.h +
    • +
  • stp_color_get_name() +: color.h +
    • +
  • stp_color_get_row() +: color.h +
    • +
  • stp_color_init() +: color.h +
    • +
  • stp_color_list_parameters() +: color.h +
    • +
  • stp_color_register() +: color.h +
    • +
  • stp_color_t +: color.h +
    • +
  • stp_color_unregister() +: color.h +
    • +
  • stp_compute_linewidth_func +: weave.h +
    • +
  • stp_compute_tiff_linewidth +: weave.h +
    • +
  • stp_compute_uncompressed_linewidth +: weave.h +
    • +
  • stp_const_parameter_list_t +: vars.h +
    • +
  • stp_copy_data_func_t +: vars.h +
    • +
  • stp_copy_options() +: vars.h +
    • +
  • stp_copy_vars_from() +: vars.h +
    • +
  • stp_current_interface +: gutenprint-version.h +
    • +
  • STP_CURRENT_INTERFACE +: gutenprint-version.h +
    • +
  • STP_CURVE_BOUNDS_CLIP +: curve.h +
    • +
  • STP_CURVE_BOUNDS_ERROR +: curve.h +
    • +
  • STP_CURVE_BOUNDS_RESCALE +: curve.h +
    • +
  • stp_curve_bounds_t +: curve.h +
    • +
  • stp_curve_cache_copy() +: curve-cache.h +
    • +
  • stp_curve_cache_curve_data() +: curve-cache.h +
    • +
  • stp_curve_cache_curve_invalidate() +: curve-cache.h +
    • +
  • stp_curve_cache_get_count() +: curve-cache.h +
    • +
  • stp_curve_cache_get_curve() +: curve-cache.h +
    • +
  • stp_curve_cache_get_double_data() +: curve-cache.h +
    • +
  • stp_curve_cache_get_ushort_data() +: curve-cache.h +
    • +
  • stp_curve_cache_set_curve() +: curve-cache.h +
    • +
  • stp_curve_cache_set_curve_copy() +: curve-cache.h +
    • +
  • stp_curve_compose() +: curve.h +
    • +
  • STP_CURVE_COMPOSE_ADD +: curve.h +
    • +
  • STP_CURVE_COMPOSE_EXPONENTIATE +: curve.h +
    • +
  • STP_CURVE_COMPOSE_MULTIPLY +: curve.h +
    • +
  • stp_curve_compose_t +: curve.h +
    • +
  • stp_curve_copy() +: curve.h +
    • +
  • stp_curve_count_points() +: curve.h +
    • +
  • stp_curve_create() +: curve.h +
    • +
  • stp_curve_create_copy() +: curve.h +
    • +
  • stp_curve_create_from_file() +: curve.h +
    • +
  • stp_curve_create_from_stream() +: curve.h +
    • +
  • stp_curve_create_from_string() +: curve.h +
    • +
  • stp_curve_create_from_xmltree() +: xml.h +
    • +
  • stp_curve_create_reverse() +: curve.h +
    • +
  • stp_curve_destroy() +: curve.h +
    • +
  • stp_curve_free_curve_cache() +: curve-cache.h +
    • +
  • stp_curve_get_bounds() +: curve.h +
    • +
  • stp_curve_get_data() +: curve.h +
    • +
  • stp_curve_get_data_points() +: curve.h +
    • +
  • stp_curve_get_float_data() +: curve.h +
    • +
  • stp_curve_get_gamma() +: curve.h +
    • +
  • stp_curve_get_int_data() +: curve.h +
    • +
  • stp_curve_get_interpolation_type() +: curve.h +
    • +
  • stp_curve_get_long_data() +: curve.h +
    • +
  • stp_curve_get_point() +: curve.h +
    • +
  • stp_curve_get_range() +: curve.h +
    • +
  • stp_curve_get_sequence() +: curve.h +
    • +
  • stp_curve_get_short_data() +: curve.h +
    • +
  • stp_curve_get_subrange() +: curve.h +
    • +
  • stp_curve_get_uint_data() +: curve.h +
    • +
  • stp_curve_get_ulong_data() +: curve.h +
    • +
  • stp_curve_get_ushort_data() +: curve.h +
    • +
  • stp_curve_get_wrap() +: curve.h +
    • +
  • stp_curve_interpolate_value() +: curve.h +
    • +
  • stp_curve_is_piecewise() +: curve.h +
    • +
  • stp_curve_resample() +: curve.h +
    • +
  • stp_curve_rescale() +: curve.h +
    • +
  • stp_curve_reverse() +: curve.h +
    • +
  • stp_curve_set_bounds() +: curve.h +
    • +
  • stp_curve_set_data() +: curve.h +
    • +
  • stp_curve_set_data_points() +: curve.h +
    • +
  • stp_curve_set_float_data() +: curve.h +
    • +
  • stp_curve_set_gamma() +: curve.h +
    • +
  • stp_curve_set_int_data() +: curve.h +
    • +
  • stp_curve_set_interpolation_type() +: curve.h +
    • +
  • stp_curve_set_long_data() +: curve.h +
    • +
  • stp_curve_set_point() +: curve.h +
    • +
  • stp_curve_set_short_data() +: curve.h +
    • +
  • stp_curve_set_subrange() +: curve.h +
    • +
  • stp_curve_set_uint_data() +: curve.h +
    • +
  • stp_curve_set_ulong_data() +: curve.h +
    • +
  • stp_curve_set_ushort_data() +: curve.h +
    • +
  • stp_curve_t +: curve.h +
    • +
  • STP_CURVE_TYPE_LINEAR +: curve.h +
    • +
  • STP_CURVE_TYPE_SPLINE +: curve.h +
    • +
  • stp_curve_type_t +: curve.h +
    • +
  • STP_CURVE_WRAP_AROUND +: curve.h +
    • +
  • stp_curve_wrap_mode_t +: curve.h +
    • +
  • STP_CURVE_WRAP_NONE +: curve.h +
    • +
  • stp_curve_write() +: curve.h +
    • +
  • stp_curve_write_string() +: curve.h +
    • +
  • STP_DBG_ASSERTIONS +: util.h +
    • +
  • STP_DBG_CANON +: util.h +
    • +
  • STP_DBG_COLORFUNC +: util.h +
    • +
  • STP_DBG_CURVE +: util.h +
    • +
  • STP_DBG_CURVE_ERRORS +: util.h +
    • +
  • STP_DBG_DPL +: util.h +
    • +
  • STP_DBG_DYESUB +: util.h +
    • +
  • STP_DBG_ESCP2 +: util.h +
    • +
  • STP_DBG_INK +: util.h +
    • +
  • STP_DBG_LEXMARK +: util.h +
    • +
  • STP_DBG_LIST +: util.h +
    • +
  • STP_DBG_LUT +: util.h +
    • +
  • STP_DBG_MARK_FILE +: util.h +
    • +
  • STP_DBG_MODULE +: util.h +
    • +
  • STP_DBG_NO_COMPRESSION +: util.h +
    • +
  • STP_DBG_PAPER +: util.h +
    • +
  • STP_DBG_PATH +: util.h +
    • +
  • STP_DBG_PCL +: util.h +
    • +
  • STP_DBG_PPD +: util.h +
    • +
  • STP_DBG_PRINTERS +: util.h +
    • +
  • STP_DBG_PS +: util.h +
    • +
  • STP_DBG_ROWS +: util.h +
    • +
  • STP_DBG_VARS +: util.h +
    • +
  • STP_DBG_WEAVE_PARAMS +: util.h +
    • +
  • STP_DBG_XML +: util.h +
    • +
  • stp_default_media_size() +: paper.h +
    • +
  • stp_default_settings() +: vars.h +
    • +
  • stp_deprintf() +: util.h +
    • +
  • stp_describe_output() +: printers.h +
    • +
  • stp_describe_parameter() +: vars.h +
    • +
  • stp_describe_resolution() +: vars.h +
    • +
  • stp_destroy_component_data() +: vars.h +
    • +
  • stp_dither() +: dither.h +
    • +
  • stp_dither_add_channel() +: dither.h +
    • +
  • stp_dither_describe_parameter() +: dither.h +
    • +
  • stp_dither_get_channel() +: dither.h +
    • +
  • stp_dither_get_first_position() +: dither.h +
    • +
  • stp_dither_get_last_position() +: dither.h +
    • +
  • stp_dither_init() +: dither.h +
    • +
  • stp_dither_internal() +: dither.h +
    • +
  • stp_dither_list_parameters() +: dither.h +
    • +
  • stp_dither_matrix_clone() +: dither.h +
    • +
  • stp_dither_matrix_copy() +: dither.h +
    • +
  • stp_dither_matrix_destroy() +: dither.h +
    • +
  • stp_dither_matrix_generic_t +: dither.h +
    • +
  • stp_dither_matrix_impl_t +: dither.h +
    • +
  • stp_dither_matrix_init() +: dither.h +
    • +
  • stp_dither_matrix_init_from_dither_array() +: dither.h +
    • +
  • stp_dither_matrix_init_short() +: dither.h +
    • +
  • stp_dither_matrix_iterated_init() +: dither.h +
    • +
  • stp_dither_matrix_normal_t +: dither.h +
    • +
  • stp_dither_matrix_scale_exponentially() +: dither.h +
    • +
  • stp_dither_matrix_set_row() +: dither.h +
    • +
  • stp_dither_matrix_shear() +: dither.h +
    • +
  • stp_dither_matrix_short_t +: dither.h +
    • +
  • stp_dither_matrix_validate_array() +: dither.h +
    • +
  • stp_dither_set_adaptive_limit() +: dither.h +
    • +
  • stp_dither_set_ink_spread() +: dither.h +
    • +
  • stp_dither_set_inks() +: dither.h +
    • +
  • stp_dither_set_inks_full() +: dither.h +
    • +
  • stp_dither_set_inks_simple() +: dither.h +
    • +
  • stp_dither_set_iterated_matrix() +: dither.h +
    • +
  • stp_dither_set_matrix() +: dither.h +
    • +
  • stp_dither_set_matrix_from_dither_array() +: dither.h +
    • +
  • stp_dither_set_randomizer() +: dither.h +
    • +
  • stp_dither_set_transition() +: dither.h +
    • +
  • stp_dotsize_t +: dither.h +
    • +
  • stp_dprintf() +: util.h +
    • +
  • STP_ECOLOR_C +: dither.h +
    • +
  • STP_ECOLOR_K +: dither.h +
    • +
  • STP_ECOLOR_M +: dither.h +
    • +
  • STP_ECOLOR_Y +: dither.h +
    • +
  • stp_end_job() +: printers.h +
    • +
  • stp_eprintf() +: util.h +
    • +
  • stp_erprintf() +: util.h +
    • +
  • stp_erputc() +: util.h +
    • +
  • stp_family_register() +: printers.h +
    • +
  • stp_family_t +: printers.h +
    • +
  • stp_family_unregister() +: printers.h +
    • +
  • stp_fill_parameter_settings() +: vars.h +
    • +
  • stp_fill_tiff +: weave.h +
    • +
  • stp_fill_uncompressed +: weave.h +
    • +
  • stp_fillfunc +: weave.h +
    • +
  • stp_find_standard_dither_array() +: dither.h +
    • +
  • stp_flush_all() +: weave.h +
    • +
  • stp_flush_debug_messages() +: util.h +
    • +
  • stp_flushfunc +: weave.h +
    • +
  • stp_fold() +: bit-ops.h +
    • +
  • stp_fold_3bit() +: bit-ops.h +
    • +
  • stp_fold_3bit_323() +: bit-ops.h +
    • +
  • stp_fold_4bit() +: bit-ops.h +
    • +
  • stp_fold_8bit() +: bit-ops.h +
    • +
  • stp_free() +: util.h +
    • +
  • stp_free_data_func_t +: vars.h +
    • +
  • stp_get_array_parameter() +: vars.h +
    • +
  • stp_get_array_parameter_active() +: vars.h +
    • +
  • stp_get_boolean_parameter() +: vars.h +
    • +
  • stp_get_boolean_parameter_active() +: vars.h +
    • +
  • stp_get_color_by_colorfuncs() +: color.h +
    • +
  • stp_get_color_by_index() +: color.h +
    • +
  • stp_get_color_by_name() +: color.h +
    • +
  • stp_get_color_conversion() +: vars.h +
    • +
  • stp_get_component_data() +: vars.h +
    • +
  • stp_get_curve_parameter() +: vars.h +
    • +
  • stp_get_curve_parameter_active() +: vars.h +
    • +
  • stp_get_debug_level() +: util.h +
    • +
  • stp_get_dimension_parameter() +: vars.h +
    • +
  • stp_get_dimension_parameter_active() +: vars.h +
    • +
  • stp_get_driver() +: vars.h +
    • +
  • stp_get_errdata() +: vars.h +
    • +
  • stp_get_errfunc() +: vars.h +
    • +
  • stp_get_external_options() +: printers.h +
    • +
  • stp_get_file_parameter() +: vars.h +
    • +
  • stp_get_file_parameter_active() +: vars.h +
    • +
  • stp_get_float_parameter() +: vars.h +
    • +
  • stp_get_float_parameter_active() +: vars.h +
    • +
  • stp_get_height() +: vars.h +
    • +
  • stp_get_imageable_area() +: vars.h +
    • +
  • stp_get_int_parameter() +: vars.h +
    • +
  • stp_get_int_parameter_active() +: vars.h +
    • +
  • stp_get_left() +: vars.h +
    • +
  • stp_get_lineactive_by_pass() +: weave.h +
    • +
  • stp_get_linebases_by_pass() +: weave.h +
    • +
  • stp_get_linecount_by_pass() +: weave.h +
    • +
  • stp_get_lineoffsets_by_pass() +: weave.h +
    • +
  • stp_get_maximum_imageable_area() +: vars.h +
    • +
  • stp_get_media_size() +: vars.h +
    • +
  • stp_get_model_id() +: printers.h +
    • +
  • stp_get_outdata() +: vars.h +
    • +
  • stp_get_outfunc() +: vars.h +
    • +
  • stp_get_page_height() +: vars.h +
    • +
  • stp_get_page_width() +: vars.h +
    • +
  • stp_get_papersize_by_index() +: paper.h +
    • +
  • stp_get_papersize_by_name() +: paper.h +
    • +
  • stp_get_papersize_by_size() +: paper.h +
    • +
  • stp_get_papersize_by_size_exact() +: paper.h +
    • +
  • stp_get_parameter_active() +: vars.h +
    • +
  • stp_get_parameter_list() +: vars.h +
    • +
  • stp_get_pass_by_pass() +: weave.h +
    • +
  • stp_get_printer() +: printers.h +
    • +
  • stp_get_printer_by_device_id() +: printers.h +
    • +
  • stp_get_printer_by_driver() +: printers.h +
    • +
  • stp_get_printer_by_foomatic_id() +: printers.h +
    • +
  • stp_get_printer_by_index() +: printers.h +
    • +
  • stp_get_printer_by_long_name() +: printers.h +
    • +
  • stp_get_printer_index_by_driver() +: printers.h +
    • +
  • stp_get_raw_parameter() +: vars.h +
    • +
  • stp_get_raw_parameter_active() +: vars.h +
    • +
  • stp_get_release_version() +: util.h +
    • +
  • stp_get_size_limit() +: vars.h +
    • +
  • stp_get_string_parameter() +: vars.h +
    • +
  • stp_get_string_parameter_active() +: vars.h +
    • +
  • stp_get_top() +: vars.h +
    • +
  • stp_get_verified() +: vars.h +
    • +
  • stp_get_version() +: util.h +
    • +
  • stp_get_width() +: vars.h +
    • +
  • stp_image_conclude() +: image.h +
    • +
  • stp_image_get_appname() +: image.h +
    • +
  • stp_image_get_row() +: image.h +
    • +
  • stp_image_height() +: image.h +
    • +
  • stp_image_init() +: image.h +
    • +
  • stp_image_reset() +: image.h +
    • +
  • STP_IMAGE_STATUS_ABORT +: image.h +
    • +
  • STP_IMAGE_STATUS_OK +: image.h +
    • +
  • stp_image_status_t +: image.h +
    • +
  • stp_image_t +: image.h +
    • +
  • stp_image_width() +: image.h +
    • +
  • stp_init() +: util.h +
    • +
  • stp_init_debug_messages() +: util.h +
    • +
  • stp_initialize_printer_defaults() +: printers.h +
    • +
  • stp_initialize_weave() +: weave.h +
    • +
  • stp_interface_age +: gutenprint-version.h +
    • +
  • STP_INTERFACE_AGE +: gutenprint-version.h +
    • +
  • stp_known_papersizes() +: paper.h +
    • +
  • stp_list_array_parameters() +: vars.h +
    • +
  • stp_list_boolean_parameters() +: vars.h +
    • +
  • stp_list_copy() +: list.h +
    • +
  • stp_list_create() +: list.h +
    • +
  • stp_list_curve_parameters() +: vars.h +
    • +
  • stp_list_destroy() +: list.h +
    • +
  • stp_list_dimension_parameters() +: vars.h +
    • +
  • stp_list_file_parameters() +: vars.h +
    • +
  • stp_list_float_parameters() +: vars.h +
    • +
  • stp_list_get_copyfunc() +: list.h +
    • +
  • stp_list_get_end() +: list.h +
    • +
  • stp_list_get_freefunc() +: list.h +
    • +
  • stp_list_get_item_by_index() +: list.h +
    • +
  • stp_list_get_item_by_long_name() +: list.h +
    • +
  • stp_list_get_item_by_name() +: list.h +
    • +
  • stp_list_get_length() +: list.h +
    • +
  • stp_list_get_long_namefunc() +: list.h +
    • +
  • stp_list_get_namefunc() +: list.h +
    • +
  • stp_list_get_sortfunc() +: list.h +
    • +
  • stp_list_get_start() +: list.h +
    • +
  • stp_list_int_parameters() +: vars.h +
    • +
  • stp_list_item_create() +: list.h +
    • +
  • stp_list_item_destroy() +: list.h +
    • +
  • stp_list_item_get_data() +: list.h +
    • +
  • stp_list_item_next() +: list.h +
    • +
  • stp_list_item_prev() +: list.h +
    • +
  • stp_list_item_set_data() +: list.h +
    • +
  • stp_list_item_t +: list.h +
    • +
  • stp_list_node_free_data() +: list.h +
    • +
  • stp_list_parameters() +: vars.h +
    • +
  • stp_list_raw_parameters() +: vars.h +
    • +
  • stp_list_set_copyfunc() +: list.h +
    • +
  • stp_list_set_freefunc() +: list.h +
    • +
  • stp_list_set_long_namefunc() +: list.h +
    • +
  • stp_list_set_namefunc() +: list.h +
    • +
  • stp_list_set_sortfunc() +: list.h +
    • +
  • stp_list_string_parameters() +: vars.h +
    • +
  • stp_list_t +: list.h +
    • +
  • STP_MAJOR_VERSION +: gutenprint-version.h +
    • +
  • stp_major_version +: gutenprint-version.h +
    • +
  • stp_malloc() +: util.h +
    • +
  • STP_MAX_WEAVE +: weave.h +
    • +
  • stp_merge_printvars() +: vars.h +
    • +
  • STP_MICRO_VERSION +: gutenprint-version.h +
    • +
  • stp_micro_version +: gutenprint-version.h +
    • +
  • stp_minor_version +: gutenprint-version.h +
    • +
  • STP_MINOR_VERSION +: gutenprint-version.h +
    • +
  • STP_MODULE +: gutenprint-module.h +
    • +
  • STP_MODULE_CLASS_COLOR +: module.h +
    • +
  • STP_MODULE_CLASS_DITHER +: module.h +
    • +
  • STP_MODULE_CLASS_FAMILY +: module.h +
    • +
  • STP_MODULE_CLASS_INVALID +: module.h +
    • +
  • STP_MODULE_CLASS_MISC +: module.h +
    • +
  • stp_module_class_t +: module.h +
    • +
  • stp_module_close() +: module.h +
    • +
  • stp_module_exit() +: module.h +
    • +
  • stp_module_get_class() +: module.h +
    • +
  • stp_module_init() +: module.h +
    • +
  • stp_module_load() +: module.h +
    • +
  • stp_module_open() +: module.h +
    • +
  • stp_module_t +: module.h +
    • +
  • stp_module_version_t +: module.h +
    • +
  • STP_MXML_ADD_AFTER +: mxml.h +
    • +
  • STP_MXML_ADD_BEFORE +: mxml.h +
    • +
  • STP_MXML_ADD_TO_PARENT +: mxml.h +
    • +
  • stp_mxml_attr_t +: mxml.h +
    • +
  • STP_MXML_DESCEND +: mxml.h +
    • +
  • STP_MXML_DESCEND_FIRST +: mxml.h +
    • +
  • STP_MXML_ELEMENT +: mxml.h +
    • +
  • stp_mxml_element_t +: mxml.h +
    • +
  • STP_MXML_INTEGER +: mxml.h +
    • +
  • STP_MXML_NO_CALLBACK +: mxml.h +
    • +
  • STP_MXML_NO_DESCEND +: mxml.h +
    • +
  • STP_MXML_NO_PARENT +: mxml.h +
    • +
  • stp_mxml_node_t +: mxml.h +
    • +
  • STP_MXML_OPAQUE +: mxml.h +
    • +
  • STP_MXML_REAL +: mxml.h +
    • +
  • STP_MXML_TAB +: mxml.h +
    • +
  • STP_MXML_TEXT +: mxml.h +
    • +
  • stp_mxml_text_t +: mxml.h +
    • +
  • stp_mxml_type_e +: mxml.h +
    • +
  • stp_mxml_type_t +: mxml.h +
    • +
  • stp_mxml_value_t +: mxml.h +
    • +
  • STP_MXML_WRAP +: mxml.h +
    • +
  • STP_MXML_WS_AFTER_CLOSE +: mxml.h +
    • +
  • STP_MXML_WS_AFTER_OPEN +: mxml.h +
    • +
  • STP_MXML_WS_BEFORE_CLOSE +: mxml.h +
    • +
  • STP_MXML_WS_BEFORE_OPEN +: mxml.h +
    • +
  • stp_mxmlAdd() +: mxml.h +
    • +
  • stp_mxmlDelete() +: mxml.h +
    • +
  • stp_mxmlElementGetAttr() +: mxml.h +
    • +
  • stp_mxmlElementSetAttr() +: mxml.h +
    • +
  • stp_mxmlFindElement() +: mxml.h +
    • +
  • stp_mxmlLoadFile() +: mxml.h +
    • +
  • stp_mxmlLoadFromFile() +: mxml.h +
    • +
  • stp_mxmlLoadString() +: mxml.h +
    • +
  • stp_mxmlNewElement() +: mxml.h +
    • +
  • stp_mxmlNewInteger() +: mxml.h +
    • +
  • stp_mxmlNewOpaque() +: mxml.h +
    • +
  • stp_mxmlNewReal() +: mxml.h +
    • +
  • stp_mxmlNewText() +: mxml.h +
    • +
  • stp_mxmlRemove() +: mxml.h +
    • +
  • stp_mxmlSaveAllocString() +: mxml.h +
    • +
  • stp_mxmlSaveFile() +: mxml.h +
    • +
  • stp_mxmlSaveString() +: mxml.h +
    • +
  • stp_mxmlSaveToFile() +: mxml.h +
    • +
  • stp_mxmlWalkNext() +: mxml.h +
    • +
  • stp_mxmlWalkPrev() +: mxml.h +
    • +
  • STP_NCOLORS +: dither.h +
    • +
  • stp_node_copyfunc +: list.h +
    • +
  • stp_node_freefunc +: list.h +
    • +
  • stp_node_namefunc +: list.h +
    • +
  • stp_node_sortfunc +: list.h +
    • +
  • stp_outfunc_t +: vars.h +
    • +
  • stp_pack_tiff +: weave.h +
    • +
  • stp_pack_uncompressed +: weave.h +
    • +
  • stp_packfunc +: weave.h +
    • +
  • stp_papersize_type_t +: paper.h +
    • +
  • stp_papersize_unit_t +: paper.h +
    • +
  • STP_PARAMETER_ACTIVE +: vars.h +
    • +
  • stp_parameter_activity_t +: vars.h +
    • +
  • STP_PARAMETER_CLASS_CORE +: vars.h +
    • +
  • STP_PARAMETER_CLASS_FEATURE +: vars.h +
    • +
  • STP_PARAMETER_CLASS_INVALID +: vars.h +
    • +
  • STP_PARAMETER_CLASS_OUTPUT +: vars.h +
    • +
  • stp_parameter_class_t +: vars.h +
    • +
  • STP_PARAMETER_DEFAULTED +: vars.h +
    • +
  • stp_parameter_description_destroy() +: vars.h +
    • +
  • stp_parameter_find() +: vars.h +
    • +
  • stp_parameter_find_in_settings() +: vars.h +
    • +
  • stp_parameter_get_categories() +: vars.h +
    • +
  • stp_parameter_get_category() +: vars.h +
    • +
  • stp_parameter_has_category_value() +: vars.h +
    • +
  • STP_PARAMETER_INACTIVE +: vars.h +
    • +
  • STP_PARAMETER_LEVEL_ADVANCED +: vars.h +
    • +
  • STP_PARAMETER_LEVEL_ADVANCED1 +: vars.h +
    • +
  • STP_PARAMETER_LEVEL_ADVANCED2 +: vars.h +
    • +
  • STP_PARAMETER_LEVEL_ADVANCED3 +: vars.h +
    • +
  • STP_PARAMETER_LEVEL_ADVANCED4 +: vars.h +
    • +
  • STP_PARAMETER_LEVEL_BASIC +: vars.h +
    • +
  • STP_PARAMETER_LEVEL_EXTERNAL +: vars.h +
    • +
  • STP_PARAMETER_LEVEL_INTERNAL +: vars.h +
    • +
  • STP_PARAMETER_LEVEL_INVALID +: vars.h +
    • +
  • stp_parameter_level_t +: vars.h +
    • +
  • stp_parameter_list_add_param() +: vars.h +
    • +
  • stp_parameter_list_append() +: vars.h +
    • +
  • stp_parameter_list_copy() +: vars.h +
    • +
  • stp_parameter_list_count() +: vars.h +
    • +
  • stp_parameter_list_create() +: vars.h +
    • +
  • stp_parameter_list_destroy() +: vars.h +
    • +
  • stp_parameter_list_param() +: vars.h +
    • +
  • stp_parameter_list_t +: vars.h +
    • +
  • STP_PARAMETER_TYPE_ARRAY +: vars.h +
    • +
  • STP_PARAMETER_TYPE_BOOLEAN +: vars.h +
    • +
  • STP_PARAMETER_TYPE_CURVE +: vars.h +
    • +
  • STP_PARAMETER_TYPE_DIMENSION +: vars.h +
    • +
  • STP_PARAMETER_TYPE_DOUBLE +: vars.h +
    • +
  • STP_PARAMETER_TYPE_FILE +: vars.h +
    • +
  • STP_PARAMETER_TYPE_INT +: vars.h +
    • +
  • STP_PARAMETER_TYPE_INVALID +: vars.h +
    • +
  • STP_PARAMETER_TYPE_RAW +: vars.h +
    • +
  • STP_PARAMETER_TYPE_STRING_LIST +: vars.h +
    • +
  • stp_parameter_type_t +: vars.h +
    • +
  • stp_parameter_verify_t +: vars.h +
    • +
  • stp_path_search() +: path.h +
    • +
  • stp_path_split() +: path.h +
    • +
  • stp_print() +: printers.h +
    • +
  • stp_printer_describe_parameter() +: printers.h +
    • +
  • stp_printer_get_comment() +: printers.h +
    • +
  • stp_printer_get_defaults() +: printers.h +
    • +
  • stp_printer_get_device_id() +: printers.h +
    • +
  • stp_printer_get_driver() +: printers.h +
    • +
  • stp_printer_get_family() +: printers.h +
    • +
  • stp_printer_get_foomatic_id() +: printers.h +
    • +
  • stp_printer_get_long_name() +: printers.h +
    • +
  • stp_printer_get_manufacturer() +: printers.h +
    • +
  • stp_printer_get_model() +: printers.h +
    • +
  • stp_printer_list_parameters() +: printers.h +
    • +
  • stp_printer_model_count() +: printers.h +
    • +
  • stp_printer_t +: printers.h +
    • +
  • stp_prtraw() +: xml.h +
    • +
  • stp_prune_inactive_options() +: util.h +
    • +
  • stp_put16_be() +: util.h +
    • +
  • stp_put16_le() +: util.h +
    • +
  • stp_put32_be() +: util.h +
    • +
  • stp_put32_le() +: util.h +
    • +
  • stp_putc() +: util.h +
    • +
  • stp_putraw() +: util.h +
    • +
  • stp_puts() +: util.h +
    • +
  • STP_RAW +: vars.h +
    • +
  • STP_RAW_STRING +: vars.h +
    • +
  • stp_rawtoxmlstr() +: xml.h +
    • +
  • stp_read_and_compose_curves() +: util.h +
    • +
  • stp_realloc() +: util.h +
    • +
  • stp_register_xml_parser() +: xml.h +
    • +
  • stp_register_xml_preload() +: xml.h +
    • +
  • STP_SAFE_FREE +: util.h +
    • +
  • stp_scale_float_parameter() +: vars.h +
    • +
  • stp_send_command() +: util.h +
    • +
  • stp_sequence_copy() +: sequence.h +
    • +
  • stp_sequence_create() +: sequence.h +
    • +
  • stp_sequence_create_copy() +: sequence.h +
    • +
  • stp_sequence_create_from_xmltree() +: xml.h +
    • +
  • stp_sequence_create_reverse() +: sequence.h +
    • +
  • stp_sequence_destroy() +: sequence.h +
    • +
  • stp_sequence_get_bounds() +: sequence.h +
    • +
  • stp_sequence_get_data() +: sequence.h +
    • +
  • stp_sequence_get_float_data() +: sequence.h +
    • +
  • stp_sequence_get_int_data() +: sequence.h +
    • +
  • stp_sequence_get_long_data() +: sequence.h +
    • +
  • stp_sequence_get_point() +: sequence.h +
    • +
  • stp_sequence_get_range() +: sequence.h +
    • +
  • stp_sequence_get_short_data() +: sequence.h +
    • +
  • stp_sequence_get_size() +: sequence.h +
    • +
  • stp_sequence_get_uint_data() +: sequence.h +
    • +
  • stp_sequence_get_ulong_data() +: sequence.h +
    • +
  • stp_sequence_get_ushort_data() +: sequence.h +
    • +
  • stp_sequence_reverse() +: sequence.h +
    • +
  • stp_sequence_set_bounds() +: sequence.h +
    • +
  • stp_sequence_set_data() +: sequence.h +
    • +
  • stp_sequence_set_float_data() +: sequence.h +
    • +
  • stp_sequence_set_int_data() +: sequence.h +
    • +
  • stp_sequence_set_long_data() +: sequence.h +
    • +
  • stp_sequence_set_point() +: sequence.h +
    • +
  • stp_sequence_set_short_data() +: sequence.h +
    • +
  • stp_sequence_set_size() +: sequence.h +
    • +
  • stp_sequence_set_subrange() +: sequence.h +
    • +
  • stp_sequence_set_uint_data() +: sequence.h +
    • +
  • stp_sequence_set_ulong_data() +: sequence.h +
    • +
  • stp_sequence_set_ushort_data() +: sequence.h +
    • +
  • stp_sequence_t +: sequence.h +
    • +
  • stp_set_array_parameter() +: vars.h +
    • +
  • stp_set_array_parameter_active() +: vars.h +
    • +
  • stp_set_boolean_parameter() +: vars.h +
    • +
  • stp_set_boolean_parameter_active() +: vars.h +
    • +
  • stp_set_color_conversion() +: vars.h +
    • +
  • stp_set_color_conversion_n() +: vars.h +
    • +
  • stp_set_curve_parameter() +: vars.h +
    • +
  • stp_set_curve_parameter_active() +: vars.h +
    • +
  • stp_set_default_array_parameter() +: vars.h +
    • +
  • stp_set_default_boolean_parameter() +: vars.h +
    • +
  • stp_set_default_curve_parameter() +: vars.h +
    • +
  • stp_set_default_dimension_parameter() +: vars.h +
    • +
  • stp_set_default_file_parameter() +: vars.h +
    • +
  • stp_set_default_file_parameter_n() +: vars.h +
    • +
  • stp_set_default_float_parameter() +: vars.h +
    • +
  • stp_set_default_int_parameter() +: vars.h +
    • +
  • stp_set_default_raw_parameter() +: vars.h +
    • +
  • stp_set_default_string_parameter() +: vars.h +
    • +
  • stp_set_default_string_parameter_n() +: vars.h +
    • +
  • stp_set_dimension_parameter() +: vars.h +
    • +
  • stp_set_dimension_parameter_active() +: vars.h +
    • +
  • stp_set_driver() +: vars.h +
    • +
  • stp_set_driver_n() +: vars.h +
    • +
  • stp_set_errdata() +: vars.h +
    • +
  • stp_set_errfunc() +: vars.h +
    • +
  • stp_set_file_parameter() +: vars.h +
    • +
  • stp_set_file_parameter_active() +: vars.h +
    • +
  • stp_set_file_parameter_n() +: vars.h +
    • +
  • stp_set_float_parameter() +: vars.h +
    • +
  • stp_set_float_parameter_active() +: vars.h +
    • +
  • stp_set_height() +: vars.h +
    • +
  • stp_set_int_parameter() +: vars.h +
    • +
  • stp_set_int_parameter_active() +: vars.h +
    • +
  • stp_set_left() +: vars.h +
    • +
  • stp_set_outdata() +: vars.h +
    • +
  • stp_set_outfunc() +: vars.h +
    • +
  • stp_set_output_codeset() +: util.h +
    • +
  • stp_set_page_height() +: vars.h +
    • +
  • stp_set_page_width() +: vars.h +
    • +
  • stp_set_parameter_active() +: vars.h +
    • +
  • stp_set_printer_defaults() +: printers.h +
    • +
  • stp_set_printer_defaults_soft() +: printers.h +
    • +
  • stp_set_raw_parameter() +: vars.h +
    • +
  • stp_set_raw_parameter_active() +: vars.h +
    • +
  • stp_set_string_parameter() +: vars.h +
    • +
  • stp_set_string_parameter_active() +: vars.h +
    • +
  • stp_set_string_parameter_n() +: vars.h +
    • +
  • stp_set_top() +: vars.h +
    • +
  • stp_set_verified() +: vars.h +
    • +
  • stp_set_width() +: vars.h +
    • +
  • stp_shade_t +: dither.h +
    • +
  • stp_split() +: bit-ops.h +
    • +
  • stp_split_2() +: bit-ops.h +
    • +
  • stp_split_4() +: bit-ops.h +
    • +
  • stp_start_job() +: printers.h +
    • +
  • stp_strdup() +: util.h +
    • +
  • stp_string_list_add_string() +: string-list.h +
    • +
  • stp_string_list_add_string_unsafe() +: string-list.h +
    • +
  • stp_string_list_count() +: string-list.h +
    • +
  • stp_string_list_create() +: string-list.h +
    • +
  • stp_string_list_create_copy() +: string-list.h +
    • +
  • stp_string_list_create_from_params() +: string-list.h +
    • +
  • stp_string_list_destroy() +: string-list.h +
    • +
  • stp_string_list_find() +: string-list.h +
    • +
  • stp_string_list_is_present() +: string-list.h +
    • +
  • stp_string_list_param() +: string-list.h +
    • +
  • stp_string_list_remove_string() +: string-list.h +
    • +
  • stp_string_list_t +: string-list.h +
    • +
  • stp_strlen() +: util.h +
    • +
  • stp_strndup() +: util.h +
    • +
  • stp_strtoxmlstr() +: xml.h +
    • +
  • stp_unpack() +: bit-ops.h +
    • +
  • stp_unpack_16() +: bit-ops.h +
    • +
  • stp_unpack_2() +: bit-ops.h +
    • +
  • stp_unpack_4() +: bit-ops.h +
    • +
  • stp_unpack_8() +: bit-ops.h +
    • +
  • stp_unregister_xml_parser() +: xml.h +
    • +
  • stp_unregister_xml_preload() +: xml.h +
    • +
  • stp_vars_copy() +: vars.h +
    • +
  • stp_vars_create() +: vars.h +
    • +
  • stp_vars_create_copy() +: vars.h +
    • +
  • stp_vars_create_from_xmltree() +: xml.h +
    • +
  • stp_vars_create_from_xmltree_ref() +: xml.h +
    • +
  • stp_vars_destroy() +: vars.h +
    • +
  • stp_vars_fill_from_xmltree() +: xml.h +
    • +
  • stp_vars_fill_from_xmltree_ref() +: xml.h +
    • +
  • stp_vars_t +: vars.h +
    • +
  • stp_verify() +: vars.h +
    • +
  • stp_verify_parameter() +: vars.h +
    • +
  • stp_verify_printer_params() +: printers.h +
    • +
  • STP_WEAVE_ASCENDING +: weave.h +
    • +
  • STP_WEAVE_ASCENDING_2X +: weave.h +
    • +
  • STP_WEAVE_ASCENDING_3X +: weave.h +
    • +
  • STP_WEAVE_DESCENDING +: weave.h +
    • +
  • stp_weave_parameters_by_row() +: weave.h +
    • +
  • STP_WEAVE_STAGGERED +: weave.h +
    • +
  • stp_weave_strategy_t +: weave.h +
    • +
  • STP_WEAVE_ZIGZAG +: weave.h +
    • +
  • stp_write_raw() +: util.h +
    • +
  • stp_write_weave() +: weave.h +
    • +
  • stp_xml_exit() +: xml.h +
    • +
  • stp_xml_get_node() +: xml.h +
    • +
  • stp_xml_init() +: xml.h +
    • +
  • stp_xml_init_defaults() +: xml.h +
    • +
  • stp_xml_parse_file() +: xml.h +
    • +
  • stp_xml_parse_file_named() +: xml.h +
    • +
  • stp_xml_parse_func +: xml.h +
    • +
  • stp_xml_preinit() +: xml.h +
    • +
  • stp_xmldoc_create_generic() +: xml.h +
    • +
  • stp_xmlstrtod() +: xml.h +
    • +
  • stp_xmlstrtol() +: xml.h +
    • +
  • stp_xmlstrtoraw() +: xml.h +
    • +
  • stp_xmlstrtoul() +: xml.h +
    • +
  • stp_xmltree_create_from_array() +: xml.h +
    • +
  • stp_xmltree_create_from_curve() +: xml.h +
    • +
  • stp_xmltree_create_from_sequence() +: xml.h +
    • +
  • stp_xmltree_create_from_vars() +: xml.h +
    • +
  • stp_zalloc() +: util.h +
    • +
  • stp_zfwrite() +: util.h +
    • +
  • stp_zprintf() +: util.h +
    • +
  • stpi_data_path() +: path.h +
    • +
  • stpi_list_files_on_data_path() +: path.h +
    • +
  • stpi_path_merge() +: path.h +
    • +
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/globals_t.html b/doc/gutenprint/html/globals_t.html new file mode 100644 index 0000000..85cf664 --- /dev/null +++ b/doc/gutenprint/html/globals_t.html @@ -0,0 +1,57 @@ + + + + + + + +libgutenprint API Reference: Globals + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+
Here is a list of all functions, variables, defines, enums, and typedefs with links to the files they belong to:
+ +

- t -

+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/globals_type.html b/doc/gutenprint/html/globals_type.html new file mode 100644 index 0000000..6cfcaae --- /dev/null +++ b/doc/gutenprint/html/globals_type.html @@ -0,0 +1,177 @@ + + + + + + + +libgutenprint API Reference: Globals + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+  + +

- c -

+ + +

- s -

+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/globals_vars.html b/doc/gutenprint/html/globals_vars.html new file mode 100644 index 0000000..a762656 --- /dev/null +++ b/doc/gutenprint/html/globals_vars.html @@ -0,0 +1,87 @@ + + + + + + + +libgutenprint API Reference: Globals + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+  +
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/group__array.html b/doc/gutenprint/html/group__array.html new file mode 100644 index 0000000..a0c287e --- /dev/null +++ b/doc/gutenprint/html/group__array.html @@ -0,0 +1,554 @@ + + + + + + + +libgutenprint API Reference: array + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+
+Typedefs | +Functions
+
+
array
+
+
+ +

The array is a simple "two-dimensional array of numbers" data structure. +More...

+ + + + + +

+Typedefs

typedef struct stp_array stp_array_t
 The array opaque data type. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

stp_array_t * stp_array_create (int x_size, int y_size)
 Create a new array. More...
 
void stp_array_destroy (stp_array_t *array)
 Destroy an array. More...
 
void stp_array_copy (stp_array_t *dest, const stp_array_t *source)
 Copy an array. More...
 
stp_array_t * stp_array_create_copy (const stp_array_t *array)
 Copy and allocate an array. More...
 
void stp_array_set_size (stp_array_t *array, int x_size, int y_size)
 Resize an array. More...
 
void stp_array_get_size (const stp_array_t *array, int *x_size, int *y_size)
 Get the size of an array. More...
 
void stp_array_set_data (stp_array_t *array, const double *data)
 Set the data in an array. More...
 
void stp_array_get_data (const stp_array_t *array, size_t *size, const double **data)
 Get the data in an array. More...
 
int stp_array_set_point (stp_array_t *array, int x, int y, double data)
 Set the data at a single point in the array. More...
 
int stp_array_get_point (const stp_array_t *array, int x, int y, double *data)
 Get the data at a single point in the array. More...
 
const stp_sequence_t * stp_array_get_sequence (const stp_array_t *array)
 Get the underlying stp_sequence_t. More...
 
+

Detailed Description

+

The array is a simple "two-dimensional array of numbers" data structure.

+

array "inherits" from the sequence data structure (implemented via containment).

+

Typedef Documentation

+ +

◆ stp_array_t

+ +
+
+ + + + +
typedef struct stp_array stp_array_t
+
+ +

The array opaque data type.

+ +
+
+

Function Documentation

+ +

◆ stp_array_copy()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_array_copy (stp_array_t * dest,
const stp_array_t * source 
)
+
+ +

Copy an array.

+

Both dest and source must be valid arrays previously created with stp_array_create().

Parameters
+ + + +
destthe destination array.
sourcethe source array.
+
+
+ +
+
+ +

◆ stp_array_create()

+ +
+
+ + + + + + + + + + + + + + + + + + +
stp_array_t* stp_array_create (int x_size,
int y_size 
)
+
+ +

Create a new array.

+

The total size of the array will be (x_size * y_size).

Parameters
+ + + +
x_sizethe number of "columns".
y_sizethe number of "rows".
+
+
+
Returns
the newly created array.
+ +
+
+ +

◆ stp_array_create_copy()

+ +
+
+ + + + + + + + +
stp_array_t* stp_array_create_copy (const stp_array_t * array)
+
+ +

Copy and allocate an array.

+

dest will be created, and then the contents of source will be copied into it. dest must not have been previously allocated with stp_array_create().

Parameters
+ + +
arraythe source array.
+
+
+
Returns
the new copy of the array.
+ +
+
+ +

◆ stp_array_destroy()

+ +
+
+ + + + + + + + +
void stp_array_destroy (stp_array_t * array)
+
+ +

Destroy an array.

+

It is an error to destroy the array more than once.

Parameters
+ + +
arraythe array to destroy.
+
+
+ +
+
+ +

◆ stp_array_get_data()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_array_get_data (const stp_array_t * array,
size_t * size,
const double ** data 
)
+
+ +

Get the data in an array.

+
Parameters
+ + + + +
arraythe array to get the data from.
sizethe number of elements in the array (x_size * y_size) are stored in the size_t pointed to.
dataa pointer to the first element of an array of doubles is stored in a pointer to double*.
stp_array_t *array;
size_t size;
double *data;
stp_array_get_data(array, &size, &data);
+
+
+ +
+
+ +

◆ stp_array_get_point()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
int stp_array_get_point (const stp_array_t * array,
int x,
int y,
double * data 
)
+
+ +

Get the data at a single point in the array.

+
Parameters
+ + + + + +
arraythe array to use.
xthe x location.
ythe y location.
datathe datum is stored in the double pointed to.
+
+
+
Returns
1 on success, 0 on failure.
+ +
+
+ +

◆ stp_array_get_sequence()

+ +
+
+ + + + + + + + +
const stp_sequence_t* stp_array_get_sequence (const stp_array_t * array)
+
+ +

Get the underlying stp_sequence_t.

+
Parameters
+ + +
arraythe array to use.
+
+
+
Returns
the (constant) stp_sequence_t.
+ +
+
+ +

◆ stp_array_get_size()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_array_get_size (const stp_array_t * array,
int * x_size,
int * y_size 
)
+
+ +

Get the size of an array.

+

The current x and y sizes are stored in the integers pointed to by x_size and y_size.

Parameters
+ + + + +
arraythe array to get the size of.
x_sizea pointer to an integer to store the x size in.
y_sizea pointer to an integer to store the y size in.
+
+
+ +
+
+ +

◆ stp_array_set_data()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_array_set_data (stp_array_t * array,
const double * data 
)
+
+ +

Set the data in an array.

+
Parameters
+ + + +
arraythe array to set.
dataa pointer to the first member of an array containing the data to set. This array must be at least as long as (x_size
    +
  • y_size).
    • +
+
+
+
+ +
+
+ +

◆ stp_array_set_point()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
int stp_array_set_point (stp_array_t * array,
int x,
int y,
double data 
)
+
+ +

Set the data at a single point in the array.

+
Parameters
+ + + + + +
arraythe array to use.
xthe x location.
ythe y location.
datathe datum to set.
+
+
+
Returns
1 on success, 0 on failure.
+ +
+
+ +

◆ stp_array_set_size()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_array_set_size (stp_array_t * array,
int x_size,
int y_size 
)
+
+ +

Resize an array.

+

Resizing an array will destroy all data stored in the array.

Parameters
+ + + + +
arraythe array to resize.
x_sizethe new number of "columns".
y_sizethe new number of "rows".
+
+
+ +
+
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/group__color.html b/doc/gutenprint/html/group__color.html new file mode 100644 index 0000000..ee7b9e2 --- /dev/null +++ b/doc/gutenprint/html/group__color.html @@ -0,0 +1,433 @@ + + + + + + + +libgutenprint API Reference: color + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+
+Data Structures | +Typedefs | +Functions
+
+
color
+
+
+ +

The color data type is responsible for providing colour conversion features. +More...

+ + + + + + +

+Data Structures

struct  stp_colorfuncs_t
 
struct  stp_color
 
+ + + +

+Typedefs

typedef struct stp_color stp_color_t
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

int stp_color_init (stp_vars_t *v, stp_image_t *image, size_t steps)
 
int stp_color_get_row (stp_vars_t *v, stp_image_t *image, int row, unsigned *zero_mask)
 
stp_parameter_list_t stp_color_list_parameters (const stp_vars_t *v)
 
void stp_color_describe_parameter (const stp_vars_t *v, const char *name, stp_parameter_t *description)
 
int stp_color_register (const stp_color_t *color)
 
int stp_color_unregister (const stp_color_t *color)
 
int stp_color_count (void)
 Get the number of available color modules. More...
 
const stp_color_t * stp_get_color_by_name (const char *name)
 Get a color module by its name. More...
 
const stp_color_t * stp_get_color_by_index (int idx)
 Get a color module by its index number. More...
 
const stp_color_t * stp_get_color_by_colorfuncs (stp_colorfuncs_t *colorfuncs)
 
const char * stp_color_get_name (const stp_color_t *c)
 Get the short (untranslated) name of a color module. More...
 
const char * stp_color_get_long_name (const stp_color_t *c)
 Get the long (translated) name of a color module. More...
 
+

Detailed Description

+

The color data type is responsible for providing colour conversion features.

+

Color modules provide the actual functionality, so different colour management modules may provide the application with different services (for example, colour profiles).

+

Typedef Documentation

+ +

◆ stp_color_t

+ +
+
+ + + + +
typedef struct stp_color stp_color_t
+
+ +
+
+

Function Documentation

+ +

◆ stp_color_count()

+ +
+
+ + + + + + + + +
int stp_color_count (void )
+
+ +

Get the number of available color modules.

+
Returns
the number of color modules.
+ +
+
+ +

◆ stp_color_describe_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_color_describe_parameter (const stp_vars_t * v,
const char * name,
stp_parameter_t * description 
)
+
+ +
+
+ +

◆ stp_color_get_long_name()

+ +
+
+ + + + + + + + +
const char* stp_color_get_long_name (const stp_color_t * c)
+
+ +

Get the long (translated) name of a color module.

+
Parameters
+ + +
cthe color module to use.
+
+
+
Returns
the long name.
+ +
+
+ +

◆ stp_color_get_name()

+ +
+
+ + + + + + + + +
const char* stp_color_get_name (const stp_color_t * c)
+
+ +

Get the short (untranslated) name of a color module.

+
Parameters
+ + +
cthe color module to use.
+
+
+
Returns
the short name.
+ +
+
+ +

◆ stp_color_get_row()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
int stp_color_get_row (stp_vars_t * v,
stp_image_t * image,
int row,
unsigned * zero_mask 
)
+
+ +
+
+ +

◆ stp_color_init()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_color_init (stp_vars_t * v,
stp_image_t * image,
size_t steps 
)
+
+ +
+
+ +

◆ stp_color_list_parameters()

+ +
+
+ + + + + + + + +
stp_parameter_list_t stp_color_list_parameters (const stp_vars_t * v)
+
+ +
+
+ +

◆ stp_color_register()

+ +
+
+ + + + + + + + +
int stp_color_register (const stp_color_t * color)
+
+ +
+
+ +

◆ stp_color_unregister()

+ +
+
+ + + + + + + + +
int stp_color_unregister (const stp_color_t * color)
+
+ +
+
+ +

◆ stp_get_color_by_colorfuncs()

+ +
+
+ + + + + + + + +
const stp_color_t* stp_get_color_by_colorfuncs (stp_colorfuncs_t * colorfuncs)
+
+ +
+
+ +

◆ stp_get_color_by_index()

+ +
+
+ + + + + + + + +
const stp_color_t* stp_get_color_by_index (int idx)
+
+ +

Get a color module by its index number.

+
Parameters
+ + +
idxthe index number. This must not be greater than (total number of papers - 1).
+
+
+
Returns
a pointer to the color module, or NULL on failure.
+ +
+
+ +

◆ stp_get_color_by_name()

+ +
+
+ + + + + + + + +
const stp_color_t* stp_get_color_by_name (const char * name)
+
+ +

Get a color module by its name.

+
Parameters
+ + +
namethe short unique name. number of papers - 1).
+
+
+
Returns
a pointer to the color module, or NULL on failure.
+ +
+
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/group__curve.html b/doc/gutenprint/html/group__curve.html new file mode 100644 index 0000000..562efbc --- /dev/null +++ b/doc/gutenprint/html/group__curve.html @@ -0,0 +1,2157 @@ + + + + + + + +libgutenprint API Reference: curve + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+
+Data Structures | +Typedefs | +Enumerations | +Functions
+
+
curve
+
+
+ +

The curve type models a linear, spline or gamma curve. +More...

+ + + + + +

+Data Structures

struct  stp_curve_point_t
 Point (x,y) for piecewise curve. More...
 
+ + + + +

+Typedefs

typedef struct stp_curve stp_curve_t
 The curve opaque data type. More...
 
+ + + + + + + + + + + + + +

+Enumerations

enum  stp_curve_type_t { STP_CURVE_TYPE_LINEAR, +STP_CURVE_TYPE_SPLINE + }
 Curve types. More...
 
enum  stp_curve_wrap_mode_t { STP_CURVE_WRAP_NONE, +STP_CURVE_WRAP_AROUND + }
 Wrapping mode. More...
 
enum  stp_curve_compose_t { STP_CURVE_COMPOSE_ADD, +STP_CURVE_COMPOSE_MULTIPLY, +STP_CURVE_COMPOSE_EXPONENTIATE + }
 Composition types. More...
 
enum  stp_curve_bounds_t { STP_CURVE_BOUNDS_RESCALE, +STP_CURVE_BOUNDS_CLIP, +STP_CURVE_BOUNDS_ERROR + }
 Behaviour when curve exceeds bounds. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

stp_curve_t * stp_curve_create (stp_curve_wrap_mode_t wrap)
 Create a new curve. More...
 
stp_curve_t * stp_curve_create_copy (const stp_curve_t *curve)
 Copy and allocate a curve. More...
 
void stp_curve_copy (stp_curve_t *dest, const stp_curve_t *source)
 Copy a curve. More...
 
stp_curve_t * stp_curve_create_reverse (const stp_curve_t *curve)
 Reverse and allocate a curve. More...
 
void stp_curve_reverse (stp_curve_t *dest, const stp_curve_t *source)
 Reverse a curve. More...
 
void stp_curve_destroy (stp_curve_t *curve)
 Destroy an curve. More...
 
int stp_curve_set_bounds (stp_curve_t *curve, double low, double high)
 Set the lower and upper bounds on a curve. More...
 
void stp_curve_get_bounds (const stp_curve_t *curve, double *low, double *high)
 Get the lower and upper bounds on a curve. More...
 
stp_curve_wrap_mode_t stp_curve_get_wrap (const stp_curve_t *curve)
 Get the wrapping mode. More...
 
int stp_curve_is_piecewise (const stp_curve_t *curve)
 Determine whether the curve is piecewise. More...
 
void stp_curve_get_range (const stp_curve_t *curve, double *low, double *high)
 
size_t stp_curve_count_points (const stp_curve_t *curve)
 Get the number of allocated points in the curve. More...
 
int stp_curve_set_interpolation_type (stp_curve_t *curve, stp_curve_type_t itype)
 Set the curve interpolation type. More...
 
stp_curve_type_t stp_curve_get_interpolation_type (const stp_curve_t *curve)
 Get the curve interpolation type. More...
 
int stp_curve_set_data (stp_curve_t *curve, size_t count, const double *data)
 Set all data points of the curve. More...
 
int stp_curve_set_data_points (stp_curve_t *curve, size_t count, const stp_curve_point_t *data)
 Set all data points of the curve. More...
 
int stp_curve_set_float_data (stp_curve_t *curve, size_t count, const float *data)
 Set the data points in a curve from float values. More...
 
int stp_curve_set_long_data (stp_curve_t *curve, size_t count, const long *data)
 Set the data points in a curve from long values. More...
 
int stp_curve_set_ulong_data (stp_curve_t *curve, size_t count, const unsigned long *data)
 Set the data points in a curve from unsigned long values. More...
 
int stp_curve_set_int_data (stp_curve_t *curve, size_t count, const int *data)
 Set the data points in a curve from integer values. More...
 
int stp_curve_set_uint_data (stp_curve_t *curve, size_t count, const unsigned int *data)
 Set the data points in a curve from unsigned integer values. More...
 
int stp_curve_set_short_data (stp_curve_t *curve, size_t count, const short *data)
 Set the data points in a curve from short values. More...
 
int stp_curve_set_ushort_data (stp_curve_t *curve, size_t count, const unsigned short *data)
 Set the data points in a curve from unsigned short values. More...
 
stp_curve_t * stp_curve_get_subrange (const stp_curve_t *curve, size_t start, size_t count)
 Get a curve containing a subrange of data. More...
 
int stp_curve_set_subrange (stp_curve_t *curve, const stp_curve_t *range, size_t start)
 
const double * stp_curve_get_data (const stp_curve_t *curve, size_t *count)
 Get a pointer to the curve's raw data. More...
 
const stp_curve_point_t * stp_curve_get_data_points (const stp_curve_t *curve, size_t *count)
 Get a pointer to the curve's raw data as points. More...
 
const float * stp_curve_get_float_data (const stp_curve_t *curve, size_t *count)
 Get pointer to the curve's raw data as floats. More...
 
const long * stp_curve_get_long_data (const stp_curve_t *curve, size_t *count)
 Get pointer to the curve's raw data as longs. More...
 
const unsigned long * stp_curve_get_ulong_data (const stp_curve_t *curve, size_t *count)
 Get pointer to the curve's raw data as unsigned longs. More...
 
const int * stp_curve_get_int_data (const stp_curve_t *curve, size_t *count)
 Get pointer to the curve's raw data as integers. More...
 
const unsigned int * stp_curve_get_uint_data (const stp_curve_t *curve, size_t *count)
 Get pointer to the curve's raw data as unsigned integers. More...
 
const short * stp_curve_get_short_data (const stp_curve_t *curve, size_t *count)
 Get pointer to the curve's raw data as shorts. More...
 
const unsigned short * stp_curve_get_ushort_data (const stp_curve_t *curve, size_t *count)
 Get pointer to the curve's raw data as unsigned shorts. More...
 
const stp_sequence_t * stp_curve_get_sequence (const stp_curve_t *curve)
 Get the underlying stp_sequence_t data structure which stp_curve_t is derived from. More...
 
int stp_curve_set_gamma (stp_curve_t *curve, double f_gamma)
 Set the gamma of a curve. More...
 
double stp_curve_get_gamma (const stp_curve_t *curve)
 Get the gamma value of the curve. More...
 
int stp_curve_set_point (stp_curve_t *curve, size_t where, double data)
 Set a point along the curve. More...
 
int stp_curve_get_point (const stp_curve_t *curve, size_t where, double *data)
 Get a point along the curve. More...
 
int stp_curve_interpolate_value (const stp_curve_t *curve, double where, double *result)
 Interpolate a point along the curve. More...
 
int stp_curve_resample (stp_curve_t *curve, size_t points)
 Resample a curve (change the number of points). More...
 
int stp_curve_rescale (stp_curve_t *curve, double scale, stp_curve_compose_t mode, stp_curve_bounds_t bounds_mode)
 Rescale a curve (multiply all points by a scaling constant). More...
 
int stp_curve_write (FILE *file, const stp_curve_t *curve)
 Write a curve to a file. More...
 
char * stp_curve_write_string (const stp_curve_t *curve)
 Write a curve to a string. More...
 
stp_curve_t * stp_curve_create_from_stream (FILE *fp)
 Create a curve from a stream. More...
 
stp_curve_t * stp_curve_create_from_file (const char *file)
 Create a curve from a stream. More...
 
stp_curve_t * stp_curve_create_from_string (const char *string)
 Create a curve from a string. More...
 
int stp_curve_compose (stp_curve_t **retval, stp_curve_t *a, stp_curve_t *b, stp_curve_compose_t mode, int points)
 Compose two curves, creating a third curve. More...
 
+

Detailed Description

+

The curve type models a linear, spline or gamma curve.

+

curve "inherits" from the sequence data structure (implemented via containment), since the curve data is represented internally as a sequence of numbers, for linear and spline curves. Linear Piecewise Curves (LPCs) should be implemented in the future which represent a curve in a more compact format.

+

Various operations are supported, including interpolation and composition.

+

Typedef Documentation

+ +

◆ stp_curve_t

+ +
+
+ + + + +
typedef struct stp_curve stp_curve_t
+
+ +

The curve opaque data type.

+ +
+
+

Enumeration Type Documentation

+ +

◆ stp_curve_bounds_t

+ +
+
+ + + + +
enum stp_curve_bounds_t
+
+ +

Behaviour when curve exceeds bounds.

+ + + + +
Enumerator
STP_CURVE_BOUNDS_RESCALE 

Rescale the bounds.

+
STP_CURVE_BOUNDS_CLIP 

Clip the curve to the existing bounds.

+
STP_CURVE_BOUNDS_ERROR 

Error if bounds are violated.

+
+ +
+
+ +

◆ stp_curve_compose_t

+ +
+
+ + + + +
enum stp_curve_compose_t
+
+ +

Composition types.

+ + + + +
Enumerator
STP_CURVE_COMPOSE_ADD 

Add composition.

+
STP_CURVE_COMPOSE_MULTIPLY 

Multiply composition.

+
STP_CURVE_COMPOSE_EXPONENTIATE 

Exponentiate composition.

+
+ +
+
+ +

◆ stp_curve_type_t

+ +
+
+ + + + +
enum stp_curve_type_t
+
+ +

Curve types.

+ + + +
Enumerator
STP_CURVE_TYPE_LINEAR 

Linear interpolation.

+
STP_CURVE_TYPE_SPLINE 

Spline interpolation.

+
+ +
+
+ +

◆ stp_curve_wrap_mode_t

+ +
+
+ + + + +
enum stp_curve_wrap_mode_t
+
+ +

Wrapping mode.

+ + + +
Enumerator
STP_CURVE_WRAP_NONE 

The curve does not wrap.

+
STP_CURVE_WRAP_AROUND 

The curve wraps to its starting point.

+
+ +
+
+

Function Documentation

+ +

◆ stp_curve_compose()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
int stp_curve_compose (stp_curve_t ** retval,
stp_curve_t * a,
stp_curve_t * b,
stp_curve_compose_t mode,
int points 
)
+
+ +

Compose two curves, creating a third curve.

+

Only add and multiply composition is currently supported. If both curves are gamma curves with the same sign, and the operation is multiplication or division, the returned curve is a gamma curve with the appropriate number of points. Both a and b must have the same wraparound type.

Parameters
+ + + + + + +
retvala pointer to store the location of the newly-created output curve in.
athe first source curve.
bthe second source curve.
modethe composition mode.
pointsthe number of points in the output curve (must not exceed 1048576). It must be at least two, unless the curve is a gamma curve and the operation chosen is multiplication or division. If -1, the resulting number of points will be the least common multiplier of the number of points in the input and output curves (but will not exceed 1048576).
+
+
+
Returns
FALSE if element-wise composition fails.
+ +
+
+ +

◆ stp_curve_copy()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_curve_copy (stp_curve_t * dest,
const stp_curve_t * source 
)
+
+ +

Copy a curve.

+

Both dest and source must be valid curves previously created with stp_curve_create().

Parameters
+ + + +
destthe destination curve.
sourcethe source curve.
+
+
+ +
+
+ +

◆ stp_curve_count_points()

+ +
+
+ + + + + + + + +
size_t stp_curve_count_points (const stp_curve_t * curve)
+
+ +

Get the number of allocated points in the curve.

+
Parameters
+ + +
curvethe curve to use.
+
+
+
Returns
the number of points.
+ +
+
+ +

◆ stp_curve_create()

+ +
+
+ + + + + + + + +
stp_curve_t* stp_curve_create (stp_curve_wrap_mode_t wrap)
+
+ +

Create a new curve.

+

Curves have y=lower..upper. The default bounds are 0..1. The default interpolation type is linear. There are no points allocated, and the gamma is defaulted to 1. The curve is a dense (equally-spaced) curve.

+

A wrapped curve has the same value at x=0 and x=1. The wrap mode of a curve cannot be changed except by routines that destroy the old curve entirely (e. g. stp_curve_copy, stp_curve_read).

Parameters
+ + +
wrapthe wrap mode of the curve.
+
+
+
Returns
the newly created curve.
+ +
+
+ +

◆ stp_curve_create_copy()

+ +
+
+ + + + + + + + +
stp_curve_t* stp_curve_create_copy (const stp_curve_t * curve)
+
+ +

Copy and allocate a curve.

+

dest will be created, and then the contents of source will be copied into it. dest must not have been previously allocated with stp_curve_create().

Parameters
+ + +
curvethe source curve.
+
+
+
Returns
the new copy of the curve.
+ +
+
+ +

◆ stp_curve_create_from_file()

+ +
+
+ + + + + + + + +
stp_curve_t* stp_curve_create_from_file (const char * file)
+
+ +

Create a curve from a stream.

+
Warning
NOTE that these calls are not thread-safe! These routines may manipulate the locale to achieve a safe representation.
+
Parameters
+ + +
filethe file to read.
+
+
+
Returns
the newly created curve, or NULL if an error occurred.
+ +
+
+ +

◆ stp_curve_create_from_stream()

+ +
+
+ + + + + + + + +
stp_curve_t* stp_curve_create_from_stream (FILE * fp)
+
+ +

Create a curve from a stream.

+
Warning
NOTE that these calls are not thread-safe! These routines may manipulate the locale to achieve a safe representation.
+
Parameters
+ + +
fpthe stream to read.
+
+
+
Returns
the newly created curve, or NULL if an error occurred.
+ +
+
+ +

◆ stp_curve_create_from_string()

+ +
+
+ + + + + + + + +
stp_curve_t* stp_curve_create_from_string (const char * string)
+
+ +

Create a curve from a string.

+
Warning
NOTE that these calls are not thread-safe! These routines may manipulate the locale to achieve a safe representation.
+
Parameters
+ + +
stringthe string to read.
+
+
+
Returns
the newly created curve, or NULL if an error occurred.
+ +
+
+ +

◆ stp_curve_create_reverse()

+ +
+
+ + + + + + + + +
stp_curve_t* stp_curve_create_reverse (const stp_curve_t * curve)
+
+ +

Reverse and allocate a curve.

+

dest will be created, and then the contents of source will be copied into it. dest must not have been previously allocated with stp_curve_create().

Parameters
+ + +
curvethe source curve.
+
+
+
Returns
the new copy of the curve.
+ +
+
+ +

◆ stp_curve_destroy()

+ +
+
+ + + + + + + + +
void stp_curve_destroy (stp_curve_t * curve)
+
+ +

Destroy an curve.

+

It is an error to destroy the curve more than once.

Parameters
+ + +
curvethe curve to destroy.
+
+
+ +
+
+ +

◆ stp_curve_get_bounds()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_curve_get_bounds (const stp_curve_t * curve,
double * low,
double * high 
)
+
+ +

Get the lower and upper bounds on a curve.

+
Parameters
+ + + + +
curvethe curve to use.
lowa pointer to a double to store the lower bound in.
higha pointer to a double to store the upper bound in.
+
+
+ +
+
+ +

◆ stp_curve_get_data()

+ +
+
+ + + + + + + + + + + + + + + + + + +
const double* stp_curve_get_data (const stp_curve_t * curve,
size_t * count 
)
+
+ +

Get a pointer to the curve's raw data.

+
Parameters
+ + + +
curvethe curve to use.
counta pointer to a size_t to store the curve size in.
+
+
+
Returns
a pointer to the curve data. This data is not guaranteed to be valid beyond the next non-const curve call. If the curve is a pure gamma curve (no associated points), NULL is returned and the count is 0. This call also returns NULL if the curve is a piecewise curve.
+ +
+
+ +

◆ stp_curve_get_data_points()

+ +
+
+ + + + + + + + + + + + + + + + + + +
const stp_curve_point_t* stp_curve_get_data_points (const stp_curve_t * curve,
size_t * count 
)
+
+ +

Get a pointer to the curve's raw data as points.

+
Parameters
+ + + +
curvethe curve to use.
counta pointer to a size_t to store the curve size in.
+
+
+
Returns
a pointer to the curve data. This data is not guaranteed to be valid beyond the next non-const curve call. If the curve is a pure gamma curve (no associated points), NULL is returned and the count is 0. This call also returns NULL if the curve is a dense (equally-spaced) curve.
+ +
+
+ +

◆ stp_curve_get_float_data()

+ +
+
+ + + + + + + + + + + + + + + + + + +
const float* stp_curve_get_float_data (const stp_curve_t * curve,
size_t * count 
)
+
+ +

Get pointer to the curve's raw data as floats.

+
Parameters
+ + + +
curvethe curve to use.
counta pointer to a size_t to store the curve size in.
+
+
+
Returns
a pointer to the curve data. This data is not guaranteed to be valid beyond the next non-const curve call. If the curve is a pure gamma curve (no associated points), NULL is returned and the count is 0. This also returns NULL if the curve is a piecewise curve.
+ +
+
+ +

◆ stp_curve_get_gamma()

+ +
+
+ + + + + + + + +
double stp_curve_get_gamma (const stp_curve_t * curve)
+
+ +

Get the gamma value of the curve.

+
Returns
the gamma value. A value of 0 indicates that the curve does not have a valid gamma value.
+ +
+
+ +

◆ stp_curve_get_int_data()

+ +
+
+ + + + + + + + + + + + + + + + + + +
const int* stp_curve_get_int_data (const stp_curve_t * curve,
size_t * count 
)
+
+ +

Get pointer to the curve's raw data as integers.

+
Parameters
+ + + +
curvethe curve to use.
counta pointer to a size_t to store the curve size in.
+
+
+
Returns
a pointer to the curve data. This data is not guaranteed to be valid beyond the next non-const curve call. If the curve is a pure gamma curve (no associated points), NULL is returned and the count is 0. This also returns NULL if the curve is a piecewise curve.
+ +
+
+ +

◆ stp_curve_get_interpolation_type()

+ +
+
+ + + + + + + + +
stp_curve_type_t stp_curve_get_interpolation_type (const stp_curve_t * curve)
+
+ +

Get the curve interpolation type.

+
Parameters
+ + +
curvethe curve to use.
+
+
+
Returns
the interpolation type.
+ +
+
+ +

◆ stp_curve_get_long_data()

+ +
+
+ + + + + + + + + + + + + + + + + + +
const long* stp_curve_get_long_data (const stp_curve_t * curve,
size_t * count 
)
+
+ +

Get pointer to the curve's raw data as longs.

+
Parameters
+ + + +
curvethe curve to use.
counta pointer to a size_t to store the curve size in.
+
+
+
Returns
a pointer to the curve data. This data is not guaranteed to be valid beyond the next non-const curve call. If the curve is a pure gamma curve (no associated points), NULL is returned and the count is 0. This also returns NULL if the curve is a piecewise curve.
+ +
+
+ +

◆ stp_curve_get_point()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_curve_get_point (const stp_curve_t * curve,
size_t where,
double * data 
)
+
+ +

Get a point along the curve.

+
Parameters
+ + + + +
curvethe curve to use.
wherethe point to get.
dataa pointer to a double to store the value of where in.
+
+
+
Returns
FALSE if where is outside of the number of valid points. This also returns NULL if the curve is a piecewise curve.
+ +
+
+ +

◆ stp_curve_get_range()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_curve_get_range (const stp_curve_t * curve,
double * low,
double * high 
)
+
+ +
+
+ +

◆ stp_curve_get_sequence()

+ +
+
+ + + + + + + + +
const stp_sequence_t* stp_curve_get_sequence (const stp_curve_t * curve)
+
+ +

Get the underlying stp_sequence_t data structure which stp_curve_t is derived from.

+

This can be used for fast access to the raw data.

Parameters
+ + +
curvethe curve to use.
+
+
+
Returns
the stp_sequence_t. If the curve is a piecewise curve, the sequence returned is NULL;
+ +
+
+ +

◆ stp_curve_get_short_data()

+ +
+
+ + + + + + + + + + + + + + + + + + +
const short* stp_curve_get_short_data (const stp_curve_t * curve,
size_t * count 
)
+
+ +

Get pointer to the curve's raw data as shorts.

+
Parameters
+ + + +
curvethe curve to use.
counta pointer to a size_t to store the curve size in.
+
+
+
Returns
a pointer to the curve data. This data is not guaranteed to be valid beyond the next non-const curve call. If the curve is a pure gamma curve (no associated points), NULL is returned and the count is 0. This also returns NULL if the curve is a piecewise curve.
+ +
+
+ +

◆ stp_curve_get_subrange()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
stp_curve_t* stp_curve_get_subrange (const stp_curve_t * curve,
size_t start,
size_t count 
)
+
+ +

Get a curve containing a subrange of data.

+

If the start or count is invalid, the returned curve will compare equal to NULL (i. e. it will be a null pointer). start and count must not exceed the number of points in the curve, and count must be at least 2. The curve must be a dense (equally-spaced) curve

Parameters
+ + + + +
curvethe curve to use.
startthe start of the subrange.
countthe number of point starting at start.
+
+
+
Returns
a curve containing the subrange. The returned curve is non-wrapping.
+ +
+
+ +

◆ stp_curve_get_uint_data()

+ +
+
+ + + + + + + + + + + + + + + + + + +
const unsigned int* stp_curve_get_uint_data (const stp_curve_t * curve,
size_t * count 
)
+
+ +

Get pointer to the curve's raw data as unsigned integers.

+
Parameters
+ + + +
curvethe curve to use.
counta pointer to a size_t to store the curve size in.
+
+
+
Returns
a pointer to the curve data. This data is not guaranteed to be valid beyond the next non-const curve call. If the curve is a pure gamma curve (no associated points), NULL is returned and the count is 0. This also returns NULL if the curve is a piecewise curve.
+ +
+
+ +

◆ stp_curve_get_ulong_data()

+ +
+
+ + + + + + + + + + + + + + + + + + +
const unsigned long* stp_curve_get_ulong_data (const stp_curve_t * curve,
size_t * count 
)
+
+ +

Get pointer to the curve's raw data as unsigned longs.

+
Parameters
+ + + +
curvethe curve to use.
counta pointer to a size_t to store the curve size in.
+
+
+
Returns
a pointer to the curve data. This data is not guaranteed to be valid beyond the next non-const curve call. If the curve is a pure gamma curve (no associated points), NULL is returned and the count is 0. This also returns NULL if the curve is a piecewise curve.
+ +
+
+ +

◆ stp_curve_get_ushort_data()

+ +
+
+ + + + + + + + + + + + + + + + + + +
const unsigned short* stp_curve_get_ushort_data (const stp_curve_t * curve,
size_t * count 
)
+
+ +

Get pointer to the curve's raw data as unsigned shorts.

+
Parameters
+ + + +
curvethe curve to use.
counta pointer to a size_t to store the curve size in.
+
+
+
Returns
a pointer to the curve data. This data is not guaranteed to be valid beyond the next non-const curve call. If the curve is a pure gamma curve (no associated points), NULL is returned and the count is 0. This also returns NULL if the curve is a piecewise curve.
+ +
+
+ +

◆ stp_curve_get_wrap()

+ +
+
+ + + + + + + + +
stp_curve_wrap_mode_t stp_curve_get_wrap (const stp_curve_t * curve)
+
+ +

Get the wrapping mode.

+
Parameters
+ + +
curvethe curve to use.
+
+
+
Returns
the wrapping mode.
+ +
+
+ +

◆ stp_curve_interpolate_value()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_curve_interpolate_value (const stp_curve_t * curve,
double where,
double * result 
)
+
+ +

Interpolate a point along the curve.

+
Parameters
+ + + + +
curvethe curve to use.
wherethe point to interpolate.
resulta pointer to double to store the value of where in. If interpolation would produce a value outside of the allowed range (as could happen with spline interpolation), the value is clipped to the range.
+
+
+
Returns
FALSE if 'where' is less than 0 or greater than the number of points, an error is returned. Also returns FALSE if the curve is a piecewise curve.
+ +
+
+ +

◆ stp_curve_is_piecewise()

+ +
+
+ + + + + + + + +
int stp_curve_is_piecewise (const stp_curve_t * curve)
+
+ +

Determine whether the curve is piecewise.

+
Parameters
+ + +
curvethe curve to use.
+
+
+
Returns
whether the curve is piecewise
+ +
+
+ +

◆ stp_curve_resample()

+ +
+
+ + + + + + + + + + + + + + + + + + +
int stp_curve_resample (stp_curve_t * curve,
size_t points 
)
+
+ +

Resample a curve (change the number of points).

+

This does not destroy the gamma value of a curve. Points are interpolated as required; any interpolation that would place points outside of the bounds of the curve will be clipped to the bounds. The resulting curve is always dense (equally-spaced). This is the correct way to convert a piecewise curve to an equally-spaced curve.

Parameters
+ + + +
curvethe curve to use (must not exceed 1048576).
pointsthe number of points.
+
+
+
Returns
FALSE if the number of points is invalid (less than two, except that zero points is permitted for a gamma curve).
+ +
+
+ +

◆ stp_curve_rescale()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
int stp_curve_rescale (stp_curve_t * curve,
double scale,
stp_curve_compose_t mode,
stp_curve_bounds_t bounds_mode 
)
+
+ +

Rescale a curve (multiply all points by a scaling constant).

+

This also rescales the bounds. Note that this currently destroys the gamma property of the curve.

Parameters
+ + + + + +
curvethe curve to use.
scalethe scaling factor.
modethe composition mode.
bounds_modethe bounds exceeding mode.
+
+
+
Returns
FALSE if this would exceed floating point limits
+ +
+
+ +

◆ stp_curve_reverse()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_curve_reverse (stp_curve_t * dest,
const stp_curve_t * source 
)
+
+ +

Reverse a curve.

+

Both dest and source must be valid curves previously created with stp_curve_create().

Parameters
+ + + +
destthe destination curve.
sourcethe source curve.
+
+
+ +
+
+ +

◆ stp_curve_set_bounds()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_curve_set_bounds (stp_curve_t * curve,
double low,
double high 
)
+
+ +

Set the lower and upper bounds on a curve.

+

To change the bounds adjusting data as required, use stp_curve_rescale instead.

Parameters
+ + + + +
curvethe curve to use.
lowthe lower bound.
highthe upper bound.
+
+
+
Returns
FALSE if any existing points on the curve are outside the bounds.
+ +
+
+ +

◆ stp_curve_set_data()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_curve_set_data (stp_curve_t * curve,
size_t count,
const double * data 
)
+
+ +

Set all data points of the curve.

+

If any of the data points fall outside the bounds, the operation is not performed and FALSE is returned. This creates a curve with equally-spaced points.

Parameters
+ + + + +
curvethe curve to use.
countthe number of points (must be at least two and not more than 1048576).
dataa pointer to an array of doubles (must be at least count in size).
+
+
+
Returns
1 on success, 0 on failure.
+ +
+
+ +

◆ stp_curve_set_data_points()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_curve_set_data_points (stp_curve_t * curve,
size_t count,
const stp_curve_point_t * data 
)
+
+ +

Set all data points of the curve.

+

If any of the data points fall outside the bounds, the operation is not performed and FALSE is returned. This creates a piecewise curve.

Parameters
+ + + + +
curvethe curve to use.
countthe number of points (must be at least two and not more than 1048576).
dataa pointer to an array of points (must be at least count in size). The first point must have X=0, and each point must have an X value at least .000001 greater than the previous point. If the curve is not a wraparound curve, the last point must have X=1.
+
+
+
Returns
1 on success, 0 on failure.
+ +
+
+ +

◆ stp_curve_set_float_data()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_curve_set_float_data (stp_curve_t * curve,
size_t count,
const float * data 
)
+
+ +

Set the data points in a curve from float values.

+

If any of the data points fall outside the bounds, the operation is not performed and FALSE is returned. This creates a curve with equally-spaced points.

Parameters
+ + + + +
curvethe curve to use.
countthe number of the number of points (must be at least two and not more than 1048576).
dataa pointer to an array of floats (must be at least count in size).
+
+
+
Returns
1 on success, 0 on failure.
+ +
+
+ +

◆ stp_curve_set_gamma()

+ +
+
+ + + + + + + + + + + + + + + + + + +
int stp_curve_set_gamma (stp_curve_t * curve,
double f_gamma 
)
+
+ +

Set the gamma of a curve.

+

This replaces all existing points along the curve. The bounds are set to 0..1. If the gamma value is positive, the function is increasing; if negative, the function is decreasing. Count must be either 0 or at least 2. If the count is zero, the gamma of the curve is set for interpolation purposes, but points cannot be assigned to. It is illegal to set gamma on a wrap-mode curve. The resulting curve is treated as a dense (equally-spaced) curve.

Parameters
+ + + +
curvethe curve to use.
f_gammathe gamma value to set.
+
+
+
Returns
FALSE if the gamma value is illegal (0, infinity, or NaN), or if the curve wraps around.
+ +
+
+ +

◆ stp_curve_set_int_data()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_curve_set_int_data (stp_curve_t * curve,
size_t count,
const int * data 
)
+
+ +

Set the data points in a curve from integer values.

+

If any of the data points fall outside the bounds, the operation is not performed and FALSE is returned. This creates a curve with equally-spaced points.

Parameters
+ + + + +
curvethe curve to use.
countthe number of the number of points (must be at least two and not more than 1048576).
dataa pointer to an array of integers (must be at least count in size).
+
+
+
Returns
1 on success, 0 on failure.
+ +
+
+ +

◆ stp_curve_set_interpolation_type()

+ +
+
+ + + + + + + + + + + + + + + + + + +
int stp_curve_set_interpolation_type (stp_curve_t * curve,
stp_curve_type_t itype 
)
+
+ +

Set the curve interpolation type.

+
Parameters
+ + + +
curvethe curve to use.
itypethe interpolation type.
+
+
+
Returns
1 on success, or 0 if itype is invalid.
+ +
+
+ +

◆ stp_curve_set_long_data()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_curve_set_long_data (stp_curve_t * curve,
size_t count,
const long * data 
)
+
+ +

Set the data points in a curve from long values.

+

If any of the data points fall outside the bounds, the operation is not performed and FALSE is returned. This creates a curve with equally-spaced points.

Parameters
+ + + + +
curvethe curve to use.
countthe number of the number of points (must be at least two and not more than 1048576).
dataa pointer to an array of longs (must be at least count in size).
+
+
+
Returns
1 on success, 0 on failure.
+ +
+
+ +

◆ stp_curve_set_point()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_curve_set_point (stp_curve_t * curve,
size_t where,
double data 
)
+
+ +

Set a point along the curve.

+

This call destroys any gamma value assigned to the curve.

Parameters
+ + + + +
curvethe curve to use.
wherethe point to set.
datathe value to set where to.
+
+
+
Returns
FALSE if data is outside the valid bounds or if where is outside the number of valid points. This also returns NULL if the curve is a piecewise curve.
+ +
+
+ +

◆ stp_curve_set_short_data()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_curve_set_short_data (stp_curve_t * curve,
size_t count,
const short * data 
)
+
+ +

Set the data points in a curve from short values.

+

If any of the data points fall outside the bounds, the operation is not performed and FALSE is returned. This creates a curve with equally-spaced points.

Parameters
+ + + + +
curvethe curve to use.
countthe number of the number of points (must be at least two and not more than 1048576).
dataa pointer to an array of shorts (must be at least count in size).
+
+
+
Returns
1 on success, 0 on failure.
+ +
+
+ +

◆ stp_curve_set_subrange()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_curve_set_subrange (stp_curve_t * curve,
const stp_curve_t * range,
size_t start 
)
+
+ +
+
+ +

◆ stp_curve_set_uint_data()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_curve_set_uint_data (stp_curve_t * curve,
size_t count,
const unsigned int * data 
)
+
+ +

Set the data points in a curve from unsigned integer values.

+

If any of the data points fall outside the bounds, the operation is not performed and FALSE is returned. This creates a curve with equally-spaced points.

Parameters
+ + + + +
curvethe curve to use.
countthe number of the number of points (must be at least two and not more than 1048576).
dataa pointer to an array of unsigned integers (must be at least count in size).
+
+
+
Returns
1 on success, 0 on failure.
+ +
+
+ +

◆ stp_curve_set_ulong_data()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_curve_set_ulong_data (stp_curve_t * curve,
size_t count,
const unsigned long * data 
)
+
+ +

Set the data points in a curve from unsigned long values.

+

If any of the data points fall outside the bounds, the operation is not performed and FALSE is returned. This creates a curve with equally-spaced points.

Parameters
+ + + + +
curvethe curve to use.
countthe number of the number of points (must be at least two and not more than 1048576).
dataa pointer to an array of unsigned longs (must be at least count in size).
+
+
+
Returns
1 on success, 0 on failure.
+ +
+
+ +

◆ stp_curve_set_ushort_data()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_curve_set_ushort_data (stp_curve_t * curve,
size_t count,
const unsigned short * data 
)
+
+ +

Set the data points in a curve from unsigned short values.

+

If any of the data points fall outside the bounds, the operation is not performed and FALSE is returned. This creates a curve with equally-spaced points.

Parameters
+ + + + +
curvethe curve to use.
countthe number of the number of points (must be at least two and not more than 1048576).
dataa pointer to an array of unsigned shorts (must be at least count in size).
+
+
+
Returns
1 on success, 0 on failure.
+ +
+
+ +

◆ stp_curve_write()

+ +
+
+ + + + + + + + + + + + + + + + + + +
int stp_curve_write (FILE * file,
const stp_curve_t * curve 
)
+
+ +

Write a curve to a file.

+

The printable representation is guaranteed to contain only 7-bit printable ASCII characters, and is null-terminated. The curve will not contain any space, newline, single quote, or comma characters. Furthermore, a printed curve will be read back correctly in all locales. These calls are not guaranteed to provide more than 6 decimal places of precision or +/-0.5e-6 accuracy, whichever is less.

Warning
NOTE that these calls are not thread-safe! These routines may manipulate the locale to achieve a safe representation.
+
Parameters
+ + + +
filethe file to write.
curvethe curve to use.
+
+
+
Returns
1 on success, 0 on failure.
+ +
+
+ +

◆ stp_curve_write_string()

+ +
+
+ + + + + + + + +
char* stp_curve_write_string (const stp_curve_t * curve)
+
+ +

Write a curve to a string.

+

The printable representation is guaranteed to contain only 7-bit printable ASCII characters, and is null-terminated. The curve will not contain any space, newline, or comma characters. Furthermore, a printed curve will be read back correctly in all locales. These calls are not guaranteed to provide more than 6 decimal places of precision or +/-0.5e-6 accuracy, whichever is less.

Warning
NOTE that these calls are not thread-safe! These routines may manipulate the locale to achieve a safe representation.
+
Parameters
+ + +
curvethe curve to use.
+
+
+
Returns
a pointer to a string. This is allocated on the heap, and it is the caller's responsibility to free it.
+ +
+
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/group__image.html b/doc/gutenprint/html/group__image.html new file mode 100644 index 0000000..e486736 --- /dev/null +++ b/doc/gutenprint/html/group__image.html @@ -0,0 +1,313 @@ + + + + + + + +libgutenprint API Reference: image + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+
+Data Structures | +Macros | +Typedefs | +Enumerations | +Functions
+
+
image
+
+
+ +

The image type is an abstract data type for interfacing with the image creation program. +More...

+ + + + + +

+Data Structures

struct  stp_image
 The image type is an abstract data type for interfacing with the image creation program. More...
 
+ + + +

+Macros

#define STP_CHANNEL_LIMIT   (64)
 
+ + + + +

+Typedefs

typedef struct stp_image stp_image_t
 The image type is an abstract data type for interfacing with the image creation program. More...
 
+ + + + +

+Enumerations

enum  stp_image_status_t { STP_IMAGE_STATUS_OK, +STP_IMAGE_STATUS_ABORT + }
 Image status. More...
 
+ + + + + + + + + + + + + + + +

+Functions

void stp_image_init (stp_image_t *image)
 
void stp_image_reset (stp_image_t *image)
 
int stp_image_width (stp_image_t *image)
 
int stp_image_height (stp_image_t *image)
 
stp_image_status_t stp_image_get_row (stp_image_t *image, unsigned char *data, size_t limit, int row)
 
const char * stp_image_get_appname (stp_image_t *image)
 
void stp_image_conclude (stp_image_t *image)
 
+

Detailed Description

+

The image type is an abstract data type for interfacing with the image creation program.

+

Macro Definition Documentation

+ +

◆ STP_CHANNEL_LIMIT

+ +
+
+ + + + +
#define STP_CHANNEL_LIMIT   (64)
+
+

The maximum number of channels.

+ +
+
+

Typedef Documentation

+ +

◆ stp_image_t

+ +
+
+ + + + +
typedef struct stp_image stp_image_t
+
+ +

The image type is an abstract data type for interfacing with the image creation program.

+

It provides callbacks to functions defined within the client application which are called while printing the image.

+ +
+
+

Enumeration Type Documentation

+ +

◆ stp_image_status_t

+ +
+
+ + + + +
enum stp_image_status_t
+
+ +

Image status.

+ + + +
Enumerator
STP_IMAGE_STATUS_OK 

Everything is OK.

+
STP_IMAGE_STATUS_ABORT 

An error occurred, or the job was aborted.

+
+ +
+
+

Function Documentation

+ +

◆ stp_image_conclude()

+ +
+
+ + + + + + + + +
void stp_image_conclude (stp_image_t * image)
+
+ +
+
+ +

◆ stp_image_get_appname()

+ +
+
+ + + + + + + + +
const char* stp_image_get_appname (stp_image_t * image)
+
+ +
+
+ +

◆ stp_image_get_row()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
stp_image_status_t stp_image_get_row (stp_image_t * image,
unsigned char * data,
size_t limit,
int row 
)
+
+ +
+
+ +

◆ stp_image_height()

+ +
+
+ + + + + + + + +
int stp_image_height (stp_image_t * image)
+
+ +
+
+ +

◆ stp_image_init()

+ +
+
+ + + + + + + + +
void stp_image_init (stp_image_t * image)
+
+ +
+
+ +

◆ stp_image_reset()

+ +
+
+ + + + + + + + +
void stp_image_reset (stp_image_t * image)
+
+ +
+
+ +

◆ stp_image_width()

+ +
+
+ + + + + + + + +
int stp_image_width (stp_image_t * image)
+
+ +
+
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/group__intl.html b/doc/gutenprint/html/group__intl.html new file mode 100644 index 0000000..33467e9 --- /dev/null +++ b/doc/gutenprint/html/group__intl.html @@ -0,0 +1,242 @@ + + + + + + + +libgutenprint API Reference: intl + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+
+Macros
+
+
intl
+
+
+ +

Internationalisation functions are used to localise Gimp-Print by translating strings into the user's native language. +More...

+ + + + + + + + + + + + + + + + +

+Macros

#define textdomain(String)   (String)
 
#define gettext(String)   (String)
 
#define dgettext(Domain, Message)   (Message)
 
#define dcgettext(Domain, Message, Type)   (Message)
 
#define bindtextdomain(Domain, Directory)   (Domain)
 
#define _(String)   (String)
 
#define N_(String)   (String)
 
+

Detailed Description

+

Internationalisation functions are used to localise Gimp-Print by translating strings into the user's native language.

+

The macros defined in this header are convenience wrappers around the gettext functions provided by libintl library (or directly by libc on GNU systems).

+

Macro Definition Documentation

+ +

◆ _

+ +
+
+ + + + + + + + +
#define _( String)   (String)
+
+ +
+
+ +

◆ bindtextdomain

+ +
+
+ + + + + + + + + + + + + + + + + + +
#define bindtextdomain( Domain,
 Directory 
)   (Domain)
+
+ +
+
+ +

◆ dcgettext

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
#define dcgettext( Domain,
 Message,
 Type 
)   (Message)
+
+ +
+
+ +

◆ dgettext

+ +
+
+ + + + + + + + + + + + + + + + + + +
#define dgettext( Domain,
 Message 
)   (Message)
+
+ +
+
+ +

◆ gettext

+ +
+
+ + + + + + + + +
#define gettext( String)   (String)
+
+ +
+
+ +

◆ N_

+ +
+
+ + + + + + + + +
#define N_( String)   (String)
+
+ +
+
+ +

◆ textdomain

+ +
+
+ + + + + + + + +
#define textdomain( String)   (String)
+
+ +
+
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/group__intl__internal.html b/doc/gutenprint/html/group__intl__internal.html new file mode 100644 index 0000000..8500a02 --- /dev/null +++ b/doc/gutenprint/html/group__intl__internal.html @@ -0,0 +1,242 @@ + + + + + + + +libgutenprint API Reference: intl-internal + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+
+Macros
+
+
intl-internal
+
+
+ +

Internationalisation functions are used to localise Gimp-Print by translating strings into the user's native language. +More...

+ + + + + + + + + + + + + + + + +

+Macros

#define textdomain(String)   (String)
 
#define gettext(String)   (String)
 
#define dgettext(Domain, Message)   (Message)
 
#define dcgettext(Domain, Message, Type)   (Message)
 
#define bindtextdomain(Domain, Directory)   (Domain)
 
#define _(String)   (String)
 
#define N_(String)   (String)
 
+

Detailed Description

+

Internationalisation functions are used to localise Gimp-Print by translating strings into the user's native language.

+

The macros defined in this header are convenience wrappers around the gettext functions provided by libintl library (or directly by libc on GNU systems). They differ from the normal intl functions in that the textdomain is fixed, for use by functions internal to Gimp-Print. This header should not be included by source files outside the gimp-print source tree.

+

Macro Definition Documentation

+ +

◆ _

+ +
+
+ + + + + + + + +
#define _( String)   (String)
+
+ +
+
+ +

◆ bindtextdomain

+ +
+
+ + + + + + + + + + + + + + + + + + +
#define bindtextdomain( Domain,
 Directory 
)   (Domain)
+
+ +
+
+ +

◆ dcgettext

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
#define dcgettext( Domain,
 Message,
 Type 
)   (Message)
+
+ +
+
+ +

◆ dgettext

+ +
+
+ + + + + + + + + + + + + + + + + + +
#define dgettext( Domain,
 Message 
)   (Message)
+
+ +
+
+ +

◆ gettext

+ +
+
+ + + + + + + + +
#define gettext( String)   (String)
+
+ +
+
+ +

◆ N_

+ +
+
+ + + + + + + + +
#define N_( String)   (String)
+
+ +
+
+ +

◆ textdomain

+ +
+
+ + + + + + + + +
#define textdomain( String)   (String)
+
+ +
+
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/group__list.html b/doc/gutenprint/html/group__list.html new file mode 100644 index 0000000..512d01e --- /dev/null +++ b/doc/gutenprint/html/group__list.html @@ -0,0 +1,1088 @@ + + + + + + + +libgutenprint API Reference: list + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+
+Typedefs | +Functions
+
+
list
+
+
+ +

The list data type implements a fast generic doubly-linked list. +More...

+ + + + + + + + + + + + + + + + + + + + +

+Typedefs

typedef struct stp_list_item stp_list_item_t
 The list item opaque data type. More...
 
typedef struct stp_list stp_list_t
 The list opaque data type. More...
 
typedef void(* stp_node_freefunc) (void *)
 A callback function to free the data a node contains. More...
 
typedef void *(* stp_node_copyfunc) (const void *)
 A callback function to copy the data a node contains. More...
 
typedef const char *(* stp_node_namefunc) (const void *)
 A callback function to get the name of a node. More...
 
typedef int(* stp_node_sortfunc) (const void *, const void *)
 A callback function to compare two nodes. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

void stp_list_node_free_data (void *item)
 Free node data allocated with stp_malloc. More...
 
stp_list_t * stp_list_create (void)
 Create a new list object. More...
 
stp_list_t * stp_list_copy (const stp_list_t *list)
 Copy and allocate a list object. More...
 
int stp_list_destroy (stp_list_t *list)
 Destroy a list object. More...
 
stp_list_item_t * stp_list_get_start (const stp_list_t *list)
 Find the first item in a list. More...
 
stp_list_item_t * stp_list_get_end (const stp_list_t *list)
 Find the last item in a list. More...
 
stp_list_item_t * stp_list_get_item_by_index (const stp_list_t *list, int idx)
 Find an item in a list by its index. More...
 
stp_list_item_t * stp_list_get_item_by_name (const stp_list_t *list, const char *name)
 Find an item in a list by its name. More...
 
stp_list_item_t * stp_list_get_item_by_long_name (const stp_list_t *list, const char *long_name)
 Find an item in a list by its long name. More...
 
int stp_list_get_length (const stp_list_t *list)
 Get the length of a list. More...
 
void stp_list_set_freefunc (stp_list_t *list, stp_node_freefunc freefunc)
 Set a list node free function. More...
 
stp_node_freefunc stp_list_get_freefunc (const stp_list_t *list)
 Get a list node free function. More...
 
void stp_list_set_copyfunc (stp_list_t *list, stp_node_copyfunc copyfunc)
 Set a list node copy function. More...
 
stp_node_copyfunc stp_list_get_copyfunc (const stp_list_t *list)
 Get a list node copy function. More...
 
void stp_list_set_namefunc (stp_list_t *list, stp_node_namefunc namefunc)
 Set a list node name function. More...
 
stp_node_namefunc stp_list_get_namefunc (const stp_list_t *list)
 Get a list node name function. More...
 
void stp_list_set_long_namefunc (stp_list_t *list, stp_node_namefunc long_namefunc)
 Set a list node long name function. More...
 
stp_node_namefunc stp_list_get_long_namefunc (const stp_list_t *list)
 Get a list node long name function. More...
 
void stp_list_set_sortfunc (stp_list_t *list, stp_node_sortfunc sortfunc)
 Set a list node sort function. More...
 
stp_node_sortfunc stp_list_get_sortfunc (const stp_list_t *list)
 Get a list node sort function. More...
 
int stp_list_item_create (stp_list_t *list, stp_list_item_t *next, const void *data)
 Create a new list item. More...
 
int stp_list_item_destroy (stp_list_t *list, stp_list_item_t *item)
 Destroy a list item. More...
 
stp_list_item_t * stp_list_item_prev (const stp_list_item_t *item)
 Get the previous item in the list. More...
 
stp_list_item_t * stp_list_item_next (const stp_list_item_t *item)
 Get the next item in the list. More...
 
void * stp_list_item_get_data (const stp_list_item_t *item)
 Get the data associated with a list item. More...
 
int stp_list_item_set_data (stp_list_item_t *item, void *data)
 Set the data associated with a list item. More...
 
+

Detailed Description

+

The list data type implements a fast generic doubly-linked list.

+

It supports all of the operations you might want in a list (insert, remove, iterate over the list, copy whole lists), plus some (optional) less common features: finding items by index, name or long name, and sorting. These should also be fairly fast, due to caching in the list head.

+

Typedef Documentation

+ +

◆ stp_list_item_t

+ +
+
+ + + + +
typedef struct stp_list_item stp_list_item_t
+
+ +

The list item opaque data type.

+

This object is a node in the list.

+ +
+
+ +

◆ stp_list_t

+ +
+
+ + + + +
typedef struct stp_list stp_list_t
+
+ +

The list opaque data type.

+

This object represents the list as a whole.

+ +
+
+ +

◆ stp_node_copyfunc

+ +
+
+ + + + +
typedef void*(* stp_node_copyfunc) (const void *)
+
+ +

A callback function to copy the data a node contains.

+

The parameter is a pointer to the node data. The return value is a pointer to the new copy of the data.

+ +
+
+ +

◆ stp_node_freefunc

+ +
+
+ + + + +
typedef void(* stp_node_freefunc) (void *)
+
+ +

A callback function to free the data a node contains.

+

The parameter is a pointer to the node data.

+ +
+
+ +

◆ stp_node_namefunc

+ +
+
+ + + + +
typedef const char*(* stp_node_namefunc) (const void *)
+
+ +

A callback function to get the name of a node.

+

The parameter is a pointer to the node data. The return value is a pointer to the name of the node, or NULL if there is no name.

+ +
+
+ +

◆ stp_node_sortfunc

+ +
+
+ + + + +
typedef int(* stp_node_sortfunc) (const void *, const void *)
+
+ +

A callback function to compare two nodes.

+

The two parameters are pointers to node data. The return value is <0 if the first sorts before the second, 0 if they sort identically, and >0 if the first sorts after the second.

+ +
+
+

Function Documentation

+ +

◆ stp_list_copy()

+ +
+
+ + + + + + + + +
stp_list_t* stp_list_copy (const stp_list_t * list)
+
+ +

Copy and allocate a list object.

+

list must be a valid list object previously created with stp_list_create().

Parameters
+ + +
listthe list to copy.
+
+
+
Returns
a pointer to the new copy of the list.
+ +
+
+ +

◆ stp_list_create()

+ +
+
+ + + + + + + + +
stp_list_t* stp_list_create (void )
+
+ +

Create a new list object.

+
Returns
the newly created list object.
+ +
+
+ +

◆ stp_list_destroy()

+ +
+
+ + + + + + + + +
int stp_list_destroy (stp_list_t * list)
+
+ +

Destroy a list object.

+

It is an error to destroy the list more than once.

Parameters
+ + +
listthe list to destroy.
+
+
+
Returns
0 on success, 1 on failure.
+ +
+
+ +

◆ stp_list_get_copyfunc()

+ +
+
+ + + + + + + + +
stp_node_copyfunc stp_list_get_copyfunc (const stp_list_t * list)
+
+ +

Get a list node copy function.

+
Parameters
+ + +
listthe list to use.
+
+
+
Returns
the function previously set with stp_list_set_copyfunc, or NULL if no function has been set.
+ +
+
+ +

◆ stp_list_get_end()

+ +
+
+ + + + + + + + +
stp_list_item_t* stp_list_get_end (const stp_list_t * list)
+
+ +

Find the last item in a list.

+
Parameters
+ + +
listthe list to use.
+
+
+
Returns
a pointer to the last list item, or NULL if the list is empty.
+ +
+
+ +

◆ stp_list_get_freefunc()

+ +
+
+ + + + + + + + +
stp_node_freefunc stp_list_get_freefunc (const stp_list_t * list)
+
+ +

Get a list node free function.

+
Parameters
+ + +
listthe list to use.
+
+
+
Returns
the function previously set with stp_list_set_freefunc, or NULL if no function has been set.
+ +
+
+ +

◆ stp_list_get_item_by_index()

+ +
+
+ + + + + + + + + + + + + + + + + + +
stp_list_item_t* stp_list_get_item_by_index (const stp_list_t * list,
int idx 
)
+
+ +

Find an item in a list by its index.

+
Parameters
+ + + +
listthe list to use.
idxthe index to find.
+
+
+
Returns
a pointer to the list item, or NULL if the index is invalid or the list is empty.
+ +
+
+ +

◆ stp_list_get_item_by_long_name()

+ +
+
+ + + + + + + + + + + + + + + + + + +
stp_list_item_t* stp_list_get_item_by_long_name (const stp_list_t * list,
const char * long_name 
)
+
+ +

Find an item in a list by its long name.

+
Parameters
+ + + +
listthe list to use.
long_namethe long name to find.
+
+
+
Returns
a pointer to the list item, or NULL if the long name is invalid or the list is empty.
+ +
+
+ +

◆ stp_list_get_item_by_name()

+ +
+
+ + + + + + + + + + + + + + + + + + +
stp_list_item_t* stp_list_get_item_by_name (const stp_list_t * list,
const char * name 
)
+
+ +

Find an item in a list by its name.

+
Parameters
+ + + +
listthe list to use.
namethe name to find.
+
+
+
Returns
a pointer to the list item, or NULL if the name is invalid or the list is empty.
+ +
+
+ +

◆ stp_list_get_length()

+ +
+
+ + + + + + + + +
int stp_list_get_length (const stp_list_t * list)
+
+ +

Get the length of a list.

+
Parameters
+ + +
listthe list to use.
+
+
+
Returns
the list length (number of list items).
+ +
+
+ +

◆ stp_list_get_long_namefunc()

+ +
+
+ + + + + + + + +
stp_node_namefunc stp_list_get_long_namefunc (const stp_list_t * list)
+
+ +

Get a list node long name function.

+
Parameters
+ + +
listthe list to use.
+
+
+
Returns
the function previously set with stp_list_set_long_namefunc, or NULL if no function has been set.
+ +
+
+ +

◆ stp_list_get_namefunc()

+ +
+
+ + + + + + + + +
stp_node_namefunc stp_list_get_namefunc (const stp_list_t * list)
+
+ +

Get a list node name function.

+
Parameters
+ + +
listthe list to use.
+
+
+
Returns
the function previously set with stp_list_set_namefunc, or NULL if no function has been set.
+ +
+
+ +

◆ stp_list_get_sortfunc()

+ +
+
+ + + + + + + + +
stp_node_sortfunc stp_list_get_sortfunc (const stp_list_t * list)
+
+ +

Get a list node sort function.

+
Parameters
+ + +
listthe list to use.
+
+
+
Returns
the function previously set with stp_list_set_sortfunc, or NULL if no function has been set.
+ +
+
+ +

◆ stp_list_get_start()

+ +
+
+ + + + + + + + +
stp_list_item_t* stp_list_get_start (const stp_list_t * list)
+
+ +

Find the first item in a list.

+
Parameters
+ + +
listthe list to use.
+
+
+
Returns
a pointer to the first list item, or NULL if the list is empty.
+ +
+
+ +

◆ stp_list_item_create()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_list_item_create (stp_list_t * list,
stp_list_item_t * next,
const void * data 
)
+
+ +

Create a new list item.

+
Parameters
+ + + + +
listthe list to use.
nextthe next item in the list, or NULL to insert at the end of the list.
datathe data the list item will contain.
+
+
+
Returns
0 on success, 1 on failure (if data is NULL, for example).
+ +
+
+ +

◆ stp_list_item_destroy()

+ +
+
+ + + + + + + + + + + + + + + + + + +
int stp_list_item_destroy (stp_list_t * list,
stp_list_item_t * item 
)
+
+ +

Destroy a list item.

+
Parameters
+ + + +
listthe list to use.
itemthe item to destroy.
+
+
+
Returns
0 on success, 1 on failure.
+ +
+
+ +

◆ stp_list_item_get_data()

+ +
+
+ + + + + + + + +
void* stp_list_item_get_data (const stp_list_item_t * item)
+
+ +

Get the data associated with a list item.

+
Parameters
+ + +
itemthe list item to use.
+
+
+
Returns
the data associated with item.
+ +
+
+ +

◆ stp_list_item_next()

+ +
+
+ + + + + + + + +
stp_list_item_t* stp_list_item_next (const stp_list_item_t * item)
+
+ +

Get the next item in the list.

+
Parameters
+ + +
itemthe item to start from.
+
+
+
Returns
a pointer to the list item following from item, or NULL if item is the end of the list.
+ +
+
+ +

◆ stp_list_item_prev()

+ +
+
+ + + + + + + + +
stp_list_item_t* stp_list_item_prev (const stp_list_item_t * item)
+
+ +

Get the previous item in the list.

+
Parameters
+ + +
itemthe item to start from.
+
+
+
Returns
a pointer to the list item prior to item, or NULL if item is the start of the list.
+ +
+
+ +

◆ stp_list_item_set_data()

+ +
+
+ + + + + + + + + + + + + + + + + + +
int stp_list_item_set_data (stp_list_item_t * item,
void * data 
)
+
+ +

Set the data associated with a list item.

+
Warning
Note that if a sortfunc is in use, changing the data will NOT re-sort the list!
+
Parameters
+ + + +
itemthe list item to use.
datathe data to set.
+
+
+
Returns
0 on success, 1 on failure (if data is NULL).
+ +
+
+ +

◆ stp_list_node_free_data()

+ +
+
+ + + + + + + + +
void stp_list_node_free_data (void * item)
+
+ +

Free node data allocated with stp_malloc.

+

This function is indended for use as an stp_node_freefunc, which uses stp_free to free the node data.

Parameters
+ + +
itemthe node data to free
+
+
+ +
+
+ +

◆ stp_list_set_copyfunc()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_list_set_copyfunc (stp_list_t * list,
stp_node_copyfunc copyfunc 
)
+
+ +

Set a list node copy function.

+

This callback function will be called whenever a list item is copied. Its intended use is for automatic object copying (since C lacks a copy constructor).

Parameters
+ + + +
listthe list to use.
copyfuncthe function to set.
+
+
+ +
+
+ +

◆ stp_list_set_freefunc()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_list_set_freefunc (stp_list_t * list,
stp_node_freefunc freefunc 
)
+
+ +

Set a list node free function.

+

This callback function will be called whenever a list item is destroyed. Its intended use is for automatic object destruction and any other cleanup required.

Parameters
+ + + +
listthe list to use.
freefuncthe function to set.
+
+
+ +
+
+ +

◆ stp_list_set_long_namefunc()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_list_set_long_namefunc (stp_list_t * list,
stp_node_namefunc long_namefunc 
)
+
+ +

Set a list node long name function.

+

This callback function will be called whenever the long name of a list item needs to be determined. This is used to find list items by long name.

Parameters
+ + + +
listthe list to use.
long_namefuncthe function to set.
+
+
+ +
+
+ +

◆ stp_list_set_namefunc()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_list_set_namefunc (stp_list_t * list,
stp_node_namefunc namefunc 
)
+
+ +

Set a list node name function.

+

This callback function will be called whenever the name of a list item needs to be determined. This is used to find list items by name.

Parameters
+ + + +
listthe list to use.
namefuncthe function to set.
+
+
+ +
+
+ +

◆ stp_list_set_sortfunc()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_list_set_sortfunc (stp_list_t * list,
stp_node_sortfunc sortfunc 
)
+
+ +

Set a list node sort function.

+

This callback function will be called to determine the sort order for list items in sorted lists.

Parameters
+ + + +
listthe list to use.
sortfuncthe function to set.
+
+
+ +
+
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/group__papersize.html b/doc/gutenprint/html/group__papersize.html new file mode 100644 index 0000000..80b6cef --- /dev/null +++ b/doc/gutenprint/html/group__papersize.html @@ -0,0 +1,350 @@ + + + + + + + +libgutenprint API Reference: papersize + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+
+Data Structures | +Enumerations | +Functions
+
+
papersize
+
+
+ +

The papersize describes the dimensions of a paper. +More...

+ + + + + +

+Data Structures

struct  stp_papersize_t
 The papersize data type. More...
 
+ + + + + + +

+Enumerations

enum  stp_papersize_unit_t { PAPERSIZE_ENGLISH_STANDARD, +PAPERSIZE_METRIC_STANDARD, +PAPERSIZE_ENGLISH_EXTENDED, +PAPERSIZE_METRIC_EXTENDED + }
 Units of measurement. More...
 
enum  stp_papersize_type_t { PAPERSIZE_TYPE_STANDARD = 0, +PAPERSIZE_TYPE_ENVELOPE, +PAPERSIZE_TYPE_SPECIAL + }
 
+ + + + + + + + + + + + + + + + + + + +

+Functions

int stp_known_papersizes (void)
 Get the number of available papersizes. More...
 
const stp_papersize_t * stp_get_papersize_by_name (const char *name)
 Get a papersize by name. More...
 
const stp_papersize_t * stp_get_papersize_by_size (int length, int width)
 Get a papersize by size. More...
 
const stp_papersize_t * stp_get_papersize_by_size_exact (int length, int width)
 Get a papersize by size if an exact match is found. More...
 
const stp_papersize_t * stp_get_papersize_by_index (int idx)
 Get a papersize by its index number. More...
 
void stp_default_media_size (const stp_vars_t *v, int *width, int *height)
 Get the default paper dimensions for the current configuration. More...
 
+

Detailed Description

+

The papersize describes the dimensions of a paper.

+

Enumeration Type Documentation

+ +

◆ stp_papersize_type_t

+ +
+
+ + + + +
enum stp_papersize_type_t
+
+ + + + +
Enumerator
PAPERSIZE_TYPE_STANDARD 

Standard paper size.

+
PAPERSIZE_TYPE_ENVELOPE 

Envelope.

+
PAPERSIZE_TYPE_SPECIAL 

Special (not normally displayed)

+
+ +
+
+ +

◆ stp_papersize_unit_t

+ +
+
+ + + + +
enum stp_papersize_unit_t
+
+ +

Units of measurement.

+ + + + + +
Enumerator
PAPERSIZE_ENGLISH_STANDARD 

English/Imperial units.

+
PAPERSIZE_METRIC_STANDARD 

Metric units.

+
PAPERSIZE_ENGLISH_EXTENDED 

English/Imperial units (optional paper, not displayed by default).

+
PAPERSIZE_METRIC_EXTENDED 

Metric units (optional paper, not displayed by default).

+
+ +
+
+

Function Documentation

+ +

◆ stp_default_media_size()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_default_media_size (const stp_vars_t * v,
int * width,
int * height 
)
+
+ +

Get the default paper dimensions for the current configuration.

+

The default is derived from the PageSize parameter if set, otherwise the default page size for the printer is used. If no value can be determined, 1x1 will be returned.

Parameters
+ + + + +
vthe Gutenprint vars object
widthpointer to storage that the width will be returned in.
heightpointer to storage that the height will be returned in.
+
+
+ +
+
+ +

◆ stp_get_papersize_by_index()

+ +
+
+ + + + + + + + +
const stp_papersize_t* stp_get_papersize_by_index (int idx)
+
+ +

Get a papersize by its index number.

+
Parameters
+ + +
idxthe index number. This must not be greater than (total number of papers - 1).
+
+
+
Returns
a static pointer to the papersize, or NULL on failure.
+ +
+
+ +

◆ stp_get_papersize_by_name()

+ +
+
+ + + + + + + + +
const stp_papersize_t* stp_get_papersize_by_name (const char * name)
+
+ +

Get a papersize by name.

+
Parameters
+ + +
namethe short unique name of the paper.
+
+
+
Returns
a static pointer to the papersize, or NULL on failure.
+ +
+
+ +

◆ stp_get_papersize_by_size()

+ +
+
+ + + + + + + + + + + + + + + + + + +
const stp_papersize_t* stp_get_papersize_by_size (int length,
int width 
)
+
+ +

Get a papersize by size.

+

The nearest available size to the size requested will be found. Only paper sizes within 5 points of width and height will be considered.

Parameters
+ + + +
lengththe length of the paper.
widththe width of the paper
+
+
+
Returns
a static pointer to the papersize, or NULL on failure.
+ +
+
+ +

◆ stp_get_papersize_by_size_exact()

+ +
+
+ + + + + + + + + + + + + + + + + + +
const stp_papersize_t* stp_get_papersize_by_size_exact (int length,
int width 
)
+
+ +

Get a papersize by size if an exact match is found.

+
Parameters
+ + + +
lengththe length of the paper.
widththe width of the paper
+
+
+
Returns
a static pointer to the papersize, or NULL on failure.
+ +
+
+ +

◆ stp_known_papersizes()

+ +
+
+ + + + + + + + +
int stp_known_papersizes (void )
+
+ +

Get the number of available papersizes.

+
Returns
the number of papersizes.
+ +
+
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/group__printer.html b/doc/gutenprint/html/group__printer.html new file mode 100644 index 0000000..407fd78 --- /dev/null +++ b/doc/gutenprint/html/group__printer.html @@ -0,0 +1,1030 @@ + + + + + + + +libgutenprint API Reference: printer + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+
+Data Structures | +Typedefs | +Functions
+
+
printer
+
+
+ +

The printer type represents a printer model. +More...

+ + + + + + +

+Data Structures

struct  stp_printfuncs_t
 
struct  stp_family
 
+ + + + + + +

+Typedefs

typedef struct stp_printer stp_printer_t
 The printer opaque data type (representation of printer model). More...
 
typedef struct stp_family stp_family_t
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

int stp_printer_model_count (void)
 Get the number of available printer models. More...
 
const stp_printer_t * stp_get_printer_by_index (int idx)
 Get a printer model by its index number. More...
 
const stp_printer_t * stp_get_printer_by_long_name (const char *long_name)
 Get a printer model by its long (translated) name. More...
 
const stp_printer_t * stp_get_printer_by_driver (const char *driver)
 Get a printer model by its short name. More...
 
const stp_printer_t * stp_get_printer_by_device_id (const char *device_id)
 Get a printer model by its IEEE 1284 device ID. More...
 
const stp_printer_t * stp_get_printer_by_foomatic_id (const char *foomatic_id)
 Get a printer model by its foomatic ID. More...
 
const stp_printer_t * stp_get_printer (const stp_vars_t *v)
 Get the printer model from a vars object. More...
 
int stp_get_printer_index_by_driver (const char *driver)
 Get the printer index number from the printer model short (driver) name. More...
 
const char * stp_printer_get_long_name (const stp_printer_t *p)
 Get a printer model's long (translated) name. More...
 
const char * stp_printer_get_driver (const stp_printer_t *p)
 Get a printer model's short (driver) name. More...
 
const char * stp_printer_get_device_id (const stp_printer_t *p)
 Get a printer model's IEEE 1284 device ID, if known. More...
 
const char * stp_printer_get_family (const stp_printer_t *p)
 Get a printer model's family name. More...
 
const char * stp_printer_get_manufacturer (const stp_printer_t *p)
 Get a printer model's manufacturer's name. More...
 
const char * stp_printer_get_foomatic_id (const stp_printer_t *p)
 Get a printer model's foomatic ID. More...
 
const char * stp_printer_get_comment (const stp_printer_t *p)
 Get a printer model's comment string. More...
 
int stp_printer_get_model (const stp_printer_t *p)
 Get a printer model's model number. More...
 
const stp_vars_t * stp_printer_get_defaults (const stp_printer_t *p)
 Get the default vars for a particular printer model. More...
 
void stp_set_printer_defaults (stp_vars_t *v, const stp_printer_t *p)
 Set a vars object to use a particular driver, and set the parameters to their defaults. More...
 
void stp_set_printer_defaults_soft (stp_vars_t *v, const stp_printer_t *p)
 Set a vars object to use a particular driver, and set any unset parameters to their defaults. More...
 
int stp_print (const stp_vars_t *v, stp_image_t *image)
 Print the image. More...
 
int stp_start_job (const stp_vars_t *v, stp_image_t *image)
 Start a print job. More...
 
int stp_end_job (const stp_vars_t *v, stp_image_t *image)
 End a print job. More...
 
stp_string_list_t * stp_get_external_options (const stp_vars_t *v)
 Retrieve options that need to be passed to the underlying print system. More...
 
int stp_get_model_id (const stp_vars_t *v)
 
int stp_verify_printer_params (stp_vars_t *v)
 
int stp_family_register (stp_list_t *family)
 
int stp_family_unregister (stp_list_t *family)
 
void stp_initialize_printer_defaults (void)
 
stp_parameter_list_t stp_printer_list_parameters (const stp_vars_t *v)
 
void stp_printer_describe_parameter (const stp_vars_t *v, const char *name, stp_parameter_t *description)
 
const char * stp_describe_output (const stp_vars_t *v)
 
+

Detailed Description

+

The printer type represents a printer model.

+

A particular printer model must selected in order to be able to print. Each printer model provides default print options through a default vars object.

+

Typedef Documentation

+ +

◆ stp_family_t

+ +
+
+ + + + +
typedef struct stp_family stp_family_t
+
+ +
+
+ +

◆ stp_printer_t

+ +
+
+ + + + +
typedef struct stp_printer stp_printer_t
+
+ +

The printer opaque data type (representation of printer model).

+ +
+
+

Function Documentation

+ +

◆ stp_describe_output()

+ +
+
+ + + + + + + + +
const char* stp_describe_output (const stp_vars_t * v)
+
+ +
+
+ +

◆ stp_end_job()

+ +
+
+ + + + + + + + + + + + + + + + + + +
int stp_end_job (const stp_vars_t * v,
stp_image_t * image 
)
+
+ +

End a print job.

+
Parameters
+ + + +
vthe vars to use.
imagethe image to print.
+
+
+
Returns
1 on success, 0 on failure.
+ +
+
+ +

◆ stp_family_register()

+ +
+
+ + + + + + + + +
int stp_family_register (stp_list_t * family)
+
+ +
+
+ +

◆ stp_family_unregister()

+ +
+
+ + + + + + + + +
int stp_family_unregister (stp_list_t * family)
+
+ +
+
+ +

◆ stp_get_external_options()

+ +
+
+ + + + + + + + +
stp_string_list_t* stp_get_external_options (const stp_vars_t * v)
+
+ +

Retrieve options that need to be passed to the underlying print system.

+
Parameters
+ + +
vthe vars to use.
+
+
+
Returns
list of options in a string list ('name' is the name of the option; 'text' is the value it takes on). NULL return means no external options are required. User must stp_string_list_destroy the list after use.
+ +
+
+ +

◆ stp_get_model_id()

+ +
+
+ + + + + + + + +
int stp_get_model_id (const stp_vars_t * v)
+
+ +
+
+ +

◆ stp_get_printer()

+ +
+
+ + + + + + + + +
const stp_printer_t* stp_get_printer (const stp_vars_t * v)
+
+ +

Get the printer model from a vars object.

+
Parameters
+ + +
vthe vars to use.
+
+
+
Returns
a pointer to the printer model, or NULL on failure. The pointer should not be freed.
+ +
+
+ +

◆ stp_get_printer_by_device_id()

+ +
+
+ + + + + + + + +
const stp_printer_t* stp_get_printer_by_device_id (const char * device_id)
+
+ +

Get a printer model by its IEEE 1284 device ID.

+
Parameters
+ + +
device_idthe printer model's device ID.
+
+
+
Returns
a pointer to the printer model, or NULL on failure. The pointer should not be freed.
+ +
+
+ +

◆ stp_get_printer_by_driver()

+ +
+
+ + + + + + + + +
const stp_printer_t* stp_get_printer_by_driver (const char * driver)
+
+ +

Get a printer model by its short name.

+
Parameters
+ + +
driverthe printer model's short (driver) name.
+
+
+
Returns
a pointer to the printer model, or NULL on failure. The pointer should not be freed.
+ +
+
+ +

◆ stp_get_printer_by_foomatic_id()

+ +
+
+ + + + + + + + +
const stp_printer_t* stp_get_printer_by_foomatic_id (const char * foomatic_id)
+
+ +

Get a printer model by its foomatic ID.

+
Parameters
+ + +
foomatic_idthe printer model's foomatic ID
+
+
+
Returns
a pointer to the printer model, or NULL on failure. The pointer should not be freed.
+ +
+
+ +

◆ stp_get_printer_by_index()

+ +
+
+ + + + + + + + +
const stp_printer_t* stp_get_printer_by_index (int idx)
+
+ +

Get a printer model by its index number.

+
Parameters
+ + +
idxthe index number. This must not be greater than (total number of printers - 1).
+
+
+
Returns
a pointer to the printer model, or NULL on failure. The pointer should not be freed.
+ +
+
+ +

◆ stp_get_printer_by_long_name()

+ +
+
+ + + + + + + + +
const stp_printer_t* stp_get_printer_by_long_name (const char * long_name)
+
+ +

Get a printer model by its long (translated) name.

+
Parameters
+ + +
long_namethe printer model's long (translated) name.
+
+
+
Returns
a pointer to the printer model, or NULL on failure. The pointer should not be freed.
+ +
+
+ +

◆ stp_get_printer_index_by_driver()

+ +
+
+ + + + + + + + +
int stp_get_printer_index_by_driver (const char * driver)
+
+ +

Get the printer index number from the printer model short (driver) name.

+
Deprecated:
There should never be any need to use this function.
+
Parameters
+ + +
driverthe printer model's short (driver) name.
+
+
+
Returns
the index number, or -1 on failure.
+ +
+
+ +

◆ stp_initialize_printer_defaults()

+ +
+
+ + + + + + + + +
void stp_initialize_printer_defaults (void )
+
+ +
+
+ +

◆ stp_print()

+ +
+
+ + + + + + + + + + + + + + + + + + +
int stp_print (const stp_vars_t * v,
stp_image_t * image 
)
+
+ +

Print the image.

+
Warning
stp_job_start() must be called prior to the first call to this function.
+
Parameters
+ + + +
vthe vars to use.
imagethe image to print.
+
+
+
Returns
0 on failure, 1 on success, 2 on abort requested by the driver.
+ +
+
+ +

◆ stp_printer_describe_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_printer_describe_parameter (const stp_vars_t * v,
const char * name,
stp_parameter_t * description 
)
+
+ +
+
+ +

◆ stp_printer_get_comment()

+ +
+
+ + + + + + + + +
const char* stp_printer_get_comment (const stp_printer_t * p)
+
+ +

Get a printer model's comment string.

+
Parameters
+ + +
pthe printer model to use.
+
+
+
Returns
the comments or NULL (should never be freed)
+ +
+
+ +

◆ stp_printer_get_defaults()

+ +
+
+ + + + + + + + +
const stp_vars_t* stp_printer_get_defaults (const stp_printer_t * p)
+
+ +

Get the default vars for a particular printer model.

+

The default vars should be copied to a new vars object and customised prior to printing.

Parameters
+ + +
pthe printer model to use.
+
+
+
Returns
the printer model's default vars.
+ +
+
+ +

◆ stp_printer_get_device_id()

+ +
+
+ + + + + + + + +
const char* stp_printer_get_device_id (const stp_printer_t * p)
+
+ +

Get a printer model's IEEE 1284 device ID, if known.

+
Parameters
+ + +
pthe printer model to use.
+
+
+
Returns
the IEEE 1284 device ID, or NULL if not known.
+ +
+
+ +

◆ stp_printer_get_driver()

+ +
+
+ + + + + + + + +
const char* stp_printer_get_driver (const stp_printer_t * p)
+
+ +

Get a printer model's short (driver) name.

+
Parameters
+ + +
pthe printer model to use.
+
+
+
Returns
the short name (should never be freed).
+ +
+
+ +

◆ stp_printer_get_family()

+ +
+
+ + + + + + + + +
const char* stp_printer_get_family (const stp_printer_t * p)
+
+ +

Get a printer model's family name.

+

The family name is the name of the modular "family" driver this model uses.

Parameters
+ + +
pthe printer model to use.
+
+
+
Returns
the family name (should never be freed).
+ +
+
+ +

◆ stp_printer_get_foomatic_id()

+ +
+
+ + + + + + + + +
const char* stp_printer_get_foomatic_id (const stp_printer_t * p)
+
+ +

Get a printer model's foomatic ID.

+
Parameters
+ + +
pthe printer model to use.
+
+
+
Returns
the foomatic ID or NULL (should never be freed)
+ +
+
+ +

◆ stp_printer_get_long_name()

+ +
+
+ + + + + + + + +
const char* stp_printer_get_long_name (const stp_printer_t * p)
+
+ +

Get a printer model's long (translated) name.

+
Parameters
+ + +
pthe printer model to use.
+
+
+
Returns
the long name (should never be freed).
+ +
+
+ +

◆ stp_printer_get_manufacturer()

+ +
+
+ + + + + + + + +
const char* stp_printer_get_manufacturer (const stp_printer_t * p)
+
+ +

Get a printer model's manufacturer's name.

+
Parameters
+ + +
pthe printer model to use.
+
+
+
Returns
the manufacturer's name (should never be freed).
+ +
+
+ +

◆ stp_printer_get_model()

+ +
+
+ + + + + + + + +
int stp_printer_get_model (const stp_printer_t * p)
+
+ +

Get a printer model's model number.

+

The model number is used internally by the "family" driver module, and has no meaning out of that context. It bears no relation to the model name/number actually found on the printer itself.

Parameters
+ + +
pthe printer model to use.
+
+
+
Returns
the model number.
+ +
+
+ +

◆ stp_printer_list_parameters()

+ +
+
+ + + + + + + + +
stp_parameter_list_t stp_printer_list_parameters (const stp_vars_t * v)
+
+ +
+
+ +

◆ stp_printer_model_count()

+ +
+
+ + + + + + + + +
int stp_printer_model_count (void )
+
+ +

Get the number of available printer models.

+
Returns
the number of printer models.
+ +
+
+ +

◆ stp_set_printer_defaults()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_set_printer_defaults (stp_vars_t * v,
const stp_printer_t * p 
)
+
+ +

Set a vars object to use a particular driver, and set the parameters to their defaults.

+
Parameters
+ + + +
vthe vars to use.
pthe printer model to use.
+
+
+ +
+
+ +

◆ stp_set_printer_defaults_soft()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_set_printer_defaults_soft (stp_vars_t * v,
const stp_printer_t * p 
)
+
+ +

Set a vars object to use a particular driver, and set any unset parameters to their defaults.

+
Parameters
+ + + +
vthe vars to use.
pthe printer model to use.
+
+
+ +
+
+ +

◆ stp_start_job()

+ +
+
+ + + + + + + + + + + + + + + + + + +
int stp_start_job (const stp_vars_t * v,
stp_image_t * image 
)
+
+ +

Start a print job.

+
Warning
This function must be called prior to the first call to stp_print().
+
Parameters
+ + + +
vthe vars to use.
imagethe image to print.
+
+
+
Returns
1 on success, 0 on failure.
+ +
+
+ +

◆ stp_verify_printer_params()

+ +
+
+ + + + + + + + +
int stp_verify_printer_params (stp_vars_t * v)
+
+ +
+
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/group__sequence.html b/doc/gutenprint/html/group__sequence.html new file mode 100644 index 0000000..5481080 --- /dev/null +++ b/doc/gutenprint/html/group__sequence.html @@ -0,0 +1,1358 @@ + + + + + + + +libgutenprint API Reference: sequence + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+
+Typedefs | +Functions
+
+
sequence
+
+
+ +

The sequence is a simple "vector of numbers" data structure. +More...

+ + + + + +

+Typedefs

typedef struct stp_sequence stp_sequence_t
 The sequence opaque data type. More...
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

stp_sequence_t * stp_sequence_create (void)
 Create a new sequence. More...
 
void stp_sequence_destroy (stp_sequence_t *sequence)
 Destroy a sequence. More...
 
void stp_sequence_copy (stp_sequence_t *dest, const stp_sequence_t *source)
 Copy a sequence. More...
 
stp_sequence_t * stp_sequence_create_copy (const stp_sequence_t *sequence)
 Copy and allocate a sequence. More...
 
void stp_sequence_reverse (stp_sequence_t *dest, const stp_sequence_t *source)
 Reverse a sequence. More...
 
stp_sequence_t * stp_sequence_create_reverse (const stp_sequence_t *sequence)
 Reverse and allocate a sequence. More...
 
int stp_sequence_set_bounds (stp_sequence_t *sequence, double low, double high)
 Set the lower and upper bounds. More...
 
void stp_sequence_get_bounds (const stp_sequence_t *sequence, double *low, double *high)
 Get the lower and upper bounds. More...
 
void stp_sequence_get_range (const stp_sequence_t *sequence, double *low, double *high)
 Get range of values stored in the sequence. More...
 
int stp_sequence_set_size (stp_sequence_t *sequence, size_t size)
 Set the sequence size. More...
 
size_t stp_sequence_get_size (const stp_sequence_t *sequence)
 Get the sequence size. More...
 
int stp_sequence_set_data (stp_sequence_t *sequence, size_t count, const double *data)
 Set the data in a sequence. More...
 
int stp_sequence_set_subrange (stp_sequence_t *sequence, size_t where, size_t size, const double *data)
 Set the data in a subrange of a sequence. More...
 
void stp_sequence_get_data (const stp_sequence_t *sequence, size_t *size, const double **data)
 Get the data in a sequence. More...
 
int stp_sequence_set_point (stp_sequence_t *sequence, size_t where, double data)
 Set the data at a single point in a sequence. More...
 
int stp_sequence_get_point (const stp_sequence_t *sequence, size_t where, double *data)
 Get the data at a single point in a sequence. More...
 
int stp_sequence_set_float_data (stp_sequence_t *sequence, size_t count, const float *data)
 Set the data in a sequence from float values. More...
 
int stp_sequence_set_long_data (stp_sequence_t *sequence, size_t count, const long *data)
 Set the data in a sequence from long values. More...
 
int stp_sequence_set_ulong_data (stp_sequence_t *sequence, size_t count, const unsigned long *data)
 Set the data in a sequence from unsigned long values. More...
 
int stp_sequence_set_int_data (stp_sequence_t *sequence, size_t count, const int *data)
 Set the data in a sequence from int values. More...
 
int stp_sequence_set_uint_data (stp_sequence_t *sequence, size_t count, const unsigned int *data)
 Set the data in a sequence from unsigned int values. More...
 
int stp_sequence_set_short_data (stp_sequence_t *sequence, size_t count, const short *data)
 Set the data in a sequence from short values. More...
 
int stp_sequence_set_ushort_data (stp_sequence_t *sequence, size_t count, const unsigned short *data)
 Set the data in a sequence from unsigned short values. More...
 
const float * stp_sequence_get_float_data (const stp_sequence_t *sequence, size_t *count)
 Get the data in a sequence as float data. More...
 
const long * stp_sequence_get_long_data (const stp_sequence_t *sequence, size_t *count)
 Get the data in a sequence as long data. More...
 
const unsigned long * stp_sequence_get_ulong_data (const stp_sequence_t *sequence, size_t *count)
 Get the data in a sequence as unsigned long data. More...
 
const int * stp_sequence_get_int_data (const stp_sequence_t *sequence, size_t *count)
 Get the data in a sequence as int data. More...
 
const unsigned int * stp_sequence_get_uint_data (const stp_sequence_t *sequence, size_t *count)
 Get the data in a sequence as unsigned int data. More...
 
const short * stp_sequence_get_short_data (const stp_sequence_t *sequence, size_t *count)
 Get the data in a sequence as short data. More...
 
const unsigned short * stp_sequence_get_ushort_data (const stp_sequence_t *sequence, size_t *count)
 Get the data in a sequence as unsigned short data. More...
 
+

Detailed Description

+

The sequence is a simple "vector of numbers" data structure.

+

Typedef Documentation

+ +

◆ stp_sequence_t

+ +
+
+ + + + +
typedef struct stp_sequence stp_sequence_t
+
+ +

The sequence opaque data type.

+ +
+
+

Function Documentation

+ +

◆ stp_sequence_copy()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_sequence_copy (stp_sequence_t * dest,
const stp_sequence_t * source 
)
+
+ +

Copy a sequence.

+

Both dest and source must be valid sequences previously created with stp_sequence_create().

Parameters
+ + + +
destthe destination sequence.
sourcethe source sequence.
+
+
+ +
+
+ +

◆ stp_sequence_create()

+ +
+
+ + + + + + + + +
stp_sequence_t* stp_sequence_create (void )
+
+ +

Create a new sequence.

+
Returns
the newly created sequence.
+ +
+
+ +

◆ stp_sequence_create_copy()

+ +
+
+ + + + + + + + +
stp_sequence_t* stp_sequence_create_copy (const stp_sequence_t * sequence)
+
+ +

Copy and allocate a sequence.

+

A new sequence will be created, and then the contents of source will be copied into it. The destination must not have been previously allocated with stp_sequence_create().

Parameters
+ + +
sequencethe source sequence.
+
+
+
Returns
the new copy of the sequence.
+ +
+
+ +

◆ stp_sequence_create_reverse()

+ +
+
+ + + + + + + + +
stp_sequence_t* stp_sequence_create_reverse (const stp_sequence_t * sequence)
+
+ +

Reverse and allocate a sequence.

+

A new sequence will be created, and then the contents of source will be copied into it. The destination must not have been previously allocated with stp_sequence_create().

Parameters
+ + +
sequencethe source sequence.
+
+
+
Returns
the new copy of the sequence.
+ +
+
+ +

◆ stp_sequence_destroy()

+ +
+
+ + + + + + + + +
void stp_sequence_destroy (stp_sequence_t * sequence)
+
+ +

Destroy a sequence.

+

It is an error to destroy the sequence more than once.

Parameters
+ + +
sequencethe sequence to destroy.
+
+
+ +
+
+ +

◆ stp_sequence_get_bounds()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_sequence_get_bounds (const stp_sequence_t * sequence,
double * low,
double * high 
)
+
+ +

Get the lower and upper bounds.

+

The values are stored in the variables pointed to by low and high.

Parameters
+ + + + +
sequencethe sequence to work on.
lowa pointer to a double to store the low bound in.
higha pointer to a double to store the high bound in.
+
+
+ +
+
+ +

◆ stp_sequence_get_data()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_sequence_get_data (const stp_sequence_t * sequence,
size_t * size,
const double ** data 
)
+
+ +

Get the data in a sequence.

+
Parameters
+ + + + +
sequencethe sequence to get the data from.
sizethe number of elements in the sequence are stored in the size_t pointed to.
dataa pointer to the first element of an sequence of doubles is stored in a pointer to double*.
stp_sequence_t *sequence;
size_t size;
double *data;
stp_sequence_get_data(sequence, &size, &data);
+
+
+ +
+
+ +

◆ stp_sequence_get_float_data()

+ +
+
+ + + + + + + + + + + + + + + + + + +
const float* stp_sequence_get_float_data (const stp_sequence_t * sequence,
size_t * count 
)
+
+ +

Get the data in a sequence as float data.

+

The pointer returned is owned by the curve, and is not guaranteed to be valid beyond the next non-const curve call; If the bounds of the curve exceed the limits of the data type, NULL is returned.

Parameters
+ + + +
sequencethe sequence to get the data from.
countthe number of elements in the sequence are stored in the size_t pointed to.
+
+
+
Returns
a pointer to the first element of an sequence of floats is stored in a pointer to float*.
+ +
+
+ +

◆ stp_sequence_get_int_data()

+ +
+
+ + + + + + + + + + + + + + + + + + +
const int* stp_sequence_get_int_data (const stp_sequence_t * sequence,
size_t * count 
)
+
+ +

Get the data in a sequence as int data.

+

The pointer returned is owned by the curve, and is not guaranteed to be valid beyond the next non-const curve call; If the bounds of the curve exceed the limits of the data type, NULL is returned.

Parameters
+ + + +
sequencethe sequence to get the data from.
countthe number of elements in the sequence are stored in the size_t pointed to.
+
+
+
Returns
a pointer to the first element of an sequence of ints is stored in a pointer to int*.
+ +
+
+ +

◆ stp_sequence_get_long_data()

+ +
+
+ + + + + + + + + + + + + + + + + + +
const long* stp_sequence_get_long_data (const stp_sequence_t * sequence,
size_t * count 
)
+
+ +

Get the data in a sequence as long data.

+

The pointer returned is owned by the curve, and is not guaranteed to be valid beyond the next non-const curve call; If the bounds of the curve exceed the limits of the data type, NULL is returned.

Parameters
+ + + +
sequencethe sequence to get the data from.
countthe number of elements in the sequence are stored in the size_t pointed to.
+
+
+
Returns
a pointer to the first element of an sequence of longs is stored in a pointer to long*.
+ +
+
+ +

◆ stp_sequence_get_point()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_sequence_get_point (const stp_sequence_t * sequence,
size_t where,
double * data 
)
+
+ +

Get the data at a single point in a sequence.

+
Parameters
+ + + + +
sequencethe sequence to use.
wherethe location (indexed from zero).
datathe datum is stored in the double pointed to.
+
+
+
Returns
1 on success, 0 on failure.
+ +
+
+ +

◆ stp_sequence_get_range()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_sequence_get_range (const stp_sequence_t * sequence,
double * low,
double * high 
)
+
+ +

Get range of values stored in the sequence.

+

The values are stored in the variables pointed to by low and high.

Parameters
+ + + + +
sequencethe sequence to work on.
lowa pointer to a double to store the low bound in.
higha pointer to a double to store the high bound in.
+
+
+ +
+
+ +

◆ stp_sequence_get_short_data()

+ +
+
+ + + + + + + + + + + + + + + + + + +
const short* stp_sequence_get_short_data (const stp_sequence_t * sequence,
size_t * count 
)
+
+ +

Get the data in a sequence as short data.

+

The pointer returned is owned by the curve, and is not guaranteed to be valid beyond the next non-const curve call; If the bounds of the curve exceed the limits of the data type, NULL is returned.

Parameters
+ + + +
sequencethe sequence to get the data from.
countthe number of elements in the sequence are stored in the size_t pointed to.
+
+
+
Returns
a pointer to the first element of an sequence of shorts is stored in a pointer to short*.
+ +
+
+ +

◆ stp_sequence_get_size()

+ +
+
+ + + + + + + + +
size_t stp_sequence_get_size (const stp_sequence_t * sequence)
+
+ +

Get the sequence size.

+
Returns
the sequence size.
+ +
+
+ +

◆ stp_sequence_get_uint_data()

+ +
+
+ + + + + + + + + + + + + + + + + + +
const unsigned int* stp_sequence_get_uint_data (const stp_sequence_t * sequence,
size_t * count 
)
+
+ +

Get the data in a sequence as unsigned int data.

+

The pointer returned is owned by the curve, and is not guaranteed to be valid beyond the next non-const curve call; If the bounds of the curve exceed the limits of the data type, NULL is returned.

Parameters
+ + + +
sequencethe sequence to get the data from.
countthe number of elements in the sequence are stored in the size_t pointed to.
+
+
+
Returns
a pointer to the first element of an sequence of unsigned ints is stored in a pointer to unsigned int*.
+ +
+
+ +

◆ stp_sequence_get_ulong_data()

+ +
+
+ + + + + + + + + + + + + + + + + + +
const unsigned long* stp_sequence_get_ulong_data (const stp_sequence_t * sequence,
size_t * count 
)
+
+ +

Get the data in a sequence as unsigned long data.

+

The pointer returned is owned by the curve, and is not guaranteed to be valid beyond the next non-const curve call; If the bounds of the curve exceed the limits of the data type, NULL is returned.

Parameters
+ + + +
sequencethe sequence to get the data from.
countthe number of elements in the sequence are stored in the size_t pointed to.
+
+
+
Returns
a pointer to the first element of an sequence of unsigned longs is stored in a pointer to unsigned long*.
+ +
+
+ +

◆ stp_sequence_get_ushort_data()

+ +
+
+ + + + + + + + + + + + + + + + + + +
const unsigned short* stp_sequence_get_ushort_data (const stp_sequence_t * sequence,
size_t * count 
)
+
+ +

Get the data in a sequence as unsigned short data.

+

The pointer returned is owned by the curve, and is not guaranteed to be valid beyond the next non-const curve call; If the bounds of the curve exceed the limits of the data type, NULL is returned.

Parameters
+ + + +
sequencethe sequence to get the data from.
countthe number of elements in the sequence are stored in the size_t pointed to.
+
+
+
Returns
a pointer to the first element of an sequence of unsigned shorts is stored in a pointer to unsigned short*.
+ +
+
+ +

◆ stp_sequence_reverse()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_sequence_reverse (stp_sequence_t * dest,
const stp_sequence_t * source 
)
+
+ +

Reverse a sequence.

+

Both dest and source must be valid sequences previously created with stp_sequence_create().

Parameters
+ + + +
destthe destination sequence.
sourcethe source sequence.
+
+
+ +
+
+ +

◆ stp_sequence_set_bounds()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_sequence_set_bounds (stp_sequence_t * sequence,
double low,
double high 
)
+
+ +

Set the lower and upper bounds.

+

The lower and upper bounds set the minimum and maximum values that a point in the sequence may hold.

Parameters
+ + + + +
sequencethe sequence to work on.
lowthe lower bound.
highthe upper bound.
+
+
+
Returns
1 on success, or 0 if the lower bound is greater than the upper bound.
+ +
+
+ +

◆ stp_sequence_set_data()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_sequence_set_data (stp_sequence_t * sequence,
size_t count,
const double * data 
)
+
+ +

Set the data in a sequence.

+
Parameters
+ + + + +
sequencethe sequence to set.
countthe number of elements in the data.
dataa pointer to the first member of a sequence containing the data to set.
+
+
+
Returns
1 on success, 0 on failure.
+ +
+
+ +

◆ stp_sequence_set_float_data()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_sequence_set_float_data (stp_sequence_t * sequence,
size_t count,
const float * data 
)
+
+ +

Set the data in a sequence from float values.

+
Parameters
+ + + + +
sequencethe sequence to set.
countthe number of elements in the data.
dataa pointer to the first member of a sequence containing the data to set.
+
+
+
Returns
1 on success, 0 on failure.
+ +
+
+ +

◆ stp_sequence_set_int_data()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_sequence_set_int_data (stp_sequence_t * sequence,
size_t count,
const int * data 
)
+
+ +

Set the data in a sequence from int values.

+
Parameters
+ + + + +
sequencethe sequence to set.
countthe number of elements in the data.
dataa pointer to the first member of a sequence containing the data to set.
+
+
+
Returns
1 on success, 0 on failure.
+ +
+
+ +

◆ stp_sequence_set_long_data()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_sequence_set_long_data (stp_sequence_t * sequence,
size_t count,
const long * data 
)
+
+ +

Set the data in a sequence from long values.

+
Parameters
+ + + + +
sequencethe sequence to set.
countthe number of elements in the data.
dataa pointer to the first member of a sequence containing the data to set.
+
+
+
Returns
1 on success, 0 on failure.
+ +
+
+ +

◆ stp_sequence_set_point()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_sequence_set_point (stp_sequence_t * sequence,
size_t where,
double data 
)
+
+ +

Set the data at a single point in a sequence.

+
Parameters
+ + + + +
sequencethe sequence to use.
wherethe location (indexed from zero).
datathe datum to set.
+
+
+
Returns
1 on success, 0 on failure.
+ +
+
+ +

◆ stp_sequence_set_short_data()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_sequence_set_short_data (stp_sequence_t * sequence,
size_t count,
const short * data 
)
+
+ +

Set the data in a sequence from short values.

+
Parameters
+ + + + +
sequencethe sequence to set.
countthe number of elements in the data.
dataa pointer to the first member of a sequence containing the data to set.
+
+
+
Returns
1 on success, 0 on failure.
+ +
+
+ +

◆ stp_sequence_set_size()

+ +
+
+ + + + + + + + + + + + + + + + + + +
int stp_sequence_set_size (stp_sequence_t * sequence,
size_t size 
)
+
+ +

Set the sequence size.

+

The size is the number of elements the sequence contains. Note that resizing will destroy all data contained in the sequence.

Parameters
+ + + +
sequencethe sequence to work on.
sizethe size to set the sequence to.
+
+
+
Returns
1 on success, 0 on failure.
+ +
+
+ +

◆ stp_sequence_set_subrange()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
int stp_sequence_set_subrange (stp_sequence_t * sequence,
size_t where,
size_t size,
const double * data 
)
+
+ +

Set the data in a subrange of a sequence.

+
Parameters
+ + + + + +
sequencethe sequence to set.
wherethe starting element in the sequence (indexed from 0).
sizethe number of elements in the data.
dataa pointer to the first member of a sequence containing the data to set.
+
+
+
Returns
1 on success, 0 on failure.
+ +
+
+ +

◆ stp_sequence_set_uint_data()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_sequence_set_uint_data (stp_sequence_t * sequence,
size_t count,
const unsigned int * data 
)
+
+ +

Set the data in a sequence from unsigned int values.

+
Parameters
+ + + + +
sequencethe sequence to set.
countthe number of elements in the data.
dataa pointer to the first member of a sequence containing the data to set.
+
+
+
Returns
1 on success, 0 on failure.
+ +
+
+ +

◆ stp_sequence_set_ulong_data()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_sequence_set_ulong_data (stp_sequence_t * sequence,
size_t count,
const unsigned long * data 
)
+
+ +

Set the data in a sequence from unsigned long values.

+
Parameters
+ + + + +
sequencethe sequence to set.
countthe number of elements in the data.
dataa pointer to the first member of a sequence containing the data to set.
+
+
+
Returns
1 on success, 0 on failure.
+ +
+
+ +

◆ stp_sequence_set_ushort_data()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_sequence_set_ushort_data (stp_sequence_t * sequence,
size_t count,
const unsigned short * data 
)
+
+ +

Set the data in a sequence from unsigned short values.

+
Parameters
+ + + + +
sequencethe sequence to set.
countthe number of elements in the data.
dataa pointer to the first member of a sequence containing the data to set.
+
+
+
Returns
1 on success, 0 on failure.
+ +
+
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/group__util.html b/doc/gutenprint/html/group__util.html new file mode 100644 index 0000000..1363fb7 --- /dev/null +++ b/doc/gutenprint/html/group__util.html @@ -0,0 +1,1490 @@ + + + + + + + +libgutenprint API Reference: util + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+
+Macros | +Functions
+
+
util
+
+
+ +

Utility functions. +More...

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Macros

#define STP_DBG_LUT   0x1
 
#define STP_DBG_COLORFUNC   0x2
 
#define STP_DBG_INK   0x4
 
#define STP_DBG_PS   0x8
 
#define STP_DBG_PCL   0x10
 
#define STP_DBG_ESCP2   0x20
 
#define STP_DBG_CANON   0x40
 
#define STP_DBG_LEXMARK   0x80
 
#define STP_DBG_WEAVE_PARAMS   0x100
 
#define STP_DBG_ROWS   0x200
 
#define STP_DBG_MARK_FILE   0x400
 
#define STP_DBG_LIST   0x800
 
#define STP_DBG_MODULE   0x1000
 
#define STP_DBG_PATH   0x2000
 
#define STP_DBG_PAPER   0x4000
 
#define STP_DBG_PRINTERS   0x8000
 
#define STP_DBG_XML   0x10000
 
#define STP_DBG_VARS   0x20000
 
#define STP_DBG_DYESUB   0x40000
 
#define STP_DBG_CURVE   0x80000
 
#define STP_DBG_CURVE_ERRORS   0x100000
 
#define STP_DBG_PPD   0x200000
 
#define STP_DBG_NO_COMPRESSION   0x400000
 
#define STP_DBG_ASSERTIONS   0x800000
 
#define STP_DBG_DPL   0x1000000
 
#define STP_SAFE_FREE(x)
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

int stp_init (void)
 Initialise libgimpprint. More...
 
const char * stp_set_output_codeset (const char *codeset)
 Set the output encoding. More...
 
stp_curve_t * stp_read_and_compose_curves (const char *s1, const char *s2, stp_curve_compose_t comp, size_t piecewise_point_count)
 
void stp_abort (void)
 
void stp_prune_inactive_options (stp_vars_t *v)
 
void stp_zprintf (const stp_vars_t *v, const char *format,...) __attribute__((format(__printf__
 
void void stp_zfwrite (const char *buf, size_t bytes, size_t nitems, const stp_vars_t *v)
 
void stp_write_raw (const stp_raw_t *raw, const stp_vars_t *v)
 
void stp_putc (int ch, const stp_vars_t *v)
 
void stp_put16_le (unsigned short sh, const stp_vars_t *v)
 
void stp_put16_be (unsigned short sh, const stp_vars_t *v)
 
void stp_put32_le (unsigned int sh, const stp_vars_t *v)
 
void stp_put32_be (unsigned int sh, const stp_vars_t *v)
 
void stp_puts (const char *s, const stp_vars_t *v)
 
void stp_putraw (const stp_raw_t *r, const stp_vars_t *v)
 
void stp_send_command (const stp_vars_t *v, const char *command, const char *format,...)
 
void stp_erputc (int ch)
 
void stp_eprintf (const stp_vars_t *v, const char *format,...) __attribute__((format(__printf__
 
void void stp_erprintf (const char *format,...) __attribute__((format(__printf__
 
void void void stp_asprintf (char **strp, const char *format,...) __attribute__((format(__printf__
 
void void void void stp_catprintf (char **strp, const char *format,...) __attribute__((format(__printf__
 
unsigned long stp_get_debug_level (void)
 
void stp_dprintf (unsigned long level, const stp_vars_t *v, const char *format,...) __attribute__((format(__printf__
 
void void stp_deprintf (unsigned long level, const char *format,...) __attribute__((format(__printf__
 
void void void stp_init_debug_messages (stp_vars_t *v)
 
void stp_flush_debug_messages (stp_vars_t *v)
 
void * stp_malloc (size_t)
 
void * stp_zalloc (size_t)
 
void * stp_realloc (void *ptr, size_t)
 
void stp_free (void *ptr)
 
size_t stp_strlen (const char *s)
 
char * stp_strndup (const char *s, int n)
 
char * stp_strdup (const char *s)
 
const char * stp_get_version (void)
 Get the library version string (x.y.z) More...
 
const char * stp_get_release_version (void)
 Get the library release version string (x.y) More...
 
+

Detailed Description

+

Utility functions.

+

Macro Definition Documentation

+ +

◆ STP_DBG_ASSERTIONS

+ +
+
+ + + + +
#define STP_DBG_ASSERTIONS   0x800000
+
+ +
+
+ +

◆ STP_DBG_CANON

+ +
+
+ + + + +
#define STP_DBG_CANON   0x40
+
+ +
+
+ +

◆ STP_DBG_COLORFUNC

+ +
+
+ + + + +
#define STP_DBG_COLORFUNC   0x2
+
+ +
+
+ +

◆ STP_DBG_CURVE

+ +
+
+ + + + +
#define STP_DBG_CURVE   0x80000
+
+ +
+
+ +

◆ STP_DBG_CURVE_ERRORS

+ +
+
+ + + + +
#define STP_DBG_CURVE_ERRORS   0x100000
+
+ +
+
+ +

◆ STP_DBG_DPL

+ +
+
+ + + + +
#define STP_DBG_DPL   0x1000000
+
+ +
+
+ +

◆ STP_DBG_DYESUB

+ +
+
+ + + + +
#define STP_DBG_DYESUB   0x40000
+
+ +
+
+ +

◆ STP_DBG_ESCP2

+ +
+
+ + + + +
#define STP_DBG_ESCP2   0x20
+
+ +
+
+ +

◆ STP_DBG_INK

+ +
+
+ + + + +
#define STP_DBG_INK   0x4
+
+ +
+
+ +

◆ STP_DBG_LEXMARK

+ +
+
+ + + + +
#define STP_DBG_LEXMARK   0x80
+
+ +
+
+ +

◆ STP_DBG_LIST

+ +
+
+ + + + +
#define STP_DBG_LIST   0x800
+
+ +
+
+ +

◆ STP_DBG_LUT

+ +
+
+ + + + +
#define STP_DBG_LUT   0x1
+
+ +
+
+ +

◆ STP_DBG_MARK_FILE

+ +
+
+ + + + +
#define STP_DBG_MARK_FILE   0x400
+
+ +
+
+ +

◆ STP_DBG_MODULE

+ +
+
+ + + + +
#define STP_DBG_MODULE   0x1000
+
+ +
+
+ +

◆ STP_DBG_NO_COMPRESSION

+ +
+
+ + + + +
#define STP_DBG_NO_COMPRESSION   0x400000
+
+ +
+
+ +

◆ STP_DBG_PAPER

+ +
+
+ + + + +
#define STP_DBG_PAPER   0x4000
+
+ +
+
+ +

◆ STP_DBG_PATH

+ +
+
+ + + + +
#define STP_DBG_PATH   0x2000
+
+ +
+
+ +

◆ STP_DBG_PCL

+ +
+
+ + + + +
#define STP_DBG_PCL   0x10
+
+ +
+
+ +

◆ STP_DBG_PPD

+ +
+
+ + + + +
#define STP_DBG_PPD   0x200000
+
+ +
+
+ +

◆ STP_DBG_PRINTERS

+ +
+
+ + + + +
#define STP_DBG_PRINTERS   0x8000
+
+ +
+
+ +

◆ STP_DBG_PS

+ +
+
+ + + + +
#define STP_DBG_PS   0x8
+
+ +
+
+ +

◆ STP_DBG_ROWS

+ +
+
+ + + + +
#define STP_DBG_ROWS   0x200
+
+ +
+
+ +

◆ STP_DBG_VARS

+ +
+
+ + + + +
#define STP_DBG_VARS   0x20000
+
+ +
+
+ +

◆ STP_DBG_WEAVE_PARAMS

+ +
+
+ + + + +
#define STP_DBG_WEAVE_PARAMS   0x100
+
+ +
+
+ +

◆ STP_DBG_XML

+ +
+
+ + + + +
#define STP_DBG_XML   0x10000
+
+ +
+
+ +

◆ STP_SAFE_FREE

+ +
+
+ + + + + + + + +
#define STP_SAFE_FREE( x)
+
+Value:
do \
{ \
if ((x)) \
stp_free((char *)(x)); \
((x)) = NULL; \
} while (0)
+
+
+

Function Documentation

+ +

◆ stp_abort()

+ +
+
+ + + + + + + + +
void stp_abort (void )
+
+ +
+
+ +

◆ stp_asprintf()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void void void stp_asprintf (char ** strp,
const char * format,
 ... 
)
+
+ +
+
+ +

◆ stp_catprintf()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void void void void stp_catprintf (char ** strp,
const char * format,
 ... 
)
+
+ +
+
+ +

◆ stp_deprintf()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void void stp_deprintf (unsigned long level,
const char * format,
 ... 
)
+
+ +
+
+ +

◆ stp_dprintf()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_dprintf (unsigned long level,
const stp_vars_t * v,
const char * format,
 ... 
)
+
+ +
+
+ +

◆ stp_eprintf()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_eprintf (const stp_vars_t * v,
const char * format,
 ... 
)
+
+ +
+
+ +

◆ stp_erprintf()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void void stp_erprintf (const char * format,
 ... 
)
+
+ +
+
+ +

◆ stp_erputc()

+ +
+
+ + + + + + + + +
void stp_erputc (int ch)
+
+ +
+
+ +

◆ stp_flush_debug_messages()

+ +
+
+ + + + + + + + +
void stp_flush_debug_messages (stp_vars_t * v)
+
+ +
+
+ +

◆ stp_free()

+ +
+
+ + + + + + + + +
void stp_free (void * ptr)
+
+ +
+
+ +

◆ stp_get_debug_level()

+ +
+
+ + + + + + + + +
unsigned long stp_get_debug_level (void )
+
+ +
+
+ +

◆ stp_get_release_version()

+ +
+
+ + + + + + + + +
const char* stp_get_release_version (void )
+
+ +

Get the library release version string (x.y)

+
Returns
a pointer to the release name of the package, which must not be modified or freed.
+ +
+
+ +

◆ stp_get_version()

+ +
+
+ + + + + + + + +
const char* stp_get_version (void )
+
+ +

Get the library version string (x.y.z)

+
Returns
a pointer to the version name of the package, which must not be modified or freed.
+ +
+
+ +

◆ stp_init()

+ +
+
+ + + + + + + + +
int stp_init (void )
+
+ +

Initialise libgimpprint.

+

This function must be called prior to any other use of the library. It is responsible for loading modules and XML data and initialising internal data structures.

Returns
0 on success, 1 on failure.
+ +
+
+ +

◆ stp_init_debug_messages()

+ +
+
+ + + + + + + + +
void void void stp_init_debug_messages (stp_vars_t * v)
+
+ +
+
+ +

◆ stp_malloc()

+ +
+
+ + + + + + + + +
void* stp_malloc (size_t )
+
+ +
+
+ +

◆ stp_prune_inactive_options()

+ +
+
+ + + + + + + + +
void stp_prune_inactive_options (stp_vars_t * v)
+
+ +
+
+ +

◆ stp_put16_be()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_put16_be (unsigned short sh,
const stp_vars_t * v 
)
+
+ +
+
+ +

◆ stp_put16_le()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_put16_le (unsigned short sh,
const stp_vars_t * v 
)
+
+ +
+
+ +

◆ stp_put32_be()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_put32_be (unsigned int sh,
const stp_vars_t * v 
)
+
+ +
+
+ +

◆ stp_put32_le()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_put32_le (unsigned int sh,
const stp_vars_t * v 
)
+
+ +
+
+ +

◆ stp_putc()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_putc (int ch,
const stp_vars_t * v 
)
+
+ +
+
+ +

◆ stp_putraw()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_putraw (const stp_raw_t * r,
const stp_vars_t * v 
)
+
+ +
+
+ +

◆ stp_puts()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_puts (const char * s,
const stp_vars_t * v 
)
+
+ +
+
+ +

◆ stp_read_and_compose_curves()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
stp_curve_t* stp_read_and_compose_curves (const char * s1,
const char * s2,
stp_curve_compose_t comp,
size_t piecewise_point_count 
)
+
+ +
+
+ +

◆ stp_realloc()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void* stp_realloc (void * ptr,
size_t  
)
+
+ +
+
+ +

◆ stp_send_command()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_send_command (const stp_vars_t * v,
const char * command,
const char * format,
 ... 
)
+
+ +
+
+ +

◆ stp_set_output_codeset()

+ +
+
+ + + + + + + + +
const char* stp_set_output_codeset (const char * codeset)
+
+ +

Set the output encoding.

+

This function sets the encoding that all strings translated by gettext are output in. It is a wrapper around the gettext bind_textdomain_codeset() function.

Parameters
+ + +
codesetthe standard name of the encoding, which must be usable with iconv_open(). For example, "US-ASCII" or "UTF-8". If NULL, the currently-selected codeset will be returned (or NULL if no codeset has been selected yet).
+
+
+
Returns
a string containing the selected codeset, or NULL on failure (errno is set accordingly).
+ +
+
+ +

◆ stp_strdup()

+ +
+
+ + + + + + + + +
char* stp_strdup (const char * s)
+
+ +
+
+ +

◆ stp_strlen()

+ +
+
+ + + + + + + + +
size_t stp_strlen (const char * s)
+
+ +
+
+ +

◆ stp_strndup()

+ +
+
+ + + + + + + + + + + + + + + + + + +
char* stp_strndup (const char * s,
int n 
)
+
+ +
+
+ +

◆ stp_write_raw()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_write_raw (const stp_raw_t * raw,
const stp_vars_t * v 
)
+
+ +
+
+ +

◆ stp_zalloc()

+ +
+
+ + + + + + + + +
void* stp_zalloc (size_t )
+
+ +
+
+ +

◆ stp_zfwrite()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void void stp_zfwrite (const char * buf,
size_t bytes,
size_t nitems,
const stp_vars_t * v 
)
+
+ +
+
+ +

◆ stp_zprintf()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_zprintf (const stp_vars_t * v,
const char * format,
 ... 
)
+
+ +
+
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/group__vars.html b/doc/gutenprint/html/group__vars.html new file mode 100644 index 0000000..da13abb --- /dev/null +++ b/doc/gutenprint/html/group__vars.html @@ -0,0 +1,6301 @@ + + + + + + + +libgutenprint API Reference: vars + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+
+Data Structures | +Macros | +Typedefs | +Enumerations | +Functions
+
+
vars
+
+
+ +

The vars data type contains all the information about a print job, this includes information such as the printer model, paper size, print resolution etc. +More...

+ + + + + + + + + + + + + + +

+Data Structures

struct  stp_raw_t
 Raw parameter. More...
 
struct  stp_double_bound_t
 double_bound (range) parameter. More...
 
struct  stp_int_bound_t
 int_bound (range) parameter. More...
 
struct  stp_parameter_t
 Parameter description. More...
 
+ + + + + + + +

+Macros

#define STP_RAW(x)   { sizeof((x)), (x) }
 
#define STP_RAW_STRING(x)   { sizeof((x)) - 1, (x) }
 
#define STP_CHANNEL_NONE   ((unsigned char) -1)
 
+ + + + + + + + + + + + + + + + + + + +

+Typedefs

typedef struct stp_vars stp_vars_t
 The vars opaque data type. More...
 
typedef void * stp_parameter_list_t
 The parameter_list opaque data type. More...
 
typedef const void * stp_const_parameter_list_t
 The constant parameter_list opaque data type. More...
 
typedef void(* stp_outfunc_t) (void *data, const char *buffer, size_t bytes)
 Output function supplied by the calling application. More...
 
typedef void *(* stp_copy_data_func_t) (void *)
 
typedef void(* stp_free_data_func_t) (void *)
 
typedef struct stp_compdata compdata_t
 
+ + + + + + + + + + + + + + + +

+Enumerations

enum  stp_parameter_type_t {
+  STP_PARAMETER_TYPE_STRING_LIST, +STP_PARAMETER_TYPE_INT, +STP_PARAMETER_TYPE_BOOLEAN, +STP_PARAMETER_TYPE_DOUBLE, +
+  STP_PARAMETER_TYPE_CURVE, +STP_PARAMETER_TYPE_FILE, +STP_PARAMETER_TYPE_RAW, +STP_PARAMETER_TYPE_ARRAY, +
+  STP_PARAMETER_TYPE_DIMENSION, +STP_PARAMETER_TYPE_INVALID +
+ }
 Parameter types. More...
 
enum  stp_parameter_class_t { STP_PARAMETER_CLASS_FEATURE, +STP_PARAMETER_CLASS_OUTPUT, +STP_PARAMETER_CLASS_CORE, +STP_PARAMETER_CLASS_INVALID + }
 Parameter class. More...
 
enum  stp_parameter_level_t {
+  STP_PARAMETER_LEVEL_BASIC, +STP_PARAMETER_LEVEL_ADVANCED, +STP_PARAMETER_LEVEL_ADVANCED1, +STP_PARAMETER_LEVEL_ADVANCED2, +
+  STP_PARAMETER_LEVEL_ADVANCED3, +STP_PARAMETER_LEVEL_ADVANCED4, +STP_PARAMETER_LEVEL_INTERNAL, +STP_PARAMETER_LEVEL_EXTERNAL, +
+  STP_PARAMETER_LEVEL_INVALID +
+ }
 Parameter level. More...
 
enum  stp_parameter_activity_t { STP_PARAMETER_INACTIVE, +STP_PARAMETER_DEFAULTED, +STP_PARAMETER_ACTIVE + }
 Parameter activity. More...
 
enum  stp_parameter_verify_t { PARAMETER_BAD, +PARAMETER_OK, +PARAMETER_INACTIVE + }
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

stp_vars_t * stp_vars_create (void)
 Create a new vars object. More...
 
void stp_vars_copy (stp_vars_t *dest, const stp_vars_t *source)
 Copy a vars object. More...
 
stp_vars_t * stp_vars_create_copy (const stp_vars_t *source)
 Copy and allocate a vars object. More...
 
void stp_vars_destroy (stp_vars_t *v)
 Destroy a vars object. More...
 
void stp_set_driver (stp_vars_t *v, const char *val)
 Set the name of the printer driver. More...
 
void stp_set_driver_n (stp_vars_t *v, const char *val, int bytes)
 Set the name of the printer driver. More...
 
const char * stp_get_driver (const stp_vars_t *v)
 Get the name of the printer driver. More...
 
void stp_set_color_conversion (stp_vars_t *v, const char *val)
 Set the name of the color conversion routine, if not the default. More...
 
void stp_set_color_conversion_n (stp_vars_t *v, const char *val, int bytes)
 Set the name of the color conversion routine, if not the default. More...
 
const char * stp_get_color_conversion (const stp_vars_t *v)
 Get the name of the color conversion routine. More...
 
void stp_set_left (stp_vars_t *v, int val)
 Set the left edge of the image. More...
 
int stp_get_left (const stp_vars_t *v)
 Get the left edge of the image. More...
 
void stp_set_top (stp_vars_t *v, int val)
 Set the top edge of the image. More...
 
int stp_get_top (const stp_vars_t *v)
 Get the top edge of the image. More...
 
void stp_set_width (stp_vars_t *v, int val)
 Set the width of the image. More...
 
int stp_get_width (const stp_vars_t *v)
 Get the width edge of the image. More...
 
void stp_set_height (stp_vars_t *v, int val)
 Set the height of the image. More...
 
int stp_get_height (const stp_vars_t *v)
 Get the height of the image. More...
 
void stp_set_page_width (stp_vars_t *v, int val)
 Set the page width. More...
 
int stp_get_page_width (const stp_vars_t *v)
 Get the page width. More...
 
void stp_set_page_height (stp_vars_t *v, int val)
 Set the page height. More...
 
int stp_get_page_height (const stp_vars_t *v)
 Get the page height. More...
 
void stp_set_outfunc (stp_vars_t *v, stp_outfunc_t val)
 Set the function used to print output information. More...
 
stp_outfunc_t stp_get_outfunc (const stp_vars_t *v)
 Get the function used to print output information. More...
 
void stp_set_errfunc (stp_vars_t *v, stp_outfunc_t val)
 Set the function used to print error and diagnostic information. More...
 
stp_outfunc_t stp_get_errfunc (const stp_vars_t *v)
 Get the function used to print output information. More...
 
void stp_set_outdata (stp_vars_t *v, void *val)
 Set the output data. More...
 
void * stp_get_outdata (const stp_vars_t *v)
 Get the output data. More...
 
void stp_set_errdata (stp_vars_t *v, void *val)
 Set the error data. More...
 
void * stp_get_errdata (const stp_vars_t *v)
 Get the error data. More...
 
void stp_merge_printvars (stp_vars_t *user, const stp_vars_t *print)
 Merge defaults for a printer with user-chosen settings. More...
 
void stp_copy_vars_from (stp_vars_t *to, const stp_vars_t *from)
 Copy settings from one vars object to another, not modifying anything unset in the source. More...
 
stp_parameter_list_t stp_get_parameter_list (const stp_vars_t *v)
 List the available parameters for the currently chosen settings. More...
 
size_t stp_parameter_list_count (stp_const_parameter_list_t list)
 List the number of available parameters for the currently chosen settings. More...
 
const stp_parameter_t * stp_parameter_find (stp_const_parameter_list_t list, const char *name)
 Find a parameter by its name. More...
 
const stp_parameter_t * stp_parameter_list_param (stp_const_parameter_list_t list, size_t item)
 Find a parameter by its index number. More...
 
void stp_parameter_list_destroy (stp_parameter_list_t list)
 Destroy a parameter_list. More...
 
stp_parameter_list_t stp_parameter_list_create (void)
 Create a parameter_list. More...
 
void stp_parameter_list_add_param (stp_parameter_list_t list, const stp_parameter_t *item)
 Add a parameter to a parameter_list. More...
 
stp_parameter_list_t stp_parameter_list_copy (stp_const_parameter_list_t list)
 Copy and allocate a parameter_list. More...
 
void stp_parameter_list_append (stp_parameter_list_t list, stp_const_parameter_list_t append)
 Append one parameter_list to another. More...
 
void stp_describe_parameter (const stp_vars_t *v, const char *name, stp_parameter_t *description)
 Describe a parameter in detail. More...
 
void stp_parameter_description_destroy (stp_parameter_t *description)
 Destroy a parameter description. More...
 
const stp_parameter_t * stp_parameter_find_in_settings (const stp_vars_t *v, const char *name)
 Find a parameter by its name from a vars object. More...
 
void stp_set_string_parameter (stp_vars_t *v, const char *parameter, const char *value)
 Set a string parameter. More...
 
void stp_set_string_parameter_n (stp_vars_t *v, const char *parameter, const char *value, size_t bytes)
 Set a string parameter. More...
 
void stp_set_file_parameter (stp_vars_t *v, const char *parameter, const char *value)
 Set a file parameter. More...
 
void stp_set_file_parameter_n (stp_vars_t *v, const char *parameter, const char *value, size_t bytes)
 Set a file parameter. More...
 
void stp_set_float_parameter (stp_vars_t *v, const char *parameter, double value)
 Set a float parameter. More...
 
void stp_set_int_parameter (stp_vars_t *v, const char *parameter, int value)
 Set an integer parameter. More...
 
void stp_set_dimension_parameter (stp_vars_t *v, const char *parameter, int value)
 Set a dimension parameter. More...
 
void stp_set_boolean_parameter (stp_vars_t *v, const char *parameter, int value)
 Set a boolean parameter. More...
 
void stp_set_curve_parameter (stp_vars_t *v, const char *parameter, const stp_curve_t *value)
 Set a curve parameter. More...
 
void stp_set_array_parameter (stp_vars_t *v, const char *parameter, const stp_array_t *value)
 Set an array parameter. More...
 
void stp_set_raw_parameter (stp_vars_t *v, const char *parameter, const void *value, size_t bytes)
 Set a raw parameter. More...
 
void stp_scale_float_parameter (stp_vars_t *v, const char *parameter, double scale)
 Multiply the value of a float parameter by a scaling factor. More...
 
void stp_set_default_string_parameter (stp_vars_t *v, const char *parameter, const char *value)
 Set a default string parameter. More...
 
void stp_set_default_string_parameter_n (stp_vars_t *v, const char *parameter, const char *value, size_t bytes)
 Set a default string parameter. More...
 
void stp_set_default_file_parameter (stp_vars_t *v, const char *parameter, const char *value)
 Set a default file parameter. More...
 
void stp_set_default_file_parameter_n (stp_vars_t *v, const char *parameter, const char *value, size_t bytes)
 Set a default file parameter. More...
 
void stp_set_default_float_parameter (stp_vars_t *v, const char *parameter, double value)
 Set a default float parameter. More...
 
void stp_set_default_int_parameter (stp_vars_t *v, const char *parameter, int value)
 Set a default integer parameter. More...
 
void stp_set_default_dimension_parameter (stp_vars_t *v, const char *parameter, int value)
 Set a default dimension parameter. More...
 
void stp_set_default_boolean_parameter (stp_vars_t *v, const char *parameter, int value)
 Set a default boolean parameter. More...
 
void stp_set_default_curve_parameter (stp_vars_t *v, const char *parameter, const stp_curve_t *value)
 Set a default curve parameter. More...
 
void stp_set_default_array_parameter (stp_vars_t *v, const char *parameter, const stp_array_t *value)
 Set a default array parameter. More...
 
void stp_set_default_raw_parameter (stp_vars_t *v, const char *parameter, const void *value, size_t bytes)
 Set a default raw parameter. More...
 
const char * stp_get_string_parameter (const stp_vars_t *v, const char *parameter)
 Get a string parameter. More...
 
const char * stp_get_file_parameter (const stp_vars_t *v, const char *parameter)
 Get a file parameter. More...
 
double stp_get_float_parameter (const stp_vars_t *v, const char *parameter)
 Get a float parameter. More...
 
int stp_get_int_parameter (const stp_vars_t *v, const char *parameter)
 Get an integer parameter. More...
 
int stp_get_dimension_parameter (const stp_vars_t *v, const char *parameter)
 Get a dimension parameter. More...
 
int stp_get_boolean_parameter (const stp_vars_t *v, const char *parameter)
 Get a boolean parameter. More...
 
const stp_curve_t * stp_get_curve_parameter (const stp_vars_t *v, const char *parameter)
 Get a curve parameter. More...
 
const stp_array_t * stp_get_array_parameter (const stp_vars_t *v, const char *parameter)
 Get an array parameter. More...
 
const stp_raw_t * stp_get_raw_parameter (const stp_vars_t *v, const char *parameter)
 Get a raw parameter. More...
 
void stp_clear_string_parameter (stp_vars_t *v, const char *parameter)
 Clear a string parameter. More...
 
void stp_clear_file_parameter (stp_vars_t *v, const char *parameter)
 Clear a file parameter. More...
 
void stp_clear_float_parameter (stp_vars_t *v, const char *parameter)
 Clear (remove) a float parameter. More...
 
void stp_clear_int_parameter (stp_vars_t *v, const char *parameter)
 Clear (remove) an integer parameter. More...
 
void stp_clear_dimension_parameter (stp_vars_t *v, const char *parameter)
 Clear (remove) a dimension parameter. More...
 
void stp_clear_boolean_parameter (stp_vars_t *v, const char *parameter)
 Clear (remove) a boolean parameter. More...
 
void stp_clear_curve_parameter (stp_vars_t *v, const char *parameter)
 Clear a curve parameter. More...
 
void stp_clear_array_parameter (stp_vars_t *v, const char *parameter)
 Clear an array parameter. More...
 
void stp_clear_raw_parameter (stp_vars_t *v, const char *parameter)
 Clear a raw parameter. More...
 
void stp_clear_parameter (stp_vars_t *v, const char *parameter, stp_parameter_type_t type)
 Clear a parameter. More...
 
stp_string_list_t * stp_list_string_parameters (const stp_vars_t *v)
 List all string parameters. More...
 
stp_string_list_t * stp_list_file_parameters (const stp_vars_t *v)
 List all file parameters. More...
 
stp_string_list_t * stp_list_float_parameters (const stp_vars_t *v)
 List all float parameters. More...
 
stp_string_list_t * stp_list_int_parameters (const stp_vars_t *v)
 List all integer parameters. More...
 
stp_string_list_t * stp_list_dimension_parameters (const stp_vars_t *v)
 List all dimension parameters. More...
 
stp_string_list_t * stp_list_boolean_parameters (const stp_vars_t *v)
 List all boolean parameters. More...
 
stp_string_list_t * stp_list_curve_parameters (const stp_vars_t *v)
 List all curve parameters. More...
 
stp_string_list_t * stp_list_array_parameters (const stp_vars_t *v)
 List all array parameters. More...
 
stp_string_list_t * stp_list_raw_parameters (const stp_vars_t *v)
 List all raw parameters. More...
 
stp_string_list_t * stp_list_parameters (const stp_vars_t *v, stp_parameter_type_t type)
 List all parameters. More...
 
void stp_set_string_parameter_active (stp_vars_t *v, const char *parameter, stp_parameter_activity_t active)
 Set the activity of a string parameter. More...
 
void stp_set_file_parameter_active (stp_vars_t *v, const char *parameter, stp_parameter_activity_t active)
 Set the activity of a file parameter. More...
 
void stp_set_float_parameter_active (stp_vars_t *v, const char *parameter, stp_parameter_activity_t active)
 Set the activity of a float parameter. More...
 
void stp_set_int_parameter_active (stp_vars_t *v, const char *parameter, stp_parameter_activity_t active)
 Set the activity of an integer parameter. More...
 
void stp_set_dimension_parameter_active (stp_vars_t *v, const char *parameter, stp_parameter_activity_t active)
 Set the activity of a dimension parameter. More...
 
void stp_set_boolean_parameter_active (stp_vars_t *v, const char *parameter, stp_parameter_activity_t active)
 Set the activity of a boolean parameter. More...
 
void stp_set_curve_parameter_active (stp_vars_t *v, const char *parameter, stp_parameter_activity_t active)
 Set the activity of a curveparameter. More...
 
void stp_set_array_parameter_active (stp_vars_t *v, const char *parameter, stp_parameter_activity_t active)
 Set the activity of an array parameter. More...
 
void stp_set_raw_parameter_active (stp_vars_t *v, const char *parameter, stp_parameter_activity_t active)
 Set the activity of a raw parameter. More...
 
void stp_set_parameter_active (stp_vars_t *v, const char *parameter, stp_parameter_activity_t active, stp_parameter_type_t type)
 Set the activity of a parameter. More...
 
int stp_check_string_parameter (const stp_vars_t *v, const char *parameter, stp_parameter_activity_t active)
 Check if a string parameter is set. More...
 
int stp_check_file_parameter (const stp_vars_t *v, const char *parameter, stp_parameter_activity_t active)
 Check if a file parameter is set. More...
 
int stp_check_float_parameter (const stp_vars_t *v, const char *parameter, stp_parameter_activity_t active)
 Check if a float parameter is set. More...
 
int stp_check_int_parameter (const stp_vars_t *v, const char *parameter, stp_parameter_activity_t active)
 Check if an integer parameter is set. More...
 
int stp_check_dimension_parameter (const stp_vars_t *v, const char *parameter, stp_parameter_activity_t active)
 Check if a dimension parameter is set. More...
 
int stp_check_boolean_parameter (const stp_vars_t *v, const char *parameter, stp_parameter_activity_t active)
 Check if a boolean parameter is set. More...
 
int stp_check_curve_parameter (const stp_vars_t *v, const char *parameter, stp_parameter_activity_t active)
 Check if a curve parameter is set. More...
 
int stp_check_array_parameter (const stp_vars_t *v, const char *parameter, stp_parameter_activity_t active)
 Check if an array parameter is set. More...
 
int stp_check_raw_parameter (const stp_vars_t *v, const char *parameter, stp_parameter_activity_t active)
 Check if a raw parameter is set. More...
 
int stp_check_parameter (const stp_vars_t *v, const char *parameter, stp_parameter_activity_t active, stp_parameter_type_t type)
 Check if a parameter is set. More...
 
stp_parameter_activity_t stp_get_string_parameter_active (const stp_vars_t *v, const char *parameter)
 Get the activity status of a string parameter. More...
 
stp_parameter_activity_t stp_get_file_parameter_active (const stp_vars_t *v, const char *parameter)
 Get the activity status of a file parameter. More...
 
stp_parameter_activity_t stp_get_float_parameter_active (const stp_vars_t *v, const char *parameter)
 Get the activity status of a float parameter. More...
 
stp_parameter_activity_t stp_get_int_parameter_active (const stp_vars_t *v, const char *parameter)
 Get the activity status of an integer parameter. More...
 
stp_parameter_activity_t stp_get_dimension_parameter_active (const stp_vars_t *v, const char *parameter)
 Get the activity status of a dimension parameter. More...
 
stp_parameter_activity_t stp_get_boolean_parameter_active (const stp_vars_t *v, const char *parameter)
 Get the activity status of a boolean parameter. More...
 
stp_parameter_activity_t stp_get_curve_parameter_active (const stp_vars_t *v, const char *parameter)
 Get the activity status of a curve parameter. More...
 
stp_parameter_activity_t stp_get_array_parameter_active (const stp_vars_t *v, const char *parameter)
 Get the activity status of an array parameter. More...
 
stp_parameter_activity_t stp_get_raw_parameter_active (const stp_vars_t *v, const char *parameter)
 Get the activity status of a raw parameter. More...
 
stp_parameter_activity_t stp_get_parameter_active (const stp_vars_t *v, const char *parameter, stp_parameter_type_t type)
 Get the activity status of a parameter. More...
 
void stp_get_media_size (const stp_vars_t *v, int *width, int *height)
 Get the media (paper) size. More...
 
void stp_get_imageable_area (const stp_vars_t *v, int *left, int *right, int *bottom, int *top)
 Get the imagable area of the page. More...
 
void stp_get_maximum_imageable_area (const stp_vars_t *v, int *left, int *right, int *bottom, int *top)
 Get the maximum imagable area of the page. More...
 
void stp_get_size_limit (const stp_vars_t *v, int *max_width, int *max_height, int *min_width, int *min_height)
 Get the media size limits. More...
 
void stp_describe_resolution (const stp_vars_t *v, int *x, int *y)
 Retrieve the printing resolution of the selected resolution. More...
 
int stp_verify (stp_vars_t *v)
 Verify parameters. More...
 
const stp_vars_t * stp_default_settings (void)
 Get default global settings. More...
 
char * stp_parameter_get_category (const stp_vars_t *v, const stp_parameter_t *desc, const char *category)
 Get the value of a specified category for the specified parameter. More...
 
int stp_parameter_has_category_value (const stp_vars_t *v, const stp_parameter_t *desc, const char *category, const char *value)
 Determine whether a parameter has a category with the specified value. More...
 
stp_string_list_t * stp_parameter_get_categories (const stp_vars_t *v, const stp_parameter_t *desc)
 Get the list of categories and their values for the specified parameter. More...
 
void stp_allocate_component_data (stp_vars_t *v, const char *name, stp_copy_data_func_t copyfunc, stp_free_data_func_t freefunc, void *data)
 
void stp_destroy_component_data (stp_vars_t *v, const char *name)
 
void * stp_get_component_data (const stp_vars_t *v, const char *name)
 
stp_parameter_verify_t stp_verify_parameter (const stp_vars_t *v, const char *parameter, int quiet)
 
int stp_get_verified (const stp_vars_t *v)
 
void stp_set_verified (stp_vars_t *v, int value)
 
void stp_copy_options (stp_vars_t *vd, const stp_vars_t *vs)
 
void stp_fill_parameter_settings (stp_parameter_t *desc, const stp_parameter_t *param)
 
+

Detailed Description

+

The vars data type contains all the information about a print job, this includes information such as the printer model, paper size, print resolution etc.

+

Most of these job options are expressed as parameters which vary according to the model and other options selected.

+

The representation of printer settings has changed dramatically from 4.2. All (well most, anyway) settings outside of basics such as the printer model and sizing settings are now typed parameters.

+

Macro Definition Documentation

+ +

◆ STP_CHANNEL_NONE

+ +
+
+ + + + +
#define STP_CHANNEL_NONE   ((unsigned char) -1)
+
+ +
+
+ +

◆ STP_RAW

+ +
+
+ + + + + + + + +
#define STP_RAW( x)   { sizeof((x)), (x) }
+
+ +
+
+ +

◆ STP_RAW_STRING

+ +
+
+ + + + + + + + +
#define STP_RAW_STRING( x)   { sizeof((x)) - 1, (x) }
+
+ +
+
+

Typedef Documentation

+ +

◆ compdata_t

+ +
+
+ + + + +
typedef struct stp_compdata compdata_t
+
+ +
+
+ +

◆ stp_const_parameter_list_t

+ +
+
+ + + + +
typedef const void* stp_const_parameter_list_t
+
+ +

The constant parameter_list opaque data type.

+ +
+
+ +

◆ stp_copy_data_func_t

+ +
+
+ + + + +
typedef void*(* stp_copy_data_func_t) (void *)
+
+ +
+
+ +

◆ stp_free_data_func_t

+ +
+
+ + + + +
typedef void(* stp_free_data_func_t) (void *)
+
+ +
+
+ +

◆ stp_outfunc_t

+ +
+
+ + + + +
typedef void(* stp_outfunc_t) (void *data, const char *buffer, size_t bytes)
+
+ +

Output function supplied by the calling application.

+

There are two output functions supplied by the caller, one to send output data and one to report errors.

Parameters
+ + + + +
dataa pointer to an opaque object owned by the calling application.
bufferthe data to output.
bytesthe size of buffer (in bytes).
+
+
+ +
+
+ +

◆ stp_parameter_list_t

+ +
+
+ + + + +
typedef void* stp_parameter_list_t
+
+ +

The parameter_list opaque data type.

+ +
+
+ +

◆ stp_vars_t

+ +
+
+ + + + +
typedef struct stp_vars stp_vars_t
+
+ +

The vars opaque data type.

+ +
+
+

Enumeration Type Documentation

+ +

◆ stp_parameter_activity_t

+ +
+
+ + + + +
enum stp_parameter_activity_t
+
+ +

Parameter activity.

+

Whether a parameter is currently active (i. e. whether its value should be used by the driver or not). All parameters default to being active unless explicitly "turned off".

+ + + + +
Enumerator
STP_PARAMETER_INACTIVE 

Parameter is inactive (unused).

+
STP_PARAMETER_DEFAULTED 

Parameter is set to its default value.

+
STP_PARAMETER_ACTIVE 

Parameter is active (used).

+
+ +
+
+ +

◆ stp_parameter_class_t

+ +
+
+ + + + +
enum stp_parameter_class_t
+
+ +

Parameter class.

+

What kind of setting this is, for the purpose of user interface representation.

+ + + + + +
Enumerator
STP_PARAMETER_CLASS_FEATURE 

Printer feature.

+
STP_PARAMETER_CLASS_OUTPUT 

Output control.

+
STP_PARAMETER_CLASS_CORE 

Core Gimp-Print parameter.

+
STP_PARAMETER_CLASS_INVALID 

Invalid class (should never be used).

+
+ +
+
+ +

◆ stp_parameter_level_t

+ +
+
+ + + + +
enum stp_parameter_level_t
+
+ +

Parameter level.

+

What "level" a setting is at, for UI design.

+ + + + + + + + + + +
Enumerator
STP_PARAMETER_LEVEL_BASIC 

Basic parameter, shown by all UIs.

+
STP_PARAMETER_LEVEL_ADVANCED 

Advanced parameter, shown by advanced UIs.

+
STP_PARAMETER_LEVEL_ADVANCED1 

Advanced1 parameter, shown by advanced UIs.

+
STP_PARAMETER_LEVEL_ADVANCED2 

Advanced2 parameter, shown by advanced UIs.

+
STP_PARAMETER_LEVEL_ADVANCED3 

Advanced3 parameter, shown by advanced UIs.

+
STP_PARAMETER_LEVEL_ADVANCED4 

Advanced4 parameter, shown by advanced UIs.

+
STP_PARAMETER_LEVEL_INTERNAL 

Parameters used only within Gimp-Print.

+
STP_PARAMETER_LEVEL_EXTERNAL 

Parameters used only outside Gimp-Print.

+
STP_PARAMETER_LEVEL_INVALID 

Invalid level (should never be used).

+
+ +
+
+ +

◆ stp_parameter_type_t

+ +
+
+ + + + +
enum stp_parameter_type_t
+
+ +

Parameter types.

+

The following types are permitted for a printer setting. Not all are currently implemented.

+ + + + + + + + + + + +
Enumerator
STP_PARAMETER_TYPE_STRING_LIST 

Single string choice from a list.

+
STP_PARAMETER_TYPE_INT 

Integer.

+
STP_PARAMETER_TYPE_BOOLEAN 

Boolean.

+
STP_PARAMETER_TYPE_DOUBLE 

Floating point number.

+
STP_PARAMETER_TYPE_CURVE 

Curve.

+
STP_PARAMETER_TYPE_FILE 

Filename (NYI, need to consider security).

+
STP_PARAMETER_TYPE_RAW 

Raw, opaque data.

+
STP_PARAMETER_TYPE_ARRAY 

Array.

+
STP_PARAMETER_TYPE_DIMENSION 

Linear dimension.

+
STP_PARAMETER_TYPE_INVALID 

Invalid type (should never be used).

+
+ +
+
+ +

◆ stp_parameter_verify_t

+ +
+
+ + + + +
enum stp_parameter_verify_t
+
+ + + + +
Enumerator
PARAMETER_BAD 
PARAMETER_OK 
PARAMETER_INACTIVE 
+ +
+
+

Function Documentation

+ +

◆ stp_allocate_component_data()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_allocate_component_data (stp_vars_t * v,
const char * name,
stp_copy_data_func_t copyfunc,
stp_free_data_func_t freefunc,
void * data 
)
+
+ +
+
+ +

◆ stp_check_array_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_check_array_parameter (const stp_vars_t * v,
const char * parameter,
stp_parameter_activity_t active 
)
+
+ +

Check if an array parameter is set.

+
Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
activethe minimum activity status.
+
+
+ +
+
+ +

◆ stp_check_boolean_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_check_boolean_parameter (const stp_vars_t * v,
const char * parameter,
stp_parameter_activity_t active 
)
+
+ +

Check if a boolean parameter is set.

+
Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
activethe minimum activity status.
+
+
+ +
+
+ +

◆ stp_check_curve_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_check_curve_parameter (const stp_vars_t * v,
const char * parameter,
stp_parameter_activity_t active 
)
+
+ +

Check if a curve parameter is set.

+
Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
activethe minimum activity status.
+
+
+ +
+
+ +

◆ stp_check_dimension_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_check_dimension_parameter (const stp_vars_t * v,
const char * parameter,
stp_parameter_activity_t active 
)
+
+ +

Check if a dimension parameter is set.

+
Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
activethe minimum activity status.
+
+
+ +
+
+ +

◆ stp_check_file_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_check_file_parameter (const stp_vars_t * v,
const char * parameter,
stp_parameter_activity_t active 
)
+
+ +

Check if a file parameter is set.

+
Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
activethe minimum activity status.
+
+
+ +
+
+ +

◆ stp_check_float_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_check_float_parameter (const stp_vars_t * v,
const char * parameter,
stp_parameter_activity_t active 
)
+
+ +

Check if a float parameter is set.

+
Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
activethe minimum activity status.
+
+
+ +
+
+ +

◆ stp_check_int_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_check_int_parameter (const stp_vars_t * v,
const char * parameter,
stp_parameter_activity_t active 
)
+
+ +

Check if an integer parameter is set.

+
Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
activethe minimum activity status.
+
+
+ +
+
+ +

◆ stp_check_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
int stp_check_parameter (const stp_vars_t * v,
const char * parameter,
stp_parameter_activity_t active,
stp_parameter_type_t type 
)
+
+ +

Check if a parameter is set.

+
Parameters
+ + + + + +
vthe vars to use.
parameterthe name of the parameter.
activethe minimum activity status.
typethe type of the parameter.
+
+
+ +
+
+ +

◆ stp_check_raw_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_check_raw_parameter (const stp_vars_t * v,
const char * parameter,
stp_parameter_activity_t active 
)
+
+ +

Check if a raw parameter is set.

+
Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
activethe minimum activity status.
+
+
+ +
+
+ +

◆ stp_check_string_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
int stp_check_string_parameter (const stp_vars_t * v,
const char * parameter,
stp_parameter_activity_t active 
)
+
+ +

Check if a string parameter is set.

+
Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
activethe minimum activity status.
+
+
+ +
+
+ +

◆ stp_clear_array_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_clear_array_parameter (stp_vars_t * v,
const char * parameter 
)
+
+ +

Clear an array parameter.

+

The parameter is set to NULL.

Parameters
+ + + +
vthe vars to use.
parameterthe name of the parameter.
+
+
+ +
+
+ +

◆ stp_clear_boolean_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_clear_boolean_parameter (stp_vars_t * v,
const char * parameter 
)
+
+ +

Clear (remove) a boolean parameter.

+
Parameters
+ + + +
vthe vars to use.
parameterthe name of the parameter.
+
+
+ +
+
+ +

◆ stp_clear_curve_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_clear_curve_parameter (stp_vars_t * v,
const char * parameter 
)
+
+ +

Clear a curve parameter.

+

The parameter is set to NULL.

Parameters
+ + + +
vthe vars to use.
parameterthe name of the parameter.
+
+
+ +
+
+ +

◆ stp_clear_dimension_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_clear_dimension_parameter (stp_vars_t * v,
const char * parameter 
)
+
+ +

Clear (remove) a dimension parameter.

+
Parameters
+ + + +
vthe vars to use.
parameterthe name of the parameter.
+
+
+ +
+
+ +

◆ stp_clear_file_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_clear_file_parameter (stp_vars_t * v,
const char * parameter 
)
+
+ +

Clear a file parameter.

+

The parameter is set to NULL.

Parameters
+ + + +
vthe vars to use.
parameterthe name of the parameter.
+
+
+ +
+
+ +

◆ stp_clear_float_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_clear_float_parameter (stp_vars_t * v,
const char * parameter 
)
+
+ +

Clear (remove) a float parameter.

+
Parameters
+ + + +
vthe vars to use.
parameterthe name of the parameter.
+
+
+ +
+
+ +

◆ stp_clear_int_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_clear_int_parameter (stp_vars_t * v,
const char * parameter 
)
+
+ +

Clear (remove) an integer parameter.

+
Parameters
+ + + +
vthe vars to use.
parameterthe name of the parameter.
+
+
+ +
+
+ +

◆ stp_clear_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_clear_parameter (stp_vars_t * v,
const char * parameter,
stp_parameter_type_t type 
)
+
+ +

Clear a parameter.

+
Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
typethe type of the parameter.
+
+
+ +
+
+ +

◆ stp_clear_raw_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_clear_raw_parameter (stp_vars_t * v,
const char * parameter 
)
+
+ +

Clear a raw parameter.

+

The parameter is set to NULL.

Parameters
+ + + +
vthe vars to use.
parameterthe name of the parameter.
+
+
+ +
+
+ +

◆ stp_clear_string_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_clear_string_parameter (stp_vars_t * v,
const char * parameter 
)
+
+ +

Clear a string parameter.

+

The parameter is set to NULL.

Parameters
+ + + +
vthe vars to use.
parameterthe name of the parameter.
+
+
+ +
+
+ +

◆ stp_copy_options()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_copy_options (stp_vars_t * vd,
const stp_vars_t * vs 
)
+
+ +
+
+ +

◆ stp_copy_vars_from()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_copy_vars_from (stp_vars_t * to,
const stp_vars_t * from 
)
+
+ +

Copy settings from one vars object to another, not modifying anything unset in the source.

+
Parameters
+ + + +
tothe destination vars.
fromthe vars to merge into user.
+
+
+ +
+
+ +

◆ stp_default_settings()

+ +
+
+ + + + + + + + +
const stp_vars_t* stp_default_settings (void )
+
+ +

Get default global settings.

+

The main use of this is to provide a usable stp_vars_t for purposes of parameter inquiry in the absence of a specific printer. This is currently used in a variety of places to get information on the standard color parameters without querying a particular printer.

Returns
the default settings.
+ +
+
+ +

◆ stp_describe_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_describe_parameter (const stp_vars_t * v,
const char * name,
stp_parameter_t * description 
)
+
+ +

Describe a parameter in detail.

+

All of the parameter fields will be populated.

Parameters
+ + + + +
vthe vars to use.
namethe name of the parameter.
descriptiona pointer to an stp_parameter_t to store the parameter description in.
+
+
+ +
+
+ +

◆ stp_describe_resolution()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_describe_resolution (const stp_vars_t * v,
int * x,
int * y 
)
+
+ +

Retrieve the printing resolution of the selected resolution.

+

If the resolution is invalid, -1 will be returned in both x and y.

Parameters
+ + + + +
vthe vars to use.
xa pointer to an int to store the horizontal resolution in.
ya pointer to an int to store the vertical resolution in.
+
+
+ +
+
+ +

◆ stp_destroy_component_data()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_destroy_component_data (stp_vars_t * v,
const char * name 
)
+
+ +
+
+ +

◆ stp_fill_parameter_settings()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_fill_parameter_settings (stp_parameter_t * desc,
const stp_parameter_t * param 
)
+
+ +
+
+ +

◆ stp_get_array_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + +
const stp_array_t* stp_get_array_parameter (const stp_vars_t * v,
const char * parameter 
)
+
+ +

Get an array parameter.

+
Parameters
+ + + +
vthe vars to use.
parameterthe name of the parameter.
+
+
+
Returns
the array, or NULL if no parameter was found.
+ +
+
+ +

◆ stp_get_array_parameter_active()

+ +
+
+ + + + + + + + + + + + + + + + + + +
stp_parameter_activity_t stp_get_array_parameter_active (const stp_vars_t * v,
const char * parameter 
)
+
+ +

Get the activity status of an array parameter.

+
Parameters
+ + + +
vthe vars to use.
parameterthe name of the parameter.
+
+
+
Returns
the activity status.
+ +
+
+ +

◆ stp_get_boolean_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + +
int stp_get_boolean_parameter (const stp_vars_t * v,
const char * parameter 
)
+
+ +

Get a boolean parameter.

+
Parameters
+ + + +
vthe vars to use.
parameterthe name of the parameter.
+
+
+
Returns
the boolean value.
+ +
+
+ +

◆ stp_get_boolean_parameter_active()

+ +
+
+ + + + + + + + + + + + + + + + + + +
stp_parameter_activity_t stp_get_boolean_parameter_active (const stp_vars_t * v,
const char * parameter 
)
+
+ +

Get the activity status of a boolean parameter.

+
Parameters
+ + + +
vthe vars to use.
parameterthe name of the parameter.
+
+
+
Returns
the activity status.
+ +
+
+ +

◆ stp_get_color_conversion()

+ +
+
+ + + + + + + + +
const char* stp_get_color_conversion (const stp_vars_t * v)
+
+ +

Get the name of the color conversion routine.

+
Returns
the name of the color conversion routine (must not be freed).
+ +
+
+ +

◆ stp_get_component_data()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void* stp_get_component_data (const stp_vars_t * v,
const char * name 
)
+
+ +
+
+ +

◆ stp_get_curve_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + +
const stp_curve_t* stp_get_curve_parameter (const stp_vars_t * v,
const char * parameter 
)
+
+ +

Get a curve parameter.

+
Parameters
+ + + +
vthe vars to use.
parameterthe name of the parameter.
+
+
+
Returns
the curve, or NULL if no parameter was found.
+ +
+
+ +

◆ stp_get_curve_parameter_active()

+ +
+
+ + + + + + + + + + + + + + + + + + +
stp_parameter_activity_t stp_get_curve_parameter_active (const stp_vars_t * v,
const char * parameter 
)
+
+ +

Get the activity status of a curve parameter.

+
Parameters
+ + + +
vthe vars to use.
parameterthe name of the parameter.
+
+
+
Returns
the activity status.
+ +
+
+ +

◆ stp_get_dimension_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + +
int stp_get_dimension_parameter (const stp_vars_t * v,
const char * parameter 
)
+
+ +

Get a dimension parameter.

+
Parameters
+ + + +
vthe vars to use.
parameterthe name of the parameter.
+
+
+
Returns
the dimension (integer) value.
+ +
+
+ +

◆ stp_get_dimension_parameter_active()

+ +
+
+ + + + + + + + + + + + + + + + + + +
stp_parameter_activity_t stp_get_dimension_parameter_active (const stp_vars_t * v,
const char * parameter 
)
+
+ +

Get the activity status of a dimension parameter.

+
Parameters
+ + + +
vthe vars to use.
parameterthe name of the parameter.
+
+
+
Returns
the activity status.
+ +
+
+ +

◆ stp_get_driver()

+ +
+
+ + + + + + + + +
const char* stp_get_driver (const stp_vars_t * v)
+
+ +

Get the name of the printer driver.

+
Returns
the name of the printer driver (must not be freed).
+ +
+
+ +

◆ stp_get_errdata()

+ +
+
+ + + + + + + + +
void* stp_get_errdata (const stp_vars_t * v)
+
+ +

Get the error data.

+
Parameters
+ + +
vthe vars to use.
+
+
+
Returns
the output data.
+ +
+
+ +

◆ stp_get_errfunc()

+ +
+
+ + + + + + + + +
stp_outfunc_t stp_get_errfunc (const stp_vars_t * v)
+
+ +

Get the function used to print output information.

+
Parameters
+ + +
vthe vars to use.
+
+
+
Returns
the outfunc.
+ +
+
+ +

◆ stp_get_file_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + +
const char* stp_get_file_parameter (const stp_vars_t * v,
const char * parameter 
)
+
+ +

Get a file parameter.

+
Parameters
+ + + +
vthe vars to use.
parameterthe name of the parameter.
+
+
+
Returns
the filename, or NULL if no parameter was found.
+ +
+
+ +

◆ stp_get_file_parameter_active()

+ +
+
+ + + + + + + + + + + + + + + + + + +
stp_parameter_activity_t stp_get_file_parameter_active (const stp_vars_t * v,
const char * parameter 
)
+
+ +

Get the activity status of a file parameter.

+
Parameters
+ + + +
vthe vars to use.
parameterthe name of the parameter.
+
+
+
Returns
the activity status.
+ +
+
+ +

◆ stp_get_float_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + +
double stp_get_float_parameter (const stp_vars_t * v,
const char * parameter 
)
+
+ +

Get a float parameter.

+
Parameters
+ + + +
vthe vars to use.
parameterthe name of the parameter.
+
+
+
Returns
the float value.
+ +
+
+ +

◆ stp_get_float_parameter_active()

+ +
+
+ + + + + + + + + + + + + + + + + + +
stp_parameter_activity_t stp_get_float_parameter_active (const stp_vars_t * v,
const char * parameter 
)
+
+ +

Get the activity status of a float parameter.

+
Parameters
+ + + +
vthe vars to use.
parameterthe name of the parameter.
+
+
+
Returns
the activity status.
+ +
+
+ +

◆ stp_get_height()

+ +
+
+ + + + + + + + +
int stp_get_height (const stp_vars_t * v)
+
+ +

Get the height of the image.

+
Returns
the left edge.
+ +
+
+ +

◆ stp_get_imageable_area()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_get_imageable_area (const stp_vars_t * v,
int * left,
int * right,
int * bottom,
int * top 
)
+
+ +

Get the imagable area of the page.

+

Retrieve the boundaries of the printable area of the page. In combination with the media size, this can be used to determine the actual printable region, which callers can use to place the image precisely. The dimensions are relative to the top left of the physical page.

+

If a customizable page size is used (see stp_printer_get_media_size), the actual desired width and/or height must be filled in using stp_set_page_width and/or stp_set_page_height. If these are not filled in, the margins will be returned.

+

Returned values may be negative if a printer is capable of full bleed by printing beyond the physical boundaries of the page.

+

If the media size stored in V is invalid, the return values will be indeterminate. It is up to the user to specify legal values.

Parameters
+ + + + + + +
vthe vars to use.
lefta pointer to an int to store the left edge in.
righta pointer to an int to store the right edge in.
bottoma pointer to an int to store the bottom edge in.
topa pointer to an int to store the top edge in.
+
+
+ +
+
+ +

◆ stp_get_int_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + +
int stp_get_int_parameter (const stp_vars_t * v,
const char * parameter 
)
+
+ +

Get an integer parameter.

+
Parameters
+ + + +
vthe vars to use.
parameterthe name of the parameter.
+
+
+
Returns
the integer value.
+ +
+
+ +

◆ stp_get_int_parameter_active()

+ +
+
+ + + + + + + + + + + + + + + + + + +
stp_parameter_activity_t stp_get_int_parameter_active (const stp_vars_t * v,
const char * parameter 
)
+
+ +

Get the activity status of an integer parameter.

+
Parameters
+ + + +
vthe vars to use.
parameterthe name of the parameter.
+
+
+
Returns
the activity status.
+ +
+
+ +

◆ stp_get_left()

+ +
+
+ + + + + + + + +
int stp_get_left (const stp_vars_t * v)
+
+ +

Get the left edge of the image.

+
Returns
the left edge.
+ +
+
+ +

◆ stp_get_maximum_imageable_area()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_get_maximum_imageable_area (const stp_vars_t * v,
int * left,
int * right,
int * bottom,
int * top 
)
+
+ +

Get the maximum imagable area of the page.

+

Retrieve the maximum (regardless of settings other than page sise) boundaries of the printable area of the page. In combination with the media size, this can be used to determine the actual printable region, which callers can use to place the image precisely. The dimensions are relative to the top left of the physical page.

+

If a customizable page size is used (see stp_printer_get_media_size), the actual desired width and/or height must be filled in using stp_set_page_width and/or stp_set_page_height. If these are not filled in, the margins will be returned.

+

Returned values may be negative if a printer is capable of full bleed by printing beyond the physical boundaries of the page.

+

If the media size stored in V is invalid, the return values will be indeterminate. It is up to the user to specify legal values.

Parameters
+ + + + + + +
vthe vars to use.
lefta pointer to an int to store the left edge in.
righta pointer to an int to store the right edge in.
bottoma pointer to an int to store the bottom edge in.
topa pointer to an int to store the top edge in.
+
+
+ +
+
+ +

◆ stp_get_media_size()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_get_media_size (const stp_vars_t * v,
int * width,
int * height 
)
+
+ +

Get the media (paper) size.

+

Retrieve the media size of the media type set in V, expressed in units of 1/72". If the media size is invalid, width and height will be set to -1. Values of 0 for width or height indicate that the dimension is variable, so that custom page sizes or roll paper can be used. In this case, the size limit should be used to determine maximum and minimum values permitted.

Parameters
+ + + + +
vthe vars to use.
widtha pointer to an int to store the media width in.
heighta pointer to an int to store the media height in.
+
+
+ +
+
+ +

◆ stp_get_outdata()

+ +
+
+ + + + + + + + +
void* stp_get_outdata (const stp_vars_t * v)
+
+ +

Get the output data.

+
Parameters
+ + +
vthe vars to use.
+
+
+
Returns
the output data.
+ +
+
+ +

◆ stp_get_outfunc()

+ +
+
+ + + + + + + + +
stp_outfunc_t stp_get_outfunc (const stp_vars_t * v)
+
+ +

Get the function used to print output information.

+
Parameters
+ + +
vthe vars to use.
+
+
+
Returns
the outfunc.
+ +
+
+ +

◆ stp_get_page_height()

+ +
+
+ + + + + + + + +
int stp_get_page_height (const stp_vars_t * v)
+
+ +

Get the page height.

+
Returns
the page height.
+ +
+
+ +

◆ stp_get_page_width()

+ +
+
+ + + + + + + + +
int stp_get_page_width (const stp_vars_t * v)
+
+ +

Get the page width.

+
Returns
the page width.
+ +
+
+ +

◆ stp_get_parameter_active()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
stp_parameter_activity_t stp_get_parameter_active (const stp_vars_t * v,
const char * parameter,
stp_parameter_type_t type 
)
+
+ +

Get the activity status of a parameter.

+
Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
typethe type of the parameter.
+
+
+ +
+
+ +

◆ stp_get_parameter_list()

+ +
+
+ + + + + + + + +
stp_parameter_list_t stp_get_parameter_list (const stp_vars_t * v)
+
+ +

List the available parameters for the currently chosen settings.

+

This does not fill in the bounds and defaults; it merely provides a list of settings. To fill in detailed information for a setting, use stp_describe_parameter.

Parameters
+ + +
vthe vars to use.
+
+
+
Returns
a list of available parameters (must be freed with stp_parameter_list_destroy()).
+ +
+
+ +

◆ stp_get_raw_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + +
const stp_raw_t* stp_get_raw_parameter (const stp_vars_t * v,
const char * parameter 
)
+
+ +

Get a raw parameter.

+
Parameters
+ + + +
vthe vars to use.
parameterthe name of the parameter.
+
+
+
Returns
the raw data, or NULL if no parameter was found.
+ +
+
+ +

◆ stp_get_raw_parameter_active()

+ +
+
+ + + + + + + + + + + + + + + + + + +
stp_parameter_activity_t stp_get_raw_parameter_active (const stp_vars_t * v,
const char * parameter 
)
+
+ +

Get the activity status of a raw parameter.

+
Parameters
+ + + +
vthe vars to use.
parameterthe name of the parameter.
+
+
+
Returns
the activity status.
+ +
+
+ +

◆ stp_get_size_limit()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_get_size_limit (const stp_vars_t * v,
int * max_width,
int * max_height,
int * min_width,
int * min_height 
)
+
+ +

Get the media size limits.

+

Retrieve the minimum and maximum size limits for custom media sizes with the current printer settings.

Parameters
+ + + + + + +
vthe vars to use.
max_widtha pointer to an int to store the maximum width in.
max_heighta pointer to an int to store the maximum height in.
min_widtha pointer to an int to store the minimum width in.
min_heighta pointer to an int to store the minimum height in.
+
+
+ +
+
+ +

◆ stp_get_string_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + +
const char* stp_get_string_parameter (const stp_vars_t * v,
const char * parameter 
)
+
+ +

Get a string parameter.

+
Parameters
+ + + +
vthe vars to use.
parameterthe name of the parameter.
+
+
+
Returns
the string, or NULL if no parameter was found.
+ +
+
+ +

◆ stp_get_string_parameter_active()

+ +
+
+ + + + + + + + + + + + + + + + + + +
stp_parameter_activity_t stp_get_string_parameter_active (const stp_vars_t * v,
const char * parameter 
)
+
+ +

Get the activity status of a string parameter.

+
Parameters
+ + + +
vthe vars to use.
parameterthe name of the parameter.
+
+
+
Returns
the activity status.
+ +
+
+ +

◆ stp_get_top()

+ +
+
+ + + + + + + + +
int stp_get_top (const stp_vars_t * v)
+
+ +

Get the top edge of the image.

+
Returns
the left edge.
+ +
+
+ +

◆ stp_get_verified()

+ +
+
+ + + + + + + + +
int stp_get_verified (const stp_vars_t * v)
+
+ +
+
+ +

◆ stp_get_width()

+ +
+
+ + + + + + + + +
int stp_get_width (const stp_vars_t * v)
+
+ +

Get the width edge of the image.

+
Returns
the left edge.
+ +
+
+ +

◆ stp_list_array_parameters()

+ +
+
+ + + + + + + + +
stp_string_list_t* stp_list_array_parameters (const stp_vars_t * v)
+
+ +

List all array parameters.

+

The return value must be freed after use.

Parameters
+ + +
vthe vars to use.
+
+
+ +
+
+ +

◆ stp_list_boolean_parameters()

+ +
+
+ + + + + + + + +
stp_string_list_t* stp_list_boolean_parameters (const stp_vars_t * v)
+
+ +

List all boolean parameters.

+

The return value must be freed after use.

Parameters
+ + +
vthe vars to use.
+
+
+ +
+
+ +

◆ stp_list_curve_parameters()

+ +
+
+ + + + + + + + +
stp_string_list_t* stp_list_curve_parameters (const stp_vars_t * v)
+
+ +

List all curve parameters.

+

The return value must be freed after use.

Parameters
+ + +
vthe vars to use.
+
+
+ +
+
+ +

◆ stp_list_dimension_parameters()

+ +
+
+ + + + + + + + +
stp_string_list_t* stp_list_dimension_parameters (const stp_vars_t * v)
+
+ +

List all dimension parameters.

+

The return value must be freed after use.

Parameters
+ + +
vthe vars to use.
+
+
+ +
+
+ +

◆ stp_list_file_parameters()

+ +
+
+ + + + + + + + +
stp_string_list_t* stp_list_file_parameters (const stp_vars_t * v)
+
+ +

List all file parameters.

+

The return value must be freed after use.

Parameters
+ + +
vthe vars to use.
+
+
+ +
+
+ +

◆ stp_list_float_parameters()

+ +
+
+ + + + + + + + +
stp_string_list_t* stp_list_float_parameters (const stp_vars_t * v)
+
+ +

List all float parameters.

+

The return value must be freed after use.

Parameters
+ + +
vthe vars to use.
+
+
+ +
+
+ +

◆ stp_list_int_parameters()

+ +
+
+ + + + + + + + +
stp_string_list_t* stp_list_int_parameters (const stp_vars_t * v)
+
+ +

List all integer parameters.

+

The return value must be freed after use.

Parameters
+ + +
vthe vars to use.
+
+
+ +
+
+ +

◆ stp_list_parameters()

+ +
+
+ + + + + + + + + + + + + + + + + + +
stp_string_list_t* stp_list_parameters (const stp_vars_t * v,
stp_parameter_type_t type 
)
+
+ +

List all parameters.

+

The return value must be freed after use.

Parameters
+ + + +
vthe vars to use.
typethe type of the parameter.
+
+
+ +
+
+ +

◆ stp_list_raw_parameters()

+ +
+
+ + + + + + + + +
stp_string_list_t* stp_list_raw_parameters (const stp_vars_t * v)
+
+ +

List all raw parameters.

+

The return value must be freed after use.

Parameters
+ + +
vthe vars to use.
+
+
+ +
+
+ +

◆ stp_list_string_parameters()

+ +
+
+ + + + + + + + +
stp_string_list_t* stp_list_string_parameters (const stp_vars_t * v)
+
+ +

List all string parameters.

+

The return value must be freed after use.

Parameters
+ + +
vthe vars to use.
+
+
+ +
+
+ +

◆ stp_merge_printvars()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_merge_printvars (stp_vars_t * user,
const stp_vars_t * print 
)
+
+ +

Merge defaults for a printer with user-chosen settings.

+
Deprecated:
This is likely to go away.
+
Parameters
+ + + +
userthe destination vars.
printthe vars to merge into user.
+
+
+ +
+
+ +

◆ stp_parameter_description_destroy()

+ +
+
+ + + + + + + + +
void stp_parameter_description_destroy (stp_parameter_t * description)
+
+ +

Destroy a parameter description.

+

This must be called even if the stp_parameter_t was not allocated with malloc, since some members are dynamically allocated.

Parameters
+ + +
descriptionthe parameter description to destroy.
+
+
+ +
+
+ +

◆ stp_parameter_find()

+ +
+
+ + + + + + + + + + + + + + + + + + +
const stp_parameter_t* stp_parameter_find (stp_const_parameter_list_t list,
const char * name 
)
+
+ +

Find a parameter by its name.

+
Parameters
+ + + +
listthe parameter_list to use.
namethe name of the parameter.
+
+
+
Returns
a pointer to the parameter (must not be freed), or NULL if no parameter was found.
+ +
+
+ +

◆ stp_parameter_find_in_settings()

+ +
+
+ + + + + + + + + + + + + + + + + + +
const stp_parameter_t* stp_parameter_find_in_settings (const stp_vars_t * v,
const char * name 
)
+
+ +

Find a parameter by its name from a vars object.

+
Parameters
+ + + +
vthe vars to use.
namethe name of the parameter.
+
+
+
Returns
a pointer to the parameter (must not be freed), or NULL if no parameter was found.
+ +
+
+ +

◆ stp_parameter_get_categories()

+ +
+
+ + + + + + + + + + + + + + + + + + +
stp_string_list_t* stp_parameter_get_categories (const stp_vars_t * v,
const stp_parameter_t * desc 
)
+
+ +

Get the list of categories and their values for the specified parameter.

+
Parameters
+ + + +
vthe vars to use.
descthe parameter description to use (must already be described)
+
+
+
Returns
the list of categories.
+ +
+
+ +

◆ stp_parameter_get_category()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
char* stp_parameter_get_category (const stp_vars_t * v,
const stp_parameter_t * desc,
const char * category 
)
+
+ +

Get the value of a specified category for the specified parameter.

+
Parameters
+ + + + +
vthe vars to use.
descthe parameter description to use (must already be described)
categorythe name of the category to search for.
+
+
+
Returns
the value of the category or NULL. String must be freed by caller.
+ +
+
+ +

◆ stp_parameter_has_category_value()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
int stp_parameter_has_category_value (const stp_vars_t * v,
const stp_parameter_t * desc,
const char * category,
const char * value 
)
+
+ +

Determine whether a parameter has a category with the specified value.

+

If a null value is passed in, return whether the parameter has the category at all. Return -1 if any other error condition (null vars, desc, or category).

Parameters
+ + + + + +
vthe vars to use.
descthe parameter description to use (must already be described)
categorythe name of the category to search for.
valuethe value of the category to search for.
+
+
+
Returns
whether the parameter has the category with the specified value.
+ +
+
+ +

◆ stp_parameter_list_add_param()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_parameter_list_add_param (stp_parameter_list_t list,
const stp_parameter_t * item 
)
+
+ +

Add a parameter to a parameter_list.

+
Parameters
+ + + +
listthe parameter_list to use.
itemthe parameter to add.
+
+
+ +
+
+ +

◆ stp_parameter_list_append()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_parameter_list_append (stp_parameter_list_t list,
stp_const_parameter_list_t append 
)
+
+ +

Append one parameter_list to another.

+
Parameters
+ + + +
listthe destination list (to append to).
appendthe list of parameters to append. Each item that does not already exist in list will be appended.
+
+
+ +
+
+ +

◆ stp_parameter_list_copy()

+ +
+
+ + + + + + + + +
stp_parameter_list_t stp_parameter_list_copy (stp_const_parameter_list_t list)
+
+ +

Copy and allocate a parameter_list.

+

A new parameter_list will be created, and then the contents of source will be copied into it.

Parameters
+ + +
listthe source parameter_list.
+
+
+
Returns
the new copy of the parameter_list.
+ +
+
+ +

◆ stp_parameter_list_count()

+ +
+
+ + + + + + + + +
size_t stp_parameter_list_count (stp_const_parameter_list_t list)
+
+ +

List the number of available parameters for the currently chosen settings.

+
Parameters
+ + +
listthe parameter_list to use.
+
+
+
Returns
the number of parameters.
+ +
+
+ +

◆ stp_parameter_list_create()

+ +
+
+ + + + + + + + +
stp_parameter_list_t stp_parameter_list_create (void )
+
+ +

Create a parameter_list.

+
Returns
the newly created parameter_list.
+ +
+
+ +

◆ stp_parameter_list_destroy()

+ +
+
+ + + + + + + + +
void stp_parameter_list_destroy (stp_parameter_list_t list)
+
+ +

Destroy a parameter_list.

+

It is an error to destroy the parameter_list more than once.

Parameters
+ + +
listthe parameter_list to destroy.
+
+
+ +
+
+ +

◆ stp_parameter_list_param()

+ +
+
+ + + + + + + + + + + + + + + + + + +
const stp_parameter_t* stp_parameter_list_param (stp_const_parameter_list_t list,
size_t item 
)
+
+ +

Find a parameter by its index number.

+
Parameters
+ + + +
listthe parameter_list to use.
itemthe index number of the parameter (must not be greater than stp_parameter_list_count - 1).
+
+
+
Returns
a pointer to the parameter (must not be freed), or NULL if no parameter was found.
+ +
+
+ +

◆ stp_scale_float_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_scale_float_parameter (stp_vars_t * v,
const char * parameter,
double scale 
)
+
+ +

Multiply the value of a float parameter by a scaling factor.

+
Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
scalethe factor to multiply the value by.
+
+
+ +
+
+ +

◆ stp_set_array_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_array_parameter (stp_vars_t * v,
const char * parameter,
const stp_array_t * value 
)
+
+ +

Set an array parameter.

+
Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
valuethe value to set.
+
+
+ +
+
+ +

◆ stp_set_array_parameter_active()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_array_parameter_active (stp_vars_t * v,
const char * parameter,
stp_parameter_activity_t active 
)
+
+ +

Set the activity of an array parameter.

+
Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
activethe activity status to set (should be set to STP_PARAMETER_ACTIVE or STP_PARAMETER_INACTIVE).
+
+
+ +
+
+ +

◆ stp_set_boolean_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_boolean_parameter (stp_vars_t * v,
const char * parameter,
int value 
)
+
+ +

Set a boolean parameter.

+
Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
valuethe value to set.
+
+
+ +
+
+ +

◆ stp_set_boolean_parameter_active()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_boolean_parameter_active (stp_vars_t * v,
const char * parameter,
stp_parameter_activity_t active 
)
+
+ +

Set the activity of a boolean parameter.

+
Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
activethe activity status to set (should be set to STP_PARAMETER_ACTIVE or STP_PARAMETER_INACTIVE).
+
+
+ +
+
+ +

◆ stp_set_color_conversion()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_set_color_conversion (stp_vars_t * v,
const char * val 
)
+
+ +

Set the name of the color conversion routine, if not the default.

+
Parameters
+ + + +
vthe vars to use.
valthe name to set.
+
+
+ +
+
+ +

◆ stp_set_color_conversion_n()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_color_conversion_n (stp_vars_t * v,
const char * val,
int bytes 
)
+
+ +

Set the name of the color conversion routine, if not the default.

+
Parameters
+ + + + +
vthe vars to use.
valthe name to set.
bytesthe length of val (in bytes).
+
+
+ +
+
+ +

◆ stp_set_curve_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_curve_parameter (stp_vars_t * v,
const char * parameter,
const stp_curve_t * value 
)
+
+ +

Set a curve parameter.

+
Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
valuethe value to set.
+
+
+ +
+
+ +

◆ stp_set_curve_parameter_active()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_curve_parameter_active (stp_vars_t * v,
const char * parameter,
stp_parameter_activity_t active 
)
+
+ +

Set the activity of a curveparameter.

+
Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
activethe activity status to set (should be set to STP_PARAMETER_ACTIVE or STP_PARAMETER_INACTIVE).
+
+
+ +
+
+ +

◆ stp_set_default_array_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_default_array_parameter (stp_vars_t * v,
const char * parameter,
const stp_array_t * value 
)
+
+ +

Set a default array parameter.

+

The value is set if the parameter is not already set. This avoids having to check if the parameter is set prior to setting it, if you do not want to override the existing value.

Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
valuethe value to set.
+
+
+ +
+
+ +

◆ stp_set_default_boolean_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_default_boolean_parameter (stp_vars_t * v,
const char * parameter,
int value 
)
+
+ +

Set a default boolean parameter.

+

The value is set if the parameter is not already set. This avoids having to check if the parameter is set prior to setting it, if you do not want to override the existing value.

Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
valuethe value to set.
+
+
+ +
+
+ +

◆ stp_set_default_curve_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_default_curve_parameter (stp_vars_t * v,
const char * parameter,
const stp_curve_t * value 
)
+
+ +

Set a default curve parameter.

+

The value is set if the parameter is not already set. This avoids having to check if the parameter is set prior to setting it, if you do not want to override the existing value.

Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
valuethe value to set.
+
+
+ +
+
+ +

◆ stp_set_default_dimension_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_default_dimension_parameter (stp_vars_t * v,
const char * parameter,
int value 
)
+
+ +

Set a default dimension parameter.

+

The value is set if the parameter is not already set. This avoids having to check if the parameter is set prior to setting it, if you do not want to override the existing value.

Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
valuethe value to set.
+
+
+ +
+
+ +

◆ stp_set_default_file_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_default_file_parameter (stp_vars_t * v,
const char * parameter,
const char * value 
)
+
+ +

Set a default file parameter.

+

The value is set if the parameter is not already set. This avoids having to check if the parameter is set prior to setting it, if you do not want to override the existing value.

Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
valuethe value to set.
+
+
+ +
+
+ +

◆ stp_set_default_file_parameter_n()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_default_file_parameter_n (stp_vars_t * v,
const char * parameter,
const char * value,
size_t bytes 
)
+
+ +

Set a default file parameter.

+

The value is set if the parameter is not already set. This avoids having to check if the parameter is set prior to setting it, if you do not want to override the existing value.

Parameters
+ + + + + +
vthe vars to use.
parameterthe name of the parameter.
valuethe value to set (must not contain NUL).
bytesthe length of value (in bytes).
+
+
+ +
+
+ +

◆ stp_set_default_float_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_default_float_parameter (stp_vars_t * v,
const char * parameter,
double value 
)
+
+ +

Set a default float parameter.

+

The value is set if the parameter is not already set. This avoids having to check if the parameter is set prior to setting it, if you do not want to override the existing value.

Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
valuethe value to set.
+
+
+ +
+
+ +

◆ stp_set_default_int_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_default_int_parameter (stp_vars_t * v,
const char * parameter,
int value 
)
+
+ +

Set a default integer parameter.

+

The value is set if the parameter is not already set. This avoids having to check if the parameter is set prior to setting it, if you do not want to override the existing value.

Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
valuethe value to set.
+
+
+ +
+
+ +

◆ stp_set_default_raw_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_default_raw_parameter (stp_vars_t * v,
const char * parameter,
const void * value,
size_t bytes 
)
+
+ +

Set a default raw parameter.

+

The value is set if the parameter is not already set. This avoids having to check if the parameter is set prior to setting it, if you do not want to override the existing value.

Parameters
+ + + + + +
vthe vars to use.
parameterthe name of the parameter.
valuethe value to set.
bytesthe length of value (in bytes).
+
+
+ +
+
+ +

◆ stp_set_default_string_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_default_string_parameter (stp_vars_t * v,
const char * parameter,
const char * value 
)
+
+ +

Set a default string parameter.

+

The value is set if the parameter is not already set. This avoids having to check if the parameter is set prior to setting it, if you do not want to override the existing value.

Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
valuethe value to set.
+
+
+ +
+
+ +

◆ stp_set_default_string_parameter_n()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_default_string_parameter_n (stp_vars_t * v,
const char * parameter,
const char * value,
size_t bytes 
)
+
+ +

Set a default string parameter.

+

The value is set if the parameter is not already set. This avoids having to check if the parameter is set prior to setting it, if you do not want to override the existing value.

Parameters
+ + + + + +
vthe vars to use.
parameterthe name of the parameter.
valuethe value to set (must not contain NUL).
bytesthe length of value (in bytes).
+
+
+ +
+
+ +

◆ stp_set_dimension_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_dimension_parameter (stp_vars_t * v,
const char * parameter,
int value 
)
+
+ +

Set a dimension parameter.

+
Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
valuethe value to set.
+
+
+ +
+
+ +

◆ stp_set_dimension_parameter_active()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_dimension_parameter_active (stp_vars_t * v,
const char * parameter,
stp_parameter_activity_t active 
)
+
+ +

Set the activity of a dimension parameter.

+
Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
activethe activity status to set (should be set to STP_PARAMETER_ACTIVE or STP_PARAMETER_INACTIVE).
+
+
+ +
+
+ +

◆ stp_set_driver()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_set_driver (stp_vars_t * v,
const char * val 
)
+
+ +

Set the name of the printer driver.

+
Parameters
+ + + +
vthe vars to use.
valthe name to set.
+
+
+ +
+
+ +

◆ stp_set_driver_n()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_driver_n (stp_vars_t * v,
const char * val,
int bytes 
)
+
+ +

Set the name of the printer driver.

+
Parameters
+ + + + +
vthe vars to use.
valthe name to set.
bytesthe length of val (in bytes).
+
+
+ +
+
+ +

◆ stp_set_errdata()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_set_errdata (stp_vars_t * v,
void * val 
)
+
+ +

Set the error data.

+
Parameters
+ + + +
vthe vars to use.
valthe error data. This will typically be a file descriptor, but it is entirely up to the caller exactly what type this might be.
+
+
+ +
+
+ +

◆ stp_set_errfunc()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_set_errfunc (stp_vars_t * v,
stp_outfunc_t val 
)
+
+ +

Set the function used to print error and diagnostic information.

+

These must be supplied by the caller. errdata is passed as an arguments to errfunc; typically it will be a file descriptor.

Parameters
+ + + +
vthe vars to use.
valthe value to set.
+
+
+ +
+
+ +

◆ stp_set_file_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_file_parameter (stp_vars_t * v,
const char * parameter,
const char * value 
)
+
+ +

Set a file parameter.

+
Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
valuethe value to set.
+
+
+ +
+
+ +

◆ stp_set_file_parameter_active()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_file_parameter_active (stp_vars_t * v,
const char * parameter,
stp_parameter_activity_t active 
)
+
+ +

Set the activity of a file parameter.

+
Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
activethe activity status to set (should be set to STP_PARAMETER_ACTIVE or STP_PARAMETER_INACTIVE).
+
+
+ +
+
+ +

◆ stp_set_file_parameter_n()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_file_parameter_n (stp_vars_t * v,
const char * parameter,
const char * value,
size_t bytes 
)
+
+ +

Set a file parameter.

+
Parameters
+ + + + + +
vthe vars to use.
parameterthe name of the parameter.
valuethe value to set (must not contain NUL).
bytesthe length of value (in bytes).
+
+
+ +
+
+ +

◆ stp_set_float_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_float_parameter (stp_vars_t * v,
const char * parameter,
double value 
)
+
+ +

Set a float parameter.

+
Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
valuethe value to set.
+
+
+ +
+
+ +

◆ stp_set_float_parameter_active()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_float_parameter_active (stp_vars_t * v,
const char * parameter,
stp_parameter_activity_t active 
)
+
+ +

Set the activity of a float parameter.

+
Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
activethe activity status to set (should be set to STP_PARAMETER_ACTIVE or STP_PARAMETER_INACTIVE).
+
+
+ +
+
+ +

◆ stp_set_height()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_set_height (stp_vars_t * v,
int val 
)
+
+ +

Set the height of the image.

+
Parameters
+ + + +
vthe vars to use.
valthe value to set.
+
+
+ +
+
+ +

◆ stp_set_int_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_int_parameter (stp_vars_t * v,
const char * parameter,
int value 
)
+
+ +

Set an integer parameter.

+
Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
valuethe value to set.
+
+
+ +
+
+ +

◆ stp_set_int_parameter_active()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_int_parameter_active (stp_vars_t * v,
const char * parameter,
stp_parameter_activity_t active 
)
+
+ +

Set the activity of an integer parameter.

+
Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
activethe activity status to set (should be set to STP_PARAMETER_ACTIVE or STP_PARAMETER_INACTIVE).
+
+
+ +
+
+ +

◆ stp_set_left()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_set_left (stp_vars_t * v,
int val 
)
+
+ +

Set the left edge of the image.

+
Parameters
+ + + +
vthe vars to use.
valthe value to set.
+
+
+ +
+
+ +

◆ stp_set_outdata()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_set_outdata (stp_vars_t * v,
void * val 
)
+
+ +

Set the output data.

+
Parameters
+ + + +
vthe vars to use.
valthe output data. This will typically be a file descriptor, but it is entirely up to the caller exactly what type this might be.
+
+
+ +
+
+ +

◆ stp_set_outfunc()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_set_outfunc (stp_vars_t * v,
stp_outfunc_t val 
)
+
+ +

Set the function used to print output information.

+

These must be supplied by the caller. outdata is passed as an arguments to outfunc; typically it will be a file descriptor.

Parameters
+ + + +
vthe vars to use.
valthe value to set.
+
+
+ +
+
+ +

◆ stp_set_page_height()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_set_page_height (stp_vars_t * v,
int val 
)
+
+ +

Set the page height.

+
Parameters
+ + + +
vthe vars to use.
valthe value to set.
+
+
+ +
+
+ +

◆ stp_set_page_width()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_set_page_width (stp_vars_t * v,
int val 
)
+
+ +

Set the page width.

+
Parameters
+ + + +
vthe vars to use.
valthe value to set.
+
+
+ +
+
+ +

◆ stp_set_parameter_active()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_parameter_active (stp_vars_t * v,
const char * parameter,
stp_parameter_activity_t active,
stp_parameter_type_t type 
)
+
+ +

Set the activity of a parameter.

+
Parameters
+ + + + + +
vthe vars to use.
parameterthe name of the parameter.
activethe activity status to set (should be set to STP_PARAMETER_ACTIVE or STP_PARAMETER_INACTIVE).
typethe type of the parameter.
+
+
+ +
+
+ +

◆ stp_set_raw_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_raw_parameter (stp_vars_t * v,
const char * parameter,
const void * value,
size_t bytes 
)
+
+ +

Set a raw parameter.

+
Parameters
+ + + + + +
vthe vars to use.
parameterthe name of the parameter.
valuethe value to set.
bytesthe length of value (in bytes).
+
+
+ +
+
+ +

◆ stp_set_raw_parameter_active()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_raw_parameter_active (stp_vars_t * v,
const char * parameter,
stp_parameter_activity_t active 
)
+
+ +

Set the activity of a raw parameter.

+
Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
activethe activity status to set (should be set to STP_PARAMETER_ACTIVE or STP_PARAMETER_INACTIVE).
+
+
+ +
+
+ +

◆ stp_set_string_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_string_parameter (stp_vars_t * v,
const char * parameter,
const char * value 
)
+
+ +

Set a string parameter.

+
Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
valuethe value to set.
+
+
+ +
+
+ +

◆ stp_set_string_parameter_active()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_string_parameter_active (stp_vars_t * v,
const char * parameter,
stp_parameter_activity_t active 
)
+
+ +

Set the activity of a string parameter.

+
Parameters
+ + + + +
vthe vars to use.
parameterthe name of the parameter.
activethe activity status to set (should be set to STP_PARAMETER_ACTIVE or STP_PARAMETER_INACTIVE).
+
+
+ +
+
+ +

◆ stp_set_string_parameter_n()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void stp_set_string_parameter_n (stp_vars_t * v,
const char * parameter,
const char * value,
size_t bytes 
)
+
+ +

Set a string parameter.

+
Parameters
+ + + + + +
vthe vars to use.
parameterthe name of the parameter.
valuethe value to set (must not contain NUL).
bytesthe length of value (in bytes).
+
+
+ +
+
+ +

◆ stp_set_top()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_set_top (stp_vars_t * v,
int val 
)
+
+ +

Set the top edge of the image.

+
Parameters
+ + + +
vthe vars to use.
valthe value to set.
+
+
+ +
+
+ +

◆ stp_set_verified()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_set_verified (stp_vars_t * v,
int value 
)
+
+ +
+
+ +

◆ stp_set_width()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_set_width (stp_vars_t * v,
int val 
)
+
+ +

Set the width of the image.

+
Parameters
+ + + +
vthe vars to use.
valthe value to set.
+
+
+ +
+
+ +

◆ stp_vars_copy()

+ +
+
+ + + + + + + + + + + + + + + + + + +
void stp_vars_copy (stp_vars_t * dest,
const stp_vars_t * source 
)
+
+ +

Copy a vars object.

+

Both dest and source must be valid vars objects previously created with stp_vars_create().

Parameters
+ + + +
destthe destination vars.
sourcethe source vars.
+
+
+ +
+
+ +

◆ stp_vars_create()

+ +
+
+ + + + + + + + +
stp_vars_t* stp_vars_create (void )
+
+ +

Create a new vars object.

+
Returns
the newly created vars object.
+ +
+
+ +

◆ stp_vars_create_copy()

+ +
+
+ + + + + + + + +
stp_vars_t* stp_vars_create_copy (const stp_vars_t * source)
+
+ +

Copy and allocate a vars object.

+

source must be a valid vars object previously created with stp_vars_create().

Parameters
+ + +
sourcethe source vars.
+
+
+
Returns
the new copy of the vars.
+ +
+
+ +

◆ stp_vars_destroy()

+ +
+
+ + + + + + + + +
void stp_vars_destroy (stp_vars_t * v)
+
+ +

Destroy a vars object.

+

It is an error to destroy the vars more than once.

Parameters
+ + +
vthe vars to destroy.
+
+
+ +
+
+ +

◆ stp_verify()

+ +
+
+ + + + + + + + +
int stp_verify (stp_vars_t * v)
+
+ +

Verify parameters.

+

Verify that the parameters selected are consistent with those allowed by the driver. This must be called prior to printing; failure to do so will result in printing failing.

Parameters
+ + +
vthe vars to use.
+
+
+
Returns
0 on failure, 1 on success; other status values are reserved.
+ +
+
+ +

◆ stp_verify_parameter()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
stp_parameter_verify_t stp_verify_parameter (const stp_vars_t * v,
const char * parameter,
int quiet 
)
+
+ +
+
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/group__version.html b/doc/gutenprint/html/group__version.html new file mode 100644 index 0000000..0b90548 --- /dev/null +++ b/doc/gutenprint/html/group__version.html @@ -0,0 +1,372 @@ + + + + + + + +libgutenprint API Reference: version + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+
+Macros | +Functions | +Variables
+
+
version
+
+
+ +

Version information. +More...

+ + + + + + + + + + + + + + + + +

+Macros

#define STP_MAJOR_VERSION   (5)
 
#define STP_MINOR_VERSION   (2)
 
#define STP_MICRO_VERSION   (13)
 
#define STP_CURRENT_INTERFACE   (8)
 
#define STP_BINARY_AGE   (6)
 
#define STP_INTERFACE_AGE   (0)
 
#define STP_CHECK_VERSION(major, minor, micro)
 
+ + + + +

+Functions

const char * stp_check_version (unsigned int required_major, unsigned int required_minor, unsigned int required_micro)
 Check whether the library provides the requested version. More...
 
+ + + + + + + + + + + + + + + + + + + +

+Variables

const unsigned int stp_major_version
 The library major version number. More...
 
const unsigned int stp_minor_version
 The library minor version number. More...
 
const unsigned int stp_micro_version
 The library micro version number. More...
 
const unsigned int stp_current_interface
 The library ABI revision number (number of incompatible revisions). More...
 
const unsigned int stp_binary_age
 The library ABI binary age number (number of forward-compatible revisions). More...
 
const unsigned int stp_interface_age
 The library ABI interface age number (number of revisions of this ABI). More...
 
+

Detailed Description

+

Version information.

+

Version information may be used to check the library version at compile-time, using macros, or at run-time, using constants.

+

Macro Definition Documentation

+ +

◆ STP_BINARY_AGE

+ +
+
+ + + + +
#define STP_BINARY_AGE   (6)
+
+ +
+
+ +

◆ STP_CHECK_VERSION

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
#define STP_CHECK_VERSION( major,
 minor,
 micro 
)
+
+Value:
(STP_MAJOR_VERSION > (major) || \
(STP_MAJOR_VERSION == (major) && \
STP_MINOR_VERSION > (minor)) || \
(STP_MAJOR_VERSION == (major) && \
STP_MINOR_VERSION == (minor) && \
STP_MICRO_VERSION >= (micro)))
STP_MAJOR_VERSION
#define STP_MAJOR_VERSION
Definition: gutenprint-version.h:47
+
STP_MINOR_VERSION
#define STP_MINOR_VERSION
Definition: gutenprint-version.h:48
+
+
+
+ +

◆ STP_CURRENT_INTERFACE

+ +
+
+ + + + +
#define STP_CURRENT_INTERFACE   (8)
+
+ +
+
+ +

◆ STP_INTERFACE_AGE

+ +
+
+ + + + +
#define STP_INTERFACE_AGE   (0)
+
+ +
+
+ +

◆ STP_MAJOR_VERSION

+ +
+
+ + + + +
#define STP_MAJOR_VERSION   (5)
+
+ +
+
+ +

◆ STP_MICRO_VERSION

+ +
+
+ + + + +
#define STP_MICRO_VERSION   (13)
+
+ +
+
+ +

◆ STP_MINOR_VERSION

+ +
+
+ + + + +
#define STP_MINOR_VERSION   (2)
+
+ +
+
+

Function Documentation

+ +

◆ stp_check_version()

+ +
+
+ + + + + + + + + + + + + + + + + + + + + + + + +
const char* stp_check_version (unsigned int required_major,
unsigned int required_minor,
unsigned int required_micro 
)
+
+ +

Check whether the library provides the requested version.

+
Parameters
+ + + + +
required_majorthe minimum major revision.
required_minorthe minimum minor revision.
required_microthe minimum micro revision.
+
+
+
Returns
NULL if the version matches, or else a description of the error if the library is too old or too new.
+ +
+
+

Variable Documentation

+ +

◆ stp_binary_age

+ +
+
+ + + + +
const unsigned int stp_binary_age
+
+ +

The library ABI binary age number (number of forward-compatible revisions).

+ +
+
+ +

◆ stp_current_interface

+ +
+
+ + + + +
const unsigned int stp_current_interface
+
+ +

The library ABI revision number (number of incompatible revisions).

+ +
+
+ +

◆ stp_interface_age

+ +
+
+ + + + +
const unsigned int stp_interface_age
+
+ +

The library ABI interface age number (number of revisions of this ABI).

+ +
+
+ +

◆ stp_major_version

+ +
+
+ + + + +
const unsigned int stp_major_version
+
+ +

The library major version number.

+ +
+
+ +

◆ stp_micro_version

+ +
+
+ + + + +
const unsigned int stp_micro_version
+
+ +

The library micro version number.

+ +
+
+ +

◆ stp_minor_version

+ +
+
+ + + + +
const unsigned int stp_minor_version
+
+ +

The library minor version number.

+ +
+
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/gutenprint-intl-internal_8h.html b/doc/gutenprint/html/gutenprint-intl-internal_8h.html new file mode 100644 index 0000000..3b8e159 --- /dev/null +++ b/doc/gutenprint/html/gutenprint-intl-internal_8h.html @@ -0,0 +1,83 @@ + + + + + + + +libgutenprint API Reference: include/gutenprint/gutenprint-intl-internal.h File Reference + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + + +
+
+
+Macros
+
+
gutenprint-intl-internal.h File Reference
+
+
+ +

Internationalisation functions. +More...

+
#include <locale.h>
+
+ + + + + + + + + + + + + + + +

+Macros

#define textdomain(String)   (String)
 
#define gettext(String)   (String)
 
#define dgettext(Domain, Message)   (Message)
 
#define dcgettext(Domain, Message, Type)   (Message)
 
#define bindtextdomain(Domain, Directory)   (Domain)
 
#define _(String)   (String)
 
#define N_(String)   (String)
 
+

Detailed Description

+

Internationalisation functions.

+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/gutenprint-intl_8h.html b/doc/gutenprint/html/gutenprint-intl_8h.html new file mode 100644 index 0000000..012eafd --- /dev/null +++ b/doc/gutenprint/html/gutenprint-intl_8h.html @@ -0,0 +1,83 @@ + + + + + + + +libgutenprint API Reference: include/gutenprint/gutenprint-intl.h File Reference + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + + +
+
+
+Macros
+
+
gutenprint-intl.h File Reference
+
+
+ +

Internationalisation functions. +More...

+
#include <locale.h>
+
+ + + + + + + + + + + + + + + +

+Macros

#define textdomain(String)   (String)
 
#define gettext(String)   (String)
 
#define dgettext(Domain, Message)   (Message)
 
#define dcgettext(Domain, Message, Type)   (Message)
 
#define bindtextdomain(Domain, Directory)   (Domain)
 
#define _(String)   (String)
 
#define N_(String)   (String)
 
+

Detailed Description

+

Internationalisation functions.

+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/gutenprint-module_8h.html b/doc/gutenprint/html/gutenprint-module_8h.html new file mode 100644 index 0000000..fffdec8 --- /dev/null +++ b/doc/gutenprint/html/gutenprint-module_8h.html @@ -0,0 +1,96 @@ + + + + + + + +libgutenprint API Reference: include/gutenprint/gutenprint-module.h File Reference + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + + +
+
+
+Macros
+
+
gutenprint-module.h File Reference
+
+
+ +

Gutenprint module header. +More...

+
#include <gutenprint/gutenprint.h>
+#include <gutenprint/bit-ops.h>
+#include <gutenprint/channel.h>
+#include <gutenprint/color.h>
+#include <gutenprint/dither.h>
+#include <gutenprint/list.h>
+#include <gutenprint/module.h>
+#include <gutenprint/path.h>
+#include <gutenprint/weave.h>
+#include <gutenprint/xml.h>
+
+ + + +

+Macros

#define STP_MODULE   1
 
+

Detailed Description

+

Gutenprint module header.

+

This header includes all of the public headers used by modules.

+

Macro Definition Documentation

+ +

◆ STP_MODULE

+ +
+
+ + + + +
#define STP_MODULE   1
+
+ +
+
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/gutenprint-version_8h.html b/doc/gutenprint/html/gutenprint-version_8h.html new file mode 100644 index 0000000..8b6a766 --- /dev/null +++ b/doc/gutenprint/html/gutenprint-version_8h.html @@ -0,0 +1,111 @@ + + + + + + + +libgutenprint API Reference: include/gutenprint/gutenprint-version.h File Reference + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + + +
+
+
+Macros | +Functions | +Variables
+
+
gutenprint-version.h File Reference
+
+
+ +

Version functions. +More...

+ + + + + + + + + + + + + + + + +

+Macros

#define STP_MAJOR_VERSION   (5)
 
#define STP_MINOR_VERSION   (2)
 
#define STP_MICRO_VERSION   (13)
 
#define STP_CURRENT_INTERFACE   (8)
 
#define STP_BINARY_AGE   (6)
 
#define STP_INTERFACE_AGE   (0)
 
#define STP_CHECK_VERSION(major, minor, micro)
 
+ + + + +

+Functions

const char * stp_check_version (unsigned int required_major, unsigned int required_minor, unsigned int required_micro)
 Check whether the library provides the requested version. More...
 
+ + + + + + + + + + + + + + + + + + + +

+Variables

const unsigned int stp_major_version
 The library major version number. More...
 
const unsigned int stp_minor_version
 The library minor version number. More...
 
const unsigned int stp_micro_version
 The library micro version number. More...
 
const unsigned int stp_current_interface
 The library ABI revision number (number of incompatible revisions). More...
 
const unsigned int stp_binary_age
 The library ABI binary age number (number of forward-compatible revisions). More...
 
const unsigned int stp_interface_age
 The library ABI interface age number (number of revisions of this ABI). More...
 
+

Detailed Description

+

Version functions.

+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/gutenprint_8h.html b/doc/gutenprint/html/gutenprint_8h.html new file mode 100644 index 0000000..38b127c --- /dev/null +++ b/doc/gutenprint/html/gutenprint_8h.html @@ -0,0 +1,75 @@ + + + + + + + +libgutenprint API Reference: include/gutenprint/gutenprint.h File Reference + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + + +
+
+
+
gutenprint.h File Reference
+
+
+ +

Gutenprint master header. +More...

+
#include <stddef.h>
+#include <stdio.h>
+#include <gutenprint/array.h>
+#include <gutenprint/curve.h>
+#include <gutenprint/gutenprint-version.h>
+#include <gutenprint/image.h>
+#include <gutenprint/paper.h>
+#include <gutenprint/printers.h>
+#include <gutenprint/sequence.h>
+#include <gutenprint/string-list.h>
+#include <gutenprint/util.h>
+#include <gutenprint/vars.h>
+

Detailed Description

+

Gutenprint master header.

+

This header includes all of the public headers.

+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/image_8h.html b/doc/gutenprint/html/image_8h.html new file mode 100644 index 0000000..1f729af --- /dev/null +++ b/doc/gutenprint/html/image_8h.html @@ -0,0 +1,111 @@ + + + + + + + +libgutenprint API Reference: include/gutenprint/image.h File Reference + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + + +
+
+
+Data Structures | +Macros | +Typedefs | +Enumerations | +Functions
+
+
image.h File Reference
+
+
+ +

Image functions. +More...

+ + + + + +

+Data Structures

struct  stp_image
 The image type is an abstract data type for interfacing with the image creation program. More...
 
+ + + +

+Macros

#define STP_CHANNEL_LIMIT   (64)
 
+ + + + +

+Typedefs

typedef struct stp_image stp_image_t
 The image type is an abstract data type for interfacing with the image creation program. More...
 
+ + + + +

+Enumerations

enum  stp_image_status_t { STP_IMAGE_STATUS_OK, +STP_IMAGE_STATUS_ABORT + }
 Image status. More...
 
+ + + + + + + + + + + + + + + +

+Functions

void stp_image_init (stp_image_t *image)
 
void stp_image_reset (stp_image_t *image)
 
int stp_image_width (stp_image_t *image)
 
int stp_image_height (stp_image_t *image)
 
stp_image_status_t stp_image_get_row (stp_image_t *image, unsigned char *data, size_t limit, int row)
 
const char * stp_image_get_appname (stp_image_t *image)
 
void stp_image_conclude (stp_image_t *image)
 
+

Detailed Description

+

Image functions.

+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/index.html b/doc/gutenprint/html/index.html new file mode 100644 index 0000000..4c66344 --- /dev/null +++ b/doc/gutenprint/html/index.html @@ -0,0 +1,53 @@ + + + + + + + +libgutenprint API Reference: Main Page + + + + + + +
+
+ + + + + + +
+
libgutenprint API Reference +  5.2.13 +
+
+
+ + + + + + +
+
+
+
libgutenprint API Reference Documentation
+
+
+
+ +
+Generated by   +doxygen + 1.8.13 +
+ + diff --git a/doc/gutenprint/html/jquery.js b/doc/gutenprint/html/jquery.js new file mode 100644 index 0000000..f5343ed --- /dev/null +++ b/doc/gutenprint/html/jquery.js @@ -0,0 +1,87 @@ +/*! + * jQuery JavaScript Library v1.7.1 + * http://jquery.com/ + * + * Copyright 2011, John Resig + * Dual licensed under the MIT or GPL Version 2 licenses. + * http://jquery.org/license + * + * Includes Sizzle.js + * http://sizzlejs.com/ + * Copyright 2011, The Dojo Foundation + * Released under the MIT, BSD, and GPL Licenses. + * + * Date: Mon Nov 21 21:11:03 2011 -0500 + */ +(function(bb,L){var av=bb.document,bu=bb.navigator,bl=bb.location;var b=(function(){var bF=function(b0,b1){return new bF.fn.init(b0,b1,bD)},bU=bb.jQuery,bH=bb.$,bD,bY=/^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,bM=/\S/,bI=/^\s+/,bE=/\s+$/,bA=/^<(\w+)\s*\/?>(?:<\/\1>)?$/,bN=/^[\],:{}\s]*$/,bW=/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,bP=/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,bJ=/(?:^|:|,)(?:\s*\[)+/g,by=/(webkit)[ \/]([\w.]+)/,bR=/(opera)(?:.*version)?[ \/]([\w.]+)/,bQ=/(msie) ([\w.]+)/,bS=/(mozilla)(?:.*? rv:([\w.]+))?/,bB=/-([a-z]|[0-9])/ig,bZ=/^-ms-/,bT=function(b0,b1){return(b1+"").toUpperCase()},bX=bu.userAgent,bV,bC,e,bL=Object.prototype.toString,bG=Object.prototype.hasOwnProperty,bz=Array.prototype.push,bK=Array.prototype.slice,bO=String.prototype.trim,bv=Array.prototype.indexOf,bx={};bF.fn=bF.prototype={constructor:bF,init:function(b0,b4,b3){var b2,b5,b1,b6;if(!b0){return this}if(b0.nodeType){this.context=this[0]=b0;this.length=1;return this}if(b0==="body"&&!b4&&av.body){this.context=av;this[0]=av.body;this.selector=b0;this.length=1;return this}if(typeof b0==="string"){if(b0.charAt(0)==="<"&&b0.charAt(b0.length-1)===">"&&b0.length>=3){b2=[null,b0,null]}else{b2=bY.exec(b0)}if(b2&&(b2[1]||!b4)){if(b2[1]){b4=b4 instanceof bF?b4[0]:b4;b6=(b4?b4.ownerDocument||b4:av);b1=bA.exec(b0);if(b1){if(bF.isPlainObject(b4)){b0=[av.createElement(b1[1])];bF.fn.attr.call(b0,b4,true)}else{b0=[b6.createElement(b1[1])]}}else{b1=bF.buildFragment([b2[1]],[b6]);b0=(b1.cacheable?bF.clone(b1.fragment):b1.fragment).childNodes}return bF.merge(this,b0)}else{b5=av.getElementById(b2[2]);if(b5&&b5.parentNode){if(b5.id!==b2[2]){return b3.find(b0)}this.length=1;this[0]=b5}this.context=av;this.selector=b0;return this}}else{if(!b4||b4.jquery){return(b4||b3).find(b0)}else{return this.constructor(b4).find(b0)}}}else{if(bF.isFunction(b0)){return b3.ready(b0)}}if(b0.selector!==L){this.selector=b0.selector;this.context=b0.context}return bF.makeArray(b0,this)},selector:"",jquery:"1.7.1",length:0,size:function(){return this.length},toArray:function(){return bK.call(this,0)},get:function(b0){return b0==null?this.toArray():(b0<0?this[this.length+b0]:this[b0])},pushStack:function(b1,b3,b0){var b2=this.constructor();if(bF.isArray(b1)){bz.apply(b2,b1)}else{bF.merge(b2,b1)}b2.prevObject=this;b2.context=this.context;if(b3==="find"){b2.selector=this.selector+(this.selector?" ":"")+b0}else{if(b3){b2.selector=this.selector+"."+b3+"("+b0+")"}}return b2},each:function(b1,b0){return bF.each(this,b1,b0)},ready:function(b0){bF.bindReady();bC.add(b0);return this},eq:function(b0){b0=+b0;return b0===-1?this.slice(b0):this.slice(b0,b0+1)},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},slice:function(){return this.pushStack(bK.apply(this,arguments),"slice",bK.call(arguments).join(","))},map:function(b0){return this.pushStack(bF.map(this,function(b2,b1){return b0.call(b2,b1,b2)}))},end:function(){return this.prevObject||this.constructor(null)},push:bz,sort:[].sort,splice:[].splice};bF.fn.init.prototype=bF.fn;bF.extend=bF.fn.extend=function(){var b9,b2,b0,b1,b6,b7,b5=arguments[0]||{},b4=1,b3=arguments.length,b8=false;if(typeof b5==="boolean"){b8=b5;b5=arguments[1]||{};b4=2}if(typeof b5!=="object"&&!bF.isFunction(b5)){b5={}}if(b3===b4){b5=this;--b4}for(;b40){return}bC.fireWith(av,[bF]);if(bF.fn.trigger){bF(av).trigger("ready").off("ready")}}},bindReady:function(){if(bC){return}bC=bF.Callbacks("once memory");if(av.readyState==="complete"){return setTimeout(bF.ready,1)}if(av.addEventListener){av.addEventListener("DOMContentLoaded",e,false);bb.addEventListener("load",bF.ready,false)}else{if(av.attachEvent){av.attachEvent("onreadystatechange",e);bb.attachEvent("onload",bF.ready);var b0=false;try{b0=bb.frameElement==null}catch(b1){}if(av.documentElement.doScroll&&b0){bw()}}}},isFunction:function(b0){return bF.type(b0)==="function"},isArray:Array.isArray||function(b0){return bF.type(b0)==="array"},isWindow:function(b0){return b0&&typeof b0==="object"&&"setInterval" in b0},isNumeric:function(b0){return !isNaN(parseFloat(b0))&&isFinite(b0)},type:function(b0){return b0==null?String(b0):bx[bL.call(b0)]||"object"},isPlainObject:function(b2){if(!b2||bF.type(b2)!=="object"||b2.nodeType||bF.isWindow(b2)){return false}try{if(b2.constructor&&!bG.call(b2,"constructor")&&!bG.call(b2.constructor.prototype,"isPrototypeOf")){return false}}catch(b1){return false}var b0;for(b0 in b2){}return b0===L||bG.call(b2,b0)},isEmptyObject:function(b1){for(var b0 in b1){return false}return true},error:function(b0){throw new Error(b0)},parseJSON:function(b0){if(typeof b0!=="string"||!b0){return null}b0=bF.trim(b0);if(bb.JSON&&bb.JSON.parse){return bb.JSON.parse(b0)}if(bN.test(b0.replace(bW,"@").replace(bP,"]").replace(bJ,""))){return(new Function("return "+b0))()}bF.error("Invalid JSON: "+b0)},parseXML:function(b2){var b0,b1;try{if(bb.DOMParser){b1=new DOMParser();b0=b1.parseFromString(b2,"text/xml")}else{b0=new ActiveXObject("Microsoft.XMLDOM");b0.async="false";b0.loadXML(b2)}}catch(b3){b0=L}if(!b0||!b0.documentElement||b0.getElementsByTagName("parsererror").length){bF.error("Invalid XML: "+b2)}return b0},noop:function(){},globalEval:function(b0){if(b0&&bM.test(b0)){(bb.execScript||function(b1){bb["eval"].call(bb,b1)})(b0)}},camelCase:function(b0){return b0.replace(bZ,"ms-").replace(bB,bT)},nodeName:function(b1,b0){return b1.nodeName&&b1.nodeName.toUpperCase()===b0.toUpperCase()},each:function(b3,b6,b2){var b1,b4=0,b5=b3.length,b0=b5===L||bF.isFunction(b3);if(b2){if(b0){for(b1 in b3){if(b6.apply(b3[b1],b2)===false){break}}}else{for(;b40&&b0[0]&&b0[b1-1])||b1===0||bF.isArray(b0));if(b3){for(;b21?aJ.call(arguments,0):bG;if(!(--bw)){bC.resolveWith(bC,bx)}}}function bz(bF){return function(bG){bB[bF]=arguments.length>1?aJ.call(arguments,0):bG;bC.notifyWith(bE,bB)}}if(e>1){for(;bv
a";bI=bv.getElementsByTagName("*");bF=bv.getElementsByTagName("a")[0];if(!bI||!bI.length||!bF){return{}}bG=av.createElement("select");bx=bG.appendChild(av.createElement("option"));bE=bv.getElementsByTagName("input")[0];bJ={leadingWhitespace:(bv.firstChild.nodeType===3),tbody:!bv.getElementsByTagName("tbody").length,htmlSerialize:!!bv.getElementsByTagName("link").length,style:/top/.test(bF.getAttribute("style")),hrefNormalized:(bF.getAttribute("href")==="/a"),opacity:/^0.55/.test(bF.style.opacity),cssFloat:!!bF.style.cssFloat,checkOn:(bE.value==="on"),optSelected:bx.selected,getSetAttribute:bv.className!=="t",enctype:!!av.createElement("form").enctype,html5Clone:av.createElement("nav").cloneNode(true).outerHTML!=="<:nav>",submitBubbles:true,changeBubbles:true,focusinBubbles:false,deleteExpando:true,noCloneEvent:true,inlineBlockNeedsLayout:false,shrinkWrapBlocks:false,reliableMarginRight:true};bE.checked=true;bJ.noCloneChecked=bE.cloneNode(true).checked;bG.disabled=true;bJ.optDisabled=!bx.disabled;try{delete bv.test}catch(bC){bJ.deleteExpando=false}if(!bv.addEventListener&&bv.attachEvent&&bv.fireEvent){bv.attachEvent("onclick",function(){bJ.noCloneEvent=false});bv.cloneNode(true).fireEvent("onclick")}bE=av.createElement("input");bE.value="t";bE.setAttribute("type","radio");bJ.radioValue=bE.value==="t";bE.setAttribute("checked","checked");bv.appendChild(bE);bD=av.createDocumentFragment();bD.appendChild(bv.lastChild);bJ.checkClone=bD.cloneNode(true).cloneNode(true).lastChild.checked;bJ.appendChecked=bE.checked;bD.removeChild(bE);bD.appendChild(bv);bv.innerHTML="";if(bb.getComputedStyle){bA=av.createElement("div");bA.style.width="0";bA.style.marginRight="0";bv.style.width="2px";bv.appendChild(bA);bJ.reliableMarginRight=(parseInt((bb.getComputedStyle(bA,null)||{marginRight:0}).marginRight,10)||0)===0}if(bv.attachEvent){for(by in {submit:1,change:1,focusin:1}){bB="on"+by;bw=(bB in bv);if(!bw){bv.setAttribute(bB,"return;");bw=(typeof bv[bB]==="function")}bJ[by+"Bubbles"]=bw}}bD.removeChild(bv);bD=bG=bx=bA=bv=bE=null;b(function(){var bM,bU,bV,bT,bN,bO,bL,bS,bR,e,bP,bQ=av.getElementsByTagName("body")[0];if(!bQ){return}bL=1;bS="position:absolute;top:0;left:0;width:1px;height:1px;margin:0;";bR="visibility:hidden;border:0;";e="style='"+bS+"border:5px solid #000;padding:0;'";bP="
";bM=av.createElement("div");bM.style.cssText=bR+"width:0;height:0;position:static;top:0;margin-top:"+bL+"px";bQ.insertBefore(bM,bQ.firstChild);bv=av.createElement("div");bM.appendChild(bv);bv.innerHTML="
t
";bz=bv.getElementsByTagName("td");bw=(bz[0].offsetHeight===0);bz[0].style.display="";bz[1].style.display="none";bJ.reliableHiddenOffsets=bw&&(bz[0].offsetHeight===0);bv.innerHTML="";bv.style.width=bv.style.paddingLeft="1px";b.boxModel=bJ.boxModel=bv.offsetWidth===2;if(typeof bv.style.zoom!=="undefined"){bv.style.display="inline";bv.style.zoom=1;bJ.inlineBlockNeedsLayout=(bv.offsetWidth===2);bv.style.display="";bv.innerHTML="
";bJ.shrinkWrapBlocks=(bv.offsetWidth!==2)}bv.style.cssText=bS+bR;bv.innerHTML=bP;bU=bv.firstChild;bV=bU.firstChild;bN=bU.nextSibling.firstChild.firstChild;bO={doesNotAddBorder:(bV.offsetTop!==5),doesAddBorderForTableAndCells:(bN.offsetTop===5)};bV.style.position="fixed";bV.style.top="20px";bO.fixedPosition=(bV.offsetTop===20||bV.offsetTop===15);bV.style.position=bV.style.top="";bU.style.overflow="hidden";bU.style.position="relative";bO.subtractsBorderForOverflowNotVisible=(bV.offsetTop===-5);bO.doesNotIncludeMarginInBodyOffset=(bQ.offsetTop!==bL);bQ.removeChild(bM);bv=bM=null;b.extend(bJ,bO)});return bJ})();var aS=/^(?:\{.*\}|\[.*\])$/,aA=/([A-Z])/g;b.extend({cache:{},uuid:0,expando:"jQuery"+(b.fn.jquery+Math.random()).replace(/\D/g,""),noData:{embed:true,object:"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",applet:true},hasData:function(e){e=e.nodeType?b.cache[e[b.expando]]:e[b.expando];return !!e&&!S(e)},data:function(bx,bv,bz,by){if(!b.acceptData(bx)){return}var bG,bA,bD,bE=b.expando,bC=typeof bv==="string",bF=bx.nodeType,e=bF?b.cache:bx,bw=bF?bx[bE]:bx[bE]&&bE,bB=bv==="events";if((!bw||!e[bw]||(!bB&&!by&&!e[bw].data))&&bC&&bz===L){return}if(!bw){if(bF){bx[bE]=bw=++b.uuid}else{bw=bE}}if(!e[bw]){e[bw]={};if(!bF){e[bw].toJSON=b.noop}}if(typeof bv==="object"||typeof bv==="function"){if(by){e[bw]=b.extend(e[bw],bv)}else{e[bw].data=b.extend(e[bw].data,bv)}}bG=bA=e[bw];if(!by){if(!bA.data){bA.data={}}bA=bA.data}if(bz!==L){bA[b.camelCase(bv)]=bz}if(bB&&!bA[bv]){return bG.events}if(bC){bD=bA[bv];if(bD==null){bD=bA[b.camelCase(bv)]}}else{bD=bA}return bD},removeData:function(bx,bv,by){if(!b.acceptData(bx)){return}var bB,bA,bz,bC=b.expando,bD=bx.nodeType,e=bD?b.cache:bx,bw=bD?bx[bC]:bC;if(!e[bw]){return}if(bv){bB=by?e[bw]:e[bw].data;if(bB){if(!b.isArray(bv)){if(bv in bB){bv=[bv]}else{bv=b.camelCase(bv);if(bv in bB){bv=[bv]}else{bv=bv.split(" ")}}}for(bA=0,bz=bv.length;bA-1){return true}}return false},val:function(bx){var e,bv,by,bw=this[0];if(!arguments.length){if(bw){e=b.valHooks[bw.nodeName.toLowerCase()]||b.valHooks[bw.type];if(e&&"get" in e&&(bv=e.get(bw,"value"))!==L){return bv}bv=bw.value;return typeof bv==="string"?bv.replace(aU,""):bv==null?"":bv}return}by=b.isFunction(bx);return this.each(function(bA){var bz=b(this),bB;if(this.nodeType!==1){return}if(by){bB=bx.call(this,bA,bz.val())}else{bB=bx}if(bB==null){bB=""}else{if(typeof bB==="number"){bB+=""}else{if(b.isArray(bB)){bB=b.map(bB,function(bC){return bC==null?"":bC+""})}}}e=b.valHooks[this.nodeName.toLowerCase()]||b.valHooks[this.type];if(!e||!("set" in e)||e.set(this,bB,"value")===L){this.value=bB}})}});b.extend({valHooks:{option:{get:function(e){var bv=e.attributes.value;return !bv||bv.specified?e.value:e.text}},select:{get:function(e){var bA,bv,bz,bx,by=e.selectedIndex,bB=[],bC=e.options,bw=e.type==="select-one";if(by<0){return null}bv=bw?by:0;bz=bw?by+1:bC.length;for(;bv=0});if(!e.length){bv.selectedIndex=-1}return e}}},attrFn:{val:true,css:true,html:true,text:true,data:true,width:true,height:true,offset:true},attr:function(bA,bx,bB,bz){var bw,e,by,bv=bA.nodeType;if(!bA||bv===3||bv===8||bv===2){return}if(bz&&bx in b.attrFn){return b(bA)[bx](bB)}if(typeof bA.getAttribute==="undefined"){return b.prop(bA,bx,bB)}by=bv!==1||!b.isXMLDoc(bA);if(by){bx=bx.toLowerCase();e=b.attrHooks[bx]||(ao.test(bx)?aY:be)}if(bB!==L){if(bB===null){b.removeAttr(bA,bx);return}else{if(e&&"set" in e&&by&&(bw=e.set(bA,bB,bx))!==L){return bw}else{bA.setAttribute(bx,""+bB);return bB}}}else{if(e&&"get" in e&&by&&(bw=e.get(bA,bx))!==null){return bw}else{bw=bA.getAttribute(bx);return bw===null?L:bw}}},removeAttr:function(bx,bz){var by,bA,bv,e,bw=0;if(bz&&bx.nodeType===1){bA=bz.toLowerCase().split(af);e=bA.length;for(;bw=0)}}})});var bd=/^(?:textarea|input|select)$/i,n=/^([^\.]*)?(?:\.(.+))?$/,J=/\bhover(\.\S+)?\b/,aO=/^key/,bf=/^(?:mouse|contextmenu)|click/,T=/^(?:focusinfocus|focusoutblur)$/,U=/^(\w*)(?:#([\w\-]+))?(?:\.([\w\-]+))?$/,Y=function(e){var bv=U.exec(e);if(bv){bv[1]=(bv[1]||"").toLowerCase();bv[3]=bv[3]&&new RegExp("(?:^|\\s)"+bv[3]+"(?:\\s|$)")}return bv},j=function(bw,e){var bv=bw.attributes||{};return((!e[1]||bw.nodeName.toLowerCase()===e[1])&&(!e[2]||(bv.id||{}).value===e[2])&&(!e[3]||e[3].test((bv["class"]||{}).value)))},bt=function(e){return b.event.special.hover?e:e.replace(J,"mouseenter$1 mouseleave$1")};b.event={add:function(bx,bC,bJ,bA,by){var bD,bB,bK,bI,bH,bF,e,bG,bv,bz,bw,bE;if(bx.nodeType===3||bx.nodeType===8||!bC||!bJ||!(bD=b._data(bx))){return}if(bJ.handler){bv=bJ;bJ=bv.handler}if(!bJ.guid){bJ.guid=b.guid++}bK=bD.events;if(!bK){bD.events=bK={}}bB=bD.handle;if(!bB){bD.handle=bB=function(bL){return typeof b!=="undefined"&&(!bL||b.event.triggered!==bL.type)?b.event.dispatch.apply(bB.elem,arguments):L};bB.elem=bx}bC=b.trim(bt(bC)).split(" ");for(bI=0;bI=0){bG=bG.slice(0,-1);bw=true}if(bG.indexOf(".")>=0){bx=bG.split(".");bG=bx.shift();bx.sort()}if((!bA||b.event.customEvent[bG])&&!b.event.global[bG]){return}bv=typeof bv==="object"?bv[b.expando]?bv:new b.Event(bG,bv):new b.Event(bG);bv.type=bG;bv.isTrigger=true;bv.exclusive=bw;bv.namespace=bx.join(".");bv.namespace_re=bv.namespace?new RegExp("(^|\\.)"+bx.join("\\.(?:.*\\.)?")+"(\\.|$)"):null;by=bG.indexOf(":")<0?"on"+bG:"";if(!bA){e=b.cache;for(bC in e){if(e[bC].events&&e[bC].events[bG]){b.event.trigger(bv,bD,e[bC].handle.elem,true)}}return}bv.result=L;if(!bv.target){bv.target=bA}bD=bD!=null?b.makeArray(bD):[];bD.unshift(bv);bF=b.event.special[bG]||{};if(bF.trigger&&bF.trigger.apply(bA,bD)===false){return}bB=[[bA,bF.bindType||bG]];if(!bJ&&!bF.noBubble&&!b.isWindow(bA)){bI=bF.delegateType||bG;bH=T.test(bI+bG)?bA:bA.parentNode;bz=null;for(;bH;bH=bH.parentNode){bB.push([bH,bI]);bz=bH}if(bz&&bz===bA.ownerDocument){bB.push([bz.defaultView||bz.parentWindow||bb,bI])}}for(bC=0;bCbA){bH.push({elem:this,matches:bz.slice(bA)})}for(bC=0;bC0?this.on(e,null,bx,bw):this.trigger(e)};if(b.attrFn){b.attrFn[e]=true}if(aO.test(e)){b.event.fixHooks[e]=b.event.keyHooks}if(bf.test(e)){b.event.fixHooks[e]=b.event.mouseHooks}}); +/*! + * Sizzle CSS Selector Engine + * Copyright 2011, The Dojo Foundation + * Released under the MIT, BSD, and GPL Licenses. + * More information: http://sizzlejs.com/ + */ +(function(){var bH=/((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,bC="sizcache"+(Math.random()+"").replace(".",""),bI=0,bL=Object.prototype.toString,bB=false,bA=true,bK=/\\/g,bO=/\r\n/g,bQ=/\W/;[0,0].sort(function(){bA=false;return 0});var by=function(bV,e,bY,bZ){bY=bY||[];e=e||av;var b1=e;if(e.nodeType!==1&&e.nodeType!==9){return[]}if(!bV||typeof bV!=="string"){return bY}var bS,b3,b6,bR,b2,b5,b4,bX,bU=true,bT=by.isXML(e),bW=[],b0=bV;do{bH.exec("");bS=bH.exec(b0);if(bS){b0=bS[3];bW.push(bS[1]);if(bS[2]){bR=bS[3];break}}}while(bS);if(bW.length>1&&bD.exec(bV)){if(bW.length===2&&bE.relative[bW[0]]){b3=bM(bW[0]+bW[1],e,bZ)}else{b3=bE.relative[bW[0]]?[e]:by(bW.shift(),e);while(bW.length){bV=bW.shift();if(bE.relative[bV]){bV+=bW.shift()}b3=bM(bV,b3,bZ)}}}else{if(!bZ&&bW.length>1&&e.nodeType===9&&!bT&&bE.match.ID.test(bW[0])&&!bE.match.ID.test(bW[bW.length-1])){b2=by.find(bW.shift(),e,bT);e=b2.expr?by.filter(b2.expr,b2.set)[0]:b2.set[0]}if(e){b2=bZ?{expr:bW.pop(),set:bF(bZ)}:by.find(bW.pop(),bW.length===1&&(bW[0]==="~"||bW[0]==="+")&&e.parentNode?e.parentNode:e,bT);b3=b2.expr?by.filter(b2.expr,b2.set):b2.set;if(bW.length>0){b6=bF(b3)}else{bU=false}while(bW.length){b5=bW.pop();b4=b5;if(!bE.relative[b5]){b5=""}else{b4=bW.pop()}if(b4==null){b4=e}bE.relative[b5](b6,b4,bT)}}else{b6=bW=[]}}if(!b6){b6=b3}if(!b6){by.error(b5||bV)}if(bL.call(b6)==="[object Array]"){if(!bU){bY.push.apply(bY,b6)}else{if(e&&e.nodeType===1){for(bX=0;b6[bX]!=null;bX++){if(b6[bX]&&(b6[bX]===true||b6[bX].nodeType===1&&by.contains(e,b6[bX]))){bY.push(b3[bX])}}}else{for(bX=0;b6[bX]!=null;bX++){if(b6[bX]&&b6[bX].nodeType===1){bY.push(b3[bX])}}}}}else{bF(b6,bY)}if(bR){by(bR,b1,bY,bZ);by.uniqueSort(bY)}return bY};by.uniqueSort=function(bR){if(bJ){bB=bA;bR.sort(bJ);if(bB){for(var e=1;e0};by.find=function(bX,e,bY){var bW,bS,bU,bT,bV,bR;if(!bX){return[]}for(bS=0,bU=bE.order.length;bS":function(bW,bR){var bV,bU=typeof bR==="string",bS=0,e=bW.length;if(bU&&!bQ.test(bR)){bR=bR.toLowerCase();for(;bS=0)){if(!bS){e.push(bV)}}else{if(bS){bR[bU]=false}}}}return false},ID:function(e){return e[1].replace(bK,"")},TAG:function(bR,e){return bR[1].replace(bK,"").toLowerCase()},CHILD:function(e){if(e[1]==="nth"){if(!e[2]){by.error(e[0])}e[2]=e[2].replace(/^\+|\s*/g,"");var bR=/(-?)(\d*)(?:n([+\-]?\d*))?/.exec(e[2]==="even"&&"2n"||e[2]==="odd"&&"2n+1"||!/\D/.test(e[2])&&"0n+"+e[2]||e[2]);e[2]=(bR[1]+(bR[2]||1))-0;e[3]=bR[3]-0}else{if(e[2]){by.error(e[0])}}e[0]=bI++;return e},ATTR:function(bU,bR,bS,e,bV,bW){var bT=bU[1]=bU[1].replace(bK,"");if(!bW&&bE.attrMap[bT]){bU[1]=bE.attrMap[bT]}bU[4]=(bU[4]||bU[5]||"").replace(bK,"");if(bU[2]==="~="){bU[4]=" "+bU[4]+" "}return bU},PSEUDO:function(bU,bR,bS,e,bV){if(bU[1]==="not"){if((bH.exec(bU[3])||"").length>1||/^\w/.test(bU[3])){bU[3]=by(bU[3],null,null,bR)}else{var bT=by.filter(bU[3],bR,bS,true^bV);if(!bS){e.push.apply(e,bT)}return false}}else{if(bE.match.POS.test(bU[0])||bE.match.CHILD.test(bU[0])){return true}}return bU},POS:function(e){e.unshift(true);return e}},filters:{enabled:function(e){return e.disabled===false&&e.type!=="hidden"},disabled:function(e){return e.disabled===true},checked:function(e){return e.checked===true},selected:function(e){if(e.parentNode){e.parentNode.selectedIndex}return e.selected===true},parent:function(e){return !!e.firstChild},empty:function(e){return !e.firstChild},has:function(bS,bR,e){return !!by(e[3],bS).length},header:function(e){return(/h\d/i).test(e.nodeName)},text:function(bS){var e=bS.getAttribute("type"),bR=bS.type;return bS.nodeName.toLowerCase()==="input"&&"text"===bR&&(e===bR||e===null)},radio:function(e){return e.nodeName.toLowerCase()==="input"&&"radio"===e.type},checkbox:function(e){return e.nodeName.toLowerCase()==="input"&&"checkbox"===e.type},file:function(e){return e.nodeName.toLowerCase()==="input"&&"file"===e.type},password:function(e){return e.nodeName.toLowerCase()==="input"&&"password"===e.type},submit:function(bR){var e=bR.nodeName.toLowerCase();return(e==="input"||e==="button")&&"submit"===bR.type},image:function(e){return e.nodeName.toLowerCase()==="input"&&"image"===e.type},reset:function(bR){var e=bR.nodeName.toLowerCase();return(e==="input"||e==="button")&&"reset"===bR.type},button:function(bR){var e=bR.nodeName.toLowerCase();return e==="input"&&"button"===bR.type||e==="button"},input:function(e){return(/input|select|textarea|button/i).test(e.nodeName)},focus:function(e){return e===e.ownerDocument.activeElement}},setFilters:{first:function(bR,e){return e===0},last:function(bS,bR,e,bT){return bR===bT.length-1},even:function(bR,e){return e%2===0},odd:function(bR,e){return e%2===1},lt:function(bS,bR,e){return bRe[3]-0},nth:function(bS,bR,e){return e[3]-0===bR},eq:function(bS,bR,e){return e[3]-0===bR}},filter:{PSEUDO:function(bS,bX,bW,bY){var e=bX[1],bR=bE.filters[e];if(bR){return bR(bS,bW,bX,bY)}else{if(e==="contains"){return(bS.textContent||bS.innerText||bw([bS])||"").indexOf(bX[3])>=0}else{if(e==="not"){var bT=bX[3];for(var bV=0,bU=bT.length;bV=0)}}},ID:function(bR,e){return bR.nodeType===1&&bR.getAttribute("id")===e},TAG:function(bR,e){return(e==="*"&&bR.nodeType===1)||!!bR.nodeName&&bR.nodeName.toLowerCase()===e},CLASS:function(bR,e){return(" "+(bR.className||bR.getAttribute("class"))+" ").indexOf(e)>-1},ATTR:function(bV,bT){var bS=bT[1],e=by.attr?by.attr(bV,bS):bE.attrHandle[bS]?bE.attrHandle[bS](bV):bV[bS]!=null?bV[bS]:bV.getAttribute(bS),bW=e+"",bU=bT[2],bR=bT[4];return e==null?bU==="!=":!bU&&by.attr?e!=null:bU==="="?bW===bR:bU==="*="?bW.indexOf(bR)>=0:bU==="~="?(" "+bW+" ").indexOf(bR)>=0:!bR?bW&&e!==false:bU==="!="?bW!==bR:bU==="^="?bW.indexOf(bR)===0:bU==="$="?bW.substr(bW.length-bR.length)===bR:bU==="|="?bW===bR||bW.substr(0,bR.length+1)===bR+"-":false},POS:function(bU,bR,bS,bV){var e=bR[2],bT=bE.setFilters[e];if(bT){return bT(bU,bS,bR,bV)}}}};var bD=bE.match.POS,bx=function(bR,e){return"\\"+(e-0+1)};for(var bz in bE.match){bE.match[bz]=new RegExp(bE.match[bz].source+(/(?![^\[]*\])(?![^\(]*\))/.source));bE.leftMatch[bz]=new RegExp(/(^(?:.|\r|\n)*?)/.source+bE.match[bz].source.replace(/\\(\d+)/g,bx))}var bF=function(bR,e){bR=Array.prototype.slice.call(bR,0);if(e){e.push.apply(e,bR);return e}return bR};try{Array.prototype.slice.call(av.documentElement.childNodes,0)[0].nodeType}catch(bP){bF=function(bU,bT){var bS=0,bR=bT||[];if(bL.call(bU)==="[object Array]"){Array.prototype.push.apply(bR,bU)}else{if(typeof bU.length==="number"){for(var e=bU.length;bS";e.insertBefore(bR,e.firstChild);if(av.getElementById(bS)){bE.find.ID=function(bU,bV,bW){if(typeof bV.getElementById!=="undefined"&&!bW){var bT=bV.getElementById(bU[1]);return bT?bT.id===bU[1]||typeof bT.getAttributeNode!=="undefined"&&bT.getAttributeNode("id").nodeValue===bU[1]?[bT]:L:[]}};bE.filter.ID=function(bV,bT){var bU=typeof bV.getAttributeNode!=="undefined"&&bV.getAttributeNode("id");return bV.nodeType===1&&bU&&bU.nodeValue===bT}}e.removeChild(bR);e=bR=null})();(function(){var e=av.createElement("div");e.appendChild(av.createComment(""));if(e.getElementsByTagName("*").length>0){bE.find.TAG=function(bR,bV){var bU=bV.getElementsByTagName(bR[1]);if(bR[1]==="*"){var bT=[];for(var bS=0;bU[bS];bS++){if(bU[bS].nodeType===1){bT.push(bU[bS])}}bU=bT}return bU}}e.innerHTML="";if(e.firstChild&&typeof e.firstChild.getAttribute!=="undefined"&&e.firstChild.getAttribute("href")!=="#"){bE.attrHandle.href=function(bR){return bR.getAttribute("href",2)}}e=null})();if(av.querySelectorAll){(function(){var e=by,bT=av.createElement("div"),bS="__sizzle__";bT.innerHTML="

";if(bT.querySelectorAll&&bT.querySelectorAll(".TEST").length===0){return}by=function(b4,bV,bZ,b3){bV=bV||av;if(!b3&&!by.isXML(bV)){var b2=/^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec(b4);if(b2&&(bV.nodeType===1||bV.nodeType===9)){if(b2[1]){return bF(bV.getElementsByTagName(b4),bZ)}else{if(b2[2]&&bE.find.CLASS&&bV.getElementsByClassName){return bF(bV.getElementsByClassName(b2[2]),bZ)}}}if(bV.nodeType===9){if(b4==="body"&&bV.body){return bF([bV.body],bZ)}else{if(b2&&b2[3]){var bY=bV.getElementById(b2[3]);if(bY&&bY.parentNode){if(bY.id===b2[3]){return bF([bY],bZ)}}else{return bF([],bZ)}}}try{return bF(bV.querySelectorAll(b4),bZ)}catch(b0){}}else{if(bV.nodeType===1&&bV.nodeName.toLowerCase()!=="object"){var bW=bV,bX=bV.getAttribute("id"),bU=bX||bS,b6=bV.parentNode,b5=/^\s*[+~]/.test(b4);if(!bX){bV.setAttribute("id",bU)}else{bU=bU.replace(/'/g,"\\$&")}if(b5&&b6){bV=bV.parentNode}try{if(!b5||b6){return bF(bV.querySelectorAll("[id='"+bU+"'] "+b4),bZ)}}catch(b1){}finally{if(!bX){bW.removeAttribute("id")}}}}}return e(b4,bV,bZ,b3)};for(var bR in e){by[bR]=e[bR]}bT=null})()}(function(){var e=av.documentElement,bS=e.matchesSelector||e.mozMatchesSelector||e.webkitMatchesSelector||e.msMatchesSelector;if(bS){var bU=!bS.call(av.createElement("div"),"div"),bR=false;try{bS.call(av.documentElement,"[test!='']:sizzle")}catch(bT){bR=true}by.matchesSelector=function(bW,bY){bY=bY.replace(/\=\s*([^'"\]]*)\s*\]/g,"='$1']");if(!by.isXML(bW)){try{if(bR||!bE.match.PSEUDO.test(bY)&&!/!=/.test(bY)){var bV=bS.call(bW,bY);if(bV||!bU||bW.document&&bW.document.nodeType!==11){return bV}}}catch(bX){}}return by(bY,null,null,[bW]).length>0}}})();(function(){var e=av.createElement("div");e.innerHTML="
";if(!e.getElementsByClassName||e.getElementsByClassName("e").length===0){return}e.lastChild.className="e";if(e.getElementsByClassName("e").length===1){return}bE.order.splice(1,0,"CLASS");bE.find.CLASS=function(bR,bS,bT){if(typeof bS.getElementsByClassName!=="undefined"&&!bT){return bS.getElementsByClassName(bR[1])}};e=null})();function bv(bR,bW,bV,bZ,bX,bY){for(var bT=0,bS=bZ.length;bT0){bU=e;break}}}e=e[bR]}bZ[bT]=bU}}}if(av.documentElement.contains){by.contains=function(bR,e){return bR!==e&&(bR.contains?bR.contains(e):true)}}else{if(av.documentElement.compareDocumentPosition){by.contains=function(bR,e){return !!(bR.compareDocumentPosition(e)&16)}}else{by.contains=function(){return false}}}by.isXML=function(e){var bR=(e?e.ownerDocument||e:0).documentElement;return bR?bR.nodeName!=="HTML":false};var bM=function(bS,e,bW){var bV,bX=[],bU="",bY=e.nodeType?[e]:e;while((bV=bE.match.PSEUDO.exec(bS))){bU+=bV[0];bS=bS.replace(bE.match.PSEUDO,"")}bS=bE.relative[bS]?bS+"*":bS;for(var bT=0,bR=bY.length;bT0){for(bB=bA;bB=0:b.filter(e,this).length>0:this.filter(e).length>0)},closest:function(by,bx){var bv=[],bw,e,bz=this[0];if(b.isArray(by)){var bB=1;while(bz&&bz.ownerDocument&&bz!==bx){for(bw=0;bw-1:b.find.matchesSelector(bz,by)){bv.push(bz);break}else{bz=bz.parentNode;if(!bz||!bz.ownerDocument||bz===bx||bz.nodeType===11){break}}}}bv=bv.length>1?b.unique(bv):bv;return this.pushStack(bv,"closest",by)},index:function(e){if(!e){return(this[0]&&this[0].parentNode)?this.prevAll().length:-1}if(typeof e==="string"){return b.inArray(this[0],b(e))}return b.inArray(e.jquery?e[0]:e,this)},add:function(e,bv){var bx=typeof e==="string"?b(e,bv):b.makeArray(e&&e.nodeType?[e]:e),bw=b.merge(this.get(),bx);return this.pushStack(C(bx[0])||C(bw[0])?bw:b.unique(bw))},andSelf:function(){return this.add(this.prevObject)}});function C(e){return !e||!e.parentNode||e.parentNode.nodeType===11}b.each({parent:function(bv){var e=bv.parentNode;return e&&e.nodeType!==11?e:null},parents:function(e){return b.dir(e,"parentNode")},parentsUntil:function(bv,e,bw){return b.dir(bv,"parentNode",bw)},next:function(e){return b.nth(e,2,"nextSibling")},prev:function(e){return b.nth(e,2,"previousSibling")},nextAll:function(e){return b.dir(e,"nextSibling")},prevAll:function(e){return b.dir(e,"previousSibling")},nextUntil:function(bv,e,bw){return b.dir(bv,"nextSibling",bw)},prevUntil:function(bv,e,bw){return b.dir(bv,"previousSibling",bw)},siblings:function(e){return b.sibling(e.parentNode.firstChild,e)},children:function(e){return b.sibling(e.firstChild)},contents:function(e){return b.nodeName(e,"iframe")?e.contentDocument||e.contentWindow.document:b.makeArray(e.childNodes)}},function(e,bv){b.fn[e]=function(by,bw){var bx=b.map(this,bv,by);if(!ab.test(e)){bw=by}if(bw&&typeof bw==="string"){bx=b.filter(bw,bx)}bx=this.length>1&&!ay[e]?b.unique(bx):bx;if((this.length>1||a9.test(bw))&&aq.test(e)){bx=bx.reverse()}return this.pushStack(bx,e,P.call(arguments).join(","))}});b.extend({filter:function(bw,e,bv){if(bv){bw=":not("+bw+")"}return e.length===1?b.find.matchesSelector(e[0],bw)?[e[0]]:[]:b.find.matches(bw,e)},dir:function(bw,bv,by){var e=[],bx=bw[bv];while(bx&&bx.nodeType!==9&&(by===L||bx.nodeType!==1||!b(bx).is(by))){if(bx.nodeType===1){e.push(bx)}bx=bx[bv]}return e},nth:function(by,e,bw,bx){e=e||1;var bv=0;for(;by;by=by[bw]){if(by.nodeType===1&&++bv===e){break}}return by},sibling:function(bw,bv){var e=[];for(;bw;bw=bw.nextSibling){if(bw.nodeType===1&&bw!==bv){e.push(bw)}}return e}});function aG(bx,bw,e){bw=bw||0;if(b.isFunction(bw)){return b.grep(bx,function(bz,by){var bA=!!bw.call(bz,by,bz);return bA===e})}else{if(bw.nodeType){return b.grep(bx,function(bz,by){return(bz===bw)===e})}else{if(typeof bw==="string"){var bv=b.grep(bx,function(by){return by.nodeType===1});if(bp.test(bw)){return b.filter(bw,bv,!e)}else{bw=b.filter(bw,bv)}}}}return b.grep(bx,function(bz,by){return(b.inArray(bz,bw)>=0)===e})}function a(e){var bw=aR.split("|"),bv=e.createDocumentFragment();if(bv.createElement){while(bw.length){bv.createElement(bw.pop())}}return bv}var aR="abbr|article|aside|audio|canvas|datalist|details|figcaption|figure|footer|header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",ag=/ jQuery\d+="(?:\d+|null)"/g,ar=/^\s+/,R=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,d=/<([\w:]+)/,w=/",""],legend:[1,"
","
"],thead:[1,"","
"],tr:[2,"","
"],td:[3,"","
"],col:[2,"","
"],area:[1,"",""],_default:[0,"",""]},ac=a(av);ax.optgroup=ax.option;ax.tbody=ax.tfoot=ax.colgroup=ax.caption=ax.thead;ax.th=ax.td;if(!b.support.htmlSerialize){ax._default=[1,"div
","
"]}b.fn.extend({text:function(e){if(b.isFunction(e)){return this.each(function(bw){var bv=b(this);bv.text(e.call(this,bw,bv.text()))})}if(typeof e!=="object"&&e!==L){return this.empty().append((this[0]&&this[0].ownerDocument||av).createTextNode(e))}return b.text(this)},wrapAll:function(e){if(b.isFunction(e)){return this.each(function(bw){b(this).wrapAll(e.call(this,bw))})}if(this[0]){var bv=b(e,this[0].ownerDocument).eq(0).clone(true);if(this[0].parentNode){bv.insertBefore(this[0])}bv.map(function(){var bw=this;while(bw.firstChild&&bw.firstChild.nodeType===1){bw=bw.firstChild}return bw}).append(this)}return this},wrapInner:function(e){if(b.isFunction(e)){return this.each(function(bv){b(this).wrapInner(e.call(this,bv))})}return this.each(function(){var bv=b(this),bw=bv.contents();if(bw.length){bw.wrapAll(e)}else{bv.append(e)}})},wrap:function(e){var bv=b.isFunction(e);return this.each(function(bw){b(this).wrapAll(bv?e.call(this,bw):e)})},unwrap:function(){return this.parent().each(function(){if(!b.nodeName(this,"body")){b(this).replaceWith(this.childNodes)}}).end()},append:function(){return this.domManip(arguments,true,function(e){if(this.nodeType===1){this.appendChild(e)}})},prepend:function(){return this.domManip(arguments,true,function(e){if(this.nodeType===1){this.insertBefore(e,this.firstChild)}})},before:function(){if(this[0]&&this[0].parentNode){return this.domManip(arguments,false,function(bv){this.parentNode.insertBefore(bv,this)})}else{if(arguments.length){var e=b.clean(arguments);e.push.apply(e,this.toArray());return this.pushStack(e,"before",arguments)}}},after:function(){if(this[0]&&this[0].parentNode){return this.domManip(arguments,false,function(bv){this.parentNode.insertBefore(bv,this.nextSibling)})}else{if(arguments.length){var e=this.pushStack(this,"after",arguments);e.push.apply(e,b.clean(arguments));return e}}},remove:function(e,bx){for(var bv=0,bw;(bw=this[bv])!=null;bv++){if(!e||b.filter(e,[bw]).length){if(!bx&&bw.nodeType===1){b.cleanData(bw.getElementsByTagName("*"));b.cleanData([bw])}if(bw.parentNode){bw.parentNode.removeChild(bw)}}}return this},empty:function(){for(var e=0,bv;(bv=this[e])!=null;e++){if(bv.nodeType===1){b.cleanData(bv.getElementsByTagName("*"))}while(bv.firstChild){bv.removeChild(bv.firstChild)}}return this},clone:function(bv,e){bv=bv==null?false:bv;e=e==null?bv:e;return this.map(function(){return b.clone(this,bv,e)})},html:function(bx){if(bx===L){return this[0]&&this[0].nodeType===1?this[0].innerHTML.replace(ag,""):null}else{if(typeof bx==="string"&&!ae.test(bx)&&(b.support.leadingWhitespace||!ar.test(bx))&&!ax[(d.exec(bx)||["",""])[1].toLowerCase()]){bx=bx.replace(R,"<$1>");try{for(var bw=0,bv=this.length;bw1&&bw0?this.clone(true):this).get();b(bC[bA])[bv](by);bz=bz.concat(by)}return this.pushStack(bz,e,bC.selector)}}});function bg(e){if(typeof e.getElementsByTagName!=="undefined"){return e.getElementsByTagName("*")}else{if(typeof e.querySelectorAll!=="undefined"){return e.querySelectorAll("*")}else{return[]}}}function az(e){if(e.type==="checkbox"||e.type==="radio"){e.defaultChecked=e.checked}}function E(e){var bv=(e.nodeName||"").toLowerCase();if(bv==="input"){az(e)}else{if(bv!=="script"&&typeof e.getElementsByTagName!=="undefined"){b.grep(e.getElementsByTagName("input"),az)}}}function al(e){var bv=av.createElement("div");ac.appendChild(bv);bv.innerHTML=e.outerHTML;return bv.firstChild}b.extend({clone:function(by,bA,bw){var e,bv,bx,bz=b.support.html5Clone||!ah.test("<"+by.nodeName)?by.cloneNode(true):al(by);if((!b.support.noCloneEvent||!b.support.noCloneChecked)&&(by.nodeType===1||by.nodeType===11)&&!b.isXMLDoc(by)){ai(by,bz);e=bg(by);bv=bg(bz);for(bx=0;e[bx];++bx){if(bv[bx]){ai(e[bx],bv[bx])}}}if(bA){t(by,bz);if(bw){e=bg(by);bv=bg(bz);for(bx=0;e[bx];++bx){t(e[bx],bv[bx])}}}e=bv=null;return bz},clean:function(bw,by,bH,bA){var bF;by=by||av;if(typeof by.createElement==="undefined"){by=by.ownerDocument||by[0]&&by[0].ownerDocument||av}var bI=[],bB;for(var bE=0,bz;(bz=bw[bE])!=null;bE++){if(typeof bz==="number"){bz+=""}if(!bz){continue}if(typeof bz==="string"){if(!W.test(bz)){bz=by.createTextNode(bz)}else{bz=bz.replace(R,"<$1>");var bK=(d.exec(bz)||["",""])[1].toLowerCase(),bx=ax[bK]||ax._default,bD=bx[0],bv=by.createElement("div");if(by===av){ac.appendChild(bv)}else{a(by).appendChild(bv)}bv.innerHTML=bx[1]+bz+bx[2];while(bD--){bv=bv.lastChild}if(!b.support.tbody){var e=w.test(bz),bC=bK==="table"&&!e?bv.firstChild&&bv.firstChild.childNodes:bx[1]===""&&!e?bv.childNodes:[];for(bB=bC.length-1;bB>=0;--bB){if(b.nodeName(bC[bB],"tbody")&&!bC[bB].childNodes.length){bC[bB].parentNode.removeChild(bC[bB])}}}if(!b.support.leadingWhitespace&&ar.test(bz)){bv.insertBefore(by.createTextNode(ar.exec(bz)[0]),bv.firstChild)}bz=bv.childNodes}}var bG;if(!b.support.appendChecked){if(bz[0]&&typeof(bG=bz.length)==="number"){for(bB=0;bB=0){return bx+"px"}}else{return bx}}}});if(!b.support.opacity){b.cssHooks.opacity={get:function(bv,e){return au.test((e&&bv.currentStyle?bv.currentStyle.filter:bv.style.filter)||"")?(parseFloat(RegExp.$1)/100)+"":e?"1":""},set:function(by,bz){var bx=by.style,bv=by.currentStyle,e=b.isNumeric(bz)?"alpha(opacity="+bz*100+")":"",bw=bv&&bv.filter||bx.filter||"";bx.zoom=1;if(bz>=1&&b.trim(bw.replace(ak,""))===""){bx.removeAttribute("filter");if(bv&&!bv.filter){return}}bx.filter=ak.test(bw)?bw.replace(ak,e):bw+" "+e}}}b(function(){if(!b.support.reliableMarginRight){b.cssHooks.marginRight={get:function(bw,bv){var e;b.swap(bw,{display:"inline-block"},function(){if(bv){e=Z(bw,"margin-right","marginRight")}else{e=bw.style.marginRight}});return e}}}});if(av.defaultView&&av.defaultView.getComputedStyle){aI=function(by,bw){var bv,bx,e;bw=bw.replace(z,"-$1").toLowerCase();if((bx=by.ownerDocument.defaultView)&&(e=bx.getComputedStyle(by,null))){bv=e.getPropertyValue(bw);if(bv===""&&!b.contains(by.ownerDocument.documentElement,by)){bv=b.style(by,bw)}}return bv}}if(av.documentElement.currentStyle){aX=function(bz,bw){var bA,e,by,bv=bz.currentStyle&&bz.currentStyle[bw],bx=bz.style;if(bv===null&&bx&&(by=bx[bw])){bv=by}if(!bc.test(bv)&&bn.test(bv)){bA=bx.left;e=bz.runtimeStyle&&bz.runtimeStyle.left;if(e){bz.runtimeStyle.left=bz.currentStyle.left}bx.left=bw==="fontSize"?"1em":(bv||0);bv=bx.pixelLeft+"px";bx.left=bA;if(e){bz.runtimeStyle.left=e}}return bv===""?"auto":bv}}Z=aI||aX;function p(by,bw,bv){var bA=bw==="width"?by.offsetWidth:by.offsetHeight,bz=bw==="width"?an:a1,bx=0,e=bz.length;if(bA>0){if(bv!=="border"){for(;bx)<[^<]*)*<\/script>/gi,q=/^(?:select|textarea)/i,h=/\s+/,br=/([?&])_=[^&]*/,K=/^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+))?)?/,A=b.fn.load,aa={},r={},aE,s,aV=["*/"]+["*"];try{aE=bl.href}catch(aw){aE=av.createElement("a");aE.href="";aE=aE.href}s=K.exec(aE.toLowerCase())||[];function f(e){return function(by,bA){if(typeof by!=="string"){bA=by;by="*"}if(b.isFunction(bA)){var bx=by.toLowerCase().split(h),bw=0,bz=bx.length,bv,bB,bC;for(;bw=0){var e=bw.slice(by,bw.length);bw=bw.slice(0,by)}var bx="GET";if(bz){if(b.isFunction(bz)){bA=bz;bz=L}else{if(typeof bz==="object"){bz=b.param(bz,b.ajaxSettings.traditional);bx="POST"}}}var bv=this;b.ajax({url:bw,type:bx,dataType:"html",data:bz,complete:function(bC,bB,bD){bD=bC.responseText;if(bC.isResolved()){bC.done(function(bE){bD=bE});bv.html(e?b("
").append(bD.replace(a6,"")).find(e):bD)}if(bA){bv.each(bA,[bD,bB,bC])}}});return this},serialize:function(){return b.param(this.serializeArray())},serializeArray:function(){return this.map(function(){return this.elements?b.makeArray(this.elements):this}).filter(function(){return this.name&&!this.disabled&&(this.checked||q.test(this.nodeName)||aZ.test(this.type))}).map(function(e,bv){var bw=b(this).val();return bw==null?null:b.isArray(bw)?b.map(bw,function(by,bx){return{name:bv.name,value:by.replace(bs,"\r\n")}}):{name:bv.name,value:bw.replace(bs,"\r\n")}}).get()}});b.each("ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "),function(e,bv){b.fn[bv]=function(bw){return this.on(bv,bw)}});b.each(["get","post"],function(e,bv){b[bv]=function(bw,by,bz,bx){if(b.isFunction(by)){bx=bx||bz;bz=by;by=L}return b.ajax({type:bv,url:bw,data:by,success:bz,dataType:bx})}});b.extend({getScript:function(e,bv){return b.get(e,L,bv,"script")},getJSON:function(e,bv,bw){return b.get(e,bv,bw,"json")},ajaxSetup:function(bv,e){if(e){am(bv,b.ajaxSettings)}else{e=bv;bv=b.ajaxSettings}am(bv,e);return bv},ajaxSettings:{url:aE,isLocal:aM.test(s[1]),global:true,type:"GET",contentType:"application/x-www-form-urlencoded",processData:true,async:true,accepts:{xml:"application/xml, text/xml",html:"text/html",text:"text/plain",json:"application/json, text/javascript","*":aV},contents:{xml:/xml/,html:/html/,json:/json/},responseFields:{xml:"responseXML",text:"responseText"},converters:{"* text":bb.String,"text html":true,"text json":b.parseJSON,"text xml":b.parseXML},flatOptions:{context:true,url:true}},ajaxPrefilter:f(aa),ajaxTransport:f(r),ajax:function(bz,bx){if(typeof bz==="object"){bx=bz;bz=L}bx=bx||{};var bD=b.ajaxSetup({},bx),bS=bD.context||bD,bG=bS!==bD&&(bS.nodeType||bS instanceof b)?b(bS):b.event,bR=b.Deferred(),bN=b.Callbacks("once memory"),bB=bD.statusCode||{},bC,bH={},bO={},bQ,by,bL,bE,bI,bA=0,bw,bK,bJ={readyState:0,setRequestHeader:function(bT,bU){if(!bA){var e=bT.toLowerCase();bT=bO[e]=bO[e]||bT;bH[bT]=bU}return this},getAllResponseHeaders:function(){return bA===2?bQ:null},getResponseHeader:function(bT){var e;if(bA===2){if(!by){by={};while((e=aD.exec(bQ))){by[e[1].toLowerCase()]=e[2]}}e=by[bT.toLowerCase()]}return e===L?null:e},overrideMimeType:function(e){if(!bA){bD.mimeType=e}return this},abort:function(e){e=e||"abort";if(bL){bL.abort(e)}bF(0,e);return this}};function bF(bZ,bU,b0,bW){if(bA===2){return}bA=2;if(bE){clearTimeout(bE)}bL=L;bQ=bW||"";bJ.readyState=bZ>0?4:0;var bT,b4,b3,bX=bU,bY=b0?bj(bD,bJ,b0):L,bV,b2;if(bZ>=200&&bZ<300||bZ===304){if(bD.ifModified){if((bV=bJ.getResponseHeader("Last-Modified"))){b.lastModified[bC]=bV}if((b2=bJ.getResponseHeader("Etag"))){b.etag[bC]=b2}}if(bZ===304){bX="notmodified";bT=true}else{try{b4=G(bD,bY);bX="success";bT=true}catch(b1){bX="parsererror";b3=b1}}}else{b3=bX;if(!bX||bZ){bX="error";if(bZ<0){bZ=0}}}bJ.status=bZ;bJ.statusText=""+(bU||bX);if(bT){bR.resolveWith(bS,[b4,bX,bJ])}else{bR.rejectWith(bS,[bJ,bX,b3])}bJ.statusCode(bB);bB=L;if(bw){bG.trigger("ajax"+(bT?"Success":"Error"),[bJ,bD,bT?b4:b3])}bN.fireWith(bS,[bJ,bX]);if(bw){bG.trigger("ajaxComplete",[bJ,bD]);if(!(--b.active)){b.event.trigger("ajaxStop")}}}bR.promise(bJ);bJ.success=bJ.done;bJ.error=bJ.fail;bJ.complete=bN.add;bJ.statusCode=function(bT){if(bT){var e;if(bA<2){for(e in bT){bB[e]=[bB[e],bT[e]]}}else{e=bT[bJ.status];bJ.then(e,e)}}return this};bD.url=((bz||bD.url)+"").replace(bq,"").replace(c,s[1]+"//");bD.dataTypes=b.trim(bD.dataType||"*").toLowerCase().split(h);if(bD.crossDomain==null){bI=K.exec(bD.url.toLowerCase());bD.crossDomain=!!(bI&&(bI[1]!=s[1]||bI[2]!=s[2]||(bI[3]||(bI[1]==="http:"?80:443))!=(s[3]||(s[1]==="http:"?80:443))))}if(bD.data&&bD.processData&&typeof bD.data!=="string"){bD.data=b.param(bD.data,bD.traditional)}aW(aa,bD,bx,bJ);if(bA===2){return false}bw=bD.global;bD.type=bD.type.toUpperCase();bD.hasContent=!aQ.test(bD.type);if(bw&&b.active++===0){b.event.trigger("ajaxStart")}if(!bD.hasContent){if(bD.data){bD.url+=(M.test(bD.url)?"&":"?")+bD.data;delete bD.data}bC=bD.url;if(bD.cache===false){var bv=b.now(),bP=bD.url.replace(br,"$1_="+bv);bD.url=bP+((bP===bD.url)?(M.test(bD.url)?"&":"?")+"_="+bv:"")}}if(bD.data&&bD.hasContent&&bD.contentType!==false||bx.contentType){bJ.setRequestHeader("Content-Type",bD.contentType)}if(bD.ifModified){bC=bC||bD.url;if(b.lastModified[bC]){bJ.setRequestHeader("If-Modified-Since",b.lastModified[bC])}if(b.etag[bC]){bJ.setRequestHeader("If-None-Match",b.etag[bC])}}bJ.setRequestHeader("Accept",bD.dataTypes[0]&&bD.accepts[bD.dataTypes[0]]?bD.accepts[bD.dataTypes[0]]+(bD.dataTypes[0]!=="*"?", "+aV+"; q=0.01":""):bD.accepts["*"]);for(bK in bD.headers){bJ.setRequestHeader(bK,bD.headers[bK])}if(bD.beforeSend&&(bD.beforeSend.call(bS,bJ,bD)===false||bA===2)){bJ.abort();return false}for(bK in {success:1,error:1,complete:1}){bJ[bK](bD[bK])}bL=aW(r,bD,bx,bJ);if(!bL){bF(-1,"No Transport")}else{bJ.readyState=1;if(bw){bG.trigger("ajaxSend",[bJ,bD])}if(bD.async&&bD.timeout>0){bE=setTimeout(function(){bJ.abort("timeout")},bD.timeout)}try{bA=1;bL.send(bH,bF)}catch(bM){if(bA<2){bF(-1,bM)}else{throw bM}}}return bJ},param:function(e,bw){var bv=[],by=function(bz,bA){bA=b.isFunction(bA)?bA():bA;bv[bv.length]=encodeURIComponent(bz)+"="+encodeURIComponent(bA)};if(bw===L){bw=b.ajaxSettings.traditional}if(b.isArray(e)||(e.jquery&&!b.isPlainObject(e))){b.each(e,function(){by(this.name,this.value)})}else{for(var bx in e){v(bx,e[bx],bw,by)}}return bv.join("&").replace(k,"+")}});function v(bw,by,bv,bx){if(b.isArray(by)){b.each(by,function(bA,bz){if(bv||ap.test(bw)){bx(bw,bz)}else{v(bw+"["+(typeof bz==="object"||b.isArray(bz)?bA:"")+"]",bz,bv,bx)}})}else{if(!bv&&by!=null&&typeof by==="object"){for(var e in by){v(bw+"["+e+"]",by[e],bv,bx)}}else{bx(bw,by)}}}b.extend({active:0,lastModified:{},etag:{}});function bj(bD,bC,bz){var bv=bD.contents,bB=bD.dataTypes,bw=bD.responseFields,by,bA,bx,e;for(bA in bw){if(bA in bz){bC[bw[bA]]=bz[bA]}}while(bB[0]==="*"){bB.shift();if(by===L){by=bD.mimeType||bC.getResponseHeader("content-type")}}if(by){for(bA in bv){if(bv[bA]&&bv[bA].test(by)){bB.unshift(bA);break}}}if(bB[0] in bz){bx=bB[0]}else{for(bA in bz){if(!bB[0]||bD.converters[bA+" "+bB[0]]){bx=bA;break}if(!e){e=bA}}bx=bx||e}if(bx){if(bx!==bB[0]){bB.unshift(bx)}return bz[bx]}}function G(bH,bz){if(bH.dataFilter){bz=bH.dataFilter(bz,bH.dataType)}var bD=bH.dataTypes,bG={},bA,bE,bw=bD.length,bB,bC=bD[0],bx,by,bF,bv,e;for(bA=1;bA=bw.duration+this.startTime){this.now=this.end;this.pos=this.state=1;this.update();bw.animatedProperties[this.prop]=true;for(bA in bw.animatedProperties){if(bw.animatedProperties[bA]!==true){e=false}}if(e){if(bw.overflow!=null&&!b.support.shrinkWrapBlocks){b.each(["","X","Y"],function(bC,bD){bz.style["overflow"+bD]=bw.overflow[bC]})}if(bw.hide){b(bz).hide()}if(bw.hide||bw.show){for(bA in bw.animatedProperties){b.style(bz,bA,bw.orig[bA]);b.removeData(bz,"fxshow"+bA,true);b.removeData(bz,"toggle"+bA,true)}}bv=bw.complete;if(bv){bw.complete=false;bv.call(bz)}}return false}else{if(bw.duration==Infinity){this.now=bx}else{bB=bx-this.startTime;this.state=bB/bw.duration;this.pos=b.easing[bw.animatedProperties[this.prop]](this.state,bB,0,1,bw.duration);this.now=this.start+((this.end-this.start)*this.pos)}this.update()}return true}};b.extend(b.fx,{tick:function(){var bw,bv=b.timers,e=0;for(;e").appendTo(e),bw=bv.css("display");bv.remove();if(bw==="none"||bw===""){if(!a8){a8=av.createElement("iframe");a8.frameBorder=a8.width=a8.height=0}e.appendChild(a8);if(!m||!a8.createElement){m=(a8.contentWindow||a8.contentDocument).document;m.write((av.compatMode==="CSS1Compat"?"":"")+"");m.close()}bv=m.createElement(bx);m.body.appendChild(bv);bw=b.css(bv,"display");e.removeChild(a8)}Q[bx]=bw}return Q[bx]}var V=/^t(?:able|d|h)$/i,ad=/^(?:body|html)$/i;if("getBoundingClientRect" in av.documentElement){b.fn.offset=function(bI){var by=this[0],bB;if(bI){return this.each(function(e){b.offset.setOffset(this,bI,e)})}if(!by||!by.ownerDocument){return null}if(by===by.ownerDocument.body){return b.offset.bodyOffset(by)}try{bB=by.getBoundingClientRect()}catch(bF){}var bH=by.ownerDocument,bw=bH.documentElement;if(!bB||!b.contains(bw,by)){return bB?{top:bB.top,left:bB.left}:{top:0,left:0}}var bC=bH.body,bD=aK(bH),bA=bw.clientTop||bC.clientTop||0,bE=bw.clientLeft||bC.clientLeft||0,bv=bD.pageYOffset||b.support.boxModel&&bw.scrollTop||bC.scrollTop,bz=bD.pageXOffset||b.support.boxModel&&bw.scrollLeft||bC.scrollLeft,bG=bB.top+bv-bA,bx=bB.left+bz-bE;return{top:bG,left:bx}}}else{b.fn.offset=function(bF){var bz=this[0];if(bF){return this.each(function(bG){b.offset.setOffset(this,bF,bG)})}if(!bz||!bz.ownerDocument){return null}if(bz===bz.ownerDocument.body){return b.offset.bodyOffset(bz)}var bC,bw=bz.offsetParent,bv=bz,bE=bz.ownerDocument,bx=bE.documentElement,bA=bE.body,bB=bE.defaultView,e=bB?bB.getComputedStyle(bz,null):bz.currentStyle,bD=bz.offsetTop,by=bz.offsetLeft;while((bz=bz.parentNode)&&bz!==bA&&bz!==bx){if(b.support.fixedPosition&&e.position==="fixed"){break}bC=bB?bB.getComputedStyle(bz,null):bz.currentStyle;bD-=bz.scrollTop;by-=bz.scrollLeft;if(bz===bw){bD+=bz.offsetTop;by+=bz.offsetLeft;if(b.support.doesNotAddBorder&&!(b.support.doesAddBorderForTableAndCells&&V.test(bz.nodeName))){bD+=parseFloat(bC.borderTopWidth)||0;by+=parseFloat(bC.borderLeftWidth)||0}bv=bw;bw=bz.offsetParent}if(b.support.subtractsBorderForOverflowNotVisible&&bC.overflow!=="visible"){bD+=parseFloat(bC.borderTopWidth)||0;by+=parseFloat(bC.borderLeftWidth)||0}e=bC}if(e.position==="relative"||e.position==="static"){bD+=bA.offsetTop;by+=bA.offsetLeft}if(b.support.fixedPosition&&e.position==="fixed"){bD+=Math.max(bx.scrollTop,bA.scrollTop);by+=Math.max(bx.scrollLeft,bA.scrollLeft)}return{top:bD,left:by}}}b.offset={bodyOffset:function(e){var bw=e.offsetTop,bv=e.offsetLeft;if(b.support.doesNotIncludeMarginInBodyOffset){bw+=parseFloat(b.css(e,"marginTop"))||0;bv+=parseFloat(b.css(e,"marginLeft"))||0}return{top:bw,left:bv}},setOffset:function(bx,bG,bA){var bB=b.css(bx,"position");if(bB==="static"){bx.style.position="relative"}var bz=b(bx),bv=bz.offset(),e=b.css(bx,"top"),bE=b.css(bx,"left"),bF=(bB==="absolute"||bB==="fixed")&&b.inArray("auto",[e,bE])>-1,bD={},bC={},bw,by;if(bF){bC=bz.position();bw=bC.top;by=bC.left}else{bw=parseFloat(e)||0;by=parseFloat(bE)||0}if(b.isFunction(bG)){bG=bG.call(bx,bA,bv)}if(bG.top!=null){bD.top=(bG.top-bv.top)+bw}if(bG.left!=null){bD.left=(bG.left-bv.left)+by}if("using" in bG){bG.using.call(bx,bD)}else{bz.css(bD)}}};b.fn.extend({position:function(){if(!this[0]){return null}var bw=this[0],bv=this.offsetParent(),bx=this.offset(),e=ad.test(bv[0].nodeName)?{top:0,left:0}:bv.offset();bx.top-=parseFloat(b.css(bw,"marginTop"))||0;bx.left-=parseFloat(b.css(bw,"marginLeft"))||0;e.top+=parseFloat(b.css(bv[0],"borderTopWidth"))||0;e.left+=parseFloat(b.css(bv[0],"borderLeftWidth"))||0;return{top:bx.top-e.top,left:bx.left-e.left}},offsetParent:function(){return this.map(function(){var e=this.offsetParent||av.body;while(e&&(!ad.test(e.nodeName)&&b.css(e,"position")==="static")){e=e.offsetParent}return e})}});b.each(["Left","Top"],function(bv,e){var bw="scroll"+e;b.fn[bw]=function(bz){var bx,by;if(bz===L){bx=this[0];if(!bx){return null}by=aK(bx);return by?("pageXOffset" in by)?by[bv?"pageYOffset":"pageXOffset"]:b.support.boxModel&&by.document.documentElement[bw]||by.document.body[bw]:bx[bw]}return this.each(function(){by=aK(this);if(by){by.scrollTo(!bv?bz:b(by).scrollLeft(),bv?bz:b(by).scrollTop())}else{this[bw]=bz}})}});function aK(e){return b.isWindow(e)?e:e.nodeType===9?e.defaultView||e.parentWindow:false}b.each(["Height","Width"],function(bv,e){var bw=e.toLowerCase();b.fn["inner"+e]=function(){var bx=this[0];return bx?bx.style?parseFloat(b.css(bx,bw,"padding")):this[bw]():null};b.fn["outer"+e]=function(by){var bx=this[0];return bx?bx.style?parseFloat(b.css(bx,bw,by?"margin":"border")):this[bw]():null};b.fn[bw]=function(bz){var bA=this[0];if(!bA){return bz==null?null:this}if(b.isFunction(bz)){return this.each(function(bE){var bD=b(this);bD[bw](bz.call(this,bE,bD[bw]()))})}if(b.isWindow(bA)){var bB=bA.document.documentElement["client"+e],bx=bA.document.body;return bA.document.compatMode==="CSS1Compat"&&bB||bx&&bx["client"+e]||bB}else{if(bA.nodeType===9){return Math.max(bA.documentElement["client"+e],bA.body["scroll"+e],bA.documentElement["scroll"+e],bA.body["offset"+e],bA.documentElement["offset"+e])}else{if(bz===L){var bC=b.css(bA,bw),by=parseFloat(bC);return b.isNumeric(by)?by:bC}else{return this.css(bw,typeof bz==="string"?bz:bz+"px")}}}}});bb.jQuery=bb.$=b;if(typeof define==="function"&&define.amd&&define.amd.jQuery){define("jquery",[],function(){return b})}})(window);/*! + * jQuery UI 1.8.18 + * + * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about) + * Dual licensed under the MIT or GPL Version 2 licenses. + * http://jquery.org/license + * + * http://docs.jquery.com/UI + */ +(function(a,d){a.ui=a.ui||{};if(a.ui.version){return}a.extend(a.ui,{version:"1.8.18",keyCode:{ALT:18,BACKSPACE:8,CAPS_LOCK:20,COMMA:188,COMMAND:91,COMMAND_LEFT:91,COMMAND_RIGHT:93,CONTROL:17,DELETE:46,DOWN:40,END:35,ENTER:13,ESCAPE:27,HOME:36,INSERT:45,LEFT:37,MENU:93,NUMPAD_ADD:107,NUMPAD_DECIMAL:110,NUMPAD_DIVIDE:111,NUMPAD_ENTER:108,NUMPAD_MULTIPLY:106,NUMPAD_SUBTRACT:109,PAGE_DOWN:34,PAGE_UP:33,PERIOD:190,RIGHT:39,SHIFT:16,SPACE:32,TAB:9,UP:38,WINDOWS:91}});a.fn.extend({propAttr:a.fn.prop||a.fn.attr,_focus:a.fn.focus,focus:function(e,f){return typeof e==="number"?this.each(function(){var g=this;setTimeout(function(){a(g).focus();if(f){f.call(g)}},e)}):this._focus.apply(this,arguments)},scrollParent:function(){var e;if((a.browser.msie&&(/(static|relative)/).test(this.css("position")))||(/absolute/).test(this.css("position"))){e=this.parents().filter(function(){return(/(relative|absolute|fixed)/).test(a.curCSS(this,"position",1))&&(/(auto|scroll)/).test(a.curCSS(this,"overflow",1)+a.curCSS(this,"overflow-y",1)+a.curCSS(this,"overflow-x",1))}).eq(0)}else{e=this.parents().filter(function(){return(/(auto|scroll)/).test(a.curCSS(this,"overflow",1)+a.curCSS(this,"overflow-y",1)+a.curCSS(this,"overflow-x",1))}).eq(0)}return(/fixed/).test(this.css("position"))||!e.length?a(document):e},zIndex:function(h){if(h!==d){return this.css("zIndex",h)}if(this.length){var f=a(this[0]),e,g;while(f.length&&f[0]!==document){e=f.css("position");if(e==="absolute"||e==="relative"||e==="fixed"){g=parseInt(f.css("zIndex"),10);if(!isNaN(g)&&g!==0){return g}}f=f.parent()}}return 0},disableSelection:function(){return this.bind((a.support.selectstart?"selectstart":"mousedown")+".ui-disableSelection",function(e){e.preventDefault()})},enableSelection:function(){return this.unbind(".ui-disableSelection")}});a.each(["Width","Height"],function(g,e){var f=e==="Width"?["Left","Right"]:["Top","Bottom"],h=e.toLowerCase(),k={innerWidth:a.fn.innerWidth,innerHeight:a.fn.innerHeight,outerWidth:a.fn.outerWidth,outerHeight:a.fn.outerHeight};function j(m,l,i,n){a.each(f,function(){l-=parseFloat(a.curCSS(m,"padding"+this,true))||0;if(i){l-=parseFloat(a.curCSS(m,"border"+this+"Width",true))||0}if(n){l-=parseFloat(a.curCSS(m,"margin"+this,true))||0}});return l}a.fn["inner"+e]=function(i){if(i===d){return k["inner"+e].call(this)}return this.each(function(){a(this).css(h,j(this,i)+"px")})};a.fn["outer"+e]=function(i,l){if(typeof i!=="number"){return k["outer"+e].call(this,i)}return this.each(function(){a(this).css(h,j(this,i,true,l)+"px")})}});function c(g,e){var j=g.nodeName.toLowerCase();if("area"===j){var i=g.parentNode,h=i.name,f;if(!g.href||!h||i.nodeName.toLowerCase()!=="map"){return false}f=a("img[usemap=#"+h+"]")[0];return !!f&&b(f)}return(/input|select|textarea|button|object/.test(j)?!g.disabled:"a"==j?g.href||e:e)&&b(g)}function b(e){return !a(e).parents().andSelf().filter(function(){return a.curCSS(this,"visibility")==="hidden"||a.expr.filters.hidden(this)}).length}a.extend(a.expr[":"],{data:function(g,f,e){return !!a.data(g,e[3])},focusable:function(e){return c(e,!isNaN(a.attr(e,"tabindex")))},tabbable:function(g){var e=a.attr(g,"tabindex"),f=isNaN(e);return(f||e>=0)&&c(g,!f)}});a(function(){var e=document.body,f=e.appendChild(f=document.createElement("div"));f.offsetHeight;a.extend(f.style,{minHeight:"100px",height:"auto",padding:0,borderWidth:0});a.support.minHeight=f.offsetHeight===100;a.support.selectstart="onselectstart" in f;e.removeChild(f).style.display="none"});a.extend(a.ui,{plugin:{add:function(f,g,j){var h=a.ui[f].prototype;for(var e in j){h.plugins[e]=h.plugins[e]||[];h.plugins[e].push([g,j[e]])}},call:function(e,g,f){var j=e.plugins[g];if(!j||!e.element[0].parentNode){return}for(var h=0;h0){return true}h[e]=1;g=(h[e]>0);h[e]=0;return g},isOverAxis:function(f,e,g){return(f>e)&&(f<(e+g))},isOver:function(j,f,i,h,e,g){return a.ui.isOverAxis(j,i,e)&&a.ui.isOverAxis(f,h,g)}})})(jQuery);/*! + * jQuery UI Widget 1.8.18 + * + * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about) + * Dual licensed under the MIT or GPL Version 2 licenses. + * http://jquery.org/license + * + * http://docs.jquery.com/UI/Widget + */ +(function(b,d){if(b.cleanData){var c=b.cleanData;b.cleanData=function(f){for(var g=0,h;(h=f[g])!=null;g++){try{b(h).triggerHandler("remove")}catch(j){}}c(f)}}else{var a=b.fn.remove;b.fn.remove=function(e,f){return this.each(function(){if(!f){if(!e||b.filter(e,[this]).length){b("*",this).add([this]).each(function(){try{b(this).triggerHandler("remove")}catch(g){}})}}return a.call(b(this),e,f)})}}b.widget=function(f,h,e){var g=f.split(".")[0],j;f=f.split(".")[1];j=g+"-"+f;if(!e){e=h;h=b.Widget}b.expr[":"][j]=function(k){return !!b.data(k,f)};b[g]=b[g]||{};b[g][f]=function(k,l){if(arguments.length){this._createWidget(k,l)}};var i=new h();i.options=b.extend(true,{},i.options);b[g][f].prototype=b.extend(true,i,{namespace:g,widgetName:f,widgetEventPrefix:b[g][f].prototype.widgetEventPrefix||f,widgetBaseClass:j},e);b.widget.bridge(f,b[g][f])};b.widget.bridge=function(f,e){b.fn[f]=function(i){var g=typeof i==="string",h=Array.prototype.slice.call(arguments,1),j=this;i=!g&&h.length?b.extend.apply(null,[true,i].concat(h)):i;if(g&&i.charAt(0)==="_"){return j}if(g){this.each(function(){var k=b.data(this,f),l=k&&b.isFunction(k[i])?k[i].apply(k,h):k;if(l!==k&&l!==d){j=l;return false}})}else{this.each(function(){var k=b.data(this,f);if(k){k.option(i||{})._init()}else{b.data(this,f,new e(i,this))}})}return j}};b.Widget=function(e,f){if(arguments.length){this._createWidget(e,f)}};b.Widget.prototype={widgetName:"widget",widgetEventPrefix:"",options:{disabled:false},_createWidget:function(f,g){b.data(g,this.widgetName,this);this.element=b(g);this.options=b.extend(true,{},this.options,this._getCreateOptions(),f);var e=this;this.element.bind("remove."+this.widgetName,function(){e.destroy()});this._create();this._trigger("create");this._init()},_getCreateOptions:function(){return b.metadata&&b.metadata.get(this.element[0])[this.widgetName]},_create:function(){},_init:function(){},destroy:function(){this.element.unbind("."+this.widgetName).removeData(this.widgetName);this.widget().unbind("."+this.widgetName).removeAttr("aria-disabled").removeClass(this.widgetBaseClass+"-disabled ui-state-disabled")},widget:function(){return this.element},option:function(f,g){var e=f;if(arguments.length===0){return b.extend({},this.options)}if(typeof f==="string"){if(g===d){return this.options[f]}e={};e[f]=g}this._setOptions(e);return this},_setOptions:function(f){var e=this;b.each(f,function(g,h){e._setOption(g,h)});return this},_setOption:function(e,f){this.options[e]=f;if(e==="disabled"){this.widget()[f?"addClass":"removeClass"](this.widgetBaseClass+"-disabled ui-state-disabled").attr("aria-disabled",f)}return this},enable:function(){return this._setOption("disabled",false)},disable:function(){return this._setOption("disabled",true)},_trigger:function(e,f,g){var j,i,h=this.options[e];g=g||{};f=b.Event(f);f.type=(e===this.widgetEventPrefix?e:this.widgetEventPrefix+e).toLowerCase();f.target=this.element[0];i=f.originalEvent;if(i){for(j in i){if(!(j in f)){f[j]=i[j]}}}this.element.trigger(f,g);return !(b.isFunction(h)&&h.call(this.element[0],f,g)===false||f.isDefaultPrevented())}}})(jQuery);/*! + * jQuery UI Mouse 1.8.18 + * + * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about) + * Dual licensed under the MIT or GPL Version 2 licenses. + * http://jquery.org/license + * + * http://docs.jquery.com/UI/Mouse + * + * Depends: + * jquery.ui.widget.js + */ +(function(b,c){var a=false;b(document).mouseup(function(d){a=false});b.widget("ui.mouse",{options:{cancel:":input,option",distance:1,delay:0},_mouseInit:function(){var d=this;this.element.bind("mousedown."+this.widgetName,function(e){return d._mouseDown(e)}).bind("click."+this.widgetName,function(e){if(true===b.data(e.target,d.widgetName+".preventClickEvent")){b.removeData(e.target,d.widgetName+".preventClickEvent");e.stopImmediatePropagation();return false}});this.started=false},_mouseDestroy:function(){this.element.unbind("."+this.widgetName)},_mouseDown:function(f){if(a){return}(this._mouseStarted&&this._mouseUp(f));this._mouseDownEvent=f;var e=this,g=(f.which==1),d=(typeof this.options.cancel=="string"&&f.target.nodeName?b(f.target).closest(this.options.cancel).length:false);if(!g||d||!this._mouseCapture(f)){return true}this.mouseDelayMet=!this.options.delay;if(!this.mouseDelayMet){this._mouseDelayTimer=setTimeout(function(){e.mouseDelayMet=true},this.options.delay)}if(this._mouseDistanceMet(f)&&this._mouseDelayMet(f)){this._mouseStarted=(this._mouseStart(f)!==false);if(!this._mouseStarted){f.preventDefault();return true}}if(true===b.data(f.target,this.widgetName+".preventClickEvent")){b.removeData(f.target,this.widgetName+".preventClickEvent")}this._mouseMoveDelegate=function(h){return e._mouseMove(h)};this._mouseUpDelegate=function(h){return e._mouseUp(h)};b(document).bind("mousemove."+this.widgetName,this._mouseMoveDelegate).bind("mouseup."+this.widgetName,this._mouseUpDelegate);f.preventDefault();a=true;return true},_mouseMove:function(d){if(b.browser.msie&&!(document.documentMode>=9)&&!d.button){return this._mouseUp(d)}if(this._mouseStarted){this._mouseDrag(d);return d.preventDefault()}if(this._mouseDistanceMet(d)&&this._mouseDelayMet(d)){this._mouseStarted=(this._mouseStart(this._mouseDownEvent,d)!==false);(this._mouseStarted?this._mouseDrag(d):this._mouseUp(d))}return !this._mouseStarted},_mouseUp:function(d){b(document).unbind("mousemove."+this.widgetName,this._mouseMoveDelegate).unbind("mouseup."+this.widgetName,this._mouseUpDelegate);if(this._mouseStarted){this._mouseStarted=false;if(d.target==this._mouseDownEvent.target){b.data(d.target,this.widgetName+".preventClickEvent",true)}this._mouseStop(d)}return false},_mouseDistanceMet:function(d){return(Math.max(Math.abs(this._mouseDownEvent.pageX-d.pageX),Math.abs(this._mouseDownEvent.pageY-d.pageY))>=this.options.distance)},_mouseDelayMet:function(d){return this.mouseDelayMet},_mouseStart:function(d){},_mouseDrag:function(d){},_mouseStop:function(d){},_mouseCapture:function(d){return true}})})(jQuery);(function(c,d){c.widget("ui.resizable",c.ui.mouse,{widgetEventPrefix:"resize",options:{alsoResize:false,animate:false,animateDuration:"slow",animateEasing:"swing",aspectRatio:false,autoHide:false,containment:false,ghost:false,grid:false,handles:"e,s,se",helper:false,maxHeight:null,maxWidth:null,minHeight:10,minWidth:10,zIndex:1000},_create:function(){var f=this,k=this.options;this.element.addClass("ui-resizable");c.extend(this,{_aspectRatio:!!(k.aspectRatio),aspectRatio:k.aspectRatio,originalElement:this.element,_proportionallyResizeElements:[],_helper:k.helper||k.ghost||k.animate?k.helper||"ui-resizable-helper":null});if(this.element[0].nodeName.match(/canvas|textarea|input|select|button|img/i)){this.element.wrap(c('
').css({position:this.element.css("position"),width:this.element.outerWidth(),height:this.element.outerHeight(),top:this.element.css("top"),left:this.element.css("left")}));this.element=this.element.parent().data("resizable",this.element.data("resizable"));this.elementIsWrapper=true;this.element.css({marginLeft:this.originalElement.css("marginLeft"),marginTop:this.originalElement.css("marginTop"),marginRight:this.originalElement.css("marginRight"),marginBottom:this.originalElement.css("marginBottom")});this.originalElement.css({marginLeft:0,marginTop:0,marginRight:0,marginBottom:0});this.originalResizeStyle=this.originalElement.css("resize");this.originalElement.css("resize","none");this._proportionallyResizeElements.push(this.originalElement.css({position:"static",zoom:1,display:"block"}));this.originalElement.css({margin:this.originalElement.css("margin")});this._proportionallyResize()}this.handles=k.handles||(!c(".ui-resizable-handle",this.element).length?"e,s,se":{n:".ui-resizable-n",e:".ui-resizable-e",s:".ui-resizable-s",w:".ui-resizable-w",se:".ui-resizable-se",sw:".ui-resizable-sw",ne:".ui-resizable-ne",nw:".ui-resizable-nw"});if(this.handles.constructor==String){if(this.handles=="all"){this.handles="n,e,s,w,se,sw,ne,nw"}var l=this.handles.split(",");this.handles={};for(var g=0;g
');if(/sw|se|ne|nw/.test(j)){h.css({zIndex:++k.zIndex})}if("se"==j){h.addClass("ui-icon ui-icon-gripsmall-diagonal-se")}this.handles[j]=".ui-resizable-"+j;this.element.append(h)}}this._renderAxis=function(q){q=q||this.element;for(var n in this.handles){if(this.handles[n].constructor==String){this.handles[n]=c(this.handles[n],this.element).show()}if(this.elementIsWrapper&&this.originalElement[0].nodeName.match(/textarea|input|select|button/i)){var o=c(this.handles[n],this.element),p=0;p=/sw|ne|nw|se|n|s/.test(n)?o.outerHeight():o.outerWidth();var m=["padding",/ne|nw|n/.test(n)?"Top":/se|sw|s/.test(n)?"Bottom":/^e$/.test(n)?"Right":"Left"].join("");q.css(m,p);this._proportionallyResize()}if(!c(this.handles[n]).length){continue}}};this._renderAxis(this.element);this._handles=c(".ui-resizable-handle",this.element).disableSelection();this._handles.mouseover(function(){if(!f.resizing){if(this.className){var i=this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i)}f.axis=i&&i[1]?i[1]:"se"}});if(k.autoHide){this._handles.hide();c(this.element).addClass("ui-resizable-autohide").hover(function(){if(k.disabled){return}c(this).removeClass("ui-resizable-autohide");f._handles.show()},function(){if(k.disabled){return}if(!f.resizing){c(this).addClass("ui-resizable-autohide");f._handles.hide()}})}this._mouseInit()},destroy:function(){this._mouseDestroy();var e=function(g){c(g).removeClass("ui-resizable ui-resizable-disabled ui-resizable-resizing").removeData("resizable").unbind(".resizable").find(".ui-resizable-handle").remove()};if(this.elementIsWrapper){e(this.element);var f=this.element;f.after(this.originalElement.css({position:f.css("position"),width:f.outerWidth(),height:f.outerHeight(),top:f.css("top"),left:f.css("left")})).remove()}this.originalElement.css("resize",this.originalResizeStyle);e(this.originalElement);return this},_mouseCapture:function(f){var g=false;for(var e in this.handles){if(c(this.handles[e])[0]==f.target){g=true}}return !this.options.disabled&&g},_mouseStart:function(g){var j=this.options,f=this.element.position(),e=this.element;this.resizing=true;this.documentScroll={top:c(document).scrollTop(),left:c(document).scrollLeft()};if(e.is(".ui-draggable")||(/absolute/).test(e.css("position"))){e.css({position:"absolute",top:f.top,left:f.left})}this._renderProxy();var k=b(this.helper.css("left")),h=b(this.helper.css("top"));if(j.containment){k+=c(j.containment).scrollLeft()||0;h+=c(j.containment).scrollTop()||0}this.offset=this.helper.offset();this.position={left:k,top:h};this.size=this._helper?{width:e.outerWidth(),height:e.outerHeight()}:{width:e.width(),height:e.height()};this.originalSize=this._helper?{width:e.outerWidth(),height:e.outerHeight()}:{width:e.width(),height:e.height()};this.originalPosition={left:k,top:h};this.sizeDiff={width:e.outerWidth()-e.width(),height:e.outerHeight()-e.height()};this.originalMousePosition={left:g.pageX,top:g.pageY};this.aspectRatio=(typeof j.aspectRatio=="number")?j.aspectRatio:((this.originalSize.width/this.originalSize.height)||1);var i=c(".ui-resizable-"+this.axis).css("cursor");c("body").css("cursor",i=="auto"?this.axis+"-resize":i);e.addClass("ui-resizable-resizing");this._propagate("start",g);return true},_mouseDrag:function(e){var h=this.helper,g=this.options,m={},q=this,j=this.originalMousePosition,n=this.axis;var r=(e.pageX-j.left)||0,p=(e.pageY-j.top)||0;var i=this._change[n];if(!i){return false}var l=i.apply(this,[e,r,p]),k=c.browser.msie&&c.browser.version<7,f=this.sizeDiff;this._updateVirtualBoundaries(e.shiftKey);if(this._aspectRatio||e.shiftKey){l=this._updateRatio(l,e)}l=this._respectSize(l,e);this._propagate("resize",e);h.css({top:this.position.top+"px",left:this.position.left+"px",width:this.size.width+"px",height:this.size.height+"px"});if(!this._helper&&this._proportionallyResizeElements.length){this._proportionallyResize()}this._updateCache(l);this._trigger("resize",e,this.ui());return false},_mouseStop:function(h){this.resizing=false;var i=this.options,m=this;if(this._helper){var g=this._proportionallyResizeElements,e=g.length&&(/textarea/i).test(g[0].nodeName),f=e&&c.ui.hasScroll(g[0],"left")?0:m.sizeDiff.height,k=e?0:m.sizeDiff.width;var n={width:(m.helper.width()-k),height:(m.helper.height()-f)},j=(parseInt(m.element.css("left"),10)+(m.position.left-m.originalPosition.left))||null,l=(parseInt(m.element.css("top"),10)+(m.position.top-m.originalPosition.top))||null;if(!i.animate){this.element.css(c.extend(n,{top:l,left:j}))}m.helper.height(m.size.height);m.helper.width(m.size.width);if(this._helper&&!i.animate){this._proportionallyResize()}}c("body").css("cursor","auto");this.element.removeClass("ui-resizable-resizing");this._propagate("stop",h);if(this._helper){this.helper.remove()}return false},_updateVirtualBoundaries:function(g){var j=this.options,i,h,f,k,e;e={minWidth:a(j.minWidth)?j.minWidth:0,maxWidth:a(j.maxWidth)?j.maxWidth:Infinity,minHeight:a(j.minHeight)?j.minHeight:0,maxHeight:a(j.maxHeight)?j.maxHeight:Infinity};if(this._aspectRatio||g){i=e.minHeight*this.aspectRatio;f=e.minWidth/this.aspectRatio;h=e.maxHeight*this.aspectRatio;k=e.maxWidth/this.aspectRatio;if(i>e.minWidth){e.minWidth=i}if(f>e.minHeight){e.minHeight=f}if(hl.width),s=a(l.height)&&i.minHeight&&(i.minHeight>l.height);if(h){l.width=i.minWidth}if(s){l.height=i.minHeight}if(t){l.width=i.maxWidth}if(m){l.height=i.maxHeight}var f=this.originalPosition.left+this.originalSize.width,p=this.position.top+this.size.height;var k=/sw|nw|w/.test(q),e=/nw|ne|n/.test(q);if(h&&k){l.left=f-i.minWidth}if(t&&k){l.left=f-i.maxWidth}if(s&&e){l.top=p-i.minHeight}if(m&&e){l.top=p-i.maxHeight}var n=!l.width&&!l.height;if(n&&!l.left&&l.top){l.top=null}else{if(n&&!l.top&&l.left){l.left=null}}return l},_proportionallyResize:function(){var k=this.options;if(!this._proportionallyResizeElements.length){return}var g=this.helper||this.element;for(var f=0;f');var e=c.browser.msie&&c.browser.version<7,g=(e?1:0),h=(e?2:-1);this.helper.addClass(this._helper).css({width:this.element.outerWidth()+h,height:this.element.outerHeight()+h,position:"absolute",left:this.elementOffset.left-g+"px",top:this.elementOffset.top-g+"px",zIndex:++i.zIndex});this.helper.appendTo("body").disableSelection()}else{this.helper=this.element}},_change:{e:function(g,f,e){return{width:this.originalSize.width+f}},w:function(h,f,e){var j=this.options,g=this.originalSize,i=this.originalPosition;return{left:i.left+f,width:g.width-f}},n:function(h,f,e){var j=this.options,g=this.originalSize,i=this.originalPosition;return{top:i.top+e,height:g.height-e}},s:function(g,f,e){return{height:this.originalSize.height+e}},se:function(g,f,e){return c.extend(this._change.s.apply(this,arguments),this._change.e.apply(this,[g,f,e]))},sw:function(g,f,e){return c.extend(this._change.s.apply(this,arguments),this._change.w.apply(this,[g,f,e]))},ne:function(g,f,e){return c.extend(this._change.n.apply(this,arguments),this._change.e.apply(this,[g,f,e]))},nw:function(g,f,e){return c.extend(this._change.n.apply(this,arguments),this._change.w.apply(this,[g,f,e]))}},_propagate:function(f,e){c.ui.plugin.call(this,f,[e,this.ui()]);(f!="resize"&&this._trigger(f,e,this.ui()))},plugins:{},ui:function(){return{originalElement:this.originalElement,element:this.element,helper:this.helper,position:this.position,size:this.size,originalSize:this.originalSize,originalPosition:this.originalPosition}}});c.extend(c.ui.resizable,{version:"1.8.18"});c.ui.plugin.add("resizable","alsoResize",{start:function(f,g){var e=c(this).data("resizable"),i=e.options;var h=function(j){c(j).each(function(){var k=c(this);k.data("resizable-alsoresize",{width:parseInt(k.width(),10),height:parseInt(k.height(),10),left:parseInt(k.css("left"),10),top:parseInt(k.css("top"),10)})})};if(typeof(i.alsoResize)=="object"&&!i.alsoResize.parentNode){if(i.alsoResize.length){i.alsoResize=i.alsoResize[0];h(i.alsoResize)}else{c.each(i.alsoResize,function(j){h(j)})}}else{h(i.alsoResize)}},resize:function(g,i){var f=c(this).data("resizable"),j=f.options,h=f.originalSize,l=f.originalPosition;var k={height:(f.size.height-h.height)||0,width:(f.size.width-h.width)||0,top:(f.position.top-l.top)||0,left:(f.position.left-l.left)||0},e=function(m,n){c(m).each(function(){var q=c(this),r=c(this).data("resizable-alsoresize"),p={},o=n&&n.length?n:q.parents(i.originalElement[0]).length?["width","height"]:["width","height","top","left"];c.each(o,function(s,u){var t=(r[u]||0)+(k[u]||0);if(t&&t>=0){p[u]=t||null}});q.css(p)})};if(typeof(j.alsoResize)=="object"&&!j.alsoResize.nodeType){c.each(j.alsoResize,function(m,n){e(m,n)})}else{e(j.alsoResize)}},stop:function(e,f){c(this).removeData("resizable-alsoresize")}});c.ui.plugin.add("resizable","animate",{stop:function(i,n){var p=c(this).data("resizable"),j=p.options;var h=p._proportionallyResizeElements,e=h.length&&(/textarea/i).test(h[0].nodeName),f=e&&c.ui.hasScroll(h[0],"left")?0:p.sizeDiff.height,l=e?0:p.sizeDiff.width;var g={width:(p.size.width-l),height:(p.size.height-f)},k=(parseInt(p.element.css("left"),10)+(p.position.left-p.originalPosition.left))||null,m=(parseInt(p.element.css("top"),10)+(p.position.top-p.originalPosition.top))||null;p.element.animate(c.extend(g,m&&k?{top:m,left:k}:{}),{duration:j.animateDuration,easing:j.animateEasing,step:function(){var o={width:parseInt(p.element.css("width"),10),height:parseInt(p.element.css("height"),10),top:parseInt(p.element.css("top"),10),left:parseInt(p.element.css("left"),10)};if(h&&h.length){c(h[0]).css({width:o.width,height:o.height})}p._updateCache(o);p._propagate("resize",i)}})}});c.ui.plugin.add("resizable","containment",{start:function(f,r){var t=c(this).data("resizable"),j=t.options,l=t.element;var g=j.containment,k=(g instanceof c)?g.get(0):(/parent/.test(g))?l.parent().get(0):g;if(!k){return}t.containerElement=c(k);if(/document/.test(g)||g==document){t.containerOffset={left:0,top:0};t.containerPosition={left:0,top:0};t.parentData={element:c(document),left:0,top:0,width:c(document).width(),height:c(document).height()||document.body.parentNode.scrollHeight}}else{var n=c(k),i=[];c(["Top","Right","Left","Bottom"]).each(function(p,o){i[p]=b(n.css("padding"+o))});t.containerOffset=n.offset();t.containerPosition=n.position();t.containerSize={height:(n.innerHeight()-i[3]),width:(n.innerWidth()-i[1])};var q=t.containerOffset,e=t.containerSize.height,m=t.containerSize.width,h=(c.ui.hasScroll(k,"left")?k.scrollWidth:m),s=(c.ui.hasScroll(k)?k.scrollHeight:e);t.parentData={element:k,left:q.left,top:q.top,width:h,height:s}}},resize:function(g,q){var t=c(this).data("resizable"),i=t.options,f=t.containerSize,p=t.containerOffset,m=t.size,n=t.position,r=t._aspectRatio||g.shiftKey,e={top:0,left:0},h=t.containerElement;if(h[0]!=document&&(/static/).test(h.css("position"))){e=p}if(n.left<(t._helper?p.left:0)){t.size.width=t.size.width+(t._helper?(t.position.left-p.left):(t.position.left-e.left));if(r){t.size.height=t.size.width/i.aspectRatio}t.position.left=i.helper?p.left:0}if(n.top<(t._helper?p.top:0)){t.size.height=t.size.height+(t._helper?(t.position.top-p.top):t.position.top);if(r){t.size.width=t.size.height*i.aspectRatio}t.position.top=t._helper?p.top:0}t.offset.left=t.parentData.left+t.position.left;t.offset.top=t.parentData.top+t.position.top;var l=Math.abs((t._helper?t.offset.left-e.left:(t.offset.left-e.left))+t.sizeDiff.width),s=Math.abs((t._helper?t.offset.top-e.top:(t.offset.top-p.top))+t.sizeDiff.height);var k=t.containerElement.get(0)==t.element.parent().get(0),j=/relative|absolute/.test(t.containerElement.css("position"));if(k&&j){l-=t.parentData.left}if(l+t.size.width>=t.parentData.width){t.size.width=t.parentData.width-l;if(r){t.size.height=t.size.width/t.aspectRatio}}if(s+t.size.height>=t.parentData.height){t.size.height=t.parentData.height-s;if(r){t.size.width=t.size.height*t.aspectRatio}}},stop:function(f,n){var q=c(this).data("resizable"),g=q.options,l=q.position,m=q.containerOffset,e=q.containerPosition,i=q.containerElement;var j=c(q.helper),r=j.offset(),p=j.outerWidth()-q.sizeDiff.width,k=j.outerHeight()-q.sizeDiff.height;if(q._helper&&!g.animate&&(/relative/).test(i.css("position"))){c(this).css({left:r.left-e.left-m.left,width:p,height:k})}if(q._helper&&!g.animate&&(/static/).test(i.css("position"))){c(this).css({left:r.left-e.left-m.left,width:p,height:k})}}});c.ui.plugin.add("resizable","ghost",{start:function(g,h){var e=c(this).data("resizable"),i=e.options,f=e.size;e.ghost=e.originalElement.clone();e.ghost.css({opacity:0.25,display:"block",position:"relative",height:f.height,width:f.width,margin:0,left:0,top:0}).addClass("ui-resizable-ghost").addClass(typeof i.ghost=="string"?i.ghost:"");e.ghost.appendTo(e.helper)},resize:function(f,g){var e=c(this).data("resizable"),h=e.options;if(e.ghost){e.ghost.css({position:"relative",height:e.size.height,width:e.size.width})}},stop:function(f,g){var e=c(this).data("resizable"),h=e.options;if(e.ghost&&e.helper){e.helper.get(0).removeChild(e.ghost.get(0))}}});c.ui.plugin.add("resizable","grid",{resize:function(e,m){var p=c(this).data("resizable"),h=p.options,k=p.size,i=p.originalSize,j=p.originalPosition,n=p.axis,l=h._aspectRatio||e.shiftKey;h.grid=typeof h.grid=="number"?[h.grid,h.grid]:h.grid;var g=Math.round((k.width-i.width)/(h.grid[0]||1))*(h.grid[0]||1),f=Math.round((k.height-i.height)/(h.grid[1]||1))*(h.grid[1]||1);if(/^(se|s|e)$/.test(n)){p.size.width=i.width+g;p.size.height=i.height+f}else{if(/^(ne)$/.test(n)){p.size.width=i.width+g;p.size.height=i.height+f;p.position.top=j.top-f}else{if(/^(sw)$/.test(n)){p.size.width=i.width+g;p.size.height=i.height+f;p.position.left=j.left-g}else{p.size.width=i.width+g;p.size.height=i.height+f;p.position.top=j.top-f;p.position.left=j.left-g}}}}});var b=function(e){return parseInt(e,10)||0};var a=function(e){return !isNaN(parseInt(e,10))}})(jQuery);/*! + * jQuery hashchange event - v1.3 - 7/21/2010 + * http://benalman.com/projects/jquery-hashchange-plugin/ + * + * Copyright (c) 2010 "Cowboy" Ben Alman + * Dual licensed under the MIT and GPL licenses. + * http://benalman.com/about/license/ + */ +(function($,e,b){var c="hashchange",h=document,f,g=$.event.special,i=h.documentMode,d="on"+c in e&&(i===b||i>7);function a(j){j=j||location.href;return"#"+j.replace(/^[^#]*#?(.*)$/,"$1")}$.fn[c]=function(j){return j?this.bind(c,j):this.trigger(c)};$.fn[c].delay=50;g[c]=$.extend(g[c],{setup:function(){if(d){return false}$(f.start)},teardown:function(){if(d){return false}$(f.stop)}});f=(function(){var j={},p,m=a(),k=function(q){return q},l=k,o=k;j.start=function(){p||n()};j.stop=function(){p&&clearTimeout(p);p=b};function n(){var r=a(),q=o(m);if(r!==m){l(m=r,q);$(e).trigger(c)}else{if(q!==m){location.href=location.href.replace(/#.*/,"")+q}}p=setTimeout(n,$.fn[c].delay)}$.browser.msie&&!d&&(function(){var q,r;j.start=function(){if(!q){r=$.fn[c].src;r=r&&r+a();q=$('