It is a rather complex interface as its name implies it is a root for the entire application:
public interface IRootCollection : IStorableCollection {
void Reinitialize(ISerializationContext context);
string ProjectIdentifier { get ; }
UsageLevel LicensingLevel { get; }
Mnemonic ServerProjectId { get; }
ILocalSettingsProvider Settings { get; }
IDisplayManager DisplayManager { get; }
IComposition CurrentComposition { get; set; }
IStorable CurrentCadContext { get; set; }
IInitialSite InitialSite { get; }
IMnemonicPath CurrentSite { get; set;}
Matrix4D CurrentTransform { get; set;}
ISiteTableInstance SiteTable { get; }
ILegacyMslinkTableInstance LegacyMslinkTable { get; }
IDataSetManager DataSetManager { get; }
IPrivilegeController PrivilegeController { get; }
bool IsReadonly { get; }
event PropertyChangeEventHandler CadContextChanged;
}
It extends another interface
public interface IStorableCollection : IStorable {
void Serialize (ISerializationContext context, Predicate<IMnemonicPath> filter);
void SerializeDeep (ISerializationContext context, Predicate<IMnemonicPath> filter);
void SerializeDeep(ISerializationContext context);
IStorable Resolve(IMnemonicPath path);
IMnemonicPath NewMnemonic (IInternalId internalId, ICollection exclusions);
IMnemonicPath GetChildPath(IStorable child, IMnemonicPath tail);
Mnemonic AddChild(string mnemonicCandidate, IStorable child, IChangeScope scope);
void RemoveChild (Mnemonic child, string description);
void Drop(IMnemonicPath child, bool refreshDisplay);
void RemoveChildren ();
}
Which extends another interface:
public interface IStorable : IDisposable, IDescribable {
void Serialize(ISerializationContext context);
int CompareInternalId (IInternalId id);
StorableStatusOverlays Status { get; }
IPropertyProvider PropertyProvider { get; }
void OnIntegrate (ISerializationContext newContext);
IMnemonicPath Path { get; }
void AddStoreExtender (IStoreExtender extender);
void RemoveStoreExtender (Mnemonic extenderType, string extenderId);
bool AutoResolve (IConflictManager conflictManager, IAggregateConflict aggreateConflict);
int BaseRevision { get; set; }
IChangeManager ChangeManager { get; }
}
Which is disposable and extends another interface
public interface IDescribable {
object Describe(IDescribeContext context);
}
In all this, there is only one event (a custom event that basically is to fire when something changes and provides the old and new versions.
When we attach an event and try to fire it, nothing happens. No exceptions, no method execution - i.e. no side effects of trying to fire the event. Here the event:
public class PropertyChangeEventArgs : EventArgs {
public readonly object Old;
public readonly object New;
public PropertyChangeEventArgs (object oldObj, object newObj) : base () {
Old = oldObj;
New = newObj;
}
}
public delegate void PropertyChangeEventHandler (object sender, PropertyChangeEventArgs args);
I hope this helps.
