Пример #1
0
        // ------------------------------------------------------------------
        /// <summary>
        /// Unwraps the specified collection.
        /// </summary>
        /// <param name="collection">The collection.</param>
        // ------------------------------------------------------------------
        public void Unwrap(CollectionBase <IDiagramEntity> collection)
        {
            if (collection == null)
            {
                return;
            }
            foreach (IDiagramEntity entity in collection)
            {
                Unwrap(entity);
            }
            //reconnect the connectors, just like the deserialization of a filed diagram
            Dictionary <Guid, Anchor> .Enumerator enumer = Anchors.GetEnumerator();
            System.Collections.Generic.KeyValuePair <Guid, Anchor> pair;
            Anchor anchor;

            while (enumer.MoveNext())
            {
                pair   = enumer.Current;
                anchor = pair.Value;
                if (anchor.Parent != Guid.Empty) //there's a parent connector
                {
                    if (Anchors.ContainsKey(anchor.Parent))
                    {
                        Anchors.GetAnchor(anchor.Parent).Instance.AttachConnector(anchor.Instance);
                    }
                }
            }
            //clean up the anchoring matrix
            Anchors.Clear();
        }
Пример #2
0
        /// <summary>
        /// Called when the tool is activated.
        /// </summary>
        protected override void OnActivateTool()
        {
            if (Selection.SelectedItems.Count == 0)
            {
                return;
            }

            try
            {
                //Clear the Anchors otherwise subsequent Copy operations will raise an exception due to the fact that the Anchors class is a static helper class
                Anchors.Clear();
                //this will create a volatile collection of entities, they need to be unwrapped!
                //I never managed to get things working by putting the serialized collection directly onto the Clipboad. Thanks to Leppie's suggestion it works by
                //putting the Stream onto the Clipboard, which is weird but it works.
                MemoryStream       copy       = Selection.SelectedItems.ToStream();
                DataFormats.Format format     = DataFormats.GetFormat(typeof(CopyTool).FullName);
                IDataObject        dataObject = new DataObject();
                dataObject.SetData(format.Name, false, copy);
                Clipboard.SetDataObject(dataObject, false);
            }
            catch (Exception exc)
            {
                throw new InconsistencyException("The Copy operation failed.", exc);
            }
            finally
            {
                DeactivateTool();
            }
        }
Пример #3
0
        /// <summary>
        /// Runs when the entire object graph has been deserialized.
        /// </summary>
        /// <param name="sender">The object that initiated the callback. The functionality for this parameter is not currently implemented.</param>
        public void OnDeserialization(object sender)
        {
            if (Tracing.BinaryDeserializationSwitch.Enabled)
            {
                Trace.WriteLine("IDeserializationCallback of 'Model' called.");
            }
            Init();
            #region Binding of connectors

            Dictionary <Guid, Anchor> .Enumerator enumer = Anchors.GetEnumerator();
            System.Collections.Generic.KeyValuePair <Guid, Anchor> pair;
            Anchor anchor;
            while (enumer.MoveNext())
            {
                pair   = enumer.Current;
                anchor = pair.Value;
                if (anchor.Parent != Guid.Empty) //there's a parent connector
                {
                    if (Anchors.ContainsKey(anchor.Parent))
                    {
                        Anchors.GetAnchor(anchor.Parent).Instance.AttachConnector(anchor.Instance);
                    }
                }
            }
            //clean up the anchoring matrix
            Anchors.Clear();
            #endregion
        }
Пример #4
0
        void OnDeserializing(StreamingContext context)
        {
            if (Tracing.BinaryDeserializationSwitch.Enabled)
            {
                Trace.WriteLine("Starting deserializing the 'Model' class...");
            }
            //the anchors is a temporary collection of Uid's and parent entities to re-connect connectors
            //to their parent. The serialization process does serialize parenting because you need on deserialization an
            //instance in order to connect to it.

            Anchors.Clear();
        }
