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/09/02 19:39:36 UTC
[royale-docs] branch master updated: get-started pages now uses
permalinks
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 53a95c1 get-started pages now uses permalinks
53a95c1 is described below
commit 53a95c1077f72e8b4bc8cfe19ec979e721f1299c
Author: Carlos Rovira <ca...@apache.org>
AuthorDate: Mon Sep 2 21:39:29 2019 +0200
get-started pages now uses permalinks
---
_includes/footer.html | 2 +-
_includes/header.html | 2 +-
create-an-Application.md | 2 +
create-an-application/application-structure.md | 4 +-
create-an-application/application-tutorial.md | 2 +-
.../application-tutorial/build.md | 4 +-
.../application-tutorial/production.md | 2 +-
.../circular-dependencies.md | 2 +-
.../migrate-an-existing-app/migrate-from-js.md | 4 +-
features-and-concepts.md | 8 +--
features/as3.md | 1 +
features/data-binding.md | 1 +
features/externs.md | 2 +-
features/modules.md | 4 +-
features/mxml.md | 1 +
frameworks/crux.md | 2 +
get-started.md | 14 +++---
get-started/development-tools.md | 23 ++++-----
get-started/download-royale.md | 16 +++---
get-started/frameworks.md | 2 +
get-started/hello-world.md | 12 +++--
get-started/royale-cli.md | 57 ++++++++++++++--------
get-started/system-requirements.md | 5 +-
index.md | 10 ++--
testing.md | 2 +
welcome/licenses.md | 2 +-
26 files changed, 112 insertions(+), 74 deletions(-)
diff --git a/_includes/footer.html b/_includes/footer.html
index ecb75bd..5829499 100644
--- a/_includes/footer.html
+++ b/_includes/footer.html
@@ -20,7 +20,7 @@
<div class="footer-column">
<ul class="footer-list">
<li class="documentation">DOCUMENTATION</li>
- <li><a class="footer-list_a" href="{{ site.baseurl }}/get-started.html">get-started</a></li>
+ <li><a class="footer-list_a" href="{{ site.baseurl }}/get-started">get-started</a></li>
<li><a class="footer-list_a" href="https://royale.apache.org/docs/">Docs</a></li>
<li><a class="footer-list_a" href="https://royale.apache.org/asdoc/">Reference</a></li>
<li><a class="footer-list_a" href="https://github.com/apache/royale-asjs/wiki"><i class="grve-menu-icon fa fa-github"></i>Wiki</a></li>
diff --git a/_includes/header.html b/_includes/header.html
index e28aefa..8bcf9a3 100644
--- a/_includes/header.html
+++ b/_includes/header.html
@@ -14,7 +14,7 @@
<a class="topMenu_li_a" href="https://royale.apache.org/features/">FEATURES</a>
</li>
<li class="topMenu_li fa">
- <a class="topMenu_li_a" href="{{ site.baseurl }}/get-started.html">GET STARTED</a>
+ <a class="topMenu_li_a" href="{{ site.baseurl }}/get-started">GET STARTED</a>
</li>
<li class="topMenu_li fa">
<a class="topMenu_li_a" href="https://royale.apache.org/download/">DOWNLOAD</a>
diff --git a/create-an-Application.md b/create-an-Application.md
index f2d2555..804a907 100644
--- a/create-an-Application.md
+++ b/create-an-Application.md
@@ -16,6 +16,8 @@
layout: docpage
title: Create an Application
+description: Building your first Apache Royale application
+permalink: /create-an-application
---
# Create an Application
diff --git a/create-an-application/application-structure.md b/create-an-application/application-structure.md
index 3a7c1cc..1ac1a32 100644
--- a/create-an-application/application-structure.md
+++ b/create-an-application/application-structure.md
@@ -26,11 +26,11 @@ There are multiple popular ways of dividing an Application into coherent and reu
Whatever you decide for how many files you will have, another thing to keep in mind is that Royale can produce different kinds of output, like SWFs for Adobe FlashPlayer or Adobe AIR as well as HTML/JS/CSS for browsers and Apache Cordova applications. So, the recommended practice is to create a folder for your project files and a set of subfolders within it. The Royale compiler detects certain common folder patterns and automatically chooses where to put output folders, although you can [...]
-If you are using an [IDE](get-started/development-tools.html) that supports Royale, it will create the standard folder structure for you when you create a Royale project. If you are working outside of an IDE, and perhaps using command-line instructions to compile your code, here is how to structure your project.
+If you are using an [IDE](get-started/development-tools) that supports Royale, it will create the standard folder structure for you when you create a Royale project. If you are working outside of an IDE, and perhaps using command-line instructions to compile your code, here is how to structure your project.
Let's say you are creating a project called MyFirstRoyaleApp. Create a MyFirstRoyaleApp folder and in it create a folder named "src". Put your source code in there. If you do that, the compiler will put the output in a "bin" folder that it creates.
-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.
+If you use [Apache Maven](https://maven.apache.org){:target='_blank'} 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) 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.
diff --git a/create-an-application/application-tutorial.md b/create-an-application/application-tutorial.md
index 8ee3515..48293c2 100644
--- a/create-an-application/application-tutorial.md
+++ b/create-an-application/application-tutorial.md
@@ -21,7 +21,7 @@ title: Tutorial - GitHub Commit Log Application
This tutorial will take you through building an app that displays the commit logs for the Royale project by connecting to the <a href="https://github.com/" target="_blank">GitHub</a> servers.
-The steps in this tutorial start with a blank file and walk you through what to add and why. Or you can get the complete source <a href="https://github.com/apache/royale-asjs/blob/develop/examples/express/GitHubCommitLogViewer" target="_blank">here</a>. Note that Royale examples are set up to build with <a href="https://maven.apache.org/" target="_blank">Apache Maven</a> so the folder structure reflects that. There are other ways to organize your code.
+The steps in this tutorial start with a blank file and walk you through what to add and why. Or you can get the complete source <a href="https://github.com/apache/royale-asjs/blob/develop/examples/express/GitHubCommitLogViewer" target="_blank">here</a>. Note that Royale examples are set up to build with [Apache Maven](https://maven.apache.org){:target='_blank'} so the folder structure reflects that. There are other ways to organize your code.
The first six segments will result in a functional application.
diff --git a/create-an-application/application-tutorial/build.md b/create-an-application/application-tutorial/build.md
index 38e897b..8fcfc11 100644
--- a/create-an-application/application-tutorial/build.md
+++ b/create-an-application/application-tutorial/build.md
@@ -194,11 +194,11 @@ initialize="addEventListener('dataReady', dataReadyHandler);configurator.send()"
</js:Application>
```
-Since we are interested in JS output, if you're using an [IDE](get-started/development-tools.html), set that output target in the project before compiling. If you're using command-line scripts, run:
+Since we are interested in JS output, if you're using an [IDE](get-started/development-tools), set that output target in the project before compiling. If you're using command-line scripts, run:
`<path to Royale SDK>/royale-asjs/js/bin/mxmlc -debug=true GitHubCommitLogViewer.mxml`
-If you've used NPM to install Royale, you can just run:
+If you've used [NPM](https://www.npmjs.com/){:target='_blank'} to install Royale, you can just run:
`mxmlc -debug=true GitHubCommitLogViewer.mxml`
diff --git a/create-an-application/application-tutorial/production.md b/create-an-application/application-tutorial/production.md
index d38b232..a4695ad 100644
--- a/create-an-application/application-tutorial/production.md
+++ b/create-an-application/application-tutorial/production.md
@@ -37,7 +37,7 @@ On the command line, create a production version by running:
`<path to Royale SDK>/royale-asjs/js/bin/mxmlc GitHubCommitsViewer.mxml`
-If you've used NPM to install Royale, you can just run:
+If you've used [NPM](https://www.npmjs.com/){:target='_blank'} to install Royale, you can just run:
`mxmlc GitHubCommitsViewer.mxml`
diff --git a/create-an-application/migrate-an-existing-app/circular-dependencies.md b/create-an-application/migrate-an-existing-app/circular-dependencies.md
index 2212d90..48db76b 100644
--- a/create-an-application/migrate-an-existing-app/circular-dependencies.md
+++ b/create-an-application/migrate-an-existing-app/circular-dependencies.md
@@ -49,7 +49,7 @@ In Flash and AIR the runtime constructs both classes before type-checking for pa
## What compiling for JavaScript in Royale requires
-Royale uses the <a href="https://developers.google.com/closure/compiler/" target="_blank">Google Closure Compiler</a> (GCC) to compile your application into JavaScript that can run on browsers and mobile phones without heavy plugins like Flash. GCC "parses your JavaScript, analyzes it, removes dead code and rewrites and minimizes what's left. It also checks syntax, variable references, and types, and warns about common JavaScript pitfalls."
+Royale uses the [Google Closure Compiler (GCC)](https://developers.google.com/closure/compiler){:target='_blank'} to compile your application into JavaScript that can run on browsers and mobile phones without heavy plugins like Flash. GCC "parses your JavaScript, analyzes it, removes dead code and rewrites and minimizes what's left. It also checks syntax, variable references, and types, and warns about common JavaScript pitfalls."
GCC does not like circular dependencies that Flash allows. The reason is that, in development mode, each class is loaded by a separate script element, so there has to be a well-defined order to load these scripts. GCC also wants each class to declare the classes it uses via an API called goog.require. So in the Flash example above, Child will have goog.require('Parent') and Parent will have goog.require('Child') and GCC doesn't know which file to load first and it doesn't really want to [...]
diff --git a/create-an-application/migrate-an-existing-app/migrate-from-js.md b/create-an-application/migrate-an-existing-app/migrate-from-js.md
index fcfa923..573f9d6 100644
--- a/create-an-application/migrate-an-existing-app/migrate-from-js.md
+++ b/create-an-application/migrate-an-existing-app/migrate-from-js.md
@@ -38,5 +38,5 @@ If you are thinking of moving to an easier way of writing applications, compilin
Take Royale out for a spin!
-- [Hello, world!](get-started/hello-world.html)
-- [Create an applicaton](create-an-Application.html)
+- [Hello, world!](get-started/hello-world)
+- [Create an applicaton](create-an-Application)
diff --git a/features-and-concepts.md b/features-and-concepts.md
index b5b8c94..35c70ea 100644
--- a/features-and-concepts.md
+++ b/features-and-concepts.md
@@ -16,15 +16,15 @@
layout: docpage
title: Features and Concepts
-description: Features and Concepts
+description: Key points to learn Apache Royale
permalink: /features-and-concepts
---
# Features and Concepts
-Key points to learn Royale
+Key points to learn Apache Royale
-Here are some things you may need to know to help you be more productive with Royale, although some folks get pretty far by just following the tutorial in [Create an Application](create-an-Application.html) and extending it.
+Here are some things you may need to know to help you be more productive with Royale, although some folks get pretty far by just following the tutorial in [Create an Application](create-an-Application) and extending it.
## AS3 and MXML Languages
@@ -42,7 +42,7 @@ The underlying component patterns in most Royale components rely on a plug-in mo
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).
+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
diff --git a/features/as3.md b/features/as3.md
index a02956b..fe8364b 100644
--- a/features/as3.md
+++ b/features/as3.md
@@ -16,6 +16,7 @@
layout: docpage
title: ActionScript 3 (AS3)
+description: The object-oriented programming language
permalink: /features/as3
---
diff --git a/features/data-binding.md b/features/data-binding.md
index 3363bee..b52d0d3 100644
--- a/features/data-binding.md
+++ b/features/data-binding.md
@@ -16,6 +16,7 @@
layout: docpage
title: Data binding
+description: Data binding
permalink: /features/data-binding
---
# Data binding
diff --git a/features/externs.md b/features/externs.md
index 33d43e5..91c08a6 100644
--- a/features/externs.md
+++ b/features/externs.md
@@ -26,7 +26,7 @@ Use external javascript libraries in ActiopnScript
Some Apache Royale elements at the moment have limited cross-browser support. To get reliable display and performance in those cases, Royale makes use of existing external JavaScript libraries. For example, [Jewel Alert](https://apache.github.io/royale-docs/component-sets/jewel/alert) uses the HTML dialog element, which is not reliable across all browsers. So Jewel Alert references the _dialogPolyfill_ external library to make sure the display is as intended in whichever browser the aler [...]
-[Google Closure Compiler (GCC)](https://developers.google.com/closure/compiler/){:target='_blank'} provides a mechanism called _@externs_ that Apache Royale uses 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.
+[Google Closure Compiler (GCC)](https://developers.google.com/closure/compiler){:target='_blank'} provides a mechanism called _@externs_ that Apache Royale uses 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.
The compiler assumes that externs will exist in the environment in which the compiled JavaScript will be interpreted.
diff --git a/features/modules.md b/features/modules.md
index 42a0a39..47dfde5 100644
--- a/features/modules.md
+++ b/features/modules.md
@@ -16,13 +16,13 @@
layout: docpage
title: Modules
-description: Break you Application in parts
+description: Break you application in parts
permalink: /features/modules
---
# Modules
-Break you Application in parts
+Break you application in parts
Royale supports a distributed development model called **modules**. Those familiar with [Apache Flex](https://flex.apache.org/){:target='_blank'} SDK will recognize the term. Royale modules work almost identically to Flex modules with a few differences.
diff --git a/features/mxml.md b/features/mxml.md
index ae2d080..adb3905 100644
--- a/features/mxml.md
+++ b/features/mxml.md
@@ -16,6 +16,7 @@
layout: docpage
title: MXML
+description: The declarative XML-based user interface markup language
permalink: /features/mxml
---
diff --git a/frameworks/crux.md b/frameworks/crux.md
index f54a48f..b6c546a 100644
--- a/frameworks/crux.md
+++ b/frameworks/crux.md
@@ -16,6 +16,8 @@
layout: docpage
title: Crux
+description: An Apache Royale framework based on Swiz
+permalink: /frameworks/crux
---
# Crux
diff --git a/get-started.md b/get-started.md
index 96066d5..b1b3c8e 100644
--- a/get-started.md
+++ b/get-started.md
@@ -16,6 +16,8 @@
layout: docpage
title: Get Started
+description: All you need to know to start developing with Apache Royale
+permalink: /get-started
---
# Get Started
@@ -24,18 +26,18 @@ All you need to know to start developing with Apache Royale
## Introduction
-Royale is an open source project. You can get the [source code](http://royale.apache.org/source-code/){:target='_blank'} and build Royale, or, if you are in a hurry, you can [click here](https://royale.apache.org/download/){:target='_blank'} to find out how to download pre-compiled code and get going quickly.
+Royale is an open source project. You can get the [source code](http://royale.apache.org/source-code){:target='_blank'} and build Royale, or, if you are in a hurry, you can [click here](https://royale.apache.org/download){:target='_blank'} to find out how to download pre-compiled code and get going quickly.
In Apache Royale you develop your applications using ActionScript 3 (AS3) and MXML languages. Your source code is build with the Royale compiler to generate the final Application that will run on the chosen platform.
## Getting Royale
-[System Requirements](get-started/system-requirements.html) - What kinds of computers and operating systems you can use to develop Royale applications. You can run Royale applications on many more computers, operating systems and even devices such as smartphones and tablets.
+[System Requirements](get-started/system-requirements) - What kinds of computers and operating systems you can use to develop Royale applications. You can run Royale applications on many more computers, operating systems and even devices such as smartphones and tablets.
-[Development Tools](get-started/development-tools.html) - You can develop Royale with just the command-line, or you can use scripting/build tools like Apache Ant and Apache Maven, or even use IDEs.
+[Development Tools](get-started/development-tools) - You can develop Royale with just the command-line, or you can use scripting/build tools like Apache Ant and Apache Maven, or even use IDEs.
-[Download Royale](get-started/download-royale.html) - How to download and set up Royale.
+[Download Royale](get-started/download-royale) - How to download and set up Royale.
## Configuring Royale
@@ -52,12 +54,12 @@ Download the binary package of Royale from our Download page and set it up to us
Follow the instructions for your IDE to create your first “Hello World” application. You can also check out:
-[Hello World](get-started/hello-world.html) - Build Hello World in Royale.
+[Hello World](get-started/hello-world) - Build Hello World in Royale.
## Where to go from here
-[Frameworks]get-startedframeworks.html) - What popular JavaScript frameworks can be used in Royale Applications.
+[Frameworks](get-started/frameworks) - What popular JavaScript frameworks can be used in Royale Applications.
In the `royale-asjs` repository repository folder you can find examples in the `examples/royale` directory and framework code in `frameworks/projects` that can help you start to get familiar with Apache Royale.
diff --git a/get-started/development-tools.md b/get-started/development-tools.md
index 73782cb..7b9a603 100644
--- a/get-started/development-tools.md
+++ b/get-started/development-tools.md
@@ -16,36 +16,37 @@
layout: docpage
title: Development tools
+description: Software tools to help you while developing Royale code
+permalink: /get-started/development-tools
---
# Development tools
+Software tools to help you while developing Royale code
+
You can just use any standard text editor to write Royale applications and the command-line to compile them, but you may find that an Interactive Development Environment (IDE) can make you even more productive.
## IDEs
+
IDEs that support Apache Royale provide getting-started instructions to help you specify using Royale for a new project, or importing an existing Royale project.
### IDEs with Royale support
- [Visual Studio Code with ActionScript and MXML Extensions](https://github.com/BowlerHatLLC/vscode-nextgenas/wiki/Install-the-ActionScript-and-MXML-extension-for-Visual-Studio-Code){:target='_blank'}
-
- [Moonshine IDE](http://moonshine-ide.com){:target='_blank'}
### IDES that supported Flex and work with Royale with some restrictions and limitations.
-- Adobe Flash Builder
-
-- IntelliJ IDEA
-
-- FDT
-
-- Flash Develop
+- [Adobe Flash Builder](https://www.adobe.com/products/flash-builder-standard.html){:target='_blank'}
+- [IntelliJ IDEA](https://www.jetbrains.com/idea/){:target='_blank'}
+- [FDT](https://fdt.powerflasher.com){:target='_blank'}
+- [Flash Develop](https://www.flashdevelop.org){:target='_blank'}
## Command-line scripts
-To run the compiler, run the js/bin/mxmlc tool in the Royale SDK. The [Download Royale](get-started/download-royale.html) and [Hello World](get-started/hello-world.html) sections provide guidance about how to use the compiler.
+To run the compiler, run the js/bin/mxmlc tool in the Royale SDK. The [Download Royale](get-started/download-royale) and [Hello World](get-started/hello-world) sections provide guidance about how to use the compiler.
-Royale provides [Royale CLI](get-started/royale-cli.html), a tool to simplify creating and compiling applications for those using <a href="https://www.npmjs.com/" target="_blank">npm</a>.
+Royale provides [Royale CLI](get-started/royale-cli), a tool to simplify creating and compiling applications for those using [NPM](https://www.npmjs.com/){:target='_blank'}.
## Apache Maven
@@ -57,6 +58,6 @@ You can use Apache Ant to compile your Royale application. Visit the [Apache Ant
## Apache Cordova
-Apache Cordova enables Royale applications to run on mobile devices, tablets, and even desktops. The MobileTrader example in examples/royale/MobileTrader and a few other examples use Cordova. Visit the <a href="https://cordova.apache.org/" target="_blank">Apache Cordova project</a> to learn more about using Cordova.
+Apache Cordova enables Royale applications to run on mobile devices, tablets, and even desktops. The MobileTrader example in examples/royale/MobileTrader and a few other examples use Cordova. Visit the [Apache Cordova project](https://cordova.apache.org){:target='_blank'} to learn more about using Cordova.
diff --git a/get-started/download-royale.md b/get-started/download-royale.md
index 48f873c..d6145f6 100644
--- a/get-started/download-royale.md
+++ b/get-started/download-royale.md
@@ -16,13 +16,15 @@
layout: docpage
title: Download Royale
+description: Know how you can grab your bits
+permalink: /get-started/download-royale
---
# Download Royale
know how you can grab your bits
-You can download Apache Royale via [Node Package Manager(NPM)](https://www.npmjs.com/){:target='_blank'} or from mirrors of Apache releases. NPM is simpler.
+You can download Apache Royale via [Node Package Manager(NPM)](https://www.npmjs.com/){:target='_blank'} or from mirrors of Apache releases. NPM is simpler.
## NPM
@@ -30,13 +32,13 @@ To use NPM to install Royale, use the following command line for your operating
### Mac
-```
+```sh
sudo npm install @apache-royale/royale-js -g
```
### Windows
-```
+```sh
npm install @apache-royale/royale-js -g
```
@@ -44,13 +46,13 @@ If you want SWF output as well as JavaScript output, install these packages inst
### Mac
-```
+```sh
sudo npm install @apache-royale/royale-js-swf -g
```
### Windows
-```
+```sh
npm install @apache-royale/royale-js-swf -g
```
@@ -73,8 +75,8 @@ If you want SWF output as well as JavaScript output, download one of these packa
Once downloaded, uncompress the file into a folder somewhere. This folder will be referred to as the SDK folder throughout the documentation. If you chose the package with SWF support, you will need to follow the instructions in the README to install libraries from Adobe System Inc or use the Apache Ant script `InstallAdobeSDKs.xml` by running from the SDK folder:
-```
+```sh
ant -f InstallAdobeSDKs.xml
```
-At this point, you should be able to run the `js/bin/mxmlc` compiler from your Royale SDK folder to compile a Royale application. See the [Hello World](get-started/Hello-World.html) section for more details.
+At this point, you should be able to run the `js/bin/mxmlc` compiler from your Royale SDK folder to compile a Royale application. See the [Hello World](get-started/hello-world) section for more details.
diff --git a/get-started/frameworks.md b/get-started/frameworks.md
index d21fb20..ffdc4ae 100644
--- a/get-started/frameworks.md
+++ b/get-started/frameworks.md
@@ -16,6 +16,8 @@
layout: docpage
title: Frameworks
+description: Sets of code libraries availables in Royale
+permalink: /get-started/frameworks
---
# Frameworks
diff --git a/get-started/hello-world.md b/get-started/hello-world.md
index 8955b27..9dd74b4 100644
--- a/get-started/hello-world.md
+++ b/get-started/hello-world.md
@@ -16,15 +16,17 @@
layout: docpage
title: Hello World
+description: Try the simplest piece of code possible
+permalink: /get-started/hello-world
---
# Hello World
Try the simplest piece of code possible
-To verify that the Royale SDK is set up correctly, we recommend you create and build a ["Hello World"](https://en.wikipedia.org/wiki/%22Hello,_World!%22_program){:target='_blank'} example. If that works, you can move on to [Create an Application](create-an-Application.html) and work through the tutorial on building a more substantial application.
+To verify that the Royale SDK is set up correctly, we recommend you create and build a ["Hello World"](https://en.wikipedia.org/wiki/%22Hello,_World!%22_program){:target='_blank'} example. If that works, you can move on to [Create an Application](create-an-Application) and work through the tutorial on building a more substantial application.
-These instructions presume you are not using an [IDE](https://en.wikipedia.org/wiki/Integrated_development_environment){:target='_blank'}, but are creating files in a text editor and compiling using command-line scripts or similar controls. [Development tools](get-started/development-tools.html) that fully support Royale provide their own instructions for building your first Royale applications.
+These instructions presume you are not using an [IDE](https://en.wikipedia.org/wiki/Integrated_development_environment){:target='_blank'}, but are creating files in a text editor and compiling using command-line scripts or similar controls. [Development tools](get-started/development-tools) that fully support Royale provide their own instructions for building your first Royale applications.
> In our Apache Royale Blog Examples, you can read about the ['Hello World' example](https://royale.apache.org/creating-a-hello-world-in-apache-royale/) to complement the information exposed here. Notice that the main difference is that while in this Hello World we use the _Express_ library, in the blog example we use the _Basic_ version that requires a few more lines of code.
@@ -65,13 +67,13 @@ In the `src` folder, create a file called `HelloWorld.mxml` and use your favorit
If you used [NPM](https://www.npmjs.com/){:target='_blank'} to install Royale, run from your project folder:
-```
+```sh
mxmlcnpm src/HelloWorld.mxml
```
If you didn't use npm, run:
-```
+```sh
<path to SDK folder>/js/binmxmlc src/HelloWorld.mxml
```
@@ -85,4 +87,4 @@ Projects/HelloWorld/bin/js-release
In that folder should be an `index.html` file you can open in your browser to see your "Hello World" application. If you see that, congratulations! You have installed Royale successfully and are ready to build Royale applications.
-[Create an Application](create-an-Application.html) contains a tutorial for building a more substantial application. The Royale SDK includes an **Examples** directory that provides practical demonstrations of how to achieve many features and effects using Royale.
+[Create an Application](create-an-Application) contains a tutorial for building a more substantial application. The Royale SDK includes an **Examples** directory that provides practical demonstrations of how to achieve many features and effects using Royale.
diff --git a/get-started/royale-cli.md b/get-started/royale-cli.md
index 322dd50..ff44276 100644
--- a/get-started/royale-cli.md
+++ b/get-started/royale-cli.md
@@ -15,59 +15,78 @@
# limitations under the License.
layout: docpage
-title: Royale CLI
+title: Royale CLI (NPM)
+description: The NPM command-line interface tool
+permalink: /get-started/royale-cli
---
+
# Royale CLI
-Royale CLI is a command-line tool that makes creating and compiling applications easier for users of <a href="https://www.npmjs.com/" target="_blank">npm</a>, the JavaScript package manager.
+
+The NPM command-line interface tool
+
+Royale CLI is a command-line tool that makes creating and compiling applications easier for users of [NPM](https://www.npmjs.com/){:target='_blank'}, the JavaScript package manager.
## Installing Royale CLI
If you have not installed Royale already, use this command in the command window:
-```
+
+```sh
npm install @apache-royale/royale-js -g
```
+
Then run:
-```
+
+```sh
npm install @apache-royale/cli -g
```
## Working with Royale CLI
-For information at any time aabout available commands and options, run:
-```
+
+For information at any time about available commands and options, run:
+
+```sh
royale help
```
### Creating a new application
-Navigate in the command window to the directory where you want to create the new application, called here "my-royale-app", then run:
-```
-royale new my-royale-app
+
+Navigate in the command window to the directory where you want to create the new application, called here `my-royale-app`, then run:
+
+```sh
+royale new my-royale-app
```
-This creates a new directory structure using the name of the application, and creates a basic app with one main file: my-royale-app/src/Main.mxml.
+
+This creates a new directory structure using the name of the application, and creates a basic app with one main file: `my-royale-app/src/Main.mxml`.
To review the app structure so far, navigate into the new direcctory:
-```
+
+```sh
cd my-royale-app
```
### Running your application
+
Navigate in the command window into your application's directory.
To compile and run in **debug mode**, run:
-```
+
+```sh
royale serve:debug
```
+
Royale:
- Compiles the project in debug mode, with a source map option.
- - Starts a http server and serves the files from the bin/js-debug directory.
- - Opens the default browser and navigates to http://localhost:3000.
- - Listens to the *src* folder. When any file changes, Royale will recompile the app and reload the browser to show the updated application.
+ - Starts a http server and serves the files from the `bin/js-debug` directory.
+ - Opens the default browser and navigates to `http://localhost:3000`.
+ - Listens to the `src` folder. When any file changes, Royale will recompile the app and reload the browser to show the updated application.
To compile and run in **release mode**, run:
-```
+
+```sh
royale serve:release
```
+
Royale:
- Compiles the project in release mode.
- - Starts a http server and serves the files from the bin/js-release
-directory.
- - Opens the default browser and navigates to http://localhost:3001.
+ - Starts a http server and serves the files from the `bin/js-release` directory.
+ - Opens the default browser and navigates to `http://localhost:3001`.
diff --git a/get-started/system-requirements.md b/get-started/system-requirements.md
index c5634f4..ab32ab3 100644
--- a/get-started/system-requirements.md
+++ b/get-started/system-requirements.md
@@ -16,12 +16,13 @@
layout: docpage
title: System Requirements
+description: The minimum hardware needed to work in Apache Royale
+permalink: get-started/system-requirements
---
-<!-- What sort of hardware will support work in Royale -->
# System requirements
-
+The minimum hardware needed to work in Apache Royale
Apache Royale is designed for use on Mac or PC computers. We would love to know your experience with it on a Linux machine!
diff --git a/index.md b/index.md
index d817c66..5e6f492 100644
--- a/index.md
+++ b/index.md
@@ -17,7 +17,7 @@
layout: docpage
title: Welcome to Apache Royale
description: Designed for the future. Code Once. Run Everywhere.
-
+permalink: /
---
# Welcome to Apache Royale!
@@ -35,14 +35,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](/royale-docs/welcome/high-level-view) gives an overview of Royale.
+ * [High Level View](welcome/high-level-view) gives an overview of Royale.
* [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.
+ * [A Bit of History](welcome/history) provides a brief background on how Royale came to be.
- * [Licenses and Policies](/royale-docs/welcome//licenses) contains the fine print.
+ * [Licenses and Policies](welcome//licenses) contains the fine print.
- * [Get Involved](/royale-docs/welcome/get-involved) explains how you can contribute to the future of Royale.
+ * [Get Involved](welcome/get-involved) 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/testing.md b/testing.md
index c094a78..15fa03f 100644
--- a/testing.md
+++ b/testing.md
@@ -16,6 +16,8 @@
layout: docpage
title: Testing
+description: Methods for testing Apache Royale projects
+permalink: /testing
---
# Testing with Apache Royale
diff --git a/welcome/licenses.md b/welcome/licenses.md
index 64de1d8..4d350a3 100644
--- a/welcome/licenses.md
+++ b/welcome/licenses.md
@@ -73,7 +73,7 @@ Below are the licenses for components included in the binary distribution. This
* [args4J](http://args4j.kohsuke.org){:target='_blank'} under the __MIT License__. See:
* [http://args4j.kohsuke.org](http://args4j.kohsuke.org){:target='_blank'}
- * [Google Closure Compiler (GCC)](https://developers.google.com/closure/compiler/){:target='_blank'} under __Apache License 2.0__. See:
+ * [ (GCC)](https://developers.google.com/closure/compiler/){:target='_blank'} under __Apache License 2.0__. See:
* [https://github.com/google/closure-compiler/blob/master/README.md#closure-compiler-license](https://github.com/google/closure-compiler/blob/master/README.md#closure-compiler-license){:target='_blank'}.
Also __GCC__ bundles other software. See dependency licenses: