// ----------------------------------------------------------------------
public bool IsPartOfConnection(iCS_EditorObject testedPort)
{
if (this == testedPort)
{
return(true);
}
var src = ProducerPort;
if (src == null)
{
return(false);
}
return(src.IsPartOfConnection(testedPort));
}
// ----------------------------------------------------------------------
public float ProposeViewportScalingFor(iCS_EditorObject node, float minScale, float maxScale)
{
var newScale = ProposeViewportScalingFor(node);
if (newScale < minScale)
{
newScale = minScale;
}
if (newScale > maxScale)
{
newScale = maxScale;
}
return(newScale);
}
// ===================================================================
// ENABLE PORTS
// -------------------------------------------------------------------------
/// Returns the list of all enable ports on the given node.
///
/// @param node The node from which to extract the enable ports.
/// @return The list of enable ports.
///
public static iCS_EditorObject[] GetEnablePorts(iCS_EditorObject node)
{
var enables = new List <iCS_EditorObject>();
node.ForEachChildPort(
p => {
if (p.IsEnablePort)
{
enables.Add(p);
}
}
);
return(enables.ToArray());
}
// -------------------------------------------------------------------------
/// Returns the list of functions inside the given package.
///
/// @param package The package to examine.
/// @return The list of all functions nested inside the package.
///
public static List <iCS_EditorObject> GetListOfFunctions(iCS_EditorObject package)
{
var childFunctions = new List <iCS_EditorObject>();
package.ForEachChildRecursiveDepthFirst(
c => {
if (c.IsKindOfFunction)
{
childFunctions.Add(c);
}
}
);
return(childFunctions);
}
// ----------------------------------------------------------------------
private bool WasPresent(iCS_EditorObject obj)
{
if (obj == null)
{
return(false);
}
int id = obj.InstanceId;
if (id < 0 || id >= myWasPresent.Length)
{
return(false);
}
return(myWasPresent[id]);
}
// ----------------------------------------------------------------------
public static void DragAndDropSetPortValue(iCS_EditorObject port, UnityEngine.Object value)
{
var iStorage = port.IStorage;
OpenTransaction(iStorage);
try {
port.Value = value;
}
catch (System.Exception) {
CancelTransaction(iStorage);
return;
}
CloseTransaction(iStorage, "Set port " + port.DisplayName);
}
// ----------------------------------------------------------------------
// This function will attempt to remove dupliacte ports on the same module.
public void OptimizeDataConnection(iCS_EditorObject inPort, iCS_EditorObject outPort)
{
var provider = inPort.ProducerPort;
if (provider == null)
{
return;
}
if (provider != outPort)
{
OptimizeDataConnection(provider, outPort);
}
OptimizeDataConnection(provider);
}
// ----------------------------------------------------------------------
public void SmartFocusOn(iCS_EditorObject obj)
{
if (IStorage == null)
{
return;
}
var focusNode = obj;
// Focus on port parent.
if (obj.IsPort)
{
focusNode = obj.ParentNode;
}
// Move to higher parent if scale is too large.
float scale = ProposeViewportScalingFor(focusNode, 0.75f, 1f);
if (Math3D.IsSmallerOrEqual(scale, 0.75f))
{
CenterAndScaleOn(focusNode);
return;
}
if (focusNode != IStorage.DisplayRoot)
{
var focusNodeParent = focusNode.ParentNode;
if (focusNodeParent != null)
{
var parentScale = ProposeViewportScalingFor(focusNodeParent, 0.80f, 1f);
while (parentScale > 0.80f)
{
scale = parentScale;
focusNode = focusNodeParent;
focusNodeParent = focusNode.ParentNode;
if (focusNode == IStorage.DisplayRoot || focusNodeParent == null)
{
break;
}
parentScale = ProposeViewportScalingFor(focusNodeParent, 0.80f, 1f);
}
}
}
// Center on focus node
if (focusNode == IStorage.DisplayRoot)
{
CenterAndScaleOnRoot();
}
else
{
CenterAtWithScale(focusNode.GlobalPosition, scale);
}
}
// ----------------------------------------------------------------------
static Vector2 BindingDirectionFromTo(iCS_EditorObject port, iCS_EditorObject to, iCS_IStorage storage)
{
// Don't compute complex tangents if we don't have a proper parent.
iCS_EditorObject portParent = port.ParentNode;
if (port.IsFloating || to.IsFloating)
{
if (port.IsDataOrControlPort || !portParent.IsPositionOnEdge(port.AnimatedPosition, port.Edge))
{
Vector2 fromPos = port.AnimatedPosition;
Vector2 toPos = to.AnimatedPosition;
return(GetBestDirectionFrom((toPos - fromPos).normalized));
}
}
if (port.IsOutTransitionPort && portParent.IsIconizedOnDisplay)
{
return(storage.GetTransitionPackageVector(portParent));
}
if (port.IsInTransitionPort && portParent.IsIconizedOnDisplay)
{
return(-storage.GetTransitionPackageVector(portParent));
}
Vector2 direction;
if (port.IsOnLeftEdge)
{
direction = LeftDirection;
}
else if (port.IsOnRightEdge)
{
direction = RightDirection;
}
else if (port.IsOnTopEdge)
{
direction = UpDirection;
}
else
{
direction = DownDirection;
}
// Inverse direction for connection between nested nodes.
iCS_EditorObject toParent = to.ParentNode;
if (storage.IsChildOf(toParent, portParent) && !port.IsInStatePort)
{
direction = -direction;
}
return(direction);
}
public bool IsBelowInHierarchyTo(iCS_EditorObject node)
{
bool result = false;
node.ForEachChildRecursiveDepthLast(
c => {
if (c == this)
{
result = true;
}
}
);
return(result);
}
// ----------------------------------------------------------------------
public iCS_EditorObject PropertiesWizardFindFunction(iCS_EditorObject module, LibraryObject libraryObject)
{
iCS_EditorObject foundNode = null;
module.ForEachChildNode(
n => {
if (n.DisplayName == libraryObject.nodeName)
{
foundNode = n;
}
}
);
return(foundNode);
}
// -------------------------------------------------------------------------
public iCS_EditorObject[] CleanupEnablePorts(iCS_EditorObject node)
{
var enables = GetEnablePorts(node);
if (enables == null || enables.Length == 0)
{
return(null);
}
for (int i = 0; i < enables.Length; ++i)
{
enables[i].PortIndex = (int)iCS_PortIndex.EnablesStart + i;
}
return(enables);
}
// ======================================================================
// Transition helpers.
// ----------------------------------------------------------------------
public iCS_EditorObject GetFromStatePort(iCS_EditorObject transitionObject)
{
if (transitionObject == null)
{
return(null);
}
if (transitionObject.IsInStatePort)
{
iCS_EditorObject source = transitionObject.ProducerPort;
if (source == null)
{
return(null);
}
if (source.IsOutStatePort)
{
return(source);
}
transitionObject = source.Parent;
}
if (transitionObject.IsTransitionPackage)
{
if (!UntilMatchingChildPort(transitionObject,
child => {
if (child.IsInTransitionPort)
{
transitionObject = child;
return(true);
}
return(false);
}
))
{
return(null);
}
}
if (transitionObject.IsInTransitionPort)
{
iCS_EditorObject source = transitionObject.ProducerPort;
if (source == null)
{
return(null);
}
transitionObject = source;
}
if (transitionObject.IsOutStatePort)
{
return(transitionObject);
}
return(null);
}
// ---------------------------------------------------------------------------------
public void ShowElement(iCS_EditorObject eObj)
{
if (eObj == null)
{
return;
}
var parent = eObj.Parent;
while (parent != null)
{
myTreeView.Unfold(parent);
parent = parent.Parent;
}
}
public static LibraryMemberInfo getAssociatedHelpMemberInfo(iCS_EditorObject edObj)
{
if (edObj != null)
{
if (edObj.IsPort)
{
// check for special types of ports.
// TODO: support these.
if (edObj.PortIndex == (int)PortIndex.Return && edObj.ParentNode.IsStaticField)
{
// return port will be same as parent node description.
}
else if (edObj.IsKindOfPackagePort && !edObj.IsInstanceNodePort && !edObj.IsProposedDataPort)
{
return(null);
}
else if (edObj.PortIndex >= (int)PortIndex.ParametersEnd)
{
return(null);
}
// Following port will contain the member info
if (edObj.IsProposedDataPort)
{
// contained in edObj
}
else if (edObj.IsInputPort)
{
var consumerPorts = edObj.SegmentEndConsumerPorts;
var aConsumer = consumerPorts.Length != 0 ? consumerPorts[0] : edObj;
edObj = aConsumer.Parent;
}
else if (edObj.IsOutputPort)
{
edObj = edObj.SegmentProducerPort.Parent;
}
}
LibraryMemberInfo memberInfo = null;
// Try and Get Member Info from GetAssociatedDescriptor
if (edObj.IsKindOfFunction || edObj.IsEventHandler)
{
memberInfo = edObj.GetLibraryObject() as LibraryMemberInfo;
}
return(memberInfo);
}
return(null);
}
// ----------------------------------------------------------------------
public static void RunOnWillDestroyNode(iCS_EditorObject obj)
{
if (!obj.IsNode || OnWillDestroyNode == null)
{
return;
}
foreach (Action <iCS_EditorObject> handler in OnWillDestroyNode.GetInvocationList())
{
try {
handler(obj);
}
catch (Exception) {}
}
}
// ----------------------------------------------------------------------
/// Returns the port with the given port index.
///
/// @return The found port or _null_ otherwise.
///
public iCS_EditorObject GetPortWithIndex(int portIndex)
{
iCS_EditorObject result = null;
ForEachChildPort(
p => {
if (p.PortIndex == portIndex)
{
result = p;
}
}
);
return(result);
}
// Hierarchy Queries ====================================================
public bool IsParentOf(iCS_EditorObject obj)
{
if (obj == null)
{
return(false);
}
var parent = obj.Parent;
if (parent == this)
{
return(true);
}
return(IsParentOf(parent));
}
public static void Case(iCS_EditorObject obj,
Func <iCS_EditorObject, bool> c1, Action <iCS_EditorObject> f1,
Func <iCS_EditorObject, bool> c2, Action <iCS_EditorObject> f2,
Func <iCS_EditorObject, bool> c3, Action <iCS_EditorObject> f3,
Func <iCS_EditorObject, bool> c4, Action <iCS_EditorObject> f4,
Func <iCS_EditorObject, bool> c5, Action <iCS_EditorObject> f5,
Func <iCS_EditorObject, bool> c6, Action <iCS_EditorObject> f6,
Func <iCS_EditorObject, bool> c7, Action <iCS_EditorObject> f7,
Func <iCS_EditorObject, bool> c8, Action <iCS_EditorObject> f8,
Func <iCS_EditorObject, bool> c9, Action <iCS_EditorObject> f9,
Action <iCS_EditorObject> defaultFnc = null)
{
Prelude.choice(obj, c1, f1, c2, f2, c3, f3, c4, f4, c5, f5, c6, f6, c7, f7, c8, f8, c9, f9, defaultFnc);
}
// ----------------------------------------------------------------------
public static void RunOnPortCreated(iCS_EditorObject obj)
{
if (!obj.IsPort || OnPortCreated == null)
{
return;
}
foreach (Action <iCS_EditorObject> handler in OnPortCreated.GetInvocationList())
{
try {
handler(obj);
}
catch (Exception) {}
}
}
// ----------------------------------------------------------------------
public iCS_EditorObject GetOutTransitionPort(iCS_EditorObject transitionObject)
{
if (transitionObject.IsInStatePort)
{
transitionObject = transitionObject.ProducerPort;
if (transitionObject == null)
{
return(null);
}
}
if (transitionObject.IsOutTransitionPort)
{
return(transitionObject);
}
if (transitionObject.IsOutStatePort)
{
transitionObject = FindAConnectedPort(transitionObject);
if (transitionObject == null)
{
return(null);
}
}
if (transitionObject.IsInTransitionPort)
{
transitionObject = transitionObject.ParentNode;
if (transitionObject == null)
{
return(null);
}
}
if (transitionObject.IsTransitionPackage)
{
UntilMatchingChildPort(transitionObject,
p => {
if (p.IsOutTransitionPort)
{
transitionObject = p;
return(true);
}
return(false);
}
);
if (transitionObject.IsOutTransitionPort)
{
return(transitionObject);
}
}
return(null);
}
// ----------------------------------------------------------------------
iCS_EditorObject PropertiesWizardCreatePortIfNonExisting(iCS_EditorObject module, string portName, Type portType,
VSObjectType objType, int portIdx = -1)
{
iCS_EditorObject port = PropertiesWizardGetPort(module, portName, objType, portIdx);
if (port == null)
{
port = CreatePort(portName, module.InstanceId, portType, objType);
if (portIdx != -1)
{
port.PortIndex = portIdx;
}
}
return(port);
}
// ----------------------------------------------------------------------
void OnStatePackageMenu(iCS_EditorObject targetObject)
{
iCS_MenuContext[] menu = StartWithFocusMenu(targetObject);
if (!targetObject.IsIconizedInLayout && !targetObject.IsFoldedInLayout)
{
// Base menu items
int idx = GrowMenuBy(ref menu, 3);
menu[idx] = new iCS_MenuContext(PackageStr);
menu[idx + 1] = new iCS_MenuContext(StateChartStr);
menu[idx + 2] = new iCS_MenuContext(SeparatorStr);
}
AddShowInHierarchyMenuItem(ref menu);
AddDeleteMenuItem(ref menu);
ShowMenu(menu, targetObject, targetObject.IStorage);
}
// ======================================================================
// Creation
// ----------------------------------------------------------------------
public void MoveDynamicPortToLastIndex(iCS_EditorObject port)
{
// -- Display error for invalid use. --
if (port.IsFixDataPort)
{
Debug.LogWarning("iCanScript: Internal error: Tryng to move port index of a fix port");
return;
}
// -- Get next available parameter index. --
iCS_EditorObject parent = port.ParentNode;
port.PortIndex = GetNextDynamicOrProposedPortIndex(parent);
// -- Reajust the port indexes. --
GraphEditor.AdjustPortIndexes(parent);
}
// ----------------------------------------------------------------------
// Creates the missing fix ports
public bool BuildMissingPorts(iCS_EditorObject node, PortInfo[] neededPorts)
{
bool changed = false;
foreach (var pi in neededPorts)
{
if (!DoesPortExist(node, pi.Name, pi.ValueType, pi.PortType))
{
var port = CreatePort(pi.Name, node.InstanceId, pi.ValueType, pi.PortType);
port.Value = pi.InitialValue;
changed = true;
}
}
return(changed);
}
// =========================================================================
// Utilities
// -------------------------------------------------------------------------
// Don't use this function directly !!!
// Use ToggleMultiSelection or SelectedObject= value to add an object to the
// selection list.
void RemoveFromSelectedObjects(iCS_EditorObject obj)
{
int idx = mySelectedObjects.IndexOf(obj);
if (idx == -1)
{
return;
}
mySelectedObjects.RemoveAt(idx);
if (idx == 0)
{
SelectedObjectId = mySelectedObjects.Count == 0 ? -1 : mySelectedObjects[0].InstanceId;
}
obj.ForEachConnectedProducerTypeCast(n => RemoveFromSelectedObjects(n));
}
// ----------------------------------------------------------------------
public int NbOfChildren(iCS_EditorObject parent, Func <iCS_EditorObject, bool> filter)
{
if (!IsValid(parent))
{
return(0);
}
int cnt = 0;
ForEachChild(parent, c => { if (filter(c))
{
++cnt;
}
});
return(cnt);
}
Prelude.Tree <iCS_EditorObject> BuildTreeNode(iCS_EditorObject nodeRoot, List <bool> filterFlags)
{
Prelude.Tree <iCS_EditorObject> tree = new Prelude.Tree <iCS_EditorObject>(nodeRoot);
myIStorage.ForEachChild(nodeRoot,
c => {
Prelude.Tree <iCS_EditorObject> newNode = BuildTreeNode(c, filterFlags);
if (filterFlags[c.InstanceId])
{
tree.AddChild(newNode);
}
}
);
tree.Sort(SortComparaison);
return(tree);
}
// -------------------------------------------------------------------------
public static Texture2D GetDefaultNodeIconFor(iCS_EditorObject obj)
{
if (obj.IsEventHandler)
{
return(GetDefaultNodeIconFor(DefaultNodeIcons.Message));
}
else if (obj.IsInstanceNode)
{
return(GetDefaultNodeIconFor(DefaultNodeIcons.ObjectInstance));
}
else if (obj.IsKindOfPackage)
{
return(GetDefaultNodeIconFor(DefaultNodeIcons.Package));
}
else if (obj.IsConstructor)
{
return(GetDefaultNodeIconFor(DefaultNodeIcons.Builder));
}
else if (obj.IsKindOfFunction)
{
return(GetDefaultNodeIconFor(DefaultNodeIcons.Function));
}
else if (obj.IsStateChart)
{
return(GetDefaultNodeIconFor(DefaultNodeIcons.StateChart));
}
else if (obj.IsEntryState)
{
return(GetDefaultNodeIconFor(DefaultNodeIcons.EntryState));
}
else if (obj.IsState)
{
return(GetDefaultNodeIconFor(DefaultNodeIcons.State));
}
else if (obj.IsOnStateEntryPackage)
{
return(GetDefaultNodeIconFor(DefaultNodeIcons.OnStateEntry));
}
else if (obj.IsOnStateUpdatePackage)
{
return(GetDefaultNodeIconFor(DefaultNodeIcons.OnStateUpdate));
}
else if (obj.IsOnStateExitPackage)
{
return(GetDefaultNodeIconFor(DefaultNodeIcons.OnStateExit));
}
return(TextureCache.GetIcon(kDefaultIcon));
}
// ===================================================================
// BUILDER
// -------------------------------------------------------------------
/// Creates a port editor window at the given screen position.
///
/// @param screenPosition The screen position where the editor
/// should be displayed.
///
public static new EditorWindow Create(iCS_EditorObject port, Vector2 screenPosition)
{
if (port == null)
{
return(null);
}
var self = EventHandlerPortEditor.CreateInstance <EventHandlerPortEditor>();
self.vsObject = port;
Texture2D iCanScriptLogo = null;
TextureCache.GetTexture(iCS_EditorStrings.TitleLogoIcon, out iCanScriptLogo);
self.titleContent = new GUIContent("Event Handler Port Editor", iCanScriptLogo);
self.ShowUtility();
return(self);
}
