private void OnDebuggerBreak(DiagramElement element)
		{
			this.GuiAsync(() =>
			{
				ShowElementProperties(element);
			});
		}
		private void OnDebuggerBreak(DiagramElement element)
		{
			this.GuiAsync(() =>
			{
				ShowElementProperties(element);
				CommandManager.InvalidateRequerySuggested();
			});
		}
		private void ShowElementProperties(DiagramElement element)
		{
			if (element != null)
			{
				if (PropertyGridControl.SelectedObject == element)
					PropertyGridControl.SelectedObject = null;

				PropertyGridControl.SelectedObject = new DiagramElementParameters(element);
				PropertyGridControl.IsReadOnly = true;
			}
			else
				PropertyGridControl.SelectedObject = null;
		}
Example #4
0
 private void OnDebuggerBreak(DiagramElement element)
 {
     GuiDispatcher.GlobalDispatcher.AddAction(() => ShowElementProperties(element));
 }
		private void OnDebuggerBreak(DiagramElement element)
		{
			GuiDispatcher.GlobalDispatcher.AddAction(() => ShowElementProperties(element));
		}
 internal override void Init(DiagramElement element)
 {
     shape = (EnumShape)element;
     base.Init(element);
 }
        /// <summary>
        /// Распарсить XMI файл и создать объекты соответствующих классов
        /// </summary>
        /// <param name="diagram">Исходная диаграмма</param>
        /// <param name="hasJoinOrFork">Имеется ли join\fork</param>
        /// <returns></returns>
        public bool Parse(Diagram diagram, ref bool hasJoinOrFork)
        {
            xmlFile = diagram.doc;
            XmlNodeList xPackagedList;

            try {
                xPackagedList = xmlFile.GetElementsByTagName("packagedElement");
            } catch (NullReferenceException) {
                //Console.WriteLine("[x] Тег packagedElement не найден");
                return(false);
            }


            // получим корневой элемент
            XmlNode xRoot = FindActivePackageEl(xPackagedList);

            if (xRoot == null)
            {
                //Console.WriteLine("[x] Вид диаграммы не AD");
                return(false);
            }

            var attr = xRoot.Attributes["xsi:type"];

            if (attr == null)
            {
                //Console.WriteLine("[x] Не удалось распарсить xmi файл");
                return(false);
            }
            if (!attr.Value.Equals("uml:Activity"))
            {
                //Console.WriteLine("[x] Вид диаграммы не AD");
                return(false);
            }

            // пройтись по всем тегам и создать объекты
            foreach (XmlNode node in xRoot.ChildNodes)
            {
                var elAttr = node.Attributes["xsi:type"];
                if (elAttr == null)
                {
                    continue;
                }

                if (elAttr.Value == "uml:OpaqueAction" || elAttr.Value == "uml:InitialNode" || elAttr.Value == "uml:ActivityFinalNode" ||
                    elAttr.Value == "uml:FlowFinalNode" || elAttr.Value == "uml:DecisionNode" || elAttr.Value == "uml:MergeNode" ||
                    elAttr.Value == "uml:ForkNode" || elAttr.Value == "uml:JoinNode")
                {
                    DiagramElement nodeFromXMI = null;
                    switch (elAttr.Value)
                    {
                    // активность
                    case "uml:OpaqueAction":
                        nodeFromXMI = new ActivityNode(node.Attributes["xmi:id"].Value,
                                                       AttrAdapter(node.Attributes["inPartition"]), AttrAdapter(node.Attributes["name"]));
                        nodeFromXMI.setType(ElementType.ACTIVITY);
                        adNodesList.addLast(nodeFromXMI);
                        break;

                    // узел инициализации
                    case "uml:InitialNode":
                        nodeFromXMI = new InitialNode(node.Attributes["xmi:id"].Value, AttrAdapter(node.Attributes["inPartition"]));
                        nodeFromXMI.setType(ElementType.INITIAL_NODE);
                        adNodesList.addLast(nodeFromXMI);
                        break;

                    // конечное состояние
                    case "uml:ActivityFinalNode":
                    case "uml:FlowFinalNode":
                        nodeFromXMI = new FinalNode(node.Attributes["xmi:id"].Value, AttrAdapter(node.Attributes["inPartition"]));
                        nodeFromXMI.setType(ElementType.FINAL_NODE);
                        adNodesList.addLast(nodeFromXMI);
                        break;

                    // условный переход
                    case "uml:DecisionNode":
                        nodeFromXMI = new DecisionNode(node.Attributes["xmi:id"].Value, AttrAdapter(node.Attributes["inPartition"]), AttrAdapter(node.Attributes["question"]));
                        nodeFromXMI.setType(ElementType.DECISION);
                        adNodesList.addLast(nodeFromXMI);
                        break;

                    // узел слияния
                    case "uml:MergeNode":
                        nodeFromXMI = new MergeNode(node.Attributes["xmi:id"].Value, AttrAdapter(node.Attributes["inPartition"]));
                        nodeFromXMI.setType(ElementType.MERGE);
                        adNodesList.addLast(nodeFromXMI);
                        break;

                    // разветвитель
                    case "uml:ForkNode":
                        nodeFromXMI = new ForkNode(node.Attributes["xmi:id"].Value, AttrAdapter(node.Attributes["inPartition"]));
                        nodeFromXMI.setType(ElementType.FORK);
                        adNodesList.addLast(nodeFromXMI);
                        hasJoinOrFork = true;
                        break;

                    // синхронизатор
                    case "uml:JoinNode":
                        nodeFromXMI = new JoinNode(node.Attributes["xmi:id"].Value, AttrAdapter(node.Attributes["inPartition"]));
                        nodeFromXMI.setType(ElementType.JOIN);
                        adNodesList.addLast(nodeFromXMI);
                        hasJoinOrFork = true;
                        break;
                    }
                    // добавляем ид входящих и выходящих переходов
                    if (nodeFromXMI != null)
                    {
                        string idsIn  = node.Attributes["incoming"]?.Value;
                        string idsOut = node.Attributes["outgoing"]?.Value;
                        nodeFromXMI.addIn(idsIn ?? "");
                        nodeFromXMI.addOut(idsOut ?? "");
                    }
                }
                // создаем переход
                else if (node.Attributes["xsi:type"].Value.Equals("uml:ControlFlow"))
                {
                    // находим подпись перехода
                    var    markNode = node.ChildNodes[1];
                    string mark     = markNode.Attributes["value"].Value.Trim();    // если подпись является "yes", значит это подпись по умолчанию

                    ControlFlow temp = new ControlFlow(node.Attributes["xmi:id"].Value, mark.Equals("true") ? "" : mark);
                    temp.setType(ElementType.FLOW);
                    temp.setSrc(AttrAdapter(node.Attributes["source"]));
                    temp.setTarget(AttrAdapter(node.Attributes["target"]));
                    adNodesList.addLast(temp);
                }
                // создаем дорожку
                else if (node.Attributes["xsi:type"].Value.Equals("uml:ActivityPartition"))
                {
                    Swimlane temp = new Swimlane(node.Attributes["xmi:id"].Value, AttrAdapter(node.Attributes["name"]))
                    {
                        ChildCount = node.Attributes["node"] == null ? 0 : node.Attributes["node"].Value.Split().Length
                    };
                    temp.setType(ElementType.SWIMLANE);
                    if (temp.Name != "")
                    {
                        diagram.Actors.Add(temp);
                    }
                    adNodesList.addLast(temp);
                }
                // неизвестный элемент
                else
                {
                    var unknownNode = new UnknownNode(node.Attributes["xmi:id"].Value);
                    unknownNode.setType(ElementType.UNKNOWN);
                    unknownNodes.Add(unknownNode);
                }
            }

            XmlNode coordRoot = null;

            try {
                coordRoot = xmlFile.GetElementsByTagName("plane")[0];
            } catch (NullReferenceException) {
                //Console.WriteLine("[x] Тег packagedElement не найден");
            }

            if (coordRoot != null)
            {
                FindCoordinates(coordRoot, diagram);
            }
            for (int i = 0; i < adNodesList.size(); i++)
            {
                var node = adNodesList.get(i);
                if (node is DiagramElement)
                {
                    var nodeFromXMI = (DiagramElement)node;
                    switch (nodeFromXMI.getType())
                    {
                    case ElementType.FINAL_NODE:
                        if (nodeFromXMI.inSize() == 0)
                        {
                            // ошибка
                            ADMistakeFactory.createMistake(MistakesSeriousness.mistakes[MISTAKES.NO_IN], MistakeAdapter.toString(MISTAKES.NO_IN), new ADNodesList.ADNode(nodeFromXMI), ALL_MISTAKES.NO_IN);
                        }
                        break;

                    case ElementType.INITIAL_NODE:
                        if (nodeFromXMI.outSize() == 0)
                        {
                            // ошибка
                            ADMistakeFactory.createMistake(MistakesSeriousness.mistakes[MISTAKES.NO_OUT], MistakeAdapter.toString(MISTAKES.NO_OUT), new ADNodesList.ADNode(nodeFromXMI), ALL_MISTAKES.NO_OUT);
                        }
                        break;

                    default:
                        if (nodeFromXMI.inSize() == 0 || nodeFromXMI.outSize() == 0)
                        {
                            // ошибка
                            if (nodeFromXMI.inSize() == 0)
                            {
                                ADMistakeFactory.createMistake(MistakesSeriousness.mistakes[MISTAKES.NO_IN], MistakeAdapter.toString(MISTAKES.NO_IN), new ADNodesList.ADNode(nodeFromXMI), ALL_MISTAKES.NO_IN);
                            }
                            if (nodeFromXMI.outSize() == 0)
                            {
                                ADMistakeFactory.createMistake(MistakesSeriousness.mistakes[MISTAKES.NO_OUT], MistakeAdapter.toString(MISTAKES.NO_OUT), new ADNodesList.ADNode(nodeFromXMI), ALL_MISTAKES.NO_OUT);
                            }
                        }
                        break;
                    }
                }
            }
            // ошибка - тип элемента не принадлежит AD
            foreach (var node in unknownNodes)
            {
                ADMistakeFactory.createMistake(MistakesSeriousness.mistakes[MISTAKES.FORBIDDEN_ELEMENT], MistakeAdapter.toString(MISTAKES.FORBIDDEN_ELEMENT), node, ALL_MISTAKES.FORBIDDEN_ELEMENT);
            }

            return(true);
        }
 private void DiagramEditor_OnSelectionChanged(DiagramElement element)
 {
     ShowElementProperties(element);
 }
 public List<DiagramElement> SetElement(DiagramElement element)
 {
     elements.Clear ();
     elements.Add (element);
     return GetElements ();
 }
		private void OnDiagramEditorElementDoubleClicked(DiagramElement element)
		{
			var composition = element as CompositionDiagramElement;

			if (composition == null)
				return;

			Debugger.StepInto(composition);
		}
