private static void RegisterAddCommand(this ConfigElementNode elementNode, ConfigElementNodeBuilder builder,
                                               string elementType, string elementEditor = null, string commandText = null, string commandImage = null)
        {
            if (elementNode.AddCommands == null)
            {
                elementNode.AddCommands = new List <ICommand <object> >();
            }

            if (string.IsNullOrEmpty(elementEditor))
            {
                elementEditor = "EditView";
            }

            if (string.IsNullOrEmpty(commandText))
            {
                MetadataTypeNames.TryGetValue(elementType, out commandText);
            }

            if (string.IsNullOrEmpty(commandImage))
            {
                commandImage = elementType;
            }

            elementNode.AddCommands.AddItem(new AddElementCommand(builder, elementNode, elementEditor, elementType)
            {
                Text  = commandText,
                Image = commandImage
            });
        }
Exemplo n.º 2
0
 public DeleteElementCommand(ConfigElementNodeBuilder builder, ICollection <ConfigElementNode> elements,
                             ConfigElementNode elementNode)
 {
     _builder     = builder;
     _elements    = elements;
     _elementNode = elementNode;
 }
Exemplo n.º 3
0
 private static void RefreshNode(ConfigElementNode parentNode)
 {
     if (parentNode.RefreshCommand.CanExecute(true))
     {
         parentNode.RefreshCommand.Execute(true);
     }
 }
        public static void RegisterEditCommand(this ConfigElementNode elementNode, ConfigElementNodeBuilder builder,
                                               string elementEditor = null, string commandText = null, string commandImage = null)
        {
            if (elementNode.EditCommands == null)
            {
                elementNode.EditCommands = new List <ICommand <object> >();
            }

            if (string.IsNullOrEmpty(elementEditor))
            {
                elementEditor = "EditView";
            }

            if (string.IsNullOrEmpty(commandText))
            {
                commandText = Resources.Edit;
            }

            if (string.IsNullOrEmpty(commandImage))
            {
                commandImage = "Actions/Edit";
            }

            elementNode.EditCommands.AddItem(new EditElementCommand(builder, elementNode, elementEditor)
            {
                Text  = commandText,
                Image = commandImage
            });
        }
Exemplo n.º 5
0
        public void Create(ConfigElementNodeBuilder builder, ICollection <ConfigElementNode> elements,
                           ConfigElementNode elementNode)
        {
            var contentDirectory = ConfigurationManager.AppSettings["ContentDirectory"];

            if (string.IsNullOrEmpty(contentDirectory))
            {
                contentDirectory = Path.Combine("..", "Assemblies", "content");
            }

            var contentPath = Path.GetFullPath(contentDirectory);

            elementNode.ElementId   = contentPath;
            elementNode.ElementName = contentPath;
            elementNode.Version     = builder.Version;

            elementNode.RefreshCommand = new RefreshElementCommand(builder, elements, elementNode, MetadataType.Configuration);
            elementNode.RegisterAddCommands(builder, ElementChildrenTypes);
            elementNode.EditCommands = new[] { new ReconnectCommand(builder, elementNode, "EditView")
                                               {
                                                   Text = Resources.Reconnect, Image = ElementType
                                               } };
            elementNode.DeleteCommand = FactoryHelper.NoDeleteCommand;
            elementNode.CopyCommand   = FactoryHelper.NoCopyCommand;
            elementNode.PasteCommand  = FactoryHelper.NoPasteCommand;

            elementNode.RefreshCommand.TryExecute();
        }
 public AddElementCommand(ConfigElementNodeBuilder builder, ConfigElementNode elementNode, string elementEditor,
                          string elementType)
 {
     _builder       = builder;
     _elementNode   = elementNode;
     _elementEditor = elementEditor;
     _elementType   = elementType;
 }
        public static string BuildId(ConfigElementNode elementNode)
        {
            var elementMetadata = elementNode.ElementMetadata;

            var name = ((elementMetadata.Name as string) ?? String.Empty).Trim();

            return(name);
        }
