void ClearChildrenRenderers(VisualElement view)
{
if (view == null)
return;
foreach (Element logicalChild in view.LogicalChildren)
{
var child = logicalChild as VisualElement;
if (child != null)
{
IVisualElementRenderer renderer = Platform.GetRenderer(child);
if (renderer == null)
continue;
if (renderer.ViewGroup.Parent != _parent.ViewGroup)
continue;
renderer.ViewGroup.RemoveFromParent();
Platform.SetRenderer(child, null);
PushRenderer(renderer);
}
}
if (_parent.ViewGroup.ChildCount != 0)
_parent.ViewGroup.RemoveAllViews();
}
public static IWinRTRenderer GetRenderer(VisualElement view)
{
IWinRTRenderer renderer = Registrar.Registered.GetHandler<IWinRTRenderer>(view.GetType()) ?? new ViewRenderer();
renderer.Element = view;
return renderer;
}
protected override void AddChildView(VisualElement childView)
{
_pageContainer = null;
Page page = childView as NavigationPage ?? (Page)(childView as TabbedPage);
if (page == null)
{
// Not a NavigationPage or TabbedPage? Just do the normal thing
base.AddChildView(childView);
}
else
{
// The renderers for NavigationPage and TabbedPage both host fragments, so they need to be wrapped in a
// FragmentContainer in order to get isolated fragment management
Fragment fragment = FragmentContainer.CreateInstance(page);
var fc = fragment as FragmentContainer;
fc?.SetOnCreateCallback(pc =>
{
_pageContainer = pc;
SetDefaultBackgroundColor(pc.Child);
});
FragmentTransaction transaction = FragmentManager.BeginTransaction();
transaction.DisallowAddToBackStack();
transaction.Add(Id, fragment);
transaction.SetTransition((int)FragmentTransit.FragmentOpen);
transaction.Commit();
}
}
public void UpdateNewElement(VisualElement newElement)
{
if (newElement == null)
throw new ArgumentNullException("newElement");
var sameChildrenTypes = true;
var oldChildren = ((IElementController)_oldElement).LogicalChildren;
var newChildren = ((IElementController)newElement).LogicalChildren;
if (oldChildren.Count == newChildren.Count)
{
for (var i = 0; i < oldChildren.Count; i++)
{
if (oldChildren[i].GetType() != newChildren[i].GetType())
{
sameChildrenTypes = false;
break;
}
}
}
else
sameChildrenTypes = false;
if (!sameChildrenTypes)
{
ClearRenderers(_parent);
FillChildrenWithRenderers(newElement);
}
else
UpdateRenderers(newElement);
}
public void SetElement(VisualElement element)
{
var oldElement = Element;
Element = element;
Element.PropertyChanged += HandlePropertyChanged;
((WebView)Element).EvalRequested += OnEvalRequested;
((WebView)Element).GoBackRequested += OnGoBackRequested;
((WebView)Element).GoForwardRequested += OnGoForwardRequested;
Delegate = new CustomWebViewDelegate(this);
BackgroundColor = UIColor.Clear;
AutosizesSubviews = true;
_tracker = new VisualElementTracker(this);
_packager = new VisualElementPackager(this);
_packager.Load();
_events = new EventTracker(this);
_events.LoadEvents(this);
Load();
OnElementChanged(new VisualElementChangedEventArgs(oldElement, element));
if (Element != null && !string.IsNullOrEmpty(Element.AutomationId))
AccessibilityIdentifier = Element.AutomationId;
if (element != null)
element.SendViewInitialized(this);
}
public void SetElement(VisualElement element)
{
ScrollView oldElement = _view;
_view = (ScrollView)element;
if (oldElement != null)
{
oldElement.PropertyChanged -= HandlePropertyChanged;
((IScrollViewController)oldElement).ScrollToRequested -= OnScrollToRequested;
}
if (element != null)
{
OnElementChanged(new VisualElementChangedEventArgs(oldElement, element));
if (_container == null)
{
Tracker = new VisualElementTracker(this);
_container = new ScrollViewContainer(_view, Forms.Context);
}
_view.PropertyChanged += HandlePropertyChanged;
Controller.ScrollToRequested += OnScrollToRequested;
LoadContent();
UpdateBackgroundColor();
UpdateOrientation();
element.SendViewInitialized(this);
if (!string.IsNullOrEmpty(element.AutomationId))
ContentDescription = element.AutomationId;
}
}
public static IVisualElementRenderer CreateRenderer(VisualElement element)
{
if (element == null)
throw new ArgumentNullException("element");
IVisualElementRenderer renderer = Registrar.Registered.GetHandler<IVisualElementRenderer>(element.GetType()) ?? new DefaultRenderer();
renderer.SetElement(element);
return renderer;
}
public void InitializeConnectionUI(VisualElement _visElement, VisualElement _otherVisElement)
{
visElement = _visElement;
otherVisElement = _otherVisElement;
varPass = visElement.varPass;
beginTrans = visElement.transform;
endTrans = otherVisElement.transform;
}
private INavigationAware AsNavigationAware(VisualElement element)
{
var navigationAware = element.BindingContext as INavigationAware;
if (navigationAware == null)
{
navigationAware = element as INavigationAware;
}
return navigationAware;
}
protected virtual void OnChildRemoved(VisualElement view)
{
var viewRenderer = Platform.GetRenderer(view);
if (viewRenderer == null || viewRenderer.NativeView == null)
return;
viewRenderer.NativeView.RemoveFromSuperview();
if (Renderer.ViewController != null && viewRenderer.ViewController != null)
viewRenderer.ViewController.RemoveFromParentViewController();
}
public void SetElement(VisualElement element)
{
VisualElement oldElement = Element;
Element = element;
_containerMap = new Dictionary<Page, UIView>();
OnElementChanged(new VisualElementChangedEventArgs(oldElement, element));
if (element != null)
element.SendViewInitialized(NativeView);
}
public void SetElement(VisualElement element)
{
MasterDetailPage oldElement = _page;
_page = element as MasterDetailPage;
_detailLayout = new MasterDetailContainer(_page, false, Context) { LayoutParameters = new LayoutParams(ViewGroup.LayoutParams.WrapContent, ViewGroup.LayoutParams.WrapContent) };
_masterLayout = new MasterDetailContainer(_page, true, Context)
{
LayoutParameters = new LayoutParams(ViewGroup.LayoutParams.WrapContent, ViewGroup.LayoutParams.WrapContent) { Gravity = (int)GravityFlags.Start }
};
AddView(_detailLayout);
AddView(_masterLayout);
var activity = Context as Activity;
activity.ActionBar.SetDisplayShowHomeEnabled(true);
activity.ActionBar.SetHomeButtonEnabled(true);
UpdateBackgroundColor(_page);
UpdateBackgroundImage(_page);
OnElementChanged(oldElement, element);
if (oldElement != null)
((IMasterDetailPageController)oldElement).BackButtonPressed -= OnBackButtonPressed;
if (_page != null)
MasterDetailPageController.BackButtonPressed += OnBackButtonPressed;
if (Tracker == null)
Tracker = new VisualElementTracker(this);
_page.PropertyChanged += HandlePropertyChanged;
_page.Appearing += MasterDetailPageAppearing;
_page.Disappearing += MasterDetailPageDisappearing;
UpdateMaster();
UpdateDetail();
Device.Info.PropertyChanged += DeviceInfoPropertyChanged;
SetGestureState();
Presented = _page.IsPresented;
AddDrawerListener(this);
if (element != null)
element.SendViewInitialized(this);
if (element != null && !string.IsNullOrEmpty(element.AutomationId))
ContentDescription = element.AutomationId;
}
public void SetElement(VisualElement element)
{
var oldElement = Element;
Element = (NavigationPage)element;
OnElementChanged(new VisualElementChangedEventArgs(oldElement, element));
if (element != null)
element.SendViewInitialized(NativeView);
EffectUtilities.RegisterEffectControlProvider(this, oldElement, element);
}
public RendererPool(IVisualElementRenderer renderer, VisualElement oldElement)
{
if (renderer == null)
throw new ArgumentNullException("renderer");
if (oldElement == null)
throw new ArgumentNullException("oldElement");
_oldElement = oldElement;
_parent = renderer;
}
protected override void AddChildView(VisualElement childView)
{
_pageContainer = null;
Page page = childView as NavigationPage ?? (Page)(childView as TabbedPage);
if (page == null)
{
// The thing we're adding is not a NavigationPage or TabbedPage, so we can just use the old AddChildView
if (_currentFragment != null)
{
// But first, if the previous occupant of this container was a fragment, we need to remove it properly
FragmentTransaction transaction = FragmentManager.BeginTransaction();
transaction.DisallowAddToBackStack();
transaction.Remove(_currentFragment);
transaction.SetTransition((int)FragmentTransit.None);
transaction.Commit();
_currentFragment = null;
}
base.AddChildView(childView);
}
else
{
// The renderers for NavigationPage and TabbedPage both host fragments, so they need to be wrapped in a
// FragmentContainer in order to get isolated fragment management
Fragment fragment = FragmentContainer.CreateInstance(page);
var fc = fragment as FragmentContainer;
fc?.SetOnCreateCallback(pc =>
{
_pageContainer = pc;
SetDefaultBackgroundColor(pc.Child);
});
FragmentTransaction transaction = FragmentManager.BeginTransaction();
transaction.DisallowAddToBackStack();
if (_currentFragment != null)
{
transaction.Remove(_currentFragment);
}
transaction.Add(Id, fragment);
transaction.SetTransition((int)FragmentTransit.FragmentOpen);
transaction.Commit();
_currentFragment = fragment;
}
}
public void SetElement(VisualElement element)
{
if (element != null && !(element is TabbedPage))
throw new ArgumentException("Element must be a TabbedPage", "element");
TabbedPage oldElement = Element;
Element = (TabbedPage)element;
if (oldElement != null)
{
oldElement.PropertyChanged -= OnElementPropertyChanged;
((INotifyCollectionChanged)oldElement.Children).CollectionChanged -= OnPagesChanged;
}
if (element != null)
{
if (Control == null)
{
Control = new FormsPivot {
Style = (Windows.UI.Xaml.Style)Windows.UI.Xaml.Application.Current.Resources["TabbedPageStyle"]
};
Control.HeaderTemplate = (Windows.UI.Xaml.DataTemplate)Windows.UI.Xaml.Application.Current.Resources["TabbedPageHeader"];
Control.ItemTemplate = (Windows.UI.Xaml.DataTemplate)Windows.UI.Xaml.Application.Current.Resources["TabbedPage"];
Control.SelectionChanged += OnSelectionChanged;
Tracker = new BackgroundTracker<Pivot>(Windows.UI.Xaml.Controls.Control.BackgroundProperty) {
Element = (Page)element,
Control = Control,
Container = Control
};
Control.Loaded += OnLoaded;
Control.Unloaded += OnUnloaded;
}
Control.DataContext = Element;
OnPagesChanged(Element.Children, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
UpdateCurrentPage();
UpdateBarTextColor();
UpdateBarBackgroundColor();
((INotifyCollectionChanged)Element.Children).CollectionChanged += OnPagesChanged;
element.PropertyChanged += OnElementPropertyChanged;
if (!string.IsNullOrEmpty(element.AutomationId))
Control.SetValue(AutomationProperties.AutomationIdProperty, element.AutomationId);
}
OnElementChanged(new VisualElementChangedEventArgs(oldElement, element));
}
public void SetElement(VisualElement element)
{
if (element != null && !(element is TabbedPage))
throw new ArgumentException("Element must be a TabbedPage", "element");
var oldElement = Page;
Element = element;
if (oldElement != null)
{
oldElement.PropertyChanged -= OnElementPropertyChanged;
((INotifyCollectionChanged)oldElement.Children).CollectionChanged -= OnPagesChanged;
}
if (element != null)
{
if (_tracker == null)
{
_tabs = new TabsControl();
_canvas = new Canvas();
_canvas.ChildrenTransitions = new TransitionCollection
{
new EntranceThemeTransition()
};
Tracker = new BackgroundTracker<Canvas>(Panel.BackgroundProperty)
{
Element = (Page)element,
Control = _canvas,
Container = _canvas
};
_canvas.Loaded += OnLoaded;
_canvas.Unloaded += OnUnloaded;
}
_tabs.DataContext = element;
OnPagesChanged(Page.Children, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
UpdateCurrentPage();
UpdateBarTextColor();
UpdateBarBackgroundColor();
((INotifyCollectionChanged)Page.Children).CollectionChanged += OnPagesChanged;
element.PropertyChanged += OnElementPropertyChanged;
}
OnElementChanged(new VisualElementChangedEventArgs(oldElement, element));
}
public MultiBindingHack (VisualElement element)
{
LabelWithBounds = string.Format("{{X={0:0.00} Y={1:0.00} Width={2:0.00} Height={3:0.00}}}", element.X, element.Y, element.Width, element.Height);
element.PropertyChanged += (sender, args) => {
if (args.PropertyName == "X" ||
args.PropertyName == "Y" ||
args.PropertyName == "Width" ||
args.PropertyName == "Height" ||
args.PropertyName == "Rotation") {
LabelWithBounds = string.Format("{{X={0:0.00} Y={1:0.00} Width={2:0.00} Height={3:0.00}}}", element.X, element.Y, element.Width, element.Height); // super hack
}
};
}
public void SetCurrentElement(VisualElement element)
{
DataContext = element;
element.BatchCommitted += (ss,ee)=>
{
this.Height = ee.Data.Height;
this.Width = ee.Data.Width;
};
this.Loaded += (ss, ee) => ((TabbedPage)element).SendAppearing();
this.Unloaded += (ss, ee) => ((TabbedPage)element).SendDisappearing();
}
protected virtual void AddChildView(VisualElement childView)
{
IVisualElementRenderer renderer = Platform.GetRenderer(childView);
if (renderer == null)
Platform.SetRenderer(childView, renderer = Platform.CreateRenderer(childView));
if (renderer.ViewGroup.Parent != this)
{
if (renderer.ViewGroup.Parent != null)
renderer.ViewGroup.RemoveFromParent();
SetDefaultBackgroundColor(renderer);
AddView(renderer.ViewGroup);
renderer.UpdateLayout();
}
}
public void SetElement(VisualElement element)
{
TabbedPage oldElement = _page;
_page = (TabbedPage)element;
_tracker = new BackgroundTracker<Control>(BackgroundProperty) { Model = _page, Element = this };
DataContext = element;
_page.PropertyChanged += OnPropertyChanged;
Loaded += (sender, args) => ((IPageController)_page).SendAppearing();
Unloaded += (sender, args) => ((IPageController)_page).SendDisappearing();
OnElementChanged(new VisualElementChangedEventArgs(_page, element));
}
public IVisualElementRenderer GetFreeRenderer(VisualElement view)
{
if (view == null)
throw new ArgumentNullException("view");
var rendererType = Registrar.Registered.GetHandlerType(view.GetType()) ?? typeof(ViewRenderer);
Stack<IVisualElementRenderer> renderers;
if (!_freeRenderers.TryGetValue(rendererType, out renderers) || renderers.Count == 0)
return null;
var renderer = renderers.Pop();
renderer.SetElement(view);
return renderer;
}
protected virtual void OnChildAdded(VisualElement view)
{
if (_isDisposed)
return;
var viewRenderer = Platform.CreateRenderer(view);
Platform.SetRenderer(view, viewRenderer);
var uiview = Renderer.NativeView;
uiview.AddSubview(viewRenderer.NativeView);
if (Renderer.ViewController != null && viewRenderer.ViewController != null)
Renderer.ViewController.AddChildViewController(viewRenderer.ViewController);
EnsureChildrenOrder();
}
public void SetElement(VisualElement element)
{
VisualElement oldElement = Element;
Element = element;
UpdateTitle();
OnElementChanged(new VisualElementChangedEventArgs(oldElement, element));
if (Element != null && !string.IsNullOrEmpty(Element.AutomationId))
SetAutomationId(Element.AutomationId);
if (element != null)
element.SendViewInitialized(NativeView);
EffectUtilities.RegisterEffectControlProvider(this, oldElement, element);
}
public void SetElement(VisualElement element)
{
var newPage = element as CarouselPage;
if (element != null && newPage == null)
throw new ArgumentException("element must be a CarouselPage");
CarouselPage oldPage = Element;
Element = newPage;
if (oldPage != null)
{
((IPageController)oldPage).SendDisappearing();
((INotifyCollectionChanged)oldPage.Children).CollectionChanged -= OnChildrenChanged;
oldPage.PropertyChanged -= OnElementPropertyChanged;
}
if (newPage != null)
{
if (_tracker == null)
{
_tracker = new BackgroundTracker<FlipView>(BackgroundProperty) { Control = this };
}
_tracker.Element = newPage;
// Adding Items triggers the SelectionChanged event,
// which will reset the CurrentPage unless we tell it to ignore.
_fromUpdate = true;
for (var i = 0; i < newPage.Children.Count; i++)
Items.Add(newPage.Children[i]);
_fromUpdate = false;
((INotifyCollectionChanged)newPage.Children).CollectionChanged += OnChildrenChanged;
newPage.PropertyChanged += OnElementPropertyChanged;
UpdateCurrentPage();
((IPageController)newPage).SendAppearing();
}
OnElementChanged(new ElementChangedEventArgs<CarouselPage>(oldPage, newPage));
if (!string.IsNullOrEmpty(Element?.AutomationId))
SetValue(AutomationProperties.AutomationIdProperty, Element.AutomationId);
}
public SizeRequest GetNativeSize (VisualElement view, double widthConstraint, double heightConstraint)
{
if (getNativeSizeFunc != null)
return getNativeSizeFunc (view, widthConstraint, heightConstraint);
// EVERYTHING IS 100 x 20
var label = view as Label;
if (label != null && useRealisticLabelMeasure) {
var letterSize = new Size (5, 10);
var w = label.Text.Length * letterSize.Width;
var h = letterSize.Height;
if (!double.IsPositiveInfinity (widthConstraint) && w > widthConstraint) {
h = ((int) w / (int) widthConstraint) * letterSize.Height;
w = widthConstraint - (widthConstraint % letterSize.Width);
}
return new SizeRequest (new Size (w, h), new Size (Math.Min (10, w), h));
}
return new SizeRequest(new Size (100, 20));
}
public void SetElement(VisualElement element)
{
var oldElement = Element;
Element = element;
Element.SizeChanged += PageOnSizeChanged;
_masterController = new ChildViewController();
_detailController = new ChildViewController();
_clickOffView = new UIView();
_clickOffView.BackgroundColor = new Color(0, 0, 0, 0).ToUIColor();
Presented = ((MasterDetailPage)Element).IsPresented;
OnElementChanged(new VisualElementChangedEventArgs(oldElement, element));
EffectUtilities.RegisterEffectControlProvider(this, oldElement, element);
if (element != null)
element.SendViewInitialized(NativeView);
}
void AddChild(VisualElement view, IVisualElementRenderer oldRenderer = null, RendererPool pool = null, bool sameChildren = false)
{
Performance.Start();
if (_childViews == null)
_childViews = new List<IVisualElementRenderer>();
IVisualElementRenderer renderer = oldRenderer;
if (pool != null)
renderer = pool.GetFreeRenderer(view);
if (renderer == null)
{
Performance.Start("New renderer");
renderer = Platform.CreateRenderer(view);
Performance.Stop("New renderer");
}
if (renderer == oldRenderer)
{
Platform.SetRenderer(renderer.Element, null);
renderer.SetElement(view);
}
Performance.Start("Set renderer");
Platform.SetRenderer(view, renderer);
Performance.Stop("Set renderer");
Performance.Start("Add view");
if (!sameChildren)
{
_renderer.ViewGroup.AddView(renderer.ViewGroup);
_childViews.Add(renderer);
}
Performance.Stop("Add view");
Performance.Stop();
}
public void SetElement(VisualElement element)
{
var oldElement = Element;
Element = element;
FinishedCustomizingViewControllers += HandleFinishedCustomizingViewControllers;
Tabbed.PropertyChanged += OnPropertyChanged;
Tabbed.PagesChanged += OnPagesChanged;
OnElementChanged(new VisualElementChangedEventArgs(oldElement, element));
OnPagesChanged(null, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
if (element != null)
element.SendViewInitialized(NativeView);
//disable edit/reorder of tabs
CustomizableViewControllers = null;
UpdateBarBackgroundColor();
UpdateBarTextColor();
EffectUtilities.RegisterEffectControlProvider(this, oldElement, element);
}
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 = Resources.Load <StyleSheet>("Styles/Noise");
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 Settings",
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 To Texture"
};
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;
}
protected virtual void HandleFormsElementMeasureInvalidated(VisualElement formsElement)
{
RemeasureLayout(formsElement);
}
public virtual (bool, VisualElement) CreateUI(SerializedObject so, SerializedProperty property, VisualElement preElement)
{
return(false, null);
}
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 = "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 = "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 static object FindByNameMemberImpl(IBindingMemberInfo bindingMemberInfo, VisualElement target, object[] arg3)
{
var name = (string)arg3[0];
return(target.FindByName <object>(name));
}
public static void BuildInspectorPropertiesElement(string elementPath, IEditorContainer editor, System.Collections.Generic.HashSet <System.Type> usedComponents, SerializedProperty obj, UnityEngine.UIElements.VisualElement container, bool noFields, System.Action <int, PropertyField> onBuild = null)
{
obj = obj.Copy();
container.Clear();
var source = obj.Copy();
SerializedProperty iterator = obj;
if (iterator.NextVisible(true) == false)
{
return;
}
if (iterator.NextVisible(true) == false)
{
return;
}
var depth = iterator.depth;
var i = 0;
var iteratorNext = iterator.Copy();
do
{
if (string.IsNullOrEmpty(elementPath) == false)
{
iterator = iteratorNext.FindPropertyRelative(elementPath);
}
else
{
iterator = iteratorNext;
}
if (iterator.propertyType != SerializedPropertyType.ManagedReference)
{
continue;
}
var element = new VisualElement();
element.AddToClassList("element");
var itCopy = iterator.Copy();
GetTypeFromManagedReferenceFullTypeName(iterator.managedReferenceFullTypename, out var type);
element.AddToClassList(i % 2 == 0 ? "even" : "odd");
element.RegisterCallback <UnityEngine.UIElements.ContextClickEvent, int>((evt, idx) => {
var menu = new GenericMenu();
if (usedComponents != null)
{
menu.AddItem(new GUIContent("Delete"), false, () => {
RemoveComponent((DataConfigEditor)editor, usedComponents, source, type, noFields);
editor.Save();
BuildInspectorProperties(editor, usedComponents, source, container, noFields);
});
menu.AddItem(new GUIContent("Copy JSON"), false, () => {
var instance = itCopy.GetValue();
var json = JsonUtility.ToJson(instance, true);
EditorGUIUtility.systemCopyBuffer = json;
});
}
editor.OnComponentMenu(menu, idx);
menu.ShowAsContext();
}, i);
if (type != null && usedComponents?.Contains(type) == false)
{
usedComponents?.Add(type);
}
if (type == null)
{
var label = new UnityEngine.UIElements.Label("MISSING: " + iterator.managedReferenceFullTypename);
element.name = "missing";
label.AddToClassList("inner-element");
label.AddToClassList("missing-label");
element.Add(label);
}
else if (iterator.hasVisibleChildren == false || noFields == true)
{
var horizontal = new UnityEngine.UIElements.VisualElement();
horizontal.AddToClassList("inner-element");
horizontal.AddToClassList("no-fields-container");
element.name = type.Name;
var toggle = new UnityEngine.UIElements.Toggle();
toggle.AddToClassList("no-fields-toggle");
toggle.SetEnabled(false);
toggle.SetValueWithoutNotify(true);
horizontal.Add(toggle);
var label = new UnityEngine.UIElements.Label(GUILayoutExt.GetStringCamelCaseSpace(type.Name));
label.AddToClassList("no-fields-label");
horizontal.Add(label);
element.Add(horizontal);
}
else
{
var label = GUILayoutExt.GetStringCamelCaseSpace(type.Name);
if (iterator.hasVisibleChildren == true)
{
var childs = iterator.Copy();
//var height = EditorUtilities.GetPropertyHeight(childs, true, new GUIContent(label));
var cnt = EditorUtilities.GetPropertyChildCount(childs);
if (cnt == 1 /*&& height <= 22f*/)
{
iterator.NextVisible(true);
}
}
var propertyField = new PropertyField(iterator.Copy(), label);
propertyField.BindProperty(iterator);
onBuild?.Invoke(i, propertyField);
propertyField.AddToClassList("property-field");
propertyField.AddToClassList("inner-element");
element.name = type.Name;
element.Add(propertyField);
}
if (type != null)
{
var helps = type.GetCustomAttributes(typeof(ComponentHelpAttribute), false);
if (helps.Length > 0)
{
var label = new UnityEngine.UIElements.Label(((ComponentHelpAttribute)helps[0]).comment);
label.AddToClassList("comment");
element.Add(label);
}
if (typeof(IComponentStatic).IsAssignableFrom(type) == true)
{
var label = new UnityEngine.UIElements.Label("Static");
label.AddToClassList("static-component");
element.AddToClassList("has-static-component");
element.Add(label);
}
if (typeof(IComponentShared).IsAssignableFrom(type) == true)
{
var label = new UnityEngine.UIElements.Label("Shared");
label.AddToClassList("shared-component");
element.AddToClassList("has-shared-component");
element.Add(label);
}
}
container.Add(element);
++i;
} while (iteratorNext.NextVisible(false) == true && depth <= iteratorNext.depth);
}
void SetElement(VisualElement oldElement, VisualElement newElement)
{
if (oldElement != null)
{
oldElement.BatchCommitted -= _batchCommittedHandler;
oldElement.PropertyChanged -= _propertyChangedHandler;
_context = null;
}
_element = newElement;
if (newElement != null)
{
newElement.BatchCommitted += _batchCommittedHandler;
newElement.PropertyChanged += _propertyChangedHandler;
_context = _renderer.View.Context;
if (oldElement != null)
{
AView view = _renderer.View;
// ReSharper disable CompareOfFloatsByEqualityOperator
if (oldElement.AnchorX != newElement.AnchorX)
{
UpdateAnchorX();
}
if (oldElement.AnchorY != newElement.AnchorY)
{
UpdateAnchorY();
}
if (oldElement.IsVisible != newElement.IsVisible)
{
UpdateIsVisible();
}
if (oldElement.IsEnabled != newElement.IsEnabled)
{
view.Enabled = newElement.IsEnabled;
}
if (oldElement.Opacity != newElement.Opacity)
{
UpdateOpacity();
}
if (oldElement.Rotation != newElement.Rotation)
{
UpdateRotation();
}
if (oldElement.RotationX != newElement.RotationX)
{
UpdateRotationX();
}
if (oldElement.RotationY != newElement.RotationY)
{
UpdateRotationY();
}
if (oldElement.Scale != newElement.Scale || oldElement.ScaleX != newElement.ScaleX || oldElement.ScaleY != newElement.ScaleY)
{
UpdateScale();
}
// ReSharper restore CompareOfFloatsByEqualityOperator
_initialUpdateNeeded = false;
}
}
}
public void CreateGUI()
{
m_SerializedObject = new SerializedObject(this);
converterEditorAsset.CloneTree(rootVisualElement);
// This is temp now to get the information filled in
RenderPipelineConverterContainer converterContainer =
(RenderPipelineConverterContainer)Activator.CreateInstance(m_ConverterContainers[0]);
rootVisualElement.Q<Label>("conversionName").text = converterContainer.name;
rootVisualElement.Q<TextElement>("conversionInfo").text = converterContainer.info;
rootVisualElement.Q<Image>("converterContainerHelpIcon").image = CoreEditorStyles.iconHelp;
// Getting the scrollview where the converters should be added
m_ScrollView = rootVisualElement.Q<ScrollView>("convertersScrollView");
for (int i = 0; i < m_CoreConvertersList.Count; ++i)
{
// Making an item using the converterListAsset as a template.
// Then adding the information needed for each converter
VisualElement item = new VisualElement();
converterListAsset.CloneTree(item);
var conv = m_CoreConvertersList[i];
item.SetEnabled(conv.IsEnabled);
item.Q<Label>("converterName").text = conv.name;
item.Q<Label>("converterInfo").text = conv.info;
item.Q<VisualElement>("converterTopVisualElement").tooltip = conv.info;
// setup the images
item.Q<Image>("pendingImage").image = CoreEditorStyles.iconPending;
item.Q<Image>("pendingImage").tooltip = "Pending";
var pendingLabel = item.Q<Label>("pendingLabel");
item.Q<Image>("warningImage").image = CoreEditorStyles.iconWarn;
item.Q<Image>("warningImage").tooltip = "Warnings";
var warningLabel = item.Q<Label>("warningLabel");
item.Q<Image>("errorImage").image = CoreEditorStyles.iconFail;
item.Q<Image>("errorImage").tooltip = "Failed";
var errorLabel = item.Q<Label>("errorLabel");
item.Q<Image>("successImage").image = CoreEditorStyles.iconSuccess;
item.Q<Image>("successImage").tooltip = "Success";
var successLabel = item.Q<Label>("successLabel");
var converterEnabledToggle = item.Q<Toggle>("converterEnabled");
converterEnabledToggle.bindingPath =
$"{nameof(m_ConverterStates)}.Array.data[{i}].{nameof(ConverterState.isActive)}";
pendingLabel.bindingPath =
$"{nameof(m_ConverterStates)}.Array.data[{i}].{nameof(ConverterState.pending)}";
warningLabel.bindingPath =
$"{nameof(m_ConverterStates)}.Array.data[{i}].{nameof(ConverterState.warnings)}";
errorLabel.bindingPath =
$"{nameof(m_ConverterStates)}.Array.data[{i}].{nameof(ConverterState.errors)}";
successLabel.bindingPath =
$"{nameof(m_ConverterStates)}.Array.data[{i}].{nameof(ConverterState.success)}";
VisualElement child = item;
ListView listView = child.Q<ListView>("converterItems");
listView.showBoundCollectionSize = false;
listView.bindingPath = $"{nameof(m_ConverterStates)}.Array.data[{i}].{nameof(ConverterState.items)}";
int id = i;
listView.makeItem = () =>
{
var convertItem = converterItem.CloneTree();
// Adding the contextual menu for each item
convertItem.AddManipulator(new ContextualMenuManipulator(evt => AddToContextMenu(evt, id)));
return convertItem;
};
listView.bindItem = (element, index) =>
{
m_SerializedObject.Update();
var property = m_SerializedObject.FindProperty($"{listView.bindingPath}.Array.data[{index}]");
// ListView doesn't bind the child elements for us properly, so we do that for it
// In the UXML our root is a BindableElement, as we can't bind otherwise.
var bindable = (BindableElement)element;
bindable.BindProperty(property);
// Adding index here to userData so it can be retrieved later
element.userData = index;
Status status = (Status)property.FindPropertyRelative("status").enumValueIndex;
string info = property.FindPropertyRelative("message").stringValue;
// Update the amount of things to convert
child.Q<Label>("converterStats").text = $"{m_ItemsToConvert[id].Count} items";
ConverterItemDescriptor convItemDesc = m_ItemsToConvert[id][index];
element.Q<Label>("converterItemName").text = convItemDesc.name;
element.Q<Label>("converterItemPath").text = convItemDesc.info;
element.Q<Image>("converterItemHelpIcon").image = CoreEditorStyles.iconHelp;
element.Q<Image>("converterItemHelpIcon").tooltip = convItemDesc.helpLink;
// Changing the icon here depending on the status.
Texture2D icon = null;
switch (status)
{
case Status.Pending:
icon = CoreEditorStyles.iconPending;
break;
case Status.Error:
icon = CoreEditorStyles.iconFail;
break;
case Status.Warning:
icon = CoreEditorStyles.iconWarn;
break;
case Status.Success:
icon = CoreEditorStyles.iconSuccess;
break;
}
element.Q<Image>("converterItemStatusIcon").image = icon;
element.Q<Image>("converterItemStatusIcon").tooltip = info;
};
listView.onSelectionChange += obj => { m_CoreConvertersList[id].OnClicked(listView.selectedIndex); };
listView.unbindItem = (element, index) =>
{
var bindable = (BindableElement)element;
bindable.Unbind();
};
m_ScrollView.Add(item);
}
rootVisualElement.Bind(m_SerializedObject);
var button = rootVisualElement.Q<Button>("convertButton");
button.RegisterCallback<ClickEvent>(Convert);
button.SetEnabled(false);
var initButton = rootVisualElement.Q<Button>("initializeButton");
initButton.RegisterCallback<ClickEvent>(InitializeAllActiveConverters);
}
public VFXBlackboard(VFXView view)
{
m_View = view;
editTextRequested = OnEditName;
addItemRequested = OnAddItem;
this.scrollable = true;
SetPosition(BoardPreferenceHelper.LoadPosition(BoardPreferenceHelper.Board.blackboard, defaultRect));
m_DefaultCategory = new VFXBlackboardCategory()
{
title = "parameters"
};
Add(m_DefaultCategory);
m_DefaultCategory.headerVisible = false;
styleSheets.Add(VFXView.LoadStyleSheet("VFXBlackboard"));
RegisterCallback <MouseDownEvent>(OnMouseClick, TrickleDown.TrickleDown);
RegisterCallback <DragUpdatedEvent>(OnDragUpdatedEvent);
RegisterCallback <DragPerformEvent>(OnDragPerformEvent);
RegisterCallback <DragLeaveEvent>(OnDragLeaveEvent);
RegisterCallback <KeyDownEvent>(OnKeyDown);
focusable = true;
m_AddButton = this.Q <Button>(name: "addButton");
m_DragIndicator = new VisualElement();
m_DragIndicator.name = "dragIndicator";
m_DragIndicator.style.position = PositionType.Absolute;
hierarchy.Add(m_DragIndicator);
SetDragIndicatorVisible(false);
Resizer resizer = this.Query <Resizer>();
hierarchy.Add(new UnityEditor.Experimental.GraphView.ResizableElement());
style.position = PositionType.Absolute;
m_PathLabel = hierarchy.ElementAt(0).Q <Label>("subTitleLabel");
m_PathLabel.RegisterCallback <MouseDownEvent>(OnMouseDownSubTitle);
m_PathTextField = new TextField {
visible = false
};
m_PathTextField.Q(TextField.textInputUssName).RegisterCallback <FocusOutEvent>(e => { OnEditPathTextFinished(); });
m_PathTextField.Q(TextField.textInputUssName).RegisterCallback <KeyDownEvent>(OnPathTextFieldKeyPressed);
hierarchy.Add(m_PathTextField);
resizer.RemoveFromHierarchy();
if (s_LayoutManual != null)
{
s_LayoutManual.SetValue(this, false);
}
m_LockedElement = new Label("Asset is locked");
m_LockedElement.style.color = Color.white * 0.75f;
m_LockedElement.style.position = PositionType.Absolute;
m_LockedElement.style.left = 0f;
m_LockedElement.style.right = new StyleLength(0f);
m_LockedElement.style.top = new StyleLength(0f);
m_LockedElement.style.bottom = new StyleLength(0f);
m_LockedElement.style.unityTextAlign = TextAnchor.MiddleCenter;
var fontSize = 54f;
m_LockedElement.style.fontSize = new StyleLength(fontSize);
m_LockedElement.style.paddingBottom = fontSize / 2f;
m_LockedElement.style.paddingTop = fontSize / 2f;
m_LockedElement.style.display = DisplayStyle.None;
m_LockedElement.focusable = true;
m_LockedElement.RegisterCallback <KeyDownEvent>(e => e.StopPropagation());
Add(m_LockedElement);
m_AddButton.SetEnabled(false);
this.AddManipulator(new ContextualMenuManipulator(BuildContextualMenu));
}
public void ChangeDocumentTheme(VisualElement documentElement, CanvasTheme canvasTheme)
{
m_CurrentCanvasTheme = canvasTheme;
RefreshStyle(documentElement);
}
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);
previewManager.onPrimaryMasterChanged = OnPrimaryMasterChanged;
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;
CreateMasterPreview();
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 bool SaveNewDocument(string uxmlPath, string ussPath, VisualElement documentRootElement, bool isSaveAs)
{
if (!isSaveAs)
{
var ussInstanceId = mainStyleSheet.GetInstanceID().ToString();
m_VisualTreeAsset.FixStyleSheetPaths(ussInstanceId, ussPath);
// Fix old paths if the uss filename/path has since been changed.
m_VisualTreeAsset.ReplaceStyleSheetPaths(ussOldPath, ussPath);
#if UNITY_2019_3_OR_NEWER
AddStyleSheetToAllRootElements(ussPath);
#endif
}
else
{
visualTreeAsset.ReplaceStyleSheetPaths(ussOldPath, ussPath);
}
var tempVisualTreeAsset = m_VisualTreeAsset.DeepCopy();
var tempMainStyleSheet = m_MainStyleSheet.DeepCopy();
WriteToFiles(uxmlPath, ussPath);
AssetDatabase.Refresh();
var loadedVisualTreeAsset = AssetDatabase.LoadAssetAtPath <VisualTreeAsset>(uxmlPath);
var loadedStyleSheet = AssetDatabase.LoadAssetAtPath <StyleSheet>(ussPath);
bool needFullRefresh =
loadedVisualTreeAsset != m_VisualTreeAsset ||
loadedStyleSheet != m_MainStyleSheet;
if (needFullRefresh)
{
NewDocument(documentRootElement);
// Re-init setting.
if (m_Settings != null)
{
m_Settings.UxmlGuid = AssetDatabase.AssetPathToGUID(uxmlPath);
m_Settings.UxmlPath = uxmlPath;
SaveSettingsToDisk();
}
}
else
{
m_VisualTreeAsset.ClearUndo();
m_MainStyleSheet.ClearUndo();
ClearBackups();
}
// Recreate backups.
m_VisualTreeAssetBackup = loadedVisualTreeAsset.DeepCopy();
m_MainStyleSheetBackup = loadedStyleSheet.DeepCopy();
// To get all the selection markers into the new assets.
tempVisualTreeAsset.DeepOverwrite(loadedVisualTreeAsset);
tempMainStyleSheet.DeepOverwrite(loadedStyleSheet);
// Destroy temps.
tempVisualTreeAsset.Destroy();
tempMainStyleSheet.Destroy();
m_VisualTreeAsset = loadedVisualTreeAsset;
m_MainStyleSheet = loadedStyleSheet;
// Reset asset name.
m_VisualTreeAsset.name = Path.GetFileNameWithoutExtension(uxmlPath);
m_VisualTreeAsset.ConvertAllAssetReferencesToPaths();
m_OpenendMainStyleSheetOldPath = ussPath;
hasUnsavedChanges = false;
SaveToDisk();
return(needFullRefresh);
}
protected virtual void AddChildView(VisualElement childView)
{
_pageContainer = null;
Page page = childView as NavigationPage ?? (Page)(childView as TabbedPage);
if (page == null)
{
// The thing we're adding is not a NavigationPage or TabbedPage, so we can just use the old AddChildView
if (_currentFragment != null)
{
if (!_parent.IsAttachedToRoot())
{
return;
}
// But first, if the previous occupant of this container was a fragment, we need to remove it properly
FragmentTransaction transaction = FragmentManager.BeginTransactionEx();
transaction.RemoveEx(_currentFragment);
transaction.SetTransitionEx((int)FragmentTransit.None);
if (IsAttachedToWindow)
{
ExecuteTransaction(transaction);
}
else
{
_transaction = transaction;
}
_currentFragment = null;
}
IVisualElementRenderer renderer = Platform.GetRenderer(childView);
if (renderer == null)
{
Platform.SetRenderer(childView, renderer = Platform.CreateRenderer(childView, Context));
}
if (renderer.View.Parent != this)
{
if (renderer.View.Parent != null)
{
renderer.View.RemoveFromParent();
}
SetDefaultBackgroundColor(renderer);
AddView(renderer.View);
renderer.UpdateLayout();
}
}
else
{
if (!_parent.IsAttachedToRoot())
{
return;
}
// The renderers for NavigationPage and TabbedPage both host fragments, so they need to be wrapped in a
// FragmentContainer in order to get isolated fragment management
Fragment fragment = FragmentContainer.CreateInstance(page);
var fc = fragment as FragmentContainer;
fc?.SetOnCreateCallback(pc =>
{
_pageContainer = pc;
UpdateFlowDirection();
SetDefaultBackgroundColor(pc.Child);
});
FragmentTransaction transaction = FragmentManager.BeginTransactionEx();
if (_currentFragment != null)
{
transaction.RemoveEx(_currentFragment);
}
transaction.AddEx(Id, fragment);
transaction.SetTransitionEx((int)FragmentTransit.None);
if (IsAttachedToWindow)
{
ExecuteTransaction(transaction);
}
else
{
_transaction = transaction;
}
_currentFragment = fragment;
}
}
private void Draw(CustomFunctionNode node)
{
var currentControls = this.Children().ToArray();
for (int i = 0; i < currentControls.Length; i++)
{
currentControls[i].RemoveFromHierarchy();
}
m_Type = new EnumField(node.sourceType);
m_Type.RegisterValueChangedCallback(s =>
{
if ((HlslSourceType)s.newValue != node.sourceType)
{
node.owner.owner.RegisterCompleteObjectUndo("Change Function Type");
node.sourceType = (HlslSourceType)s.newValue;
Draw(node);
node.Dirty(ModificationScope.Graph);
}
});
m_FunctionName = new TextField {
value = node.functionName, multiline = false
};
m_FunctionName.RegisterCallback <FocusInEvent>(s =>
{
if (m_FunctionName.value == CustomFunctionNode.defaultFunctionName)
{
m_FunctionName.value = "";
}
});
m_FunctionName.RegisterCallback <FocusOutEvent>(s =>
{
if (m_FunctionName.value == "")
{
m_FunctionName.value = CustomFunctionNode.defaultFunctionName;
}
if (m_FunctionName.value != node.functionName)
{
node.owner.owner.RegisterCompleteObjectUndo("Change Function Name");
node.functionName = m_FunctionName.value;
node.Dirty(ModificationScope.Graph);
}
});
m_FunctionSource = new TextField {
value = node.functionSource, multiline = false
};
m_FunctionSource.RegisterCallback <FocusInEvent>(s =>
{
if (m_FunctionSource.value == CustomFunctionNode.defaultFunctionSource)
{
m_FunctionSource.value = "";
}
});
m_FunctionSource.RegisterCallback <FocusOutEvent>(s =>
{
if (m_FunctionSource.value == "")
{
m_FunctionSource.value = CustomFunctionNode.defaultFunctionSource;
}
if (m_FunctionSource.value != node.functionSource)
{
node.owner.owner.RegisterCompleteObjectUndo("Change Function Source");
node.functionSource = m_FunctionSource.value;
node.Dirty(ModificationScope.Graph);
}
});
m_FunctionBody = new TextField {
value = node.functionBody, multiline = true
};
m_FunctionBody.RegisterCallback <FocusInEvent>(s =>
{
if (m_FunctionBody.value == CustomFunctionNode.defaultFunctionBody)
{
m_FunctionBody.value = "";
}
});
m_FunctionBody.RegisterCallback <FocusOutEvent>(s =>
{
if (m_FunctionBody.value == "")
{
m_FunctionBody.value = CustomFunctionNode.defaultFunctionBody;
}
if (m_FunctionBody.value != node.functionBody)
{
node.owner.owner.RegisterCompleteObjectUndo("Change Function Body");
node.functionBody = m_FunctionBody.value;
node.Dirty(ModificationScope.Graph);
}
});
VisualElement typeRow = new VisualElement()
{
name = "Row"
};
{
typeRow.Add(new Label("Type"));
typeRow.Add(m_Type);
}
Add(typeRow);
VisualElement nameRow = new VisualElement()
{
name = "Row"
};
{
nameRow.Add(new Label("Name"));
nameRow.Add(m_FunctionName);
}
Add(nameRow);
switch (node.sourceType)
{
case HlslSourceType.File:
VisualElement sourceRow = new VisualElement()
{
name = "Row"
};
{
sourceRow.Add(new Label("Source"));
sourceRow.Add(m_FunctionSource);
}
Add(sourceRow);
break;
case HlslSourceType.String:
VisualElement bodyRow = new VisualElement()
{
name = "Row"
};
{
bodyRow.Add(new Label("Body"));
bodyRow.style.height = 200;
bodyRow.Add(m_FunctionBody);
}
Add(bodyRow);
break;
}
}
public void OnEnable()
{
var root = rootVisualElement;
var styleSheet = EditorGUIUtility.Load(s_StyleSheetPath) as StyleSheet;
root.styleSheets.Add(styleSheet);
var themedStyleSheet = EditorGUIUtility.isProSkin
? EditorGUIUtility.Load(s_DarkStyleSheetPath) as StyleSheet
: EditorGUIUtility.Load(s_LightStyleSheetPath) as StyleSheet;
root.styleSheets.Add(themedStyleSheet);
SampleTreeItem.ResetNextId();
var items = new List <ITreeViewItem>()
{
new SampleTreeItem("Styles", StylesExplorer.Create),
new SampleTreeItem("Button", ButtonSnippet.Create),
new SampleTreeItem("Scroller", ScrollerSnippet.Create),
new SampleTreeItem("Toggle", ToggleSnippet.Create),
new SampleTreeItem("Label", LabelSnippet.Create),
new SampleTreeItem("Text Field", TextFieldSnippet.Create),
new SampleTreeItem("HelpBox", HelpBoxSnippet.Create),
new SampleTreeItem("Object Field", ObjectFieldSnippet.Create),
new SampleTreeItem("List View", ListViewSnippet.Create),
new SampleTreeItem("Numeric Fields", MakeNumericFieldsPanel, new List <TreeViewItem <string> >()
{
new SampleTreeItem("Integer", IntegerFieldSnippet.Create),
new SampleTreeItem("Float", FloatFieldSnippet.Create),
new SampleTreeItem("Long", LongFieldSnippet.Create),
new SampleTreeItem("MinMaxSlider", MinMaxSliderSnippet.Create),
new SampleTreeItem("Slider", SliderSnippet.Create),
new SampleTreeItem("Vector2", Vector2FieldSnippet.Create),
new SampleTreeItem("Vector3", Vector3FieldSnippet.Create),
new SampleTreeItem("Vector4", Vector4FieldSnippet.Create),
new SampleTreeItem("Rect", RectFieldSnippet.Create),
new SampleTreeItem("Bounds", BoundsFieldSnippet.Create),
new SampleTreeItem("SliderInt", SliderIntSnippet.Create),
new SampleTreeItem("Vector2Int", Vector2IntFieldSnippet.Create),
new SampleTreeItem("Vector3Int", Vector3IntFieldSnippet.Create),
new SampleTreeItem("RectInt", RectIntFieldSnippet.Create),
new SampleTreeItem("BoundsInt", BoundsIntFieldSnippet.Create)
}),
new SampleTreeItem("Value Fields", MakeValueFieldsPanel, new List <TreeViewItem <string> >()
{
new SampleTreeItem("Color", ColorFieldSnippet.Create),
new SampleTreeItem("Curve", CurveFieldSnippet.Create),
new SampleTreeItem("Gradient", GradientFieldSnippet.Create)
}),
new SampleTreeItem("Choice Fields", MakeChoiceFieldsPanel, new List <TreeViewItem <string> >()
{
new SampleTreeItem("Enum", EnumFieldSnippet.Create),
new SampleTreeItem("EnumFlags", EnumFlagsFieldSnippet.Create),
new SampleTreeItem("Popup", PopupFieldSnippet.Create),
new SampleTreeItem("Tag", TagFieldSnippet.Create),
new SampleTreeItem("Mask", MaskFieldSnippet.Create),
new SampleTreeItem("Layer", LayerFieldSnippet.Create),
new SampleTreeItem("LayerMask", LayerMaskFieldSnippet.Create)
}),
};
Func <VisualElement> makeItem = () =>
{
var box = new VisualElement();
box.AddToClassList(k_TreeItemClassName);
var label = new Label();
label.AddToClassList(k_TreeItemLabelClassName);
box.Add(label);
return(box);
};
Action <VisualElement, ITreeViewItem> bindItem = (element, item) =>
{
(element.ElementAt(0) as Label).text = (item as SampleTreeItem).data;
element.userData = item;
};
Action <IEnumerable <ITreeViewItem> > onSelectionChanged = selectedItems =>
{
var item = (SampleTreeItem)selectedItems.FirstOrDefault();
if (item == null)
{
return;
}
m_ContentPanel.Clear();
m_ContentPanel.Add(item.makeItem(item));
};
var treeView = new TreeView()
{
name = k_TreeViewName
};
treeView.AddToClassList(k_TreeViewClassName);
m_ContentPanel = new VisualElement()
{
name = k_ContentPanelName
};
m_ContentPanel.AddToClassList(k_ContentPanelClassName);
var splitter = new DebuggerSplitter();
splitter.AddToClassList(k_SplitterClassName);
splitter.leftPane.style.width = k_SplitterLeftPaneStartingWidth;
root.Add(splitter);
splitter.leftPane.Add(treeView);
splitter.rightPane.Add(m_ContentPanel);
treeView.viewDataKey = "samples-tree";
treeView.itemHeight = 20;
treeView.rootItems = items;
treeView.makeItem = makeItem;
treeView.bindItem = bindItem;
treeView.onSelectionChange += onSelectionChanged;
treeView.Refresh();
// Force TreeView to call onSelectionChanged when it restores its own selection from view data.
treeView.schedule.Execute(() =>
{
onSelectionChanged(treeView.selectedItems);
}).StartingIn(k_TreeViewSelectionRestoreDelay);
// Force TreeView to select something if nothing is selected.
treeView.schedule.Execute(() =>
{
if (treeView.selectedItems.Count() > 0)
{
return;
}
treeView.SetSelection(0);
// Auto-expand all items on load.
foreach (var item in treeView.rootItems)
{
treeView.ExpandItem(item.id);
}
}).StartingIn(k_TreeViewInitialSelectionDelay);
}
void SetElement(VisualElement oldElement, VisualElement newElement)
{
Performance.Start(out string reference);
var sameChildrenTypes = false;
IReadOnlyList <Element> newChildren = null, oldChildren = null;
RendererPool pool = null;
if (oldElement != null)
{
oldElement.ChildAdded -= _childAddedHandler;
oldElement.ChildRemoved -= _childRemovedHandler;
oldElement.ChildrenReordered -= _childReorderedHandler;
oldChildren = ((IElementController)oldElement).LogicalChildren;
if (newElement != null)
{
sameChildrenTypes = true;
newChildren = ((IElementController)newElement).LogicalChildren;
if (oldChildren.Count == newChildren.Count)
{
for (var i = 0; i < oldChildren.Count; i++)
{
if (oldChildren[i].GetType() != newChildren[i].GetType())
{
sameChildrenTypes = false;
break;
}
}
}
else
{
sameChildrenTypes = false;
}
}
else
{
for (var i = 0; i < oldChildren.Count; i++)
{
RemoveChild((VisualElement)oldChildren[i]);
}
}
if (!sameChildrenTypes)
{
_childViews = new List <IVisualElementRenderer>();
pool = new RendererPool(_renderer, oldElement);
pool.ClearChildrenRenderers();
}
}
if (newElement != null)
{
Performance.Start(reference, "Setup");
newElement.ChildAdded += _childAddedHandler;
newElement.ChildRemoved += _childRemovedHandler;
newElement.ChildrenReordered += _childReorderedHandler;
newChildren = newChildren ?? ((IElementController)newElement).LogicalChildren;
for (var i = 0; i < newChildren.Count; i++)
{
IVisualElementRenderer oldRenderer = null;
if (oldChildren != null && sameChildrenTypes && _childViews != null)
{
oldRenderer = _childViews[i];
}
AddChild((VisualElement)newChildren[i], oldRenderer, pool, sameChildrenTypes);
}
#if DEBUG
//if (renderer.Element.LogicalChildren.Any() && renderer.ViewGroup.ChildCount != renderer.Element.LogicalChildren.Count)
// throw new InvalidOperationException ("SetElement did not create the correct number of children");
#endif
EnsureChildOrder();
Performance.Stop(reference, "Setup");
}
Performance.Stop(reference);
}
void IControlledElement.OnControllerChanged(ref ControllerChangedEvent e)
{
if (e.controller != controller && !(e.controller is VFXParameterController)) //optim : reorder only is only the order has changed
{
return;
}
if (e.controller == controller && e.change == VFXViewController.Change.assetName)
{
title = controller.name;
return;
}
if (controller.model.subgraph is VisualEffectSubgraphOperator && m_OutputCategory == null)
{
m_OutputCategory = new VFXBlackboardCategory()
{
title = "Output"
};
m_OutputCategory.headerVisible = true;
m_OutputCategory.expanded = PlayerPrefs.GetInt("VFX.blackboard.outputexpanded", 0) != 0;
Add(m_OutputCategory);
var addOutputButton = new Button()
{
name = "addOutputButton", text = "+"
};
addOutputButton.clicked += OnAddOutputParameterMenu;
var sectionHeader = m_OutputCategory.Q("sectionHeader");
var spacer = new VisualElement();
spacer.style.flexGrow = 1;
sectionHeader.Add(spacer);
sectionHeader.Add(addOutputButton);
m_OutputCategory.AddToClassList("output");
}
else if (!(controller.model.subgraph is VisualEffectSubgraphOperator) && m_OutputCategory != null)
{
Remove(m_OutputCategory);
m_OutputCategory = null;
}
var actualControllers = new HashSet <VFXParameterController>(controller.parameterControllers.Where(t => !t.isOutput && string.IsNullOrEmpty(t.model.category)));
m_DefaultCategory.SyncParameters(actualControllers);
var orderedCategories = controller.graph.UIInfos.categories;
var newCategories = new List <VFXBlackboardCategory>();
if (orderedCategories != null)
{
foreach (var catModel in controller.graph.UIInfos.categories)
{
VFXBlackboardCategory cat = null;
if (!m_Categories.TryGetValue(catModel.name, out cat))
{
cat = new VFXBlackboardCategory()
{
title = catModel.name
};
cat.SetSelectable();
m_Categories.Add(catModel.name, cat);
}
m_ExpandedStatus[catModel.name] = !catModel.collapsed;
newCategories.Add(cat);
}
foreach (var category in m_Categories.Keys.Except(orderedCategories.Select(t => t.name)).ToArray())
{
m_Categories[category].RemoveFromHierarchy();
m_Categories.Remove(category);
m_ExpandedStatus.Remove(category);
}
}
var prevCat = m_DefaultCategory;
foreach (var cat in newCategories)
{
if (cat.parent == null)
{
Insert(IndexOf(prevCat) + 1, cat);
}
else
{
cat.PlaceInFront(prevCat);
}
prevCat = cat;
}
if (m_OutputCategory != null)
{
m_OutputCategory.PlaceInFront(prevCat);
}
foreach (var cat in newCategories)
{
actualControllers = new HashSet <VFXParameterController>(controller.parameterControllers.Where(t => t.model.category == cat.title && !t.isOutput));
cat.SyncParameters(actualControllers);
cat.expanded = m_ExpandedStatus[cat.title];
}
if (m_OutputCategory != null)
{
var outputControllers = new HashSet <VFXParameterController>(controller.parameterControllers.Where(t => t.isOutput));
m_OutputCategory.SyncParameters(outputControllers);
}
m_PathLabel.text = controller.graph.categoryPath;
}
internal virtual void SendVisualElementInitialized(VisualElement element, AView nativeView)
{
element.SendViewInitialized(nativeView);
}
public EventTypeSearchField()
{
m_Choices = new List <EventTypeChoice>();
m_State = new Dictionary <long, bool>();
m_GroupedEvents = new Dictionary <string, List <long> >();
AppDomain currentDomain = AppDomain.CurrentDomain;
HashSet <string> userAssemblies = new HashSet <string>(ScriptingRuntime.GetAllUserAssemblies());
foreach (Assembly assembly in currentDomain.GetAssemblies())
{
if (userAssemblies.Contains(assembly.GetName().Name + ".dll"))
{
continue;
}
try
{
foreach (var type in assembly.GetTypes().Where(t => typeof(EventBase).IsAssignableFrom(t) && !t.ContainsGenericParameters))
{
// Only select Pointer events on startup
AddType(type, IsGenericTypeOf(type, typeof(PointerEventBase <>)));
}
// Special case for ChangeEvent<>.
var implementingTypes = GetAllTypesImplementingOpenGenericType(typeof(INotifyValueChanged <>), assembly).ToList();
foreach (var valueChangedType in implementingTypes)
{
var baseType = valueChangedType.BaseType;
if (baseType == null || baseType.GetGenericArguments().Length <= 0)
{
continue;
}
var argumentType = baseType.GetGenericArguments()[0];
if (!argumentType.IsGenericParameter)
{
AddType(typeof(ChangeEvent <>).MakeGenericType(argumentType), false);
}
}
}
catch (TypeLoadException e)
{
Debug.LogWarningFormat("Error while loading types from assembly {0}: {1}", assembly.FullName, e);
}
catch (ReflectionTypeLoadException e)
{
for (var i = 0; i < e.LoaderExceptions.Length; i++)
{
if (e.LoaderExceptions[i] != null)
{
Debug.LogError(e.Types[i] + ": " + e.LoaderExceptions[i].Message);
}
}
}
}
m_State.Add(0, false);
// Add groups, with negative ids.
var keyIndex = -1;
foreach (var key in m_GroupedEvents.Keys.OrderBy(k => k))
{
m_Choices.Add(new EventTypeChoice()
{
Name = key, Group = key, TypeId = keyIndex
});
m_State.Add(keyIndex--, key.Contains("IPointerEvent"));
}
m_Choices.Sort();
m_Choices.Insert(0, new EventTypeChoice()
{
Name = "IAll", Group = "IAll", TypeId = 0
});
m_FilteredChoices = m_Choices.ToList();
m_MenuContainer = new VisualElement();
m_MenuContainer.AddToClassList(ussClassName);
m_OuterContainer = new VisualElement();
m_OuterContainer.AddToClassList(ussContainerClassName);
m_MenuContainer.Add(m_OuterContainer);
m_ListView = new ListView();
m_ListView.AddToClassList(ussListViewClassName);
m_ListView.pickingMode = PickingMode.Position;
m_ListView.showBoundCollectionSize = false;
m_ListView.fixedItemHeight = 20;
m_ListView.selectionType = SelectionType.None;
m_ListView.showAlternatingRowBackgrounds = AlternatingRowBackground.All;
m_ListView.makeItem = () =>
{
var container = new VisualElement();
container.AddToClassList(ussItemContainerClassName);
var toggle = new Toggle();
toggle.labelElement.AddToClassList(ussItemLabelClassName);
toggle.visualInput.AddToClassList(ussItemToggleClassName);
toggle.RegisterValueChangedCallback(OnToggleValueChanged);
container.Add(toggle);
var label = new Label();
label.AddToClassList(ussItemCountClassName);
label.pickingMode = PickingMode.Ignore;
container.Add(label);
return(container);
};
m_ListView.bindItem = (element, i) =>
{
var toggle = element[0] as Toggle;
var countLabel = element[1] as Label;
var choice = m_FilteredChoices[i];
toggle.SetValueWithoutNotify(m_State[choice.TypeId]);
var isGroup = choice.Name == choice.Group;
toggle.label = isGroup ? $"{choice.Group.Substring(1).Replace("Event", "")} Events" : choice.Name;
toggle.labelElement.RemoveFromClassList(isGroup ? ussItemLabelClassName : ussGroupLabelClassName);
toggle.labelElement.AddToClassList(isGroup ? ussGroupLabelClassName : ussItemLabelClassName);
toggle.userData = i;
if (m_EventCountLog != null && m_EventCountLog.ContainsKey(choice.TypeId))
{
countLabel.style.display = DisplayStyle.Flex;
countLabel.text = m_EventCountLog[choice.TypeId].ToString();
}
else
{
countLabel.text = "";
countLabel.style.display = DisplayStyle.None;
}
};
m_ListView.itemsSource = m_FilteredChoices;
m_OuterContainer.Add(m_ListView);
UpdateTextHint();
m_MenuContainer.RegisterCallback <AttachToPanelEvent>(OnAttachToPanel);
m_MenuContainer.RegisterCallback <DetachFromPanelEvent>(OnDetachFromPanel);
textInputField.RegisterValueChangedCallback(OnValueChanged);
RegisterCallback <FocusInEvent>(OnFocusIn);
RegisterCallback <FocusEvent>(OnFocus);
RegisterCallback <FocusOutEvent>(OnFocusOut);
}
private static IMGUIContainer CreateButton(DataConfigEditor editor, System.Collections.Generic.HashSet <System.Type> usedComponents, SerializedProperty source, VisualElement elements, bool noFields)
{
var addMenuButton = new IMGUIContainer(() => {
GUILayoutExt.DrawAddComponentMenu(usedComponents, (type, isUsed) => {
if (isUsed == false)
{
usedComponents.Add(type);
source.serializedObject.Update();
++source.arraySize;
var elem = source.GetArrayElementAtIndex(source.arraySize - 1);
elem.managedReferenceValue = System.Activator.CreateInstance(type);
source.serializedObject.ApplyModifiedProperties();
if (noFields == true)
{
editor.OnAddComponentFromRemoveList(type);
}
else
{
editor.OnAddComponent(type);
}
}
else
{
RemoveComponent(editor, usedComponents, source, type, noFields);
}
editor.Save();
BuildInspectorProperties(editor, usedComponents, source, elements, noFields);
}, showRuntime: noFields);
});
addMenuButton.AddToClassList("add-component-menu-button-imgui");
return(addMenuButton);
}
public SizeRequest GetNativeSize(VisualElement view, double widthConstraint, double heightConstraint)
{
return(Platform.GetNativeSize(view, widthConstraint, heightConstraint));
}
private static void BuildTemplates(System.Collections.Generic.HashSet <ME.ECS.DataConfigs.DataConfigTemplate> usedComponents, VisualElement templatesContainer, SerializedProperty source)
{
source = source.Copy();
templatesContainer.Clear();
templatesContainer.AddToClassList("templates-container");
for (int i = 0; i < source.arraySize; ++i)
{
var elem = source.GetArrayElementAtIndex(i);
var guid = elem.stringValue;
if (string.IsNullOrEmpty(guid) == true)
{
continue;
}
var path = AssetDatabase.GUIDToAssetPath(guid);
if (string.IsNullOrEmpty(path) == true)
{
continue;
}
var template = AssetDatabase.LoadAssetAtPath <ME.ECS.DataConfigs.DataConfigTemplate>(path);
if (template == null)
{
continue;
}
if (usedComponents.Contains(template) == false)
{
usedComponents.Add(template);
}
var button = new Button(() => {
EditorGUIUtility.PingObject(template);
});
button.AddToClassList("template-button");
button.text = template.name;
templatesContainer.Add(button);
}
}
internal void UpdateView(object view, DataTemplate viewTemplate, ref UIView uiView, ref VisualElement formsElement)
{
// Is view set on the ItemsView?
if (view == null)
{
if (formsElement != null)
{
//Platform.GetRenderer(formsElement)?.DisposeRendererAndChildren();
}
uiView?.Dispose();
uiView = null;
formsElement = null;
}
else
{
// Create the native renderer for the view, and keep the actual Forms element (if any)
// around for updating the layout later
(uiView, formsElement) = TemplateHelpers.RealizeView(view, viewTemplate, ItemsView);
}
}
private static IMGUIContainer CreateTemplatesButton(DataConfigEditor editor,
System.Collections.Generic.HashSet <ME.ECS.DataConfigs.DataConfigTemplate> usedComponents,
VisualElement rootElement,
VisualElement templatesContainer,
SerializedProperty source,
SerializedObject so,
System.Action <SerializedObject, ME.ECS.DataConfigs.DataConfigTemplate> onAddTemplate,
System.Action <SerializedObject, ME.ECS.DataConfigs.DataConfigTemplate> onRemoveTemplate)
{
var container = new IMGUIContainer(() => {
GUILayoutExt.DrawManageDataConfigTemplateMenu(usedComponents, (template, isUsed) => {
var path = AssetDatabase.GetAssetPath(template);
var guid = AssetDatabase.AssetPathToGUID(path);
if (string.IsNullOrEmpty(guid) == true)
{
return;
}
if (isUsed == true)
{
var copy = source.Copy();
var i = 0;
var enterChildren = true;
while (copy.NextVisible(enterChildren) == true)
{
enterChildren = false;
if (copy.propertyType != SerializedPropertyType.String)
{
continue;
}
if (copy.stringValue == guid)
{
usedComponents.Remove(template);
source.DeleteArrayElementAtIndex(i);
so.ApplyModifiedProperties();
onRemoveTemplate.Invoke(so, template);
break;
}
++i;
}
}
else
{
usedComponents.Add(template);
onAddTemplate.Invoke(so, template);
++source.arraySize;
var elem = source.GetArrayElementAtIndex(source.arraySize - 1);
elem.stringValue = guid;
so.ApplyModifiedProperties();
}
editor.Save();
BuildContainer(editor, rootElement, so);
});
});
container.AddToClassList("add-template-menu-button-imgui");
return(container);
}
Task<bool> SwitchContentAsync(Page view, bool animated, bool removed = false)
{
Context.HideKeyboard(this);
IVisualElementRenderer rendererToAdd = Platform.GetRenderer(view);
bool existing = rendererToAdd != null;
if (!existing)
Platform.SetRenderer(view, rendererToAdd = Platform.CreateRenderer(view, Context));
Page pageToRemove = _current;
IVisualElementRenderer rendererToRemove = pageToRemove == null ? null : Platform.GetRenderer(pageToRemove);
PageContainer containerToRemove = rendererToRemove == null ? null : (PageContainer)rendererToRemove.View.Parent;
PageContainer containerToAdd = (PageContainer)rendererToAdd.View.Parent ?? new PageContainer(Context, rendererToAdd);
containerToAdd.SetWindowBackground();
_current = view;
((Platform)Element.Platform).NavAnimationInProgress = true;
var tcs = new TaskCompletionSource<bool>();
if (animated)
{
if (s_currentAnimation != null)
s_currentAnimation.Cancel();
if (removed)
{
// animate out
if (containerToAdd.Parent != this)
AddView(containerToAdd, ((IElementController)Element).LogicalChildren.IndexOf(rendererToAdd.Element));
else
((IPageController)rendererToAdd.Element).SendAppearing();
containerToAdd.Visibility = ViewStates.Visible;
if (containerToRemove != null)
{
Action<AndroidAnimation.Animator> done = a =>
{
containerToRemove.Visibility = ViewStates.Gone;
containerToRemove.Alpha = 1;
containerToRemove.ScaleX = 1;
containerToRemove.ScaleY = 1;
RemoveView(containerToRemove);
tcs.TrySetResult(true);
((Platform)Element.Platform).NavAnimationInProgress = false;
VisualElement removedElement = rendererToRemove.Element;
rendererToRemove.Dispose();
if (removedElement != null)
Platform.SetRenderer(removedElement, null);
};
// should always happen
s_currentAnimation = containerToRemove.Animate().Alpha(0).ScaleX(0.8f).ScaleY(0.8f).SetDuration(250).SetListener(new GenericAnimatorListener { OnEnd = a =>
{
s_currentAnimation = null;
done(a);
},
OnCancel = done });
}
}
else
{
bool containerAlreadyAdded = containerToAdd.Parent == this;
// animate in
if (!containerAlreadyAdded)
AddView(containerToAdd);
else
((IPageController)rendererToAdd.Element).SendAppearing();
if (existing)
Element.ForceLayout();
containerToAdd.Alpha = 0;
containerToAdd.ScaleX = containerToAdd.ScaleY = 0.8f;
containerToAdd.Visibility = ViewStates.Visible;
s_currentAnimation = containerToAdd.Animate().Alpha(1).ScaleX(1).ScaleY(1).SetDuration(250).SetListener(new GenericAnimatorListener { OnEnd = a =>
{
if (containerToRemove != null && containerToRemove.Handle != IntPtr.Zero)
{
containerToRemove.Visibility = ViewStates.Gone;
((IPageController)pageToRemove)?.SendDisappearing();
}
s_currentAnimation = null;
tcs.TrySetResult(true);
if (Element?.Platform != null)
{
((Platform)Element.Platform).NavAnimationInProgress = false;
}
} });
}
}
else
{
// just do it fast
if (containerToRemove != null)
{
if (removed)
RemoveView(containerToRemove);
else
containerToRemove.Visibility = ViewStates.Gone;
}
if (containerToAdd.Parent != this)
AddView(containerToAdd);
else
((IPageController)rendererToAdd.Element).SendAppearing();
if (containerToRemove != null && !removed)
((IPageController)pageToRemove).SendDisappearing();
if (existing)
Element.ForceLayout();
containerToAdd.Visibility = ViewStates.Visible;
tcs.SetResult(true);
((Platform)Element.Platform).NavAnimationInProgress = false;
}
return tcs.Task;
}
void IVisualElementRenderer.SetElement(VisualElement element) =>
Element = (element as Slider) ?? throw new ArgumentException($"Element must be of type {nameof(Slider)}.");
void IVisualElementRenderer.SetElement(VisualElement element)
{
MasterDetailPage oldElement = Element;
MasterDetailPage newElement = Element = element as MasterDetailPage;
if (oldElement != null)
{
Device.Info.PropertyChanged -= DeviceInfoPropertyChanged;
((IMasterDetailPageController)oldElement).BackButtonPressed -= OnBackButtonPressed;
oldElement.PropertyChanged -= HandlePropertyChanged;
oldElement.Appearing -= MasterDetailPageAppearing;
oldElement.Disappearing -= MasterDetailPageDisappearing;
RemoveDrawerListener(this);
if (_detailLayout != null)
{
RemoveView(_detailLayout);
}
if (_masterLayout != null)
{
RemoveView(_masterLayout);
}
}
if (newElement != null)
{
if (_detailLayout == null)
{
_detailLayout = new MasterDetailContainer(newElement, false, Context)
{
LayoutParameters = new LayoutParams(ViewGroup.LayoutParams.WrapContent, ViewGroup.LayoutParams.WrapContent)
};
_masterLayout = new MasterDetailContainer(newElement, true, Context)
{
LayoutParameters = new LayoutParams(ViewGroup.LayoutParams.WrapContent, ViewGroup.LayoutParams.WrapContent)
{
Gravity = (int)GravityFlags.Start
}
};
if (_fragmentManager != null)
{
_detailLayout.SetFragmentManager(_fragmentManager);
_masterLayout.SetFragmentManager(_fragmentManager);
}
AddView(_detailLayout);
AddView(_masterLayout);
Device.Info.PropertyChanged += DeviceInfoPropertyChanged;
AddDrawerListener(this);
}
UpdateBackgroundColor(newElement);
UpdateBackgroundImage(newElement);
UpdateMaster();
UpdateDetail();
UpdateFlowDirection();
((IMasterDetailPageController)newElement).BackButtonPressed += OnBackButtonPressed;
newElement.PropertyChanged += HandlePropertyChanged;
newElement.Appearing += MasterDetailPageAppearing;
newElement.Disappearing += MasterDetailPageDisappearing;
SetGestureState();
Presented = newElement.IsPresented;
newElement.SendViewInitialized(this);
}
OnElementChanged(oldElement, newElement);
// Make sure to initialize this AFTER event is fired
if (_tracker == null)
{
_tracker = new VisualElementTracker(this);
}
if (element != null && !string.IsNullOrEmpty(element.AutomationId))
{
SetAutomationId(element.AutomationId);
}
SetContentDescription();
}
public BuilderVisualTreeStyleUpdaterTraversal(VisualElement document)
{
m_DocumentElement = document;
}
protected virtual void OnElementChanged(VisualElement oldElement, VisualElement newElement)
{
ElementChanged?.Invoke(this, new VisualElementChangedEventArgs(oldElement, newElement));
}
void SetElement(VisualElement oldElement, VisualElement newElement)
{
if (oldElement != null)
{
oldElement.BatchCommitted -= _batchCommittedHandler;
oldElement.PropertyChanged -= _propertyChangedHandler;
_context = null;
}
_element = newElement;
if (newElement != null)
{
newElement.BatchCommitted += _batchCommittedHandler;
newElement.PropertyChanged += _propertyChangedHandler;
_context = _renderer.ViewGroup.Context;
if (oldElement != null)
{
AView view = _renderer.ViewGroup;
// ReSharper disable CompareOfFloatsByEqualityOperator
if (oldElement.AnchorX != newElement.AnchorX)
UpdateAnchorX();
if (oldElement.AnchorY != newElement.AnchorY)
UpdateAnchorY();
if (oldElement.IsVisible != newElement.IsVisible)
UpdateIsVisible();
if (oldElement.IsEnabled != newElement.IsEnabled)
view.Enabled = newElement.IsEnabled;
if (oldElement.Opacity != newElement.Opacity)
UpdateOpacity();
if (oldElement.Rotation != newElement.Rotation)
UpdateRotation();
if (oldElement.RotationX != newElement.RotationX)
UpdateRotationX();
if (oldElement.RotationY != newElement.RotationY)
UpdateRotationY();
if (oldElement.Scale != newElement.Scale)
UpdateScale();
// ReSharper restore CompareOfFloatsByEqualityOperator
_initialUpdateNeeded = false;
}
}
}
public CollabHistoryItem(RevisionData data)
{
m_RevisionId = data.id;
m_TimeStamp = data.timeStamp;
name = "HistoryItem";
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);
m_Description = shouldTruncate
? new Label(GetTruncatedDescription(m_FullDescription))
: 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_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)
{
var buildButton = data.buildState == BuildState.Configure
? new BuildStatusButton(ShowServicePage)
: new BuildStatusButton(ShowBuildForCommit, data.buildState, data.buildFailures);
var topContainer = new VisualElement {
name = "HistoryItemActionsTop"
};
topContainer.Add(m_ProgressSpinner);
topContainer.Add(buildButton);
var bottomContainer = new VisualElement {
name = "HistoryItemActionsBottom"
};
bottomContainer.Add(m_Button);
m_Details.Add(topContainer);
m_Details.Add(bottomContainer);
}
else
{
var container = new VisualElement {
name = "HistoryItemActionsTop"
};
container.Add(m_ProgressSpinner);
container.Add(m_Button);
m_Details.Add(container);
}
m_Details.Add(dropdown);
Add(m_Details);
schedule.Execute(UpdateTimeAgo).Every(1000 * 20);
}
