/// <summary> /// Unregister ManagedObject /// </summary> /// <param name="oObject">The sap.ui.base.ManagedObject</param> public extern virtual void unregisterObject([email protected] oObject);
/// <summary> /// When using the databinding type system, the validation/parsing of a new property value could fail. In this case, a validationError/parseError event is fired. These events bubble up to the core. For registered ManagedObjects, the MessageManager attaches to these events and creates a <code>sap.ui.core.message.Message</code> (bHandleValidation=true) for each of these errors and cancels the event bubbling. /// </summary> /// <param name="oObject">The sap.ui.base.ManagedObject</param> /// <param name="bHandleValidation">Handle validationError/parseError events for this object. If set to true, the MessageManager creates a Message for each validation/parse error. The event bubbling is canceled in every case.</param> public extern virtual void registerObject([email protected] oObject, bool bHandleValidation);
/// <summary>
/// Returns the Component instance in whose "context" the given ManagedObject has been created or <code>undefined</code>.
///
/// This is a convenience wrapper around {@link sap.ui.core.Component.getOwnerIdFor Component.getOwnerIdFor}. If the owner ID cannot be determined for reasons documented on <code>getOwnerForId</code> or when the Component for the determined ID no longer exists, <code>undefined</code> will be returned.
/// </summary>
/// <param name="oObject">Object to retrieve the owner Component for</param>
/// <returns>the owner Component or <code>undefined</code>.</returns>
public extern static sap.ui.core.Component getOwnerComponentFor([email protected] oObject);
/// <summary>
/// Returns the ID of the object in whose "context" the given ManagedObject has been created.
///
/// For objects that are not ManagedObjects or for which the owner is unknown, <code>undefined</code> will be returned as owner ID.
///
/// <strong>Note</strong>: Ownership for objects is only checked by the framework at the time when they are created. It is not checked or updated afterwards. And it can only be detected while the {@link sap.ui.core.Component#runAsOwner Component.runAsOwner} function is executing. Without further action, this is only the case while the content of a UIComponent is {@link sap.ui.core.UIComponent#createContent constructed} or when a {@link sap.ui.core.routing.Router Router} creates a new View and its content.
///
/// <strong>Note</strong>: This method does not guarantee that the returned owner ID belongs to a Component. Currently, it always does. But future versions of UI5 might introduce a more fine grained ownership concept, e.g. taking Views into account. Callers that want to deal only with components as owners, should use the following method: {@link sap.ui.core.Component.getOwnerComponentFor Component.getOwnerComponentFor}. It guarantees that the returned object (if any) will be a Component.
///
/// <strong>Further note</strong> that only the ID of the owner is recorded. In rare cases, when the lifecycle of a ManagedObject is not bound to the lifecycle of its owner, (e.g. by the means of aggregations), then the owner might have been destroyed already whereas the ManagedObject is still alive. So even the existence of an owner ID is not a guarantee for the existence of the corresponding owner.
/// </summary>
/// <param name="oObject">Object to retrieve the owner ID for</param>
/// <returns>ID of the owner or <code>undefined</code></returns>
public extern static string getOwnerIdFor([email protected] oObject);
/// <summary> /// The ManagedObjectModel class allows you to bind to properties and aggregations of managed objects. /// </summary> /// <param name="oObject">the managed object models root object</param> /// <param name="oData">an object for custom data</param> public extern ManagedObjectModel([email protected] oObject, object oData);
/// <summary> /// Triggers rerendering of this element and its children. /// </summary> /// <param name="oOrigin">Child control for which the method was called</param> public extern override void invalidate([email protected] oOrigin);
/// <summary> /// Adds information to the given oAggregatedObject about its original API parent (or a subsequent API parent in case of multiple forwarding). /// </summary> /// <param name="oAggregatedObject">Object to which the new API parent info should be added</param> /// <param name="oParent">Object that is a new API parent</param> /// <param name="sAggregationName">the name of the aggregation under which oAggregatedObject is aggregated by the API parent</param> public extern static void addAPIParentInfo([email protected] oAggregatedObject, [email protected] oParent, string sAggregationName);
/// <summary> /// Load and returns the design time metadata asynchronously. It inherits/merges parent design time metadata and if provided merges also instance specific design time metadata that was provided via the dt namespace. /// /// Be aware that ManagedObjects do not ensure to have unique IDs. This may lead to issues if you would like to persist DesignTime based information. In that case you need to take care of identification yourself. /// </summary> /// <param name="oManagedObject">instance that could have instance specific design time metadata</param> /// <returns>A promise which will return the loaded design time metadata</returns> private extern jquery.JQueryPromise <object> loadDesignTime([email protected] oManagedObject);
/// <summary> /// Load and returns the design time metadata asynchronously. It inherits/merges parent design time metadata and if provided merges also instance specific design time metadata that was provided via the dt namespace. /// /// Be aware that ManagedObjects do not ensure to have unique IDs. This may lead to issues if you would like to persist DesignTime based information. In that case you need to take care of identification yourself. /// </summary> /// <param name="oManagedObject">instance that could have instance specific design time metadata</param> /// <param name="sScopeKey">scope name for which metadata will be resolved, see sap.ui.base.ManagedObjectMetadataScope</param> /// <returns>A promise which will return the loaded design time metadata</returns> private extern jquery.JQueryPromise <object> loadDesignTime([email protected] oManagedObject, string sScopeKey);
/// <summary> /// Completes the information about the original API parent of the given element. MUST be called after an element is forwarded to another internal aggregation. For every call to ManagedObjectMetadata.addAPIParentInfoBegin(...) this method here must be called as well. /// </summary> /// <param name="oAggregatedObject">Object to which the new API parent info should be added</param> public extern static void addAPIParentInfoEnd([email protected] oAggregatedObject);
/// <summary> /// Load and returns the design time metadata asynchronously. It inherits/merges parent design time metadata and if provided merges also instance specific design time metadata that was provided via the dt namespace. /// /// Be aware that ManagedObjects do not ensure to have unique IDs. This may lead to issues if you would like to persist DesignTime based information. In that case you need to take care of identification yourself. /// </summary> /// <param name="oManagedObject">instance that could have instance specific design time metadata</param> /// <returns>A promise which will return the loaded design time metadata</returns> private extern es5.Promise <object> loadDesignTime([email protected] oManagedObject);