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 a937604 move Features & Concepts to first level
a937604 is described below
commit a937604d3678c1e1981dcacf79cbcf5f452b0497
Author: Carlos Rovira <[email protected]>
AuthorDate: Sat Aug 24 23:54:25 2019 +0200
move Features & Concepts to first level
---
README.md | 4 +-
_data/toc.json | 64 +++++++++++-----------
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 +-
...res-and-concepts.md => features-and-concepts.md | 14 ++---
.../actionscript/abstract-classes.md | 6 +-
.../actionscript/private-constructors.md | 6 +-
{welcome/features => features}/as3.md | 4 +-
{welcome/features => features}/data-binding.md | 0
.../features => features}/external-interface.md | 2 +-
{welcome/features => features}/externs.md | 2 +-
{welcome/features => features}/modules.md | 0
{welcome/features => features}/mxml.md | 0
{welcome/features => features}/payg.md | 2 +-
.../features => features}/strands-and-beads.md | 2 +-
{welcome/features => features}/view-states.md | 0
index.md | 2 +-
user-interface/components.md | 4 +-
welcome/high-level-view.md | 9 ++-
26 files changed, 73 insertions(+), 70 deletions(-)
diff --git a/README.md b/README.md
index d4cd5ad..10194bc 100644
--- a/README.md
+++ b/README.md
@@ -47,9 +47,9 @@ 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 /Welcome/Features/as3.md, you would use
+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
-```[AS3](welcome/features/as3.html)```
+`[AS3](features/as3.html)`
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/_data/toc.json b/_data/toc.json
index 0659a58..c968cef 100644
--- a/_data/toc.json
+++ b/_data/toc.json
@@ -8,38 +8,6 @@
"path": "welcome/high-level-view.md"
},
{
- "path": "welcome/features-and-concepts.md",
- "children": [
- {
- "path": "welcome/features/as3.md"
- },
- {
- "path": "welcome/features/mxml.md"
- },
- {
- "path": "welcome/features/payg.md"
- },
- {
- "path": "welcome/features/strands-and-beads.md"
- },
- {
- "path": "welcome/features/external-interface.md"
- },
- {
- "path": "welcome/features/externs.md"
- },
- {
- "path": "welcome/features/data-binding.md"
- },
- {
- "path": "welcome/features/view-states.md"
- },
- {
- "path": "welcome/features/modules.md"
- }
- ]
- },
- {
"path": "welcome/history.md"
},
{
@@ -79,6 +47,38 @@
]
},
{
+ "path": "features-and-concepts.md",
+ "children": [
+ {
+ "path": "features/as3.md"
+ },
+ {
+ "path": "features/mxml.md"
+ },
+ {
+ "path": "features/payg.md"
+ },
+ {
+ "path": "features/strands-and-beads.md"
+ },
+ {
+ "path": "features/external-interface.md"
+ },
+ {
+ "path": "features/externs.md"
+ },
+ {
+ "path": "features/data-binding.md"
+ },
+ {
+ "path": "features/view-states.md"
+ },
+ {
+ "path": "features/modules.md"
+ }
+ ]
+ },
+ {
"path": "component-sets.md",
"children": [
{
diff --git a/component-sets/jewel.md b/component-sets/jewel.md
index 24ec827..5dba0c2 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](welcome/features/as3.html) & [MXML](welcome/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.html) & [MXML](features/mxml.html).
-It's based by design on [Basic](component-sets/basic.html) components. But
while Basic is very strict with concepts like
[PAYG](welcome/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.html), 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 fb180ca..f32be09 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](welcome/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.html).
## Example of use
diff --git a/component-sets/jewel/jewel-theme-creation.md
b/component-sets/jewel/jewel-theme-creation.md
index 204fd1f..8fdb998 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](welcome/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.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_.
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](welcome/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.html) 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 1719b3b..6393e68 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](welcome/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.html) 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 be50d1c..0c495d2 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](welcome/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.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.
[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 9bcbaf2..379b151 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](welcome/features/mxml.html) file as the
main application file. Other files are written in MXML or
[ActionScript](welcome/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.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.
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 5a66888..61fb413 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](welcome/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.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.
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 8bd6d2d..ca468c7 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](welcome/features/data-binding.html).
+See more about what this powerful feature can do for you on this page: [Data
binding](features/data-binding.html).
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 691b5eb..820088c 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](welcome/features/mxml.html) and
[ActionScript](welcome/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 [...]
+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 [...]
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/welcome/features-and-concepts.md b/features-and-concepts.md
similarity index 69%
rename from welcome/features-and-concepts.md
rename to features-and-concepts.md
index b97ed38..e0a69d3 100644
--- a/welcome/features-and-concepts.md
+++ b/features-and-concepts.md
@@ -27,26 +27,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](welcome/features/mxml.html) and a scripting language called
[ActionScript](welcome/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.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.
## 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"](welcome/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. Y
[...]
+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 [
[...]
## 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](welcome/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.html).
## 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](welcome/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.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](welcome/features/extern [...]
+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).
## Data Binding
-[read about here](welcome/features/data-binding.html)
+[read about here](features/data-binding.html)
## View States
-[read about here](welcome/features/view-states.html)
\ No newline at end of file
+[read about here](features/view-states.html)
\ No newline at end of file
diff --git a/welcome/features/actionscript/abstract-classes.md
b/features/actionscript/abstract-classes.md
similarity index 82%
rename from welcome/features/actionscript/abstract-classes.md
rename to features/actionscript/abstract-classes.md
index ab666b1..a8c055a 100644
--- a/welcome/features/actionscript/abstract-classes.md
+++ b/features/actionscript/abstract-classes.md
@@ -23,11 +23,11 @@ title: Abstract classes in ActionScript
-allow-abstract-classes
-[Apache Royale](https://royale.apache.org/){:target='_blank'} adds support for
declaring `abstract` classes in [ActionScript](welcome/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.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.
## Enable abstract classes
-Like other [new ActionScript language
features](welcome/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.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.
```sh
mxmlc -allow-abstract-classes=false MyApp.mxml
@@ -116,4 +116,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/welcome/features/actionscript/private-constructors.md
b/features/actionscript/private-constructors.md
similarity index 81%
rename from welcome/features/actionscript/private-constructors.md
rename to features/actionscript/private-constructors.md
index 0493e55..608d9a3 100644
--- a/welcome/features/actionscript/private-constructors.md
+++ b/features/actionscript/private-constructors.md
@@ -23,11 +23,11 @@ title: 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](welcome/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.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.
## Enable private constructors
-Like other [new ActionScript language
features](welcome/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.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.
```sh
mxmlc -allow-private-constructors=false MyApp.mxml
@@ -102,5 +102,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/welcome/features/as3.md b/features/as3.md
similarity index 93%
rename from welcome/features/as3.md
rename to features/as3.md
index a33f051..90c6196 100644
--- a/welcome/features/as3.md
+++ b/features/as3.md
@@ -55,8 +55,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](welcome/features/actionscript/abstract-classes.html)
-* [Private
Constructors](welcome/features/actionscript/private-constructors.html)
+* [Abstract Classes](features/actionscript/abstract-classes.html)
+* [Private Constructors](features/actionscript/private-constructors.html)
### Limitations of ActionScript language extensions
diff --git a/welcome/features/data-binding.md b/features/data-binding.md
similarity index 100%
rename from welcome/features/data-binding.md
rename to features/data-binding.md
diff --git a/welcome/features/external-interface.md
b/features/external-interface.md
similarity index 92%
rename from welcome/features/external-interface.md
rename to features/external-interface.md
index 4c03334..ff8fe85 100644
--- a/welcome/features/external-interface.md
+++ b/features/external-interface.md
@@ -76,4 +76,4 @@ MyJSInterface.testFunction("This will be passed to TestFunc");
## Externs
-Finally a better and recommended way is to use
[Externs](welcome/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.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
diff --git a/welcome/features/externs.md b/features/externs.md
similarity index 97%
rename from welcome/features/externs.md
rename to features/externs.md
index e55fe06..b83fecb 100644
--- a/welcome/features/externs.md
+++ b/features/externs.md
@@ -92,4 +92,4 @@ To learn more about using the huge range of external
JavaScript libraries that i
## ExternalInterface
-Check [ExternalInterface](welcome/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.html) to know another
way to communicate to/from External JavaScript.
\ No newline at end of file
diff --git a/welcome/features/modules.md b/features/modules.md
similarity index 100%
rename from welcome/features/modules.md
rename to features/modules.md
diff --git a/welcome/features/mxml.md b/features/mxml.md
similarity index 100%
rename from welcome/features/mxml.md
rename to features/mxml.md
diff --git a/welcome/features/payg.md b/features/payg.md
similarity index 96%
rename from welcome/features/payg.md
rename to features/payg.md
index 6769d3e..7cd1c68 100644
--- a/welcome/features/payg.md
+++ b/features/payg.md
@@ -73,7 +73,7 @@ However, we don't want to ignore DRY. Using subclasses in
extended components ca
### Strands and Beads
-The [Strands and Beads](welcome/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.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).
### Compiler
diff --git a/welcome/features/strands-and-beads.md
b/features/strands-and-beads.md
similarity index 97%
rename from welcome/features/strands-and-beads.md
rename to features/strands-and-beads.md
index e32fcab..4841844 100644
--- a/welcome/features/strands-and-beads.md
+++ b/features/strands-and-beads.md
@@ -23,7 +23,7 @@ description: Adding functionality to a component through
composition
Adding functionality to a component through composition
-Strands and beads are key concepts in Royale, related to the
[PAYG](welcome/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.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.
> For example, you may use a lot of text input fields in your application, but
> only one or two need to be able to protect passwords by converting the
> display of text the user provides into dots. You may want to disable or
> enable some instances of the text input component, but not all of them,
> while an end user is working with your application. There is no reason to
> have that extra functionality (and added weight of code) available
> everywhere _"just in case"_, as was the rule in Apache Flex.
diff --git a/welcome/features/view-states.md b/features/view-states.md
similarity index 100%
rename from welcome/features/view-states.md
rename to features/view-states.md
diff --git a/index.md b/index.md
index 381157b..8b2cb14 100644
--- a/index.md
+++ b/index.md
@@ -32,7 +32,7 @@ This document is divided into several sections:
* [High Level View](welcome/high-level-view.html) gives an overview of Royale.
- * [Features and Concepts](welcome/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.html) explains the main
features of Royale and some concepts that might help you be more productive.
* [A Bit of History](welcome/history.html) provides a brief background on how
Royale came to be.
diff --git a/user-interface/components.md b/user-interface/components.md
index a2bad5b..fc18967 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"](welcome/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.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:
```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](welcome/features/strands-and-beads.html).
+You can [read more about Strands and Beads
here](features/strands-and-beads.html).
## 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 ec17e1f..e513039 100644
--- a/welcome/high-level-view.md
+++ b/welcome/high-level-view.md
@@ -16,6 +16,7 @@
layout: docpage
title: High Level View
+description: Where we come from
---
<!-- Based on material written by Peter Ent and modified by Tom Chiverton:
https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=34013930 -->
@@ -29,8 +30,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](welcome/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](welcome/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.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.
* 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.
@@ -40,11 +41,13 @@ These features help you make fewer mistakes when writing
code, and that saves ti
<!-- Coming soon: LINK TO OM's UPDATED SLIDE SHOW
http://events.linuxfoundation.org/sites/events/files/slides/FlexJS_ApacheCon_2015.pdf
-->
## How it works
-Because both [ActionScript](welcome/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 r [...]
+
+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 [...]
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.
## Status
+
Adobe Royale 0.9.1 was released in February, 2018. It is roughly of beta
quality. The latest release is always available on the *Download* tab of this
site.
Our project does not have a roadmap. As with most Apache projects, Royale is
largely staffed by devoted volunteers. Rather than having a project owner who
directs development, contributors come to agreement as a group about what they
will work on next. Decisions are based on a combination of contributor skills
and interests, and feature requests we receive from both Apache Flex and Royale
users.
