New TOC for dart-by-example page

src/site/articles/event-loop/index.markdown

 ---
 layout: article
 title: "The Event Loop and Dart"
 description: "Learn how Dart handles the event queue and microtask queue, so you can write better asynchronous code with fewer surprises."
 rel:
     author: kathy-walrath
 has-permalinks: true
 article:
   written_on: 2013-09-30
   updated_on: 2013-10-22
@@ skipping 228 matching lines @@
 If you can’t, then use scheduleMicrotask() to
 add an item to the microtask queue.
 For example, in a web app use a microtask to
 avoid prematurely releasing a js-interop proxy or
 ending an IndexedDB transaction or event handler.
 
 ![shows chain of event handler execution, with tasks added using Future and scheduleMicrotask().](images/scheduling-tasks.png)
 
 
 #### Event queue: new Future()
+{:.no_toc}
 
 To schedule a task on the event queue,
 use `new Future()` or `new Future.delayed()`.
 These are two of the
 [Future](http://api.dartlang.org/dart_async/Future.html)
 constructors defined in the dart:async library.
 
 <aside class="alert alert-info" markdown="1">
 **Note:**
 You can also use
@@ skipping 65 matching lines @@
 1. The **Future()** and **Future.delayed()** constructors
 don’t complete immediately;
 they add an item to the event queue.
 1. The **Future.value()** constructor completes in a microtask,
 similar to #2.
 1. The **Future.sync()** constructor executes its function argument immediately
 and (unless that function returns a Future)
 completes in a microtask, similar to #2.
 
 #### Microtask queue: scheduleMicrotask()
+{:.no_toc}
 
 The dart:async library defines scheduleMicrotask() as a top-level function.
 You can call scheduleMicrotask() like this:
 
 {% prettify dart %}
 scheduleMicrotask(() {
   // ...code goes here...
 });
 {% endprettify %}
 
@@ skipping 208 matching lines @@
 The reason is that returning a Future from your callback
 is how you get then() (which itself returns a new Future)
 to _chain_ those two Futures together,
 so that the Future returned by then() completes
 when the Future returned by the callback completes.
 See the [then() reference](http://api.dartlang.org/docs/releases/latest/dart_async/Future.html#then)
 for more information.
 
 
 #### Annotated sample and output
+{:.no_toc}
 
 Here are some figures that might clarify the answer to question #2.
 First, here’s the annotated program source:
 
 ![Lines that schedule a microtask are gold; lines that schedule an event are blue](images/test-annotated.png)
 
 And here’s what the queues and output look like at various points in time,
 assuming no external events come in:
 
 ![3 columns: Time, Output, Queues](images/test-queue-output.png)
@@ skipping 29 matching lines @@
 avoid compute-intensive tasks on either event loop.
 * To perform compute-intensive tasks,
 create additional isolates or workers.
 
 As you write asynchronous code, you might find these resources helpful:
 
 * [Using Future Based APIs](/articles/using-future-based-apis/)
 * [Futures and Error Handling](/articles/futures-and-error-handling/)
 * [dart:async - Asynchronous Programming](/docs/dart-up-and-running/contents/ch03.html#ch03-asynchronous-programming) section of the library tour
 * [dart:async API reference](http://api.dartlang.org/dart_async.html)