Merge branch 'testing'

Display session information very early in logs, this makes it easy to figure out if a reported problem is something that needs priority attention or if it may be ran on an unsupported platform.
Preparing for releases, no new features, only testing and bug fixes until new version is tagged.
2026-01-01 00:17:30 -05:00 · 2025-12-31 18:43:08 -05:00 · 2025-12-31 13:26:45 -05:00 · 2025-12-31 13:05:53 -05:00 · 2025-12-30 14:30:09 -05:00 · 2025-12-30 14:29:37 -05:00
992 changed files with 33696 additions and 161431 deletions
@@ -1,7 +1,11 @@
+# Meson build artifacts
+_build/
+builddir/
+build/
+
+# Legacy autotools artifacts (if any remain)
 ABOUT-NLS
 INSTALL
-Makefile
-Makefile.in
 aclocal.m4
 autom4te.cache
 compile
@@ -39,6 +43,57 @@ bld
 patch.*
 [0-9][0-9][0-9][0-9][-]*

+# Generated Python files
+src/cthulhu/cthulhu_bin.py
+src/cthulhu/cthulhu_i18n.py
+src/cthulhu/cthulhu_platform.py
+
+# Python bytecode
+*.pyc
+*.pyo
+__pycache__/
+
+# Editor backup files
+*~
+*.bak
+*.swp
+*.tmp
+*.orig
+*.rej
+
+# AT-SPI test/debug files
+debug*.log
+debug*.out
+
+# Local build directory and artifacts
+local-build/
+debug-*.out
+debug.log
+*.gmo
+*.pot
+
+# Package artifacts
+*.pkg.tar.zst
+distro-packages/*/cthulhu/
+distro-packages/*/pkg/
+
+# Generated makefiles (should not be committed)
+Makefile
+Makefile.in
+
+# Sound files (if binary)
+sounds/
+
+# Test files that might be temporary
+test-dbus.sh
+test-local-meson.sh
+test_displayversion.py
+PORTING-NOTES.md
+
+# Translation files
+po/stamp-po
+po/insert-header.sed
+
 # /help
 /help/*.omf
 /help/*/*.page
@@ -0,0 +1,56 @@
+# AGENTS.md (Codex CLI guidance)
+
+This repository is a screen reader. Prioritize accessibility, correctness, and stability over “clever” changes.
+
+## System interactions
+- If a command requires `sudo`, stop and ask the user to run it (no password entry is possible from here).
+
+## Build / run quick refs
+- Local dev build + install: `./build-local.sh`
+- Quick local sanity checks: `./test-local.sh`
+- Clean local artifacts/install: `./clean-local.sh`
+- Meson (manual):
+  - `meson setup _build --prefix=$HOME/.local`
+  - `meson compile -C _build`
+  - `meson install -C _build`
+
+## Coding guidelines
+- **When modifying existing code:** follow the surrounding code’s conventions.
+- **When writing new code from scratch:** prefer
+  - variables: `camelCase`
+  - functions/methods: `snake_case`
+  - classes: `PascalCase`
+- Add debug logs where helpful for troubleshooting. When adding timestamps to logs, use: `"Message [timestamp]"` (message first).
+
+## Accessibility requirements (high priority)
+### General
+- Screen-reader-first UX: assume non-visual navigation.
+- No keyboard traps; Tab/Shift+Tab must move through all controls.
+- Use clear, complete labels (e.g., “Confirm Password”, not “Confirm”).
+- **No Speech-Dispatcher usage in GUI apps** (no `spd-say`); rely on the accessibility API.
+
+### Python GTK (Gtk 3)
+- Associate labels with controls (mnemonics + buddy widget):
+  - `label.set_use_underline(True)`
+  - `label.set_mnemonic_widget(entry)`
+- For `Gtk.TextView`, call `set_accepts_tab(False)` so Tab moves focus.
+- For custom widgets, set accessible name/role via ATK where applicable.
+
+### PySide6 / Qt
+- Set `setAccessibleName()` on all widgets.
+- Associate labels via `setBuddy()`.
+- Use `setAccessibleDescription()` when extra context is needed.
+
+## Shell script rules
+- **Bash variables must be `camelCase`** (except system env vars like `ACCESSIBILITY_ENABLED`).
+- If you edit a `#!/usr/bin/env bash`, `#!/bin/bash`, or POSIX `sh` script, run `shellcheck` and fix issues.
+- Avoid colorized output unless explicitly requested (accessibility-first; keep scripts simple).
+
+## Plugins (Cthulhu)
+- System plugins live in `src/cthulhu/plugins/`.
+- Follow existing plugin patterns (keybinding registration, GTK dialog/window patterns, debug logging).
+- Ensure plugin install integration is wired via Meson (`src/cthulhu/plugins/meson.build` + plugin subdir `meson.build`).
+
+## Meson install reminder (important)
+- If you add new Python modules under `src/cthulhu/`, update `src/cthulhu/meson.build` so they get installed (otherwise imports can fail after install).
+- If you add a new plugin directory, update `src/cthulhu/plugins/meson.build` and add a `meson.build` in the plugin directory.
@@ -1,14 +0,0 @@
-Cthulhu Authors
-
-Marc Mulcahy
-Willie Walker
-Mike Pedersen
-Rich Burridge
-Joanmarie Diggs
-Eitan Isaacson
-Scott Haeger
-
-
-Cthulhu authors
-
-Storm Dragon
@@ -0,0 +1,845 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+Cthulhu is a fork of the Orca screen reader, providing access to the graphical desktop via speech and/or braille. It's designed as a supplemental screen reader for advanced users, particularly useful for older Qt applications and specific window managers like i3.
+
+## Build System and Commands
+
+### Local Development Build (Recommended)
+```bash
+# Build and install locally to ~/.local (no system overwrite)
+./build-local.sh
+
+# Test local installation
+./test-local.sh
+
+# Run local version
+~/.local/bin/cthulhu
+
+# Clean build artifacts and local installation
+./clean-local.sh
+```
+
+### System Build (Meson)
+```bash
+# Configure and build for system installation
+meson setup _build --prefix=/usr
+meson compile -C _build
+sudo meson install -C _build
+```
+
+### Alternative Build (Python packaging)
+```bash
+# Using pip/hatchling
+pip install -e .
+```
+
+### Testing
+```bash
+# Run all regression tests
+test/harness/runall.sh
+
+# Run single test
+test/harness/runone.sh <test.py> <app-name>
+
+# Run specific app tests
+test/harness/runall.sh -a /path/to/app/tests
+
+# Coverage analysis
+test/harness/runall.sh -c
+
+# Profile mode
+test/harness/runall.sh -p
+```
+
+## Core Architecture
+
+### Main Components
+- **Event System**: `event_manager.py`, `signal_manager.py` - Central event handling
+- **Accessibility Layer**: `ax_object.py`, `ax_utilities.py` - AT-SPI object management  
+- **Output Systems**: `speech.py`, `braille.py` - Speech and braille generation
+- **Navigation**: `structural_navigation.py`, `flat_review.py` - Document and screen navigation
+- **Plugin System**: `plugin_system_manager.py` - Extensible plugin architecture using pluggy
+
+### Application Scripts
+Scripts in `src/cthulhu/scripts/` provide application-specific behavior:
+- `scripts/apps/` - Specific applications (Firefox, Thunderbird, LibreOffice)
+- `scripts/toolkits/` - Toolkit support (GTK, Qt, Gecko, WebKit)
+- `scripts/web/` - Web browsing enhancements
+
+### Plugin Development
+System plugins in `src/cthulhu/plugins/`, user plugins in `~/.local/share/cthulhu/plugins/`:
+
+#### Basic Plugin Structure
+```
+src/cthulhu/plugins/MyPlugin/
+├── __init__.py          # Package import: from .plugin import MyPlugin
+├── plugin.py            # Main implementation
+├── plugin.info          # Metadata
+└── meson.build          # Meson install integration
+```
+
+#### Minimal Plugin Template
+```python
+from cthulhu.plugin import Plugin, cthulhu_hookimpl
+
+class MyPlugin(Plugin):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._enabled = True
+        
+    @cthulhu_hookimpl
+    def activate(self, plugin=None):
+        if plugin is not None and plugin is not self:
+            return
+        # Plugin activation logic
+        return True
+        
+    @cthulhu_hookimpl  
+    def deactivate(self, plugin=None):
+        if plugin is not None and plugin is not self:
+            return
+        # Cleanup logic
+        return True
+```
+
+#### Plugin Integration Patterns
+
+**1. Keybinding Registration:**
+```python
+def _register_keybinding(self):
+    if not self.app:
+        return
+    api_helper = self.app.getAPIHelper()
+    self._kb_binding = api_helper.registerGestureByString(
+        "Cthulhu+key", self._handler_method, "Description"
+    )
+```
+
+**2. Accessing Cthulhu APIs:**
+```python
+# Get current active script
+state = self.app.getDynamicApiManager().getAPI('CthulhuState')
+active_script = state.activeScript
+
+# Access speech/messages
+speech = self.app.getDynamicApiManager().getAPI('Speech')
+messages = self.app.getDynamicApiManager().getAPI('Messages')
+```
+
+**3. Sound Generation:**
+```python
+from cthulhu import sound
+from cthulhu.sound_generator import Tone
+
+# Initialize player
+self._player = sound.getPlayer()
+
+# Create and play tone
+tone = Tone(duration=0.15, frequency=400, volumeMultiplier=0.7)
+self._player.play(tone, interrupt=False)
+```
+
+**4. Script Method Monkey-Patching:**
+```python
+def _monkey_patch_script_methods(self):
+    state = self.app.getDynamicApiManager().getAPI('CthulhuState')
+    if state and state.activeScript:
+        script = state.activeScript
+        self._original_method = script.methodName
+        
+        def wrapped_method(*args, **kwargs):
+            result = self._original_method(*args, **kwargs)
+            # Add custom logic here
+            return result
+            
+        script.methodName = wrapped_method
+```
+
+#### Plugin Files
+
+**plugin.info format:**
+```ini
+[Core]
+Name = PluginName
+Module = PluginName
+
+[Documentation]
+Description = Plugin description
+Author = Author Name
+Version = 1.0.0
+Website = https://example.com
+```
+
+**meson.build template:**
+```meson
+plugin_python_sources = files([
+  '__init__.py',
+  'plugin.py',
+])
+
+python3.install_sources(
+  plugin_python_sources,
+  subdir: 'cthulhu/plugins/PluginName'
+)
+
+install_data(
+  'plugin.info',
+  install_dir: python3.get_install_dir() / 'cthulhu' / 'plugins' / 'PluginName'
+)
+```
+
+**Build Integration:**
+Add plugin to `src/cthulhu/plugins/meson.build`:
+
+```meson
+subdir('PluginName')
+```
+
+#### Advanced Plugin Features
+
+**Event System Integration:**
+- Register with Dynamic API: `api_manager.registerAPI('MyPlugin', self)`
+- Hook into script changes via monkey-patching
+- Access event manager for custom event handling
+
+**Text Analysis:**
+- Use `script.getTextLineAtCaret(obj)` for current line
+- Access text attributes via `script.utilities.getTextAttributes()`
+- Leverage existing utilities like `indentationDescription()`
+
+**Settings Integration:**
+- Access settings manager: `settings_manager.getManager()`
+- Create plugin-specific settings with prefixes
+- Integrate with preferences GUI if needed
+
+## Development Workflow
+
+### Contributing
+- Repository: https://git.stormux.org/storm/cthulhu
+- Create branch for changes, merge to master when ready
+- Email patches to storm_dragon@stormux.org if no direct access
+- Community: IRC #stormux on irc.stormux.org
+
+### Key Dependencies
+- Python 3.9+, pygobject-3.0, pluggy, gtk+-3.0
+- AT-SPI2, ATK for accessibility
+- Optional: BrlTTY/BrlAPI (braille), Speech Dispatcher, liblouis, GStreamer
+
+### Version Information
+Current version and codename in `src/cthulhu/cthulhuVersion.py`
+
+### Self-voicing Feature
+Direct speech output via Unix socket:
+```bash
+echo "Hello world." | socat - UNIX-CLIENT:/tmp/cthulhu.sock
+echo "<!#APPEND#!>Hello world." | socat - UNIX-CLIENT:/tmp/cthulhu.sock  # No interrupt
+echo "Hello world.<#APPEND#>" | socat - UNIX-CLIENT:/tmp/cthulhu.sock    # Persistent braille
+```
+
+## Key Directories
+
+- `src/cthulhu/` - Core source code
+- `test/` - Regression test framework with keystroke-based testing
+- `po/` - Internationalization files (extensive i18n support)
+- `help/` - Multi-language user documentation
+- `ci/` - Continuous integration scripts
+
+## Testing Notes
+
+The test system uses keystroke recording/playback with speech and braille output comparison. Tests are organized by application and toolkit. The testing framework automatically handles application launching and result comparison for regression testing.
+
+---
+
+## ORCA vs CTHULHU COMPARISON & INTEGRATION CONSIDERATIONS
+
+### **Fork History & Strategic Decisions**
+- **Cthulhu Origin**: Forked from Orca 45 (GNOME-45 release) - `git log` shows initial commit `a523205`
+- **Strategic Goals**: 
+  - Supplemental screen reader for advanced users
+  - Better support for older Qt applications
+  - Enhanced window manager support (i3, etc.)
+  - Plugin system with pluggy framework
+  - Community-driven development
+
+### **Major Architectural Differences**
+
+#### **Build Systems**
+- **Cthulhu**: Meson/Ninja (primary build system)
+- **Orca**: Meson/Ninja
+
+#### **Plugin Architecture**
+- **Cthulhu**: Extensive pluggy-based plugin system with 9 core plugins
+- **Orca**: No comparable plugin system - features are integrated directly into core
+- **Strategic Value**: Plugin system is Cthulhu's key differentiator - maintain this advantage
+
+#### **New Orca Features (v49.alpha)**
+1. **D-Bus Remote Controller** (`dbus_service.py`)
+   - Service: `org.gnome.Orca.Service`
+   - Remote command execution, module access
+   - Requires: `dasbus` library
+   - **Integration Value**: HIGH - would enable external control of Cthulhu
+
+2. **Spiel TTS Support** (`spiel.py`)
+   - Alternative to speech-dispatcher
+   - Multi-synthesizer support (eSpeak, Piper)
+   - Flatpak-based providers
+   - **Integration Value**: MEDIUM - broader TTS options
+
+3. **Enhanced Module Architecture**
+   - `focus_manager.py`, `input_event_manager.py`
+   - Better separation of concerns
+   - **Integration Value**: LOW - architectural improvement but not user-facing
+
+### **Current Bug Investigation: Plugin Keybindings**
+[Previous debugging section remains valid - plugin keybinding integration is working but needs refinement]
+
+### **Integration Recommendations**
+
+#### **HIGH Priority - D-Bus Remote Controller**
+- **Benefit**: External application control, automation, integration with other tools
+- **Risk**: LOW - self-contained feature, minimal core impact
+- **Files to Port**: `dbus_service.py`, related D-Bus infrastructure
+- **Dependencies**: Add `dasbus` to Cthulhu's requirements
+
+#### **MEDIUM Priority - Build System Migration**
+- **Benefit**: Faster builds, better dependency management, alignment with GNOME ecosystem
+- **Risk**: MEDIUM - significant build system changes, potential disruption
+- **Approach**: Gradual migration, maintain autotools compatibility initially
+
+#### **LOW Priority - Spiel Integration**
+- **Benefit**: More TTS options, potentially better voice quality
+- **Risk**: MEDIUM - additional complexity, Flatpak dependencies
+- **Approach**: Optional feature, don't replace speech-dispatcher by default
+
+### **Files Requiring Attention for Integration**
+
+#### **D-Bus Remote Controller Integration**:
+```bash
+# Core files to review and potentially port:
+src/orca/dbus_service.py           # Main D-Bus service implementation
+README-REMOTE-CONTROLLER.md       # API documentation and examples
+```
+
+#### **Build System Files**:
+```bash
+# Modern build configuration to consider:
+meson.build                        # Root build configuration
+meson_options.txt                  # Build options
+subprojects/spiel.wrap            # Subproject integration
+```
+
+### **Strategic Questions for Decision**
+
+1. **Build System**: Should Cthulhu migrate to Meson for better GNOME ecosystem alignment?
+2. **D-Bus Interface**: High value feature - should this be priority #1 for integration?
+3. **Plugin System**: How to maintain Cthulhu's plugin advantage while integrating Orca improvements?
+4. **Version Strategy**: Selective feature backporting vs. major version sync?
+
+## AI Assistant Integration
+
+### **NEW FEATURE**: AI-Powered Accessibility Assistant
+Cthulhu now includes an optional AI assistant plugin for enhanced accessibility support:
+
+- **Vision Analysis**: Screenshots + AT-SPI data for understanding unlabeled UI elements
+- **Safe Actions**: Confirmed element clicking and navigation assistance  
+- **Multi-Provider Support**: Claude, ChatGPT, Gemini, and Ollama backends
+- **Privacy-First**: Disabled by default, requires explicit opt-in and API key configuration
+
+### AI Assistant Configuration
+```bash
+# Access via Cthulhu Preferences
+~/.local/bin/cthulhu -s  # Opens preferences dialog
+# Navigate to "AI Assistant" tab
+# 1. Check "Enable AI Assistant" 
+# 2. Select provider (Claude, ChatGPT, Gemini, Ollama)
+# 3. Set API key file path
+# 4. Configure safety and quality settings
+```
+
+### AI Assistant Keybindings
+- **Cthulhu+Control+Shift+Q**: Ask questions about current screen
+- **Cthulhu+Control+Shift+D**: Describe current screen 
+- **Cthulhu+Control+Shift+A**: Request actions (click, type, copy)
+
+### AI Provider Setup
+
+#### 1. Claude (Anthropic) - **Recommended**
+```bash
+# Get API key from: https://console.anthropic.com/
+# 1. Sign up/login → "Get API Keys" → Create new key
+# 2. Copy the key (starts with "sk-ant-...")
+# 3. Save to file:
+mkdir -p ~/.config/cthulhu
+echo "sk-ant-your-actual-key-here" > ~/.config/cthulhu/claude-api-key
+chmod 600 ~/.config/cthulhu/claude-api-key
+
+# Pricing: ~$3 per million input tokens, ~$15 per million output tokens
+# Best vision capabilities and safety for accessibility use
+```
+
+#### 2. ChatGPT (OpenAI)
+```bash
+# Get API key from: https://platform.openai.com/api-keys  
+# 1. Sign up/login → "Create new secret key"
+# 2. Copy immediately (can't view again, starts with "sk-...")
+# 3. Save to file:
+mkdir -p ~/.config/cthulhu
+echo "sk-your-actual-openai-key" > ~/.config/cthulhu/openai-api-key
+chmod 600 ~/.config/cthulhu/openai-api-key
+
+# Pricing: ~$2.50 per million input tokens, ~$10 per million output tokens
+# Good vision capabilities, widely supported
+```
+
+#### 3. Gemini (Google) 
+```bash
+# Get API key from: https://aistudio.google.com/app/apikey
+# 1. Sign up/login → "Create API key" 
+# 2. Copy the generated key
+# 3. Save to file:
+mkdir -p ~/.config/cthulhu
+echo "your-actual-gemini-key" > ~/.config/cthulhu/gemini-api-key
+chmod 600 ~/.config/cthulhu/gemini-api-key
+
+# Pricing: Free tier (15 requests/min), then ~$1.25 per million tokens
+# Good for testing, has generous free allowance
+```
+
+#### 4. Ollama (Local) - **Privacy-Focused**
+```bash
+# Install Ollama (no API key needed!)
+sudo pacman -S ollama  # Arch Linux
+# OR: curl -fsSL https://ollama.ai/install.sh | sh
+
+# Start service
+systemctl --user enable ollama
+systemctl --user start ollama
+
+# Download vision-capable model (required for AI assistant)
+ollama pull llama3.2-vision  # 7.9GB download
+# OR smaller model: ollama pull moondream    # 1.7GB
+
+# Verify installation
+ollama list  # Should show downloaded models
+
+# No API key needed - runs entirely offline!
+# Free to use, privacy-focused, but slower than cloud providers
+```
+
+### AI Assistant Usage Patterns
+- **Information Queries**: "What does this unlabeled button do?"
+- **Navigation Help**: "Where is the login form?" 
+- **Action Assistance**: "Click the submit button", "Type hello world and press enter"
+- **Layout Understanding**: "Describe the main sections of this page"
+- **Text Operations**: "Copy this text to clipboard", "Enter my username in the field"
+
+### Safety Framework
+- **Confirmation Required**: All actions require user approval by default
+- **Action Descriptions**: Clear explanation of what will happen before execution
+- **Safe Defaults**: Conservative timeouts and quality settings
+- **Privacy Protection**: API keys stored securely, no data logging
+- **Action Types**: Click, Type, Copy operations via PyAutoGUI (Wayland/X11 compatible)
+
+### Troubleshooting AI Assistant Setup
+
+#### Common Issues
+```bash
+# Check if AI settings loaded correctly
+~/.local/bin/cthulhu -s  # Open preferences, check AI Assistant tab
+
+# Verify API key file permissions and format
+ls -la ~/.config/cthulhu/*-api-key  # Should show 600 permissions
+cat ~/.config/cthulhu/claude-api-key  # Should contain only the API key
+
+# Test Ollama connection
+curl http://localhost:11434/api/version  # Should return Ollama version
+ollama ps  # Should show running models
+
+# Check dependencies
+python3 -c "import requests, PIL, pyautogui; print('Dependencies OK')"
+
+# Test screenshot capability (requires X11/Wayland)
+python3 -c "
+from gi.repository import Gdk
+window = Gdk.get_default_root_window()
+print('Screenshot capability available')
+"
+```
+
+#### Required Permissions
+- **File Access**: API key files in `~/.config/cthulhu/`
+- **Screen Access**: Screenshot capture (automatic on most setups)
+- **Network Access**: HTTP requests to AI providers (except Ollama)
+- **AT-SPI Access**: Accessibility tree traversal (enabled by default)
+- **Input Synthesis**: PyAutoGUI for action execution (click, type, copy)
+
+## Cthulhu Plugin System - Developer Reference
+
+### **Plugin Architecture Overview**
+
+Cthulhu uses a **pluggy-based plugin system** with the following components:
+
+1. **Plugin Manager**: `src/cthulhu/plugin_system_manager.py` - Central plugin loading/management
+2. **Base Plugin Class**: `src/cthulhu/plugin.py` - Provides common functionality
+3. **Hook System**: Uses `@cthulhu_hookimpl` decorators for lifecycle management
+4. **Plugin Discovery**: Automatic scanning of `src/cthulhu/plugins/` and `~/.local/share/cthulhu/plugins/`
+
+### **Plugin Directory Structure**
+
+Every plugin must follow this exact structure:
+```
+src/cthulhu/plugins/YourPlugin/
+├── __init__.py          # Import: from .plugin import YourPlugin
+├── plugin.py            # Main plugin class
+├── plugin.info          # Metadata (name, version, description)
+└── meson.build          # Meson install integration
+```
+
+### **Essential Plugin Files**
+
+#### **`__init__.py`** - Package Import
+```python
+from .plugin import YourPlugin
+```
+
+#### **`plugin.info`** - Metadata
+```ini
+name = Your Plugin Name
+version = 1.0.0
+description = What your plugin does
+authors = Your Name <email@example.com>
+website = https://example.com
+copyright = Copyright 2025
+builtin = false
+hidden = false
+```
+
+#### **`meson.build`** - Build Integration
+```meson
+yourplugin_python_sources = files([
+  '__init__.py',
+  'plugin.py',
+])
+
+python3.install_sources(
+  yourplugin_python_sources,
+  subdir: 'cthulhu/plugins/YourPlugin'
+)
+
+install_data(
+  'plugin.info',
+  install_dir: python3.get_install_dir() / 'cthulhu' / 'plugins' / 'YourPlugin'
+)
+```
+
+### **Plugin Class Template**
+
+```python
+#!/usr/bin/env python3
+import logging
+from cthulhu.plugin import Plugin, cthulhu_hookimpl
+
+logger = logging.getLogger(__name__)
+
+class YourPlugin(Plugin):
+    """Your plugin description."""
+    
+    def __init__(self, *args, **kwargs):
+        """Initialize the plugin."""
+        super().__init__(*args, **kwargs)
+        logger.info("YourPlugin initialized")
+        
+        # Keybinding storage - use individual variables, NOT dictionaries
+        self._kb_binding = None
+        
+    @cthulhu_hookimpl
+    def activate(self, plugin=None):
+        """Activate the plugin."""
+        if plugin is not None and plugin is not self:
+            return
+            
+        try:
+            logger.info("=== YourPlugin activation starting ===")
+            
+            # Register keybindings
+            self._register_keybinding()
+            
+            logger.info("YourPlugin activated successfully")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error activating YourPlugin: {e}")
+            return False
+    
+    @cthulhu_hookimpl
+    def deactivate(self, plugin=None):
+        """Deactivate the plugin."""
+        if plugin is not None and plugin is not self:
+            return
+            
+        logger.info("Deactivating YourPlugin")
+        self._kb_binding = None
+        return True
+        
+    def _register_keybinding(self):
+        """Register plugin keybindings."""
+        try:
+            # CRITICAL: Use this exact parameter order!
+            self._kb_binding = self.registerGestureByString(
+                self._your_handler_method,    # Handler method (first)
+                "Description of action",      # Description (second) 
+                'kb:cthulhu+your+keys'       # Gesture string (third)
+            )
+            
+            if self._kb_binding:
+                logger.info(f"Registered keybinding: {gesture_string}")
+            else:
+                logger.error(f"Failed to register keybinding")
+                
+        except Exception as e:
+            logger.error(f"Error registering keybinding: {e}")
+    
+    def _your_handler_method(self, script=None, inputEvent=None):
+        """Handle the keybinding activation."""
+        try:
+            logger.info("Keybinding triggered")
+            
+            # Your plugin logic here
+            
+            return True
+        except Exception as e:
+            logger.error(f"Error in handler: {e}")
+            return False
+```
+
+### **🚨 CRITICAL Keybinding Patterns**
+
+#### **✅ CORRECT Pattern (What Works)**
+```python
+# Individual binding storage (NOT dictionaries)
+self._kb_binding = None
+self._kb_binding_action1 = None  
+self._kb_binding_action2 = None
+
+# Correct registerGestureByString parameter order
+self._kb_binding = self.registerGestureByString(
+    self._handler_method,        # 1st: Handler method
+    "Action description",        # 2nd: Description  
+    'kb:cthulhu+your+keys'      # 3rd: Gesture string
+)
+```
+
+#### **❌ INCORRECT Patterns (What Fails)**
+```python
+# DON'T use dictionaries for keybinding storage
+self._kb_bindings = {}  # ❌ WRONG
+self._kb_bindings['action'] = self.registerGestureByString(...)  # ❌ WRONG
+
+# DON'T use wrong parameter order
+self.registerGestureByString(
+    'kb:cthulhu+keys',          # ❌ WRONG ORDER
+    "Description", 
+    self._handler_method
+)
+
+# DON'T use description as handler parameter
+self.registerGestureByString(
+    self._handler_method,
+    'kb:cthulhu+keys',          # ❌ WRONG ORDER
+    "Description"
+)
+```
+
+### **Plugin Registration & Activation**
+
+#### **Add to Build System**
+1. **Add to `src/cthulhu/plugins/meson.build`**:
+   ```meson
+   subdir('YourPlugin')
+   ```
+
+#### **Add to Default Active Plugins**
+In `src/cthulhu/settings.py`:
+```python
+activePlugins = ['YourPlugin', 'DisplayVersion', 'PluginManager', ...]
+```
+
+### **Plugin Lifecycle Events**
+
+1. **`__init__`**: Plugin instance created
+2. **`activate`**: Plugin enabled (register keybindings, connect events)
+3. **`deactivate`**: Plugin disabled (cleanup, disconnect)
+
+**Note**: `activate()` may be called multiple times for different script contexts.
+
+### **Common Plugin Patterns**
+
+#### **Settings Integration**
+```python
+from cthulhu import settings_manager
+
+class YourPlugin(Plugin):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._settings_manager = settings_manager.getManager()
+    
+    def activate(self, plugin=None):
+        # Check if plugin should be active
+        enabled = self._settings_manager.getSetting('yourPluginEnabled')
+        if not enabled:
+            return
+```
+
+#### **Message Presentation**
+```python
+def _present_message(self, message):
+    """Present a message to the user via speech."""
+    try:
+        if self.app:
+            state = self.app.getDynamicApiManager().getAPI('CthulhuState')
+            if state and state.activeScript:
+                state.activeScript.presentMessage(message, resetStyles=False)
+    except Exception as e:
+        logger.error(f"Error presenting message: {e}")
+```
+
+#### **Sound Generation**
+```python
+from cthulhu import sound
+from cthulhu.sound_generator import Tone
+
+def _play_sound(self):
+    player = sound.getPlayer()
+    tone = Tone(duration=0.15, frequency=400, volumeMultiplier=0.7)
+    player.play(tone, interrupt=False)
+```
+
+### **Debugging Plugin Issues**
+
+#### **Common Debug Techniques**
+1. **Add debug output to both logger and print**:
+   ```python
+   logger.info("Plugin message")
+   print("DEBUG: Plugin message")  # Shows in terminal
+   ```
+
+2. **Check plugin loading**:
+   ```python
+   # In __init__
+   with open('/tmp/your_plugin_debug.log', 'a') as f:
+       f.write("Plugin loaded\n")
+   ```
+
+3. **Verify keybinding registration**:
+   ```python
+   if self._kb_binding:
+       print(f"DEBUG: Keybinding registered: {self._kb_binding}")
+   else:
+       print("DEBUG: Keybinding registration FAILED")
+   ```
+
+#### **Common Issues & Solutions**
+
+| Issue | Symptom | Solution |
+|-------|---------|----------|
+| Plugin not loading | No __init__ debug output | Check `activePlugins` list |
+| Keybindings not working | "stored for later registration" | Use correct parameter order |
+| Import errors | Plugin fails to activate | Check module imports and dependencies |
+| Settings not loading | Default values used | Verify settings key names |
+
+### **Working Plugin Examples**
+- **`DisplayVersion`**: Simple keybinding + message
+- **`PluginManager`**: GUI dialog + settings management  
+- **`IndentationAudio`**: Event listening + sound generation
+- **`AIAssistant`**: Complex settings + multi-keybinding + external APIs
+
+## D-Bus Remote Controller Integration
+
+### **EXISTING FEATURE**: D-Bus Service for Remote Control
+Cthulhu includes a D-Bus service (ported from Orca v49.alpha) for external control and automation:
+
+- **Service Name**: `org.stormux.Cthulhu.Service`
+- **Object Path**: `/org/stormux/Cthulhu/Service`
+- **Dependency**: `dasbus` library (automatically detected)
+
+### Testing D-Bus Functionality
+```bash
+# Start Cthulhu with D-Bus service
+~/.local/bin/cthulhu
+
+# Test service availability
+busctl --user list | grep Cthulhu
+
+# Get Cthulhu version via D-Bus
+busctl --user call org.stormux.Cthulhu.Service /org/stormux/Cthulhu/Service org.stormux.Cthulhu.Service GetVersion
+
+# Present message to user via D-Bus
+busctl --user call org.stormux.Cthulhu.Service /org/stormux/Cthulhu/Service org.stormux.Cthulhu.Service PresentMessage s "Hello from D-Bus"
+
+# List available modules and commands
+busctl --user call org.stormux.Cthulhu.Service /org/stormux/Cthulhu/Service org.stormux.Cthulhu.Service ListModules
+```
+
+### Integration Status
+- ✅ **Core D-Bus service**: Fully ported and integrated
+- ✅ **Service lifecycle**: Automatic start/shutdown with Cthulhu
+- ✅ **Message presentation**: `PresentMessage()` method working - **FULLY FUNCTIONAL**
+- ✅ **Version info**: `GetVersion()` method working - **FULLY FUNCTIONAL**
+- ✅ **Circular import issues**: All resolved - Cthulhu imports work correctly
+- ✅ **GDK version conflicts**: Fixed with proper gi.require_version calls
+- ✅ **Presenter singleton patterns**: Fixed with lazy initialization
+- ✅ **Settings manager backend**: Fixed with proper activation sequence
+- ✅ **ATSPI registry startup**: Fixed with deferred D-Bus service initialization
+- ✅ **API naming conventions**: All Orca→Cthulhu API differences resolved
+- 🔄 **Module registration**: Ready for individual managers to register D-Bus commands
+- 🔄 **Plugin integration**: Plugins can expose D-Bus commands using decorators
+
+### **✅ COMPLETED - Enhanced D-Bus Remote Controller with Speech and Key Echo Controls**
+The D-Bus Remote Controller from Orca v49.alpha has been successfully re-ported and enhanced with comprehensive speech and typing echo controls.
+
+**Latest Enhancement (2025)**:
+- **SpeechManager Module**: Complete D-Bus control over speech settings (muting, verbosity, punctuation, capitalization, number pronunciation)
+- **TypingEchoManager Module**: Granular key echo controls (character/word/sentence echo, per-key-type settings)
+- **No systemd dependency**: Direct session bus registration without service files
+- **Real-time effect**: All settings take effect immediately
+
+**Files Created/Modified for Enhanced D-Bus Integration**:
+- `src/cthulhu/speech_and_verbosity_manager.py` - Enhanced with D-Bus getters/setters for all speech settings
+- `src/cthulhu/typing_echo_presenter.py` (NEW FILE) - Complete typing echo system with D-Bus controls
+- `src/cthulhu/cthulhu.py` - D-Bus service registration for speech and typing echo managers
+- `src/cthulhu/meson.build` - Added typing_echo_presenter.py to build
+- `README-REMOTE-CONTROLLER.md` - Updated with comprehensive speech and key echo examples
+
+**Available D-Bus Modules**:
+- **SpeechManager**: Speech muting, verbosity, punctuation, capitalization, number styles, indentation speech
+- **TypingEchoManager**: Master key echo, character/word/sentence echo, per-key-type controls (alphabetic, numeric, punctuation, space, modifier, function, action, navigation, diacritical keys)
+- **DefaultScript**: Core Cthulhu commands
+
+**D-Bus Interface Design**:
+- Service: `org.stormux.Cthulhu.Service`
+- Module paths: `/org/stormux/Cthulhu/Service/ModuleName`
+- Generic interface: `org.stormux.Cthulhu.Module`
+- Methods: `ExecuteRuntimeGetter`, `ExecuteRuntimeSetter`, `ExecuteCommand`
+
+### Bug Fixes Applied
+- Fixed circular imports in presenter modules (learn_mode_presenter, notification_presenter, etc.)
+- Added lazy imports for BrailleEvent to break cthulhu.py ↔ input_event.py cycle
+- Fixed GDK version conflicts by adding gi.require_version("Gdk", "3.0") to input_event.py
+- Changed all presenter singleton patterns to lazy initialization to prevent import-time issues
+- Added settings manager activation before loadUserSettings() to fix backend initialization
+
+### **Commands for Analysis**
+```bash
+# Compare specific features between projects
+diff -r /home/storm/devel/cthulhu/src/cthulhu /home/storm/devel/orca/src/orca
+
+# Test Orca's new features
+cd /home/storm/devel/orca && meson setup _build && meson compile -C _build
+
+# Test D-Bus interface
+# (requires running Orca instance with D-Bus support)
+```
@@ -1,4 +0,0 @@
-2009-06-09  Willie Walker <william.walker@sun.com>
-
-        As of June 9, 2009, the ChangeLog is auto-generated when releasing.
-        If you are seeing this, use 'git log' for a detailed list of changes.
@@ -1,6 +1,6 @@
 Welcome to Cthulhu

