FontResources.cs :  » PDF » PDF-Clown » it » stefanochizzolini » clown » documents » contents » C# / CSharp Open Source

/*
  Copyright 2006,2008 Stefano Chizzolini. http://clown.stefanochizzolini.it

  Contributors:
    * Stefano Chizzolini (original code developer, http://www.stefanochizzolini.it)

  This file should be part of the source code distribution of "PDF Clown library"
  (the Program): see the accompanying README files for more info.

  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, either expressed or implied; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the License for more details.

  You should have received a copy of the GNU General Public License along with this
  Program (see README files); if not, go to the GNU website (http://www.gnu.org/).

  Redistribution and use, with or without modification, are permitted provided that such
  redistributions retain the above copyright notice, license and disclaimer, along with
  this list of conditions.
*/

using it.stefanochizzolini.clown;
using it.stefanochizzolini.clown.documents;
using it.stefanochizzolini.clown.documents.contents.fonts;
using it.stefanochizzolini.clown.files;
using it.stefanochizzolini.clown.objects;

using System;
using System.Collections;
using System.Collections.Generic;

namespace it.stefanochizzolini.clown.documents.contents{
  /**
    <summary>Fonts collection [PDF:1.6:3.7.2].</summary>
  */
  public class FontResources
    : PdfObjectWrapper<PdfDictionary>,
      IDictionary<PdfName,Font>
  {
    #region dynamic
    #region constructors
    public FontResources(
      Document context
      ) : base(
        context.File,
        new PdfDictionary()
        )
    {}

    internal FontResources(
      PdfDirectObject baseObject,
      PdfIndirectObject container
      ) : base(
        baseObject,
        container
        )
    {}
    #endregion

    #region interface
    #region public
    public override object Clone(
      Document context
      )
    {throw new NotImplementedException();}

    /**
      <summary>Gets the key associated to a given value.</summary>
    */
    public PdfName GetKey(
      Font value
      )
    {return BaseDataObject.GetKey(value.BaseObject);}

    #region IDictionary
    public void Add(
      PdfName key,
      Font value
      )
    {BaseDataObject.Add(key,value.BaseObject);}

    public bool ContainsKey(
      PdfName key
      )
    {return BaseDataObject.ContainsKey(key);}

    public ICollection<PdfName> Keys
    {get{return BaseDataObject.Keys;}}

    public bool Remove(
      PdfName key
      )
    {return BaseDataObject.Remove(key);}

    public Font this[
      PdfName key
      ]
    {
      get
      {
        return Font.Wrap(
          (PdfReference)BaseDataObject[key]
          );
      }
      set
      {
        BaseDataObject[key] = value.BaseObject;
      }
    }

    public bool TryGetValue(
      PdfName key,
      out Font value
      )
    {
      value = this[key];
      if(value == null)
        return ContainsKey(key);
      else
        return true;
    }

    public ICollection<Font> Values
    {
      get
      {
        /*
          NOTE: We have to encapsulate raw objects into Font-derived ones.
        */
        // Get the raw objects!
        ICollection<PdfDirectObject> objs = BaseDataObject.Values;
        // Instantiate the target list!
        List<Font> values = new List<Font>(objs.Count);
        // Populate the list!
        foreach(PdfDirectObject obj in objs)
        {values.Add(Font.Wrap((PdfReference)obj));}

        return values;
      }
    }

    #region ICollection
    void ICollection<KeyValuePair<PdfName,Font>>.Add(
      KeyValuePair<PdfName,Font> entry
      )
    {Add(entry.Key,entry.Value);}

    public void Clear(
      )
    {BaseDataObject.Clear();}

    bool ICollection<KeyValuePair<PdfName,Font>>.Contains(
      KeyValuePair<PdfName,Font> entry
      )
    {return BaseDataObject[entry.Key].Equals(entry.Value.BaseObject);}

    public void CopyTo(
      KeyValuePair<PdfName,Font>[] entries,
      int index
      )
    {throw new NotImplementedException();}

    public int Count
    {get{return BaseDataObject.Count;}}

    public bool IsReadOnly
    {get{return false;}}

    public bool Remove(
      KeyValuePair<PdfName,Font> entry
      )
    {
      return BaseDataObject.Remove(
        new KeyValuePair<PdfName,PdfDirectObject>(
          entry.Key,
          entry.Value.BaseObject
          )
        );
    }

    #region IEnumerable<KeyValuePair<PdfName,Font>>
    IEnumerator<KeyValuePair<PdfName,Font>> IEnumerable<KeyValuePair<PdfName,Font>>.GetEnumerator(
      )
    {
      foreach(PdfName key in Keys)
      {yield return new KeyValuePair<PdfName,Font>(key,this[key]);}
    }

    #region IEnumerable
    IEnumerator IEnumerable.GetEnumerator(
      )
    {return ((IEnumerable<KeyValuePair<PdfName,Font>>)this).GetEnumerator();}
    #endregion
    #endregion
    #endregion
    #endregion
    #endregion
    #endregion
    #endregion
  }
}