internal void ApplyTypeFilter(IVisualisableTypeWithAssociations currentSubject)
{
if (currentSubject == null)
{
return;
}
Task.Factory.StartNew(
() =>
{
foreach (DiagramElement element in this.DiagramElements.ToList())
{
bool show = this.trivialFilter.IsVisible(element, !this.SecondaryAssociationElements.ContainsKey(element.DiagramContent.Id));
DiagramElement copyOfElement = element;
this.dispatcher.BeginInvoke(() => copyOfElement.Show = show, DispatcherPriority.Normal);
}
// This needs to happen because the filter only knows how to show/hide associations and secondary lines. The filter
// does not understand the dependency relationships between elements.
// The primary lines are shown/hidden based on events raised by the associations. Without doing the below refresh
// primary lines are not hidden sometimes.
foreach (DiagramElement element in this.DiagramElements.Where(e => e.DiagramContent is Association).ToList())
{
this.dispatcher.BeginInvoke(element.RefreshPosition, DispatcherPriority.Normal);
}
});
}
public ClassUmlDrawingEngine(Guid diagramId, IVisualisableTypeWithAssociations mainSubject)
{
DiagramId = diagramId;
MainSubject = mainSubject;
var subjectAssociation = Factory.GetInstance<SubjectAssociation>().Initialise(mainSubject);
MainDrawingSubject = new DiagramElement(DiagramId, subjectAssociation);
}
public void TestCleanup()
{
this.mockery = null;
this.mockSubject = null;
this.factory.Dispose();
this.factory = null;
}
public static void ClassInitialise(TestContext context)
{
IoC.MapHardcodedRegistrations();
GlobalIntermediateLanguageConstants.LoadOpCodes();
visualisableType = VisualisableTypeTestData.FullModel<Car>(new Container());
subject = VisualisableTypeWithAssociationsDataAdaptor.ExtractPersistentData(visualisableType);
}
public static void ClassInitialise(TestContext context)
{
IoC.MapHardcodedRegistrations();
var modelContainer = new Container();
subjectCar = VisualisableTypeTestData.FullModel<Car>(modelContainer);
subjectFleet = VisualisableTypeTestData.FullModel<Fleet>(modelContainer);
GlobalIntermediateLanguageConstants.LoadOpCodes();
}
public static void ClassInitialise(TestContext context)
{
var cache = PrivateAccessor.GetStaticField(typeof(ModelBuilder), "TypeCache") as ConcurrentDictionary<Type, IVisualisableType>;
cache.Clear();
IoC.MapHardcodedRegistrations();
GlobalIntermediateLanguageConstants.LoadOpCodes();
subject = VisualisableTypeTestData.FullModel<Car>(new Container());
}
public void TestInitialise()
{
this.mockery = new MockRepository();
this.mockSubject = this.mockery.Stub<IVisualisableTypeWithAssociations>();
this.factory = new Container(config => config.For<IVisualisableTypeWithAssociations>().Use(mockSubject));
this.target = new ModelBuilder();
PrivateAccessor.SetField(this.target, "doNotUseFactory", this.factory);
}
public static void ClassInitialise(TestContext context)
{
IoC.MapHardcodedRegistrations();
mockFilter = MockRepository.GenerateMock<ITrivialFilter>();
var modelContainer = new Container();
mockFilter.Expect(m => m.HideTrivialTypes).Return(true).Repeat.Any();
mockFilter.Expect(m => m.IsTrivialType(typeof(String).FullName)).Return(true).Repeat.Any();
mockFilter.Expect(m => m.IsTrivialType(typeof(Delegate).FullName)).Return(true).Repeat.Any();
subject = VisualisableTypeTestData.FullModel<Car>(modelContainer, mockFilter);
}
public static void ClassInitialise(TestContext context)
{
GlobalIntermediateLanguageConstants.LoadOpCodes();
IoC.MapHardcodedRegistrations();
mockTrivialFilter = MockRepository.GenerateMock<ITrivialFilter>();
mockTrivialFilter.Expect(m => m.HideTrivialTypes).Return(true).Repeat.Any();
mockTrivialFilter.Expect(m => m.IsTrivialType(typeof(Delegate).FullName)).Return(true).Repeat.Any();
mockTrivialFilter.Expect(m => m.IsTrivialType(typeof(bool).FullName)).Return(true).Repeat.Any();
mockTrivialFilter.Expect(m => m.IsTrivialType(typeof(Interlocked).FullName)).Return(true).Repeat.Any();
mockEmptyTrivialFilter = MockRepository.GenerateStub<ITrivialFilter>();
// By default filter is off
modelContainer = new Container(c => c.For<ITrivialFilter>().Use(mockEmptyTrivialFilter));
subjectCar = VisualisableTypeTestData.FullModel<Car>(modelContainer);
subjectFleet = VisualisableTypeTestData.FullModel<Fleet>(modelContainer);
}
public ParentAssociation Initialise(Type parent, IVisualisableTypeWithAssociations from)
{
if (parent == null)
{
throw new ArgumentNullResourceException("parent", Resources.General_Given_Parameter_Cannot_Be_Null);
}
if (from == null)
{
throw new ArgumentNullResourceException("from", Resources.General_Given_Parameter_Cannot_Be_Null);
}
if (this.modelBuilder == null)
{
throw new ArgumentNullResourceException("modelBuilder", Resources.General_Given_Parameter_Cannot_Be_Null);
}
IVisualisableTypeWithAssociations parentVisualisableType = this.modelBuilder.BuildSubject(parent, 0);
if (parentVisualisableType == null)
{
throw new ArgumentNullResourceException("parentVisualisableType", Resources.General_Given_Parameter_Cannot_Be_Null);
}
this.AssociatedTo = parentVisualisableType;
if (parentVisualisableType.Modifiers.Kind == TypeKind.Interface)
{
this.fieldName = "Implements: " + parentVisualisableType.Name;
}
else
{
this.fieldName = "Inherits: " + parentVisualisableType.Name;
}
this.AssociatedFrom = from;
this.IsInitialised = true;
return this;
}
public static void ClassInitialise(TestContext context)
{
IoC.MapHardcodedRegistrations();
target = VisualisableTypeTestData.FullModel(typeof(TiptronicTransmission<>), new Container());
}
public static void ClassInitialise(TestContext context)
{
carData = VisualisableTypeTestData.FullModel<Car>(new Container());
}
private void OnTypeFinishedLoadingFromFile(IVisualisableTypeWithAssociations subject)
{
OnTypeFinishedLoading(subject, OnDiagramFinishedLoadingFromFile);
}
private void OnTypeFinishedLoading(IVisualisableTypeWithAssociations subject, EventHandler diagramFinishedLoadingHandler)
{
// At this point the expensive work is done. The VisualisableTypes have been constructed, all that remains is dumping them onto the diagram surface.
// This is done visually and the progress screen does not need to be displayed.
Dispatcher.BeginInvoke(() =>
{
// Ensure UI bound properties set by UI thread.
Diagram diagram = CreateDiagram();
OpenViews.Add(diagram);
CurrentView = diagram;
CurrentView.Controller.DiagramLoaded += diagramFinishedLoadingHandler;
ResetFilters();
CurrentView.Controller.AssignDiagramData(subject);
Title = CurrentView.FullName;
LoadingProgress = LoadingProgressMaximum;
},
DispatcherPriority.Normal);
// Ensure this is at back of queue.
Dispatcher.BeginInvoke(() => SetLoadingStatus(false), DispatcherPriority.ContextIdle);
}
public static VisualisableTypeSubjectData ExtractPersistentData(IVisualisableTypeWithAssociations subject)
{
var returnValue = (VisualisableTypeSubjectData)subject.ExtractPersistentData();
CleanUp();
return returnValue;
}
public SubjectAssociation Initialise(IVisualisableTypeWithAssociations subject)
{
this.AssociatedTo = subject;
this.IsInitialised = true;
return this;
}
public void TestCleanUp()
{
this.mockResources = null;
this.mockType = null;
}
public void TestInitialise()
{
this.mockType = MockRepository.GenerateStub<IVisualisableTypeWithAssociations>();
this.mockModelBuilder = MockRepository.GenerateMock<IModelBuilder>();
this.mockResources = MockRepository.GenerateStub<IApplicationResources>();
this.mockType.Expect(m => m.Name).Return("1234567890");
this.mockType.Expect(m => m.Modifiers).Return(new ModifiersData(typeof (string)));
}
