/// <summary>
/// Determines if the specified x and y offsets are for a valid paste location
/// </summary>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <returns></returns>
/// <remarks></remarks>
private bool IsValidPasteLocation(int dx, int dy)
{
TransitionDiagramClipData cd = (TransitionDiagramClipData)Clipboard.GetData(Strings.CLIPBOARD_FORMAT_TRANSITION_DIAGRAM);
foreach (TransitionDiagramClipDataEntry Entry in cd.Entries)
{
int TargetRow = Entry.Row + dy;
int TargetColumn = Entry.Column + dx;
if (TargetRow < 0 || TargetColumn < 0 || TargetRow >= Constants.TRANSITION_DIAGRAM_MAX_ROWS || TargetColumn >= Constants.TRANSITION_DIAGRAM_MAX_COLUMNS)
{
return(false);
}
BoxDiagramShape s = this.GetShapeAt(TargetRow, TargetColumn);
if (s != null)
{
if (!s.IsStatic)
{
return(false);
}
}
}
return(true);
}
private void PastePTBetween(TransitionDiagramClipData cd, List <ProbabilisticTransitionClipData> alreadyPasted)
{
foreach (TransitionDiagramClipDataEntry Entry in cd.Entries)
{
this.PastePTOutgoingBetween(cd, Entry, alreadyPasted);
}
}
private bool ConfirmPasteOverwrite(TransitionDiagramClipData cd)
{
bool OverwriteRequired = false;
foreach (TransitionDiagramClipDataEntry Entry in cd.Entries)
{
if (this.m_ExplicitClasses.ContainsKey(Entry.ShapeData.StateClassIdSource))
{
OverwriteRequired = true;
break;
}
else if (this.m_WildcardClasses.ContainsKey(Entry.ShapeData.StateClassIdSource))
{
if (!this.m_StratumId.HasValue)
{
OverwriteRequired = true;
break;
}
}
}
if (OverwriteRequired)
{
if (FormsUtilities.ApplicationMessageBox(MessageStrings.CONFIRM_DIAGRAM_PASTE_OVERWRITE, MessageBoxButtons.YesNo) != DialogResult.Yes)
{
return(false);
}
}
return(true);
}
private void PastePTOutgoing(TransitionDiagramClipData cd, List <ProbabilisticTransitionClipData> alreadyPasted, DTAnalyzer analyzer)
{
foreach (TransitionDiagramClipDataEntry Entry in cd.Entries)
{
this.PastePTOutgoing(Entry, alreadyPasted, analyzer);
}
}
/// <summary>
/// Pastes any incoming deterministic transitions
/// </summary>
/// <param name="cd"></param>
/// <param name="entry"></param>
/// <remarks>
/// Create all incoming deterministic transitions described in the specified clipboard entry as follows:
///
/// (1.) We are not going to look at any state classes that are in the clipboard since the transitions for these state
/// classes were established when the state classes paste was performed.
///
/// (2.) If the transition is coming from a state class in the same diagram (but that state class is not found in the clipboard) then we
/// can create that transition. But we can only do this if the source state class does not have a transition to another state class.
///
/// (3.) If it is a transition coming from an off-stratum state class, make sure the state class still exists in the source stratum. And,
/// as with a state class in this diagram, only do this if the source state class does not have a transition to another state class.
/// </remarks>
private void PasteDTIncoming(TransitionDiagramClipData cd, TransitionDiagramClipDataEntry entry, DTAnalyzer analyzer)
{
foreach (DeterministicTransitionClipData t in entry.IncomingDT)
{
if (!ClipContainsStateClass(cd, t.StateClassIdSource))
{
if (this.m_ExplicitClasses.ContainsKey(t.StateClassIdSource))
{
DataRow dr = analyzer.GetStateClassRow(this.m_StratumId, t.StateClassIdSource);
if (IsDTToSelf(dr))
{
dr[Strings.DATASHEET_DT_STATECLASSIDDEST_COLUMN_NAME] = entry.ShapeData.StateClassIdSource;
}
}
else
{
DataRow dr = analyzer.GetStateClassRow(t.StratumIdSource, t.StateClassIdSource);
if (dr != null && IsDTToSelf(dr))
{
dr[Strings.DATASHEET_DT_STATECLASSIDDEST_COLUMN_NAME] = entry.ShapeData.StateClassIdSource;
dr[Strings.DATASHEET_DT_STRATUMIDDEST_COLUMN_NAME] = this.m_StratumId;
}
}
}
}
}
private void InternalPasteStateClasses(TransitionDiagramClipData cd, int dx, int dy, bool pasteNone, DTAnalyzer analyzer)
{
foreach (TransitionDiagramClipDataEntry Entry in cd.Entries)
{
Dictionary <int, StateClassShape> d = null;
if (this.m_StratumId.HasValue)
{
d = this.m_ExplicitClasses;
}
else
{
d = this.m_WildcardClasses;
}
//If the state class being pasted is already in the diagram then just
//update the ages. Otherwise, create a new state class in this stratum.
if (d.ContainsKey(Entry.ShapeData.StateClassIdSource))
{
this.PasteStateClassesReplace(Entry, analyzer);
}
else
{
this.PasteStateClassesCreateNew(cd, Entry, dx, dy, pasteNone, analyzer);
}
}
}
private void PastePT(TransitionDiagramClipData cd, DTAnalyzer analyzer)
{
List <ProbabilisticTransitionClipData> AlreadyPasted = new List <ProbabilisticTransitionClipData>();
this.PastePTBetween(cd, AlreadyPasted);
this.PastePTIncoming(cd, AlreadyPasted, analyzer);
this.PastePTOutgoing(cd, AlreadyPasted, analyzer);
}
private void InternalCopyToClip()
{
DataObject dobj = new DataObject();
TransitionDiagramClipData data = new TransitionDiagramClipData();
DataSheet StratumSheet = this.m_DataFeed.Project.GetDataSheet(Strings.DATASHEET_STRATA_NAME);
DataSheet StateClassSheet = this.m_DataFeed.Project.GetDataSheet(Strings.DATASHEET_STATECLASS_NAME);
DataSheet TransitionTypeSheet = this.m_DataFeed.Project.GetDataSheet(Strings.DATASHEET_TRANSITION_TYPE_NAME);
List <StateClassShape> PrioritizedShapes = this.GetPrioritizedShapeList();
foreach (StateClassShape Shape in PrioritizedShapes)
{
TransitionDiagramClipDataEntry Entry = new TransitionDiagramClipDataEntry();
if (Shape.StratumIdSource.HasValue)
{
Entry.ShapeData.StratumSource = StratumSheet.ValidationTable.GetDisplayName(Shape.StratumIdSource.Value);
}
Entry.ShapeData.StateClassSource = StateClassSheet.ValidationTable.GetDisplayName(Shape.StateClassIdSource);
if (Shape.StratumIdDest.HasValue)
{
Entry.ShapeData.StratumDest = StratumSheet.ValidationTable.GetDisplayName(Shape.StratumIdDest.Value);
}
if (Shape.StateClassIdDest.HasValue)
{
Entry.ShapeData.StateClassDest = StateClassSheet.ValidationTable.GetDisplayName(Shape.StateClassIdDest.Value);
}
Entry.ShapeData.AgeMin = Shape.AgeMinimum;
Entry.ShapeData.AgeMax = Shape.AgeMaximum;
Entry.Row = Shape.Row;
Entry.Column = Shape.Column;
Entry.Bounds = Shape.Bounds;
foreach (DeterministicTransition t in Shape.IncomingDT)
{
Entry.IncomingDT.Add(DTToClipFormat(t, StratumSheet, StateClassSheet));
}
foreach (Transition t in Shape.IncomingPT)
{
Entry.IncomingPT.Add(PTToClipFormat(t, StratumSheet, StateClassSheet, TransitionTypeSheet));
}
foreach (Transition t in Shape.OutgoingPT)
{
Entry.OutgoingPT.Add(PTToClipFormat(t, StratumSheet, StateClassSheet, TransitionTypeSheet));
}
data.Entries.Add(Entry);
}
dobj.SetData(Strings.CLIPBOARD_FORMAT_TRANSITION_DIAGRAM, data);
Clipboard.SetDataObject(dobj);
}
private void PasteDTIncoming(TransitionDiagramClipData cd, DTAnalyzer analyzer)
{
foreach (TransitionDiagramClipDataEntry Entry in cd.Entries)
{
if (!this.m_ExplicitClasses.ContainsKey(Entry.ShapeData.StateClassIdSource))
{
this.PasteDTIncoming(cd, Entry, analyzer);
}
}
}
private static bool ClipContainsStateClass(TransitionDiagramClipData cd, int stateClassId)
{
foreach (TransitionDiagramClipDataEntry Entry in cd.Entries)
{
if (Entry.ShapeData.StateClassIdSource == stateClassId)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Gets the upper left clipboard entry
/// </summary>
/// <returns></returns>
/// <remarks></remarks>
private static TransitionDiagramClipDataEntry GetUpperLeftClipEntry()
{
int MinRow = int.MaxValue;
int MinColumn = int.MaxValue;
List <TransitionDiagramClipDataEntry> lst = new List <TransitionDiagramClipDataEntry>();
TransitionDiagramClipData cd = (TransitionDiagramClipData)Clipboard.GetData(Strings.CLIPBOARD_FORMAT_TRANSITION_DIAGRAM);
foreach (TransitionDiagramClipDataEntry e in cd.Entries)
{
if (e.Row < MinRow)
{
MinRow = e.Row;
}
}
foreach (TransitionDiagramClipDataEntry e in cd.Entries)
{
if (e.Row == MinRow)
{
lst.Add(e);
}
}
foreach (TransitionDiagramClipDataEntry e in lst)
{
if (e.Column < MinColumn)
{
MinColumn = e.Column;
}
}
foreach (TransitionDiagramClipDataEntry e in lst)
{
if (e.Column == MinColumn)
{
return(e);
}
}
Debug.Assert(false);
return(null);
}
private static bool ValidateClipData(TransitionDiagramClipData cd, DataSheet stratumSheet, DataSheet stateClassSheet, DataSheet transitionTypeSheet)
{
Debug.Assert(stratumSheet.Name == Strings.DATASHEET_STRATA_NAME);
Debug.Assert(stateClassSheet.Name == Strings.DATASHEET_STATECLASS_NAME);
Debug.Assert(transitionTypeSheet.Name == Strings.DATASHEET_TRANSITION_TYPE_NAME);
foreach (TransitionDiagramClipDataEntry entry in cd.Entries)
{
if (!ValidateDTClipData(entry.ShapeData, stratumSheet, stateClassSheet))
{
return(false);
}
foreach (DeterministicTransitionClipData t in entry.IncomingDT)
{
if (!ValidateDTClipData(t, stratumSheet, stateClassSheet))
{
return(false);
}
}
foreach (ProbabilisticTransitionClipData t in entry.IncomingPT)
{
if (!ValidatePTClipData(t, stratumSheet, stateClassSheet, transitionTypeSheet))
{
return(false);
}
}
foreach (ProbabilisticTransitionClipData t in entry.OutgoingPT)
{
if (!ValidatePTClipData(t, stratumSheet, stateClassSheet, transitionTypeSheet))
{
return(false);
}
}
}
return(true);
}
private void PasteStateClassesCreateNew(TransitionDiagramClipData cd, TransitionDiagramClipDataEntry entry, int dx, int dy, bool pasteNone, DTAnalyzer analyzer)
{
int TargetRow = entry.Row + dy;
int TargetColumn = entry.Column + dx;
//If 'PasteNone" or there is no destination state class then
//create a transition-to-self in this stratum.
if (pasteNone || (!entry.ShapeData.StateClassIdDest.HasValue))
{
this.CreateDTRecord(entry.ShapeData.StateClassIdSource, null, null, entry.ShapeData.AgeMin, entry.ShapeData.AgeMax, TargetRow, TargetColumn);
return;
}
//If the destination state class is in the clipboard then create a transition
//to that state class in this stratum.
if (ClipContainsStateClass(cd, entry.ShapeData.StateClassIdDest.Value))
{
this.CreateDTRecord(entry.ShapeData.StateClassIdSource, null, entry.ShapeData.StateClassIdDest.Value, entry.ShapeData.AgeMin, entry.ShapeData.AgeMax, TargetRow, TargetColumn);
return;
}
//Resolve the destination stratum and create a transition to that stratum. Note that the resolution
//will fail if the destination state class no longer exists and is not in the wild card stratum. In
//this case, create a transition-to-self.
int?StratumIdActual = null;
if (analyzer.ResolveStateClassStratum(entry.ShapeData.StratumIdSource, entry.ShapeData.StratumIdDest, entry.ShapeData.StateClassIdDest.Value, ref StratumIdActual))
{
this.CreateDTRecord(entry.ShapeData.StateClassIdSource, StratumIdActual, entry.ShapeData.StateClassIdDest.Value, entry.ShapeData.AgeMin, entry.ShapeData.AgeMax, TargetRow, TargetColumn);
}
else
{
this.CreateDTRecord(entry.ShapeData.StateClassIdSource, null, null, entry.ShapeData.AgeMin, entry.ShapeData.AgeMax, TargetRow, TargetColumn);
}
}
private void PastePTOutgoingBetween(TransitionDiagramClipData cd, TransitionDiagramClipDataEntry entry, List <ProbabilisticTransitionClipData> alreadyPasted)
{
foreach (ProbabilisticTransitionClipData t in entry.OutgoingPT)
{
if (AlreadyPastedPT(t, alreadyPasted))
{
continue;
}
if (!t.StateClassIdDest.HasValue)
{
continue;
}
if (ClipContainsStateClass(cd, t.StateClassIdDest.Value))
{
this.CreatePTRecord(this.m_StratumId, entry.ShapeData.StateClassIdSource, null, t.StateClassIdDest, t.TransitionTypeId, t.Probability, t.Proportion, t.AgeMin, t.AgeMax, t.AgeRelative, t.AgeReset, t.TstMin, t.TstMax, t.TstRelative);
alreadyPasted.Add(t);
}
}
}
private void PasteTransitions(TransitionDiagramClipData cd, bool pasteAll, bool pasteBetween, bool pasteDeterministic, bool pasteProbabilistic, DTAnalyzer analyzer)
{
if (pasteAll)
{
if (pasteDeterministic)
{
this.PasteDTIncoming(cd, analyzer);
}
if (pasteProbabilistic)
{
this.PastePT(cd, analyzer);
}
}
else if (pasteBetween)
{
if (pasteProbabilistic)
{
List <ProbabilisticTransitionClipData> AlreadyPasted = new List <ProbabilisticTransitionClipData>();
this.PastePTBetween(cd, AlreadyPasted);
}
}
}
private void InternalPasteSpecial(bool pasteAll, bool pasteBetween, bool pasteNone, bool pasteDeterministic, bool pasteProbabilistic, bool isTargeted)
{
//Get the clipboard data and verify that all items can be pasted. Note that
//once it has been validated it will contain the correct Ids for those items.
TransitionDiagramClipData cd = (TransitionDiagramClipData)Clipboard.GetData(Strings.CLIPBOARD_FORMAT_TRANSITION_DIAGRAM);
DataSheet StratumSheet = this.m_DataFeed.Project.GetDataSheet(Strings.DATASHEET_STRATA_NAME);
DataSheet StateClassSheet = this.m_DataFeed.Project.GetDataSheet(Strings.DATASHEET_STATECLASS_NAME);
DataSheet TransitionTypeSheet = this.m_DataFeed.Project.GetDataSheet(Strings.DATASHEET_TRANSITION_TYPE_NAME);
if (!ValidateClipData(cd, StratumSheet, StateClassSheet, TransitionTypeSheet))
{
return;
}
//Make sure the user is Ok with overwriting any existing data
if (!this.ConfirmPasteOverwrite(cd))
{
return;
}
//Get the paste location deltas for the current paste shapes
int dx = 0;
int dy = 0;
if (!this.GetPasteLocationDeltas(ref dx, ref dy, isTargeted))
{
if (isTargeted)
{
FormsUtilities.ErrorMessageBox(MessageStrings.ERROR_DIAGRAM_CANNOT_PASTE_SPECIFIC_LOCATION);
}
else
{
FormsUtilities.ErrorMessageBox(MessageStrings.ERROR_DIAGRAM_CANNOT_PASTE_ANY_LOCATION);
}
return;
}
//Paste all state classes and transitions
this.m_DTDataSheet.BeginAddRows();
this.m_PTDataSheet.BeginAddRows();
DTAnalyzer Analyzer = new DTAnalyzer(this.m_DTDataSheet.GetData(), this.m_DataFeed.Project);
this.InternalPasteStateClasses(cd, dx, dy, pasteNone, Analyzer);
this.PasteTransitions(cd, pasteAll, pasteBetween, pasteDeterministic, pasteProbabilistic, Analyzer);
this.m_DTDataSheet.EndAddRows();
this.m_PTDataSheet.EndAddRows();
this.DeselectAllShapes();
foreach (TransitionDiagramClipDataEntry Entry in cd.Entries)
{
if (this.m_ExplicitClasses.ContainsKey(Entry.ShapeData.StateClassIdSource))
{
this.SelectShape(this.m_ExplicitClasses[Entry.ShapeData.StateClassIdSource]);
}
else if (this.m_WildcardClasses.ContainsKey(Entry.ShapeData.StateClassIdSource))
{
this.SelectShape(this.m_WildcardClasses[Entry.ShapeData.StateClassIdSource]);
}
}
this.Focus();
}
