more cross-linking
diff --git a/compiler/compiler-options.md b/compiler/compiler-options.md
index 160be97..6c1c8dc 100644
--- a/compiler/compiler-options.md
+++ b/compiler/compiler-options.md
@@ -26,7 +26,7 @@
The [**mxmlc** and **compc** compilers](compiler) bundled with [Apache Royale](https://royale.apache.org/) have a number of useful configuration options. The list below is also available by running `mxmlc -help advanced` in a terminal.
-- `-allow-dynamic-bindings` -- Controls whether data binding may use reflection for dynamic access.
+- `-allow-dynamic-bindings` -- Controls whether [data binding](features/data-binding) may use reflection for dynamic access.
- `-api-report` `<filename>` -- Used to generate a report of APIs used in a project.
- `-closure-lib` `<string>` -- Customize the version of Google Closure Library used by the framework.
- `-compiler.accessible` -- Controls whether accessibility is enabled for a generated _.swf_ file.
@@ -97,7 +97,7 @@
- `-compiler.report-missing-required-skin-parts-as-warnings`
- `-compiler.services` `<filename>`
- `-compiler.show-actionscript-warnings`
-- [`-compiler.show-binding-warnings`](compiler/compiler-options#show-binding-warnings)
+- [`-compiler.show-binding-warnings`](compiler/compiler-options#show-binding-warnings) -- Determines if [data binding](features/data-binding) warnings are displayed or not
- `-compiler.show-invalid-css-property-warnings`
- `-compiler.show-multiple-definition-warnings`
- `-compiler.show-shadowed-device-font-warnings`
@@ -955,7 +955,7 @@
### show-binding-warnings {#show-binding-warnings}
-Set to false to remove all binding warnings.
+Set to false to remove all [data binding](features/data-binding) warnings.
```sh
-show-binding-warnings=false
diff --git a/component-sets/jewel.md b/component-sets/jewel.md
index c777e53..1d90736 100644
--- a/component-sets/jewel.md
+++ b/component-sets/jewel.md
@@ -24,7 +24,7 @@
A set of modern UI components
-Jewel is a themeable and responsive set of user interface components for [Apache Royale](https://royale.apache.org/) to help you quickly build the front end of your applications with [ActionScript](features/as3) & [MXML](features/mxml).
+Jewel is a themeable and responsive set of [user interface](user-interface) components for [Apache Royale](https://royale.apache.org/) to help you quickly build the front end of your applications with [ActionScript](features/as3) & [MXML](features/mxml).
It's based by design on [Basic](component-sets/basic) components. But while Basic is very strict with concepts like [PAYG](features/payg), in Jewel, while PAYG is important, when necessary we prioritize other things like responsiveness, themes and look and feel.
diff --git a/component-sets/jewel/jewel-alert.md b/component-sets/jewel/jewel-alert.md
index 413d0ca..6ab9e18 100644
--- a/component-sets/jewel/jewel-alert.md
+++ b/component-sets/jewel/jewel-alert.md
@@ -36,7 +36,7 @@
## Overview
The `Alert` component displays a message and one or more buttons in a window that pops up over all other controls and views.
-It uses the `AlertView` bead to display a [modal dialog](https://en.wikipedia.org/wiki/Modal_window){:target='_blank'} with a title and a variety of buttons configured through the flag property of its `show` static function.
+It uses the `AlertView` [beads](features/strands-and-beads) to display a [modal dialog](https://en.wikipedia.org/wiki/Modal_window){:target='_blank'} with a title and a variety of buttons configured through the flag property of its `show` static function.
> `Alert` uses the HTML dialog element, which currently has very limited cross-browser support. To ensure support across all modern browsers, we use the dialogPolyfill [externs](features/externs).
diff --git a/component-sets/jewel/jewel-button.md b/component-sets/jewel/jewel-button.md
index 9d7a260..8653d38 100644
--- a/component-sets/jewel/jewel-button.md
+++ b/component-sets/jewel/jewel-button.md
@@ -122,7 +122,7 @@
## Relevant Beads
-Unlike other components in Royale, the Jewel `Button` does not have beads for _View_, _Controller_ or _Model_ in the JavaScript platform.
+Unlike other components in Royale, the Jewel `Button` does not have [beads](features/strands-and-beads) for _View_, _Controller_ or _Model_ in the JavaScript platform.
On the other hand, you can add to it other common Jewel control beads to provide more functionality. Many Jewel controls share these beads.
diff --git a/component-sets/jewel/jewel-checkbox.md b/component-sets/jewel/jewel-checkbox.md
index 0727c08..cb1b63f 100644
--- a/component-sets/jewel/jewel-checkbox.md
+++ b/component-sets/jewel/jewel-checkbox.md
@@ -116,7 +116,7 @@
## Relevant Beads
-Unlike other components in Royale, the Jewel `CheckBox` does not have beads for _View_, _Controller_ or _Model_ in the JavaScript platform.
+Unlike other components in Royale, the Jewel `CheckBox` does not have [beads](features/strands-and-beads) for _View_, _Controller_ or _Model_ in the JavaScript platform.
On the other hand, you can add to it other common Jewel control beads to provide more functionality. Many Jewel controls share these beads.
diff --git a/component-sets/mxroyale.md b/component-sets/mxroyale.md
index 5bbdc3f..de5d09d 100644
--- a/component-sets/mxroyale.md
+++ b/component-sets/mxroyale.md
@@ -58,5 +58,5 @@
When you browse the components in the SDK, you will encounter some that seem to have no functioning code. This is a _stub_. We have created it so we can get an app migrating from Flex to compile, creating a class of the same package name and class name as the Flex component but removing all of the code and leaving a TODO note
-The application including this stub can compile but the component does not do anything yet. The next task will be to add the minimal code the component needs to perform its most basic functions, and put optional and special-case functions into beads a developer can add to the component strand.
+The application including this stub can compile but the component does not do anything yet. The next task will be to add the minimal code the component needs to perform its most basic functions, and put optional and special-case functions into [beads](features/strands-and-beads) a developer can add to the component strand.
diff --git a/component-sets/sparkroyale.md b/component-sets/sparkroyale.md
index ab20e03..7ddab94 100644
--- a/component-sets/sparkroyale.md
+++ b/component-sets/sparkroyale.md
@@ -42,4 +42,4 @@
When you browse the components in the SDK, you will encounter some that seem to have no functioning code. This is a _stub_. We have created it so we can get an app migrating from Flex to compile, creating a class of the same package name and class name as the Flex component but removing all of the code and leaving a TODO note
-The application including this stub can compile but the component does not do anything yet. The next task will be to add the minimal code the component needs to perform its most basic functions, and put optional and special-case functions into beads a developer can add to the component strand.
+The application including this stub can compile but the component does not do anything yet. The next task will be to add the minimal code the component needs to perform its most basic functions, and put optional and special-case functions into [beads](features/strands-and-beads) a developer can add to the component strand.
diff --git a/create-an-application/application-tutorial/build.md b/create-an-application/application-tutorial/build.md
index de90892..539e879 100644
--- a/create-an-application/application-tutorial/build.md
+++ b/create-an-application/application-tutorial/build.md
@@ -24,7 +24,7 @@
Building the application
-In many other *HTML/JS/CSS* development models, you write the *JS* and then just view it in the browser. [Apache Royale](https://royale.apache.org/) uses a compiler to convert your *MXML* and *ActionScript* code into *HTML/JS/CSS*. Why? Because there is a philosophy that the sooner you catch a bug, the less expensive it is to fix it. The compiler scans your source code to make sure that it makes sense. The compiler checks that there aren't typos in property names, that if you are expecting a `String` you'll probably get one, and more.
+In many other *HTML/JS/CSS* development models, you write the *JS* and then just view it in the browser. [Apache Royale](https://royale.apache.org/) uses a compiler to convert your [*MXML*](features/mxml) and [*ActionScript*](features/as3) code into *HTML/JS/CSS*. Why? Because there is a philosophy that the sooner you catch a bug, the less expensive it is to fix it. The compiler scans your source code to make sure that it makes sense. The compiler checks that there aren't typos in property names, that if you are expecting a `String` you'll probably get one, and more.
The main *MXML* file should now look like this:
diff --git a/create-an-application/application-tutorial/data-model.md b/create-an-application/application-tutorial/data-model.md
index 256d470..ab40d91 100644
--- a/create-an-application/application-tutorial/data-model.md
+++ b/create-an-application/application-tutorial/data-model.md
@@ -24,7 +24,7 @@
Abstract model that organizes elements of data for easy use in the application
-Since the goal of this application is to display a list of commits to the [Apache Royale](https://royale.apache.org/) GitHub repositories (repos), the data the application will work with must include that list of commits. The application will query GitHub for the information, place what GitHub provides in a data structure, and then connect that data structure to components in the user interface that can display it.
+Since the goal of this application is to display a list of commits to the [Apache Royale](https://royale.apache.org/) GitHub repositories (repos), the data the application will work with must include that list of commits. The application will query GitHub for the information, place what GitHub provides in a data structure, and then connect that data structure to components in the [user interface](user-interface) that can display it.
> For large projects, the model is often built in a separate class and source file so it can be separately developed, documented, and maintained (maybe by other team members). But to get something up quickly, we are going to just stick a few variables in the main application file in a script block.
diff --git a/create-an-application/application-tutorial/deploy.md b/create-an-application/application-tutorial/deploy.md
index 2c09a8f..31a0654 100644
--- a/create-an-application/application-tutorial/deploy.md
+++ b/create-an-application/application-tutorial/deploy.md
@@ -24,7 +24,7 @@
Running the application in a browser
-Assuming you followed the typical directory and file pattern, and the MXML file was in a `src` directory, next to the `src` directory should be a `bin` directory with a `js-debug` directory inside it.
+Assuming you followed the typical directory and file pattern, and the [MXML](features/mxml) file was in a `src` directory, next to the `src` directory should be a `bin` directory with a `js-debug` directory inside it.
Inside the `js-debug` directory is an `index.html` file. You can open it in your browser and you should see the list of commits appear.
diff --git a/create-an-application/application-tutorial/view.md b/create-an-application/application-tutorial/view.md
index 7b95545..9ac0730 100644
--- a/create-an-application/application-tutorial/view.md
+++ b/create-an-application/application-tutorial/view.md
@@ -24,7 +24,7 @@
Contains the user interface elements that display data and accept user input
-In an [MVC](https://en.wikipedia.org/wiki/Model–view–controller){:target='_blank'} application the **View** contains the user interface elements that display data and accept user input. We want a way to display the list of commits and also some useful information about those commits. In [Apache Royale](https://royale.apache.org/) a popular way to do that is with a [DataGrid](https://royale.apache.org/asdoc/index.html#!org.apache.royale.html/DataGrid){:target='_blank'}.
+In an [MVC](https://en.wikipedia.org/wiki/Model–view–controller){:target='_blank'} application the **View** contains the [user interface](user-interface) elements that display data and accept user input. We want a way to display the list of commits and also some useful information about those commits. In [Apache Royale](https://royale.apache.org/) a popular way to do that is with a [DataGrid](https://royale.apache.org/asdoc/index.html#!org.apache.royale.html/DataGrid){:target='_blank'}.
The main or initial view of an application is identified as its `initialView` property. We want our user interface elements to appear vertically so we use [VView](https://royale.apache.org/asdoc/index.html#!org.apache.royale.express/VView){:target='_blank'} as the view:
diff --git a/create-an-application/optimizations/compiler-configuration-settings.md b/create-an-application/optimizations/compiler-configuration-settings.md
index 430bea7..8c00fff 100644
--- a/create-an-application/optimizations/compiler-configuration-settings.md
+++ b/create-an-application/optimizations/compiler-configuration-settings.md
@@ -73,7 +73,7 @@
In most cases this extra code can be eliminated in the output after the application has been validated to be error-free at runtime. There may however be cases with legacy actionscript that depend on error-handling for these situations and where refactoring that aspect is not a priority. In these cases it can be left on in the release build, or there is also the option to switch it off in general but force it to remain on for specific code scope, for example, using [@royalesuppresscompleximplicitcoercion](create-an-application/optimizations/doc-comment-directives.html#royalesuppresscompleximplicitcoercion).
-Does this feature always catch implicit complex coercions? No, currently there can still be cases which are missing this level of runtime type safety. Notably this can occur in the processing of mxml instances or binding support.
+Does this feature always catch implicit complex coercions? No, currently there can still be cases which are missing this level of runtime type safety. Notably this can occur in the processing of MXML instances or [data binding](features/data-binding) support.
**Pro tip:** How do I know how much of my code is being affected by this setting? In the javascript **js‑debug** output, you can do a ***search in files*** for the string **/* implicit cast */** which precedes the compiler-generated code the to support this parity with AVM. That will show you all the sites where it is being output. As with all other code, this can be minimized in the js-release output, but as mentioned earlier, if the application does not have runtime errors, then the performance of the application could be optimized by eliminating these checks.
diff --git a/create-an-application/optimizations/doc-comment-directives.md b/create-an-application/optimizations/doc-comment-directives.md
index 789b73a..9537e1f 100644
--- a/create-an-application/optimizations/doc-comment-directives.md
+++ b/create-an-application/optimizations/doc-comment-directives.md
@@ -242,7 +242,7 @@
The above is used to prevent a public class member from having an exported setting in the release build.
This can be used with classes that are used to emulate certain as3 language features in javascript, and often are intended only for output generated by the compiler and not used directly by a developer.
It has the effect to making the annotated class member 'pay as you go' because if the compiler does not generate output that uses it, the code and any dependencies that are specific to it are eliminated from the release build output.
-They can also be used as another way to offer opt-in features, for a type of PAYG approach that works in regular actionscrip, and which could also be then supported in code via a bead for use in mxml.
+They can also be used as another way to offer opt-in features, for a type of [PAYG](features/PAYG) approach that works in regular actionscrip, and which could also be then supported in code via a [beads](features/strands-and-beads) for use in [MXML](features/mxml).
An example of this is the ExtraData class in the Reflection library, which has static methods to add opt-in support for additional reflection data.
### @royalesuppressclosure {#royalesuppressclosure}
diff --git a/features-and-concepts.md b/features-and-concepts.md
index 497f2df..0773ee8 100644
--- a/features-and-concepts.md
+++ b/features-and-concepts.md
@@ -42,7 +42,7 @@
Sometimes you may want your Royale application to call an external piece of JavaScript that is also hosted in your web page, or even for some extenal JavaScript from your page to call into the Royale application. In the Flex (and Flash) world, there was the possibility to use the `ExternalInterface` class to achieve this functionality. If you want this in Royale, there are some options available that you can [read about here](features/external-interface).
-Another option is externs, which use [Google Closure Compiler (GCC)](https://developers.google.com/closure/compiler){:target='_blank'} to declare that a name for a class, property or function is defined in external code and so should not be renamed when your application code is compiled. Apache Royale can use the properties of the external library, and you can even see them as options if you are using an __IDE__, with _code intelligence_ enabled. [Learn more about externs](features/externs).
+Another option is [externs](features/externs), which use [Google Closure Compiler (GCC)](https://developers.google.com/closure/compiler){:target='_blank'} to declare that a name for a class, property or function is defined in external code and so should not be renamed when your application code is compiled. Apache Royale can use the properties of the external library, and you can even see them as options if you are using an __IDE__, with _code intelligence_ enabled. [Learn more about externs](features/externs).
## Data Binding
diff --git a/features/data-binding.md b/features/data-binding.md
index 78a3f05..4df2251 100644
--- a/features/data-binding.md
+++ b/features/data-binding.md
@@ -23,7 +23,7 @@
Update the UI in real time as data changes
-[Apache Royale](https://royale.apache.org/), like Flex before it, makes it easy to pass data around your application. A change to data can automatically update the display of that data in the user interface, and potentially in calculations or other functions that use that data. The feature that makes this possible without having to write lots of code is *data binding*.
+[Apache Royale](https://royale.apache.org/), like Flex before it, makes it easy to pass data around your application. A change to data can automatically update the display of that data in the [user interface](user-interface), and potentially in calculations or other functions that use that data. The feature that makes this possible without having to write lots of code is *data binding*.
Data binding requires
- a **data binding bead** that adds this functionality to the whole application, or to the container in which the data binding happens. If you enable data binding for a container, it only applies to the componenents within that container; if you enable it at the application level, all application components inherit the ability to use data binding.
diff --git a/features/mxml.md b/features/mxml.md
index 414e89a..71df39c 100644
--- a/features/mxml.md
+++ b/features/mxml.md
@@ -24,7 +24,7 @@
The declarative XML-based user interface markup language
-MXML is an XML-based language introduced in 2004 by Macromedia. In [Apache Royale](https://royale.apache.org/) you use it to lay out user-interface components. You can create an application in Royale using only [ActionScript](features/as3), but it takes a lot more work.
+MXML is an XML-based language introduced in 2004 by Macromedia. In [Apache Royale](https://royale.apache.org/) you use it to lay out [user interface](user-interface) components. You can create an application in Royale using only [ActionScript](features/as3), but it takes a lot more work.
Most Royale applications have an MXML file as the main file. It provides the structure of the application. The main MXML file from our very simple <a href="https://apache.github.io/royale-docs/get-started/hello-world" target="_blank">hello world example</a> looks a bit like this:
diff --git a/features/routing.md b/features/routing.md
index 147b61c..e029743 100644
--- a/features/routing.md
+++ b/features/routing.md
@@ -44,7 +44,7 @@
In the above examples, any time the route changes, the `stateChanged` function will be called.
-The state of the router can likewise be changed directly by modifying the `router.routeState` and calling `router.setState()` `router.renderState()` is a similar method, but it will dispatch the `stateChanged` event as well and cause any attached beads to react to the state change.
+The state of the router can likewise be changed directly by modifying the `router.routeState` and calling `router.setState()` `router.renderState()` is a similar method, but it will dispatch the `stateChanged` event as well and cause any attached [beads](features/strands-and-beads) to react to the state change.
## Router Beads
The full power of the Router becomes apparent when you use beads. Router can automatically sync the route state with the component's state. It can change which component is shown by creating and removing components. It can handle parameters, etc. Here are some examples:
diff --git a/features/styles-skins-themes.md b/features/styles-skins-themes.md
index 97e4847..fed1200 100644
--- a/features/styles-skins-themes.md
+++ b/features/styles-skins-themes.md
@@ -28,7 +28,7 @@
## Styles
-You can plug different style classes into your Royale app that can manage different levels of styling features. Usually a Royale application will include a Style class at the Application bead level like this:
+You can plug different style classes into your Royale app that can manage different levels of styling features. Usually a Royale application will include a Style class at the Application [bead](features/strands-and-beads) level like this:
```mxml
<js:Application xmlns:fx="http://ns.adobe.com/mxml/2009"
diff --git a/formatter.md b/formatter.md
index 4c77b84..2917f2d 100644
--- a/formatter.md
+++ b/formatter.md
@@ -26,7 +26,7 @@
## User Guide
-Below are some pointers to help you get started with the [Apache Royale](https://royale.apache.org/) formatter in various environments.
+Below are some pointers to help you get started with the [Apache Royale](https://royale.apache.org/) formatter in various environments. This tool can format both [MXML](features/mxml) and [ActionScript 3.0 (AS3)](features/as3).
### Command line
diff --git a/formatter/formatter-options.md b/formatter/formatter-options.md
index d8a36f1..f653820 100644
--- a/formatter/formatter-options.md
+++ b/formatter/formatter-options.md
@@ -24,7 +24,7 @@
List of all available formatter options
-The [**asformat**](formatter) tool has a number of useful configuration options
+The [**asformat**](formatter) tool included with [Apache Royale](https://royale.apache.org/) has a number of useful configuration options
. The list below is also available by running `asformat -help advanced` in a terminal.
- `-collapse-empty-blocks` -- Determines if empty blocks containing no statements will be collapsed to a single line, or if the closing curly brace should still appear on a new line. Default: `false`
diff --git a/get-started.md b/get-started.md
index 41522ee..563a46c 100644
--- a/get-started.md
+++ b/get-started.md
@@ -28,7 +28,7 @@
[Apache Royale](https://royale.apache.org/) is an open source project. You can get the [source code](http://royale.apache.org/source-code){:target='_blank'} and build Royale, or, if you are in a hurry, you can [click here](https://royale.apache.org/download){:target='_blank'} to find out how to download pre-compiled code and get going quickly.
-In Apache Royale you develop your applications using ActionScript 3 (AS3) and MXML languages. Your source code is build with the Royale compiler to generate the final Application that will run on the chosen platform.
+In Apache Royale you develop your applications using [ActionScript 3 (AS3)](features/as3) and [MXML](features/mxml) languages. Your source code is build with the Royale compiler to generate the final Application that will run on the chosen platform.
## Getting Royale
diff --git a/get-started/development-tools.md b/get-started/development-tools.md
index 2601e43..6d090c2 100644
--- a/get-started/development-tools.md
+++ b/get-started/development-tools.md
@@ -32,8 +32,8 @@
### IDEs with Royale support
-- [Visual Studio Code with ActionScript and MXML Extensions](https://github.com/BowlerHatLLC/vscode-nextgenas/wiki/Install-the-ActionScript-and-MXML-extension-for-Visual-Studio-Code){:target='_blank'}
-- [Moonshine IDE](http://moonshine-ide.com){:target='_blank'}
+- [Visual Studio Code with ActionScript and MXML Extensions](https://github.com/BowlerHatLLC/vscode-as3mxml/wiki/Install-the-ActionScript-and-MXML-extension-for-Visual-Studio-Code){:target='_blank'}
+- [Moonshine IDE](https://moonshine-ide.com){:target='_blank'}
### IDES that supported Flex and work with Royale with some restrictions and limitations.
diff --git a/get-started/frameworks.md b/get-started/frameworks.md
index f1db85a..35a0520 100644
--- a/get-started/frameworks.md
+++ b/get-started/frameworks.md
@@ -42,7 +42,7 @@
## Apache Royale Component Sets
-Apache Royale supports its own [component sets](component-sets) of controls, options for grouping controls, and other elements designed to help developers get the most of the technology.
+Apache Royale supports its own [component sets](component-sets) of [user interface](user-interface) controls, options for grouping and layouting out controls, and other elements designed to help developers get the most of the technology.
- [Basic](component-sets/basic) is the most smallest, fastest and most PAYG set of components possible in Royale, and is used by other sets like Jewel as their base.
diff --git a/get-started/hello-world.md b/get-started/hello-world.md
index 3316a5b..379ef05 100644
--- a/get-started/hello-world.md
+++ b/get-started/hello-world.md
@@ -48,7 +48,7 @@
## Create the source file
-In the `src` folder, create a file called `HelloWorld.mxml` and use your favorite text editor to give that file the following contents:
+In the `src` folder, create an [MXML](features/mxml) file called `HelloWorld.mxml` and use your favorite text editor to give that file the following contents:
```mxml
<?xml version="1.0" encoding="utf-8"?>
diff --git a/get-started/royale-cli.md b/get-started/royale-cli.md
index 03a94d9..75bccd8 100644
--- a/get-started/royale-cli.md
+++ b/get-started/royale-cli.md
@@ -56,7 +56,7 @@
royale new my-royale-app
```
-This creates a new directory structure using the name of the application, and creates a basic app with one main file: `my-royale-app/src/Main.mxml`.
+This creates a new directory structure using the name of the application, and creates a basic app with one main [MXML](features/mxml) file: `my-royale-app/src/Main.mxml`.
To review the app structure so far, navigate into the new direcctory:
diff --git a/index.md b/index.md
index d77b932..27ecb11 100644
--- a/index.md
+++ b/index.md
@@ -27,7 +27,7 @@
{:align="center"}
{:height="33%" width="33%"}
-[Apache Royale](https://royale.apache.org/) is the new SDK, built on the solid foundation developed by the Flex universe, that lets you create applications in MXML and ActionScript that will run almost anywhere without heavy plugins like Flash or Adobe AIR.
+[Apache Royale](https://royale.apache.org/) is the new SDK, built on the solid foundation developed by the Flex universe, that lets you create applications in [MXML](features/mxml) and [ActionScript 3.0 (AS3)](features/as3) that will run almost anywhere without heavy plugins like Flash or Adobe AIR.
With Royale, you can create a single code base that can be compiled to work like a native app on Windows or Apple systems, on Android phones, on tablets of all systems and sizes, in browsers, or on embedded JavaScript environments like Chromium Embedded Framework.
diff --git a/libraries/compiled-code-libraries.md b/libraries/compiled-code-libraries.md
index 9fdb20f..01c3fdd 100644
--- a/libraries/compiled-code-libraries.md
+++ b/libraries/compiled-code-libraries.md
@@ -26,9 +26,9 @@
## Concepts
-On the most basic level, SWC libraries are just compiled ActionScript classes. You need to include the necessary classes and the code will be included in your compiled SWC.
+On the most basic level, SWC libraries are just compiled [ActionScript](features/as3) classes. You need to include the necessary classes and the code will be included in your compiled SWC.
-Libraries can also declare components that can be used in MXML files by referencing a namespace.
+Libraries can also declare components that can be used in [MXML](features/MXML) files by referencing a namespace.
In this example, we're going to assume that you have both code and components to include.
@@ -81,7 +81,7 @@
Just referencing the classes like that is enough to have them included.
## The CSS file
-`defaults.css` is where you declare any HTML or Royale CSS that's needed for your library. This is where you declare default beads and the like. Make sure you declare your namespace that's used for the MXML declarations of you components.
+`defaults.css` is where you declare any HTML or Royale CSS that's needed for your library. This is where you declare default [beads](features/strands-and-beads) and the like. Make sure you declare your namespace that's used for the MXML declarations of you components.
```
@namespace "library://ns.somesite.com/kapow";
@@ -101,7 +101,7 @@
The notable difference between the two files:
1. `compile-config.xml` has `playerglobal.swc` referenced in the `external-library-path`.
2. `compile-config.xml` has `COMPILE::SWF` as `true` while `js-compile-config.xml` has `COMPILE::JS` as `true`.
-3. If you have a `lib/Foo.swc` JS typedef dependency that you want to include, you should add the following to the `js-compile-config.xml`:
+3. If you have a `lib/Foo.swc` JS [typedef (sometimes also called externs)](features/externs) dependency that you want to include, you should add the following to the `js-compile-config.xml`:
```
<js-external-library-path append="true">
diff --git a/libraries/crux/dependency-injection.md b/libraries/crux/dependency-injection.md
index f80d613..28a5818 100644
--- a/libraries/crux/dependency-injection.md
+++ b/libraries/crux/dependency-injection.md
@@ -49,7 +49,7 @@
By default, injections in view components happen during the `ADDED_TO_STAGE` event. <!--This behavior can be modified by changing the Crux configuration.--> It is important to understand that this means that injections occur after the <!--CREATION_COMPLETE-->`initComplete` event. If you need to trigger logic during creation that depends on injections, use a `[PostConstruct]` method.
-> Note: `ADDED_TO_STAGE` is a SWF event. In __Javascript__ you need to add a bead to your Application beads called `JSStageEvents` to simulated stage events like `ADDED_TO_STAGE` or 'REMOVED_FROM_STAGE`
+> Note: `ADDED_TO_STAGE` is a SWF event. In __Javascript__ you need to add a [bead](features/strands-and-beads) to your Application beads called `JSStageEvents` to simulated stage events like `ADDED_TO_STAGE` or 'REMOVED_FROM_STAGE`
## Inject by type {#inject-by-type}
diff --git a/libraries/library-basics.md b/libraries/library-basics.md
index ea1f364..982b187 100644
--- a/libraries/library-basics.md
+++ b/libraries/library-basics.md
@@ -32,7 +32,7 @@
## Types of libraries
There are two basic library types:
1. Compiled Code libraries
-2. Typedef libraries
+2. Typedef libraries (sometimes called Externs libraries)
There is no obvious way to tell the difference. Both have a `.swc` extension, although typedef libraries do not have any `js` code included and will generally be smaller.
@@ -42,7 +42,7 @@
Compiled code libraries are created using the `compc` compiler. See [detailed instructions on how to create one](libraries/compiled-code-libraries).
### Typedef libraries
-Typedef libraries define the types of different classes, but contain no code that would be added to an application. Typedef libraries hold core Web APIs and third party JavaScript libraries which could be included in applications as separate JavaScript files (such as jQuery). Typedef libraries are similar to Typescript `d.ts` files.
+Typedef libraries define the types of different classes, but contain no code that would be added to an application. [Typedef (sometimes called externs)](features/externs) libraries hold core Web APIs and third party JavaScript libraries which could be included in applications as separate JavaScript files (such as jQuery). Typedef libraries are similar to Typescript `d.ts` files.
Typedef libraries are created using the `externc` compiler. (TODO add sample configs for doing this.)
diff --git a/linter.md b/linter.md
index 18d685d..8ea55c4 100644
--- a/linter.md
+++ b/linter.md
@@ -26,7 +26,7 @@
## User Guide
-Below are some pointers to help you get started with the [Apache Royale](https://royale.apache.org/) linter in various environments.
+Below are some pointers to help you get started with the [Apache Royale](https://royale.apache.org/) linter in various environments. This tool can analyze both [MXML](features/mxml) and [ActionScript 3.0 (AS3)](features/as3).
### Command line
diff --git a/linter/linter-options.md b/linter/linter-options.md
index 584fb4d..66e9863 100644
--- a/linter/linter-options.md
+++ b/linter/linter-options.md
@@ -24,7 +24,7 @@
List of all available linter options
-The [**aslint**](linter) tool has a number of useful configuration options. The list below is also available by running `aslint -help advanced` in a terminal.
+The [**aslint**](linter) tool included with [Apache Royale](https://royale.apache.org/) has a number of useful configuration options. The list below is also available by running `aslint -help advanced` in a terminal.
- `-class-name` -- Ensures that class names match the pattern `^[A-Z][a-zA-Z0-9]*$`. Default: `false`
- `-constant-name` -- Ensures that constant names match the pattern `^[A-Z][A-Z0-9]*(_[A-Z0-9]+)*$`. Default: `false`
diff --git a/migrate-an-existing-app/migrate-from-js.md b/migrate-an-existing-app/migrate-from-js.md
index cb18621..c60a073 100644
--- a/migrate-an-existing-app/migrate-from-js.md
+++ b/migrate-an-existing-app/migrate-from-js.md
@@ -34,9 +34,9 @@
Most of us are familiar with furniture, toys, and other comsumables that have "some assembly required". That is true of all software languages, but some provide better guidance than others. JS offers lots of options for writing your code and sticking it together, but unless you are very attentive or very experienced, you can end up with a package that has a mysterious glitch somewhere that is hard to track down and fix.
-Royale is also an assemble-it-yourself language. However, like the better furniture stores that provide not just the nails and screws but instructions with illustrations, Royale helps you develop in a way that minimizes errors. Semi-structured languages like ActionScript let you establish custom connectors so that the components you write can only go together in certain ways. Declarative languages like MXML provide diagrams to help you see the pieces that you are attaching and what you can expect when you stick them together. The Royale code verifier acts like an inspector, checking your work at runtime.
+Royale is also an assemble-it-yourself language. However, like the better furniture stores that provide not just the nails and screws but instructions with illustrations, Royale helps you develop in a way that minimizes errors. Semi-structured languages like [ActionScript](features/as3) let you establish custom connectors so that the components you write can only go together in certain ways. Declarative languages like [MXML](features/mxml) provide diagrams to help you see the pieces that you are attaching and what you can expect when you stick them together. The Royale code verifier acts like an inspector, checking your work at runtime.
-Many in the JS world use higher-level languages like Dart and TypeScript to reduce the chances of error in the JS code they write. Royale provides similar guardrails; it also provdes the option to use a declarative language, MXML.
+Many in the JS world use higher-level languages like Dart and TypeScript to reduce the chances of error in the JS code they write. Royale provides similar guardrails; it also provides the option to use a declarative language, [MXML](features/mxml).
If you are thinking of moving to an easier way of writing applications, compiling them into JavaScript and releasing them to the world on a wide range of platforms, Royale may be your answer.
diff --git a/testing/royaleunit/create-a-unit-test.md b/testing/royaleunit/create-a-unit-test.md
index 7cda9d6..bb8ac1d 100644
--- a/testing/royaleunit/create-a-unit-test.md
+++ b/testing/royaleunit/create-a-unit-test.md
@@ -69,7 +69,7 @@
## Run unit tests
-Create a simple Apache Royale application and name it *MyTests.mxml*:
+Create a simple Apache Royale application in an [MXML](features/mxml) file with the name *MyTests.mxml*:
```mxml
<?xml version="1.0" encoding="utf-8"?>
diff --git a/tutorials.md b/tutorials.md
index 9f4d2c5..b742c3f 100644
--- a/tutorials.md
+++ b/tutorials.md
@@ -41,4 +41,4 @@
* [Customization through the Royale API](https://royale.apache.org/customization-through-the-royale-api){:target='_blank'}
* [Data binding](https://royale.apache.org/binding-the-text-property-of-a-jewel-textinput-to-update-a-text-label/){:target="_blank"}
-[Tour de Jewel](https://royale.apache.org/tourdejewel){:target='_blank'} is an ever-expanding set of examples of how to use the [Jewel component set](component-sets/jewel) to build a user interface that will deliver what you want and provide a great user experience.
+[Tour de Jewel](https://royale.apache.org/tourdejewel){:target='_blank'} is an ever-expanding set of examples of how to use the [Jewel component set](component-sets/jewel) to build a [user interface](user-interface) that will deliver what you want and provide a great user experience.
diff --git a/user-interface/components.md b/user-interface/components.md
index b0bdef7..bdc41e5 100644
--- a/user-interface/components.md
+++ b/user-interface/components.md
@@ -23,7 +23,7 @@
Meet the UI building blocks.
-[Apache Royale](https://royale.apache.org/) provides a wide range of components to help you design a user interface that presents your material clearly and offers a pleasing user experience. As with Flex, these include:
+[Apache Royale](https://royale.apache.org/) provides a wide range of components to help you design a [user interface](user-interface) that presents your material clearly and offers a pleasing user experience. As with Flex, these include:
* Layout aids (groups, cards, grids, forms)
* Ways to display data (lists, text boxes, tables, charts, repeating components)
@@ -32,7 +32,7 @@
* Usability features (alerts, snackbar pop-ups, localization features, dynamic displays depending on the user's metadata)
* Rich content (images, videos, audio, transitions)
-Developers who have worked in Flex will quickly feel at home with Royale components, although they will need to pay attention to the ["Pay as you go"](features/payg) concept that is a Royale hallmark. Components do well the basic functions associated with their names, but to add features (for instance, you want to force the text the user enters to lower case), you need to add the appropriate bead to the strand of the component:
+Developers who have worked in Flex will quickly feel at home with Royale components, although they will need to pay attention to the ["Pay as you go"](features/payg) concept that is a Royale hallmark. Components do well the basic functions associated with their names, but to add features (for instance, you want to force the text the user enters to lower case), you need to add the appropriate [bead](features/strands-and-beads) to the strand of the component:
```as3
<j:TextInput text="Your entry will appear in LOWER case">
diff --git a/welcome/high-level-view.md b/welcome/high-level-view.md
index 438456c..8068a11 100644
--- a/welcome/high-level-view.md
+++ b/welcome/high-level-view.md
@@ -45,7 +45,7 @@
Because both [ActionScript](features/as3) and JavaScript are based on the same language, ECMAScript, most code you write in AS translates well to JS. One significant difference is that AS uses the concepts of classes and objects to structure how your code functions, while pure JavaScript does not have those concepts. When you get ready to compile and run your application, the Royale compiler translates AS-specific code into JS code organized into pseudo-classes, which then run just fine in a JavaScript world.
-That takes care of pretty much everything except the user interface. For that, Royale provides a set of UI containers and controls that do the work that the pure Flex containers and controls required the Flash engine to do.
+That takes care of pretty much everything except the [user interface](user-interface). For that, Royale provides a set of UI containers and controls that do the work that the pure Flex containers and controls required the Flash engine to do.
## Status
diff --git a/working-with-data/loading-external-data/httpservice.md b/working-with-data/loading-external-data/httpservice.md
index c28f1ef..03b4fa8 100644
--- a/working-with-data/loading-external-data/httpservice.md
+++ b/working-with-data/loading-external-data/httpservice.md
@@ -32,7 +32,7 @@
* **MXRoyale**: Is an emulation of the implementation that Flex applications use. It is the best option if you're migrating from Flex since it supports the same API that the Flex framework uses.
-* **Network**: Is a newer bead implementation. This is still under development, so you may run into some issues that will need to be resolved.
+* **Network**: Is a newer [bead](features/strands-and-beads) implementation. This is still under development, so you may run into some issues that will need to be resolved.
## Examples
diff --git a/working-with-data/loading-external-data/remoteobject.md b/working-with-data/loading-external-data/remoteobject.md
index 524f6e8..798a63c 100644
--- a/working-with-data/loading-external-data/remoteobject.md
+++ b/working-with-data/loading-external-data/remoteobject.md
@@ -32,7 +32,7 @@
* **MXRoyale**: Is an emulation of the implementation that Flex applications use. It is the best option if you're migrating from Flex since it supports the same API that the Flex framework uses.
-* **Network**: Is a newer bead implementation. This is still under development, so you may run into some issues that will need to be resolved.
+* **Network**: Is a newer [bead](features/strands-and-beads) implementation. This is still under development, so you may run into some issues that will need to be resolved.
> We recommend using `MXRoyale` instead of the `Network` version for now, since it is closer to the Flex implementation and is already in use in Apache Royale applications currently in production.
