public override void PreAttachElement()
{
base.PreAttachElement();
rootElement.AddToClassList(BaseTreeView.itemUssClassName);
m_Container?.RegisterCallback(m_PointerUpCallback);
m_Toggle?.RegisterValueChangedCallback(m_ToggleValueChangedCallback);
}
public BooleanSetFlagNode CreateBoolSetFlagNode(bool flagBool, string flagName, Vector2 mousePosition)
{
var setFlagNode = new BooleanSetFlagNode
{
title = "SetFlagNode",
FlagName = flagName,
FlagBool = flagBool,
GUID = Guid.NewGuid().ToString()
};
var inputPort = GeneratePort(setFlagNode, Direction.Input, Port.Capacity.Multi);
inputPort.portName = "Input";
setFlagNode.inputContainer.Add(inputPort);
var generatedPort = GeneratePort(setFlagNode, Direction.Output);
generatedPort.portName = "Next";
generatedPort.name = "Next";
setFlagNode.outputContainer.Add(generatedPort);
setFlagNode.styleSheets.Add(Resources.Load <StyleSheet>("FlagNode"));
var textFieldTarget = new TextField
{
name = "FlagName",
value = flagName,
label = "FlagName\n"
};
textFieldTarget.RegisterValueChangedCallback(evt =>
{
setFlagNode.FlagName = evt.newValue;
});
setFlagNode.mainContainer.Add(textFieldTarget);
var boolFieldTarget = new UnityEngine.UIElements.Toggle
{
name = "FlagSet",
value = flagBool,
label = "FlagSet\n"
};
boolFieldTarget.RegisterValueChangedCallback(evt =>
{
setFlagNode.FlagBool = evt.newValue;
});
setFlagNode.mainContainer.Add(boolFieldTarget);
setFlagNode.RefreshExpandedState();
setFlagNode.RefreshPorts();
setFlagNode.SetPosition(new Rect(mousePosition, defaultNodeSize));
return(setFlagNode);
}
public void OnInjectionFinished()
{
// Select recording device if none.
if (settings.MicProfile.Name.IsNullOrEmpty() ||
!Microphone.devices.Contains(settings.MicProfile.Name))
{
settings.SetMicProfileName(Microphone.devices.FirstOrDefault());
}
settings.ObserveEveryValueChanged(it => it.MicProfile)
.Subscribe(_ => OnMicProfileChanged());
micSampleRecorder.IsRecording.Subscribe(OnRecordingStateChanged);
micSampleRecorder.FinalSampleRate.Subscribe(_ => UpdateRecordingDeviceInfo());
// All controls are hidden until a connection has been established.
onlyVisibleWhenConnected.ForEach(it => it.HideByDisplay());
onlyVisibleWhenNotConnected.ForEach(it => it.ShowByDisplay());
connectionThroubleshootingText.HideByDisplay();
serverErrorResponseText.HideByDisplay();
toggleRecordingButton.RegisterCallbackButtonTriggered(ToggleRecording);
clientNameTextField.value = settings.ClientName;
clientNameTextField.RegisterCallback <NavigationSubmitEvent>(_ => OnClientNameTextFieldSubmit());
clientNameTextField.RegisterCallback <BlurEvent>(_ => OnClientNameTextFieldSubmit());
visualizeAudioToggle.value = settings.ShowAudioWaveForm;
audioWaveForm.SetVisibleByDisplay(settings.ShowAudioWaveForm);
visualizeAudioToggle.RegisterValueChangedCallback(changeEvent =>
{
audioWaveForm.SetVisibleByDisplay(changeEvent.newValue);
settings.ShowAudioWaveForm = changeEvent.newValue;
});
clientSideConnectRequestManager.ConnectEventStream
.Subscribe(UpdateConnectionStatus);
songListRequestor.SongListEventStream.Subscribe(evt => HandleSongListEvent(evt));
UpdateVersionInfoText();
audioWaveForm.RegisterCallbackOneShot <GeometryChangedEvent>(evt =>
{
audioWaveFormVisualization = new AudioWaveFormVisualization(gameObject, audioWaveForm);
});
songSearchTextField.RegisterValueChangedCallback(evt =>
{
songSearchHint.SetVisibleByDisplay(songSearchTextField.value.IsNullOrEmpty());
UpdateSongList();
});
InitTabGroup();
InitMenu();
}
private VisualElement MakeTreeItem()
{
var itemContainer = new VisualElement()
{
name = s_ItemName,
style =
{
flexDirection = FlexDirection.Row
}
};
itemContainer.AddToClassList(s_ItemName);
itemContainer.RegisterCallback <MouseUpEvent>(OnItemMouseUp);
var indents = new VisualElement()
{
name = s_ItemIndentsContainerName,
style =
{
flexDirection = FlexDirection.Row
}
};
indents.AddToClassList(s_ItemIndentsContainerName);
itemContainer.hierarchy.Add(indents);
var toggle = new Toggle()
{
name = s_ItemToggleName
};
toggle.AddToClassList(Foldout.toggleUssClassName);
toggle.RegisterValueChangedCallback(ToggleExpandedState);
itemContainer.hierarchy.Add(toggle);
var userContentContainer = new VisualElement()
{
name = s_ItemContentContainerName,
style =
{
flexGrow = 1
}
};
userContentContainer.AddToClassList(s_ItemContentContainerName);
itemContainer.Add(userContentContainer);
if (m_MakeItem != null)
{
userContentContainer.Add(m_MakeItem());
}
return(itemContainer);
}
private VisualElement MakeTreeItem()
{
VisualElement visualElement = new VisualElement
{
name = TreeView.s_ItemName,
style =
{
flexDirection = FlexDirection.Row
}
};
visualElement.AddToClassList(TreeView.s_ItemName);
visualElement.RegisterCallback <MouseUpEvent>(new EventCallback <MouseUpEvent>(this.OnItemMouseUp), TrickleDown.NoTrickleDown);
VisualElement visualElement2 = new VisualElement
{
name = TreeView.s_ItemIndentsContainerName,
style =
{
flexDirection = FlexDirection.Row
}
};
visualElement2.AddToClassList(TreeView.s_ItemIndentsContainerName);
visualElement.hierarchy.Add(visualElement2);
Toggle toggle = new Toggle
{
name = TreeView.s_ItemToggleName
};
toggle.AddToClassList(Foldout.toggleUssClassName);
toggle.RegisterValueChangedCallback(new EventCallback <ChangeEvent <bool> >(this.ToggleExpandedState));
visualElement.hierarchy.Add(toggle);
VisualElement visualElement3 = new VisualElement
{
name = TreeView.s_ItemContentContainerName,
style =
{
flexGrow = 1f
}
};
visualElement3.AddToClassList(TreeView.s_ItemContentContainerName);
visualElement.Add(visualElement3);
bool flag = this.m_MakeItem != null;
if (flag)
{
visualElement3.Add(this.m_MakeItem());
}
return(visualElement);
}
private void Start()
{
clientSideMicSampleRecorder.DeviceName
.Subscribe(_ => UpdateSelectedRecordingDeviceText());
clientSideMicSampleRecorder.SampleRate
.Subscribe(_ => UpdateSelectedRecordingDeviceText());
clientSideMicSampleRecorder.IsRecording
.Subscribe(OnRecordingStateChanged);
// All controls are hidden until a connection has been established.
uiDoc.rootVisualElement.Query(null, "onlyVisibleWhenConnected").ForEach(it => it.Hide());
connectionThroubleshootingText.Hide();
serverErrorResponseText.Hide();
toggleRecordingButton.RegisterCallbackButtonTriggered(ToggleRecording);
clientNameTextField.value = settings.ClientName;
clientNameTextField.RegisterCallback <NavigationSubmitEvent>(_ => OnClientNameTextFieldSubmit());
clientNameTextField.RegisterCallback <BlurEvent>(_ => OnClientNameTextFieldSubmit());
visualizeAudioToggle.value = settings.ShowAudioWaveForm;
audioWaveForm.SetVisible(settings.ShowAudioWaveForm);
visualizeAudioToggle.RegisterValueChangedCallback(changeEvent =>
{
audioWaveForm.SetVisible(changeEvent.newValue);
settings.ShowAudioWaveForm = changeEvent.newValue;
});
clientSideConnectRequestManager.ConnectEventStream
.Subscribe(UpdateConnectionStatus);
songListRequestor.SongListEventStream.Subscribe(evt => HandleSongListEvent(evt));
showSongListButton.RegisterCallbackButtonTriggered(() => ShowSongList());
closeSongListButton.RegisterCallbackButtonTriggered(() => songListContainer.Hide());
UpdateVersionInfoText();
}
public MoveToPosNode CreateMoveToPosNode(string targetObject, string referenceObject, Vector3 posOffset, bool wait, Vector2 mousePosition)
{
var moveToPosNode = new MoveToPosNode
{
title = "MoveToPosNode",
TargetObject = targetObject,
ReferenceObject = referenceObject,
PosOffset = posOffset,
Wait = wait,
GUID = Guid.NewGuid().ToString()
};
var inputPort = GeneratePort(moveToPosNode, Direction.Input, Port.Capacity.Multi);
inputPort.portName = "Input";
moveToPosNode.inputContainer.Add(inputPort);
var generatedPort = GeneratePort(moveToPosNode, Direction.Output);
generatedPort.portName = "Next";
generatedPort.name = "Next";
moveToPosNode.outputContainer.Add(generatedPort);
moveToPosNode.styleSheets.Add(Resources.Load <StyleSheet>("FlagNode"));
var textFieldTarget = new TextField
{
name = "TargetObject",
value = targetObject,
label = "TargetObject\n"
};
textFieldTarget.RegisterValueChangedCallback(evt =>
{
moveToPosNode.TargetObject = evt.newValue;
});
moveToPosNode.mainContainer.Add(textFieldTarget);
textFieldTarget = new TextField
{
name = "ReferenceObject",
value = referenceObject,
label = "ReferenceObject\n"
};
textFieldTarget.RegisterValueChangedCallback(evt =>
{
moveToPosNode.ReferenceObject = evt.newValue;
});
moveToPosNode.mainContainer.Add(textFieldTarget);
var vector3FieldTarget = new Vector3Field
{
name = "PositionOffset",
value = posOffset,
label = "PositionOffset\n"
};
vector3FieldTarget.RegisterValueChangedCallback(evt =>
{
moveToPosNode.PosOffset = evt.newValue;
});
moveToPosNode.mainContainer.Add(vector3FieldTarget);
var boolFieldTarget = new UnityEngine.UIElements.Toggle
{
name = "Wait",
value = wait,
label = "Wait\n"
};
boolFieldTarget.RegisterValueChangedCallback(evt =>
{
moveToPosNode.Wait = evt.newValue;
});
moveToPosNode.mainContainer.Add(boolFieldTarget);
moveToPosNode.RefreshExpandedState();
moveToPosNode.RefreshPorts();
moveToPosNode.SetPosition(new Rect(mousePosition, defaultNodeSize));
return(moveToPosNode);
}
public SpeakEasyNode InitializeNode(SpeakEasyNode node, Vector2 position, NodeType nodeTypeChoice)
{
//Actual logic for the creation of the node
//This is the UI layout
//Set the color of the node so it's not super transparent.
node.mainContainer.style.backgroundColor = new Color(0.25f, 0.25f, 0.25f, 0.75f);
//Initialize the Label of the Node, determining if it's a SPEECH or RESPONSE node
Label nodeTypeLabel = new Label();
nodeTypeLabel.style.fontSize = 15;
nodeTypeLabel.style.alignSelf = Align.Center;
if (node.nodeType == NodeType.speech)
{
nodeTypeLabel.text = "SPEECH";
node.titleContainer.style.backgroundColor = speechColor;
}
else
{
nodeTypeLabel.text = "RESPONSE";
node.titleContainer.style.backgroundColor = responseColor;
}
node.titleContainer.Add(nodeTypeLabel);
//The integer field, this field references the index in the Localization file. It's a read only field.
IntegerField stringIndexField = new IntegerField("String Index:");
stringIndexField.SetEnabled(false); //We shouldn't be able to directly edit this value.
node.mainContainer.Add(stringIndexField);
//This is the "text preview" which we morphed into a auto-localization file. The editor on save stores this data back into the specified XML file.
TextField textPreviewField = new TextField();
textPreviewField.multiline = true;
textPreviewField.style.maxWidth = 350;
textPreviewField.style.whiteSpace = WhiteSpace.Normal;
textPreviewField.SetEnabled(false);
textPreviewField.isDelayed = true;
node.mainContainer.Add(textPreviewField);
//adds an ID reference so we can see the GUID
Label idReference = new Label(node.nodeID);
node.mainContainer.Add(idReference);
idReference.style.color = new Color(0.75f, 0.75f, 0.75f);
//This is the stringRefField, aka the identifier for our string. This is what we store in our file data.
TextField stringRefField = new TextField("String Reference:");
stringRefField.isDelayed = true;
stringRefField.RegisterValueChangedCallback(evt =>
{
node.stringReference = evt.newValue; //set the node's string reference to the new Value
Debug.Log("Saving localization data");
SetLocalizationIdentifier(node.stringIndex, evt.newValue); //Sets the localization identifier for the index if one is specified.
});
node.mainContainer.Add(stringRefField);
stringRefField.SetValueWithoutNotify(node.stringReference);
stringIndexField.SetValueWithoutNotify(FindStringIndex(node.stringReference)); //Look up our string reference identifier and return the index if one exists.
//We need to set the stringIndex of the node too.
node.stringIndex = stringIndexField.value; // set the node's internal value to the stringIndexField value.
textPreviewField.SetValueWithoutNotify(GetStringIndex(node.stringIndex)); //Update the localized box auto match the .. you know what this does.
textPreviewField.RegisterValueChangedCallback(evt =>
{
Debug.Log("Saving localization data");
SetLocalizationText(node.stringIndex, evt.newValue); //If we change the text in this field, update the localization table to match our new entry.
});
//This button will give us a brand new spanking place in the localization file hashtag smiley face
Button addNewTableEntryButton = null; //I do not understand this logic...
addNewTableEntryButton = new Button(() => AddNewTableEntry(addNewTableEntryButton, node, stringIndexField, textPreviewField))
{
text = "Add Table Entry"
};
if (localText == null)
{
addNewTableEntryButton.SetEnabled(false);
}
node.mainContainer.Add(addNewTableEntryButton);
//Check if we already have this data
if (CheckIfStringReferenceExists(node.stringReference))
{
//We already have our connection
addNewTableEntryButton.SetEnabled(false);
textPreviewField.SetEnabled(true);
}
//Serialize Save/Load for Audio Clips and Animation Trigger
ObjectField audioField = new ObjectField("Audio Field");
audioField.objectType = typeof(AudioClip);
audioField.allowSceneObjects = false;
audioField.SetEnabled(false);
node.mainContainer.Add(audioField);
TextField animationTriggerField = new TextField("Animation Trigger");
animationTriggerField.SetEnabled(false);
node.mainContainer.Add(animationTriggerField);
UnityEngine.UIElements.Toggle entryPointToggle = new UnityEngine.UIElements.Toggle("Entry Point");
entryPointToggle.RegisterValueChangedCallback(evt =>
{
node.isEntryPoint = evt.newValue;
});
node.mainContainer.Add(entryPointToggle);
entryPointToggle.SetValueWithoutNotify(node.isEntryPoint);
IntegerField priorityField = new IntegerField("Priority:");
priorityField.RegisterValueChangedCallback(evt =>
{
node.priority = evt.newValue;
});
priorityField.SetValueWithoutNotify(node.priority);
node.mainContainer.Add(priorityField);
/*
* ObjectField testRef = new ObjectField("OnConditional");
* testRef.objectType = typeof(SpeakEasyLogics_Test);
* testRef.allowSceneObjects = false;
* node.mainContainer.Add(testRef);
*
* ObjectField eventRef = new ObjectField("OnFire");
* eventRef.objectType = typeof(SpeakEasyLogics_Event);
* eventRef.allowSceneObjects = false;
* node.mainContainer.Add(eventRef);
*/
//adds a OnConditional reference
ObjectField testRefField = new ObjectField("Test Script Ref:");
testRefField.objectType = typeof(SpeakEasyLogics_Test);
testRefField.allowSceneObjects = false;
testRefField.RegisterValueChangedCallback(evt =>
{
node.scriptTest = (evt.newValue as SpeakEasyLogics_Test);
//SpeakEasyNode startNode = (startPort.node as SpeakEasyNode);
});
node.mainContainer.Add(testRefField);
testRefField.SetValueWithoutNotify(node.scriptTest);
//adds a OnFire reference
ObjectField eventRefField = new ObjectField("Event Script Ref:");
eventRefField.objectType = typeof(SpeakEasyLogics_Event);
eventRefField.allowSceneObjects = false;
eventRefField.RegisterValueChangedCallback(evt =>
{
node.scriptEvent = (evt.newValue as SpeakEasyLogics_Event);
});
node.mainContainer.Add(eventRefField);
eventRefField.SetValueWithoutNotify(node.scriptEvent);
//This port is the IN connection, this is where we will lead the conversation TO. The Input can recieve a number of connections from conversation choices
Port inputPort = GetPortInstance(node, Direction.Input, Port.Capacity.Multi);
node.inputConnection = inputPort;
inputPort.portName = "Connections";
node.inputContainer.Add(inputPort);
Port outputPort = GetPortInstance(node, Direction.Output, Port.Capacity.Multi);
node.outputConnection = outputPort;
outputPort.portName = "Responses";
node.outputContainer.Add(outputPort);
//
//node.outputContainer.style.flexDirection <-- this is what I was looking for last night! controls the direction of the container?
node.RefreshExpandedState();
node.RefreshPorts();
node.SetPosition(new Rect(position, defaultNodeSize));
Button debugTestValues = new Button(() => PrintValues(node, inputPort, outputPort))
{
text = "Print Values"
};
node.mainContainer.Add(debugTestValues);
return(node);
}
public BlackboardFieldPropertyView(AbstractNodeGraph graph, INodeProperty property)
{
styleSheets.Add(Resources.Load <StyleSheet>("Styles/NodeGraphBlackboard"));
m_Graph = graph;
m_Reference = new TextField();
m_Reference.RegisterValueChangedCallback(evt =>
{
property.reference = evt.newValue;
DirtyNodes(ModificationScope.Graph);
});
m_Reference.value = property.reference;
AddRow("Reference", m_Reference);
if (property is ValueProperty <float> )
{
var floatProperty = (ValueProperty <float>)property;
FloatField floatField = new FloatField {
value = floatProperty.value
};
floatField.RegisterValueChangedCallback(evt =>
{
floatProperty.value = (float)evt.newValue;
DirtyNodes();
});
AddRow("Default", floatField);
/*if (floatProperty.floatType == FloatType.Slider)
* {
* var minField = new FloatField { value = floatProperty.rangeValues.x };
* minField.OnValueChanged(minEvt =>
* {
* floatProperty.rangeValues = new Vector2((float)minEvt.newValue, floatProperty.rangeValues.y);
* floatProperty.value = Mathf.Max(Mathf.Min(floatProperty.value, floatProperty.rangeValues.y), floatProperty.rangeValues.x);
* floatField.value = floatProperty.value;
* DirtyNodes();
* });
* minRow = AddRow("Min", minField);
* var maxField = new FloatField { value = floatProperty.rangeValues.y };
* maxField.OnValueChanged(maxEvt =>
* {
* floatProperty.rangeValues = new Vector2(floatProperty.rangeValues.x, (float)maxEvt.newValue);
* floatProperty.value = Mathf.Max(Mathf.Min(floatProperty.value, floatProperty.rangeValues.y), floatProperty.rangeValues.x);
* floatField.value = floatProperty.value;
* DirtyNodes();
* });
* maxRow = AddRow("Max", maxField);
* }*/
}
else if (property is ValueProperty <int> )
{
var intProperty = (ValueProperty <int>)property;
var field = new IntegerField {
value = intProperty.value
};
field.RegisterValueChangedCallback(intEvt =>
{
intProperty.value = intEvt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is ValueProperty <Vector2> )
{
var vectorProperty = (ValueProperty <Vector2>)property;
var field = new Vector2Field {
value = vectorProperty.value
};
field.RegisterValueChangedCallback(evt =>
{
vectorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is ValueProperty <Vector3> )
{
var vectorProperty = (ValueProperty <Vector3>)property;
var field = new Vector3Field {
value = vectorProperty.value
};
field.RegisterValueChangedCallback(evt =>
{
vectorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is ValueProperty <Vector4> )
{
var vectorProperty = (ValueProperty <Vector4>)property;
var field = new Vector4Field {
value = vectorProperty.value
};
field.RegisterValueChangedCallback(evt =>
{
vectorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is ValueProperty <Color> )
{
var colorProperty = (ValueProperty <Color>)property;
//todo add HDR
var colorField = new ColorField {
value = (Color)property.defaultValue, showEyeDropper = false
};
colorField.RegisterValueChangedCallback(evt =>
{
colorProperty.value = evt.newValue;
DirtyNodes();
});
AddRow("Default", colorField);
}
else if (property is ValueProperty <Texture2D> )
{
var textureProperty = (ValueProperty <Texture2D>)property;
var field = new ObjectField {
value = textureProperty.value, objectType = typeof(Texture2D)
};
field.RegisterValueChangedCallback(evt =>
{
textureProperty.value = (Texture2D)evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is ValueProperty <Cubemap> )
{
var cubemapProperty = (ValueProperty <Cubemap>)property;
var field = new ObjectField {
value = cubemapProperty.value, objectType = typeof(Cubemap)
};
field.RegisterValueChangedCallback(evt =>
{
cubemapProperty.value = (Cubemap)evt.newValue;
DirtyNodes();
});
AddRow("Default", field);
}
else if (property is ValueProperty <bool> )
{
var booleanProperty = (ValueProperty <bool>)property;
EventCallback <ChangeEvent <bool> > onBooleanChanged = evt =>
{
booleanProperty.value = evt.newValue;
DirtyNodes();
};
var field = new Toggle();
field.RegisterValueChangedCallback(onBooleanChanged);
field.value = booleanProperty.value;
AddRow("Default", field);
}
// AddRow("Type", new TextField());
// AddRow("Exposed", new Toggle(null));
// AddRow("Range", new Toggle(null));
// AddRow("Default", new TextField());
// AddRow("Tooltip", new TextField());
AddToClassList("sgblackboardFieldPropertyView");
}
void OnEnable()
{
m_LabelConfigTypes = AddToConfigWindow.FindAllSubTypes(typeof(LabelConfig <>));
var mySerializedObject = new SerializedObject(serializedObject.targetObjects[0]);
m_Labeling = mySerializedObject.targetObject as Labeling;
m_UxmlPath = m_UxmlDir + "Labeling_Main.uxml";
m_Root = AssetDatabase.LoadAssetAtPath <VisualTreeAsset>(m_UxmlPath).CloneTree();
m_CurrentLabelsListView = m_Root.Q <ListView>("current-labels-listview");
m_SuggestedLabelsListViewFromName = m_Root.Q <ListView>("suggested-labels-name-listview");
m_SuggestedLabelsListViewFromPath = m_Root.Q <ListView>("suggested-labels-path-listview");
m_LabelConfigsScrollView = m_Root.Q <ScrollView>("label-configs-scrollview");
m_SuggestedOnNamePanel = m_Root.Q <VisualElement>("suggested-labels-from-name");
m_SuggestedOnPathPanel = m_Root.Q <VisualElement>("suggested-labels-from-path");
m_AddButton = m_Root.Q <Button>("add-label");
m_CurrentAutoLabel = m_Root.Q <Label>("current-auto-label");
m_CurrentAutoLabelTitle = m_Root.Q <Label>("current-auto-label-title");
m_AutoLabelingToggle = m_Root.Q <Toggle>("auto-or-manual-toggle");
m_ManualLabelingContainer = m_Root.Q <VisualElement>("manual-labeling");
m_AutoLabelingContainer = m_Root.Q <VisualElement>("automatic-labeling");
m_FromLabelConfigsContainer = m_Root.Q <VisualElement>("from-label-configs");
m_SuggestedLabelsContainer = m_Root.Q <VisualElement>("suggested-labels");
m_AddAutoLabelToConfButton = m_Root.Q <Button>("add-auto-label-to-config");
m_AddManualLabelsTitle = m_Root.Q <Label>("add-manual-labels-title");
var dropdownParent = m_Root.Q <VisualElement>("drop-down-parent");
m_ItIsPossibleToAddMultipleAutoLabelsToConfig = false;
InitializeLabelingSchemes(dropdownParent);
AssesAutoLabelingStatus();
m_FirstItemLabelsArray = serializedObject.FindProperty(nameof(Labeling.labels));
if (serializedObject.targetObjects.Length > 1)
{
var addedTitle = m_Root.Q <Label>("added-labels-title");
addedTitle.text = "Common Labels of Selected Items";
m_SuggestedOnNamePanel.style.display = DisplayStyle.None;
m_AddAutoLabelToConfButton.text = "Add Automatic Labels of All Selected Assets to Config...";
}
else
{
m_AddAutoLabelToConfButton.text = "Add to Label Config...";
}
m_AddAutoLabelToConfButton.clicked += () =>
{
AddToConfigWindow.ShowWindow(CreateUnionOfAllLabels().ToList());
};
m_AddButton.clicked += () =>
{
var labelsUnion = CreateUnionOfAllLabels();
var newLabel = FindNewLabelValue(labelsUnion);
foreach (var targetObject in targets)
{
if (targetObject is Labeling labeling)
{
var serializedLabelingObject2 = new SerializedObject(labeling);
var serializedLabelArray2 = serializedLabelingObject2.FindProperty(nameof(Labeling.labels));
serializedLabelArray2.InsertArrayElementAtIndex(serializedLabelArray2.arraySize);
serializedLabelArray2.GetArrayElementAtIndex(serializedLabelArray2.arraySize - 1).stringValue = newLabel;
serializedLabelingObject2.ApplyModifiedProperties();
serializedLabelingObject2.SetIsDifferentCacheDirty();
serializedObject.SetIsDifferentCacheDirty();
}
}
ChangesHappeningInForeground = true;
RefreshManualLabelingData();
};
m_AutoLabelingToggle.RegisterValueChangedCallback(evt =>
{
AutoLabelToggleChanged();
});
ChangesHappeningInForeground = true;
m_Root.schedule.Execute(CheckForModelChanges).Every(30);
}