Exemplo n.º 8
0
 public RefreshElementCommand(ConfigElementNodeBuilder builder, ICollection <ConfigElementNode> elements,
                              ConfigElementNode elementNode, string elementType)
 {
     _builder     = builder;
     _elements    = elements;
     _elementNode = elementNode;
     _elementType = elementType;
 }
        public static IDataProvider GetMetadataProvider(ConfigElementNode elementNode, string elementType, string server, int port, string routeVersion)
        {
            var metadataProvider = new MetadataProvider(elementType);

            metadataProvider.SetConfigId(elementNode.ConfigId);
            metadataProvider.SetDocumentId(elementNode.DocumentId);
            metadataProvider.SetVersion(elementNode.Version);
            return(metadataProvider);
        }
        public static void RemoveNode(ICollection <ConfigElementNode> elements, ConfigElementNode elementNode)
        {
            RemoveChildNodes(elements, elementNode);
            elements.Remove(elementNode);

            if (elementNode.Parent != null)
            {
                elementNode.Parent.Nodes.Remove(elementNode);
            }
        }
        public static void RegisterPasteCommand(this ConfigElementNode elementNode, ConfigElementNodeBuilder builder,
                                                string elementEditor = null)
        {
            if (string.IsNullOrEmpty(elementEditor))
            {
                elementEditor = "EditView";
            }

            elementNode.PasteCommand = new PasteElementCommand(builder, elementNode, elementEditor);
        }
        public static void AddEmptyElement(ICollection <ConfigElementNode> elements, ConfigElementNode elementParent)
        {
            var emptyElement = new ConfigElementNode(elementParent, null, null)
            {
                ElementName = Resources.Loading
            };

            elementParent.Nodes.Add(emptyElement);
            elements.Add(emptyElement);
        }
        public static void RegisterAddCommands(this ConfigElementNode elementNode, ConfigElementNodeBuilder builder,
                                               string[] elementChildrenTypes)
        {
            elementNode.ElementChildrenTypes = elementChildrenTypes;

            foreach (var elementType in elementChildrenTypes)
            {
                elementNode.RegisterAddCommand(builder, elementType);
            }
        }
        public void Create(ConfigElementNodeBuilder builder, ICollection <ConfigElementNode> elements,
                           ConfigElementNode elementNode)
        {
            elementNode.ElementId   = FactoryHelper.BuildId(elementNode);
            elementNode.ElementName = FactoryHelper.BuildName(elementNode);

            elementNode.RefreshCommand = FactoryHelper.NoRefreshCommand;
            elementNode.RegisterEditCommand(builder);
            elementNode.DeleteCommand = new DeleteElementCommand(builder, elements, elementNode);
            elementNode.RegisterCopyCommand();
            elementNode.PasteCommand = FactoryHelper.NoPasteCommand;
        }
Exemplo n.º 15
0
        public void Create(ConfigElementNodeBuilder builder, ICollection <ConfigElementNode> elements,
                           ConfigElementNode elementNode)
        {
            elementNode.ElementName = Resources.ScenarioContainer;

            elementNode.RefreshCommand = new RefreshElementCommand(builder, elements, elementNode, MetadataType.Scenario);
            elementNode.RegisterAddCommands(builder, ElementChildrenTypes);
            elementNode.DeleteCommand = FactoryHelper.NoDeleteCommand;
            elementNode.CopyCommand   = FactoryHelper.NoCopyCommand;
            elementNode.RegisterPasteCommand(builder);

            FactoryHelper.AddEmptyElement(elements, elementNode);
        }
Exemplo n.º 16
0
        private static bool CanExecuteCommand <T>(ConfigElementNode node, Func <ConfigElementNode, ICommand <T> > selector,
                                                  T parameter = default(T))
        {
            if (node != null)
            {
                var command = selector(node);

                if (command != null)
                {
                    return(command.CanExecute(parameter));
                }
            }

            return(false);
        }
Exemplo n.º 17
0
        private static void ExecuteCommand <T>(ConfigElementNode node, Func <ConfigElementNode, ICommand <T> > selector,
                                               T parameter = default(T))
        {
            if (node != null)
            {
                var command = selector(node);

                if (command != null)
                {
                    //try
                    //{
                    command.Execute(parameter);
                    //}
                    //catch (Exception error)
                    //{
                    //    CommonHelper.ShowErrorMessage(error.Message);
                    //}
                }
            }
        }
        public static string BuildName(ConfigElementNode elementNode)
        {
            var elementMetadata = elementNode.ElementMetadata;

            var name    = ((elementMetadata.Name as string) ?? String.Empty).Trim();
            var caption = ((elementMetadata.Caption as string) ?? String.Empty).Trim();

            if (!String.IsNullOrEmpty(name) && !String.IsNullOrEmpty(caption))
            {
                if (name != caption)
                {
                    return(String.Format("{0} ({1})", name, caption));
                }

                return(name);
            }

            if (!String.IsNullOrEmpty(caption))
            {
                return(caption);
            }

            return(name);
        }
 public CopyElementCommand(ConfigElementNode elementNode)
 {
     _elementNode = elementNode;
 }
