Ejemplo n.º 1
0
        private void MoveLeft(KeyEventArgs args)
        {
            var oldPos  = GetCursorPosInt();
            int nextPos = Math.Max(0, GetCursorPosInt() - 1);

            if (args.Control)
            {
                Regex  r      = new Regex(@"\S*\s*$");
                string before = Text.Substring(0, GetCursorPosInt());
                nextPos = r.Match(before).Index;
            }
            CursorPos = new CP(nextPos);

            if (args.Shift)
            {
                if (SelectionLength <= 0)
                {
                    SelectionLength -= GetCursorPosInt() - oldPos;
                }
                else
                {
                    SelectionLength -= GetCursorPosInt() - oldPos;
                }
            }
            else
            {
                SelectionLength = 0;
            }
            Redraw();
            m_additionUndoAction = null;
        }
Ejemplo n.º 2
0
 private void MoveUp(KeyEventArgs args)
 {
     if (m_dropDownOpen)
     {
         ItemIndex--;
     }
     else
     {
         if (args.Shift)
         {
             var selectionEnd = GetCursorPosInt() + SelectionLength;
             var point        = CursorToXY(CursorPos.GetUV(GetLines().ToList()));
             point.Y        -= Font.Height;
             CursorPos       = XYToCursor(point.X, point.Y);
             SelectionLength = selectionEnd - GetCursorPosInt();
         }
         else
         {
             SelectionLength = 0;
             var point = CursorToXY(CursorPos.GetUV(GetLines().ToList()));
             point.Y  -= Font.Height;
             CursorPos = XYToCursor(point.X, point.Y);
         }
         Redraw();
         m_additionUndoAction = null;
     }
 }
Ejemplo n.º 3
0
 private void Delete(KeyEventArgs args)
 {
     if (InputForm != InputFormEnum.None)
     {
         var undo = MakeUndoAction();
         if (SelectionLength != 0)
         {
             DeleteSelection();
         }
         else if (GetCursorPosInt() < Text.Length)
         {
             if (args.Control)
             {
                 Regex r = new Regex(@"\s*\S*");
                 SelectionLength = r.Match(Text, GetCursorPosInt()).Length;
                 DeleteSelection();
             }
             else
             {
                 Text = Text.Remove(GetCursorPosInt(), 1);
             }
             Redraw();
         }
         m_additionUndoAction = null;
         undo.SetRedo(m_state);
     }
 }
Ejemplo n.º 4
0
 private void Backspace(KeyEventArgs args)
 {
     if (InputForm != InputFormEnum.None)
     {
         var undo = MakeUndoAction();
         if (SelectionLength != 0)
         {
             DeleteSelection();
         }
         else if (GetCursorPosInt() > 0)
         {
             if (args.Control)
             {
                 Regex  r      = new Regex(@"\S*\s*$");
                 string before = Text.Substring(0, GetCursorPosInt());
                 var    match  = r.Match(before);
                 CursorPos       = new CP(match.Index);
                 SelectionLength = match.Length;
                 DeleteSelection();
             }
             else
             {
                 Text = Text.Remove(GetCursorPosInt() - 1, 1);
                 var lines = GetLines().ToList();
                 CursorPos = new CP(Math.Max(0, CursorPos.Pos - 1), CursorPos.GetUV(lines).X == 0);
             }
             Redraw();
         }
         m_additionUndoAction = null;
         undo.SetRedo(m_state);
     }
 }
Ejemplo n.º 5
0
        private void MoveRight(KeyEventArgs args)
        {
            var oldPos  = GetCursorPosInt();
            int nextPos = 1;

            if (args.Control)
            {
                Regex r = new Regex(@"\s*\S*");
                nextPos = r.Match(Text, GetCursorPosInt()).Length;
            }
            CursorPos = new CP(CursorPos.Pos + nextPos);

            if (args.Shift)
            {
                if (SelectionLength <= 0)
                {
                    SelectionLength -= GetCursorPosInt() - oldPos;
                }
                else
                {
                    SelectionLength -= GetCursorPosInt() - oldPos;
                }
            }
            else
            {
                SelectionLength = 0;
            }
            Redraw();
            m_additionUndoAction = null;
        }
Ejemplo n.º 6
0
    public void SetTrapezoidal(bool val)
    {
        if (val != IsTrapezoidal)
        {
            AttChange change = new AttChange();

            List <float> prop = new List <float>();
            prop.Add((float)this.GetId());
            prop.Add((float)0.0);
            prop.Add((float)0.0);
            prop.Add((float)1.0);                   // value of attribute index,, not nessesary but just frameword for case of adding attributes
            prop.Add((float)1.0);                   // value as a sign of revertion of bool attribute

            change.SetChange(prop);
            UndoAction undoAction = new UndoAction();
            undoAction.AddChange(change);

            GUICircuitComponent.globalUndoList.AddUndo(undoAction);
        }
        IsTrapezoidal = val;
        if (GameObject.Find("PlayToggle").GetComponent <UnityEngine.UI.Toggle>().isOn)
        {
            GameObject.Find("PlayButton").GetComponent <GUICircuit>().RunSimulation();
        }
    }
            public void onInspectorPostFieldModification()
            {
                GuiEditorProfilesTree         GuiEditorProfilesTree         = "GuiEditorProfilesTree";
                GuiEditorProfileChangeManager GuiEditorProfileChangeManager = "GuiEditorProfileChangeManager";

                GuiEditorGui.GuiEditor GuiEditor   = "GuiEditor";
                ProfilePane            ProfilePane = "ProfilePane";

                UndoAction action     = this.currentFieldEditAction;
                SimObject  objectx    = action["objectId"];
                string     fieldName  = action["fieldName"];
                string     arrayIndex = action["arrayIndex"];
                string     oldValue   = action["fieldValue"];
                string     newValue   = objectx.getFieldValue(fieldName, arrayIndex == "(null)" ? -1 : arrayIndex.AsInt());

                // If it's the name field, make sure to sync up the treeview.

                if (action["fieldName"] == "name")
                {
                    GuiEditorProfilesTree.onProfileRenamed(objectx, newValue);
                }

                ProfilePane.onProfileSelected();

                // Add change record.

                GuiEditorProfileChangeManager.registerEdit(objectx, fieldName, arrayIndex, oldValue);

                this.currentFieldEditAction.addToManager(ProfilePane.getUndoManager());
                this.currentFieldEditAction = "";

                //GuiEditor.updateUndoMenu();
                GuiEditor.setProfileDirty(objectx, true, false);
            }