Example #11
0
 internal abstract void Init(DiagramElement element);
Example #12
0
 internal abstract void Relocate(DiagramElement element);
Example #13
0
 internal override void Init(DiagramElement element)
 {
     Connection = (TransitionConnection)element;
     RefreshValues();
 }
Example #14
0
 internal override void Relocate(DiagramElement element)
 {
     Relocate((PackageShape)element);
 }
Example #15
0
 internal override void Init(DiagramElement element)
 {
     Shape = (StateShape)element;
     RefreshValues();
 }
        //private void ExecutedSaveComposition(object sender, ExecutedRoutedEventArgs e)
        //{
        //	var composition = (CompositionDiagramElement)DiagramPanel.PaletteElement;

        //	composition.Name = CompositionName.Text;
        //	composition.Parameters.First(p => p.Name.CompareIgnoreCase("Category")).Value = CompositionCategory.Text;

        //	ConfigManager
        //		.GetService<CompositionRegistry>()
        //		.Save(composition);
        //}

        //private void CanExecuteSaveComposition(object sender, CanExecuteRoutedEventArgs e)
        //{
        //	e.CanExecute = DiagramPanel != null && DiagramPanel.PaletteElement != null && DiagramPanel.PaletteElement is CompositionDiagramElement &&
        //				   (!CompositionName.Text.IsEmpty() && CompositionName.Text != DiagramPanel.PaletteElement.Name ||
        //				   !CompositionCategory.Text.IsEmpty() && CompositionCategory.Text != DiagramPanel.PaletteElement.Category);
        //}

        private static DiagramElementParam <T> GetParameter <T>(DiagramElement element, string name)
        {
            return((DiagramElementParam <T>)element.Parameters.First(p => p.Name.CompareIgnoreCase(name)));
        }
