/// <summary>
/// DeleteRule: typeof(DiagramDisplayHasDiagramOrder), FireTime=LocalCommit, Priority=FrameworkDomainModel.BeforeDelayValidateRulePriority;
/// Make sure that deletion of a diagram order results in a reorder
/// </summary>
private static void DiagramOrderDeletedRule(ElementDeletedEventArgs e)
{
DiagramDisplayHasDiagramOrder link = (DiagramDisplayHasDiagramOrder)e.ModelElement;
Diagram diagram = link.Diagram;
if (!diagram.IsDeleted)
{
Store store = diagram.Store;
if (diagram.Partition == store.DefaultPartition) // This should never happen, but it is easy to check
{
if (null == DiagramDisplayHasDiagramOrder.GetDiagramDisplay(diagram))
{
DiagramDisplay displayContainer = link.DiagramDisplay;
if (displayContainer.IsDeleted)
{
ReadOnlyCollection <DiagramDisplay> displays = store.ElementDirectory.FindElements <DiagramDisplay>(false);
displayContainer = (displays.Count != 0) ? displays[0] : new DiagramDisplay(store);
}
new DiagramDisplayHasDiagramOrder(displayContainer, diagram);
}
}
}
else
{
DiagramDisplay displayContainer = link.DiagramDisplay;
if (!displayContainer.IsDeleted && displayContainer.OrderedDiagramCollection.Count == 0)
{
// No more diagrams, don't need the container
displayContainer.Delete();
}
}
}
/// <summary>
/// Display the diagram order dialog with the specified diagram order and update
/// the diagram order as specified by the user.
/// </summary>
/// <param name="serviceProvider">A <see cref="IServiceProvider"/> used to parent the dialog</param>
/// <param name="docData">The owning <see cref="ModelingDocData"/> of the diagrams being reordered</param>
/// <param name="diagrams">A list of <see cref="Diagram"/> elements to reorder</param>
/// <param name="selectedDiagram">A <see cref="Diagram"/> to select when the dialog is initially displayed.</param>
/// <param name="images">The diagram images to display. Images are keyed off the Guid of the diagram type (format "N")</param>
public static void ShowDialog(IServiceProvider serviceProvider, ModelingDocData docData, IList <Diagram> diagrams, Diagram selectedDiagram, ImageList images)
{
DiagramOrderDialog orderDialog = new DiagramOrderDialog(diagrams, selectedDiagram, images);
if (orderDialog.ShowDialog(Utility.GetDialogOwnerWindow(serviceProvider)) == DialogResult.OK)
{
DiagramDisplay.UpdateDiagramDisplayOrder(docData.Store, orderDialog.myDiagramOrder);
}
}
/// <summary>
/// Make this the active view for the display
/// </summary>
public void Activate()
{
if (!myIsActive)
{
DiagramDisplay container = DiagramDisplay;
foreach (DiagramDisplayHasDiagramOrder link in DiagramDisplayHasDiagramOrder.GetLinksToOrderedDiagramCollection(DiagramDisplay))
{
link.myIsActive = false; // Doesn't matter if we set ours
}
myIsActive = true;
}
}
public static PropertyDescriptor CreateDescriptor(ModelElement contextElement)
{
Store store = contextElement.Store;
IList <DiagramDisplay> containers = store.ElementDirectory.FindElements <DiagramDisplay>();
if (containers.Count != 0)
{
DiagramDisplay container = containers[0];
PropertyDescriptor descriptor = DomainTypeDescriptor.CreatePropertyDescriptor(container, store.DomainDataDirectory.GetDomainProperty(DiagramDisplay.SaveDiagramPositionDomainPropertyId));
return(new DiagramContextDescriptor(container, descriptor));
}
return(null);
}
/// <summary>
/// AddRule: typeof(Microsoft.VisualStudio.Modeling.Diagrams.Diagram), FireTime=LocalCommit, Priority=FrameworkDomainModel.BeforeDelayValidateRulePriority;
/// Make sure a diagram is included in the ordered list
/// </summary>
private static void DiagramAddedRule(ElementAddedEventArgs e)
{
Diagram diagram = (Diagram)e.ModelElement;
if (!diagram.IsDeleted)
{
Store store = diagram.Store;
if (diagram.Partition == store.DefaultPartition)
{
DiagramDisplay displayContainer = DiagramDisplayHasDiagramOrder.GetDiagramDisplay(diagram);
if (displayContainer == null)
{
ReadOnlyCollection <DiagramDisplay> displays = store.ElementDirectory.FindElements <DiagramDisplay>(false);
displayContainer = (displays.Count != 0) ? displays[0] : new DiagramDisplay(store);
new DiagramDisplayHasDiagramOrder(displayContainer, diagram);
}
}
}
}
public override void ElementDeleted(Microsoft.VisualStudio.Modeling.ElementDeletedEventArgs e)
{
ORMSolutions.ORMArchitect.Framework.Diagnostics.TraceUtility.TraceRuleStart(e.ModelElement.Store, "ORMSolutions.ORMArchitect.Framework.Shell.DiagramDisplay.DiagramOrderDeletedRule");
DiagramDisplay.DiagramOrderDeletedRule(e);
ORMSolutions.ORMArchitect.Framework.Diagnostics.TraceUtility.TraceRuleEnd(e.ModelElement.Store, "ORMSolutions.ORMArchitect.Framework.Shell.DiagramDisplay.DiagramOrderDeletedRule");
}
/// <summary>
/// Constructor
/// Creates a DiagramDisplayHasDiagramOrder link in the same Partition as the given DiagramDisplay
/// </summary>
/// <param name="source">DiagramDisplay to use as the source of the relationship.</param>
/// <param name="target">Diagram to use as the target of the relationship.</param>
public DiagramDisplayHasDiagramOrder(DiagramDisplay source, global::Microsoft.VisualStudio.Modeling.Diagrams.Diagram target)
: base((source != null ? source.Partition : null), new DslModeling::RoleAssignment[] { new DslModeling::RoleAssignment(DiagramDisplayHasDiagramOrder.DiagramDisplayDomainRoleId, source), new DslModeling::RoleAssignment(DiagramDisplayHasDiagramOrder.DiagramDomainRoleId, target) }, null)
{
}
public static DslModeling::LinkedElementCollection <global::Microsoft.VisualStudio.Modeling.Diagrams.Diagram> GetOrderedDiagramCollection(DiagramDisplay element)
{
return(GetRoleCollection <DslModeling::LinkedElementCollection <global::Microsoft.VisualStudio.Modeling.Diagrams.Diagram>, global::Microsoft.VisualStudio.Modeling.Diagrams.Diagram>(element, DiagramDisplayDomainRoleId));
}
public static void SetDiagramDisplay(global::Microsoft.VisualStudio.Modeling.Diagrams.Diagram element, DiagramDisplay newDiagramDisplay)
{
DslModeling::DomainRoleInfo.SetLinkedElement(element, DiagramDomainRoleId, newDiagramDisplay);
}
/// <summary>
/// Process diagram items to make sure they have a current ordering representation
/// </summary>
protected sealed override void ProcessElement(Diagram element, Store store, INotifyElementAdded notifyAdded)
{
DiagramDisplayHasDiagramOrder link = DiagramDisplayHasDiagramOrder.GetLinkToDiagramDisplay(element);
DiagramDisplay container = myDiagramDisplay;
if (container == null)
{
if (link != null)
{
container = link.DiagramDisplay;
}
// Make sure we only have one container, use the one we've already grabbed
ReadOnlyCollection <DiagramDisplay> containers = store.ElementDirectory.FindElements <DiagramDisplay>(false);
int containerCount = containers.Count;
for (int i = containerCount - 1; i >= 0; --i)
{
DiagramDisplay testContainer = containers[i];
if (container != null)
{
if (testContainer != container)
{
testContainer.Delete();
}
}
else if (i == 0)
{
container = testContainer;
}
else
{
testContainer.Delete();
}
}
if (container == null)
{
container = new DiagramDisplay(store);
notifyAdded.ElementAdded(container, false);
}
myDiagramDisplay = container;
if (link != null)
{
// There is nothing else to do, the element has been validated
if (link.IsActiveDiagram)
{
if (mySeenActive)
{
link.IsActiveDiagram = false;
}
else
{
mySeenActive = true;
}
}
return;
}
}
if (link == null)
{
// This will add to the end of the existing collection
link = new DiagramDisplayHasDiagramOrder(container, element);
notifyAdded.ElementAdded(link, false);
}
else
{
if (link.DiagramDisplay != container)
{
link.DiagramDisplay = container;
}
if (link.IsActiveDiagram)
{
if (mySeenActive)
{
link.IsActiveDiagram = false;
}
else
{
mySeenActive = true;
}
}
}
}
public DiagramTabPage(MultiDiagramDocViewControl docViewControl, DiagramView designer)
{
myDocViewControl = docViewControl;
Designer = designer;
base.SuspendLayout();
base.SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.OptimizedDoubleBuffer | ControlStyles.UserPaint | ControlStyles.SupportsTransparentBackColor, true);
base.UseVisualStyleBackColor = false;
Diagram diagram = designer.Diagram;
base.Text = base.Name = diagram.Name;
base.Controls.Add(designer);
// Find the correct tab location for this diagram, depending on the diagram order and the
// pages that have already been added
TabControl.TabPageCollection pages = docViewControl.TabPages;
bool inserted = false;
Store store = diagram.Store;
bool useDiagramDisplay = store.FindDomainModel(DiagramDisplayDomainModel.DomainModelId) != null;
if (useDiagramDisplay)
{
DiagramDisplay display = DiagramDisplayHasDiagramOrder.GetDiagramDisplay(diagram);
if (display != null)
{
// Walk the existing pages and match up the expected display order. Note that
// there is no guarantee that all of the preceding diagrams have tab pages already.
// If the previous pages are out of order, then we will get a reorder event later on
// that puts them in the correct order. This will add them in an unpredictable order
// if the sequences are different.
IList <Diagram> orderedDiagrams = display.OrderedDiagramCollection;
int diagramCount = orderedDiagrams.Count;
int nextDiagramIndex = 0;
Diagram nextDiagram = orderedDiagrams[nextDiagramIndex];
int pageCount = pages.Count;
if (nextDiagram == diagram)
{
if (pageCount != 0)
{
// The new diagram is first, insert at the beginning
pages.Insert(0, this);
inserted = true;
}
}
else
{
for (int pageIndex = 0; pageIndex < pageCount && !inserted; ++pageIndex)
{
DiagramTabPage page = (DiagramTabPage)pages[pageIndex];
Diagram pageDiagram = page.Diagram;
bool getNextDiagram = false;
if (pageDiagram == nextDiagram)
{
getNextDiagram = true;
}
else
{
// Keep walking diagrams until we get a match
while (nextDiagramIndex < diagramCount)
{
nextDiagram = orderedDiagrams[++nextDiagramIndex];
if (pageDiagram == nextDiagram)
{
getNextDiagram = true;
}
else if (nextDiagram == diagram)
{
if ((pageIndex + 1) < pageCount)
{
pages.Insert(pageIndex + 1, this);
inserted = true;
break;
}
}
}
}
if (getNextDiagram)
{
if (nextDiagramIndex < diagramCount)
{
nextDiagram = orderedDiagrams[++nextDiagramIndex];
if (nextDiagram == diagram)
{
// Insert immediately after the current page
if ((pageIndex + 1) < pageCount)
{
pages.Insert(pageIndex + 1, this);
inserted = true;
}
break;
}
}
else
{
break;
}
}
}
}
}
}
if (!inserted)
{
pages.Add(this);
}
// If the image key is set before the page is inserted then the tab size is incorrect
// and nothing draws property. I have no idea why.
base.ImageKey = diagram.GetType().GUID.ToString("N", null);
base.ResumeLayout(false);
store.EventManagerDirectory.ElementPropertyChanged.Add(diagram.GetDomainClass().NameDomainProperty, diagram.Id, (EventHandler <ElementPropertyChangedEventArgs>)DiagramNameChanged);
if (useDiagramDisplay)
{
designer.DiagramClientView.GotFocus += new EventHandler(ViewGotFocus);
designer.DiagramClientView.Resize += new EventHandler(InitialViewResize);
myTurnOffResizeEventInFocusEvent = true;
}
designer.DiagramClientView.DiagramDisassociating += DiagramDisassociating;
}
/// <summary>
/// Update the diagram display order
/// </summary>
/// <param name="store">The current <see cref="Store"/></param>
/// <param name="orderedDiagrams">An ordered list of diagrams</param>
public static void UpdateDiagramDisplayOrder(Store store, IList<Diagram> orderedDiagrams)
{
DiagramDisplay container = null;
IList<DiagramDisplay> containers = store.ElementDirectory.FindElements<DiagramDisplay>(false);
if (containers.Count != 0)
{
container = containers[0];
}
using (Transaction t = store.TransactionManager.BeginTransaction(FrameworkResourceStrings.DiagramDisplayReorderDiagramsTransactionName))
{
int orderCount = orderedDiagrams.Count;
if (orderCount == 0)
{
if (container != null)
{
container.OrderedDiagramCollection.Clear();
}
return;
}
else if (container == null)
{
container = new DiagramDisplay(store);
}
LinkedElementCollection<Diagram> existingDiagrams = container.OrderedDiagramCollection;
int existingDiagramCount = existingDiagrams.Count;
for (int i = existingDiagramCount - 1; i >= 0; --i)
{
Diagram testDiagram = existingDiagrams[i];
if (!orderedDiagrams.Contains(testDiagram))
{
existingDiagrams.RemoveAt(i);
--existingDiagramCount;
}
}
for (int i = 0; i < orderCount; ++i)
{
Diagram orderedDiagram = orderedDiagrams[i];
int existingIndex = existingDiagrams.IndexOf(orderedDiagram);
if (existingIndex == -1)
{
if (i < existingDiagramCount)
{
existingDiagrams.Insert(i, orderedDiagram);
}
else if (!existingDiagrams.Contains(orderedDiagram))
{
existingDiagrams.Add(orderedDiagram);
}
++existingDiagramCount;
}
else if (existingIndex != i)
{
existingDiagrams.Move(existingIndex, i);
}
}
if (t.HasPendingChanges)
{
t.Commit();
}
}
}
private DiagramContextDescriptor(DiagramDisplay contextElement, PropertyDescriptor descriptor)
: base(descriptor.Name, null)
{
myInnerElement = contextElement;
myInnerDescriptor = descriptor;
}
/// <summary>
/// Update the diagram display order
/// </summary>
/// <param name="store">The current <see cref="Store"/></param>
/// <param name="orderedDiagrams">An ordered list of diagrams</param>
public static void UpdateDiagramDisplayOrder(Store store, IList <Diagram> orderedDiagrams)
{
DiagramDisplay container = null;
IList <DiagramDisplay> containers = store.ElementDirectory.FindElements <DiagramDisplay>(false);
if (containers.Count != 0)
{
container = containers[0];
}
using (Transaction t = store.TransactionManager.BeginTransaction(FrameworkResourceStrings.DiagramDisplayReorderDiagramsTransactionName))
{
int orderCount = orderedDiagrams.Count;
if (orderCount == 0)
{
if (container != null)
{
container.OrderedDiagramCollection.Clear();
}
return;
}
else if (container == null)
{
container = new DiagramDisplay(store);
}
LinkedElementCollection <Diagram> existingDiagrams = container.OrderedDiagramCollection;
int existingDiagramCount = existingDiagrams.Count;
for (int i = existingDiagramCount - 1; i >= 0; --i)
{
Diagram testDiagram = existingDiagrams[i];
if (!orderedDiagrams.Contains(testDiagram))
{
existingDiagrams.RemoveAt(i);
--existingDiagramCount;
}
}
for (int i = 0; i < orderCount; ++i)
{
Diagram orderedDiagram = orderedDiagrams[i];
int existingIndex = existingDiagrams.IndexOf(orderedDiagram);
if (existingIndex == -1)
{
if (i < existingDiagramCount)
{
existingDiagrams.Insert(i, orderedDiagram);
}
else if (!existingDiagrams.Contains(orderedDiagram))
{
existingDiagrams.Add(orderedDiagram);
}
++existingDiagramCount;
}
else if (existingIndex != i)
{
existingDiagrams.Move(existingIndex, i);
}
}
if (t.HasPendingChanges)
{
t.Commit();
}
}
}
private DiagramContextDescriptor(DiagramDisplay contextElement, PropertyDescriptor descriptor)
: base(descriptor.Name, null)
{
myInnerElement = contextElement;
myInnerDescriptor = descriptor;
}