Exemplo n.º 20
0
 private void OnTreeListSelectedItemChanged(object sender, SelectedItemChangedEventArgs e)
 {
     SelectedElement = e.NewItem as ConfigElementNode;
 }
Exemplo n.º 21
0
        public void Create(ConfigElementNodeBuilder builder, ICollection <ConfigElementNode> elements, ConfigElementNode elementNode)
        {
            elementNode.DocumentId  = elementNode.ElementMetadata.Name;
            elementNode.ElementId   = FactoryHelper.BuildId(elementNode);
            elementNode.ElementName = FactoryHelper.BuildName(elementNode);

            elementNode.RefreshCommand = new RefreshContainerCommand(elementNode);
            elementNode.RegisterAddCommands(builder, ElementChildrenTypes);
            elementNode.RegisterEditCommand(builder);
            elementNode.DeleteCommand = new DeleteElementCommand(builder, elements, elementNode);
            elementNode.CopyCommand   = FactoryHelper.NoCopyCommand;
            elementNode.RegisterPasteCommand(builder);

            builder.BuildElement(elements, elementNode, elementNode.ElementMetadata, ViewContainerNodeFactory.ElementType);
            builder.BuildElement(elements, elementNode, elementNode.ElementMetadata, PrintViewContainerNodeFactory.ElementType);
            builder.BuildElement(elements, elementNode, elementNode.ElementMetadata, ScenarioContainerNodeFactory.ElementType);
            builder.BuildElement(elements, elementNode, elementNode.ElementMetadata, ProcessContainerNodeFactory.ElementType);
            builder.BuildElement(elements, elementNode, elementNode.ElementMetadata, ServiceContainerNodeFactory.ElementType);
        }
 public static void RegisterCopyCommand(this ConfigElementNode elementNode)
 {
     elementNode.CopyCommand = new CopyElementCommand(elementNode);
 }
        public static void RemoveChildNodes(ICollection <ConfigElementNode> elements, ConfigElementNode elementNode)
        {
            foreach (var childNode in elementNode.Nodes)
            {
                RemoveChildNodes(elements, childNode);
                elements.Remove(childNode);
            }

            elementNode.Nodes.Clear();
        }
Exemplo n.º 24
0
        public void Create(ConfigElementNodeBuilder builder, ICollection <ConfigElementNode> elements, ConfigElementNode elementNode)
        {
            elementNode.ConfigId    = elementNode.ElementMetadata.Name;
            elementNode.Version     = elementNode.ElementMetadata.Version;
            elementNode.ElementId   = FactoryHelper.BuildId(elementNode);
            elementNode.ElementName = FactoryHelper.BuildName(elementNode);

            elementNode.RefreshCommand = new RefreshContainerCommand(elementNode);
            elementNode.RegisterAddCommands(builder, ElementChildrenTypes);
            elementNode.RegisterEditCommand(builder);
            elementNode.DeleteCommand = new DeleteElementCommand(builder, elements, elementNode);
            elementNode.CopyCommand   = FactoryHelper.NoCopyCommand;
            elementNode.PasteCommand  = FactoryHelper.NoPasteCommand;

            builder.BuildElement(elements, elementNode, elementNode.ElementMetadata, MenuContainerNodeFactory.ElementType);
            builder.BuildElement(elements, elementNode, elementNode.ElementMetadata, DocumentContainerNodeFactory.ElementType);
            builder.BuildElement(elements, elementNode, elementNode.ElementMetadata, RegisterContainerNodeFactory.ElementType);
            builder.BuildElement(elements, elementNode, elementNode.ElementMetadata, ReportContainerNodeFactory.ElementType);

            elementNode.RefreshCommand.TryExecute();
        }
Exemplo n.º 25
0
 public EditElementCommand(ConfigElementNodeBuilder builder, ConfigElementNode elementNode, string elementEditor)
 {
     _builder       = builder;
     _elementNode   = elementNode;
     _elementEditor = elementEditor;
 }
Exemplo n.º 26
0
 public RefreshContainerCommand(ConfigElementNode elementNode)
 {
     _elementNode = elementNode;
 }