Пример #5
0
        /// <summary>
        /// Deserialization constructor
        /// </summary>
        /// <param name="info">The info.</param>
        /// <param name="context">The context.</param>
        protected ConnectorBase(SerializationInfo info, StreamingContext context) : base(info, context)
        {
            if (Tracing.BinaryDeserializationSwitch.Enabled)
            {
                Trace.WriteLine("Deserializing the fields of 'ConnectorBase'.");
            }
            this.mPoint        = (Point)info.GetValue("Point", typeof(Point));
            attachedConnectors = new CollectionBase <IConnector>();

            #region Preparation of the anchoring process
            Guid tuid = new Guid(info.GetString("AttachedTo"));
            Anchors.Add(this.Uid, new Anchor(tuid, this));
            #endregion
        }
Пример #6
0
        /// <summary>
        /// Called when the tool is activated.
        /// </summary>
        protected override void OnActivateTool()
        {
            try
            {
                IDataObject data   = Clipboard.GetDataObject();
                string      format = typeof(CopyTool).FullName;
                if (data.GetDataPresent(format))
                {
                    MemoryStream stream = data.GetData(format) as MemoryStream;
                    CollectionBase <IDiagramEntity>    collection = null;
                    GenericFormatter <BinaryFormatter> f          = new GenericFormatter <BinaryFormatter>();
                    //Anchors collection is a helper collection to re-connect connectors to their parent
                    Anchors.Clear();
                    //but is it actually a stream coming this application?
                    collection = f.Deserialize <CollectionBase <IDiagramEntity> >(stream);



                    if (collection != null)
                    {
                        #region Unwrap the bundle
                        this.Controller.Model.Unwrap(collection);
                        Rectangle rec = Utils.BoundingRectangle(collection);
                        rec.Inflate(30, 30);
                        this.Controller.View.Invalidate(rec);
                        #endregion
                    }
                }
                else if (data.GetDataPresent(DataFormats.Bitmap))
                {
                    Bitmap bmp = data.GetData(DataFormats.Bitmap) as Bitmap;
                    if (bmp != null)
                    {
                        #region Unwrap into an image shape
                        //TODO: Insert the image shape here
                        #endregion
                    }
                }
            }
            catch (Exception exc)
            {
                throw new InconsistencyException("The Copy operation failed.", exc);
            }
            finally
            {
                DeactivateTool();
            }
        }
Пример #7
0
        // ------------------------------------------------------------------
        /// <summary>
        /// Called when the tool is activated.
        /// </summary>
        // ------------------------------------------------------------------
        protected override void OnActivateTool()
        {
            if (this.Controller.Model.Selection.SelectedItems.Count == 0)
            {
                return;
            }

            try {
                //Clear the Anchors otherwise subsequent Copy operations will
                // raise an exception due to the fact that the Anchors class
                // is a static helper class.
                Anchors.Clear();

                // First add the image to the Windows Clipboard so it can be
                // pasted into other applications, like PowerPoint.
                Bitmap image = this.Controller.Model.Selection.ToBitmap();
                Clipboard.SetDataObject(image, true);

                // This will create a volatile collection of entities, but they
                // need to be unwrapped!  I never managed to get things
                // working by putting the serialized collection directly onto
                // the Clipboad. Thanks to Leppie's suggestion it works by
                // putting the Stream onto the Clipboard, which is weird but
                // it works.
                //MemoryStream copy = Selection.SelectedItems.ToStream();
                //DataFormats.Format format =
                //    DataFormats.GetFormat(typeof(CopyTool).FullName);

                //IDataObject dataObject = new DataObject();
                //dataObject.SetData(format.Name, false, copy);
                //Clipboard.SetDataObject(dataObject, false);

                // Rather than placing the stream of entities on the Windows
                // Clipboard, we're using our custom clipboard to keep the
                // Windows clipboard for moving data across apps.
                NetronClipboard.Clear();
                NetronClipboard.Add(this.Controller.Model.Selection.SelectedItems.Copy());
            }
            catch (Exception exc) {
                //throw new InconsistencyException(
                //    "The Copy operation failed.", exc);
                MessageBox.Show("Unable to copy the selection.\n\n" +
                                "Error Message: " + exc.Message);
            }
            finally {
                DeactivateTool();
            }
        }
        /// <summary>
        /// Deserialization constructor
        /// </summary>
        /// <param name="info">The info.</param>
        /// <param name="context">The context.</param>
        protected ConnectorBase(SerializationInfo info, StreamingContext context)
            : base(info, context)
        {
            if (Tracing.BinaryDeserializationSwitch.Enabled)
            {
                Trace.WriteLine("Deserializing the fields of 'ConnectorBase'.");
            }

            double version = info.GetDouble("ConnectorBaseVersion");

            this.mShowName     = info.GetBoolean("ShowName");
            this.mNameLocation = (ConnectorNameLocation)info.GetValue(
                "NameLocation",
                typeof(ConnectorNameLocation));

            this.mPoint         = (Point)info.GetValue("Point", typeof(Point));
            mAttachedConnectors = new CollectionBase <IConnector>();

            #region Preparation of the anchoring process
            Guid tuid = new Guid(info.GetString("AttachedTo"));
            Anchors.Add(this.Uid, new Anchor(tuid, this));
            #endregion
        }
