public object SetObjectData( object obj, SerializationInfo info, StreamingContext context, ISurrogateSelector selector )
        {
            var data = info.GetInt32( "data" );
            ( ( GenericParameterHelper )obj ).Data = data;

            return obj;
        }

            /// <summary>
            /// Populates the object using the information in the SerializationInfo
            /// </summary>
            /// <param name="obj">The object to populate.</param>
            /// <param name="info">The information to populate the object.</param>
            /// <param name="context">The source from which the object is deserialized.</param>
            /// <param name="selector">The surrogate selector where the search for a compatible surrogate begins.</param>
            /// <returns></returns>
            Object ISerializationSurrogate.SetObjectData(Object obj, SerializationInfo info, StreamingContext context,
                ISurrogateSelector selector)
            {
                throw new NotSupportedException();
                /*
                _hatchBrush = new HatchBrush(
                    (HatchStyle)info.GetValue("HatchStyle", typeof(HatchStyle)),
                    (Color)info.GetValue("ForegroundColor", typeof(Color)),
                    (Color)info.GetValue("BackgroundColor", typeof(Color)));

                return _hatchBrush;
                 */
                /*
                Utility.SetPropertyValue(ref obj, "HatchStyle", Utility.PrivateInstance,
                    (HatchStyle)info.GetValue("HatchStyle", typeof(HatchStyle)));

                Console.WriteLine(((HatchBrush)obj).HatchStyle);
                Utility.SetFieldValue(ref obj, "ForegroundColor", Utility.PrivateInstance,
                    );

                Utility.SetFieldValue(ref obj, "BackgroundColor", Utility.PrivateInstance,
                    (Color)info.GetValue("BackgroundColor", typeof(Color)));

                return null;
                 */
            }

 public SoapFormatter(ISurrogateSelector selector, StreamingContext context)
 {
     this.m_assemblyFormat = FormatterAssemblyStyle.Full;
     this.m_securityLevel = TypeFilterLevel.Full;
     this.m_surrogates = selector;
     this.m_context = context;
 }

 public virtual ISerializationSurrogate GetSurrogate(Type type, StreamingContext context, out ISurrogateSelector ssout)
 {
     if (type == null)
     {
         throw new ArgumentNullException("type");
     }
     if (type.IsMarshalByRef)
     {
         ssout = this;
         return this._remotingSurrogate;
     }
     if (s_IMethodCallMessageType.IsAssignableFrom(type) || s_IMethodReturnMessageType.IsAssignableFrom(type))
     {
         ssout = this;
         return this._messageSurrogate;
     }
     if (s_ObjRefType.IsAssignableFrom(type))
     {
         ssout = this;
         return this._objRefSurrogate;
     }
     if (this._next != null)
     {
         return this._next.GetSurrogate(type, context, out ssout);
     }
     ssout = null;
     return null;
 }

        public object SetObjectData(object obj, SerializationInfo info, StreamingContext context, ISurrogateSelector selector)
        {
            Keyframe[] keyframes;

            AnimationCurve curve=new AnimationCurve();

            //	curve.preWrapMode=(WrapMode)info.GetValue("preWrapMode",typeof(WrapMode));
            //	curve.postWrapMode=(WrapMode)info.GetValue("postWrapMode",typeof(WrapMode));

            int numKeys=info.GetInt32("keysn");

            keyframes=new Keyframe[numKeys];

            Keyframe keyframeCurrent;
            for (int i=0; i<numKeys; i++) {
                keyframeCurrent=keyframes[i]=new Keyframe(info.GetSingle("keyt"+i),
                info.GetSingle("keyv"+i));
                keyframeCurrent.tangentMode=info.GetInt32("keymod"+i);
                keyframeCurrent.inTangent=info.GetSingle("keyin"+i);
                keyframeCurrent.outTangent=info.GetSingle("keyout"+i);
            }

            curve.keys = keyframes;

            // don't know how to make connection between AnimaitonCurver and Keyframes surrogate
            // AnimationCurve surrogate keys are constructed before thoose in Keyframe surrogate resulting in 0,0 Keyframes
            //return new AnimationCurve((Keyframe[])info.GetValue ("keys", typeof(Keyframe[])));

            return curve;
        }

		public virtual object SetObjectData(object obj, SerializationInfo info, StreamingContext context, ISurrogateSelector selector)
		{
			Diagram diagram = (Diagram) obj;

			diagram.SuspendEvents = true;
			diagram.Suspend();
			
			mShapes = (Elements) info.GetValue("Shapes",typeof(Elements));
			mLines = (Elements) info.GetValue("Lines",typeof(Elements));
			mLayers = (Layers) info.GetValue("Layers",typeof(Layers));
			
			//Diagram is created without a constructor, so need to do some initialization
			diagram.SetRender(new Render());

			diagram.DiagramSize = Serialize.GetSize(info.GetString("DiagramSize"));
			diagram.Zoom = info.GetSingle("Zoom");
			diagram.ShowTooltips = info.GetBoolean("ShowTooltips");
			diagram.Paged = info.GetBoolean("Paged");
			diagram.CheckBounds = info.GetBoolean("CheckBounds");
			diagram.Margin = (Margin) info.GetValue("Margin",typeof(Margin));
			diagram.WorkspaceColor = Color.FromArgb(Convert.ToInt32(info.GetString("WorkspaceColor")));
			if (Serialize.Contains(info,"Animator", typeof(Animator))) diagram.Animator = (Animator) info.GetValue("Animator", typeof(Animator));

			diagram.Resume();
			diagram.SuspendEvents = false;
			return diagram;
		}

		public object SetObjectData(object obj, SerializationInfo info, StreamingContext context, ISurrogateSelector selector)
		{
			int @int = info.GetInt32("value");
			LayerMask layerMask = default(LayerMask);
			layerMask.value = @int;
			return layerMask;
		}

 /// <summary>
 /// Adds the specified <see cref="T:System.Runtime.Serialization.ISurrogateSelector"/> that
 /// can handle a particular object type to the list of surrogates.
 /// </summary>
 /// <param name="selector">The surrogate selector to add.</param>
 /// <exception cref="T:System.ArgumentNullException">The
 /// <paramref name="selector"/>parameter is null.</exception>
 /// <exception cref="T:System.Runtime.Serialization.SerializationException">The selector is
 /// already on the list of selectors.</exception>
 /// <exception cref="T:System.Security.SecurityException">The caller does not have the
 /// required permission.</exception>
 public virtual void ChainSelector(ISurrogateSelector selector) {
     if (selector == null)
         throw new ArgumentNullException("Selector is null.");
     if (_nextSelector != null)
         selector.ChainSelector(_nextSelector);
     _nextSelector = selector;
 }

        /// <summary>
        /// Returns the surrogate for a particular type.
        /// </summary>
        ///
        /// <returns>The surrogate for a particular type.</returns>
        /// <param name="type">The <see cref="T:System.Type"/> for which the surrogate is
        /// requested.</param>
        /// <param name="context">The streaming context.</param>
        /// <param name="selector">The surrogate to use.</param>
        /// <exception cref="T:System.ArgumentNullException">The
        /// <paramref name="type"/>parameter is null.</exception>
        /// <exception cref="T:System.Security.SecurityException">The caller does not have the
        /// required permission.</exception>
        /// <PermissionSet><IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="SerializationFormatter"/></PermissionSet>
        public virtual ISerializationSurrogate GetSurrogate(Type type, StreamingContext context, out ISurrogateSelector selector) {
            if (type == null) {
                throw new ArgumentNullException("type is null.");
            }

            Dictionary<StreamingContextStates, ISerializationSurrogate> surrogates;
            ISerializationSurrogate serializationSurrogate = null;
            if (_surrogates.TryGetValue(type, out surrogates)) {
                surrogates.TryGetValue(context.State, out serializationSurrogate);
            }

            if (serializationSurrogate != null) {
                selector = this;
                return serializationSurrogate;
            }

            else {
                if (_nextSelector != null) {
                    return _nextSelector.GetSurrogate(type, context, out selector);
                }

                selector = null;
                return null;
            }
        }

 object ISerializationSurrogate.SetObjectData(object obj, SerializationInfo info, StreamingContext context, ISurrogateSelector selector)
 {
     var blend = (ColorBlend)obj;
     blend.Colors = (Color[])info.GetValue("Colors", typeof(Color[]));
     blend.Positions = (float[])info.GetValue("Positions", typeof(float[]));
     return null;
 }

 public object SetObjectData(object obj, SerializationInfo info, StreamingContext context, ISurrogateSelector selector)
 {
     var res = (Resolution)obj;
     res.Id = info.GetString("id");
     res.UnitsPerPixel = info.GetDouble("upp");
     return res;
 }

 object ISerializationSurrogate.SetObjectData(object obj, SerializationInfo info, StreamingContext context, ISurrogateSelector selector)
 {
     var blend = (ColorMap)obj;
     blend.OldColor = (Color)info.GetValue("old", typeof(Color));
     blend.NewColor = (Color)info.GetValue("new", typeof(Color));
     return null;
 }

 /// <summary>
 /// Populates the object using the information in the SerializationInfo
 /// </summary>
 /// <param name="obj">The object to populate.</param>
 /// <param name="info">The information to populate the object.</param>
 /// <param name="context">The source from which the object is deserialized.</param>
 /// <param name="selector">The surrogate selector where the search for a compatible surrogate begins.</param>
 /// <returns></returns>
 public Object SetObjectData(Object obj, SerializationInfo info, StreamingContext context,
                             ISurrogateSelector selector)
 {
     float[] elements = (float[]) info.GetValue("Elements", typeof (float[]));
     Matrix mat = new Matrix(elements[0], elements[1], elements[2], elements[3], elements[4], elements[5]);
     return null;
 }

        [System.Security.SecurityCritical]  // auto-generated
        private static bool HasCycle(ISurrogateSelector selector) {
            ISurrogateSelector head;
            ISurrogateSelector tail; 

            Contract.Assert(selector!=null, "[HasCycle]selector!=null"); 
 

            head = selector; 
            tail = selector;

            while (head!=null) {
                head = head.GetNextSelector(); 
                if (head==null) {
                    return true; 
                } 
                if (head==tail) {
                    return false; 
                }
                head = head.GetNextSelector();
                tail = tail.GetNextSelector();
 
                if (head==tail) {
                    return false; 
                } 
            }
 
            return true;

        }

        public object SetObjectData(object obj, SerializationInfo info, StreamingContext context, ISurrogateSelector selector)
        {
            var session = getSession(context);

            //Return a reference to a tracked object if available.
            var rawInternalId = info.GetValue(AggregateReferenceSurrogate.ReferenceInfoKey, typeof(InternalId));

            if (rawInternalId == null)
                throw new InvalidOperationException("Expected SerializationInfo to contain an internal id for an aggregate");

            var internalId = (InternalId)rawInternalId;

            if(session.GraphIsTracked(internalId))
                return session.TrackedGraphForInternalId(internalId);

            //To avoid circular references in separate deserialisation sessions, we track active deserialisations.
            session.RecordActiveDeserialization(internalId, obj);

            //If we are not tracking already, then deserialise.
            var data =
                getSerializableMembers(obj, context)
                    .Select(_ => info.GetValue(_.Name, ((FieldInfo)_).FieldType))
                    .ToArray();

            //Returns the passed in obj ref.
            return FormatterServices.PopulateObjectMembers(obj, getSerializableMembers(obj, context), data);
        }

		public override object SetObjectData(object obj, SerializationInfo info, StreamingContext context, ISurrogateSelector selector)
		{
			base.SetObjectData(obj,info,context,selector);

			Model model = (Model) obj;
			
			model.SuspendEvents = true;
			model.Suspend();

			model.AlignGrid = info.GetBoolean("AlignGrid");
			model.DragScroll = info.GetBoolean("DragScroll");
			model.DrawGrid = info.GetBoolean("DrawGrid");
			model.DrawPageLines = info.GetBoolean("DrawPageLines");
			model.DrawSelections = info.GetBoolean("DrawSelections");
			model.GridColor = Color.FromArgb(Convert.ToInt32(info.GetString("GridColor")));
			model.GridSize = Serialize.GetSize(info.GetString("GridSize"));
			model.GridStyle = (GridStyle) Enum.Parse(typeof(GridStyle), info.GetString("GridStyle"));
			model.PageLineSize = Serialize.GetSizeF(info.GetString("PageLineSize"));

			if (Serialize.Contains(info,"DragSelect")) model.DragSelect = info.GetBoolean("DragSelect");

			mRuntime = (Runtime) info.GetValue("Runtime",typeof(Runtime));

			model.SuspendEvents = false;
			model.Resume();
			
			return model;
		}

 internal ObjectManager(ISurrogateSelector selector, StreamingContext context, bool checkSecurity, bool isCrossAppDomain)
 {
     _objects = new ObjectHolder[DefaultInitialSize];
     _selector = selector;
     _context = context;
     _isCrossAppDomain = isCrossAppDomain;
 }

        public void ChainSelector (ISurrogateSelector! selector) {
        /*
            CodeContract.Requires(selector != null);
            CodeContract.Requires(selector != this);
            */

        }

 public object SetObjectData(Object obj, SerializationInfo info, StreamingContext context, ISurrogateSelector selector)
 {
   ModelStencil modelStencil = (ModelStencil)obj;
   try
   {
     modelStencil.Groups = (ArrayList)info.GetValue("groups", typeof(ArrayList));
   }
   catch
   {
     modelStencil.Groups = new ArrayList();
     modelStencil.Groups.Add((String)info.GetValue("groupName", typeof(String)));
   }
   modelStencil.Anchors = (ArrayList)info.GetValue("anchors", typeof(ArrayList));
   modelStencil.Decorations = (ArrayList)info.GetValue("decorations", typeof(ArrayList));
   modelStencil.Elements = (ArrayList)info.GetValue("elements", typeof(ArrayList));
   modelStencil.Tag = (String)info.GetValue("tag", typeof(String));
   try
   {
     modelStencil.DefaultSize = (Size)info.GetValue("defaultSize", typeof(String));
   }
   catch
   {
     modelStencil.DefaultSize = new Size(10.0, 10.0);
   }
   return modelStencil;
 }

        public object SetObjectData(object obj, SerializationInfo info, StreamingContext context, ISurrogateSelector selector)
        {
            typeof(Point).GetField("X").SetValue(obj, info.GetString("X"));
            typeof(Point).GetField("Y").SetValue(obj, info.GetString("Y"));

            return null;
        }