/// <summary>
/// Checks if the specified workspace can possibly have resources that belong to the
/// workspace but not to any of the containers.
/// </summary>
public bool HasResourcesOutsideContainers(IResource workspace)
{
if (workspace == null)
{
return(false);
}
IResourceList resList = workspace.GetLinksTo(null, _props.InWorkspace);
for (int i = 0; i < resList.Count; i++)
{
// Workaround of OM-13038 and related.
try
{
if (resList [i].Type != "WorkspaceOtherView")
{
WorkspaceTypeRec typeRec = (WorkspaceTypeRec)_resTypeToWorkspaceRec [resList [i].Type];
if (typeRec == null || typeRec._workspaceResType == WorkspaceResourceType.Filter ||
typeRec._workspaceResType == WorkspaceResourceType.None)
{
return(true);
}
}
}
catch (OpenAPI.InvalidResourceIdException)
{
// Nothing to do, just ignore
}
}
return(false);
}
private void FillResourcesInContainers(IResource workspace, IResource res,
ref IResourceList resourcesInContainers, bool recursive)
{
WorkspaceTypeRec rec = (WorkspaceTypeRec)_resTypeToWorkspaceRec [res.Type];
if (rec == null || rec._workspaceResType == WorkspaceResourceType.None ||
rec._workspaceResType == WorkspaceResourceType.Filter)
{
return;
}
for (int i = 0; i < rec._linkPropIds.Length; i++)
{
resourcesInContainers = GetWorkspaceLinks(res, rec._linkPropIds [i]).Union(resourcesInContainers);
}
if (recursive)
{
foreach (IResource child in res.GetLinksTo(null, rec._recurseLinkPropId))
{
if (!child.HasLink(_props.ExcludeFromWorkspace, workspace))
{
FillResourcesInContainers(workspace, child, ref resourcesInContainers, true);
}
}
}
}
public void RegisterWorkspaceType(string resType, int[] linkPropIDs, WorkspaceResourceType wrType)
{
WorkspaceTypeRec rec = new WorkspaceTypeRec(resType, linkPropIDs, Core.Props.Parent, wrType);
_workspaceTypes.Add(rec);
_resTypeToWorkspaceRec [resType] = rec;
}
private IResource[] GetFilterResources(IResource workspace)
{
ArrayList result = ArrayListPool.Alloc();
try
{
IResourceList resources = workspace.GetLinksTo(null, Props.InWorkspace).Union(
workspace.GetLinksTo(null, Props.InWorkspaceRecursive));
foreach (IResource res in resources)
{
WorkspaceTypeRec rec = (WorkspaceTypeRec)_resTypeToWorkspaceRec [res.Type];
if (rec != null && rec._workspaceResType == WorkspaceResourceType.Filter)
{
result.Add(res);
}
}
if (result.Count == 0)
{
return(null);
}
return((IResource[])result.ToArray(typeof(IResource)));
}
finally
{
ArrayListPool.Dispose(result);
}
}
public void RegisterWorkspaceFolderType(string resType, string contentType, int[] linkPropIDs)
{
WorkspaceTypeRec rec = new WorkspaceTypeRec(resType, linkPropIDs,
Core.Props.Parent, WorkspaceResourceType.Folder);
_workspaceTypes.Add(rec);
_resTypeToWorkspaceRec [resType] = rec;
}
public void RegisterWorkspaceContainerType(string resType, int[] linkPropIds, int recurseLinkPropId)
{
WorkspaceTypeRec rec = new WorkspaceTypeRec(resType, linkPropIds,
recurseLinkPropId, WorkspaceResourceType.Container);
_workspaceTypes.Add(rec);
_resTypeToWorkspaceRec [resType] = rec;
}
public int GetRecurseLinkPropId(string resType)
{
WorkspaceTypeRec rec = (WorkspaceTypeRec)_resTypeToWorkspaceRec [resType];
if (rec == null)
{
return(Core.Props.Parent);
}
return(rec._recurseLinkPropId);
}
public WorkspaceResourceType GetWorkspaceResourceType(string resType)
{
WorkspaceTypeRec rec = (WorkspaceTypeRec)_resTypeToWorkspaceRec [resType];
if (rec == null)
{
return(WorkspaceResourceType.None);
}
return(rec._workspaceResType);
}
private void ProcessWorkspaceVisibleLink(IResource workspace, IResource res, LinkChangeType changeType,
bool recursive, IResource[] filterResources)
{
if ((changeType == LinkChangeType.Add && res.HasLink(Props.WorkspaceVisible, workspace) ||
(changeType == LinkChangeType.Delete && !res.HasLink(Props.WorkspaceVisible, workspace))))
{
return;
}
if (changeType == LinkChangeType.Add)
{
res.AddLink(Props.WorkspaceVisible, workspace);
}
else
{
if (HaveLinksToFilterResources(res, filterResources))
{
return;
}
res.DeleteLink(Props.WorkspaceVisible, workspace);
}
WorkspaceTypeRec wrType = (WorkspaceTypeRec)_resTypeToWorkspaceRec [res.Type];
if (wrType != null)
{
foreach (int linkPropId in wrType._linkPropIds)
{
IResourceList linkList = GetWorkspaceLinks(res, linkPropId);
foreach (IResource linkRes in linkList)
{
ProcessWorkspaceVisibleLink(workspace, linkRes, changeType, false, filterResources);
}
}
}
if (recursive)
{
int parentLinkType = GetRecurseLinkPropId(res.Type);
foreach (IResource childRes in res.GetLinksTo(null, parentLinkType))
{
if (!childRes.HasLink(Props.ExcludeFromWorkspace, workspace))
{
ProcessWorkspaceVisibleLink(workspace, childRes, changeType, true, filterResources);
}
}
}
}
private void ResourceStore_OnResourceSaved(object sender, ResourcePropEventArgs e)
{
if (Props.WorkspaceVisible != 0 && e.Resource.HasProp(Props.WorkspaceVisible) && e.Resource.Type != _props.WorkspaceResourceType)
{
IResourceList wsList = null;
int recurseLinkProp = GetRecurseLinkPropId(e.Resource.Type);
if (e.ChangeSet.IsPropertyChanged(-recurseLinkProp))
{
if (wsList == null)
{
wsList = e.Resource.GetLinksOfType(null, Props.WorkspaceVisible);
}
foreach (IResource ws in wsList)
{
if (IsInWorkspaceRecursive(ws, e.Resource))
{
LinkChange[] linkChanges = e.ChangeSet.GetLinkChanges(-recurseLinkProp);
ProcessWorkspaceLinkChanges(ws, linkChanges);
}
}
}
WorkspaceTypeRec wrType = (WorkspaceTypeRec)_resTypeToWorkspaceRec [e.Resource.Type];
if (wrType != null)
{
foreach (int linkPropId in wrType._linkPropIds)
{
if (e.ChangeSet.IsPropertyChanged(linkPropId))
{
if (wsList == null)
{
wsList = e.Resource.GetLinksOfType(null, Props.WorkspaceVisible);
}
LinkChange[] linkChanges = e.ChangeSet.GetLinkChanges(linkPropId);
foreach (IResource workspace in wsList)
{
ProcessWorkspaceLinkChanges(workspace, linkChanges);
}
}
}
}
}
}
private bool HaveLinksToFilterResources(IResource res, IResource[] filterResources)
{
if (filterResources == null)
{
return(false);
}
for (int i = 0; i < filterResources.Length; i++)
{
WorkspaceTypeRec rec = (WorkspaceTypeRec)_resTypeToWorkspaceRec [filterResources [i].Type];
for (int j = 0; j < rec._linkPropIds.Length; j++)
{
if (res.HasLink(rec._linkPropIds [j], filterResources [i]))
{
return(true);
}
}
}
return(false);
}
