public ViewPool(Transform parent, PrefabRef <TView> prefab, PresentOptions options) : this(parent, prefab.ExtractPrefab(parent)) { if ((options & PresentOptions.UseLoadedViews) != 0) { Rui.FillPoolWithChildrenViews(this, parent, prefab, this.prefab, options); } }
public static void FillPoolWithChildrenViews <TView, TData>(IViewPool <TView, TData> pool, Transform parent, PrefabRef <TView> prefabRef, TView prefab, PresentOptions options) where TView : ReusableView { if (parent == null) { return; } foreach (var obj in parent) { var view = ((Transform)obj).GetComponent <TView>(); if (view != null) { if (view.prefabRef != null && view.prefabRef == prefab) { pool.AddViewToUse((TView)view.prefabRef, view); } else if (options.Has(PresentOptions.UseChildWithSameTypeAsView) && view.GetType() == prefabRef.ExtractType()) { view.prefabRef = prefab; pool.AddViewToUse((TView)view.prefabRef, view); } else if (options.Has(PresentOptions.UseChildWithSameNameAsView) && view.name == prefabRef.ExtractName()) { view.prefabRef = prefab; pool.AddViewToUse((TView)view.prefabRef, view); } } } }
private IPresentable CreatePresentable(IPresentable parent, Type controllerType, PresentOptions presentOptions, PresentArgs args) { Debug.Assert(controllerType != null); Debug.Assert(!_disposed); var resultType = typeof(int); var attrs = (ViewControllerAttribute[])controllerType.GetCustomAttributes(typeof(ViewControllerAttribute), false); var presentContext = new PresentResultArgs() { Id = ++_idCounter, ServiceProvider = _serviceProvider, ControllerFactory = _controllerFactory, ViewFactory = _viewFactory, ControllerType = controllerType, Parent = parent, PresentOptions = presentOptions, PresentArgs = args ?? PresentArgs.Default }; if (attrs != null && attrs.Length > 0) { var controllerAttr = attrs[0]; presentContext.PresentOptions |= controllerAttr.PresentOptions; presentContext.Layer = controllerAttr.Layer; presentContext.Tag = controllerAttr.Tag; presentContext.PrefabPath = controllerAttr.PrefabPath; } // Types inherited from IViewControllerResult<> use specific result values. if (IsAssignableToGenericType(controllerType, typeof(IViewControllerResult<>), out var t)) { resultType = t.GenericTypeArguments[0]; } // If parent is going to be dismissed, use its parent instead. if ((presentOptions & PresentOptions.Child) == 0) { presentContext.Parent = null; } else if ((presentOptions & PresentOptions.DismissAll) != 0) { presentContext.Parent = null; } else if ((presentOptions & PresentOptions.DismissCurrent) != 0) { presentContext.Parent = parent?.Parent; } // Instantiate the presentable. // https://docs.microsoft.com/en-us/dotnet/framework/reflection-and-codedom/how-to-examine-and-instantiate-generic-types-with-reflection var presentResultType = typeof(PresentResult<,>).MakeGenericType(controllerType, resultType); var c = (IPresentable)Activator.CreateInstance(presentResultType, this, presentContext); AddPresentable(c); return c; }
public WindowRenderTargetProperties( WindowHandle window, Size pixelSize, PresentOptions options = PresentOptions.None) { _hwnd = window; PixelSize = pixelSize; PresentOptions = options; }
public static TableConnectionsAndComponents <TView, TData> PresentWithLayout <TData, TView>( this IReactiveCollection <TData> data, RectTransform rect, PrefabRef <TView> prefab, Action <TData, TView> fillFactory, IScrollViewLayout layout = null, // Linear layout is default TableDelegates <TView> delegates = null, PresentOptions options = PresentOptions.UseChildWithSameTypeAsView) where TView : ReusableView { var components = CreateBasicTableComponents(data, rect, fillFactory, prefab: prefab, layout: layout, delegates: delegates, options: options | PresentOptions.NeedLayout); components.viewPort = new AllVisibleViewPort(); return(ControlItemVisibilityAndRecycle(components)); }
public void Clear() { autoDepthStencilFormat = DepthFormat.Unknown; backBufferCount = 0; backBufferFormat = SurfaceFormat.Unknown; backBufferHeight = 0; backBufferWidth = 0; deviceWindowHandle = IntPtr.Zero; enableAutoDepthStencil = false; fullScreenRefreshRateInHz = 0; isFullScreen = false; multiSampleQuality = 0; multiSampleType = MultiSampleType.None; presentationInterval = PresentInterval.Default; presentOptions = PresentOptions.None; swapEffect = SwapEffect.Default; }
public PresentResult(IPresenterInternal presenter, PresentResultArgs context) { Debug.Assert(presenter != null); Debug.Assert(context != null); _presenter = presenter; _id = context.Id; _tag = context.Tag; _layer = context.Layer; _parent = context.Parent; _serviceProvider = context.ServiceProvider; _controllerFactory = context.ControllerFactory; _controllerType = context.ControllerType; _presentArgs = context.PresentArgs; _presentOptions = context.PresentOptions; _deeplinkId = GetDeeplinkId(_controllerType); _prefabPath = string.IsNullOrEmpty(context.PrefabPath) ? GetDefaultPrefabName(_controllerType) : context.PrefabPath; }
public static SimplePresentComponents <TView, T> Present <T, TView>( this IReactiveCollection <T> coll, Transform parent, PrefabRef <TView> prefab = default, Action <T, TView> show = null, Func <T, IEventStream> updater = null, Func <T, PrefabRef <TView> > prefabSelector = null, IViewPool <TView, T> pool = null, PresentOptions options = PresentOptions.UseChildWithSameTypeAsView, TableDelegates <TView> delegates = null ) where TView : ReusableView { var components = CreateBasicTableComponents(coll, parent, show, pool, prefab, prefabSelector, null, delegates, updater, options); var viewStorage = components.viewLoader; components.addConnection = coll.update.Subscribe(e => { switch (e.type) { case ReactiveCollectionEventType.Reset: viewStorage.UnloadAll(); viewStorage.ReloadAll(e.newData); break; case ReactiveCollectionEventType.Insert: viewStorage.LoadView(e.position, e.newItem); break; case ReactiveCollectionEventType.Remove: viewStorage.UnloadView(e.position); break; case ReactiveCollectionEventType.Set: viewStorage.UnloadView(e.position); viewStorage.LoadView(e.position, e.newItem); break; } }); viewStorage.ReloadAll(coll); // TODO think about how destroy should work components.addConnection = new AnonymousDisposable(() => components.viewLoader.UnloadAll()); components.animationsEnabled = true; return(components); }
public static TableConnectionsAndComponents <TView, TData> PresentInScrollWithLayout <TData, TView>( this IReactiveCollection <TData> data, ReactiveScrollRect scroll, PrefabRef <TView> prefab = default, Action <TData, TView> show = null, Func <TData, PrefabRef <TView> > prefabSelector = null, IScrollViewLayout layout = null, // Linear layout is default TableDelegates <TView> delegates = null, PresentOptions options = PresentOptions.UseChildWithSameTypeAsView ) where TView : ReusableView { var components = CreateBasicTableComponents( data, scroll.scroll.content, show, prefab: prefab, prefabSelector: prefabSelector, layout: layout, delegates: delegates, options: options | PresentOptions.NeedLayout); return(PresentInScrollWithLayout(components, scroll)); }
IPresentResult IPresenterInternal.PresentAsync(IPresentable presentable, Type controllerType, PresentOptions presentOptions, Transform parent, PresentArgs args) { return PresentInternal(presentable, controllerType, presentOptions, parent, args); }
/// <summary> /// Presents a controller of the specified type. /// </summary> /// <typeparam name="TController">Type of the controller to instantiate.</typeparam> /// <param name="presenter">The presenter.</param> /// <param name="options">Present options.</param> /// <param name="args">Controller arguments.</param> /// <returns>An object that can be used to track the operation progress.</returns> /// <exception cref="ArgumentException">Thrown if <typeparamref name="TController"/> cannot be used to instantiate the controller (for instance it is abstract type).</exception> /// <exception cref="ObjectDisposedException">Thrown if the presenter is disposed.</exception> public static Task PresentAsync <TController>(this IPresenter presenter, PresentArgs args, PresentOptions options) where TController : IViewController { return(presenter.Present(typeof(TController), args, options, null).Task); }
public static bool Has(this PresentOptions self, PresentOptions option) { return((self & option) == option); }
/// <summary> /// Presents a controller of the specified type. /// </summary> /// <param name="presenter">The presenter.</param> /// <param name="controllerType">Type of the view controller to present.</param> /// <param name="options">Present options.</param> /// <param name="args">Controller arguments.</param> /// <returns>An object that can be used to track the operation progress.</returns> /// <exception cref="ArgumentNullException">Thrown if <paramref name="controllerType"/> is <see langword="null"/>.</exception> /// <exception cref="ArgumentException">Thrown if <paramref name="controllerType"/> cannot be used to instantiate the controller (for instance it is abstract type).</exception> /// <exception cref="ObjectDisposedException">Thrown if the presenter is disposed.</exception> /// <seealso cref="Present(Type)"/> public static Task PresentAsync(this IPresenter presenter, Type controllerType, PresentArgs args, PresentOptions options) { return(presenter.Present(controllerType, args, options, null).Task); }
/// <summary> /// Presents a controller of the specified type. /// </summary> /// <param name="presenter">The presenter.</param> /// <param name="controllerType">Type of the view controller to present.</param> /// <param name="options">Present options.</param> /// <param name="transform">Parent transform of the controller view.</param> /// <returns>An object that can be used to track the operation progress.</returns> /// <exception cref="ArgumentNullException">Thrown if <paramref name="controllerType"/> is <see langword="null"/>.</exception> /// <exception cref="ArgumentException">Thrown if <paramref name="controllerType"/> cannot be used to instantiate the controller (for instance it is abstract type).</exception> /// <exception cref="ObjectDisposedException">Thrown if the presenter is disposed.</exception> /// <seealso cref="Present(Type)"/> public static IPresentResult Present(this IPresenter presenter, Type controllerType, PresentOptions options, Transform transform) { return(presenter.Present(controllerType, null, options, transform)); }
// Creates everithing except viewport. public static TableConnectionsAndComponents <TView, TData> CreateBasicTableComponents <TData, TView>( IReactiveCollection <TData> data, Transform parent, Action <TData, TView> show, IViewPool <TView, TData> pool = null, PrefabRef <TView> prefab = default, Func <TData, PrefabRef <TView> > prefabSelector = null, IScrollViewLayout layout = null, // Linear layout is default TableDelegates <TView> delegates = null, Func <TData, IEventStream> updater = null, PresentOptions options = PresentOptions.None ) where TView : ReusableView { var components = new TableConnectionsAndComponents <TView, TData>(); if (pool == null) { if (prefabSelector != null) { pool = new DistinctivePool <TView, TData>(parent, prefabSelector, options); } else { var actualPrefab = prefab.ExtractPrefab(parent); pool = new ViewPool <TView, TData>(parent, actualPrefab); if (options.Has(PresentOptions.UseLoadedViews)) { FillPoolWithChildrenViews(pool, parent, prefab, actualPrefab, options); } } } if (updater != null) { var showCopy = show; Action <TData, TView> showAndSubscribe = (item, view) => { showCopy(item, view); view.connections += updater(item).Subscribe(() => showCopy(item, view)); }; show = showAndSubscribe; } delegates = delegates ?? new TableDelegates <TView>(); if (delegates.onInsert != null) { show += (d, view) => { if (components.animationsEnabled) { delegates.onInsert(view); } } } ; if (options.Has(PresentOptions.PreserveSiblingOrder)) { show += (d, view) => { view.tr.SetSiblingIndex(view.indexInModel); }; } components.viewLoader = new LinearViewLoader <TView, TData>(pool, show, delegates.onRemove); components.delegates = delegates; components.collection = data; if (options.Has(PresentOptions.NeedLayout) && layout == null) { layout = LinearLayout(); } components.layout = layout; return(components); }
private IPresentResult PresentInternal(IPresentable presentable, Type controllerType, PresentOptions presentOptions, Transform transform, PresentArgs args) { ThrowIfDisposed(); ThrowIfInvalidControllerType(controllerType); var result = CreatePresentable(presentable, controllerType, presentOptions, args); PresentInternal(result, presentable, transform); return result; }
/// <summary> /// Presents a controller of the specified type. /// </summary> /// <typeparam name="TController">Type of the controller to instantiate.</typeparam> /// <param name="presenter">The presenter.</param> /// <param name="options">Present options.</param> /// <param name="args">Controller arguments.</param> /// <returns>An object that can be used to track the operation progress.</returns> /// <exception cref="ArgumentException">Thrown if <typeparamref name="TController"/> cannot be used to instantiate the controller (for instance it is abstract type).</exception> /// <exception cref="ObjectDisposedException">Thrown if the presenter is disposed.</exception> public static IPresentResultOf <TController> Present <TController>(this IPresenter presenter, PresentArgs args, PresentOptions options) where TController : IViewController { return((IPresentResultOf <TController>)presenter.Present(typeof(TController), args, options, null)); }
static bool Has(this PresentOptions self, PresentOptions option) { return((self & option) != 0); }
/// <summary> /// Presents a controller of the specified type. /// </summary> /// <typeparam name="TController">Type of the controller to instantiate.</typeparam> /// <param name="presenter">The presenter.</param> /// <param name="options">Present options.</param> /// <param name="transform">Parent transform of the controller view.</param> /// <returns>An object that can be used to track the operation progress.</returns> /// <exception cref="ArgumentException">Thrown if <typeparamref name="TController"/> cannot be used to instantiate the controller (for instance it is abstract type).</exception> /// <exception cref="ObjectDisposedException">Thrown if the presenter is disposed.</exception> public static IPresentResultOf <TController> Present <TController>(this IPresenter presenter, PresentOptions options, Transform transform) where TController : IViewController { return((IPresentResultOf <TController>)presenter.Present(typeof(TController), null, options, transform)); }
/// <summary> /// Presents a controller of the specified type. /// </summary> /// <param name="presenter">The presenter.</param> /// <param name="controllerType">Type of the view controller to present.</param> /// <param name="options">Present options.</param> /// <param name="args">Controller arguments.</param> /// <returns>An object that can be used to track the operation progress.</returns> /// <exception cref="ArgumentNullException">Thrown if <paramref name="controllerType"/> is <see langword="null"/>.</exception> /// <exception cref="ArgumentException">Thrown if <paramref name="controllerType"/> cannot be used to instantiate the controller (for instance it is abstract type).</exception> /// <exception cref="ObjectDisposedException">Thrown if the presenter is disposed.</exception> /// <seealso cref="Present(Type)"/> public static IPresentResult Present(this IPresenter presenter, Type controllerType, PresentArgs args, PresentOptions options) { return(presenter.Present(controllerType, args, options, null)); }
/// <summary> /// Presents a controller of the specified type. /// </summary> /// <typeparam name="TController">Type of the controller to instantiate.</typeparam> /// <typeparam name="TResult">Type of the controller result value.</typeparam> /// <param name="presenter">The presenter.</param> /// <param name="options">Present options.</param> /// <param name="transform">Parent transform of the controller view.</param> /// <returns>An object that can be used to track the operation progress.</returns> /// <exception cref="ArgumentException">Thrown if <typeparamref name="TController"/> cannot be used to instantiate the controller (for instance it is abstract type).</exception> /// <exception cref="InvalidCastException">Thrown if the <typeparamref name="TResult"/> does not match result type of the <typeparamref name="TController"/>.</exception> /// <exception cref="ObjectDisposedException">Thrown if the presenter is disposed.</exception> public static Task <TResult> PresentAsync <TController, TResult>(this IPresenter presenter, PresentOptions options, Transform transform) where TController : IViewController, IViewControllerResult <TResult> { return(((IPresentResultOf <TController, TResult>)presenter.Present(typeof(TController), null, options, transform)).Task); }
/// <summary> /// Presents a controller of the specified type. /// </summary> /// <typeparam name="TController">Type of the controller to instantiate.</typeparam> /// <typeparam name="TResult">Type of the controller result value.</typeparam> /// <param name="presenter">The presenter.</param> /// <param name="options">Present options.</param> /// <param name="transform">Parent transform of the controller view.</param> /// <param name="args">Controller arguments.</param> /// <returns>An object that can be used to track the operation progress.</returns> /// <exception cref="ArgumentException">Thrown if <typeparamref name="TController"/> cannot be used to instantiate the controller (for instance it is abstract type).</exception> /// <exception cref="InvalidCastException">Thrown if the <typeparamref name="TResult"/> does not match result type of the <typeparamref name="TController"/>.</exception> /// <exception cref="ObjectDisposedException">Thrown if the presenter is disposed.</exception> public static IPresentResultOf <TController, TResult> Present <TController, TResult>(this IPresenter presenter, PresentArgs args, PresentOptions options, Transform transform) where TController : IViewController, IViewControllerResult <TResult> { return((IPresentResultOf <TController, TResult>)presenter.Present(typeof(TController), args, options, transform)); }
/// <summary> /// Presents a controller of the specified type. /// </summary> /// <typeparam name="TController">Type of the controller to instantiate.</typeparam> /// <typeparam name="TResult">Type of the controller result value.</typeparam> /// <param name="presenter">The presenter.</param> /// <param name="args">Controller arguments.</param> /// <param name="options">Present options.</param> /// <returns>An object that can be used to track the operation progress.</returns> /// <exception cref="ArgumentException">Thrown if <typeparamref name="TController"/> cannot be used to instantiate the controller (for instance it is abstract type).</exception> /// <exception cref="InvalidCastException">Thrown if the <typeparamref name="TResult"/> does not match result type of the <typeparamref name="TController"/>.</exception> /// <exception cref="ObjectDisposedException">Thrown if the presenter is disposed.</exception> public static Task <TResult> PresentAsync <TController, TResult>(this IPresenter presenter, PresentArgs args, PresentOptions options) where TController : IViewController, IViewControllerResult <TResult> { return(((IPresentResultOf <TController, TResult>)presenter.Present(typeof(TController), args, options, null)).Task); }
/// <summary> /// Presents a controller of the specified type. /// </summary> /// <typeparam name="TController">Type of the controller to instantiate.</typeparam> /// <param name="presenter">The presenter.</param> /// <param name="options">Present options.</param> /// <param name="transform">Parent transform of the controller view.</param> /// <returns>An object that can be used to track the operation progress.</returns> /// <exception cref="ArgumentException">Thrown if <typeparamref name="TController"/> cannot be used to instantiate the controller (for instance it is abstract type).</exception> /// <exception cref="ObjectDisposedException">Thrown if the presenter is disposed.</exception> public static Task PresentAsync <TController>(this IPresenter presenter, PresentOptions options, Transform transform) where TController : IViewController { return(presenter.Present(typeof(TController), null, options, transform).Task); }
public IPresentResult Present(Type controllerType, PresentArgs args, PresentOptions presentOptions, Transform parent) { return PresentInternal(null, controllerType, presentOptions, parent, args); }
public SimpleViewPool(Transform parent, PrefabRef <TView> prefab, PresentOptions options) : base(parent, prefab, options) { }
public DistinctivePool(Transform parent, Func <TData, PrefabRef <TView> > prefabSelector, PresentOptions options) { this.prefabSelector = prefabSelector; this.parent = parent; this.options = options; }
/// <summary> /// Presents a controller of the specified type. /// </summary> /// <param name="presenter">The presenter.</param> /// <param name="controllerType">Type of the view controller to present.</param> /// <param name="options">Present options.</param> /// <param name="transform">Parent transform of the controller view.</param> /// <returns>An object that can be used to track the operation progress.</returns> /// <exception cref="ArgumentNullException">Thrown if <paramref name="controllerType"/> is <see langword="null"/>.</exception> /// <exception cref="ArgumentException">Thrown if <paramref name="controllerType"/> cannot be used to instantiate the controller (for instance it is abstract type).</exception> /// <exception cref="ObjectDisposedException">Thrown if the presenter is disposed.</exception> /// <seealso cref="Present(Type)"/> public static Task PresentAsync(this IPresenter presenter, Type controllerType, PresentOptions options, Transform transform) { return(presenter.Present(controllerType, null, options, transform).Task); }
public Task <IView> CreateViewAsync(string prefabPath, int layer, int zIndex, PresentOptions options, Transform parent) { switch (prefabPath) { case "MessageBox": return(Task.FromResult <IView>(new MessageBoxView())); } return(Task.FromResult <IView>(new DefaultView())); }