C# Pdf.PdfDictionary類代碼示例

 /// <summary>
 /// Retrieves the specifed dictionary object as an object encoded with DCTDecode filter (JPEG).
 /// </summary>
 /// <param name="dictionary">The dictionary to extract the object from.</param>
 /// <returns>The image retrieve from the dictionary. If not found or an invalid image, then null is returned.</returns>
 private static Image ImageFromDCTDecode(PdfDictionary dictionary)
 {
   // DCTDecode a lossy filter based on the JPEG standard
   // We can just load directly from the stream.
   MemoryStream stream = new MemoryStream(dictionary.Stream.Value);
   return (Bitmap.FromStream(stream));
 }

        static bool ExportImage(PdfDictionary image, ref int count)
        {
            bool ret = false;
            try
            {
                string filter = image.Elements.GetName("/Filter");
            
                switch (filter)
                {
                    case "/DCTDecode":
                        ret = ExportJpegImage(image, ref count);
                        break;
                    /* case "/FlateDecode":
                            ExportAsPngImage(image, ref count);
                            break;*/
                    default:
                        ret = true;
                        break;
                }
            }
            catch (Exception)//in case its an object array so we need first to decompress it
            {
                byte[] stream = image.Stream.Value;

                PdfSharp.Pdf.Filters.FlateDecode aug = new PdfSharp.Pdf.Filters.FlateDecode();
                stream = aug.Decode(stream);
                ret = ExportJpegImage(stream, ref count);
            }

            return ret;
        }

 static void ExportJpegImage(PdfDictionary image, ref int count)
 {
     byte[] stream = image.Stream.Value;
     using (FileStream fs = new FileStream(String.Format("Image{0}.jpg", count++), FileMode.Create, FileAccess.Write))
     {
         fs.Write(stream, 0, stream.Length);
     }
 }

 /// <summary>
 /// </summary>
 public PdfContentWriter(DocumentRenderingContext context, PdfDictionary contentDictionary)
 {
   if (!(contentDictionary is IContentStream))
     throw new ArgumentException("contentDictionary must implement IContentStream.");
   this.context = context;
   this.contentDictionary = contentDictionary;
   this.contentStreamDictionary = (IContentStream)contentDictionary;
   this.renderMode = RenderMode.Default;
   //this.colorMode = page.document.Options.ColorMode;
   //this.options = options;
   this.content = new StringBuilder();
   this.graphicsState = new PdfGraphicsState(this);
 }

 internal PdfPage(PdfDictionary dict)
     : base(dict)
 {
     // Set Orientation depending on /Rotate.
     int rotate = Elements.GetInteger(InheritablePageKeys.Rotate);
     if (Math.Abs((rotate / 90)) % 2 == 1)
         _orientation = PageOrientation.Landscape;
 }

        static void ExportImage(PdfDictionary image, ref int count)
        {
            string filter = image.Elements.GetName("/Filter");
            switch (filter)
            {
                case "/DCTDecode":
                    ExportJpegImage(image, ref count);
                    break;

                case "/FlateDecode":
                    ExportAsPngImage(image, ref count);
                    break;
            }

        }

        static void ExportJpegImage(PdfDictionary image, ref int count)
        {

            // Fortunately JPEG has native support in PDF and exporting an image is just writing the stream to a file.

            byte[] stream = image.Stream.Value;

            FileStream fs = new FileStream(String.Format("F:\\Image{0}.jpeg", count++), FileMode.Create, FileAccess.Write);
            
            BinaryWriter bw = new BinaryWriter(fs);

            bw.Write(stream);

            bw.Close();

        }

    public PdfCIDFont(PdfDocument document, PdfFontDescriptor fontDescriptor, byte[] fontData)
      : base(document)
    {
      Elements.SetName(Keys.Type, "/Font");
      Elements.SetName(Keys.Subtype, "/CIDFontType2");
      PdfDictionary cid = new PdfDictionary();
      cid.Elements.SetString("/Ordering", "Identity");
      cid.Elements.SetString("/Registry", "Adobe");
      cid.Elements.SetInteger("/Supplement", 0);
      Elements.SetValue(Keys.CIDSystemInfo, cid);

      this.fontDescriptor = fontDescriptor;
      Owner.irefTable.Add(fontDescriptor);
      Elements[Keys.FontDescriptor] = fontDescriptor.Reference;

      FontEncoding = PdfFontEncoding.Unicode;
      FontEmbedding = PdfFontEmbedding.Always;
    }

        static void ExportImage(PdfDictionary image, ref int count)
        {
            string filter = image.Elements.GetName(PdfImage.Keys.Filter);
            switch (filter)
            {
                case "/DCTDecode":
                    ExportJpegImage(image, ref count);
                    break;

                case "":
                case "/FlateDecode":
                    ExportUnfilterableImage(image, ref count);
                    break;

                case "/CCITTFaxDecode":
                case "/RunLengthDecode,":
                default:
                    throw new NotSupportedException();
            }
        }

 PdfDictionary CreateDictionary(Type type, PdfDictionary oldDictionary)
 {
   ConstructorInfo ctorInfo;
   PdfDictionary dict;
   if (oldDictionary == null)
   {
     // Use contstructor with signature 'Ctor(PdfDocument owner)'.
     ctorInfo = type.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
       null, new Type[] { typeof(PdfDocument) }, null);
     Debug.Assert(ctorInfo != null, "No appropriate constructor found for type: " + type.Name);
     dict = ctorInfo.Invoke(new object[] { this.owner.Owner }) as PdfDictionary;
   }
   else
   {
     // Use contstructor with signature 'Ctor(PdfDictionary dict)'.
     ctorInfo = type.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
       null, new Type[] { typeof(PdfDictionary) }, null);
     Debug.Assert(ctorInfo != null, "No appropriate constructor found for type: " + type.Name);
     dict = ctorInfo.Invoke(new object[] { oldDictionary }) as PdfDictionary;
   }
   return dict;
 }

        /// <summary>
        /// Add all inheritable values from the specified page to the specified values structure.
        /// </summary>
        internal static void InheritValues(PdfDictionary page, ref InheritedValues values)
        {
            PdfItem item = page.Elements[InheritablePageKeys.Resources];
            if (item != null)
            {
                PdfReference reference = item as PdfReference;
                if (reference != null)
                    values.Resources = (PdfDictionary)(reference.Value);
                else
                    values.Resources = (PdfDictionary)item;
            }

            item = page.Elements[InheritablePageKeys.MediaBox];
            if (item != null)
                values.MediaBox = new PdfRectangle(item);

            item = page.Elements[InheritablePageKeys.CropBox];
            if (item != null)
                values.CropBox = new PdfRectangle(item);

            item = page.Elements[InheritablePageKeys.Rotate];
            if (item != null)
            {
                if (item is PdfReference)
                    item = ((PdfReference)item).Value;
                values.Rotate = (PdfInteger)item;
            }
        }

 /// <summary>
 /// Initializes a new instance from an existing dictionary. Used for object type transformation.
 /// </summary>
 public PdfOutline(PdfDictionary dict)
     : base(dict)
 {
     Initialize();
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="PdfAnnotation"/> class.
 /// </summary>
 internal PdfAnnotation(PdfDictionary dict)
   : base(dict)
 {
 }

      /// <summary>
      /// Initializes the item based on the specified PdfDictionary.
      /// </summary>
      /// <param name="dictionary">The dictionary to use for initialization.</param>
      private void Initialize(PdfDictionary dictionary)
      {
        if (dictionary == null) throw new ArgumentNullException("dictionary", "The PDF dictionary item to extract image meta data from was null.");
        if (!dictionary.IsImage()) throw new ArgumentException("The specified dictionary does not represent an image.", "dictionary");

        Height = dictionary.Elements.GetInteger("/Height");
        Width = dictionary.Elements.GetInteger("/Width");
        BitsPerPixel = dictionary.Elements.GetInteger("/BitsPerComponent");
        Length = dictionary.Elements.GetInteger("/Length");

        PdfItem colorSpace = null;
        if (dictionary.Elements.TryGetValue("/ColorSpace", out colorSpace)) {
          ColorSpace = PdfDictionaryColorSpace.Parse(colorSpace);
        }
        else ColorSpace = new PdfRGBColorSpace(); // Default to RGB Color Space
      }

    /// <summary>
    /// Retrieves the specifed dictionary object as an object encoded with FlateDecode filter.
    /// </summary>
    /// <remarks>
    /// FlateDecode a commonly used filter based on the zlib/deflate algorithm (a.k.a. gzip, but not zip) 
    /// defined in RFC 1950 and RFC 1951; introduced in PDF 1.2; it can use one of two groups of predictor 
    /// functions for more compact zlib/deflate compression: Predictor 2 from the TIFF 6.0 specification 
    /// and predictors (filters) from the PNG specification (RFC 2083)
    /// </remarks>
    /// <param name="dictionary">The dictionary to extract the object from.</param>
    /// <returns>The image retrieve from the dictionary. If not found or an invalid image, then null is returned.</returns>
    private static Image ImageFromFlateDecode(PdfDictionary dictionary)
    {
      PdfDictionaryImageMetaData imageData = new PdfDictionaryImageMetaData(dictionary);

      // FlateDecode can be either indexed or a traditional ColorSpace
      bool isIndexed = imageData.ColorSpace.IsIndexed;
      PixelFormat format = GetPixelFormat(imageData.ColorSpace, imageData.BitsPerPixel, isIndexed);

      Bitmap bitmap = new Bitmap(imageData.Width, imageData.Height, format);

      // If indexed, retrieve and assign the color palette for the item.
      if ((isIndexed) && (imageData.ColorSpace.IsRGB)) bitmap.Palette = ((PdfIndexedRGBColorSpace) imageData.ColorSpace).ToColorPalette();
      else if (imageData.ColorSpace is PdfGrayColorSpace) bitmap.Palette = ((PdfGrayColorSpace)imageData.ColorSpace).ToColorPalette(imageData.BitsPerPixel);

      // If not an indexed color, the .NET image component expects pixels to be in BGR order. However, our PDF stream is in RGB order.
      byte[] stream = (format == PixelFormat.Format24bppRgb) ? ConvertRGBStreamToBGR(dictionary.Stream.UnfilteredValue) : dictionary.Stream.UnfilteredValue;

      BitmapData bitmapData = bitmap.LockBits(new Rectangle(0, 0, imageData.Width, imageData.Height), ImageLockMode.WriteOnly, format);
      // We can't just copy the bytes directly; the BitmapData .NET class has a stride (padding) associated with it. 
      int bitsPerPixel = ((((int)format >> 8) & 0xFF));
      int length = (int)Math.Ceiling(bitmapData.Width * bitsPerPixel / 8.0);
      for (int y = 0, height = bitmapData.Height; y < height; y++) {
        int offset = y * length;
        Marshal.Copy(stream, offset, bitmapData.Scan0 + (y * bitmapData.Stride), length);
      }
      bitmap.UnlockBits(bitmapData);

      return (bitmap);
    }