void FillView(IEnumerable <ITreeViewItem> items, VisualElement itemsParent = null) { foreach (var item in items) { if (item is BuilderLibraryTreeItem libraryTreeItem) { if (libraryTreeItem.isHeader) { var categoryFoldout = new LibraryFoldout { text = libraryTreeItem.data }; if (libraryTreeItem.isEditorOnly) { categoryFoldout.tag = BuilderConstants.EditorOnlyTag; categoryFoldout.Q(LibraryFoldout.TagLabelName).AddToClassList(BuilderConstants.TagPillClassName); } categoryFoldout.contentContainer.RegisterCallback <GeometryChangedEvent>(e => AdjustSpace(categoryFoldout)); categoryFoldout.AddToClassList(k_PlainViewFoldoutStyle); Add(categoryFoldout); FillView(libraryTreeItem.children, categoryFoldout); continue; } var plainViewItem = new LibraryPlainViewItem(libraryTreeItem); plainViewItem.AddManipulator(new ContextualMenuManipulator(OnContextualMenuPopulateEvent)); plainViewItem.RegisterCallback <MouseDownEvent, LibraryPlainViewItem>(OnPlainViewItemMouseDown, plainViewItem); LinkToTreeViewItem(plainViewItem, libraryTreeItem); // The element set up is not yet completed at this point. // SetupView has to be called as well. plainViewItem.RegisterCallback <AttachToPanelEvent>(e => { RegisterControlContainer(plainViewItem); }); plainViewItem.RegisterCallback <MouseDownEvent>(e => { if (e.clickCount == 2) { AddItemToTheDocument(libraryTreeItem); } }); itemsParent?.Add(plainViewItem); m_PlainViewItems.Add(plainViewItem); } } }
void Start() { var uiRoot = m_UiRoot.rootVisualElement; // CONTAINER m_Container = new VisualElement(); m_Container.name = "build-menu-container"; m_Container.style.display = DisplayStyle.None; m_Container.style.position = Position.Absolute; m_Container.style.width = 398; m_Container.style.height = 398; // BACKGROUND var backgroundLarge = new VisualElement(); backgroundLarge.style.visibility = Visibility.Visible; backgroundLarge.style.position = Position.Absolute; backgroundLarge.style.backgroundImage = new StyleBackground(spriteBackgroundLarge); backgroundLarge.style.width = Length.Percent(100); backgroundLarge.style.height = Length.Percent(100); backgroundLarge.style.left = Length.Percent(-50); backgroundLarge.style.top = Length.Percent(-50); m_Container.Add(backgroundLarge); // ICON { m_IconWrapper = new VisualElement(); // CALLBACK HANDLERS m_IconWrapper.RegisterCallback <PointerEnterEvent>(e => { m_Logger.Log($"PointerEnterEvent ({e.localPosition})"); SetIconState(IconState.Selected); }); m_IconWrapper.RegisterCallback <PointerMoveEvent>(e => { m_Logger.Log($"PointerMoveEvent ({e.localPosition})"); }); m_IconWrapper.RegisterCallback <PointerLeaveEvent>(e => { m_Logger.Log($"PointerLeaveEvent ({e.localPosition})"); SetIconState(IconState.Active); }); // Set icon position var centerX = 100; var centerY = 0; m_IconWrapper.style.left = (-65 / 2) + centerX; m_IconWrapper.style.top = (-77 / 2) + centerY; m_IconSelected = new VisualElement(); m_IconSelected.style.visibility = Visibility.Hidden; m_IconSelected.style.position = Position.Absolute; m_IconSelected.style.backgroundImage = new StyleBackground(spriteIcon2); m_IconSelected.style.width = 65; m_IconSelected.style.height = 77; m_IconWrapper.Add(m_IconSelected); m_IconActive = new VisualElement(); m_IconActive.style.visibility = Visibility.Hidden; m_IconActive.style.position = Position.Absolute; m_IconActive.style.backgroundImage = new StyleBackground(spriteIcon1); m_IconActive.style.width = 65; m_IconActive.style.height = 77; m_IconWrapper.Add(m_IconActive); m_IconDisabled = new VisualElement(); m_IconDisabled.style.visibility = Visibility.Hidden; m_IconDisabled.style.position = Position.Absolute; m_IconDisabled.style.backgroundImage = new StyleBackground(spriteIcon0); m_IconDisabled.style.width = 65; m_IconDisabled.style.height = 77; m_IconWrapper.Add(m_IconDisabled); m_Container.Add(m_IconWrapper); } // Add container to root uiRoot.Add(m_Container); SetIconState(IconState.Active); }
public VisualElement Create() { var root = new ScrollView(); m_parent.OnStats += (peer, report) => { if (peer != m_peerConnection || report.Stats.Keys.Count == m_lastUpdateKeys?.Count) { return; } m_lastUpdateKeys = report.Stats.Keys; root.Clear(); var container = new VisualElement(); var popup = new PopupField <string>(m_lastUpdateKeys.ToList(), 0, id => $"{id}", id => $"{id}"); root.Add(popup); root.Add(container); popup.RegisterValueChangedCallback(e => { container.Clear(); var id = e.newValue; var type = report.Get(id).Type; switch (type) { case RTCStatsType.Codec: container.Add(CreateCodecView(id)); break; case RTCStatsType.InboundRtp: container.Add(CreateInboundRtpView(id)); break; case RTCStatsType.OutboundRtp: container.Add(CreateOutboundRtpView(id)); break; case RTCStatsType.RemoteInboundRtp: container.Add(CreateRemoteInboundRtpView(id)); break; case RTCStatsType.RemoteOutboundRtp: container.Add(CreateRemoteOutboundRtpView(id)); break; case RTCStatsType.MediaSource: container.Add(CreateMediaSourceView(id)); break; case RTCStatsType.Csrc: container.Add(CreateCsrcView(id)); break; case RTCStatsType.PeerConnection: container.Add(CreatePeerConnectionView(id)); break; case RTCStatsType.DataChannel: container.Add(CreateDataChannelView(id)); break; case RTCStatsType.Stream: container.Add(CreateStreamView(id)); break; case RTCStatsType.Track: container.Add(CreateTrackView(id)); break; case RTCStatsType.Transceiver: container.Add(CreateTransceiverView(id)); break; case RTCStatsType.Sender: container.Add(CreateSenderView(id)); break; case RTCStatsType.Receiver: container.Add(CreateReceiverView(id)); break; case RTCStatsType.Transport: container.Add(CreateTransportView(id)); break; case RTCStatsType.SctpTransport: container.Add(CreateSctpTransportView(id)); break; case RTCStatsType.CandidatePair: container.Add(CreateCandidatePairView(id)); break; case RTCStatsType.LocalCandidate: container.Add(CreateLocalCandidateView(id)); break; case RTCStatsType.RemoteCandidate: container.Add(CreateRemoteCandidateView(id)); break; case RTCStatsType.Certificate: container.Add(CreateCertificateView(id)); break; case RTCStatsType.IceServer: container.Add(CreateIceServerView(id)); break; default: throw new ArgumentOutOfRangeException($"this type is not supported : {type}"); } }); }; return(root); }
public void Initialize(AbstractMaterialNode inNode, PreviewManager previewManager, IEdgeConnectorListener connectorListener, GraphView graphView) { styleSheets.Add(Resources.Load <StyleSheet>("Styles/MaterialNodeView")); styleSheets.Add(Resources.Load <StyleSheet>($"Styles/ColorMode")); AddToClassList("MaterialNode"); if (inNode == null) { return; } var contents = this.Q("contents"); m_GraphView = graphView; m_ConnectorListener = connectorListener; node = inNode; viewDataKey = node.guid.ToString(); UpdateTitle(); // Add controls container var controlsContainer = new VisualElement { name = "controls" }; { m_ControlsDivider = new VisualElement { name = "divider" }; m_ControlsDivider.AddToClassList("horizontal"); controlsContainer.Add(m_ControlsDivider); m_ControlItems = new VisualElement { name = "items" }; controlsContainer.Add(m_ControlItems); // Instantiate control views from node foreach (var propertyInfo in node.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)) { foreach (IControlAttribute attribute in propertyInfo.GetCustomAttributes(typeof(IControlAttribute), false)) { m_ControlItems.Add(attribute.InstantiateControl(node, propertyInfo)); } } } if (m_ControlItems.childCount > 0) { contents.Add(controlsContainer); } if (node.hasPreview) { // Add actual preview which floats on top of the node m_PreviewContainer = new VisualElement { name = "previewContainer", cacheAsBitmap = true, style = { overflow = Overflow.Hidden }, pickingMode = PickingMode.Ignore }; m_PreviewImage = new Image { name = "preview", pickingMode = PickingMode.Ignore, image = Texture2D.whiteTexture, }; { // Add preview collapse button on top of preview var collapsePreviewButton = new VisualElement { name = "collapse" }; collapsePreviewButton.Add(new VisualElement { name = "icon" }); collapsePreviewButton.AddManipulator(new Clickable(() => { node.owner.owner.RegisterCompleteObjectUndo("Collapse Preview"); UpdatePreviewExpandedState(false); })); m_PreviewImage.Add(collapsePreviewButton); } m_PreviewContainer.Add(m_PreviewImage); // Hook up preview image to preview manager m_PreviewRenderData = previewManager.GetPreview(inNode); m_PreviewRenderData.onPreviewChanged += UpdatePreviewTexture; UpdatePreviewTexture(); // Add fake preview which pads out the node to provide space for the floating preview m_PreviewFiller = new VisualElement { name = "previewFiller" }; m_PreviewFiller.AddToClassList("expanded"); { var previewDivider = new VisualElement { name = "divider" }; previewDivider.AddToClassList("horizontal"); m_PreviewFiller.Add(previewDivider); var expandPreviewButton = new VisualElement { name = "expand" }; expandPreviewButton.Add(new VisualElement { name = "icon" }); expandPreviewButton.AddManipulator(new Clickable(() => { node.owner.owner.RegisterCompleteObjectUndo("Expand Preview"); UpdatePreviewExpandedState(true); })); m_PreviewFiller.Add(expandPreviewButton); } contents.Add(m_PreviewFiller); UpdatePreviewExpandedState(node.previewExpanded); } // Add port input container, which acts as a pixel cache for all port inputs m_PortInputContainer = new VisualElement { name = "portInputContainer", cacheAsBitmap = true, style = { overflow = Overflow.Hidden }, pickingMode = PickingMode.Ignore }; Add(m_PortInputContainer); AddSlots(node.GetSlots <MaterialSlot>()); UpdatePortInputs(); base.expanded = node.drawState.expanded; RefreshExpandedState(); //This should not be needed. GraphView needs to improve the extension api here UpdatePortInputVisibilities(); SetPosition(new Rect(node.drawState.position.x, node.drawState.position.y, 0, 0)); if (node is SubGraphNode) { RegisterCallback <MouseDownEvent>(OnSubGraphDoubleClick); } m_PortInputContainer.SendToBack(); m_TitleContainer = this.Q("title"); var masterNode = node as IMasterNode; if (masterNode != null) { AddToClassList("master"); if (!masterNode.IsPipelineCompatible(GraphicsSettings.renderPipelineAsset)) { AttachMessage("The current render pipeline is not compatible with this master node.", ShaderCompilerMessageSeverity.Error); } } m_NodeSettingsView = new NodeSettingsView(); m_NodeSettingsView.visible = false; Add(m_NodeSettingsView); m_SettingsButton = new VisualElement { name = "settings-button" }; m_SettingsButton.Add(new VisualElement { name = "icon" }); m_Settings = new VisualElement(); AddDefaultSettings(); // Add Node type specific settings var nodeTypeSettings = node as IHasSettings; if (nodeTypeSettings != null) { m_Settings.Add(nodeTypeSettings.CreateSettingsElement()); } // Add manipulators m_SettingsButton.AddManipulator(new Clickable(() => { UpdateSettingsExpandedState(); })); if (m_Settings.childCount > 0) { m_ButtonContainer = new VisualElement { name = "button-container" }; m_ButtonContainer.style.flexDirection = FlexDirection.Row; m_ButtonContainer.Add(m_SettingsButton); m_ButtonContainer.Add(m_CollapseButton); m_TitleContainer.Add(m_ButtonContainer); } }
void InitializeDebug() { ComputeOrderUpdatedCallback(); debugContainer.Add(computeOrderLabel); }
void OnEnable() { minSize = new Vector2(560.0f, 200.0f); #if UNITY_2019_1_OR_NEWER var root = rootVisualElement; root.styleSheets.Add(Resources.Load <StyleSheet>(s_StylesFolder + "recorder")); root.styleSheets.Add(Resources.Load <StyleSheet>(s_StylesFolder + (EditorGUIUtility.isProSkin ? "recorder_darkSkin" : "recorder_lightSkin"))); #else var root = this.GetRootVisualContainer(); root.AddStyleSheetPath(s_StylesFolder + "recorder"); root.AddStyleSheetPath(s_StylesFolder + (EditorGUIUtility.isProSkin ? "recorder_darkSkin" : "recorder_lightSkin")); #endif root.style.flexDirection = FlexDirection.Column; UIElementHelper.SetFocusable(root); var mainControls = new VisualElement { style = { flexDirection = FlexDirection.Row, minHeight = 110.0f } }; root.Add(mainControls); var controlLeftPane = new VisualElement { style = { #if UNITY_2018_1 minWidth = 350.0f, #else minWidth = 180.0f, #endif maxWidth = 450.0f, flexDirection = FlexDirection.Row, } }; UIElementHelper.SetFlex(controlLeftPane, 0.5f); var controlRightPane = new VisualElement { style = { flexDirection = FlexDirection.Column, } }; UIElementHelper.SetFlex(controlRightPane, 0.5f); mainControls.Add(controlLeftPane); mainControls.Add(controlRightPane); controlLeftPane.AddToClassList("StandardPanel"); controlRightPane.AddToClassList("StandardPanel"); m_RecordButtonIcon = new Button(OnRecordButtonClick) { name = "recorderIcon", style = { backgroundImage = Resources.Load <Texture2D>("recorder_icon"), } }; controlLeftPane.Add(m_RecordButtonIcon); var leftButtonsStack = new VisualElement { style = { flexDirection = FlexDirection.Column, } }; UIElementHelper.SetFlex(leftButtonsStack, 1.0f); m_RecordButton = new Button(OnRecordButtonClick) { name = "recordButton" }; UpdateRecordButtonText(); leftButtonsStack.Add(m_RecordButton); m_RecordOptionsPanel = new IMGUIContainer(() => { PrepareGUIState(m_RecordOptionsPanel.layout.width); Options.exitPlayMode = EditorGUILayout.Toggle(Styles.ExitPlayModeLabel, Options.exitPlayMode); }) { name = "recordOptions" }; UIElementHelper.SetFlex(m_RecordOptionsPanel, 1.0f); leftButtonsStack.Add(m_RecordOptionsPanel); m_RecordModeOptionsPanel = new IMGUIContainer(() => { PrepareGUIState(m_RecordModeOptionsPanel.layout.width); if (m_RecorderSettingsPrefsEditor.RecordModeGUI()) { OnGlobalSettingsChanged(); } }); UIElementHelper.SetFlex(m_RecordModeOptionsPanel, 1.0f); leftButtonsStack.Add(m_RecordModeOptionsPanel); controlLeftPane.Add(leftButtonsStack); m_FrameRateOptionsPanel = new IMGUIContainer(() => { PrepareGUIState(m_FrameRateOptionsPanel.layout.width); if (m_RecorderSettingsPrefsEditor.FrameRateGUI()) { OnGlobalSettingsChanged(); } }); UIElementHelper.SetFlex(m_FrameRateOptionsPanel, 1.0f); controlRightPane.Add(m_FrameRateOptionsPanel); m_SettingsPanel = new ScrollView(); UIElementHelper.SetFlex(m_SettingsPanel, 1.0f); UIElementHelper.ResetStylePosition(m_SettingsPanel.contentContainer.style); var recordersAndParameters = new VisualElement { style = { alignSelf = Align.Stretch, flexDirection = FlexDirection.Row, } }; UIElementHelper.SetFlex(recordersAndParameters, 1.0f); m_RecordersPanel = new VisualElement { name = "recordersPanel", style = { width = 200.0f, minWidth = 150.0f, maxWidth = 500.0f } }; m_RecordersPanel.AddToClassList("StandardPanel"); m_PanelSplitter = new PanelSplitter(m_RecordersPanel); recordersAndParameters.Add(m_RecordersPanel); recordersAndParameters.Add(m_PanelSplitter); recordersAndParameters.Add(m_SettingsPanel); m_SettingsPanel.AddToClassList("StandardPanel"); root.Add(recordersAndParameters); var addRecordButton = new Label("+ Add New Recorders"); UIElementHelper.SetFlex(addRecordButton, 1.0f); var recorderListPresetButton = new VisualElement { name = "recorderListPreset" }; recorderListPresetButton.RegisterCallback <MouseUpEvent>(evt => ShowRecorderListMenu()); recorderListPresetButton.Add(new Image { image = (Texture2D)EditorGUIUtility.Load("Builtin Skins/" + (EditorGUIUtility.isProSkin ? "DarkSkin" : "LightSkin") + "/Images/pane options.png"), style = { width = 16.0f, height = 11.0f } }); addRecordButton.AddToClassList("RecorderListHeader"); recorderListPresetButton.AddToClassList("RecorderListHeader"); addRecordButton.RegisterCallback <MouseUpEvent>(evt => ShowNewRecorderMenu()); m_AddNewRecordPanel = new VisualElement { name = "addRecordersButton", style = { flexDirection = FlexDirection.Row } }; m_AddNewRecordPanel.Add(addRecordButton); m_AddNewRecordPanel.Add(recorderListPresetButton); m_RecordingListItem = new RecorderItemList { name = "recorderList" }; UIElementHelper.SetFlex(m_RecordingListItem, 1.0f); UIElementHelper.SetFocusable(m_RecordingListItem); m_RecordingListItem.OnItemContextMenu += OnRecordContextMenu; m_RecordingListItem.OnSelectionChanged += OnRecordSelectionChanged; m_RecordingListItem.OnItemRename += item => item.StartRenaming(); m_RecordingListItem.OnContextMenu += ShowNewRecorderMenu; m_RecordersPanel.Add(m_AddNewRecordPanel); m_RecordersPanel.Add(m_RecordingListItem); m_ParametersControl = new VisualElement { style = { minWidth = 300.0f, } }; UIElementHelper.SetFlex(m_ParametersControl, 1.0f); m_ParametersControl.Add(new Button(OnRecorderSettingPresetClicked) { name = "presetButton", style = { alignSelf = Align.FlexEnd, backgroundImage = PresetHelper.presetIcon, paddingTop = 0.0f, paddingLeft = 0.0f, paddingBottom = 0.0f, paddingRight = 0.0f, #if UNITY_2019_1_OR_NEWER unityBackgroundScaleMode = ScaleMode.ScaleToFit, #elif UNITY_2018_3_OR_NEWER backgroundScaleMode = ScaleMode.ScaleToFit, #else backgroundSize = ScaleMode.ScaleToFit, #endif #if UNITY_2019_1_OR_NEWER unitySliceTop = 0, unitySliceBottom = 0, unitySliceLeft = 0, unitySliceRight = 0, #else sliceTop = 0, sliceBottom = 0, sliceLeft = 0, sliceRight = 0, #endif } }); m_RecorderSettingPanel = new IMGUIContainer(OnRecorderSettingsGUI) { name = "recorderSettings" }; UIElementHelper.SetFlex(m_RecorderSettingPanel, 1.0f); var statusBar = new VisualElement { name = "statusBar" }; statusBar.Add(new IMGUIContainer(UpdateRecordingProgressGUI)); root.Add(statusBar); m_ParametersControl.Add(m_RecorderSettingPanel); m_SettingsPanel.Add(m_ParametersControl); m_ControllerSettings = RecorderControllerSettings.LoadOrCreate(Application.dataPath + s_PrefsFileName); m_RecorderController = new RecorderController(m_ControllerSettings); m_RecorderSettingsPrefsEditor = (RecorderSettingsPrefsEditor)Editor.CreateEditor(m_ControllerSettings); #if UNITY_2018_2_OR_NEWER m_RecordingListItem.RegisterCallback <ValidateCommandEvent>(OnRecorderListValidateCommand); m_RecordingListItem.RegisterCallback <ExecuteCommandEvent>(OnRecorderListExecuteCommand); #else m_RecordingListItem.RegisterCallback <IMGUIEvent>(OnRecorderListIMGUI); #endif m_RecordingListItem.RegisterCallback <KeyUpEvent>(OnRecorderListKeyUp); ReloadRecordings(); Undo.undoRedoPerformed += SaveAndRepaint; EditorApplication.playModeStateChanged += OnPlayModeStateChanged; }
private Node CreateNode(AssetGroup assetGroup, Object obj, string assetPath, bool isMainNode, int dependencyAmount) { Node resultNode; string assetGUID = AssetDatabase.AssetPathToGUID(assetPath); if (m_GUIDNodeLookup.TryGetValue(assetGUID, out resultNode)) { //----not sure what this is, the more dependencies the further removed on the chart? //int currentDepth = (int)resultNode.userData; //resultNode.userData = currentDepth + 1; return(resultNode); } if (AssetDatabase.TryGetGUIDAndLocalFileIdentifier(obj, out var assetGuid, out long _)) { var objNode = new Node { title = obj.name, style = { width = kNodeWidth } }; objNode.extensionContainer.style.backgroundColor = new Color(0.24f, 0.24f, 0.24f, 0.8f); #region Select button objNode.titleContainer.Add(new Button(() => { Selection.activeObject = obj; EditorGUIUtility.PingObject(obj); }) { style = { height = 16.0f, alignSelf = Align.Center, alignItems = Align.Center }, text = "Select" }); #endregion #region Padding var infoContainer = new VisualElement { style = { paddingBottom = 4.0f, paddingTop = 4.0f, paddingLeft = 4.0f, paddingRight = 4.0f } }; #endregion #region Asset Path, removed to improve visibility with large amount of assets // infoContainer.Add(new Label { // text = assetPath, //#if UNITY_2019_1_OR_NEWER // style = { whiteSpace = WhiteSpace.Normal } //#else // style = { wordWrap = true } //#endif // }); #endregion #region Asset type var typeName = obj.GetType().Name; if (isMainNode) { var prefabType = PrefabUtility.GetPrefabAssetType(obj); if (prefabType != PrefabAssetType.NotAPrefab) { typeName = $"{prefabType} Prefab"; } } var typeLabel = new Label { text = $"Type: {typeName}", }; infoContainer.Add(typeLabel); objNode.extensionContainer.Add(infoContainer); #endregion var typeContainer = new VisualElement { style = { paddingBottom = 4.0f, paddingTop = 4.0f, paddingLeft = 4.0f, paddingRight = 4.0f, backgroundColor = GetColorByAssetType(obj) } }; objNode.extensionContainer.Add(typeContainer); #region Node Icon, replaced with color //Texture assetTexture = AssetPreview.GetAssetPreview(obj); //if (!assetTexture) // assetTexture = AssetPreview.GetMiniThumbnail(obj); //if (assetTexture) //{ // AddDivider(objNode); // objNode.extensionContainer.Add(new Image // { // image = assetTexture, // scaleMode = ScaleMode.ScaleToFit, // style = // { // paddingBottom = 4.0f, // paddingTop = 4.0f, // paddingLeft = 4.0f, // paddingRight = 4.0f // } // }); //} #endregion // Ports //if (!isMainNode) { Port realPort = objNode.InstantiatePort(Orientation.Horizontal, Direction.Input, Port.Capacity.Single, typeof(Object)); realPort.portName = "Dependent"; objNode.inputContainer.Add(realPort); //} if (dependencyAmount > 0) { #if UNITY_2018_1 Port port = objNode.InstantiatePort(Orientation.Horizontal, Direction.Output, typeof(Object)); #else Port port = objNode.InstantiatePort(Orientation.Horizontal, Direction.Output, Port.Capacity.Single, typeof(Object)); #endif port.portName = dependencyAmount + " Dependencies"; objNode.outputContainer.Add(port); objNode.RefreshPorts(); } resultNode = objNode; resultNode.RefreshExpandedState(); resultNode.RefreshPorts(); resultNode.capabilities &= ~Capabilities.Deletable; resultNode.capabilities |= Capabilities.Collapsible; } //Debug.Log(assetGUID); m_GUIDNodeLookup[assetGUID] = resultNode; return(resultNode); }
public NoiseEditorView(NoiseSettings _noiseUpdateTarget_ = null, NoiseSettings _sourceAsset_ = null) { // create temp noisesettings asset and the IMGUI view for this window m_noiseUpdateTarget = _noiseUpdateTarget_ == null?ScriptableObject.CreateInstance <NoiseSettings>() : _noiseUpdateTarget_; m_serializedNoiseProfile = new SerializedObject(m_noiseUpdateTarget); m_noiseGUI = new NoiseSettingsGUI(); m_noiseGUI.Init(m_noiseUpdateTarget); m_noiseSourceAsset = _sourceAsset_; var stylesheet = EditorGUIUtility.isProSkin ? AssetDatabase.LoadAssetAtPath <StyleSheet>("Packages/com.unity.terrain-tools/Editor/TerrainTools/NoiseLib/Styles/Noise_Dark.uss") : AssetDatabase.LoadAssetAtPath <StyleSheet>("Packages/com.unity.terrain-tools/Editor/TerrainTools/NoiseLib/Styles/Noise_Light.uss"); var settingsScrollView = new ScrollView() { name = Styles.settingsScrollViewName }; /////////////////////////////////////////////////////////////////////////////// // settings buttons /////////////////////////////////////////////////////////////////////////////// var noiseGUIContainer = new IMGUIContainer() { name = Styles.noiseGUIContainerName }; noiseGUIContainer.onGUIHandler = () => { EditorGUI.BeginChangeCheck(); { m_noiseGUI.OnGUI(NoiseSettingsGUIFlags.All & (~NoiseSettingsGUIFlags.Preview)); } bool changed = EditorGUI.EndChangeCheck(); if (changed) { INTERNAL_OnSettingsChanged(); } }; settingsScrollView.Add(noiseGUIContainer); /////////////////////////////////////////////////////////////////////////////// // settings buttons /////////////////////////////////////////////////////////////////////////////// filePanelContainer = new VisualElement() { name = Styles.saveButtonsContainer, style = { flexDirection = FlexDirection.Row } }; filePanelContainer.AddToClassList(Styles.filePanelContainer); saveAsButton = new Button(SaveAsCallback) { name = Styles.saveAsButtonName, text = "Save As", tooltip = Styles.saveasTooltip }; saveAsButton.AddToClassList(Styles.filePanelButton); revertButton = new Button(ResetRevertCallback) { name = Styles.resetButtonName, text = "Reset", tooltip = Styles.resetTooltip }; revertButton.AddToClassList(Styles.filePanelButton); applyButton = new Button(() => { Undo.RecordObject(m_noiseSourceAsset, "NoiseWindow - Apply Settings"); m_noiseSourceAsset.CopySerialized(m_noiseUpdateTarget); }) { name = Styles.applyButtonName, text = "Apply", tooltip = Styles.applyTooltip }; applyButton.AddToClassList(Styles.filePanelButton); applyButton.AddToClassList(Styles.filePanelButton); /////////////////////////////////////////////////////////////////////////////// // noise settings object field /////////////////////////////////////////////////////////////////////////////// var objectFieldContainer = new VisualElement() { name = Styles.objectFieldContainer }; objectFieldContainer.AddToClassList(Styles.objectFieldContainer); objectField = new ObjectField() { name = Styles.noiseAssetFieldName, allowSceneObjects = false, objectType = typeof(NoiseSettings), label = Styles.noiseAssetFieldLabel, tooltip = Styles.noiseAssetFieldTooltip //, // viewDataKey = Styles.noiseAssetFieldName }; objectField.AddToClassList(Styles.noiseAssetFieldName); objectField.RegisterCallback <ChangeEvent <UnityEngine.Object> >(OnSourceProfileChanged); objectFieldContainer.Add(objectField); /////////////////////////////////////////////////////////////////////////////// // export settings /////////////////////////////////////////////////////////////////////////////// var flexArea = new VisualElement() { name = Styles.flexArea }; flexArea.AddToClassList(Styles.flexArea); var exportContainer = new VisualElement() { name = Styles.exportContainer }; exportContainer.AddToClassList(Styles.exportContainer); var exportHeader = new Foldout() { name = Styles.exportHeader, text = "Export Noise to Texture", tooltip = Styles.exportTooltip, viewDataKey = Styles.exportHeader }; exportHeader.RegisterCallback <ChangeEvent <bool> >( (evt) => { if (evt.newValue) { m_exportContainer.Add(m_exportSettings); m_exportContainer.Add(m_exportButton); } else { m_exportContainer.Remove(m_exportSettings); m_exportContainer.Remove(m_exportButton); } } ); exportHeader.AddToClassList(Styles.foldoutContainer); var exportSettings = CreateExportSettingsView(); var exportButton = new Button( () => { if (m_exportType.value == ExportTextureType.Texture2D) { Export2D(); } else if (m_exportType.value == ExportTextureType.Texture3D) { Export3D(); } } ) { name = Styles.exportButton, text = "Export" }; exportButton.AddToClassList(Styles.exportButton); m_exportButton = exportButton; exportContainer.Add(exportHeader); // exportContainer.Add( exportSettings ); // exportContainer.Add( exportButton ); m_exportContainer = exportContainer; exportHeader.value = false; // container for the settings panel var settingsContainer = new VisualElement() { name = Styles.settingsContainerName }; settingsContainer.AddToClassList(Styles.settingsContainerName); settingsContainer.Add(objectFieldContainer); settingsContainer.Add(filePanelContainer); settingsContainer.Add(settingsScrollView); settingsContainer.Add(flexArea); // add this so the export stuff stays at the bottom of the settings container settingsContainer.Add(exportContainer); settingsContainer.Bind(m_serializedNoiseProfile); /////////////////////////////////////////////////////////////////////////////// // settings buttons /////////////////////////////////////////////////////////////////////////////// var previewContainer = new VisualElement() { name = Styles.noisePreviewContainerName }; previewContainer.AddToClassList(Styles.noisePreviewContainerName); var previewLabel = new Label() { name = Styles.noisePreviewLabelName, text = Styles.previewLabel, tooltip = Styles.previewLabelTooltip }; previewLabel.AddToClassList(Styles.noisePreviewLabelName); previewContainer.Add(previewLabel); m_noiseFieldView = new NoiseFieldView(m_serializedNoiseProfile) { name = Styles.noisePreviewTextureName }; m_noiseFieldView.onGUIHandler += () => { INTERNAL_OnSettingsChanged(); }; m_noiseFieldView.AddToClassList(Styles.noisePreviewTextureName); previewContainer.Add(m_noiseFieldView); /////////////////////////////////////////////////////////////////////////////// // wrap it all up /////////////////////////////////////////////////////////////////////////////// styleSheets.Add(stylesheet); AddToClassList(Styles.noiseWindowName); Add(settingsContainer); Add(previewContainer); this.Bind(m_serializedNoiseProfile); m_settingsContainer = settingsContainer; INTERNAL_OnSourceProfileChanged(_sourceAsset_); this.viewDataKey = Styles.noiseWindowName; }
public CollabHistoryItem(RevisionData data) { m_RevisionId = data.id; m_TimeStamp = data.timeStamp; name = "HistoryItem"; m_ActionsTray = new VisualElement { name = "HistoryItemActionsTray" }; m_ProgressSpinner = new HistoryProgressSpinner(); m_Details = new VisualElement { name = "HistoryDetail" }; var author = new Label(data.authorName) { name = "Author" }; m_TimeAgo = new Label(TimeAgo.GetString(m_TimeStamp)); m_FullDescription = data.comment; var shouldTruncate = ShouldTruncateDescription(m_FullDescription); if (shouldTruncate) { m_Description = new Label(GetTruncatedDescription(m_FullDescription)); } else { m_Description = new Label(m_FullDescription); } m_Description.name = "RevisionDescription"; var dropdown = new CollabHistoryDropDown(data.changes, data.changesTotal, data.changesTruncated, data.id); if (data.current) { m_Button = new Button(Restore) { name = "ActionButton", text = "Restore" }; } else if (data.obtained) { m_Button = new Button(GoBackTo) { name = "ActionButton", text = "Go back to..." }; } else { m_Button = new Button(UpdateTo) { name = "ActionButton", text = "Update" }; } m_Button.SetEnabled(data.enabled); m_ProgressSpinner.ProgressEnabled = data.inProgress; m_ActionsTray.Add(m_ProgressSpinner); m_ActionsTray.Add(m_Button); m_Details.Add(author); m_Details.Add(m_TimeAgo); m_Details.Add(m_Description); if (shouldTruncate) { m_ExpandCollapseButton = new Button(ToggleDescription) { name = "ToggleDescription", text = "Show More" }; m_Details.Add(m_ExpandCollapseButton); } if (data.buildState != BuildState.None) { BuildStatusButton buildButton; if (data.buildState == BuildState.Configure) { buildButton = new BuildStatusButton(ShowServicePage); } else { buildButton = new BuildStatusButton(ShowBuildForCommit, data.buildState, data.buildFailures); } m_Details.Add(buildButton); } m_Details.Add(m_ActionsTray); m_Details.Add(dropdown); Add(m_Details); this.schedule.Execute(UpdateTimeAgo).Every(1000 * 20); }
void SyncAnchors(ReadOnlyCollection <VFXDataAnchorController> ports, VisualElement container) { var existingAnchors = container.Children().Cast <VFXDataAnchor>().ToDictionary(t => t.controller, t => t); Profiler.BeginSample("VFXNodeUI.SyncAnchors Delete"); var deletedControllers = existingAnchors.Keys.Except(ports).ToArray(); foreach (var deletedController in deletedControllers) { //Explicitely remove edges before removing anchor. GetFirstAncestorOfType <VFXView>().RemoveAnchorEdges(existingAnchors[deletedController]); container.Remove(existingAnchors[deletedController]); existingAnchors.Remove(deletedController); } Profiler.EndSample(); Profiler.BeginSample("VFXNodeUI.SyncAnchors New"); var order = ports.Select((t, i) => new KeyValuePair <VFXDataAnchorController, int>(t, i)).ToDictionary(t => t.Key, t => t.Value); var newAnchors = ports.Except(existingAnchors.Keys).ToArray(); VFXDataAnchor firstAnchor = null; foreach (var newController in newAnchors) { Profiler.BeginSample("VFXNodeUI.InstantiateDataAnchor"); var newElement = InstantiateDataAnchor(newController, this); Profiler.EndSample(); (newElement as VFXDataAnchor).controller = newController; container.Add(newElement); existingAnchors[newController] = newElement; if (firstAnchor == null) { firstAnchor = newElement as VFXDataAnchor; } } if (firstAnchor != null) { firstAnchor.AddToClassList("first"); } Profiler.EndSample(); Profiler.BeginSample("VFXNodeUI.SyncAnchors Reorder"); //Reorder anchors. if (ports.Count > 0) { var correctOrder = new VFXDataAnchor[ports.Count]; foreach (var kv in existingAnchors) { correctOrder[order[kv.Key]] = kv.Value; } correctOrder[0].SendToBack(); correctOrder[0].AddToClassList("first"); for (int i = 1; i < correctOrder.Length; ++i) { if (container.ElementAt(i) != correctOrder[i]) { correctOrder[i].PlaceInFront(correctOrder[i - 1]); } correctOrder[i].RemoveFromClassList("first"); } } Profiler.EndSample(); }
public override VisualElement CreateInspectorGUI() { var root = Root = new VisualElement(); root.AddToClassList("scene-template-asset-inspector"); root.AddToClassList(Styles.unityThemeVariables); root.AddToClassList(Styles.sceneTemplateThemeVariables); root.AddStyleSheetPath(Styles.k_CommonStyleSheetPath); root.AddStyleSheetPath(Styles.variableStyleSheet); root.style.flexDirection = FlexDirection.Column; var detailElement = new VisualElement(); // Template scene var templateSceneProperty = serializedObject.FindProperty(SceneTemplateUtils.TemplateScenePropertyName); var templatePropertyField = new PropertyField(templateSceneProperty, L10n.Tr("Template Scene")); templatePropertyField.tooltip = L10n.Tr("Scene to instantiate."); templatePropertyField.RegisterCallback <ChangeEvent <Object> >(e => { RebuildDependencies(root); TriggerSceneTemplateModified(); }); detailElement.Add(templatePropertyField); // Scene title var templateTitleProperty = serializedObject.FindProperty(SceneTemplateUtils.TemplateTitlePropertyName); var titlePropertyField = new PropertyField(templateTitleProperty, L10n.Tr("Title")); titlePropertyField.tooltip = L10n.Tr("Scene template display name. Shown in New Scene Dialog."); titlePropertyField.RegisterCallback <ChangeEvent <string> >(e => TriggerSceneTemplateModified()); titlePropertyField.RegisterCallback <SerializedPropertyBindEvent>(e => { EditorApplication.delayCall += () => { if (!titlePropertyField.Children().Any()) { return; } if (titlePropertyField.Children().First() is TextField titlePropertyFieldTextField) { titlePropertyFieldTextField.maxLength = 1024; m_TitleTextFieldReady = true; } }; }); detailElement.Add(titlePropertyField); // Scene description var templateDescriptionProperty = serializedObject.FindProperty(SceneTemplateUtils.TemplateDescriptionPropertyName); var description = new PropertyField(templateDescriptionProperty, L10n.Tr("Description")); description.tooltip = L10n.Tr("Scene template description. Shown in New Scene Dialog."); description.RegisterCallback <ChangeEvent <string> >(e => TriggerSceneTemplateModified()); description.RegisterCallback <SerializedPropertyBindEvent>(e => { EditorApplication.delayCall += () => { if (!description.Children().Any()) { return; } var descriptionTextField = description.Children().First() as TextField; if (descriptionTextField != null) { descriptionTextField.AddToClassList(Styles.classWrappingText); descriptionTextField.multiline = true; descriptionTextField.maxLength = 1024; m_DescriptionTextFieldReady = true; } }; }); detailElement.Add(description); var templateAddToDefaultsProperty = serializedObject.FindProperty(SceneTemplateUtils.TemplateAddToDefaultsPropertyName); var defaultTemplateField = new VisualElement(); defaultTemplateField.style.flexDirection = FlexDirection.Row; var addToDefaultsPropertyField = new PropertyField(templateAddToDefaultsProperty, " "); addToDefaultsPropertyField.RegisterCallback <ChangeEvent <bool> >(e => TriggerSceneTemplateModified()); addToDefaultsPropertyField.style.flexShrink = 0; defaultTemplateField.Add(addToDefaultsPropertyField); var label = new Label(L10n.Tr("Pin in New Scene Dialog")); label.tooltip = L10n.Tr("Pin in New Scene Dialog. Ensuring this template is shown before unpinned template in the list."); label.style.unityTextAlign = TextAnchor.MiddleLeft; label.style.overflow = Overflow.Hidden; label.style.textOverflow = TextOverflow.Ellipsis; label.style.flexShrink = 1; defaultTemplateField.Add(label); detailElement.Add(defaultTemplateField); root.Add(CreateFoldoutInspector(detailElement, L10n.Tr("Details"), "SceneTemplateInspectorDetailsFoldout")); // Template thumbnail var templateThumbnailProperty = serializedObject.FindProperty(SceneTemplateUtils.TemplateThumbnailPropertyName); var templateThumbnailBadgeProperty = serializedObject.FindProperty(SceneTemplateUtils.TemplateThumbnailBadgePropertyName); var thumbnailField = MakeThumbnailField(templateThumbnailProperty, templateThumbnailBadgeProperty); root.Add(CreateFoldoutInspector(thumbnailField, L10n.Tr("Thumbnail"), "SceneTemplateInspectorThumbnailFoldout")); // SceneTemplatePipeline var sceneTemplatePipeline = new VisualElement(); var pipelineProperty = serializedObject.FindProperty(SceneTemplateUtils.TemplatePipelineName); var pipelineField = new PropertyField(pipelineProperty, L10n.Tr("Scene Template Pipeline")); pipelineField.tooltip = k_SceneTemplateInfo; pipelineField.RegisterCallback <ChangeEvent <Object> >(e => { if (e.newValue != null && !SceneTemplateAsset.IsValidPipeline(e.newValue as MonoScript)) { Debug.LogWarning(k_SceneTemplateInfo); pipelineProperty.objectReferenceValue = null; serializedObject.ApplyModifiedProperties(); } }); sceneTemplatePipeline.Add(pipelineField); var buttonRow = CreateEmptyLabelRow(L10n.Tr("Scene Template Pipeline"), Styles.classUnityPropertyFieldLabel); // Use a hidden label instead of an empty element for proper alignment var createPipelineButton = new Button(OnCreateSceneTemplatePipeline) { text = k_CreatePipelineButtonLabel, tooltip = k_CreatePipelineTooltip }; createPipelineButton.AddToClassList(Styles.classUnityBaseFieldInput); buttonRow.Add(createPipelineButton); sceneTemplatePipeline.Add(buttonRow); root.Add(CreateFoldoutInspectorWithHelp(sceneTemplatePipeline, L10n.Tr("Scene Template Pipeline"), "SceneTemplatePipelineFoldout", k_PipelineHelpUrl)); // Dependencies root.Add(CreateFoldoutInspector(BuildDependencyRows(), L10n.Tr("Dependencies"), "SceneTemplateDependenciesFoldout")); return(root); }
private VisualElement MakeThumbnailField(SerializedProperty thumbnailProperty, SerializedProperty thumbnailBadgeProperty) { var propertyElement = new VisualElement(); var thumbnailBadgeObjectField = new PropertyField(thumbnailBadgeProperty, L10n.Tr("Badge")); thumbnailBadgeObjectField.tooltip = L10n.Tr("Scene template badge. Shown in New Scene Dialog."); propertyElement.Add(thumbnailBadgeObjectField); thumbnailBadgeObjectField.RegisterCallback <ChangeEvent <Object> >(e => { TriggerSceneTemplateModified(); }); var thumbnailObjectField = new PropertyField(thumbnailProperty, L10n.Tr("Preview")); thumbnailObjectField.tooltip = L10n.Tr("Scene template thumbnail. Shown in New Scene Dialog."); propertyElement.Add(thumbnailObjectField); m_PreviewArea = new SceneTemplatePreviewArea(k_ThumbnailAreaName, thumbnailProperty.objectReferenceValue as Texture2D, null, "No preview available"); var previewAreaElement = m_PreviewArea.Element; previewAreaElement.AddToClassList(Styles.classUnityBaseField); propertyElement.Add(previewAreaElement); thumbnailObjectField.RegisterCallback <ChangeEvent <Object> >(e => { m_PreviewArea.UpdatePreview(e.newValue as Texture2D, null); TriggerSceneTemplateModified(); }); // Snapshot header row var snapshotHeaderRowElement = new VisualElement(); snapshotHeaderRowElement.AddToClassList(Styles.classUnityBaseField); propertyElement.Add(snapshotHeaderRowElement); var snapshotHeaderLabel = new Label(L10n.Tr("Snapshot")); snapshotHeaderLabel.tooltip = L10n.Tr("Generate a Scene template thumbnail from a snapshot in Scene or Game view."); snapshotHeaderLabel.AddToClassList(Styles.classUnityLabel); snapshotHeaderRowElement.Add(snapshotHeaderLabel); // Snapshot button with dropdown var cameraNames = Camera.allCameras.Select(c => new SnapshotTargetInfo { Name = c.name, OnSnapshotAction = TakeSnapshotFromCamera }).ToList(); cameraNames.Add(new SnapshotTargetInfo()); // Separator cameraNames.Add(new SnapshotTargetInfo { Name = L10n.Tr("Game View"), OnSnapshotAction = (info, callback) => TakeSnapshotFromGameView(callback) }); var snapshotTargetPopup = new PopupField <SnapshotTargetInfo>(L10n.Tr("View"), cameraNames, Camera.allCameras.Length == 0 ? 1 : 0); snapshotTargetPopup.tooltip = L10n.Tr("View or Camera to use as the source of the snapshot."); snapshotTargetPopup.formatListItemCallback = info => info.Name; snapshotTargetPopup.formatSelectedValueCallback = info => info.Name; snapshotTargetPopup.name = k_SnapshotTargetPopupName; propertyElement.Add(snapshotTargetPopup); var snapshotSecondRowElement = CreateEmptyLabelRow(); propertyElement.Add(snapshotSecondRowElement); var snapshotButton = new Button(() => { var targetInfo = snapshotTargetPopup.value; if (targetInfo.OnSnapshotAction == null) { return; } targetInfo.OnSnapshotAction(targetInfo, null); }); snapshotButton.tooltip = k_SnapshotTooltip; snapshotButton.text = k_SnapshotButtonLabel; snapshotButton.AddToClassList(Styles.classUnityBaseFieldInput); snapshotSecondRowElement.Add(snapshotButton); return(propertyElement); }
VisualElement GeneratedMatchingSelectors() { m_MatchingSelectors.GetElementMatchers(); if (m_MatchingSelectors.matchedRulesExtractor.selectedElementRules == null || m_MatchingSelectors.matchedRulesExtractor.selectedElementRules.Count <= 0) { return(null); } var container = new VisualElement(); int ruleIndex = 0; foreach (var rule in m_MatchingSelectors.matchedRulesExtractor.selectedElementRules) { var selectorStr = StyleSheetToUss.ToUssSelector(rule.matchRecord.complexSelector); StyleProperty[] props = rule.matchRecord.complexSelector.rule.properties; var ruleFoldout = new PersistedFoldout() { value = false, text = selectorStr, viewDataKey = "builder-inspector-rule-foldout__" + ruleIndex }; ruleIndex++; container.Add(ruleFoldout); if (props.Length == 0) { var label = new Label("None"); label.AddToClassList(BuilderConstants.InspectorEmptyFoldoutLabelClassName); ruleFoldout.Add(label); continue; } for (int j = 0; j < props.Length; j++) { string s = ""; for (int k = 0; k < props[j].values.Length; k++) { if (k > 0) { s += " "; } var str = rule.matchRecord.sheet.ReadAsString(props[j].values[k]); s += str; } s = s.ToLower(); var textField = new TextField(props[j].name) { value = s }; textField.isReadOnly = true; ruleFoldout.Add(textField); } } return(container); }
public ComponentRow(ComponentQueryDeclarationModel componentQueryDeclarationModel, ComponentDefinition component, Stencil stencil, Store store, ExpandedContainer parentElement, Action <EventBase> onDeleteComponent, EventCallback <ChangeEvent <bool> > onUsageChanged) : base(string.Empty, componentQueryDeclarationModel, store, parentElement, null, null) { Component = component; m_Stencil = stencil; ClearClassList(); AddToClassList("componentRow"); var fieldViewContainerTooltip = new StringBuilder(); var fields = Component.TypeHandle.Resolve(stencil).GetFields(); int nbFields = fields.Length; if (nbFields > 0) { int i = 0; foreach (var field in fields) { var fieldView = new VisualElement { name = "fieldView" }; var fieldName = field.Name + ": "; var fieldTypeName = field.FieldType.Name; fieldView.Add(new Label(fieldName)); fieldView.Add(new Label(fieldTypeName)); fieldViewContainerTooltip.Append(fieldName + fieldTypeName); i++; if (i < nbFields) { fieldViewContainerTooltip.Append('\n'); } ExpandedContainer.Add(fieldView); } } else { ExpandedButton.style.display = DisplayStyle.None; } var deleteComponentButton = new Button { name = "deleteComponentIcon" }; deleteComponentButton.clickable.clickedWithEventInfo += onDeleteComponent; ExpandableRowTitleContainer.Insert(0, deleteComponentButton); var componentContainer = new VisualElement { name = "rowFieldContainer" }; string componentNamespace = component.TypeHandle.GetMetadata(stencil).Namespace; string componentName = component.TypeHandle.ToTypeSyntax(stencil).ToString().Replace(componentNamespace + ".", ""); userData = $"{GraphElementModel}/{componentName}"; var rowPillContainer = new VisualElement { name = "rowPillContainer" }; var componentPill = new ComponentPill(component, componentName, fieldViewContainerTooltip.ToString()); rowPillContainer.Add(componentPill); componentContainer.Add(rowPillContainer); var usageField = new Toggle("Subtract") { value = component.Subtract }; usageField.AddToClassList("usage"); usageField.RegisterValueChangedCallback(onUsageChanged); componentContainer.Add(usageField); ExpandableRowTitleContainer.Add(componentContainer); capabilities |= Capabilities.Selectable | Capabilities.Deletable; var expandedRowName = $"{ComponentQueriesRow.BlackboardEcsProviderTypeName}/{typeof(ComponentsSubSection).Name}/{componentQueryDeclarationModel}/{componentName}"; if (store.GetState().EditorDataModel.ShouldExpandBlackboardRowUponCreation(expandedRowName)) { Expanded = true; } OnExpanded = e => Store.GetState().EditorDataModel?.ExpandBlackboardRowsUponCreation(new[] { expandedRowName }, e); this.AddManipulator(new ContextualMenuManipulator(OnContextualMenuEvent)); }
public void Initialize(AbstractMaterialNode inNode, PreviewManager previewManager, IEdgeConnectorListener connectorListener) { AddStyleSheetPath("Styles/MaterialNodeView"); AddToClassList("MaterialNode"); if (inNode == null) { return; } var contents = this.Q("contents"); m_ConnectorListener = connectorListener; node = inNode; persistenceKey = node.guid.ToString(); UpdateTitle(); // Add controls container var controlsContainer = new VisualElement { name = "controls" }; { m_ControlsDivider = new VisualElement { name = "divider" }; m_ControlsDivider.AddToClassList("horizontal"); controlsContainer.Add(m_ControlsDivider); m_ControlItems = new VisualElement { name = "items" }; controlsContainer.Add(m_ControlItems); // Instantiate control views from node foreach (var propertyInfo in node.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)) { foreach (IControlAttribute attribute in propertyInfo.GetCustomAttributes(typeof(IControlAttribute), false)) { m_ControlItems.Add(attribute.InstantiateControl(node, propertyInfo)); } } } if (m_ControlItems.childCount > 0) { contents.Add(controlsContainer); } if (node.hasPreview) { // Add actual preview which floats on top of the node m_PreviewContainer = new VisualElement { name = "previewContainer", clippingOptions = ClippingOptions.ClipAndCacheContents, pickingMode = PickingMode.Ignore }; m_PreviewImage = new Image { name = "preview", pickingMode = PickingMode.Ignore, image = Texture2D.whiteTexture, }; { // Add preview collapse button on top of preview var collapsePreviewButton = new VisualElement { name = "collapse" }; collapsePreviewButton.Add(new VisualElement { name = "icon" }); collapsePreviewButton.AddManipulator(new Clickable(() => { node.owner.owner.RegisterCompleteObjectUndo("Collapse Preview"); UpdatePreviewExpandedState(false); })); m_PreviewImage.Add(collapsePreviewButton); } m_PreviewContainer.Add(m_PreviewImage); // Hook up preview image to preview manager m_PreviewRenderData = previewManager.GetPreview(inNode); m_PreviewRenderData.onPreviewChanged += UpdatePreviewTexture; UpdatePreviewTexture(); // Add fake preview which pads out the node to provide space for the floating preview m_PreviewFiller = new VisualElement { name = "previewFiller" }; m_PreviewFiller.AddToClassList("expanded"); { var previewDivider = new VisualElement { name = "divider" }; previewDivider.AddToClassList("horizontal"); m_PreviewFiller.Add(previewDivider); var expandPreviewButton = new VisualElement { name = "expand" }; expandPreviewButton.Add(new VisualElement { name = "icon" }); expandPreviewButton.AddManipulator(new Clickable(() => { node.owner.owner.RegisterCompleteObjectUndo("Expand Preview"); UpdatePreviewExpandedState(true); })); m_PreviewFiller.Add(expandPreviewButton); } contents.Add(m_PreviewFiller); UpdatePreviewExpandedState(node.previewExpanded); } // Add port input container, which acts as a pixel cache for all port inputs m_PortInputContainer = new VisualElement { name = "portInputContainer", clippingOptions = ClippingOptions.ClipAndCacheContents, pickingMode = PickingMode.Ignore }; Add(m_PortInputContainer); AddSlots(node.GetSlots <MaterialSlot>()); UpdatePortInputs(); base.expanded = node.drawState.expanded; RefreshExpandedState(); //This should not be needed. GraphView needs to improve the extension api here UpdatePortInputVisibilities(); SetPosition(new Rect(node.drawState.position.x, node.drawState.position.y, 0, 0)); if (node is SubGraphNode) { RegisterCallback <MouseDownEvent>(OnSubGraphDoubleClick); } var masterNode = node as IMasterNode; if (masterNode != null) { if (!masterNode.IsPipelineCompatible(RenderPipelineManager.currentPipeline)) { IconBadge wrongPipeline = IconBadge.CreateError("The current render pipeline is not compatible with this node preview."); Add(wrongPipeline); VisualElement title = this.Q("title"); wrongPipeline.AttachTo(title, SpriteAlignment.LeftCenter); } } m_PortInputContainer.SendToBack(); // Remove this after updated to the correct API call has landed in trunk. ------------ VisualElement m_TitleContainer; VisualElement m_ButtonContainer; m_TitleContainer = this.Q("title"); // ----------------------------------------------------------------------------------- var settings = node as IHasSettings; if (settings != null) { m_NodeSettingsView = new NodeSettingsView(); m_NodeSettingsView.visible = false; Add(m_NodeSettingsView); m_SettingsButton = new VisualElement { name = "settings-button" }; m_SettingsButton.Add(new VisualElement { name = "icon" }); m_Settings = settings.CreateSettingsElement(); m_SettingsButton.AddManipulator(new Clickable(() => { UpdateSettingsExpandedState(); })); // Remove this after updated to the correct API call has landed in trunk. ------------ m_ButtonContainer = new VisualElement { name = "button-container" }; m_ButtonContainer.style.flexDirection = StyleValue <FlexDirection> .Create(FlexDirection.Row); m_ButtonContainer.Add(m_SettingsButton); m_ButtonContainer.Add(m_CollapseButton); m_TitleContainer.Add(m_ButtonContainer); // ----------------------------------------------------------------------------------- //titleButtonContainer.Add(m_SettingsButton); //titleButtonContainer.Add(m_CollapseButton); RegisterCallback <GeometryChangedEvent>(OnGeometryChanged); } }
private void RenderRecordings() { if (!recordingPaths.Any()) { recordingPaths = GetAllRecordingAssetPaths(); } recordingContainer = new VisualElement(); for (int i = 0; i < recordingPaths.Count; i++) { string recordingFilePath = recordingPaths[i]; string filename = recordingFilePath.Substring($"{AutomatedQARuntimeSettings.RecordingFolderNameWithAssetPath}".Length + 1); if (!string.IsNullOrEmpty(searchFilterText)) { if (!filename.Contains(searchFilterText)) { continue; } } VisualElement row = new VisualElement(); if (renameFile == recordingFilePath) { RecordingRenameView(recordingFilePath); } else { VisualElement recordingRow = new VisualElement(); recordingRow.AddToClassList("item-row"); if (i % 2 == 0) { recordingRow.AddToClassList("even"); } if (firstRecordingListedIsBrandNew) { firstRecordingListedIsBrandNew = false; recordingRow.AddToClassList("item-row-new"); } Button playButton = new Button() { text = "▸" }; playButton.clickable.clicked += () => { if (!RecordingInputModule.isWorkInProgress) { renderStopButton = true; PlayRecording(recordingFilePath); SetUpView(); WaitForModuleToBeReady(); } }; playButton.tooltip = "Play recording"; playButton.AddToClassList("small-button"); playButton.AddToClassList("play-button"); recordingRow.Add(playButton); Button renameButton = new Button() { text = "✎" }; renameButton.clickable.clicked += () => { renameFile = recordingFilePath; SetUpView(); }; renameButton.tooltip = "Rename recording file"; renameButton.AddToClassList("small-button"); renameButton.AddToClassList("rename-button"); recordingRow.Add(renameButton); Button findButton = new Button() { text = "↯" }; findButton.clickable.clicked += () => { Selection.activeObject = AssetDatabase.LoadMainAssetAtPath(recordingFilePath); }; findButton.tooltip = "Find/Highlight recording file in project window."; findButton.AddToClassList("small-button"); findButton.AddToClassList("find-button"); recordingRow.Add(findButton); Label label = new Label(); label.AddToClassList("recording-label"); label.text = filename; recordingRow.Add(label); recordingContainer.Add(recordingRow); } } root.Add(recordingContainer); }
void RenderElements() { VisualElement buttonsRow = new VisualElement() { style = { flexDirection = FlexDirection.Row, flexShrink = 0f, alignContent = Align.Center } }; buttonsRow.AddToClassList("buttons-row"); if (!renderStopButton && !RecordingInputModule.isWorkInProgress) { Button saveButton = new Button() { text = "Record", style = { flexGrow = 1, height = 30 } }; saveButton.clickable.clicked += () => { StartRecording(); }; saveButton.AddToClassList("button"); buttonsRow.Add(saveButton); Button crawlButton = new Button() { text = "Crawl", style = { flexGrow = 1, height = 30 } }; crawlButton.clickable.clicked += () => { StartCrawl(); }; crawlButton.AddToClassList("button"); buttonsRow.Add(crawlButton); } else { stateLabel = new Label(); stateLabel.text = "●"; stateLabel.AddToClassList("state-label"); stateLabel.AddToClassList("red"); buttonsRow.Add(stateLabel); Button stopButton = new Button() { text = "Stop", style = { flexGrow = 1, height = 30 } }; stopButton.clickable.clicked += () => { StopRecording(); }; stopButton.AddToClassList("button"); buttonsRow.Add(stopButton); } if (ReportingManager.DoesReportExist(ReportingManager.ReportType.Html)) { Button reportButton = new Button() { text = "☰ Show Report", style = { flexGrow = 1, height = 30 } }; reportButton.clickable.clicked += () => { ShowHtmlReport(); }; reportButton.AddToClassList("button"); buttonsRow.Add(reportButton); } root.Add(buttonsRow); Label label = new Label(); label.text = "- Recording asset path -"; label.AddToClassList("center"); root.Add(label); Label val = new Label() { style = { marginBottom = 10 } }; val.text = AutomatedQARuntimeSettings.RecordingFolderNameWithAssetPath; val.AddToClassList("center"); root.Add(val); VisualElement refreshRow = new VisualElement() { style = { flexDirection = FlexDirection.Row, flexShrink = 0f, alignContent = Align.Center } }; Label filterLabel = new Label(); filterLabel.text = "Filter: "; filterLabel.AddToClassList("filter-label"); refreshRow.Add(filterLabel); searchFilterText = string.Empty; TextField newName = new TextField(); newName.AddToClassList("filter-field"); newName.RegisterValueChangedCallback(x => { searchFilterText = x.newValue; root.Remove(recordingContainer); RenderRecordings(); }); refreshRow.Add(newName); Button refreshListButton = new Button() { text = "↻", tooltip = "Refresh recordings list" }; refreshListButton.clickable.clicked += () => { newName.value = string.Empty; recordingPaths = GetAllRecordingAssetPaths(); recordingPaths.Sort(); SetUpView(); }; refreshListButton.AddToClassList("refresh-button"); refreshRow.Add(refreshListButton); root.Add(refreshRow); }
VisualElement GetSettings(GraphData graphData, Action onChange) { var element = new VisualElement() { name = "graphSettings" }; if (graphData.isSubGraph) { return(element); } void RegisterActionToUndo(string actionName) { graphData.owner.RegisterCompleteObjectUndo(actionName); } // Add Label var targetSettingsLabel = new Label("Target Settings"); targetSettingsLabel.style.unityFontStyleAndWeight = FontStyle.Bold; element.Add(new PropertyRow(targetSettingsLabel)); var targetNameList = graphData.validTargets.Select(x => x.displayName); element.Add(new PropertyRow(new Label("Targets")), (row) => { row.Add(new IMGUIContainer(() => { EditorGUI.BeginChangeCheck(); var activeTargetBitmask = EditorGUILayout.MaskField(graphData.activeTargetBitmask, targetNameList.ToArray(), GUILayout.Width(100f)); if (EditorGUI.EndChangeCheck()) { RegisterActionToUndo("Change active Targets"); graphData.activeTargetBitmask = activeTargetBitmask; graphData.UpdateActiveTargets(); m_postChangeTargetSettingsCallback(); } })); }); // Initialize from the active targets whenever user changes them // Is there a way to retain order even with that? if (userOrderedTargetNameList.Count != graphData.activeTargets.Count()) { var activeTargetNames = graphData.activeTargets.Select(x => x.displayName); userOrderedTargetNameList = activeTargetNames.ToList(); } var reorderableTextListView = new ReorderableListView <string>(userOrderedTargetNameList); reorderableTextListView.OnListReorderedCallback += list => { userOrderedTargetNameList = (List <string>)list; onChange(); }; element.Add(reorderableTextListView); // Iterate active TargetImplementations foreach (var targetName in reorderableTextListView.TextList) { // Ensure enabled state is being tracked and get value bool foldoutActive = true; if (!m_TargetFoldouts.TryGetValue(targetName, out foldoutActive)) { m_TargetFoldouts.Add(targetName, foldoutActive); } // Create foldout var foldout = new Foldout() { text = targetName, value = foldoutActive, name = "foldout" }; element.Add(foldout); foldout.AddToClassList("MainFoldout"); foldout.RegisterValueChangedCallback(evt => { // Update foldout value and rebuild m_TargetFoldouts[targetName] = evt.newValue; foldout.value = evt.newValue; onChange(); }); if (foldout.value) { var target = graphData.validTargets.Find(x => x.displayName == targetName); // Get settings for Target var context = new TargetPropertyGUIContext(); target.GetPropertiesGUI(ref context, onChange, RegisterActionToUndo); element.Add(context); } } return(element); }
private VisualElement CreateExportSettingsView() { var settingsContainer = new VisualElement() { name = Styles.exportSettings }; settingsContainer.AddToClassList(Styles.exportSettings); var exportTypes = new List <ExportTextureType>() { ExportTextureType.Texture2D, ExportTextureType.Texture3D }; var exportType = new PopupField <ExportTextureType>(exportTypes, exportTypes[0]) { name = Styles.exportType, label = "Texture Type" }; exportType.RegisterCallback <ChangeEvent <ExportTextureType> >( (evt) => { if (evt.newValue == ExportTextureType.Texture2D) { m_exportSettings.Remove(m_exportDims3D); m_exportSettings.Insert(1, m_exportDims2D); } else if (evt.newValue == ExportTextureType.Texture3D) { m_exportSettings.Remove(m_exportDims2D); m_exportSettings.Insert(1, m_exportDims3D); } } ); var dimensionsField2D = new Vector2IntField() { name = Styles.exportDims2D, label = "Dimensions", value = new Vector2Int(512, 512) }; var dimensionsField3D = new Vector3IntField() { name = Styles.exportDims3D, label = "Dimensions", value = new Vector3Int(64, 64, 64) }; var m_listOfFormats = new List <GraphicsFormat>() { // GraphicsFormat.R8_UNorm, // GraphicsFormat.R8_SNorm, GraphicsFormat.R16_UNorm, // GraphicsFormat.R16_SNorm, GraphicsFormat.R16_SFloat, // GraphicsFormat.R32_SFloat, }; var exportFormat = new PopupField <GraphicsFormat>(m_listOfFormats, GraphicsFormat.R16_UNorm) { name = Styles.exportFormat, label = "Texture Format" }; settingsContainer.Add(exportType); settingsContainer.Add(dimensionsField2D); settingsContainer.Add(exportFormat); m_exportSettings = settingsContainer; m_exportType = exportType; m_exportDims2D = dimensionsField2D; m_exportDims3D = dimensionsField3D; m_exportFormat = exportFormat; exportType.value = ExportTextureType.Texture2D; return(settingsContainer); }
private void InitializeButtons() { m_DisableIfCompiling = new ButtonDisableCondition(() => m_Application.isCompiling, L10n.Tr("You need to wait until the compilation is finished to perform this action.")); m_DisableIfInstallOrUninstallInProgress = new ButtonDisableCondition(() => m_PackageDatabase.isInstallOrUninstallInProgress, L10n.Tr("You need to wait until other install or uninstall operations are finished to perform this action.")); m_DisableIfNoNetwork = new ButtonDisableCondition(() => !m_Application.isInternetReachable, L10n.Tr("You need to restore your network connection to perform this action.")); m_UnlockButton = new PackageUnlockButton(m_PageManager); m_UnlockButton.onAction += RefreshBuiltInButtons; m_BuiltInActions.Add(m_UnlockButton.element); m_AddButton = new PackageAddButton(m_Application, m_PackageDatabase); m_AddButton.SetGlobalDisableConditions(m_DisableIfInstallOrUninstallInProgress, m_DisableIfCompiling); m_AddButton.onAction += RefreshBuiltInButtons; m_BuiltInActions.Add(m_AddButton.element); m_UpdateButton = new PackageUpdateButton(m_Application, m_PackageDatabase, m_PageManager); m_UpdateButton.SetGlobalDisableConditions(m_DisableIfInstallOrUninstallInProgress, m_DisableIfCompiling); m_UpdateButton.onAction += RefreshBuiltInButtons; m_BuiltInActions.Add(m_UpdateButton.element); m_GitUpdateButton = new PackageGitUpdateButton(m_PackageDatabase); m_GitUpdateButton.SetGlobalDisableConditions(m_DisableIfInstallOrUninstallInProgress, m_DisableIfCompiling); m_GitUpdateButton.onAction += RefreshBuiltInButtons; m_BuiltInActions.Add(m_GitUpdateButton.element); m_RemoveButton = new PackageRemoveButton(m_Application, m_PackageManagerPrefs, m_PackageDatabase, m_PageManager); m_RemoveButton.SetGlobalDisableConditions(m_DisableIfInstallOrUninstallInProgress, m_DisableIfCompiling); m_RemoveButton.onAction += RefreshBuiltInButtons; m_BuiltInActions.Add(m_RemoveButton.element); m_RemoveCustomButton = new PackageRemoveCustomButton(m_Application, m_PackageDatabase, m_PageManager); m_RemoveCustomButton.SetGlobalDisableConditions(m_DisableIfInstallOrUninstallInProgress, m_DisableIfCompiling); m_RemoveCustomButton.onAction += RefreshBuiltInButtons; m_BuiltInActions.Add(m_RemoveCustomButton.element); m_ResetButton = new PackageResetButton(m_Application, m_PackageDatabase, m_PageManager); m_ResetButton.SetGlobalDisableConditions(m_DisableIfInstallOrUninstallInProgress, m_DisableIfCompiling); m_ResetButton.onAction += RefreshBuiltInButtons; m_ResetButton.element.SetIcon("customizedIcon"); m_BuiltInActions.Add(m_ResetButton.element); m_ImportButton = new PackageImportButton(m_AssetStoreDownloadManager, m_PackageDatabase); m_ImportButton.SetGlobalDisableConditions(m_DisableIfCompiling); m_ImportButton.onAction += RefreshBuiltInButtons; m_BuiltInActions.Add(m_ImportButton.element); m_RedownloadButton = new PackageRedownloadButton(m_AssetStoreDownloadManager, m_AssetStoreCache, m_PackageDatabase); m_RedownloadButton.SetGlobalDisableConditions(m_DisableIfCompiling); m_RedownloadButton.onAction += RefreshBuiltInButtons; m_BuiltInActions.Add(m_RedownloadButton.element); m_DownloadButton = new PackageDownloadButton(m_AssetStoreDownloadManager, m_AssetStoreCache, m_PackageDatabase); m_DownloadButton.SetGlobalDisableConditions(m_DisableIfNoNetwork, m_DisableIfCompiling); m_DownloadButton.onAction += Refresh; m_BuiltInActions.Add(m_DownloadButton.element); m_DownloadUpdateButton = new PackageDownloadUpdateButton(m_AssetStoreDownloadManager, m_AssetStoreCache, m_PackageDatabase); m_DownloadUpdateButton.SetGlobalDisableConditions(m_DisableIfNoNetwork, m_DisableIfCompiling); m_DownloadUpdateButton.onAction += Refresh; m_BuiltInActions.Add(m_DownloadUpdateButton.element); m_DowngradeButton = new PackageDowngradeButton(m_AssetStoreDownloadManager, m_AssetStoreCache, m_PackageDatabase); m_DowngradeButton.SetGlobalDisableConditions(m_DisableIfNoNetwork, m_DisableIfCompiling); m_DowngradeButton.onAction += Refresh; m_BuiltInActions.Add(m_DowngradeButton.element); m_SignInButton = new PackageSignInButton(m_UnityConnectProxy); m_SignInButton.SetGlobalDisableConditions(m_DisableIfNoNetwork); m_SignInButton.onAction += RefreshBuiltInButtons; m_BuiltInActions.Add(m_SignInButton.element); // Since pause, resume, cancel buttons are only used to control the download progress, we want to put them in the progress container instead m_CancelButton = new PackageCancelDownloadButton(m_AssetStoreDownloadManager, m_PackageDatabase); m_CancelButton.SetGlobalDisableConditions(m_DisableIfCompiling); m_CancelButton.onAction += Refresh; m_ProgressContainer.Add(m_CancelButton.element); m_PauseButton = new PackagePauseDownloadButton(m_AssetStoreDownloadManager, m_PackageDatabase); m_PauseButton.SetGlobalDisableConditions(m_DisableIfCompiling); m_PauseButton.onAction += RefreshProgressControlButtons; m_ProgressContainer.Add(m_PauseButton.element); m_ResumeButton = new PackageResumeDownloadButton(m_AssetStoreDownloadManager, m_PackageDatabase); m_ResumeButton.SetGlobalDisableConditions(m_DisableIfNoNetwork, m_DisableIfCompiling); m_ResumeButton.onAction += RefreshProgressControlButtons; m_ProgressContainer.Add(m_ResumeButton.element); }
public void OnEnable() { m_GraphView = new AssetGraphView { name = "Asset Dependency Graph", }; #region Toolbar var toolbar = new VisualElement { style = { flexDirection = FlexDirection.Row, flexGrow = 0, backgroundColor = new Color(0.25f, 0.25f, 0.25f, 0.75f) } }; var options = new VisualElement { style = { alignContent = Align.Center } }; toolbar.Add(options); toolbar.Add(new Button(ExploreAsset) { text = "Explore Asset", }); toolbar.Add(new Button(ClearGraph) { text = "Clear" }); toolbar.Add(new Button(ResetAllGroups) { text = "Reset" }); codeToggle = new Toggle(); codeToggle.text = "Hide Scripts"; codeToggle.value = true; codeToggle.RegisterValueChangedCallback(x => { FilterAssetGroups(); }); toolbar.Add(codeToggle); MaterialToggle = new Toggle(); MaterialToggle.text = "Hide Materials"; MaterialToggle.value = false; MaterialToggle.RegisterValueChangedCallback(x => { FilterAssetGroups(); }); toolbar.Add(MaterialToggle); textureToggle = new Toggle(); textureToggle.text = "Hide Textures"; textureToggle.value = true; textureToggle.RegisterValueChangedCallback(x => { FilterAssetGroups(); }); toolbar.Add(textureToggle); shaderToggle = new Toggle(); shaderToggle.text = "Hide Shaders"; shaderToggle.value = true; shaderToggle.RegisterValueChangedCallback(x => { FilterAssetGroups(); }); toolbar.Add(shaderToggle); audioClipToggle = new Toggle(); audioClipToggle.text = "Hide Audioclips"; audioClipToggle.value = false; audioClipToggle.RegisterValueChangedCallback(x => { FilterAssetGroups(); }); toolbar.Add(audioClipToggle); animationClipToggle = new Toggle(); animationClipToggle.text = "Hide Animationclips"; animationClipToggle.value = false; animationClipToggle.RegisterValueChangedCallback(x => { FilterAssetGroups(); }); toolbar.Add(animationClipToggle); CustomToggle = new Toggle(); CustomToggle.text = "Hide Custom"; CustomToggle.value = true; CustomToggle.RegisterValueChangedCallback(x => { FilterAssetGroups(); }); toolbar.Add(CustomToggle); var ts = new ToolbarSearchField(); ts.RegisterValueChangedCallback(x => { if (string.IsNullOrEmpty(x.newValue)) { m_GraphView.FrameAll(); return; } m_GraphView.ClearSelection(); // m_GraphView.graphElements.ForEach(y => { // BROKEN, Case 1268337 m_GraphView.graphElements.ToList().ForEach(y => { if (y is Node node && y.title.IndexOf(x.newValue, System.StringComparison.OrdinalIgnoreCase) >= 0) { m_GraphView.AddToSelection(node); } }); m_GraphView.FrameSelection(); }); toolbar.Add(ts); AlignmentToggle = new Toggle(); AlignmentToggle.text = "Horizontal Layout"; AlignmentToggle.value = false; AlignmentToggle.RegisterValueChangedCallback(x => { ResetAllGroups(); }); toolbar.Add(AlignmentToggle); #endregion #if !UNITY_2019_1_OR_NEWER rootVisualElement = this.GetRootVisualContainer(); #endif rootVisualElement.Add(toolbar); rootVisualElement.Add(m_GraphView); m_GraphView.StretchToParentSize(); toolbar.BringToFront(); }
public void Initialize(AbstractMaterialNode inNode, PreviewManager previewManager, IEdgeConnectorListener connectorListener) { AddStyleSheetPath("Styles/MaterialNodeView"); AddToClassList("MaterialNode"); if (inNode == null) { return; } var contents = this.Q("contents"); m_ConnectorListener = connectorListener; node = inNode; persistenceKey = node.guid.ToString(); UpdateTitle(); // Add controls container var controlsContainer = new VisualElement { name = "controls" }; { m_ControlsDivider = new VisualElement { name = "divider" }; m_ControlsDivider.AddToClassList("horizontal"); controlsContainer.Add(m_ControlsDivider); m_ControlItems = new VisualElement { name = "items" }; controlsContainer.Add(m_ControlItems); // Instantiate control views from node foreach (var propertyInfo in node.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)) { foreach (IControlAttribute attribute in propertyInfo.GetCustomAttributes(typeof(IControlAttribute), false)) { m_ControlItems.Add(attribute.InstantiateControl(node, propertyInfo)); } } } if (m_ControlItems.childCount > 0) { contents.Add(controlsContainer); } if (node.hasPreview) { // Add actual preview which floats on top of the node m_PreviewContainer = new VisualElement { name = "previewContainer", clippingOptions = ClippingOptions.ClipAndCacheContents, pickingMode = PickingMode.Ignore }; m_PreviewImage = new Image { name = "preview", pickingMode = PickingMode.Ignore, image = Texture2D.whiteTexture, }; { // Add preview collapse button on top of preview var collapsePreviewButton = new VisualElement { name = "collapse" }; collapsePreviewButton.Add(new VisualElement { name = "icon" }); collapsePreviewButton.AddManipulator(new Clickable(() => { node.owner.owner.RegisterCompleteObjectUndo("Collapse Preview"); UpdatePreviewExpandedState(false); })); m_PreviewImage.Add(collapsePreviewButton); } m_PreviewContainer.Add(m_PreviewImage); // Hook up preview image to preview manager m_PreviewRenderData = previewManager.GetPreview(inNode); m_PreviewRenderData.onPreviewChanged += UpdatePreviewTexture; UpdatePreviewTexture(); // Add fake preview which pads out the node to provide space for the floating preview m_PreviewFiller = new VisualElement { name = "previewFiller" }; m_PreviewFiller.AddToClassList("expanded"); { var previewDivider = new VisualElement { name = "divider" }; previewDivider.AddToClassList("horizontal"); m_PreviewFiller.Add(previewDivider); var expandPreviewButton = new VisualElement { name = "expand" }; expandPreviewButton.Add(new VisualElement { name = "icon" }); expandPreviewButton.AddManipulator(new Clickable(() => { node.owner.owner.RegisterCompleteObjectUndo("Expand Preview"); UpdatePreviewExpandedState(true); })); m_PreviewFiller.Add(expandPreviewButton); } contents.Add(m_PreviewFiller); UpdatePreviewExpandedState(node.previewExpanded); } // Add port input container, which acts as a pixel cache for all port inputs m_PortInputContainer = new VisualElement { name = "portInputContainer", clippingOptions = ClippingOptions.ClipAndCacheContents, pickingMode = PickingMode.Ignore }; Add(m_PortInputContainer); AddSlots(node.GetSlots <MaterialSlot>()); UpdatePortInputs(); base.expanded = node.drawState.expanded; RefreshExpandedState(); //This should not be needed. GraphView needs to improve the extension api here UpdatePortInputVisibilities(); SetPosition(new Rect(node.drawState.position.x, node.drawState.position.y, 0, 0)); /*if (node is PreviewNode) * { * var resizeHandle = new Label { name = "resize", text = "" }; * resizeHandle.AddManipulator(new Draggable(OnResize)); * Add(resizeHandle); * UpdateSize(); * }*/ m_PortInputContainer.SendToBack(); if (node.hasPreview) { m_PreviewFiller.BringToFront(); } }
public LogicGraphEditorView(LogicGraphEditorWindow editorWindow, LogicGraphEditorObject logicGraphEditorObject) { Debug.Log(logicGraphEditorObject.GetInstanceID()); _editorWindow = editorWindow; _logicGraphEditorObject = logicGraphEditorObject; _logicGraphEditorObject.Deserialized += LogicGraphEditorDataOnDeserialized; this.LoadAndAddStyleSheet("Styles/LogicGraphEditorView"); var toolbar = new IMGUIContainer(() => { GUILayout.BeginHorizontal(EditorStyles.toolbar); if (GUILayout.Button("Save Asset", EditorStyles.toolbarButton)) { saveRequested?.Invoke(); } GUILayout.Space(6); if (GUILayout.Button("Show In Project", EditorStyles.toolbarButton)) { showInProjectRequested?.Invoke(); } GUILayout.FlexibleSpace(); GUILayout.EndHorizontal(); }); Add(toolbar); var content = new VisualElement { name = "content" }; { _graphView = new LogicGraphView(_logicGraphEditorObject) { name = "GraphView", // persistenceKey = "LogicGraphView", }; _graphView.SetupZoom(0.05f, ContentZoomer.DefaultMaxScale); _graphView.AddManipulator(new ContentDragger()); _graphView.AddManipulator(new SelectionDragger()); _graphView.AddManipulator(new RectangleSelector()); _graphView.AddManipulator(new ClickSelector()); _graphView.RegisterCallback <KeyDownEvent>(KeyDown); content.Add(_graphView); _graphView.graphViewChanged = GraphViewChanged; } _searchWindowProvider = ScriptableObject.CreateInstance <SearchWindowProvider>(); _searchWindowProvider.Initialize(editorWindow, this, _graphView); _edgeConnectorListener = new EdgeConnectorListener(this, _searchWindowProvider); _graphView.nodeCreationRequest = (c) => { _searchWindowProvider.ConnectedLogicPort = null; SearchWindow.Open(new SearchWindowContext(c.screenMousePosition), _searchWindowProvider); }; LoadElements(); Add(content); }
public GraphEditorView(EditorWindow editorWindow, GraphData graph, MessageManager messageManager) { m_Graph = graph; m_MessageManager = messageManager; styleSheets.Add(Resources.Load <StyleSheet>("Styles/GraphEditorView")); previewManager = new PreviewManager(graph, messageManager); string serializedToggle = EditorUserSettings.GetConfigValue(k_ToggleSettings); if (!string.IsNullOrEmpty(serializedToggle)) { m_ToggleSettings = JsonUtility.FromJson <ToggleSettings>(serializedToggle); } string serializedWindowLayout = EditorUserSettings.GetConfigValue(k_FloatingWindowsLayoutKey); if (!string.IsNullOrEmpty(serializedWindowLayout)) { m_FloatingWindowsLayout = JsonUtility.FromJson <FloatingWindowsLayout>(serializedWindowLayout); } else { m_FloatingWindowsLayout = new FloatingWindowsLayout { blackboardLayout = { dockingTop = true, dockingLeft = true, verticalOffset = 16, horizontalOffset = 16, size = new Vector2(200, 400) } }; } if (m_FloatingWindowsLayout.masterPreviewSize.x > 0f && m_FloatingWindowsLayout.masterPreviewSize.y > 0f) { previewManager.ResizeMasterPreview(m_FloatingWindowsLayout.masterPreviewSize); } previewManager.RenderPreviews(); var toolbar = new IMGUIContainer(() => { GUILayout.BeginHorizontal(EditorStyles.toolbar); if (GUILayout.Button("Save Asset", EditorStyles.toolbarButton)) { if (saveRequested != null) { saveRequested(); } } GUILayout.Space(6); if (GUILayout.Button("Show In Project", EditorStyles.toolbarButton)) { if (showInProjectRequested != null) { showInProjectRequested(); } } GUILayout.FlexibleSpace(); EditorGUI.BeginChangeCheck(); m_ToggleSettings.isBlackboardVisible = GUILayout.Toggle(m_ToggleSettings.isBlackboardVisible, "Blackboard", EditorStyles.toolbarButton); GUILayout.Space(6); m_ToggleSettings.isPreviewVisible = GUILayout.Toggle(m_ToggleSettings.isPreviewVisible, "Main Preview", EditorStyles.toolbarButton); if (EditorGUI.EndChangeCheck()) { m_MasterPreviewView.visible = m_ToggleSettings.isPreviewVisible; m_BlackboardProvider.blackboard.visible = m_ToggleSettings.isBlackboardVisible; string serializedToggleables = JsonUtility.ToJson(m_ToggleSettings); EditorUserSettings.SetConfigValue(k_ToggleSettings, serializedToggleables); } GUILayout.EndHorizontal(); }); Add(toolbar); var content = new VisualElement { name = "content" }; { m_GraphView = new MaterialGraphView(graph) { name = "GraphView", viewDataKey = "MaterialGraphView" }; m_GraphView.SetupZoom(0.05f, ContentZoomer.DefaultMaxScale); m_GraphView.AddManipulator(new ContentDragger()); m_GraphView.AddManipulator(new SelectionDragger()); m_GraphView.AddManipulator(new RectangleSelector()); m_GraphView.AddManipulator(new ClickSelector()); m_GraphView.RegisterCallback <KeyDownEvent>(OnSpaceDown); m_GraphView.groupTitleChanged = OnGroupTitleChanged; m_GraphView.elementsAddedToGroup = OnElementsAddedToGroup; m_GraphView.elementsRemovedFromGroup = OnElementsRemovedFromGroup; content.Add(m_GraphView); m_BlackboardProvider = new BlackboardProvider(graph); m_GraphView.Add(m_BlackboardProvider.blackboard); // Initialize toggle settings if it doesnt exist. if (m_ToggleSettings == null) { m_ToggleSettings = new ToggleSettings(); } m_BlackboardProvider.blackboard.visible = m_ToggleSettings.isBlackboardVisible; m_MasterPreviewView = new MasterPreviewView(previewManager, graph) { name = "masterPreview" }; WindowDraggable masterPreviewViewDraggable = new WindowDraggable(null, this); m_MasterPreviewView.AddManipulator(masterPreviewViewDraggable); m_GraphView.Add(m_MasterPreviewView); //m_BlackboardProvider.onDragFinished += UpdateSerializedWindowLayout; //m_BlackboardProvider.onResizeFinished += UpdateSerializedWindowLayout; masterPreviewViewDraggable.OnDragFinished += UpdateSerializedWindowLayout; m_MasterPreviewView.previewResizeBorderFrame.OnResizeFinished += UpdateSerializedWindowLayout; m_MasterPreviewView.visible = m_ToggleSettings.isPreviewVisible; m_GraphView.graphViewChanged = GraphViewChanged; RegisterCallback <GeometryChangedEvent>(ApplySerializewindowLayouts); } m_SearchWindowProvider = ScriptableObject.CreateInstance <SearchWindowProvider>(); m_SearchWindowProvider.Initialize(editorWindow, m_Graph, m_GraphView); m_GraphView.nodeCreationRequest = (c) => { m_SearchWindowProvider.connectedPort = null; SearchWindow.Open(new SearchWindowContext(c.screenMousePosition), m_SearchWindowProvider); }; m_EdgeConnectorListener = new EdgeConnectorListener(m_Graph, m_SearchWindowProvider); foreach (var graphGroup in graph.groups) { AddGroup(graphGroup); } foreach (var node in graph.GetNodes <AbstractMaterialNode>()) { AddNode(node); } foreach (var edge in graph.edges) { AddEdge(edge); } Add(content); }
public override void OnActivate(string searchContext, VisualElement root) { var padRect = new VisualElement(); int padding = 10; padRect.style.paddingBottom = padding; padRect.style.paddingLeft = padding; padRect.style.paddingRight = padding; padRect.style.paddingTop = padding - 5; root.Add(padRect); var title = new Label("Notch Solution"); title.style.fontSize = 15; title.style.unityFontStyleAndWeight = FontStyle.Bold; padRect.Add(title); var repo = new Label("https://github.com/5argon/NotchSolution"); repo.style.paddingBottom = 15; repo.style.unityFontStyleAndWeight = FontStyle.Bold; repo.RegisterCallback((MouseDownEvent ev) => { System.Diagnostics.Process.Start("https://github.com/5argon/NotchSolution"); }); padRect.Add(repo); var colorField = new ColorField("Prefab mode overlay color"); colorField.value = NotchSolutionUtility.PrefabModeOverlayColor; colorField.RegisterValueChangedCallback(ev => { NotchSolutionUtility.PrefabModeOverlayColor = ev.newValue; NotchSimulator.UpdateAllMockups(); NotchSimulator.UpdateSimulatorTargets(); }); padRect.Add(colorField); string shortcutString = ShortcutManager.instance.GetShortcutBinding(NotchSolutionShortcuts.switchNarrowestWidestShortcut).ToString(); string text = $"This feature allows you to press {shortcutString} to quick switch between 2 aspect ratio choices. Commonly I would often switch between the longest phone like LG G7 and widest device like an iPad as I design. The index is counted from the top choice where 0 equals Free Aspect."; var box = new Box(); var helpBox = new Label(text); helpBox.style.whiteSpace = WhiteSpace.Normal; box.style.paddingTop = 5; box.style.paddingLeft = 5; box.style.paddingRight = 5; box.style.paddingBottom = 2; box.style.marginTop = 10; box.style.marginBottom = 10; box.Add(helpBox); padRect.Add(box); //TODO : Reflect to `GameViewSizes.instance` and request all sizes to draw a nicer drop down menu instead of index number. var narrowest = new IntegerField("Narrowest aspect index"); narrowest.value = NotchSolutionUtility.NarrowestAspectIndex; narrowest.RegisterValueChangedCallback(ev => { narrowest.value = Mathf.Max(0, ev.newValue); //go to -1 and the game view crashes.. NotchSolutionUtility.NarrowestAspectIndex = ev.newValue; NotchSimulator.UpdateAllMockups(); NotchSimulator.UpdateSimulatorTargets(); }); padRect.Add(narrowest); var widest = new IntegerField("Widest aspect index"); widest.value = NotchSolutionUtility.WidestAspectIndex; widest.RegisterValueChangedCallback(ev => { widest.value = Mathf.Max(0, ev.newValue); NotchSolutionUtility.WidestAspectIndex = ev.newValue; NotchSimulator.UpdateAllMockups(); NotchSimulator.UpdateSimulatorTargets(); }); padRect.Add(widest); }
public BoxModelElement(BoxType boxType, VisualElement content, VisualElement topTextFieldContainer, VisualElement bottomTextFieldContainer) { string title = ""; switch (boxType) { case BoxType.Margin: title = "margin"; break; case BoxType.Border: title = "border"; break; case BoxType.Padding: title = "padding"; break; } this.boxType = boxType; m_Title = new Label(title); m_Title.AddToClassList("box-model-title"); m_CenterContent = content; m_CenterContent.AddToClassList("box-model-center-content"); m_LeftTextField = new IntegerField(); m_LeftTextField.AddToClassList("box-model-textfield"); m_LeftTextField.RegisterValueChangedCallback(e => OnTextFieldValueChanged(e, SideChanged.Left)); m_RightTextField = new IntegerField(); m_RightTextField.AddToClassList("box-model-textfield"); m_RightTextField.RegisterValueChangedCallback(e => OnTextFieldValueChanged(e, SideChanged.Right)); m_TopTextField = new IntegerField(); m_TopTextField.AddToClassList("box-model-textfield"); m_TopTextField.RegisterValueChangedCallback(e => OnTextFieldValueChanged(e, SideChanged.Top)); m_FakeTopTextField = new IntegerField(); m_FakeTopTextField.AddToClassList("box-model-textfield"); m_FakeTopTextField.visible = false; m_BottomTextField = new IntegerField(); m_BottomTextField.AddToClassList("box-model-textfield"); m_BottomTextField.RegisterValueChangedCallback(e => OnTextFieldValueChanged(e, SideChanged.Bottom)); m_FakeBottomTextField = new IntegerField(); m_FakeBottomTextField.AddToClassList("box-model-textfield"); m_FakeBottomTextField.visible = false; m_Left = new VisualElement(); m_Left.AddToClassList("box-model-side"); m_Left.Add(m_LeftTextField); m_Right = new VisualElement(); m_Right.AddToClassList("box-model-side"); m_Right.Add(m_RightTextField); m_Center = new VisualElement(); m_Center.AddToClassList("box-model-center"); m_CenterTop = new VisualElement(); m_CenterTop.AddToClassList("box-model-center-top"); m_CenterTop.Add(m_FakeTopTextField); topTextFieldContainer.Add(m_TopTextField); m_CenterBottom = new VisualElement(); m_CenterBottom.AddToClassList("box-model-center-bottom"); m_CenterBottom.Add(m_FakeBottomTextField); bottomTextFieldContainer.Add(m_BottomTextField); m_Center.Add(m_CenterTop); m_Center.Add(m_CenterContent); m_Center.Add(m_CenterBottom); Add(m_Title); Add(m_Left); Add(m_Center); Add(m_Right); // Sync styles values schedule.Execute(SyncValues).Every(100); }
private VisualElement CreateInboundRtpView(string id) { var root = new VisualElement(); var container = new VisualElement(); root.Add(container); var inboundGraph = new InboundRTPStreamGraphView(); m_parent.OnStats += (peer, report) => { if (peer != m_peerConnection) { return; } container.Clear(); if (!report.TryGetValue(id, out var stats) || !(stats is RTCInboundRTPStreamStats inboundStats)) { container.Add(new Label($"no stats report about {RTCStatsType.InboundRtp}")); return; } container.Add(new Label($"{nameof(inboundStats.Id)}: {inboundStats.Id}")); container.Add(new Label($"{nameof(inboundStats.Timestamp)}: {inboundStats.Timestamp}")); container.Add(new Label($"{nameof(inboundStats.ssrc)}: {inboundStats.ssrc}")); container.Add(new Label($"{nameof(inboundStats.estimatedPlayoutTimestamp)}: {inboundStats.estimatedPlayoutTimestamp}")); container.Add(new Label($"{nameof(inboundStats.isRemote)}: {inboundStats.isRemote}")); container.Add(new Label($"{nameof(inboundStats.mediaType)}: {inboundStats.mediaType}")); container.Add(new Label($"{nameof(inboundStats.kind)}: {inboundStats.kind}")); container.Add(new Label($"{nameof(inboundStats.trackId)}: {inboundStats.trackId}")); container.Add(new Label($"{nameof(inboundStats.transportId)}: {inboundStats.transportId}")); container.Add(new Label($"{nameof(inboundStats.codecId)}: {inboundStats.codecId}")); container.Add(new Label($"{nameof(inboundStats.firCount)}: {inboundStats.firCount}")); container.Add(new Label($"{nameof(inboundStats.pliCount)}: {inboundStats.pliCount}")); container.Add(new Label($"{nameof(inboundStats.nackCount)}: {inboundStats.nackCount}")); container.Add(new Label($"{nameof(inboundStats.sliCount)}: {inboundStats.sliCount}")); container.Add(new Label($"{nameof(inboundStats.qpSum)}: {inboundStats.qpSum}")); container.Add(new Label($"{nameof(inboundStats.packetsReceived)}: {inboundStats.packetsReceived}")); container.Add(new Label($"{nameof(inboundStats.bytesReceived)}: {inboundStats.bytesReceived}")); container.Add( new Label($"{nameof(inboundStats.headerBytesReceived)}: {inboundStats.headerBytesReceived}")); container.Add(new Label($"{nameof(inboundStats.packetsLost)}: {inboundStats.packetsLost}")); container.Add(new Label( $"{nameof(inboundStats.lastPacketReceivedTimestamp)}: {inboundStats.lastPacketReceivedTimestamp}")); container.Add(new Label($"{nameof(inboundStats.jitter)}: {inboundStats.jitter}")); container.Add(new Label($"{nameof(inboundStats.roundTripTime)}: {inboundStats.roundTripTime}")); container.Add(new Label($"{nameof(inboundStats.packetsDiscarded)}: {inboundStats.packetsDiscarded}")); container.Add(new Label($"{nameof(inboundStats.packetsRepaired)}: {inboundStats.packetsRepaired}")); container.Add(new Label($"{nameof(inboundStats.burstPacketsLost)}: {inboundStats.burstPacketsLost}")); container.Add( new Label($"{nameof(inboundStats.burstPacketsDiscarded)}: {inboundStats.burstPacketsDiscarded}")); container.Add(new Label($"{nameof(inboundStats.burstLossCount)}: {inboundStats.burstLossCount}")); container.Add(new Label($"{nameof(inboundStats.burstDiscardCount)}: {inboundStats.burstDiscardCount}")); container.Add(new Label($"{nameof(inboundStats.burstLossRate)}: {inboundStats.burstLossRate}")); container.Add(new Label($"{nameof(inboundStats.burstDiscardRate)}: {inboundStats.burstDiscardRate}")); container.Add(new Label($"{nameof(inboundStats.gapLossRate)}: {inboundStats.gapLossRate}")); container.Add(new Label($"{nameof(inboundStats.gapDiscardRate)}: {inboundStats.gapDiscardRate}")); container.Add(new Label($"{nameof(inboundStats.framesDecoded)}: {inboundStats.framesDecoded}")); container.Add(new Label($"{nameof(inboundStats.keyFramesDecoded)}: {inboundStats.keyFramesDecoded}")); container.Add(new Label($"{nameof(inboundStats.totalDecodeTime)}: {inboundStats.totalDecodeTime}")); container.Add(new Label($"{nameof(inboundStats.contentType)}: {inboundStats.contentType}")); container.Add( new Label($"{nameof(inboundStats.decoderImplementation)}: {inboundStats.decoderImplementation}")); inboundGraph.AddInput(inboundStats); }; root.Add(inboundGraph.Create()); return(root); }
public BoxModelView() { AddToClassList("box-model-view"); visible = false; m_OverlayPainter = new HighlightOverlayPainter(); m_Container = new VisualElement(); m_Container.AddToClassList("box-model-view-container"); m_Layer1 = new VisualElement() { name = "BoxModelViewLayer1" }; m_Layer2 = new VisualElement() { name = "BoxModelViewLayer2" }; m_Layer2.style.position = Position.Absolute; m_Layer2.pickingMode = PickingMode.Ignore; m_Layer2.StretchToParentSize(); m_TopTextFieldMarginContainer.pickingMode = PickingMode.Ignore; m_TopTextFieldMarginContainer.AddToClassList("box-model-textfield-top-bottom-spacer"); m_BottomTextFieldMarginContainer.pickingMode = PickingMode.Ignore; m_BottomTextFieldMarginContainer.AddToClassList("box-model-textfield-top-bottom-spacer"); m_TopTextFieldBorderContainer.pickingMode = PickingMode.Ignore; m_TopTextFieldBorderContainer.AddToClassList("box-model-textfield-top-bottom-spacer"); m_BottomTextFieldBorderContainer.pickingMode = PickingMode.Ignore; m_BottomTextFieldBorderContainer.AddToClassList("box-model-textfield-top-bottom-spacer"); m_TopTextFieldPaddingContainer.pickingMode = PickingMode.Ignore; m_TopTextFieldPaddingContainer.AddToClassList("box-model-textfield-top-bottom-spacer"); m_BottomTextFieldPaddingContainer.pickingMode = PickingMode.Ignore; m_BottomTextFieldPaddingContainer.AddToClassList("box-model-textfield-top-bottom-spacer"); m_ContentSpacer.pickingMode = PickingMode.Ignore; m_ContentSpacer.AddToClassList("box-model-textfield-top-bottom-spacer"); m_Layer2.Add(m_TopTextFieldMarginContainer); m_Layer2.Add(m_TopTextFieldBorderContainer); m_Layer2.Add(m_TopTextFieldPaddingContainer); m_Layer2.Add(m_ContentSpacer); m_Layer2.Add(m_BottomTextFieldPaddingContainer); m_Layer2.Add(m_BottomTextFieldBorderContainer); m_Layer2.Add(m_BottomTextFieldMarginContainer); m_ContentBox = new ContentBox(); m_ContentBox.AddToClassList("box-model"); m_ContentBox.AddToClassList("box-model-container-content"); m_ContentBox.RegisterCallback <MouseOverEvent, BoxType>(OnMouseOver, BoxType.Content); m_PaddingBox = new BoxModelElement(BoxType.Padding, m_ContentBox, m_TopTextFieldPaddingContainer, m_BottomTextFieldPaddingContainer); m_PaddingBox.AddToClassList("box-model"); m_PaddingBox.AddToClassList("box-model-container-padding"); m_PaddingBox.RegisterCallback <MouseOverEvent, BoxType>(OnMouseOver, BoxType.Padding); m_BorderBox = new BoxModelElement(BoxType.Border, m_PaddingBox, m_TopTextFieldBorderContainer, m_BottomTextFieldBorderContainer); m_BorderBox.AddToClassList("box-model"); m_BorderBox.AddToClassList("box-model-container-border"); m_BorderBox.RegisterCallback <MouseOverEvent, BoxType>(OnMouseOver, BoxType.Border); m_MarginBox = new BoxModelElement(BoxType.Margin, m_BorderBox, m_TopTextFieldMarginContainer, m_BottomTextFieldMarginContainer); m_MarginBox.AddToClassList("box-model"); m_MarginBox.AddToClassList("box-model-container-margin"); m_MarginBox.RegisterCallback <MouseOverEvent, BoxType>(OnMouseOver, BoxType.Margin); m_Layer1.Add(m_MarginBox); m_Container.Add(m_Layer1); m_Container.Add(m_Layer2); var spacerLeft = new VisualElement() { style = { flexGrow = 1 } }; var spacerRight = new VisualElement() { style = { flexGrow = 1 } }; Add(spacerLeft); Add(m_Container); Add(spacerRight); RegisterCallback <MouseOutEvent>(OnMouseOut); }
private VisualElement CreateOutboundRtpView(string id) { var root = new VisualElement(); var container = new VisualElement(); root.Add(container); var outboundGraph = new OutboundRTPStreamGraphView(); m_parent.OnStats += (peer, report) => { if (peer != m_peerConnection) { return; } container.Clear(); if (!report.TryGetValue(id, out var stats) || !(stats is RTCOutboundRTPStreamStats outboundStats)) { container.Add(new Label($"no stats report about {RTCStatsType.OutboundRtp}")); return; } container.Add(new Label($"{nameof(outboundStats.Id)}: {outboundStats.Id}")); container.Add(new Label($"{nameof(outboundStats.Timestamp)}: {outboundStats.Timestamp}")); container.Add(new Label($"{nameof(outboundStats.ssrc)}: {outboundStats.ssrc}")); container.Add(new Label($"{nameof(outboundStats.estimatedPlayoutTimestamp)}: {outboundStats.estimatedPlayoutTimestamp}")); container.Add(new Label($"{nameof(outboundStats.isRemote)}: {outboundStats.isRemote}")); container.Add(new Label($"{nameof(outboundStats.mediaType)}: {outboundStats.mediaType}")); container.Add(new Label($"{nameof(outboundStats.kind)}: {outboundStats.kind}")); container.Add(new Label($"{nameof(outboundStats.trackId)}: {outboundStats.trackId}")); container.Add(new Label($"{nameof(outboundStats.transportId)}: {outboundStats.transportId}")); container.Add(new Label($"{nameof(outboundStats.codecId)}: {outboundStats.codecId}")); container.Add(new Label($"{nameof(outboundStats.firCount)}: {outboundStats.firCount}")); container.Add(new Label($"{nameof(outboundStats.pliCount)}: {outboundStats.pliCount}")); container.Add(new Label($"{nameof(outboundStats.nackCount)}: {outboundStats.nackCount}")); container.Add(new Label($"{nameof(outboundStats.sliCount)}: {outboundStats.sliCount}")); container.Add(new Label($"{nameof(outboundStats.qpSum)}: {outboundStats.qpSum}")); container.Add(new Label($"{nameof(outboundStats.mediaSourceId)}: {outboundStats.mediaSourceId}")); container.Add(new Label($"{nameof(outboundStats.packetsSent)}: {outboundStats.packetsSent}")); container.Add(new Label( $"{nameof(outboundStats.retransmittedPacketsSent)}: {outboundStats.retransmittedPacketsSent}")); container.Add(new Label($"{nameof(outboundStats.bytesSent)}: {outboundStats.bytesSent}")); container.Add(new Label($"{nameof(outboundStats.headerBytesSent)}: {outboundStats.headerBytesSent}")); container.Add(new Label( $"{nameof(outboundStats.retransmittedBytesSent)}: {outboundStats.retransmittedBytesSent}")); container.Add(new Label($"{nameof(outboundStats.targetBitrate)}: {outboundStats.targetBitrate}")); container.Add(new Label($"{nameof(outboundStats.framesEncoded)}: {outboundStats.framesEncoded}")); container.Add(new Label($"{nameof(outboundStats.keyFramesEncoded)}: {outboundStats.keyFramesEncoded}")); container.Add(new Label($"{nameof(outboundStats.totalEncodeTime)}: {outboundStats.totalEncodeTime}")); container.Add(new Label( $"{nameof(outboundStats.totalEncodedBytesTarget)}: {outboundStats.totalEncodedBytesTarget}")); container.Add( new Label($"{nameof(outboundStats.totalPacketSendDelay)}: {outboundStats.totalPacketSendDelay}")); container.Add(new Label( $"{nameof(outboundStats.qualityLimitationReason)}: {outboundStats.qualityLimitationReason}")); container.Add(new Label( $"{nameof(outboundStats.qualityLimitationResolutionChanges)}: {outboundStats.qualityLimitationResolutionChanges}")); container.Add(new Label($"{nameof(outboundStats.contentType)}: {outboundStats.contentType}")); container.Add(new Label( $"{nameof(outboundStats.encoderImplementation)}: {outboundStats.encoderImplementation}")); outboundGraph.AddInput(outboundStats); }; root.Add(outboundGraph.Create()); return(root); }
void InitializeCoppaManager(VisualElement rootVisualElement) { rootVisualElement.AddStyleSheetPath(k_CoppaCommonStyleSheetPath); rootVisualElement.AddStyleSheetPath(EditorGUIUtility.isProSkin ? k_CoppaDarkStyleSheetPath : k_CoppaLightStyleSheetPath); var coppaTemplate = EditorGUIUtility.Load(k_CoppaTemplatePath) as VisualTreeAsset; rootVisualElement.Add(coppaTemplate.CloneTree().contentContainer); m_CoppaContainer = rootVisualElement.Q(coppaContainerName); var persistContainer = m_CoppaContainer.Q(k_PersistContainerName); var coppaField = BuildPopupField(m_CoppaContainer, k_CoppaFieldName); //Setup dashboard link var learnMoreClickable = new Clickable(() => { Application.OpenURL(k_CoppaLearnMoreUrl); }); m_CoppaContainer.Q(k_CoppaLearnLinkBtnName).AddManipulator(learnMoreClickable); var originalCoppaValue = UnityConnect.instance.GetProjectInfo().COPPA; var coppaChoicesList = new List <String>() { L10n.Tr(k_No), L10n.Tr(k_Yes) }; if (originalCoppaValue == COPPACompliance.COPPAUndefined) { coppaChoicesList.Insert(0, L10n.Tr(k_Undefined)); } coppaField.choices = coppaChoicesList; SetCoppaFieldValue(originalCoppaValue, coppaField); persistContainer.Q <Button>(k_SaveBtnName).clicked += () => { try { ServicesConfiguration.instance.RequestCurrentProjectCoppaApiUrl(projectCoppaApiUrl => { var payload = $"{{\"coppa\":\"{GetCompliancyJsonValueFromFieldValue(coppaField)}\"}}"; var uploadHandler = new UploadHandlerRaw(Encoding.UTF8.GetBytes(payload)); var currentSaveRequest = new UnityWebRequest(projectCoppaApiUrl, UnityWebRequest.kHttpVerbPUT) { uploadHandler = uploadHandler }; currentSaveRequest.suppressErrorsToConsole = true; currentSaveRequest.SetRequestHeader("AUTHORIZATION", $"Bearer {UnityConnect.instance.GetUserInfo().accessToken}"); currentSaveRequest.SetRequestHeader("Content-Type", "application/json;charset=UTF-8"); var operation = currentSaveRequest.SendWebRequest(); SetEnabledCoppaControls(coppaContainer, false); operation.completed += asyncOperation => { try { if (currentSaveRequest.responseCode == k_HttpStatusNoContent) { try { var newCompliancyValue = GetCompliancyForFieldValue(coppaField); if (!UnityConnect.instance.SetCOPPACompliance(newCompliancyValue)) { EditorAnalytics.SendCoppaComplianceEvent(new CoppaState() { isCompliant = newCompliancyValue == COPPACompliance.COPPACompliant }); SetCoppaFieldValue(originalCoppaValue, coppaField); SetPersistContainerVisibility(originalCoppaValue, persistContainer, coppaField); exceptionCallback?.Invoke(originalCoppaValue, new CoppaComplianceEditorConfigurationException(k_CoppaComplianceEditorConfigurationExceptionMessage)); } else { originalCoppaValue = newCompliancyValue; SetCoppaFieldValue(originalCoppaValue, coppaField); SetPersistContainerVisibility(originalCoppaValue, persistContainer, coppaField); NotificationManager.instance.Publish(Notification.Topic.CoppaCompliance, Notification.Severity.Info, L10n.Tr(CoppaComplianceChangedMessage)); saveButtonCallback?.Invoke(originalCoppaValue); } } catch (Exception ex) { SetCoppaFieldValue(originalCoppaValue, coppaField); SetPersistContainerVisibility(originalCoppaValue, persistContainer, coppaField); exceptionCallback?.Invoke(originalCoppaValue, new CoppaComplianceEditorConfigurationException(k_CoppaComplianceEditorConfigurationExceptionMessage, ex)); } finally { currentSaveRequest.Dispose(); currentSaveRequest = null; } } else { try { SetCoppaFieldValue(originalCoppaValue, coppaField); SetPersistContainerVisibility(originalCoppaValue, persistContainer, coppaField); exceptionCallback?.Invoke(originalCoppaValue, new CoppaComplianceWebConfigurationException(L10n.Tr(k_CoppaUnexpectedSaveRequestBehaviorMessage)) { error = currentSaveRequest.error, method = currentSaveRequest.method, timeout = currentSaveRequest.timeout, url = currentSaveRequest.url, responseHeaders = currentSaveRequest.GetResponseHeaders(), responseCode = currentSaveRequest.responseCode, isHttpError = (currentSaveRequest.result == UnityWebRequest.Result.ProtocolError), isNetworkError = (currentSaveRequest.result == UnityWebRequest.Result.ConnectionError), }); } finally { currentSaveRequest.Dispose(); currentSaveRequest = null; } } } finally { SetEnabledCoppaControls(coppaContainer, true); } }; }); } catch (Exception ex) { SetCoppaFieldValue(originalCoppaValue, coppaField); SetPersistContainerVisibility(originalCoppaValue, persistContainer, coppaField); exceptionCallback?.Invoke(originalCoppaValue, ex); } }; persistContainer.Q <Button>(k_CancelBtnName).clicked += () => { SetCoppaFieldValue(originalCoppaValue, coppaField); SetPersistContainerVisibility(originalCoppaValue, persistContainer, coppaField); cancelButtonCallback?.Invoke(originalCoppaValue); }; persistContainer.style.display = DisplayStyle.None; coppaField.RegisterValueChangedCallback(evt => { SetPersistContainerVisibility(originalCoppaValue, persistContainer, coppaField); }); }