Ejemplo n.º 8
0
    //Rotate functionality to invoke rotation from button, -90 degrees
    public void RoateCounterClockWise()
    {
        if (SelectObject.SelectedObjects.Count == 1)
        {
            foreach (GameObject objectSelected in SelectObject.SelectedObjects)
            {
                Vector3 curentPos = objectSelected.transform.position;

                objectSelected.transform.Rotate(new Vector3(0, 0, +90));

                Vector3 finalPos = objectSelected.transform.position;

                List <float> properties = new List <float>();
                properties.Add(objectSelected.GetComponent <GUICircuitComponent>().GetId());
                properties.Add(curentPos[0] - finalPos[0]);
                properties.Add(curentPos[1] - finalPos[1]);
                properties.Add(-90);

                PosChange change = new PosChange();
                change.SetChange(properties);

                UndoAction undoAction = new UndoAction();
                undoAction.AddChange(change);

                GUICircuitComponent.globalUndoList.AddUndo(undoAction);
            }

            //transform position of each lines in scene
            Line.TransformLines();
        }
    }
Ejemplo n.º 9
0
 /// <summary>
 /// Creates an object that describes both the value and the undo action to a command.
 /// </summary>
 /// <param name="value">The value of the object.</param>
 /// <param name="undoAction">The Undo action.</param>
 public UndoObject(object oldValue, object newValue, UndoAction undoAction)
 {
     // Initialize the object
     this.oldValueField   = oldValue;
     this.newValueField   = newValue;
     this.undoActionField = undoAction;
 }
Ejemplo n.º 10
0
    public void SetInductance(double val)
    {
        if (Inductance != val)
        {
            AttChange change = new AttChange();

            List <float> prop = new List <float>();
            prop.Add((float)this.GetId());
            prop.Add((float)1.0);                   // value of attribute index,, not nessesary but just frameword for case of adding attributes
            prop.Add((float)(Inductance - val));
            prop.Add((float)0.0);                   // hodnoty ostatnych atributov sa nezmenia
            prop.Add((float)0.0);

            change.SetChange(prop);
            UndoAction undoAction = new UndoAction();
            undoAction.AddChange(change);

            GUICircuitComponent.globalUndoList.AddUndo(undoAction);
        }
        Inductance = val;
        if (GameObject.Find("PlayToggle").GetComponent <UnityEngine.UI.Toggle>().isOn)
        {
            GameObject.Find("PlayButton").GetComponent <GUICircuit>().RunSimulation();
        }
    }
Ejemplo n.º 11
0
        private UndoAction MakeUndoAction()
        {
            var result = new UndoAction(m_state, s => { Text = s.Text; CursorPos = s.CursorPos; SelectionLength = s.SelectionLength; });

            m_undoQueue.Queue(result);
            return(result);
        }
Ejemplo n.º 12
0
        private void Home(KeyEventArgs args)
        {
            if (args.Shift)
            {
                var end   = GetCursorPosInt() + SelectionLength;
                var lines = GetLines().ToList();
                var uv    = CursorPos.GetUV(lines);
                CursorPos       = new CP(lines.Take(uv.Y).Select(l => l.Length).Concat(0.Only()).Sum());
                SelectionLength = end - CursorPos.Pos;
            }
            else
            {
                SelectionLength = 0;
            }

            if (args.Control)
            {
                CursorPos = new CP(0);
            }
            else
            {
                var lines = GetLines().ToList();
                var uv    = CursorPos.GetUV(lines);
                CursorPos = new CP(lines.Take(uv.Y).Select(l => l.Length).Concat(0.Only()).Sum());
            }

            m_additionUndoAction = null;
        }
