public static IResourceList ExcludeUnloadedPluginResources(IResourceList resList)
{
ArrayList unloadedResourceTypes = null;
IResourceList excludedTypes = null;
foreach (IResourceType rt in Core.ResourceStore.ResourceTypes)
{
if (!rt.OwnerPluginLoaded)
{
if (unloadedResourceTypes == null)
{
unloadedResourceTypes = new ArrayList();
}
unloadedResourceTypes.Add(rt.Name);
}
}
if (unloadedResourceTypes != null)
{
string[] resTypes = (string[])unloadedResourceTypes.ToArray(typeof(string));
excludedTypes = Core.ResourceStore.GetAllResourcesLive(resTypes);
}
foreach (IPropType pt in Core.ResourceStore.PropTypes)
{
if (pt.HasFlag(PropTypeFlags.SourceLink) && !pt.OwnerPluginLoaded)
{
excludedTypes = Core.ResourceStore.FindResourcesWithProp(null, pt.Id).Union(excludedTypes);
}
}
if (excludedTypes != null)
{
return(resList.Minus(excludedTypes));
}
return(resList);
}
public IResourceList Filter(string resType)
{
IResourceList result = Core.ResourceStore.FindResourcesWithProp(SelectionType.LiveSnapshot, null, "Category");
result = result.Minus(Core.ResourceStore.GetAllResources("Category"));
return(result);
}
public IResourceList GetChildResources(IResource parent)
{
IResourceList result = null;
if (parent == _treeRoot)
{
return(_workspaceContentsList);
}
WorkspaceResourceType wrType = Core.WorkspaceManager.GetWorkspaceResourceType(parent.Type);
if (wrType == WorkspaceResourceType.Container && parent.HasLink(_workspaceManager.Props.InWorkspace, _workspace))
{
// if it's a container that is not linked recursively - do not show children
return(Core.ResourceStore.EmptyResourceList);
}
result = parent.GetLinksToLive(null, _dataProvider.ParentProperty);
result = result.Minus(_workspace.GetLinksToLive(null, _workspaceManager.Props.ExcludeFromWorkspace));
string sortProps = Core.ResourceTreeManager.GetResourceNodeSort(parent);
if (sortProps != null)
{
result.Sort(sortProps);
}
return(result);
}
private static IResourceList ComputeList(IResource view)
{
IResourceList list = Core.FilterEngine.ExecView(view, null, SelectionType.Live);
list = ResourceTypeHelper.ExcludeUnloadedPluginResources(list);
list = list.Minus(Core.ResourceStore.FindResourcesWithProp(null, Core.Props.IsDeleted));
list = list.Intersect(Core.ResourceStore.FindResourcesWithProp(null, Core.Props.IsUnread), true);
return(list);
}
public bool DecorateNode(IResource res, RichText nodeText)
{
if (res.HasProp(Core.Props.ShowTotalCount))
{
IResource wsp = Core.WorkspaceManager.ActiveWorkspace;
if (res.Type == FilterManagerProps.ViewResName)
{
IResourceList total = Core.FilterEngine.ExecView(res);
if (!res.HasProp("ShowDeletedItems"))
{
total = total.Minus(_allDeleted);
}
total = total.Intersect(_allTyped);
if (wsp != null)
{
total = total.Intersect(wsp.GetLinksOfType(null, "WorkspaceVisible"), true);
}
if (total.Count != 0)
{
nodeText.Append(" ");
nodeText.Append("[" + total.Count + "]", _textStyle);
}
return(true);
}
else
if (res.Type == "Category")
{
bool leafCategory = (res.GetLinksTo(null, Core.Props.Parent).Count == 0);
IResourceList inThis = Core.ResourceStore.EmptyResourceList, total;
if (leafCategory)
{
total = CollectResources(res, wsp);
}
else
{
CollectResources(res, wsp, out inThis, out total);
}
if (total.Count != 0)
{
nodeText.Append(" ");
if (leafCategory)
{
nodeText.Append("[" + total.Count + "]", _textStyle);
}
else
{
nodeText.Append("[" + inThis.Count + "|" + total.Count + "]", _textStyle);
}
}
return(true);
}
}
return(false);
}
public static IResourceList GetVisibleResourceTypes()
{
IResourceList resTypes = Core.ResourceStore.GetAllResources("ResourceType");
resTypes = resTypes.Minus(Core.ResourceStore.FindResources("ResourceType", "Internal", 1));
resTypes.Sort(new SortSettings(ResourceProps.DisplayName, true));
return(resTypes);
}
//---------------------------------------------------------------------
// 1. Collect all ContactNames from Myself which are NOT linked to
// any email account.
// 2. Iterate over all such cNames, if a cName with such name string
// was already met, relink all dependant links to correspondence
// to that first cName.
//---------------------------------------------------------------------
private void MergeContactNamesWithoutAccount()
{
int removedCount = 0;
IContact myself = Core.ContactManager.MySelf;
IResourceList linkedCNames = myself.Resource.GetLinksOfType(null, "BaseContact");
IResourceList properCNames = Core.ResourceStore.FindResourcesWithProp("ContactName", Core.ContactManager.Props.LinkEmailAcct);
linkedCNames = linkedCNames.Minus(properCNames);
Hashtable cnames = new Hashtable();
for (int i = 0; i < linkedCNames.Count; i++)
{
IResource cName = linkedCNames[i];
Debug.Assert(cName.GetLinksOfType("EmailAccount", Core.ContactManager.Props.LinkEmailAcct).Count == 0);
string name = cName.GetStringProp("Name");
// Empty names are removed unconditionally.
if (name == null)
{
linkedCNames[i].Delete();
}
else
if (cnames.ContainsKey(name))
{
IResource existingCName = (IResource)cnames[name];
IResourceList linkedMails = cName.GetLinksOfType(null, Core.ContactManager.Props.LinkNameTo);
foreach (IResource mail in linkedMails)
{
mail.AddLink(Core.ContactManager.Props.LinkNameTo, existingCName);
}
linkedMails = cName.GetLinksOfType(null, Core.ContactManager.Props.LinkNameFrom);
foreach (IResource mail in linkedMails)
{
mail.AddLink(Core.ContactManager.Props.LinkNameFrom, existingCName);
}
linkedMails = cName.GetLinksOfType(null, Core.ContactManager.Props.LinkNameCC);
foreach (IResource mail in linkedMails)
{
mail.AddLink(Core.ContactManager.Props.LinkNameCC, existingCName);
}
linkedCNames[i].Delete();
}
else
{
cnames[cName.GetStringProp("Name")] = linkedCNames[i];
}
}
Trace.WriteLine("ContactUpgrader -- MergeContactNamesWithoutAccount removed " + removedCount + " contact names with equal name.");
}
/// <summary>
/// Initiates the procedure for fetching the descriptions of all change sets which
/// don't currently have known descriptions.
/// </summary>
private void DescribeNewChangeSets(IResource repository)
{
IResourceList changeSets = repository.GetLinksOfType(Props.ChangeSetResource, Props.ChangeSetRepository);
changeSets = changeSets.Minus(Core.ResourceStore.FindResourcesWithProp(Props.ChangeSetResource, Core.Props.Subject));
if (changeSets.Count > 0)
{
Core.NetworkAP.QueueJob("Describing Perforce changeset",
() => DescribeChangeSets(repository, changeSets, 0));
}
}
internal bool HandleDropResourceOnCategory(IResourceList resDroppedRaw, IResource category)
{
// Categories have already been processed separately
IResourceList resDropped = resDroppedRaw.Minus(Core.ResourceStore.GetAllResources("Category"));
// Content-type of the target category
string contentType = category.GetStringProp("ContentType");
// Constrain
foreach (IResource res in resDropped)
{
if (Core.ResourceStore.ResourceTypes[res.Type].HasFlag(ResourceTypeFlags.Internal))
{
continue;
}
if (contentType != null && contentType != res.Type)
{
DialogResult dr = MessageBox.Show(Core.MainWindow,
String.Format("The category “{0}” is configured to contain only “{1}” resources. Do you wish to change it to a general category?", category.DisplayName, contentType), "Add Resource to Category", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (dr == DialogResult.No)
{
return(false);
}
Debug.WriteLine("Changing parent for category " + category.Id);
_categoryManager.SetContentTypeRecursive(category, null);
new ResourceProxy(category, JobPriority.Immediate).SetPropAsync("Parent", Core.CategoryManager.RootCategory);
contentType = null;
break;
}
}
// Presence of Alt modifier means "movement" of a resource to a category,
// not an addition of another one.
bool isMove = (Control.ModifierKeys & Keys.Alt) > 0;
foreach (IResource res in resDropped)
{
if (!Core.ResourceStore.ResourceTypes[res.Type].HasFlag(ResourceTypeFlags.Internal))
{
if (!isMove)
{
Core.CategoryManager.AddResourceCategory(res, category);
}
else
{
Core.CategoryManager.SetResourceCategory(res, category);
}
}
}
return(true);
}
private static void FixValidButIgnoredContacts()
{
IResourceStore store = Core.ResourceStore;
IResourceList ignored = store.FindResourcesWithProp("Contact", "IsIgnored");
ignored = ignored.Minus(store.FindResourcesWithProp("Contact", Core.Props.IsDeleted));
Trace.WriteLine("Upgrade1Initializer -- Found " + ignored.Count + " ignored but non-deleted contacts");
for (int i = 0; i < ignored.Count; i++)
{
ignored[i].DeleteProp("IsIgnored");
}
}
private void AttachResourceWatchHandlers()
{
_categories.ResourceAdded += _categories_ResourceAdded;
_categories.ResourceDeleting += _categories_ResourceDeleted;
_views = Core.ResourceStore.GetAllResourcesLive(FilterManagerProps.ViewResName);
_views = _views.Minus(Core.ResourceStore.FindResourcesWithPropLive(FilterManagerProps.ViewResName, "IsTrayIconFilter"));
_views = _views.Minus(Core.ResourceStore.FindResourcesWithPropLive(FilterManagerProps.ViewResName, "IsFormattingFilter"));
_views.ResourceAdded += _views_ResourceAdded;
_views.ResourceChanged += _views_ResourceChanged;
_views.ResourceDeleting += _views_ResourceDeleted;
}
private void buttonRemoveContact_Click(object sender, EventArgs e)
{
IResourceList sel = _contactsToMerge.GetSelectedResources();
for (int i = 0; i < sel.Count; i++)
{
_suggestedContactList = _suggestedContactList.Union(sel);
_contactsToMergeList = _contactsToMergeList.Minus(sel);
_suggestedContacts.JetListView.Nodes.Add(sel[i]);
_contactsToMerge.JetListView.Nodes.Remove(sel[i]);
}
VerifyButtonsCondition();
}
private void buttonOneToLeaved_Click(object sender, System.EventArgs e)
{
Debug.Assert(listSplittedContacts.SelectedIndex != -1);
if (buttonOneToLeaved.Enabled)
{
ListBox.SelectedObjectCollection coll = listSplittedContacts.SelectedItems;
foreach (IResource res in coll)
{
listLeavedContacts.Items.Add(res);
}
IResource[] list = new IResource[coll.Count];
coll.CopyTo(list, 0);
foreach (IResource res in list)
{
listSplittedContacts.Items.Remove(res);
AccumulatedContactsToSplit = AccumulatedContactsToSplit.Minus(res.ToResourceList());
}
VerifyButtonsAccessibility();
}
}
private void EnumerateFavorites(string folder, IResource parent)
{
FileInfo[] files = IOTools.GetFiles(folder);
if (files != null)
{
IResourceList weblinks = BookmarkService.SubNodes("Weblink", parent);
IntArrayList processedWeblinks = new IntArrayList(files.Length);
foreach (FileInfo fileInfo in files)
{
IResource weblink = null;
try
{
if (fileInfo.Extension.ToLower() == ".url")
{
weblink = ProcessFavoriteFile(fileInfo, parent);
}
else if (fileInfo.Extension.ToLower() == ".lnk")
{
weblink = ProcessShortcut(fileInfo, parent);
}
}
catch (Exception e)
{
FavoritesTools.TraceIfAllowed(e.Message);
continue;
}
if (weblink != null)
{
processedWeblinks.Add(weblink.Id);
}
}
_bookmarkservice.DeleteBookmarks(weblinks.Minus(
Core.ResourceStore.ListFromIds(processedWeblinks, false)));
}
DirectoryInfo[] dirs = IOTools.GetDirectories(folder);
if (dirs != null)
{
IResourceList folders = BookmarkService.SubNodes("Folder", parent);
IntArrayList processedFolders = new IntArrayList(dirs.Length);
foreach (DirectoryInfo dirInfo in dirs)
{
IResource subfolder = _bookmarkservice.FindOrCreateFolder(parent, dirInfo.Name);
EnumerateFavorites(IOTools.GetFullName(dirInfo), subfolder);
processedFolders.Add(subfolder.Id);
}
_bookmarkservice.DeleteFolders(folders.Minus(
Core.ResourceStore.ListFromIds(processedFolders, false)));
}
}
public IResourceList Filter(string resType, IActionParameterStore actionStore)
{
IResourceList categories = actionStore.ParametersAsResList();
categories = CategoriesTree(categories);
IResourceList result = Core.ResourceStore.EmptyResourceList;
foreach (IResource category in categories)
{
result = result.Union(category.GetLinksOfType(null, "Category"));
}
result = result.Minus(Core.ResourceStore.GetAllResources("Category"));
return(result);
}
/**
* If there are any resources or subcategories connected to the category,
* shows a confirmation dialog.
*/
public static bool ConfirmDeleteCategories(IWin32Window ownerWindow, IResourceList categoryList)
{
int linkCount = 0, subCategoryCount = 0;
foreach (IResource category in categoryList)
{
IResourceList linked = category.GetLinksOfType(null, _propCategory);
linked = linked.Minus(Core.ResourceStore.FindResourcesWithProp(null, Core.Props.IsDeleted));
linkCount += linked.Count;
subCategoryCount += category.GetLinksTo(null, Core.Props.Parent).Count;
}
if (linkCount > 0 || subCategoryCount > 0)
{
string msg = "There are ";
if (linkCount > 0)
{
msg += linkCount + " resources ";
if (subCategoryCount > 0)
{
msg += "and ";
}
}
if (subCategoryCount > 0)
{
msg += subCategoryCount + " subcategories ";
}
if (categoryList.Count == 1)
{
msg += "in the category " + categoryList [0].DisplayName +
". Are you sure you wish to delete the category?";
}
else
{
msg += "in the " + categoryList.Count + " selected categories" +
". Are you sure you wish to delete the categories?";
}
DialogResult dr = MessageBox.Show(ownerWindow,
msg, "Delete Category", MessageBoxButtons.YesNo);
if (dr == DialogResult.No)
{
return(false);
}
}
return(true);
}
private static bool CheckExpirationExceptions(IResourceList exceptions)
{
if (exceptions.IndexOf(Core.FilterRegistry.Std.ResourceIsFlagged) != -1)
{
exceptions = exceptions.Minus(Core.FilterRegistry.Std.ResourceIsFlagged.ToResourceList());
exceptions = exceptions.Minus(Core.FilterRegistry.Std.ResourceIsAnnotated.ToResourceList());
}
exceptions = exceptions.Minus(Core.FilterRegistry.Std.ResourceIsCategorized.ToResourceList());
exceptions = exceptions.Minus(Core.FilterRegistry.Std.ResourceIsUnread.ToResourceList());
if (exceptions.Count == 1)
{
IResource cond = exceptions[0];
IResource template = cond.GetLinkProp("TemplateLink");
if (template != null && template.Id == Core.FilterRegistry.Std.ReceivedInTheTimeSpanX.Id)
{
string text = EditTimeSpanConditionForm.Condition2Text(cond);
string[] fields = text.Split(' ');
return(fields[0].ToLower() == "last");
}
}
return(false);
}
private void ExportTasksImpl()
{
IResourceList tasksToExport = Core.ResourceStore.GetAllResources(STR.Task);
IResourceList tasksWithEntry = Core.ResourceStore.FindResourcesWithProp(null, PROP.EntryID);
tasksToExport = tasksToExport.Minus(tasksWithEntry);
foreach (IResource task in tasksToExport.ValidResources)
{
if (Finished)
{
break;
}
new ExportTaskDescriptor(task).QueueJob(JobPriority.AboveNormal);
}
}
public WatchedArticlesDecorator()
{
IResourceStore store = Core.ResourceStore;
_unreadArticles = store.FindResourcesWithPropLive(NntpPlugin._newsArticle, Core.Props.IsUnread);
_unreadArticles = _unreadArticles.Minus(store.FindResourcesWithPropLive(null, Core.Props.IsDeleted));
_unreadArticles.ResourceAdded += _unreadArticles_Updated;
_unreadArticles.ResourceDeleting += _unreadArticles_Updated;
_formattingRules = Core.FilterRegistry.GetFormattingRules(false);
_formattingRules.ResourceAdded += RuleConditionsListChanged;
_formattingRules.ResourceDeleting += RuleConditionsListChanged;
_formattingRules.ResourceChanged += RuleConditionsChanged;
HeadsChanged();
}
/// <summary>
/// Queue for download those enclosures of the feed's unread items which
/// are not yet downloaded or queued.
/// </summary>
/// <param name="feed">A feed resource which items are to be analyzed.</param>
private void ScheduleEnclosures(IResource feed)
{
IResourceList items = feed.GetLinksOfType(Props.RSSItemResource, Props.RSSItem);
items = items.Intersect(Core.ResourceStore.FindResourcesWithProp(Props.RSSItemResource, Core.Props.IsUnread), true);
items = items.Minus(Core.ResourceStore.FindResourcesWithProp(Props.RSSItemResource, Core.Props.IsDeleted));
IResourceList itemsWithEncls = Core.ResourceStore.FindResources(null, Props.EnclosureDownloadingState, (int)EnclosureDownloadState.NotDownloaded);
items = items.Intersect(itemsWithEncls, true);
foreach (IResource item in items)
{
EnclosureDownloadManager.PlanToDownload(item);
}
}
public override void ShowPane()
{
_wereChanges = false;
_statusBox.Items.AddRange(new string[] { "Immediately", "On Startup", "Never" });
_statusBox.SelectedIndex = 1;
_folders = Core.ResourceStore.FindResourcesWithPropLive(
FileProxy._folderResourceType, FileProxy._propStatus);
_folders = _folders.Minus(Core.ResourceStore.FindResourcesWithPropLive(
FileProxy._folderResourceType, FileProxy._propDeleted));
ArrayList garbage = new ArrayList();
foreach (IResource folder in _folders)
{
if (!folder.HasLink(FileProxy._propParentFolder, FoldersCollection.Instance.FilesRoot))
{
garbage.Add(folder);
}
}
foreach (IResource folder in garbage)
{
FoldersCollection.Instance.DeleteResource(folder);
}
// force monitoring of my documents if list is empty and we are in Startup Wizard
if (IsStartupPane)
{
_statusColumn.Width = 0;
_statusBox.Visible = false;
if (_folders.Count == 0)
{
_wereChanges = true;
Core.ResourceAP.RunUniqueJob(new MethodInvoker(CreateMyDocumentsFolder));
}
}
foreach (IResource folder in _folders)
{
_initialStatuses[folder.GetPropText(FileProxy._propDirectory)] =
folder.GetIntProp(FileProxy._propStatus);
}
_folders.Sort(new int[] { Core.Props.Name }, true);
_folderList.DataProvider = new ResourceListDataProvider(_folders);
}
private void InitializeWatcher(IResource rule, string name, Icon icon)
{
IResourceList watchList = Core.FilterEngine.ExecView(rule);
watchList = watchList.Minus(Core.ResourceStore.FindResourcesWithPropLive(null, Core.Props.IsDeleted));
WatchersOrder.Add(name);
WatchedLists[name] = watchList;
WatchedIcons[name] = icon;
watchList.ResourceAdded += watchList_ResourceAdded;
watchList.ResourceDeleting += watchList_ResourceDeleting;
if (!rule.HasProp("RuleTurnedOff") && watchList.Count > 0)
{
FireIconOfWatcher(name);
SetTooltipText();
}
}
public void RegisterViewsFirstRun()
{
IResourceList list = Core.ResourceStore.FindResources(FilterManagerProps.ConditionTemplateResName, "Name", RSSViewsConstructor.PostInCategoryName);
IResource one = Core.ResourceStore.FindUniqueResource(FilterManagerProps.ConditionTemplateResName, "DeepName", RSSViewsConstructor.PostInCategoryName);
if (one != null)
{
list = list.Minus(one.ToResourceList());
list.DeleteAll();
one.SetProp("DeepName", RSSViewsConstructor.PostInCategoryDeep);
}
else
{
IFilterRegistry mgr = Core.FilterRegistry;
IResource res = mgr.CreateConditionTemplate(RSSViewsConstructor.PostInCategoryName, RSSViewsConstructor.PostInCategoryDeep,
new string[] { "RSSItem" }, ConditionOp.Eq, "RSSCategory");
mgr.AssociateConditionWithGroup(res, RSSViewsConstructor.RSSConditionsGroup);
}
}
private void InitSpyResourceList(IResource task)
{
IResourceStore store = Core.ResourceStore;
IResourceList currTasks = Core.ResourceStore.EmptyResourceList;
// In order to correctly form a new live list we have to reconstruct
// it from scratch - first, form a "plain" (Union with merge) list
// and only then add minus and intersection.
foreach (IResource res in _taskLive)
{
currTasks = currTasks.Union(res.ToResourceListLive(), true);
}
_taskLive = currTasks.Union(task.ToResourceListLive(), true);
_taskLive = _taskLive.Minus(store.FindResources(null, TasksPlugin._propStatus, (int)TaskStatuses.Completed));
_taskLive = _taskLive.Intersect(store.FindResourcesInRange(null, TasksPlugin._propRemindDate,
DateTime.MinValue.AddSeconds(1), DateTime.Now), true);
_taskLive.ResourceDeleting += new ResourceIndexEventHandler(_taskLive_ResourceDeleting);
}
public void _btnMoreContacts_Click(object sender, EventArgs e)
{
IResourceList contactsList = Core.ResourceStore.GetAllResources("Contact");
contactsList = contactsList.Minus(_contactsToMergeList);
contactsList.Sort(new SortSettings(ResourceProps.DisplayName, true));
IResourceList contacts = Core.UIManager.SelectResourcesFromList(this, contactsList,
"Select Contact(s) for Merging");
if (contacts != null)
{
foreach (IResource res in contacts)
{
_contactsToMerge.JetListView.Nodes.Add(res);
}
_contactsToMergeList = _contactsToMergeList.Union(contacts);
}
VerifyButtonsCondition();
}
public static IResourceList GetCustomProperties()
{
if (_customProperties == null)
{
IResourceStore store = ICore.Instance.ResourceStore;
_customProperties = store.FindResourcesLive("PropType", "Custom", 1);
_customProperties = _customProperties.Minus(store.FindResources("PropType",
"DataType", (int)PropDataType.Link));
_customProperties.ResourceAdded += OnCustomPropertyAdded;
_customProperties.ResourceDeleting += OnCustomPropertyDeleting;
_customPropTypes = new ArrayList();
foreach (IResource res in _customProperties)
{
int propID = res.GetIntProp("ID");
_customPropTypes.Add(store.PropTypes [propID]);
}
}
return(_customProperties);
}
private IResourceList GetNodeResourceList(IResource res)
{
IResourceList result = Core.ResourceStore.EmptyResourceList;
if (res.Type == _resourceNodeType)
{
result = res.GetLinksOfType(null, _itemLink);
}
if (_folderLink >= 0)
{
foreach (IResource child in res.GetLinksTo(null, _folderLink))
{
result = result.Union(GetNodeResourceList(child));
}
}
if (!res.HasProp("ShowDeletedItems"))
{
result = result.Minus(_allDel);
}
return(result);
}
/// <summary>
/// Rebuilds the list of unread resources belonging to the workspace.
/// </summary>
private void UpdateUnreadResourceList()
{
if (_workspace != null && _workspace.IsDeleting)
{
return;
}
string workspaceName = WorkspaceName;
Trace.WriteLine("Start update unread resources list for workspace " + workspaceName);
if (_unreadResources != null)
{
_unreadResources.Dispose();
}
IResourceList unreadList = Core.ResourceStore.FindResourcesWithPropLive(null, Core.Props.IsUnread);
unreadList = unreadList.Minus(Core.ResourceStore.FindResourcesWithProp(null, Core.Props.IsDeleted));
Text = workspaceName;
if (_workspace != null)
{
if (ICore.Instance != null)
{
_unreadResources = unreadList.Intersect(_manager.GetFilterList(_workspace), true);
}
}
else
{
_unreadResources = unreadList;
}
if (_unreadResources != null)
{
_unreadResources.ResourceAdded += OnUnreadResourceAdded;
_unreadResources.ResourceDeleting += OnUnreadResourceDeleting;
}
UpdateUnreadCounters();
Trace.WriteLine("End update unread resources list for workspace " + workspaceName);
}
/**
* Saves the category links from the specified tree node collection.
*/
private void SaveCategoriesFromNodes(IResourceList resList)
{
IResourceList checkedCats = Core.ResourceStore.EmptyResourceList;
GetCheckedCategories(ref checkedCats);
foreach (IResource res in resList)
{
IResourceList currCats = Core.CategoryManager.GetResourceCategories(res);
IResourceList minusCats = currCats.Minus(checkedCats);
foreach (IResource cat in checkedCats)
{
Core.CategoryManager.AddResourceCategory(res, cat);
}
foreach (IResource cat in minusCats)
{
Core.CategoryManager.RemoveResourceCategory(res, cat);
}
}
}
private void InitializeLists()
{
String[] contextKeys = new String[] { "IsActionFilter", "IsFormattingFilter", "IsTrayIconFilter", "IsExpirationFilter" };
IResourceList invisibles = Store.FindResources(null, "Invisible", true);
foreach (string context in contextKeys)
{
IResourceList allRules = Store.FindResourcesWithProp(null, context);
allRules = allRules.Minus(invisibles);
allRules = FilterOutRulesByLoadedPluginType(allRules);
switch (context)
{
case "IsActionFilter": InitList(ref _listActionRules, "_listActionRules", allRules); break;
case "IsFormattingFilter": InitList(ref _listFormattingRules, "_listFormattingRules", allRules); break;
case "IsTrayIconFilter": InitList(ref _listTrayIconRules, "_listTrayIconRules", allRules); break;
case "IsExpirationFilter": InitList(ref _listExpirationRules, "_listExpirationRules", allRules); break;
}
}
}
