From: Vincent Cheng Date: Tue, 18 Aug 2020 09:48:00 +0000 (+0100) Subject: 0ad (0.0.23.1-5) unstable; urgency=medium X-Git-Tag: archive/raspbian/0.0.25b-1.1+rpi1~1^2^2~6 X-Git-Url: https://dgit.raspbian.org/?a=commitdiff_plain;h=a24bd9ade3fbc64c7663ca4c6a791f9ee202f298;p=0ad.git 0ad (0.0.23.1-5) unstable; urgency=medium * Fix FTBFS with gcc-10. (Closes: #956967) * Avoid build-dep on unversioned python2. (Closes: #967118) * Cherrypick patch from upstream to add workaround for L3 cache detection on Ryzen 3000 series CPUs. (Closes: #949699) * Update to dh compat level 12. * Update Standards version to 4.5.0. * Add upstream metadata file. [dgit import unpatched 0ad 0.0.23.1-5] --- a24bd9ade3fbc64c7663ca4c6a791f9ee202f298 diff --cc debian/0ad.6 index 0000000,0000000..ab71e27 new file mode 100644 --- /dev/null +++ b/debian/0ad.6 @@@ -1,0 -1,0 +1,147 @@@ ++.TH 0AD "6" "April 7, 2012" ++.SH NAME ++0ad \- A real-time strategy game of ancient warfare ++.SH SYNOPSIS ++.B 0ad ++.RI [ options ] ++.SH DESCRIPTION ++0 A.D. is a free, open-source, cross-platform real-time strategy game ++of ancient warfare. As the military leader of an ancient civilisation, ++you must gather the resources you need to raise a military force ++capable of dominating your enemies. ++.SH OPTIONS ++.SS Basic gameplay ++.TP ++.B \-autostart ++Load a map instead of showing main menu (see below). ++.TP ++.B \-editor ++Launch the Atlas scenario editor. ++.TP ++.B \-mod NAME ++Start the game using NAME mod. ++.TP ++.B \-quickstart ++Load faster (disables audio and some system info logging). ++.SS Autostart ++.TP ++.B \-autostart=NAME ++Map NAME for scenario, or rms name for random map. ++.TP ++.B \-autostart-ai=PLAYER:AI ++Adds named AI to the given PLAYER (e.g. 2:testbot). ++.SS Multiplayer ++.TP ++.B \-autostart-playername=NAME ++Multiplayer local player NAME (default 'anonymous'). ++.TP ++.B \-autostart-host ++Multiplayer host mode. ++.TP ++.B \-autostart-players=NUMBER ++Multiplayer host: NUMBER of client players (default 2). ++.TP ++.B \-autostart-client ++Multiplayer client mode. ++.TP ++.B \-autostart-ip=IP ++Multiplayer client: connect to this host IP. ++.SS Random maps only ++.TP ++.B \-autostart-random ++Random map. ++.TP ++.B \-autostart-random=SEED ++Random map with SEED value (default 0, use \-1 for random). ++.TP ++.B \-autostart-size=TILES ++Random map SIZE in tiles (default 192). ++.TP ++.B \-autostart-players=NUMBER ++NUMBER of players on random map. ++.SS Configuration ++.TP ++.B \-conf:KEY=VALUE ++Set a config value (overrides the contents of system.cfg). ++.TP ++.B \-g=F ++Set the gamma correction to 'F' (default 1.0). ++.TP ++.B \-nosound ++Disable audio. ++.TP ++.B \-onlyPublicFiles ++Force game to use only the public (default) mod. ++.TP ++.B \-shadows ++Enable shadows. ++.TP ++.B \-vsync ++Enable VSync, i.e. lock FPS to monitor refresh rate. ++.TP ++.B \-xres=N ++Set screen X resolution to 'N'. ++.TP ++.B \-yres=N ++Set screen Y resolution to 'N'. ++.SS Advanced / diagnostic ++.TP ++.B \-dumpSchema ++Creates a file entity.rng in the working directory, containing ++complete entity XML schema, used by various analysis tools. ++.TP ++.B \-replay=PATH ++Non-visual replay of a previous game, used for analysis purposes. ++PATH is system path to commands.txt containing simulation log. ++.TP ++.B \-writableRoot ++Store runtime game data in root data directory (only use if you ++have write permissions on that directory). ++.SS Archive builder ++.TP ++.B \-archivebuild=PATH ++System PATH of the base directory containing mod data to be ++archived/precached. ++.TP ++.B \-archivebuild-output=PATH ++System PATH to output of the resulting .zip archive (use with ++archivebuild). ++.TP ++.B \-archivebuild-compress ++Enable deflate compression in the .zip (no zip compression by ++default since it hurts compression of release packages). ++ ++.SH "FILES" ++.TP ++.B ~/.config/0ad/config/local.cfg ++User specific settings. You may put in this file any user specific ++settings using the same syntax of the default settings file. ++.PP ++0 A.D. also uses the ++.B ~/.cache/0ad/ ++, ++.B ~/.config/0ad/ ++and ++.B ~/.local/share/0ad/ ++directories for other user specific files, such as texture cache, ++screenshots and saved games. ++ ++.SH SEE ALSO ++.TP ++.B http://wildfiregames.com/0ad/ ++0 A.D. main web site. ++.TP ++.B http://trac.wildfiregames.com/ ++0 A.D. wiki and developer web site. ++ ++.SH AUTHOR ++0ad was written by the 0 A.D. Team. ++.PP ++This manual page was written by Fabio Pedretti , ++for the Debian project (and may be used by others). Permission is ++granted to copy, distribute and/or modify this document under the ++terms of the GNU General Public License, Version 2 or any later version ++published by the Free Software Foundation. ++.PP ++On Debian systems, the complete text of the GNU General Public License ++can be found in /usr/share/common-licenses/GPL-2. diff --cc debian/changelog index 0000000,0000000..6a3641e new file mode 100644 --- /dev/null +++ b/debian/changelog @@@ -1,0 -1,0 +1,371 @@@ ++0ad (0.0.23.1-5) unstable; urgency=medium ++ ++ * Fix FTBFS with gcc-10. (Closes: #956967) ++ * Avoid build-dep on unversioned python2. (Closes: #967118) ++ * Cherrypick patch from upstream to add workaround for L3 cache detection on ++ Ryzen 3000 series CPUs. (Closes: #949699) ++ * Update to dh compat level 12. ++ * Update Standards version to 4.5.0. ++ * Add upstream metadata file. ++ ++ -- Vincent Cheng Tue, 18 Aug 2020 02:48:00 -0700 ++ ++0ad (0.0.23.1-4) unstable; urgency=medium ++ ++ * Team upload. ++ * Re-upload source-only to enable migration to testing. ++ ++ -- Bruno Kleinert Mon, 05 Aug 2019 18:56:58 +0200 ++ ++0ad (0.0.23.1-3) unstable; urgency=medium ++ ++ * Team upload. ++ * Build against GTK 3 version of wxWidget. Replaced build dependency ++ libwxgtk3.0-dev by libwxgtk3.0-gtk3-dev. (Closes: #933456) ++ * Added NEWS.Debian to document a workaround for a known issue caused by the ++ GTK 3 variant of wxWidget. ++ ++ -- Bruno Kleinert Sat, 03 Aug 2019 05:18:37 +0200 ++ ++0ad (0.0.23.1-2) unstable; urgency=medium ++ ++ * d/control: version 0.0.23.1 also needs a new 0ad-data ++ ++ -- Ludovic Rousseau Wed, 09 Jan 2019 10:33:09 +0100 ++ ++0ad (0.0.23.1-1) unstable; urgency=medium ++ ++ * New upstream release. ++ - Re-release of 0 A.D. Alpha 23 Ken Wood ++ https://play0ad.com/re-release-of-0-a-d-alpha-23-ken-wood/ ++ * d/control: change Depends: to use 0.0.23 since 0ad-data is unchanged. ++ * Fix "Alpha 23 Lobby lag and other multiplayer issues" (Closes: #905470) ++ ++ -- Ludovic Rousseau Fri, 04 Jan 2019 11:18:19 +0100 ++ ++0ad (0.0.23-1) unstable; urgency=medium ++ ++ * New upstream release. ++ - Remove enable-hardening-relro.patch and armhf-wchar-signedness.patch; ++ obsolete, applied upstream. ++ - Remove create_empty_dirs.patch and move logic into debian/rules. ++ * Add new build-dep on libsodium-dev (>= 1.0.14). ++ * Restore all supported archs as of 0ad/0.0.21-2, i.e. arm64 and kfreebsd-*. ++ * Update Standards version to 4.1.4, no changes required. ++ ++ -- Vincent Cheng Mon, 21 May 2018 23:38:30 -0700 ++ ++0ad (0.0.22-4) unstable; urgency=medium ++ ++ * Create empty directory not stored in git ++ * Add description to a quilt patch ++ * Enable parallel build ++ * Use debhelper version 10 (instead of 9) ++ * Migrate the repository from SVN to GIT ++ ++ -- Ludovic Rousseau Wed, 10 Jan 2018 16:27:16 +0100 ++ ++0ad (0.0.22-3.1) unstable; urgency=medium ++ ++ * Non-maintainer upload with maintainers permission. ++ * Add armhf back to architecture list. ++ * Fix "0ad FTBFS with on armhf with gcc 7: error: call of overloaded ++ 'abs(unsigned int)' is ambiguous" (Closes: #879071) ++ ++ -- Peter Michael Green Tue, 21 Nov 2017 00:15:10 +0000 ++ ++0ad (0.0.22-3) unstable; urgency=medium ++ ++ * remove support of kfreebsd-amd64 and kfreebsd-i386 since auto test fails ++ for 0ad alpha 22 and then 0ad FTBFS. ++ * debian/source/lintian-overrides: remove unused-override ++ outdated-autotools-helper-file. ++ Reported by lintian. ++ * debian/rules: enable hardening=+all ++ ++ -- Ludovic Rousseau Sat, 04 Nov 2017 11:04:26 +0100 ++ ++0ad (0.0.22-2) unstable; urgency=medium ++ ++ * Fix "0ad FTBFS with on armhf with gcc 7: error: call of overloaded ++ 'abs(unsigned int)' is ambiguous" by removing support of armhf ++ (Closes: #879071) ++ * remove support of arm64 because of FTBFS in spidermonkey/mozjs-38.0.0 ++ https://buildd.debian.org/status/fetch.php?pkg=0ad&arch=arm64&ver=0.0.22-1&stamp=1508351579&raw=0 ++ ++ -- Ludovic Rousseau Fri, 27 Oct 2017 16:22:15 +0200 ++ ++0ad (0.0.22-1) unstable; urgency=medium ++ ++ * New upstream release. ++ * Fix "New Release: 0 A.D. Alpha 22 Venustas" (Closes: #872654) ++ * Export SHELL to make mozjs-38 build using debuild(1) ++ ++ -- Ludovic Rousseau Wed, 18 Oct 2017 15:33:17 +0200 ++ ++0ad (0.0.21-2) unstable; urgency=medium ++ ++ * Fix FTBFS by installing missing files with dh_install. ++ ++ -- Vincent Cheng Sat, 12 Nov 2016 22:57:56 -0800 ++ ++0ad (0.0.21-1) unstable; urgency=medium ++ ++ * New upstream release. ++ - Drop debian/patches/fix-gcc6-segfault.patch, obsolete. ++ - Refresh remaining patches. ++ ++ -- Vincent Cheng Sat, 12 Nov 2016 16:46:11 -0800 ++ ++0ad (0.0.20-3) unstable; urgency=medium ++ ++ * Add debian/patches/fix-gcc6-segfault.patch to fix spidermonkey segfault ++ when built with gcc6. (Closes: #835176) ++ * Temporarily disable test suite on arm64 to fix arch-specific FTBFS. ++ * Call dh_strip --dbgsym-migration to cleanly migrate from the old -dbg ++ package to -dbgsym. ++ ++ -- Vincent Cheng Wed, 07 Sep 2016 22:44:22 -0700 ++ ++0ad (0.0.20-2) unstable; urgency=medium ++ ++ * Team upload. ++ * Drop 0ad-dbg package and use the automatic -dbgsym package instead. ++ * d/rules: Remove override for dh_builddeb because xz is the default ++ compression. ++ * Declare compliance with Debian Policy 3.9.8. ++ * Build-depend on python and fix FTBFS. ++ Thanks to Lucas Nussbaum for the report. (Closes: #832870) ++ * Ensure that 0ad can be built twice in a row by updating dh_auto_clean ++ target. Thanks to Peter Green for the patch. ++ ++ -- Markus Koschany Sun, 21 Aug 2016 04:54:55 +0200 ++ ++0ad (0.0.20-1) unstable; urgency=medium ++ ++ * New upstream release. ++ - Drop build-dep on libjpeg-dev. ++ - Refresh patches. ++ * Remove debian/menu file as per tech-ctte decision in #741573. ++ * Update Standards version to 3.9.7, no changes required. ++ * Update jQuery/JavaScript related lintian overrides. ++ ++ -- Vincent Cheng Sun, 03 Apr 2016 19:42:21 -0700 ++ ++0ad (0.0.19-1) unstable; urgency=medium ++ ++ * New upstream release. (Closes: #807447) ++ - Add support for arm64. (Closes: #790306) ++ - Replace dependency on libsdl1.2-dev with libsdl2-dev (>= 2.0.2). ++ - Remove gcc-5.1.patch, applied upstream. ++ - Refresh remaining patches. ++ * Fix typo in override target in d/rules. ++ * Update watch file. ++ ++ -- Vincent Cheng Sun, 20 Dec 2015 19:56:20 -0800 ++ ++0ad (0.0.18-2) unstable; urgency=medium ++ ++ [ Logan Rosen ] ++ * debian/patches/gcc-5.1.patch: Pull patch from upstream Git to fix build ++ with GCC 5.1. ++ ++ -- Vincent Cheng Fri, 28 Aug 2015 20:46:34 -0700 ++ ++0ad (0.0.18-1) unstable; urgency=medium ++ ++ * New upstream release. ++ - Refresh patches. ++ - Replace build-dep on libmozjs-24-dev with libnspr4-dev. ++ ++ -- Vincent Cheng Wed, 18 Mar 2015 16:58:45 -0700 ++ ++0ad (0.0.17-1) unstable; urgency=medium ++ ++ * New upstream release. ++ - Drop debian/patches/{support_miniupnpc_1.9.patch,fix_gcc4.9_ftbfs.patch}: ++ applied upstream. ++ - Add debian/patches/allow-build-with-root.patch. ++ - Add debian/patches/fix-bindir.patch. (LP: #1380737) ++ - Refresh remaining patches. ++ * Update Standards version to 3.9.6, no changes required. ++ ++ -- Vincent Cheng Mon, 13 Oct 2014 20:01:57 -0700 ++ ++0ad (0.0.16-4) unstable; urgency=medium ++ ++ * Add debian/patches/fix_gcc4.9_ftbfs.patch to fix FTBFS when running the ++ test suite when built with gcc 4.9. (Closes: #746822) ++ ++ -- Vincent Cheng Tue, 24 Jun 2014 21:21:36 -0700 ++ ++0ad (0.0.16-3) unstable; urgency=medium ++ ++ * Add debian/patches/support_miniupnpc_1.9.patch to fix FTBFS when built ++ with miniupnpc >= 1.9. (Closes: #751224) ++ * Tighten build-dep on libminiupnpc-dev (>= 1.6). ++ ++ -- Vincent Cheng Wed, 11 Jun 2014 19:46:46 -0700 ++ ++0ad (0.0.16-2) unstable; urgency=medium ++ ++ * Remove armel from Architecture list in debian/control. ++ ++ -- Vincent Cheng Sun, 18 May 2014 19:14:10 -0700 ++ ++0ad (0.0.16-1) unstable; urgency=medium ++ ++ * New upstream release. ++ - Drop debian/patches/fix-kfreebsd-ftbfs.patch; applied upstream. ++ * Avoid repacking tarball by including missing jquery sources in Debian diff, ++ see debian/missing-sources/jquery-1.8.{0,3}.js. Alternative way of fixing ++ #735349. ++ - Update debian/copyright to include missing license entries for the ++ various javascript libraries contained in the source tarball. ++ - Revert changes made to debian/control in 0ad/0.0.15+dfsg-3, i.e.: ++ revert: debian/control: Hardcode versions of 0ad-data{,-common} to ++ depend on to workaround the fact that 0.0.15+dfsg is strictly ++ greater than 0.0.15. ++ * Build-dep on libgloox-dev (>= 1.0.9) to ensure that 0ad is built with ++ newer enough gloox to avoid lobby connectivity issues. ++ * Add new build-deps: libicu-dev, libmozjs-24-dev. ++ ++ -- Vincent Cheng Sat, 17 May 2014 16:30:39 -0700 ++ ++0ad (0.0.15+dfsg-3) unstable; urgency=medium ++ ++ * Repack tarball to remove minified javascript files without source in ++ source/tools/jsdebugger/. (Closes: #735349) ++ - debian/control: Hardcode versions of 0ad-data{,-common} to depend on to ++ workaround the fact that 0.0.15+dfsg is strictly greater than 0.0.15. ++ * Update debian/copyright to include text of IBM Common Public License. ++ * Update email address. ++ ++ -- Vincent Cheng Tue, 18 Feb 2014 23:21:11 -0800 ++ ++0ad (0.0.15-2) unstable; urgency=medium ++ ++ * Add debian/patches/fix-kfreebsd-ftbfs.patch to fix FTBFS on kfreebsd. ++ ++ -- Vincent Cheng Fri, 27 Dec 2013 15:03:44 -0800 ++ ++0ad (0.0.15-1) unstable; urgency=low ++ ++ * New upstream release. ++ - Remove fix-arm-ftbfs.patch, fixed upstream. ++ * Add build-dep on libgloox-dev and libminiupnpc-dev. ++ * Append '~' to libnvtt-dev build dependency to ease backporting. ++ * Prefer libwxgtk3.0-dev over libwxgtk2.8-dev as build-dep (keep latter as ++ alternate build-dep to ease backports). ++ * Update Standards version to 3.9.5, no changes required. ++ ++ -- Vincent Cheng Wed, 25 Dec 2013 17:41:29 -0800 ++ ++0ad (0.0.14-3) unstable; urgency=low ++ ++ * Add debian/patches/fix-arm-ftbfs.patch to fix FTBFS on armel and armhf. ++ ++ -- Vincent Cheng Tue, 17 Sep 2013 01:08:10 -0700 ++ ++0ad (0.0.14-2) unstable; urgency=low ++ ++ * Tighten build dependency on libnvtt-dev to >= 2.0.8-1+dfsg-4 to ensure ++ that amd64 builds of 0ad do not FTBFS on certain hardware. See #713966 ++ for details. ++ * Build 0ad for armel and armhf. ++ ++ -- Vincent Cheng Fri, 06 Sep 2013 23:00:24 -0700 ++ ++0ad (0.0.14-1) unstable; urgency=low ++ ++ * New upstream release. ++ - Remove fix-bindir.patch, boost-libnames.patch; applied/fixed upstream. ++ - Refresh remaining patches. ++ ++ -- Vincent Cheng Thu, 05 Sep 2013 20:02:20 -0700 ++ ++0ad (0.0.13-2) unstable; urgency=low ++ ++ * Add boost-libnames.patch to fix FTBFS with boost 1.53. (Closes: #709570) ++ ++ -- Vincent Cheng Fri, 24 May 2013 01:47:14 -0700 ++ ++0ad (0.0.13-1) unstable; urgency=low ++ ++ * New upstream release. ++ - Refresh patches. ++ * Add icon to Debian menu entry. (Closes: #703254) ++ ++ -- Vincent Cheng Tue, 02 Apr 2013 19:40:54 -0700 ++ ++0ad (0.0.12-1) unstable; urgency=low ++ ++ [ Vincent Cheng ] ++ * New upstream release. ++ - Remove debian/patches/fix-kfreebsd-ftbfs.patch; applied upstream. ++ - Refresh remaining patches. ++ * Add depends on 0ad-data-common. ++ * Add lintian overrides for: ++ - outdated-autotools-helper-file (caused by config.{guess,sub} in a ++ convenience copy of libenet, which we don't use). ++ - version-substvar-for-external-package (not a problem since 0ad and ++ 0ad-data uploaded at same time, and no other mechanism provided by ++ dpkg-gencontrol for packages that want to depend on versioned packages ++ built from a separate source package). ++ * Update Standards version to 3.9.4, no changes required. ++ * Enable verbose build. ++ ++ [ Ansgar Burchardt ] ++ * debian/control: Remove DM-Upload-Allowed. ++ ++ -- Vincent Cheng Tue, 12 Feb 2013 19:24:59 -0800 ++ ++0ad (0.0.11-1) unstable; urgency=low ++ ++ * New upstream release. (Alpha 11 Kronos) ++ - Upstream disabled FAM support as of svn r12550, so remove build-depends ++ on libgamin-dev, and remove depends on gamin | fam. (Closes: #679087) ++ - Refresh existing patches. ++ * Add fallback to launcher script when /usr/games is not in $PATH. ++ (Closes: #679033) ++ * Restrict list of architectures to i386, amd64, and kfreebsd-{i386,amd64}. ++ (Closes: #683282) ++ * Update debian/watch file. ++ * Add DMUA field in debian/control with agreement of sponsor. ++ ++ -- Vincent Cheng Sat, 08 Sep 2012 02:43:25 -0700 ++ ++0ad (0~r11863-2) unstable; urgency=low ++ ++ * Add stricter dependency on 0ad-data. (Closes: #673526) ++ ++ -- Vincent Cheng Sun, 20 May 2012 01:48:59 -0700 ++ ++0ad (0~r11863-1) unstable; urgency=low ++ ++ * New upstream release. ++ - Refresh patches. ++ * Add debian/patches/enable-hardening-relro.patch to build using the ++ "read-only relocation" link flag, as suggested by lintian. ++ * Add build-depends on libxcursor-dev. ++ ++ -- Vincent Cheng Wed, 16 May 2012 23:50:12 -0700 ++ ++0ad (0~r11339-2) unstable; urgency=low ++ ++ * Add debian/patches/fix-kfreebsd-ftbfs.patch to fix FTBFS on kfreebsd. ++ * Update debian/0ad.6. ++ * Add build-depends on dpkg-dev (>= 1.15.5) for xz compression support. ++ * Change build-depends on libjpeg8-dev to libjpeg-dev. ++ * Change build-depends on libpng12-dev to libpng-dev. (Closes: #668453) ++ * Add alternate build-depends on libcurl4-dev. ++ * Add alternate dependency on fam. (Closes: #668353) ++ * Override dh_auto_clean to clean source properly. (Closes: #668686) ++ ++ -- Vincent Cheng Thu, 26 Apr 2012 19:12:26 -0700 ++ ++0ad (0~r11339-1) unstable; urgency=low ++ ++ * Initial release (Closes: #594800) ++ ++ -- Vincent Cheng Thu, 29 Mar 2012 16:13:33 -0700 diff --cc debian/control index 0000000,0000000..ee91c02 new file mode 100644 --- /dev/null +++ b/debian/control @@@ -1,0 -1,0 +1,57 @@@ ++Source: 0ad ++Section: games ++Priority: optional ++Maintainer: Debian Games Team ++Uploaders: ++ Vincent Cheng , ++ Ludovic Rousseau ++Build-Depends: ++ autoconf, ++ debhelper-compat (= 12), ++ dpkg-dev (>= 1.15.5), ++ libboost-dev, ++ libboost-filesystem-dev, ++ libcurl4-gnutls-dev | libcurl4-dev, ++ libenet-dev (>= 1.3), ++ libgloox-dev (>= 1.0.10), ++ libicu-dev, ++ libminiupnpc-dev (>= 1.6), ++ libnspr4-dev, ++ libnvtt-dev (>= 2.0.8-1+dfsg-4~), ++ libogg-dev, ++ libopenal-dev, ++ libpng-dev, ++ libsdl2-dev (>= 2.0.2), ++ libsodium-dev (>= 1.0.14), ++ libvorbis-dev, ++ libwxgtk3.0-gtk3-dev, ++ libxcursor-dev, ++ libxml2-dev, ++ pkg-config, ++ python2, ++ python3, ++ zlib1g-dev ++Standards-Version: 4.5.0 ++Homepage: http://play0ad.com/ ++Vcs-Git: https://salsa.debian.org/games-team/0ad.git ++Vcs-Browser: https://salsa.debian.org/games-team/0ad ++Rules-Requires-Root: no ++ ++Package: 0ad ++Architecture: amd64 arm64 armhf i386 kfreebsd-amd64 kfreebsd-i386 ++Pre-Depends: dpkg (>= 1.15.6~) ++Depends: ++ 0ad-data (>= ${source:Upstream-Version}), ++ 0ad-data (<= ${source:Version}), ++ 0ad-data-common (>= ${source:Upstream-Version}), ++ 0ad-data-common (<= ${source:Version}), ++ ${misc:Depends}, ++ ${shlibs:Depends} ++Description: Real-time strategy game of ancient warfare ++ 0 A.D. (pronounced "zero ey-dee") is a free, open-source, cross-platform ++ real-time strategy (RTS) game of ancient warfare. In short, it is a ++ historically-based war/economy game that allows players to relive or rewrite ++ the history of Western civilizations, focusing on the years between 500 B.C. ++ and 500 A.D. The project is highly ambitious, involving state-of-the-art 3D ++ graphics, detailed artwork, sound, and a flexible and powerful custom-built ++ game engine. diff --cc debian/copyright index 0000000,0000000..7f72083 new file mode 100644 --- /dev/null +++ b/debian/copyright @@@ -1,0 -1,0 +1,945 @@@ ++Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/ ++Upstream-Name: 0ad ++Source: http://releases.wildfiregames.com/ ++ ++Files: * ++Copyright: 2010 Wildfire Games ++License: GPL-2.0+ ++ ++Files: debian/* ++Copyright: 2010-2012 Rico Tzschichholz ++ 2012-2014 Vincent Cheng ++License: GPL-2.0+ ++ ++Files: debian/0ad.6 ++Copyright: 2010 Fabio Pedretti ++License: GPL-2.0+ ++ ++Files: source/lib/* ++Copyright: 2010 Wildfire Games ++License: Expat ++ ++Files: source/ps/Preprocessor.h ++ source/ps/Preprocessor.cpp ++Copyright: 2000-2009 Torus Knot Software Ltd ++License: Expat ++ ++Files: source/third_party/* ++Copyright: 2004-2011 Sergey Lyubka ++License: Expat ++ ++Files: source/tools/fontbuilder2/Packer.py ++Copyright: 2002-2009 Nuclex Development Labs ++License: CPL ++ ++Files: source/tools/templatesanalyzer/tablefilter/* ++Copyright: 2014-2016 Max Guglielmi ++License: Expat ++ ++Files: build/premake/* ++Copyright: 2002-2009 Jason Perkins and the Premake project ++License: BSD-3-clause ++ ++Files: libraries/source/cxxtest-4.4/* ++Copyright: 2004 Erez Volk ++ 2004 Jared Grubb ++ 2004 Kevin Fitch ++License: LGPL-2.1+ ++ ++Files: libraries/source/fcollada/* ++Copyright: 2005-2007 Feeling Software Inc. ++ 2005-2007 Sony Computer Entertainment America ++License: Expat ++ ++Files: libraries/source/fcollada/include/FCDocument/* ++ libraries/source/fcollada/include/FUtils/* ++ libraries/source/fcollada/src/FCollada/FCDocument/* ++ libraries/source/fcollada/src/FCollada/FUtils/* ++ libraries/source/fcollada/src/FColladaPlugins/FArchiveXML/* ++Copyright: 2005-2006 Autodesk Media Entertainment ++ 2005-2007 Feeling Software Inc. ++ 2005-2007 Sony Computer Entertainment America ++License: Expat ++ ++Files: libraries/source/nvtt/* ++Copyright: 2007 NVIDIA Corporation ++License: Expat ++ ++Files: libraries/source/nvtt/src/src/nvtt/squish/* ++Copyright: 2006 Simon Brown ++License: Expat ++ ++Files: libraries/source/nvtt/src/src/nvcore/poshlib/posh.c ++ libraries/source/nvtt/src/src/nvcore/poshlib/posh.h ++Copyright: 2004 Brian Hook ++License: BSD-3-clause ++ ++Files: libraries/source/nvtt/src/src/nvcore/BitArray.h ++ libraries/source/nvtt/src/src/nvcore/Containers.h ++ libraries/source/nvtt/src/src/nvcore/Debug.cpp ++ libraries/source/nvtt/src/src/nvcore/Debug.h ++ libraries/source/nvtt/src/src/nvcore/Library.h ++ libraries/source/nvtt/src/src/nvcore/Memory.cpp ++ libraries/source/nvtt/src/src/nvcore/Memory.h ++ libraries/source/nvtt/src/src/nvcore/Prefetch.h ++ libraries/source/nvtt/src/src/nvcore/Ptr.h ++ libraries/source/nvtt/src/src/nvcore/StrLib.cpp ++ libraries/source/nvtt/src/src/nvcore/StrLib.h ++ libraries/source/nvtt/src/src/nvcore/Stream.h ++ libraries/source/nvtt/src/src/nvcore/TextReader.cpp ++ libraries/source/nvtt/src/src/nvcore/TextReader.h ++ libraries/source/nvtt/src/src/nvcore/TextWriter.cpp ++ libraries/source/nvtt/src/src/nvcore/TextWriter.h ++ libraries/source/nvtt/src/src/nvcore/Tokenizer.cpp ++ libraries/source/nvtt/src/src/nvcore/Tokenizer.h ++ libraries/source/nvtt/src/src/nvcore/nvcore.h ++ libraries/source/nvtt/src/src/nvimage/ColorBlock.cpp ++ libraries/source/nvtt/src/src/nvimage/ColorBlock.h ++ libraries/source/nvtt/src/src/nvimage/Filter.cpp ++ libraries/source/nvtt/src/src/nvimage/Filter.h ++ libraries/source/nvtt/src/src/nvimage/FloatImage.cpp ++ libraries/source/nvtt/src/src/nvimage/FloatImage.h ++ libraries/source/nvtt/src/src/nvimage/HoleFilling.cpp ++ libraries/source/nvtt/src/src/nvimage/HoleFilling.h ++ libraries/source/nvtt/src/src/nvimage/Image.cpp ++ libraries/source/nvtt/src/src/nvimage/Image.h ++ libraries/source/nvtt/src/src/nvimage/ImageIO.cpp ++ libraries/source/nvtt/src/src/nvimage/ImageIO.h ++ libraries/source/nvtt/src/src/nvimage/NormalMipmap.cpp ++ libraries/source/nvtt/src/src/nvimage/NormalMipmap.h ++ libraries/source/nvtt/src/src/nvimage/PsdFile.h ++ libraries/source/nvtt/src/src/nvimage/Quantize.cpp ++ libraries/source/nvtt/src/src/nvimage/Quantize.h ++ libraries/source/nvtt/src/src/nvimage/TgaFile.h ++ libraries/source/nvtt/src/src/nvimage/nvimage.h ++ libraries/source/nvtt/src/src/nvmath/Basis.cpp ++ libraries/source/nvtt/src/src/nvmath/Basis.h ++ libraries/source/nvtt/src/src/nvmath/Box.h ++ libraries/source/nvtt/src/src/nvmath/Color.h ++ libraries/source/nvtt/src/src/nvmath/Matrix.h ++ libraries/source/nvtt/src/src/nvmath/Montecarlo.cpp ++ libraries/source/nvtt/src/src/nvmath/Montecarlo.h ++ libraries/source/nvtt/src/src/nvmath/Plane.cpp ++ libraries/source/nvtt/src/src/nvmath/Plane.h ++ libraries/source/nvtt/src/src/nvmath/Quaternion.h ++ libraries/source/nvtt/src/src/nvmath/Random.cpp ++ libraries/source/nvtt/src/src/nvmath/Random.h ++ libraries/source/nvtt/src/src/nvmath/SphericalHarmonic.cpp ++ libraries/source/nvtt/src/src/nvmath/SphericalHarmonic.h ++ libraries/source/nvtt/src/src/nvmath/Triangle.cpp ++ libraries/source/nvtt/src/src/nvmath/Triangle.h ++ libraries/source/nvtt/src/src/nvmath/Vector.h ++ libraries/source/nvtt/src/src/nvmath/nvmath.h ++Copyright: Ignacio Castano ++License: public-domain ++ The license is not specified beyond public-domain. ++ The line from the source code is the following: ++ "This code is in the public domain -- castanyo@yahoo.es" ++ ++Files: libraries/source/spidermonkey/* ++Copyright: 1998-2011 Mozilla Corporation ++License: MPL-1.1 and GPL-2.0 and LGPL-2.1 ++ ++Files: libraries/source/valgrind/* ++Copyright: 2003-2009 Josef Weidendorfer ++ 2000-2009 Julian Seward ++License: Expat ++ ++License: BSD-3-clause ++ Redistribution and use in source and binary forms, with or without ++ modification, are permitted provided that the following conditions are met: ++ * Redistributions of source code must retain the above copyright ++ notice, this list of conditions and the following disclaimer. ++ * Redistributions in binary form must reproduce the above copyright ++ notice, this list of conditions and the following disclaimer in the ++ documentation and/or other materials provided with the distribution. ++ * Neither the name of the nor the ++ names of its contributors may be used to endorse or promote products ++ derived from this software without specific prior written permission. ++ . ++ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ++ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED ++ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE ++ DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY ++ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES ++ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ++ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ++ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS ++ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ++ ++License: CPL ++ THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS COMMON PUBLIC ++ LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM ++ CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT. ++ . ++ 1. DEFINITIONS ++ . ++ "Contribution" means: ++ . ++ a) in the case of the initial Contributor, the initial code and ++ documentation distributed under this Agreement, and ++ . ++ b) in the case of each subsequent Contributor: ++ . ++ i) changes to the Program, and ++ . ++ ii) additions to the Program; ++ . ++ where such changes and/or additions to the Program originate from and are ++ distributed by that particular Contributor. A Contribution 'originates' from a ++ Contributor if it was added to the Program by such Contributor itself or anyone ++ acting on such Contributor's behalf. Contributions do not include additions to ++ the Program which: (i) are separate modules of software distributed in ++ conjunction with the Program under their own license agreement, and (ii) are not ++ derivative works of the Program. ++ . ++ "Contributor" means any person or entity that distributes the Program. ++ . ++ "Licensed Patents " mean patent claims licensable by a Contributor which are ++ necessarily infringed by the use or sale of its Contribution alone or when ++ combined with the Program. ++ . ++ "Program" means the Contributions distributed in accordance with this Agreement. ++ . ++ "Recipient" means anyone who receives the Program under this Agreement, ++ including all Contributors. ++ . ++ 2. GRANT OF RIGHTS ++ . ++ a) Subject to the terms of this Agreement, each Contributor hereby grants ++ Recipient a non-exclusive, worldwide, royalty-free copyright license to ++ reproduce, prepare derivative works of, publicly display, publicly perform, ++ distribute and sublicense the Contribution of such Contributor, if any, and such ++ derivative works, in source code and object code form. ++ . ++ b) Subject to the terms of this Agreement, each Contributor hereby grants ++ Recipient a non-exclusive, worldwide, royalty-free patent license under Licensed ++ Patents to make, use, sell, offer to sell, import and otherwise transfer the ++ Contribution of such Contributor, if any, in source code and object code form. ++ This patent license shall apply to the combination of the Contribution and the ++ Program if, at the time the Contribution is added by the Contributor, such ++ addition of the Contribution causes such combination to be covered by the ++ Licensed Patents. The patent license shall not apply to any other combinations ++ which include the Contribution. No hardware per se is licensed hereunder. ++ . ++ c) Recipient understands that although each Contributor grants the licenses ++ to its Contributions set forth herein, no assurances are provided by any ++ Contributor that the Program does not infringe the patent or other intellectual ++ property rights of any other entity. Each Contributor disclaims any liability to ++ Recipient for claims brought by any other entity based on infringement of ++ intellectual property rights or otherwise. As a condition to exercising the ++ rights and licenses granted hereunder, each Recipient hereby assumes sole ++ responsibility to secure any other intellectual property rights needed, if any. ++ For example, if a third party patent license is required to allow Recipient to ++ distribute the Program, it is Recipient's responsibility to acquire that license ++ before distributing the Program. ++ . ++ d) Each Contributor represents that to its knowledge it has sufficient ++ copyright rights in its Contribution, if any, to grant the copyright license set ++ forth in this Agreement. ++ . ++ 3. REQUIREMENTS ++ . ++ A Contributor may choose to distribute the Program in object code form under its ++ own license agreement, provided that: ++ . ++ a) it complies with the terms and conditions of this Agreement; and ++ . ++ b) its license agreement: ++ . ++ i) effectively disclaims on behalf of all Contributors all warranties and ++ conditions, express and implied, including warranties or conditions of title and ++ non-infringement, and implied warranties or conditions of merchantability and ++ fitness for a particular purpose; ++ . ++ ii) effectively excludes on behalf of all Contributors all liability for ++ damages, including direct, indirect, special, incidental and consequential ++ damages, such as lost profits; ++ . ++ iii) states that any provisions which differ from this Agreement are offered ++ by that Contributor alone and not by any other party; and ++ . ++ iv) states that source code for the Program is available from such ++ Contributor, and informs licensees how to obtain it in a reasonable manner on or ++ through a medium customarily used for software exchange. ++ . ++ When the Program is made available in source code form: ++ . ++ a) it must be made available under this Agreement; and ++ . ++ b) a copy of this Agreement must be included with each copy of the Program. ++ . ++ Contributors may not remove or alter any copyright notices contained within the ++ Program. ++ . ++ Each Contributor must identify itself as the originator of its Contribution, if ++ any, in a manner that reasonably allows subsequent Recipients to identify the ++ originator of the Contribution. ++ . ++ 4. COMMERCIAL DISTRIBUTION ++ . ++ Commercial distributors of software may accept certain responsibilities with ++ respect to end users, business partners and the like. While this license is ++ intended to facilitate the commercial use of the Program, the Contributor who ++ includes the Program in a commercial product offering should do so in a manner ++ which does not create potential liability for other Contributors. Therefore, if ++ a Contributor includes the Program in a commercial product offering, such ++ Contributor ("Commercial Contributor") hereby agrees to defend and indemnify ++ every other Contributor ("Indemnified Contributor") against any losses, damages ++ and costs (collectively "Losses") arising from claims, lawsuits and other legal ++ actions brought by a third party against the Indemnified Contributor to the ++ extent caused by the acts or omissions of such Commercial Contributor in ++ connection with its distribution of the Program in a commercial product ++ offering. The obligations in this section do not apply to any claims or Losses ++ relating to any actual or alleged intellectual property infringement. In order ++ to qualify, an Indemnified Contributor must: a) promptly notify the Commercial ++ Contributor in writing of such claim, and b) allow the Commercial Contributor to ++ control, and cooperate with the Commercial Contributor in, the defense and any ++ related settlement negotiations. The Indemnified Contributor may participate in ++ any such claim at its own expense. ++ . ++ For example, a Contributor might include the Program in a commercial product ++ offering, Product X. That Contributor is then a Commercial Contributor. If that ++ Commercial Contributor then makes performance claims, or offers warranties ++ related to Product X, those performance claims and warranties are such ++ Commercial Contributor's responsibility alone. Under this section, the ++ Commercial Contributor would have to defend claims against the other ++ Contributors related to those performance claims and warranties, and if a court ++ requires any other Contributor to pay any damages as a result, the Commercial ++ Contributor must pay those damages. ++ . ++ 5. NO WARRANTY ++ . ++ EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN ++ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR ++ IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, ++ NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each ++ Recipient is solely responsible for determining the appropriateness of using and ++ distributing the Program and assumes all risks associated with its exercise of ++ rights under this Agreement, including but not limited to the risks and costs of ++ program errors, compliance with applicable laws, damage to or loss of data, ++ programs or equipment, and unavailability or interruption of operations. ++ . ++ 6. DISCLAIMER OF LIABILITY ++ . ++ EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY ++ CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST ++ PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS ++ GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. ++ . ++ 7. GENERAL ++ . ++ If any provision of this Agreement is invalid or unenforceable under applicable ++ law, it shall not affect the validity or enforceability of the remainder of the ++ terms of this Agreement, and without further action by the parties hereto, such ++ provision shall be reformed to the minimum extent necessary to make such ++ provision valid and enforceable. ++ . ++ If Recipient institutes patent litigation against a Contributor with respect to ++ a patent applicable to software (including a cross-claim or counterclaim in a ++ lawsuit), then any patent licenses granted by that Contributor to such Recipient ++ under this Agreement shall terminate as of the date such litigation is filed. In ++ addition, if Recipient institutes patent litigation against any entity ++ (including a cross-claim or counterclaim in a lawsuit) alleging that the Program ++ itself (excluding combinations of the Program with other software or hardware) ++ infringes such Recipient's patent(s), then such Recipient's rights granted under ++ Section 2(b) shall terminate as of the date such litigation is filed. ++ . ++ All Recipient's rights under this Agreement shall terminate if it fails to ++ comply with any of the material terms or conditions of this Agreement and does ++ not cure such failure in a reasonable period of time after becoming aware of ++ such noncompliance. If all Recipient's rights under this Agreement terminate, ++ Recipient agrees to cease use and distribution of the Program as soon as ++ reasonably practicable. However, Recipient's obligations under this Agreement ++ and any licenses granted by Recipient relating to the Program shall continue and ++ survive. ++ . ++ Everyone is permitted to copy and distribute copies of this Agreement, but in ++ order to avoid inconsistency the Agreement is copyrighted and may only be ++ modified in the following manner. The Agreement Steward reserves the right to ++ publish new versions (including revisions) of this Agreement from time to time. ++ No one other than the Agreement Steward has the right to modify this Agreement. ++ IBM is the initial Agreement Steward. IBM may assign the responsibility to serve ++ as the Agreement Steward to a suitable separate entity. Each new version of the ++ Agreement will be given a distinguishing version number. The Program (including ++ Contributions) may always be distributed subject to the version of the Agreement ++ under which it was received. In addition, after a new version of the Agreement ++ is published, Contributor may elect to distribute the Program (including its ++ Contributions) under the new version. Except as expressly stated in Sections ++ 2(a) and 2(b) above, Recipient receives no rights or licenses to the ++ intellectual property of any Contributor under this Agreement, whether ++ expressly, by implication, estoppel or otherwise. All rights in the Program not ++ expressly granted under this Agreement are reserved. ++ . ++ This Agreement is governed by the laws of the State of New York and the ++ intellectual property laws of the United States of America. No party to this ++ Agreement will bring a legal action under this Agreement more than one year ++ after the cause of action arose. Each party waives its rights to a jury trial in ++ any resulting litigation. ++ ++License: Expat ++ Permission is hereby granted, free of charge, to any person obtaining a copy ++ of this software and associated documentation files (the "Software"), to deal ++ in the Software without restriction, including without limitation the rights ++ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell ++ copies of the Software, and to permit persons to whom the Software is ++ furnished to do so, subject to the following conditions: ++ . ++ The above copyright notice and this permission notice shall be included in ++ all copies or substantial portions of the Software. ++ . ++ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE ++ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER ++ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ++ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN ++ THE SOFTWARE ++ ++License: GPL-2.0 ++ This package is free software; you can redistribute it and/or modify ++ it under the terms of the GNU General Public License, version 2 of ++ the License, as published by the Free Software Foundation. ++ . ++ This package is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ . ++ You should have received a copy of the GNU General Public License ++ along with this program. If not, see ++ . ++ On Debian systems, the complete text of the GNU General ++ Public License version 2 can be found in "/usr/share/common-licenses/GPL-2". ++ ++License: GPL-2.0+ ++ This package is free software; you can redistribute it and/or modify ++ it under the terms of the GNU General Public License as published by ++ the Free Software Foundation; either version 2 of the License, or ++ (at your option) any later version. ++ . ++ This package is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ . ++ You should have received a copy of the GNU General Public License ++ along with this program. If not, see ++ . ++ On Debian systems, the complete text of the GNU General ++ Public License version 2 can be found in "/usr/share/common-licenses/GPL-2". ++ ++License: LGPL-2.1 ++ This library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License, version 2.1 of the License, as published by the ++ Free Software Foundation. ++ . ++ This library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ . ++ You should have received a copy of the GNU General Public License ++ along with this program. If not, see ++ . ++ On Debian systems, the complete text of the GNU General ++ Public License version 2 can be found in "/usr/share/common-licenses/ ++ LGPL-2.1". ++ ++License: LGPL-2.1+ ++ This library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) any later version. ++ . ++ This library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ . ++ You should have received a copy of the GNU General Public License ++ along with this program. If not, see ++ . ++ On Debian systems, the complete text of the GNU General ++ Public License version 2 can be found in "/usr/share/common-licenses/ ++ LGPL-2.1". ++ ++License: MPL-1.1 ++ Mozilla Public License Version 1.1 ++ . ++ 1. Definitions. ++ . ++ 1.0.1. "Commercial Use" ++ means distribution or otherwise making the Covered Code available ++ to a third party. ++ 1.1. "Contributor" ++ means each entity that creates or contributes to the creation of ++ Modifications. ++ 1.2. "Contributor Version" ++ means the combination of the Original Code, prior Modifications ++ used by a Contributor, and the Modifications made by that ++ particular Contributor. ++ 1.3. "Covered Code" ++ means the Original Code or Modifications or the combination of ++ the Original Code and Modifications, in each case including ++ portions thereof. ++ 1.4. "Electronic Distribution Mechanism" ++ means a mechanism generally accepted in the software development ++ community for the electronic transfer of data. ++ 1.5. "Executable" ++ means Covered Code in any form other than Source Code. ++ 1.6. "Initial Developer" ++ means the individual or entity identified as the Initial ++ Developer in the Source Code notice required by Exhibit A. ++ 1.7. "Larger Work" ++ means a work which combines Covered Code or portions thereof with ++ code not governed by the terms of this License. ++ 1.8. "License" ++ means this document. ++ 1.8.1. "Licensable" ++ means having the right to grant, to the maximum extent possible, ++ whether at the time of the initial grant or subsequently ++ acquired, any and all of the rights conveyed herein. ++ 1.9. "Modifications" ++ means any addition to or deletion from the substance or structure ++ of either the Original Code or any previous Modifications. When ++ Covered Code is released as a series of files, a Modification is: ++ a. Any addition to or deletion from the contents of a file ++ containing Original Code or previous Modifications. ++ b. Any new file that contains any part of the Original Code or ++ previous Modifications. ++ 1.10. "Original Code" ++ means Source Code of computer software code which is described in ++ the Source Code notice required by Exhibit A as Original Code, ++ and which, at the time of its release under this License is not ++ already Covered Code governed by this License. ++ 1.10.1. "Patent Claims" ++ means any patent claim(s), now owned or hereafter acquired, ++ including without limitation, method, process, and apparatus ++ claims, in any patent Licensable by grantor. ++ 1.11. "Source Code" ++ means the preferred form of the Covered Code for making ++ modifications to it, including all modules it contains, plus any ++ associated interface definition files, scripts used to control ++ compilation and installation of an Executable, or source code ++ differential comparisons against either the Original Code or ++ another well known, available Covered Code of the Contributor's ++ choice. The Source Code can be in a compressed or archival form, ++ provided the appropriate decompression or de-archiving software ++ is widely available for no charge. ++ 1.12. "You" (or "Your") ++ means an individual or a legal entity exercising rights under, ++ and complying with all of the terms of, this License or a future ++ version of this License issued under Section 6.1. For legal ++ entities, "You" includes any entity which controls, is controlled ++ by, or is under common control with You. For purposes of this ++ definition, "control" means (a) the power, direct or indirect, to ++ cause the direction or management of such entity, whether by ++ contract or otherwise, or (b) ownership of more than fifty ++ percent (50%) of the outstanding shares or beneficial ownership ++ of such entity. ++ . ++ 2. Source Code License. ++ . ++ 2.1. The Initial Developer Grant. ++ . ++ The Initial Developer hereby grants You a world-wide, royalty-free, ++ non-exclusive license, subject to third party intellectual property ++ claims: ++ . ++ a. under intellectual property rights (other than patent or ++ trademark) Licensable by Initial Developer to use, reproduce, ++ modify, display, perform, sublicense and distribute the Original ++ Code (or portions thereof) with or without Modifications, and/or ++ as part of a Larger Work; and ++ b. under Patents Claims infringed by the making, using or selling of ++ Original Code, to make, have made, use, practice, sell, and offer ++ for sale, and/or otherwise dispose of the Original Code (or ++ portions thereof). ++ c. the licenses granted in this Section 2.1 (a) and (b) are ++ effective on the date Initial Developer first distributes ++ Original Code under the terms of this License. ++ d. Notwithstanding Section 2.1 (b) above, no patent license is ++ granted: 1) for code that You delete from the Original Code; 2) ++ separate from the Original Code; or 3) for infringements caused ++ by: i) the modification of the Original Code or ii) the ++ combination of the Original Code with other software or devices. ++ . ++ 2.2. Contributor Grant. ++ . ++ Subject to third party intellectual property claims, each Contributor ++ hereby grants You a world-wide, royalty-free, non-exclusive license ++ . ++ a. under intellectual property rights (other than patent or ++ trademark) Licensable by Contributor, to use, reproduce, modify, ++ display, perform, sublicense and distribute the Modifications ++ created by such Contributor (or portions thereof) either on an ++ unmodified basis, with other Modifications, as Covered Code and/ ++ or as part of a Larger Work; and ++ b. under Patent Claims infringed by the making, using, or selling of ++ Modifications made by that Contributor either alone and/or in ++ combination with its Contributor Version (or portions of such ++ combination), to make, use, sell, offer for sale, have made, and/ ++ or otherwise dispose of: 1) Modifications made by that ++ Contributor (or portions thereof); and 2) the combination of ++ Modifications made by that Contributor with its Contributor ++ Version (or portions of such combination). ++ c. the licenses granted in Sections 2.2 (a) and 2.2 (b) are ++ effective on the date Contributor first makes Commercial Use of ++ the Covered Code. ++ d. Notwithstanding Section 2.2 (b) above, no patent license is ++ granted: 1) for any code that Contributor has deleted from the ++ Contributor Version; 2) separate from the Contributor Version; 3) ++ for infringements caused by: i) third party modifications of ++ Contributor Version or ii) the combination of Modifications made ++ by that Contributor with other software (except as part of the ++ Contributor Version) or other devices; or 4) under Patent Claims ++ infringed by Covered Code in the absence of Modifications made by ++ that Contributor. ++ . ++ 3. Distribution Obligations. ++ . ++ 3.1. Application of License. ++ . ++ The Modifications which You create or to which You contribute are ++ governed by the terms of this License, including without limitation ++ Section 2.2. The Source Code version of Covered Code may be ++ distributed only under the terms of this License or a future version ++ of this License released under Section 6.1, and You must include a ++ copy of this License with every copy of the Source Code You ++ distribute. You may not offer or impose any terms on any Source Code ++ version that alters or restricts the applicable version of this ++ License or the recipients' rights hereunder. However, You may include ++ an additional document offering the additional rights described in ++ Section 3.5. ++ . ++ 3.2. Availability of Source Code. ++ . ++ Any Modification which You create or to which You contribute must be ++ made available in Source Code form under the terms of this License ++ either on the same media as an Executable version or via an accepted ++ Electronic Distribution Mechanism to anyone to whom you made an ++ Executable version available; and if made available via Electronic ++ Distribution Mechanism, must remain available for at least twelve ++ (12) months after the date it initially became available, or at least ++ six (6) months after a subsequent version of that particular ++ Modification has been made available to such recipients. You are ++ responsible for ensuring that the Source Code version remains ++ available even if the Electronic Distribution Mechanism is maintained ++ by a third party. ++ . ++ 3.3. Description of Modifications. ++ . ++ You must cause all Covered Code to which You contribute to contain a ++ file documenting the changes You made to create that Covered Code and ++ the date of any change. You must include a prominent statement that ++ the Modification is derived, directly or indirectly, from Original ++ Code provided by the Initial Developer and including the name of the ++ Initial Developer in (a) the Source Code, and (b) in any notice in an ++ Executable version or related documentation in which You describe the ++ origin or ownership of the Covered Code. ++ . ++ 3.4. Intellectual Property Matters ++ . ++ (a) Third Party Claims ++ . ++ If Contributor has knowledge that a license under a third party's ++ intellectual property rights is required to exercise the rights ++ granted by such Contributor under Sections 2.1 or 2.2, Contributor ++ must include a text file with the Source Code distribution titled ++ "LEGAL" which describes the claim and the party making the claim in ++ sufficient detail that a recipient will know whom to contact. If ++ Contributor obtains such knowledge after the Modification is made ++ available as described in Section 3.2, Contributor shall promptly ++ modify the LEGAL file in all copies Contributor makes available ++ thereafter and shall take other steps (such as notifying appropriate ++ mailing lists or newsgroups) reasonably calculated to inform those ++ who received the Covered Code that new knowledge has been obtained. ++ . ++ (b) Contributor APIs ++ . ++ If Contributor's Modifications include an application programming ++ interface and Contributor has knowledge of patent licenses which are ++ reasonably necessary to implement that API, Contributor must also ++ include this information in the legal file. ++ . ++ (c) Representations. ++ . ++ Contributor represents that, except as disclosed pursuant to Section ++ 3.4 (a) above, Contributor believes that Contributor's Modifications ++ are Contributor's original creation(s) and/or Contributor has ++ sufficient rights to grant the rights conveyed by this License. ++ . ++ 3.5. Required Notices. ++ . ++ You must duplicate the notice in Exhibit A in each file of the Source ++ Code. If it is not possible to put such notice in a particular Source ++ Code file due to its structure, then You must include such notice in ++ a location (such as a relevant directory) where a user would be ++ likely to look for such a notice. If You created one or more ++ Modification(s) You may add your name as a Contributor to the notice ++ described in Exhibit A. You must also duplicate this License in any ++ documentation for the Source Code where You describe recipients' ++ rights or ownership rights relating to Covered Code. You may choose ++ to offer, and to charge a fee for, warranty, support, indemnity or ++ liability obligations to one or more recipients of Covered Code. ++ However, You may do so only on Your own behalf, and not on behalf of ++ the Initial Developer or any Contributor. You must make it absolutely ++ clear than any such warranty, support, indemnity or liability ++ obligation is offered by You alone, and You hereby agree to indemnify ++ the Initial Developer and every Contributor for any liability ++ incurred by the Initial Developer or such Contributor as a result of ++ warranty, support, indemnity or liability terms You offer. ++ . ++ 3.6. Distribution of Executable Versions. ++ . ++ You may distribute Covered Code in Executable form only if the ++ requirements of Sections 3.1, 3.2, 3.3, 3.4 and 3.5 have been met for ++ that Covered Code, and if You include a notice stating that the ++ Source Code version of the Covered Code is available under the terms ++ of this License, including a description of how and where You have ++ fulfilled the obligations of Section 3.2. The notice must be ++ conspicuously included in any notice in an Executable version, ++ related documentation or collateral in which You describe recipients' ++ rights relating to the Covered Code. You may distribute the ++ Executable version of Covered Code or ownership rights under a ++ license of Your choice, which may contain terms different from this ++ License, provided that You are in compliance with the terms of this ++ License and that the license for the Executable version does not ++ attempt to limit or alter the recipient's rights in the Source Code ++ version from the rights set forth in this License. If You distribute ++ the Executable version under a different license You must make it ++ absolutely clear that any terms which differ from this License are ++ offered by You alone, not by the Initial Developer or any ++ Contributor. You hereby agree to indemnify the Initial Developer and ++ every Contributor for any liability incurred by the Initial Developer ++ or such Contributor as a result of any such terms You offer. ++ . ++ 3.7. Larger Works. ++ . ++ You may create a Larger Work by combining Covered Code with other ++ code not governed by the terms of this License and distribute the ++ Larger Work as a single product. In such a case, You must make sure ++ the requirements of this License are fulfilled for the Covered Code. ++ . ++ 4. Inability to Comply Due to Statute or Regulation. ++ . ++ If it is impossible for You to comply with any of the terms of this ++ License with respect to some or all of the Covered Code due to ++ statute, judicial order, or regulation then You must: (a) comply with ++ the terms of this License to the maximum extent possible; and (b) ++ describe the limitations and the code they affect. Such description ++ must be included in the legal file described in Section 3.4 and must ++ be included with all distributions of the Source Code. Except to the ++ extent prohibited by statute or regulation, such description must be ++ sufficiently detailed for a recipient of ordinary skill to be able to ++ understand it. ++ . ++ 5. Application of this License. ++ . ++ This License applies to code to which the Initial Developer has ++ attached the notice in Exhibit A and to related Covered Code. ++ . ++ 6. Versions of the License. ++ . ++ 6.1. New Versions ++ . ++ Netscape Communications Corporation ("Netscape") may publish revised ++ and/or new versions of the License from time to time. Each version ++ will be given a distinguishing version number. ++ . ++ 6.2. Effect of New Versions ++ . ++ Once Covered Code has been published under a particular version of ++ the License, You may always continue to use it under the terms of ++ that version. You may also choose to use such Covered Code under the ++ terms of any subsequent version of the License published by Netscape. ++ No one other than Netscape has the right to modify the terms ++ applicable to Covered Code created under this License. ++ . ++ 6.3. Derivative Works ++ . ++ If You create or use a modified version of this License (which you ++ may only do in order to apply it to code which is not already Covered ++ Code governed by this License), You must (a) rename Your license so ++ that the phrases "Mozilla", "MOZILLAPL", "MOZPL", "Netscape", "MPL", ++ "NPL" or any confusingly similar phrase do not appear in your license ++ (except to note that your license differs from this License) and (b) ++ otherwise make it clear that Your version of the license contains ++ terms which differ from the Mozilla Public License and Netscape ++ Public License. (Filling in the name of the Initial Developer, ++ Original Code or Contributor in the notice described in Exhibit A ++ shall not of themselves be deemed to be modifications of this ++ License.) ++ . ++ 7. Disclaimer of warranty ++ . ++ Covered code is provided under this license on an "as is" basis, ++ without warranty of any kind, either expressed or implied, including, ++ without limitation, warranties that the covered code is free of ++ defects, merchantable, fit for a particular purpose or ++ non-infringing. The entire risk as to the quality and performance of ++ the covered code is with you. Should any covered code prove defective ++ in any respect, you (not the initial developer or any other ++ contributor) assume the cost of any necessary servicing, repair or ++ correction. This disclaimer of warranty constitutes an essential part ++ of this license. No use of any covered code is authorized hereunder ++ except under this disclaimer. ++ . ++ 8. Termination ++ . ++ 8.1. This License and the rights granted hereunder will terminate ++ automatically if You fail to comply with terms herein and fail to ++ cure such breach within 30 days of becoming aware of the breach. All ++ sublicenses to the Covered Code which are properly granted shall ++ survive any termination of this License. Provisions which, by their ++ nature, must remain in effect beyond the termination of this License ++ shall survive. ++ . ++ 8.2. If You initiate litigation by asserting a patent infringement ++ claim (excluding declatory judgment actions) against Initial ++ Developer or a Contributor (the Initial Developer or Contributor ++ against whom You file such action is referred to as "Participant") ++ alleging that: ++ . ++ a. such Participant's Contributor Version directly or indirectly ++ infringes any patent, then any and all rights granted by such ++ Participant to You under Sections 2.1 and/or 2.2 of this License ++ shall, upon 60 days notice from Participant terminate ++ prospectively, unless if within 60 days after receipt of notice ++ You either: (i) agree in writing to pay Participant a mutually ++ agreeable reasonable royalty for Your past and future use of ++ Modifications made by such Participant, or (ii) withdraw Your ++ litigation claim with respect to the Contributor Version against ++ such Participant. If within 60 days of notice, a reasonable ++ royalty and payment arrangement are not mutually agreed upon in ++ writing by the parties or the litigation claim is not withdrawn, ++ the rights granted by Participant to You under Sections 2.1 and/ ++ or 2.2 automatically terminate at the expiration of the 60 day ++ notice period specified above. ++ b. any software, hardware, or device, other than such Participant's ++ Contributor Version, directly or indirectly infringes any patent, ++ then any rights granted to You by such Participant under Sections ++ 2.1(b) and 2.2(b) are revoked effective as of the date You first ++ made, used, sold, distributed, or had made, Modifications made by ++ that Participant. ++ . ++ 8.3. If You assert a patent infringement claim against Participant ++ alleging that such Participant's Contributor Version directly or ++ indirectly infringes any patent where such claim is resolved (such as ++ by license or settlement) prior to the initiation of patent ++ infringement litigation, then the reasonable value of the licenses ++ granted by such Participant under Sections 2.1 or 2.2 shall be taken ++ into account in determining the amount or value of any payment or ++ license. ++ . ++ 8.4. In the event of termination under Sections 8.1 or 8.2 above, all ++ end user license agreements (excluding distributors and resellers) ++ which have been validly granted by You or any distributor hereunder ++ prior to termination shall survive termination. ++ . ++ 9. Limitation of liability ++ . ++ Under no circumstances and under no legal theory, whether tort ++ (including negligence), contract, or otherwise, shall you, the ++ initial developer, any other contributor, or any distributor of ++ covered code, or any supplier of any of such parties, be liable to ++ any person for any indirect, special, incidental, or consequential ++ damages of any character including, without limitation, damages for ++ loss of goodwill, work stoppage, computer failure or malfunction, or ++ any and all other commercial damages or losses, even if such party ++ shall have been informed of the possibility of such damages. This ++ limitation of liability shall not apply to liability for death or ++ personal injury resulting from such party's negligence to the extent ++ applicable law prohibits such limitation. Some jurisdictions do not ++ allow the exclusion or limitation of incidental or consequential ++ damages, so this exclusion and limitation may not apply to you. ++ . ++ 10. U.S. government end users ++ . ++ The Covered Code is a "commercial item," as that term is defined in ++ 48 C.F.R. 2.101 (Oct. 1995), consisting of "commercial computer ++ software" and "commercial computer software documentation," as such ++ terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48 ++ C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June ++ 1995), all U.S. Government End Users acquire Covered Code with only ++ those rights set forth herein. ++ . ++ 11. Miscellaneous ++ . ++ This License represents the complete agreement concerning subject ++ matter hereof. If any provision of this License is held to be ++ unenforceable, such provision shall be reformed only to the extent ++ necessary to make it enforceable. This License shall be governed by ++ California law provisions (except to the extent applicable law, if ++ any, provides otherwise), excluding its conflict-of-law provisions. ++ With respect to disputes in which at least one party is a citizen of, ++ or an entity chartered or registered to do business in the United ++ States of America, any litigation relating to this License shall be ++ subject to the jurisdiction of the Federal Courts of the Northern ++ District of California, with venue lying in Santa Clara County, ++ California, with the losing party responsible for costs, including ++ without limitation, court costs and reasonable attorneys' fees and ++ expenses. The application of the United Nations Convention on ++ Contracts for the International Sale of Goods is expressly excluded. ++ Any law or regulation which provides that the language of a contract ++ shall be construed against the drafter shall not apply to this ++ License. ++ . ++ 12. Responsibility for claims ++ . ++ As between Initial Developer and the Contributors, each party is ++ responsible for claims and damages arising, directly or indirectly, ++ out of its utilization of rights under this License and You agree to ++ work with Initial Developer and Contributors to distribute such ++ responsibility on an equitable basis. Nothing herein is intended or ++ shall be deemed to constitute any admission of liability. ++ . ++ 13. Multiple-licensed code ++ . ++ Initial Developer may designate portions of the Covered Code as ++ "Multiple-Licensed". "Multiple-Licensed" means that the Initial ++ Developer permits you to utilize portions of the Covered Code under ++ Your choice of the MPL or the alternative licenses, if any, specified ++ by the Initial Developer in the file described in Exhibit A. ++ . ++ Exhibit A - Mozilla Public License. ++ . ++ "The contents of this file are subject to the Mozilla Public License ++ Version 1.1 (the "License"); you may not use this file except in ++ compliance with the License. You may obtain a copy of the License at ++ http://www.mozilla.org/MPL/ ++ . ++ Software distributed under the License is distributed on an "AS IS" ++ basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the ++ License for the specific language governing rights and limitations ++ under the License. ++ . ++ The Original Code is ______________________________________. ++ . ++ The Initial Developer of the Original Code is ________________________. ++ Portions created by ______________________ are Copyright (C) ______ ++ _______________________. All Rights Reserved. ++ . ++ Contributor(s): ______________________________________. ++ . ++ Alternatively, the contents of this file may be used under the terms ++ of the _____ license (the "[___] License"), in which case the ++ provisions of [______] License are applicable instead of those ++ above. If you wish to allow use of your version of this file only ++ under the terms of the [____] License and not to allow others to use ++ your version of this file under the MPL, indicate your decision by ++ deleting the provisions above and replace them with the notice and ++ other provisions required by the [___] License. If you do not delete ++ the provisions above, a recipient may use your version of this file ++ under either the MPL or the [___] License." ++ . ++ NOTE: The text of this Exhibit A may differ slightly from the text of ++ the notices in the Source Code files of the Original Code. You should ++ use the text of this Exhibit A rather than the text found in the ++ Original Code Source Code for Your Modifications. diff --cc debian/docs index 0000000,0000000..71dfd5b new file mode 100644 --- /dev/null +++ b/debian/docs @@@ -1,0 -1,0 +1,1 @@@ ++README.txt diff --cc debian/install index 0000000,0000000..a2485a7 new file mode 100644 --- /dev/null +++ b/debian/install @@@ -1,0 -1,0 +1,10 @@@ ++binaries/data/l10n usr/share/games/0ad/ ++binaries/system/libAtlasUI.so usr/lib/games/0ad/ ++binaries/system/libCollada.so usr/lib/games/0ad/ ++binaries/system/libmozjs38-ps-release.so usr/lib/games/0ad/ ++binaries/system/ActorEditor usr/lib/games/0ad/ ++binaries/system/pyrogenesis usr/games/ ++build/resources/0ad.appdata.xml usr/share/appdata/ ++build/resources/0ad.desktop usr/share/applications/ ++build/resources/0ad.png usr/share/pixmaps/ ++usr/games/0ad diff --cc debian/manpages index 0000000,0000000..4ff5397 new file mode 100644 --- /dev/null +++ b/debian/manpages @@@ -1,0 -1,0 +1,2 @@@ ++debian/0ad.6 ++debian/pyrogenesis.6 diff --cc debian/missing-sources/README.txt index 0000000,0000000..427fdd4 new file mode 100644 --- /dev/null +++ b/debian/missing-sources/README.txt @@@ -1,0 -1,0 +1,21 @@@ ++This directory provides the non-minified versions of the embedded JQuery files ++in the orig source tarball, in order to comply with Debian Policy. (#735349) ++ ++The minified javascript files for which this directory provides the ++non-minified versions are as follows. Each of the lines below indicate the ++minified file, followed by the non-minified source file(s) present in this ++directory. ++ ++source/tools/replayprofile/jquery.flot.js: ++ jquery.colorhelpers.js ++source/tools/replayprofile/jquery.flot.navigate.js: ++ jquery.event.drag.js ++ jquery.mousewheel.js ++ ++source/tools/templatesanalyzer/tablefilter/tablefilter.js: ++source/tools/templatesanalyzer/tablefilter/tf-1.js: ++ tablefilter/*.js ++ ++(Tablefilter 0.0.11: https://github.com/koalyptus/TableFilter/tree/4f2316a4b57021a41edd10d3b98e7f8159642392) ++ ++ diff --cc debian/missing-sources/jquery.colorhelpers.js index 0000000,0000000..fa44961 new file mode 100644 --- /dev/null +++ b/debian/missing-sources/jquery.colorhelpers.js @@@ -1,0 -1,0 +1,174 @@@ ++/* Plugin for jQuery for working with colors. ++ * ++ * Version 1.0. ++ * ++ * Inspiration from jQuery color animation plugin by John Resig. ++ * ++ * Released under the MIT license by Ole Laursen, October 2009. ++ * ++ * Examples: ++ * ++ * $.color.parse("#fff").scale('rgb', 0.25).add('a', -0.5).toString() ++ * var c = $.color.extract($("#mydiv"), 'background-color'); ++ * console.log(c.r, c.g, c.b, c.a); ++ * $.color.make(100, 50, 25, 0.4).toString() // returns "rgba(100,50,25,0.4)" ++ * ++ * Note that .scale() and .add() work in-place instead of returning ++ * new objects. ++ */ ++ ++(function() { ++ jQuery.color = {}; ++ ++ // construct color object with some convenient chainable helpers ++ jQuery.color.make = function (r, g, b, a) { ++ var o = {}; ++ o.r = r || 0; ++ o.g = g || 0; ++ o.b = b || 0; ++ o.a = a != null ? a : 1; ++ ++ o.add = function (c, d) { ++ for (var i = 0; i < c.length; ++i) ++ o[c.charAt(i)] += d; ++ return o.normalize(); ++ }; ++ ++ o.scale = function (c, f) { ++ for (var i = 0; i < c.length; ++i) ++ o[c.charAt(i)] *= f; ++ return o.normalize(); ++ }; ++ ++ o.toString = function () { ++ if (o.a >= 1.0) { ++ return "rgb("+[o.r, o.g, o.b].join(",")+")"; ++ } else { ++ return "rgba("+[o.r, o.g, o.b, o.a].join(",")+")"; ++ } ++ }; ++ ++ o.normalize = function () { ++ function clamp(min, value, max) { ++ return value < min ? min: (value > max ? max: value); ++ } ++ ++ o.r = clamp(0, parseInt(o.r), 255); ++ o.g = clamp(0, parseInt(o.g), 255); ++ o.b = clamp(0, parseInt(o.b), 255); ++ o.a = clamp(0, o.a, 1); ++ return o; ++ }; ++ ++ o.clone = function () { ++ return jQuery.color.make(o.r, o.b, o.g, o.a); ++ }; ++ ++ return o.normalize(); ++ } ++ ++ // extract CSS color property from element, going up in the DOM ++ // if it's "transparent" ++ jQuery.color.extract = function (elem, css) { ++ var c; ++ do { ++ c = elem.css(css).toLowerCase(); ++ // keep going until we find an element that has color, or ++ // we hit the body ++ if (c != '' && c != 'transparent') ++ break; ++ elem = elem.parent(); ++ } while (!jQuery.nodeName(elem.get(0), "body")); ++ ++ // catch Safari's way of signalling transparent ++ if (c == "rgba(0, 0, 0, 0)") ++ c = "transparent"; ++ ++ return jQuery.color.parse(c); ++ } ++ ++ // parse CSS color string (like "rgb(10, 32, 43)" or "#fff"), ++ // returns color object ++ jQuery.color.parse = function (str) { ++ var res, m = jQuery.color.make; ++ ++ // Look for rgb(num,num,num) ++ if (res = /rgb\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*\)/.exec(str)) ++ return m(parseInt(res[1], 10), parseInt(res[2], 10), parseInt(res[3], 10)); ++ ++ // Look for rgba(num,num,num,num) ++ if (res = /rgba\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]+(?:\.[0-9]+)?)\s*\)/.exec(str)) ++ return m(parseInt(res[1], 10), parseInt(res[2], 10), parseInt(res[3], 10), parseFloat(res[4])); ++ ++ // Look for rgb(num%,num%,num%) ++ if (res = /rgb\(\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*\)/.exec(str)) ++ return m(parseFloat(res[1])*2.55, parseFloat(res[2])*2.55, parseFloat(res[3])*2.55); ++ ++ // Look for rgba(num%,num%,num%,num) ++ if (res = /rgba\(\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\s*\)/.exec(str)) ++ return m(parseFloat(res[1])*2.55, parseFloat(res[2])*2.55, parseFloat(res[3])*2.55, parseFloat(res[4])); ++ ++ // Look for #a0b1c2 ++ if (res = /#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})/.exec(str)) ++ return m(parseInt(res[1], 16), parseInt(res[2], 16), parseInt(res[3], 16)); ++ ++ // Look for #fff ++ if (res = /#([a-fA-F0-9])([a-fA-F0-9])([a-fA-F0-9])/.exec(str)) ++ return m(parseInt(res[1]+res[1], 16), parseInt(res[2]+res[2], 16), parseInt(res[3]+res[3], 16)); ++ ++ // Otherwise, we're most likely dealing with a named color ++ var name = jQuery.trim(str).toLowerCase(); ++ if (name == "transparent") ++ return m(255, 255, 255, 0); ++ else { ++ res = lookupColors[name]; ++ return m(res[0], res[1], res[2]); ++ } ++ } ++ ++ var lookupColors = { ++ aqua:[0,255,255], ++ azure:[240,255,255], ++ beige:[245,245,220], ++ black:[0,0,0], ++ blue:[0,0,255], ++ brown:[165,42,42], ++ cyan:[0,255,255], ++ darkblue:[0,0,139], ++ darkcyan:[0,139,139], ++ darkgrey:[169,169,169], ++ darkgreen:[0,100,0], ++ darkkhaki:[189,183,107], ++ darkmagenta:[139,0,139], ++ darkolivegreen:[85,107,47], ++ darkorange:[255,140,0], ++ darkorchid:[153,50,204], ++ darkred:[139,0,0], ++ darksalmon:[233,150,122], ++ darkviolet:[148,0,211], ++ fuchsia:[255,0,255], ++ gold:[255,215,0], ++ green:[0,128,0], ++ indigo:[75,0,130], ++ khaki:[240,230,140], ++ lightblue:[173,216,230], ++ lightcyan:[224,255,255], ++ lightgreen:[144,238,144], ++ lightgrey:[211,211,211], ++ lightpink:[255,182,193], ++ lightyellow:[255,255,224], ++ lime:[0,255,0], ++ magenta:[255,0,255], ++ maroon:[128,0,0], ++ navy:[0,0,128], ++ olive:[128,128,0], ++ orange:[255,165,0], ++ pink:[255,192,203], ++ purple:[128,0,128], ++ violet:[128,0,128], ++ red:[255,0,0], ++ silver:[192,192,192], ++ white:[255,255,255], ++ yellow:[255,255,0] ++ }; ++})(); diff --cc debian/missing-sources/jquery.event.drag.js index 0000000,0000000..ad66b10 new file mode 100644 --- /dev/null +++ b/debian/missing-sources/jquery.event.drag.js @@@ -1,0 -1,0 +1,137 @@@ ++/*! ++jquery.event.drag.js ~ v1.5 ~ Copyright (c) 2008, Three Dub Media (http://threedubmedia.com) ++Liscensed under the MIT License ~ http://threedubmedia.googlecode.com/files/MIT-LICENSE.txt ++*/ ++;(function($){ // secure $ jQuery alias ++/*******************************************************************************************/ ++// Created: 2008-06-04 | Updated: 2009-03-24 ++/*******************************************************************************************/ ++// Events: drag, dragstart, dragend ++/*******************************************************************************************/ ++ ++// jquery method ++$.fn.drag = function( fn1, fn2, fn3 ){ ++ if ( fn2 ) this.bind('dragstart', fn1 ); // 2+ args ++ if ( fn3 ) this.bind('dragend', fn3 ); // 3 args ++ return !fn1 ? this.trigger('drag') // 0 args ++ : this.bind('drag', fn2 ? fn2 : fn1 ); // 1+ args ++ }; ++ ++// local refs ++var $event = $.event, $special = $event.special, ++ ++// special event configuration ++drag = $special.drag = { ++ not: ':input', // don't begin to drag on event.targets that match this selector ++ distance: 0, // distance dragged before dragstart ++ which: 1, // mouse button pressed to start drag sequence ++ dragging: false, // hold the active target element ++ setup: function( data ){ ++ data = $.extend({ ++ distance: drag.distance, ++ which: drag.which, ++ not: drag.not ++ }, data || {}); ++ data.distance = squared( data.distance ); // x² + y² = distance² ++ $event.add( this, "mousedown", handler, data ); ++ if ( this.attachEvent ) this.attachEvent("ondragstart", dontStart ); // prevent image dragging in IE... ++ }, ++ teardown: function(){ ++ $event.remove( this, "mousedown", handler ); ++ if ( this === drag.dragging ) drag.dragging = drag.proxy = false; // deactivate element ++ selectable( this, true ); // enable text selection ++ if ( this.detachEvent ) this.detachEvent("ondragstart", dontStart ); // prevent image dragging in IE... ++ } ++ }; ++ ++// prevent normal event binding... ++$special.dragstart = $special.dragend = { setup:function(){}, teardown:function(){} }; ++ ++// handle drag-releatd DOM events ++function handler ( event ){ ++ var elem = this, returned, data = event.data || {}; ++ // mousemove or mouseup ++ if ( data.elem ){ ++ // update event properties... ++ elem = event.dragTarget = data.elem; // drag source element ++ event.dragProxy = drag.proxy || elem; // proxy element or source ++ event.cursorOffsetX = data.pageX - data.left; // mousedown offset ++ event.cursorOffsetY = data.pageY - data.top; // mousedown offset ++ event.offsetX = event.pageX - event.cursorOffsetX; // element offset ++ event.offsetY = event.pageY - event.cursorOffsetY; // element offset ++ } ++ // mousedown, check some initial props to avoid the switch statement ++ else if ( drag.dragging || ( data.which>0 && event.which!=data.which ) || ++ $( event.target ).is( data.not ) ) return; ++ // handle various events ++ switch ( event.type ){ ++ // mousedown, left click, event.target is not restricted, init dragging ++ case 'mousedown': ++ $.extend( data, $( elem ).offset(), { ++ elem: elem, target: event.target, ++ pageX: event.pageX, pageY: event.pageY ++ }); // store some initial attributes ++ $event.add( document, "mousemove mouseup", handler, data ); ++ selectable( elem, false ); // disable text selection ++ drag.dragging = null; // pending state ++ return false; // prevents text selection in safari ++ // mousemove, check distance, start dragging ++ case !drag.dragging && 'mousemove': ++ if ( squared( event.pageX-data.pageX ) ++ + squared( event.pageY-data.pageY ) // x² + y² = distance² ++ < data.distance ) break; // distance tolerance not reached ++ event.target = data.target; // force target from "mousedown" event (fix distance issue) ++ returned = hijack( event, "dragstart", elem ); // trigger "dragstart", return proxy element ++ if ( returned !== false ){ // "dragstart" not rejected ++ drag.dragging = elem; // activate element ++ drag.proxy = event.dragProxy = $( returned || elem )[0]; // set proxy ++ } ++ // mousemove, dragging ++ case 'mousemove': ++ if ( drag.dragging ){ ++ returned = hijack( event, "drag", elem ); // trigger "drag" ++ if ( $special.drop ){ // manage drop events ++ $special.drop.allowed = ( returned !== false ); // prevent drop ++ $special.drop.handler( event ); // "dropstart", "dropend" ++ } ++ if ( returned !== false ) break; // "drag" not rejected, stop ++ event.type = "mouseup"; // helps "drop" handler behave ++ } ++ // mouseup, stop dragging ++ case 'mouseup': ++ $event.remove( document, "mousemove mouseup", handler ); // remove page events ++ if ( drag.dragging ){ ++ if ( $special.drop ) $special.drop.handler( event ); // "drop" ++ hijack( event, "dragend", elem ); // trigger "dragend" ++ } ++ selectable( elem, true ); // enable text selection ++ drag.dragging = drag.proxy = data.elem = false; // deactivate element ++ break; ++ } ++ return true; ++ }; ++ ++// set event type to custom value, and handle it ++function hijack ( event, type, elem ){ ++ event.type = type; // force the event type ++ var result = $.event.handle.call( elem, event ); ++ return result===false ? false : result || event.result; ++ }; ++ ++// return the value squared ++function squared ( value ){ return Math.pow( value, 2 ); }; ++ ++// suppress default dragstart IE events... ++function dontStart(){ return ( drag.dragging === false ); }; ++ ++// toggles text selection attributes ++function selectable ( elem, bool ){ ++ if ( !elem ) return; // maybe element was removed ? ++ elem.unselectable = bool ? "off" : "on"; // IE ++ elem.onselectstart = function(){ return bool; }; // IE ++ //if ( document.selection && document.selection.empty ) document.selection.empty(); // IE ++ if ( elem.style ) elem.style.MozUserSelect = bool ? "" : "none"; // FF ++ }; ++ ++/*******************************************************************************************/ ++})( jQuery ); // confine scope diff --cc debian/missing-sources/jquery.mousewheel.js index 0000000,0000000..528defe new file mode 100644 --- /dev/null +++ b/debian/missing-sources/jquery.mousewheel.js @@@ -1,0 -1,0 +1,79 @@@ ++/*! Copyright (c) 2010 Brandon Aaron (http://brandonaaron.net) ++ * Licensed under the MIT License (LICENSE.txt). ++ * ++ * Thanks to: http://adomas.org/javascript-mouse-wheel/ for some pointers. ++ * Thanks to: Mathias Bank(http://www.mathias-bank.de) for a scope bug fix. ++ * Thanks to: Seamus Leahy for adding deltaX and deltaY ++ * ++ * Version: 3.0.3 ++ * ++ * Requires: 1.2.2+ ++ */ ++ ++(function($) { ++ ++var types = ['DOMMouseScroll', 'mousewheel']; ++ ++$.event.special.mousewheel = { ++ setup: function() { ++ if ( this.addEventListener ) { ++ for ( var i=types.length; i; ) { ++ this.addEventListener( types[--i], handler, false ); ++ } ++ } else { ++ this.onmousewheel = handler; ++ } ++ }, ++ ++ teardown: function() { ++ if ( this.removeEventListener ) { ++ for ( var i=types.length; i; ) { ++ this.removeEventListener( types[--i], handler, false ); ++ } ++ } else { ++ this.onmousewheel = null; ++ } ++ } ++}; ++ ++$.fn.extend({ ++ mousewheel: function(fn) { ++ return fn ? this.bind("mousewheel", fn) : this.trigger("mousewheel"); ++ }, ++ ++ unmousewheel: function(fn) { ++ return this.unbind("mousewheel", fn); ++ } ++}); ++ ++ ++function handler(event) { ++ var orgEvent = event, args = [].slice.call( arguments, 1 ), delta = 0, returnValue = true, deltaX = 0, deltaY = 0; ++ ++ event = $.event.fix(event || window.event); ++ event.type = "mousewheel"; ++ ++ // Old school scrollwheel delta ++ if ( event.wheelDelta ) { delta = event.wheelDelta/120; } ++ if ( event.detail ) { delta = -event.detail/3; } ++ ++ // New school multidimensional scroll (touchpads) deltas ++ deltaY = delta; ++ ++ // Gecko ++ if ( orgEvent.axis !== undefined && orgEvent.axis === orgEvent.HORIZONTAL_AXIS ) { ++ deltaY = 0; ++ deltaX = -1*delta; ++ } ++ ++ // Webkit ++ if ( orgEvent.wheelDeltaY !== undefined ) { deltaY = orgEvent.wheelDeltaY/120; } ++ if ( orgEvent.wheelDeltaX !== undefined ) { deltaX = -1*orgEvent.wheelDeltaX/120; } ++ ++ // Add event and delta to the front of the arguments ++ args.unshift(event, delta, deltaX, deltaY); ++ ++ return $.event.handle.apply(this, args); ++} ++ ++})(jQuery); diff --cc debian/missing-sources/tablefilter/array.js index 0000000,0000000..dd10bc5 new file mode 100644 --- /dev/null +++ b/debian/missing-sources/tablefilter/array.js @@@ -1,0 -1,0 +1,17 @@@ ++/** ++ * Array utilities ++ */ ++ ++import Str from './string'; ++ ++export default { ++ has: function(arr, val, caseSensitive){ ++ let sCase = caseSensitive===undefined ? false : caseSensitive; ++ for (var i=0; i2){ ++ return yr; ++ } ++ let y; ++ //>50 belong to 1900 ++ if(yr <= 99 && yr>50){ ++ y = '19' + yr; ++ } ++ //<50 belong to 2000 ++ if(yr<50 || yr === '00'){ ++ y = '20' + yr; ++ } ++ return y; ++} ++ ++function mmm2mm(mmm){ ++ if(mmm === undefined){ ++ return 0; ++ } ++ let mondigit; ++ let MONTH_NAMES = [ ++ 'january','february','march','april','may','june','july', ++ 'august','september','october','november','december', ++ 'jan','feb','mar','apr','may','jun','jul','aug','sep','oct', ++ 'nov','dec' ++ ]; ++ for(let m_i=0; m_i < MONTH_NAMES.length; m_i++){ ++ let month_name = MONTH_NAMES[m_i]; ++ if (mmm.toLowerCase() === month_name){ ++ mondigit = m_i+1; ++ break; ++ } ++ } ++ if(mondigit > 11 || mondigit < 23){ ++ mondigit = mondigit - 12; ++ } ++ if(mondigit < 1 || mondigit > 12){ ++ return 0; ++ } ++ return mondigit; ++} diff --cc debian/missing-sources/tablefilter/dom.js index 0000000,0000000..175bda9 new file mode 100644 --- /dev/null +++ b/debian/missing-sources/tablefilter/dom.js @@@ -1,0 -1,0 +1,142 @@@ ++/** ++ * DOM utilities ++ */ ++ ++export default { ++ ++ /** ++ * Returns text + text of children of given node ++ * @param {NodeElement} node ++ * @return {String} ++ */ ++ getText(node){ ++ let s = node.textContent || node.innerText || ++ node.innerHTML.replace(/<[^<>]+>/g, ''); ++ s = s.replace(/^\s+/, '').replace(/\s+$/, ''); ++ return s; ++ }, ++ ++ /** ++ * Creates an html element with given collection of attributes ++ * @param {String} tag a string of the html tag to create ++ * @param {Array} an undetermined number of arrays containing the with 2 ++ * items, the attribute name and its value ['id','myId'] ++ * @return {Object} created element ++ */ ++ create(tag){ ++ if(!tag || tag===''){ ++ return; ++ } ++ ++ let el = document.createElement(tag), ++ args = arguments; ++ ++ if(args.length > 1){ ++ for(let i=0; i { this._setAdvancedGrid(); }); ++ } ++ if(this.loadStylesheet && !tf.isImported(this.stylesheet, 'link')){ ++ tf.import(this.stylesheetName, this.stylesheet, null, 'link'); ++ } ++ } ++ ++ /** ++ * Instantiate ezEditTable component for advanced grid features ++ */ ++ _setAdvancedGrid(){ ++ var tf = this.tf; ++ ++ //start row for EditTable constructor needs to be calculated ++ var startRow, ++ cfg = this.cfg, ++ thead = Dom.tag(tf.tbl, 'thead'); ++ ++ //if thead exists and startRow not specified, startRow is calculated ++ //automatically by EditTable ++ if(thead.length > 0 && !cfg.startRow){ ++ startRow = undefined; ++ } ++ //otherwise startRow config property if any or TableFilter refRow ++ else{ ++ startRow = cfg.startRow || tf.refRow; ++ } ++ ++ cfg.base_path = cfg.base_path || tf.basePath + 'ezEditTable/'; ++ var editable = cfg.editable; ++ var selectable = cfg.selection; ++ ++ if(selectable){ ++ cfg.default_selection = cfg.default_selection || 'row'; ++ } ++ //CSS Styles ++ cfg.active_cell_css = cfg.active_cell_css || 'ezETSelectedCell'; ++ ++ var _lastValidRowIndex = 0; ++ var _lastRowIndex = 0; ++ ++ if(selectable){ ++ //Row navigation needs to be calculated according to TableFilter's ++ //validRowsIndex array ++ var onAfterSelection = function(et, selectedElm, e){ ++ var slc = et.Selection; ++ //Next valid filtered row needs to be selected ++ var doSelect = function(nextRowIndex){ ++ if(et.defaultSelection === 'row'){ ++ slc.SelectRowByIndex(nextRowIndex); ++ } else { ++ et.ClearSelections(); ++ var cellIndex = selectedElm.cellIndex, ++ row = tf.tbl.rows[nextRowIndex]; ++ if(et.defaultSelection === 'both'){ ++ slc.SelectRowByIndex(nextRowIndex); ++ } ++ if(row){ ++ slc.SelectCell(row.cells[cellIndex]); ++ } ++ } ++ //Table is filtered ++ if(tf.validRowsIndex.length !== tf.getRowsNb()){ ++ var r = tf.tbl.rows[nextRowIndex]; ++ if(r){ ++ r.scrollIntoView(false); ++ } ++ if(cell){ ++ if(cell.cellIndex === (tf.getCellsNb()-1) && ++ tf.gridLayout){ ++ tf.tblCont.scrollLeft = 100000000; ++ } ++ else if(cell.cellIndex===0 && tf.gridLayout){ ++ tf.tblCont.scrollLeft = 0; ++ } else { ++ cell.scrollIntoView(false); ++ } ++ } ++ } ++ }; ++ ++ //table is not filtered ++ if(!tf.validRowsIndex){ ++ return; ++ } ++ var validIndexes = tf.validRowsIndex, ++ validIdxLen = validIndexes.length, ++ row = et.defaultSelection !== 'row' ? ++ selectedElm.parentNode : selectedElm, ++ //cell for default_selection = 'both' or 'cell' ++ cell = selectedElm.nodeName==='TD' ? selectedElm : null, ++ keyCode = e !== undefined ? et.Event.GetKey(e) : 0, ++ isRowValid = validIndexes.indexOf(row.rowIndex) !== -1, ++ nextRowIndex, ++ paging = tf.feature('paging'), ++ //pgup/pgdown keys ++ d = (keyCode === 34 || keyCode === 33 ? ++ (paging && paging.pagingLength || et.nbRowsPerPage) :1); ++ ++ //If next row is not valid, next valid filtered row needs to be ++ //calculated ++ if(!isRowValid){ ++ //Selection direction up/down ++ if(row.rowIndex>_lastRowIndex){ ++ //last row ++ if(row.rowIndex >= validIndexes[validIdxLen-1]){ ++ nextRowIndex = validIndexes[validIdxLen-1]; ++ } else { ++ var calcRowIndex = (_lastValidRowIndex + d); ++ if(calcRowIndex > (validIdxLen-1)){ ++ nextRowIndex = validIndexes[validIdxLen-1]; ++ } else { ++ nextRowIndex = validIndexes[calcRowIndex]; ++ } ++ } ++ } else{ ++ //first row ++ if(row.rowIndex <= validIndexes[0]){ ++ nextRowIndex = validIndexes[0]; ++ } else { ++ var v = validIndexes[_lastValidRowIndex - d]; ++ nextRowIndex = v ? v : validIndexes[0]; ++ } ++ } ++ _lastRowIndex = row.rowIndex; ++ doSelect(nextRowIndex); ++ } else { ++ //If filtered row is valid, special calculation for ++ //pgup/pgdown keys ++ if(keyCode!==34 && keyCode!==33){ ++ _lastValidRowIndex = validIndexes.indexOf(row.rowIndex); ++ _lastRowIndex = row.rowIndex; ++ } else { ++ if(keyCode === 34){ //pgdown ++ //last row ++ if((_lastValidRowIndex + d) <= (validIdxLen-1)){ ++ nextRowIndex = validIndexes[ ++ _lastValidRowIndex + d]; ++ } else { ++ nextRowIndex = [validIdxLen-1]; ++ } ++ } else { //pgup ++ //first row ++ if((_lastValidRowIndex - d) <= validIndexes[0]){ ++ nextRowIndex = validIndexes[0]; ++ } else { ++ nextRowIndex = validIndexes[ ++ _lastValidRowIndex - d]; ++ } ++ } ++ _lastRowIndex = nextRowIndex; ++ _lastValidRowIndex = validIndexes.indexOf(nextRowIndex); ++ doSelect(nextRowIndex); ++ } ++ } ++ }; ++ ++ //Page navigation has to be enforced whenever selected row is out of ++ //the current page range ++ var onBeforeSelection = function(et, selectedElm){ ++ var row = et.defaultSelection !== 'row' ? ++ selectedElm.parentNode : selectedElm; ++ if(tf.paging){ ++ if(tf.feature('paging').nbPages > 1){ ++ var paging = tf.feature('paging'); ++ //page length is re-assigned in case it has changed ++ et.nbRowsPerPage = paging.pagingLength; ++ var validIndexes = tf.validRowsIndex, ++ validIdxLen = validIndexes.length, ++ pagingEndRow = parseInt(paging.startPagingRow, 10) + ++ parseInt(paging.pagingLength, 10); ++ var rowIndex = row.rowIndex; ++ ++ if((rowIndex === validIndexes[validIdxLen-1]) && ++ paging.currentPageNb!==paging.nbPages){ ++ paging.setPage('last'); ++ } ++ else if((rowIndex == validIndexes[0]) && ++ paging.currentPageNb!==1){ ++ paging.setPage('first'); ++ } ++ else if(rowIndex > validIndexes[pagingEndRow-1] && ++ rowIndex < validIndexes[validIdxLen-1]){ ++ paging.setPage('next'); ++ } ++ else if( ++ rowIndex < validIndexes[paging.startPagingRow] && ++ rowIndex > validIndexes[0]){ ++ paging.setPage('previous'); ++ } ++ } ++ } ++ }; ++ ++ //Selected row needs to be visible when paging is activated ++ if(tf.paging){ ++ tf.feature('paging').onAfterChangePage = function(paging){ ++ var advGrid = paging.tf.extension('advancedGrid'); ++ var et = advGrid._ezEditTable; ++ var slc = et.Selection; ++ var row = slc.GetActiveRow(); ++ if(row){ ++ row.scrollIntoView(false); ++ } ++ var cell = slc.GetActiveCell(); ++ if(cell){ ++ cell.scrollIntoView(false); ++ } ++ }; ++ } ++ ++ //Rows navigation when rows are filtered is performed with the ++ //EditTable row selection callback events ++ if(cfg.default_selection==='row'){ ++ var fnB = cfg.on_before_selected_row; ++ cfg.on_before_selected_row = function(){ ++ onBeforeSelection(arguments[0], arguments[1], arguments[2]); ++ if(fnB){ ++ fnB.call( ++ null, arguments[0], arguments[1], arguments[2]); ++ } ++ }; ++ var fnA = cfg.on_after_selected_row; ++ cfg.on_after_selected_row = function(){ ++ onAfterSelection(arguments[0], arguments[1], arguments[2]); ++ if(fnA){ ++ fnA.call( ++ null, arguments[0], arguments[1], arguments[2]); ++ } ++ }; ++ } else { ++ var fnD = cfg.on_before_selected_cell; ++ cfg.on_before_selected_cell = function(){ ++ onBeforeSelection(arguments[0], arguments[1], arguments[2]); ++ if(fnD){ ++ fnD.call( ++ null, arguments[0], arguments[1], arguments[2]); ++ } ++ }; ++ var fnC = cfg.on_after_selected_cell; ++ cfg.on_after_selected_cell = function(){ ++ onAfterSelection(arguments[0], arguments[1], arguments[2]); ++ if(fnC){ ++ fnC.call( ++ null, arguments[0], arguments[1], arguments[2]); ++ } ++ }; ++ } ++ } ++ if(editable){ ++ //Added or removed rows, TF rows number needs to be re-calculated ++ var fnE = cfg.on_added_dom_row; ++ cfg.on_added_dom_row = function(){ ++ tf.nbFilterableRows++; ++ if(!tf.paging){ ++ tf.feature('rowsCounter').refresh(); ++ } else { ++ tf.nbRows++; ++ tf.nbVisibleRows++; ++ tf.nbFilterableRows++; ++ tf.paging=false; ++ tf.feature('paging').destroy(); ++ tf.feature('paging').reset(); ++ } ++ if(tf.alternateRows){ ++ tf.feature('alternateRows').init(); ++ } ++ if(fnE){ ++ fnE.call(null, arguments[0], arguments[1], arguments[2]); ++ } ++ }; ++ if(cfg.actions && cfg.actions['delete']){ ++ var fnF = cfg.actions['delete'].on_after_submit; ++ cfg.actions['delete'].on_after_submit = function(){ ++ tf.nbFilterableRows--; ++ if(!tf.paging){ ++ tf.feature('rowsCounter').refresh(); ++ } else { ++ tf.nbRows--; ++ tf.nbVisibleRows--; ++ tf.nbFilterableRows--; ++ tf.paging=false; ++ tf.feature('paging').destroy(); ++ tf.feature('paging').reset(false); ++ } ++ if(tf.alternateRows){ ++ tf.feature('alternateRows').init(); ++ } ++ if(fnF){ ++ fnF.call(null, arguments[0], arguments[1]); ++ } ++ }; ++ } ++ } ++ ++ try{ ++ this._ezEditTable = new EditTable(tf.id, cfg, startRow); ++ this._ezEditTable.Init(); ++ } catch(e) { throw new Error(this.err); } ++ ++ this.initialized = true; ++ } ++ ++ /** ++ * Reset advanced grid when previously removed ++ */ ++ reset(){ ++ var ezEditTable = this._ezEditTable; ++ if(ezEditTable){ ++ if(this.cfg.selection){ ++ ezEditTable.Selection.Set(); ++ } ++ if(this.cfg.editable){ ++ ezEditTable.Editable.Set(); ++ } ++ } ++ } ++ ++ /** ++ * Remove advanced grid ++ */ ++ destroy(){ ++ var ezEditTable = this._ezEditTable; ++ if(ezEditTable){ ++ if(this.cfg.selection){ ++ ezEditTable.Selection.ClearSelections(); ++ ezEditTable.Selection.Remove(); ++ } ++ if(this.cfg.editable){ ++ ezEditTable.Editable.Remove(); ++ } ++ } ++ this.initialized = false; ++ } ++} diff --cc debian/missing-sources/tablefilter/extensions/advancedGrid/advancedGrid.js index 0000000,0000000..e548ef4 new file mode 100644 --- /dev/null +++ b/debian/missing-sources/tablefilter/extensions/advancedGrid/advancedGrid.js @@@ -1,0 -1,0 +1,3 @@@ ++import AdapterEzEditTable from './adapterEzEditTable'; ++ ++export default AdapterEzEditTable; diff --cc debian/missing-sources/tablefilter/extensions/colOps/colOps.js index 0000000,0000000..aa9ca66 new file mode 100644 --- /dev/null +++ b/debian/missing-sources/tablefilter/extensions/colOps/colOps.js @@@ -1,0 -1,0 +1,315 @@@ ++import Dom from '../../dom'; ++import Str from '../../string'; ++import Types from '../../types'; ++ ++export default class ColOps{ ++ ++ /** ++ * Column calculations ++ * @param {Object} tf TableFilter instance ++ */ ++ constructor(tf, opts) { ++ ++ //calls function before col operation ++ this.onBeforeOperation = Types.isFn(opts.on_before_operation) ? ++ opts.on_before_operation : null; ++ //calls function after col operation ++ this.onAfterOperation = Types.isFn(opts.on_after_operation) ? ++ opts.on_after_operation : null; ++ ++ this.opts = opts; ++ this.tf = tf; ++ } ++ ++ init(){ ++ this.calc(); ++ } ++ ++ /** ++ * Calculates columns' values ++ * Configuration options are stored in 'opts' property ++ * - 'id' contains ids of elements showing result (array) ++ * - 'col' contains the columns' indexes (array) ++ * - 'operation' contains operation type (array, values: 'sum', 'mean', ++ * 'min', 'max', 'median', 'q1', 'q3') ++ * - 'write_method' array defines which method to use for displaying the ++ * result (innerHTML, setValue, createTextNode) - default: 'innerHTML' ++ * - 'tot_row_index' defines in which row results are displayed ++ * (integers array) ++ * ++ * - changes made by Nuovella: ++ * (1) optimized the routine (now it will only process each column once), ++ * (2) added calculations for the median, lower and upper quartile. ++ */ ++ calc() { ++ var tf = this.tf; ++ if(!tf.isFirstLoad && !tf.hasGrid()){ ++ return; ++ } ++ ++ if(this.onBeforeOperation){ ++ this.onBeforeOperation.call(null, tf); ++ } ++ ++ var opts = this.opts, ++ labelId = opts.id, ++ colIndex = opts.col, ++ operation = opts.operation, ++ outputType = opts.write_method, ++ totRowIndex = opts.tot_row_index, ++ excludeRow = opts.exclude_row, ++ decimalPrecision = Types.isUndef(opts.decimal_precision) ? ++ 2 : opts.decimal_precision; ++ ++ //nuovella: determine unique list of columns to operate on ++ var ucolIndex = [], ++ ucolMax = 0; ++ ucolIndex[ucolMax] = colIndex[0]; ++ ++ for(var ii=1; ii maxValue ? ++ parseFloat( cvalue ): maxValue; ++ } ++ } ++ } ++ }//for j ++ if(meanFlag===1){ ++ meanValue = sumValue/nbvalues; ++ } ++ if(medFlag===1){ ++ var aux = 0; ++ if(nbvalues%2 === 1){ ++ aux = Math.floor(nbvalues/2); ++ medValue = theList[aux]; ++ } else{ ++ medValue = ++ (theList[nbvalues/2] + theList[((nbvalues/2)-1)])/2; ++ } ++ } ++ var posa; ++ if(q1Flag===1){ ++ posa=0.0; ++ posa = Math.floor(nbvalues/4); ++ if(4*posa == nbvalues){ ++ q1Value = (theList[posa-1] + theList[posa])/2; ++ } else { ++ q1Value = theList[posa]; ++ } ++ } ++ if (q3Flag===1){ ++ posa=0.0; ++ var posb=0.0; ++ posa = Math.floor(nbvalues/4); ++ if (4*posa === nbvalues){ ++ posb = 3*posa; ++ q3Value = (theList[posb] + theList[posb-1])/2; ++ } else { ++ q3Value = theList[nbvalues-posa-1]; ++ } ++ } ++ ++ for(var i=0; i<=mThisCol; i++){ ++ switch( opsThisCol[i] ){ ++ case 'mean': ++ result=meanValue; ++ break; ++ case 'sum': ++ result=sumValue; ++ break; ++ case 'min': ++ result=minValue; ++ break; ++ case 'max': ++ result=maxValue; ++ break; ++ case 'median': ++ result=medValue; ++ break; ++ case 'q1': ++ result=q1Value; ++ break; ++ case 'q3': ++ result=q3Value; ++ break; ++ } ++ ++ var precision = !isNaN(decThisCol[i]) ? decThisCol[i] : 2; ++ ++ //if outputType is defined ++ if(oTypeThisCol && result){ ++ result = result.toFixed( precision ); ++ ++ if(Dom.id(labThisCol[i])){ ++ switch( Str.lower(oTypeThisCol) ){ ++ case 'innerhtml': ++ if (isNaN(result) || !isFinite(result) || ++ nbvalues===0){ ++ Dom.id(labThisCol[i]).innerHTML = '.'; ++ } else{ ++ Dom.id(labThisCol[i]).innerHTML= result; ++ } ++ break; ++ case 'setvalue': ++ Dom.id( labThisCol[i] ).value = result; ++ break; ++ case 'createtextnode': ++ var oldnode = Dom.id(labThisCol[i]) ++ .firstChild; ++ var txtnode = Dom.text(result); ++ Dom.id(labThisCol[i]) ++ .replaceChild(txtnode, oldnode); ++ break; ++ }//switch ++ } ++ } else { ++ try{ ++ if(isNaN(result) || !isFinite(result) || ++ nbvalues===0){ ++ Dom.id(labThisCol[i]).innerHTML = '.'; ++ } else { ++ Dom.id(labThisCol[i]).innerHTML = ++ result.toFixed(precision); ++ } ++ } catch(e) {}//catch ++ }//else ++ }//for i ++ ++ // row(s) with result are always visible ++ var totRow = totRowIndex && totRowIndex[ucol] ? ++ rows[totRowIndex[ucol]] : null; ++ if(totRow){ ++ totRow.style.display = ''; ++ } ++ }//for ucol ++ }//if typeof ++ ++ if(this.onAfterOperation){ ++ this.onAfterOperation.call(null, tf); ++ } ++ } ++ ++ destroy(){} ++ ++} diff --cc debian/missing-sources/tablefilter/extensions/colsVisibility/colsVisibility.js index 0000000,0000000..5181861 new file mode 100644 --- /dev/null +++ b/debian/missing-sources/tablefilter/extensions/colsVisibility/colsVisibility.js @@@ -1,0 -1,0 +1,520 @@@ ++import Dom from '../../dom'; ++import Types from '../../types'; ++import Event from '../../event'; ++ ++export default class ColsVisibility{ ++ ++ /** ++ * Columns Visibility extension ++ * @param {Object} tf TableFilter instance ++ * @param {Object} f Config ++ */ ++ constructor(tf, f){ ++ ++ // Configuration object ++ var cfg = tf.config(); ++ ++ this.initialized = false; ++ this.name = f.name; ++ this.desc = f.description || 'Columns visibility manager'; ++ ++ //show/hide cols span element ++ this.spanEl = null; ++ //show/hide cols button element ++ this.btnEl = null; ++ //show/hide cols container div element ++ this.contEl = null; ++ ++ //tick to hide or show column ++ this.tickToHide = f.tick_to_hide===false ? false : true; ++ //enables/disables cols manager generation ++ this.manager = f.manager===false ? false : true; ++ //only if external headers ++ this.headersTbl = f.headers_table || false; ++ //only if external headers ++ this.headersIndex = f.headers_index || 1; ++ //id of container element ++ this.contElTgtId = f.container_target_id || null; ++ //alternative headers text ++ this.headersText = f.headers_text || null; ++ //id of button container element ++ this.btnTgtId = f.btn_target_id || null; ++ //defines show/hide cols text ++ this.btnText = f.btn_text || 'Columns▼'; ++ //defines show/hide cols button innerHtml ++ this.btnHtml = f.btn_html || null; ++ //defines css class for show/hide cols button ++ this.btnCssClass = f.btn_css_class || 'colVis'; ++ //defines close link text ++ this.btnCloseText = f.btn_close_text || 'Close'; ++ //defines close button innerHtml ++ this.btnCloseHtml = f.btn_close_html || null; ++ //defines css class for close button ++ this.btnCloseCssClass = f.btn_close_css_class || this.btnCssClass; ++ this.stylesheet = f.stylesheet || 'colsVisibility.css'; ++ //span containing show/hide cols button ++ this.prfx = 'colVis_'; ++ //defines css class span containing show/hide cols ++ this.spanCssClass = f.span_css_class || 'colVisSpan'; ++ this.prfxCont = this.prfx + 'Cont_'; ++ //defines css class div containing show/hide cols ++ this.contCssClass = f.cont_css_class || 'colVisCont'; ++ //defines css class for cols list (ul) ++ this.listCssClass = cfg.list_css_class ||'cols_checklist'; ++ //defines css class for list item (li) ++ this.listItemCssClass = cfg.checklist_item_css_class || ++ 'cols_checklist_item'; ++ //defines css class for selected list item (li) ++ this.listSlcItemCssClass = cfg.checklist_selected_item_css_class || ++ 'cols_checklist_slc_item'; ++ //text preceding columns list ++ this.text = f.text || (this.tickToHide ? 'Hide: ' : 'Show: '); ++ this.atStart = f.at_start || null; ++ this.enableHover = Boolean(f.enable_hover); ++ //enables select all option ++ this.enableTickAll = Boolean(f.enable_tick_all); ++ //text preceding columns list ++ this.tickAllText = f.tick_all_text || 'Select all:'; ++ ++ //array containing hidden columns indexes ++ this.hiddenCols = []; ++ this.tblHasColTag = (Dom.tag(tf.tbl,'col').length > 0); ++ ++ //callback invoked just after cols manager is loaded ++ this.onLoaded = Types.isFn(f.on_loaded) ? f.on_loaded : null; ++ //calls function before cols manager is opened ++ this.onBeforeOpen = Types.isFn(f.on_before_open) ? ++ f.on_before_open : null; ++ //calls function after cols manager is opened ++ this.onAfterOpen = Types.isFn(f.on_after_open) ? f.on_after_open : null; ++ //calls function before cols manager is closed ++ this.onBeforeClose = Types.isFn(f.on_before_close) ? ++ f.on_before_close : null; ++ //calls function after cols manager is closed ++ this.onAfterClose = Types.isFn(f.on_after_close) ? ++ f.on_after_close : null; ++ ++ //callback before col is hidden ++ this.onBeforeColHidden = Types.isFn(f.on_before_col_hidden) ? ++ f.on_before_col_hidden : null; ++ //callback after col is hidden ++ this.onAfterColHidden = Types.isFn(f.on_after_col_hidden) ? ++ f.on_after_col_hidden : null; ++ //callback before col is displayed ++ this.onBeforeColDisplayed = Types.isFn(f.on_before_col_displayed) ? ++ f.on_before_col_displayed : null; ++ //callback after col is displayed ++ this.onAfterColDisplayed = Types.isFn(f.on_after_col_displayed) ? ++ f.on_after_col_displayed : null; ++ ++ //Grid layout compatibility ++ if(tf.gridLayout){ ++ this.headersTbl = tf.feature('gridLayout').headTbl; //headers table ++ this.headersIndex = 0; //headers index ++ this.onAfterColDisplayed = function(){}; ++ this.onAfterColHidden = function(){}; ++ } ++ ++ //Loads extension stylesheet ++ tf.import(f.name+'Style', tf.stylePath + this.stylesheet, null, 'link'); ++ ++ this.tf = tf; ++ } ++ ++ toggle(){ ++ var contDisplay = this.contEl.style.display; ++ var onBeforeOpen = this.onBeforeOpen; ++ var onBeforeClose = this.onBeforeClose; ++ var onAfterOpen = this.onAfterOpen; ++ var onAfterClose = this.onAfterClose; ++ ++ if(onBeforeOpen && contDisplay !== 'inline'){ ++ onBeforeOpen.call(null, this); ++ } ++ if(onBeforeClose && contDisplay === 'inline'){ ++ onBeforeClose.call(null, this); ++ } ++ ++ this.contEl.style.display = contDisplay === 'inline' ? ++ 'none' : 'inline'; ++ ++ if(onAfterOpen && contDisplay !== 'inline'){ ++ onAfterOpen.call(null, this); ++ } ++ if(onAfterClose && contDisplay === 'inline'){ ++ onAfterClose.call(null, this); ++ } ++ } ++ ++ checkItem(lbl){ ++ var li = lbl.parentNode; ++ if(!li || !lbl){ ++ return; ++ } ++ var isChecked = lbl.firstChild.checked; ++ var colIndex = lbl.firstChild.getAttribute('id').split('_')[1]; ++ colIndex = parseInt(colIndex, 10); ++ if(isChecked){ ++ Dom.addClass(li, this.listSlcItemCssClass); ++ } else { ++ Dom.removeClass(li, this.listSlcItemCssClass); ++ } ++ ++ var hide = false; ++ if((this.tickToHide && isChecked) || (!this.tickToHide && !isChecked)){ ++ hide = true; ++ } ++ this.setHidden(colIndex, hide); ++ } ++ ++ init(){ ++ if(!this.manager){ ++ return; ++ } ++ this.buildBtn(); ++ this.buildManager(); ++ ++ this.initialized = true; ++ } ++ ++ /** ++ * Build main button UI ++ */ ++ buildBtn(){ ++ if(this.btnEl){ ++ return; ++ } ++ var tf = this.tf; ++ var span = Dom.create('span', ['id', this.prfx+tf.id]); ++ span.className = this.spanCssClass; ++ ++ //Container element (rdiv or custom element) ++ if(!this.btnTgtId){ ++ tf.setToolbar(); ++ } ++ var targetEl = !this.btnTgtId ? tf.rDiv : Dom.id(this.btnTgtId); ++ ++ if(!this.btnTgtId){ ++ var firstChild = targetEl.firstChild; ++ firstChild.parentNode.insertBefore(span, firstChild); ++ } else { ++ targetEl.appendChild(span); ++ } ++ ++ if(!this.btnHtml){ ++ var btn = Dom.create('a', ['href','javascript:;']); ++ btn.className = this.btnCssClass; ++ btn.title = this.desc; ++ ++ btn.innerHTML = this.btnText; ++ span.appendChild(btn); ++ if(!this.enableHover){ ++ Event.add(btn, 'click', (evt)=> { this.toggle(evt); }); ++ } else { ++ Event.add(btn, 'mouseover', (evt)=> { this.toggle(evt); }); ++ } ++ } else { //Custom html ++ span.innerHTML = this.btnHtml; ++ var colVisEl = span.firstChild; ++ if(!this.enableHover){ ++ Event.add(colVisEl, 'click', (evt)=> { this.toggle(evt); }); ++ } else { ++ Event.add(colVisEl, 'mouseover', (evt)=> { this.toggle(evt); }); ++ } ++ } ++ ++ this.spanEl = span; ++ this.btnEl = this.spanEl.firstChild; ++ ++ if(this.onLoaded){ ++ this.onLoaded.call(null, this); ++ } ++ } ++ ++ /** ++ * Build columns manager UI ++ */ ++ buildManager(){ ++ var tf = this.tf; ++ ++ var container = !this.contElTgtId ? ++ Dom.create('div', ['id', this.prfxCont+tf.id]) : ++ Dom.id(this.contElTgtId); ++ container.className = this.contCssClass; ++ ++ //Extension description ++ var extNameLabel = Dom.create('p'); ++ extNameLabel.innerHTML = this.text; ++ container.appendChild(extNameLabel); ++ ++ //Headers list ++ var ul = Dom.create('ul' ,['id', 'ul'+this.name+'_'+tf.id]); ++ ul.className = this.listCssClass; ++ ++ var tbl = this.headersTbl ? this.headersTbl : tf.tbl; ++ var headerIndex = this.headersTbl ? ++ this.headersIndex : tf.getHeadersRowIndex(); ++ var headerRow = tbl.rows[headerIndex]; ++ ++ //Tick all option ++ if(this.enableTickAll){ ++ var li = Dom.createCheckItem( ++ 'col__'+tf.id, this.tickAllText, this.tickAllText); ++ Dom.addClass(li, this.listItemCssClass); ++ ul.appendChild(li); ++ li.check.checked = !this.tickToHide; ++ ++ Event.add(li.check, 'click', ()=> { ++ for(var h = 0; h < headerRow.cells.length; h++){ ++ var itm = Dom.id('col_'+h+'_'+tf.id); ++ if(itm && li.check.checked !== itm.checked){ ++ itm.click(); ++ itm.checked = li.check.checked; ++ } ++ } ++ }); ++ } ++ ++ for(var i = 0; i < headerRow.cells.length; i++){ ++ var cell = headerRow.cells[i]; ++ var cellText = this.headersText && this.headersText[i] ? ++ this.headersText[i] : this._getHeaderText(cell); ++ var liElm = Dom.createCheckItem( ++ 'col_'+i+'_'+tf.id, cellText, cellText); ++ Dom.addClass(liElm, this.listItemCssClass); ++ if(!this.tickToHide){ ++ Dom.addClass(liElm, this.listSlcItemCssClass); ++ } ++ ul.appendChild(liElm); ++ if(!this.tickToHide){ ++ liElm.check.checked = true; ++ } ++ ++ Event.add(liElm.check, 'click', (evt)=> { ++ var elm = Event.target(evt); ++ var lbl = elm.parentNode; ++ this.checkItem(lbl); ++ }); ++ } ++ ++ //separator ++ var p = Dom.create('p', ['align','center']); ++ var btn; ++ //Close link ++ if(!this.btnCloseHtml){ ++ btn = Dom.create('a', ['href','javascript:;']); ++ btn.className = this.btnCloseCssClass; ++ btn.innerHTML = this.btnCloseText; ++ Event.add(btn, 'click', (evt)=> { this.toggle(evt); }); ++ p.appendChild(btn); ++ } else { ++ p.innerHTML = this.btnCloseHtml; ++ btn = p.firstChild; ++ Event.add(btn, 'click', (evt)=> { this.toggle(evt); }); ++ } ++ ++ container.appendChild(ul); ++ container.appendChild(p); ++ ++ this.btnEl.parentNode.insertBefore(container, this.btnEl); ++ this.contEl = container; ++ ++ if(this.atStart){ ++ var a = this.atStart; ++ for(var k=0; k