Ejemplo n.º 13
0
 private void AddUndoableAction(TextBoxBase sender, UndoAction action)
 {
     if (action == UndoAction.Undo)
     {
         redoStack.Push(new UndoOperation(sender, action));
     }
     else
     {
         if (undoStack.Count > 0)
         {
             UndoOperation op = undoStack.Peek();
             if ((op.Sender == sender) && (action == UndoAction.Merge))
             {
                 // no-op
             }
             else
             {
                 PushUndoOperation(sender, action);
             }
         }
         else
         {
             PushUndoOperation(sender, action);
         }
     }
 }
 public CollectionChangedEventArgs(RoutedEvent routedEvent, UndoAction undoAction, CollectionChangedAction collectionChangedAction)
     : base(routedEvent)
 {
     // Initialize the object
     this.undoAction = undoAction;
     this.collectionChangedAction = collectionChangedAction;
 }
            public void onInspectorPreFieldModification(string fieldName, string arrayIndex)
            {
                GuiEditorGui.GuiEditor GuiEditor = "GuiEditor";

                Util.pushInstantGroup();
                //UndoManager undoManager = GuiEditor.getUndoManager();

                SimObject objectx = this.getInspectObject();

                string nameOrClass = objectx.getName();

                if (nameOrClass == "")
                {
                    nameOrClass = objectx.getClassName();
                }

                ObjectCreator oc = new ObjectCreator("InspectorFieldUndoAction");

                oc["actionName"] = nameOrClass + "." + fieldName + " Change";

                oc["objectId"]   = objectx.getId();
                oc["fieldName"]  = fieldName;
                oc["fieldValue"] = objectx.getFieldValue(fieldName, arrayIndex == "(null)" ? -1 : arrayIndex.AsInt());
                oc["arrayIndex"] = arrayIndex;

                oc["inspectorGui"] = this;

                InspectorFieldUndoAction action = oc.Create();

                this.currentFieldEditAction = action;
                Util.popInstantGroup();
            }
        public CollectionChangedEventArgs(RoutedEvent routedEvent, UndoAction undoAction, CollectionChangedAction collectionChangedAction, object item, int index)
            : base(routedEvent)
        {
            // Initialize the object
            this.undoAction = undoAction;
            this.collectionChangedAction = collectionChangedAction;

            ArrayList items = new ArrayList();

            items.Add(item);

            switch (this.collectionChangedAction)
            {
            case CollectionChangedAction.Add:

                this.newStartingIndex = index;
                this.newItems         = items;
                break;

            case CollectionChangedAction.Remove:

                this.oldStartingIndex = index;
                this.oldItems         = items;
                break;
            }
        }
        public CollectionChangedEventArgs(RoutedEvent routedEvent, UndoAction undoAction,
                                          CollectionChangedAction collectionChangedAction, object newItem, object oldItem, int newIndex)
            : base(routedEvent)
        {
            // Initialize the object
            this.undoAction = undoAction;
            this.collectionChangedAction = collectionChangedAction;

            ArrayList newItems = new ArrayList();

            newItems.Add(newItem);

            ArrayList oldItems = new ArrayList();

            oldItems.Add(oldItem);

            switch (this.collectionChangedAction)
            {
            case CollectionChangedAction.Replace:

                this.newItems         = newItems;
                this.oldItems         = oldItems;
                this.newStartingIndex = newIndex;
                break;
            }
        }
Ejemplo n.º 18
0
 /// <summary>
 /// Creates an object that describes both the value and the undo action to a command.
 /// </summary>
 /// <param name="value">The value of the object.</param>
 /// <param name="undoAction">The Undo action.</param>
 public UndoObject(object oldValue, object newValue, UndoAction undoAction)
 {
     // Initialize the object
     this.OldValue   = oldValue;
     this.NewValue   = newValue;
     this.UndoAction = undoAction;
 }
Ejemplo n.º 19
0
 public UndoInfo(FrameLayerPair layerAddress, int drawingItemID, UndoAction undoAction, object oldValue, object newValue)
 {
     this.LayerAddress = layerAddress;
     this.DrawingItemID = drawingItemID;
     this.Action = undoAction;
     this.OldValue = oldValue;
     this.NewValue = newValue;
 }
Ejemplo n.º 20
0
 public UndoStep(byte[] bytes, byte[] oldBytes, int start, UndoAction action)
 {
     this.bytes     = bytes;
     this.oldBytes  = oldBytes;
     this.start     = start;
     this.action    = action;
     this.timeStamp = DateTime.Now.Ticks;
 }
Ejemplo n.º 21
0
 private void Copy()
 {
     if (!string.IsNullOrEmpty(SelectedText))
     {
         Clipboard.SetText(SelectedText);
     }
     m_additionUndoAction = null;
 }
Ejemplo n.º 22
0
		public UndoStep(byte[] bytes, byte[] oldBytes, int start, UndoAction action)
		{
			this.bytes = bytes;
			this.oldBytes = oldBytes;
			this.start = start;
			this.action = action;
			this.timeStamp = DateTime.Now.Ticks;
		}
Ejemplo n.º 23
0
        /// <summary>
        /// Undoes the most recent undo command on the stack.
        /// </summary>
        /// <param name="dependencyObject">The target of the undo operation.</param>
        private void UndoCollection(object sender, GenericEventArgs genericEventArgs)
        {
            // Extract the specific arguments from the generic arguments
            ReportGrid reportGrid = (ReportGrid)genericEventArgs.Arguments[0];
            CollectionChangedEventArgs collectionChangedEventArgs = (CollectionChangedEventArgs)genericEventArgs.Arguments[1];
            UndoAction undoAction = (UndoAction)genericEventArgs.Arguments[2];

            // Each action done to a collection has a specific method to be undone.  Note that the 'Undo' state is passed onto the method to indicate the state
            // of the action.  This tells the event handler on which stack to place the command needed to undo the action.  For example, when undoing a a
            // column addition, you will remove the column.  That removal operation needs to be encoded so that it is placed on the 'Redo' stack when the event
            // is handled.
            switch (collectionChangedEventArgs.Action)
            {
            case CollectionChangedAction.Add:

                // This will undo the action of adding a column to a collection by removing it.
                foreach (ReportColumn reportColumn in collectionChangedEventArgs.NewItems)
                {
                    reportGrid.reportColumnCollection.Remove(reportColumn, undoAction);
                }

                break;

            case CollectionChangedAction.Move:

                // This will undo the action of moving a column by returning it to the original position.
                int oldIndex = collectionChangedEventArgs.OldStartingIndex;
                int newIndex = collectionChangedEventArgs.NewStartingIndex;
                foreach (ReportColumn reportColumn in collectionChangedEventArgs.NewItems)
                {
                    reportGrid.reportColumnCollection.Move(newIndex, oldIndex, undoAction);
                    newIndex++;
                    oldIndex++;
                }

                break;

            case CollectionChangedAction.Replace:

                // This will undo the action of replacing the entire list by restoring the original list.
                reportGrid.reportColumnCollection.Replace(collectionChangedEventArgs.OldItems as List <ReportColumn>, undoAction);

                break;

            case CollectionChangedAction.Remove:

                // This will undo the action of removing a column by inserting back in at the original position.
                int index = collectionChangedEventArgs.OldStartingIndex;
                foreach (ReportColumn reportColumn in collectionChangedEventArgs.OldItems)
                {
                    reportGrid.reportColumnCollection.Insert(index++, reportColumn, undoAction);
                }

                break;
            }
        }
 public UndoPropertyChangedEventArgs(RoutedEvent routedEvent, UndoAction undoAction,
                                     DependencyProperty dependencyProperty, object oldValue, object newValue)
     : base(routedEvent)
 {
     // Initialize the object
     this.UndoAction         = undoAction;
     this.DependencyProperty = dependencyProperty;
     this.OldValue           = oldValue;
     this.NewValue           = newValue;
 }