Example #17
0
 /// <summary>
 /// Notifies the data context (represented by this Diagram Content) that a previously registered position-dependent diagram element has moved.
 /// </summary>
 /// <param name="dependentElement">The dependent element.</param>
 /// <returns>
 /// A result containing information if layout changes are required with new suggested values.
 /// </returns>
 public ParentHasMovedNotificationResult NotifyDiagramContentParentHasMoved(DiagramElement dependentElement)
 {
     return new ParentHasMovedNotificationResult();
 }
		private void DiagramEditor_OnPaletteSelectionChanged(DiagramElement element)
		{
			PaletteSelectionChanged.SafeInvoke(element);
		}
 private void DiagramEditor_OnPaletteSelectionChanged(DiagramElement element)
 {
     PaletteSelectionChanged.SafeInvoke(element);
 }
Example #20
0
 internal override void Init(DiagramElement element)
 {
     Shape = (CompositeTypeShape)element;
     RefreshValues();
 }
Example #21
0
 internal sealed override void Relocate(DiagramElement element)
 {
     Relocate((TypeShape)element);
 }
Example #22
0
 internal override void Init(DiagramElement element)
 {
     Shape = (DelegateShape)element;
     base.Init(element);
 }
Example #23
0
 internal abstract override void Relocate(DiagramElement element);
		private void ShowElementProperties(DiagramElement element)
		{
			if (element != null)
			{
				if (PropertyGridControl.SelectedObject == element)
					PropertyGridControl.SelectedObject = null;

				PropertyGridControl.SelectedObject = new DiagramElementParameters(element);
				PropertyGridControl.IsReadOnly = true;
			}
			else
			{
				PropertyGridControl.SelectedObject = Strategy;
				PropertyGridControl.IsReadOnly = Strategy.ProcessState != ProcessStates.Stopped;
			}
		}