-We are excited to have you here and welcome your contributions to the Cthulhu screen reader project! This project is a fork of Cthulhu, with a focus on creating an open and collaborative community where contributions are encouraged.
+We are excited to have you here and welcome your contributions to the Cthulhu screen reader project! This project is a fork of Orca, with a focus on creating an open and collaborative community where contributions are encouraged.


 How to Contribute
@@ -1,53 +0,0 @@
-ACLOCAL_AMFLAGS = -I m4 ${ACLOCAL_FLAGS}
-
-SUBDIRS = docs icons po src help
-
-DISTCHECK_CONFIGURE_FLAGS =     \
-	--disable-scrollkeeper
-
-DISTCLEANFILES =                \
-	cthulhu-autostart.desktop
-
-README: README.md
-	cp $< $@
-
-gtk_update_icon_cache = gtk-update-icon-cache -f -t $(datadir)/icons/hicolor
-
-install-data-hook: update-icon-cache
-uninstall-hook: update-icon-cache
-update-icon-cache:
-	@-if test -z "$(DESTDIR)"; then \
-		echo "Updating Gtk icon cache."; \
-		$(gtk_update_icon_cache); \
-	else \
-		echo "*** Icon cache not updated.  After (un)install, run this:"; \
-		echo "***   $(gtk_update_icon_cache)"; \
-	fi
-
-autostartdir	 = $(sysconfdir)/xdg/autostart
-autostart_in_files = cthulhu-autostart.desktop.in
-autostart_DATA   = $(autostart_in_files:.desktop.in=.desktop)
-
-$(autostart_DATA): $(autostart_in_files)
-	$(AM_V_GEN)$(MSGFMT) --desktop --template $< -d $(top_srcdir)/po -o $@
-
-EXTRA_DIST =                \
-	$(autostart_in_files) \
-	$(icon_DATA)        \
-	ChangeLog           \
-	MAINTAINERS         \
-	README.md
-
-dist-hook:
-	@if test -d "$(srcdir)/.git"; \
-	then \
-		echo Creating ChangeLog && \
-		( cd "$(top_srcdir)" && \
-		  echo '# Generated by Makefile. Do not edit.'; echo; \
-		  $(top_srcdir)/missing --run git log --pretty=format:"%ai %an <%ae>%n%n        %s%n" --name-status CTHULHU_2_26_0.. ) > ChangeLog.tmp \
-		&& mv -f ChangeLog.tmp $(top_distdir)/ChangeLog \
-		|| ( rm -f ChangeLog.tmp ; \
-		echo Failed to generate ChangeLog >&2 ); \
-	else \
-		echo A git clone is required to generate a ChangeLog >&2; \
-	fi
@@ -8452,7 +8452,7 @@ General:
  some areas, and has fixed a number of latent bugs.  It also enables
  finer granularity for switching voices and helps set us up for
  incorporating audio cues.  Please help us by testing with the latest
-  code and by reporting issues and suggestions at cthulhu-list@gnome.org.
+  code and by reporting issues and suggestions at https://groups.io/g/stormux.

 * Fix for bgo#583274 - portability for cthulhu script (Thomas Klausner)