Ejemplo n.º 25
0
 public Undo(UndoAction act, string t,string ot, int c, int r, int sc, int sr)
 {
     action = act;
     text = t;
     oldtext = ot;
     col = c;
     row = r;
     selCol = sc;
     selRow = sr;
 }
Ejemplo n.º 26
0
 //Adds an action to the undo queue
 public void AddUndoAction(UndoAction action)
 {
     while (UndoQueue.Count > (UndoQueuePointer + 1))
     {
         UndoQueue.RemoveAt(UndoQueue.Count - 1);
     }
     UndoQueuePointer++;
     UndoQueue.Add(action);
     UndoQueueChangedFlag = true;
 }
Ejemplo n.º 27
0
 public Undo(UndoAction act, string t, string ot, int c, int r, int sc, int sr)
 {
     action  = act;
     text    = t;
     oldtext = ot;
     col     = c;
     row     = r;
     selCol  = sc;
     selRow  = sr;
 }
Ejemplo n.º 28
0
    public void AddUndo(UndoAction undoAction)
    {
        if (undoList.Count == 5)
        {
            undoList.RemoveLast();
        }

        FlushRedoActions();
        undoList.AddFirst(undoAction);
    }
Ejemplo n.º 29
0
        /// <summary>

        /// Undo the previous change.

        /// </summary>

        public void Undo()

        {
            if (undoStack.Count == 0)
            {
                throw new InvalidOperationException("Undo stack is empty.");
            }



            // Get the last change from the undo stack.

            UndoAction action = undoStack.Pop();



            // Add the change to the redo stack.

            redoStack.Push(action);



            switch (action.Change)

            {
            case UndoAction.ChangeMode.AddRow:

                this.RemoveRow(action);

                break;



            case UndoAction.ChangeMode.DeleteRow:

                this.InsertRow(action);

                break;



            case UndoAction.ChangeMode.ModifyCell:

                this.UpdateCell(action);

                break;



            default:

                throw new InvalidOperationException("Unknown undo action change: " + action.Change);
            }
        }
Ejemplo n.º 30
0
 public void SetUndoRedoActions(UndoAction undo)//, RedoAction redo)
 {
     this.undo = undo;
     //this.redo = redo;
     timerText.text = "00:00";
     //redoAction.GetComponent<Button>().image.color = actionUnavailableColor;
     undoAction.GetComponent <Button>().image.color = actionUnavailableColor;
     //redoAction.GetComponent<Button>().interactable = false;
     undoAction.GetComponent <Button>().interactable = false;
     timerText.gameObject.SetActive(true);
 }
Ejemplo n.º 31
0
 public void AddAction(Action<ActionData> action, Entity entity)
 {
     UndoAction item = new UndoAction {
         Action = action
     };
     ActionData data = new ActionData {
         Entity = entity
     };
     item.Data = data;
     this._actions.Push(item);
 }
 public ColumnChangedEventArgs(RoutedEvent routedEvent, UndoAction undoAction,
                               ReportColumn reportColumn, DependencyProperty dependencyProperty,
                               object oldValue, object newValue)
     : base(routedEvent)
 {
     // Initialize the object.
     this.UndoAction         = undoAction;
     this.ColumnDefinition   = reportColumn;
     this.DependencyProperty = dependencyProperty;
     this.OldValue           = oldValue;
     this.NewValue           = newValue;
 }
Ejemplo n.º 33
0
        /// <summary>
        /// Undoes the most recent undo command on the stack.
        /// </summary>
        /// <param name="dependencyObject">The target of the undo operation.</param>
        private void UndoColumn(object sender, GenericEventArgs genericEventArgs)
        {
            // Extract the specific arguments from the generic arguments
            ReportGrid             reportGrid             = (ReportGrid)genericEventArgs.Arguments[0];
            ColumnChangedEventArgs columnChangedEventArgs = (ColumnChangedEventArgs)genericEventArgs.Arguments[1];
            UndoAction             undoAction             = (UndoAction)genericEventArgs.Arguments[2];

            // This will undo a change to the width of a column.
            if (columnChangedEventArgs.DependencyProperty == ReportColumn.WidthProperty)
            {
                reportGrid.reportColumnCollection.SetColumnWidth(columnChangedEventArgs.ColumnDefinition, (Double)columnChangedEventArgs.OldValue, undoAction);
            }
        }
Ejemplo n.º 34
0
        /// <summary>
        /// Undoes or Redoes a change to a property in a MarkThree.Windows.Controls.Report.
        /// </summary>
        /// <param name="dependencyObject">The target of the undo operation.</param>
        private void UndoProperty(object sender, GenericEventArgs genericEventArgs)
        {
            // Extract the specific arguments from the generic arguments stored on the Undo/Redo stacks.
            ReportGrid         reportGrid         = (ReportGrid)genericEventArgs.Arguments[0];
            DependencyProperty dependencyProperty = (DependencyProperty)genericEventArgs.Arguments[1];
            object             oldValue           = genericEventArgs.Arguments[2];
            object             newValue           = genericEventArgs.Arguments[3];
            UndoAction         undoAction         = (UndoAction)genericEventArgs.Arguments[4];

            // This will use the property map to Undo or Redo the change to the property.  Notice that the new value and old value are transposed here from
            // their original positions.
            this.propertyMap[dependencyProperty].Execute(new UndoObject(newValue, oldValue, undoAction), reportGrid);
        }