Example #25
0
 internal override void Init(DiagramElement element)
 {
     RefreshValues();
 }
Example #26
0
 internal override void Relocate(DiagramElement element)
 {
     Relocate((CompositeTypeShape)element);
 }
		private void DiagramEditor_OnElementDoubleClicked(DiagramElement element)
		{
			var compositionElement = element as CompositionDiagramElement;

			if (compositionElement == null)
				return;

			var originalComposition = ConfigManager
				.GetService<StrategiesRegistry>()
				.DiagramElements
				.OfType<CompositionDiagramElement>()
				.First(c => c.TypeId == compositionElement.TypeId);

			ConfigManager
				.GetService<LayoutManager>()
				.OpenDocumentWindow(new DiagramEditorControl
				{
					Composition = new CompositionItem(CompositionType.Composition, originalComposition)
				});
        }
Example #28
0
 internal override void Relocate(DiagramElement element)
 {
     throw new System.NotImplementedException();
 }
Example #29
0
 private void DiagramEditor_OnSelectionChanged(DiagramElement element)
 {
     PropertyGridControl.SelectedObject = element;
 }
		private void DiagramEditor_OnSelectionChanged(DiagramElement element)
		{
			ShowElementProperties(element);
		}
		private void DiagramEditor_OnElementDoubleClicked(DiagramElement element)
		{
			var composition = element as CompositionDiagramElement;

			if (composition == null)
				return;

			var originalComposition = (CompositionDiagramElement)ConfigManager
				.GetService<CompositionRegistry>()
				.DiagramElements
				.First(e => e.TypeId == composition.TypeId);

			new OpenCompositionCommand(originalComposition).Process(this);
		}
