/** * Adds the existing unread states for the specified tab and list of workspaces * to the specified array list. */ private void FillStatesForTab(IList states, IResourceList workspaces, string tab) { if (tab == _tabProvider.GetDefaultTab()) { states.Add(_defaultUnreadState); } IntHashTable tabHash = (IntHashTable)_unreadStateTabMap [tab]; if (tabHash != null) { if (tab != _tabProvider.GetDefaultTab()) { UnreadState state = (UnreadState)tabHash [0]; if (state != null) { states.Add(state); } } foreach (IResource ws in workspaces) { UnreadState state = (UnreadState)tabHash [ws.Id]; if (state != null) { states.Add(state); } } } }
/// <summary> /// Adjusts the unread count for the specified resource stored in the specified /// count map by the specified delta value. /// </summary> private void AdjustUnreadCount(IResource res, int delta, UnreadState state) { if (!state.IsPersistent && !state.IsCounterValid(res)) { return; } int count; if (state.IsCounterValid(res) || (state.IsPersistent && !_unreadCountProviders.Contains(res.Type))) { count = state.GetUnreadCount(res) + delta; } else { // this will initiate a new count calculation which will already take into account // the new unread state of the resource count = state.GetUnreadCount(res); } if (count >= 0) { state.UpdateUnreadCounter(res, count); if (state.IsPersistent && !_unreadCountProviders.Contains(res.Type)) { MarkUnreadCounterChanged(res); } } }
private int GetUnreadCountFromLinks(IResource res, UnreadState state) { int count; int persistentCount = GetPersistentUnreadCount(res); if (persistentCount == 0) { count = 0; } else { int unfilteredCount; IResourceList links = GetUnreadCountedLinks(res, out unfilteredCount); if (links == null) { count = 0; } else { links = links.Intersect(_tabProvider.GetTabFilterList(state.Tab), true); count = CountUnreadResources(links); // HACK: Cleanup for out-of-sync UnreadCount values if (links.Count == unfilteredCount && count != persistentCount) { SetPersistentUnreadCount(res, count); MarkUnreadCounterChanged(res); } } } return(count); }
/** * Switches the state of unread counters to the state associated with the * specified key and filter list, and creates a new state if necessary. */ public UnreadState SetUnreadState(string activeTab, IResource activeWorkspace) { if (activeTab == _tabProvider.GetDefaultTab() && activeWorkspace == null) { _curUnreadState = _defaultUnreadState; } else { IntHashTable tabHash = (IntHashTable)_unreadStateTabMap [activeTab]; if (tabHash == null) { tabHash = new IntHashTable(); _unreadStateTabMap [activeTab] = tabHash; } int wsId = (activeWorkspace == null) ? 0 : activeWorkspace.Id; UnreadState state = (UnreadState)tabHash [wsId]; if (state == null) { state = new UnreadState(this, activeTab, activeWorkspace); tabHash [wsId] = state; } _curUnreadState = state; } return(_curUnreadState); }
private void AdjustCounterInState(IntHashTable tabMap, int workspaceId, IResource resource, int delta) { if (tabMap != null) { UnreadState tabState = (UnreadState)tabMap [workspaceId]; if (tabState != null) { AdjustUnreadCount(resource, delta, tabState); } } }
public void InvalidateUnreadCounter(IResource res) { _defaultUnreadState.InvalidateCounter(res); foreach (DictionaryEntry de in _unreadStateTabMap) { IntHashTable ht = (IntHashTable)de.Value; foreach (IntHashTable.Entry entry in ht) { UnreadState state = (UnreadState)entry.Value; state.InvalidateCounter(res); } } _curUnreadState.OnUnreadCountChanged(res); }
public UnreadManager(WorkspaceManager workspaceManager, IResourceTabProvider tabProvider, ISettingStore settingStore, ICoreProps coreProps) { _tabProvider = tabProvider; _workspaceManager = workspaceManager; _coreProps = coreProps; _defaultUnreadState = new UnreadState(this, null, null); _curUnreadState = _defaultUnreadState; _store = Core.ResourceStore; _propUnreadCount = _store.PropTypes.Register("UnreadCount", PropDataType.Int, PropTypeFlags.Internal); _traceUnreadCounters = settingStore.ReadBool("UnreadCounters", "TraceUnreadCounters", false); Core.ResourceAP.JobFinished += environment_ResourceOperationFinished; Enabled = true; }
/** * Returns the count of unread resources returned by the specified provider and * filtered by the workspace. */ private int GetProviderUnreadCount(IResource res, UnreadState state, IUnreadCountProvider provider) { IResourceList unreadList = provider.GetResourcesForView(res); if (unreadList == Core.ResourceStore.EmptyResourceList) { return(0); } if (state != _defaultUnreadState) { unreadList = unreadList.Intersect(_tabProvider.GetTabFilterList(state.Tab)); if (state.Workspace != null) { unreadList = unreadList.Intersect(_workspaceManager.GetFilterList(state.Workspace)); } } return(unreadList.Count); }
/** * Refreshes the unread counters on all resources. Assumes to be invoked from the * resource thread. */ public void RefreshUnreadCounters() { IResourceList unreadCountedResources = _store.FindResourcesWithProp(null, _propUnreadCount); foreach (IResource unreadCountedRes in unreadCountedResources) { int linkCount; IResourceList unreadCountedLinks = GetUnreadCountedLinks(unreadCountedRes, out linkCount); unreadCountedRes.SetProp(_propUnreadCount, CountUnreadResources(unreadCountedLinks)); } _defaultUnreadState.ResetCounters(); foreach (DictionaryEntry de in _unreadStateTabMap) { IntHashTable tabHash = (IntHashTable)de.Value; foreach (IntHashTable.Entry ie in tabHash) { UnreadState state = (UnreadState)ie.Value; state.ResetCounters(); } } }
/** * Returns the unread count for the specified state. */ internal int GetCountForState(UnreadState state, IResource res) { if (state.IsCounterValid(res) || (state != _curUnreadState && !state.IsPersistent)) { return(state.GetCountFromBuffer(res)); } int count; IUnreadCountProvider provider = (IUnreadCountProvider)_unreadCountProviders [res.Type]; if (provider == null) { count = state.IsPersistent ? res.GetIntProp(_propUnreadCount) : GetUnreadCountFromLinks(res, state); } else { count = GetProviderUnreadCount(res, state, provider); } state.UpdateUnreadCounter(res, count); return(count); }