Ejemplo n.º 35
0
		public UndoPoint(Element element, UndoAction action)
		{
			if (! (element is Shape || element is Line)) throw new UndoPointException("Element must be of type Shape or type Line.");
			
			mKey = element.Key;
			mBytes = SerializeElement(element);
			mAction = action;
			mObjectType = element.GetType();
			if (element is Shape) mUndoType = UndoType.Shape;
			if (element is Line) mUndoType = UndoType.Line;

			mContainer = element.Container;
			mLayer = element.Layer;
		}
Ejemplo n.º 36
0
        /// <summary>
        /// constructor
        /// </summary>
        /// <param name="id">event id</param>
        /// <param name="action">UndoAction</param>
        /// <param name="changes">ReadOnlyCollection</param>
        public TextChangedEventArgs(RoutedEvent id, UndoAction action, ICollection<TextChange> changes) : base()
        {
            if (id == null)
            {
                throw new ArgumentNullException("id");
            }

            if (action < UndoAction.None || action > UndoAction.Create)
            {
                throw new InvalidEnumArgumentException("action", (int)action, typeof(UndoAction));
            }

            RoutedEvent=id;
            _undoAction = action;
            _changes = changes;
        }
Ejemplo n.º 37
0
 public UndoOperation(TextBoxBase sender, UndoAction action)
 {
     this.Sender = sender;
     this.Action = action;
 }
 public TextChangedEventArgs(System.Windows.RoutedEvent id, UndoAction action)
 {
 }
Ejemplo n.º 39
0
        private void mnuFileDocument_Click(object sender, RoutedEventArgs e)
        {
            string previousTitle = circuitDisplay.Document.Metadata.Title;
            string previousDescription = circuitDisplay.Document.Metadata.Description;

            winDocumentProperties documentInfoWindow = new winDocumentProperties();
            documentInfoWindow.Owner = this;
            documentInfoWindow.SetDocument(circuitDisplay.Document);
            documentInfoWindow.ShowDialog();

            if (circuitDisplay.Document.Metadata.Title != previousTitle || circuitDisplay.Document.Metadata.Description != previousDescription)
            {
                UndoAction editMetadataAction = new UndoAction(UndoCommand.ModifyMetadata, "Modify metadata");
                editMetadataAction.AddData("before", new string[2] { previousTitle, previousDescription});
                editMetadataAction.AddData("after", new string[2] { circuitDisplay.Document.Metadata.Title, circuitDisplay.Document.Metadata.Description });
                UndoManager.AddAction(editMetadataAction);
            }
        }
Ejemplo n.º 40
0
		private UndoPoint AddPoint(Element element, UndoAction action, string description, bool overwrite)
		{
			if (Suspended) return null;

			UndoPoint undo = null;
			string key = null;
			string createDesc = null;

			//Create undopoint
			if (element is Shape || element is Line)
			{
				undo = new UndoPoint(element, action);
				key = element.Key;
				createDesc = element.GetType().Name;
			}
			else
			{
				return null;
			}

			//Remove any previous undos ahead of this one
			if (mUndoPointer < List.Count)
			{
				for (int i = mUndoPointer+1;  i < List.Count; i++)
				{
					List.RemoveAt(i);
				}
			}

			//Set description
			if (description == null || description == "")
			{
				if (action == UndoAction.Add)
				{
					undo.Description = "Add " + createDesc;
				}
				else if (action == UndoAction.Edit)
				{
					undo.Description = "Edit " + createDesc;
				}
				else if (action == UndoAction.Remove)
				{
					undo.Description = "Remove " + createDesc;
				}
			}
			else
			{
				undo.Description = description;
			}

			//Get current undopoint
			UndoPoint currentUndo = null;

			if (mUndoPointer > -1) currentUndo = (UndoPoint) List[mUndoPointer];

			//Check if must add or update the undopoint
			if (overwrite && mUndoPointer > -1 && action == UndoAction.Edit && currentUndo.Key == key)
			{
				List[mUndoPointer] = undo; 
			}
			else
			{
				//Add object to internal arraylist
				List.Add(undo);
				mUndoPointer = List.Count - 1;
			}

			return undo;
		}
 public TextChangedEventArgs(System.Windows.RoutedEvent id, UndoAction action, ICollection<TextChange> changes)
 {
 }
Ejemplo n.º 42
0
        public void DeleteComponentCommand(object sender, System.Windows.Input.ExecutedRoutedEventArgs e)
        {
            if (m_selectedComponents.Count > 0)
            {
                UndoAction undoAction = new UndoAction(UndoCommand.DeleteComponents, "delete", m_selectedComponents.ToArray());
                UndoManager.AddAction(undoAction);

                foreach (Component component in m_selectedComponents)
                {
                    Document.Elements.Remove(component);
                }
                m_selectedComponents.Clear();
                foreach (Component component in Document.Components)
                    component.DisconnectConnections();
                foreach (Component component in Document.Components)
                    component.ApplyConnections(Document);
                DrawConnections();

                // Clear selection box
                using (DrawingContext dc = m_selectedVisual.RenderOpen())
                {
                }
                // Clear resize visual
                using (DrawingContext dc = m_resizeVisual.RenderOpen())
                {
                }

            }
            else if (m_resizingComponent != null)
            {
                UndoAction undoAction = new UndoAction(UndoCommand.DeleteComponents, "delete", new Component[] { m_resizingComponent });
                UndoManager.AddAction(undoAction);

                Document.Elements.Remove(m_resizingComponent);
                m_resizingComponent = null;
                foreach (Component component in Document.Components)
                    component.DisconnectConnections();
                foreach (Component component in Document.Components)
                    component.ApplyConnections(Document);
                DrawConnections();

                // Clear selection box
                using (DrawingContext dc = m_selectedVisual.RenderOpen())
                {
                }
                // Clear resize visual
                using (DrawingContext dc = m_resizeVisual.RenderOpen())
                {
                }
            }
        }
