Chart

Adds a listener that will receive events from the Chart instance.
The same listener can be added to several different Chart instances.

Lifecycle: a listener can be added at any time.

Adds field(s) to be used as the source of the Y-coordinate for each update An optional parser can be passed to normalize the value before it is used to plot the chart. The resulting values should be in the limits posed by the ChartLine#positionYAxis related to the involved line, otherwise a ChartListener#onYOverflow event is fired to handle the situation. null can also be specified, in which case, if the associated X value is null the chart line will be cleared, otherwise the update will be ignored.
It is possible to specify an array of fields instead of specifying a single field. If that's the case multiple chart lines will be generated per each row in the model.
Note that for each field in the underlying model it is possible to associate only one line. If multiple lines based on the same fields are needed, dedicated fields should be added to the model, through AbstractWidget#updateRow. In case this instance is used to listen to events from Subscription instance(s), updateRow() can be invoked from within SubscriptionListener#onItemUpdate.

Lifecycle: The method can be invoked at any time, in order to add fields to be plotted or in order to change the parser associated to fields already being plotted. Until invoked for the first time, no chart will be printed.

Removes all the rows from the model and reflects the change on the view.

Lifecycle: once the AbstractWidget#parseHtml method has been called, this method can be used at any time.

Setter method that sets the stylesheet and positioning to be applied to the chart area.

Lifecycle: The chart area stylesheet and position attributes can be set and changed at any time.

Returns an array containing the ChartListener instances that were added to this client.

Returns the value from the model for the specified key/field pair. If the row for the specified key does not exist or if the specified field is not available in the row then null is returned.

Lifecycle: This method can be called at any time.

Event handler that is called by Lightstreamer each time a request to clear the snapshot pertaining to an item in the Subscription has been received from the Server. More precisely, this kind of request can occur in two cases:

• For an item delivered in COMMAND mode, to notify that the state of the item becomes empty; this is equivalent to receiving an update carrying a DELETE command once for each key that is currently active.
• For an item delivered in DISTINCT mode, to notify that all the previous updates received for the item should be considered as obsolete; hence, if the listener were showing a list of recent updates for the item, it should clear the list in order to keep a coherent view.

Note that, if the involved Subscription has a two-level behavior enabled, the notification refers to the first-level item (which is in COMMAND mode). This kind of notification is not possible for second-level items (which are in MERGE mode).
This event can be sent by the Lightstreamer Server since version 6.0

Event handler that is called by Lightstreamer to notify that, due to internal resource limitations, Lightstreamer Server dropped one or more updates for an item that was subscribed to as a second-level subscription. Such notifications are sent only if the Subscription was configured in unfiltered mode (second-level items are always in "MERGE" mode and inherit the frequency configuration from the first-level Subscription).
By implementing this method it is possible to perform recovery actions.

Event handler that is called when the Server notifies an error on a second-level subscription.
By implementing this method it is possible to perform recovery actions.

Event handler that is called by Lightstreamer to notify that all snapshot events for an item in the Subscription have been received, so that real time events are now going to be received. The received snapshot could be empty. Such notifications are sent only if the items are delivered in DISTINCT or COMMAND subscription mode and snapshot information was indeed requested for the items. By implementing this method it is possible to perform actions which require that all the initial values have been received.
Note that, if the involved Subscription has a two-level behavior enabled, the notification refers to the first-level item (which is in COMMAND mode). Snapshot-related updates for the second-level items (which are in MERGE mode) can be received both before and after this notification.

Event handler that is called by Lightstreamer to notify that, due to internal resource limitations, Lightstreamer Server dropped one or more updates for an item in the Subscription. Such notifications are sent only if the items are delivered in an unfiltered mode; this occurs if the subscription mode is:

• RAW
• MERGE or DISTINCT, with unfiltered dispatching specified
• COMMAND, with unfiltered dispatching specified
• COMMAND, without unfiltered dispatching specified (in this case, notifications apply to ADD and DELETE events only)

By implementing this method it is possible to perform recovery actions.

Event handler that is called by Lightstreamer each time an update pertaining to an item in the Subscription has been received from the Server.

Event handler that receives a notification when the SubscriptionListener instance is removed from a Subscription through Subscription#removeListener. This is the last event to be fired on the listener.

Event handler that receives a notification when the SubscriptionListener instance is added to a Subscription through Subscription#addListener. This is the first event to be fired on the listener.