Example #32
0
 internal override void Relocate(DiagramElement element)
 {
     Relocate((EnumShape)element);
 }
Example #33
0
 internal override void Init(DiagramElement element)
 {
     Connection = (SourceSinkConnection)element;
     RefreshValues();
 }
Example #34
0
 internal override void Init(DiagramElement element)
 {
     shape = (CompositeTypeShape)element;
     RefreshToolAvailability();
     RefreshValues();
 }
 public bool IsMainSelection(DiagramElement element)
 {
     return false;
 }
Example #36
0
 internal virtual void Init(DiagramElement element)
 {
 }
 public List<DiagramElement> AddElement(DiagramElement element)
 {
     elements.Add (element);
     return GetElements ();
 }
		private void Palette_OnElementDoubleClicked(DiagramElement element)
		{
			var composition = element as CompositionDiagramElement;

			if (composition != null)
				new OpenCompositionCommand(composition).Process(this, true);
		}
 public List<DiagramElement> RemoveElement(DiagramElement element)
 {
     elements.Remove (element);
     return GetElements ();
 }
		private void DiagramEditor_OnSelectionChanged(DiagramElement element)
		{
			PropertyGrid.SelectedObject = element;
		}
Example #41
0
        void ResizeControl_DragDelta(object sender, DragDeltaEventArgs e)
        {
            DiagramElement DiagramElement = this.DataContext as DiagramElement;
            DiagramCanvas  designer       = VisualTreeHelper.GetParent(DiagramElement) as DiagramCanvas;

            if (DiagramElement != null && designer != null && DiagramElement.IsSelected)
            {
                double minLeft, minTop, minDeltaHorizontal, minDeltaVertical;
                double dragDeltaVertical, dragDeltaHorizontal, scale;

                IEnumerable <DiagramElement> selectedDiagramElements = designer.SelectionService.CurrentSelection.OfType <DiagramElement>();

                CalculateDragLimits(selectedDiagramElements, out minLeft, out minTop,
                                    out minDeltaHorizontal, out minDeltaVertical);

                foreach (DiagramElement item in selectedDiagramElements)
                {
                    if (item != null && item.ParentID == Guid.Empty)
                    {
                        switch (base.VerticalAlignment)
                        {
                        case VerticalAlignment.Bottom:
                            dragDeltaVertical = Math.Min(-e.VerticalChange, minDeltaVertical);
                            scale             = (item.ActualHeight - dragDeltaVertical) / item.ActualHeight;
                            DragBottom(scale, item, designer.SelectionService);
                            break;

                        case VerticalAlignment.Top:
                            double top = Canvas.GetTop(item);
                            dragDeltaVertical = Math.Min(Math.Max(-minTop, e.VerticalChange), minDeltaVertical);
                            scale             = (item.ActualHeight - dragDeltaVertical) / item.ActualHeight;
                            DragTop(scale, item, designer.SelectionService);
                            break;

                        default:
                            break;
                        }

                        switch (base.HorizontalAlignment)
                        {
                        case HorizontalAlignment.Left:
                            double left = Canvas.GetLeft(item);
                            dragDeltaHorizontal = Math.Min(Math.Max(-minLeft, e.HorizontalChange), minDeltaHorizontal);
                            scale = (item.ActualWidth - dragDeltaHorizontal) / item.ActualWidth;
                            DragLeft(scale, item, designer.SelectionService);
                            break;

                        case HorizontalAlignment.Right:
                            dragDeltaHorizontal = Math.Min(-e.HorizontalChange, minDeltaHorizontal);
                            scale = (item.ActualWidth - dragDeltaHorizontal) / item.ActualWidth;
                            DragRight(scale, item, designer.SelectionService);
                            break;

                        default:
                            break;
                        }
                    }
                }
                e.Handled = true;
            }
        }