Ejemplo n.º 43
0
        private void CommandPaste_Executed(object sender, ExecutedRoutedEventArgs e)
        {
            ComponentDeserializer deserializer = new ComponentDeserializer(Clipboard.GetData("CircuitDiagram.ComponentData") as string);
            deserializer.Components.ForEach(c => circuitDisplay.Document.Elements.Add(c));
            circuitDisplay.SetSelectedComponents(deserializer.Components);

            UndoAction action = new UndoAction(UndoCommand.AddComponents, "Add components", deserializer.Components.ToArray());
            UndoManager.AddAction(action);
        }
Ejemplo n.º 44
0
        public void PushUndoBlock(UndoAction Action, string Text, string ReplacedText, int x, int y)
        {
            UndoBlock undo = new UndoBlock();
            undo.Action = Action;
            undo.Text = Text;
            undo.ReplacedText = ReplacedText;
            undo.Position.Y = y;
            undo.Position.X = x;
            //AddToUndoList(undo);

            if (mCaptureMode)
            {
                mCaptureBlock.Add(undo);
            }
            else
            {
                AddToUndoList(undo);
            }
        }
Ejemplo n.º 45
0
        public void FlipComponentCommand(object sender, System.Windows.Input.ExecutedRoutedEventArgs e)
        {
            if (m_selectedComponents.Count == 1 && m_selectedComponents[0].Description.CanFlip)
            {
                m_selectedComponents[0].IsFlipped = !m_selectedComponents[0].IsFlipped;
                m_elementVisuals[m_selectedComponents[0]].UpdateVisual();
                m_selectedComponents[0].ResetConnections();
                m_selectedComponents[0].ApplyConnections(Document);

                UndoAction undoAction = new UndoAction(UndoCommand.ModifyComponents, "Flip component", new Component[] { m_selectedComponents[0] });
                undoAction.AddData("before", m_undoManagerBeforeData);
                Dictionary<Component, string> afterDictionary = new Dictionary<Component, string>(1);
                afterDictionary.Add(m_selectedComponents[0], m_selectedComponents[0].SerializeToString());
                undoAction.AddData("after", afterDictionary);
                UndoManager.AddAction(undoAction);
                m_undoManagerBeforeData = new Dictionary<Component, string>();
            }
            else if (m_resizingComponent != null && m_resizingComponent.Description.CanFlip)
            {
                Dictionary<Component, string> beforeData = new Dictionary<Component, string>();
                beforeData.Add(m_resizingComponent, m_resizingComponent.SerializeToString());

                m_resizingComponent.IsFlipped = !m_resizingComponent.IsFlipped;
                m_elementVisuals[m_resizingComponent].UpdateVisual();
                m_resizingComponent.ResetConnections();
                m_resizingComponent.ApplyConnections(Document);

                UndoAction undoAction = new UndoAction(UndoCommand.ModifyComponents, "Flip component", new Component[] { m_resizingComponent });
                undoAction.AddData("before", beforeData);
                Dictionary<Component, string> afterDictionary = new Dictionary<Component, string>(1);
                afterDictionary.Add(m_resizingComponent, m_resizingComponent.SerializeToString());
                undoAction.AddData("after", afterDictionary);
                UndoManager.AddAction(undoAction);
                m_undoManagerBeforeData = new Dictionary<Component, string>();
            }
        }
Ejemplo n.º 46
0
        protected override void OnMouseLeave(System.Windows.Input.MouseEventArgs e)
        {
            base.OnMouseLeave(e);

            if (m_resizing != ComponentResizeMode.None)
            {
                m_resizingComponent.ResetConnections();
                m_resizingComponent.ApplyConnections(Document);
                DrawConnections();

                UndoAction undoAction = new UndoAction(UndoCommand.ModifyComponents, "Move component", new Component[] { m_resizingComponent });
                undoAction.AddData("before", m_undoManagerBeforeData);
                Dictionary<Component, string> afterDictionary = new Dictionary<Component, string>(1);
                afterDictionary.Add(m_resizingComponent, m_resizingComponent.SerializeToString());
                undoAction.AddData("after", afterDictionary);
                UndoManager.AddAction(undoAction);
                m_undoManagerBeforeData = new Dictionary<Component, string>();

                m_resizing = ComponentResizeMode.None;
                this.Cursor = System.Windows.Input.Cursors.Arrow;
            }

            m_selectionBox = false;
            m_placingComponent = false;
        }
Ejemplo n.º 47
0
 /// <summary>
 /// constructor
 /// </summary>
 /// <param name="id">event id</param>
 /// <param name="action">UndoAction</param>
 public TextChangedEventArgs(RoutedEvent id, UndoAction action)
     : this(id, action, new ReadOnlyCollection<TextChange>(new List<TextChange>()))
 {
 }
Ejemplo n.º 48
0
 private void PushUndoOperation(TextBoxBase sender, UndoAction action)
 {
     undoStack.Push(new UndoOperation(sender, action));
     System.Diagnostics.Debug.WriteLine("PUSHED");
 }
Ejemplo n.º 49
0
 private void AddUndoableAction(TextBoxBase sender, UndoAction action)
 {
     if (action == UndoAction.Undo)
     {
         redoStack.Push(new UndoOperation(sender, action));
     }
     else
     {
         if (undoStack.Count > 0)
         {
             UndoOperation op = undoStack.Peek();
             if ((op.Sender == sender) && (action == UndoAction.Merge))
             {
                 // no-op
             }
             else
             {
                 PushUndoOperation(sender, action);
             }
         }
         else
         {
             PushUndoOperation(sender, action);
         }
     }
 }
