protected void SendOutPDF(System.IO.MemoryStream PDFData)
        {
            // Clear response content & headers
            Response.Clear();
            Response.ClearContent();
            Response.ClearHeaders();
            Response.ContentType = "application/pdf";
            Response.Charset = string.Empty;
            Response.Cache.SetCacheability(System.Web.HttpCacheability.Public);
            Response.AddHeader("Content-Disposition",
                "attachment; filename=Ticket.pdf");

            Response.OutputStream.Write(PDFData.GetBuffer(), 0, PDFData.GetBuffer().Length);
            Response.OutputStream.Flush();
            Response.OutputStream.Close();
            Response.End();
        }
Beispiel #2
0
 private static char[] GetChars(System.IO.MemoryStream b, Encoding e)
 {
     return e.GetChars(b.GetBuffer(), 0, (int)b.Length);
 }
Beispiel #3
0
 public static float[] FloatArrayFromStream(System.IO.MemoryStream stream)
 {
     return FloatArrayFromByteArray(stream.GetBuffer());
 }
 /// <summary> Decodes the input char sequence into the output byte sequence.  Before
 /// calling this method, ensure that the output ByteBuffer has sufficient
 /// capacity by calling {@link #GetDecodedLength(java.nio.CharBuffer)}.
 /// 
 /// </summary>
 /// <param name="input">The char sequence to decode
 /// </param>
 /// <param name="output">Where the byte sequence decoding result will go.  The limit
 /// is set to one past the position of the final char.
 /// </param>
 /// <throws>  IllegalArgumentException If either the input or the output buffer </throws>
 /// <summary>  is not backed by an array
 /// </summary>
 public static void Decode(System.IO.MemoryStream input, System.IO.MemoryStream output)
 {
     // if (input.hasArray() && output.hasArray()) // {{Aroush-2.9}}
     {
         // int numInputChars = input.limit() - input.arrayOffset() - 1; // {{Aroush-2.9}}
         long numInputChars = input.Capacity - input.Position - 1;
         int numOutputBytes = GetDecodedLength(input);
         // output.limit(numOutputBytes + output.arrayOffset()); // Set output final pos + 1 // {{Aroush-2.9}}
         output.Capacity = (int) (numOutputBytes + output.Position);
         // output.position(0); // {{Aroush-2.9}}
         output.Position = 0;
         // byte[] outputArray = output.array(); // {{Aroush-2.9}}
         byte[] outputArray = output.GetBuffer();
         // char[] inputArray = input.array(); // {{Aroush-2.9}}
         byte[] inputArray = (byte[]) input.GetBuffer();
         if (numOutputBytes > 0)
         {
             int caseNum = 0;
             // int outputByteNum = output.arrayOffset(); // {{Aroush-2.9}}
             long outputByteNum = output.Position;
             // int inputCharNum = input.arrayOffset(); // {{Aroush-2.9}}
             long inputCharNum = input.Position;
             short inputChar;
             CodingCase codingCase;
             for (; inputCharNum < numInputChars - 1; ++inputCharNum)
             {
                 codingCase = CODING_CASES[caseNum];
                 inputChar = (short) inputArray[inputCharNum];
                 if (2 == codingCase.numBytes)
                 {
                     if (0 == caseNum)
                     {
                         outputArray[outputByteNum] = (byte) (SupportClass.Number.URShift(inputChar, codingCase.initialShift));
                     }
                     else
                     {
                         outputArray[outputByteNum] = (byte) (outputArray[outputByteNum] + (byte) (SupportClass.Number.URShift(inputChar, codingCase.initialShift)));
                     }
                     outputArray[outputByteNum + 1] = (byte) ((inputChar & codingCase.finalMask) << codingCase.finalShift);
                 }
                 else
                 {
                     // numBytes is 3
                     outputArray[outputByteNum] = (byte) (outputArray[outputByteNum] + (byte) (SupportClass.Number.URShift(inputChar, codingCase.initialShift)));
                     outputArray[outputByteNum + 1] = (byte) (SupportClass.Number.URShift((inputChar & codingCase.middleMask), codingCase.middleShift));
                     outputArray[outputByteNum + 2] = (byte) ((inputChar & codingCase.finalMask) << codingCase.finalShift);
                 }
                 outputByteNum += codingCase.advanceBytes;
                 if (++caseNum == CODING_CASES.Length)
                 {
                     caseNum = 0;
                 }
             }
             // Handle final char
             inputChar = (short) inputArray[inputCharNum];
             codingCase = CODING_CASES[caseNum];
             if (0 == caseNum)
             {
                 outputArray[outputByteNum] = 0;
             }
             outputArray[outputByteNum] = (byte) (outputArray[outputByteNum] + (byte) (SupportClass.Number.URShift(inputChar, codingCase.initialShift)));
             long bytesLeft = numOutputBytes - outputByteNum;
             if (bytesLeft > 1)
             {
                 if (2 == codingCase.numBytes)
                 {
                     outputArray[outputByteNum + 1] = (byte) (SupportClass.Number.URShift((inputChar & codingCase.finalMask), codingCase.finalShift));
                 }
                 else
                 {
                     // numBytes is 3
                     outputArray[outputByteNum + 1] = (byte) (SupportClass.Number.URShift((inputChar & codingCase.middleMask), codingCase.middleShift));
                     if (bytesLeft > 2)
                     {
                         outputArray[outputByteNum + 2] = (byte) ((inputChar & codingCase.finalMask) << codingCase.finalShift);
                     }
                 }
             }
         }
     }
     // else // {{Aroush-2.9}}
     // {
     // 	throw new System.ArgumentException("Arguments must have backing arrays"); // {{Aroush-2.9}}
     // }
 }
        /// <summary> Encodes the input byte sequence into the output char sequence.  Before
        /// calling this method, ensure that the output CharBuffer has sufficient
        /// capacity by calling {@link #GetEncodedLength(java.nio.ByteBuffer)}.
        /// 
        /// </summary>
        /// <param name="input">The byte sequence to encode
        /// </param>
        /// <param name="output">Where the char sequence encoding result will go.  The limit
        /// is set to one past the position of the final char.
        /// </param>
        /// <throws>  IllegalArgumentException If either the input or the output buffer </throws>
        /// <summary>  is not backed by an array
        /// </summary>
        public static void Encode(System.IO.MemoryStream input, System.IO.MemoryStream output)
        {
            // if (input.hasArray() && output.hasArray()) // {{Aroush-2.9}}
            {
                // byte[] inputArray = input.array();   // {{Aroush-2.9}}
                byte[] inputArray = input.GetBuffer();
                // int inputOffset = input.arrayOffset(); // {{Aroush-2.9}}
                long inputOffset = input.Position;
                // int inputLength = input.limit() - inputOffset; // {{Aroush-2.9}}
                long inputLength = input.Capacity - inputOffset;
                // char[] outputArray = output.array(); // {{Aroush-2.9}}
                byte[] outputArray = output.GetBuffer();
                // int outputOffset = output.arrayOffset(); // {{Aroush-2.9}}
                long outputOffset = output.Position;
                int outputLength = GetEncodedLength(input);
                // output.limit(outputOffset + outputLength); // Set output final pos + 1 // {{Aroush-2.9}}
                output.Position = outputOffset + outputLength;
                // output.position(0); // {{Aroush-2.9}}
                output.Position = 0;
                if (inputLength > 0)
                {
                    long inputByteNum = inputOffset;
                    int caseNum = 0;
                    long outputCharNum = outputOffset;
                    CodingCase codingCase;
                    for (; inputByteNum + CODING_CASES[caseNum].numBytes <= inputLength; ++outputCharNum)
                    {
                        codingCase = CODING_CASES[caseNum];
                        if (2 == codingCase.numBytes)
                        {
                            outputArray[outputCharNum] = (byte) (((inputArray[inputByteNum] & 0xFF) << codingCase.initialShift) + ((SupportClass.Number.URShift((inputArray[inputByteNum + 1] & 0xFF), codingCase.finalShift)) & codingCase.finalMask) & (short) 0x7FFF);
                        }
                        else
                        {
                            // numBytes is 3
                            outputArray[outputCharNum] = (byte) (((inputArray[inputByteNum] & 0xFF) << codingCase.initialShift) + ((inputArray[inputByteNum + 1] & 0xFF) << codingCase.middleShift) + ((SupportClass.Number.URShift((inputArray[inputByteNum + 2] & 0xFF), codingCase.finalShift)) & codingCase.finalMask) & (short) 0x7FFF);
                        }
                        inputByteNum += codingCase.advanceBytes;
                        if (++caseNum == CODING_CASES.Length)
                        {
                            caseNum = 0;
                        }
                    }
                    // Produce final char (if any) and trailing count chars.
                    codingCase = CODING_CASES[caseNum];

                    if (inputByteNum + 1 < inputLength)
                    {
                        // codingCase.numBytes must be 3
                        outputArray[outputCharNum++] = (byte) ((((inputArray[inputByteNum] & 0xFF) << codingCase.initialShift) + ((inputArray[inputByteNum + 1] & 0xFF) << codingCase.middleShift)) & (short) 0x7FFF);
                        // Add trailing char containing the number of full bytes in final char
                        outputArray[outputCharNum++] = (byte) 1;
                    }
                    else if (inputByteNum < inputLength)
                    {
                        outputArray[outputCharNum++] = (byte) (((inputArray[inputByteNum] & 0xFF) << codingCase.initialShift) & (short) 0x7FFF);
                        // Add trailing char containing the number of full bytes in final char
                        outputArray[outputCharNum++] = caseNum == 0?(byte) 1:(byte) 0;
                    }
                    else
                    {
                        // No left over bits - last char is completely filled.
                        // Add trailing char containing the number of full bytes in final char
                        outputArray[outputCharNum++] = (byte) 1;
                    }
                }
            }
            // else // {{Aroush-2.9}}
            // {
            // 	throw new System.ArgumentException("Arguments must have backing arrays"); // {{Aroush-2.9}}
            // }
        }