Class baja.Subscriber

A Subscriber can be used to subscribe to multiple Components in the Station and can be used to listen for Component Events. For instance, a common one would be a Property changed event...

  // sub is a Subscriber and is subscribed to a Component
  sub.attach("changed", function (prop, cx) {
    if (prop.getName() === "out") {
      baja.outln("The output of the point is: " + this.getOutDisplay());
    }
  });

Here are some examples of the different event handlers that can be attached to a Component...

  // Property Changed
  sub.attach("changed", function (prop, cx) {
    // prop: the Property that has changed
    // cx: the Context (used internally)
  });
  
  // Property Added
  sub.attach("added", function (prop, cx) {
    // prop: the Property that has been added
    // cx: the Context (used internally)
  });
  
  // Property Removed
  sub.attach("removed", function (prop, val, cx) {
    // prop: the Property that has been removed
    // val: the old value of the Property
    // cx: the Context (used internally)
  });
  
  // Property Renamed
  sub.attach("renamed", function (prop, oldName, cx) {
    // prop: the Property that has been renamed
    // oldName: the old slot name
    // cx: the Context (used internally)
  });
  
  // Dynamic Slots Reordered
  sub.attach("reordered", function (cx) {
    // cx: the Context (used internally)
  });
  
  // Topic Fired
  sub.attach("topicFired", function (topic, event, cx) {
    // topic: the Topic that has been fired
    // event: the Topic event data (can be null)
    // cx: the Context (used internally)
  });
  
  // Slot Flags Changed
  sub.attach("flagsChanged", function (slot, cx) {
    // slot: the slot whose flags have changed
    // cx: the Context (used internally)
  });
  
  // Slot Facets Changed
  sub.attach("facetsChanged", function (slot, cx) {
    // slot: the slot whose facets have changed
    // cx: the Context (used internally)
  });

  // Component subscribed
  sub.attach("subscribed", function (cx) {
    // cx: the Context (used internally)
  });

  // Component unsubscribed
  sub.attach("unsubscribed", function (cx) {
    // cx: the Context (used internally)
  });

  // Component unmounted (called just before Component is removed from parent)
  sub.attach("unmount", function (cx) {
    // cx: the Context (used internally)
  });

  // Component renamed in parent
  sub.attach("componentRenamed", function (oldName, cx) {
    // cx: the Context (used internally)
  });

  // Component's flags changed in parent
  sub.attach("componentFlagsChanged", function (cx) {
    // cx: the Context (used internally)
  });

  // Component's facets changed in parent
  sub.attach("componentFacetsChanged", function (cx) {
    // cx: the Context (used internally)
  });

  // Component reordered in parent
  sub.attach("componentReordered", function (cx) {
    // cx: the Context (used internally)
  });

An Object Literal can be used to specify multiple handlers. For example...

  var sub = new baja.Subscriber();
  sub.attach({
    changed: function (prop, cx) {
    },
    subscribed: function (cx) {
    }
  });

Spaces can be used in a name to specify a function for multiple events...

  var sub = new baja.Subscriber();
  sub.attach("subscribed changed", function () {
    updateGui(this);
  });

If no arguments are used with this method then all events are removed.

For a list of all the event handlers, please see baja.Subscriber#attach.

A String with spaces can be supplied to remove multiple event handlers. For example...

  sub.detach("subscribed changed"); // Remove all subscribed and changed event handlers

For a list of all the event handlers, please see baja.Subscriber#attach.

To access multiple handlers, insert a space between the handler names.

If no handler name is specified then test to see if there are any handlers registered at all.

For a list of all the event handlers, please see baja.Subscriber#attach.

Multiple handlers can be tested for by using a space character between the names.

This will put the Components into subscription if they are not already subscribed and are mounted. The Subscription will last until the page is refreshed or unsubscribe is called.

If the Components are mounted and able to be subscribed, this will result in an asynchronous network call.

A Component instance, array of Components or an optional Object Literal can be used to specify the method's arguments...

  // Subscribe a single Component
  sub.subscribe(aComp);

  // ...or subscribe an array of Components...
  sub.subscribe([aComp1, aComp2]);

  // ...or use an Object Literal for more arguments...
  sub.subscribe({
    comps: [aComp1, aComp2], // Can also just be an singular Component instance
    ok: function () {
      // Called once the Components are subscribed (optional)
    },
    fail: function (err) {
      // Called if the Components fail to subscribe (optional)
    },
    batch // if defined, any network calls will be batched into this object (optional)
  });

This will unsubscribe the mounted Components if they are not already unsubscribed.

If the Components are able to be unsubscribed, this will result in an asynchronous network call.

A Component instance, array of Components or an optional Object Literal can be used to specify the method's arguments...

  // Unsubscribe a single Component
  sub.unsubscribe(aComp);

  // ...or unsubscribe an array of Components...
  sub.unsubscribe([aComp1, aComp2]);

  // ...or use an Object Literal for more arguments...
  sub.unsubscribe({
    comps: [aComp1, aComp2], // Can also just be an singular Component instance
    ok: function () {
      // Called once the Components are unsubscribed (optional)
    },
    fail: function (err) {
      // Called if the Components fail to unsubscribe (optional)
    },
    batch // if defined, any network calls will be batched into this object (optional)
  });

This will unregister all Components from this Subscriber.

If the Components are able to be unsubscribed, this will result in an asynchronous network call.

An Object Literal is used to specify the method's arguments...

  // ...or use an Object Literal for more arguments...
  sub.unsubscribeAll({
    ok: function () {
      // Called once the Components are unsubscribed (optional)
    },
    fail: function (err) {
      // Called if the Components fail to unsubscribe (optional)
    },
    batch // if defined, any network calls will be batched into this object (optional)
  });