// -----------------------------------------------------------------------------------------
public void Generate_Subscriber_Grid_Spacing_Field()
{
var v2 = new Vector2Property();
v2.PropertyName = _TranzmitGraphView.GridLayoutSpacing_Subscriber.PropertyName;
v2.PropertyValue = _TranzmitGraphView.GridLayoutSpacing_Subscriber.PropertyValue;
var visualElement = new VisualElement();
var blackboardField = new BlackboardField {
text = v2.PropertyName, typeText = ""
};
visualElement.Add(blackboardField);
var field = new Vector2Field("Value:");
field.value = v2.PropertyValue;
field.RegisterValueChangedCallback(ChangeEvent =>
{
_TranzmitGraphView.GridLayoutSpacing_Subscriber.PropertyValue = field.value;
if (_TranzmitGraphView.CurrentArrangementType == Tranzmit_Graph_View.ArrangementTypes.Grid)
{
_TranzmitGraphView.Arrange_Subscriber_Results(Tranzmit_Graph_View.ArrangementTypes.Grid);
}
});
var blackBoardValueRow = new BlackboardRow(blackboardField, field);
visualElement.Add(blackBoardValueRow);
_TranzmitGraphView.Blackboard.Add(visualElement);
}
public BlackboardPropertyView(BlackboardField field, EditorView editorView, AbstractProperty property)
{
this.AddStyleSheet("Styles/PropertyView/Blackboard");
this.field = field;
this.editorView = editorView;
this.property = property;
rows = new List <VisualElement>();
keyDownCallback = evt => {
// Record Undo for input field edit
if (undoGroup == -1)
{
undoGroup = Undo.GetCurrentGroup();
editorView.DlogObject.RegisterCompleteObjectUndo("Change property value");
}
// Handle escaping input field edit
if (evt.keyCode == KeyCode.Escape && undoGroup > -1)
{
Undo.RevertAllDownToGroup(undoGroup);
undoGroup = -1;
evt.StopPropagation();
}
// Dont record Undo again until input field is unfocused
undoGroup++;
MarkDirtyRepaint();
};
focusOutCallback = evt => undoGroup = -1;
BuildFields(property);
AddToClassList("blackboardPropertyView");
}
// -----------------------------------------------------------------------------------------
public void Generate_Broadcaster_Vertical_Spacing_Field()
{
var floatProp = new FloatProperty();
floatProp.PropertyName = _TranzmitGraphView.VerticalYSpacing_Broadcaster.PropertyName;
floatProp.PropertyValue = _TranzmitGraphView.VerticalYSpacing_Broadcaster.PropertyValue;
var visualElement = new VisualElement();
var blackboardField = new BlackboardField {
text = floatProp.PropertyName, typeText = ""
};
visualElement.Add(blackboardField);
var field = new FloatField("Value:");
field.value = floatProp.PropertyValue;
field.RegisterValueChangedCallback(ChangeEvent =>
{
_TranzmitGraphView.VerticalYSpacing_Broadcaster.PropertyValue = field.value;
if (_TranzmitGraphView.CurrentArrangementType == Tranzmit_Graph_View.ArrangementTypes.Vertical)
{
_TranzmitGraphView.Arrange_Broadcaster_Results(Tranzmit_Graph_View.ArrangementTypes.Vertical);
}
});
var blackBoardValueRow = new BlackboardRow(blackboardField, field);
visualElement.Add(blackBoardValueRow);
_TranzmitGraphView.Blackboard.Add(visualElement);
}
// -----------------------------------------------------------------------------------------
public void Generate_BlackBoard_Error_Color_Field()
{
var color = new ColorProperty();
color.PropertyName = _TranzmitGraphView.ErrorColor.PropertyName;
color.PropertyValue = _TranzmitGraphView.ErrorColor.PropertyValue;
var visualElement = new VisualElement();
var blackboardField = new BlackboardField {
text = color.PropertyName, typeText = ""
};
visualElement.Add(blackboardField);
var field = new ColorField("Value:");
field.value = color.PropertyValue;
field.RegisterValueChangedCallback(ChangeEvent =>
{
_TranzmitGraphView.ErrorColor.PropertyValue = field.value;
_TranzmitGraphView.UpdateErrorColorsOnGraphElements();
});
var blackBoardValueRow = new BlackboardRow(blackboardField, field);
visualElement.Add(blackBoardValueRow);
_TranzmitGraphView.Blackboard.Add(visualElement);
}
internal void AddPropertyToBlackBoard(ExposedProperty exposedProperty)
{
var localPropertyName = exposedProperty.PropertyName;
var localPropertyValue = exposedProperty.PropertyValue;
while (ExposedProperties.Any(x => x.PropertyName == localPropertyName))
{
localPropertyName = $"{localPropertyName}(1)"; // Username || Username(1)
}
var property = new ExposedProperty();
property.PropertyName = localPropertyName;
property.PropertyValue = localPropertyValue;
ExposedProperties.Add(property);
var container = new VisualElement();
var blackboardField = new BlackboardField {
text = property.PropertyName, typeText = "string property"
};
var propertyValueTextField = new TextField("Value: ")
{
value = localPropertyValue
};
propertyValueTextField.RegisterValueChangedCallback(evt =>
{
var changingPropertyIndex = ExposedProperties.FindIndex(x => x.PropertyName == property.PropertyName);
ExposedProperties[changingPropertyIndex].PropertyValue = evt.newValue;
});
var blackBoardValueRow = new BlackboardRow(blackboardField, propertyValueTextField);
container.Add(blackBoardValueRow);
Blackboard.Add(container);
}
public Blackboard(VisualElement visualParent, GraphView graph)
{
m_visualParent = visualParent;
UnityEditor.Experimental.GraphView.Blackboard bb = new UnityEditor.Experimental.GraphView.Blackboard(graph);
//bb.subTitle = string.Empty;
//m_visualParent.Add(bb);
graph.Add(bb);
bb.title = "Test Blackboard";
BlackboardSection bbSection = new BlackboardSection();
bbSection.title = "Section Test Name";
bbSection.headerVisible = true;
bb.Add(bbSection);
BlackboardField bbField = new BlackboardField();
bbField.title = "TestVariable";
bbField.text = "TestText";
//bbSection.Add(bbField);
BlackboardRow bbRow = new BlackboardRow(bbField, new VisualElement());
bbSection.Add(bbRow);
bbSection.Add(bbRow);
Debug.Log($"Is Field Droppable {bbField.IsDroppable()}");
}
private VisualElement GenerateBlackboardField(ExposedProperty property)
{
var container = new VisualElement();
var blackboardField = new BlackboardField
{
text = property.propertyName,
typeText = "String",
};
container.Add(blackboardField);
var propertyValueTextField = new TextField("Value:");
propertyValueTextField.Q(className: "unity-label").style.minWidth = 50;
propertyValueTextField.value = property.propertyValue;
propertyValueTextField.RegisterValueChangedCallback(evt =>
{
int changingPropertyIndex = graphView.exposedProperties.FindIndex(
exposedProperty => exposedProperty.propertyName == property.propertyName);
graphView.exposedProperties[changingPropertyIndex].propertyValue = evt.newValue;
});
var blackboardValueRow = new BlackboardRow(propertyValueTextField, propertyValueTextField);
container.Add(blackboardValueRow);
return(container);
}
/// <summary>
/// The Blackboard contains the values of each Exposed Property
/// This Method allows us to create a new exposed property and adds it to the BlackBoard
/// </summary>
/// <param name="exposedProperty"></param>
/// <param name="refreshing"></param>
public void AddPropertyToBlackBoard(Runtime.ExposedProperty exposedProperty, bool refreshing = false)
{
var localPropertyName = exposedProperty.PropertyName;
var localPropertyValue = exposedProperty.PropertyValue;
while (ExposedProperties.Any(x => x.PropertyName == localPropertyName) && !refreshing)
{
localPropertyName = $"{localPropertyName}(1)";
}
if (!refreshing)
{
var property = new Runtime.ExposedProperty();
property.PropertyName = localPropertyName;
property.PropertyValue = localPropertyValue;
ExposedProperties.Add(property);
}
int j = ExposedProperties.Count - 1;
var container = new VisualElement();
var blackboardField = new BlackboardField {
text = localPropertyName, typeText = "string"
};
blackboardField.Add(new Button(() => { RemovePropertyFromBlackboard(j); })
{
text = "x"
});
container.Add(blackboardField);
var propertyValueTextField = new TextField(label: "Value:")
{
value = localPropertyValue
};
propertyValueTextField.RegisterValueChangedCallback(evt => {
int i = j;
var changingPropertyIndex = ExposedProperties.FindIndex(x => x.PropertyName == localPropertyName);
ExposedProperties[i].PropertyValue = evt.newValue;
});
var blackBoardValueRow = new BlackboardRow(blackboardField, propertyValueTextField);
container.Add(blackBoardValueRow);
_blackboard.Add(container);
if (_dialogueGraph.GetAutoSave())
{
_dialogueGraph.RequestDataOperation(true);
}
}
public IEnumerator BlackboardSelectionIsRestoredWhenEnteringPlaymode_AddFieldsAfterAddingBBToGV()
{
{ // Create initial blackboard.
var blackboard = new Blackboard();
blackboard.SetupBuildAndUpdate(null, CommandDispatcher, graphView);
var inSection = new BlackboardSection(blackboard, "Section 1");
blackboard.Add(inSection);
var field = new BlackboardField {
viewDataKey = "bfield"
};
var propertyView = new Label("Prop");
var row = new BlackboardRow();
row.Add(field);
row.Add(propertyView);
inSection.Add(row);
graphView.AddElement(blackboard);
CommandDispatcher.Dispatch(new SelectElementsCommand(SelectElementsCommand.SelectionMode.Add, row.Model));
Assert.True(row.IsSelected());
}
// Allow 1 frame to let the persistent data get saved
yield return(null);
// This will re-create the window, flushing all temporary state
yield return(new EnterPlayMode());
// Allow 1 frame to let the persistence be restored
yield return(null);
{ // Add blackboard to graphview first then add field to blackboard.
var blackboard = new Blackboard();
blackboard.SetupBuildAndUpdate(null, CommandDispatcher, graphView);
graphView.AddElement(blackboard);
var inSection = new BlackboardSection(blackboard, "Section 1");
blackboard.Add(inSection);
var field = new BlackboardField {
viewDataKey = "bfield"
};
var propertyView = new Label("Prop");
var row = new BlackboardRow();
row.Add(field);
row.Add(propertyView);
inSection.Add(row);
Assert.True(row.IsSelected());
}
}
public void AddPropertyToBlackBoard(ExposedVariable exposedVariable)
{
var localVariableName = exposedVariable.variableName;
var localVariableValue = exposedVariable.variableValue;
int iterator = 1;
while (exposedVariables.Any(x => x.variableName == localVariableName))
{
localVariableName = $"{localVariableName}({iterator})";
iterator++;
/* FIX Later
* if (localVariableName.Contains($"({iterator - 1})")) {
* localVariableName = $"{localVariableName.Substring(0, localVariableName.Length -3}" +"({iterator})";
* }
*/
}
var variable = new ExposedVariable();
variable.variableName = localVariableName;
variable.variableValue = localVariableValue;
exposedVariables.Add(variable);
var container = new VisualElement();
var blackboardField = new BlackboardField {
text = variable.variableName, typeText = "int variable"
};
// blackboardField.RegisterCallback<DragAndDrop>(evt => { });
container.Add(blackboardField);
var variableValueTextField = new TextField("Value:")
{
value = variable.variableValue
};
variableValueTextField.RegisterValueChangedCallback(evt => {
var changingVariableIndex = exposedVariables.FindIndex(x => x.variableName == variable.variableName);
exposedVariables[changingVariableIndex].variableValue = evt.newValue;
});
var blackboardValueRow = new BlackboardRow(blackboardField, variableValueTextField);
container.Add(blackboardValueRow);
blackboard.Add(container);
}
public void AddPropertyToBlackBoard(ExposedProperty exposedProperty)
{
int duplicateNameIndex = 1;
string localPropertyName = exposedProperty.PropertyName;
string localPropertyValue = exposedProperty.PropertyValue;
while (ExposedProperties.Any(x => x.PropertyName == localPropertyName))
{
localPropertyName = $"{localPropertyName}{duplicateNameIndex}"; // Name || Name1 || Name12
duplicateNameIndex++;
}
ExposedProperty property = new ExposedProperty();
property.PropertyName = localPropertyName;
property.PropertyValue = localPropertyValue;
ExposedProperties.Add(property);
VisualElement container = new VisualElement();
BlackboardField field = new BlackboardField
{
text = property.PropertyName,
typeText = "string",
};
container.Add(field);
TextField propertyValueTextField = new TextField("Value : ")
{
value = localPropertyValue,
style = { width = new Length(80, LengthUnit.Percent) }
};
propertyValueTextField.RegisterValueChangedCallback(delegate(ChangeEvent <string> evt)
{
int changingPropertyIndex = ExposedProperties.FindIndex(x => x.PropertyName == property.PropertyName);
ExposedProperties[changingPropertyIndex].PropertyValue = evt.newValue;
});
BlackboardRow blackboardRow = new BlackboardRow(field, propertyValueTextField);
container.Add(blackboardRow);
if (Blackboard != null)
{
Blackboard.Add(container);
}
}
public IEnumerator BlackboardSelectionIsRestoredWhenEnteringPlaymode_AddFieldsBeforeAddingBBToGV()
{
{ // Create initial blackboard.
var blackboard = new Blackboard();
var inSection = new BlackboardSection();
blackboard.Add(inSection);
var field = new BlackboardField()
{
viewDataKey = "bfield"
};
var propertyView = new Label("Prop");
var row = new BlackboardRow(field, propertyView);
inSection.Add(row);
graphView.AddElement(blackboard);
graphView.AddToSelection(field);
Assert.True(field.selected);
}
// Allow 1 frame to let the persistent data get saved
yield return(null);
// This will re-create the window, flushing all temporary state
yield return(new EnterPlayMode());
// Allow 1 frame to let the persistence be restored
yield return(null);
{ // Add field to blackboard first then add blackboard to graphview.
var blackboard = new Blackboard();
var inSection = new BlackboardSection();
blackboard.Add(inSection);
var field = new BlackboardField()
{
viewDataKey = "bfield"
};
var propertyView = new Label("Prop");
var row = new BlackboardRow(field, propertyView);
inSection.Add(row);
graphView.AddElement(blackboard);
Assert.True(field.selected);
}
}
public CharacterProperty(string propertyName, string propertyValue, DialogueGraphView dialogueGraphView)
{
graphView = dialogueGraphView;
propertyType = BlackboardType.Character;
PropertyName = propertyName;
PropertyValue = propertyValue;
propertyElement = new VisualElement();
var blackboardField = new BlackboardField {
text = propertyName, typeText = "Character"
};
blackboardField.Q <Label>("typeLabel").style.flexBasis = StyleKeyword.Auto;
blackboardField.capabilities &= ~Capabilities.Deletable;
blackboardField.RegisterCallback <ContextualMenuPopulateEvent>(PopulateDeleteOption);
blackboardField.Add(new Button(() => { graphView.RemovePropertyFromBlackboard(this.PropertyName); })
{
text = "X"
});
propertyElement.Add(blackboardField);
var propertyValueTextField = new TextField("Value:")
{
value = PropertyValue
};
propertyValueTextField.Q <Label>().style.minWidth = StyleKeyword.Auto;
propertyValueTextField.RegisterValueChangedCallback(evt =>
{
var changingPropertyIndex = graphView.exposedProperties.FindIndex(x => x.PropertyName == this.PropertyName);
if (changingPropertyIndex < 0)
{
return;
}
graphView.exposedProperties[changingPropertyIndex].PropertyValue = evt.newValue;
propertyValueTextField.value = evt.newValue;
});
var blackboardValueRow = new BlackboardRow(blackboardField, propertyValueTextField);
propertyElement.Add(blackboardValueRow);
}
public void AddPropertyToBlackBoard(ExposedProperty property, bool loadMode = false)
{
var localPropertyName = property.PropertyName;
var localPropertyValue = property.PropertyValue;
// var localPropertySprite = property.PropertySprite;
var localPropertyNameCharacter = property.PropertyNameCharacter;
if (!loadMode)
{
while (ExposedProperties.Any(x => x.PropertyName == localPropertyName))
{
localPropertyName = $"{localPropertyName}(1)";
}
}
var item = ExposedProperty.CreateInstance();
item.PropertyName = localPropertyName;
item.PropertyValue = localPropertyValue;
item.PropertyNameCharacter = localPropertyNameCharacter;
// item.PropertySprite = localPropertySprite;
ExposedProperties.Add(item);
var container = new VisualElement();
//Serch Elements in BlackBoard
var field = new BlackboardField {
text = localPropertyName, typeText = "string"
};
container.Add(field);
var propertyValueTextField = new TextField("Value:")
{
value = localPropertyValue
};
propertyValueTextField.RegisterValueChangedCallback(evt =>
{
var index = ExposedProperties.FindIndex(x => x.PropertyName == item.PropertyName);
ExposedProperties[index].PropertyValue = evt.newValue;
});
var sa = new BlackboardRow(field, propertyValueTextField);
container.Add(sa);
Blackboard.Add(container);
}
internal void AddPropertyToBlackBoard(ExposedProperty exposedProperty)
{
//local var for the blackboard prop
var localPropertyName = exposedProperty.PropertyName;
var localPropertyValue = exposedProperty.PropertyValue;
//loop through and find the any duplicts and another +1 to name
while (ExposedProperties.Any(x => x.PropertyName == localPropertyName))
{
localPropertyName = $"{localPropertyName}(1)"; //
}
var property = new ExposedProperty();
property.PropertyName = localPropertyName;
property.PropertyValue = localPropertyValue;
ExposedProperties.Add(property);
var container = new VisualElement();
var blackboardField = new BlackboardField
{
text = property.PropertyName,
typeText = "string property"
};
container.Add(blackboardField);
//add value fiels into black board
var propertyValueTextField = new TextField("value")
{
value = localPropertyValue
};
propertyValueTextField.RegisterValueChangedCallback(evt =>
{
var changingPropertyIndex = ExposedProperties.FindIndex(x => x.PropertyName == property.PropertyName);
ExposedProperties[changingPropertyIndex].PropertyValue = evt.newValue;
});
var blackBoardValueRow = new BlackboardRow(blackboardField, propertyValueTextField);
container.Add(blackBoardValueRow);
Blackboard.Add(container);
}
private void InitVariables(BehaviourGraphModel model)
{
inspector.VariableContainer.Clear();
if (model.Settings.variableDefinition.Value != null)
{
foreach (var variable in model.Settings.variableDefinition.Value.Decompose())
{
var blackboardField = new BlackboardField(ICON, $"{model.Settings.variableDefinition.Value.Name}.{variable.fullName}", $"{variable.type.Value.FullName}")
{
capabilities = Capabilities.Selectable | Capabilities.Deletable | Capabilities.Droppable
};
blackboardField.userData = new VariableInfo {
fieldOffsetInfo = variable, model = model
};
blackboardField.AddToClassList(BEHAVIOUR_VARIABLE_CLASS);
blackboardField.Q <Image>("icon").tintColor = variable.type.Value.GetColor();
inspector.VariableContainer.Add(blackboardField);
}
}
}
public void AddFieldView(string _name, ICZType _data)
{
BlackboardField blackboardField = new BlackboardField()
{
text = _name, typeText = _data.ValueType.Name, userData = _data
};
blackboardField.RegisterCallback <MouseEnterEvent>(evt =>
{
GraphView.nodes.ForEach(node =>
{
if (node is ParameterNodeView parameterNodeView && parameterNodeView.T_Model.Name == blackboardField.text)
{
parameterNodeView.HighlightOn();
}
});
});
blackboardField.RegisterCallback <MouseLeaveEvent>(evt =>
{
GraphView.nodes.ForEach(node =>
{
if (node is ParameterNodeView parameterNodeView && parameterNodeView.T_Model.Name == blackboardField.text)
{
parameterNodeView.HighlightOff();
}
});
});
BindableElement fieldDrawer = UIElementsFactory.CreateField("", _data.ValueType, _data.GetValue(), _newValue =>
{
_data.SetValue(_newValue);
if (_data.GetValue() != null)
{
blackboardField.typeText = _data.ValueType.Name;
}
});
BlackboardRow blackboardRow = new BlackboardRow(blackboardField, fieldDrawer);
contentContainer.Add(blackboardRow);
fields[_name] = blackboardRow;
}
void AddProperty(INodeProperty property, bool create = false, int index = -1)
{
if (m_PropertyRows.ContainsKey(property.guid))
{
return;
}
if (create)
{
property.displayName = m_Graph.SanitizePropertyName(property.displayName);
}
var field = new BlackboardField(m_ExposedIcon, property.displayName, property.propertyType.ToString())
{
userData = property
};
var row = new BlackboardRow(field, new BlackboardFieldPropertyView(m_Graph, property));
row.userData = property;
if (index < 0)
{
index = m_PropertyRows.Count;
}
if (index == m_PropertyRows.Count)
{
m_Section.Add(row);
}
else
{
m_Section.Insert(index, row);
}
m_PropertyRows[property.guid] = row;
if (create)
{
row.expanded = true;
m_Graph.owner.RegisterCompleteObjectUndo("Create Property");
m_Graph.AddShaderProperty(property);
field.OpenTextEditor();
}
}
public void AddPropertyToBlackboard(ExposedProperty exposedProperty)
{
List <string> existingNamesList = (from p in ExposedProperties select p.PropertyName).ToList();
var localPropertyName = StringUtils.IncrementName(exposedProperty.PropertyName, existingNamesList);
var localPropertyValue = exposedProperty.PropertyValue;
var property = new ExposedProperty
{
PropertyName = localPropertyName,
PropertyValue = localPropertyValue
};
ExposedProperties.Add(property);
var container = new VisualElement();
var blackboardField = new BlackboardField {
text = property.PropertyName, typeText = "string"
};
container.Add(blackboardField);
var propertyValueTextField = new TextField("Value:")
{
value = property.PropertyValue
};
propertyValueTextField.RegisterValueChangedCallback(evt =>
{
var changingPropertyIndex = ExposedProperties.FindIndex(x => x.PropertyName == property.PropertyName);
ExposedProperties[changingPropertyIndex].PropertyValue = evt.newValue;
});
var blackboardValueRow = new BlackboardRow(blackboardField, propertyValueTextField);
container.Add(blackboardValueRow);
Blackboard.Add(container);
}
VisualElement MakeFieldRow(FieldModel fieldModel)
{
var field = new BlackboardField(null, fieldModel.Name, fieldModel.Type?.FriendlyName() ?? "<unknown>");
field.userData = fieldModel;
var propertyView = new VisualElement();
var fieldRow = new BlackboardRow(field, propertyView)
{
userData = fieldModel
};
fieldRow.expanded = m_ExpandedRows.Contains(fieldModel);
field.Add(new Button(() => DeleteField(fieldRow, fieldModel))
{
name = "deleteComponentIcon"
});
var fieldType = new Button()
{
text = fieldModel.Type?.FriendlyName() ?? "<unknown>"
};
fieldType.clickable.clicked += () =>
{
InitializeTypeItemsAndCache(); // delay init as the type cache seems to have a weird timing issue otherwise
SearcherWindow.Show(this, new Searcher.Searcher(new SearcherDatabase(TypeItems), new TypeSearcherAdapter("Pick a type")), item =>
{
PickTypeSearcherItem titem = item as PickTypeSearcherItem;
if (titem == null)
{
return(true);
}
fieldModel.Type = titem.Type;
fieldType.text = titem.Type.FriendlyName();
if (titem.Shared)
{
SetStructType(CurrentStruct, StructType.SharedComponent);
}
SetModelDirty();
return(true);
}, Event.current.mousePosition, null);
};
propertyView.Add(new PropertyRow("Type", fieldType));
var toggle = new Toggle()
{
value = fieldModel.HideInInspector
};
toggle.RegisterValueChangedCallback(e =>
{
fieldModel.HideInInspector = e.newValue;
SetModelDirty();
});
propertyView.Add(new PropertyRow("Hide in inspector", toggle));
// TODO ugly
if (!fieldModel.Type.IsValueType && fieldModel.Type != typeof(GameObject))
{
propertyView.Add(new Label("This is a reference type and requires the component to be a shared component"));
}
return(fieldRow);
}
void Rename(Blackboard _blackboard, VisualElement _field, string _newName)
{
BlackboardField blackboardField = _field as BlackboardField;
GraphView.Model.RenameData_BB(blackboardField.text, _newName);
}
