Example #1
0
        private void comboSection_SelectedValueChanged(object sender, EventArgs e)
        {
            string    sectionName = comboSection.Text;
            IResource section     = RStore.FindUniqueResource(DocumentSectionResource.DocSectionResName, "Name", sectionName);

            if (section.HasProp(DocumentSectionResource.SectionHelpDescription))
            {
                resTypeToolTip.SetToolTip(comboSection, section.GetStringProp(DocumentSectionResource.SectionHelpDescription));
            }
            else
            {
                resTypeToolTip.SetToolTip(comboSection, "");
            }
        }
Example #2
0
        public EditRuleForm(string ruleName) : base("IsActionRuleLinked", true, true, true)
        {
            #region Preconditions
            if (String.IsNullOrEmpty(ruleName))
            {
                throw new ArgumentNullException("ruleName", "EditRuleForm -- Input rule name is NULL");
            }
            #endregion Preconditions

            Initialize("Edit Action Rule", ruleName);
            BaseResource = RStore.FindUniqueResource(FilterManagerProps.RuleResName, "Name", ruleName);
            ArrayList parameters = new ArrayList();
            ArrayList actions    = CollectResourcesAndTemplates(BaseResource, parameters, Core.FilterRegistry.Props.LinkedActions);
            AddConditions(_panelActions, actions, parameters);
            InitializeBasePanels(BaseResource);
            InitializeEventsList(BaseResource);
        }
Example #3
0
        public EditExpirationRuleForm(string ruleName) : base("IsExpirationRuleLinked", false, true, true)
        {
            #region Preconditions
            if (String.IsNullOrEmpty(ruleName))
            {
                throw new ArgumentNullException("ruleName", "EditExpirationRuleForm -- Input rule name is NULL");
            }
            #endregion Preconditions

            BaseResource = RStore.FindUniqueResource(FilterManagerProps.RuleResName, "Name", ruleName);
            IResourceList linked = BaseResource.GetLinksOfType(null, "ExpirationRuleLink");
            if (linked.Count == 0)
            {
                linked = BaseResource.GetLinksOfType(null, "ExpirationRuleOnDeletedLink");
                if (linked.Count == 1 && linked[0].Type == "ResourceType")
                {
                    _isForDeletedItems = true;
                    _baseResType       = linked[0];
                }
                else
                {
                    throw new ApplicationException("EditExpirationRule -- Contract violation - No linkage between rule and related resources");
                }
            }
            else
            if (linked.Count == 1 && linked[0].Type == "ResourceType")
            {
                _baseResType = linked[0];
            }

            Initialize((_baseResType == null) ? linked : null);

            InitializeActions(BaseResource);
            InitializeBasePanels(BaseResource);
            if (_baseResType != null)
            {
                ConstructLinkText(_baseResType);
                resourceTypesLink.Enabled = false;
            }
            else
            {
                ConstructLinkText(linked);
            }
        }
Example #4
0
        private void PerformSearch()
        {
            string query = _editHeading.Text.Trim();

            IResource[][] conditions = Controls2Resources(panelConditions.Controls);
            if (query.Length > 0)
            {
                IResource queryCondition = ((FilterRegistry)FMgr).CreateQueryConditionAux(null, query, comboSection.Text);
                FilterRegistry.ReferCondition2Template(queryCondition, FMgr.Std.BodyMatchesSearchQueryXName);

                //  Copy query condition to every subgroup or create the single one.
                if (conditions != null && conditions.Length > 0)
                {
                    for (int i = 0; i < conditions.Length; i++)
                    {
                        IResource[] group    = conditions[i];
                        IResource[] newGroup = new IResource[group.Length + 1];

                        for (int j = 0; j < group.Length; j++)
                        {
                            newGroup[j] = group[j];
                        }
                        newGroup[newGroup.Length - 1] = queryCondition;

                        conditions[i] = newGroup;
                    }
                }
                else
                {
                    conditions = FilterRegistry.Convert2Group(queryCondition);
                }
                UpdateStoredQueriesList(query);
            }

            IResource[] exceptions = ConvertTemplates2Conditions(panelExceptions.Controls);

            //-----------------------------------------------------------------
            //  need to remove existing basic View?
            //  NB: it removes all underlying AUX conditions including query search
            //-----------------------------------------------------------------
            IResource view = RStore.FindUniqueResource(FilterManagerProps.ViewResName, "DeepName", FMgr.ViewNameForSearchResults);

            string[] formTypes = ReformatTypes(CurrentResTypeDeep);
            if (view != null)
            {
                BaseResource = view;
                FMgr.ReregisterView(view, FMgr.ViewNameForSearchResults, formTypes, conditions, exceptions);
            }
            else
            {
                BaseResource = FMgr.RegisterView(FMgr.ViewNameForSearchResults, formTypes, conditions, exceptions);
            }

            //-----------------------------------------------------------------
            bool          showContext = (query.Length > 0) && Core.SettingStore.ReadBool("Resources", "ShowSearchContext", true);
            ResourceProxy proxy       = new ResourceProxy(BaseResource);

            proxy.BeginUpdate();
            proxy.SetProp(Core.Props.Name, SearchViewPrefix + query);
            proxy.SetProp(Core.Props.ShowDeletedItems, true);
            proxy.SetProp("ForceExec", true);
            proxy.SetProp("ShowContexts", showContext);
            if (BaseResource.HasProp(Core.Props.ContentType) || BaseResource.HasProp("ContentLinks"))
            {
                proxy.DeleteProp("ShowInAllTabs");
            }
            else
            {
                proxy.SetProp("ShowInAllTabs", true);
            }
            proxy.EndUpdate();

            //  if search is done specifically for the particular resource
            //  type - set the focus onto that tab.
            Core.ResourceTreeManager.LinkToResourceRoot(BaseResource, 1);
            if ((CurrentResTypeDeep != null) &&
                (CurrentResTypeDeep.IndexOf('|') == -1) && (CurrentResTypeDeep.IndexOf('#') == -1))
            {
                Core.TabManager.SelectResourceTypeTab(CurrentResTypeDeep);
            }
            else
            {
                Core.TabManager.SelectResourceTypeTab("");
            }

            Core.UIManager.BeginUpdateSidebar();
            Core.LeftSidebar.ActivateViewPane(StandardViewPanes.ViewsCategories);
            Core.UIManager.EndUpdateSidebar();
            Core.LeftSidebar.DefaultViewPane.SelectResource(BaseResource);
            BringToFront();
        }