Ejemplo n.º 50
0
        public void PushUndoBlock(UndoAction Action, string Text, int x, int y, RowRevisionMark mark)
        {
            var undo = new UndoBlock();
            undo.Action = Action;
            undo.Text = Text;
            undo.Position.Y = y;
            undo.Position.X = x;
            undo.RowModified = (mark != RowRevisionMark.Unchanged);
            //AddToUndoList(undo);

            if (captureMode)
            {
                captureBlock.Add(undo);
            }
            else
            {
                AddToUndoList(undo);
            }
        }
Ejemplo n.º 51
0
        protected override void OnMouseLeftButtonUp(System.Windows.Input.MouseButtonEventArgs e)
        {
            base.OnMouseUp(e);

            m_movingMouse = false;
            if (m_resizing != ComponentResizeMode.None)
            {
                m_resizingComponent.ResetConnections();
                m_resizingComponent.ApplyConnections(Document);
                DrawConnections();

                UndoAction undoAction = new UndoAction(UndoCommand.ModifyComponents, "Move component", new Component[] { m_resizingComponent });
                undoAction.AddData("before", m_undoManagerBeforeData);
                Dictionary<Component, string> afterDictionary = new Dictionary<Component, string>(1);
                afterDictionary.Add(m_resizingComponent, m_resizingComponent.SerializeToString());
                undoAction.AddData("after", afterDictionary);
                UndoManager.AddAction(undoAction);
                m_undoManagerBeforeData = new Dictionary<Component, string>();
            }
            m_resizing = ComponentResizeMode.None;
            this.Cursor = System.Windows.Input.Cursors.Arrow;
            m_resizingComponent = null;

            if (m_placingComponent)
            {
                Component newComponent = Component.Create(NewComponentData);
                ComponentHelper.SizeComponent(newComponent, m_mouseDownPos, e.GetPosition(this));

                // Flip if necessary
                if (newComponent.Orientation == Orientation.Horizontal && newComponent.Description.CanFlip)
                {
                    if (m_mouseDownPos.X > e.GetPosition(this).X)
                        newComponent.IsFlipped = true;
                    else
                        newComponent.IsFlipped = false;
                }
                else if (newComponent.Description.CanFlip)
                {
                    if (m_mouseDownPos.Y > e.GetPosition(this).Y)
                        newComponent.IsFlipped = true;
                    else
                        newComponent.IsFlipped = false;
                }

                Document.Elements.Add(newComponent);
                newComponent.ApplyConnections(Document);
                DrawConnections();
                m_placingComponent = false;

                UndoAction undoAction = new UndoAction(UndoCommand.AddComponents, "Add component", new Component[] { newComponent });
                UndoManager.AddAction(undoAction);

                RemoveVisualChild(m_elementVisuals[m_tempComponent]);
                RemoveLogicalChild(m_elementVisuals[m_tempComponent]);
                m_elementVisuals.Remove(m_tempComponent);
                m_tempComponent = null;
            }
            else if (m_selectedComponents.Count > 0)
            {
                Dictionary<Component, string> afterData = new Dictionary<Component, string>();

                foreach (Component component in m_selectedComponents)
                {
                    string afterDataString = component.SerializeToString();
                    if (afterDataString == m_undoManagerBeforeData[component])
                        break;

                    afterData.Add(component, afterDataString);
                }

                if (afterData.Count > 0)
                {
                    UndoAction undoAction = new UndoAction(UndoCommand.ModifyComponents, "move", m_selectedComponents.ToArray());
                    undoAction.AddData("before", m_undoManagerBeforeData);
                    undoAction.AddData("after", afterData);
                    UndoManager.AddAction(undoAction);
                    m_undoManagerBeforeData = new Dictionary<Component, string>();
                }
            }
            else if (m_selectionBox)
            {
                using (DrawingContext dc = m_selectedVisual.RenderOpen())
                {
                    enclosingRect = Rect.Empty;

                    VisualTreeHelper.HitTest(this, new HitTestFilterCallback(delegate(DependencyObject testObject)
                    {
                        if (testObject is CircuitElementDrawingVisual)
                            return HitTestFilterBehavior.ContinueSkipChildren;
                        else
                            return HitTestFilterBehavior.ContinueSkipSelf;
                    }),
                    new HitTestResultCallback(delegate(HitTestResult result)
                    {
                        m_selectedComponents.Add((result.VisualHit as CircuitElementDrawingVisual).CircuitElement as Component);

                        if (result.VisualHit is CircuitElementDrawingVisual)
                        {
                            Rect rect = VisualTreeHelper.GetContentBounds(result.VisualHit as Visual);
                            dc.PushTransform(new TranslateTransform((result.VisualHit as CircuitElementDrawingVisual).Offset.X, (result.VisualHit as CircuitElementDrawingVisual).Offset.Y));
                            dc.DrawRectangle(new SolidColorBrush(Color.FromArgb(100, 0, 0, 100)), null, rect);
                            dc.Pop();

                            if (enclosingRect.IsEmpty)
                            {
                                rect.Offset((result.VisualHit as CircuitElementDrawingVisual).Offset.X, (result.VisualHit as CircuitElementDrawingVisual).Offset.Y);
                                enclosingRect = rect;
                            }
                            else
                            {
                                rect.Offset((result.VisualHit as CircuitElementDrawingVisual).Offset.X, (result.VisualHit as CircuitElementDrawingVisual).Offset.Y);
                                enclosingRect.Union(rect);
                            }
                        }

                        return HitTestResultBehavior.Continue;
                    }), new GeometryHitTestParameters(new RectangleGeometry(new Rect(m_mouseDownPos, e.GetPosition(this)))));

                    dc.DrawRectangle(Brushes.Transparent, new Pen(Brushes.Black, 1d), enclosingRect);
                }

                m_selectionBox = false;
            }
        }
