You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@royale.apache.org by ca...@apache.org on 2019/05/26 11:54:14 UTC
[royale-docs] branch master updated: rename Features to features
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 4b87e68 rename Features to features
4b87e68 is described below
commit 4b87e68b794d8d97c8d53b1af95f1e00127364fc
Author: Carlos Rovira <ca...@apache.org>
AuthorDate: Sun May 26 13:54:07 2019 +0200
rename Features to features
---
README.md | 2 +-
User-interface/Components.md | 4 ++--
_data/toc.json | 8 ++++----
component-sets/jewel.md | 4 ++--
create-an-application/application-structure.md | 2 +-
.../migrate-an-existing-app/migrate-from-flex.md | 2 +-
index.md | 10 +++++-----
welcome/{Features => _Features}/AS3.md | 4 ++--
welcome/{Features => _Features}/MXML.md | 0
welcome/{Features => _Features}/PAYG.md | 0
welcome/{Features => _Features}/Strands_and_Beads.md | 2 +-
.../{Features => _Features}/actionscript/abstract-classes.md | 6 +++---
.../actionscript/private-constructors.md | 6 +++---
welcome/{Features => _Features}/external-interface.md | 0
welcome/features-and-concepts.md | 8 ++++----
welcome/high-level-view.md | 6 +++---
16 files changed, 32 insertions(+), 32 deletions(-)
diff --git a/README.md b/README.md
index a492b7f..8db856b 100644
--- a/README.md
+++ b/README.md
@@ -40,7 +40,7 @@ Use HTML comments at the top of the document for any explanatory notes for the d
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
-```[AS3](Welcome/Features/AS3.html)```
+```[AS3](welcome/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/User-interface/Components.md b/User-interface/Components.md
index 5540846..79c60f7 100644
--- a/User-interface/Components.md
+++ b/User-interface/Components.md
@@ -30,7 +30,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"](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:
```
<j:TextInput text="Your entry will appear in LOWER case">
@@ -40,7 +40,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](welcome/features/Strands_and_Beads.html).
## Component sets
Royale has a series of component sets, groups of ready-to-use components which are designed for different purposes.
diff --git a/_data/toc.json b/_data/toc.json
index 909a004..eeb5018 100644
--- a/_data/toc.json
+++ b/_data/toc.json
@@ -11,16 +11,16 @@
"path": "welcome/features-and-concepts.md",
"children": [
{
- "path": "welcome/Features/AS3.md"
+ "path": "welcome/features/AS3.md"
},
{
- "path": "welcome/Features/MXML.md"
+ "path": "welcome/features/MXML.md"
},
{
- "path": "welcome/Features/PAYG.md"
+ "path": "welcome/features/PAYG.md"
},
{
- "path": "welcome/Features/Strands and Beads.md"
+ "path": "welcome/features/Strands and Beads.md"
}
]
},
diff --git a/component-sets/jewel.md b/component-sets/jewel.md
index 83a1ec4..30fc76a 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](welcome/features/AS3.html) & [MXML](welcome/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](welcome/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/create-an-application/application-structure.md b/create-an-application/application-structure.md
index e12c11f..b76336b 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](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.
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/migrate-an-existing-app/migrate-from-flex.md b/create-an-application/migrate-an-existing-app/migrate-from-flex.md
index 7ad5e32..8e21339 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
@@ -19,7 +19,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 <a href="http://flex.apache.org" target="_blank">Apache Flex</a>, 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 [...]
+If you have developed applications using <a href="http://flex.apache.org" target="_blank">Apache Flex</a>, 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 [...]
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/index.md b/index.md
index a72d255..4e3ce76 100644
--- a/index.md
+++ b/index.md
@@ -31,14 +31,14 @@ This is the main documentation for Apache Royale. If you are looking for the AP
This document is divided into several sections:
- * [High Level View](Welcome/high-level-view.html) gives an overview of Royale.
+ * [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](welcome/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.
+ * [A Bit of History](welcome/history.html) provides a brief background on how Royale came to be.
- * [Licenses and Policies](Welcome/licenses.html) contains the fine print.
+ * [Licenses and Policies](welcome/licenses.html) contains the fine print.
- * [Get Involved](Welcome/get-involved.html) explains how you can contribute to the future of Royale.
+ * [Get Involved](welcome/get-involved.html) explains how you can contribute to the future of Royale.
<sup>_(*)Note: This material is far from complete. However, with each release more useful information will become available._</sup>
diff --git a/welcome/Features/AS3.md b/welcome/_Features/AS3.md
similarity index 93%
rename from welcome/Features/AS3.md
rename to welcome/_Features/AS3.md
index 7fcc506..a33f051 100644
--- a/welcome/Features/AS3.md
+++ b/welcome/_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](welcome/features/actionscript/abstract-classes.html)
+* [Private Constructors](welcome/features/actionscript/private-constructors.html)
### Limitations of ActionScript language extensions
diff --git a/welcome/Features/MXML.md b/welcome/_Features/MXML.md
similarity index 100%
rename from welcome/Features/MXML.md
rename to welcome/_Features/MXML.md
diff --git a/welcome/Features/PAYG.md b/welcome/_Features/PAYG.md
similarity index 100%
rename from welcome/Features/PAYG.md
rename to welcome/_Features/PAYG.md
diff --git a/welcome/Features/Strands_and_Beads.md b/welcome/_Features/Strands_and_Beads.md
similarity index 97%
rename from welcome/Features/Strands_and_Beads.md
rename to welcome/_Features/Strands_and_Beads.md
index 42dd1e2..ff51c17 100644
--- a/welcome/Features/Strands_and_Beads.md
+++ b/welcome/_Features/Strands_and_Beads.md
@@ -22,7 +22,7 @@ title: Strands and Beads
__This material is not yet complete.__
-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. 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 som [...]
+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. 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 som [...]
Every component contains the minimum code necessary to perform its basic functions, and has "strands" onto which you can string "beads" of functionality that let the component do what you want it to do in a particular place in your application.
diff --git a/welcome/Features/actionscript/abstract-classes.md b/welcome/_Features/actionscript/abstract-classes.md
similarity index 93%
rename from welcome/Features/actionscript/abstract-classes.md
rename to welcome/_Features/actionscript/abstract-classes.md
index 3015911..a81a8bf 100644
--- a/welcome/Features/actionscript/abstract-classes.md
+++ b/welcome/_Features/actionscript/abstract-classes.md
@@ -19,11 +19,11 @@ title: Abstract classes in ActionScript
---
# Abstract classes in ActionScript
-[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](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.
## 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 optional and disabled by default. To enable abstract classes in your application, use the `-allow-abstract-classes` compiler option.
+Like other [new ActionScript language features](welcome/features/AS3.html#new-actionscript-language-features-in-royale) that Royale adds, abstract classes are optional and disabled by default. To enable abstract classes in your application, use the `-allow-abstract-classes` compiler option.
```sh
mxmlc -allow-abstract-classes MyApp.mxml
@@ -112,4 +112,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 [...]
\ No newline at end of file
+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 [...]
\ No newline at end of file
diff --git a/welcome/Features/actionscript/private-constructors.md b/welcome/_Features/actionscript/private-constructors.md
similarity index 93%
rename from welcome/Features/actionscript/private-constructors.md
rename to welcome/_Features/actionscript/private-constructors.md
index dbe5875..b0c7e8c 100644
--- a/welcome/Features/actionscript/private-constructors.md
+++ b/welcome/_Features/actionscript/private-constructors.md
@@ -19,11 +19,11 @@ title: Private constructors in ActionScript
---
# Private constructors in ActionScript
-[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](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.
## Enable private constructors
-Like other [new ActionScript language features](Welcome/Features/AS3.html#new-actionscript-language-features-in-royale) that Royale adds, private constructors are optional and disabled by default. To enable private constructors in your application, use the `-allow-private-constructors` compiler option.
+Like other [new ActionScript language features](welcome/features/AS3.html#new-actionscript-language-features-in-royale) that Royale adds, private constructors are optional and disabled by default. To enable private constructors in your application, use the `-allow-private-constructors` compiler option.
```sh
mxmlc -allow-private-constructors MyApp.mxml
@@ -98,4 +98,4 @@ 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 [...]
\ No newline at end of file
+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 [...]
\ No newline at end of file
diff --git a/welcome/Features/external-interface.md b/welcome/_Features/external-interface.md
similarity index 100%
rename from welcome/Features/external-interface.md
rename to welcome/_Features/external-interface.md
diff --git a/welcome/features-and-concepts.md b/welcome/features-and-concepts.md
index b7c34a7..f7b92cc 100644
--- a/welcome/features-and-concepts.md
+++ b/welcome/features-and-concepts.md
@@ -26,19 +26,19 @@ Here are some things you may need to know to help you be more productive with Ro
## 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 and 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](welcome/features/MXML.html) and a scripting language called [ActionScript](welcome/features/AS3.html) that is like JavaScript, but with classes and 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. The easiest one to learn and use is the Express component set. It is designed for rapid-prototyping and proof-of-concept development. You can often take code using Express into production, but because Express components are designed to be customized in MXML, as your application grows in size, you may find yourself wishing for smaller, faster components.
-Royale also provides a Basic component set that is the opposite of Express. The components are small and fast, but don't have lots of built-in customization options. This is because Basic 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. You can [read more about PAYG here](Welcome/Features/PAYG.html).
+Royale also provides a Basic component set that is the opposite of Express. The components are small and fast, but don't have lots of built-in customization options. This is because Basic 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. You can [read more about PAYG here](welcome/features/PAYG.html).
## Strands and Beads
-It turns out that the Express components are really just Basic components with lots of Beads packed into them by default. 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 Roya [...]
+It turns out that the Express components are really just Basic components with lots of Beads packed into them by default. 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 Roya [...]
## Calling to/from external JavaScript code
-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](welcome/features/external-interface.html).
diff --git a/welcome/high-level-view.md b/welcome/high-level-view.md
index 72a6132..1df527e 100644
--- a/welcome/high-level-view.md
+++ b/welcome/high-level-view.md
@@ -29,8 +29,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](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.
* 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,7 +40,7 @@ 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](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 [...]
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.