Module lyntin.engine

This holds the engine which both contains most of the other objects that do work in Lyntin as well as encapsulates the event queue, event handling methods, and some of the other singleton managers such as the HelpManager and the CommandManager.

Engine also holds hooks to the various event types. Events will call all appropriate hooks allowing you to add functionality via the modules interface without changing the Lyntin internals.

The engine also holds a list of registered threads. This helps in diagnostics. Use the methods in exported to handle spinning off threads.

The Engine class is a singleton and the reference to it is stored in "engine.Engine.instance". However, you should use the exported module to access the engine using the "get_engine()" function.

  The startup hook is called after Lyntin has bootstrapped itself
  enough to allow everything to initialize itself.

  Arg mapping: {}

  When Lyntin is shutting down, this hook is called.  It's possible
  Lyntin might be in a state of disarray at this point, so it's not
  clear what is and what is not available.

  Arg mapping: {}

  The timer hook spams all registered functions every second.  This
  is how the scheduler works.

  Arg mapping: { "tick": int }

  tick - the current tick (starts at 0)

  All input typed in by the user (as well as other things that
  eventually go through the handleUserData method) get passed
  through this hook (unless it's specified as internal).  All
  registered functions get to see the raw user data this way.

  Arg mapping: {"data": string}

  data - the user data passed into handleUserData

  This hook is for data to be displayed to the user.  The UI listens
  on this hook as do logger functions.

  NOTE: Functions registered with this hook should NEVER call 
  exported.write* functions.  That will result in an infinite loop and 
  then Lyntin will either hang or die.  If you want to spit out output
  use an OutputEvent.

  Arg mapping: { "message": string }

  message - The message to be displayed.  This can be either a string
            of a ui.base.Message object.

  Every time an event kicks up an unhandled error, we add one to
  our error count and also spam this hook with the current
  number of errors.

  Arg mapping: { "count": int }

  count - the current number of errors

  When we hit the maximum number of errors, this hook gets spammed and
  then Lyntin shuts down.

  Arg mapping: {}

  This hook gets spammed whenever the current session changes,
  after changing.

  Arg mapping: { "new": session.Session, "previous": session.Session }

  new - the session that is being changed to

  previous - the session that was previously the current session