indexes and tweaks

docs/actions.md

@@ -1 +0,0 @@
-# Actions

docs/guide/app.md

@@ -41,7 +41,7 @@ One such event is the *mount* event which is sent to an application after it ent
 
 !!! info
 
-    You may have noticed we use the term "send" and "sent" in relation to event handler methods in preference to "calling". This is because Textual uses a message passing system where events are passed (or *sent*) between components. We will cover the details in [events][events.md].
+    You may have noticed we use the term "send" and "sent" in relation to event handler methods in preference to "calling". This is because Textual uses a message passing system where events are passed (or *sent*) between components. We will cover the details in [events][./events.md].
 
 Another such event is the *key* event which is sent when the user presses a key. The following example contains handlers for both those events:
 
@@ -99,7 +99,7 @@ Notice the `on_button_pressed` method which handles the [Button.Pressed][textual
 
 ### Mounting
 
-While composing is the preferred way of adding widgets when your app starts it is sometimes necessary to add new widget(s) in response to events. You can do this by calling [mount()](textual.widget.Widget.mount) which will add a new widget to the UI.
+While composing is the preferred way of adding widgets when your app starts it is sometimes necessary to add new widget(s) in response to events. You can do this by calling [mount()][textual.widget.Widget.mount] which will add a new widget to the UI.
 
 Here's an app which adds the welcome widget in response to any key press:
 
@@ -114,7 +114,7 @@ When you first run this you will get a blank screen. Press any key to add the we
 
 ### Exiting
 
-An app will run until you call [App.exit()](textual.app.App.exit) which will exit application mode and the [run](textual.app.App.run) method will return. If this is the last line in your code you will return to the command prompt.
+An app will run until you call [App.exit()][textual.app.App.exit] which will exit application mode and the [run][textual.app.App.run] method will return. If this is the last line in your code you will return to the command prompt.
 
 The exit method will also accept an optional positional value to be returned by `run()`. The following example uses this to return the `id` (identifier) of a clicked button.
 

docs/index.md

@@ -4,7 +4,7 @@ Welcome to the [Textual](https://github.com/Textualize/textual) framework docume
 
 <hr>
 
-Textual is a framework for building applications that run within your terminal. Such Text User Interfaces (TUIs) have a number of advantages over traditional web and desktop apps.
+Textual is a framework for building applications that run within your terminal. Text User Interfaces (TUIs) have a number of advantages over web and desktop apps.
 
 <div class="grid cards" markdown>
 

docs/tutorial.md

@@ -68,8 +68,9 @@ def repeat(text: str, count: int) -> str:
     return text * count
 ```
 
-- Parameter types follow a colon. So `text: str` indicates that `text` requires a string and `count: int` means that `count` requires an integer.
-- Return types follow `->`. So `-> str:` indicates this method returns a string.
+Parameter types follow a colon. So `text: str` indicates that `text` requires a string and `count: int` means that `count` requires an integer.
+
+Return types follow `->`. So `-> str:` indicates this method returns a string.
 
 
 ## The App class

docs/user_guide/messages.md

@@ -1,42 +0,0 @@
-# Messages & Events
-
-Each component of a Textual application has it its heart a queue of messages and a task which monitors this queue and calls Python code in response. The queue and task are collectively known as a _message pump_.
-
-You will most often deal with _events_ which are a particular type of message that are created in response to user actions, such as key presses and mouse clicks, but also internal events such as timers. These events typically originate from a Driver class which sends them to an App class which is where you write code to respond to those events.
-
-Lets write an _app_ which responds to a key event. This is probably the simplest Textual application that I can conceive of:
-
-```python
-from textual.app import App
-
-
-class Beeper(App):
-    async def on_key(self, event):
-        self.console.bell()
-
-
-Beeper.run()
-```
-
-If you run the above code, Textual will switch the terminal in to _application mode_. The terminal will go blank and the app will start processing events. If you hit any key you should hear a beep. Hit ctrl+C (control key and C key at the same time) to exit application mode and return to the terminal.
-
-Although simple, this app follows the same pattern as more sophisticated applications. It starts by deriving a class from `App`; in this case `Beeper`. Calling the classmethod `run()` starts the application.
-
-In our Beeper class there is a single event handler `on_key` which is called in response to a `Key` event. The method name is assumed by concatenating `on_` with the event name, hence `on_key` for a Key event, `on_timer` for a Timer event, etc. In Beeper, the on_key event calls `self.console.bell()` which is what plays the beep noise (if supported by your terminal).
-
-The `on_key` method is preceded by the keyword `async` making it an asynchronous method. Textual is an asynchronous framework so event handlers and most methods are async.
-
-Our Beeper app is missing typing information. Although completely optional, I recommend adding typing information which will help catch bugs (using tools such as [Mypy](https://mypy.readthedocs.io/en/stable/)). Here is the Beeper class with added typing:
-
-```python
-from textual.app import App
-from textual import events
-
-
-class Beeper(App):
-    async def on_key(self, event: events.Key) -> None:
-        self.console.bell()
-
-
-Beeper.run()
-```