Пример #9
0
        /// <summary>
        /// Called when the tool is activated.
        /// </summary>
        protected override void OnActivateTool()
        {
            try {
                // Used to get a collection of entities from the
                // NetronClipboard.
                Type entitiesType = typeof(CollectionBase <IDiagramEntity>);

                // First calculate the insertion point based on the
                // current location of the cursor.
                InsertionPoint = Point.Round(
                    Controller.View.ViewToWorld(
                        Controller.View.DeviceToView(
                            Controller.ParentControl.PointToClient(Cursor.Position))));

                IDataObject data   = Clipboard.GetDataObject();
                string      format = typeof(CopyTool).FullName;
                if (data.GetDataPresent(format))
                {
                    MemoryStream stream = data.GetData(format) as MemoryStream;
                    CollectionBase <IDiagramEntity>    collection = null;
                    GenericFormatter <BinaryFormatter> f          =
                        new GenericFormatter <BinaryFormatter>();
                    //Anchors collection is a helper collection to re-connect connectors to their parent
                    Anchors.Clear();
                    //but is it actually a stream coming this application?
                    collection = f.Deserialize <CollectionBase <IDiagramEntity> >(stream);
                    UnwrapBundle(collection);
                }
                else if (NetronClipboard.ContainsData(entitiesType))
                {
                    CollectionBase <IDiagramEntity> collection =
                        (CollectionBase <IDiagramEntity>)NetronClipboard.Get(
                            entitiesType);

                    UnwrapBundle(collection.DeepCopy());
                }
                else if (data.GetDataPresent(DataFormats.Bitmap))
                {
                    Bitmap bmp = data.GetData(DataFormats.Bitmap) as Bitmap;
                    if (bmp != null)
                    {
                        #region Unwrap into an image shape
                        //TODO: Insert the image shape here
                        ImageShape shape = new ImageShape();
                        shape.Image    = bmp;
                        shape.Location = InsertionPoint;
                        Controller.Model.AddShape(shape);
                        #endregion
                    }
                }
                else if (data.GetDataPresent(DataFormats.Text))
                {
                    string   text      = (string)data.GetData(typeof(string));
                    TextOnly textShape = new TextOnly(Controller.Model);
                    textShape.Text     = text;
                    textShape.Location = InsertionPoint;
                    Controller.Model.AddShape(textShape);
                }
            }
            catch (Exception exc) {
                throw new InconsistencyException("The Paste operation failed.", exc);
            }
            finally {
                DeactivateTool();
            }
        }