This is an automated email from the ASF dual-hosted git repository.
carlosrovira pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/royale-docs.git
The following commit(s) were added to refs/heads/master by this push:
new b97ef29 use permalinks in all "features" pages
b97ef29 is described below
commit b97ef29c8d358ede3a415ce3d03dc1653d84fb5f
Author: Carlos Rovira <[email protected]>
AuthorDate: Mon Sep 2 19:02:52 2019 +0200
use permalinks in all "features" pages
---
README.md | 8 +++++---
component-sets/jewel.md | 4 ++--
component-sets/jewel/jewel-alert.md | 2 +-
component-sets/jewel/jewel-theme-creation.md | 4 ++--
component-sets/jewel/jewel-themes.md | 2 +-
create-an-Application.md | 2 +-
create-an-application/application-structure.md | 2 +-
.../application-tutorial/value-objects.md | 2 +-
create-an-application/application-tutorial/view.md | 2 +-
.../migrate-an-existing-app/migrate-from-flex.md | 2 +-
features-and-concepts.md | 15 ++++++++-------
features/actionscript/abstract-classes.md | 7 ++++---
features/actionscript/metadata.md | 1 +
features/actionscript/private-constructors.md | 7 ++++---
features/as3.md | 5 +++--
features/data-binding.md | 2 ++
features/external-interface.md | 3 ++-
features/externs.md | 3 ++-
features/loading-external-data.md | 8 +++++---
features/loading-external-data/amf.md | 3 +++
features/loading-external-data/httpservice.md | 3 ++-
features/loading-external-data/json.md | 3 ++-
features/modules.md | 1 +
features/mxml.md | 1 +
features/payg.md | 3 ++-
features/strands-and-beads.md | 3 ++-
features/styling.md | 3 ++-
features/view-states.md | 3 ++-
index.md | 2 +-
user-interface/components.md | 4 ++--
welcome/high-level-view.md | 6 +++---
31 files changed, 70 insertions(+), 46 deletions(-)
diff --git a/README.md b/README.md
index 39ec9f3..a9442a5 100644
--- a/README.md
+++ b/README.md
@@ -17,7 +17,7 @@ We produce four flavors of documentation:
1. *Tutorials* to show how to do a complete thing, with source code a reader
can copy and learn from. These generally appear on the website blog at the
moment.
2. *How-to guides* that explain how to achieve something in Royale that is
either of a general nature ("How to find the bead you need") or does not merit
a full tutorial ("How to disable an input field"). This material should be in
the user documentation.
-3. *Explanations* that explain the "why" of Royale features--why we do it this
way, or avoid doing it that way. This appears in the [High Level
View](welcome/high-level-view.html){:target='_blank'} pages of the user
documentation.
+3. *Explanations* that explain the "why" of Royale features--why we do it this
way, or avoid doing it that way. This appears in the [High Level
View](welcome/high-level-view){:target='_blank'} pages of the user
documentation.
4. *Technical references* are all the gritty details of what each Royale
component, bead, and feature requires, produces, and can do. This material
would normally be in the [ASDoc
reference](https://royale.apache.org/asdoc/){:target='_blank'}, the [framework
wiki](https://github.com/apache/royale-asjs/wiki){:target='_blank'}, or the
[compiler
wiki](https://github.com/apache/royale-compiler/wiki){:target='_blank'}.
No one flavor is better in all circumstances than the others. All
contributions strengthen Royale by expanding the number of people who can find
the answers they need to create applications.
@@ -59,9 +59,11 @@ Use HTML comments at the top of the document for any
explanatory notes for the d
## Links
-In the .md files, links have to be full paths without the leading slash. So to
link to the published, HTML, version of features/as3.md, you would use
+In the .md files, links have to be full paths without the leading slash. The
link to the published HTML version of features/as3.md, is
`[AS3](features/as3.html)`, but we want to use permalinks so the link to use
should be:
-`[AS3](features/as3.html)`
+`[AS3](features/as3)`
+
+and the permalink on that page will be, `permalink: /features/as3`
without the leading "/". Links are case-sensitive, and you need to insert
`%20` for any space that appears in the target file's name. Check the guidance
about file names, above.
diff --git a/component-sets/jewel.md b/component-sets/jewel.md
index 87f81c7..9e42f7b 100644
--- a/component-sets/jewel.md
+++ b/component-sets/jewel.md
@@ -22,9 +22,9 @@ title: Jewel
A set of modern UI components
-Jewel is a themeable and responsive set of user interface components for
Apache Royale to help you quickly build the front end of your applications with
[ActionScript](features/as3.html) & [MXML](features/mxml.html).
+Jewel is a themeable and responsive set of user interface components for
Apache Royale 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.html) components. But
while Basic is very strict with concepts like [PAYG](features/payg.html), in
Jewel, while PAYG is important, when necessary we prioritize other things like
responsiveness, themes and look and feel.
+It's based by design on [Basic](component-sets/basic.html) 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.
## Browser Support
diff --git a/component-sets/jewel/jewel-alert.md
b/component-sets/jewel/jewel-alert.md
index f32be09..46f19d7 100644
--- a/component-sets/jewel/jewel-alert.md
+++ b/component-sets/jewel/jewel-alert.md
@@ -37,7 +37,7 @@ Available since version __0.9.4__
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.
-> `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.html).
+> `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).
## Example of use
diff --git a/component-sets/jewel/jewel-theme-creation.md
b/component-sets/jewel/jewel-theme-creation.md
index 8fdb998..b7a8a12 100644
--- a/component-sets/jewel/jewel-theme-creation.md
+++ b/component-sets/jewel/jewel-theme-creation.md
@@ -40,11 +40,11 @@ The `default.css` file is the resuling CSS file that holds
all CSS definitions f
## Jewel Library
-Here you'll find the [ActionScript](features/as3.html) classes that define
each component and support class files components need to work properly. You'll
find a `sass` folder with a `.sass` file for each component which holds all
_structural_ definitions. Those definitions can be normal _CSS rules_ or
_royale bead definition rules_.
+Here you'll find the [ActionScript](features/as3) classes that define each
component and support class files components need to work properly. You'll find
a `sass` folder with a `.sass` file for each component which holds all
_structural_ definitions. Those definitions can be normal _CSS rules_ or
_royale bead definition rules_.
You'll never find a style rule in the Jewel library that define _colors,
lines, fonts, or shapes_ (the theme we locate in the __theme library__ handles
these values). We'll find only the CSS rules needed to generate each jewel
component visual structure (i.e: display, position, z-index, overflow,...), and
the default ActionScript bead classes that ship with a concrete component per
platform (i.e: BeadView, BeadModel, BeadController, BeadLayout,...).
-> Apache Royale uses CSS through all the framwework to link [beads to the
component's strand](features/strands-and-beads.html) so components define the
default composition of beads via CSS.
+> Apache Royale uses CSS through all the framwework to link [beads to the
component's strand](features/strands-and-beads) so components define the
default composition of beads via CSS.
## Jewel Theme Library
diff --git a/component-sets/jewel/jewel-themes.md
b/component-sets/jewel/jewel-themes.md
index 0c710d7..e45ff46 100644
--- a/component-sets/jewel/jewel-themes.md
+++ b/component-sets/jewel/jewel-themes.md
@@ -23,7 +23,7 @@ title: Jewel Themes
The look and feel of the jewel component set
Jewel component set focus on themes. Themes provides the capability of change
the appearance of _all_ components at once.
-A theme is a predefined CSS file (and optionally a other assets like images)
that holds the definitions of each Jewel component, its subcomponents and the
default [beads](features/strands-and-beads.html) used to configure that
components.
+A theme is a predefined CSS file (and optionally a other assets like images)
that holds the definitions of each Jewel component, its subcomponents and the
default [beads](features/strands-and-beads) used to configure that components.
Royale use the theme to add the right css selectors to the final compilation
so when the user loads the application the required css and other files are
loaded and the application shows a concrete look and feel.
diff --git a/create-an-Application.md b/create-an-Application.md
index 0c495d2..f2d2555 100644
--- a/create-an-Application.md
+++ b/create-an-Application.md
@@ -33,7 +33,7 @@ This document is divided into several sections:
[Security](create-an-application/security.html) provides more information
about making sure hackers can't use your app to be malicous and about dealing
with common security restrictions when your app wants to access external
resources.
-[Modules](features/modules.html) discusses how to break your application into
pieces so it doesn't have to all get downloaded at once. Or have the whole
thing compiled at once.
+[Modules](features/modules) discusses how to break your application into
pieces so it doesn't have to all get downloaded at once. Or have the whole
thing compiled at once.
[Royale code conventions](create-an-application/code-conventions.html)
explains the typical ways Royale developers name files, classes, function,
variables and more.
diff --git a/create-an-application/application-structure.md
b/create-an-application/application-structure.md
index 144b46b..3a7c1cc 100644
--- a/create-an-application/application-structure.md
+++ b/create-an-application/application-structure.md
@@ -32,7 +32,7 @@ Let's say you are creating a project called MyFirstRoyaleApp.
Create a MyFirstRo
If you use <a href="https://maven.apache.org/"; target="_blank">Apache
Maven</a> to build your app, you can use one of the Maven archetypes, which put
the main application source code 3 levels deep in a "src/main/royale" folder
structure. Other kinds of files then go in "src/main/resource",
"src/main/config" and so on. Maven instructs the compiler to put the output in
a "target/javascript/bin" folder.
-Most Royale applications use an [MXML](features/mxml.html) file as the main
application file. Other files are written in MXML or
[ActionScript](features/as3.html) depending on whether you are assembling
pieces or writing custom logic. You can write a Royale Application without
using MXML at all, but you'll end up writing more code.
+Most Royale applications use an [MXML](features/mxml) file as the main
application file. Other files are written in MXML or
[ActionScript](features/as3) depending on whether you are assembling pieces or
writing custom logic. You can write a Royale Application without using MXML at
all, but you'll end up writing more code.
So, if you decide to use MXML as your main application file, then your folder
structure might look like this:
diff --git a/create-an-application/application-tutorial/value-objects.md
b/create-an-application/application-tutorial/value-objects.md
index 61fb413..98444d2 100644
--- a/create-an-application/application-tutorial/value-objects.md
+++ b/create-an-application/application-tutorial/value-objects.md
@@ -48,7 +48,7 @@ public class LogEntry
```
You can download this file from
[here](https://github.com/apache/royale-asjs/blob/develop/examples/express/GitHubCommitLogViewer/src/main/royale/LogEntry.as).
-Notice the use of [Bindable](features/data-binding.html) metadata. This
special syntax indicates to the compiler that there are no DataBinding
notifications for the message field. Once it is set, it will not change. We
could also specify "message" as a "const" instead of a "var" and set up a
constructor with parameters, but constructor parameters are not allowed for
anything that wants to be declared in MXML.
+Notice the use of [Bindable](features/data-binding) metadata. This special
syntax indicates to the compiler that there are no DataBinding notifications
for the message field. Once it is set, it will not change. We could also
specify "message" as a "const" instead of a "var" and set up a constructor with
parameters, but constructor parameters are not allowed for anything that wants
to be declared in MXML.
Once we have the LogEntry Value Object, we use LogEntry throughout the app. In
the conversion loop, we change it to look like this:
diff --git a/create-an-application/application-tutorial/view.md
b/create-an-application/application-tutorial/view.md
index e43f2cd..cb7d1ba 100644
--- a/create-an-application/application-tutorial/view.md
+++ b/create-an-application/application-tutorial/view.md
@@ -61,7 +61,7 @@ myLabel.text = projectName;
And we'd also have to write change detection code if the value could change at
runtime (which it doesn't in this case).
-See more about what this powerful feature can do for you on this page: [Data
binding](features/data-binding.html).
+See more about what this powerful feature can do for you on this page: [Data
binding](features/data-binding).
Also, a commit message might be too long to read in a row of a DataGrid so we
will add a place to display the longer message of a selected commit.
diff --git a/create-an-application/migrate-an-existing-app/migrate-from-flex.md
b/create-an-application/migrate-an-existing-app/migrate-from-flex.md
index 7c04fe1..4d24fb4 100644
--- a/create-an-application/migrate-an-existing-app/migrate-from-flex.md
+++ b/create-an-application/migrate-an-existing-app/migrate-from-flex.md
@@ -21,7 +21,7 @@ title: Migrate from Flex
<!-- This is from material created by Peter Ent and modified by Tom Chiverton:
https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=34013930 -->
# Migrate from Flex
-If you have developed applications using [Apache Flex
SDK](https://flex.apache.org/){:target='_blank'}, or Adobe Flex before it, your
applications probably combine [MXML](features/mxml.html) and
[ActionScript](features/as3.html) files along with resources like images and
audio files; and some of the MXML files have <fx:Script> tags with ActionScript
snippets inside them. If that is the case, you will find yourself at home
working with Apache Royale. The big difference is not so much the [...]
+If you have developed applications using [Apache Flex
SDK](https://flex.apache.org/){:target='_blank'}, or Adobe Flex before it, your
applications probably combine [MXML](features/mxml) and
[ActionScript](features/as3) files along with resources like images and audio
files; and some of the MXML files have <fx:Script> tags with ActionScript
snippets inside them. If that is the case, you will find yourself at home
working with Apache Royale. The big difference is not so much the code you u
[...]
It is not yet possible to just import an existing Flex application into Apache
Royale and then produce output in JavaScript that will run almost anywhere.
However, you may need to do less hands-on conversion than you think to get to
where you can produce your application, transpiled to JavaScript, through
Royale.
diff --git a/features-and-concepts.md b/features-and-concepts.md
index e0a69d3..b5b8c94 100644
--- a/features-and-concepts.md
+++ b/features-and-concepts.md
@@ -17,6 +17,7 @@
layout: docpage
title: Features and Concepts
description: Features and Concepts
+permalink: /features-and-concepts
---
# Features and Concepts
@@ -27,26 +28,26 @@ Here are some things you may need to know to help you be
more productive with Ro
## AS3 and MXML Languages
-Royale uses both a declarative markup language called
[MXML](features/mxml.html) and a scripting language called
[ActionScript](features/as3.html) that is like JavaScript, but with classes,
interfaces and types. This allows you to more efficiently declare the static
portions of your application and write up the dynamic portions in a language
where the compiler can catch more errors sooner.
+Royale uses both a declarative markup language called [MXML](features/mxml)
and a scripting language called [ActionScript](features/as3) that is like
JavaScript, but with classes, interfaces and types. This allows you to more
efficiently declare the static portions of your application and write up the
dynamic portions in a language where the compiler can catch more errors sooner.
## Pay as you go (PAYG)
-Royale provides a variety of [component
sets](./user-interface/components.html), each tuned towards different
applications requirements. Components are designed with a ["Pay as you
go"](features/payg.html) philosophy. Only the most common functionality is
built into the component, and other options are added as plugins called Beads.
Components designed this way use to be small and fast, and don't have lots of
built-in customization options that will never use most of the times. You can [
[...]
+Royale provides a variety of [component
sets](./user-interface/components.html), each tuned towards different
applications requirements. Components are designed with a ["Pay as you
go"](features/payg) philosophy. Only the most common functionality is built
into the component, and other options are added as plugins called Beads.
Components designed this way use to be small and fast, and don't have lots of
built-in customization options that will never use most of the times. You can
[read [...]
## Strands and Beads
-The underlying component patterns in most Royale components rely on a plug-in
model. Instead of making large component classes with lots of code baked in,
each individual feature of a component is designed as its own class with an
interface marking it as a "Bead", and then the component itself is called a
"Strand" and Beads are placed on the Strand to compose a Royale component. You
can [read more about Strands and Beads here](features/strands-and-beads.html).
+The underlying component patterns in most Royale components rely on a plug-in
model. Instead of making large component classes with lots of code baked in,
each individual feature of a component is designed as its own class with an
interface marking it as a "Bead", and then the component itself is called a
"Strand" and Beads are placed on the Strand to compose a Royale component. You
can [read more about Strands and Beads here](features/strands-and-beads).
## ExternalInterface and Externs
-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.html).
+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 are externs, wich is uses [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 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.
[read about here](features/externs.html).
+Another option are externs, wich is uses [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 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.
[read about here](features/externs).
## Data Binding
-[read about here](features/data-binding.html)
+[read about here](features/data-binding)
## View States
-[read about here](features/view-states.html)
\ No newline at end of file
+[read about here](features/view-states)
\ No newline at end of file
diff --git a/features/actionscript/abstract-classes.md
b/features/actionscript/abstract-classes.md
index f946593..5aaaa41 100644
--- a/features/actionscript/abstract-classes.md
+++ b/features/actionscript/abstract-classes.md
@@ -17,17 +17,18 @@
layout: docpage
title: Abstract classes
description: Abstract classes in ActionScript
+permalink: /features/as3/abstract-classes
---
# Abstract classes in ActionScript
-allow-abstract-classes
-[Apache Royale](https://royale.apache.org/){:target='_blank'} adds support for
declaring `abstract` classes in [ActionScript](features/as3.html). An abstract
class cannot be instantiated using the `new` keyword, meaning that it must be
subclassed. Additionally, an abstract class may declare `abstract` methods that
do not have a function body. Abstract methods must be implemented by the
concrete subclass, similar to how the methods of an interface must also be
implemented.
+[Apache Royale](https://royale.apache.org/){:target='_blank'} adds support for
declaring `abstract` classes in [ActionScript](features/as3). An abstract class
cannot be instantiated using the `new` keyword, meaning that it must be
subclassed. Additionally, an abstract class may declare `abstract` methods that
do not have a function body. Abstract methods must be implemented by the
concrete subclass, similar to how the methods of an interface must also be
implemented.
## Enable abstract classes
-Like other [new ActionScript language
features](features/as3.html#new-actionscript-language-features-in-royale) that
Royale adds, abstract classes are enabled by default. To disable abstract
classes in your application, use the `-allow-abstract-classes` compiler option.
+Like other [new ActionScript language
features](features/as3#new-actionscript-language-features-in-royale) that
Royale adds, abstract classes are enabled by default. To disable abstract
classes in your application, use the `-allow-abstract-classes` compiler option.
```sh
mxmlc -allow-abstract-classes=false MyApp.mxml
@@ -116,4 +117,4 @@ Checking whether a class is abstract happens at
compile-time only. However, by u
If a SWC library contains classes with abstract classes, applications using
that library must also enable abstract classes before the compiler will enforce
any restrictions.
-Other ActionScript compilers, such as the one in the [Apache Flex
SDK](https://flex.apache.org/){:target='_blank'}, may not recognize or enforce
private constructors. Attemping to pass source code or SWC libraries that
contain classes with private constructors to another compiler may result in
compile-time errors or unexpected behavior at run-time. In other words, to
write 100% portable ActionScript code that works with any compiler, you should
avoid using abstract classes and any of Roy [...]
+Other ActionScript compilers, such as the one in the [Apache Flex
SDK](https://flex.apache.org/){:target='_blank'}, may not recognize or enforce
private constructors. Attemping to pass source code or SWC libraries that
contain classes with private constructors to another compiler may result in
compile-time errors or unexpected behavior at run-time. In other words, to
write 100% portable ActionScript code that works with any compiler, you should
avoid using abstract classes and any of Roy [...]
diff --git a/features/actionscript/metadata.md
b/features/actionscript/metadata.md
index 65777ce..1476324 100644
--- a/features/actionscript/metadata.md
+++ b/features/actionscript/metadata.md
@@ -17,6 +17,7 @@
layout: docpage
title: Metadata
description: Metadata
+permalink: /features/as3/metadata
---
# Metadata
diff --git a/features/actionscript/private-constructors.md
b/features/actionscript/private-constructors.md
index 3a02a48..614f097 100644
--- a/features/actionscript/private-constructors.md
+++ b/features/actionscript/private-constructors.md
@@ -17,17 +17,18 @@
layout: docpage
title: Private constructors
description: Private constructors in ActionScript
+permalink: /features/as3/private-constructors
---
# Private constructors in ActionScript
-allow-private-constructors
-[Apache Royale](https://royale.apache.org/){:target='_blank'} adds support for
declaring the constructor of a class `private` instead of `public` in
[ActionScript](features/as3.html). When a constructor is private, it cannot be
instantiated with the `new` keyword outside of the class where it is defined.
Private constructors are commonly used for implementing the *singleton* design
pattern, which is when only one instance of a particular class should ever be
created.
+[Apache Royale](https://royale.apache.org/){:target='_blank'} adds support for
declaring the constructor of a class `private` instead of `public` in
[ActionScript](features/as3). When a constructor is private, it cannot be
instantiated with the `new` keyword outside of the class where it is defined.
Private constructors are commonly used for implementing the *singleton* design
pattern, which is when only one instance of a particular class should ever be
created.
## Enable private constructors
-Like other [new ActionScript language
features](features/as3.html#new-actionscript-language-features-in-royale) that
Royale adds, are enabled by default. To disable private constructors in your
application, use the `-allow-private-constructors` compiler option.
+Like other [new ActionScript language
features](features/as3#new-actionscript-language-features-in-royale) that
Royale adds, are enabled by default. To disable private constructors in your
application, use the `-allow-private-constructors` compiler option.
```sh
mxmlc -allow-private-constructors=false MyApp.mxml
@@ -102,5 +103,5 @@ Checking whether a constructor is private or not happens at
compile-time only. H
If a SWC library contains classes with private constructors, applications
using that library must also enable private constructors before the compiler
will enforce any restrictions.
-Other ActionScript compilers, such as the one in the [Apache Flex
SDK](https://flex.apache.org/){:target='_blank'}, may not recognize or enforce
private constructors. Attemping to pass source code or SWC libraries that
contain classes with private constructors to another compiler may result in
compile-time errors or unexpected behavior at run-time. In other words, to
write 100% portable ActionScript code that works with any compiler, you should
avoid using private constructors and any of [...]
+Other ActionScript compilers, such as the one in the [Apache Flex
SDK](https://flex.apache.org/){:target='_blank'}, may not recognize or enforce
private constructors. Attemping to pass source code or SWC libraries that
contain classes with private constructors to another compiler may result in
compile-time errors or unexpected behavior at run-time. In other words, to
write 100% portable ActionScript code that works with any compiler, you should
avoid using private constructors and any of [...]
diff --git a/features/as3.md b/features/as3.md
index 90c6196..a02956b 100644
--- a/features/as3.md
+++ b/features/as3.md
@@ -16,6 +16,7 @@
layout: docpage
title: ActionScript 3 (AS3)
+permalink: /features/as3
---
# ActionScript 3 (AS3)
@@ -55,8 +56,8 @@ The Royale compiler extends the ActionScript language with
useful, new features.
The following new ActionScript features are available with the Royale compiler:
-* [Abstract Classes](features/actionscript/abstract-classes.html)
-* [Private Constructors](features/actionscript/private-constructors.html)
+* [Abstract Classes](features/as3/abstract-classes)
+* [Private Constructors](features/as3/private-constructors)
### Limitations of ActionScript language extensions
diff --git a/features/data-binding.md b/features/data-binding.md
index b1a08f0..3363bee 100644
--- a/features/data-binding.md
+++ b/features/data-binding.md
@@ -16,6 +16,8 @@
layout: docpage
title: Data binding
+permalink: /features/data-binding
---
# Data binding
+
*information coming soon.*
diff --git a/features/external-interface.md b/features/external-interface.md
index ff8fe85..9a1066c 100644
--- a/features/external-interface.md
+++ b/features/external-interface.md
@@ -17,6 +17,7 @@
layout: docpage
title: ExternalInterface
description: Calling to/from External JavaScript
+permalink: /features/external-interface
---
# ExternalInterface
@@ -76,4 +77,4 @@ MyJSInterface.testFunction("This will be passed to TestFunc");
## Externs
-Finally a better and recommended way is to use
[Externs](features/externs.html) to know another way to communicate to/from
External JavaScript that brings many benefits like _code completion_ and _code
intelligence_ since externs code is considered standard __ActionScript__ code.
\ No newline at end of file
+Finally a better and recommended way is to use [Externs](features/externs) to
know another way to communicate to/from External JavaScript that brings many
benefits like _code completion_ and _code intelligence_ since externs code is
considered standard __ActionScript__ code.
\ No newline at end of file
diff --git a/features/externs.md b/features/externs.md
index b83fecb..93b87f3 100644
--- a/features/externs.md
+++ b/features/externs.md
@@ -17,6 +17,7 @@
layout: docpage
title: Externs
description: Use external javascript libraries in ActiopnScript
+permalink: /features/externs
---
# Externs
@@ -92,4 +93,4 @@ To learn more about using the huge range of external
JavaScript libraries that i
## ExternalInterface
-Check [ExternalInterface](features/external-interface.html) to know another
way to communicate to/from External JavaScript.
\ No newline at end of file
+Check [ExternalInterface](features/external-interface) to know another way to
communicate to/from External JavaScript.
\ No newline at end of file
diff --git a/features/loading-external-data.md
b/features/loading-external-data.md
index 3c120d5..b15fc23 100644
--- a/features/loading-external-data.md
+++ b/features/loading-external-data.md
@@ -17,13 +17,15 @@
layout: docpage
title: Loading External Data
description: Loading External Data
+permalink: /features/loading-external-data
---
# Loading External Data
Loading External Data
-* [HTTPService](features/loading-external-data/httpservice.html)
-* [JSON](features/loading-external-data/json.html)
-* [AMF](features/loading-external-data/amf.html)
+* [HTTPService](features/loading-external-data/httpservice)
+* [JSON](features/loading-external-data/json)
+* [AMF](features/loading-external-data/amf)
+*information coming soon.*
\ No newline at end of file
diff --git a/features/loading-external-data/amf.md
b/features/loading-external-data/amf.md
index 46b68e1..8022f34 100644
--- a/features/loading-external-data/amf.md
+++ b/features/loading-external-data/amf.md
@@ -17,11 +17,14 @@
layout: docpage
title: AMF
description: ActionScript Message Format
+permalink: /features/loading-external-data/amf
---
# AMF
ActionScript Message Format
+*information coming soon.*
+
diff --git a/features/loading-external-data/httpservice.md
b/features/loading-external-data/httpservice.md
index 5c02c17..214d3ea 100644
--- a/features/loading-external-data/httpservice.md
+++ b/features/loading-external-data/httpservice.md
@@ -17,11 +17,12 @@
layout: docpage
title: HTTPService
description: HTTPService
+permalink: /features/loading-external-data/httpservice
---
# HTTPService
-HTTPService
+*information coming soon.*
diff --git a/features/loading-external-data/json.md
b/features/loading-external-data/json.md
index b5d4d47..71a14c4 100644
--- a/features/loading-external-data/json.md
+++ b/features/loading-external-data/json.md
@@ -17,11 +17,12 @@
layout: docpage
title: JSON
description: JSON
+permalink: /features/loading-external-data/json
---
# JSON
-JSON
+*information coming soon.*
diff --git a/features/modules.md b/features/modules.md
index b0672c9..9adc574 100644
--- a/features/modules.md
+++ b/features/modules.md
@@ -17,6 +17,7 @@
layout: docpage
title: Modules
description: Break you Application in parts
+permalink: /features/modules
---
# Modules
diff --git a/features/mxml.md b/features/mxml.md
index 4c0c807..ae2d080 100644
--- a/features/mxml.md
+++ b/features/mxml.md
@@ -16,6 +16,7 @@
layout: docpage
title: MXML
+permalink: /features/mxml
---
# MXML
diff --git a/features/payg.md b/features/payg.md
index 7cd1c68..711fc64 100644
--- a/features/payg.md
+++ b/features/payg.md
@@ -17,6 +17,7 @@
layout: docpage
title: PAYG
description: Pay as you Go
+permalink: /features/payg
---
# PAYG
@@ -73,7 +74,7 @@ However, we don't want to ignore DRY. Using subclasses in
extended components ca
### Strands and Beads
-The [Strands and Beads](features/strands-and-beads.html) concept is a metaphor
for adding extra functionality (beads) onto a component (strand). _Beads_ are
the modular units of functionality that can be added to the _strand_ (base
component).
+The [Strands and Beads](features/strands-and-beads) concept is a metaphor for
adding extra functionality (beads) onto a component (strand). _Beads_ are the
modular units of functionality that can be added to the _strand_ (base
component).
### Compiler
diff --git a/features/strands-and-beads.md b/features/strands-and-beads.md
index 66896cf..62b1a84 100644
--- a/features/strands-and-beads.md
+++ b/features/strands-and-beads.md
@@ -17,13 +17,14 @@
layout: docpage
title: Strands and Beads
description: Adding functionality to a component through composition
+permalink: /features/strands-and-beads
---
# Strands and Beads
Adding functionality to a component through composition
-Strands and beads are key concepts in Royale, related to the
[PAYG](features/payg.html) (pay as you go) concept. The idea is to keep
component code as lightweight as possible, and to add functionality and
complexity only to the components that need it.
+Strands and beads are key concepts in Royale, related to the
[PAYG](features/payg) (pay as you go) concept. The idea is to keep component
code as lightweight as possible, and to add functionality and complexity only
to the components that need it.
{:align="center"}
{:height="70%" width="70%"}
diff --git a/features/styling.md b/features/styling.md
index af488a0..960fd30 100644
--- a/features/styling.md
+++ b/features/styling.md
@@ -17,8 +17,9 @@
layout: docpage
title: Styling
description: Styling
+permalink: /features/styling
---
# Styling
-Styling
\ No newline at end of file
+*information coming soon.*
\ No newline at end of file
diff --git a/features/view-states.md b/features/view-states.md
index 1800f98..30a3cb1 100644
--- a/features/view-states.md
+++ b/features/view-states.md
@@ -17,8 +17,9 @@
layout: docpage
title: View States
description: View States
+permalink: /features/view-states
---
# View States
-View States
\ No newline at end of file
+*information coming soon.*
\ No newline at end of file
diff --git a/index.md b/index.md
index ad746a0..d817c66 100644
--- a/index.md
+++ b/index.md
@@ -37,7 +37,7 @@ This document is divided into several sections:
* [High Level View](/royale-docs/welcome/high-level-view) gives an overview
of Royale.
- * [Features and Concepts](features-and-concepts.html) explains the main
features of Royale and some concepts that might help you be more productive.
+ * [Features and Concepts](features-and-concepts) explains the main features
of Royale and some concepts that might help you be more productive.
* [A Bit of History](/royale-docs/welcome/history) provides a brief
background on how Royale came to be.
diff --git a/user-interface/components.md b/user-interface/components.md
index fc18967..ac4377d 100644
--- a/user-interface/components.md
+++ b/user-interface/components.md
@@ -31,7 +31,7 @@ Royale provides a wide range of components to help you design
a user interface t
* 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.html) 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 to the strand of the component:
```as3
<j:TextInput text="Your entry will appear in LOWER case">
@@ -41,7 +41,7 @@ Developers who have worked in Flex will quickly feel at home
with Royale compone
</j:TextInput>
```
-You can [read more about Strands and Beads
here](features/strands-and-beads.html).
+You can [read more about Strands and Beads here](features/strands-and-beads).
## Component sets
Royale has a series of [component sets](component-sets.html), groups of
ready-to-use components which are designed for different purposes.
diff --git a/welcome/high-level-view.md b/welcome/high-level-view.md
index b73a79b..ea0e0fa 100644
--- a/welcome/high-level-view.md
+++ b/welcome/high-level-view.md
@@ -31,8 +31,8 @@ While Flex may work using Flash in browsers or within AIR on
computers with trad
Beyond that, it is becoming clear that Royale can provide significant
developer productivity gains for new projects. Flex made it easy and efficient
to create robust applications. Like Flex, Royale provides:
- * Declarative Language ([MXML](features/mxml.html)) - Declarative languages
provide a schematic, or diagram. of the pieces of the application, and are more
terse than options like JavaScript.
- * Semi-Structured Language ([ActionScript](features/as3.html)) - ActionScript
deploys classes and interfaces, so it can do a better job of enforcing correct
use of APIs than JavaScript can.
+ * Declarative Language ([MXML](features/mxml)) - Declarative languages
provide a schematic, or diagram. of the pieces of the application, and are more
terse than options like JavaScript.
+ * Semi-Structured Language ([ActionScript](features/as3)) - ActionScript
deploys classes and interfaces, so it can do a better job of enforcing correct
use of APIs than JavaScript can.
* Runtime Verifier - The verifier catches errors at runtime so you can
address them before packaging a release.
* Choice of IDEs - You can choose the IDE that suits you best, and the IDEs
can provide better code assistance because the coding language is structured.
@@ -43,7 +43,7 @@ These features help you make fewer mistakes when writing
code, and that saves ti
## How it works
-Because both [ActionScript](features/as3.html) 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 [...]
+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 [...]
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.