Ejemplo n.º 52
0
		public new UndoPoint Add(Element element, UndoAction action, string description, bool overwrite)
		{
			return AddPoint(element, action, description, overwrite);
		}
Ejemplo n.º 53
0
        public void RotateComponentCommand_Executed(object sender, System.Windows.Input.ExecutedRoutedEventArgs e)
        {
            if (m_selectedComponents.Count == 1)
            {
                m_selectedComponents[0].Orientation = m_selectedComponents[0].Orientation.Reverse();
                m_selectedComponents[0].ResetConnections();
                RedrawComponent(m_selectedComponents[0]);
                foreach (Component component in Document.Components)
                    component.DisconnectConnections();
                foreach (Component component in Document.Components)
                    component.ApplyConnections(Document);
                DrawConnections();

                UndoAction undoAction = new UndoAction(UndoCommand.ModifyComponents, "Rotate component", new Component[] { m_selectedComponents[0] });
                undoAction.AddData("before", m_undoManagerBeforeData);
                Dictionary<Component, string> afterDictionary = new Dictionary<Component, string>(1);
                afterDictionary.Add(m_selectedComponents[0], m_selectedComponents[0].SerializeToString());
                undoAction.AddData("after", afterDictionary);
                UndoManager.AddAction(undoAction);
                m_undoManagerBeforeData = new Dictionary<Component, string>();
            }
            else if (m_resizingComponent != null)
            {
                Dictionary<Component, string> beforeData = new Dictionary<Component, string>();
                beforeData.Add(m_resizingComponent, m_resizingComponent.SerializeToString());

                m_resizingComponent.Orientation = m_resizingComponent.Orientation.Reverse();
                m_resizingComponent.ResetConnections();
                RedrawComponent(m_resizingComponent);
                foreach (Component component in Document.Components)
                    component.DisconnectConnections();
                foreach (Component component in Document.Components)
                    component.ApplyConnections(Document);
                DrawConnections();

                UndoAction undoAction = new UndoAction(UndoCommand.ModifyComponents, "Rotate component", new Component[] { m_resizingComponent });
                undoAction.AddData("before", beforeData);
                Dictionary<Component, string> afterDictionary = new Dictionary<Component, string>(1);
                afterDictionary.Add(m_resizingComponent, m_resizingComponent.SerializeToString());
                undoAction.AddData("after", afterDictionary);
                UndoManager.AddAction(undoAction);
                m_undoManagerBeforeData = new Dictionary<Component, string>();
            }
        }
Ejemplo n.º 54
0
		public new UndoPoint Add(Element element, UndoAction action, string description)
		{
			return AddPoint(element, action, description, false);
		}
Ejemplo n.º 55
0
		public void PushUndoBlock(UndoAction Action, string Text, int x, int y)
		{
            PushUndoBlock(Action, Text, "", x, y);
		}
Ejemplo n.º 56
0
		public new UndoPoint Add(Element element, UndoAction action, bool overwrite)
		{
			return AddPoint(element, action, "", overwrite);
		}
Ejemplo n.º 57
0
        public void PushUndoBlock(UndoAction Action, string text, int x, int y)
        {
            var undo = new UndoBlock {
                           Action = Action,
                           Text = text
                       };

            undo.Position.Y = y;
            undo.Position.X = x;
            //AddToUndoList(undo);

            if (captureMode)
            {
                captureBlock.Add(undo);
            }
            else
            {
                AddToUndoList(undo);
            }
        }
Ejemplo n.º 58
0
		//Methods
		//Adds a new element to the list
		public new UndoPoint Add(Element element, UndoAction action)
		{
			return AddPoint(element, action, "", false);
		}
Ejemplo n.º 59
0
 private void mnuEditResizeDocument(object sender, RoutedEventArgs e)
 {
     winDocumentSize docSizeWindow = new winDocumentSize();
     docSizeWindow.Owner = this;
     docSizeWindow.DocumentWidth = circuitDisplay.Document.Size.Width;
     docSizeWindow.DocumentHeight = circuitDisplay.Document.Size.Height;
     if (docSizeWindow.ShowDialog() == true)
     {
         Size newSize = new Size(docSizeWindow.DocumentWidth, docSizeWindow.DocumentHeight);
         if (newSize != circuitDisplay.Document.Size)
         {
             UndoAction resizeAction = new UndoAction(UndoCommand.ResizeDocument, "Resize document");
             resizeAction.AddData("before", circuitDisplay.Document.Size);
             circuitDisplay.Document.Size = newSize;
             circuitDisplay.DocumentSizeChanged();
             resizeAction.AddData("after", newSize);
             UndoManager.AddAction(resizeAction);
         }
     }
 }
Ejemplo n.º 60
0
        void Editor_ComponentUpdated(object sender, ComponentUpdatedEventArgs e)
        {
            UndoAction undoAction = new UndoAction(UndoCommand.ModifyComponents, "edit", new Component[] { e.Component });
            Dictionary<Component, string> previousData = new Dictionary<Component, string>(1);
            previousData.Add(e.Component, e.PreviousData);
            undoAction.AddData("before", previousData);
            Dictionary<Component, string> newData = new Dictionary<Component, string>(1);
            newData.Add(e.Component, e.Component.SerializeToString());
            undoAction.AddData("after", newData);
            UndoManager.AddAction(undoAction);

            // Update connections
            e.Component.ResetConnections();
            e.Component.ApplyConnections(circuitDisplay.Document);
            circuitDisplay.DrawConnections();
        }