Event handler that is called by Lightstreamer to notify the client with the real maximum update frequency of the Subscription. It is called immediately after the Subscription is established and in response to a requested change (see Subscription#setRequestedMaxFrequency). Since the frequency limit is applied on an item basis and a Subscription can involve multiple items, this is actually the maximum frequency among all items. For Subscriptions with two-level behavior (see Subscription#setCommandSecondLevelFields and Subscription#setCommandSecondLevelFieldSchema) , the reported frequency limit applies to both first-level and second-level items.
The value may differ from the requested one because of restrictions operated on the server side, but also because of number rounding.
Note that a maximum update frequency (that is, a non-unlimited one) may be applied by the Server even when the subscription mode is RAW or the Subscription was done with unfiltered dispatching.

Event handler that is called by Lightstreamer to notify that a Subscription has been successfully subscribed to through the Server. This can happen multiple times in the life of a Subscription instance, in case the Subscription is performed multiple times through LightstreamerClient#unsubscribe and LightstreamerClient#subscribe. This can also happen multiple times in case of automatic recovery after a connection restart.
This notification is always issued before the other ones related to the same subscription. It invalidates all data that has been received previously.
Note that two consecutive calls to this method are not possible, as before a second onSubscription event is fired an onUnsubscription event is eventually fired.
If the involved Subscription has a two-level behavior enabled, second-level subscriptions are not notified.

Event handler that is called when the Server notifies an error on a Subscription. By implementing this method it is possible to perform recovery actions.
Note that, in order to perform a new subscription attempt, LightstreamerClient#unsubscribe and LightstreamerClient#subscribe should be issued again, even if no change to the Subscription attributes has been applied.

Event handler that is called by Lightstreamer to notify that a Subscription has been successfully unsubscribed from. This can happen multiple times in the life of a Subscription instance, in case the Subscription is performed multiple times through LightstreamerClient#unsubscribe and LightstreamerClient#subscribe. This can also happen multiple times in case of automatic recovery after a connection restart.

After this notification no more events can be recieved until a new SubscriptionListener#onSubscription event.
Note that two consecutive calls to this method are not possible, as before a second onUnsubscription event is fired an onSubscription event is eventually fired.
If the involved Subscription has a two-level behavior enabled, second-level unsubscriptions are not notified.

This method is automatically called by the constructor of this class. It will bind the current instance with the HTML element having the id specified in the constructor.

Operation method that sets or changes the limits for the visible part of the X axis of the chart (that is, the minimum and maximum X-coordinates shown in the chart). If these limits are changed while the internal model is not empty then this causes a repaint of the whole chart.
Note that rising the minimum X value shown also clears from the memory all the points whose X value becomes lower. So, those points will not be displayed again after lowering again the minimum X value.

Lifecycle: The X axis limits can be set at any time.

Removes a listener from the Chart instance so that it will not receive events anymore.

Lifecycle: a listener can be removed at any time.

Removes a row from the internal model and reflects the change on the view. If no row associated with the given key is found nothing is done.

Lifecycle: once the AbstractWidget#parseHtml method has been called, this method can be used at any time.

Removes field(s) currently used as the source of the Y-coordinate for each update and all the related ChartLine.
It is possible to specify an array of fields instead of specifying a single field. If that's the case all the specified fields and related chart lines will be removed.

Lifecycle: The method can be invoked at any time, in order to remove plotted fields.

Utility method that can be used to control part of the behavior of the widget in case it is used as a listener for one or more Subscription instances.
Specifying the two flags it is possible to decide to clean the model and view based on the status (subscribed or not) of the Subscriptions this instance is listening to.

Lifecycle: This method can be called at any time.

Setter method that sets the field to be used as the source of the X-coordinate for each update. An optional parser can be passed to normalize the value before it is used to plot the chart. The resulting values should be in the limits posed by the Chart#positionXAxis method, otherwise a ChartListener#onXOverflow event is fired to handle the situation. null can also be specified, in which case, if the associated Y value is null the chart will be cleared, otherwise the update will be ignored.

Lifecycle: The X axis field can be set at any time. Until set, no chart will be printed. If already set, the new setting only affects the new points while all the previously plotted points are cleaned.

Setter method that configures the legend for the X axis. The legend consists of a specified number of labels for the values in the X axis. The labels values are determined based on the axis limits; the labels appearance is controlled by supplying a stylesheet and a formatter function.
Note that the room for the X axis labels on the page is not provided by the library; it should be provided by specifying a chart height smaller than the container element height, through the Chart#configureArea setting. Moreover, as the first and last labels are centered on the chart area borders, a suitable space should be provided also on the left and right of the chart area, through the same method.

Lifecycle: Labels can be configured at any time. If not set, no labels are displayed relative to the X axis.

Updates a row in the internal model and reflects the change on the view. If no row associated with the given key is found then a new row is created.
Example usage:
myWidget.updateRow("key1", {field1:"val1",field2:"val2"});

Lifecycle: once the AbstractWidget#parseHtml method has been called, this method can be used at any time. If called while an updateRow on the same internal model is still executing (e.g. if called while handling an onVisualUpdate callback), then the new update:

• if pertaining to a different key and/or if called on a Chart instance, will be postponed until the first updateRow execution terminates;
• if pertaining to the same key and if called on a StaticGrid / DynaGrid instance, will be merged with the current one.