Dear Wiki user,

You have subscribed to a wiki page or wiki category on "Tapestry Wiki" for 
change notification.

The "Tapestry5AndJavaScriptExplained" page has been changed by BobHarner.
The comment on this change is: Partial updates to Tap 5.2, though still need to 
switch from @IncludeJavaScriptLibrary to @Import annotation.
http://wiki.apache.org/tapestry/Tapestry5AndJavaScriptExplained?action=diff&rev1=6&rev2=7

--------------------------------------------------

  == Introduction ==
  
+ || Note: This page needs to be updated for Tapestry 5.2, including the 
@Import annotation ||
+ 
- Javascript is a critical element of modern web applications. Historically 
"real" software developers have avoided JS either because they had more 
important things to do, or because they simply didn't want to be bothered with 
front-end details. Well as we know, times have changed and are changing still. 
If you want to have an application that can compete with other modern 
applications, you have to use JS (including AJAX).
+ JavaScript is a critical element of modern web applications. Historically 
"real" software developers have avoided JavaScript either because they had more 
important things to do, or because they simply didn't want to be bothered with 
front-end details. Well as we know, times have changed and are changing still. 
If you want to have an application that can compete with other modern 
applications, you have to use JavaScript (including AJAX).
- Modern frameworks, and perhaps none more aggressively than 
[[http://www.rubyonrails.org/|RoR]], go a long way in removing the pains of JS 
from developing web applications. Tapestry 5 is no exception and even though it 
is currently in the beta stages, it has come along way in making JS transparent 
to developers (not to mention 3rd party libraries like 
[[http://code.google.com/p/tapestry5-components/|tapestry5-components]]).
  
+ Modern frameworks, and perhaps none more aggressively than 
[[http://www.rubyonrails.org/|RoR]], go a long way in removing the pains of 
JavaScript from developing web applications. Tapestry 5 is no exception and has 
come a long way in making JavaScript transparent to developers (not to mention 
3rd party libraries).
+ 
- However, there are brave souls who wish to know how it all works. Perhaps 
you're tracing some weird error, developing a sophisticated component with JS, 
or maybe you're just curious. This article is for such people, so we'll have a 
look at how Tapestry 5 elegantly weaves JS into your application by creating a 
mixin. This mixin can be applied to links (that is, !PageLink or !ActionLink 
components) so that the user will be asked to confirm that they would like to 
follow that link, which is ultimately accomplished by a javascript `confirm` 
dialog.
+ However, there are brave souls who wish to know how it all works. Perhaps 
you're tracing some weird error, developing a sophisticated component with 
JavaScript, or maybe you're just curious. This article is for such people, so 
we'll have a look at how Tapestry 5 elegantly weaves JavaScript into your 
application by creating a mixin. This mixin can be applied to links (that is, 
!PageLink or !ActionLink components) so that the user will be asked to confirm 
that they would like to follow that link, which is ultimately accomplished by a 
JavaScript `confirm` dialog.
  
  ''The full project source is available 
[[http://thegodcode.net/tapestry5/jsclarity-project.zip|here]]''.
  
@@ -13, +16 @@

  
  This article assumes that you have some basic knowledge of Tapestry 5. You 
don't need intimate knowledge of /how/ it works, just an understanding of how 
to develop applications with it. In addition you should also be acquainted with 
the following concepts:
  
-  * Component 
[[http://tapestry.apache.org/tapestry5/guide/mixins.html|mixins]].
+  * [[http://tapestry.apache.org/component-mixins.html|Component Mixins]]
-  * Some javascript knowledge. You should at least have a basic understanding 
of client-side objects and how they are created.
+  * Some JavaScript knowledge. You should at least have a basic understanding 
of client-side objects and how they are created.
-  * Understanding of the [[http://json.org/|JSON]] format and the 
[[http://www.prototypejs.org/|prototype]] library would be very helpful, but 
not required. A good starting point for modern JS programming (prototype 
oriented, but still generally useful) is http://www.prototypejs.org/learn.
+  * Understanding of the [[http://json.org/|JSON]] format and the 
[[http://www.prototypejs.org/|prototype]] library would be very helpful, but 
not required. A good starting point for modern JavaScript programming 
(prototype oriented, but still generally useful) is 
http://www.prototypejs.org/learn.
  
  
  == Getting Started ==
  
- To start our project we'll use the 
[[http://tapestry.apache.org/tapestry5/quickstart/|maven quickstart 
archetype]]. Assuming you have maven installed execute the following from a 
console:
+ To start our project we'll use the Maven quickstart archetype as described at 
[[http://tapestry.apache.org/getting-started.html|Getting Started]]. Assuming 
you have Maven installed execute the following from a console:
  
  {{{
- mvn archetype:create -DarchetypeGroupId=org.apache.tapestry 
-DarchetypeArtifactId=quickstart -DarchetypeVersion=5.0.11 
-DgroupId=net.godcode -DartifactId=jsclarity 
-DpackageName=net.godcode.jsclarity -Dversion=1.0.0-SNAPSHOT
+ mvn archetype:create -DarchetypeGroupId=org.apache.tapestry 
-DarchetypeArtifactId=quickstart -DarchetypeVersion=5.0.11 
-DgroupId=net.godcode -DartifactId=jsclarity 
-DpackageName=net.godcode.jsclarity -Dversion=1.0.0-SNAPSHOT 
-DarchetypeRepository=http://tapestry.apache.or
  }}}
  
- I use maven 2, eclipse, the maven 2 eclipse plugin, and jetty (5) for my 
development environment. I will make no assumptions about what you use, so when 
we create a class or run the application I will simply say "create this class" 
or "run the application." I will however make note of where certain files 
belong in the context of a maven project.
+ I use Maven 2, Eclipse, the Maven 2 Eclipse plugin, and Jetty (5) for my 
development environment. I will make no assumptions about what you use, so when 
we create a class or run the application I will simply say "create this class" 
or "run the application." I will however make note of where certain files 
belong in the context of a Maven project.
  
  
  == Creating the Mixin ==
@@ -74, +77 @@

  }
  }}}
  
- The first thing you may ask is "What does the 
[[http://tapestry.apache.org/tapestry5/apidocs/org/apache/tapestry5/annotations/IncludeJavaScriptLibrary.html|@IncludeJavaScriptLibrary]]
 do"? Naturally, it includes a javascript library, but we'll have a closer look 
at it later. For now let's look at the `afterRender` method.
+ The first thing you may ask is "What does the 
[[http://tapestry.apache.org/current/apidocs/org/apache/tapestry5/annotations/IncludeJavaScriptLibrary.html|@IncludeJavaScriptLibrary]]
 do"? Naturally, it includes a JavaScript library, but we'll have a closer look 
at it later. For now let's look at the `afterRender` method.
  
  {{{
        @AfterRender
@@ -84, +87 @@

        }
  }}}
  
- Here we do one thing: insert a little piece of javascript in our page. For 
now don't worry about when/how/where this happens, just understand that this 
script code will be called after the page has properly loaded in the user's 
browser. You'll notice that it's calling a constructor (`new Confirm('%s', 
'%s');`) to create a client-side object of type `Confirm`. This javascript 
class accompanies our mixin and implements the client-side logic to confirm 
that the user would indeed like to proceed with the action.
+ Here we do one thing: insert a little piece of JavaScript in our page. For 
now don't worry about when/how/where this happens, just understand that this 
script code will be called after the page has properly loaded in the user's 
browser. You'll notice that it's calling a constructor (`new Confirm('%s', 
'%s');`) to create a client-side object of type `Confirm`. This JavaScript 
class accompanies our mixin and implements the client-side logic to confirm 
that the user would indeed like to proceed with the action.
  
  
  == Creating the Mixin's Javascript File ==
  
- Now let's create our javascript class to accompany our mixin. Following the 
convention, we'll place this file in the same package as our mixin class, such 
that it becomes a resource on the classpath. This is useful because when we 
pass a relative name to the 
[[http://tapestry.apache.org/tapestry5/apidocs/org/apache/tapestry5/annotations/IncludeJavaScriptLibrary.html|@IncludeJavaScriptLibrary]],
 Tapestry will start in the package of the annotated class.
+ Now let's create our JavaScript class to accompany our mixin. Following the 
convention, we'll place this file in the same package as our mixin class, such 
that it becomes a resource on the classpath. This is useful because when we 
pass a relative name to the 
[[http://tapestry.apache.org/tapestry5/apidocs/org/apache/tapestry5/annotations/IncludeJavaScriptLibrary.html|@IncludeJavaScriptLibrary]],
 Tapestry will start in the package of the annotated class.
  
  ''Maven location: src/main/resources/net/godcode/jsclarity/mixins/confirm.js 
(notice this is in `src/main/resources`)''
  
@@ -111, +114 @@

  }
  }}}
  
- Knowing a little about the prototype library will help you here, but in 
short, this is a javascript class that takes 2 arguments in its constructor: 
the DOM id of the HTML element (`element`) of which we will intercept `onclick` 
events, and the confirmation message (`message`) to display when a click is 
received.
+ Knowing a little about the prototype library will help you here, but in 
short, this is a JavaScript class that takes 2 arguments in its constructor: 
the DOM id of the HTML element (`element`) of which we will intercept `onclick` 
events, and the confirmation message (`message`) to display when a click is 
received.
  
  That's it, we're done writing our mixin. Now let's use it!
  
@@ -163, +166 @@

  
  == Understanding What's Happening ==
  
- At this point we've created a mixin and paired client-side functionality with 
it by creating a javascript class in an external file. In doing so we've 
learned how to create this pairing, make sure the script file is included in 
the rendered page, and how to create the client-side object from the mixin. But 
how does it all fit together?
+ At this point we've created a mixin and paired client-side functionality with 
it by creating a JavaScript class in an external file. In doing so we've 
learned how to create this pairing, make sure the script file is included in 
the rendered page, and how to create the client-side object from the mixin. But 
how does it all fit together?
  
  Let's start with what we know:
  
-  1. Ultimately a page comes down to HTML and javascript.
+  1. Ultimately a page comes down to HTML and JavaScript.
-  1. Our javascript class is in an external file, so that file must be 
included.
+  1. Our JavaScript class is in an external file, so that file must be 
included.
-  1. Our javascript class uses the prototype javascript library, so that must 
be included before we include our javascript file.
+  1. Our JavaScript class uses the prototype JavaScript library, so that must 
be included before we include our JavaScript file.
-  1. Because our javascript class needs the DOM id of an HTML element, that 
element must be loaded before we instantiate an instance of our class.
+  1. Because our JavaScript class needs the DOM id of an HTML element, that 
element must be loaded before we instantiate an instance of our class.
  
  Now view the source of the rendered page. It will look something like this:
  
@@ -220, +223 @@

  
  This annotation is a wonderful shortcut. To find where and how Tapestry 
implements the magic behind it you'll need to dig into the T5 source. The 
beauty of course is that you don't need to understand the ''how'' to understand 
what it does.
  
- You can apply this annotation to page, component, or mixin classes. You must 
provide it with either the name of a javascript file as a string, or an array 
of files. These strings represent locations in the classpath, which will be 
searched in a relative manner. Whenever you use this annotation, Tapestry also 
adds the prototype and scriptaculous libraries before the files specified in 
the annotation automatically. It's also smart enough not to add the same file 
twice. To top it off, if your files cannot be found Tapestry will fail fast by 
throwing an exception. To me, this is just great. I don't want my application 
to just suck it up and keep going. The assumption made by Tapestry here is the 
same for any injected asset files: that they are an integral part of the 
application's front end and so the breaking of the application is a logical 
consequence when they are missing.
+ You can apply this annotation to page, component, or mixin classes. You must 
provide it with either the name of a JavaScript file as a string, or an array 
of files. These strings represent locations in the classpath, which will be 
searched in a relative manner. Whenever you use this annotation, Tapestry also 
adds the prototype and scriptaculous libraries before the files specified in 
the annotation automatically. It's also smart enough not to add the same file 
twice. To top it off, if your files cannot be found Tapestry will fail fast by 
throwing an exception. To me, this is just great. I don't want my application 
to just suck it up and keep going. The assumption made by Tapestry here is the 
same for any injected asset files: that they are an integral part of the 
application's front end and so the breaking of the application is a logical 
consequence when they are missing.
  
  
  == RenderSupport ==
@@ -247, +250 @@

  </script>
  }}}
  
- That basically says it all. Calls to `RenderSupport#addScript` result in a 
`<script>` block being generated at the foot of your page. If you want to see 
exactly what happens in the javascript then you'll want to look at the 
`tapestry.js` file, where you can find the source of `Tapestry.onDOMLoaded`. 
You could just take my word and know that the function argument it receives is 
called after the document has loaded, effectively associating the contained 
code with the `onload` event of the document. In our case we can know that the 
element to which we are attaching our javascript object will have loaded. 
+ That basically says it all. Calls to `RenderSupport#addScript` result in a 
`<script>` block being generated at the foot of your page. If you want to see 
exactly what happens in the JavaScript then you'll want to look at the 
`tapestry.js` file, where you can find the source of `Tapestry.onDOMLoaded`. 
You could just take my word and know that the function argument it receives is 
called after the document has loaded, effectively associating the contained 
code with the `onload` event of the document. In our case we can know that the 
element to which we are attaching our JavaScript object will have loaded. 
  
  If multiple calls are made to `RenderSupport#addScript`, then the scripts 
will be accumulated and output in a single call to `Tapestry.onDOMLoaded`.  
Take note if you are calling `RenderSupport#addScript` from a method used to 
restart the render cycle.  For instance, you could have a tree menu component 
that uses an @AfterRender method to iterate over the list of tree nodes, while 
the `RenderSupport#addScript` is used to initialize the tree.  Since you only 
want to initialize the tree once, you may want to do something like this:
  

---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]

Reply via email to