();
+ }
+
+ [ScriptableMember]
+ ///
+ /// Uploads the next chunk of the current file. Returns true/false if there is more chunks.
+ ///
+ /// true/false if there is more chunks
+ public bool UploadNextChunk() {
+ if (this.currentFile != null)
+ return this.currentFile.UploadNextChunk();
+
+ return false;
+ }
+
+ ///
+ /// Send debug message to firebug console.
+ ///
+ ///
+
+ v3.5
+
+
+ Debug
+ AnyCPU
+ Plupload
+ plupload.silverlight
+ Moxiecode.Plupload
+ false
+ 2.1.1535.0
+ {95F0DEE8-DE7A-46C5-9DCC-0570B0FC4643}
+ Library
+ true
+ v3.0
+ {A1591282-1198-4647-A2B1-27E5FF5F6F3B};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}
+ Default.html
+ true
+ plupload.silverlight.xap
+ true
+ Properties\AppManifest.xml
+ Moxiecode.Plupload.App
+ true
+ Default.html
+ SILVERLIGHT
+ true
+ C:\Users\spocke\AppData\Roaming\ICSharpCode/SharpDevelop3.0\Settings.SourceAnalysis
+ OnBuildSuccess
+ False
+ false
+
+
+
+
+ 3.5
+ Silverlight
+ $(TargetFrameworkVersion)
+ false
+ publish\
+ true
+ Disk
+ false
+ Foreground
+ 7
+ Days
+ false
+ false
+ true
+ 0
+ 1.0.0.%2a
+ false
+ true
+ true
+
+
+ true
+ full
+ false
+ bin\Debug\
+ TRACE;DEBUG;SILVERLIGHT
+ prompt
+ 4
+
+
+ PdbOnly
+ true
+ bin\
+ SILVERLIGHT
+ prompt
+ 4
+ false
+
+
+ False
+
+
+ False
+ Auto
+ 4194304
+ AnyCPU
+ 4096
+
+
+
+ MSBuild:Compile
+ Designer
+ MSBuild:Compile
+ Designer
+
+
+ App.xaml
+
+
+ Code
+
+
+ Code
+
+
+ Code
+
+
+ Code
+
+
+ Code
+
+
+ Code
+
+
+ Code
+
+
+ Code
+
+
+ Code
+
+
+ Code
+
+
+ Code
+
+
+ Code
+
+
+ Code
+
+
+ Code
+
+
+ Code
+
+
+ Code
+
+
+ Code
+
+
+ Code
+
+
+ Page.xaml
+
+
+ MSBuild:Compile
+ Designer
+ MSBuild:Compile
+ Designer
+
+
+
+
+
+
+ False
+ .NET Framework 3.5 SP1 Client Profile
+ false
+
+
+ False
+ .NET Framework 3.5 SP1
+ true
+
+
+ False
+ Microsoft Visual Basic PowerPacks 10.0
+ true
+
+
+ False
+ Windows Installer 3.1
+ true
+
+
+
+
+
+ copy /Y plupload.silverlight.xap ..\..\..\..\js\plupload.silverlight.xap
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/public/javascripts/plupload/src/csharp/Plupload/Plupload.sln b/public/javascripts/plupload/src/csharp/Plupload/Plupload.sln
new file mode 100644
index 0000000..47a792e
--- /dev/null
+++ b/public/javascripts/plupload/src/csharp/Plupload/Plupload.sln
@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 11.00
+# Visual Studio 2010
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Plupload", "Plupload.csproj", "{95F0DEE8-DE7A-46C5-9DCC-0570B0FC4643}"
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|Any CPU = Debug|Any CPU
+ Release|Any CPU = Release|Any CPU
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {95F0DEE8-DE7A-46C5-9DCC-0570B0FC4643}.Debug|Any CPU.ActiveCfg = Release|Any CPU
+ {95F0DEE8-DE7A-46C5-9DCC-0570B0FC4643}.Debug|Any CPU.Build.0 = Release|Any CPU
+ {95F0DEE8-DE7A-46C5-9DCC-0570B0FC4643}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {95F0DEE8-DE7A-46C5-9DCC-0570B0FC4643}.Release|Any CPU.Build.0 = Release|Any CPU
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+EndGlobal
diff --git a/public/javascripts/plupload/src/csharp/Plupload/PngEncoder/Adler32.cs b/public/javascripts/plupload/src/csharp/Plupload/PngEncoder/Adler32.cs
new file mode 100644
index 0000000..febc82e
--- /dev/null
+++ b/public/javascripts/plupload/src/csharp/Plupload/PngEncoder/Adler32.cs
@@ -0,0 +1,216 @@
+// Adler32.cs - Computes Adler32 data checksum of a data stream
+// Copyright (C) 2001 Mike Krueger
+//
+// This file was translated from java, it was part of the GNU Classpath
+// Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
+//
+// This program 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 program 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, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+// Linking this library statically or dynamically with other modules is
+// making a combined work based on this library. Thus, the terms and
+// conditions of the GNU General Public License cover the whole
+// combination.
+//
+// As a special exception, the copyright holders of this library give you
+// permission to link this library with independent modules to produce an
+// executable, regardless of the license terms of these independent
+// modules, and to copy and distribute the resulting executable under
+// terms of your choice, provided that you also meet, for each linked
+// independent module, the terms and conditions of the license of that
+// module. An independent module is a module which is not derived from
+// or based on this library. If you modify this library, you may extend
+// this exception to your version of the library, but you are not
+// obligated to do so. If you do not wish to do so, delete this
+// exception statement from your version.
+
+using System;
+
+namespace Plupload.PngEncoder {
+
+ ///
+ /// Computes Adler32 checksum for a stream of data. An Adler32
+ /// checksum is not as reliable as a CRC32 checksum, but a lot faster to
+ /// compute.
+ ///
+ /// The specification for Adler32 may be found in RFC 1950.
+ /// ZLIB Compressed Data Format Specification version 3.3)
+ ///
+ ///
+ /// From that document:
+ ///
+ /// "ADLER32 (Adler-32 checksum)
+ /// This contains a checksum value of the uncompressed data
+ /// (excluding any dictionary data) computed according to Adler-32
+ /// algorithm. This algorithm is a 32-bit extension and improvement
+ /// of the Fletcher algorithm, used in the ITU-T X.224 / ISO 8073
+ /// standard.
+ ///
+ /// Adler-32 is composed of two sums accumulated per byte: s1 is
+ /// the sum of all bytes, s2 is the sum of all s1 values. Both sums
+ /// are done modulo 65521. s1 is initialized to 1, s2 to zero. The
+ /// Adler-32 checksum is stored as s2*65536 + s1 in most-
+ /// significant-byte first (network) order."
+ ///
+ /// "8.2. The Adler-32 algorithm
+ ///
+ /// The Adler-32 algorithm is much faster than the CRC32 algorithm yet
+ /// still provides an extremely low probability of undetected errors.
+ ///
+ /// The modulo on unsigned long accumulators can be delayed for 5552
+ /// bytes, so the modulo operation time is negligible. If the bytes
+ /// are a, b, c, the second sum is 3a + 2b + c + 3, and so is position
+ /// and order sensitive, unlike the first sum, which is just a
+ /// checksum. That 65521 is prime is important to avoid a possible
+ /// large class of two-byte errors that leave the check unchanged.
+ /// (The Fletcher checksum uses 255, which is not prime and which also
+ /// makes the Fletcher check insensitive to single byte changes 0 -
+ /// 255.)
+ ///
+ /// The sum s1 is initialized to 1 instead of zero to make the length
+ /// of the sequence part of s2, so that the length does not have to be
+ /// checked separately. (Any sequence of zeroes has a Fletcher
+ /// checksum of zero.)"
+ ///
+ ///
+ /// largest prime smaller than 65536
+ ///
+ const uint BASE = 65521;
+
+ ///
+ /// Returns the Adler32 data checksum computed so far.
+ ///
+ public long Value {
+ get {
+ return checksum;
+ }
+ }
+
+ ///
+ /// Creates a new instance of the Adler32 class.
+ /// The checksum starts off with a value of 1.
+ ///
+ public Adler32() {
+ Reset();
+ }
+
+ ///
+ /// Resets the Adler32 checksum to the initial value.
+ ///
+ public void Reset() {
+ checksum = 1;
+ }
+
+ ///
+ /// Updates the checksum with a byte value.
+ ///
+ ///
+ /// Updates the checksum with an array of bytes.
+ ///
+ ///
+ /// Updates the checksum with the bytes taken from the array.
+ ///
+ ///
+ /// Generate a table for a byte-wise 32-bit CRC calculation on the polynomial:
+ /// x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.
+ ///
+ /// Polynomials over GF(2) are represented in binary, one bit per coefficient,
+ /// with the lowest powers in the most significant bit. Then adding polynomials
+ /// is just exclusive-or, and multiplying a polynomial by x is a right shift by
+ /// one. If we call the above polynomial p, and represent a byte as the
+ /// polynomial q, also with the lowest power in the most significant bit (so the
+ /// byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,
+ /// where a mod b means the remainder after dividing a by b.
+ ///
+ /// This calculation is done using the shift-register method of multiplying and
+ /// taking the remainder. The register is initialized to zero, and for each
+ /// incoming bit, x^32 is added mod p to the register if the bit is a one (where
+ /// x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by
+ /// x (which is shifting right by one and adding x^32 mod p if the bit shifted
+ /// out is a one). We start with the highest power (least significant bit) of
+ /// q and repeat for all eight bits of q.
+ ///
+ /// The table is simply the CRC of all possible eight bit values. This is all
+ /// the information needed to generate CRC's on data a byte at a time for all
+ /// combinations of CRC register values and incoming bytes.
+ ///
+ public sealed class Crc32 : IChecksum {
+ const uint CrcSeed = 0xFFFFFFFF;
+
+ readonly static uint[] CrcTable = new uint[] {
+ 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419,
+ 0x706AF48F, 0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4,
+ 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07,
+ 0x90BF1D91, 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
+ 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856,
+ 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9,
+ 0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4,
+ 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
+ 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3,
+ 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 0x26D930AC, 0x51DE003A,
+ 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599,
+ 0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
+ 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, 0x76DC4190,
+ 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F,
+ 0x9FBFE4A5, 0xE8B8D433, 0x7807C9A2, 0x0F00F934, 0x9609A88E,
+ 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
+ 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED,
+ 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950,
+ 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3,
+ 0xFBD44C65, 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
+ 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A,
+ 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5,
+ 0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA, 0xBE0B1010,
+ 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
+ 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17,
+ 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6,
+ 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615,
+ 0x73DC1683, 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
+ 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 0xF00F9344,
+ 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB,
+ 0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A,
+ 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
+ 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1,
+ 0xA6BC5767, 0x3FB506DD, 0x48B2364B, 0xD80D2BDA, 0xAF0A1B4C,
+ 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF,
+ 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
+ 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE,
+ 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31,
+ 0x2CD99E8B, 0x5BDEAE1D, 0x9B64C2B0, 0xEC63F226, 0x756AA39C,
+ 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
+ 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B,
+ 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242,
+ 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1,
+ 0x18B74777, 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
+ 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, 0xA00AE278,
+ 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7,
+ 0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66,
+ 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
+ 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605,
+ 0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8,
+ 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B,
+ 0x2D02EF8D
+ };
+
+ internal static uint ComputeCrc32(uint oldCrc, byte value) {
+ return (uint) (Crc32.CrcTable[(oldCrc ^ value) & 0xFF] ^ (oldCrc >> 8));
+ }
+
+ ///
+ /// The crc data checksum so far.
+ ///
+ uint crc;
+
+ ///
+ /// Returns the CRC32 data checksum computed so far.
+ ///
+ public long Value {
+ get {
+ return (long) crc;
+ }
+ set {
+ crc = (uint) value;
+ }
+ }
+
+ ///
+ /// Resets the CRC32 data checksum as if no update was ever called.
+ ///
+ public void Reset() {
+ crc = 0;
+ }
+
+ ///
+ /// Updates the checksum with the int bval.
+ ///
+ ///
+ /// Updates the checksum with the bytes taken from the array.
+ ///
+ ///
+ /// Adds the byte array to the data checksum.
+ ///
+ ///
+ /// This is the Deflater class. The deflater class compresses input
+ /// with the deflate algorithm described in RFC 1951. It has several
+ /// compression levels and three different strategies described below.
+ ///
+ /// This class is not thread safe. This is inherent in the API, due
+ /// to the split of deflate and setInput.
+ ///
+ /// author of the original java version : Jochen Hoenicke
+ ///
+ public class Deflater {
+ #region Deflater Documentation
+ /*
+ * The Deflater can do the following state transitions:
+ *
+ * (1) -> INIT_STATE ----> INIT_FINISHING_STATE ---.
+ * / | (2) (5) |
+ * / v (5) |
+ * (3)| SETDICT_STATE ---> SETDICT_FINISHING_STATE |(3)
+ * \ | (3) | ,--------'
+ * | | | (3) /
+ * v v (5) v v
+ * (1) -> BUSY_STATE ----> FINISHING_STATE
+ * | (6)
+ * v
+ * FINISHED_STATE
+ * \_____________________________________/
+ * | (7)
+ * v
+ * CLOSED_STATE
+ *
+ * (1) If we should produce a header we start in INIT_STATE, otherwise
+ * we start in BUSY_STATE.
+ * (2) A dictionary may be set only when we are in INIT_STATE, then
+ * we change the state as indicated.
+ * (3) Whether a dictionary is set or not, on the first call of deflate
+ * we change to BUSY_STATE.
+ * (4) -- intentionally left blank -- :)
+ * (5) FINISHING_STATE is entered, when flush() is called to indicate that
+ * there is no more INPUT. There are also states indicating, that
+ * the header wasn't written yet.
+ * (6) FINISHED_STATE is entered, when everything has been flushed to the
+ * internal pending output buffer.
+ * (7) At any time (7)
+ *
+ */
+ #endregion
+ #region Public Constants
+ ///
+ /// The best and slowest compression level. This tries to find very
+ /// long and distant string repetitions.
+ ///
+ public const int BEST_COMPRESSION = 9;
+
+ ///
+ /// The worst but fastest compression level.
+ ///
+ public const int BEST_SPEED = 1;
+
+ ///
+ /// The default compression level.
+ ///
+ public const int DEFAULT_COMPRESSION = -1;
+
+ ///
+ /// This level won't compress at all but output uncompressed blocks.
+ ///
+ public const int NO_COMPRESSION = 0;
+
+ ///
+ /// The compression method. This is the only method supported so far.
+ /// There is no need to use this constant at all.
+ ///
+ public const int DEFLATED = 8;
+ #endregion
+ #region Local Constants
+ private const int IS_SETDICT = 0x01;
+ private const int IS_FLUSHING = 0x04;
+ private const int IS_FINISHING = 0x08;
+
+ private const int INIT_STATE = 0x00;
+ private const int SETDICT_STATE = 0x01;
+ // private static int INIT_FINISHING_STATE = 0x08;
+ // private static int SETDICT_FINISHING_STATE = 0x09;
+ private const int BUSY_STATE = 0x10;
+ private const int FLUSHING_STATE = 0x14;
+ private const int FINISHING_STATE = 0x1c;
+ private const int FINISHED_STATE = 0x1e;
+ private const int CLOSED_STATE = 0x7f;
+ #endregion
+ #region Constructors
+ ///
+ /// Creates a new deflater with default compression level.
+ ///
+ public Deflater()
+ : this(DEFAULT_COMPRESSION, false) {
+
+ }
+
+ ///
+ /// Creates a new deflater with given compression level.
+ ///
+ /// if lvl is out of range.
+ public Deflater(int level)
+ : this(level, false) {
+
+ }
+
+ ///
+ /// Creates a new deflater with given compression level.
+ ///
+ /// if lvl is out of range.
+ public Deflater(int level, bool noZlibHeaderOrFooter) {
+ if (level == DEFAULT_COMPRESSION) {
+ level = 6;
+ } else if (level < NO_COMPRESSION || level > BEST_COMPRESSION) {
+ throw new ArgumentOutOfRangeException("level");
+ }
+
+ pending = new DeflaterPending();
+ engine = new DeflaterEngine(pending);
+ this.noZlibHeaderOrFooter = noZlibHeaderOrFooter;
+ SetStrategy(DeflateStrategy.Default);
+ SetLevel(level);
+ Reset();
+ }
+ #endregion
+
+ ///
+ /// Resets the deflater. The deflater acts afterwards as if it was
+ /// just created with the same compression level and strategy as it
+ /// had before.
+ ///
+ public void Reset() {
+ state = (noZlibHeaderOrFooter ? BUSY_STATE : INIT_STATE);
+ totalOut = 0;
+ pending.Reset();
+ engine.Reset();
+ }
+
+ ///
+ /// Gets the current adler checksum of the data that was processed so far.
+ ///
+ public int Adler {
+ get {
+ return engine.Adler;
+ }
+ }
+
+ ///
+ /// Gets the number of input bytes processed so far.
+ ///
+ public long TotalIn {
+ get {
+ return engine.TotalIn;
+ }
+ }
+
+ ///
+ /// Gets the number of output bytes so far.
+ ///
+ public long TotalOut {
+ get {
+ return totalOut;
+ }
+ }
+
+ ///
+ /// Flushes the current input block. Further calls to deflate() will
+ /// produce enough output to inflate everything in the current input
+ /// block. This is not part of Sun's JDK so I have made it package
+ /// private. It is used by DeflaterOutputStream to implement
+ /// flush().
+ ///
+ public void Flush() {
+ state |= IS_FLUSHING;
+ }
+
+ ///
+ /// Finishes the deflater with the current input block. It is an error
+ /// to give more input after this method was called. This method must
+ /// be called to force all bytes to be flushed.
+ ///
+ public void Finish() {
+ state |= (IS_FLUSHING | IS_FINISHING);
+ }
+
+ ///
+ /// Returns true if the stream was finished and no more output bytes
+ /// are available.
+ ///
+ public bool IsFinished {
+ get {
+ return (state == FINISHED_STATE) && pending.IsFlushed;
+ }
+ }
+
+ ///
+ /// Returns true, if the input buffer is empty.
+ /// You should then call setInput().
+ /// NOTE: This method can also return true when the stream
+ /// was finished.
+ ///
+ public bool IsNeedingInput {
+ get {
+ return engine.NeedsInput();
+ }
+ }
+
+ ///
+ /// Sets the data which should be compressed next. This should be only
+ /// called when needsInput indicates that more input is needed.
+ /// If you call setInput when needsInput() returns false, the
+ /// previous input that is still pending will be thrown away.
+ /// The given byte array should not be changed, before needsInput() returns
+ /// true again.
+ /// This call is equivalent to setInput(input, 0, input.length).
+ ///
+ ///
+ /// if the buffer was finished() or ended().
+ ///
+ public void SetInput(byte[] input) {
+ SetInput(input, 0, input.Length);
+ }
+
+ ///
+ /// Sets the data which should be compressed next. This should be
+ /// only called when needsInput indicates that more input is needed.
+ /// The given byte array should not be changed, before needsInput() returns
+ /// true again.
+ ///
+ ///
+ /// if the buffer was Finish()ed or if previous input is still pending.
+ ///
+ public void SetInput(byte[] input, int offset, int count) {
+ if ((state & IS_FINISHING) != 0) {
+ throw new InvalidOperationException("Finish() already called");
+ }
+ engine.SetInput(input, offset, count);
+ }
+
+ ///
+ /// Sets the compression level. There is no guarantee of the exact
+ /// position of the change, but if you call this when needsInput is
+ /// true the change of compression level will occur somewhere near
+ /// before the end of the so far given input.
+ ///
+ ///
+ /// Get current compression level
+ ///
+ /// Returns the current compression level
+ public int GetLevel() {
+ return level;
+ }
+
+ ///
+ /// Sets the compression strategy. Strategy is one of
+ /// DEFAULT_STRATEGY, HUFFMAN_ONLY and FILTERED. For the exact
+ /// position where the strategy is changed, the same as for
+ /// SetLevel() applies.
+ ///
+ ///
+ /// Deflates the current input block with to the given array.
+ ///
+ ///
+ /// The number of compressed bytes added to the output, or 0 if either
+ /// IsNeedingInput() or IsFinished returns true or length is zero.
+ ///
+ public int Deflate(byte[] output) {
+ return Deflate(output, 0, output.Length);
+ }
+
+ ///
+ /// Deflates the current input block to the given array.
+ ///
+ ///
+ /// The number of compressed bytes added to the output, or 0 if either
+ /// needsInput() or finished() returns true or length is zero.
+ ///
+ ///
+ /// If Finish() was previously called.
+ ///
+ ///
+ /// If offset or length don't match the array length.
+ ///
+ public int Deflate(byte[] output, int offset, int length) {
+ int origLength = length;
+
+ if (state == CLOSED_STATE) {
+ throw new InvalidOperationException("Deflater closed");
+ }
+
+ if (state < BUSY_STATE) {
+ // output header
+ int header = (DEFLATED +
+ ((DeflaterConstants.MAX_WBITS - 8) << 4)) << 8;
+ int level_flags = (level - 1) >> 1;
+ if (level_flags < 0 || level_flags > 3) {
+ level_flags = 3;
+ }
+ header |= level_flags << 6;
+ if ((state & IS_SETDICT) != 0) {
+ // Dictionary was set
+ header |= DeflaterConstants.PRESET_DICT;
+ }
+ header += 31 - (header % 31);
+
+ pending.WriteShortMSB(header);
+ if ((state & IS_SETDICT) != 0) {
+ int chksum = engine.Adler;
+ engine.ResetAdler();
+ pending.WriteShortMSB(chksum >> 16);
+ pending.WriteShortMSB(chksum & 0xffff);
+ }
+
+ state = BUSY_STATE | (state & (IS_FLUSHING | IS_FINISHING));
+ }
+
+ for (; ; ) {
+ int count = pending.Flush(output, offset, length);
+ offset += count;
+ totalOut += count;
+ length -= count;
+
+ if (length == 0 || state == FINISHED_STATE) {
+ break;
+ }
+
+ if (!engine.Deflate((state & IS_FLUSHING) != 0, (state & IS_FINISHING) != 0)) {
+ if (state == BUSY_STATE) {
+ // We need more input now
+ return origLength - length;
+ } else if (state == FLUSHING_STATE) {
+ if (level != NO_COMPRESSION) {
+ /* We have to supply some lookahead. 8 bit lookahead
+ * is needed by the zlib inflater, and we must fill
+ * the next byte, so that all bits are flushed.
+ */
+ int neededbits = 8 + ((-pending.BitCount) & 7);
+ while (neededbits > 0) {
+ /* write a static tree block consisting solely of
+ * an EOF:
+ */
+ pending.WriteBits(2, 10);
+ neededbits -= 10;
+ }
+ }
+ state = BUSY_STATE;
+ } else if (state == FINISHING_STATE) {
+ pending.AlignToByte();
+
+ // Compressed data is complete. Write footer information if required.
+ if (!noZlibHeaderOrFooter) {
+ int adler = engine.Adler;
+ pending.WriteShortMSB(adler >> 16);
+ pending.WriteShortMSB(adler & 0xffff);
+ }
+ state = FINISHED_STATE;
+ }
+ }
+ }
+ return origLength - length;
+ }
+
+ ///
+ /// Sets the dictionary which should be used in the deflate process.
+ /// This call is equivalent to setDictionary(dict, 0, dict.Length).
+ ///
+ ///
+ /// if SetInput () or Deflate () were already called or another dictionary was already set.
+ ///
+ public void SetDictionary(byte[] dictionary) {
+ SetDictionary(dictionary, 0, dictionary.Length);
+ }
+
+ ///
+ /// Sets the dictionary which should be used in the deflate process.
+ /// The dictionary is a byte array containing strings that are
+ /// likely to occur in the data which should be compressed. The
+ /// dictionary is not stored in the compressed output, only a
+ /// checksum. To decompress the output you need to supply the same
+ /// dictionary again.
+ ///
+ ///
+ /// If SetInput () or Deflate() were already called or another dictionary was already set.
+ ///
+ public void SetDictionary(byte[] dictionary, int index, int count) {
+ if (state != INIT_STATE) {
+ throw new InvalidOperationException();
+ }
+
+ state = SETDICT_STATE;
+ engine.SetDictionary(dictionary, index, count);
+ }
+
+ #region Instance Fields
+ ///
+ /// Compression level.
+ ///
+ int level;
+
+ ///
+ /// If true no Zlib/RFC1950 headers or footers are generated
+ ///
+ bool noZlibHeaderOrFooter;
+
+ ///
+ /// The current state.
+ ///
+ int state;
+
+ ///
+ /// The total bytes of output written.
+ ///
+ long totalOut;
+
+ ///
+ /// The pending output.
+ ///
+ DeflaterPending pending;
+
+ ///
+ /// The deflater engine.
+ ///
+ DeflaterEngine engine;
+ #endregion
+ }
+}
diff --git a/public/javascripts/plupload/src/csharp/Plupload/PngEncoder/DeflaterConstants.cs b/public/javascripts/plupload/src/csharp/Plupload/PngEncoder/DeflaterConstants.cs
new file mode 100644
index 0000000..46587b6
--- /dev/null
+++ b/public/javascripts/plupload/src/csharp/Plupload/PngEncoder/DeflaterConstants.cs
@@ -0,0 +1,184 @@
+// DeflaterConstants.cs
+//
+// Copyright (C) 2001 Mike Krueger
+// Copyright (C) 2004 John Reilly
+//
+// This file was translated from java, it was part of the GNU Classpath
+// Copyright (C) 2001 Free Software Foundation, Inc.
+//
+// This program 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 program 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, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+// Linking this library statically or dynamically with other modules is
+// making a combined work based on this library. Thus, the terms and
+// conditions of the GNU General Public License cover the whole
+// combination.
+//
+// As a special exception, the copyright holders of this library give you
+// permission to link this library with independent modules to produce an
+// executable, regardless of the license terms of these independent
+// modules, and to copy and distribute the resulting executable under
+// terms of your choice, provided that you also meet, for each linked
+// independent module, the terms and conditions of the license of that
+// module. An independent module is a module which is not derived from
+// or based on this library. If you modify this library, you may extend
+// this exception to your version of the library, but you are not
+// obligated to do so. If you do not wish to do so, delete this
+// exception statement from your version.
+
+using System;
+
+namespace Plupload.PngEncoder {
+
+ ///
+ /// This class contains constants used for deflation.
+ ///
+ public class DeflaterConstants {
+ ///
+ /// Set to true to enable debugging
+ ///
+ public const bool DEBUGGING = false;
+
+ ///
+ /// Written to Zip file to identify a stored block
+ ///
+ public const int STORED_BLOCK = 0;
+
+ ///
+ /// Identifies static tree in Zip file
+ ///
+ public const int STATIC_TREES = 1;
+
+ ///
+ /// Identifies dynamic tree in Zip file
+ ///
+ public const int DYN_TREES = 2;
+
+ ///
+ /// Header flag indicating a preset dictionary for deflation
+ ///
+ public const int PRESET_DICT = 0x20;
+
+ ///
+ /// Sets internal buffer sizes for Huffman encoding
+ ///
+ public const int DEFAULT_MEM_LEVEL = 8;
+
+ ///
+ /// Internal compression engine constant
+ ///
+ public const int MAX_MATCH = 258;
+
+ ///
+ /// Internal compression engine constant
+ ///
+ public const int MIN_MATCH = 3;
+
+ ///
+ /// Internal compression engine constant
+ ///
+ public const int MAX_WBITS = 15;
+
+ ///
+ /// Internal compression engine constant
+ ///
+ public const int WSIZE = 1 << MAX_WBITS;
+
+ ///
+ /// Internal compression engine constant
+ ///
+ public const int WMASK = WSIZE - 1;
+
+ ///
+ /// Internal compression engine constant
+ ///
+ public const int HASH_BITS = DEFAULT_MEM_LEVEL + 7;
+
+ ///
+ /// Internal compression engine constant
+ ///
+ public const int HASH_SIZE = 1 << HASH_BITS;
+
+ ///
+ /// Internal compression engine constant
+ ///
+ public const int HASH_MASK = HASH_SIZE - 1;
+
+ ///
+ /// Internal compression engine constant
+ ///
+ public const int HASH_SHIFT = (HASH_BITS + MIN_MATCH - 1) / MIN_MATCH;
+
+ ///
+ /// Internal compression engine constant
+ ///
+ public const int MIN_LOOKAHEAD = MAX_MATCH + MIN_MATCH + 1;
+
+ ///
+ /// Internal compression engine constant
+ ///
+ public const int MAX_DIST = WSIZE - MIN_LOOKAHEAD;
+
+ ///
+ /// Internal compression engine constant
+ ///
+ public const int PENDING_BUF_SIZE = 1 << (DEFAULT_MEM_LEVEL + 8);
+
+ ///
+ /// Internal compression engine constant
+ ///
+ public static int MAX_BLOCK_SIZE = Math.Min(65535, PENDING_BUF_SIZE - 5);
+
+ ///
+ /// Internal compression engine constant
+ ///
+ public const int DEFLATE_STORED = 0;
+
+ ///
+ /// Internal compression engine constant
+ ///
+ public const int DEFLATE_FAST = 1;
+
+ ///
+ /// Internal compression engine constant
+ ///
+ public const int DEFLATE_SLOW = 2;
+
+ ///
+ /// Internal compression engine constant
+ ///
+ public static int[] GOOD_LENGTH = { 0, 4, 4, 4, 4, 8, 8, 8, 32, 32 };
+
+ ///
+ /// Internal compression engine constant
+ ///
+ public static int[] MAX_LAZY = { 0, 4, 5, 6, 4, 16, 16, 32, 128, 258 };
+
+ ///
+ /// Internal compression engine constant
+ ///
+ public static int[] NICE_LENGTH = { 0, 8, 16, 32, 16, 32, 128, 128, 258, 258 };
+
+ ///
+ /// Internal compression engine constant
+ ///
+ public static int[] MAX_CHAIN = { 0, 4, 8, 32, 16, 32, 128, 256, 1024, 4096 };
+
+ ///
+ /// Internal compression engine constant
+ ///
+ public static int[] COMPR_FUNC = { 0, 1, 1, 1, 1, 2, 2, 2, 2, 2 };
+
+ }
+}
diff --git a/public/javascripts/plupload/src/csharp/Plupload/PngEncoder/DeflaterEngine.cs b/public/javascripts/plupload/src/csharp/Plupload/PngEncoder/DeflaterEngine.cs
new file mode 100644
index 0000000..7b56b59
--- /dev/null
+++ b/public/javascripts/plupload/src/csharp/Plupload/PngEncoder/DeflaterEngine.cs
@@ -0,0 +1,832 @@
+// DeflaterEngine.cs
+//
+// Copyright (C) 2001 Mike Krueger
+// Copyright (C) 2004 John Reilly
+//
+// This file was translated from java, it was part of the GNU Classpath
+// Copyright (C) 2001 Free Software Foundation, Inc.
+//
+// This program 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 program 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, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+// Linking this library statically or dynamically with other modules is
+// making a combined work based on this library. Thus, the terms and
+// conditions of the GNU General Public License cover the whole
+// combination.
+//
+// As a special exception, the copyright holders of this library give you
+// permission to link this library with independent modules to produce an
+// executable, regardless of the license terms of these independent
+// modules, and to copy and distribute the resulting executable under
+// terms of your choice, provided that you also meet, for each linked
+// independent module, the terms and conditions of the license of that
+// module. An independent module is a module which is not derived from
+// or based on this library. If you modify this library, you may extend
+// this exception to your version of the library, but you are not
+// obligated to do so. If you do not wish to do so, delete this
+// exception statement from your version.
+
+using System;
+
+namespace Plupload.PngEncoder {
+
+ ///
+ /// Strategies for deflater
+ ///
+ public enum DeflateStrategy {
+ ///
+ /// The default strategy
+ ///
+ Default = 0,
+
+ ///
+ /// This strategy will only allow longer string repetitions. It is
+ /// useful for random data with a small character set.
+ ///
+ Filtered = 1,
+
+
+ ///
+ /// This strategy will not look for string repetitions at all. It
+ /// only encodes with Huffman trees (which means, that more common
+ /// characters get a smaller encoding.
+ ///
+ HuffmanOnly = 2
+ }
+
+ // DEFLATE ALGORITHM:
+ //
+ // The uncompressed stream is inserted into the window array. When
+ // the window array is full the first half is thrown away and the
+ // second half is copied to the beginning.
+ //
+ // The head array is a hash table. Three characters build a hash value
+ // and they the value points to the corresponding index in window of
+ // the last string with this hash. The prev array implements a
+ // linked list of matches with the same hash: prev[index & WMASK] points
+ // to the previous index with the same hash.
+ //
+
+
+ ///
+ /// Low level compression engine for deflate algorithm which uses a 32K sliding window
+ /// with secondary compression from Huffman/Shannon-Fano codes.
+ ///
+ public class DeflaterEngine : DeflaterConstants {
+ #region Constants
+ const int TooFar = 4096;
+ #endregion
+
+ #region Constructors
+ ///
+ /// Construct instance with pending buffer
+ ///
+ ///
+ /// Deflate drives actual compression of data
+ ///
+ /// Returns true if progress has been made.
+ public bool Deflate(bool flush, bool finish) {
+ bool progress;
+ do {
+ FillWindow();
+ bool canFlush = flush && (inputOff == inputEnd);
+
+#if DebugDeflation
+ if (DeflaterConstants.DEBUGGING) {
+ Console.WriteLine("window: [" + blockStart + "," + strstart + ","
+ + lookahead + "], " + compressionFunction + "," + canFlush);
+ }
+#endif
+ switch (compressionFunction) {
+ case DEFLATE_STORED:
+ progress = DeflateStored(canFlush, finish);
+ break;
+ case DEFLATE_FAST:
+ progress = DeflateFast(canFlush, finish);
+ break;
+ case DEFLATE_SLOW:
+ progress = DeflateSlow(canFlush, finish);
+ break;
+ default:
+ throw new InvalidOperationException("unknown compressionFunction");
+ }
+ } while (pending.IsFlushed && progress); // repeat while we have no pending output and progress was made
+ return progress;
+ }
+
+ ///
+ /// Sets input data to be deflated. Should only be called when NeedsInput()
+ /// returns true
+ ///
+ ///
+ /// Determines if more input is needed.
+ ///
+ /// Return true if input is needed via SetInput
+ public bool NeedsInput() {
+ return (inputEnd == inputOff);
+ }
+
+ ///
+ /// Set compression dictionary
+ ///
+ ///
+ /// Reset internal state
+ ///
+ public void Reset() {
+ huffman.Reset();
+ adler.Reset();
+ blockStart = strstart = 1;
+ lookahead = 0;
+ totalIn = 0;
+ prevAvailable = false;
+ matchLen = MIN_MATCH - 1;
+
+ for (int i = 0; i < HASH_SIZE; i++) {
+ head[i] = 0;
+ }
+
+ for (int i = 0; i < WSIZE; i++) {
+ prev[i] = 0;
+ }
+ }
+
+ ///
+ /// Reset Adler checksum
+ ///
+ public void ResetAdler() {
+ adler.Reset();
+ }
+
+ ///
+ /// Get current value of Adler checksum
+ ///
+ public int Adler {
+ get {
+ return unchecked((int) adler.Value);
+ }
+ }
+
+ ///
+ /// Total data processed
+ ///
+ public long TotalIn {
+ get {
+ return totalIn;
+ }
+ }
+
+ ///
+ /// Get/set the deflate strategy
+ ///
+ public DeflateStrategy Strategy {
+ get {
+ return strategy;
+ }
+ set {
+ strategy = value;
+ }
+ }
+
+ ///
+ /// Set the deflate level (0-9)
+ ///
+ ///
+ /// Fill the window
+ ///
+ public void FillWindow() {
+ /* If the window is almost full and there is insufficient lookahead,
+ * move the upper half to the lower one to make room in the upper half.
+ */
+ if (strstart >= WSIZE + MAX_DIST) {
+ SlideWindow();
+ }
+
+ /* If there is not enough lookahead, but still some input left,
+ * read in the input
+ */
+ while (lookahead < DeflaterConstants.MIN_LOOKAHEAD && inputOff < inputEnd) {
+ int more = 2 * WSIZE - lookahead - strstart;
+
+ if (more > inputEnd - inputOff) {
+ more = inputEnd - inputOff;
+ }
+
+ System.Array.Copy(inputBuf, inputOff, window, strstart + lookahead, more);
+ adler.Update(inputBuf, inputOff, more);
+
+ inputOff += more;
+ totalIn += more;
+ lookahead += more;
+ }
+
+ if (lookahead >= MIN_MATCH) {
+ UpdateHash();
+ }
+ }
+
+ void UpdateHash() {
+ /*
+ if (DEBUGGING) {
+ Console.WriteLine("updateHash: "+strstart);
+ }
+ */
+ ins_h = (window[strstart] << HASH_SHIFT) ^ window[strstart + 1];
+ }
+
+ ///
+ /// Inserts the current string in the head hash and returns the previous
+ /// value for this hash.
+ ///
+ /// The previous hash value
+ int InsertString() {
+ short match;
+ int hash = ((ins_h << HASH_SHIFT) ^ window[strstart + (MIN_MATCH - 1)]) & HASH_MASK;
+
+#if DebugDeflation
+ if (DeflaterConstants.DEBUGGING)
+ {
+ if (hash != (((window[strstart] << (2*HASH_SHIFT)) ^
+ (window[strstart + 1] << HASH_SHIFT) ^
+ (window[strstart + 2])) & HASH_MASK)) {
+ throw new SharpZipBaseException("hash inconsistent: " + hash + "/"
+ +window[strstart] + ","
+ +window[strstart + 1] + ","
+ +window[strstart + 2] + "," + HASH_SHIFT);
+ }
+ }
+#endif
+ prev[strstart & WMASK] = match = head[hash];
+ head[hash] = unchecked((short) strstart);
+ ins_h = hash;
+ return match & 0xffff;
+ }
+
+ void SlideWindow() {
+ Array.Copy(window, WSIZE, window, 0, WSIZE);
+ matchStart -= WSIZE;
+ strstart -= WSIZE;
+ blockStart -= WSIZE;
+
+ // Slide the hash table (could be avoided with 32 bit values
+ // at the expense of memory usage).
+ for (int i = 0; i < HASH_SIZE; ++i) {
+ int m = head[i] & 0xffff;
+ head[i] = (short) (m >= WSIZE ? (m - WSIZE) : 0);
+ }
+
+ // Slide the prev table.
+ for (int i = 0; i < WSIZE; i++) {
+ int m = prev[i] & 0xffff;
+ prev[i] = (short) (m >= WSIZE ? (m - WSIZE) : 0);
+ }
+ }
+
+ ///
+ /// Find the best (longest) string in the window matching the
+ /// string starting at strstart.
+ ///
+ /// Preconditions:
+ ///
+ /// strstart + MAX_MATCH <= window.length.
+ ///
+ /// True if a match greater than the minimum length is found
+ bool FindLongestMatch(int curMatch) {
+ int chainLength = this.max_chain;
+ int niceLength = this.niceLength;
+ short[] prev = this.prev;
+ int scan = this.strstart;
+ int match;
+ int best_end = this.strstart + matchLen;
+ int best_len = Math.Max(matchLen, MIN_MATCH - 1);
+
+ int limit = Math.Max(strstart - MAX_DIST, 0);
+
+ int strend = strstart + MAX_MATCH - 1;
+ byte scan_end1 = window[best_end - 1];
+ byte scan_end = window[best_end];
+
+ // Do not waste too much time if we already have a good match:
+ if (best_len >= this.goodLength) {
+ chainLength >>= 2;
+ }
+
+ /* Do not look for matches beyond the end of the input. This is necessary
+ * to make deflate deterministic.
+ */
+ if (niceLength > lookahead) {
+ niceLength = lookahead;
+ }
+
+#if DebugDeflation
+
+ if (DeflaterConstants.DEBUGGING && (strstart > 2 * WSIZE - MIN_LOOKAHEAD))
+ {
+ throw new InvalidOperationException("need lookahead");
+ }
+#endif
+
+ do {
+
+#if DebugDeflation
+
+ if (DeflaterConstants.DEBUGGING && (curMatch >= strstart) )
+ {
+ throw new InvalidOperationException("no future");
+ }
+#endif
+ if (window[curMatch + best_len] != scan_end ||
+ window[curMatch + best_len - 1] != scan_end1 ||
+ window[curMatch] != window[scan] ||
+ window[curMatch + 1] != window[scan + 1]) {
+ continue;
+ }
+
+ match = curMatch + 2;
+ scan += 2;
+
+ /* We check for insufficient lookahead only every 8th comparison;
+ * the 256th check will be made at strstart + 258.
+ */
+ while (
+ window[++scan] == window[++match] &&
+ window[++scan] == window[++match] &&
+ window[++scan] == window[++match] &&
+ window[++scan] == window[++match] &&
+ window[++scan] == window[++match] &&
+ window[++scan] == window[++match] &&
+ window[++scan] == window[++match] &&
+ window[++scan] == window[++match] &&
+ (scan < strend)) {
+ // Do nothing
+ }
+
+ if (scan > best_end) {
+#if DebugDeflation
+ if (DeflaterConstants.DEBUGGING && (ins_h == 0) )
+ Console.Error.WriteLine("Found match: " + curMatch + "-" + (scan - strstart));
+#endif
+ matchStart = curMatch;
+ best_end = scan;
+ best_len = scan - strstart;
+
+ if (best_len >= niceLength) {
+ break;
+ }
+
+ scan_end1 = window[best_end - 1];
+ scan_end = window[best_end];
+ }
+ scan = strstart;
+ } while ((curMatch = (prev[curMatch & WMASK] & 0xffff)) > limit && --chainLength != 0);
+
+ matchLen = Math.Min(best_len, lookahead);
+ return matchLen >= MIN_MATCH;
+ }
+
+ bool DeflateStored(bool flush, bool finish) {
+ if (!flush && (lookahead == 0)) {
+ return false;
+ }
+
+ strstart += lookahead;
+ lookahead = 0;
+
+ int storedLength = strstart - blockStart;
+
+ if ((storedLength >= DeflaterConstants.MAX_BLOCK_SIZE) || // Block is full
+ (blockStart < WSIZE && storedLength >= MAX_DIST) || // Block may move out of window
+ flush) {
+ bool lastBlock = finish;
+ if (storedLength > DeflaterConstants.MAX_BLOCK_SIZE) {
+ storedLength = DeflaterConstants.MAX_BLOCK_SIZE;
+ lastBlock = false;
+ }
+
+#if DebugDeflation
+ if (DeflaterConstants.DEBUGGING)
+ {
+ Console.WriteLine("storedBlock[" + storedLength + "," + lastBlock + "]");
+ }
+#endif
+
+ huffman.FlushStoredBlock(window, blockStart, storedLength, lastBlock);
+ blockStart += storedLength;
+ return !lastBlock;
+ }
+ return true;
+ }
+
+ bool DeflateFast(bool flush, bool finish) {
+ if (lookahead < MIN_LOOKAHEAD && !flush) {
+ return false;
+ }
+
+ while (lookahead >= MIN_LOOKAHEAD || flush) {
+ if (lookahead == 0) {
+ // We are flushing everything
+ huffman.FlushBlock(window, blockStart, strstart - blockStart, finish);
+ blockStart = strstart;
+ return false;
+ }
+
+ if (strstart > 2 * WSIZE - MIN_LOOKAHEAD) {
+ /* slide window, as FindLongestMatch needs this.
+ * This should only happen when flushing and the window
+ * is almost full.
+ */
+ SlideWindow();
+ }
+
+ int hashHead;
+ if (lookahead >= MIN_MATCH &&
+ (hashHead = InsertString()) != 0 &&
+ strategy != DeflateStrategy.HuffmanOnly &&
+ strstart - hashHead <= MAX_DIST &&
+ FindLongestMatch(hashHead)) {
+ // longestMatch sets matchStart and matchLen
+#if DebugDeflation
+ if (DeflaterConstants.DEBUGGING)
+ {
+ for (int i = 0 ; i < matchLen; i++) {
+ if (window[strstart + i] != window[matchStart + i]) {
+ throw new SharpZipBaseException("Match failure");
+ }
+ }
+ }
+#endif
+
+ bool full = huffman.TallyDist(strstart - matchStart, matchLen);
+
+ lookahead -= matchLen;
+ if (matchLen <= max_lazy && lookahead >= MIN_MATCH) {
+ while (--matchLen > 0) {
+ ++strstart;
+ InsertString();
+ }
+ ++strstart;
+ } else {
+ strstart += matchLen;
+ if (lookahead >= MIN_MATCH - 1) {
+ UpdateHash();
+ }
+ }
+ matchLen = MIN_MATCH - 1;
+ if (!full) {
+ continue;
+ }
+ } else {
+ // No match found
+ huffman.TallyLit(window[strstart] & 0xff);
+ ++strstart;
+ --lookahead;
+ }
+
+ if (huffman.IsFull()) {
+ bool lastBlock = finish && (lookahead == 0);
+ huffman.FlushBlock(window, blockStart, strstart - blockStart, lastBlock);
+ blockStart = strstart;
+ return !lastBlock;
+ }
+ }
+ return true;
+ }
+
+ bool DeflateSlow(bool flush, bool finish) {
+ if (lookahead < MIN_LOOKAHEAD && !flush) {
+ return false;
+ }
+
+ while (lookahead >= MIN_LOOKAHEAD || flush) {
+ if (lookahead == 0) {
+ if (prevAvailable) {
+ huffman.TallyLit(window[strstart - 1] & 0xff);
+ }
+ prevAvailable = false;
+
+ // We are flushing everything
+#if DebugDeflation
+ if (DeflaterConstants.DEBUGGING && !flush)
+ {
+ throw new SharpZipBaseException("Not flushing, but no lookahead");
+ }
+#endif
+ huffman.FlushBlock(window, blockStart, strstart - blockStart,
+ finish);
+ blockStart = strstart;
+ return false;
+ }
+
+ if (strstart >= 2 * WSIZE - MIN_LOOKAHEAD) {
+ /* slide window, as FindLongestMatch needs this.
+ * This should only happen when flushing and the window
+ * is almost full.
+ */
+ SlideWindow();
+ }
+
+ int prevMatch = matchStart;
+ int prevLen = matchLen;
+ if (lookahead >= MIN_MATCH) {
+
+ int hashHead = InsertString();
+
+ if (strategy != DeflateStrategy.HuffmanOnly &&
+ hashHead != 0 &&
+ strstart - hashHead <= MAX_DIST &&
+ FindLongestMatch(hashHead)) {
+
+ // longestMatch sets matchStart and matchLen
+
+ // Discard match if too small and too far away
+ if (matchLen <= 5 && (strategy == DeflateStrategy.Filtered || (matchLen == MIN_MATCH && strstart - matchStart > TooFar))) {
+ matchLen = MIN_MATCH - 1;
+ }
+ }
+ }
+
+ // previous match was better
+ if ((prevLen >= MIN_MATCH) && (matchLen <= prevLen)) {
+#if DebugDeflation
+ if (DeflaterConstants.DEBUGGING)
+ {
+ for (int i = 0 ; i < matchLen; i++) {
+ if (window[strstart-1+i] != window[prevMatch + i])
+ throw new SharpZipBaseException();
+ }
+ }
+#endif
+ huffman.TallyDist(strstart - 1 - prevMatch, prevLen);
+ prevLen -= 2;
+ do {
+ strstart++;
+ lookahead--;
+ if (lookahead >= MIN_MATCH) {
+ InsertString();
+ }
+ } while (--prevLen > 0);
+
+ strstart++;
+ lookahead--;
+ prevAvailable = false;
+ matchLen = MIN_MATCH - 1;
+ } else {
+ if (prevAvailable) {
+ huffman.TallyLit(window[strstart - 1] & 0xff);
+ }
+ prevAvailable = true;
+ strstart++;
+ lookahead--;
+ }
+
+ if (huffman.IsFull()) {
+ int len = strstart - blockStart;
+ if (prevAvailable) {
+ len--;
+ }
+ bool lastBlock = (finish && (lookahead == 0) && !prevAvailable);
+ huffman.FlushBlock(window, blockStart, len, lastBlock);
+ blockStart += len;
+ return !lastBlock;
+ }
+ }
+ return true;
+ }
+
+ #region Instance Fields
+
+ // Hash index of string to be inserted
+ int ins_h;
+
+ ///
+ /// Hashtable, hashing three characters to an index for window, so
+ /// that window[index]..window[index+2] have this hash code.
+ /// Note that the array should really be unsigned short, so you need
+ /// to and the values with 0xffff.
+ ///
+ short[] head;
+
+ ///
+ /// prev[index & WMASK] points to the previous index that has the
+ /// same hash code as the string starting at index. This way
+ /// entries with the same hash code are in a linked list.
+ /// Note that the array should really be unsigned short, so you need
+ /// to and the values with 0xffff.
+ ///
+ short[] prev;
+
+ int matchStart;
+ // Length of best match
+ int matchLen;
+ // Set if previous match exists
+ bool prevAvailable;
+ int blockStart;
+
+ ///
+ /// Points to the current character in the window.
+ ///
+ int strstart;
+
+ ///
+ /// lookahead is the number of characters starting at strstart in
+ /// window that are valid.
+ /// So window[strstart] until window[strstart+lookahead-1] are valid
+ /// characters.
+ ///
+ int lookahead;
+
+ ///
+ /// This array contains the part of the uncompressed stream that
+ /// is of relevance. The current character is indexed by strstart.
+ ///
+ byte[] window;
+
+ DeflateStrategy strategy;
+ int max_chain, max_lazy, niceLength, goodLength;
+
+ ///
+ /// The current compression function.
+ ///
+ int compressionFunction;
+
+ ///
+ /// The input data for compression.
+ ///
+ byte[] inputBuf;
+
+ ///
+ /// The total bytes of input read.
+ ///
+ long totalIn;
+
+ ///
+ /// The offset into inputBuf, where input data starts.
+ ///
+ int inputOff;
+
+ ///
+ /// The end offset of the input data.
+ ///
+ int inputEnd;
+
+ DeflaterPending pending;
+ DeflaterHuffman huffman;
+
+ ///
+ /// The adler checksum
+ ///
+ Adler32 adler;
+ #endregion
+ }
+}
diff --git a/public/javascripts/plupload/src/csharp/Plupload/PngEncoder/DeflaterHuffman.cs b/public/javascripts/plupload/src/csharp/Plupload/PngEncoder/DeflaterHuffman.cs
new file mode 100644
index 0000000..e94cbd5
--- /dev/null
+++ b/public/javascripts/plupload/src/csharp/Plupload/PngEncoder/DeflaterHuffman.cs
@@ -0,0 +1,881 @@
+// DeflaterHuffman.cs
+//
+// Copyright (C) 2001 Mike Krueger
+// Copyright (C) 2004 John Reilly
+//
+// This file was translated from java, it was part of the GNU Classpath
+// Copyright (C) 2001 Free Software Foundation, Inc.
+//
+// This program 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 program 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, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+// Linking this library statically or dynamically with other modules is
+// making a combined work based on this library. Thus, the terms and
+// conditions of the GNU General Public License cover the whole
+// combination.
+//
+// As a special exception, the copyright holders of this library give you
+// permission to link this library with independent modules to produce an
+// executable, regardless of the license terms of these independent
+// modules, and to copy and distribute the resulting executable under
+// terms of your choice, provided that you also meet, for each linked
+// independent module, the terms and conditions of the license of that
+// module. An independent module is a module which is not derived from
+// or based on this library. If you modify this library, you may extend
+// this exception to your version of the library, but you are not
+// obligated to do so. If you do not wish to do so, delete this
+// exception statement from your version.
+
+using System;
+
+namespace Plupload.PngEncoder {
+
+ ///
+ /// This is the DeflaterHuffman class.
+ ///
+ /// This class is not thread safe. This is inherent in the API, due
+ /// to the split of Deflate and SetInput.
+ ///
+ /// author of the original java version : Jochen Hoenicke
+ ///
+ public class DeflaterHuffman {
+ const int BUFSIZE = 1 << (DeflaterConstants.DEFAULT_MEM_LEVEL + 6);
+ const int LITERAL_NUM = 286;
+
+ // Number of distance codes
+ const int DIST_NUM = 30;
+ // Number of codes used to transfer bit lengths
+ const int BITLEN_NUM = 19;
+
+ // repeat previous bit length 3-6 times (2 bits of repeat count)
+ const int REP_3_6 = 16;
+ // repeat a zero length 3-10 times (3 bits of repeat count)
+ const int REP_3_10 = 17;
+ // repeat a zero length 11-138 times (7 bits of repeat count)
+ const int REP_11_138 = 18;
+
+ const int EOF_SYMBOL = 256;
+
+ // The lengths of the bit length codes are sent in order of decreasing
+ // probability, to avoid transmitting the lengths for unused bit length codes.
+ static readonly int[] BL_ORDER = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 };
+
+ static readonly byte[] bit4Reverse = {
+ 0,
+ 8,
+ 4,
+ 12,
+ 2,
+ 10,
+ 6,
+ 14,
+ 1,
+ 9,
+ 5,
+ 13,
+ 3,
+ 11,
+ 7,
+ 15
+ };
+
+ static short[] staticLCodes;
+ static byte[] staticLLength;
+ static short[] staticDCodes;
+ static byte[] staticDLength;
+
+ class Tree {
+ #region Instance Fields
+ public short[] freqs;
+
+ public byte[] length;
+
+ public int minNumCodes;
+
+ public int numCodes;
+
+ short[] codes;
+ int[] bl_counts;
+ int maxLength;
+ DeflaterHuffman dh;
+ #endregion
+
+ #region Constructors
+ public Tree(DeflaterHuffman dh, int elems, int minCodes, int maxLength) {
+ this.dh = dh;
+ this.minNumCodes = minCodes;
+ this.maxLength = maxLength;
+ freqs = new short[elems];
+ bl_counts = new int[maxLength];
+ }
+
+ #endregion
+
+ ///
+ /// Resets the internal state of the tree
+ ///
+ public void Reset() {
+ for (int i = 0; i < freqs.Length; i++) {
+ freqs[i] = 0;
+ }
+ codes = null;
+ length = null;
+ }
+
+ public void WriteSymbol(int code) {
+ // if (DeflaterConstants.DEBUGGING) {
+ // freqs[code]--;
+ // // Console.Write("writeSymbol("+freqs.length+","+code+"): ");
+ // }
+ dh.pending.WriteBits(codes[code] & 0xffff, length[code]);
+ }
+
+ ///
+ /// Check that all frequencies are zero
+ ///
+ ///
+ /// At least one frequency is non-zero
+ ///
+ public void CheckEmpty() {
+ bool empty = true;
+ for (int i = 0; i < freqs.Length; i++) {
+ if (freqs[i] != 0) {
+ //Console.WriteLine("freqs[" + i + "] == " + freqs[i]);
+ empty = false;
+ }
+ }
+
+ if (!empty) {
+ throw new Exception("!Empty");
+ }
+ }
+
+ ///
+ /// Set static codes and length
+ ///
+ ///
+ /// Build dynamic codes and lengths
+ ///
+ public void BuildCodes() {
+ int numSymbols = freqs.Length;
+ int[] nextCode = new int[maxLength];
+ int code = 0;
+
+ codes = new short[freqs.Length];
+
+ // if (DeflaterConstants.DEBUGGING) {
+ // //Console.WriteLine("buildCodes: "+freqs.Length);
+ // }
+
+ for (int bits = 0; bits < maxLength; bits++) {
+ nextCode[bits] = code;
+ code += bl_counts[bits] << (15 - bits);
+
+ // if (DeflaterConstants.DEBUGGING) {
+ // //Console.WriteLine("bits: " + ( bits + 1) + " count: " + bl_counts[bits]
+ // +" nextCode: "+code);
+ // }
+ }
+
+#if DebugDeflation
+ if ( DeflaterConstants.DEBUGGING && (code != 65536) )
+ {
+ throw new SharpZipBaseException("Inconsistent bl_counts!");
+ }
+#endif
+ for (int i = 0; i < numCodes; i++) {
+ int bits = length[i];
+ if (bits > 0) {
+
+ // if (DeflaterConstants.DEBUGGING) {
+ // //Console.WriteLine("codes["+i+"] = rev(" + nextCode[bits-1]+"),
+ // +bits);
+ // }
+
+ codes[i] = BitReverse(nextCode[bits - 1]);
+ nextCode[bits - 1] += 1 << (16 - bits);
+ }
+ }
+ }
+
+ public void BuildTree() {
+ int numSymbols = freqs.Length;
+
+ /* heap is a priority queue, sorted by frequency, least frequent
+ * nodes first. The heap is a binary tree, with the property, that
+ * the parent node is smaller than both child nodes. This assures
+ * that the smallest node is the first parent.
+ *
+ * The binary tree is encoded in an array: 0 is root node and
+ * the nodes 2*n+1, 2*n+2 are the child nodes of node n.
+ */
+ int[] heap = new int[numSymbols];
+ int heapLen = 0;
+ int maxCode = 0;
+ for (int n = 0; n < numSymbols; n++) {
+ int freq = freqs[n];
+ if (freq != 0) {
+ // Insert n into heap
+ int pos = heapLen++;
+ int ppos;
+ while (pos > 0 && freqs[heap[ppos = (pos - 1) / 2]] > freq) {
+ heap[pos] = heap[ppos];
+ pos = ppos;
+ }
+ heap[pos] = n;
+
+ maxCode = n;
+ }
+ }
+
+ /* We could encode a single literal with 0 bits but then we
+ * don't see the literals. Therefore we force at least two
+ * literals to avoid this case. We don't care about order in
+ * this case, both literals get a 1 bit code.
+ */
+ while (heapLen < 2) {
+ int node = maxCode < 2 ? ++maxCode : 0;
+ heap[heapLen++] = node;
+ }
+
+ numCodes = Math.Max(maxCode + 1, minNumCodes);
+
+ int numLeafs = heapLen;
+ int[] childs = new int[4 * heapLen - 2];
+ int[] values = new int[2 * heapLen - 1];
+ int numNodes = numLeafs;
+ for (int i = 0; i < heapLen; i++) {
+ int node = heap[i];
+ childs[2 * i] = node;
+ childs[2 * i + 1] = -1;
+ values[i] = freqs[node] << 8;
+ heap[i] = i;
+ }
+
+ /* Construct the Huffman tree by repeatedly combining the least two
+ * frequent nodes.
+ */
+ do {
+ int first = heap[0];
+ int last = heap[--heapLen];
+
+ // Propagate the hole to the leafs of the heap
+ int ppos = 0;
+ int path = 1;
+
+ while (path < heapLen) {
+ if (path + 1 < heapLen && values[heap[path]] > values[heap[path + 1]]) {
+ path++;
+ }
+
+ heap[ppos] = heap[path];
+ ppos = path;
+ path = path * 2 + 1;
+ }
+
+ /* Now propagate the last element down along path. Normally
+ * it shouldn't go too deep.
+ */
+ int lastVal = values[last];
+ while ((path = ppos) > 0 && values[heap[ppos = (path - 1) / 2]] > lastVal) {
+ heap[path] = heap[ppos];
+ }
+ heap[path] = last;
+
+
+ int second = heap[0];
+
+ // Create a new node father of first and second
+ last = numNodes++;
+ childs[2 * last] = first;
+ childs[2 * last + 1] = second;
+ int mindepth = Math.Min(values[first] & 0xff, values[second] & 0xff);
+ values[last] = lastVal = values[first] + values[second] - mindepth + 1;
+
+ // Again, propagate the hole to the leafs
+ ppos = 0;
+ path = 1;
+
+ while (path < heapLen) {
+ if (path + 1 < heapLen && values[heap[path]] > values[heap[path + 1]]) {
+ path++;
+ }
+
+ heap[ppos] = heap[path];
+ ppos = path;
+ path = ppos * 2 + 1;
+ }
+
+ // Now propagate the new element down along path
+ while ((path = ppos) > 0 && values[heap[ppos = (path - 1) / 2]] > lastVal) {
+ heap[path] = heap[ppos];
+ }
+ heap[path] = last;
+ } while (heapLen > 1);
+
+ if (heap[0] != childs.Length / 2 - 1) {
+ throw new Exception("Heap invariant violated");
+ }
+
+ BuildLength(childs);
+ }
+
+ ///
+ /// Get encoded length
+ ///
+ /// Encoded length, the sum of frequencies * lengths
+ public int GetEncodedLength() {
+ int len = 0;
+ for (int i = 0; i < freqs.Length; i++) {
+ len += freqs[i] * length[i];
+ }
+ return len;
+ }
+
+ ///
+ /// Scan a literal or distance tree to determine the frequencies of the codes
+ /// in the bit length tree.
+ ///
+ public void CalcBLFreq(Tree blTree) {
+ int max_count; /* max repeat count */
+ int min_count; /* min repeat count */
+ int count; /* repeat count of the current code */
+ int curlen = -1; /* length of current code */
+
+ int i = 0;
+ while (i < numCodes) {
+ count = 1;
+ int nextlen = length[i];
+ if (nextlen == 0) {
+ max_count = 138;
+ min_count = 3;
+ } else {
+ max_count = 6;
+ min_count = 3;
+ if (curlen != nextlen) {
+ blTree.freqs[nextlen]++;
+ count = 0;
+ }
+ }
+ curlen = nextlen;
+ i++;
+
+ while (i < numCodes && curlen == length[i]) {
+ i++;
+ if (++count >= max_count) {
+ break;
+ }
+ }
+
+ if (count < min_count) {
+ blTree.freqs[curlen] += (short) count;
+ } else if (curlen != 0) {
+ blTree.freqs[REP_3_6]++;
+ } else if (count <= 10) {
+ blTree.freqs[REP_3_10]++;
+ } else {
+ blTree.freqs[REP_11_138]++;
+ }
+ }
+ }
+
+ ///
+ /// Write tree values
+ ///
+ ///
+ /// Pending buffer to use
+ ///
+ public DeflaterPending pending;
+
+ Tree literalTree;
+ Tree distTree;
+ Tree blTree;
+
+ // Buffer for distances
+ short[] d_buf;
+ byte[] l_buf;
+ int last_lit;
+ int extra_bits;
+ #endregion
+
+ static DeflaterHuffman() {
+ // See RFC 1951 3.2.6
+ // Literal codes
+ staticLCodes = new short[LITERAL_NUM];
+ staticLLength = new byte[LITERAL_NUM];
+
+ int i = 0;
+ while (i < 144) {
+ staticLCodes[i] = BitReverse((0x030 + i) << 8);
+ staticLLength[i++] = 8;
+ }
+
+ while (i < 256) {
+ staticLCodes[i] = BitReverse((0x190 - 144 + i) << 7);
+ staticLLength[i++] = 9;
+ }
+
+ while (i < 280) {
+ staticLCodes[i] = BitReverse((0x000 - 256 + i) << 9);
+ staticLLength[i++] = 7;
+ }
+
+ while (i < LITERAL_NUM) {
+ staticLCodes[i] = BitReverse((0x0c0 - 280 + i) << 8);
+ staticLLength[i++] = 8;
+ }
+
+ // Distance codes
+ staticDCodes = new short[DIST_NUM];
+ staticDLength = new byte[DIST_NUM];
+ for (i = 0; i < DIST_NUM; i++) {
+ staticDCodes[i] = BitReverse(i << 11);
+ staticDLength[i] = 5;
+ }
+ }
+
+ ///
+ /// Construct instance with pending buffer
+ ///
+ ///
+ /// Reset internal state
+ ///
+ public void Reset() {
+ last_lit = 0;
+ extra_bits = 0;
+ literalTree.Reset();
+ distTree.Reset();
+ blTree.Reset();
+ }
+
+ ///
+ /// Write all trees to pending buffer
+ ///
+ ///
+ /// Compress current buffer writing data to pending buffer
+ ///
+ public void CompressBlock() {
+ for (int i = 0; i < last_lit; i++) {
+ int litlen = l_buf[i] & 0xff;
+ int dist = d_buf[i];
+ if (dist-- != 0) {
+ // if (DeflaterConstants.DEBUGGING) {
+ // Console.Write("["+(dist+1)+","+(litlen+3)+"]: ");
+ // }
+
+ int lc = Lcode(litlen);
+ literalTree.WriteSymbol(lc);
+
+ int bits = (lc - 261) / 4;
+ if (bits > 0 && bits <= 5) {
+ pending.WriteBits(litlen & ((1 << bits) - 1), bits);
+ }
+
+ int dc = Dcode(dist);
+ distTree.WriteSymbol(dc);
+
+ bits = dc / 2 - 1;
+ if (bits > 0) {
+ pending.WriteBits(dist & ((1 << bits) - 1), bits);
+ }
+ } else {
+ // if (DeflaterConstants.DEBUGGING) {
+ // if (litlen > 32 && litlen < 127) {
+ // Console.Write("("+(char)litlen+"): ");
+ // } else {
+ // Console.Write("{"+litlen+"}: ");
+ // }
+ // }
+ literalTree.WriteSymbol(litlen);
+ }
+ }
+
+#if DebugDeflation
+ if (DeflaterConstants.DEBUGGING) {
+ Console.Write("EOF: ");
+ }
+#endif
+ literalTree.WriteSymbol(EOF_SYMBOL);
+
+#if DebugDeflation
+ if (DeflaterConstants.DEBUGGING) {
+ literalTree.CheckEmpty();
+ distTree.CheckEmpty();
+ }
+#endif
+ }
+
+ ///
+ /// Flush block to output with no compression
+ ///
+ ///
+ /// Flush block to output with compression
+ ///
+ ///
+ /// Get value indicating if internal buffer is full
+ ///
+ /// true if buffer is full
+ public bool IsFull() {
+ return last_lit >= BUFSIZE;
+ }
+
+ ///
+ /// Add literal to buffer
+ ///
+ /// Value indicating internal buffer is full
+ public bool TallyLit(int literal) {
+ // if (DeflaterConstants.DEBUGGING) {
+ // if (lit > 32 && lit < 127) {
+ // //Console.WriteLine("("+(char)lit+")");
+ // } else {
+ // //Console.WriteLine("{"+lit+"}");
+ // }
+ // }
+ d_buf[last_lit] = 0;
+ l_buf[last_lit++] = (byte) literal;
+ literalTree.freqs[literal]++;
+ return IsFull();
+ }
+
+ ///
+ /// Add distance code and length to literal and distance trees
+ ///
+ /// Value indicating if internal buffer is full
+ public bool TallyDist(int distance, int length) {
+ // if (DeflaterConstants.DEBUGGING) {
+ // //Console.WriteLine("[" + distance + "," + length + "]");
+ // }
+
+ d_buf[last_lit] = (short) distance;
+ l_buf[last_lit++] = (byte) (length - 3);
+
+ int lc = Lcode(length - 3);
+ literalTree.freqs[lc]++;
+ if (lc >= 265 && lc < 285) {
+ extra_bits += (lc - 261) / 4;
+ }
+
+ int dc = Dcode(distance - 1);
+ distTree.freqs[dc]++;
+ if (dc >= 4) {
+ extra_bits += dc / 2 - 1;
+ }
+ return IsFull();
+ }
+
+
+ ///
+ /// Reverse the bits of a 16 bit value.
+ ///
+ /// Value with bits reversed
+ public static short BitReverse(int toReverse) {
+ return (short) (bit4Reverse[toReverse & 0xF] << 12 |
+ bit4Reverse[(toReverse >> 4) & 0xF] << 8 |
+ bit4Reverse[(toReverse >> 8) & 0xF] << 4 |
+ bit4Reverse[toReverse >> 12]);
+ }
+
+ static int Lcode(int length) {
+ if (length == 255) {
+ return 285;
+ }
+
+ int code = 257;
+ while (length >= 8) {
+ code += 4;
+ length >>= 1;
+ }
+ return code + length;
+ }
+
+ static int Dcode(int distance) {
+ int code = 0;
+ while (distance >= 4) {
+ code += 2;
+ distance >>= 1;
+ }
+ return code + distance;
+ }
+ }
+}
diff --git a/public/javascripts/plupload/src/csharp/Plupload/PngEncoder/DeflaterOutputStream.cs b/public/javascripts/plupload/src/csharp/Plupload/PngEncoder/DeflaterOutputStream.cs
new file mode 100644
index 0000000..4556487
--- /dev/null
+++ b/public/javascripts/plupload/src/csharp/Plupload/PngEncoder/DeflaterOutputStream.cs
@@ -0,0 +1,469 @@
+// DeflaterOutputStream.cs
+//
+// Copyright (C) 2001 Mike Krueger
+//
+// This file was translated from java, it was part of the GNU Classpath
+// Copyright (C) 2001 Free Software Foundation, Inc.
+//
+// This program 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 program 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, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+// Linking this library statically or dynamically with other modules is
+// making a combined work based on this library. Thus, the terms and
+// conditions of the GNU General Public License cover the whole
+// combination.
+//
+// As a special exception, the copyright holders of this library give you
+// permission to link this library with independent modules to produce an
+// executable, regardless of the license terms of these independent
+// modules, and to copy and distribute the resulting executable under
+// terms of your choice, provided that you also meet, for each linked
+// independent module, the terms and conditions of the license of that
+// module. An independent module is a module which is not derived from
+// or based on this library. If you modify this library, you may extend
+// this exception to your version of the library, but you are not
+// obligated to do so. If you do not wish to do so, delete this
+// exception statement from your version.
+
+using System;
+using System.IO;
+
+namespace Plupload.PngEncoder {
+ ///
+ /// A special stream deflating or compressing the bytes that are
+ /// written to it. It uses a Deflater to perform actual deflating.
+ public class DeflaterOutputStream : Stream {
+ #region Constructors
+ ///
+ /// Creates a new DeflaterOutputStream with a default Deflater and default buffer size.
+ ///
+ ///
+ /// Creates a new DeflaterOutputStream with the given Deflater and
+ /// default buffer size.
+ ///
+ ///
+ /// Creates a new DeflaterOutputStream with the given Deflater and
+ /// buffer size.
+ ///
+ ///
+ /// bufsize is less than or equal to zero.
+ ///
+ ///
+ /// baseOutputStream does not support writing
+ ///
+ ///
+ /// deflater instance is null
+ ///
+ public DeflaterOutputStream(Stream baseOutputStream, Deflater deflater, int bufferSize) {
+ if (baseOutputStream == null) {
+ throw new ArgumentNullException("baseOutputStream");
+ }
+
+ if (baseOutputStream.CanWrite == false) {
+ throw new ArgumentException("Must support writing", "baseOutputStream");
+ }
+
+ if (deflater == null) {
+ throw new ArgumentNullException("deflater");
+ }
+
+ if (bufferSize <= 0) {
+ throw new ArgumentOutOfRangeException("bufferSize");
+ }
+
+ baseOutputStream_ = baseOutputStream;
+ buffer_ = new byte[bufferSize];
+ deflater_ = deflater;
+ }
+ #endregion
+
+ #region Public API
+ ///
+ /// Finishes the stream by calling finish() on the deflater.
+ ///
+ ///
+ /// Not all input is deflated
+ ///
+ public virtual void Finish() {
+ deflater_.Finish();
+ while (!deflater_.IsFinished) {
+ int len = deflater_.Deflate(buffer_, 0, buffer_.Length);
+ if (len <= 0) {
+ break;
+ }
+
+ if (keys != null) {
+ EncryptBlock(buffer_, 0, len);
+ }
+
+ baseOutputStream_.Write(buffer_, 0, len);
+ }
+
+ if (!deflater_.IsFinished) {
+ throw new Exception("Can't deflate all input?");
+ }
+
+ baseOutputStream_.Flush();
+
+
+ if (keys != null) {
+ keys = null;
+ }
+
+ }
+
+ ///
+ /// Get/set flag indicating ownership of the underlying stream.
+ /// When the flag is true
+ public bool IsStreamOwner {
+ get { return isStreamOwner_; }
+ set { isStreamOwner_ = value; }
+ }
+
+ ///
+ /// Allows client to determine if an entry can be patched after its added
+ ///
+ public bool CanPatchEntries {
+ get {
+ return baseOutputStream_.CanSeek;
+ }
+ }
+
+ #endregion
+
+ #region Encryption
+
+ string password;
+
+ uint[] keys;
+
+ ///
+ /// Get/set the password used for encryption.
+ ///
+ /// When set to null or if the password is empty no encryption is performed
+ public string Password {
+ get {
+ return password;
+ }
+ set {
+ if ((value != null) && (value.Length == 0)) {
+ password = null;
+ } else {
+ password = value;
+ }
+ }
+ }
+
+ ///
+ /// Encrypt a block of data
+ ///
+ ///
+ /// Encrypt a single byte
+ ///
+ ///
+ /// The encrypted value
+ ///
+ protected byte EncryptByte() {
+ uint temp = ((keys[2] & 0xFFFF) | 2);
+ return (byte) ((temp * (temp ^ 1)) >> 8);
+ }
+
+ ///
+ /// Update encryption keys
+ ///
+ protected void UpdateKeys(byte ch) {
+ keys[0] = Crc32.ComputeCrc32(keys[0], ch);
+ keys[1] = keys[1] + (byte) keys[0];
+ keys[1] = keys[1] * 134775813 + 1;
+ keys[2] = Crc32.ComputeCrc32(keys[2], (byte) (keys[1] >> 24));
+ }
+
+ #endregion
+
+ #region Deflation Support
+ ///
+ /// Deflates everything in the input buffers. This will call
+ /// def.deflate() until all bytes from the input buffers
+ /// are processed.
+ ///
+ protected void Deflate() {
+ while (!deflater_.IsNeedingInput) {
+ int deflateCount = deflater_.Deflate(buffer_, 0, buffer_.Length);
+
+ if (deflateCount <= 0) {
+ break;
+ }
+
+ if (keys != null) {
+ EncryptBlock(buffer_, 0, deflateCount);
+ }
+
+ baseOutputStream_.Write(buffer_, 0, deflateCount);
+ }
+
+ if (!deflater_.IsNeedingInput) {
+ throw new Exception("DeflaterOutputStream can't deflate all input?");
+ }
+ }
+ #endregion
+
+ #region Stream Overrides
+ ///
+ /// Gets value indicating stream can be read from
+ ///
+ public override bool CanRead {
+ get {
+ return false;
+ }
+ }
+
+ ///
+ /// Gets a value indicating if seeking is supported for this stream
+ /// This property always returns false
+ ///
+ public override bool CanSeek {
+ get {
+ return false;
+ }
+ }
+
+ ///
+ /// Get value indicating if this stream supports writing
+ ///
+ public override bool CanWrite {
+ get {
+ return baseOutputStream_.CanWrite;
+ }
+ }
+
+ ///
+ /// Get current length of stream
+ ///
+ public override long Length {
+ get {
+ return baseOutputStream_.Length;
+ }
+ }
+
+ ///
+ /// Gets the current position within the stream.
+ ///
+ /// Any attempt to set position
+ public override long Position {
+ get {
+ return baseOutputStream_.Position;
+ }
+ set {
+ throw new NotSupportedException("Position property not supported");
+ }
+ }
+
+ ///
+ /// Sets the current position of this stream to the given value. Not supported by this class!
+ ///
+ /// The new position in the stream.
+ /// Any access
+ public override long Seek(long offset, SeekOrigin origin) {
+ throw new NotSupportedException("DeflaterOutputStream Seek not supported");
+ }
+
+ ///
+ /// Sets the length of this stream to the given value. Not supported by this class!
+ ///
+ /// Any access
+ public override void SetLength(long value) {
+ throw new NotSupportedException("DeflaterOutputStream SetLength not supported");
+ }
+
+ ///
+ /// Read a byte from stream advancing position by one
+ ///
+ /// The byte read cast to an int. THe value is -1 if at the end of the stream.
+ /// Any access
+ public override int ReadByte() {
+ throw new NotSupportedException("DeflaterOutputStream ReadByte not supported");
+ }
+
+ ///
+ /// Read a block of bytes from stream
+ ///
+ /// The actual number of bytes read. Zero if end of stream is detected.
+ /// Any access
+ public override int Read(byte[] buffer, int offset, int count) {
+ throw new NotSupportedException("DeflaterOutputStream Read not supported");
+ }
+
+ ///
+ /// Asynchronous reads are not supported a NotSupportedException is always thrown
+ ///
+ /// Returns an
+ /// Any access
+ public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state) {
+ throw new NotSupportedException("DeflaterOutputStream BeginRead not currently supported");
+ }
+
+ ///
+ /// Asynchronous writes arent supported, a NotSupportedException is always thrown
+ ///
+ /// Returns an IAsyncResult.
+ /// Any access
+ public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state) {
+ throw new NotSupportedException("BeginWrite is not supported");
+ }
+
+ ///
+ /// Flushes the stream by calling Flush on the deflater and then
+ /// on the underlying stream. This ensures that all bytes are flushed.
+ ///
+ public override void Flush() {
+ deflater_.Flush();
+ Deflate();
+ baseOutputStream_.Flush();
+ }
+
+ ///
+ /// Calls
+ public override void Close() {
+ if (!isClosed_) {
+ isClosed_ = true;
+
+ try {
+ Finish();
+
+ keys = null;
+ } finally {
+ if (isStreamOwner_) {
+ baseOutputStream_.Close();
+ }
+ }
+ }
+ }
+
+ ///
+ /// Writes a single byte to the compressed output stream.
+ ///
+ ///
+ /// Writes bytes from an array to the compressed stream.
+ ///
+ ///
+ /// This buffer is used temporarily to retrieve the bytes from the
+ /// deflater and write them to the underlying output stream.
+ ///
+ byte[] buffer_;
+
+ ///
+ /// The deflater which is used to deflate the stream.
+ ///
+ protected Deflater deflater_;
+
+ ///
+ /// Base stream the deflater depends on.
+ ///
+ protected Stream baseOutputStream_;
+
+ bool isClosed_;
+
+ bool isStreamOwner_ = true;
+ #endregion
+ }
+}
diff --git a/public/javascripts/plupload/src/csharp/Plupload/PngEncoder/DeflaterPending.cs b/public/javascripts/plupload/src/csharp/Plupload/PngEncoder/DeflaterPending.cs
new file mode 100644
index 0000000..3d5ea36
--- /dev/null
+++ b/public/javascripts/plupload/src/csharp/Plupload/PngEncoder/DeflaterPending.cs
@@ -0,0 +1,55 @@
+// DeflaterPending.cs
+//
+// Copyright (C) 2001 Mike Krueger
+// Copyright (C) 2004 John Reilly
+//
+// This file was translated from java, it was part of the GNU Classpath
+// Copyright (C) 2001 Free Software Foundation, Inc.
+//
+// This program 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 program 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, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+// Linking this library statically or dynamically with other modules is
+// making a combined work based on this library. Thus, the terms and
+// conditions of the GNU General Public License cover the whole
+// combination.
+//
+// As a special exception, the copyright holders of this library give you
+// permission to link this library with independent modules to produce an
+// executable, regardless of the license terms of these independent
+// modules, and to copy and distribute the resulting executable under
+// terms of your choice, provided that you also meet, for each linked
+// independent module, the terms and conditions of the license of that
+// module. An independent module is a module which is not derived from
+// or based on this library. If you modify this library, you may extend
+// this exception to your version of the library, but you are not
+// obligated to do so. If you do not wish to do so, delete this
+// exception statement from your version.
+
+namespace Plupload.PngEncoder {
+
+ ///
+ /// This class stores the pending output of the Deflater.
+ ///
+ /// author of the original java version : Jochen Hoenicke
+ ///
+ public class DeflaterPending : PendingBuffer {
+ ///
+ /// Construct instance with default buffer size
+ ///
+ public DeflaterPending()
+ : base(DeflaterConstants.PENDING_BUF_SIZE) {
+ }
+ }
+}
diff --git a/public/javascripts/plupload/src/csharp/Plupload/PngEncoder/IChecksum.cs b/public/javascripts/plupload/src/csharp/Plupload/PngEncoder/IChecksum.cs
new file mode 100644
index 0000000..66c5111
--- /dev/null
+++ b/public/javascripts/plupload/src/csharp/Plupload/PngEncoder/IChecksum.cs
@@ -0,0 +1,90 @@
+// IChecksum.cs - Interface to compute a data checksum
+// Copyright (C) 2001 Mike Krueger
+//
+// This file was translated from java, it was part of the GNU Classpath
+// Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
+//
+// This program 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 program 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, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+// Linking this library statically or dynamically with other modules is
+// making a combined work based on this library. Thus, the terms and
+// conditions of the GNU General Public License cover the whole
+// combination.
+//
+// As a special exception, the copyright holders of this library give you
+// permission to link this library with independent modules to produce an
+// executable, regardless of the license terms of these independent
+// modules, and to copy and distribute the resulting executable under
+// terms of your choice, provided that you also meet, for each linked
+// independent module, the terms and conditions of the license of that
+// module. An independent module is a module which is not derived from
+// or based on this library. If you modify this library, you may extend
+// this exception to your version of the library, but you are not
+// obligated to do so. If you do not wish to do so, delete this
+// exception statement from your version.
+
+namespace Plupload.PngEncoder {
+
+ ///
+ /// Interface to compute a data checksum used by checked input/output streams.
+ /// A data checksum can be updated by one byte or with a byte array. After each
+ /// update the value of the current checksum can be returned by calling
+ /// getValue. The complete checksum object can also be reset
+ /// so it can be used again with new data.
+ ///
+ public interface IChecksum {
+ ///
+ /// Returns the data checksum computed so far.
+ ///
+ long Value {
+ get;
+ }
+
+ ///
+ /// Resets the data checksum as if no update was ever called.
+ ///
+ void Reset();
+
+ ///
+ /// Adds one byte to the data checksum.
+ ///
+ ///
+ /// Updates the data checksum with the bytes taken from the array.
+ ///
+ ///
+ /// Adds the byte array to the data checksum.
+ ///
+ ///
+ /// This class is general purpose class for writing data to a buffer.
+ ///
+ /// It allows you to write bits as well as bytes
+ /// Based on DeflaterPending.java
+ ///
+ /// author of the original java version : Jochen Hoenicke
+ ///
+ public class PendingBuffer {
+ #region Instance Fields
+ ///
+ /// Internal work buffer
+ ///
+ byte[] buffer_;
+
+ int start;
+ int end;
+
+ uint bits;
+ int bitCount;
+ #endregion
+
+ #region Constructors
+ ///
+ /// construct instance using default buffer size of 4096
+ ///
+ public PendingBuffer()
+ : this(4096) {
+ }
+
+ ///
+ /// construct instance using specified buffer size
+ ///
+ ///
+ /// Clear internal state/buffers
+ ///
+ public void Reset() {
+ start = end = bitCount = 0;
+ }
+
+ ///
+ /// Write a byte to buffer
+ ///
+ ///
+ /// Write a short value to buffer LSB first
+ ///
+ ///
+ /// write an integer LSB first
+ ///
+ ///
+ /// Write a block of data to buffer
+ ///
+ ///
+ /// The number of bits written to the buffer
+ ///
+ public int BitCount {
+ get {
+ return bitCount;
+ }
+ }
+
+ ///
+ /// Align internal buffer on a byte boundary
+ ///
+ public void AlignToByte() {
+#if DebugDeflation
+ if (DeflaterConstants.DEBUGGING && (start != 0) )
+ {
+ throw new SharpZipBaseException("Debug check: start != 0");
+ }
+#endif
+ if (bitCount > 0) {
+ buffer_[end++] = unchecked((byte) bits);
+ if (bitCount > 8) {
+ buffer_[end++] = unchecked((byte) (bits >> 8));
+ }
+ }
+ bits = 0;
+ bitCount = 0;
+ }
+
+ ///
+ /// Write bits to internal buffer
+ ///
+ ///
+ /// Write a short value to internal buffer most significant byte first
+ ///
+ ///
+ /// Indicates if buffer has been flushed
+ ///
+ public bool IsFlushed {
+ get {
+ return end == 0;
+ }
+ }
+
+ ///
+ /// Flushes the pending buffer into the given output array. If the
+ /// output array is to small, only a partial flush is done.
+ ///
+ /// The number of bytes flushed.
+ public int Flush(byte[] output, int offset, int length) {
+ if (bitCount >= 8) {
+ buffer_[end++] = unchecked((byte) bits);
+ bits >>= 8;
+ bitCount -= 8;
+ }
+
+ if (length > end - start) {
+ length = end - start;
+ System.Array.Copy(buffer_, start, output, offset, length);
+ start = 0;
+ end = 0;
+ } else {
+ System.Array.Copy(buffer_, start, output, offset, length);
+ start += length;
+ }
+ return length;
+ }
+
+ ///
+ /// Convert internal buffer to byte array.
+ /// Buffer is empty on completion
+ ///
+ ///
+ /// The internal buffer contents converted to a byte array.
+ ///
+ public byte[] ToByteArray() {
+ byte[] result = new byte[end - start];
+ System.Array.Copy(buffer_, start, result, 0, result.Length);
+ start = 0;
+ end = 0;
+ return result;
+ }
+ }
+}
diff --git a/public/javascripts/plupload/src/csharp/Plupload/PngEncoder/PngEncoder.cs b/public/javascripts/plupload/src/csharp/Plupload/PngEncoder/PngEncoder.cs
new file mode 100644
index 0000000..7ef7366
--- /dev/null
+++ b/public/javascripts/plupload/src/csharp/Plupload/PngEncoder/PngEncoder.cs
@@ -0,0 +1,467 @@
+/**
+ * PngEncoder takes a pixel data byte array and creates a byte string which can be saved as a PNG file.
+ *
+ * Thanks to Jay Denny at KeyPoint Software
+ * http://www.keypoint.com/
+ * who let me develop this code on company time.
+ *
+ * You may contact me with (probably very-much-needed) improvements,
+ * comments, and bug fixes at:
+ *
+ * david@catcode.com
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.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 Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * A copy of the GNU LGPL may be found at
+ * http://www.gnu.org/copyleft/lesser.html
+ *
+ * @author J. David Eisenberg
+ * @version 1.5, 19 Oct 2003
+ *
+ * CHANGES:
+ * --------
+ * 19-Nov-2002 : CODING STYLE CHANGES ONLY (by David Gilbert for Object Refinery Limited);
+ * 19-Sep-2003 : Fix for platforms using EBCDIC (contributed by Paulo Soares);
+ * 19-Oct-2003 : Change private fields to protected fields so that
+ * PngEncoderB can inherit them (JDE)
+ * Fixed bug with calculation of nRows
+ * 2009-12-22 : Ported Java version over to C#.
+ */
+
+using System;
+using System.IO;
+
+namespace Plupload.PngEncoder {
+ public class PngEncoder {
+ /** Constant specifying that alpha channel should be encoded. */
+ public const bool ENCODE_ALPHA = true;
+
+ /** Constant specifying that alpha channel should not be encoded. */
+ public const bool NO_ALPHA = false;
+
+ /** Constants for filter (NONE) */
+ public const int FILTER_NONE = 0;
+
+ /** Constants for filter (SUB) */
+ public const int FILTER_SUB = 1;
+
+ /** Constants for filter (UP) */
+ public const int FILTER_UP = 2;
+
+ /** Constants for filter (LAST) */
+ public const int FILTER_LAST = 2;
+
+ /** IHDR tag. */
+ protected static byte[] IHDR = new byte[] { 73, 72, 68, 82 };
+
+ /** IDAT tag. */
+ protected static byte[] IDAT = new byte[] { 73, 68, 65, 84 };
+
+ /** IEND tag. */
+ protected static byte[] IEND = new byte[] { 73, 69, 78, 68 };
+
+ /** The png bytes. */
+ protected byte[] pngBytes;
+
+ /** The prior row. */
+ protected byte[] priorRow;
+
+ /** The left bytes. */
+ protected byte[] leftBytes;
+
+ /** The width. */
+ protected int width, height;
+
+ /** The byte position. */
+ protected int bytePos, maxPos;
+
+ /** CRC. */
+ protected Crc32 crc = new Crc32();
+
+ /** The CRC value. */
+ protected long crcValue;
+
+ /** Encode alpha? */
+ protected bool encodeAlpha;
+
+ /** The filter type. */
+ protected int filter;
+
+ /** The bytes-per-pixel. */
+ protected int bytesPerPixel;
+
+ /** The compression level. */
+ protected int compressionLevel;
+
+ /** PixelData array to encode */
+ protected int[] pixelData;
+
+ /**
+ * Class constructor specifying Image source to encode, whether to encode alpha, filter to use,
+ * and compression level.
+ *
+ * @param pixel_data A Java Image object
+ * @param encodeAlpha Encode the alpha channel? false=no; true=yes
+ * @param whichFilter 0=none, 1=sub, 2=up
+ * @param compLevel 0..9
+ * @see java.awt.Image
+ */
+ public PngEncoder(int[] pixel_data, int width, int height, bool encodeAlpha, int whichFilter, int compLevel) {
+ this.pixelData = pixel_data;
+ this.width = width;
+ this.height = height;
+ this.encodeAlpha = encodeAlpha;
+
+ this.filter = FILTER_NONE;
+ if (whichFilter <= FILTER_LAST) {
+ this.filter = whichFilter;
+ }
+
+ if (compLevel >= 0 && compLevel <= 9) {
+ this.compressionLevel = compLevel;
+ }
+ }
+
+ /**
+ * Creates an array of bytes that is the PNG equivalent of the current image, specifying
+ * whether to encode alpha or not.
+ *
+ * @param encodeAlpha boolean false=no alpha, true=encode alpha
+ * @return an array of bytes, or null if there was a problem
+ */
+ public byte[] Encode(bool encodeAlpha) {
+ byte[] pngIdBytes = { 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A };
+
+ /*
+ * start with an array that is big enough to hold all the pixels
+ * (plus filter bytes), and an extra 200 bytes for header info
+ */
+ pngBytes = new byte[((width + 1) * height * 3) + 200];
+
+ /*
+ * keep track of largest byte written to the array
+ */
+ maxPos = 0;
+
+ bytePos = WriteBytes(pngIdBytes, 0);
+ //hdrPos = bytePos;
+ writeHeader();
+ //dataPos = bytePos;
+ if (WriteImageData()) {
+ writeEnd();
+ pngBytes = ResizeByteArray(pngBytes, maxPos);
+ } else {
+ pngBytes = null;
+ }
+ return pngBytes;
+ }
+
+ /**
+ * Creates an array of bytes that is the PNG equivalent of the current image.
+ * Alpha encoding is determined by its setting in the constructor.
+ *
+ * @return an array of bytes, or null if there was a problem
+ */
+ public byte[] pngEncode() {
+ return Encode(encodeAlpha);
+ }
+
+ /**
+ * Increase or decrease the length of a byte array.
+ *
+ * @param array The original array.
+ * @param newLength The length you wish the new array to have.
+ * @return Array of newly desired length. If shorter than the
+ * original, the trailing elements are truncated.
+ */
+ protected byte[] ResizeByteArray(byte[] array, int newLength) {
+ byte[] newArray = new byte[newLength];
+ int oldLength = array.Length;
+
+ Array.Copy(array, 0, newArray, 0, Math.Min(oldLength, newLength));
+ return newArray;
+ }
+
+ /**
+ * Write an array of bytes into the pngBytes array.
+ * Note: This routine has the side effect of updating
+ * maxPos, the largest element written in the array.
+ * The array is resized by 1000 bytes or the length
+ * of the data to be written, whichever is larger.
+ *
+ * @param data The data to be written into pngBytes.
+ * @param offset The starting point to write to.
+ * @return The next place to be written to in the pngBytes array.
+ */
+ protected int WriteBytes(byte[] data, int offset) {
+ maxPos = Math.Max(maxPos, offset + data.Length);
+ if (data.Length + offset > pngBytes.Length)
+ pngBytes = ResizeByteArray(pngBytes, pngBytes.Length + Math.Max(1000, data.Length));
+
+ Array.Copy(data, 0, pngBytes, offset, data.Length);
+ return offset + data.Length;
+ }
+
+ /**
+ * Write an array of bytes into the pngBytes array, specifying number of bytes to write.
+ * Note: This routine has the side effect of updating
+ * maxPos, the largest element written in the array.
+ * The array is resized by 1000 bytes or the length
+ * of the data to be written, whichever is larger.
+ *
+ * @param data The data to be written into pngBytes.
+ * @param nBytes The number of bytes to be written.
+ * @param offset The starting point to write to.
+ * @return The next place to be written to in the pngBytes array.
+ */
+ protected int WriteBytes(byte[] data, int nBytes, int offset) {
+ maxPos = Math.Max(maxPos, offset + nBytes);
+ if (nBytes + offset > pngBytes.Length)
+ pngBytes = ResizeByteArray(pngBytes, pngBytes.Length + Math.Max(1000, nBytes));
+
+ Array.Copy(data, 0, pngBytes, offset, nBytes);
+ return offset + nBytes;
+ }
+
+ /**
+ * Write a two-byte integer into the pngBytes array at a given position.
+ *
+ * @param n The integer to be written into pngBytes.
+ * @param offset The starting point to write to.
+ * @return The next place to be written to in the pngBytes array.
+ */
+ protected int WriteInt2(int n, int offset) {
+ byte[] temp = { (byte) ((n >> 8) & 0xff), (byte) (n & 0xff) };
+
+ return WriteBytes(temp, offset);
+ }
+
+ /**
+ * Write a four-byte integer into the pngBytes array at a given position.
+ *
+ * @param n The integer to be written into pngBytes.
+ * @param offset The starting point to write to.
+ * @return The next place to be written to in the pngBytes array.
+ */
+ protected int WriteInt4(int n, int offset) {
+ byte[] temp = {(byte) ((n >> 24) & 0xff),
+ (byte) ((n >> 16) & 0xff),
+ (byte) ((n >> 8) & 0xff),
+ (byte) (n & 0xff)};
+
+ return WriteBytes(temp, offset);
+ }
+
+ /**
+ * Write a single byte into the pngBytes array at a given position.
+ *
+ * @param b The integer to be written into pngBytes.
+ * @param offset The starting point to write to.
+ * @return The next place to be written to in the pngBytes array.
+ */
+ protected int WriteByte(int b, int offset) {
+ byte[] temp = { (byte) b };
+
+ return WriteBytes(temp, offset);
+ }
+
+ /**
+ * Write a PNG "IHDR" chunk into the pngBytes array.
+ */
+ protected void writeHeader() {
+ int startPos;
+
+ startPos = bytePos = WriteInt4(13, bytePos);
+
+ bytePos = WriteBytes(IHDR, bytePos);
+ bytePos = WriteInt4(width, bytePos);
+ bytePos = WriteInt4(height, bytePos);
+ bytePos = WriteByte(8, bytePos); // bit depth
+ bytePos = WriteByte((encodeAlpha) ? 6 : 2, bytePos); // direct model
+ bytePos = WriteByte(0, bytePos); // compression method
+ bytePos = WriteByte(0, bytePos); // filter method
+ bytePos = WriteByte(0, bytePos); // no interlace
+
+ crc.Reset();
+ crc.Update(pngBytes, startPos, bytePos - startPos);
+ crcValue = crc.Value;
+
+ bytePos = WriteInt4((int) crcValue, bytePos);
+ }
+
+ /**
+ * Perform "sub" filtering on the given row.
+ * Uses temporary array leftBytes to store the original values
+ * of the previous pixels. The array is 16 bytes long, which
+ * will easily hold two-byte samples plus two-byte alpha.
+ *
+ * @param pixels The array holding the scan lines being built
+ * @param startPos Starting position within pixels of bytes to be filtered.
+ * @param width Width of a scanline in pixels.
+ */
+ protected void FilterSub(byte[] pixels, int startPos, int width) {
+ int i;
+ int offset = bytesPerPixel;
+ int actualStart = startPos + offset;
+ int nBytes = width * bytesPerPixel;
+ int leftInsert = offset;
+ int leftExtract = 0;
+
+ for (i = actualStart; i < startPos + nBytes; i++) {
+ leftBytes[leftInsert] = pixels[i];
+ pixels[i] = (byte) ((pixels[i] - leftBytes[leftExtract]) % 256);
+ leftInsert = (leftInsert + 1) % 0x0f;
+ leftExtract = (leftExtract + 1) % 0x0f;
+ }
+ }
+
+ /**
+ * Perform "up" filtering on the given row.
+ * Side effect: refills the prior row with current row
+ *
+ * @param pixels The array holding the scan lines being built
+ * @param startPos Starting position within pixels of bytes to be filtered.
+ * @param width Width of a scanline in pixels.
+ */
+ protected void FilterUp(byte[] pixels, int startPos, int width) {
+ int i, nBytes;
+ byte currentByte;
+
+ nBytes = width * bytesPerPixel;
+
+ for (i = 0; i < nBytes; i++) {
+ currentByte = pixels[startPos + i];
+ pixels[startPos + i] = (byte) ((pixels[startPos + i] - priorRow[i]) % 256);
+ priorRow[i] = currentByte;
+ }
+ }
+
+ /**
+ * Write the image data into the pngBytes array.
+ * This will write one or more PNG "IDAT" chunks. In order
+ * to conserve memory, this method grabs as many rows as will
+ * fit into 32K bytes, or the whole image; whichever is less.
+ *
+ *
+ * @return true if no errors; false if error grabbing pixels
+ */
+ protected bool WriteImageData() {
+ int rowsLeft = height; // number of rows remaining to write
+ int startRow = 0; // starting row to process this time through
+ int nRows; // how many rows to grab at a time
+
+ byte[] scanLines; // the scan lines to be compressed
+ int scanPos; // where we are in the scan lines
+ int startPos; // where this line's actual pixels start (used for filtering)
+
+ byte[] compressedLines; // the resultant compressed lines
+ int nCompressed; // how big is the compressed area?
+
+ //int depth; // color depth ( handle only 8 or 32 )
+
+ bytesPerPixel = (encodeAlpha) ? 4 : 3;
+
+ Deflater scrunch = new Deflater(compressionLevel);
+ MemoryStream outBytes = new MemoryStream(1024);
+
+ DeflaterOutputStream compBytes = new DeflaterOutputStream(outBytes, scrunch);
+ try {
+ while (rowsLeft > 0) {
+ nRows = Math.Min(32767 / (width * (bytesPerPixel + 1)), rowsLeft);
+ nRows = Math.Max(nRows, 1);
+
+ int[] pixels = new int[width * nRows];
+ Array.Copy(this.pixelData, width * startRow, pixels, 0, width * nRows);
+
+ /*
+ * Create a data chunk. scanLines adds "nRows" for
+ * the filter bytes.
+ */
+ scanLines = new byte[width * nRows * bytesPerPixel + nRows];
+
+ if (filter == FILTER_SUB) {
+ leftBytes = new byte[16];
+ }
+ if (filter == FILTER_UP) {
+ priorRow = new byte[width * bytesPerPixel];
+ }
+
+ scanPos = 0;
+ startPos = 1;
+ for (int i = 0; i < width * nRows; i++) {
+ if (i % width == 0) {
+ scanLines[scanPos++] = (byte) filter;
+ startPos = scanPos;
+ }
+ scanLines[scanPos++] = (byte) ((pixels[i] >> 16) & 0xff);
+ scanLines[scanPos++] = (byte) ((pixels[i] >> 8) & 0xff);
+ scanLines[scanPos++] = (byte) ((pixels[i]) & 0xff);
+ if (encodeAlpha) {
+ scanLines[scanPos++] = (byte) ((pixels[i] >> 24) & 0xff);
+ }
+ if ((i % width == width - 1) && (filter != FILTER_NONE)) {
+ if (filter == FILTER_SUB) {
+ FilterSub(scanLines, startPos, width);
+ }
+ if (filter == FILTER_UP) {
+ FilterUp(scanLines, startPos, width);
+ }
+ }
+ }
+
+ /*
+ * Write these lines to the output area
+ */
+ compBytes.Write(scanLines, 0, scanPos);
+
+ startRow += nRows;
+ rowsLeft -= nRows;
+ }
+ compBytes.Close();
+
+ /*
+ * Write the compressed bytes
+ */
+ compressedLines = outBytes.ToArray();
+ nCompressed = compressedLines.Length;
+
+ crc.Reset();
+ bytePos = WriteInt4(nCompressed, bytePos);
+ bytePos = WriteBytes(IDAT, bytePos);
+ crc.Update(IDAT);
+ bytePos = WriteBytes(compressedLines, nCompressed, bytePos);
+ crc.Update(compressedLines, 0, nCompressed);
+
+ crcValue = crc.Value;
+ bytePos = WriteInt4((int) crcValue, bytePos);
+ scrunch.Finish();
+ return true;
+ } catch {
+ return false;
+ }
+ }
+
+ /**
+ * Write a PNG "IEND" chunk into the pngBytes array.
+ */
+ protected void writeEnd() {
+ bytePos = WriteInt4(0, bytePos);
+ bytePos = WriteBytes(IEND, bytePos);
+ crc.Reset();
+ crc.Update(IEND);
+ crcValue = crc.Value;
+ bytePos = WriteInt4((int) crcValue, bytePos);
+ }
+ }
+}
\ No newline at end of file
diff --git a/public/javascripts/plupload/src/csharp/Plupload/Properties/AppManifest.xml b/public/javascripts/plupload/src/csharp/Plupload/Properties/AppManifest.xml
new file mode 100644
index 0000000..1b45a1d
--- /dev/null
+++ b/public/javascripts/plupload/src/csharp/Plupload/Properties/AppManifest.xml
@@ -0,0 +1,6 @@
+
+
+
+
\ No newline at end of file
diff --git a/public/javascripts/plupload/src/csharp/Plupload/Properties/AssemblyInfo.cs b/public/javascripts/plupload/src/csharp/Plupload/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..005e313
--- /dev/null
+++ b/public/javascripts/plupload/src/csharp/Plupload/Properties/AssemblyInfo.cs
@@ -0,0 +1,45 @@
+/**
+ * $Id: AssemblyInfo.cs 480 2008-10-20 15:37:42Z spocke $
+ *
+ * @package MCManagerCore
+ * @author Moxiecode
+ * @copyright Copyright © 2007, Moxiecode Systems AB, All rights reserved.
+ */
+
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Plupload")]
+[assembly: AssemblyDescription("Multiple upload component.")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("Moxiecode Systems AB")]
+[assembly: AssemblyProduct("Upload")]
+[assembly: AssemblyCopyright("Copyright © 2009")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components. If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("95f0dee8-de7a-46c5-9dcc-0570b0fc4643")]
+
+// Version information for an assembly consists of the following four values:
+//
+// Major Version
+// Minor Version
+// Build Number
+// Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/public/javascripts/plupload/src/csharp/Plupload/Utils/JsonReader.cs b/public/javascripts/plupload/src/csharp/Plupload/Utils/JsonReader.cs
new file mode 100644
index 0000000..659c4fe
--- /dev/null
+++ b/public/javascripts/plupload/src/csharp/Plupload/Utils/JsonReader.cs
@@ -0,0 +1,486 @@
+/*
+ * $Id: JSONReader.cs 9 2007-05-27 10:47:07Z spocke $
+ *
+ * Copyright © 2007, Moxiecode Systems AB, All rights reserved.
+ */
+
+using System;
+using System.IO;
+using System.Text;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Moxiecode.Plupload.Utils {
+ class Stack {
+ private List items;
+
+ public Stack() {
+ items = new List();
+ }
+
+ public void Push(object item) {
+ items.Add(item);
+ }
+
+ public object Pop() {
+ object item = items[items.Count - 1];
+
+ items.RemoveAt(items.Count - 1);
+
+ return item;
+ }
+ }
+
+ ///
+ ///
+ ///
+ public enum JsonLocation {
+ ///
+ InArray,
+
+ ///
+ InObject,
+
+ ///
+ Normal
+ }
+
+ ///
+ ///
+ ///
+ public enum JsonToken {
+ ///
+ Boolean,
+
+ ///
+ Integer,
+
+ ///
+ String,
+
+ ///
+ Null,
+
+ ///
+ Float,
+
+ ///
+ StartArray,
+
+ ///
+ EndArray,
+
+ ///
+ PropertyName,
+
+ ///
+ StartObject,
+
+ ///
+ EndObject
+ }
+
+ ///
+ /// Description of JSONReader.
+ ///
+ public class JsonReader {
+ private TextReader reader;
+ private JsonToken token;
+ private object val;
+ private JsonLocation location;
+ private Stack lastLocations;
+ private bool needProp;
+
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ public JsonLocation Location {
+ get { return location; }
+ }
+
+ ///
+ ///
+ ///
+ public JsonToken TokenType {
+ get {
+ return this.token;
+ }
+ }
+
+ ///
+ ///
+ ///
+ public object Value {
+ get {
+ return this.val;
+ }
+ }
+
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ /// ) {
+ ((Dictionary)cur)[key] = this.Value;
+ } else if (cur is List)
+ ((List) cur).Add(this.Value);
+ else
+ return this.Value;
+
+ break;
+
+ case JsonToken.PropertyName:
+ key = (string) this.Value;
+ break;
+
+ case JsonToken.StartArray:
+ case JsonToken.StartObject:
+ if (this.TokenType == JsonToken.StartObject) {
+ obj = new Dictionary();
+ } else {
+ obj = new List();
+ }
+
+ if (cur is Dictionary) {
+ ((Dictionary)cur)[key] = obj;
+ } else if (cur is List) {
+ ((List)cur).Add(obj);
+ }
+
+ parents.Push(cur);
+ cur = obj;
+
+ break;
+
+ case JsonToken.EndArray:
+ case JsonToken.EndObject:
+ obj = parents.Pop();
+
+ if (obj != null)
+ cur = obj;
+
+ break;
+ }
+ }
+
+ return cur;
+ }
+
+ #endregion
+ }
+}
diff --git a/public/javascripts/plupload/src/flash/plupload/Plupload.as3proj b/public/javascripts/plupload/src/flash/plupload/Plupload.as3proj
new file mode 100644
index 0000000..7dc2ba0
--- /dev/null
+++ b/public/javascripts/plupload/src/flash/plupload/Plupload.as3proj
@@ -0,0 +1,85 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/public/javascripts/plupload/src/flash/plupload/build.sh b/public/javascripts/plupload/src/flash/plupload/build.sh
new file mode 100644
index 0000000..ec0ae46
--- /dev/null
+++ b/public/javascripts/plupload/src/flash/plupload/build.sh
@@ -0,0 +1,21 @@
+#!/bin/sh
+
+if [ -z "$FLEX_HOME" ]; then
+ FLEX_HOME=/opt/flex/flex
+fi
+
+export FLEX_HOME
+
+$FLEX_HOME/bin/mxmlc \
+ -compiler.source-path src \
+ -compiler.optimize \
+ -compiler.use-resource-bundle-metadata \
+ -compiler.show-actionscript-warnings \
+ -compiler.show-binding-warnings \
+ -compiler.show-unused-type-selector-warnings \
+ -compiler.strict \
+ -compiler.accessible=false \
+ -use-network \
+ -static-link-runtime-shared-libraries \
+ -output ../../../js/plupload.flash.swf \
+ src/com/plupload/Plupload.as
diff --git a/public/javascripts/plupload/src/flash/plupload/src/com/formatlos/BitmapDataUnlimited.as b/public/javascripts/plupload/src/flash/plupload/src/com/formatlos/BitmapDataUnlimited.as
new file mode 100644
index 0000000..792f264
--- /dev/null
+++ b/public/javascripts/plupload/src/flash/plupload/src/com/formatlos/BitmapDataUnlimited.as
@@ -0,0 +1,291 @@
+/*
+Copyright (c) 2008 Martin Raedlinger (mr@formatlos.de)
+
+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.
+*/
+
+package com.formatlos
+{
+ import com.formatlos.events.BitmapDataUnlimitedEvent;
+
+ import flash.display.Bitmap;
+ import flash.display.BitmapData;
+ import flash.display.DisplayObject;
+ import flash.display.IBitmapDrawable;
+ import flash.display.Loader;
+ import flash.events.Event;
+ import flash.events.EventDispatcher;
+ import flash.events.IEventDispatcher;
+ import flash.geom.ColorTransform;
+ import flash.geom.Matrix;
+ import flash.geom.Point;
+ import flash.geom.Rectangle;
+
+ /**
+ * Dispatched when the BitmapData is ready
+ *
+ * @eventType com.formatlos.events.BitmapDataUnlimitedEvent
+ */
+ [Event(name='COMPLETE', type='com.formatlos.events.BitmapDataUnlimitedEvent')]
+
+ /**
+ * Dispatched when the BitmapData can't be created due to memory issues.
+ * watch your system memory and/or System.totalMemory
+ *
+ * @eventType com.formatlos.events.BitmapDataUnlimitedEvent
+ */
+ [Event(name='ERROR', type='com.formatlos.events.BitmapDataUnlimitedEvent')]
+
+ // ---------------------------------------------------------------------------
+
+ /**
+ * The BitmapDataUnlimited Class creates an empty gif image
+ *
+ * @author Martin Raedlinger
+ *
+ * @example
+ * The example shows how to use the BitmapDataUnlimited
+ *
+ *
+ *
+ * var bdu:BitmapDataUnlimited = new BitmapDataUnlimited();
+ * bdu.addEventListener(BitmapDataUnlimitedEvent.COMPLETE, onBmpReady);
+ * bdu.create(5000, 5000, true);
+ *
+ * var hugeBitmapData : BitmapData;
+ *
+ * function onBmpReady(event : BitmapDataUnlimitedEvent) : void
+ * {
+ * hugeBitmapData = bdu.bitmapData;
+ *
+ * var rect : Rectangle = new Rectangle(10, 10, 10, 10);
+ *
+ * hugeBitmapData.fillRect(rect, 0xffff0000);
+ * addChild(new Bitmap(hugeBitmapData));
+ *
+ * trace("BitmapData: w=" + hugeBitmapData.width + " h=" + hugeBitmapData.height);
+ * }
+ *
+ *
+ *
' +
+ '' + file.name + '
' +
+ '' +
+ '' + file.percent + '%
' +
+ '' + plupload.formatSize(file.size) + '
' +
+ '
' +
+ inputHTML +
+ ' '
+ );
+
+ handleStatus(file);
+
+ $('#' + file.id + '.plupload_delete a').click(function(e) {
+ $('#' + file.id).remove();
+ uploader.removeFile(file);
+
+ e.preventDefault();
+ });
+ });
+
+ $('span.plupload_total_file_size', target).html(plupload.formatSize(uploader.total.size));
+
+ if (uploader.total.queued === 0) {
+ $('span.plupload_add_text', target).text(_('Add files.'));
+ } else {
+ $('span.plupload_add_text', target).text(uploader.total.queued + ' files queued.');
+ }
+
+ $('a.plupload_start', target).toggleClass('plupload_disabled', uploader.files.length == (uploader.total.uploaded + uploader.total.failed));
+
+ // Scroll to end of file list
+ fileList[0].scrollTop = fileList[0].scrollHeight;
+
+ updateTotalProgress();
+
+ // Re-add drag message if there is no files
+ if (!uploader.files.length && uploader.features.dragdrop && uploader.settings.dragdrop) {
+ $('#' + id + '_filelist').append('' + _("Drag files here.") + ' ');
+ }
+ }
+
+ uploader.bind("UploadFile", function(up, file) {
+ $('#' + file.id).addClass('plupload_current_file');
+ });
+
+ uploader.bind('Init', function(up, res) {
+ renderUI(id, target);
+
+ // Enable rename support
+ if (!settings.unique_names && settings.rename) {
+ $('#' + id + '_filelist div.plupload_file_name span', target).live('click', function(e) {
+ var targetSpan = $(e.target), file, parts, name, ext = "";
+
+ // Get file name and split out name and extension
+ file = up.getFile(targetSpan.parents('li')[0].id);
+ name = file.name;
+ parts = /^(.+)(\.[^.]+)$/.exec(name);
+ if (parts) {
+ name = parts[1];
+ ext = parts[2];
+ }
+
+ // Display input element
+ targetSpan.hide().after('' + _("Drag files here.") + ' ');
+ }
+
+ $('#' + id + '_container').attr('title', 'Using runtime: ' + res.runtime);
+
+ $('a.plupload_start', target).click(function(e) {
+ if (!$(this).hasClass('plupload_disabled')) {
+ uploader.start();
+ }
+
+ e.preventDefault();
+ });
+
+ $('a.plupload_stop', target).click(function(e) {
+ e.preventDefault();
+ uploader.stop();
+ });
+
+ $('a.plupload_start', target).addClass('plupload_disabled');
+ });
+
+ uploader.init();
+
+ uploader.bind("Error", function(up, err) {
+ var file = err.file, message;
+
+ if (file) {
+ message = err.message;
+
+ if (err.details) {
+ message += " (" + err.details + ")";
+ }
+
+ if (err.code == plupload.FILE_SIZE_ERROR) {
+ alert(_("Error: File to large: ") + file.name);
+ }
+
+ if (err.code == plupload.FILE_EXTENSION_ERROR) {
+ alert(_("Error: Invalid file extension: ") + file.name);
+ }
+
+ file['hint'] = message;
+ $('#' + file.id).attr('class', 'plupload_failed').find('a').css('display', 'block').attr('title', message);
+ }
+ });
+
+ uploader.bind('StateChanged', function() {
+ if (uploader.state === plupload.STARTED) {
+ $('li.plupload_delete a,div.plupload_buttons', target).hide();
+ $('span.plupload_upload_status,div.plupload_progress,a.plupload_stop', target).css('display', 'block');
+ $('span.plupload_upload_status', target).text('Uploaded ' + uploader.total.uploaded + '/' + uploader.files.length + ' files');
+
+ if (settings.multiple_queues) {
+ $('span.plupload_total_status,span.plupload_total_file_size', target).show();
+ }
+ } else {
+ updateList();
+ $('a.plupload_stop,div.plupload_progress', target).hide();
+ $('a.plupload_delete', target).css('display', 'block');
+ }
+ });
+
+ uploader.bind('QueueChanged', updateList);
+
+ uploader.bind('FileUploaded', function(up, file) {
+ handleStatus(file);
+ });
+
+ uploader.bind("UploadProgress", function(up, file) {
+ // Set file specific progress
+ $('#' + file.id + ' div.plupload_file_status', target).html(file.percent + '%');
+
+ handleStatus(file);
+ updateTotalProgress();
+
+ if (settings.multiple_queues && uploader.total.uploaded + uploader.total.failed == uploader.files.length) {
+ $(".plupload_buttons,.plupload_upload_status", target).css("display", "inline");
+ $(".plupload_start", target).addClass("plupload_disabled");
+ $('span.plupload_total_status,span.plupload_total_file_size', target).hide();
+ }
+ });
+
+ // Call setup function
+ if (settings.setup) {
+ settings.setup(uploader);
+ }
+ });
+
+ return this;
+ } else {
+ // Get uploader instance for specified element
+ return uploaders[$(this[0]).attr('id')];
+ }
+ };
+})(jQuery);
diff --git a/public/javascripts/plupload/src/javascript/jquery.ui.plupload.js b/public/javascripts/plupload/src/javascript/jquery.ui.plupload.js
new file mode 100644
index 0000000..c618bcc
--- /dev/null
+++ b/public/javascripts/plupload/src/javascript/jquery.ui.plupload.js
@@ -0,0 +1,743 @@
+/**
+ * jquery.ui.plupload.js
+ *
+ * Copyright 2009, Moxiecode Systems AB
+ * Released under GPL License.
+ *
+ * License: http://www.plupload.com/license
+ * Contributing: http://www.plupload.com/contributing
+ *
+ * Depends:
+ * jquery.ui.core.js
+ * jquery.ui.widget.js
+ *
+ * Optionally:
+ * jquery.ui.button.js
+ * jquery.ui.progressbar.js
+ * jquery.ui.sortable.js
+ */
+
+// JSLint defined globals
+/*global window:false, document:false, plupload:false, jQuery:false */
+
+(function(window, document, plupload, $, undef) {
+
+var uploaders = {};
+
+function _(str) {
+ return plupload.translate(str) || str;
+}
+
+function renderUI(obj) {
+ obj.html(
+ '' +
+ '
' +
+ '
' +
+ '' +
+
+ '
' +
+ '
' +
+
+ '
' +
+
+ '
' +
+ '
' +
+ '
' +
+ '
' +
+ '
' +
+ '
' + err.message + ' ';
+ details = err.details;
+
+ if (details) {
+ message += " " + err.details + " ";
+ } else {
+
+ switch (err.code) {
+ case plupload.FILE_EXTENSION_ERROR:
+ details = _("File: %s").replace('%s', file.name);
+ break;
+
+ case plupload.FILE_SIZE_ERROR:
+ details = _("File: %f, size: %s, max file size: %m").replace(/%([fsm])/g, function($0, $1) {
+ switch ($1) {
+ case 'f': return file.name;
+ case 's': return file.size;
+ case 'm': return plupload.parseSize(self.options.max_file_size);
+ }
+ });
+ break;
+
+ case self.FILE_COUNT_ERROR:
+ details = _("Upload element accepts only %d file(s) at a time. Extra files were stripped.")
+ .replace('%d', self.options.max_file_count);
+ break;
+
+ case plupload.IMAGE_FORMAT_ERROR :
+ details = plupload.translate('Image format either wrong or not supported.');
+ break;
+
+ case plupload.IMAGE_MEMORY_ERROR :
+ details = plupload.translate('Runtime ran out of available memory.');
+ break;
+
+ case plupload.IMAGE_DIMENSIONS_ERROR :
+ details = plupload.translate('Resoultion out of boundaries! %s runtime supports images only up to %wx%hpx.').replace(/%([swh])/g, function($0, $1) {
+ switch ($1) {
+ case 's': return up.runtime;
+ case 'w': return up.features.maxWidth;
+ case 'h': return up.features.maxHeight;
+ }
+ });
+ break;
+
+ case plupload.HTTP_ERROR:
+ details = _("Upload URL might be wrong or doesn't exist");
+ break;
+ }
+ message += " " + details + " ";
+ }
+
+ self._notify('error', message);
+ }
+ });
+ },
+
+ _setOption: function(key, value) {
+
+ if (key == 'buttons' && typeof(value) == 'object') {
+ value = $.extend(this.options.buttons, value);
+
+ if (!value.browse) {
+ this.browse_button.button('disable').hide();
+ $('#' + this.id + self.runtime + '_container').hide();
+ } else {
+ this.browse_button.button('enable').show();
+ $('#' + this.id + self.runtime + '_container').show();
+ }
+
+ if (!value.start) {
+ this.start_button.button('disable').hide();
+ } else {
+ this.start_button.button('enable').show();
+ }
+
+ if (!value.stop) {
+ this.stop_button.button('disable').hide();
+ } else {
+ this.start_button.button('enable').show();
+ }
+ }
+
+ this.uploader.settings[key] = value;
+ },
+
+
+ start: function() {
+ this.uploader.start();
+ this._trigger('start', null);
+ },
+
+ stop: function() {
+ this.uploader.stop();
+ this._trigger('stop', null);
+ },
+
+ getFile: function(id) {
+ var file;
+
+ if (typeof id === 'number') {
+ file = this.uploader.files[id];
+ } else {
+ file = this.uploader.getFile(id);
+ }
+ return file;
+ },
+
+ removeFile: function(id) {
+ var file = this.getFile(id);
+ if (file) {
+ this.uploader.removeFile(file);
+ }
+ },
+
+ clearQueue: function() {
+ this.uploader.splice();
+ },
+
+ getUploader: function() {
+ return this.uploader;
+ },
+
+ refresh: function() {
+ this.uploader.refresh();
+ },
+
+
+ _handleState: function() {
+ var self = this, uploader = this.uploader;
+
+ if (uploader.state === plupload.STARTED) {
+
+ $(self.start_button).button('disable');
+
+ $([])
+ .add(self.stop_button)
+ .add('.plupload_started')
+ .removeClass('plupload_hidden');
+
+ $('.plupload_upload_status', self.element).text(
+ _('Uploaded %d/%d files').replace('%d/%d', uploader.total.uploaded+'/'+uploader.files.length)
+ );
+
+ $('.plupload_header_content', self.element).addClass('plupload_header_content_bw');
+
+ } else {
+
+ $([])
+ .add(self.stop_button)
+ .add('.plupload_started')
+ .addClass('plupload_hidden');
+
+ if (self.options.multiple_queues) {
+ $(self.start_button).button('enable');
+
+ $('.plupload_header_content', self.element).removeClass('plupload_header_content_bw');
+ }
+
+ self._updateFileList();
+ }
+ },
+
+
+ _handleFileStatus: function(file) {
+ var actionClass, iconClass;
+
+ switch (file.status) {
+ case plupload.DONE:
+ actionClass = 'plupload_done';
+ iconClass = 'ui-icon ui-icon-circle-check';
+ break;
+
+ case plupload.FAILED:
+ actionClass = 'ui-state-error plupload_failed';
+ iconClass = 'ui-icon ui-icon-alert';
+ break;
+
+ case plupload.QUEUED:
+ actionClass = 'plupload_delete';
+ iconClass = 'ui-icon ui-icon-circle-minus';
+ break;
+
+ case plupload.UPLOADING:
+ actionClass = 'ui-state-highlight plupload_uploading';
+ iconClass = 'ui-icon ui-icon-circle-arrow-w';
+
+ // scroll uploading file into the view if its bottom boundary is out of it
+ var scroller = $('.plupload_scroll', this.container),
+ scrollTop = scroller.scrollTop(),
+ scrollerHeight = scroller.height(),
+ rowOffset = $('#' + file.id).position().top + $('#' + file.id).height();
+
+ if (scrollerHeight < rowOffset) {
+ scroller.scrollTop(scrollTop + rowOffset - scrollerHeight);
+ }
+ break;
+ }
+ actionClass += ' ui-state-default plupload_file';
+
+ $('#' + file.id)
+ .attr('class', actionClass)
+ .find('.ui-icon')
+ .attr('class', iconClass);
+ },
+
+
+ _updateTotalProgress: function() {
+ var uploader = this.uploader;
+
+ this.progressbar.progressbar('value', uploader.total.percent);
+
+ $('.plupload_total_status', this.element).html(uploader.total.percent + '%');
+
+ $('.plupload_upload_status', this.element).text(
+ _('Uploaded %d/%d files').replace('%d/%d', uploader.total.uploaded+'/'+uploader.files.length)
+ );
+
+ // All files are uploaded
+ if (uploader.total.uploaded === uploader.files.length) {
+ uploader.stop();
+ }
+ },
+
+
+ _updateFileList: function() {
+ var self = this, uploader = this.uploader, filelist = this.filelist,
+ count = 0,
+ id, prefix = this.id + '_',
+ fields;
+
+ // destroy sortable if enabled
+ if ($.ui.sortable && this.options.sortable) {
+ $('tbody', filelist).sortable('destroy');
+ }
+
+ filelist.empty();
+
+ $.each(uploader.files, function(i, file) {
+ fields = '';
+ id = prefix + count;
+
+ if (file.status === plupload.DONE) {
+ if (file.target_name) {
+ fields += '' +
+ '' + file.name + ' ' + file.percent + '% ' +
+ '' + plupload.formatSize(file.size) + ' ' +
+ '
' + fields + ' '
+ );
+
+ self._handleFileStatus(file);
+
+ $('#' + file.id + '.plupload_delete .ui-icon, #' + file.id + '.plupload_done .ui-icon')
+ .click(function(e) {
+ $('#' + file.id).remove();
+ uploader.removeFile(file);
+
+ e.preventDefault();
+ });
+
+ self._trigger('updatelist', null, filelist);
+ });
+
+
+ $('.plupload_total_file_size', self.element).html(plupload.formatSize(uploader.total.size));
+
+ if (uploader.total.queued === 0) {
+ $('.ui-button-text', self.browse_button).text(_('Add Files'));
+ } else {
+ $('.ui-button-text', self.browse_button).text(_('%d files queued').replace('%d', uploader.total.queued));
+ }
+
+
+ if (uploader.files.length === (uploader.total.uploaded + uploader.total.failed)) {
+ self.start_button.button('disable');
+ } else {
+ self.start_button.button('enable');
+ }
+
+
+ // Scroll to end of file list
+ filelist[0].scrollTop = filelist[0].scrollHeight;
+
+ self._updateTotalProgress();
+
+ if (!uploader.files.length && uploader.features.dragdrop && uploader.settings.dragdrop) {
+ // Re-add drag message if there are no files
+ $('#' + id + '_filelist').append('' + _("Drag files here.") + ' ' + _("Drag files here.") + ' ' +
+ '
' +
+ '
' +
+ '
' +
+ ' ';
+
+ function getFlashObj() {
+ return document.getElementById(uploader.id + '_flash');
+ }
+
+ function waitLoad() {
+
+ // Wait for 5 sec
+ if (waitCount++ > 5000) {
+ callback({success : false});
+ return;
+ }
+
+ if (!initialized[uploader.id]) {
+ setTimeout(waitLoad, 1);
+ }
+ }
+
+ waitLoad();
+
+ // Fix IE memory leaks
+ browseButton = flashContainer = null;
+
+ // Wait for Flash to send init event
+ uploader.bind("Flash:Init", function() {
+ var lookup = {}, i, resize = uploader.settings.resize || {};
+
+ getFlashObj().setFileFilters(uploader.settings.filters, uploader.settings.multi_selection);
+
+ // Prevent eventual reinitialization of the instance
+ if (initialized[uploader.id]) {
+ return;
+ }
+
+ initialized[uploader.id] = true;
+
+ uploader.bind("UploadFile", function(up, file) {
+ var settings = up.settings;
+
+ getFlashObj().uploadFile(lookup[file.id], settings.url, {
+ name : file.target_name || file.name,
+ mime : plupload.mimeTypes[file.name.replace(/^.+\.([^.]+)/, '$1')] || 'application/octet-stream',
+ chunk_size : settings.chunk_size,
+ width : resize.width,
+ height : resize.height,
+ quality : resize.quality || 90,
+ multipart : settings.multipart,
+ multipart_params : settings.multipart_params || {},
+ file_data_name : settings.file_data_name,
+ format : /\.(jpg|jpeg)$/i.test(file.name) ? 'jpg' : 'png',
+ headers : settings.headers,
+ urlstream_upload : settings.urlstream_upload
+ });
+ });
+
+
+ uploader.bind("Flash:UploadProcess", function(up, flash_file) {
+ var file = up.getFile(lookup[flash_file.id]);
+
+ if (file.status != plupload.FAILED) {
+ file.loaded = flash_file.loaded;
+ file.size = flash_file.size;
+
+ up.trigger('UploadProgress', file);
+ }
+ });
+
+ uploader.bind("Flash:UploadChunkComplete", function(up, info) {
+ var chunkArgs, file = up.getFile(lookup[info.id]);
+
+ chunkArgs = {
+ chunk : info.chunk,
+ chunks : info.chunks,
+ response : info.text
+ };
+
+ up.trigger('ChunkUploaded', file, chunkArgs);
+
+ // Stop upload if file is maked as failed
+ if (file.status != plupload.FAILED) {
+ getFlashObj().uploadNextChunk();
+ }
+
+ // Last chunk then dispatch FileUploaded event
+ if (info.chunk == info.chunks - 1) {
+ file.status = plupload.DONE;
+
+ up.trigger('FileUploaded', file, {
+ response : info.text
+ });
+ }
+ });
+
+ uploader.bind("Flash:SelectFiles", function(up, selected_files) {
+ var file, i, files = [], id;
+
+ // Add the selected files to the file queue
+ for (i = 0; i < selected_files.length; i++) {
+ file = selected_files[i];
+
+ // Store away flash ref internally
+ id = plupload.guid();
+ lookup[id] = file.id;
+ lookup[file.id] = id;
+
+ files.push(new plupload.File(id, file.name, file.size));
+ }
+
+ // Trigger FilesAdded event if we added any
+ if (files.length) {
+ uploader.trigger("FilesAdded", files);
+ }
+ });
+
+ uploader.bind("Flash:SecurityError", function(up, err) {
+ uploader.trigger('Error', {
+ code : plupload.SECURITY_ERROR,
+ message : plupload.translate('Security error.'),
+ details : err.message,
+ file : uploader.getFile(lookup[err.id])
+ });
+ });
+
+ uploader.bind("Flash:GenericError", function(up, err) {
+ uploader.trigger('Error', {
+ code : plupload.GENERIC_ERROR,
+ message : plupload.translate('Generic error.'),
+ details : err.message,
+ file : uploader.getFile(lookup[err.id])
+ });
+ });
+
+ uploader.bind("Flash:IOError", function(up, err) {
+ uploader.trigger('Error', {
+ code : plupload.IO_ERROR,
+ message : plupload.translate('IO error.'),
+ details : err.message,
+ file : uploader.getFile(lookup[err.id])
+ });
+ });
+
+ uploader.bind("Flash:ImageError", function(up, err) {
+ uploader.trigger('Error', {
+ code : parseInt(err.code),
+ message : plupload.translate('Image error.'),
+ file : uploader.getFile(lookup[err.id])
+ });
+ });
+
+ uploader.bind('Flash:StageEvent:rollOver', function(up) {
+ var browseButton, hoverClass;
+
+ browseButton = document.getElementById(uploader.settings.browse_button);
+ hoverClass = up.settings.browse_button_hover;
+
+ if (browseButton && hoverClass) {
+ plupload.addClass(browseButton, hoverClass);
+ }
+ });
+
+ uploader.bind('Flash:StageEvent:rollOut', function(up) {
+ var browseButton, hoverClass;
+
+ browseButton = document.getElementById(uploader.settings.browse_button);
+ hoverClass = up.settings.browse_button_hover;
+
+ if (browseButton && hoverClass) {
+ plupload.removeClass(browseButton, hoverClass);
+ }
+ });
+
+ uploader.bind('Flash:StageEvent:mouseDown', function(up) {
+ var browseButton, activeClass;
+
+ browseButton = document.getElementById(uploader.settings.browse_button);
+ activeClass = up.settings.browse_button_active;
+
+ if (browseButton && activeClass) {
+ plupload.addClass(browseButton, activeClass);
+
+ // Make sure that browse_button has active state removed from it
+ plupload.addEvent(document.body, 'mouseup', function() {
+ plupload.removeClass(browseButton, activeClass);
+ }, up.id);
+ }
+ });
+
+ uploader.bind('Flash:StageEvent:mouseUp', function(up) {
+ var browseButton, activeClass;
+
+ browseButton = document.getElementById(uploader.settings.browse_button);
+ activeClass = up.settings.browse_button_active;
+
+ if (browseButton && activeClass) {
+ plupload.removeClass(browseButton, activeClass);
+ }
+ });
+
+ uploader.bind("QueueChanged", function(up) {
+ uploader.refresh();
+ });
+
+ uploader.bind("FilesRemoved", function(up, files) {
+ var i;
+
+ for (i = 0; i < files.length; i++) {
+ getFlashObj().removeFile(lookup[files[i].id]);
+ }
+ });
+
+ uploader.bind("StateChanged", function(up) {
+ uploader.refresh();
+ });
+
+ uploader.bind("Refresh", function(up) {
+ var browseButton, browsePos, browseSize;
+
+ // Set file filters incase it has been changed dynamically
+ getFlashObj().setFileFilters(uploader.settings.filters, uploader.settings.multi_selection);
+
+ browseButton = document.getElementById(up.settings.browse_button);
+ if (browseButton) {
+ browsePos = plupload.getPos(browseButton, document.getElementById(up.settings.container));
+ browseSize = plupload.getSize(browseButton);
+
+ plupload.extend(document.getElementById(up.id + '_flash_container').style, {
+ top : browsePos.y + 'px',
+ left : browsePos.x + 'px',
+ width : browseSize.w + 'px',
+ height : browseSize.h + 'px'
+ });
+ }
+ });
+
+ uploader.bind("Destroy", function(up) {
+ var flashContainer;
+
+ plupload.removeAllEvents(document.body, up.id);
+
+ delete initialized[up.id];
+ delete uploadInstances[up.id];
+
+ flashContainer = document.getElementById(up.id + '_flash_container');
+ if (flashContainer) {
+ container.removeChild(flashContainer);
+ }
+ });
+
+ callback({success : true});
+ });
+ }
+ });
+})(window, document, plupload);
diff --git a/public/javascripts/plupload/src/javascript/plupload.gears.js b/public/javascripts/plupload/src/javascript/plupload.gears.js
new file mode 100644
index 0000000..b28003c
--- /dev/null
+++ b/public/javascripts/plupload/src/javascript/plupload.gears.js
@@ -0,0 +1,321 @@
+/**
+ * plupload.gears.js
+ *
+ * Copyright 2009, Moxiecode Systems AB
+ * Released under GPL License.
+ *
+ * License: http://www.plupload.com/license
+ * Contributing: http://www.plupload.com/contributing
+ */
+
+// JSLint defined globals
+/*global window:false, document:false, plupload:false, google:false */
+
+(function(window, document, plupload, undef) {
+ var blobs = {};
+
+ function scaleImage(image_blob, width, height, quality, mime) {
+ var percentage, canvas, context, scale;
+
+ // Setup canvas and scale
+ canvas = google.gears.factory.create('beta.canvas');
+ try {
+ canvas.decode(image_blob);
+ scale = Math.min(width / canvas.width, height / canvas.height);
+
+ if (scale < 1) {
+ canvas.resize(Math.round(canvas.width * scale), Math.round(canvas.height * scale));
+
+ return canvas.encode(mime, {quality : quality / 100});
+ }
+ } catch (e) {
+ // Ignore for example when a user uploads a file that can't be decoded
+ }
+
+ return image_blob;
+ }
+
+ /**
+ * Gears implementation. This runtime supports these features: dragdrop, jpgresize, pngresize, chunks.
+ *
+ * @static
+ * @class plupload.runtimes.Gears
+ * @extends plupload.Runtime
+ */
+ plupload.runtimes.Gears = plupload.addRuntime("gears", {
+ /**
+ * Returns a list of supported features for the runtime.
+ *
+ * @return {Object} Name/value object with supported features.
+ */
+ getFeatures : function() {
+ return {
+ dragdrop: true,
+ jpgresize: true,
+ pngresize: true,
+ chunks: true,
+ progress: true,
+ multipart: true
+ };
+ },
+
+ /**
+ * Initializes the upload runtime.
+ *
+ * @method init
+ * @param {plupload.Uploader} uploader Uploader instance that needs to be initialized.
+ * @param {function} callback Callback to execute when the runtime initializes or fails to initialize. If it succeeds an object with a parameter name success will be set to true.
+ */
+ init : function(uploader, callback) {
+ var desktop;
+
+ // Check for gears support
+ if (!window.google || !google.gears) {
+ return callback({success : false});
+ }
+
+ try {
+ desktop = google.gears.factory.create('beta.desktop');
+ } catch (e) {
+ // Might fail on the latest Gecko build for some odd reason
+ return callback({success : false});
+ }
+
+ function addSelectedFiles(selected_files) {
+ var file, i, files = [], id;
+
+ // Add the selected files to the file queue
+ for (i = 0; i < selected_files.length; i++) {
+ file = selected_files[i];
+
+ // Store away gears blob internally
+ id = plupload.guid();
+ blobs[id] = file.blob;
+
+ files.push(new plupload.File(id, file.name, file.blob.length));
+ }
+
+ // Fire FilesAdded event
+ uploader.trigger("FilesAdded", files);
+ }
+
+ // Add drop handler
+ uploader.bind("PostInit", function() {
+ var settings = uploader.settings, dropElm = document.getElementById(settings.drop_element);
+
+ if (dropElm) {
+ // Block browser default drag over
+ plupload.addEvent(dropElm, 'dragover', function(e) {
+ desktop.setDropEffect(e, 'copy');
+ e.preventDefault();
+ }, uploader.id);
+
+ // Attach drop handler and grab files from Gears
+ plupload.addEvent(dropElm, 'drop', function(e) {
+ var dragData = desktop.getDragData(e, 'application/x-gears-files');
+
+ if (dragData) {
+ addSelectedFiles(dragData.files);
+ }
+
+ e.preventDefault();
+ }, uploader.id);
+
+ // Prevent IE leak
+ dropElm = 0;
+ }
+
+ // Add browse button
+ plupload.addEvent(document.getElementById(settings.browse_button), 'click', function(e) {
+ var filters = [], i, a, ext;
+
+ e.preventDefault();
+
+ for (i = 0; i < settings.filters.length; i++) {
+ ext = settings.filters[i].extensions.split(',');
+
+ for (a = 0; a < ext.length; a++) {
+ filters.push('.' + ext[a]);
+ }
+ }
+
+ desktop.openFiles(addSelectedFiles, {singleFile : !settings.multi_selection, filter : filters});
+ }, uploader.id);
+ });
+
+ uploader.bind("UploadFile", function(up, file) {
+ var chunk = 0, chunks, chunkSize, loaded = 0, resize = up.settings.resize, chunking;
+
+ // If file is png or jpeg and resize is configured then resize it
+ if (resize && /\.(png|jpg|jpeg)$/i.test(file.name)) {
+ blobs[file.id] = scaleImage(blobs[file.id], resize.width, resize.height, resize.quality || 90, /\.png$/i.test(file.name) ? 'image/png' : 'image/jpeg');
+ }
+
+ file.size = blobs[file.id].length;
+
+ chunkSize = up.settings.chunk_size;
+ chunking = chunkSize > 0;
+ chunks = Math.ceil(file.size / chunkSize);
+
+ // If chunking is disabled then upload the whole file in one huge chunk
+ if (!chunking) {
+ chunkSize = file.size;
+ chunks = 1;
+ }
+
+ function uploadNextChunk() {
+ var req, curChunkSize, multipart = up.settings.multipart, multipartLength = 0, reqArgs = {name : file.target_name || file.name}, url = up.settings.url;
+
+ // Sends the binary blob multipart encoded or raw depending on config
+ function sendBinaryBlob(blob) {
+ var builder, boundary = '----pluploadboundary' + plupload.guid(), dashdash = '--', crlf = '\r\n', multipartBlob, mimeType;
+
+ // Build multipart request
+ if (multipart) {
+ req.setRequestHeader('Content-Type', 'multipart/form-data; boundary=' + boundary);
+ builder = google.gears.factory.create('beta.blobbuilder');
+
+ // Append mutlipart parameters
+ plupload.each(plupload.extend(reqArgs, up.settings.multipart_params), function(value, name) {
+ builder.append(
+ dashdash + boundary + crlf +
+ 'Content-Disposition: form-data; name="' + name + '"' + crlf + crlf
+ );
+
+ builder.append(value + crlf);
+ });
+
+ mimeType = plupload.mimeTypes[file.name.replace(/^.+\.([^.]+)/, '$1')] || 'application/octet-stream';
+
+ // Add file header
+ builder.append(
+ dashdash + boundary + crlf +
+ 'Content-Disposition: form-data; name="' + up.settings.file_data_name + '"; filename="' + file.name + '"' + crlf +
+ 'Content-Type: ' + mimeType + crlf + crlf
+ );
+
+ // Add file data
+ builder.append(blob);
+
+ // Add footer
+ builder.append(crlf + dashdash + boundary + dashdash + crlf);
+ multipartBlob = builder.getAsBlob();
+ multipartLength = multipartBlob.length - blob.length;
+ blob = multipartBlob;
+ }
+
+ // Send blob or multipart blob depending on config
+ req.send(blob);
+ }
+
+ // File upload finished
+ if (file.status == plupload.DONE || file.status == plupload.FAILED || up.state == plupload.STOPPED) {
+ return;
+ }
+
+ // Only add chunking args if needed
+ if (chunking) {
+ reqArgs.chunk = chunk;
+ reqArgs.chunks = chunks;
+ }
+
+ // Setup current chunk size
+ curChunkSize = Math.min(chunkSize, file.size - (chunk * chunkSize));
+
+ if (!multipart) {
+ url = plupload.buildUrl(up.settings.url, reqArgs);
+ }
+
+ req = google.gears.factory.create('beta.httprequest');
+ req.open('POST', url);
+
+ // Add disposition and type if multipart is disabled
+ if (!multipart) {
+ req.setRequestHeader('Content-Disposition', 'attachment; filename="' + file.name + '"');
+ req.setRequestHeader('Content-Type', 'application/octet-stream');
+ }
+
+ // Set custom headers
+ plupload.each(up.settings.headers, function(value, name) {
+ req.setRequestHeader(name, value);
+ });
+
+ req.upload.onprogress = function(progress) {
+ file.loaded = loaded + progress.loaded - multipartLength;
+ up.trigger('UploadProgress', file);
+ };
+
+ req.onreadystatechange = function() {
+ var chunkArgs;
+
+ if (req.readyState == 4) {
+ if (req.status == 200) {
+ chunkArgs = {
+ chunk : chunk,
+ chunks : chunks,
+ response : req.responseText,
+ status : req.status
+ };
+
+ up.trigger('ChunkUploaded', file, chunkArgs);
+
+ // Stop upload
+ if (chunkArgs.cancelled) {
+ file.status = plupload.FAILED;
+ return;
+ }
+
+ loaded += curChunkSize;
+
+ if (++chunk >= chunks) {
+ file.status = plupload.DONE;
+ up.trigger('FileUploaded', file, {
+ response : req.responseText,
+ status : req.status
+ });
+ } else {
+ uploadNextChunk();
+ }
+ } else {
+ up.trigger('Error', {
+ code : plupload.HTTP_ERROR,
+ message : plupload.translate('HTTP Error.'),
+ file : file,
+ chunk : chunk,
+ chunks : chunks,
+ status : req.status
+ });
+ }
+ }
+ };
+
+ if (chunk < chunks) {
+ sendBinaryBlob(blobs[file.id].slice(chunk * chunkSize, curChunkSize));
+ }
+ }
+
+ // Start uploading chunks
+ uploadNextChunk();
+ });
+
+ uploader.bind("Destroy", function(up) {
+ var name, element,
+ elements = {
+ browseButton: up.settings.browse_button,
+ dropElm: up.settings.drop_element
+ };
+
+ // Unbind event handlers
+ for (name in elements) {
+ element = document.getElementById(elements[name]);
+ if (element) {
+ plupload.removeAllEvents(element, up.id);
+ }
+ }
+ });
+
+
+ callback({success : true});
+ }
+ });
+})(window, document, plupload);
diff --git a/public/javascripts/plupload/src/javascript/plupload.html4.js b/public/javascripts/plupload/src/javascript/plupload.html4.js
new file mode 100644
index 0000000..fc7962d
--- /dev/null
+++ b/public/javascripts/plupload/src/javascript/plupload.html4.js
@@ -0,0 +1,398 @@
+/**
+ * plupload.html4.js
+ *
+ * Copyright 2010, Ryan Demmer
+ * Copyright 2009, Moxiecode Systems AB
+ * Released under GPL License.
+ *
+ * License: http://www.plupload.com/license
+ * Contributing: http://www.plupload.com/contributing
+ */
+
+// JSLint defined globals
+/*global plupload:false, window:false */
+
+(function(window, document, plupload, undef) {
+ function getById(id) {
+ return document.getElementById(id);
+ }
+
+ /**
+ * HTML4 implementation. This runtime has no special features it uses an form that posts files into an hidden iframe.
+ *
+ * @static
+ * @class plupload.runtimes.Html4
+ * @extends plupload.Runtime
+ */
+ plupload.runtimes.Html4 = plupload.addRuntime("html4", {
+ /**
+ * Returns a list of supported features for the runtime.
+ *
+ * @return {Object} Name/value object with supported features.
+ */
+ getFeatures : function() {
+ // Only multipart feature
+ return {
+ multipart: true,
+
+ /* WebKit let you trigger file dialog programmatically while FF and Opera - do not, so we
+ sniff for it here... probably not that good idea, but impossibillity of controlling cursor style
+ on top of add files button obviously feels even worse */
+ canOpenDialog: navigator.userAgent.indexOf('WebKit') !== -1
+ };
+ },
+
+ /**
+ * Initializes the upload runtime.
+ *
+ * @method init
+ * @param {plupload.Uploader} uploader Uploader instance that needs to be initialized.
+ * @param {function} callback Callback to execute when the runtime initializes or fails to initialize. If it succeeds an object with a parameter name success will be set to true.
+ */
+ init : function(uploader, callback) {
+ uploader.bind("Init", function(up) {
+ var container = document.body, iframe, url = "javascript", currentFile,
+ input, currentFileId, fileIds = [], IE = /MSIE/.test(navigator.userAgent), mimes = [],
+ filters = up.settings.filters, i, ext, type, y;
+
+ // Convert extensions to mime types list
+ for (i = 0; i < filters.length; i++) {
+ ext = filters[i].extensions.split(/,/);
+
+ for (y = 0; y < ext.length; y++) {
+ type = plupload.mimeTypes[ext[y]];
+
+ if (type) {
+ mimes.push(type);
+ }
+ }
+ }
+
+ mimes = mimes.join(',');
+
+ function createForm() {
+ var form, input, bgcolor, browseButton;
+
+ // Setup unique id for form
+ currentFileId = plupload.guid();
+
+ // Save id for Destroy handler
+ fileIds.push(currentFileId);
+
+ // Create form
+ form = document.createElement('form');
+ form.setAttribute('id', 'form_' + currentFileId);
+ form.setAttribute('method', 'post');
+ form.setAttribute('enctype', 'multipart/form-data');
+ form.setAttribute('encoding', 'multipart/form-data');
+ form.setAttribute("target", up.id + '_iframe');
+ form.style.position = 'absolute';
+
+ // Create input and set attributes
+ input = document.createElement('input');
+ input.setAttribute('id', 'input_' + currentFileId);
+ input.setAttribute('type', 'file');
+ input.setAttribute('accept', mimes);
+ input.setAttribute('size', 1);
+
+ browseButton = getById(up.settings.browse_button);
+
+ // Route click event to input element programmatically, if possible
+ if (up.features.canOpenDialog && browseButton) {
+ plupload.addEvent(getById(up.settings.browse_button), 'click', function(e) {
+ input.click();
+ e.preventDefault();
+ }, up.id);
+ }
+
+ // Set input styles
+ plupload.extend(input.style, {
+ width : '100%',
+ height : '100%',
+ opacity : 0,
+ fontSize: '2em' // force input element to be bigger then needed to occupy whole space
+ });
+
+ plupload.extend(form.style, {
+ overflow: 'hidden'
+ });
+
+ // Show the container if shim_bgcolor is specified
+ bgcolor = up.settings.shim_bgcolor;
+ if (bgcolor) {
+ form.style.background = bgcolor;
+ }
+
+ // no opacity in IE
+ if (IE) {
+ plupload.extend(input.style, {
+ filter : "alpha(opacity=0)"
+ });
+ }
+
+ // add change event
+ plupload.addEvent(input, 'change', function(e) {
+ var element = e.target, name, files = [], topElement;
+
+ if (element.value) {
+ getById('form_' + currentFileId).style.top = -0xFFFFF + "px";
+
+ // Get file name
+ name = element.value.replace(/\\/g, '/');
+ name = name.substring(name.length, name.lastIndexOf('/') + 1);
+
+ // Push files
+ files.push(new plupload.File(currentFileId, name));
+
+ // Clean-up events - they won't be needed anymore
+ if (!up.features.canOpenDialog) {
+ plupload.removeAllEvents(form, up.id);
+ } else {
+ plupload.removeEvent(browseButton, 'click', up.id);
+ }
+ plupload.removeEvent(input, 'change', up.id);
+
+ // Create and position next form
+ createForm();
+
+ // Fire FilesAdded event
+ if (files.length) {
+ uploader.trigger("FilesAdded", files);
+ }
+ }
+ }, up.id);
+
+ // append to container
+ form.appendChild(input);
+ container.appendChild(form);
+
+ up.refresh();
+ }
+
+
+ function createIframe() {
+ var temp = document.createElement('div');
+
+ // Create iframe using a temp div since IE 6 won't be able to set the name using setAttribute or iframe.name
+ temp.innerHTML = '';
+ iframe = temp.firstChild;
+ container.appendChild(iframe);
+
+ // Add IFrame onload event
+ plupload.addEvent(iframe, 'load', function(e) {
+ var n = e.target, el, result;
+
+ // Ignore load event if there is no file
+ if (!currentFile) {
+ return;
+ }
+
+ try {
+ el = n.contentWindow.document || n.contentDocument || window.frames[n.id].document;
+ } catch (ex) {
+ // Probably a permission denied error
+ up.trigger('Error', {
+ code : plupload.SECURITY_ERROR,
+ message : plupload.translate('Security error.'),
+ file : currentFile
+ });
+
+ return;
+ }
+
+ // Get result
+ result = el.documentElement.innerText || el.documentElement.textContent;
+
+ // Assume no error
+ if (result) {
+ currentFile.status = plupload.DONE;
+ currentFile.loaded = 1025;
+ currentFile.percent = 100;
+
+ up.trigger('UploadProgress', currentFile);
+ up.trigger('FileUploaded', currentFile, {
+ response : result
+ });
+ }
+ }, up.id);
+ } // end createIframe
+
+ if (up.settings.container) {
+ container = getById(up.settings.container);
+ container.style.position = 'relative';
+ }
+
+ // Upload file
+ up.bind("UploadFile", function(up, file) {
+ var form, input;
+
+ // File upload finished
+ if (file.status == plupload.DONE || file.status == plupload.FAILED || up.state == plupload.STOPPED) {
+ return;
+ }
+
+ // Get the form and input elements
+ form = getById('form_' + file.id);
+ input = getById('input_' + file.id);
+
+ // Set input element name attribute which allows it to be submitted
+ input.setAttribute('name', up.settings.file_data_name);
+
+ // Store action
+ form.setAttribute("action", up.settings.url);
+
+ // Append multipart parameters
+ plupload.each(plupload.extend({name : file.target_name || file.name}, up.settings.multipart_params), function(value, name) {
+ var hidden = document.createElement('input');
+
+ plupload.extend(hidden, {
+ type : 'hidden',
+ name : name,
+ value : value
+ });
+
+ form.insertBefore(hidden, form.firstChild);
+ });
+
+ currentFile = file;
+
+ // Hide the current form
+ getById('form_' + currentFileId).style.top = -0xFFFFF + "px";
+
+ form.submit();
+ form.parentNode.removeChild(form);
+ });
+
+
+
+ up.bind('FileUploaded', function(up) {
+ up.refresh(); // just to get the form back on top of browse_button
+ });
+
+ up.bind('StateChanged', function(up) {
+ if (up.state == plupload.STARTED) {
+ createIframe();
+ }
+
+ if (up.state == plupload.STOPPED) {
+ window.setTimeout(function() {
+ plupload.removeEvent(iframe, 'load', up.id);
+ iframe.parentNode.removeChild(iframe);
+ }, 0);
+ }
+ });
+
+ // Refresh button, will reposition the input form
+ up.bind("Refresh", function(up) {
+ var browseButton, topElement, hoverClass, activeClass, browsePos, browseSize, inputContainer, inputFile, pzIndex;
+
+ browseButton = getById(up.settings.browse_button);
+ if (browseButton) {
+ browsePos = plupload.getPos(browseButton, getById(up.settings.container));
+ browseSize = plupload.getSize(browseButton);
+ inputContainer = getById('form_' + currentFileId);
+ inputFile = getById('input_' + currentFileId);
+
+ plupload.extend(inputContainer.style, {
+ top : browsePos.y + 'px',
+ left : browsePos.x + 'px',
+ width : browseSize.w + 'px',
+ height : browseSize.h + 'px'
+ });
+
+ // for IE and WebKit place input element underneath the browse button and route onclick event
+ // TODO: revise when browser support for this feature will change
+ if (up.features.canOpenDialog) {
+ pzIndex = parseInt(browseButton.parentNode.style.zIndex, 10);
+
+ if (isNaN(pzIndex)) {
+ pzIndex = 0;
+ }
+
+ plupload.extend(browseButton.style, {
+ position : 'relative',
+ zIndex : pzIndex
+ });
+
+ plupload.extend(inputContainer.style, {
+ zIndex : pzIndex - 1
+ });
+ }
+
+ /* Since we have to place input[type=file] on top of the browse_button for some browsers (FF, Opera),
+ browse_button loses interactivity, here we try to neutralize this issue highlighting browse_button
+ with a special class
+ TODO: needs to be revised as things will change */
+ hoverClass = up.settings.browse_button_hover;
+ activeClass = up.settings.browse_button_active;
+ topElement = up.features.canOpenDialog ? browseButton : inputContainer;
+
+ if (hoverClass) {
+ plupload.addEvent(topElement, 'mouseover', function() {
+ plupload.addClass(browseButton, hoverClass);
+ }, up.id);
+ plupload.addEvent(topElement, 'mouseout', function() {
+ plupload.removeClass(browseButton, hoverClass);
+ }, up.id);
+ }
+
+ if (activeClass) {
+ plupload.addEvent(topElement, 'mousedown', function() {
+ plupload.addClass(browseButton, activeClass);
+ }, up.id);
+ plupload.addEvent(document.body, 'mouseup', function() {
+ plupload.removeClass(browseButton, activeClass);
+ }, up.id);
+ }
+ }
+ });
+
+ // Remove files
+ uploader.bind("FilesRemoved", function(up, files) {
+ var i, n;
+
+ for (i = 0; i < files.length; i++) {
+ n = getById('form_' + files[i].id);
+ if (n) {
+ n.parentNode.removeChild(n);
+ }
+ }
+ });
+
+
+ // Completely destroy the runtime
+ uploader.bind("Destroy", function(up) {
+ var name, element, form,
+ elements = {
+ inputContainer: 'form_' + currentFileId,
+ inputFile: 'input_' + currentFileId,
+ browseButton: up.settings.browse_button
+ };
+
+ // Unbind event handlers
+ for (name in elements) {
+ element = getById(elements[name]);
+ if (element) {
+ plupload.removeAllEvents(element, up.id);
+ }
+ }
+ plupload.removeAllEvents(document.body, up.id);
+
+ // Remove mark-up
+ plupload.each(fileIds, function(id, i) {
+ form = getById('form_' + id);
+ if (form) {
+ container.removeChild(form);
+ }
+ });
+
+ });
+
+ // Create initial form
+ createForm();
+ });
+
+ callback({success : true});
+ }
+ });
+})(window, document, plupload);
diff --git a/public/javascripts/plupload/src/javascript/plupload.html5.js b/public/javascripts/plupload/src/javascript/plupload.html5.js
new file mode 100644
index 0000000..e7ce9af
--- /dev/null
+++ b/public/javascripts/plupload/src/javascript/plupload.html5.js
@@ -0,0 +1,1190 @@
+/**
+ * plupload.html5.js
+ *
+ * Copyright 2009, Moxiecode Systems AB
+ * Released under GPL License.
+ *
+ * License: http://www.plupload.com/license
+ * Contributing: http://www.plupload.com/contributing
+ */
+
+// JSLint defined globals
+/*global plupload:false, File:false, window:false, atob:false, FormData:false, FileReader:false, ArrayBuffer:false, Uint8Array:false, BlobBuilder:false, unescape:false */
+
+(function(window, document, plupload, undef) {
+ var fakeSafariDragDrop, ExifParser;
+
+ function readFileAsDataURL(file, callback) {
+ var reader;
+
+ // Use FileReader if it's available
+ if ("FileReader" in window) {
+ reader = new FileReader();
+ reader.readAsDataURL(file);
+ reader.onload = function() {
+ callback(reader.result);
+ };
+ } else {
+ return callback(file.getAsDataURL());
+ }
+ }
+
+ function readFileAsBinary(file, callback) {
+ var reader;
+
+ // Use FileReader if it's available
+ if ("FileReader" in window) {
+ reader = new FileReader();
+ reader.readAsBinaryString(file);
+ reader.onload = function() {
+ callback(reader.result);
+ };
+ } else {
+ return callback(file.getAsBinary());
+ }
+ }
+
+ function scaleImage(image_file, max_width, max_height, mime, callback) {
+ var canvas, context, img, scale;
+
+ readFileAsDataURL(image_file, function(data) {
+ // Setup canvas and context
+ canvas = document.createElement("canvas");
+ canvas.style.display = 'none';
+ document.body.appendChild(canvas);
+ context = canvas.getContext('2d');
+
+ // Load image
+ img = new Image();
+ img.onload = function() {
+ var width, height, percentage, APP1, parser;
+
+ scale = Math.min(max_width / img.width, max_height / img.height);
+
+ if (scale < 1) {
+ width = Math.round(img.width * scale);
+ height = Math.round(img.height * scale);
+
+ // Scale image and canvas
+ canvas.width = width;
+ canvas.height = height;
+ context.drawImage(img, 0, 0, width, height);
+
+ // Get original EXIF info
+ parser = new ExifParser();
+ parser.init(atob(data.substring(data.indexOf('base64,') + 7)));
+ APP1 = parser.APP1({width: width, height: height});
+
+ // Remove data prefix information and grab the base64 encoded data and decode it
+ data = canvas.toDataURL(mime);
+ data = data.substring(data.indexOf('base64,') + 7);
+ data = atob(data);
+
+ // Restore EXIF info to scaled image
+ if (APP1) {
+ parser.init(data);
+ parser.setAPP1(APP1);
+ data = parser.getBinary();
+ }
+
+ // Remove canvas and execute callback with decoded image data
+ canvas.parentNode.removeChild(canvas);
+ callback({success : true, data : data});
+ } else {
+ // Image does not need to be resized
+ callback({success : false});
+ }
+ };
+
+ img.src = data;
+ });
+ }
+
+ /**
+ * HMTL5 implementation. This runtime supports these features: dragdrop, jpgresize, pngresize.
+ *
+ * @static
+ * @class plupload.runtimes.Html5
+ * @extends plupload.Runtime
+ */
+ plupload.runtimes.Html5 = plupload.addRuntime("html5", {
+ /**
+ * Returns a list of supported features for the runtime.
+ *
+ * @return {Object} Name/value object with supported features.
+ */
+ getFeatures : function() {
+ var xhr, hasXhrSupport, hasProgress, dataAccessSupport, sliceSupport, win = window;
+
+ hasXhrSupport = hasProgress = dataAccessSupport = sliceSupport = false;
+
+ /* Introduce sendAsBinary for cutting edge WebKit builds that have support for BlobBuilder and typed arrays:
+ credits: http://javascript0.org/wiki/Portable_sendAsBinary,
+ more info: http://code.google.com/p/chromium/issues/detail?id=35705
+ */
+ if (win.Uint8Array && win.ArrayBuffer && !XMLHttpRequest.prototype.sendAsBinary) {
+ XMLHttpRequest.prototype.sendAsBinary = function(datastr) {
+ var data, ui8a, bb, blob;
+
+ data = new ArrayBuffer(datastr.length);
+ ui8a = new Uint8Array(data, 0);
+
+ for (var i=0; i 0 && navigator.vendor.indexOf('Apple') !== -1;
+
+ return {
+ // Detect drag/drop file support by sniffing, will try to find a better way
+ html5: hasXhrSupport, // This is a special one that we check inside the init call
+ dragdrop: win.mozInnerScreenX !== undef || sliceSupport || fakeSafariDragDrop,
+ jpgresize: dataAccessSupport,
+ pngresize: dataAccessSupport,
+ multipart: dataAccessSupport || !!win.FileReader || !!win.FormData,
+ progress: hasProgress,
+ chunking: sliceSupport || dataAccessSupport,
+
+ /* WebKit let you trigger file dialog programmatically while FF and Opera - do not, so we
+ sniff for it here... probably not that good idea, but impossibillity of controlling cursor style
+ on top of add files button obviously feels even worse */
+ canOpenDialog: navigator.userAgent.indexOf('WebKit') !== -1
+ };
+ },
+
+ /**
+ * Initializes the upload runtime.
+ *
+ * @method init
+ * @param {plupload.Uploader} uploader Uploader instance that needs to be initialized.
+ * @param {function} callback Callback to execute when the runtime initializes or fails to initialize. If it succeeds an object with a parameter name success will be set to true.
+ */
+ init : function(uploader, callback) {
+ var html5files = {}, features;
+
+ function addSelectedFiles(native_files) {
+ var file, i, files = [], id, fileNames = {};
+
+ // Add the selected files to the file queue
+ for (i = 0; i < native_files.length; i++) {
+ file = native_files[i];
+
+ // Safari on Windows will add first file from dragged set multiple times
+ // @see: https://bugs.webkit.org/show_bug.cgi?id=37957
+ if (fileNames[file.name]) {
+ continue;
+ }
+ fileNames[file.name] = true;
+
+ // Store away gears blob internally
+ id = plupload.guid();
+ html5files[id] = file;
+
+ // Expose id, name and size
+ files.push(new plupload.File(id, file.fileName, file.fileSize || file.size)); // File.fileSize depricated
+ }
+
+ // Trigger FilesAdded event if we added any
+ if (files.length) {
+ uploader.trigger("FilesAdded", files);
+ }
+ }
+
+ // No HTML5 upload support
+ features = this.getFeatures();
+ if (!features.html5) {
+ callback({success : false});
+ return;
+ }
+
+ uploader.bind("Init", function(up) {
+ var inputContainer, browseButton, mimes = [], i, y, filters = up.settings.filters, ext, type, container = document.body, inputFile;
+
+ // Create input container and insert it at an absolute position within the browse button
+ inputContainer = document.createElement('div');
+ inputContainer.id = up.id + '_html5_container';
+
+ // Convert extensions to mime types list
+ for (i = 0; i < filters.length; i++) {
+ ext = filters[i].extensions.split(/,/);
+
+ for (y = 0; y < ext.length; y++) {
+ type = plupload.mimeTypes[ext[y]];
+
+ if (type) {
+ mimes.push(type);
+ }
+ }
+ }
+
+ plupload.extend(inputContainer.style, {
+ position : 'absolute',
+ background : uploader.settings.shim_bgcolor || 'transparent',
+ width : '100px',
+ height : '100px',
+ overflow : 'hidden',
+ zIndex : 99999,
+ opacity : uploader.settings.shim_bgcolor ? '' : 0 // Force transparent if bgcolor is undefined
+ });
+
+ inputContainer.className = 'plupload html5';
+
+ if (uploader.settings.container) {
+ container = document.getElementById(uploader.settings.container);
+ container.style.position = 'relative';
+ }
+
+ container.appendChild(inputContainer);
+
+ // Insert the input inside the input container
+ inputContainer.innerHTML = '' +
+ ' ';
+
+ function getSilverlightObj() {
+ return document.getElementById(uploader.id + '_silverlight').content.Upload;
+ }
+
+ uploader.bind("Silverlight:Init", function() {
+ var selectedFiles, lookup = {};
+
+ // Prevent eventual reinitialization of the instance
+ if (initialized[uploader.id]) {
+ return;
+ }
+
+ initialized[uploader.id] = true;
+
+ uploader.bind("Silverlight:StartSelectFiles", function(up) {
+ selectedFiles = [];
+ });
+
+ uploader.bind("Silverlight:SelectFile", function(up, sl_id, name, size) {
+ var id;
+
+ // Store away silverlight ids
+ id = plupload.guid();
+ lookup[id] = sl_id;
+ lookup[sl_id] = id;
+
+ // Expose id, name and size
+ selectedFiles.push(new plupload.File(id, name, size));
+ });
+
+ uploader.bind("Silverlight:SelectSuccessful", function() {
+ // Trigger FilesAdded event if we added any
+ if (selectedFiles.length) {
+ uploader.trigger("FilesAdded", selectedFiles);
+ }
+ });
+
+ uploader.bind("Silverlight:UploadChunkError", function(up, file_id, chunk, chunks, message) {
+ uploader.trigger("Error", {
+ code : plupload.IO_ERROR,
+ message : 'IO Error.',
+ details : message,
+ file : up.getFile(lookup[file_id])
+ });
+ });
+
+ uploader.bind("Silverlight:UploadFileProgress", function(up, sl_id, loaded, total) {
+ var file = up.getFile(lookup[sl_id]);
+
+ if (file.status != plupload.FAILED) {
+ file.size = total;
+ file.loaded = loaded;
+
+ up.trigger('UploadProgress', file);
+ }
+ });
+
+ uploader.bind("Refresh", function(up) {
+ var browseButton, browsePos, browseSize;
+
+ browseButton = document.getElementById(up.settings.browse_button);
+ if (browseButton) {
+ browsePos = plupload.getPos(browseButton, document.getElementById(up.settings.container));
+ browseSize = plupload.getSize(browseButton);
+
+ plupload.extend(document.getElementById(up.id + '_silverlight_container').style, {
+ top : browsePos.y + 'px',
+ left : browsePos.x + 'px',
+ width : browseSize.w + 'px',
+ height : browseSize.h + 'px'
+ });
+ }
+ });
+
+ uploader.bind("Silverlight:UploadChunkSuccessful", function(up, sl_id, chunk, chunks, text) {
+ var chunkArgs, file = up.getFile(lookup[sl_id]);
+
+ chunkArgs = {
+ chunk : chunk,
+ chunks : chunks,
+ response : text
+ };
+
+ up.trigger('ChunkUploaded', file, chunkArgs);
+
+ // Stop upload if file is maked as failed
+ if (file.status != plupload.FAILED) {
+ getSilverlightObj().UploadNextChunk();
+ }
+
+ // Last chunk then dispatch FileUploaded event
+ if (chunk == chunks - 1) {
+ file.status = plupload.DONE;
+
+ up.trigger('FileUploaded', file, {
+ response : text
+ });
+ }
+ });
+
+ uploader.bind("Silverlight:UploadSuccessful", function(up, sl_id, response) {
+ var file = up.getFile(lookup[sl_id]);
+
+ file.status = plupload.DONE;
+
+ up.trigger('FileUploaded', file, {
+ response : response
+ });
+ });
+
+ uploader.bind("FilesRemoved", function(up, files) {
+ var i;
+
+ for (i = 0; i < files.length; i++) {
+ getSilverlightObj().RemoveFile(lookup[files[i].id]);
+ }
+ });
+
+ uploader.bind("UploadFile", function(up, file) {
+ var settings = up.settings, resize = settings.resize || {};
+
+ getSilverlightObj().UploadFile(
+ lookup[file.id],
+ up.settings.url,
+ jsonSerialize({
+ name : file.target_name || file.name,
+ mime : plupload.mimeTypes[file.name.replace(/^.+\.([^.]+)/, '$1')] || 'application/octet-stream',
+ chunk_size : settings.chunk_size,
+ image_width : resize.width,
+ image_height : resize.height,
+ image_quality : resize.quality || 90,
+ multipart : !!settings.multipart,
+ multipart_params : settings.multipart_params || {},
+ file_data_name : settings.file_data_name,
+ headers : settings.headers
+ })
+ );
+ });
+
+
+ uploader.bind('Silverlight:MouseEnter', function(up) {
+ var browseButton, hoverClass;
+
+ browseButton = document.getElementById(uploader.settings.browse_button);
+ hoverClass = up.settings.browse_button_hover;
+
+ if (browseButton && hoverClass) {
+ plupload.addClass(browseButton, hoverClass);
+ }
+ });
+
+ uploader.bind('Silverlight:MouseLeave', function(up) {
+ var browseButton, hoverClass;
+
+ browseButton = document.getElementById(uploader.settings.browse_button);
+ hoverClass = up.settings.browse_button_hover;
+
+ if (browseButton && hoverClass) {
+ plupload.removeClass(browseButton, hoverClass);
+ }
+ });
+
+ uploader.bind('Silverlight:MouseLeftButtonDown', function(up) {
+ var browseButton, activeClass;
+
+ browseButton = document.getElementById(uploader.settings.browse_button);
+ activeClass = up.settings.browse_button_active;
+
+ if (browseButton && activeClass) {
+ plupload.addClass(browseButton, activeClass);
+
+ // Make sure that browse_button has active state removed from it
+ plupload.addEvent(document.body, 'mouseup', function() {
+ plupload.removeClass(browseButton, activeClass);
+ });
+ }
+ });
+
+ uploader.bind('Sliverlight:StartSelectFiles', function(up) {
+ var browseButton, activeClass;
+
+ browseButton = document.getElementById(uploader.settings.browse_button);
+ activeClass = up.settings.browse_button_active;
+
+ if (browseButton && activeClass) {
+ plupload.removeClass(browseButton, activeClass);
+ }
+ });
+
+ uploader.bind("Destroy", function(up) {
+ var silverlightContainer;
+
+ plupload.removeAllEvents(document.body, up.id);
+
+ delete initialized[up.id];
+ delete uploadInstances[up.id];
+
+ silverlightContainer = document.getElementById(up.id + '_silverlight_container');
+ if (silverlightContainer) {
+ container.removeChild(silverlightContainer);
+ }
+ });
+
+ callback({success : true});
+ });
+ }
+ });
+})(window, document, plupload);