private void Delete()
        {
            // If the named rule has siblings, move to next named rule.
            int index = _parentContext.Children.IndexOf(this);

            Debug.Assert(index != -1, "Its parent must contain it."); //NOXLATE

            RuleBaseContext nextRule = null;

            if (index + 1 < _parentContext.Children.Count) // Try to get next sibling
            {
                nextRule = _parentContext.Children.ElementAt(index + 1);
            }
            else if (index - 1 >= 0) // Try to get previous sibling
            {
                nextRule = _parentContext.Children.ElementAt(index - 1);
            }

            _parentContext.Children.Remove(this);
            int idx = _ruleConfigContext.SearchResult.IndexOf(this);

            if (idx != -1)
            {
                _ruleConfigContext.SearchResult.RemoveAt(idx);
            }
            _ruleConfigContext.IsDirty = true;

            if (nextRule != null)
            {
                nextRule.IsSelected = true;
            }
        }
示例#2
0
        private SortedDictionary <string, RuleBaseContext> GetWorkingSet()
        {
            SortedDictionary <string, RuleBaseContext> workingSet = new SortedDictionary <string, RuleBaseContext>();
            Queue <RuleBaseContext> workingQueue = new Queue <RuleBaseContext>();

            workingQueue.Enqueue(RootRulePoint);
            while (workingQueue.Count > 0)
            {
                RuleBaseContext theRuleContext = workingQueue.Dequeue();
                string          rulePath       = theRuleContext.Path;
                if (!workingSet.ContainsKey(rulePath))
                {
                    workingSet.Add(rulePath, theRuleContext);
                }
                else
                {
                    Debug.Assert(false, "There are rule points or named rules having duplicated rule path. This is not allowed. There must be something wrong."); //NOXLATE
                }

                RulePointContext rulePointContext = theRuleContext as RulePointContext;
                if (rulePointContext != null)
                {
                    foreach (var ruleContext in rulePointContext.Children)
                    {
                        workingQueue.Enqueue(ruleContext);
                    }
                }
            }
            return(workingSet);
        }
 private void SelectRule(RuleBaseContext ruleContext)
 {
     if (ruleContext != null)
     {
         if (!ruleContext.IsSelected)
         {
             ruleContext.IsSelected = true;
         }
     }
 }
示例#4
0
        /// <summary>
        /// Search rules including rule points and named rules, and add searching
        /// result to SearchResult property.
        /// </summary>
        private void SearchRules(Stack <RuleBaseContext> workingBuffer)
        {
            const int MaxWorkload           = 10;
            const int MaxSearchResultNumber = 1000;

            if (workingBuffer != _workingBuffer)
            {
                // System has started an another searching work by a new keyword.
                return;
            }

            int count = 0;

            while (workingBuffer.Count > 0 && count < MaxWorkload)
            {
                RuleBaseContext theContext = workingBuffer.Pop();
                if (String.IsNullOrEmpty(SearchKeyword))
                {
                    _searchResult.Add(theContext);
                }
                else
                {
                    // Call ToUpper() for search in case-insensitive way.
                    if (theContext.DisplayName.ToUpper().Contains(SearchKeyword.ToUpper()))
                    {
                        _searchResult.Add(theContext);
                    }
                }

                theContext.UpdateDisplayTexts();

                // Add children into working queue if it has.
                RulePointContext rulePoint = theContext as RulePointContext;
                if (rulePoint != null)
                {
                    foreach (var child in rulePoint.Children.Reverse()) // first child, first serve
                    {
                        workingBuffer.Push(child);
                    }
                }

                ++count;
            }

            if (_workingBuffer.Count > 0 && _searchResult.Count < MaxSearchResultNumber)
            {
                Dispatcher.CurrentDispatcher.BeginInvoke(
                    new Action <Stack <RuleBaseContext> >(SearchRules),
                    DispatcherPriority.Background,
                    workingBuffer);
            }
        }
        private void RuleConfigContext_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            RuleConfigContext context = sender as RuleConfigContext;

            Debug.Assert(context != null);

            if (e.PropertyName == "EditingRule") // NOXLATE
            {
                RuleBaseContext editingRule = context.EditingRule;
                if (editingRule == null)
                {
                    DetachDesigner();

                    if (context.SelectedRule != null && context.SelectedRule is RulePointContext)
                    {
                        RulePointContext rpc = context.SelectedRule as RulePointContext;
                        mDesignerViewContent.Content = rpc.CreateContentOperation;
                    }
                    else
                    {
                        mDesignerViewContent.Content = "TODO: show help doc here."; // NOXLATE
                    }
                }
                else
                {
                    RuleAppExtension.RuleDesignerManagerInst.UpdateDesignerAttributes();
                    _workflowDesigner      = new WorkflowDesigner();
                    _workflowDesigner.Text = context.EditingRule.Text;
                    _workflowDesigner.Load();
                    RuleEditingContext editingContext         = context.EditingRule.GetEditingContext();
                    ServiceManager     editingContextServices = _workflowDesigner.Context.Services;
                    editingContextServices.Publish <RuleEditingContextService>(new RuleEditingContextService(editingContext));
                    editingContextServices.Publish <ActivityTranslator>(RuleAppExtension.ActivityTranslatorInst);
                    editingContextServices.Publish <ActivityFactory>(RuleAppExtension.ActivityFactoryInst);
                    _workflowDesigner.ModelChanged += new EventHandler(WorkflowDesigner_ModelChanged);
                    if (_ruleDesigner == null)
                    {
                        _ruleDesigner = new InternalDesigner();
                    }
                    _ruleDesigner.SetDesigner(_workflowDesigner);
                    mDesignerViewContent.Content = _ruleDesigner;
                    //mRulesTreeView.Focus();
                }
            }
        }
示例#6
0
        /// <summary>
        /// Get RuleBaseContext instance by given path.
        /// </summary>
        /// <param name="path">The path of rule.</param>
        /// <returns>RuleBaseContext instance</returns>
        public RuleBaseContext GetRuleContext(string path)
        {
            if (String.IsNullOrEmpty(path))
            {
                throw new ArgumentNullException("path"); // NOXLATE
            }

            RuleBaseContext iter = RootRulePoint;

            string[] pathItems = RulePathHelper.GetRulePathComponents(path);
            foreach (string component in pathItems)
            {
                RulePointContext rulePoint = iter as RulePointContext;
                if (rulePoint == null)
                {
                    return(null);
                }
                iter = rulePoint.Children.FirstOrDefault((r) => (r.Name == component)) as RuleBaseContext;
            }
            return(iter);
        }