// Override these methods to notice when we are disconnected and stop receiving notifications
// from the interesting texts object.
public override void RemoveNotification(IVwNotifyChange nchng)
{
base.RemoveNotification(nchng);
m_notifieeCount--;
if (m_notifieeCount <= 0 && m_interestingTexts != null)
{
m_interestingTexts.InterestingTextsChanged -= m_interestingTexts_InterestingTextsChanged;
// Also we need to make sure the InterestingTextsList doesn't do propchanges for us anymore
// N.B. This avoids LT-12437, but we are assuming that this only gets triggered during Refresh or
// shutting down the main window, when all the Clerks are being disposed.
// If a clerk were to be disposed some other time when another clerk was still using the ITL,
// this would be a bad thing to do.
base.RemoveNotification(m_interestingTexts);
}
}
public override void RemoveNotification(IVwNotifyChange nchng)
{
base.RemoveNotification(nchng);
m_notifieeCount--;
if (m_notifieeCount <= 0 && m_interestingTexts != null)
{
m_interestingTexts.InterestingTextsChanged -= m_interestingTexts_InterestingTextsChanged;
// Also we need to make sure the InterestingTextsList doesn't do propchanges for us anymore
// N.B. This avoids LT-12437, but we are assuming that this only gets triggered during Refresh or
// shutting down the main window, when all the Clerks are being disposed.
// If a clerk were to be disposed some other time when another clerk was still using the ITL,
// this would be a bad thing to do.
base.RemoveNotification(m_interestingTexts);
}
}
/// <summary>
/// Member RemoveNotification
/// </summary>
/// <param name="_nchng">_nchng</param>
public void RemoveNotification(IVwNotifyChange _nchng)
{
m_cache.RemoveNotification(_nchng);
}
/// <summary>
/// Member AddNotification
/// </summary>
/// <param name="_nchng">_nchng</param>
public void AddNotification(IVwNotifyChange _nchng)
{
m_cache.AddNotification(_nchng);
}
/// <summary>Member PropChanged</summary>
/// <param name='_nchng'>_nchng</param>
/// <param name='_ct'>_ct</param>
/// <param name='hvo'>hvo</param>
/// <param name='tag'>tag</param>
/// <param name='ivMin'>ivMin</param>
/// <param name='cvIns'>cvIns</param>
/// <param name='cvDel'>cvDel</param>
public void PropChanged(IVwNotifyChange _nchng, int _ct, int hvo, int tag, int ivMin, int cvIns, int cvDel)
{
CheckDisposed();
throw new NotImplementedException("'PropChanged' not implemented yet.");
}
/// <summary>
/// We want to intercept notifications. So instead of registering the root box with the wrapped
/// SDA, we register ourself.
/// </summary>
/// <param name="nchng"></param>
public override void AddNotification(IVwNotifyChange nchng)
{
base.AddNotification(this);
m_notifees.Add(nchng);
}
/// <summary>
/// Notify clients who have requested it that the specified property is changing.
/// The last five arguments indicate the nature of the change, as in
/// ${IVwNotifyChange#PropChanged}. In general, that method will be called for
/// all clients that have requested notification. Certain variations in this
/// process can be made using the first two arguments.
/// If pct is kpctNotifyAll, the first argument is ignored, and all clients are
/// notified in an arbitrary order. (Currently this is also the default behavior
/// if some unrecognized constant is passed. This may eventually become an error.)
/// If pct is kpctNotifyMeThenAll, then the object indicated by the first argument
/// is notified first. This allows the main focus window to update first.
/// If pct is kpctNotifyAllButMe, then the object indicated by the first argument
/// is not notified at all, even if it is listed as requesting notification. This
/// is useful when the object making the change has already done the work that it
/// would normally do when receiving such a notification.
///
/// FDO handles notification of all data changes, so this method does not pass the call on
/// to the FDO SDA implementation.
///
/// Decorator sublasses should intercept the 'setter' calls and notify
/// their views of the change.
///</summary>
/// <param name='_nchng'> </param>
/// <param name='_ct'> </param>
/// <param name='hvo'> </param>
/// <param name='tag'> </param>
/// <param name='ivMin'> </param>
/// <param name='cvIns'> </param>
/// <param name='cvDel'> </param>
public virtual void PropChanged(IVwNotifyChange _nchng, int _ct, int hvo, int tag, int ivMin, int cvIns, int cvDel)
{
// TODO: Do not pass it on, as FDO handles notification on chages to any of its data properties.
// Decorator
m_baseSda.PropChanged(_nchng, _ct, hvo, tag, ivMin, cvIns, cvDel);
}
public void PropChanged(IVwNotifyChange _nchng, int _ct, int hvo, int tag, int ivMin,
int cvIns, int cvDel)
{
throw new NotImplementedException();
}
/// <summary>
/// Notify clients who have requested it that the specified property is changing.
/// The last five arguments indicate the nature of the change, as in
/// ${IVwNotifyChange#PropChanged}. In general, that method will be called for
/// all clients that have requested notification. Certain variations in this
/// process can be made using the first two arguments.
/// If pct is kpctNotifyAll, the first argument is ignored, and all clients are
/// notified in an arbitrary order. (Currently this is also the default behavior
/// if some unrecognized constant is passed. This may eventually become an error.)
/// If pct is kpctNotifyMeThenAll, then the object indicated by the first argument
/// is notified first. This allows the main focus window to update first.
/// If pct is kpctNotifyAllButMe, then the object indicated by the first argument
/// is not notified at all, even if it is listed as requesting notification. This
/// is useful when the object making the change has already done the work that it
/// would normally do when receiving such a notification.
///
/// FDO handles notification of all data changes, so this method does not pass the call on
/// to the FDO SDA implementation.
///
/// Decorator sublasses should intercept the 'setter' calls and notify
/// their views of the change.
///</summary>
/// <param name='_nchng'> </param>
/// <param name='_ct'> </param>
/// <param name='hvo'> </param>
/// <param name='tag'> </param>
/// <param name='ivMin'> </param>
/// <param name='cvIns'> </param>
/// <param name='cvDel'> </param>
public virtual void PropChanged(IVwNotifyChange _nchng, int _ct, int hvo, int tag, int ivMin, int cvIns, int cvDel)
{
// TODO: Do not pass it on, as FDO handles notification on chages to any of its data properties.
// Decorator
m_baseSda.PropChanged(_nchng, _ct, hvo, tag, ivMin, cvIns, cvDel);
}
/// <summary>
/// Request notification when properties change. The ${IVwNotifyChange#PropChanged}
/// method will be called when the property changes (provided the client making the
/// change properly calls ${#PropChanged}.
///</summary>
/// <param name='nchng'> </param>
public void AddNotification(IVwNotifyChange nchng)
{
m_baseSda.AddNotification(nchng);
}
/// <summary> Request removal from the list of objects to notify when properties change. </summary>
/// <param name='nchng'> </param>
public void RemoveNotification(IVwNotifyChange nchng)
{
m_uowService.RemoveNotification(nchng);
}
/// <summary>
/// Notify clients who have requested it that the specified property is changing.
/// The last five arguments indicate the nature of the change, as in
/// ${IVwNotifyChange#PropChanged}. In general, that method will be called for
/// all clients that have requested notification. Certain variations in this
/// process can be made using the first two arguments.
/// If pct is kpctNotifyAll, the first argument is ignored, and all clients are
/// notified in an arbitrary order. (Currently this is also the default behavior
/// if some unrecognized constant is passed. This may eventually become an error.)
/// If pct is kpctNotifyMeThenAll, then the object indicated by the first argument
/// is notified first. This allows the main focus window to update first.
/// If pct is kpctNotifyAllButMe, then the object indicated by the first argument
/// is not notified at all, even if it is listed as requesting notification. This
/// is useful when the object making the change has already done the work that it
/// would normally do when receiving such a notification.
///</summary>
/// <param name='_nchng'> </param>
/// <param name='_ct'> </param>
/// <param name='hvo'> </param>
/// <param name='tag'> </param>
/// <param name='ivMin'> </param>
/// <param name='cvIns'> </param>
/// <param name='cvDel'> </param>
public void PropChanged(IVwNotifyChange _nchng, int _ct, int hvo, int tag, int ivMin, int cvIns, int cvDel)
{
throw new NotSupportedException("PropChanged use is not supported.");
}
/// <summary>
/// Request notification when properties change. The ${IVwNotifyChange#PropChanged}
/// method will be called when the property changes (provided the client making the
/// change properly calls ${#PropChanged}.
///</summary>
/// <param name='nchng'> </param>
public void AddNotification(IVwNotifyChange nchng)
{
m_uowService.AddNotification(nchng);
}
/// <summary>Member RemoveNotification</summary>
/// <param name='_nchng'>_nchng</param>
public void RemoveNotification(IVwNotifyChange _nchng)
{
CheckDisposed();
throw new NotImplementedException("'RemoveNotification' not implemented yet.");
}
/// <summary> Request removal from the list of objects to notify when properties change. </summary>
/// <param name='nchng'> </param>
public void RemoveNotification(IVwNotifyChange nchng)
{
m_baseSda.RemoveNotification(nchng);
}
/// <summary>
/// Member PropChanged
/// </summary>
/// <param name="_nchng">_nchng</param><param name="_ct">_ct</param><param name="hvo">hvo</param><param name="tag">tag</param><param name="ivMin">ivMin</param><param name="cvIns">cvIns</param><param name="cvDel">cvDel</param>
public void PropChanged(IVwNotifyChange _nchng, int _ct, int hvo, int tag, int ivMin, int cvIns,
int cvDel)
{
m_cache.PropChanged(_nchng, _ct, hvo, tag, ivMin, cvIns, cvDel);
}
/// <summary>
/// We want to intercept notifications. So instead of registering the root box with the wrapped
/// SDA, we register ourself.
/// </summary>
/// <param name="nchng"></param>
public override void AddNotification(IVwNotifyChange nchng)
{
base.AddNotification(this);
m_notifees.Add(nchng);
}
/// <summary> Request removal from the list of objects to notify when properties change. </summary>
/// <param name='nchng'> </param>
public void RemoveNotification(IVwNotifyChange nchng)
{
m_baseSda.RemoveNotification(nchng);
}
/// <summary>
/// Count the things that are interested in us so that, when there are no more, we can indicate that we no longer care about
/// changes to the collection of interesting texts.
/// Review JohnT: could it ever happen that we regain our interest in those changes, getting a new notifiee after we lost our last one?
/// </summary>
/// <param name="nchng"></param>
public override void AddNotification(IVwNotifyChange nchng)
{
base.AddNotification(nchng);
m_notifieeCount++;
}
public override void AddNotification(IVwNotifyChange nchng)
{
AddedNotification = nchng;
}
/// <summary> Request removal from the lists of objects to notify when properties change. </summary>
/// <param name='nchng'> </param>
public override void RemoveNotification(IVwNotifyChange nchng)
{
m_domainDataByFlid.RemoveNotification(nchng);
base.RemoveNotification(nchng);
}
public override void RemoveNotification(IVwNotifyChange nchng)
{
RemovedNotification = nchng;
}
public override void RemoveNotification(IVwNotifyChange nchng)
{
m_notifees.Remove(nchng);
base.RemoveNotification(this);
}
public override void PropChanged(IVwNotifyChange _nchng, int _ct, int hvo, int tag, int ivMin, int cvIns, int cvDel)
{
if (tag == ReversalIndexEntrySliceView.kFlidEntries)
{
// What can we do here??
base.PropChanged(_nchng, _ct, hvo, tag, ivMin, cvIns, cvDel);
}
else
{
base.PropChanged(_nchng, _ct, hvo, tag, ivMin, cvIns, cvDel);
}
}
/// <summary>Member RemoveNotification</summary>
/// <param name='_nchng'>_nchng</param>
public void RemoveNotification(IVwNotifyChange _nchng)
{
CheckDisposed();
// No-op
}
/// ------------------------------------------------------------------------------------
/// <summary>
///
/// </summary>
/// <param name="nchng"></param>
/// ------------------------------------------------------------------------------------
public void AddNotification(IVwNotifyChange nchng)
{
CheckDisposed();
m_vvnc.Add(nchng);
}
public override void AddNotification(IVwNotifyChange nchng)
{
base.AddNotification(nchng);
m_notifieeCount++;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// This looks like it was copied from C++ because it was, okay, Tim? (Tim says "no")
/// </summary>
/// <param name="nchng"></param>
/// <param name="ct"></param>
/// <param name="hvo"></param>
/// <param name="tag"></param>
/// <param name="ivMin"></param>
/// <param name="cvIns"></param>
/// <param name="cvDel"></param>
/// ------------------------------------------------------------------------------------
public void PropChanged(IVwNotifyChange nchng, int ct, int hvo, int tag, int ivMin,
int cvIns, int cvDel)
{
CheckDisposed();
if (nchng == null && (int)PropChangeType.kpctNotifyAll != ct)
throw new ArgumentNullException("Don't pass null as the IVwNotifyChange parameter unless ct is kpctNotifyAll");
if ((int)PropChangeType.kpctNotifyMeThenAll == ct)
nchng.PropChanged(hvo, tag, ivMin, cvIns, cvDel);
// Can't use foreach since chng.PropChanged() might add or remove notifcations.
for (int ichng = 0; ichng < m_vvnc.Count; ichng++)
{
IVwNotifyChange chng = m_vvnc[ichng];
if (chng != nchng || (int)PropChangeType.kpctNotifyAll == ct)
chng.PropChanged(hvo, tag, ivMin, cvIns, cvDel);
}
}
/// <summary>
/// Member PropChanged
/// </summary>
/// <param name="_nchng">_nchng</param><param name="_ct">_ct</param><param name="hvo">hvo</param><param name="tag">tag</param><param name="ivMin">ivMin</param><param name="cvIns">cvIns</param><param name="cvDel">cvDel</param>
public void PropChanged(IVwNotifyChange _nchng, int _ct, int hvo, int tag, int ivMin, int cvIns,
int cvDel)
{
m_cache.PropChanged(_nchng, _ct, hvo, tag, ivMin, cvIns, cvDel);
}
/// ------------------------------------------------------------------------------------
/// <summary>
///
/// </summary>
/// <param name="nchng"></param>
/// ------------------------------------------------------------------------------------
public void RemoveNotification(IVwNotifyChange nchng)
{
CheckDisposed();
m_vvnc.Remove(nchng);
}
/// <summary>
/// Member AddNotification
/// </summary>
/// <param name="_nchng">_nchng</param>
public void AddNotification(IVwNotifyChange _nchng)
{
m_cache.AddNotification(_nchng);
}
public override void AddNotification(IVwNotifyChange nchng)
{
AddedNotification = nchng;
}
/// <summary>
/// Member RemoveNotification
/// </summary>
/// <param name="_nchng">_nchng</param>
public void RemoveNotification(IVwNotifyChange _nchng)
{
m_cache.RemoveNotification(_nchng);
}
public override void RemoveNotification(IVwNotifyChange nchng)
{
RemovedNotification = nchng;
}
public override void RemoveNotification(IVwNotifyChange nchng)
{
m_notifees.Remove(nchng);
base.RemoveNotification(this);
}
/// <summary>
/// Request notification when properties change. The ${IVwNotifyChange#PropChanged}
/// method will be called when the property changes (provided the client making the
/// change properly calls ${#PropChanged}. Also, adds target to the list to be
/// notified by SendPropChanged().
///</summary>
public virtual void AddNotification(IVwNotifyChange nchng)
{
m_notifiees.Add(nchng);
}
public void RemoveNotification(IVwNotifyChange _nchng)
{
throw new NotImplementedException();
}
/// <summary> Request removal from the lists of objects to notify when properties change. </summary>
/// <param name='nchng'> </param>
public virtual void RemoveNotification(IVwNotifyChange nchng)
{
m_notifiees.Remove(nchng);
}
/// <summary>
/// Notify clients who have requested it that the specified property is changing.
/// The last five arguments indicate the nature of the change, as in
/// ${IVwNotifyChange#PropChanged}. In general, that method will be called for
/// all clients that have requested notification. Certain variations in this
/// process can be made using the first two arguments.
/// If pct is kpctNotifyAll, the first argument is ignored, and all clients are
/// notified in an arbitrary order. (Currently this is also the default behavior
/// if some unrecognized constant is passed. This may eventually become an error.)
/// If pct is kpctNotifyMeThenAll, then the object indicated by the first argument
/// is notified first. This allows the main focus window to update first.
/// If pct is kpctNotifyAllButMe, then the object indicated by the first argument
/// is not notified at all, even if it is listed as requesting notification. This
/// is useful when the object making the change has already done the work that it
/// would normally do when receiving such a notification.
///
/// FDO handles notification of all data changes, so this method does not pass the call on
/// to the FDO SDA implementation.
///
/// Decorator sublasses should intercept the 'setter' calls and notify
/// their views of the change.
///</summary>
/// <param name='_nchng'> </param>
/// <param name='_ct'> </param>
/// <param name='hvo'> </param>
/// <param name='tag'> </param>
/// <param name='ivMin'> </param>
/// <param name='cvIns'> </param>
/// <param name='cvDel'> </param>
public override void PropChanged(IVwNotifyChange _nchng, int _ct, int hvo, int tag, int ivMin, int cvIns, int cvDel)
{
m_domainDataByFlid.PropChanged(_nchng, _ct, hvo, tag, ivMin, cvIns, cvDel);
}
/// <summary>
/// Request notification when properties change. The ${IVwNotifyChange#PropChanged}
/// method will be called when the property changes (provided the client making the
/// change properly calls ${#PropChanged}.
///</summary>
/// <param name='nchng'> </param>
public void AddNotification(IVwNotifyChange nchng)
{
m_baseSda.AddNotification(nchng);
}