@@ -1 +0,0 @@
-See http://wiki.gnome.org/Projects/Cthulhu
@@ -0,0 +1,108 @@
+# Cthulhu Development Guide
+
+## Local Development Build
+
+To develop Cthulhu without overwriting your system installation, use the provided build scripts:
+
+### Building Locally
+
+```bash
+# Build and install to ~/.local
+./build-local.sh
+
+# Clean build and rebuild everything
+./clean-local.sh --build-only
+./build-local.sh
+```
+
+This installs Cthulhu to `~/.local/bin/cthulhu` without touching your system installation.
+
+### Testing the Local Build
+
+```bash
+# Test the local installation
+./test-local.sh
+
+# Run the local version directly
+~/.local/bin/cthulhu --version
+```
+
+### Running Local Cthulhu
+
+```bash
+# Method 1: Direct path
+~/.local/bin/cthulhu
+
+# Method 2: Add to PATH (add to ~/.bashrc)
+export PATH="$HOME/.local/bin:$PATH"
+cthulhu
+```
+
+### Cleaning Up
+
+```bash
+# Clean build artifacts only
+./clean-local.sh --build-only
+
+# Remove local installation only  
+./clean-local.sh --install-only
+
+# Clean everything (build artifacts + local installation)
+./clean-local.sh
+```
+
+## D-Bus Remote Controller
+
+Cthulhu now includes a D-Bus service for remote control:
+
+- **Service**: `org.stormux.Cthulhu.Service`
+- **Path**: `/org/stormux/Cthulhu/Service`
+- **Requires**: `dasbus` library (should be installed)
+
+### Testing D-Bus Service
+
+```bash
+# Start Cthulhu with D-Bus service
+~/.local/bin/cthulhu
+
+# In another terminal, test the service
+busctl --user call org.stormux.Cthulhu.Service /org/stormux/Cthulhu/Service org.stormux.Cthulhu.Service GetVersion
+
+# Present a message via D-Bus
+busctl --user call org.stormux.Cthulhu.Service /org/stormux/Cthulhu/Service org.stormux.Cthulhu.Service PresentMessage s "Hello from D-Bus"
+```
+
+## Development Workflow
+
+1. **Make changes** to the code
+2. **Build locally**: `./build-local.sh`
+3. **Test**: `./test-local.sh`
+4. **Run**: `~/.local/bin/cthulhu`
+5. **Clean when done**: `./clean-local.sh --build-only`
+
+## Git Repository Management
+
+The `.gitignore` file is configured to exclude:
+- Build artifacts (`_build`, `_build_releasecheck`, `meson-private`, etc.)
+- Generated Python files (`cthulhu_bin.py`, `cthulhu_i18n.py`, etc.)
+- Python bytecode (`*.pyc`, `__pycache__/`)
+
+Before committing:
+```bash
+# Clean build artifacts to avoid committing them
+./clean-local.sh --build-only
+
+# Check what will be committed
+git status
+```
+
+## Dependencies
+
+- **Runtime**: python3, pygobject-3.0, pluggy, AT-SPI2
+- **Build**: meson, ninja, gettext
+- **Optional**: dasbus (for D-Bus service), BrlTTY, speech-dispatcher
+
+Install build dependencies on Arch Linux:
+```bash
+sudo pacman -S meson ninja gettext python-dasbus
+```
@@ -0,0 +1,372 @@
+# Cthulhu Remote Controller (D-Bus Interface)
+
+> **⚠️⚠️ WORK IN PROGRESS**: This D-Bus interface is brand new and not yet feature complete.
+Low-risk feature additions will continue to be made. The API may be
+modified beyond bug fixes in future versions based on feedback from consumers of this support.
+Such changes will be documented here.
+
+> **💡 Desktop-Agnostic Design**: Cthulhu's D-Bus Remote Controller is built on standard D-Bus
+session bus infrastructure and works across all desktop environments (GNOME, KDE Plasma, XFCE,
+i3, Sway, etc.). The D-Bus service uses no desktop-specific dependencies and follows universal
+D-Bus conventions, making it suitable for integration with any application or automation tool
+on any Linux desktop environment or window manager.
+
+[TOC]
+
+## Overview
+
+Cthulhu exposes a D-Bus service at:
+
+- **Service Name**: `org.stormux.Cthulhu.Service`
+- **Main Object Path**: `/org/stormux/Cthulhu/Service`
+- **Module Object Paths**: `/org/stormux.Cthulhu/Service/ModuleName`
+  (e.g., `/org/stormux/Cthulhu/Service/SpeechAndVerbosityManager`)
+
+See [REMOTE-CONTROLLER-COMMANDS.md](REMOTE-CONTROLLER-COMMANDS.md) for a complete
+list of available commands.
+
+## Dependencies
+
+The D-Bus interface requires:
+
+- **dasbus** - Python D-Bus library used by Cthulhu for the remote controller implementation.
+  ([Installation instructions](https://dasbus.readthedocs.io/en/latest/index.html))
+
+## Alternative Tools for D-Bus Interaction
+
+While this documentation primarily uses `gdbus` for examples, you can use any D-Bus tool or library:
+
+### Using `busctl` (systemd D-Bus tool)
+```bash
+busctl --user call org.stormux.Cthulhu.Service /org/stormux/Cthulhu/Service \
+    org.stormux.Cthulhu.Service GetVersion
+```
+
+### Using Python with `dasbus`
+```python
+from dasbus.connection import SessionMessageBus
+bus = SessionMessageBus()
+proxy = bus.get_proxy("org.stormux.Cthulhu.Service", "/org/stormux/Cthulhu/Service")
+version = proxy.GetVersion()
+```
+
+### Using `qdbus` (Qt D-Bus tool - available on KDE)
+```bash
+qdbus org.stormux.Cthulhu.Service /org/stormux/Cthulhu/Service \
+    org.stormux.Cthulhu.Service.GetVersion
+```
+
+## Service-Level Commands
+
+Commands available directly on the main service (`/org/stormux/Cthulhu/Service`):
+
+### Get Cthulhu's Version
+
+```bash
+gdbus call --session --dest org.stormux.Cthulhu.Service \
+    --object-path /org/stormux/Cthulhu/Service \
+    --method org.stormux.Cthulhu.Service.GetVersion
+```
+
+**Returns:** String containing the version (and revision if available)
+
+### Present a Custom Message in Speech and/or Braille
+
+```bash
+gdbus call --session --dest org.stormux.Cthulhu.Service \
+    --object-path /org/stormux/Cthulhu/Service \
+    --method org.stormux.Cthulhu.Service.PresentMessage "Your message here"
+```
+
+**Parameters:**
+
+- `message` (string): The message to present to the user
+
+**Returns:** Boolean indicating success
+
+### Show Cthulhu's Preferences GUI
+
+```bash
+gdbus call --session --dest org.stormux.Cthulhu.Service \
+    --object-path /org/stormux/Cthulhu/Service \
+    --method org.stormux.Cthulhu.Service.ShowPreferences
+```
+
+**Returns:** Boolean indicating success
+
+### Quit Cthulhu
+
+```bash
+gdbus call --session --dest org.stormux.Cthulhu.Service \
+    --object-path /org/stormux/Cthulhu/Service \
+    --method org.stormux.Cthulhu.Service.Quit
+```
+
+**Returns:** Boolean indicating if the quit request was accepted
+
+### List Available Service Commands
+
+```bash
+gdbus call --session --dest org.stormux.Cthulhu.Service \
+    --object-path /org/stormux/Cthulhu/Service \
+    --method org.stormux.Cthulhu.Service.ListCommands
+```
+
+**Returns:** List of (command_name, description) tuples
+
+### List Registered Modules
+
+```bash
+gdbus call --session --dest org.stormux.Cthulhu.Service \
+    --object-path /org/stormux/Cthulhu/Service \
+    --method org.stormux.Cthulhu.Service.ListModules
+```
+
+**Returns:** List of module names
+
+## Interacting with Modules
+
+Each registered module exposes its own set of operations. Based on the underlying Cthulhu code, these
+are categorized as **Commands**, **Runtime Getters**, and **Runtime Setters**:
+
+- **Commands**: Actions that perform a task. These typically correspond to Cthulhu commands bound
+  to a keystroke (e.g., `IncreaseRate`).
+- **Runtime Getters**: Operations that retrieve the current value of an item, often a setting
+  (e.g., `GetRate`).
+- **Runtime Setters**: Operations that set the current value of an item, often a setting
+  (e.g., `SetRate`). Note that setting a value does NOT cause it to become permanently saved.
+
+You can discover and execute these for each module.
+
+### Discovering Module Capabilities
+
+#### List Commands for a Module
+
+```bash
+gdbus call --session --dest org.stormux.Cthulhu.Service \
+    --object-path /org/stormux/Cthulhu/Service/ModuleName \
+    --method org.stormux.Cthulhu.Module.ListCommands
+```
+
+Replace `ModuleName` with an actual module name from `ListModules`.
+
+**Returns:** List of (command_name, description) tuples.
+
+#### List Parameterized Commands for a Module
+
+```bash
+gdbus call --session --dest org.stormux.Cthulhu.Service \
+    --object-path /org/stormux/Cthulhu/Service/ModuleName \
+    --method org.stormux.Cthulhu.Module.ListParameterizedCommands
+```
+
+Replace `ModuleName` with an actual module name from `ListModules`.
+
+**Returns:** List of (command_name, description, parameters) tuples, where `parameters` is a
+list of (parameter_name, parameter_type) tuples.
+
+**Example output:**
+
+```bash
+([('GetVoicesForLanguage',
+   'Returns a list of available voices for the specified language.',
+   [('language', 'str'), ('variant', 'str'), ('notify_user', 'bool')])],)
+```
+
+#### List Runtime Getters for a Module
+
+```bash
+gdbus call --session --dest org.stormux.Cthulhu.Service \
+    --object-path /org/stormux/Cthulhu/Service/ModuleName \
+    --method org.stormux.Cthulhu.Module.ListRuntimeGetters
+```
+
+Replace `ModuleName` with an actual module name from `ListModules`.
+
+**Returns:** List of (getter_name, description) tuples.
+
+#### List Runtime Setters for a Module
+
+```bash
+gdbus call --session --dest org.stormux.Cthulhu.Service \
+    --object-path /org/stormux/Cthulhu/Service/ModuleName \
+    --method org.stormux.Cthulhu.Module.ListRuntimeSetters
+```
+
+Replace `ModuleName` with an actual module name from `ListModules`.
+
+**Returns:** List of (setter_name, description) tuples.
+
+### Executing Module Operations
+
+#### Execute a Runtime Getter
+
+```bash
+gdbus call --session --dest org.stormux.Cthulhu.Service \
+    --object-path /org/stormux/Cthulhu/Service/ModuleName \
+    --method org.stormux.Cthulhu.Module.ExecuteRuntimeGetter 'PropertyName'
+```
+
+**Parameters:**
+
+- `PropertyName` (string): The name of the runtime getter to execute.
+
+**Returns:** The value returned by the getter as a GLib variant (type depends on the getter).
+
+##### Example: Get the current speech rate
+
+```bash
+gdbus call --session --dest org.stormux.Cthulhu.Service \
+    --object-path /org/stormux/Cthulhu/Service/SpeechAndVerbosityManager \
+    --method org.stormux.Cthulhu.Module.ExecuteRuntimeGetter 'Rate'
+
+```
+
+This will return the rate as a GLib Variant.
+
+#### Execute a Runtime Setter
+
+```bash
+gdbus call --session --dest org.stormux.Cthulhu.Service \
+    --object-path /org/stormux/Cthulhu/Service/ModuleName \
+    --method org.stormux.Cthulhu.Module.ExecuteRuntimeSetter 'PropertyName' <value>
+```
+
+**Parameters:**
+
+- `PropertyName` (string): The name of the runtime setter to execute.
+- `<value>`: The value to set, as a GLib variant (type depends on the setter).
+
+**Returns:** Boolean indicating success.
+
+##### Example: Set the current speech rate
+
+```bash
+gdbus call --session --dest org.stormux.Cthulhu.Service \
+    --object-path /org/stormux/Cthulhu/Service/SpeechAndVerbosityManager \
+    --method org.stormux.Cthulhu.Module.ExecuteRuntimeSetter 'Rate' '<90>'
+```
+
+#### Execute a Module Command
+
+```bash
+# With user notification
+gdbus call --session --dest org.stormux.Cthulhu.Service \
+    --object-path /org/stormux/Cthulhu/Service/ModuleName \
+    --method org.stormux.Cthulhu.Module.ExecuteCommand 'CommandName' true
+
+# Without user notification (silent)
+gdbus call --session --dest org.stormux.Cthulhu.Service \
+    --object-path /org/stormux/Cthulhu/Service/ModuleName \
+    --method org.stormux.Cthulhu.Module.ExecuteCommand 'CommandName' false
+```
+
+**Parameters (both required):**
+
+- `CommandName` (string): The name of the command to execute
+- `notify_user` (boolean): Whether to notify the user of the action (see section below)
+
+**Returns:** Boolean indicating success
+
+#### Execute a Parameterized Command
+
+```bash
+gdbus call --session --dest org.stormux.Cthulhu.Service \
+    --object-path /org/stormux/Cthulhu/Service/ModuleName \
+    --method org.stormux.Cthulhu.Module.ExecuteParameterizedCommand 'CommandName' \
+    '{"param1": <"value1">, "param2": <"value2">}' false
+```
+
+**Parameters:**
+
+- `CommandName` (string): The name of the parameterized command to execute
+- `parameters` (dict): Dictionary of parameter names and values as GLib variants
+- `notify_user` (boolean): Whether to notify the user of the action
+
+**Returns:** The result returned by the command as a GLib variant (type depends on the command)
+
+##### Example: Get voices for a specific language
+
+```bash
+gdbus call --session --dest org.stormux.Cthulhu.Service \
+    --object-path /org/stormux/Cthulhu/Service/SpeechAndVerbosityManager \
+    --method org.stormux.Cthulhu.Module.ExecuteParameterizedCommand 'GetVoicesForLanguage' \
+    '{"language": <"en-us">, "variant": <"">}' false
+```
+
+This will return a list of available voices for US English.
+
+### User Notification Applicability
+
+**Setting `notify_user=true` is not a guarantee that feedback will be presented.**
+
+Some commands inherently don't make sense to announce. For example:
+
+```bash
+# This command should simply stop speech, not announce that it is stopping speech.
+gdbus call --session --dest org.stormux.Cthulhu.Service \
+    --object-path /org/stormux/Cthulhu/Service/SpeechAndVerbosityManager \
+    --method org.stormux.Cthulhu.Module.ExecuteCommand 'InterruptSpeech' true
+```
+
+In those cases Cthulhu will ignore the value of `notify_user`.
+
+**Setting `notify_user=false` is not a guarantee that Cthulhu will remain silent**, though for the
+most part Cthulhu will try to respect this value. The exceptions are:
+
+1. If executing the command has resulted in UI being shown, such as a dialog or menu, the
+   newly-shown UI will be presented in speech and/or braille based on the user's settings.
+   Failure to announce that the user has been removed from one window and placed in another
+   could be extremely confusing.
+2. If the *sole* purpose of the command is to announce something without making any other
+   changes, e.g. `PresentTime`, executing it with `notify_user=false` makes no sense. Adding
+   checks and early returns to handle this possibility does not seem worth doing. If you
+   don't want Cthulhu to present the time, don't ask Cthulhu to present the time. 😃
+
+### Navigator Module "Enabled" State Applicability
+
+**In the Remote Controller, Navigator commands are expected to work even when not "enabled."**
+
+Some of Cthulhu's Navigator modules, namely Table Navigator, Caret Navigator, and Structural Navigator,
+have an "enabled" state. The reason for this is very much tied to the keyboard-centric nature of
+Cthulhu's commands. For instance, if Cthulhu always grabbed "H" (for heading navigation) and the arrow
+keys (for caret navigation), normal interaction with applications would be completely broken. For
+this reason, Navigator modules whose commands will prevent normal, native interaction with
+applications are typically not enabled by default and can be easily disabled.
+
+In contrast, performing Navigator commands via D-Bus does not prevent native interaction with
+applications. For instance, one could use the Remote Controller to move to the next heading without
+causing H to stop functioning in editable fields. For this reason, and to avoid a performance hit,
+the decision was made to not check if (keyboard-centric) navigation commands were enabled. As a
+result, it should be possible to use Remote Controller navigation even in "focus mode" or other
+cases where Cthulhu is not controlling the caret. This is by design.
+
+Given the keyboard-centric nature of Cthulhu's commands, there may be instances in which one uses the
+Remote Controller for navigation and Cthulhu fails to correctly update its location in response. If
+Cthulhu correctly updates its location when the same navigation command is executed via keyboard,
+please report the Remote Controller failure as a new bug in Cthulhu's issue tracker.
+
+### The "Stickiness" (or Lack Thereof) of On-The-Fly Settings Changes
+
+Cthulhu has a number of keyboard commands to temporarily change settings such as speech rate, pitch,
+volume; capitalization style; punctuation level; etc., etc. The question is: how long should
+on-the-fly modifications to settings persist?
+
+Early on in Cthulhu's development, the conclusion was that on-the-fly settings changes should be
+seen as quite temporary, presumed to be used to address a specific one-time need. For instance,
+if reading some difficult-to-understand text, one might want to reduce the speed just for that text.
+If one were doing a final proofread of some content, one might want to briefly set the punctuation
+level to all. If one needs slow speed and/or verbose punctuation all the time, those should be set
+in Cthulhu's Preferences dialogs -- either globally or on a per-app basis. Cthulhu also has a profile
+feature through which the user can save settings and quickly load/unload them by switching profiles*.
+
+Whether or not that historical decision was the right decision goes beyond the scope of the
+Remote Controller. The primary purpose of the Remote Controller is to provide D-Bus access to
+commands and runtime settings as if they were performed by the user via keyboard command. Thus if
+a setting changed via Remote Controller persists (or fails to persist) in the same way as when
+changed via keyboard command, it is not a Remote Controller bug. (It may be a general Cthulhu
+bug or feature request, and you are encouraged to file it as such.) On the other hand, if the
+behavior of the Remote Controller differs from that of the corresponding or related keyboard
+command, please report that Remote Controller failure as a new bug in Cthulhu's issue tracker.
+
+\* *Note: Remote Controller support for profile management is still pending.*
@@ -1,5 +1,10 @@
 # Cthulhu 

+## Note
+
+Cthulhu is a fork of the Orca screen reader. Project home: https://git.stormux.org/storm/cthulhu. Cthulhu is currently a supplemental screen reader that fills a nitch for some advanced users. E.g. some older QT based programs may work with Cthulhu, and if you use certain window managers like i3, Mozilla applications like Firefox and Thunderbird may work better.
+
+
 ## Introduction

 Cthulhu is a free, open source, flexible, and extensible screen reader
@@ -13,24 +18,66 @@ operating environments.  Applications and toolkits supporting the
 AT-SPI include the GNOME GTK+ toolkit, the Java platform's Swing
 toolkit, OpenOffice/LibreOffice, Gecko, WebKitGtk, and KDE Qt toolkit.

+## Key Features
+
+### Desktop-Agnostic Design
+- **Universal compatibility**: Works on KDE, XFCE, i3, Sway, and other desktop environments
+- **Minimal GNOME dependencies**: Reduced reliance on GNOME-specific libraries
+- **Tiling window manager optimized**: Enhanced support for i3, Sway, and similar WMs
+
+### Plugin System
+- **Extensible architecture**: Plugin system using pluggy framework
+- **Hot-reloadable plugins**: Add functionality without restarting
+- **Community plugins**: User and system plugin directories
+
+### Remote Control
+- **D-Bus interface**: External control via D-Bus service
+- **API access**: Remote access to Cthulhu functions and settings
+- **Automation support**: Script-friendly remote control
+
+### Sleep Mode
+- **Application-specific**: Disable speech/events per application
+- **Toggle keybinding**: `Cthulhu+Ctrl+Alt+Shift+Q`
+- **Preserves exit key**: Only sleep toggle remains active
+
+### Self-Voicing
+- **Unix socket interface**: Direct speech output via `/tmp/cthulhu.sock`
+- **External integration**: Other applications can speak through Cthulhu
+- **Simple protocol**: `echo "text" | socat - UNIX-CLIENT:/tmp/cthulhu.sock`

 ## Dependencies

-Cthulhu has the following dependencies:
+### Core Requirements

-* Python 3         - Python platform
-* pygobject-3.0    - Python bindings for the GObject library
-* libpeas          - GObject based Plugin engine
-* gtk+-3.0         - GTK+ toolkit
-* json-py          - a JSON (<https://json.org/>) reader and writer in Python
-* python-speechd   - Python bindings for Speech Dispatcher (optional)
-* BrlTTY           - BrlTTY (<https://mielke.cc/brltty/>) support for braille (optional)
-* BrlAPI           - BrlAPI support for braille (optional)
-* liblouis         - Liblouis (<http://liblouis.org/>) support for contracted braille (optional)
-* py-setproctitle  - Python library to set the process title (optional)
-* gstreamer-1.0    - GStreamer - Streaming media framework (optional)
-* socat            - Used for self-voicing functionality.
-* libpeas          - For the plugin system.
+* **Python 3.9+**       - Python platform
+* **pygobject-3.0**      - Python bindings for the GObject library  
+* **gtk+-3.0**           - GTK+ toolkit (minimal usage for AT-SPI integration)
+* **AT-SPI2**            - Assistive Technology Service Provider Interface
+* **ATK**                - Accessibility Toolkit
+
+### Desktop-Neutral Features
+
+* **pluggy**             - Plugin and hook calling mechanisms for Python
+* **python-dasbus**      - D-Bus remote control interface (optional)
+* **libpeas**            - Plugin loader library
+
+### Audio and Speech
+
+* **python-speechd**     - Python bindings for Speech Dispatcher (recommended)
+* **gstreamer-1.0**      - GStreamer streaming media framework (for sounds)
+
+### Braille Support (Optional)
+
+* **BrlTTY**             - BrlTTY (<https://mielke.cc/brltty/>) braille terminal support
+* **BrlAPI**             - BrlAPI Python bindings for braille
+* **liblouis**           - Liblouis (<http://liblouis.org/>) contracted braille translation
+
+### System Integration
+
+* **py-setproctitle**    - Python library to set the process title (optional)
+* **socat**              - Used for self-voicing functionality
+* **xorg-xkbcomp**       - X keyboard compiler (for key remapping)
+* **xorg-xmodmap**       - X modifier map utility

 You are strongly encouraged to also have the latest stable versions
 of AT-SPI2 and ATK.
@@ -68,6 +115,101 @@ So, you want to write a script for Cthulhu?  The best thing to do is
 start by looking at other scripts under the src/cthulhu/scripts/ hierarchy
 of the source tree. Cthulhu also has an excellent plugin system, more documentation and examples coming soon.

+## Building and Installation
+
+### Prerequisites
+
+Ensure you have the development dependencies installed:
+
+**Arch Linux:**
+```bash
+sudo pacman -S python python-gobject gtk3 at-spi2-core at-spi2-atk \
+               python-speechd gstreamer python-pluggy python-dasbus \
+               meson ninja pkgconf intltool gettext
+```
+
+**Debian/Ubuntu:**
+```bash
+sudo apt install python3 python3-gi python3-gi-cairo gir1.2-gtk-3.0 \
+                 at-spi2-core libatk-adaptor python3-speechd \
+                 gstreamer1.0-plugins-base python3-pluggy python3-dasbus \
+                 meson ninja-build pkg-config intltool gettext
+```
+
+### Local Development Build (Recommended)
+
+For active development, build and install to your user directory:
+
+```bash
+# Build and install to ~/.local
+./build-local.sh
+
+# Test the local installation
+./test-local.sh
+
+# Run your local version
+~/.local/bin/cthulhu
+
+# Clean build artifacts and local installation
+./clean-local.sh
+```
+
+This approach:
+- Installs to `~/.local/bin/cthulhu` (won't conflict with system installation)
+- Loads modules from `~/.local/lib/python*/site-packages/cthulhu/`
+- Preserves any system-wide Cthulhu installation at `/usr/bin/cthulhu`
+
+### System Installation
+
+For system-wide installation:
+
+```bash
+# Configure the build
+meson setup _build --prefix=/usr
+
+# Compile
+meson compile -C _build
+
+# Install (requires sudo)
+sudo meson install -C _build
+```
+
+### Manual Meson Build
+
+If you prefer to use Meson commands directly instead of the convenience scripts:
+
+```bash
+# Configure for local installation
+meson setup _build --prefix=$HOME/.local
+
+# Or configure for system installation  
+meson setup _build --prefix=/usr
+
+# Compile
+meson compile -C _build
+
+# Install
+meson install -C _build
+
+# Clean
+rm -rf _build
+```
+
+### Testing
+
+Run the regression test suite:
+
+```bash
+# All tests
+test/harness/runall.sh
+
+# Single test
+test/harness/runone.sh <test.py> <app-name>
+
+# App-specific tests
+test/harness/runall.sh -a /path/to/app/tests
+```
+
 ## Self-voicing

 Cthulhu offers a mechanism through which messages may be spoken directly by the screen reader. Usage is as follows:
@@ -1,84 +1,55 @@
-This document provides a step-by-step list to remind Cthulhu
-maintainers how to make a release.
+This document provides a step-by-step reminder for making a Cthulhu release.

-The general instructions for a release are here:
+PREPARE SOURCES:
+----------------

-  https://wiki.gnome.org/MaintainersCorner/Releasing
-
-See also:
-
-  https://discourse.gnome.org/t/new-gnome-versioning-scheme/4235
-
-Here's a summary for Cthulhu:
-
-PREPARE SOURCES FOR THE RELEASE:
-------------------------------
-
-Make sure you are up to date:
+Make sure you are up to date and clean:

  git pull
  git status

-Update ./NEWS with changes from the last tagged release. You can use
-commands like the following:
+Decide the release version:

-Detailed commits since the CTHULHU_40_BETA tag:
+  - Update the version in `meson.build`
+  - Update the version in `src/cthulhu/cthulhuVersion.py`

-  git log CTHULHU_40_BETA..
+Update release notes:

-Short list of translation changes with author names and files:
-
-  git log CTHULHU_40_BETA.. --grep translation --pretty=format:"%s - %an" --name-only
-
-Quick-and-dirty formatted list of translation changes:
-
-  git log CTHULHU_40_BETA.. --grep translation --pretty=format:"%s,%an" --name-only |
-    awk -F/ '/\.(po|am)/ {gsub("(\.po|Makefile.am)", "", $NF); printf(",%s",$NF); next;}
-    {gsub("(Updated* |Add(ed)* | translation| help)", "", $0); printf("\n%s",$0);}' |
-    awk -F, '!seen[$0]++ {if (NF == 3) printf("  %-15s %-25s %s\n", $3, $1, $2);}' |
-    sort
-
-Short list of non-translation commits:
-
-  git log CTHULHU_40_BETA.. --grep translation --invert-grep --pretty=format:" * %s%n"
-
-NOTE: You should also make sure the external dependencies listed in
-configure.ac and README are accurate.
+  - Update `NEWS` (or your preferred changelog location) with user-visible changes.


-BUILD THE RELEASE:
-----------------
+BUILD + SANITY CHECK:
+---------------------

-./autogen.sh --prefix=`pwd`/bld && make && make install && make distcheck
+Build with Meson:

-COMMIT RELEASE CHANGES AND TAG THE RELEASE:
-------------------------------------------
+  meson setup _build_release --prefix=/usr --buildtype=release
+  meson compile -C _build_release

-git commit -a
-git push
-git tag -a -s CTHULHU_40_RC
-git push origin CTHULHU_40_RC
+Optional sanity checks:
+
+  python3 -m compileall -q src/cthulhu
+  meson test -C _build_release  # may be empty
+
+Create a source tarball:
+
+  meson dist -C _build_release


-UPLOAD THE RELEASE:
------------------
+TAG + PUSH:
+-----------

-scp cthulhu-40.rc.tar.xz yourusername@master.gnome.org:
-ssh master.gnome.org
-ftpadmin install cthulhu-40.rc.tar.xz
+Commit release changes, tag, and push:
+
+  git commit -a
+  git push
+  git tag -a v<version>
+  git push origin v<version>


-BUMP THE VERSION:
-----------------
+PACKAGING NOTES:
+----------------

-Modify this line in ./configure.ac:
-
-    m4_define([cthulhu_version], [40.rc])
-
-The major version (40) increments by 1 each new GNOME release cycle.
-The minor version proceeds as follows: alpha, beta, rc, 0, 1, 2, 3, etc.
-
-Modify ./README.md to make sure it has the right Cthulhu version.
-
-git commit -a
-git push
+Arch packaging lives in `distro-packages/Arch-Linux/PKGBUILD`.
+If the package version is derived from `src/cthulhu/cthulhuVersion.py`,
+ensure that file matches the release version.
@@ -0,0 +1,91 @@
+# Cthulhu Remote Controller - Available Commands
+
+This document lists the currently available D-Bus commands in Cthulhu's Remote Controller interface.
+
+> **Note**: This is a work-in-progress. As more modules are exposed via D-Bus, this document will be expanded. Eventually this will be auto-generated using `tools/generate_dbus_documentation.py`.
+
+## Service-Level Commands
+
+Available on the main service object `/org/stormux/Cthulhu/Service`:
+
+### Service Commands
+
+| Command | Description | Parameters | Returns |
+|---------|-------------|------------|---------|
+| `GetVersion` | Returns Cthulhu's version string | None | String (version + revision) |
+| `PresentMessage` | Present a message via speech/braille | `message` (string) | Boolean (success) |
+| `ShowPreferences` | Opens Cthulhu's preferences GUI | None | Boolean (success) |
+| `Quit` | Exits Cthulhu | None | Boolean (accepted) |
+| `ListCommands` | Lists available service commands | None | List of (name, description) tuples |
+| `ListModules` | Lists registered D-Bus modules | None | List of module names |
+
+### Example Usage
+
+```bash
+# Get Cthulhu version
+busctl --user call org.stormux.Cthulhu.Service /org/stormux/Cthulhu/Service \
+    org.stormux.Cthulhu.Service GetVersion
+
+# Present a custom message
+busctl --user call org.stormux.Cthulhu.Service /org/stormux/Cthulhu/Service \
+    org.stormux.Cthulhu.Service PresentMessage s "Hello from D-Bus"
+
+# List available commands
+busctl --user call org.stormux.Cthulhu.Service /org/stormux/Cthulhu/Service \
+    org.stormux.Cthulhu.Service ListCommands
+
+# List registered modules
+busctl --user call org.stormux.Cthulhu.Service /org/stormux/Cthulhu/Service \
+    org.stormux.Cthulhu.Service ListModules
+
+# Open preferences
+busctl --user call org.stormux.Cthulhu.Service /org/stormux/Cthulhu/Service \
+    org.stormux.Cthulhu.Service ShowPreferences
+
+# Quit Cthulhu
+busctl --user call org.stormux.Cthulhu.Service /org/stormux/Cthulhu/Service \
+    org.stormux.Cthulhu.Service Quit
+```
+
+## Module-Level Commands
+
+Currently, no additional modules are exposed via D-Bus beyond the base service commands.
+
+**Planned modules** (to be implemented):
+- `SpeechAndVerbosityManager` - Speech settings control (muting, verbosity, punctuation, etc.)
+- `TypingEchoManager` - Typing echo settings (character/word/sentence echo)
+- `DefaultScript` - Core Cthulhu commands
+- Additional navigation and presenter modules
+
+See [README-REMOTE-CONTROLLER.md](README-REMOTE-CONTROLLER.md) for comprehensive D-Bus API documentation and usage examples.
+
+## Verifying D-Bus Service Status
+
+```bash
+# Check if Cthulhu's D-Bus service is running
+busctl --user list | grep Cthulhu
+
+# Introspect the service to see all available methods
+busctl --user introspect org.stormux.Cthulhu.Service /org/stormux/Cthulhu/Service
+
+# Get detailed service information
+busctl --user status org.stormux.Cthulhu.Service
+```
+
+## Contributing
+
+To add new D-Bus-accessible functionality:
+
+1. Add `@dbus_service.command`, `@dbus_service.getter`, or `@dbus_service.setter` decorators to methods
+2. Register the module with the D-Bus service in `src/cthulhu/cthulhu.py`
+3. Rebuild and test with busctl
+4. Update this documentation (or regenerate using `tools/generate_dbus_documentation.py` when available)
+
+## Desktop Environment Compatibility
+
+Cthulhu's D-Bus Remote Controller is desktop-agnostic and works across all Linux desktop environments:
+- GNOME, KDE Plasma, XFCE, LXDE
+- Tiling window managers (i3, Sway, bspwm, etc.)
+- Any environment with D-Bus session bus support
+
+The service uses only standard D-Bus infrastructure with no desktop-specific dependencies.
@@ -1,104 +0,0 @@
-dnl a macro to check for ability to create python extensions
-dnl  AM_CHECK_PYTHON_HEADERS([ACTION-IF-POSSIBLE], [ACTION-IF-NOT-POSSIBLE])
-dnl function also defines PYTHON_INCLUDES
-AC_DEFUN([AM_CHECK_PYTHON_HEADERS],
-[AC_REQUIRE([AM_PATH_PYTHON])
-AC_MSG_CHECKING(for headers required to compile python extensions)
-dnl deduce PYTHON_INCLUDES
-py_prefix=`$PYTHON -c "import sys; print sys.prefix"`
-py_exec_prefix=`$PYTHON -c "import sys; print sys.exec_prefix"`
-PYTHON_INCLUDES="-I${py_prefix}/include/python${PYTHON_VERSION}"
-if test "$py_prefix" != "$py_exec_prefix"; then
-  PYTHON_INCLUDES="$PYTHON_INCLUDES -I${py_exec_prefix}/include/python${PYTHON_VERSION}"
-fi
-AC_SUBST(PYTHON_INCLUDES)
-dnl check if the headers exist:
-save_CPPFLAGS="$CPPFLAGS"
-CPPFLAGS="$CPPFLAGS $PYTHON_INCLUDES"
-AC_TRY_CPP([#include <Python.h>],dnl
-[AC_MSG_RESULT(found)
-$1],dnl
-[AC_MSG_RESULT(not found)
-$2])
-CPPFLAGS="$save_CPPFLAGS"
-])
-
-dnl AM_CHECK_PYMOD(MODNAME [,SYMBOL [,ACTION-IF-FOUND [,ACTION-IF-NOT-FOUND]]])
-dnl Check if a module containing a given symbol is visible to python.
-AC_DEFUN([AM_CHECK_PYMOD],
-[AC_REQUIRE([AM_PATH_PYTHON])
-py_mod_var=`echo $1['_']$2 | sed 'y%./+-%__p_%'`
-AC_MSG_CHECKING(for ifelse([$2],[],,[$2 in ])python module $1)
-AC_CACHE_VAL(py_cv_mod_$py_mod_var, [
-ifelse([$2],[], [prog="
-import sys
-try:
-	from gi.repository import GObject
-	import $1
-except ImportError:
-	sys.exit(1)
-except:
-	sys.exit(0)
-sys.exit(0)"], [prog="
-import $1
-import $1.$2"])
-if $PYTHON -c "$prog" 1>&AC_FD_CC 2>&AC_FD_CC
-  then
-    eval "py_cv_mod_$py_mod_var=yes"
-  else
-    eval "py_cv_mod_$py_mod_var=no"
-  fi
-])
-py_val=`eval "echo \`echo '$py_cv_mod_'$py_mod_var\`"`
-if test "x$py_val" != xno; then
-  AC_MSG_RESULT(yes)
-  ifelse([$3], [],, [$3
-])dnl
-else
-  AC_MSG_RESULT(no)
-  ifelse([$4], [],, [$4
-])dnl
-fi
-])
-
-dnl   PYDOC_CHECK()
-AC_DEFUN([PYDOC_CHECK],
-[
-  dnl enable/disable documentation building
-  AC_ARG_ENABLE(pydoc,
-    AC_HELP_STRING([--enable-pydoc],
-                   [use pydoc to build documentation [default=no]]),,
-    enable_pydoc=no)
-
-  have_pydoc=no
-  if test x$enable_pydoc = xyes; then
-    AC_CHECK_FILE("$prefix/bin/pydoc", PYDOC="$prefix/bin/pydoc")
-  fi
-
-  if test -z "$PYDOC"; then
-    enable_pydoc=no
-  fi
-  AM_CONDITIONAL(ENABLE_PYDOC, test x$enable_pydoc = xyes)
-])
-
-dnl
-dnl JH_ADD_CFLAG(FLAG)
-dnl checks whether the C compiler supports the given flag, and if so, adds
-dnl it to $CFLAGS.  If the flag is already present in the list, then the
-dnl check is not performed.
-AC_DEFUN([JH_ADD_CFLAG],
-[
-case " $CFLAGS " in
-*@<:@\	\ @:>@$1@<:@\	\ @:>@*)
-  ;;
-*)
-  save_CFLAGS="$CFLAGS"
-  CFLAGS="$CFLAGS $1"
-  AC_MSG_CHECKING([whether [$]CC understands $1])
-  AC_TRY_COMPILE([], [], [jh_has_option=yes], [jh_has_option=no])
-  AC_MSG_RESULT($jh_has_option)
-  if test $jh_has_option = no; then
-    CFLAGS="$save_CFLAGS"
-  fi
-  ;;
-esac])
@@ -1,50 +0,0 @@
-#!/bin/sh
-# Run this to generate all the initial makefiles, etc.
-
-srcdir=`dirname $0`
-test -z "$srcdir" && srcdir=.
-
-(test -f $srcdir/configure.ac) || {
-        echo "**Error**: Directory "\`$srcdir\'" does not look like the top-level project directory"
-        exit 1
-}
-
-olddir=`pwd`
-
-PKG_NAME=`autoconf --trace 'AC_INIT:$1' "$srcdir/configure.ac"`
-
-if [ "$#" = 0 -a "x$NOCONFIGURE" = "x" ]; then
-        echo "**Warning**: I am going to run \`configure' with no arguments." >&2
-        echo "If you wish to pass any to it, please specify them on the" >&2
-        echo \`$0\'" command line." >&2
-        echo "" >&2
-fi
-
-cd "$srcdir"
-
-aclocal --install || {
-        echo "Try installing the 'automake' package."
-        exit 1
-}
-
-autoreconf --verbose --force --install -Wno-portability  || {
-        echo "Try installing the 'autoconf' package."
-        exit 1
-}
-
-which yelp-build > /dev/null || {
-       echo "Try installing the 'yelp-tools' package."
-       exit 1
-}
-
-cd "$olddir"
-
-if [ "$NOCONFIGURE" = "" ]; then
-        $srcdir/configure "$@" || exit 1
-
-        if [ "$1" = "--help" ]; then exit 0 else
-                echo "Now type \`make\' to compile $PKG_NAME" || exit 1
-        fi
-else
-        echo "Skipping configure process."
-fi
@@ -0,0 +1,83 @@
+#!/bin/bash
+#
+# Build script for Cthulhu screen reader using Meson build system
+# This script builds and installs Cthulhu locally to ~/.local
+#
+
+set -e  # Exit on error
+
+echo "Cthulhu Meson Local Build Script"
+echo "Building and installing Cthulhu to ~/.local"
+echo "================================================"
+
+# Check if we're in the right directory
+if [[ ! -f "meson.build" ]] || [[ ! -f "src/cthulhu/cthulhu.py" ]]; then
+    echo "Error: This script must be run from the Cthulhu source directory"
+    exit 1
+fi
+
+# Check for required dependencies
+echo "Checking dependencies..."
+for cmd in meson ninja python3; do
+    if ! command -v "$cmd" &> /dev/null; then
+        echo "Error: $cmd is not installed"
+        echo "Please install: meson ninja python"
+        exit 1
+    fi
+done
+
+# Check for optional dependencies
+missingOptional=()
+if ! python3 -c "import gi" 2>/dev/null; then
+    missingOptional+=("python-gi")
+fi
+
+if [[ ${#missingOptional[@]} -gt 0 ]]; then
+    echo "Warning: Optional dependencies missing: ${missingOptional[*]}"
+    echo "Cthulhu may not function properly without these."
+fi
+
+# Clean any cached bytecode
+echo "Removing __pycache__ directories..."
+find . -type d -name "__pycache__" -prune -exec rm -rf {} +
+
+# Clean any existing build directory
+if [[ -d "_build" ]]; then
+    echo "Removing existing build directory..."
+    rm -rf _build
+fi
+
+# Setup Meson build
+echo "Setting up Meson build..."
+meson setup _build --prefix="$HOME/.local" --buildtype=debugoptimized
+
+# Build
+echo "Building Cthulhu..."
+meson compile -C _build
+
+# Install
+echo "Installing Cthulhu to ~/.local..."
+meson install -C _build
+
+# Update desktop database and icon cache
+if command -v update-desktop-database &> /dev/null; then
+    echo "Updating desktop database..."
+    update-desktop-database "$HOME/.local/share/applications" 2>/dev/null || true
+fi
+
+if command -v gtk-update-icon-cache &> /dev/null; then
+    echo "Updating icon cache..."
+    gtk-update-icon-cache -f -t "$HOME/.local/share/icons/hicolor" 2>/dev/null || true
+fi
+
+echo
+echo "Build completed successfully!"
+echo
+echo "To run Cthulhu:"
+echo "  ~/.local/bin/cthulhu"
+echo
+echo "To run Cthulhu setup:"
+echo "  ~/.local/bin/cthulhu -s"
+echo
+echo "Build artifacts are in: _build/"
+echo "To clean build artifacts, run: rm -rf _build"
@@ -1,9 +0,0 @@
-#!/bin/sh
-
-set -eux -o pipefail
-
-mkdir -p _build
-cd _build
-../autogen.sh --prefix=/usr
-make
-make install
@@ -1,55 +0,0 @@
-include:
-  - remote: "https://gitlab.freedesktop.org/freedesktop/ci-templates/-/raw/80f87b3058efb75a1faae11826211375fba77e7f/templates/opensuse.yml"
-
-variables:
-  # When branching change the suffix to avoid conflicts with images
-  # from the main branch
-  BASE_TAG: "2023-06-09.0-master"
-  FDO_UPSTREAM_REPO: "gnome/cthulhu"
-
-.cthulhu_opensuse_tumbleweed_x86_64:
-  variables:
-    FDO_DISTRIBUTION_VERSION: "tumbleweed"
-    FDO_DISTRIBUTION_TAG: "x86_64-${BASE_TAG}"
-
-opensuse-container@x86_64:
-  extends:
-    - .cthulhu_opensuse_tumbleweed_x86_64
-    - .fdo.container-build@opensuse@x86_64
-  stage: "container-build"
-  variables:
-    FDO_DISTRIBUTION_PACKAGES: >-
-      autoconf
-      automake
-      dbus-1
-      dbus-1-devel
-      gcc
-      gettext
-      gettext-tools
-      git
-      glib2-devel
-      gobject-introspection-devel
-      gsettings-desktop-schemas
-      gstreamer-devel
-      itstool
-      libtool
-      libXi-devel
-      libXtst-devel
-      libxkbcommon-devel
-      libxml2-devel
-      libX11-devel
-      make
-      meson
-      ninja
-      python3
-      python3-brlapi
-      python3-louis      
-      python3-pip
-      python3-speechd
-      python310-gobject-devel
-      python310-simplejson
-      xvfb-run
-      yelp-devel
-      yelp-tools
-    FDO_DISTRIBUTION_EXEC: >-
-      pip3 install ruff
@@ -1,11 +0,0 @@
-#!/bin/sh
-
-set -eux -o pipefail
-
-git clone --depth 1 https://gitlab.gnome.org/GNOME/at-spi2-core.git
-cd at-spi2-core
-mkdir _build
-
-meson setup --buildtype=debug --prefix=/usr _build .
-meson compile -C _build
-meson install -C _build
@@ -1,12 +0,0 @@
-#!/bin/sh
-
-set -eux -o pipefail
-
-git clone --depth 1 https://gitlab.gnome.org/GNOME/pyatspi2.git
-cd pyatspi2
-mkdir _build
-cd _build
-
-../autogen.sh --prefix=/usr
-make
-make install
@@ -1,30 +0,0 @@
-#!/bin/sh
-#
-# Utility script so you can pull the container image from CI for local development.
-# Run this script and follow the instructions; the script will tell you how
-# to run "podman run" to launch a container that has the same environment as the
-# one used during CI pipelines.  You can debug things at leisure there.
-
-set -eu
-set -o pipefail
-
-CONTAINER_BUILDS=ci/container_builds.yml
-
-if [ ! -f $CONTAINER_BUILDS ]
-then
-    echo "Please run this from the toplevel source directory in cthulhu"
-    exit 1
-fi
-
-tag=$(grep -e '^  BASE_TAG:' $CONTAINER_BUILDS | head -n 1 | sed -E 's/.*BASE_TAG: "(.+)"/\1/')
-full_tag=x86_64-$tag
-echo full_tag=\"$full_tag\"
-
-image_name=registry.gitlab.gnome.org/gnome/cthulhu/opensuse/tumbleweed:$full_tag
-
-echo pulling image $image_name
-podman pull $image_name
-
-echo ""
-echo "You can now run this:"
-echo "  podman run --rm -ti --cap-add=SYS_PTRACE -v \$(pwd):/srv/project -w /srv/project $image_name"
@@ -0,0 +1,105 @@
+#!/bin/bash
+#
+# Clean script for Cthulhu screen reader Meson build
+# This script removes build artifacts and optionally the local installation
+#
+
+set -e  # Exit on error
+
+# Colors for output (only if stdout is a terminal)
+if [[ -t 1 ]]; then
+    RED='\033[0;31m'
+    GREEN='\033[0;32m'
+    YELLOW='\033[1;33m'
+    BLUE='\033[0;34m'
+    NC='\033[0m' # No Color
+else
+    RED=''
+    GREEN=''
+    YELLOW=''
+    BLUE=''
+    NC=''
+fi
+
+echo -e "${BLUE}Cthulhu Meson Clean Script${NC}"
+echo "Cleaning build artifacts and local installation"
+echo "=============================================="
+
+# Clean build directory
+if [[ -d "_build" ]]; then
+    echo -e "${YELLOW}Removing build directory...${NC}"
+    rm -rf _build
+    echo -e "${GREEN}Build directory cleaned${NC}"
+else
+    echo "No build directory found"
+fi
+
+# Ask about local installation cleanup
+echo
+read -p "Remove local installation from ~/.local? (y/N): " -n 1 -r
+echo
+if [[ $REPLY =~ ^[Yy]$ ]]; then
+    echo -e "${YELLOW}Removing local installation...${NC}"
+    
+    # Remove binary
+    if [[ -f "$HOME/.local/bin/cthulhu" ]]; then
+        rm -f "$HOME/.local/bin/cthulhu"
+        echo "  Removed: ~/.local/bin/cthulhu"
+    fi
+    
+    # Remove Python modules
+    PYTHON_SITE="$HOME/.local/lib/python$(python3 -c 'import sys; print(f"{sys.version_info.major}.{sys.version_info.minor}")')/site-packages"
+    if [[ -d "$PYTHON_SITE/cthulhu" ]]; then
+        rm -rf "$PYTHON_SITE/cthulhu"
+        echo "  Removed: $PYTHON_SITE/cthulhu/"
+    fi
+    
+    # Remove data files
+    
+    # Remove desktop files
+    if [[ -f "$HOME/.local/share/applications/cthulhu-autostart.desktop" ]]; then
+        rm -f "$HOME/.local/share/applications/cthulhu-autostart.desktop"
+        echo "  Removed: ~/.local/share/applications/cthulhu-autostart.desktop"
+    fi
+    
+    # Remove icons
+    for size in 16x16 22x22 24x24 32x32 48x48 256x256 scalable symbolic; do
+        icon_path="$HOME/.local/share/icons/hicolor/$size/apps"
+        if [[ -f "$icon_path/cthulhu.png" ]]; then
+            rm -f "$icon_path/cthulhu.png"
+            echo "  Removed: $icon_path/cthulhu.png"
+        fi
+        if [[ -f "$icon_path/cthulhu.svg" ]]; then
+            rm -f "$icon_path/cthulhu.svg"
+            echo "  Removed: $icon_path/cthulhu.svg"
+        fi
+        if [[ -f "$icon_path/cthulhu-symbolic.svg" ]]; then
+            rm -f "$icon_path/cthulhu-symbolic.svg"
+            echo "  Removed: $icon_path/cthulhu-symbolic.svg"
+        fi
+    done
+    
+    # Remove man page
+    if [[ -f "$HOME/.local/share/man/man1/cthulhu.1" ]]; then
+        rm -f "$HOME/.local/share/man/man1/cthulhu.1"
+        echo "  Removed: ~/.local/share/man/man1/cthulhu.1"
+    fi
+    
+    # Update caches
+    if command -v update-desktop-database &> /dev/null; then
+        echo -e "${YELLOW}Updating desktop database...${NC}"
+        update-desktop-database "$HOME/.local/share/applications" 2>/dev/null || true
+    fi
+    
+    if command -v gtk-update-icon-cache &> /dev/null; then
+        echo -e "${YELLOW}Updating icon cache...${NC}"
+        gtk-update-icon-cache -f -t "$HOME/.local/share/icons/hicolor" 2>/dev/null || true
+    fi
+    
+    echo -e "${GREEN}Local installation cleaned${NC}"
+else
+    echo "Local installation preserved"
+fi
+
+echo
+echo -e "${GREEN}Cleanup completed!${NC}"
@@ -1,177 +0,0 @@
-m4_define([get_version], [m4_esyscmd_s([
-  grep "^version = " src/cthulhu/cthulhuVersion.py | sed 's/version = "\(.*\)"/\1/'
-])])
-m4_define([cthulhu_version], [get_version])
-
-m4_define(pygobject_required_version, 3.18)
-m4_define(atspi_required_version, 2.48)
-m4_define(atkbridge_required_version, 2.26)
-
-AC_INIT([cthulhu],[cthulhu_version],[https://gitlab.gnome.org/GNOME/cthulhu/-/issues/],[cthulhu])
-
-AC_CONFIG_MACRO_DIR([m4])
-
-AM_INIT_AUTOMAKE([1.11 tar-ustar no-dist-gzip dist-xz])
-AM_MAINTAINER_MODE([enable])
-
-dnl Gettext stuff
-# FIXME: Remove AM_GNU_GETTEXT_VERSION once autoreconf supports REQUIRE_VERSION
-AM_GNU_GETTEXT_VERSION([0.19.8])
-AM_GNU_GETTEXT_REQUIRE_VERSION([0.19.8])
-AM_GNU_GETTEXT([external])
-
-GETTEXT_PACKAGE=AC_PACKAGE_TARNAME
-AC_SUBST(GETTEXT_PACKAGE)
-AC_DEFINE_UNQUOTED(GETTEXT_PACKAGE,"$GETTEXT_PACKAGE", [gettext package])
-
-# User Documentation
-YELP_HELP_INIT
-
-PKG_CHECK_MODULES([PYGOBJECT], [pygobject-3.0 >= pygobject_required_version])
-PKG_CHECK_MODULES([ATSPI2], [atspi-2 >= atspi_required_version])
-PKG_CHECK_MODULES([ATKBRIDGE], [atk-bridge-2.0 >= atkbridge_required_version])
-PKG_CHECK_MODULES([GSTREAMER], [gstreamer-1.0], [gstreamer="yes"], [gstreamer="no"])
-PKG_CHECK_MODULES([LIBPEAS], [libpeas-1.0])
-
-dnl Needed programs
-AC_PROG_INSTALL
-
-dnl Check for python and python modules needed by Cthulhu
-dnl TODO: check for incompatibilities between Cthulhu and liblouis
-dnl per http://live.gnome.org/Cthulhu/Braille
-AM_PATH_PYTHON(3.3)
-
-# Don't require the DISPLAY to be set - the gtk checking will fail 
-# if DISPLAY is not set, and we don't like that.
-
-AM_CHECK_PYMOD(gi,,,[AC_MSG_ERROR(Could not find python module: gi)])
-AM_CHECK_PYMOD(json,,,[AC_MSG_ERROR(Could not find python module: json)])
-AM_CHECK_PYMOD(pluggy,,[pluggy_available="yes"],[pluggy_available="no"])
-AM_CHECK_PYMOD(brlapi,,[brlapi_available="yes"],[brlapi_available="no"])
-AM_CHECK_PYMOD(speechd,,[speechd_available="yes"],[speechd_available="no"])
-AC_ARG_WITH([liblouis],
-  AS_HELP_STRING([--without-liblouis], [Disable liblouis support]))
-
-AS_IF([test "x$with_liblouis" != xno],
-  [AM_CHECK_PYMOD(louis,,[louis_available="yes"],[louis_available="no"])],
-  [louis_available=no])
-
-if test "x$with_liblouis" = xyes -a "x$louis_available" = xno; then
-  AC_MSG_ERROR([Liblouis was requested but could not be found])
-fi
-
-LOUIS_TABLE_DIR=""
-if test x$louis_available = "xyes"; then
-  LOUIS_TABLE_DIR=`pkg-config --variable=tablesdir liblouis`
-fi
-AC_SUBST(LOUIS_TABLE_DIR)
-
-REVISION=`git rev-parse --short HEAD 2> /dev/null`
-AC_SUBST(REVISION)
-
-dnl Check for the OS. On *Solaris systems the PATH must be set
-PLATFORM=`uname -a`
-case "${PLATFORM}" in
-    *SunOS*)
-            PLATFORM_PATH=":/usr/ccs/bin:/usr/bin:/usr/sbin:/bin:/usr/sfw/bin:/usr/openwin/bin:/usr/X11R6/bin"
-            ;;
-    *Linux*)
-            PLATFORM_PATH=":/usr/bin:/usr/sbin:/bin"
-            ;;
-esac
-AC_SUBST(PLATFORM_PATH)
-
-AC_CONFIG_FILES([
-Makefile
-docs/Makefile
-docs/man/Makefile
-po/Makefile.in
-help/Makefile
-icons/Makefile
-src/Makefile
-src/cthulhu/Makefile
-src/cthulhu/scripts/Makefile
-src/cthulhu/scripts/apps/Makefile
-src/cthulhu/scripts/apps/Banshee/Makefile
-src/cthulhu/scripts/apps/Eclipse/Makefile
-src/cthulhu/scripts/apps/epiphany/Makefile
-src/cthulhu/scripts/apps/evince/Makefile
-src/cthulhu/scripts/apps/evolution/Makefile
-src/cthulhu/scripts/apps/gajim/Makefile
-src/cthulhu/scripts/apps/gcalctool/Makefile
-src/cthulhu/scripts/apps/gedit/Makefile
-src/cthulhu/scripts/apps/gnome-documents/Makefile
-src/cthulhu/scripts/apps/gnome-shell/Makefile
-src/cthulhu/scripts/apps/kwin/Makefile
-src/cthulhu/scripts/apps/notification-daemon/Makefile
-src/cthulhu/scripts/apps/notify-osd/Makefile
-src/cthulhu/scripts/apps/pidgin/Makefile
-src/cthulhu/scripts/apps/soffice/Makefile
-src/cthulhu/scripts/apps/SeaMonkey/Makefile
-src/cthulhu/scripts/apps/smuxi-frontend-gnome/Makefile
-src/cthulhu/scripts/apps/Thunderbird/Makefile
-src/cthulhu/scripts/apps/xfwm4/Makefile
-src/cthulhu/scripts/sleepmode/Makefile
-src/cthulhu/scripts/switcher/Makefile
-src/cthulhu/scripts/terminal/Makefile
-src/cthulhu/scripts/web/Makefile
-src/cthulhu/scripts/toolkits/Makefile
-src/cthulhu/scripts/toolkits/Chromium/Makefile
-src/cthulhu/scripts/toolkits/Gecko/Makefile
-src/cthulhu/scripts/toolkits/J2SE-access-bridge/Makefile
-src/cthulhu/scripts/toolkits/clutter/Makefile
-src/cthulhu/scripts/toolkits/GAIL/Makefile
-src/cthulhu/scripts/toolkits/Qt/Makefile
-src/cthulhu/scripts/toolkits/WebKitGtk/Makefile
-src/cthulhu/scripts/toolkits/gtk/Makefile
-src/cthulhu/plugins/Makefile
-src/cthulhu/plugins/ByeCthulhu/Makefile
-src/cthulhu/plugins/HelloCthulhu/Makefile
-src/cthulhu/plugins/PluginManager/Makefile
-src/cthulhu/plugins/Clipboard/Makefile
-src/cthulhu/plugins/DisplayVersion/Makefile
-src/cthulhu/plugins/hello_world/Makefile
-src/cthulhu/plugins/CapsLockHack/Makefile
-src/cthulhu/plugins/self_voice/Makefile
-src/cthulhu/plugins/Date/Makefile
-src/cthulhu/plugins/Time/Makefile
-src/cthulhu/plugins/MouseReview/Makefile
-src/cthulhu/plugins/SimplePluginSystem/Makefile
-src/cthulhu/backends/Makefile
-src/cthulhu/cthulhu_bin.py
-src/cthulhu/cthulhu_i18n.py
-src/cthulhu/cthulhu_platform.py
-])
-AC_CONFIG_COMMANDS([default],[cp src/cthulhu/cthulhu_bin.py src/cthulhu/cthulhu],[])
-AC_OUTPUT
-
-if test "x$brlapi_available" = "xno" ; then
-echo
-echo "NOTE: Braille support requires BrlTTY >= 3.9 and BrlAPI >= 0.5.1."
-fi
-if test "x$wnck_available" = "xno" ; then
-echo
-echo "NOTE: Mouse review requires wnck, which was not found."
-fi
-
-if test "x$speechd_available" = "xno" ; then
-echo
-echo "NOTE: Speech support requires speech-dispatcher >= 0.8."
-fi
-
-if test "x$gstreamer" = "xno" ; then
-echo
-echo "NOTE: Sound support requires gstreamer-1.0."
-fi
-
-if test "$have_libpeas" = "no"; then
-  AC_MSG_ERROR([libpeas-1.0 >= 1.20 is required])
-fi
-
-echo
-echo Use pluggy: $pluggy_available
-echo Use speech-dispatcher: $speechd_available
-echo Use brltty: $brlapi_available
-echo Use liblouis: $louis_available
-echo Use gstreamer: $gstreamer
-echo
@@ -1,46 +1,59 @@
 [Desktop Entry]
 Type=Application
 Name[an]=Lector de pantalla Cthulhu
-Name[ast]=Llector de pantalla Cthulhu
-Name[be]=ÐÑÑÐÑÑÐ Cthulhu
-Name[bg]=Cthulhu âÐÐÐ ÑÑÑName[bs]=Cthulhu ÄtaÄekrana
+Name[ast]=Llector de pantalla d'Cthulhu
+Name[be]=Чытач з экрана Cthulhu
+Name[bg]=Cthulhu — екранен четец
+Name[bs]=Cthulhu čitač ekrana
 Name[ca]=Lector de pantalla Cthulhu
-Name[cs]=ÄeÄa obrazovky Cthulhu
-Name[da]=SkÃmlÃeren Cthulhu
+Name[cs]=Čtečka obrazovky Cthulhu
+Name[da]=Skærmlæseren Cthulhu
 Name[de]=Cthulhu-Bildschirmleser
-Name[el]=ÎÎÎÏÎ ÎÏÎ Cthulhu
+Name[el]=Αναγνώστης οθόνης Cthulhu
 Name[en_GB]=Cthulhu Screen Reader
-Name[eo]=Ekranlegilo Cthulhu
+Name[eo]=Ekranlegilo Orko
 Name[es]=Lector de pantalla Cthulhu
 Name[eu]=Cthulhu pantaila-irakurlea
-Name[fa]=ØØâØ Cthulhu
-Name[fi]=Cthulhu-nÃtÃlukija
-Name[fr]=Lecteur dâran Cthulhu
+Name[fa]=صفحه‌خوان اورکا
+Name[fi]=Cthulhu-näytönlukija
+Name[fr]=Lecteur d’écran Cthulhu
 Name[gl]=Lector da pantalla Cthulhu
-Name[he]=××××× Cthulhu
-Name[hi]=Cthulhu àààà
-Name[hu]=Cthulhu kÃernyÅlvasÃName[id]=Pembaca Layar Cthulhu
-Name[is]=Cthulhu skjÃestur
+Name[he]=מקריא המסך Cthulhu
+Name[hi]=Cthulhu स्क्रीन वाचक
+Name[hu]=Orka képernyőolvasó
+Name[id]=Pembaca Layar Cthulhu
+Name[is]=Cthulhu skjálestur
 Name[it]=Lettore schermo Cthulhu
-Name[ka]=Cthulhu - ááááááName[kk]=Cthulhu ÑÑÐÐ ÐÐÑ ÒÐÐÐÑ
-Name[lt]=Cthulhu ekrano skaityklÄName[lv]=Cthulhu ekrÄa lasÄÄs
-Name[mk]=Cthulhu ÑÑÑÐ ÐÑÐÑName[nb]=Cthulhu skjermleser
-Name[ne]=Cthulhu àà ààame[nl]=Cthulhu schermlezer
+Name[ka]=Cthulhu - ეკრანის მკითხველი
+Name[kk]=Cthulhu экраннан оқитын қолданбасы
+Name[lt]=Cthulhu ekrano skaityklė
+Name[lv]=Cthulhu ekrāna lasītājs
+Name[mk]=Cthulhu читач на екранот
+Name[nb]=Cthulhu skjermleser
+Name[ne]=ओर्का दृष्टि वाचक
+Name[nl]=Cthulhu schermlezer
 Name[oc]=Lector d'ecran Cthulhu
-Name[pa]=Cthulhu ààààame[pl]=Czytnik ekranowy Cthulhu
-Name[pt]=Leitor de ecrÃCthulhu
+Name[pa]=ਓਰਕਾ ਸਕਰੀਨ ਰੀਡਰ
+Name[pl]=Czytnik ekranowy Cthulhu
+Name[pt]=Leitor de ecrã Cthulhu
 Name[pt_BR]=Leitor de tela Cthulhu
 Name[ro]=Cititorul de ecran Cthulhu
-Name[ru]=ÐÑÐÑ ÐÐÐ Cthulhu
-Name[sl]=Zaslonski bralnik Cthulhu
-Name[sr]=ÐÑÑÐÑÐ Cthulhu
-Name[sv]=Cthulhu skÃmlÃare
-Name[ta]=Cthulhu àààà 
-Name[te]=Cthulhu ààà
-Name[tg]=ÐÐÐÐ ÑÑÐ Cthulhu
+Name[ru]=Экранный диктор Cthulhu
+Name[sl]=Zaslonski bralnik Orka
+Name[sr]=Читач екрана Орка
+Name[sv]=Cthulhu skärmläsare
+Name[ta]=ஆர்கா திரை படிப்பி 
+Name[te]=ఓర్కా తెరచదువరి
+Name[tg]=Хонандаи экрани Cthulhu
 Name[tr]=Cthulhu Ekran Okuyucu
-Name[ug]=Cthulhu ØÙØ ØÙØ
-Name[uk]=ÐÑÑÐÐ ÑÑÐÑÐÐÑÐ ÂthulhuÂName[zh_CN]=Cthulhu åèName[zh_HK]=Cthulhu èèName=Cthulhu Screen Reader
+Name[ug]=Cthulhu ئېكران ئوقۇغۇ
+Name[uk]=Інструмент читання з екрана «Cthulhu»
+Name[zh_CN]=Cthulhu 屏幕阅读器
+Name[zh_HK]=Cthulhu 螢幕閱讀器
+Name=Cthulhu Screen Reader
 Exec=cthulhu
 NoDisplay=true
+AutostartCondition=GSettings org.gnome.desktop.a11y.applications screen-reader-enabled
 X-GNOME-AutoRestart=true
+#X-GNOME-Autostart-Phase=Initialization
+OnlyShowIn=GNOME;MATE;Unity;Cinnamon;
@@ -3,7 +3,9 @@ Type=Application
 Name=Cthulhu Screen Reader
 Exec=cthulhu
 NoDisplay=true
-AutostartCondition=GSettings org.gnome.desktop.a11y.applications screen-reader-enabled
+# Desktop-neutral autostart - no GNOME-specific conditions
+# Users can enable/disable via their desktop environment's accessibility settings
+# or by adding/removing this file from ~/.config/autostart/
 X-GNOME-AutoRestart=true
-#X-GNOME-Autostart-Phase=Initialization
-OnlyShowIn=GNOME;MATE;Unity;Cinnamon;
+Categories=Accessibility;
+Keywords=screen;reader;accessibility;speech;braille;
@@ -7,10 +7,10 @@
  <name xml:lang="en">cthulhu</name>
  <shortdesc xml:lang="en">Screen reader for individuals who are blind or visually impaired</shortdesc>
  <description xml:lang="en">Screen reader for individuals who are blind or visually impaired</description>
-  <homepage rdf:resource="https://wiki.gnome.org/Projects/Cthulhu" />
-  <mailing-list rdf:resource="https://www.freelists.org/list/cthulhu" />
-  <download-page rdf:resource="https://download.gnome.org/sources/cthulhu/" />
-  <bug-database rdf:resource="https://gitlab.gnome.org/GNOME/cthulhu/issues" />
+  <homepage rdf:resource="https://git.stormux.org/storm/cthulhu" />
+  <mailing-list rdf:resource="https://groups.io/g/stormux" />
+  <download-page rdf:resource="https://git.stormux.org/storm/cthulhu" />
+  <bug-database rdf:resource="https://git.stormux.org/storm/cthulhu" />
  <category rdf:resource="http://api.gnome.org/doap-extensions#apps" />
  <programming-language>Python</programming-language>
  <maintainer>
@@ -1,48 +1,88 @@
 # Maintainer: Storm Dragon <storm_dragon@stormux.org>

 pkgname=cthulhu
-pkgver=0.4
+pkgver=2025.12.31
 pkgrel=1
-pkgdesc="Screen reader for individuals who are blind or visually impaired forked from Orca"
+pkgdesc="Desktop-agnostic screen reader with plugin system, forked from Orca"
 url="https://git.stormux.org/storm/cthulhu"
 arch=(any)
 license=(LGPL)
 depends=(
+  # Core AT-SPI accessibility
  at-spi2-core
-  brltty
  gobject-introspection-runtime
-  gsettings-desktop-schemas
+  python-gobject
+  python-cairo
+  gtk3
+  
+  # Audio and speech
+  speech-dispatcher
  gstreamer
  gst-plugins-base # playbin, audiotestsrc, basic decoders
  gst-plugins-good # pulsesink, more decoders
-  gtk3
-  hicolor-icon-theme
+  
+  # Braille support
+  brltty
  liblouis
-  libpeas
+  
+  # Plugin system and D-Bus remote control
+  python-pluggy
+  python-dasbus
+  
+  # AI Assistant dependencies (for screenshots, HTTP requests, and actions)
+  python-requests
+  python-pyautogui
+  
+  # Desktop integration
+  hicolor-icon-theme
  libwnck3
  pango
+  
+  # System utilities
  python
-  python-atspi
-  python-cairo
-  python-gobject
  python-setproctitle
-  socat
-  speech-dispatcher
+  socat # for self-voicing feature
  xorg-xkbcomp
  xorg-xmodmap
 )
+optdepends=(
+  'espeak-ng: Alternative TTS engine'
+  'festival: Alternative TTS engine' 
+  'flite: Lightweight TTS engine'
+  'espeak: Legacy TTS engine'
+  
+  # AI Assistant providers (optional)
+  'claude-code: Claude AI provider support'
+  'openai-codex: ChatGPT AI provider support' 
+  'gemini-cli: Gemini AI provider support'
+  'ollama: Local AI model support'
+  
+  # OCR plugin dependencies (optional)
+  'python-pillow: Image processing for OCR and AI Assistant'
+  'python-pytesseract: Python wrapper for Tesseract OCR engine'
+  'python-pdf2image: PDF to image conversion for OCR'
+  'python-scipy: Scientific computing for OCR color analysis'
+  'python-webcolors: Color name lookup for OCR text decoration'
+  'tesseract: OCR engine for text recognition'
+  'tesseract-data-eng: English language data for Tesseract'
+)
 makedepends=(
  git
-  itstool
-  yelp-tools
+  meson
+  ninja
+  python-build
+  python-installer
+  python-wheel
+)
+install=cthulhu.install
+source=(
+  "git+https://git.stormux.org/storm/cthulhu.git"
+  "cthulhu.install"
+)
+b2sums=(
+  'SKIP'
+  'SKIP'
 )
-source=("git+https://git.stormux.org/storm/cthulhu.git")
-b2sums=('SKIP')
-
-prepare() {
-  cd cthulhu
-  NOCONFIGURE=1 ./autogen.sh
-}

 pkgver() {
  cd cthulhu
@@ -51,13 +91,16 @@ pkgver() {

 build() {
  cd cthulhu
-  ./configure --prefix=/usr --sysconfdir=/etc --localstatedir=/var
-  make
+  arch-meson _build
+  meson compile -C _build
 }

 package() {
  cd cthulhu
-  make DESTDIR="$pkgdir" install
+  meson install -C _build --destdir "$pkgdir"
+
+  # Remove icon cache - it will be generated by post-install hooks
+  rm -f "$pkgdir/usr/share/icons/hicolor/icon-theme.cache"
 }

 # vim:set sw=2 sts=-1 et:
@@ -0,0 +1,11 @@
+post_install() {
+  gtk-update-icon-cache -q -t -f usr/share/icons/hicolor
+}
+
+post_upgrade() {
+  post_install
+}
+
+post_remove() {
+  gtk-update-icon-cache -q -t -f usr/share/icons/hicolor
+}
@@ -1 +0,0 @@
-SUBDIRS = man
@@ -1,5 +0,0 @@
-
-man1_MANS = cthulhu.1
-
-EXTRA_DIST = \
-	$(man1_MANS)
@@ -331,4 +331,4 @@ mailing list
 <http://mail.gnome.org/mailman/listinfo/cthulhu-list>
 To post a message to all
 .B cthulhu
-list, send a email to cthulhu-list@gnome.org
+list, send a email to https://groups.io/g/stormux
@@ -0,0 +1 @@
+install_man('cthulhu.1')
@@ -0,0 +1 @@
+subdir('man')
@@ -1,34 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="guide" id="commands">
-  <info>
-    <link type="next" xref="commands_controlling_cthulhu" />
-    <link type="guide" xref="index#quick_reference" />
-    <title type="sort">4. <app>Cthulhu</app>'s Commands</title>
-    <title type="link">Commands</title>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title><app>Cthulhu</app>'s Commands</title>
-  <section id="getting_started"  style="2column">
-    <title>Getting Started</title>
-  </section>
-  <section id="speech_braille"  style="2column">
-    <title>Speech and Braille</title>
-  </section>
-  <section id="reading_documents"  style="2column">
-    <title>Reading Web Pages and Other Documents</title>
-  </section>
-  <section id="reviewing_screen_contents"  style="2column">
-    <title>Reviewing and Interacting with Screen Contents</title>
-  </section>
-  <section id="accessing_dynamic_information"  style="2column">
-    <title>Accessing Dynamic Information</title>
-  </section>
-  <section id="troubleshooting">
-    <title>Troubleshooting</title>
-  </section>
-</page>
@@ -1,57 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="commands_bookmarks">
-  <info>
-    <link type="next" xref="commands_live_regions" />
-    <link type="guide" xref="commands#reviewing_screen_contents" />
-    <link type="seealso" xref="howto_bookmarks" />
-    <title type="sort">4. Bookmarks</title>
-    <title type="link">Bookmarks</title>
-    <desc>
-      Commands to bookmark and retrieve objects
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Bookmark Commands</title>
-  <p>
-    <app>Cthulhu</app> provides several commands which can be used to "bookmark"
-    a given object for the purpose of navigating back to it later.
-  </p>
-  <list>
-    <item>
-      <p>
-        Save a bookmark to the numbered slot: <keyseq><key>Cthulhu Modifier</key>
-        <key>Alt</key><key>1</key></keyseq>-<key>6</key>
-      </p>
-    </item>
-    <item>
-      <p>
-        Save the defined bookmarks for the application or page:
-        <keyseq><key>Cthulhu Modifier</key><key>Alt</key><key>B</key></keyseq>
-      </p>
-    </item>
-    <item>
-      <p>
-        Go to a specific, numbered bookmark: <keyseq><key>Cthulhu Modifier</key>
-        <key>1</key></keyseq>-<key>6</key>
-      </p>
-    </item>
-    <item>
-      <p>
-        Go to the previous bookmark for the application or page:
-        <keyseq><key>Cthulhu Modifier</key><key>Shift</key><key>B</key>
-        </keyseq>
-      </p>
-    </item>
-    <item>
-      <p>
-        Go to the next bookmark for the application or page:
-        <keyseq><key>Cthulhu Modifier</key><key>B</key></keyseq>
-      </p>
-    </item>
-  </list>
-</page>
@@ -1,40 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="commands_braille">
-  <info>
-    <link type="next" xref="commands_reading" />
-    <link type="guide" xref="commands#speech_braille" />
-    <link type="seealso" xref="preferences_braille" />
-    <title type="sort">2. Braille</title>
-    <title type="link">Braille</title>
-    <desc>
-      Commands executable on braille displays
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Braille Commands</title>
-  <p>
-    The following commands allow you to control <app>Cthulhu</app> from your
-    refreshable braille display rather than your keyboard:
-  </p>
-  <list>
-    <item><p>Pan braille display to the left: Line Left</p></item>
-    <item><p>Pan braille display to the right: Line Right</p></item>
-    <item><p>Toggle flat review mode: Freeze</p></item>
-    <item><p>Review the word above: Line Up</p></item>
-    <item><p>Review the word below: Line Down</p></item>
-    <item><p>Review bottom left: Bottom Right</p></item>
-    <item><p>Review the home position: Top Left</p></item>
-    <item><p>Contracted braille: Six Dots</p></item>
-    <item><p>Marks the beginning of a text selection: Cut Begin</p></item>
-    <item><p>Marks the end of a text selection: Cut Line</p></item>
-    <item><p>Processes a cursor routing key: Cursor Routing</p></item>
-    <item><p>Returns to object with keyboard focus: Cursor Position</p></item>
-  </list>
-</page>
-
-
@@ -1,52 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="commands_chat">
-  <info>
-    <link type="next" xref="commands_debugging" />
-    <link type="guide" xref="commands#accessing_dynamic_information" />
-    <link type="seealso" xref="preferences_chat" />
-    <title type="sort">2. Chat</title>
-    <title type="link">Chat</title>
-    <desc>
-      Commands for use with IM and IRC clients
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Chat Commands</title>
-  <p>
-    The following commands can be used to access information in the
-    instant messaging and internet relay chat clients supported by
-    <app>Cthulhu</app>. You will notice that several of these commands
-    are "unbound." Please see <link xref="howto_key_bindings">Modifying
-    Keybindings</link> for information on how to bind these commands to
-    keystrokes.
-  </p>
-  <list>
-    <item>
-      <p>
-        Present previous chat room messages:
-        <keyseq><key>Cthulhu Modifier</key><key>F1</key></keyseq> through <key>F9</key>
-      </p>
-    </item>
-    <item>
-      <p>
-        Enable/disable announcement of room name with messages: (Unbound)
-      </p>
-    </item>
-    <item>
-      <p>Enable/disable announcement of buddy typing status: (Unbound)</p>
-    </item>
-    <item>
-      <p>Enable/disable room-specific histories: (Unbound)</p>
-    </item>
-  </list>
-</page>
-
-
-
-
-
@@ -1,86 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="commands_controlling_cthulhu">
-  <info>
-    <link type="next" xref="commands_where_am_i" />
-    <link type="guide" xref="commands#getting_started" />
-    <title type="sort">1. Controlling and Learning to Use Cthulhu</title>
-    <title type="link">Controlling and Learning to Use Cthulhu</title>
-    <desc>
-      Commands for interacting with <app>Cthulhu</app>
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Controlling and Learning to Use Cthulhu</title>
-  <section id="controlling">
-    <title>Commands for Controlling <app>Cthulhu</app></title>
-    <p>
-      The following commands can be used to get into <app>Cthulhu</app>'s
-      Preferences dialogs, toggle <app>Cthulhu</app> on and off, and bypass
-      <app>Cthulhu</app> commands to avoid shortcut conflicts within the
-      application being accessed.
-    </p>
-    <list>
-      <item>
-        <p>
-          Toggle <app>Cthulhu</app> on and off in GNOME:
-          <keyseq><key>Super</key><key>Alt</key><key>S</key></keyseq>.
-        </p>
-        <note style="tip">
-           <p>
-             If you are using <app>Cthulhu</app> in another desktop environment in which
-             there is no command to toggle <app>Cthulhu</app> on and off, you may find the
-             command to quit <app>Cthulhu</app> helpful. This command is unbound by default.
-             Please see <link xref="howto_key_bindings">Modifying Keybindings</link> for
-             information on how to bind unbound commands.
-           </p>
-        </note>
-      </item>
-      <item>
-        <p>
-          <link xref="preferences">Cthulhu Preferences</link> dialog:
-          <keyseq><key>Cthulhu Modifier</key><key>Space</key></keyseq>.
-        </p>
-      </item>
-      <item>
-        <p>
-          Cthulhu's Preferences dialog for the focused application:
-          <keyseq><key>Ctrl</key><key>Cthulhu Modifier</key><key>Space</key></keyseq>.
-        </p>
-      </item>
-      <item>
-        <p>
-          Pass the next command on to the current application:
-          <keyseq><key>Cthulhu Modifier</key><key>BackSpace</key></keyseq>
-        </p>
-      </item>
-    </list>
-  </section>
-  <section id="learning">
-    <title>Commands for Learning to Use <app>Cthulhu</app></title>
-    <p>
-      In Learn Mode, <app>Cthulhu</app> will announce each keystroke you pressed
-      along with any associated <app>Cthulhu</app> command that keystroke is bound
-      to. In this mode, you can also get a list of shortcuts containing all the
-      <app>Cthulhu</app> commands you can use.
-    </p>
-    <list>
-      <item>
-        <p>
-          Enter Learn Mode:
-          <keyseq><key>Cthulhu Modifier</key><key>H</key></keyseq>
-        </p>
-      </item>
-      <item>
-        <p>
-          Exit Learn Mode:
-          <keyseq><key>Esc</key></keyseq>
-        </p>
-      </item>
-    </list>
-  </section>
-</page>
@@ -1,29 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="commands_debugging">
-  <info>
-    <link type="guide" xref="commands#troubleshooting" />
-    <title type="sort">1. Debugging</title>
-    <title type="link">Debugging</title>
-    <desc>
-      Commands for troubleshooting
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Debugging Commands</title>
-  <p>
-    You may be asked by the developers to provide some debugging information in
-    order to help them identify the source of a problem you are experiencing.
-    The following command is not "bound" to a keystroke. If you need to bind it,
-    please see <link xref="howto_key_bindings">Modifying Keybindings</link>.
-  </p>
-  <list>
-    <item>
-      <p>Cycle to the next debug level: (Unbound)</p>
-    </item>
-  </list>
-</page>
@@ -1,76 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="commands_find">
-  <info>
-    <link type="next" xref="commands_mouse" />
-    <link type="guide" xref="commands#reviewing_screen_contents" />
-    <link type="seealso" xref="howto_cthulhu_find" />
-    <title type="sort">2. Cthulhu Find</title>
-    <title type="link">Cthulhu Find</title>
-    <desc>
-      Commands for searching window contents
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Cthulhu Find Commands</title>
-  <p>
-    <app>Cthulhu</app>'s <link xref="howto_cthulhu_find">Find feature</link> allows
-    you to search the <link xref="howto_flat_review">Flat Review</link> context
-    for elements located within the current window.
-  </p>
-  <list>
-    <item>
-      <p>Open the <app>Cthulhu</app> Find dialog:</p>
-      <list>
-        <item>
-          <p>Desktop: <keyseq><key>KP Delete</key></keyseq></p>
-        </item>
-        <item>
-          <p>Laptop: <keyseq><key>Cthulhu Modifier</key><key>Left Bracket</key></keyseq></p>
-        </item>
-      </list>
-    </item>
-    <item>
-      <p>Move flat review to the next instance of a string:</p>
-      <list>
-        <item>
-          <p>
-            Desktop:
-            <keyseq><key>Cthulhu Modifier</key><key>KP Delete</key></keyseq>
-          </p>
-        </item>
-        <item>
-          <p>
-            Laptop:
-            <keyseq><key>Cthulhu Modifier</key><key>Right Bracket</key></keyseq>
-          </p>
-        </item>
-      </list>
-    </item>
-    <item>
-      <p>Move flat review to the previous instance of a string:</p>
-      <list>
-        <item>
-          <p>
-            Desktop:
-            <keyseq>
-              <key>Cthulhu Modifier</key><key>Shift</key><key>KP Delete</key>
-            </keyseq>
-          </p>
-        </item>
-        <item>
-          <p>
-            Laptop:
-            <keyseq>
-              <key>Cthulhu Modifier</key><key>Ctrl</key><key>Right Bracket</key>
-            </keyseq>
-          </p>
-        </item>
-      </list>
-    </item>
-  </list>
-</page>
@@ -1,199 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="commands_flat_review">
-  <info>
-    <link type="next" xref="commands_find" />
-    <link type="guide" xref="commands#reviewing_screen_contents" />
-    <link type="seealso" xref="howto_flat_review" />
-    <title type="sort">1. Flat Review</title>
-    <title type="link">Flat Review</title>
-    <desc>
-      Commands for spatially reviewing windows
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Flat Review Commands</title>
-  <p>
-    Cthulhu's <link xref="howto_flat_review">Flat Review</link> commands are
-    designed for spatially reviewing elements displayed on the screen. They
-    also provide a means for reading the current line, word, and character
-    when navigating in the text of a document. Most of these commands are
-    "bound" to keystrokes. Please see <link xref="howto_key_bindings">Modifying
-    Keybindings</link> for information on how to bind unbound commands.
-  </p>
-  <section id="line">
-    <title>Commands for Reviewing by Line</title>
-    <list>
-      <item>
-        <p>First line (The "home" position):</p>
-        <list>
-          <item><p>Desktop: <keyseq><key>Cthulhu Modifier</key><key>KP 7</key></keyseq></p></item>
-          <item><p>Laptop: <keyseq><key>Cthulhu Modifier</key><key>Ctrl</key><key>U</key></keyseq></p></item>
-        </list>
-      </item>
-      <item>
-        <p>Previous line:</p>
-        <list>
-          <item><p>Desktop: <keyseq><key>KP 7</key></keyseq></p></item>
-          <item><p>Laptop: <keyseq><key>Cthulhu Modifier</key><key>U</key></keyseq></p></item>
-        </list>
-      </item>
-      <item>
-        <p>Current line:</p>
-        <list>
-          <item><p>Desktop: <keyseq><key>KP 8</key></keyseq></p></item>
-          <item><p>Laptop: <keyseq><key>Cthulhu Modifier</key><key>I</key></keyseq></p></item>
-        </list>
-      </item>
-        <item><p>Spell current line:</p>
-        <list>
-          <item><p>Desktop: <keyseq><key>KP 8</key></keyseq> (double-clicked)</p></item>
-          <item><p>Laptop: <keyseq><key>Cthulhu Modifier</key><key>I</key></keyseq> (double-clicked)</p></item>
-        </list>
-      </item>
-      <item><p>Phonetically spell current line:</p>
-        <list>
-          <item><p>Desktop: <keyseq><key>KP 8</key></keyseq> (triple-clicked)</p></item>
-          <item><p>Laptop: <keyseq><key>Cthulhu Modifier</key><key>I</key></keyseq> (triple-clicked)</p></item>
-        </list>
-      </item>
-      <item><p>Next line:</p>
-        <list>
-          <item><p>Desktop: <keyseq><key>KP 9</key></keyseq></p></item>
-          <item><p>Laptop: <keyseq><key>Cthulhu Modifier</key><key>O</key></keyseq></p></item>
-        </list>
-      </item>
-      <item><p>Last line (The "end" position):</p>
-        <list>
-          <item><p>Desktop: <keyseq><key>Cthulhu Modifier</key><key>KP 9</key></keyseq></p></item>
-          <item><p>Laptop: <keyseq><key>Cthulhu Modifier</key><key>Ctrl</key><key>O</key></keyseq></p></item>
-        </list>
-      </item>
-    </list>
-  </section>
-  <section id="word">
-    <title>Commands for Reviewing by Word</title>
-    <list>
-      <item><p>Word above:</p>
-        <list>
-          <item><p>Desktop: <keyseq><key>Cthulhu Modifier</key><key>KP 4</key></keyseq></p></item>
-          <item><p>Laptop: <keyseq><key>Cthulhu Modifier</key><key>Ctrl</key><key>J</key></keyseq></p></item>
-        </list>
-      </item>
-      <item><p>Previous word:</p>
-        <list>
-          <item><p>Desktop: <keyseq><key>KP 4</key></keyseq></p></item>
-          <item><p>Laptop: <keyseq><key>Cthulhu Modifier</key><key>J</key></keyseq></p></item>
-        </list>
-      </item>
-      <item><p>Current word:</p>
-        <list>
-          <item><p>Desktop: <keyseq><key>KP 5</key></keyseq></p></item>
-          <item><p>Laptop: <keyseq><key>Cthulhu Modifier</key><key>K</key></keyseq></p></item>
-        </list>
-      </item>
-      <item><p>Spell current word:</p>
-        <list>
-          <item><p>Desktop: <keyseq><key>KP 5</key></keyseq> (double-clicked)</p></item>
-          <item><p>Laptop: <keyseq><key>Cthulhu Modifier</key><key>K</key></keyseq> (double-clicked)</p></item>
-        </list>
-      </item>
-      <item><p>Phonetically spell current word:</p>
-        <list>
-          <item><p>Desktop: <keyseq><key>KP 5</key></keyseq> (triple-clicked)</p></item>
-          <item><p>Laptop: <keyseq><key>Cthulhu Modifier</key><key>K</key></keyseq> (triple-clicked)</p></item>
-        </list>
-      </item>
-      <item><p>Next word:</p>
-        <list>
-          <item><p>Desktop: <keyseq><key>KP 6</key></keyseq></p></item>
-          <item><p>Laptop: <keyseq><key>Cthulhu Modifier</key><key>L</key></keyseq></p></item>
-        </list>
-      </item>
-      <item><p>Word below:</p>
-        <list>
-          <item><p>Desktop: <keyseq><key>Cthulhu Modifier</key><key>KP 6</key></keyseq></p></item>
-          <item><p>Laptop: <keyseq><key>Cthulhu Modifier</key><key>Ctrl</key><key>L</key></keyseq></p></item>
-        </list>
-      </item>
-    </list>
-  </section>
-  <section id="character">
-    <title>Commands for Reviewing by Character</title>
-    <list>
-      <item><p>Previous character:</p>
-        <list>
-          <item><p>Desktop: <keyseq><key>KP 1</key></keyseq></p></item>
-          <item><p>Laptop: <keyseq><key>Cthulhu Modifier</key><key>M</key></keyseq></p></item>
-        </list>
-      </item>
-      <item><p>Current character:</p>
-        <list>
-          <item><p>Desktop: <keyseq><key>KP 2</key></keyseq></p></item>
-          <item><p>Laptop: <keyseq><key>Cthulhu Modifier</key><key>Comma</key></keyseq></p></item>
-        </list>
-      </item>
-      <item><p>Phonetically speak current character:</p>
-        <list>
-          <item><p>Desktop: <keyseq><key>KP 2</key></keyseq> (double-clicked)</p></item>
-          <item><p>Laptop: <keyseq><key>Cthulhu Modifier</key><key>Comma</key></keyseq> (double-clicked)</p></item>
-        </list>
-      </item>
-      <item><p>Speak Unicode value of current character:</p>
-        <list>
-          <item><p>Desktop: <keyseq><key>KP 2</key></keyseq> (triple-clicked)</p></item>
-          <item><p>Laptop: <keyseq><key>Cthulhu Modifier</key><key>Comma</key></keyseq> (triple-clicked)</p></item>
-        </list>
-      </item>
-      <item><p>Next character:</p>
-        <list>
-          <item><p>Desktop: <keyseq><key>KP 3</key></keyseq></p></item>
-          <item><p>Laptop: <keyseq><key>Cthulhu Modifier</key><key>Period</key></keyseq></p></item>
-        </list>
-      </item>
-      <item><p>Last character on current line:</p>
-        <list>
-          <item><p>Desktop: <keyseq><key>Cthulhu Modifier</key><key>KP 1</key></keyseq></p></item>
-          <item><p>Laptop: <keyseq><key>Cthulhu Modifier</key><key>Ctrl</key><key>M</key></keyseq></p></item>
-        </list>
-      </item>
-    </list>
-  </section>
-  <section id="other">
-    <title>Additional Commands</title>
-    <list>
-      <item><p>Toggle flat review (refreshes the flat review context):</p>
-        <list>
-          <item><p>Desktop: <keyseq><key>Cthulhu Modifier</key><key>KP Subtract</key></keyseq></p></item>
-          <item><p>Laptop: <keyseq><key>Cthulhu Modifier</key><key>P</key></keyseq></p></item>
-        </list>
-      </item>
-      <item><p>Review current item/widget:</p>
-        <list>
-          <item><p>Desktop: <keyseq><key>Cthulhu Modifier</key><key>KP 5</key></keyseq></p></item>
-          <item><p>Laptop: <keyseq><key>Cthulhu Modifier</key><key>Ctrl</key><key>K</key></keyseq></p></item>
-        </list>
-      </item>
-      <item><p>Use Say All to review the current dialog or window:</p>
-        <list>
-          <item><p>Desktop: <key>KP Plus</key> (double-clicked)</p></item>
-          <item><p>Laptop: <keyseq><key>Cthulhu Modifier</key><key>Semicolon</key></keyseq> (double-clicked)</p></item>
-        </list>
-      </item>
-      <item>
-      <p>
-        Copy the contents under flat review to the clipboard: (Unbound)
-      </p>
-      </item>
-        <item>
-        <p>
-          Append the contents under flat review to the clipboard: (Unbound)
-      </p>
-      </item>
-    </list>
-  </section>
-</page>
@@ -1,62 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="commands_live_regions">
-  <info>
-    <link type="next" xref="commands_chat" />
-    <link type="guide" xref="commands#accessing_dynamic_information" />
-    <link type="seealso" xref="howto_live_regions"  />
-    <title type="sort">1. Live Regions</title>
-    <title type="link">Live Regions</title>
-    <desc>
-      Commands for accessing web live regions
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0
-      </p>
-    </license>
-  </info>
-  <title>Live Region Commands</title>
-  <p>
-    The following commands can be used to access dynamically-updated
-    content on web pages which have been made accessible through ARIA.
-  </p>
-  <list>
-    <item>
-      <p>
-        Monitor live regions:
-        <keyseq><key>Cthulhu Modifier</key><key>Shift</key><key>Backslash</key></keyseq>
-      </p>
-    </item>
-    <item>
-      <p>
-        Advance live region politeness setting: <key>Backslash</key>
-      </p>
-    </item>
-    <item>
-      <p>
-        Set default politeness level to off:
-        <keyseq><key>Shift</key><key>Backslash</key></keyseq>
-      </p>
-    </item>
-    <item>
-      <p>
-        Go to next/previous live region:
-        <keyseq><key>D</key></keyseq>/<keyseq><key>Shift</key><key>D</key></keyseq>
-      </p>
-    </item>
-    <item>
-      <p>
-        Go to last live region which made an announcement:
-        <keyseq><key>Y</key></keyseq>
-      </p>
-    </item>
-    <item>
-      <p>
-        Review live region announcements:
-        <keyseq><key>Cthulhu Modifier</key><key>F1</key></keyseq> through <key>F9</key>
-      </p>
-    </item>
-</list>
-</page>
@@ -1,72 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="commands_mouse">
-  <info>
-    <link type="next" xref="commands_bookmarks" />
-    <link type="guide" xref="commands#reviewing_screen_contents" />
-    <title type="sort">3. Mouse/Pointer-Related</title>
-    <title type="link">Mouse/Pointer-Related</title>
-    <link type="seealso" xref="howto_flat_review"  />
-    <link type="seealso" xref="howto_mouse_review"  />
-    <desc>
-      Commands for manipulating the pointer
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Mouse/Pointer-Related Commands</title>
-  <p>
-    <app>Cthulhu</app> provides several commands which can be used to manipulate
-    the mouse pointer and read the contents under it. All of the commands are
-    "bound" to keystrokes with one exception: Toggling Mouse Review Mode.
-    Please see <link xref="howto_key_bindings">Modifying Keybindings</link>
-    for information on how to bind this command to a keystroke.
-  </p>
-  <note style="tip">
-    <p>
-      Below you will see several references to "KP". All
-      "KP" keys are located on the numeric keypad. You will also notice that
-      there are different keystrokes depending upon whether you are using a
-      desktop or a laptop -- or more accurately, whether you are using
-      <app>Cthulhu</app>'s Desktop keyboard layout or its Laptop keyboard layout.
-      For additional information, please see the
-      <link xref="howto_keyboard_layout">Keyboard Layout</link> topic.
-    </p>
-  </note>
-  <list>
-    <item>
-      <p>Left-click on current item:</p>
-      <list>
-        <item><p>Desktop: <keyseq><key>KP Divide</key></keyseq></p></item>
-        <item><p>Laptop: <keyseq><key>Cthulhu Modifier</key><key>7</key></keyseq></p></item>
-      </list>
-    </item>
-    <item>
-      <p>Right-click on current item:</p>
-      <list>
-        <item><p>Desktop: <keyseq><key>KP Multiply</key></keyseq></p></item>
-        <item><p>Laptop: <keyseq><key>Cthulhu Modifier</key><key>8</key></keyseq></p></item>
-      </list>
-    </item>
-    <item>
-      <p>Route pointer to current item:</p>
-      <list>
-        <item><p>Desktop: <keyseq><key>Cthulhu Modifier</key><key>KP Divide</key></keyseq></p></item>
-        <item><p>Laptop: <keyseq><key>Cthulhu Modifier</key><key>9</key></keyseq></p></item>
-      </list>
-    </item>
-    <item>
-      <p>Move focus into or away from the current mouse over (web only):</p>
-      <list>
-        <item><p>Desktop: <keyseq><key>Cthulhu Modifier</key><key>KP Multiply</key></keyseq></p></item>
-        <item><p>Laptop: <keyseq><key>Cthulhu Modifier</key><key>0</key></keyseq></p></item>
-      </list>
-    </item>
-    <item>
-      <p>Enable/disable mouse review mode: (Unbound)</p>
-    </item>
-  </list>
-</page>
@@ -1,35 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="commands_profiles">
-  <info>
-    <link type="next" xref="commands_speech_settings" />
-    <link type="guide" xref="commands#getting_started" />
-    <link type="seealso" xref="howto_profiles"  />
-    <title type="sort">5. Profiles</title>
-    <title type="link">Profiles</title>
-    <desc>
-      Commands to access saved configurations
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Profile Commands</title>
-    <p>
-      Profiles allow you to save and load multiple configurations so that you
-      can quickly access the settings you need.
-    </p>
-    <p>
-     The following command is not "bound" to a keystroke. If you would like to
-     bind it, please see <link xref="howto_key_bindings">Modifying Keybindings</link>.
-    </p>
-    <list>
-      <item>
-        <p>
-          Cycle to the next profile: (Unbound)
-        </p>
-      </item>
-    </list>
-</page>
@@ -1,294 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="commands_reading">
-  <info>
-    <link type="next" xref="commands_structural_navigation" />
-    <link type="guide" xref="commands#reading_documents" />
-    <link type="seealso" xref="howto_documents"  />
-    <link type="seealso" xref="howto_text_attributes"  />
-    <link type="seealso" xref="howto_whereami"  />
-    <title type="sort">1. Reading</title>
-    <title type="link">Reading</title>
-    <desc>
-      Commands for accessing document content
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Reading Commands</title>
-  <p>
-    In addition to the caret navigation commands which are part of GNOME,
-    <app>Cthulhu</app> provides a number of commands which you can use to read a
-    document.
-  </p>
-  <note style="tip">
-    <p>
-      Below you will see several references to "KP". All
-      "KP" keys are located on the numeric keypad. You will also notice that
-      there are different keystrokes depending upon whether you are using a
-      desktop or a laptop -- or more accurately, whether you are using
-      <app>Cthulhu</app>'s Desktop keyboard layout or its Laptop keyboard layout.
-      For additional information, please see the
-      <link xref="howto_keyboard_layout">Keyboard Layout</link> topic.
-    </p>
-  </note>
-  <section id="flat_review">
-    <title>Reading Your Current Location</title>
-    <p>
-      The following <app>Cthulhu</app> <link xref="commands_flat_review">Flat
-      Review Commands</link> can be used to read your current location:
-    </p>
-    <list>
-      <item>
-        <p>Read the current line:</p>
-        <list>
-          <item>
-            <p>
-              Desktop: <keyseq><key>KP 8</key></keyseq>
-            </p>
-          </item>
-          <item>
-            <p>
-              Laptop: <keyseq><key>Cthulhu Modifier</key><key>I</key></keyseq>
-            </p>
-          </item>
-        </list>
-      </item>
-      <item>
-        <p>Read the current word:</p>
-        <list>
-          <item>
-            <p>
-              Desktop: <keyseq><key>KP 5</key></keyseq>
-            </p>
-          </item>
-          <item>
-            <p>
-              Laptop: <keyseq><key>Cthulhu Modifier</key><key>K</key></keyseq>
-            </p>
-          </item>
-        </list>
-      </item>
-      <item>
-        <p>Spell the current word:</p>
-        <list>
-          <item>
-            <p>
-              Desktop: <keyseq><key>KP 5</key></keyseq> (double-clicked)
-            </p>
-          </item>
-          <item>
-            <p>
-              Laptop: <keyseq><key>Cthulhu Modifier</key><key>K</key></keyseq>
-              (double-clicked)
-            </p>
-          </item>
-        </list>
-      </item>
-      <item>
-        <p>Phonetically spell the current word:</p>
-        <list>
-          <item>
-            <p>
-              Desktop: <keyseq><key>KP 5</key></keyseq> (triple-clicked)
-            </p>
-          </item>
-          <item>
-            <p>
-              Laptop: <keyseq><key>Cthulhu Modifier</key><key>K</key></keyseq>
-              (triple-clicked)
-            </p>
-          </item>
-        </list>
-      </item>
-      <item>
-        <p>Read the current character:</p>
-        <list>
-          <item>
-            <p>
-              Desktop: <keyseq><key>KP 2</key></keyseq>
-            </p>
-          </item>
-          <item>
-            <p>
-              Laptop: <keyseq><key>Cthulhu Modifier</key><key>Comma</key></keyseq>
-            </p>
-          </item>
-        </list>
-      </item>
-      <item>
-        <p>Phonetically speak the current character:</p>
-        <list>
-          <item>
-            <p>
-              Desktop: <keyseq><key>KP 2</key></keyseq> (double-clicked)
-            </p>
-          </item>
-          <item>
-            <p>
-              Laptop: <keyseq><key>Cthulhu Modifier</key><key>Comma</key></keyseq>
-              (double-clicked)
-            </p>
-          </item>
-        </list>
-      </item>
-      <item>
-        <p>Speak the Unicode value of current character:</p>
-        <list>
-          <item>
-            <p>
-              Desktop: <keyseq><key>KP 2</key></keyseq> (triple-clicked)
-            </p>
-          </item>
-          <item>
-            <p>
-              Laptop: <keyseq><key>Cthulhu Modifier</key><key>Comma</key></keyseq>
-              (triple-clicked)
-            </p>
-          </item>
-        </list>
-      </item>
-    </list>
-  </section>
-  <section id="say_all">
-    <title>Say All</title>
-    <p>
-      Cthulhu's Say All command will cause <app>Cthulhu</app> to speak the
-      entire document beginning from your current location.
-    </p>
-    <list>
-      <item>
-        <p>Desktop: <key>KP Plus</key></p>
-      </item>
-      <item>
-        <p>
-          Laptop: <keyseq><key>Cthulhu Modifier</key><key>Semicolon</key></keyseq>
-        </p>
-      </item>
-    </list>
-  </section>
-  <section id="attributes_and_selection">
-    <title>Text Attributes and Selected Text</title>
-    <p>
-      <app>Cthulhu</app> has a dedicated command for obtaining the attributes of the
-      text at the caret location. In addition, if you use <app>Cthulhu</app>'s
-      Where Am I commands from within a text object in which text has been
-      selected, <app>Cthulhu</app> will announce the selected text. <app>Cthulhu</app>'s
-      command to speak the current selection will also perform this function in a
-      text object.
-    </p>
-    <list>
-      <item>
-        <p>
-          Present the text attributes:
-          <keyseq><key>Cthulhu Modifier</key><key>F</key></keyseq>
-        </p>
-      </item>
-      <item>
-        <p>Perform basic Where Am I:</p>
-        <list>
-          <item>
-            <p>
-              Desktop: <key>KP Enter</key>
-            </p>
-          </item>
-          <item>
-            <p>
-              Laptop: <keyseq><key>Cthulhu Modifier</key><key>Return</key></keyseq>
-            </p>
-          </item>
-        </list>
-    </item>
-    <item>
-      <p>Perform detailed Where Am I:</p>
-      <list>
-        <item>
-          <p>
-            Desktop: <key>KP Enter</key> (double-clicked)
-          </p>
-        </item>
-        <item>
-          <p>
-            Laptop: <keyseq><key>Cthulhu Modifier</key><key>Return</key></keyseq>
-            (double-clicked)
-          </p>
-        </item>
-      </list>
-    </item>
-    <item>
-      <p>
-        Speak current selection:
-        <keyseq><key>Cthulhu Modifier</key><key>Shift</key><key>Up</key></keyseq>
-      </p>
-    </item>
-  </list>
-  </section>
-  <section id="link_details">
-    <title>Link Details</title>
-    <p>
-      If you are on a link, <app>Cthulhu</app>'s Basic Where Am I command can be
-      used to announce the details associated with the link such as the link type,
-      if the link is visited, the site description, and file size. If you would
-      instead prefer a dedicated command for this purpose, you can bind <app>Cthulhu</app>'s
-      Speak Link Details command to a keystroke. Please see <link xref="howto_key_bindings">
-      Modifying Keybindings</link> for information on how to do so.
-    </p>
-    <list>
-      <item>
-        <p>Speak the link details: (Unbound)</p>
-      </item>
-    </list>
-  </section>
-  <section id="browse_and_focus_modes">
-    <title>Browse and Focus Modes</title>
-    <p>
-      <app>Cthulhu</app>'s Browse and Focus modes let you switch between reading and
-      interacting with web content.
-    </p>
-    <list>
-      <item>
-        <p>
-          Switch between browse mode and focus mode:
-          <keyseq><key>Cthulhu Modifier</key><key>A</key></keyseq>
-        </p>
-      </item>
-      <item>
-        <p>
-          Enable sticky focus mode:
-          <keyseq><key>Cthulhu Modifier</key><key>A</key></keyseq> (double-clicked)
-        </p>
-      </item>
-      <item>
-        <p>
-          Enable sticky browse mode:
-          <keyseq><key>Cthulhu Modifier</key><key>A</key></keyseq> (triple-clicked)
-        </p>
-      </item>
-    </list>
-  </section>
-  <section id="toggling_layout_mode">
-    <title>Toggling Layout Mode</title>
-    <p>
-      When Layout mode is enabled, <app>Cthulhu</app>'s caret navigation will respect
-      the on-screen layout of the content and present the full line, including any
-      links or form fields on that line. When Layout mode is disabled, <app>Cthulhu</app>
-      will treat objects such as links and form fields as if they were on separate
-      lines, both for presentation and navigation.
-    </p>
-    <p>
-      <app>Cthulhu</app> provides a command to switch between Layout mode and Object mode.
-      This command is unbound by default. Please see <link xref="howto_key_bindings">Modifying
-      Keybindings</link> for information on how to bind unbound commands.
-    </p>
-    <list>
-      <item>
-        <p>
-          Switch between Layout mode and Object mode: (Unbound)
-        </p>
-      </item>
-    </list>
-  </section>
-</page>
@@ -1,83 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="commands_speech_settings">
-  <info>
-    <link type="next" xref="commands_braille" />
-    <link type="guide" xref="commands#speech_braille" />
-    <link type="seealso" xref="preferences_speech"  />
-    <title type="sort">2. Speech Settings</title>
-    <title type="link">Speech</title>
-    <desc>
-      Commands for customizing <app>Cthulhu</app>'s output
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Speech Settings Commands</title>
-  <p>
-    The following commands can be used to customize <app>Cthulhu</app>'s
-    speech output. You will notice that a number of these commands are
-    "unbound." Please see <link xref="howto_key_bindings">Modifying
-    Keybindings</link> for information on how to bind these commands
-    to keystrokes.
-  </p>
-  <list>
-    <item>
-      <p>
-        Enable/disable speech: <keyseq><key>Cthulhu Modifier</key><key>S</key></keyseq>
-      </p>
-    </item>
-    <item>
-      <p>
-        Toggle between cell and row reading in a table:
-        <keyseq><key>Cthulhu Modifier</key><key>F11</key></keyseq>
-      </p>
-    </item>
-    <item>
-      <p>
-        Toggle between verbose and brief verbosity levels:
-        <keyseq><key>Cthulhu Modifier</key><key>V</key></keyseq>
-      </p>
-    </item>
-    <item>
-      <p>
-        Enable/disable speaking of indentation and justification: (Unbound)
-      </p>
-    </item>
-    <item>
-      <p>Change the spoken number style: (Unbound)</p>
-    </item>
-    <item>
-      <p>Cycle to the next spoken punctuation level: (Unbound)</p>
-    </item>
-    <item>
-      <p>Cycle to the next key echo level: (Unbound)</p>
-    </item>
-    <item>
-      <p>Cycle to the next capitalization style: (Unbound)</p>
-    </item>
-    <item>
-      <p>Decrease the rate: (Unbound)</p>
-    </item>
-    <item>
-      <p>Increase the rate: (Unbound)</p>
-    </item>
-    <item>
-      <p>Decrease the pitch: (Unbound)</p>
-    </item>
-    <item>
-      <p>Increase the pitch: (Unbound)</p>
-    </item>
-    <item>
-      <p>Decrease the volume: (Unbound)</p>
-    </item>
-    <item>
-      <p>Increase the volume: (Unbound)</p>
-    </item>
-  </list>
-</page>
-
-
@@ -1,443 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="commands_structural_navigation">
-  <info>
-    <link type="next" xref="commands_table" />
-    <link type="guide" xref="commands#reading_documents" />
-    <link type="seealso" xref="howto_forms"  />
-    <title type="sort">2. Structural Navigation</title>
-    <title type="link">Structural Navigation</title>
-    <desc>
-      Commands for navigating by elements
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Structural Navigation Commands</title>
-  <p>
-    The following commands can be used to navigate by headings, links,
-    and other elements found in applications for which <app>Cthulhu</app>
-    provides structural navigation support.
-  </p>
-  <list>
-    <item>
-      <p>
-        Enable/disable Structural Navigation keys:
-        <keyseq><key>Cthulhu Modifier</key><key>Z</key></keyseq>
-      </p>
-    </item>
-  </list>
-  <section id="headings">
-    <title>Headings</title>
-      <list>
-        <item>
-          <p>
-            Next and previous heading:
-            <keyseq><key>H</key></keyseq> and
-            <keyseq><key>Shift</key><key>H</key></keyseq>
-          </p>
-        </item> 
-        <item>
-          <p>
-            Display a list of headings:
-            <keyseq><key>Alt</key><key>Shift</key><key>H</key></keyseq>
-          </p>
-        </item>
-        <item>
-          <p>
-            Next and previous heading at level 1:
-            <keyseq><key>1</key></keyseq> and
-            <keyseq><key>Shift</key><key>1</key></keyseq>
-          </p>
-        </item>
-        <item>
-          <p>
-            Display a list of headings at level 1:
-            <keyseq><key>Alt</key><key>Shift</key><key>1</key></keyseq>
-          </p>
-        </item>
-        <item>
-          <p>
-            Next and previous heading at level 2:
-            <keyseq><key>2</key></keyseq> and
-            <keyseq><key>Shift</key><key>2</key></keyseq>
-          </p>
-        </item> 
-        <item>
-          <p>
-            Display a list of headings at level 2:
-            <keyseq><key>Alt</key><key>Shift</key><key>2</key></keyseq>
-          </p>
-        </item>
-        <item>
-          <p>
-            Next and previous heading at level 3:
-            <keyseq><key>3</key></keyseq> and
-            <keyseq><key>Shift</key><key>3</key></keyseq>
-          </p>
-        </item> 
-        <item>
-          <p>
-            Display a list of headings at level 3:
-            <keyseq><key>Alt</key><key>Shift</key><key>3</key></keyseq>
-          </p>
-        </item>
-        <item>
-          <p>
-            Next and previous heading at level 4:
-            <keyseq><key>4</key></keyseq> and
-            <keyseq><key>Shift</key><key>4</key></keyseq>
-          </p>
-        </item> 
-        <item>
-          <p>
-            Display a list of headings at level 4:
-            <keyseq><key>Alt</key><key>Shift</key><key>4</key></keyseq>
-          </p>
-        </item>
-        <item>
-          <p>
-            Next and previous heading at level 5:
-            <keyseq><key>5</key></keyseq> and
-            <keyseq><key>Shift</key><key>5</key></keyseq>
-          </p>
-        </item> 
-        <item>
-          <p>
-            Display a list of headings at level 5:
-            <keyseq><key>Alt</key><key>Shift</key><key>5</key></keyseq>
-          </p>
-        </item>
-        <item>
-          <p>
-            Next and previous heading at level 6:
-            <keyseq><key>6</key></keyseq> and
-            <keyseq><key>Shift</key><key>6</key></keyseq>
-          </p>
-        </item> 
-        <item>
-          <p>
-            Display a list of headings at level 6:
-            <keyseq><key>Alt</key><key>Shift</key><key>6</key></keyseq>
-          </p>
-        </item>
-      </list>
-    </section>
-    <section id="forms">
-      <title>Forms</title>
-      <list>
-        <item>
-          <p>
-            Next and previous form field:
-            <keyseq><key>F</key></keyseq> and
-            <keyseq><key>Shift</key><key>F</key></keyseq>
-          </p>
-        </item> 
-        <item>
-          <p>
-            Display a list of form fields:
-            <keyseq><key>Alt</key><key>Shift</key><key>F</key></keyseq>
-          </p>
-        </item>
-        <item>
-          <p>
-            Next and previous button:
-            <keyseq><key>B</key></keyseq> and
-            <keyseq><key>Shift</key><key>B</key></keyseq>
-          </p>
-        </item> 
-        <item>
-          <p>
-            Display a list of buttons:
-            <keyseq><key>Alt</key><key>Shift</key><key>B</key></keyseq>
-          </p>
-        </item>
-        <item>
-          <p>
-            Next and previous combo box:
-            <keyseq><key>C</key></keyseq> and
-            <keyseq><key>Shift</key><key>C</key></keyseq>
-          </p>
-        </item> 
-        <item>
-          <p>
-            Display a list of combo boxes:
-            <keyseq><key>Alt</key><key>Shift</key><key>C</key></keyseq>
-          </p>
-        </item>
-        <item>
-          <p>
-            Next and previous entry:
-            <keyseq><key>E</key></keyseq> and
-            <keyseq><key>Shift</key><key>E</key></keyseq>
-          </p>
-        </item> 
-        <item>
-          <p>
-            Display a list of entries:
-            <keyseq><key>Alt</key><key>Shift</key><key>E</key></keyseq>
-          </p>
-        </item>
-        <item>
-          <p>
-            Next and previous radio button:
-            <keyseq><key>R</key></keyseq> and
-            <keyseq><key>Shift</key><key>R</key></keyseq>
-          </p>
-        </item>
-        <item>
-          <p>
-            Display a list of radio buttons:
-            <keyseq><key>Alt</key><key>Shift</key><key>R</key></keyseq>
-          </p>
-        </item> 
-        <item>
-          <p>
-            Next and previous checkbox:
-            <keyseq><key>X</key></keyseq> and
-            <keyseq><key>Shift</key><key>X</key></keyseq>
-          </p>
-        </item>
-        <item>
-          <p>
-            Display a list of checkboxes:
-            <keyseq><key>Alt</key><key>Shift</key><key>X</key></keyseq>
-          </p>
-        </item> 
-      </list>
-    </section>
-    <section id="links">
-    <title>Links</title>
-      <list>
-        <item>
-          <p>
-            Next and previous link:
-            <keyseq><key>K</key></keyseq> and
-            <keyseq><key>Shift</key><key>K</key></keyseq>
-          </p>
-        </item>
-        <item>
-          <p>
-            Display a list of links:
-            <keyseq><key>Alt</key><key>Shift</key><key>K</key></keyseq>
-          </p>
-        </item>
-        <item>
-          <p>
-            Next and previous unvisited link:
-            <keyseq><key>U</key></keyseq> and
-            <keyseq><key>Shift</key><key>U</key></keyseq>
-          </p>
-        </item> 
-        <item>
-          <p>
-            Display a list of unvisited links:
-            <keyseq><key>Alt</key><key>Shift</key><key>U</key></keyseq>
-          </p>
-        </item>
-        <item>
-          <p>
-            Next and previous visited link:
-            <keyseq><key>V</key></keyseq> and
-            <keyseq><key>Shift</key><key>V</key></keyseq>
-          </p>
-        </item> 
-        <item>
-          <p>
-            Display a list of visited links:
-            <keyseq><key>Alt</key><key>Shift</key><key>V</key></keyseq>
-          </p>
-        </item>
-      </list>
-    </section>
-    <section id="lists">
-      <title>Lists</title>
-      <list>
-        <item>
-          <p>
-            Next and previous list:
-            <keyseq><key>L</key></keyseq> and
-            <keyseq><key>Shift</key><key>L</key></keyseq>
-          </p>
-        </item> 
-        <item>
-          <p>
-            Display a list of lists:
-            <keyseq><key>Alt</key><key>Shift</key><key>L</key></keyseq>
-          </p>
-        </item>
-        <item>
-          <p>
-            Next and previous list item:
-            <keyseq><key>I</key></keyseq> and
-            <keyseq><key>Shift</key><key>I</key></keyseq>
-          </p>
-        </item> 
-        <item>
-          <p>
-            Display a list of list items:
-            <keyseq><key>Alt</key><key>Shift</key><key>I</key></keyseq>
-          </p>
-        </item>
-      </list>
-    </section>
-    <section id="tables">
-      <title>Tables</title>
-      <list>
-        <item>
-          <p>
-            Next and previous table:
-            <keyseq><key>T</key></keyseq> and
-            <keyseq><key>Shift</key><key>T</key></keyseq>
-          </p>
-        </item> 
-        <item>
-          <p>
-            Display a list of tables:
-            <keyseq><key>Alt</key><key>Shift</key><key>T</key></keyseq>
-          </p>
-        </item>
-        <item>
-          <p>
-            Cell on left:
-            <keyseq><key>Alt</key><key>Shift</key><key>Left</key></keyseq>
-          </p>
-        </item> 
-        <item>
-          <p>
-            Cell on right:
-            <keyseq><key>Alt</key><key>Shift</key><key>Right</key></keyseq>
-          </p>
-        </item> 
-        <item>
-          <p>
-            Cell above:
-            <keyseq><key>Alt</key><key>Shift</key><key>Up</key></keyseq>
-          </p>
-        </item> 
-        <item>
-          <p>
-            Cell below:
-            <keyseq><key>Alt</key><key>Shift</key><key>Down</key></keyseq>
-          </p>
-        </item> 
-        <item>
-          <p>
-            First cell in table:
-            <keyseq><key>Alt</key><key>Shift</key><key>Home</key></keyseq>
-          </p>
-        </item> 
-        <item>
-          <p>
-            Last cell in table:
-            <keyseq><key>Alt</key><key>Shift</key><key>End</key></keyseq>
-          </p>
-        </item> 
-      </list>
-    </section>
-    <section id="text_blocks">
-      <title>Text Blocks</title>
-      <list>
-        <item>
-          <p>
-            Next and previous paragraph:
-            <keyseq><key>P</key></keyseq> and
-            <keyseq><key>Shift</key><key>P</key></keyseq>
-          </p>
-        </item> 
-        <item>
-          <p>
-            Display a list of paragraphs:
-            <keyseq><key>Alt</key><key>Shift</key><key>P</key></keyseq>
-          </p>
-        </item>
-        <item>
-          <p>
-            Next and previous blockquote:
-            <keyseq><key>Q</key></keyseq> and
-            <keyseq><key>Shift</key><key>Q</key></keyseq>
-          </p>
-        </item> 
-        <item>
-          <p>
-            Display a list of blockquotes:
-            <keyseq><key>Alt</key><key>Shift</key><key>Q</key></keyseq>
-          </p>
-        </item>
-        <item>
-          <p>
-            Next and previous "large object":
-            <keyseq><key>O</key></keyseq> and
-            <keyseq><key>Shift</key><key>O</key></keyseq>
-          </p>
-        </item> 
-        <item>
-          <p>
-            Display a list of "large objects":
-            <keyseq><key>Alt</key><key>Shift</key><key>O</key></keyseq>
-          </p>
-        </item>
-       </list>
-    </section>
-    <section id="other">
-      <title>Other Elements</title>
-      <list>
-        <item>
-          <p>
-            Next and previous landmark:
-            <keyseq><key>M</key></keyseq> and
-            <keyseq><key>Shift</key><key>M</key></keyseq>
-          </p>
-        </item> 
-        <item>
-          <p>
-            Display a list of landmarks:
-            <keyseq><key>Alt</key><key>Shift</key><key>M</key></keyseq>
-          </p>
-        </item>
-        <item>
-          <p>
-            Next and previous separator:
-            <keyseq><key>S</key></keyseq> and
-            <keyseq><key>Shift</key><key>S</key></keyseq>
-          </p>
-        </item> 
-        <item>
-          <p>
-            Next and previous "clickable":
-            <keyseq><key>A</key></keyseq> and
-            <keyseq><key>Shift</key><key>A</key></keyseq>
-          </p>
-        </item> 
-        <item>
-          <p>
-            Display a list of "clickables":
-            <keyseq><key>Alt</key><key>Shift</key><key>A</key></keyseq>
-          </p>
-        </item>
-        <item>
-          <p>
-            Next and previous image:
-            <keyseq><key>G</key></keyseq> and
-            <keyseq><key>Shift</key><key>G</key></keyseq>
-          </p>
-        </item>
-        <item>
-          <p>
-            Display a list of images:
-            <keyseq><key>Alt</key><key>Shift</key><key>G</key></keyseq>
-          </p>
-        </item>
-        <item>
-          <p>
-            Start and end of current container:
-            <keyseq><key>Shift</key><key>Comma</key></keyseq> and
-            <keyseq><key>Comma</key></keyseq>
-          </p>
-        </item>
-      </list>
-    </section>
-</page>
@@ -1,57 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="commands_table">
-  <info>
-    <link type="next" xref="commands_flat_review" />
-    <link type="guide" xref="commands#reading_documents" />
-    <link type="seealso" xref="howto_tables"  />
-    <title type="sort">3. Table Navigation</title>
-    <title type="link">Table Navigation</title>
-    <desc>
-      Commands for accessing tabular information
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Table Navigation Commands</title>
-  <p>
-    Cthulhu's support for navigation by table cell is part of its
-    <link xref="commands_structural_navigation#tables">Structural Navigation
-    commands</link>. In addition you can:
-  </p>
-  <list>
-    <item>
-      <p>
-        Set dynamic row headers to current column:
-        <keyseq><key>Cthulhu Modifier</key><key>C</key></keyseq>
-      </p>
-    </item>
-    <item>
-      <p>
-        Set dynamic column headers to current row:
-        <keyseq><key>Cthulhu Modifier</key><key>R</key></keyseq>
-      </p>
-    </item>
-    <item>
-      <p>
-        Clear dynamic row headers:
-        <keyseq><key>Cthulhu Modifier</key><key>C</key></keyseq> (double-clicked)
-      </p>
-    </item>
-    <item>
-      <p>
-        Clear dynamic column headers:
-        <keyseq><key>Cthulhu Modifier</key><key>R</key></keyseq> (double-clicked)
-      </p>
-    </item>
-    <item>
-      <p>
-        Toggle between cell and row reading in a table:
-        <keyseq><key>Cthulhu Modifier</key><key>F11</key></keyseq>
-      </p>
-    </item>
-  </list>
-</page>
@@ -1,63 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="commands_time_date_notifications">
-  <info>
-    <link type="next" xref="commands_profiles" />
-    <link type="guide" xref="commands#getting_started" />
-    <link type="seealso" xref="howto_notifications"  />
-    <title type="sort">4. Time, Date, and Notification</title>
-    <title type="link">Time, Date, and Notification</title>
-    <desc>
-      Commands for getting the time, date, and notification messages
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Time, Date, and Notification Commands</title>
-  <p>
-    The following commands can be used to obtain the current time and date
-    and to review previously-displayed notification messages:
-  </p>
-  <section id="time_and_date">
-    <title>Obtaining the Time and Date</title>
-    <list>
-      <item>
-        <p>
-          Present the time: <keyseq><key>Cthulhu Modifier</key><key>T</key></keyseq>
-        </p>
-      </item>
-      <item>
-        <p>
-          Present the date: <keyseq><key>Cthulhu Modifier</key><key>T</key></keyseq>
-          (double-clicked)
-        </p>
-      </item>
-    </list>
-  </section>
-  <section id="notifications">
-    <title>Reviewing Notification Messages</title>
-    <p>
-      Cthulhu has three unbound commands for accessing previously-displayed
-      <link xref="howto_notifications">notification messages</link>. Please
-      see <link xref="howto_key_bindings">Modifying Keybindings</link> for
-      information on how to bind these commands to keystrokes.
-    </p>
-    <list>
-      <item>
-        <p>Present the last (most recent) notification message: (Unbound)</p>
-      </item>
-      <item>
-        <p>Present the previous notification message: (Unbound)</p>
-      </item>
-      <item>
-        <p>Present the next notification message: (Unbound)</p>
-      </item>
-      <item>
-        <p>Present list of all notification messages: (Unbound)</p>
-      </item>
-    </list>
-  </section>
-</page>
@@ -1,97 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="commands_where_am_i">
-  <info>
-    <link type="next" xref="commands_time_date_notifications" />
-    <link type="guide" xref="commands#getting_started" />
-    <link type="seealso" xref="howto_whereami"  />
-    <title type="sort">3. Where Am I</title>
-    <title type="link">Where Am I</title>
-    <desc>
-      Commands to learn about your location
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Where Am I Commands</title>
-  <p>
-    <app>Cthulhu</app>'s Where Am I feature gives you context-sensitive details
-    about your present location. For instance, in tables, Where Am I will give
-    you details about the table cell you are in, but in text it will present
-    the current line along with any text which happens to be selected. The full
-    list of what you can expect <app>Cthulhu</app> to present can be found in the
-    <link xref="howto_whereami">Introduction to Where Am I</link>.
-  </p>
-  <p><app>Cthulhu</app> provides the following Where Am I commands:</p>
-  <list>
-    <item>
-      <p>Perform basic Where Am I:</p>
-      <list>
-        <item>
-          <p>Desktop: <key>KP Enter</key></p>
-        </item>
-        <item>
-          <p>Laptop: <keyseq><key>Cthulhu Modifier</key><key>Return</key></keyseq></p>
-        </item>
-      </list>
-    </item>
-    <item>
-      <p>Perform detailed Where Am I:</p>
-      <list>
-        <item>
-          <p>Desktop: <key>KP Enter</key> (double-clicked)</p>
-        </item>
-        <item>
-          <p>
-            Laptop: <keyseq><key>Cthulhu Modifier</key><key>Return</key></keyseq>
-            (double-clicked)
-          </p>
-        </item>
-      </list>
-    </item>
-  </list>
-  <p>
-    In addition to the dedicated Where Am I commands, <app>Cthulhu</app> has
-    additional commands related to obtaining information about your present location:
-  </p>
-  <list>
-    <item>
-      <p>Present the title bar:</p>
-      <list>
-        <item>
-          <p>
-            Desktop: <keyseq><key>Cthulhu Modifier</key><key>KP Enter</key></keyseq>
-          </p>
-        </item>
-        <item>
-          <p>
-            Laptop: <keyseq><key>Cthulhu Modifier</key><key>Slash</key></keyseq>
-          </p>
-        </item>
-      </list>
-    </item>
-    <item>
-      <p>Present the status bar:</p>
-      <list>
-        <item>
-          <p>
-            Desktop: <keyseq><key>Cthulhu Modifier</key><key>KP Enter</key></keyseq>
-            (double-clicked)
-          </p>
-        </item>
-        <item>
-          <p>
-            Laptop: <keyseq><key>Cthulhu Modifier</key><key>Slash</key></keyseq>
-            (double-clicked)
-          </p>
-        </item>
-        <item>
-          <p>Present size and location of current object in pixels: (Unbound)</p>
-        </item>
-      </list>
-    </item>
-  </list>
-</page>
@@ -1,54 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="howto_bookmarks">
-  <info>
-    <link type="guide" xref="index#reviewing"/>
-    <title type="sort">6. Bookmarks</title>
-    <desc>Storing and retrieving objects</desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Bookmarks</title>
-  <p>
-    <app>Cthulhu</app>'s Bookmarks support allows you to indicate that an object
-    is of interest. It includes the following features:
-  </p>
-  <list>
-    <item>
-      <p>
-        You are not limited to a single object: You can set up to six bookmarks
-        per environment. You can also save bookmarks so that they will persist
-        from Cthulhu session to Cthulhu session.
-      </p>
-    </item>
-    <item>
-      <p>
-        Having set a bookmark you can navigate to it later, and do so regardless
-        of whether or not you have chosen to permanently save the bookmarks
-        associated with your current environment. Navigation can be based on the
-        number of the bookmark should you wish to jump directly to a specific
-        item. Alternatively, you can navigate to the next or previous bookmark
-        just like you can a <link xref="howto_structural_navigation">Structural
-        Navigation</link> object.
-      </p>
-    </item>
-    <item>
-      <p>
-        Bookmarkable objects can be widgets within an application or objects on
-        the web page you are reading. Which environment you are in determines
-        what happens as you navigate amongst bookmarks: If you are in web
-        content, the caret will be moved to the bookmark so that you can
-        continue reading; otherwise, <link xref="howto_flat_review">Flat
-        Review</link> will be activated with the bookmark becoming the current
-        review item.
-      </p>
-    </item>
-  </list>
-  <p>
-    The specific keybindings associated with each of the above tasks can be
-    found in <link xref="commands_bookmarks">Bookmark Commands</link>.
-  </p>
-</page>
@@ -1,112 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="howto_cthulhu_find">
-  <info>
-    <link type="guide" xref="index#reviewing"/>
-    <link type="next" xref="howto_mouse_review" />
-    <title type="sort">3. Cthulhu Find</title>
-    <desc>Searching a window for objects</desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Cthulhu Find</title>
-  <p>
-    <app>Cthulhu</app>'s Find feature is a
-    <link xref="howto_flat_review">Flat-Review</link>-based search designed to
-    help you quickly locate objects that are visible on-screen within the
-    current window.
-  </p>
-  <note style="tip">
-    <title>Activating Cthulhu Find</title>
-      <p>
-        To open the Cthulhu <gui>Find</gui> dialog, use the following command based
-        on your chosen <link xref="howto_keyboard_layout">keyboard layout</link>:
-      </p>
-      <list>
-        <item>
-          <p>Desktop: <keyseq><key>KP Delete</key></keyseq></p>
-        </item>
-        <item>
-          <p>Laptop:
-            <keyseq><key>Cthulhu Modifier</key><key>Left Bracket</key></keyseq>
-          </p>
-        </item>
-      </list>
-      <p>
-        For a list of additional tasks you can perform, see the
-        <link xref="commands_find">Cthulhu Find commands</link>
-      </p>
-  </note>
-  <p>
-    When you activate Cthulhu Find, you will be placed in a dialog box.
-  </p>
-  <p>
-    Here you can specify the following items:
-  </p>
-  <list>
-    <item>
-      <p>The text to find</p>
-    </item>
-    <item>
-      <p>
-        The location from which to begin the search, which can either be
-        the current location or the top of the window
-      </p>
-      <p>
-        Default value of <gui>Start from</gui>: <gui>Current location</gui>
-      </p>
-    </item>
-    <item>
-      <p>
-        Whether or not capitalization should be taken into account when seeking
-        a match
-     </p>
-      <p>
-        Default value of <gui>Match case</gui>: not checked
-      </p>
-    </item>
-    <item>
-      <p>
-        Whether or not to limit matches to those which match the entire word
-        or phrase
-     </p>
-      <p>
-        Default value of <gui>Match entire word only</gui>: not checked
-      </p>
-    </item>
-    <item>
-      <p>
-        Whether Find should look down and/or to the right for the next
-        match or up and/or to the left.
-     </p>
-      <p>
-        Default value of <gui>Search backwards</gui>: not checked
-      </p>
-    </item>
-    <item>
-      <p>
-        Whether or not Find should wrap around to the top/bottom of the window
-        if there is no match found from the starting location in the direction
-        of the search.
-     </p>
-      <p>
-        Default value of <gui>Wrap around</gui>: checked
-      </p>
-    </item>
-  </list>
-  <p>
-    Having performed a search, you can quickly search for the next or previous
-    match without having to return to the Cthulhu Find dialog box.
-  </p>
-  <p>
-    Because it is a <link xref="howto_flat_review">Flat Review</link> feature,
-    when there is a match, Flat Review will automatically be activated and the
-    matching item or text will become the current review item. Note that focus
-    within the application will not be modified, nor will the caret be
-    repositioned. If you need to accomplish either, please see
-    <link xref="commands_mouse">Cthulhu's Mouse/Pointer-Related Commands</link>.
-  </p>
-</page>
@@ -1,67 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="howto_documents">
-  <info>
-    <link type="guide" xref="index#reading"/>
-    <link type="next" xref="howto_text_attributes" />
-    <title type="sort">1. Documents</title>
-    <desc>
-      Reading content
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Documents</title>
-  <p>
-    To read the contents of any document, use the application's built-in caret
-    navigation mode. As you navigate within the text of the document, <app>Cthulhu</app>
-    will present your new location. As a result, you are likely already familiar with
-    how to read a document using <app>Cthulhu</app>. For instance:
-  </p>
-  <list>
-    <item>
-      <p>
-        Use <key>Left</key> and <key>Right</key> to move and read by character.
-      </p>
-    </item>
-    <item>
-      <p>
-        Use <keyseq><key>Ctrl</key><key>Left</key></keyseq> and
-        <keyseq><key>Ctrl</key><key>Right</key></keyseq> to move and read by word.
-      </p>
-    </item>
-    <item>
-      <p>
-        Use <key>Up</key> and <key>Down</key> to move and read by line.
-      </p>
-    </item>
-    <item>
-      <p>
-        Use <key>Shift</key> in combination with the above commands to select and
-        unselect text.
-      </p>
-    </item>
-  </list>
-  <note style="tip">
-    <title>Enabling Caret Navigation in an Application</title>
-    <p>
-      Not all applications have caret navigation enabled by default. For many GNOME
-      applications, caret navigation can be toggled on and off by pressing <key>F7</key>.
-    </p>
-  </note>
-  <p>
-    In addition to reading a document by caret navigation, you may find it helpful
-    to read, spell, and obtain the Unicode value for the current text. You can do
-    these things through <app>Cthulhu</app>'s <link xref="howto_flat_review">Flat
-    Review feature</link>.
-  </p>
-  <p>
-    Finally, in order to have <app>Cthulhu</app> speak the entire document from your
-    present location, use the Say All command. It, along with a more complete
-    listing of <app>Cthulhu</app>'s commands for accessing document text, can
-    be found in the <link xref="commands_reading">Reading Commands</link> guide.
-  </p>
-</page>
@@ -1,46 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="howto_flat_review">
-  <info>
-    <link type="guide" xref="index#reviewing"/>
-    <link type="next" xref="howto_cthulhu_find" />
-    <title type="sort">2. Flat Review</title>
-    <desc>Examining a window spatially</desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Flat Review</title>
-  <p>
-    <app>Cthulhu</app>'s Flat Review feature allows you to spatially review the
-    contents, both text and widgets, of the active window. In this mode,
-    <app>Cthulhu</app> treats the window as if it were a two-dimensional sheet of
-    text, eliminating any notion of widget hierarchy or other logical grouping
-    within the window.
-  </p>
-  <p>
-    The "flattened" contents, also known as the Flat Review context, can be
-    <link xref="commands_flat_review">navigated</link> by line, by word, by
-    character, and by object. In addition, you can perform a left-click or
-    right-click on the object being reviewed. Finally, you can use
-    <link xref="howto_cthulhu_find">Cthulhu Find</link>, a Flat-Review-based feature
-    to search the active window's contents.
-  </p>
-  <p>
-    Because the Flat Review context is a spatial representation of the active
-    window's contents, it is created when you first enter Flat Review and only
-    contains those objects which are visible. As a result, you will not be able
-    to use Flat Review to access items which are in the window but currently
-    off-screen. In addition, if the window's contents change of their own
-    accord, the Flat Review context will not automatically be updated. You can
-    cause a new context to be built by toggling Flat Review off and back on.
-  </p>
-  <p>
-    Finally, Flat Review by its nature is a mode that cannot be used at the same
-    time that <app>Cthulhu</app> is tracking focus. Thus if you are in Flat Review
-    and then use the application's navigation commands to move the caret or to
-    give focus to another object, you will automatically leave Flat Review.
-  </p>
-</page>
@@ -1,95 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="howto_forms">
-  <info>
-    <link type="guide" xref="index#reading"/>
-     <link type="next" xref="howto_live_regions" />
-    <title type="sort">5. Filling out forms</title>
-    <desc>
-      Accessing widgets embedded in documents
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Filling out forms</title>
-  <p>
-    When interacting with web pages and other documents using <app>Cthulhu</app>,
-    you are interacting with the document itself; not a buffered copy of that
-    document. <app>Cthulhu</app>'s browse and focus modes let you switch between
-    reading and filling out forms.
-  </p>
-  <section id="navigating_amongst_form_fields">
-    <title>Navigating Amongst Form Fields</title>
-    <p>
-      To navigate amongst form fields, you have several options:
-    </p>
-    <list>
-      <item>
-        <p>
-           Use <key>Tab</key> and <keyseq><key>Shift</key><key>Tab</key></keyseq>
-           to navigate amongst focusable objects, regardless of type.
-        </p>
-      </item>
-      <item>
-        <p>
-          Use <app>Cthulhu</app>'s <link xref="commands_structural_navigation#forms">
-          structural navigation commands for forms</link>.
-        </p>
-      </item>
-      <item>
-        <p>
-          Depending on the form and the application, you may also be
-          able to use the arrow keys to navigate to a given form field.
-        </p>
-      </item>
-   </list>
-   <note style="tip">
-     <p>
-       In order to use <app>Cthulhu</app>'s caret navigation or structural navigation
-       commands to navigate to a form field, you must be in browse mode. If you are
-       in focus mode, you can switch to browse mode by pressing <keyseq><key>Cthulhu
-       Modifier</key><key>A</key></keyseq>.
-     </p>
-   </note>
-  </section>
-  <section id="exiting_form_fields">
-    <title>Exiting Form Fields</title>
-    <p>
-      To exit a form field, you have several options:
-    </p>
-    <list>
-      <item>
-        <p>
-          Use <key>Tab</key>/<keyseq><key>Shift</key><key>Tab</key></keyseq>
-          if you wish to leave the currently-focused form field and move to the
-          next/previous focusable object, regardless of type.
-        </p>
-      </item>
-      <item>
-        <p>
-          Use <app>Cthulhu</app>'s <link xref="commands_structural_navigation#forms">
-          structural navigation commands for forms</link> to move to the next or
-          previous form field.
-        </p>
-      </item>
-      <item>
-        <p>
-          Depending on the form and the application, you may also be
-          able to use the arrow keys to navigate out of a given form field.
-        </p>
-      </item>
-    </list>
-   <note style="tip">
-     <p>
-       In order to use <app>Cthulhu</app>'s caret navigation or structural navigation
-       commands to exit a form field, you must be in browse mode. If you are in
-       focus mode, you can switch to browse mode by pressing <keyseq><key>Cthulhu
-       Modifier</key><key>A</key></keyseq>.
-     </p>
-   </note>
-  </section>
-</page>
-
@@ -1,141 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="howto_key_bindings">
-  <info>
-    <link type="guide" xref="index#getting_started"/>
-    <link type="next" xref="howto_profiles" />
-  <title type="sort">8. Keybindings</title>
-  <desc>Binding, rebinding, and unbinding commands</desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Keybindings</title>
-  <p>
-    Cthulhu has many commands, some of which are bound to a keystroke, others
-    of which are unbound. You can bind, rebind, and unbind <app>Cthulhu</app>'s
-    commands by following the steps below.</p>
-  <steps>
-    <title>Binding an Unbound Command</title>
-    <item>
-      <p>
-        Get into the <link xref="preferences">Cthulhu Preferences</link> dialog
-        by pressing <keyseq><key>Cthulhu Modifier</key><key>Space</key></keyseq>.
-      </p>
-    </item>
-    <item>
-      <p>Move to the <gui>Key Bindings</gui> page.</p>
-    </item>
-    <item>
-      <p>
-        Arrow to the cell which contains the command you want to assign a
-        keystroke to.
-      </p>
-    </item>
-    <item>
-      <p>
-        Arrow once to the right. This will place focus in the <gui>Key
-        Binding</gui> column. Press <key>Return</key>.
-      </p>
-    </item>
-    <item>
-      <p>Press the desired key combination.</p></item>
-    <item>
-      <p>
-        Press <key>Return</key> to confirm the new combination. The new
-        keystroke will be saved and the check box in the last column (the
-        <gui>Modified</gui> column) will indicate that the key binding
-        has been modified.
-      </p>
-    </item>
-    <item>
-      <p>Press the <gui>Apply</gui> button.</p>
-    </item>
-  </steps>
-  <steps>
-    <title>Changing Existing Bindings</title>
-    <item>
-      <p>
-        Get into the <link xref="preferences">Cthulhu Preferences</link> dialog by
-        pressing <keyseq><key>Cthulhu Modifier</key><key>Space</key></keyseq>.
-      </p>
-    </item>
-    <item>
-      <p>Move to the <gui>Key Bindings</gui> page.</p>
-    </item>
-    <item>
-      <p>
-        Arrow to the cell which contains the binding you which to change and
-        press <key>Return</key>.
-      </p>
-    </item>
-    <item>
-        <p>Press the desired key combination.</p>
-    </item>
-    <item>
-      <p>
-        Press <key>Return</key> to confirm the new combination. The new
-        keystroke will be saved and the check box in the last column (the
-        <gui>Modified</gui> column) will indicate that the key binding has
-        been modified.
-      </p>
-    </item>
-    <item>
-      <p>Press the <gui>Apply</gui> button.</p>
-    </item>
-  </steps>
-  <steps>
-    <title>Restoring Original Bindings</title>
-    <item>
-      <p>
-        Get into the <link xref="preferences">Cthulhu Preferences</link> dialog by
-        pressing <keyseq><key>Cthulhu Modifier</key><key>Space</key></keyseq>.
-      </p>
-    </item>
-    <item>
-      <p>Move to the <gui>Key Bindings</gui> page.</p>
-    </item>
-    <item>
-      <p>Arrow to the modified column associated with the key binding.</p>
-    </item>
-    <item>
-      <p>Uncheck the checkbox by pressing <key>Space</key>.</p>
-    </item>
-    <item>
-      <p>Press the <gui>Apply</gui> button.</p>
-    </item>
-  </steps>
-  <steps>
-    <title>Unbinding Bound Commands</title>
-    <item>
-      <p>
-        Get into the <link xref="preferences">Cthulhu Preferences</link> dialog by
-        pressing <keyseq><key>Cthulhu Modifier</key><key>Space</key></keyseq>.
-      </p>
-    </item>
-    <item>
-      <p>Move to the <gui>Key Bindings</gui> page.</p>
-    </item>
-    <item>
-      <p>
-        Arrow to the cell which contains the binding you which to delete
-        and press <key>Return</key>.
-      </p>
-    </item>
-    <item>
-      <p>
-        When prompted for the new keybinding, press <key>Delete</key> or
-        <key>BackSpace</key>. You will be told that the key binding has
-        been removed.
-      </p>
-    </item>
-    <item>
-      <p>Press <key>Return</key> to confirm.</p>
-    </item>
-    <item>
-      <p>Press the <gui>Apply</gui> button.</p>
-    </item>
-  </steps>
-</page>
@@ -1,62 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="howto_keyboard_layout">
-  <info>
-    <link type="guide" xref="index#getting_started"/>
-    <link type="next" xref="howto_toggling_caps_lock" />
-    <title type="sort">6. Keyboard Layout</title>
-    <desc>Selecting the Desktop or Laptop layout</desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Keyboard Layout</title>
-  <p>
-    Cthulhu has two keyboard layouts: Desktop (i.e. with a numeric keypad) and
-    Laptop. The layout you choose impacts which key is used as the Cthulhu Modifier.
-  </p>
-  <list>
-    <item>
-      <p>
-        If you are using the Laptop layout, the default Cthulhu Modifier will be
-       <key>CapsLock</key>
-      </p>
-    </item>
-    <item>
-      <p>
-        If you are using the Desktop layout, the Cthulhu Modifier will be both
-        <key>Insert</key> and <key>KP_Insert</key>, the latter being the
-        same key as <key>KP_0</key>.
-      </p>
-    </item>
-  </list>
-  <p>
-    The layout also determines the keystrokes associated with a number of
-    <app>Cthulhu</app>'s commands, especially in the areas of Flat Review,
-    Where Am I, and Say All.
-  </p>
-  <steps>
-    <title>
-      Changing Your Keyboard Layout
-    </title>
-    <item>
-      <p>
-        Get into the <link xref="preferences">Cthulhu Preferences</link> dialog
-        by pressing <keyseq><key>Cthulhu Modifier</key><key>Space</key></keyseq>.
-      </p>
-    </item>
-    <item>
-      <p>
-        Move to the <gui>Keyboard Layout</gui> group of radio buttons.
-      </p>
-    </item>
-    <item>
-      <p>Arrow to the desired layout.</p>
-    </item>
-    <item>
-      <p>Press the <gui>Apply</gui> button.</p>
-    </item>
-  </steps>
-</page>
@@ -1,69 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="howto_learn_modes">
-  <info>
-    <link type="guide" xref="index#getting_started" />
-    <link type="next" xref="howto_keyboard_layout" />
-    <title type="sort">5. Learn Mode</title>
-    <desc>
-      Discovering <app>Cthulhu</app>'s commands
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Learn Mode</title>
-  <p>
-    In Learn Mode, <app>Cthulhu</app> will announce each keystroke you pressed
-    along with any associated <app>Cthulhu</app> command that keystroke is bound
-    to. In this mode, you can also get a list of shortcuts containing all the
-    <app>Cthulhu</app> commands you can use.
-  </p>
-  <steps>
-    <title>Using Learn Mode</title>
-    <item>
-      <p>
-        Get into Learn Mode by pressing <keyseq><key>Cthulhu Modifier</key>
-        <key>H</key></keyseq>.
-      </p>
-    </item>
-    <item>
-      <p>
-        Press any key or keystroke. <app>Cthulhu</app> will announce the keys and
-        any associated command.
-      </p>
-    </item>
-    <item>
-      <p>Press <key>Esc</key> to exit Learn Mode.</p>
-    </item>
-  </steps>
-  <steps>
-    <title>Getting a List of Shortcuts</title>
-    <item>
-      <p>
-        Get into Learn Mode by pressing <keyseq><key>Cthulhu Modifier</key>
-        <key>H</key></keyseq>.
-      </p>
-    </item>
-    <item>
-      <p>
-        Press <key>F2</key> if you want a list of shortcuts that apply
-        <app>Cthulhu</app>-wide, or press <key>F3</key> if you want a list
-        of shortcuts that are specifically for the application with focus.
-      </p>
-    </item>
-    <item>
-      <p>
-        Press <key>Up</key> or <key>Down</key> to examine the contents of the
-        list.
-      </p>
-    </item>
-    <item>
-      <p>
-        Press <key>Esc</key> to exit the list.
-      </p>
-    </item>
-  </steps>
-</page>
@@ -1,60 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="howto_live_regions">
-  <info>
-    <link type="guide" xref="index#reading"/>
-    <link type="next" xref="howto_whereami" />
-    <title type="sort">6. Live Regions</title>
-    <desc>
-      Interacting with dynamic web content
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Live Regions</title>
-  <p>
-    A live region is a dynamically-updated portion of a web page, such as a
-    table of sports statistics, a list of current stock prices, a log from
-    a chat, or an alert displayed by the page you are reading. While live
-    regions appear quite frequently, fully accessible web pages with live
-    regions are encountered less often. This problem is actively being
-    addressed by a number of organizations.
-  </p>
-  <section id="politeness_levels">
-    <title>Live Region Politeness Levels</title>
-    <p>
-      Live regions have an associated "politeness" level which is set by the
-      author as a means to convey the importance of the information and to
-      suggest when users should be informed by their assistive technology of
-      updates made within that region. Live regions can be "off", "polite", or
-      "assertive" to the point of being "rude."
-    </p>
-  </section>
-  <section id="cthulhu_support">
-    <title><app>Cthulhu</app>'s Support for Live Regions</title>
-    <p>
-      Because you might not agree with the politeness level specified by the
-      author whose page you are viewing, <app>Cthulhu</app> provides a number of
-      <link xref="commands_live_regions">live region commands</link> which
-      allow you to modify the level of any or all of the regions on a page.
-      In addition, you can:
-    </p>
-    <list>
-      <item>
-        <p>Turn live region support on or off</p>
-      </item>
-      <item>
-        <p>Jump to the next and previous live region spatially</p>
-      </item>
-      <item>
-        <p>Jump to the last live region which presented information</p>
-      </item>
-      <item>
-        <p>Review the last nine live region messages which were presented</p>
-    </item>
-    </list>
-  </section>
-</page>
@@ -1,50 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="howto_mouse_review">
-  <info>
-    <link type="guide" xref="index#reviewing"/>
-    <link type="next" xref="howto_notifications" />
-    <title type="sort">4. Mouse Review</title>
-    <desc>Using the pointer to examine the screen</desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Mouse Review</title>
-  <p>
-    <app>Cthulhu</app>'s Mouse Review feature causes <app>Cthulhu</app> to present
-    the object under the mouse pointer. Unlike <app>Cthulhu</app>'s
-    <link xref="howto_flat_review">Flat Review</link> feature, Mouse Review
-    is not limited to the active window; instead, <app>Cthulhu</app> will attempt
-    to identify what accessible object, if any, is visually under the pointer
-    as you move the mouse. If you have moved the pointer over an accessible
-    object with information to present, <app>Cthulhu</app> will present that object
-    and its information to you.
-  </p>
-  <p>
-    Because enabling Mouse Review causes <app>Cthulhu</app> to listen for, and then
-    process, all changes in the position of the Mouse Pointer, this feature is
-    disabled by default. To have it always enabled, check the <gui>Speak object
-    under mouse</gui> checkbox found on the
-    <link xref="preferences_general">General page of <app>Cthulhu</app>'s
-    Preferences dialog</link>. In addition, you will find an unbound command
-    named <gui>Toggle mouse review mode</gui> on the
-    <link xref="preferences_key_bindings">Key Bindings page</link> of that same
-    dialog box. By binding this command, as described in the
-    <link xref="howto_key_bindings">Introduction to Key Bindings</link>,
-    you can enable and disable Mouse Review on an as-needed basis.
-  </p>
-  <note style="tip">
-    <title>
-      Default Settings and Keybindings Are Independent of One Another
-    </title>
-    <p>
-      Note that you can choose to have Mouse Review always enabled or not and
-      still toggle it on and off by binding and using the <gui>Toggle mouse
-      review mode</gui> command. It is not necessary to enable it in order to
-      toggle it because settings and keybindings are independent of one another.
-    </p>
-  </note>
-</page>
@@ -1,69 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="howto_notifications">
-  <info>
-    <link type="guide" xref="index#reviewing"/>
-    <link type="next" xref="howto_bookmarks" />
-    <title type="sort">5. Notifications</title>
-    <desc>Reading previously-received messages</desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Notifications</title>
-  <p>
-    The GNOME Desktop includes a "notification area" which can be used by
-    applications to present information to the user. Examples of notifications
-    include incoming chat messages, the details associated with the song your
-    media player is starting to play, and warnings that your battery level is
-    getting low.
-  </p>
-  <p>
-    Because notifications are intended to present information to users without
-    interrupting what the user is doing, these messages tend to appear and
-    disappear relatively quickly. They are also not focusable. While
-    <app>Cthulhu</app> will present these messages to you as they come in, it is
-    far too easy to interrupt <app>Cthulhu</app>'s announcement accidentally by
-    continuing to type or to change focus. For this reason, <app>Cthulhu</app> has
-    three commands which you can use to access previously-displayed notification
-    messages:
-  </p>
-  <list>
-    <item>
-      <p>Present the last (most recent) notification message</p>
-    </item>
-    <item>
-      <p>Present the previous notification message</p>
-    </item>
-    <item>
-      <p>Present list of all notification messages</p>
-    </item>
-  </list>
-  <p>
-    The first two commands are designed mainly for quick access to a message
-    you just received. The last command is the most powerful as it stores your
-    notification message history.
-  </p>
-  <p>
-    When you enter the list of notification messages, you will be told the size
-    of the list and prompted with the following choices:
-  </p>
-  <list>
-    <item><p>Press H for help.</p></item>
-    <item><p>Use Up, Down, Home or End to navigate in the list.</p></item>
-    <item><p>Press Escape to exit.</p></item>
-    <item><p>Press Space to repeat the last message read.</p></item>
-    <item><p>Press one digit to read a specific message.</p></item>
-  </list>
-  <p>
-    Note that the most recently-received message is at the top of the list.
-  </p>
-  <p>
-    Each of <app>Cthulhu</app>'s notification review commands is unbound by
-    default. You can bind any or all of them to the shortcut or shortcuts
-    you choose. How to do so is described in the
-    <link xref="howto_key_bindings">Introduction to Key Bindings</link>.
-  </p>
-</page>
@@ -1,116 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="howto_profiles">
-  <info>
-    <link type="guide" xref="index#getting_started"/>
-    <link type="next" xref="howto_documents" />
-    <title type="sort">9. Profiles</title>
-    <desc>Maintaining multiple configurations</desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Profiles</title>
-  <p>
-    Cthulhu's profiles allow you to save and load multiple configurations so
-    that you can quickly access the settings you need.
-  </p>
-  <steps>
-    <title>Saving a New Profile</title>
-    <item>
-      <p>
-        Get into the <link xref="preferences">Cthulhu Preferences</link> dialog box.
-      </p>
-    </item>
-    <item>
-      <p>Change whatever settings you wish.</p>
-    </item>
-    <item>
-      <p>
-        On the <gui>General</gui> page, press the <gui>Save As</gui> button.
-      </p>
-    </item>
-    <item>
-      <p>
-        Type the new profile name in the resulting <gui>Save Profile As</gui>
-        dialog box.
-      </p>
-    </item>
-    <item>
-      <p>
-        Press the <gui>OK</gui> button in the <gui>Save Profile As</gui>
-        dialog box.
-      </p>
-    </item>
-  </steps>
-  <steps>
-    <title>Loading an Existing Profile</title>
-    <item>
-      <p>
-        Get into the <link xref="preferences">Cthulhu Preferences</link> dialog box.
-      </p>
-    </item>
-    <item>
-      <p>
-        On the <gui>General</gui> page, select the profile to load from the
-        <gui>Active Profile</gui> combo box.
-      </p>
-    </item>
-    <item>
-      <p>Press the <gui>Load</gui> button.</p>
-    </item>
-    <item>
-      <p>
-        You will be asked to confirm. Press the <gui>Yes</gui> button.
-      </p>
-    </item>
-    <item>
-      <p>Press the <gui>OK</gui> button.</p>
-    </item>
-  </steps>
-  <steps>
-    <title>Changing an Existing Profile</title>
-    <item>
-      <p>
-        Follow the steps described above to load the profile you wish to change.
-      </p>
-    </item>
-    <item>
-      <p>Follow the steps described above to save a new profile.</p>
-    </item>
-    <item>
-      <p>
-        When prompted for the new profile name, type the same name as current
-        profile. When you press the <gui>OK</gui> button, you will be told there
-        is a name conflict.
-      </p>
-    </item>
-    <item>
-      <p>
-        Press the <gui>Yes</gui> button to confirm you wish to overwrite the
-        existing profile with the new settings.
-      </p>
-    </item>
-  </steps>
-  <steps>
-    <title>Changing the <gui>Start-up Profile</gui></title>
-    <item>
-      <p>
-        Get into the <link xref="preferences">Cthulhu Preferences</link> dialog box.
-      </p>
-    </item>
-    <item>
-      <p>
-        On the <gui>General</gui> page, select the profile to load from the
-        <gui>Start-up Profile</gui> combo box.
-      </p>
-    </item>
-    <item>
-      <p>Press the <gui>OK</gui> button. The next time you launch <app>Cthulhu</app>,
-         the newly-selected profile will be used.
-      </p>
-    </item>
-  </steps>
-</page>
@@ -1,30 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="howto_setting_up_cthulhu">
-<info>
-  <link type="seealso" xref="preferences" />
-  <link type="guide" xref="index#getting_started" />
-  <link type="next" xref="howto_the_cthulhu_modifier" />
-  <title type="sort">4. Cthulhu Configuration</title>
-  <title type="link">Configuration</title>
-    <desc>
-      Setting up <app>Cthulhu</app>
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Cthulhu Configuration</title>
-
-      <p>
-        If you want to configure <app>Cthulhu</app>, get into the
-        <link xref="preferences">Preferences</link> dialog by pressing
-        <keyseq><key>Cthulhu Modifier</key><key>Space</key></keyseq> from
-        within any accessible application. Alternatively, you can type
-        <cmd>cthulhu</cmd> followed by either <cmd>-s</cmd> or <cmd>--setup</cmd>
-        in a terminal window or within the <gui>Run</gui> dialog and then press
-        <key>Return</key>.
-      </p>
-</page>
@@ -1,123 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/"
-      type="topic"
-      id="howto_structural_navigation">
-  <info>
-    <link type="guide" xref="index#reading"/>
-    <link type="next" xref="howto_tables" />
-    <title type="sort">3. Structural Navigation</title>
-    <desc>
-      Moving by heading and other elements
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Structural Navigation</title>
-  <p>
-    <app>Cthulhu</app>'s Structural Navigation feature allows you to navigate
-    amongst elements in a document. The types of elements by which you can
-    navigate include:
-  </p>
-  <list>
-    <item><p>Headings and other text blocks</p></item>
-    <item><p>Form controls</p></item>
-    <item><p>Links</p></item>
-    <item><p>Lists and list items</p></item>
-    <item><p>Landmarks, separators, and anchors</p></item>
-    <item><p>Tables and table cells</p></item>
-  </list>
-  <p>
-    A full list of individual elements and their associated keybindings can
-    be found in <link xref="commands_structural_navigation">Structural
-    Navigation Commands</link>.
-  </p>
-  <section id="applications">
-      <title>Supported Applications</title>
-      <p>
-        Currently, Structural Navigation is fully implemented for web content,
-        including the help content you are reading now. <app>Cthulhu</app>'s
-        Structural Navigation support for table cells has also been implemented
-        for <app>OpenOffice Writer</app> and <app>LibreOffice Writer</app>.
-        Implementing the remainder of the Structural Navigation objects to
-        these office suites requires changes to be made by their respective
-        developers. Implementing any Structural Navigation features within
-        <app>Evince</app> will require a similar effort on the part of its
-        developers.
-      </p>
-      <note style="tip">
-        <title>Don't Forget To Toggle Structural Navigation On!</title>
-        <p>
-          Depending on where you are, it may be necessary for you to explicitly
-          toggle Structural Navigation on before you can use it.
-        </p>
-      </note>
-      <section id="toggling_required">
-        <title>When Toggling Structural Navigation On Is Required</title>
-        <p>
-          In web pages, explicitly toggling Structural Navigation on is
-          generally unnecessary because your interaction with the document
-          largely consists of reading its content. Thus there is no question
-          as to whether the 'H' you just pressed was meant to be a writing
-          command or a navigation command.
-        </p>
-        <p>
-          On the other hand, in editable documents such as those found in
-          <app>OpenOffice</app> and <app>LibreOffice</app>, it is far more
-          difficult for <app>Cthulhu</app> to accurately predict what you expect
-          to have happen as a result of pressing 'H'. Therefore, before you
-          can use any Structural Navigation command in an editable document,
-          you must first toggle Structural Navigation on by pressing
-          <keyseq><key>Cthulhu Modifier</key><key>Z</key></keyseq>.
-          When you are finished navigating and ready to resume writing, press
-          <keyseq><key>Cthulhu Modifier</key><key>Z</key></keyseq> again to toggle
-          Structural Navigation off.
-        </p>
-      </section>
-  </section>
-  <section id="settings">
-    <title>Available Settings</title>
-    <p>
-      In addition to the aforementioned commands, <app>Cthulhu</app> has a number
-      of configurable options available specifically for applications in which
-      there is structural navigation support.
-    </p>
-    <steps>
-      <title>Configuring Structural Navigation</title>
-      <item>
-        <p>
-          Give focus to an application for which <app>Cthulhu</app> has
-          Structural Navigation support.
-        </p>
-      </item>
-      <item>
-        <p>
-          Get into the <link xref="preferences">Cthulhu Preferences</link>
-          dialog box for the current application by pressing
-          <keyseq>
-            <key>Ctrl</key><key>Cthulhu Modifier</key><key>Space</key>
-          </keyseq>.
-        </p>
-      </item>
-      <item>
-        <p>
-          Navigate to the last page of the dialog box which should be
-          named according to the name of your current application.
-        </p>
-      </item>
-      <item>
-        <p>
-         Examine and change the settings as you see fit.
-        </p>
-      </item>
-      <item>
-        <p>
-          Press the <gui>OK</gui> button.
-        </p>
-      </item>
-    </steps>
-  </section>
-</page>
@@ -1,148 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="howto_tables">
-  <info>
-    <link type="guide" xref="index#reading"/>
-    <link type="next" xref="howto_forms" />
-    <title type="sort">4. Tables</title>
-    <desc>
-      Navigating and setting dynamic headers
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Tables</title>
-  <p>
-    <app>Cthulhu</app> provides several features specifically designed to improve
-    access to tables found in web pages and other documents: configurable cell
-    versus row reading, <link xref="howto_structural_navigation">Structural
-    Navigation</link> and Dynamic Headers.
-  </p>
-  <section id="cell_row">
-    <title>Cell Versus Row Reading</title>
-    <p>
-      Consider the process of examining the list of messages in your Inbox.
-      In order to have Cthulhu announce the sender, subject, date, and presence
-      of attachments you would need <app>Cthulhu</app> to speak the row. On the
-      other hand, when navigating amongst rows in a spreadsheet, hearing the
-      full row may not be desired if for no other reason than the sheer number
-      of cells in each row. Thus in that case, you would want <app>Cthulhu</app>
-      to only speak the cell with focus. Similar situations occur in document
-      tables.
-    </p>
-    <p>
-      <app>Cthulhu</app> allows you to customize whether only the cell should be
-      read, or if the full row should be, for GUI tables, document tables,
-      and spreadsheets. Because these settings are independent of one another,
-      you do not have to choose one table reading mode to fit multiple types of
-      tables.
-    </p>
-    <p>
-      You can set each of <app>Cthulhu</app>'s table reading preferences <app>Cthulhu</app>
-      wide as well as on an application-by-application basis. How to do each is
-      described in the guide on <link xref="preferences"><app>Cthulhu</app>'s preferences
-      dialogs</link>. The settings can be found on the <link xref="preferences_speech">
-      <gui>Speech</gui> page</link>.
-    </p>
-    <p>
-      Lastly, there is also an <app>Cthulhu</app> command which allows you to toggle
-      cell versus row reading on the fly for the currently-active table:
-      <keyseq><key>Cthulhu Modifier</key><key>F11</key></keyseq>.
-    </p>
-  </section>
-  <section id="structural_navigation">
-    <title>Structural Navigation</title>
-    <p>
-      <app>Cthulhu</app>'s <link xref="commands_structural_navigation#tables">table
-      Structural Navigation commands</link> make it possible for you to quickly
-      locate tables, jump immediately to a table's first or last cell, and
-      move to the next cell in any direction.
-    </p>
-    <p>
-      As you navigate amongst and within tables using Structural Navigation,
-      <app>Cthulhu</app> will announce additional details to help you understand
-      your position, such as the dimensions of the table you just entered and
-      the fact that you have reached the edge of the table in the direction you
-      are moving.
-    </p>
-    <p>
-      In addition, <app>Cthulhu</app> provides configurable
-      <link xref="preferences_table_navigation">presentation options</link>
-      which work in conjunction with Structural Navigation and allow you to
-      control whether or not cell coordinates are presented, multiple cell spans
-      are indicated, and cell headers are announced.
-    </p>
-    <note style="tip">
-      <title>Don't Forget To Toggle Structural Navigation On!</title>
-      <p>
-        Depending on where you are, it may be necessary for you to explicitly
-        toggle Structural Navigation on before you can use it. To learn more, read
-        <link xref="howto_structural_navigation#toggling_required">
-        when toggling Structural Navigation on is required.</link>
-      </p>
-    </note>
-  </section>
-  <section id="dynamic_headers">
-    <title>Dynamic Headers</title>
-    <p>
-      Many of the tables you will encounter while reading have cells which serve
-      as the header for a row or a column. Whether or not the creator of that
-      table correctly marked those cells as headers is hard to say. In many
-      cases, the text was simply formatted to be larger and/or bold. And even if
-      the table is correctly marked up, that is no guarantee that the application
-      or toolkit exposes that text as header information to assistive technologies.
-      <app>Cthulhu</app>'s Dynamic Header support makes it possible to overcome these
-      challenges.
-    </p>
-    <steps>
-      <title>Setting Column Headers</title>
-      <item>
-        <p>
-          Move to the row which contains all of the column headers.
-        </p>
-      </item>
-      <item>
-        <p>
-          Press <keyseq><key>Cthulhu Modifier</key><key>R</key></keyseq> to tell
-          <app>Cthulhu</app> that the current row is the one with the headers.
-        </p>
-      </item>
-    </steps>
-    <steps>
-      <title>Setting Row Headers</title>
-      <item>
-        <p>
-          Move to the column which contains all of the row headers.
-        </p>
-      </item>
-      <item>
-        <p>
-          Press <keyseq><key>Cthulhu Modifier</key><key>C</key></keyseq> to tell
-          <app>Cthulhu</app> that the current column is the one with the headers.
-        </p>
-      </item>
-    </steps>
-    <p>
-      Having set either the column headers or the row headers, you should find
-      that as you navigate amongst the cells, <app>Cthulhu</app> will present each
-      header that has changed. Or to put it another way, <app>Cthulhu</app> will
-      not present the column header over and over again as you move up or down
-      within the current column. Likewise, it will not present the row header
-      over and over again as you move left or right within the current row.
-      However, if you change rows and there are row headers, the header
-      associated with the new row will be presented. And if you change columns
-      and there are column headers, the header associated with the new column
-      will be presented.
-    </p>
-    <p>
-      To clear headers, simply double-click the command you used to set them.
-      Thus double-clicking <keyseq><key>Cthulhu Modifier</key><key>R</key></keyseq>
-      tells <app>Cthulhu</app> there are no column headers. Double-clicking 
-      <keyseq><key>Cthulhu Modifier</key><key>C</key></keyseq> tells <app>Cthulhu</app>
-      there are no row headers.
-    </p>
-  </section>
-</page>
@@ -1,71 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="howto_text_attributes">
-  <info>
-    <link type="guide" xref="index#reading"/>
-    <link type="next" xref="howto_structural_navigation" />
-    <title type="sort">2. Text Attributes</title>
-    <desc>
-      Examining text formatting
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Text Attributes</title>
-  <p>
-    The term "text attributes" refers to all of the font, style, alignment,
-    and other formatting associated with a given character or series of
-    characters.
-  </p>
-  <section id="obtaining">
-    <title>Obtaining Formatting Information</title>
-    <p>
-      When you press <keyseq><key>Cthulhu Modifier</key><key>F</key>
-      </keyseq>, <app>Cthulhu</app> will speak known text attribute
-      information about an object. In addition, <app>Cthulhu</app> 
-      will optionally indicate text attributes in braille by
-      "underlining" them as you navigate a document.
-    </p>
-    <p>
-      Because the number of text attributes is large, and not everyone cares
-      about every attribute, the <link xref="preferences_text_attributes">
-      Text Attributes page of the preferences dialog</link> allows you to
-      customize which text attributes <app>Cthulhu</app> will present in speech,
-      along with the order in which they should be presented, and which ones
-      <app>Cthulhu</app> will indicate in braille.
-    </p>
-    <p>
-      Because the <link xref="preferences_text_attributes">Text Attributes
-      page</link> is also part of the application-specific settings, you can
-      customize text attribute presentation on an as-needed basis for each
-      application you use.
-    </p>
-  </section>
-  <section id="identifying_misspelled_words">
-    <title>Identifying Misspelled Words</title>
-    <p>
-      Most applications and toolkits indicate that a word is misspelled by
-      underlining that word with a red, squiggly line. The presence of this line
-      is typically exposed to assistive technologies as a text attribute. As a
-      result, you will find spelling errors amongst the text attributes you can
-      choose. By default, the spelling error attribute is enabled for both
-      speech and braille and will therefore be presented along with any other
-      attributes whose indication you have enabled.
-    </p>
-    <p>
-      In addition to accessing the presence of spelling errors as a text
-      attribute, if you have key echo and/or word echo enabled and type a
-      word which is misspelled, when the spelling error indication appears,
-      <app>Cthulhu</app> will announce "misspelled" so that you can immediately go
-      back and correct the error.
-    </p>
-    <p>
-      Finally, when you are navigating within a document and the caret moves
-      into a word which is misspelled, <app>Cthulhu</app> will announce the
-      presence of the spelling error.
-    </p>
-  </section>
-</page>
@@ -1,75 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="howto_the_cthulhu_modifier">
-  <info>
-    <link type="guide" xref="index#getting_started"/>
-    <link type="next" xref="howto_learn_modes" />
-    <title type="sort">3. The Cthulhu Modifier</title>
-    <desc>
-        A key that works like <key>Shift</key>, <key>Ctrl</key>,
-        and <key>Alt</key>
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>The Cthulhu Modifier</title>
-  <p>
-    Cthulhu has a special modifier key that works like <key>Shift</key>,
-    <key>Ctrl</key>, and <key>Alt</key>. It is designed specifically
-    for performing <app>Cthulhu</app> commands and doing so without
-    introducing conflicts with the commands of the applications you
-    are accessing.
-  </p>
-  <p>
-    Which key the "Cthulhu Modifier" is bound to will, by default, depend
-    on whether you are using <app>Cthulhu</app>'s Laptop keyboard layout
-    or its Desktop keyboard layout:
-  </p>
-  <list>
-    <item>
-      <p>
-        If you are using the Laptop layout, the default Cthulhu Modifier
-        will be <key>CapsLock</key>
-      </p>
-    </item>
-    <item>
-      <p>
-        If you are using the Desktop layout, the Cthulhu Modifier will
-        be both <key>Insert</key> and <key>KP_Insert</key>, the
-        latter being the same key as <key>KP_0</key>.
-      </p>
-    </item>
-  </list>
-  <p>
-    If you want to maintain your current keyboard layout but select a different
-    modifier key, you can do so by performing the following steps:
-  </p>
-  <steps>
-    <title>Changing the Cthulhu Modifier</title>
-    <item>
-      <p>
-        Get into the <link xref="preferences">Cthulhu Preferences</link> dialog by
-        pressing <keyseq><key>Cthulhu Modifier</key><key>Space</key></keyseq>. Alternatively, you can start Cthulhu with the preferences dialog open from a terminal: type <cmd>cthulhu -s</cmd> and press <key>Return</key>.
-      </p>
-    </item>
-    <item>
-      <p>Move to the <gui>Key Bindings</gui> page.</p>
-    </item>
-    <item>
-      <p>Move to the <gui>Screen Reader Modifier Key(s)</gui> combobox.</p>
-    </item>
-    <item>
-      <p>Arrow to the desired modifier. The available options are:</p>
-      <list>
-        <item><p>Insert, KP_Insert</p></item>
-        <item><p>KP_Insert</p></item>
-        <item><p>Insert</p></item>
-        <item><p>Caps_Lock</p></item>
-      </list>
-    </item>
-    <item><p>Press the <gui>Apply</gui> button.</p></item>
-  </steps>
-</page>
@@ -1,37 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="howto_toggling_caps_lock">
-  <info>
-    <link type="guide" xref="index#getting_started"/>
-    <link type="next" xref="howto_key_bindings" />
-    <title type="sort">7. CapsLock in Laptop Layout</title>
-    <desc>Toggling it when it is the <key>Cthulhu Modifier</key></desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>CapsLock in Laptop Layout</title>
-  <p>
-    Cthulhu has two keyboard layouts: Desktop and Laptop. The layout you choose
-    impacts which key is used as the Cthulhu Modifier. If you are using the Laptop
-    layout, the default Cthulhu Modifier will be <key>CapsLock</key>. If you are
-    using <app>Cthulhu</app>'s Laptop Layout and want to lock or unlock
-    <key>CapsLock</key>, you can do so by either pressing <key>CapsLock</key>
-    twice (requires at-spi2 version 2.32 or later), or by performing the
-    following steps:
-  </p>
-  <steps>
-    <title>Toggling CapsLock in Laptop Layout</title>
-    <item>
-      <p>
-        Press the Bypass command, <keyseq><key>Cthulhu Modifier</key><key>BackSpace</key>
-        </keyseq>, to tell <app>Cthulhu</app> that the next command should be ignored.
-      </p>
-    </item>
-    <item>
-      <p>Press <key>CapsLock</key> to toggle its locked state.</p>
-    </item>
-  </steps>
-</page>
@@ -1,110 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="howto_whereami">
-  <info>
-    <link type="guide" xref="index#reviewing"/>
-    <link type="next" xref="howto_flat_review" />
-    <title type="sort">1. Where Am I</title>
-    <desc>
-      Learning about your location
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Where Am I</title>
-  <p>
-    In addition to dedicated commands for reading the title bar and the
-    status bar, Cthulhu provides two context-sensitive Where Am I commands:
-    Basic Where Am I and Detailed Where Am I. Basic Where Am I is implemented
-    for all objects. Detailed Where Am I is implemented just for those objects
-    for which there is a significant amount of information you may wish to know,
-    but likely will not wish to know all of the time.
-  </p>
-  <p>
-    The best way to become familiar with what Where Am I will present is to
-    give the <link xref="commands_where_am_i">Where Am I commands</link> a
-    try. However, to give you a better idea of the context-sensitive nature
-    of <app>Cthulhu</app>'s Where Am I feature, consider the following:
-  </p>
-  <p>
-    For most widgets, you will at least be told the label and/or name, the
-    type or role of the widget, and the mnemonic and/or accelerator key if
-    they happen to exist. In addition:
-  </p>
-  <list>
-    <item>
-      <p>
-        If the widget is text, and you perform a basic Where Am I, you will be
-        told the current line if no text is selected. If text is selected,
-        however, a basic Where Am I will tell you what text is selected. A
-        detailed Where Am I within the text will also include the text
-        attributes.
-      </p>
-    </item>
-    <item>
-      <p>
-        If the widget can be checked, as is the case with checkboxes and
-        radio buttons, the checked state will be included.
-      </p>
-    </item>
-    <item>
-      <p> 
-        If the widget is a list or list-like object, such as a combo box, radio
-        button group, or page tab list, the position of the current item will be
-        included.
-      </p>
-    </item>
-    <item>
-      <p>
-        If the widget is hierarchical, such as a tree, and you are on an
-        expandable node, you will be told if that node is expanded or not.
-        And if it is expanded, you will also be told how many children it
-        contains. In addition, the nesting level will also be provided.
-      </p>
-    </item>
-    <item>
-      <p>
-        If the widget is a progress bar or a slider, you will be told the
-        current percent.
-      </p>
-    </item>
-    <item>
-      <p>
-        If the widget is an icon within an icon group, a basic Where Am I
-        will include the object you are in, the item you are on, and the
-        number of items which are selected. In a detailed Where Am I, you
-        will also be told which items are selected.
-      </p>
-    </item>
-    <item>
-      <p>
-        If you are on a link, the type of link (same site, different site,
-        FTP link, etc.) will be included.
-      </p>
-    </item>
-    <item>
-      <p>
-        If you are in a table cell, the coordinates of that cell and the cell
-        headers will be included.
-      </p>
-    </item>
-    <item>
-      <p>
-        If you are in the spell checker of an application where <app>Cthulhu</app>
-        provides enhanced support, a basic Where Am I will repeat the error
-        respecting your <link xref="preferences_spellcheck">spell check
-        preferences</link>. A detailed Where Am I will cause <app>Cthulhu</app> to
-        present the full details of the error.
-      </p>
-    </item>
-  </list>
-  <p>
-    And so on. Again, the goal of <app>Cthulhu</app>'s Where Am I is to provide
-    you with the details you are most likely interested in knowing about the
-    object you are currently in. To give Where Am I a try, see the list of
-    <link xref="commands_where_am_i">Where Am I commands</link>.
-  </p>
-</page>
@@ -1,47 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/"
-    xmlns:its="http://www.w3.org/2005/11/its"
-    type="guide"
-    id="index">
-  <info>
-    <title type="text">Cthulhu Screen Reader</title>
-    <title type="link">Introduction to the <app>Cthulhu</app> Screen Reader</title>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-
-    <desc>Cthulhu is a free, open source, flexible, and extensible screen reader
-    that provides access to the graphical desktop via speech and refreshable
-    braille.</desc>
-  </info>
-
-  <title>
-    <media type="image" mime="image/png" src="figures/cthulhu-logo.png" its:translate="no">
-      <span its:translate="yes"><app>Cthulhu</app>'s logo</span>
-    </media>
-    <app>Cthulhu</app> Screen Reader
-  </title>
-  <note style="important">
-    <title>Before You Begin</title>
-    <p>
-      If you are not yet familiar with the navigation commands provided by
-      your desktop environment, you are encouraged to read that documentation
-      first.
-    </p>
-  </note>
-  <section id="getting_started" style="2column">
-    <title>Getting Started</title>
-  </section>
-  <section id="reading" style="2column">
-    <title>Reading Documents and Web Pages</title>
-  </section>
-  <section id="reviewing" style="2column">
-    <title>Reviewing and Interacting with Screen Contents</title>
-  </section>
-  <section id="quick_reference" style="2column">
-    <title>Quick Reference</title>
-  </section>
-</page>
@@ -1,138 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="introduction">
-  <info>
-    <link type="guide" xref="index#getting_started" />
-    <link type="next" xref="howto_setting_up_cthulhu" />
-    <title type="sort">1. Welcome to Cthulhu</title>
-    <desc>
-      Introducing the <app>Cthulhu</app> screen reader
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Welcome to Cthulhu</title>
-  <p>
-    <app>Cthulhu</app> is a free, open source, flexible, and extensible
-    screen reader that provides access to the graphical desktop via
-    speech and refreshable braille.
-  </p>
-  <p>
-    <app>Cthulhu</app> works with applications and toolkits that support
-    the Assistive Technology Service Provider Interface (AT-SPI), which
-    is the primary assistive technology infrastructure for Linux and
-    Solaris. Applications and toolkits supporting the AT-SPI include
-    Gtk+, Qt, Java Swing, LibreOffice, Gecko, WebKitGtk, and Chrome/Chromium.
-  </p>
-  <section id="launching">
-    <title>Launching <app>Cthulhu</app></title>
-    <p>To launch <app>Cthulhu</app>:</p>
-    <list>
-      <item>
-        <p>
-          The method for configuring <app>Cthulhu</app> to be launched
-          automatically as your preferred screen reader will depend upon
-          which desktop environment you use.
-        </p>
-      </item>
-      <item>
-        <p>
-          To toggle <app>Cthulhu</app> on and off in GNOME, press
-          <keyseq><key>Super</key><key>Alt</key><key>S</key></keyseq>.
-        </p>
-      </item>
-      <item>
-        <p>
-          Type <cmd>cthulhu</cmd>, along with any optional parameters, in a
-          terminal window or within the <gui>Run</gui> dialog and then press
-          <key>Return</key>.
-        </p>
-      </item>
-    </list>
-  </section>
-    <section id="loadtime">
-      <title>Load-Time Options</title>
-      <p>
-        The following options can be specified when launching <app>Cthulhu</app>
-	in a terminal window or within the <gui>Run</gui> dialog:
-      </p>
-      <list>
-        <item>
-          <p><cmd>-h</cmd>, <cmd>--help</cmd>: Show the help message</p>
-        </item>
-        <item>
-          <p>
-            <cmd>-v</cmd>, <cmd>--version</cmd>: Show the version of
-            <app>Cthulhu</app>
-          </p>
-        </item>
-        <item>
-          <p>
-            <cmd>-s</cmd>, <cmd>--setup</cmd>: Set up user preferences
-          </p>
-        </item>
-        <item>
-          <p>
-            <cmd>-u</cmd>, <cmd>--user-prefs=<em>dirname</em></cmd>:
-            Use <em>dirname</em> as the alternate directory for user
-            preferences
-          </p>
-        </item>
-        <item>
-          <p>
-            <cmd>-e</cmd>, <cmd>--enable=<em>option</em></cmd>: Force use
-            of option, where the <em>option</em> can be one of the following:
-          </p>
-          <list>
-            <item><p><cmd>speech</cmd></p></item>
-            <item><p><cmd>braille</cmd></p></item>
-            <item><p><cmd>braille-monitor</cmd></p></item>
-          </list>
-        </item>
-        <item>
-          <p>
-            <cmd>-d</cmd>, <cmd>--disable=<em>option</em></cmd>: Prevent the
-            use of an option, where the <em>option</em> can be one of the
-            following:
-          </p>
-          <list>
-            <item><p><cmd>speech</cmd></p></item>
-            <item><p><cmd>braille</cmd></p></item>
-            <item><p><cmd>braille-monitor</cmd></p></item>
-          </list>
-        </item>
-        <item>
-            <p>
-              <cmd>-p</cmd>, <cmd>--profile=<em>filename</em></cmd>:
-              Import a profile from a given <app>Cthulhu</app> profile file
-            </p>
-        </item>
-        <item>
-          <p>
-            <cmd>-r</cmd>, <cmd>--replace</cmd>: Replace a currently-running <app>Cthulhu</app>
-          </p>
-        </item>
-        <item>
-          <p>
-            <cmd>-l</cmd>, <cmd>--list-apps</cmd>: Print the known running
-            applications
-          </p>
-        </item>
-        <item>
-          <p>
-            <cmd>--debug</cmd>: Send debug output to debug-YYYY-MM-DD-HH:MM:SS.out
-          </p>
-        </item>
-        <item>
-          <p>
-            <cmd>--debug-file=<em>filename</em></cmd>: Send debug output to
-            the specified file
-          </p>
-        </item>
-      </list>
-    </section>
-
-</page>
@@ -1,21 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="guide" id="preferences">
-  <info>
-    <link type="next" xref="preferences_introduction" />
-    <link type="guide" xref="index#quick_reference" />
-    <title type="link">Preferences</title>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title><app>Cthulhu</app>'s Preferences Dialogs</title>
-  <section id="cthulhu" style="2column">
-    <title>Cthulhu Preferences</title>
-  </section>
-  <section id="application" style="2column">
-    <title>Application-Unique Preferences</title>
-  </section>
-</page>
@@ -1,183 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="preferences_braille">
-  <info>
-    <title type="sort">3. Braille</title>
-    <title type="link">Braille</title>
-    <desc>
-      Configuring <app>Cthulhu</app>'s braille display support
-    </desc>
-    <link type="guide" xref="preferences#cthulhu" />
-    <link type="next" xref="preferences_key_echo" />
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Braille Preferences</title>
-  <section id="braillesupport">
-    <title>Enable Braille Support</title>
-    <p>
-      This check box toggles whether or not <app>Cthulhu</app> will make
-      use of a braille display. If BrlTTY is not running, <app>Cthulhu</app>
-      will recover gracefully and will not communicate with the braille
-      display.
-    </p>
-    <p>
-      Default value: not checked
-    </p>
-    <note style="tip">
-      <p>
-        If you configure BrlTTY later on, you need to restart <app>Cthulhu</app>
-        in order to use braille.
-      </p>
-    </note>
-  </section>
-  <section id="braillewordwrap">
-    <title>Enable word wrap</title>
-    <p>
-      If <gui>Enable word wrap</gui> is checked, <app>Cthulhu</app> will adjust the
-      text so that only full words are shown on the braille display. If it is not
-      checked, <app>Cthulhu</app> will use all of the cells on the display so that
-      more text can be shown at once.
-    </p>
-    <p>
-      Default value: not checked
-    </p>
-  </section>
-  <section id="contractedbraille">
-    <title>Enable Contracted Braille</title>
-    <p>
-      Cthulhu supports contracted braille via the liblouis project. Because many
-      distros include liblouis, you will likely automatically have access to
-      contracted braille support in <app>Cthulhu</app>.
-    </p>
-    <p>
-      To enable contracted braille on a system where liblouis has been installed,
-      be sure that the <gui>Enable Contracted Braille</gui> checkbox is checked.
-      Then choose your desired translation table from the <gui>Contraction
-      Table</gui> combo box.
-    </p>
-    <p>
-      Default value: not checked
-    </p>
-  </section>
-  <section id="rolenames">
-    <title>Abbreviated Role Names</title>
-    <p>
-      This check box determines the manner in which role names are
-      displayed and can be used to help conserve real estate on the
-      braille display. For instance, if a slider had focus, the word
-      "slider" would be displayed if abbreviated role names is not
-      checked; if it were checked, "sldr" would be displayed instead.
-    </p>
-    <p>
-      Default value: not checked
-    </p>
-  </section>
-  <section id="eolindicator">
-    <title>Disable end of line symbol</title>
-    <p>
-      Checking this checkbox tells <app>Cthulhu</app> to not present the
-      "$l" string at the end of a line of text.
-    </p>
-    <p>
-      Default value: not checked
-    </p>
-  </section>
-  <section id="verbosity">
-    <title>Verbosity</title>
-    <p>
-      This radio button group determines the amount of information that
-      will be brailled in certain situations. For example, if it is set
-      to verbose, keyboard shortcut and role name information is displayed.
-      This information is not displayed in brief mode.
-    </p>
-    <p>
-      Default value: <gui>Verbose</gui>
-    </p>
-  </section>
-  <section id="selectionandhyperlink">
-    <title>Selection and Hyperlink Indicators</title>
-    <p>
-      The <gui>Selection Indicator</gui> and <gui>Hyperlink Indicator</gui>
-      radio button groups allow you to configure <app>Cthulhu</app>'s behavior
-      when displaying selected text and hyperlinks. By default, when you
-      encounter either, <app>Cthulhu</app> will "underline" that text on
-      your braille display with Dots 7 and 8. If you would prefer, you
-      can change the indicator to only be Dot 7, only be Dot 8, or not
-      be present at all.
-    </p>
-    <p>
-      Default value: <gui>Dots 7 and 8</gui>
-    </p>
-    <note style="tip">
-      <title>Text Attribute Indicators</title>
-      <p>
-        You can also optionally have text attributes indicated in braille.
-        Enabling this feature and choosing which attributes are of
-        interest is done on the <link xref="preferences_text_attributes">
-        <gui>Text Attributes</gui> page</link> of the preferences dialog.
-      </p>
-    </note>
-  </section>
-  <section id="flashMessageSettings">
-    <title>Flash Message Settings</title>
-    <p>
-        Flash messages are similar in nature to notifications or announcements:
-        They are shown on your refreshable braille display for a brief time,
-        after which the original contents of the braille display are restored.
-        <app>Cthulhu</app> has several settings you can use to control flash message
-        presentation.
-    </p>
-    <section id="flashMessageSettings_enable">
-      <title>Enable flash messages</title>
-      <p>
-        If <gui>Enable flash messages</gui> is checked, <app>Cthulhu</app> will
-        present messages to you in braille. If you prefer to only have
-        <app>Cthulhu</app>'s messages spoken, you should uncheck this checkbox.
-      </p>
-      <p>
-        Default value: checked
-      </p>
-    </section>
-    <section id="flashMessageSettings_detailed">
-      <title>Messages are detailed</title>
-      <p>
-        If <gui>Messages are detailed</gui> is checked, <app>Cthulhu</app> will
-        present detailed messages to you in braille. For instance, if you
-        use <app>Cthulhu</app>'s command to change echo, <app>Cthulhu</app> might
-        display "Echo set to word." If you would prefer shorter messages,
-        such as simply "word," you should uncheck this checkbox.
-      </p>
-      <p>
-        Default value: checked
-      </p>
-    </section>
-    <section id="flashMessageSettings_persistent">
-      <title>Messages are persistent</title>
-      <p>
-        As stated above, flash messages are only shown for a brief period of time.
-        If you would prefer messages remain displayed until you perform an action
-        which causes your display to be updated, you should check the <gui>Messages
-        are persistent</gui> checkbox.
-      </p>
-      <p>
-        Default value: not checked
-      </p>
-    </section>
-    <section id="flashMessageSettings_duration">
-      <title>Duration (secs)</title>
-      <p>
-        The amount of time <app>Cthulhu</app> will wait before removing the message and
-        restoring the original contents of your display can be set in the <gui>
-        Duration (secs)</gui> spin button. Note that the value of this
-        setting will be ignored if you have enabled persistent flash messages.
-      </p>
-      <p>
-        Default value: 5
-      </p>
-    </section>
-  </section>
-</page>
@@ -1,79 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="preferences_chat">
-  <info>
-    <link type="guide" xref="preferences#application" />
-    <link type="next" xref="preferences_spellcheck" />
-    <title type="sort">3. Chat</title>
-    <title type="link">Chat</title>
-    <desc>
-      Configuring <app>Cthulhu</app>'s support for IM and IRC
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Chat Preferences</title>
-  <p>
-    The following options allow you to customize how <app>Cthulhu</app>
-    behaves when providing access to instant messaging and internet
-    relay chat clients.
-  </p>
-  <section id="speak_name">
-    <title>Speak Chat Room name</title>
-    <p>
-      If this checkbox is checked, <app>Cthulhu</app> will prefix incoming messages
-      with the name of the room or buddy they came from, unless they came from
-      the currently-focused conversation.
-    </p>
-    <p>
-       Default value: not checked
-    </p>
-  </section>
-  <section id="announce_typing">
-    <title>Announce when your buddies are typing</title>
-    <p>
-      If this checkbox is checked, and if <app>Cthulhu</app> has sufficient
-      information identifying that your buddy is typing, <app>Cthulhu</app> will
-     announce changes in typing status.
-    </p>
-    <p>
-       Default value: not checked
-    </p>
-  </section>
-  <section id="message_histories">
-    <title>Provide chat room specific message histories</title>
-    <p>
-      If this checkbox is checked, <app>Cthulhu</app>'s commands for reviewing
-      recent messages will only apply to the currently-focused conversation.
-      Otherwise, the history will contain the most recent messages regardless
-      of which conversation they came from.
-    </p>
-    <p>
-       Default value: not checked
-    </p>
-  </section>
-  <section id="speak_messages_from">
-    <title>Speak messages from</title>
-    <p>
-      This group of radio buttons allows you to control under what circumstances
-      <app>Cthulhu</app> will present an incoming message to you. Your choices are:
-    </p>
-    <list>
-      <item>
-        <p><gui>All channels</gui></p>
-      </item>
-      <item>
-        <p><gui>A channel only if its window is active</gui></p>
-      </item>
-      <item>
-        <p><gui>All channels when any chat window is active</gui></p>
-      </item>
-    </list>
-    <p>
-       Default value: all channels
-    </p>
-  </section>
-</page>
@@ -1,279 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="preferences_general">
-  <info>
-    <title type="sort">1. General</title>
-    <title type="link">General</title>
-    <desc>
-      Configuring <app>Cthulhu</app>'s fundamental behaviors
-    </desc>
-    <link type="guide" xref="preferences#cthulhu" />
-    <link type="next" xref="preferences_voice" />
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>General Preferences</title>
-  <section id="keyboardlayout">
-    <info>
-      <desc>
-        Preferences dialog box option to select which <app>Cthulhu</app> keyboard
-        layout to use, desktop or laptop.
-      </desc>
-    </info>
-    <title>Keyboard Layout</title>
-    <p>
-      The <gui>Keyboard Layout</gui> radio button group allows you to specify if
-      you will be working on a desktop (i.e. with a numeric keypad) or laptop
-      keyboard. Which layout you choose will determine both the <key>Cthulhu
-      Modifier</key> as well as a number of keyboard shortcuts for performing
-      <app>Cthulhu</app> commands.</p>
-    <p>
-      Default value: <gui>Desktop</gui>
-    </p>
-  </section>
-  <section id="presenttooltips">
-    <info>
-      <desc>
-        Preferences dialog box option to enable presentation of tooltips which
-        appear as the result of mouse hovering.
-      </desc>
-    </info>
-    <title>Present Tooltips</title>
-    <p>
-      When checked, this option will tell <app>Cthulhu</app> to present information
-      about tooltips when they appear as the result of mouse hovering. Specific
-      actions to force tooltips to appear, such as pressing <keyseq>
-      <key>Ctrl</key><key>F1</key></keyseq> when an object has focus, will
-      always result in tooltips being presented, regardless of this setting.
-    </p>
-    <p>
-      Default value: not checked
-    </p>
-  </section>
-  <section id="objectundermouse">
-    <info>
-      <desc>
-        Preferences dialog box option to enable presentation of the object
-        under the mouse pointer.
-      </desc>
-    </info>
-    <title>Speak Object Under Mouse</title>
-    <p>
-      When checked, this option will tell <app>Cthulhu</app> to present
-      information about the object under the mouse pointer as you move
-      it around the screen using <app>Cthulhu</app>'s
-      <link xref="howto_mouse_review">Mouse Review</link> feature.
-    </p>
-    <p>
-      Default value: not checked
-    </p>
-  </section>
-  <section id="timeanddate">
-    <info>
-      <desc>
-        Preferences dialog box options for customizing the time and date
-        formats used by <app>Cthulhu</app>.
-      </desc>
-    </info>
-    <title>Time Format and Date Format</title>
-    <p>
-      The <gui>Time Format</gui> and <gui>Date Format</gui> combo boxes allow
-      you to specify how <app>Cthulhu</app> will speak and braille the time and the
-      date.
-    </p>
-    <p>
-      Default value: use the system locale's format for each
-    </p>
-  </section>
-  <section id="navigation_in_say_all">
-    <info>
-      <desc>
-        Preferences dialog box options for enabling rewind, fast forward,
-	and structural navigation during Say All.
-      </desc>
-    </info>
-    <title>Navigation in Say All</title>
-    <p>
-        <app>Cthulhu</app>'s Say All feature speaks document content from your
-        present location to the end of the document. By default, pressing any
-        key will interrupt Say All's presentation. However, if you check the
-        <gui>Enable rewind and fast forward in Say All</gui> checkbox,
-        <key>Up</key> and <key>Down</key> can be used during Say All to quickly
-        move within the document in order to re-hear something which was just
-        read or skip past text of no interest without having to restart Say All.
-    </p>
-    <p>
-       If you are reading a document within an application that has structural
-       navigation support, and you have checked the <gui>Enable structural navigation
-       in Say All</gui> checkbox, you can use the supported structural navigation
-       commands in a similar fashion: <key>H</key>/<keyseq><key>Shift</key>
-       <key>H</key></keyseq> continues reading from the next/previous heading,
-       <key>P</key>/<keyseq><key>Shift</key><key>P</key></keyseq> continues reading
-       from the next/previous paragraph, <key>T</key>/<keyseq><key>Shift</key>
-       <key>T</key></keyseq> continues reading from the next/previous table, and
-       so on.
-    </p>
-    <p>
-      Default value: not checked
-    </p>
-  </section>
-  <section id="say_all_announce_context">
-    <title>Announce Contextual Information in Say All</title>
-    <p>
-      <app>Cthulhu</app> can optionally provide more information about the document
-      content being spoken, such as announcing when you are entering and leaving
-      a blockquote, list, table, or other container. Whether or not these
-      announcements are made can be configured independently through the following
-      checkboxes:
-    </p>
-    <list>
-      <item><p>Announce blockquotes in Say All</p></item>
-      <item><p>Announce forms in Say All</p></item>
-      <item><p>Announce landmarks in Say All</p></item>
-      <item><p>Announce lists in Say All</p></item>
-      <item><p>Announce panels in Say All</p></item>
-      <item><p>Announce tables in Say All</p></item>
-    </list>
-    <p>
-      Default value: checked
-    </p>
-    <note style="note">
-      <p>
-        Whether or not <app>Cthulhu</app> makes these announcements during
-        navigation is also configurable. You will find similar checkboxes
-        on the <gui>Speech</gui> page. For more information, see
-        <link xref="preferences_speech#spoken_context">Spoken Context</link>.
-      </p>
-    </note>
-  </section>
-  <section id="say_all_by">
-   <info>
-      <desc>
-        Preferences dialog box option for customizing <app>Cthulhu</app>'s
-	Say All presentation.
-      </desc>
-   </info>
-   <title>Say All By</title>
-   <p>
-      The <gui>Say All By</gui> combo box allows you to specify whether
-      <app>Cthulhu</app> speaks a sentence at a time or a line at a time when
-      doing a "Say All" of a document.
-    </p>
-    <p>
-      Default value: <gui>Sentence</gui>
-    </p>
-  </section>
-  <section id="profiles">
-    <info>
-      <desc>
-        Preferences dialog box options for managing settings profiles.
-      </desc>
-    </info>
-    <title>Profiles</title>
-    <p>
-      The <gui>Profiles</gui> group of controls, which appear at the bottom
-      of the <gui>General</gui> page, make it possible for you to maintain
-      and use multiple configurations. 
-    </p>
-   <list>
-      <item>
-        <p>
-          The <gui>Active Profile</gui> combo box displays the current profile
-          and allows you to select a different profile to load.
-        </p>
-      </item>
-      <item>
-        <p>
-          The <gui>Load</gui> button will cause <app>Cthulhu</app> to load the
-          profile indicated in the <gui>Active Profile</gui> combo box.
-        </p>
-      </item>
-      <item>
-        <p>
-          The <gui>Save As</gui> button allows you to save the current set of
-          options from the preferences dialog box to a named profile.
-        </p>
-      </item>
-      <item>
-        <p>
-          The <gui>Start-up Profile</gui> combo box allows you to select the
-          profile which should be automatically loaded each time you launch
-          <app>Cthulhu</app>.
-        </p>
-      </item>
-    </list>
-  </section>
-  <section id="progress_bar_updates">
-    <title>Progress Bar Updates</title>
-    <section id="progress_bar_updates_speak">
-      <title>Speak updates</title>
-      <p>
-        If the <gui>Speak updates</gui> checkbox is checked <app>Cthulhu</app> will
-        periodically speak the status of progress bars.
-      </p>
-      <p>
-        Default value: checked
-      </p>
-    </section>
-    <section id="progress_bar_updates_braille">
-      <title>Braille updates</title>
-      <p>
-        If the <gui>Braille updates</gui> checkbox is checked <app>Cthulhu</app> will
-        periodically display the status of progress bars on your refreshable braille
-        display.
-      </p>
-      <p>
-        Default value: not checked
-      </p>
-    </section>
-    <section id="progress_bar_updates_beep">
-      <title>Beep updates</title>
-      <p>
-        If the <gui>Beep updates</gui> checkbox is checked <app>Cthulhu</app> will
-        periodically emit beeps which increase in pitch as the value of the progress
-        bar increases.
-      </p>
-      <p>
-        Default value: not checked
-      </p>
-    </section>
-    <section id="progress_bar_updates_frequency">
-      <title>Frequency (secs)</title>
-      <p>
-        This spin button determines how often updates are presented.
-      </p>
-      <p>
-        Default value: 10
-      </p>
-    </section>
-    <section id="progress_bar_updates_restrict">
-      <title>Applies to</title>
-      <p>
-         This combo box allows you to control which progress bars should be
-         presented, assuming the presentation of progress bar updates has been
-         enabled. The choices are <gui>All</gui>, <gui>Application</gui>, and
-         <gui>Window</gui>.
-      </p>
-      <p>
-        Choosing <gui>All</gui> will result in <app>Cthulhu</app> presenting
-        updates for all progress bars, regardless of where the progress bars
-        are located.
-      </p>
-      <p>
-        Choosing <gui>Application</gui> will result in <app>Cthulhu</app>
-        presenting updates from progress bars in the active application, even
-        if they are not in the active window.
-      </p>
-      <p>
-         Choosing <gui>Window</gui> will result in <app>Cthulhu</app> only
-         presenting updates for progress bars in the active window.
-      </p>
-      <p>
-        Default value: <gui>Application</gui>
-      </p>
-    </section>
-  </section>
-</page>
@@ -1,59 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="preferences_introduction">
-  <info>
-    <title type="sort">0. Introduction to <app>Cthulhu</app>'s Preferences</title>
-    <title type="link">Introduction to <app>Cthulhu</app>'s Preferences</title>
-    <link type="guide" xref="preferences" />
-    <link type="next" xref="preferences_general" />
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Introduction to <app>Cthulhu</app>'s Preferences</title>
-  <section id="cthulhu">
-    <title>Cthulhu Preferences</title>
-    <p>
-      Cthulhu preferences allow you to customize functionality in <app>Cthulhu</app>
-      which applies to all applications. An example of an Cthulhu preference is
-      echo because echo is something that applies to all applications.
-    </p>
-    <p>
-      Note that Cthulhu preferences can be customized on an application-by-application
-      basis. For instance you can set the default echo to words and then
-      set the echo for Pidgin to be none. Having done so, <app>Cthulhu</app>
-      would always echo each word that you typed, unless you were in Pidgin.
-    </p>
-    <note style="tip">
-      <title>Keyboard Shortcuts for Getting Into the Preferences Dialogs</title>
-      <list>
-        <item>
-          <p>
-            <keyseq><key>Cthulhu Modifier</key><key>Space</key></keyseq>:
-            <app>Cthulhu</app>'s Preferences
-          </p>
-        </item>
-        <item>
-          <p>
-            <keyseq><key>Ctrl</key><key>Cthulhu Modifier</key><key>Space</key>
-            </keyseq>: <app>Cthulhu</app>'s Preferences for the current
-            application
-          </p>
-        </item>
-      </list>
-    </note>
-  </section>
-  <section id="application_unique">
-    <title>Application-Unique Preferences</title>
-      <p>
-        In contrast to Cthulhu preferences, there are application-unique preferences.
-        These preferences allow you to customize <app>Cthulhu</app> functionality
-        that only applies in certain environments, such as on web pages or in
-        chat applications. As a result, you will only find these options
-        available in the application-specific preferences dialogs and only for
-        those applications to which these options apply.
-      </p>
-  </section>
-</page>
@@ -1,75 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="preferences_key_bindings">
-  <info>
-    <link type="guide" xref="preferences#cthulhu"/>
-    <link type="next" xref="preferences_pronunciation" />
-    <link type="seealso" xref="howto_key_bindings" />
-    <title type="sort">6. Key Bindings</title>
-    <title type="link">Key Bindings</title>
-    <desc>
-      Configuring <app>Cthulhu</app>'s keyboard shortcuts
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Key Bindings Preferences</title>
-  <section id="cthulhu_modifier_keys">
-    <title>Cthulhu Modifier Keys</title>
-    <p>
-      The <gui>Screen Reader Modifier Key(s)</gui> combo box allows you to select which
-      key or keys will serve as the Cthulhu Modifier. The available options are:
-    </p>
-    <list>
-      <item>
-        <p>
-          <gui>KP_Insert</gui> (the same key as the <key>0</key> on the
-          numeric keypad)
-      </p></item>
-      <item><p><gui>Insert</gui></p></item>
-      <item><p><gui>Insert, KP_Insert</gui></p></item>
-      <item><p><gui>Caps_Lock</gui></p></item>
-    </list>
-  </section>
-  <section id="key_bindings_table">
-    <title>The Key Bindings Table</title>
-    <p>
-      The key bindings table provides a list of <app>Cthulhu</app> operations
-      and the keys that are bound to them.
-    </p>
-    <list>
-      <item>
-        <p>
-          The <gui>Command</gui> column contains a description of the
-          <app>Cthulhu</app> command to be performed.
-        </p>
-      </item>
-      <item>
-        <p>
-          The <gui>Key Binding</gui> column contains the keyboard shortcut currently
-          assigned to the <app>Cthulhu</app> command. You can modify the value of
-          this column by pressing <key>Return</key>, pressing the keys for the
-          new binding, and pressing <key>Return</key> again.
-        </p>
-      </item>
-      <item>
-        <p>
-          The <gui>Modified</gui> column serves both as an indicator to what
-          has been changed and as a way to restore the default bindings
-          associated with that command.
-        </p>
-      </item>
-    </list>
-    <p>
-      Beneath the list of <app>Cthulhu</app> keybindings, you will find a group
-      of "unbound" commands. These are commands which we feel will be very
-      useful for some users, but not needed by most users. Rather than "use
-      up" a keystroke for such commands, we have left them unassigned by
-      default. At the end of the list are the braille bindings, for use with
-      a refreshable braille display.
-    </p>
-  </section>
-</page>
@@ -1,183 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="preferences_key_echo">
-  <info>
-    <title type="link">Echo</title>
-    <title type="sort">4. Echo</title>
-    <desc>
-      Configuring what is spoken as you type
-    </desc>
-    <link type="guide" xref="preferences#cthulhu" />
-    <link type="next" xref="preferences_key_bindings" />
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Echo Preferences</title>
-  <section id="keyecho">
-    <title>Enable key echo</title>
-    <p>
-      Cthulhu's key echo setting controls what happens each time you press
-      a key. To enable key echo, check the "Enable key echo" checkbox.
-      Doing so causes additional checkboxes to become available through
-      which you can choose exactly which keys should and should not be
-      echoed to best suit your needs.
-    </p>
-    <p>
-      Default value: checked
-    </p>  
-    <section id="keyecho_enable_alphanumeric">
-      <title>Enable alphabetic keys</title>
-      <p>
-        This option controls whether or not keys like <key>a</key>,
-        <key>b</key>, and <key>c</key> should be spoken when pressed.
-      </p>
-      <p>
-        Default value: checked
-      </p>
-    </section>
-    <section id="keyecho_enable_numeric">
-      <title>Enable numeric keys</title>
-      <p>
-        This option controls whether or not keys like <key>1</key>,
-        <key>2</key>, and <key>3</key> should be spoken when pressed.
-      </p>
-      <p>
-        Default value: checked
-      </p>
-    </section>
-    <section id="keyecho_enable_punctuation">
-      <title>Enable punctuation keys</title>
-      <p>
-        This option controls whether or not keys like <key>%</key>,
-        <key>;</key>, and <key>?</key> should be spoken when pressed.
-      </p>
-      <p>
-        Default value: checked
-      </p>
-    </section>
-    <section id="keyecho_enable_space">
-      <title>Enable space</title>
-      <p>
-        This option controls whether or not <key>Space</key> should be
-        spoken when pressed.
-      </p>
-      <p>
-        Default value: checked
-      </p>
-    </section>
-    <section id="keyecho_enable_modifier">
-      <title>Enable modifier keys</title>
-      <p>
-        This option controls whether or not <key>Shift</key>, <key>Ctrl</key>,
-        <key>Alt</key> and <key>Meta</key> should be spoken when pressed.
-      </p>
-      <p>
-        Default value: checked
-      </p>
-    </section>
-    <section id="keyecho_enable_function">
-      <title>Enable function keys</title>
-      <p>
-        This option controls whether or not <key>F1</key> through <key>F12</key>
-        should be spoken when pressed.
-      </p>
-      <p>
-        Default value: checked
-      </p>
-    </section>
-    <section id="keyecho_enable_action">
-      <title>Enable action keys</title>
-      <p>
-        This option controls whether or not <key>BackSpace</key>, <key>Delete
-        </key>, <key>Return</key>, <key>Esc</key>, <key>Tab</key>, <key>Page
-        Up</key>, <key>Page Down</key>, <key>Home</key>, and <key>End</key>
-        should be spoken when pressed.
-      </p>
-      <p>
-        Default value: checked
-      </p>
-    </section>
-    <section id="keyecho_enable_navigation">
-      <title>Enable navigation keys</title>
-      <p>
-        This option controls whether or not <key>Left</key>, <key>Right</key>,
-        <key>Up</key>, and <key>Down</key> should be spoken when pressed. This
-        option also applies to any key combination in which <key>Cthulhu
-        Modifier</key> is being held down, for instance when flat review is
-        being used.
-      </p>
-      <p>
-        Default value: not checked
-      </p>
-    </section>
-    <section id="keyecho_enable_diacritical">
-      <title>Enable non-spacing diacritical keys</title>
-      <p>
-        This option controls whether or not "dead keys" used to generate
-        accented letters should be spoken when pressed.
-      </p>
-      <p>
-        Default value: not checked
-      </p>
-    </section>
-  </section>
-  <section id="characterecho">
-    <title>Enable echo by character</title>
-    <p>
-      Enabling this option causes Cthulhu to echo the character
-      you just typed.
-    </p>
-    <p>
-      While echo by character seems quite similar to the key echo of
-      alphabetic, numeric, and punctuation keys, there are important differences,
-      especially with respect to accented letters and other symbols for which
-      there is no dedicated key:
-    </p>
-    <list>
-      <item>
-        <p>
-          Key echo causes <app>Cthulhu</app> to announce what you just <em>
-          pressed</em>.
-        </p>
-      </item>
-      <item>
-        <p>
-          Character echo causes <app>Cthulhu</app> to announce what was just
-          <em>inserted</em>.
-        </p>
-      </item>
-    </list>
-    <p>
-      Thus to have accented characters spoken as you type them, you should
-      enable character echo.
-    </p>
-    <p>
-      Default value: not checked
-    </p>
-    <note style="tip">
-      <title>Enabling both key echo and character echo</title>
-      <p>
-        If you like key echo and you frequently type accented characters,
-        consider enabling both. <app>Cthulhu</app>'s character echo logic
-        attempts to filter out characters which were spoken as a result
-        of key echo, thus minimizing the likelihood of "double speaking"
-        as you type.
-      </p>
-    </note>
-  </section>
-  <section id="wordandsentenceecho">
-    <title>Enable echo by word and Enable echo by sentence</title>
-    <p>
-      Checking the <gui>Enable echo by word</gui> checkbox causes
-      <app>Cthulhu</app> to echo the word you just typed. Similarly,
-      checking the <gui>Enable echo by sentence</gui> checkbox causes
-      <app>Cthulhu</app> to echo the sentence you just typed.
-    </p>
-    <p>
-      Default value: not checked
-    </p>
-  </section>
-</page>
@@ -1,87 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" 
-      id="preferences_pronunciation">
-  <info>
-    <link type="guide" xref="preferences#cthulhu" />
-    <link type="next" xref="preferences_text_attributes" />
-    <title type="sort">7. Pronunciation</title>
-    <title type="link">Pronunciation</title>
-    <desc>
-      Defining how specific words get pronounced
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Pronunciation Preferences</title>
-  <p>
-    Sometimes your speech synthesizer just doesn't say the right thing
-    for a given string. You might prefer to hear "laughing out loud"
-    rather than "LOL," or "accessibility" rather than "a11y". Or there
-    may be a name or a technical term which the synthesizer mispronounces.
-  </p>
-  <p>
-     The <gui>Pronunciation</gui> page of the <app>Cthulhu</app> preferences
-     dialog allows you to add, edit, and delete entries in <app>Cthulhu</app>'s
-     pronunciation dictionary.
-  </p>
-  <p>
-    Because the <gui>Pronunciation</gui> page is also part of the
-    application-specific settings, you can customize your entries on an
-    as-needed basis for each application you use.
-  </p>
-  <steps>
-    <title>Adding a new dictionary entry</title>
-    <item>
-      <p>
-        Press the <gui>New Entry</gui> button (<keyseq><key>Alt</key><key>N</key></keyseq>)
-      </p>
-    </item>
-    <item>
-      <p>
-        Type the text of the new entry and press <key>Return</key> to finish
-        editing the actual string.
-      </p>
-    </item>
-    <item>
-      <p>
-        Move to the <gui>Replacement String</gui> column and press <key>Return
-        </key> to begin editing.
-      </p>
-    </item>
-    <item>
-      <p>
-        Type the text that you would like to have spoken instead and press <key>
-        Return</key> to finish editing the replacement string.
-      </p>
-    </item>
-  </steps>
-  <steps>
-  <title>Editing an existing dictionary entry</title>
-    <item>
-      <p>
-        Move to the cell you wish to edit and press <key>Return</key> to begin
-        editing.
-      </p>
-    </item>
-    <item>
-      <p>
-        Make your changes and then press <key>Return</key> to finish editing.
-      </p>
-    </item>
-  </steps>
-  <steps>
-    <title>Deleting an existing dictionary entry</title>
-    <item>
-      <p>Move to the entry you wish to delete.</p>
-    </item>
-    <item>
-      <p>
-        Press the <gui>Delete</gui> button or <keyseq><key>Alt</key><key>D</key></keyseq>.
-      </p>
-    </item>
-  </steps>
-</page>
@@ -1,348 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="preferences_speech">
-  <info>
-    <link type="guide" xref="preferences#cthulhu" />
-    <link type="next" xref="preferences_braille" />
-    <title type="sort">2.1 Speech</title>
-    <title type="link">Speech</title>
-    <desc>
-      Configuring what gets spoken
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Speech Preferences</title>
-  <section id="enable_speech">
-    <title>Enable speech</title>
-    <p>
-      The <gui>Enable speech</gui> check box controls whether or not
-      <app>Cthulhu</app> will make use of a speech synthesizer.
-      Braille-only users will likely want to uncheck this checkbox.
-    </p>
-    <p>
-      Default value: checked
-    </p>
-  </section>
-  <section id="verbosity">
-    <title>Verbosity</title>
-    <p>
-      The <gui>Verbosity</gui> setting determines the amount of information
-      that will be spoken in various situations. For example, if it is set
-      to verbose, and you arrow into a word that is misspelled, <app>Cthulhu</app>
-      will announce that the word is misspelled. When the level is set to brief,
-      this announcement will not be made.
-    </p>
-    <p>
-      Default value: <gui>Verbose</gui>
-    </p>
-  </section>
-  <section id="punctuation_level">
-    <title>Punctuation Level</title>
-    <p>
-      The <gui>Punctuation Level</gui> radio button group is used to
-      adjust the amount of punctuation spoken by the synthesizer. The
-      available levels are <gui>None</gui>, <gui>Some</gui>, <gui>Most</gui>,
-      and <gui>All</gui>.
-    </p>
-    <p>
-      Default value: <gui>Most</gui>
-    </p>
-    <section id="punctuation_level_none">
-      <title>None</title>
-      <p>
-        Choosing a punctuation level of <gui>None</gui> would, as you expect,
-        cause no punctuation to be spoken. Note, however, that special symbols
-        such as subscripted and superscripted numbers, Unicode fractions, and
-        bullets are still spoken at this level, even though some might consider
-        these types of symbols punctuation.
-      </p>
-    </section>
-    <section id="punctuation_level_some">
-      <title>Some</title>
-      <p>
-        Choosing a punctuation level of <gui>Some</gui> causes all of the
-        previously-mentioned symbols to be spoken. In addition, <app>Cthulhu</app>
-        will speak known mathematical symbols, currency symbols, and "^", "@",
-        "/", "&amp;", "#".
-      </p>
-    </section>
-    <section id="punctuation_level_most">
-      <title>Most</title>
-      <p>
-        Choosing a punctuation level of <gui>Most</gui> causes all of the
-        previous-mentioned symbols to be spoken. In addition, <app>Cthulhu</app>
-        will speak all other known punctuation symbols <em>other than</em> "!",
-        "'", ",", ".", "?".
-      </p>
-    </section>
-    <section id="punctuation_level_all">
-      <title>All</title>
-      <p>
-        Choosing a punctuation level of <gui>All</gui>, as expected, causes
-        <app>Cthulhu</app> to speak all known punctuation symbols.
-      </p>
-    </section>
-  </section>
-  <section id="spoken_context">
-    <title>Spoken Context</title>
-    <p>
-      The following items control the presentation of a variety of
-      supplemental, "system" information about the item with focus.
-      Because the associated text does not appear on screen, this
-      information is presented in <app>Cthulhu</app>'s System voice.
-    </p>
-    <section id="only_speak_displayed_text">
-      <title>Only speak displayed text</title>
-      <p>
-        Checking this checkbox causes <app>Cthulhu</app> to only speak actual
-        text displayed on screen. This option is intended primarily for low
-        vision users and users with a visual learning disability.
-      </p>
-      <p>
-        Default value: not checked
-      </p>
-      <note style="note">
-        <p>
-          The following items will not be available for configuration if
-          the <gui>Only speak displayed text</gui> checkbox is checked.
-        </p>
-      </note>
-    </section>
-    <section id="speak_blank_lines">
-      <title>Speak blank lines</title>
-      <p>
-        If the <gui>Speak blank lines</gui> checkbox is checked,
-        <app>Cthulhu</app> will say "blank" each time you arrow to a blank
-        line. If it is unchecked, <app>Cthulhu</app> will say nothing when
-        you move to a blank line.
-      </p>
-      <p>
-        Default value: checked
-      </p>
-    </section>
-    <section id="indentation_and_justification">
-      <title>Speak indentation and justification</title>
-      <p>
-        When working with code or editing other documents it is often
-        desirable to be aware of justification and indentation. Checking
-        the <gui>Speak indentation and justification</gui> checkbox will
-        cause <app>Cthulhu</app> to announce this information.
-      </p>
-      <p>
-        Default value: not checked
-      </p>
-    </section>
-    <section id="speak_misspelled_word_indicator">
-      <title>Speak misspelled-word indicator</title>
-      <p>
-        The misspelled-word indicator is the red squiggly line that appears
-        underneath misspelled words in editable text fields. If <gui>Speak
-        misspelled-word indicator</gui> is checked, when you navigate into
-        a word with this indicator, or type a word incorrectly causing this
-        indicator to appear, <app>Cthulhu</app> will speak "misspelled."
-      </p>
-      <p>
-        Default value: checked
-      </p>
-    </section>
-    <section id="mnemonics">
-     <title>Speak object mnemonics</title>
-      <p>
-        If the <gui>Speak object mnemonics</gui> checkbox is checked,
-        <app>Cthulhu</app> will announce the mnemonic associated with the
-        object with focus (such as <keyseq><key>Alt</key><key>O</key>
-        </keyseq> for an <gui>OK</gui> button).
-      </p>
-      <p>
-        Default value: not checked
-      </p>
-    </section>
-    <section id="child_position">
-      <title>Speak child position</title>
-      <p>
-        Checking the <gui>Speak child position</gui> checkbox will cause
-        <app>Cthulhu</app> to announce the position of the focused item in
-        menus, lists, and trees (e.g. "9 of 16").
-      </p>
-      <p>
-        Default value: not checked
-      </p>
-    </section>
-    <section id="speak_tutorial_messages">
-      <title>Speak tutorial messages</title>
-      <p>
-        If the <gui>Speak tutorial messages</gui> checkbox is checked, as
-        you move amongst objects in an interface, <app>Cthulhu</app> will
-        provide additional information, such as how to interact with the
-        currently-focused object.
-      </p>
-      <p>
-        Default value: not checked
-      </p>
-    </section>
-    <section id="speak_description">
-      <title>Speak description</title>
-      <p>
-        If the <gui>Speak description</gui> checkbox is checked, as
-        you move amongst objects in an interface, <app>Cthulhu</app> will
-        speak the accessible description in addition to the accessible
-        name of the object.
-      </p>
-      <p>
-        Default value: checked
-      </p>
-    </section>
-    <section id="system_messages_are_detailed">
-      <title>System messages are detailed</title>
-      <p>
-        If <gui>System messages are detailed</gui> is checked, <app>Cthulhu</app> will
-        present detailed messages to you in speech. For instance, if you use
-        <app>Cthulhu</app>'s command to change echo, <app>Cthulhu</app> might
-        speak "Echo set to word." If you would prefer shorter messages,
-        such as simply "word," you should uncheck this checkbox.
-      </p>
-      <p>
-        Default value: checked
-      </p>
-    </section>
-    <section id="speak_colors_as_names">
-      <title>Speak colors as names</title>
-      <p>
-        If <gui>Speak colors as names</gui> is checked, <app>Cthulhu</app> will
-        describe colors, looking for the closest approximate. For instance,
-        RGB 0, 27, 51 would be spoken as "midnight blue." If you would prefer
-        to hear the exact RGB value, you should uncheck this checkbox.
-      </p>
-      <p>
-        Default value: checked
-      </p>
-    </section>
-    <section id="announce_blockquotes_during_navigation">
-      <title>Announce blockquotes during navigation</title>
-      <p>
-        If <gui>Announce blockquotes during navigation</gui> is checked,
-        <app>Cthulhu</app> will tell you when you navigate into or out of a
-        blockquote. Note that this setting is independent of whether or not
-        this announcement is made during Say All. See
-        <link xref="preferences_general#say_all_announce_context">Announce
-        Contextual Information in Say All</link> for more information.
-      </p>
-      <p>
-        Default value: checked
-      </p>
-    </section>
-    <section id="announce_forms_during_navigation">
-      <title>Announce forms during navigation</title>
-      <p>
-        If <gui>Announce forms during navigation</gui> is checked,
-        <app>Cthulhu</app> will tell you when you navigate into or out of a
-        form. Note that this setting is specific to forms which are not
-        ARIA landmarks. You can configure the presentation of ARIA landmarks
-        through the <gui>Announce landmarks during navigation</gui> checkbox.
-        In addition, note that this setting is independent of whether or not
-        this announcement is made during Say All. See
-        <link xref="preferences_general#say_all_announce_context">Announce
-        Contextual Information in Say All</link> for more information.
-      </p>
-      <p>
-        Default value: checked
-      </p>
-    </section>
-    <section id="announce_landmarks_during_navigation">
-      <title>Announce landmarks during navigation</title>
-      <p>
-        If <gui>Announce landmarks during navigation</gui> is checked,
-        <app>Cthulhu</app> will tell you when you navigate into or out of an
-        ARIA landmark. Note that this setting is independent of whether or not
-        this announcement is made during Say All. See
-        <link xref="preferences_general#say_all_announce_context">Announce
-        Contextual Information in Say All</link> for more information.
-      </p>
-      <p>
-        Default value: checked
-      </p>
-    </section>
-    <section id="announce_lists_during_navigation">
-      <title>Announce lists during navigation</title>
-      <p>
-        If <gui>Announce lists during navigation</gui> is checked,
-        <app>Cthulhu</app> will tell you when you navigate into or out of a
-        list. Note that this setting is independent of whether or not
-        this announcement is made during Say All. See
-        <link xref="preferences_general#say_all_announce_context">Announce
-        Contextual Information in Say All</link> for more information.
-      </p>
-      <p>
-        Default value: checked
-      </p>
-    </section>
-    <section id="announce_panels_during_navigation">
-      <title>Announce panels during navigation</title>
-      <p>
-        If <gui>Announce panels during navigation</gui> is checked,
-        <app>Cthulhu</app> will tell you when you navigate into or out of a
-        panel. Note that this setting is independent of whether or not
-        this announcement is made during Say All. See
-        <link xref="preferences_general#say_all_announce_context">Announce
-        Contextual Information in Say All</link> for more information.
-      </p>
-      <p>
-        Default value: checked
-      </p>
-    </section>
-    <section id="announce_tables_during_navigation">
-      <title>Announce tables during navigation</title>
-      <p>
-        If <gui>Announce tables during navigation</gui> is checked,
-        <app>Cthulhu</app> will tell you when you navigate into or out of a
-        table. Note that this setting is independent of whether or not
-        this announcement is made during Say All. See
-        <link xref="preferences_general#say_all_announce_context">Announce
-        Contextual Information in Say All</link> for more information.
-      </p>
-      <p>
-        Default value: checked
-      </p>
-    </section>
-    <section id="speak_full_row_in_gui_tables">
-      <title>Speak full row in GUI tables</title>
-      <p>
-        If <gui>Speak full row in GUI tables</gui> is checked, as you arrow up
-        and down in application tables such as the list of messages in your
-        Inbox, <app>Cthulhu</app> will speak the entire row. If you would prefer
-        to hear only the cell with focus, you should uncheck this checkbox.
-      </p>
-      <p>
-        Default value: checked
-      </p>
-    </section>
-    <section id="speak_full_row_in_document_tables">
-      <title>Speak full row in document tables</title>
-      <p>
-        If <gui>Speak full row in document tables</gui> is checked, as you arrow
-        up and down in tables such as those found in <app>Writer</app> and web
-        documents, <app>Cthulhu</app> will speak the entire row. If you would prefer
-        to hear only the cell with focus, you should uncheck this checkbox.
-      </p>
-      <p>
-        Default value: checked
-      </p>
-    </section>
-    <section id="speak_full_row_in_spreadsheets">
-      <title>Speak full row in spreadsheets</title>
-      <p>
-        If <gui>Speak full row in spreadsheets</gui> is checked, as you arrow
-        up and down in spreadsheets, <app>Cthulhu</app> will speak the entire
-        row. If you would prefer to hear only the cell with focus, you should
-        uncheck this checkbox.
-      </p>
-      <p>
-        Default value: not checked
-      </p>
-    </section>
-  </section>
-</page>
@@ -1,65 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="preferences_spellcheck">
-  <info>
-    <link type="guide" xref="preferences#application" />
-    <title type="sort">4. Spell Check</title>
-    <title type="link">Spell Check</title>
-    <desc>
-      Configuring <app>Cthulhu</app>'s support for Spell Check
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Spell Check Preferences</title>
-  <p>
-    <app>Cthulhu</app> tries to provide a consistent user experience when interacting
-     with application spell checkers. For applications where this enhanced support
-     has been provided, you will find several options which you can adjust to get
-     the verbosity level that works best for you.
-  </p>
-  <note style="tip">
-    <title>You can have both brief and verbose spell check information</title>
-    <p>
-      If you normally want very little verbosity when using a spell checker,
-      but occasionally need detailed information about a given error, you can
-      disable these options. When you need additional details, just use
-      <app>Cthulhu</app>'s detailed <link xref="howto_whereami">Where Am I</link>
-      command to have <app>Cthulhu</app> present the current error as if all of these
-      options were enabled.
-    </p>
-  </note>
-  <section id="spell_error">
-    <title>Spell error</title>
-    <p>
-      If this checkbox is checked, <app>Cthulhu</app> will spell out the misspelled
-      word after speaking it.
-    </p>
-    <p>
-       Default value: checked
-    </p>
-  </section>
-  <section id="spell_suggestion">
-    <title>Spell suggestion</title>
-    <p>
-      If this checkbox is checked, <app>Cthulhu</app> will spell out the suggested
-      correction after speaking it.
-    </p>
-    <p>
-       Default value: checked
-    </p>
-  </section>
-  <section id="error_context">
-    <title>Present context of error</title>
-    <p>
-      If this checkbox is checked, <app>Cthulhu</app> will speak the sentence or
-      line from the document in which the error is found.
-    </p>
-    <p>
-       Default value: checked
-    </p>
-  </section>
-</page>
@@ -1,69 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" 
-      id="preferences_table_navigation">
-  <info>
-    <link type="guide" xref="preferences#application" />
-    <link type="next" xref="preferences_chat" />
-    <link type="seealso" xref="commands_structural_navigation" />
-    <link type="seealso" xref="commands_table" />
-    <title type="sort">2. Table Navigation</title>
-    <title type="link">Table Navigation</title>
-    <desc>
-      Configuring <app>Cthulhu</app>'s navigation within tables
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Table Navigation Preferences</title>
-  <p>
-    The following options allow you to customize how <app>Cthulhu</app>
-    behaves when navigating within a table in
-    <link xref="howto_structural_navigation">Structural-Navigation</link>-enabled
-    applications.
-  </p>
-  <section id="speak_cell_coordinates">
-    <title>Speak cell coordinates</title>
-    <p>
-      If this checkbox is checked, <app>Cthulhu</app> will announce the coordinates
-      of each cell you navigate to.
-    </p>
-    <p>
-       Default value: checked
-    </p>
-  </section>
-  <section id="speak_multiple_cell_spans">
-    <title>Speak multiple cell spans</title>
-    <p>
-      If this checkbox is checked, <app>Cthulhu</app> will announce how many rows
-      and/or columns a cell spans when it spans more than one.
-    </p>
-    <p>
-       Default value: checked
-    </p>
-  </section>
-  <section id="announce_cell_header">
-    <title>Announce cell header</title>
-    <p>
-      If this checkbox is checked, <app>Cthulhu</app> will announce changes in the
-      header if the headers for the current cell can be determined.
-    </p>
-    <p>
-       Default value: checked
-    </p>
-  </section>
-  <section id="skip_blank_cells">
-    <title>Skip blank cells</title>
-    <p>
-      If this checkbox is checked, <app>Cthulhu</app> will skip blank cells when
-      you are using <app>Cthulhu</app>'s table structural navigation commands to
-      access the table.
-    </p>
-    <p>
-       Default value: not checked
-    </p>
-  </section>
-</page>
@@ -1,139 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" 
-      id="preferences_text_attributes">
-  <info>
-    <link type="guide" xref="preferences#cthulhu" />
-    <link type="next" xref="preferences_web" />
-    <link type="seealso" xref="howto_text_attributes" />
-    <title type="sort">8. Text Attributes</title>
-    <title type="link">Text Attributes</title>
-    <desc>
-      Configuring what formatting is presented
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Text Attributes Preferences</title>
-  <p>
-    The term "text attributes" refers to all of the font, style, alignment,
-    and other formatting associated with a given character or series of
-    characters. <app>Cthulhu</app>'s <gui>Text Attributes</gui> page allows you
-    to customize which text attributes <app>Cthulhu</app> will present in speech,
-    along with the order in which they should be presented, and which ones
-    <app>Cthulhu</app> will indicate in braille.
-  </p>
-  <section id="table">
-    <title>The text attributes table</title>
-    <p>
-      The text attributes table is where you specify what attributes will
-      and will not be presented and under what conditions. Each row consists
-      of four columns.
-    </p>
-    <list>
-      <item>
-        <p>
-          <gui>Attribute Name</gui>: The name of the text attribute.
-        </p>
-      </item>
-      <item>
-        <p>
-          <gui>Speak</gui>: Check this checkbox if you would like
-          <app>Cthulhu</app> to speak this attribute when you press
-          <keyseq><key>Cthulhu Modifier</key><key>F</key></keyseq>.
-        </p>
-      </item>
-      <item>
-        <p>
-          <gui>Mark in braille</gui>: Check this checkbox if you would
-          like <app>Cthulhu</app> to "underline" this attribute on your
-          braille display.
-        </p>
-      </item>
-      <item>
-        <p>
-          <gui>Present Unless</gui>: This editable field allows you to
-          specify when an enabled attribute is not of interest.
-        </p>
-        <p>
-          For example, by default the "underline" text attribute has a
-          value of "none". This causes <app>Cthulhu</app> to inform you
-          about underlined text as long as the text is actually underlined.
-          If you always want this attribute to be spoken irrespective of
-          whether or not the text is underlined, the <gui>Present unless</gui>
-          column should be empty for underline. In addition, you should be sure
-          that the <gui>Speak</gui> column for underline is checked.
-        </p>
-      </item>
-    </list>
-  </section>
-  <section id="reset">
-     <title>Undoing changes</title>
-     <p>
-       Beneath the list of text attributes, there is a <gui>Reset</gui> button
-       (<keyseq><key>Alt</key><key>R</key></keyseq>) which will restore
-       the values of the table to what they were when the dialog was
-       first displayed.
-    </p>
-  </section>
-  <section id="rearranging">
-     <title>Rearranging the order of presentation</title>
-     <p>
-        When you initially display the <gui>Text Attributes</gui> page, all of your enabled
-        attributes are placed at the top of the table in the order in which they
-        will be spoken. There are four buttons which can be used to rearrange
-        the order of presentation.
-    </p>
-    <list>
-      <item>
-        <p>
-          <gui>Move to top</gui> (<keyseq><key>Alt</key><key>T</key></keyseq>):
-          moves the selected attribute to the top of the list.
-        </p>
-      </item>
-      <item>
-        <p>
-          <gui>Move up</gui> (<keyseq><key>Alt</key><key>U</key></keyseq>):
-          moves the selected attribute up one row.
-        </p>
-      </item>
-      <item>
-        <p>
-          <gui>Move down</gui> (<keyseq><key>Alt</key><key>D</key></keyseq>):
-          moves the selected attribute down one row.
-        </p>
-      </item>
-      <item>
-        <p>
-          <gui>Move to bottom</gui> (<keyseq><key>Alt</key><key>B</key></keyseq>):
-          moves the selected attribute to the bottom of the list.
-        </p>
-      </item>
-    </list>
-  </section>
-  <section id="braille_indicator">
-    <title>Options for Configuring Braille "Underlining" for Formatting</title>
-    <p>
-        Beneath the push buttons is the <gui>Braille Indicator</gui> group
-        of radio buttons. Here you can select the cell or cells to be used
-        to indicate text which has at least one of the specified attributes.
-    </p>
-    <list>
-      <item>
-        <p><gui>None</gui>: Do not underline text attributes in braille (the default)</p>
-      </item>
-      <item>
-        <p><gui>Dot 7</gui>: Underline text attributes with only Dot 7</p>
-      </item>
-      <item>
-        <p><gui>Dot 8</gui>: Underline text attributes with only Dot 8</p>
-      </item>
-      <item>
-        <p><gui>Dots 7 and 8</gui>: Underline text attributes with both Dots 7 and Dots 8</p>
-      </item>
-    </list>
-  </section>
-</page>
@@ -1,138 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="preferences_voice">
-  <info>
-    <link type="guide" xref="preferences#cthulhu" />
-    <link type="next" xref="preferences_speech" />
-    <title type="sort">2.0 Voice</title>
-    <title type="link">Voice</title>
-    <desc>
-      Configuring the voice used by <app>Cthulhu</app>
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Voice Preferences</title>
-  <section id="voice_type_settings">
-    <title>Voice Type Settings</title>
-    <section id="voice_type">
-      <title>Voice type</title>
-      <p>
-        This combo box makes it possible for you to use different voices so that
-        you can better distinguish uppercase and linked text from other text,
-        and on-screen text from text added by <app>Cthulhu</app>.
-      </p>
-      <note style="tip">
-        <title>Configuring Multiple Voices</title>
-        <p>
-          For each voice you wish to configure, first select the
-          voice in the <gui>Voice type</gui> combo box. Then
-          configure the person, rate, pitch, and volume to be used
-          for that voice.
-        </p>
-      </note>
-    </section>
-    <section id="speech_system">
-      <title>Speech system</title>
-      <p>
-        This combo box allows you to select your preferred speech system from
-        those you have installed, such as Speech Dispatcher.
-      </p>
-    </section>
-    <section id="speech_synthesizer">
-      <title>Speech synthesizer</title>
-      <p>
-        This combo box allows you to select the speech synthesizer to be used
-        with your chosen Speech system.
-      </p>
-    </section>
-    <section id="person">
-      <title>Person</title>
-      <p>
-        This combo box allows you to choose which "person" or "speaker" should
-        be used with the selected voice. For instance, you might wish to have
-        David speak by default, but have hyperlinks spoken by Alice. Note that
-        what you find in the <gui>Person</gui> combo box will depend on which
-        speech synthesizers you have installed.
-      </p>
-    </section>
-    <section id="capitalization_style">
-      <title>Capitalization style</title>
-      <p>
-       This combo box allows you to choose which Speech Dispatcher capitalization
-       indication styles you wish to use in addition to <app>Cthulhu</app>'s
-       capitalization voice. The options, which are named using Speech Dispatcher's
-       terminology, are:
-     </p>
-     <list>
-       <item><p><gui>Icon</gui>: Plays a tone</p></item>
-       <item><p><gui>Spell</gui>: Speaks the word "capital"</p></item>
-       <item><p><gui>None</gui></p></item>
-    </list>
-    <note style="tip">
-      <title>This setting can be toggled on the fly</title>
-      <p>
-        <app>Cthulhu</app> also has a command to cycle through the available
-        capitalization styles. See <link xref="commands_speech_settings">
-        Speech Settings Commands</link> for more information.
-      </p>
-    </note>
-    <p>
-      Default value: none
-    </p>
-    </section>
-    <section id="rate_pitch_and_volume">
-      <title>Rate, Pitch, and Volume</title>
-      <p>
-        These three left-right sliders allow you to further customize the sound
-        of the person you have just selected.
-      </p>
-    </section>
-  </section>
-  <section id="global_voice_settings">
-  <title>Global Voice Settings</title>
-    <section id="pauses">
-      <title>Break speech into chunks between pauses</title>
-      <p>
-        Depending on the enabled speech settings, <app>Cthulhu</app> may have quite
-        a bit to say about a particular object such as its name, its role, its
-        state, its mnemonic, its tutorial message, and so on. Checking the
-        <gui>Break speech into chunks between pauses</gui> checkbox will cause
-        <app>Cthulhu</app> to insert brief pauses in between each of these pieces
-        of information.
-      </p>
-      <p>
-        Default value: checked
-      </p>
-    </section>
-    <section id="multicase_strings">
-      <title>Speak multicase strings as words</title>
-      <p>
-        In some text, and especially when working with code, one often comes
-        across a "word" consisting of several words with alternating case, such
-        as "MultiCaseString." Speech synthesizers do not always pronounce such
-        multicase strings correctly. Checking the <gui>Speak multicase strings
-        as words</gui> checkbox will cause <app>Cthulhu</app> to break a word like
-        "MultiCaseString" into separate words ("Multi," "Case," and "String")
-        prior to passing it along to the speech synthesizer.
-      </p>
-      <p>
-        Default value: not checked
-      </p>
-    </section>
-    <section id="numbers_as_digits">
-      <title>Speak numbers as digits</title>
-      <p>
-        Checking the <gui>Speak numbers as digits</gui> checkbox will cause
-        <app>Cthulhu</app> to break a number like "123" into separate digits
-        ("1," "2," and "3") prior to passing it along to the speech synthesizer.
-      </p>
-      <p>
-        Default value: not checked
-      </p>
-    </section>
-  </section>
-</page>
@@ -1,223 +0,0 @@
-<page xmlns="http://projectmallard.org/1.0/" type="topic" id="preferences_web">
-  <info>
-    <link type="guide" xref="preferences#application" />
-    <link type="next" xref="preferences_table_navigation" />
-    <title type="sort">1. Web Navigation</title>
-    <title type="link">Web Navigation</title>
-    <desc>
-      Configuring <app>Cthulhu</app>'s support for <app>Firefox</app>,
-      <app>Thunderbird</app>, and <app>Chrome</app>/<app>Chromium</app>
-    </desc>
-    <credit type="author">
-      <name>Joanmarie Diggs</name>
-      <email>joanied@gnome.org</email>
-    </credit>
-    <license>
-      <p>Creative Commons Share Alike 3.0</p>
-    </license>
-  </info>
-  <title>Web Navigation Preferences</title>
-  <section id="page_navigation">
-    <title>Page Navigation</title>
-    <p>
-      The <gui>Page Navigation</gui> group of controls make it possible for you
-      to customize how <app>Cthulhu</app> presents, and allow you to interact with,
-      text and other content.
-    </p>
-    <section id="page_navigation_control_caret">
-      <title>Control caret navigation</title>
-      <p>
-        This checkbox toggles <app>Cthulhu</app>'s caret navigation on and off.
-        When it is on, <app>Cthulhu</app> takes control of the caret as you arrow
-        around within a page; when it is off, the browser's native caret navigation is
-        active.
-      </p>
-      <p>
-        Default value: checked
-      </p>
-      <note style="tip">
-        <title>This setting can be toggled on the fly</title>
-        <p>
-          To toggle this setting on the fly without saving it, use
-          <keyseq><key>Cthulhu Modifier</key><key>F12</key></keyseq>.
-        </p>
-       </note>
-    </section>
-    <section id="page_navigation_focus_caret">
-      <title>Automatic focus mode during caret navigation</title>
-      <p>
-        If this checkbox is checked, <app>Cthulhu</app> will automatically turn on
-        focus mode when you use caret navigation commands to navigate to a form
-        field. For example, pressing <key>Down</key> would allow you to move
-        into an entry but once you had done so, Cthulhu would switch to focus mode
-        and subsequent presses of <key>Down</key> would be controlled by the web
-        browser and not by Cthulhu. If this checkbox is not checked, <app>Cthulhu</app>
-        would continue to control what happens when you press <key>Down</key>,
-        thus making it possible to arrow out of the entry and continue reading.
-      </p>
-      <p>
-        Default value: not checked
-      </p>
-      <note style="tip">
-        <title>Manually switching between browse mode and focus mode</title>
-        <p>
-          In order to start or stop interacting with the focused form field,
-          use <keyseq><key>Cthulhu Modifier</key><key>A</key></keyseq> to switch
-          between browse mode and focus mode.
-        </p>
-       </note>
-    </section>
-    <section id="page_navigation_structural">
-      <title>Enable structural navigation</title>
-      <p>
-        This checkbox toggles <app>Cthulhu</app>'s
-        <link xref="howto_structural_navigation">Structural Navigation</link>
-        on and off. Structural Navigation allows you to navigate by elements
-        such as headings, links, and form fields.
-      </p>
-      <p>
-        Default value: checked
-      </p>
-      <note style="tip">
-        <title>This setting can be toggled on the fly</title>
-        <p>
-          To toggle this setting on the fly without saving it, use
-          <keyseq><key>Cthulhu Modifier</key><key>Z</key></keyseq>.
-        </p>
-       </note>
-    </section>
-    <section id="page_navigation_focus_structural">
-      <title>Automatic focus mode during structural navigation</title>
-      <p>
-        If this checkbox is checked, <app>Cthulhu</app> will automatically turn on
-        focus mode when you use structural navigation commands to navigate to a
-        form field. For example, pressing <key>E</key> to move to the next entry
-        would move focus there and also turn focus mode on so that your next press
-        of <key>E</key> would type an "e" into that entry. If this checkbox is not
-        checked, then <app>Cthulhu</app> will leave you in browse mode and your next
-        press of <key>E</key> would move you to the next entry on the page.
-      </p>
-      <p>
-        Default value: not checked
-      </p>
-      <note style="tip">
-        <title>Manually switching between browse mode and focus mode</title>
-        <p>
-          In order to start or stop interacting with the focused form field,
-          use <keyseq><key>Cthulhu Modifier</key><key>A</key></keyseq> to switch
-          between browse mode and focus mode.
-        </p>
-       </note>
-    </section>
-    <section id="page_navigation_focus_native">
-      <title>Automatic focus mode during native navigation</title>
-      <p>
-        If this checkbox is checked, <app>Cthulhu</app> will automatically turn on
-        focus mode when you use native browser navigation commands to navigate to a
-        form field. For example, pressing <key>Tab</key> to move to the next entry
-        would move focus there and also turn focus mode on so that your next press
-        of <key>E</key> would type an "e" into that entry. If this checkbox is not
-        checked, then <app>Cthulhu</app> will leave you in browse mode and your next
-        press of <key>E</key> would move you to the next entry on the page.
-      </p>
-      <p>
-        Default value: checked
-      </p>
-      <note style="tip">
-        <title>Manually switching between browse mode and focus mode</title>
-        <p>
-          In order to start or stop interacting with the focused form field,
-          use <keyseq><key>Cthulhu Modifier</key><key>A</key></keyseq> to switch
-          between browse mode and focus mode.
-        </p>
-       </note>
-    </section>
-    <section id="page_navigation_speak">
-      <title>Automatically start speaking a page when it is first loaded</title>
-      <p>
-        If this checkbox is checked, <app>Cthulhu</app> will perform a Say All on
-        the newly opened web page or email.
-      </p>
-      <p>
-        Default value: checked for Firefox; not checked for Thunderbird
-      </p>
-    </section>
-    <section id="page_navigation_summary">
-      <title>Present summary of a page when it is first loaded</title>
-      <p>
-        If this checkbox is checked, <app>Cthulhu</app> will summarize details about the
-        newly opened web page or email, such as the number of headings, landmarks,
-        and links.
-      </p>
-      <p>
-        Default value: checked for Firefox; not checked for Thunderbird
-      </p>
-    </section>
-    <section id="page_navigation_layout_mode">
-      <title>Enable layout mode for content</title>
-      <p>
-        If this checkbox is checked, <app>Cthulhu</app>'s caret navigation will respect
-        the on-screen layout of the content and present the full line, including any
-        links or form fields on that line. If this checkbox is not checked, <app>Cthulhu</app>
-        will treat objects such as links and form fields as if they were on separate
-        lines, both for presentation and navigation.
-      </p>
-      <p>
-        Default value: checked
-      </p>
-    </section>
-  </section>
-  <section id="table_options">
-    <title>Table Options</title>
-    <note>
-      <p>
-        To learn more about <app>Cthulhu</app>'s options for navigating within
-        tables, please see <link xref="preferences_table_navigation">Table
-	Navigation Preferences</link>.
-      </p>
-    </note>
-  </section>
-  <section id="find_options">
-    <title>Find Options</title>
-    <p>
-      The <gui>Find Options</gui> group of controls make it possible for you to
-      customize how <app>Cthulhu</app> presents the results of a search conducted
-      using the application's built-in search functionality.
-    </p>
-    <section id="find_options_speak_during_find">
-      <title>Speak results during find</title>
-      <p>
-         If this checkbox is checked, <app>Cthulhu</app> will read the line which
-         matches your current search query.
-      </p>
-      <p>
-         Default value: checked
-      </p>
-    </section>
-    <section id="find_options_speak_changed_lines_during_find">
-      <title>Only speak changed lines during find</title>
-      <p>
-          If this checkbox is checked, <app>Cthulhu</app> will not present the
-          matching line if it is the same line as the previous match. This
-          option is designed to prevent "chattiness" on a line with multiple
-          instances of the string for which you are searching.
-      </p>
-      <p>
-         Default value: not checked
-      </p>
-    </section>
-    <section id="find_options_minimum_match_length">
-      <title>Minimum length of matched text</title>
-      <p>
-        This editable spin button is where you can specify the number of
-        characters which must match before <app>Cthulhu</app> announces the
-        matching line. This option is also designed to prevent "chattiness"
-        as there are many matches when you first begin typing the string
-        for which you are searching.
-      </p>
-      <p>
-        Default value: 4
-      </p>
-    </section>
-  </section>
-</page>
@@ -1,61 +0,0 @@
-@YELP_HELP_RULES@
-
-HELP_ID = cthulhu
-HELP_MEDIA = \
-	figures/cthulhu-logo.png
-
-HELP_FILES = \
-	commands_bookmarks.page \
-	commands_braille.page \
-	commands_chat.page \
-	commands_controlling_cthulhu.page \
-	commands_debugging.page \
-	commands_find.page \
-	commands_flat_review.page \
-	commands_live_regions.page \
-	commands_mouse.page \
-	commands.page \
-	commands_profiles.page \
-	commands_reading.page \
-	commands_speech_settings.page \
-	commands_structural_navigation.page \
-	commands_table.page \
-	commands_time_date_notifications.page \
-	commands_where_am_i.page \
-	howto_bookmarks.page \
-	howto_documents.page \
-	howto_flat_review.page \
-	howto_forms.page \
-	howto_key_bindings.page \
-	howto_keyboard_layout.page \
-	howto_learn_modes.page \
-	howto_live_regions.page \
-	howto_mouse_review.page \
-	howto_notifications.page \
-	howto_cthulhu_find.page \
-	howto_profiles.page \
-	howto_setting_up_cthulhu.page \
-	howto_structural_navigation.page \
-	howto_tables.page \
-	howto_text_attributes.page \
-	howto_the_cthulhu_modifier.page \
-	howto_toggling_caps_lock.page \
-	howto_whereami.page \
-	index.page \
-	introduction.page \
-	preferences_braille.page \
-	preferences_chat.page \
-	preferences_web.page \
-	preferences_general.page \
-	preferences_introduction.page \
-	preferences_key_bindings.page \
-	preferences_key_echo.page \
-	preferences.page \
-	preferences_pronunciation.page \
-	preferences_speech.page \
-	preferences_spellcheck.page \
-	preferences_table_navigation.page \
-	preferences_text_attributes.page \
-	preferences_voice.page
-
-HELP_LINGUAS = bg cs da de el es fr gl hu id pt_BR ru sl sv uk
--- a/Show More
+++ b/Show More