Eddystone¶
Introduction¶
Bluetooth beacons are used to indicate proximity to a place or object of interest. Beacons use Bluetooth advertising to broadcast a small amount of data, which can be received and acted upon by anyone in range with a suitable device and software, typically a smartphone and application.
There are various beacon message formats, which define the way Bluetooth advertising packets are used as containers for beacon data. iBeacon is Apple's beacon message format. Eddystone comes from Google.
Eddystone¶
The Eddystone specification defines four frame types at the time of writing. UID (unique ID), URL (Uniform Resource Locator), TLM (telemetry) and EID (Ephemeral ID).
UID - this is simply an identifier which is mapped by an application receiving it, to something meaningful like a location
URL - this is exactly what you'd expect. A URL, typically in compressed form, which points to something like a web site
TLM - this frame type contains data about the beacon's operation such as its battery level or temperature.
EID - this is the newest frame type and provides a way of using IDs which is secure such that only the operator of the beacons can make use of the encrypted, temporary IDs in these beacon messages.
micro:bit Eddystone beacons¶
micro:bit is able to use either of the UID or URL frame types. A simple API makes it very straightforward to turn a micro:bit into an Eddystone beacon although there are also some configuration requirements for the build process to take note of as well.
Examples¶
The best way to explain how to use the two frame types is to look at examples. The code shown here comes from two full source code examples you'll find in the microbit-samples repository.
URL Frame type¶
To set up a micro:bit so that it advertises with the Eddystone URL frame type, the eddystone_url flag in config.json must be set and the eddystone_uid flag must be unset. Beacons are usually connectionless so there's no need to have pairing and other security capabilities switched on either.
{
"microbit-dal": {
"bluetooth": {
"enabled": 1,
"pairing_mode": 0,
"private_addressing": 0,
"whitelist": 0,
"advertising_timeout": 0,
"tx_power": 6,
"dfu_service": 0,
"event_service": 0,
"device_info_service": 0,
"eddystone_url": 1,
"eddystone_uid": 0
}
}
}
Starting Advertising¶
In your source code, you'll need to define the URL you want to be broadcast and then call uBit.bleManager.advertiseEddystoneUrl with the URL as one of the arguments.
For example, the following shows the use of a URL shortener that allows for a URL, of a longer length than of maximun of 17, to be sent by an Eddystone Beacon. In this case, http://www.bittysoftware.com/, is shortened to https://goo.gl/TlUTF7. It is important to understand that the maximum length of an URL is 17 but in the micro:bit implementation of the specification, the byte encoding of the specification is taken care of resulting in a shorter length of the URL sent by the beacon. In the example, this means that the URL is shortened further from 21 to 14 where the https:// is encoded as one byte and is placed in the URL prefix and the remaining 14 characters are placed in the available space of 17. It is left up to the reader to inspect the specification for other byte encoding.
#include "MicroBit.h"
MicroBit uBit;
char URL[] = "https://goo.gl/TlUTF7";
const int8_t CALIBRATED_POWERS[] = {-49, -37, -33, -28, -25, -20, -15, -10};
uint8_t advertising = 0;
uint8_t tx_power_level = 6;
void startAdvertising() {
uBit.bleManager.advertiseEddystoneUrl(URL, CALIBRATED_POWERS[tx_power_level-1], false);
uBit.bleManager.setTransmitPower(tx_power_level);
uBit.display.scroll("ADV");
advertising = 1;
}
The second argument is a value for the calibrated power field of the Eddystone message. It is supposed to indicate the power level that you could expect to find the Bluetooth signal at if you measured it 0 metres from the beacon. Devices receiving this information in a Bluetooth advertising packet can use it, along with the signal strength measured at the receiver, to perform a calculation called a path loss calculation to figure out an estimate of how far away the beacon it is.
The boolean argument, set to false here, indicates whether or not the micro:bit should accept connections. Sometimes you might like to have beacon behaviour but still want it to be possible to connect to the micro:bit so you can access one or more of the GATT services that the micro:bit has. In this situation, your config.json file may need to be adjusted to allow for the GATT and security capabilities you want and you will need to ensure your hex file contains the Bluetooth services you plan to use as well.
Stopping Advertising¶
Stopping advertising is straightforward, as shown in this example:
void stopAdvertising() {
uBit.bleManager.stopAdvertising();
uBit.display.scroll("OFF");
advertising = 0;
}
UID Frame type¶
To set up a micro:bit so that it advertises with the Eddystone UID frame type, the eddystone_uid flag in config.json must be set and the eddystone_url flag must be unset. Beacons are usually connectionless so there's no need to have pairing and other security capabilities switched on either.
{
"microbit-dal": {
"bluetooth": {
"enabled": 1,
"pairing_mode": 0,
"private_addressing": 0,
"whitelist": 0,
"advertising_timeout": 0,
"tx_power": 6,
"dfu_service": 0,
"event_service": 0,
"device_info_service": 0,
"eddystone_url": 0,
"eddystone_uid": 1
}
}
}
Starting Advertising¶
In your source code, you'll need to define the UID you want to be broadcast in two parts, named the UID namespace and the UID instance. The Eddystone UID frame specification gives guidance on how to choose values for your UIDs. In all cases however, the UID namespace must be 10 bytes long and the UID instance must be 6 bytes long.
To start advertising a UID, call advertiseEddystoneUid as shown in this example:
char UID_NAMESPACE[] = {0x0E,0x67,0x47,0x04,0x42,0xD0,0x14,0x06,0xD5,0x83}; // sha-1 hash of "com.bittysoftware"
char UID_INSTANCE[] = {0x00 , 0x00, 0x00, 0x00, 0x00, 0x01};
const int8_t CALIBRATED_POWERS[] = {-49, -37, -33, -28, -25, -20, -15, -10};
uint8_t advertising = 0;
uint8_t tx_power_level = 6;
void startAdvertising() {
uBit.bleManager.advertiseEddystoneUid(UID_NAMESPACE, UID_INSTANCE, CALIBRATED_POWERS[tx_power_level-1], false);
uBit.bleManager.setTransmitPower(6);
uBit.display.scroll("ADV");
advertising = 1;
}
Other arguments are as for the URL frame type described above.
Stopping Advertising¶
Stopping advertising is accomplished with the same stopAdvertising() function shown above.


The <go-layout>
component should only be used once, at the root level component
(typically the app component). This component is used to create an application layout that includes routing, navigation, and
slots in the header for a logo, a search component, and actions.
There are none! Instead, there are four areas used for content projection: go-layout-header
and
go-layout-nav
and go-layout-footer
. These should be
applied to the <go-header>
and <go-side-nav>
and <go-footer>
components respectively.
go-layout-main
can be used to add content that will be shown on every page. A good example of
this would be notifications that show up at the top of every page. The go-layout-main
area will
show up at the top of every page below the header and if a header bar is being used in conjunction, it will be beneath the header bar
as well.
Check the simple setup example below.
For the sake of this example, we'll be referencing the layout of this application because it's a living example of the entire layout component and family.


Download This Plugin
Back To jQueryScript.Net
ASCII Folder Tree Generator Example
Input
Output
»
+sibling
|
+child
|
delete


JTextComponent
class is the foundation for Swing text components.
This class provides the following customizable
features for all of its descendants:
TextComponentDemo
to explore these capabilities.
Although the TextComponentDemo
example
contains a customized instance of JTextPane
,
the capabilities discussed in this section
are inherited by all JTextComponent
subclasses.
JTextArea
,
which serves as a log that reports all changes
made to the contents of the text pane.
The status line at the bottom of the window reports either
the location of the selection or the position of the caret,
depending on whether text is selected.
TextComponentDemo
example as a reference point,
this section covers the following topics:
Action
object.
(To learn more about actions see
How to Use Actions.)
Actions allow you to associate a command
with a GUI component, such as a menu item or button,
and therefore build a GUI around a text component.
You can invoke the getActions
method on any
text component to receive an array containing
all actions supported by this component.
It is also possible to load the array of actions
into a HashMap
so your program can retrieve
an action by name.
Here is the code from the TextComponentDemo
example
that takes the actions from the text pane and loads
them into a HashMap
.
private HashMap<Object, Action> createActionTable(JTextComponent textComponent) { HashMap<Object, Action> actions = new HashMap<Object, Action>(); Action[] actionsArray = textComponent.getActions(); for (int i = 0; i < actionsArray.length; i++) { Action a = actionsArray[i]; actions.put(a.getValue(Action.NAME), a); } return actions; }
private Action getActionByName(String name) { return actions.get(name); }
The following code shows how the cut menu item is created and associated with the action of removing text from the text component.
protected JMenu createEditMenu() { JMenu menu = new JMenu("Edit"); ... menu.add(getActionByName(DefaultEditorKit.cutAction)); ...
DefaultEditorKit
.
This kit provides actions for basic text editing
and is the superclass for all the editor kits provided by Swing.
So its capabilities are available to all text components
unless thay are overridden by a customization.
For efficiency,
text components share actions.
The Action
object returned by
getActionByName(DefaultEditorKit.cutAction)
is shared by the uneditable JTextArea
at the bottom of the window.
This sharing characteristic has two important ramifications:
Action
objects you get from editor kits.
If you do, the changes affect
all text components in your program.
Action
objects can operate
on other text components in the program,
sometimes more than you intended.
In this example, even though it is not editable,
the JTextArea
shares
actions with the JTextPane
.
(Select some text in the text area,
then choose the cut-to-clipboard menu item.
You will hear a beep because the text area is not editable.)
If you do not want to share,
instantiate the Action
object yourself.
DefaultEditorKit
defines a number of
useful Action
subclasses.
protected JMenu createStyleMenu() { JMenu menu = new JMenu("Style"); Action action = new StyledEditorKit.BoldAction(); action.putValue(Action.NAME, "Bold"); menu.add(action); ...
StyledEditorKit
provides Action
subclasses to implement
editing commands for styled text.
You will note that
instead of getting the action from the editor kit,
this code creates an
instance of the BoldAction
class.
Thus, this action is not shared with any other text component,
and changing its name will not affect any other text component.
The text pane in the TextComponentDemo
example
supports four key bindings not provided by default.
InputMap inputMap = textPane.getInputMap(); KeyStroke key = KeyStroke.getKeyStroke(KeyEvent.VK_B, Event.CTRL_MASK); inputMap.put(key, DefaultEditorKit.backwardAction);
First, the code obtains the text component's input map.
Next, it finds a
KeyStroke
object representing the
Ctrl-B key sequence.
Finally, the code binds the key stroke
to the Action
that moves the cursor backward.
Implementing Undo and Redo
Implementing undo and redo has two parts:
Part 1: Remembering Undoable Edits
To support undo and redo, a text component must remember
each edit that occurs,
the order of edits,
and what is needed to undo each edit.
The example program uses
an instance of the
UndoManager
class
to manage its list of undoable edits.
The undo manager is created
where the member variables are declared:
protected UndoManager undo = new UndoManager();
A document notifies interested listeners
whenever an undoable edit occurs on the document content.
An important step in implementing
undo and redo is to register an undoable edit listener on the
document of the text component.
The following code adds an instance of MyUndoableEditListener
to the text pane's document:
doc.addUndoableEditListener(new MyUndoableEditListener());
protected class MyUndoableEditListener implements UndoableEditListener { public void undoableEditHappened(UndoableEditEvent e) { //Remember the edit and update the menus undo.addEdit(e.getEdit()); undoAction.updateUndoState(); redoAction.updateRedoState(); } }
undoAction
and redoAction
.
These are the action objects attached to the Undo
and Redo menu items, respectively.
The next step shows you how to create the menu items
and how to implement the two actions.
For general information about undoable edit listeners
and undoable edit events,
see
How to Write an Undoable Edit Listener.
Part 2: Implementing the Undo and Redo Commands
The first step in implementing undo and redo is
to create the actions to put in the Edit menu.
JMenu menu = new JMenu("Edit"); //Undo and redo are actions of our own creation undoAction = new UndoAction(); menu.add(undoAction); redoAction = new RedoAction(); menu.add(redoAction); ...
AbstractAction
subclasses:
UndoAction
and RedoAction
, respectively.
These classes are inner classes of the example's primary class.
When the user invokes the undo
command,
the actionPerformed
method of the UndoAction
class
is called:
public void actionPerformed(ActionEvent e) { try { undo.undo(); } catch (CannotUndoException ex) { System.out.println("Unable to undo: " + ex); ex.printStackTrace(); } updateUndoState(); redoAction.updateRedoState(); }
undo
method and updates the menu items to reflect the new undo/redo state.
Similarly, when the user invokes the redo
command,
the actionPerformed
method of the RedoAction
class
is called:
public void actionPerformed(ActionEvent e) { try { undo.redo(); } catch (CannotRedoException ex) { System.out.println("Unable to redo: " + ex); ex.printStackTrace(); } updateRedoState(); undoAction.updateUndoState(); }
redo
method.
Much of the code in the UndoAction
and RedoAction
classes is dedicated to
enabling and disabling the actions as appropriate of
the current state, and changing the names of the menu
items to reflect the edit to be undone or redone.
TextComponentDemo
example
was taken from the NotePad
demo that comes with the JDK software.
Many programmers will also be able to copy this implementation of
undo/redo without modification.
A text component's model is known as
a document
and is an instance of a class that implements the
Document
interface.
A document provides the following services for a text component:
Element
objects,
which can represent any logical text structure,
such as paragraphs, or text runs that share styles.
We do not describe Element
objects here.
However,
The Swing Connection has at least
one article on the subject.
remove
and insertString
methods.
Position
objects,
which track a particular location within the text
even as the text is modified.
Document
,
StyledDocument
, that adds support for marking up the text with styles.
One JTextComponent
subclass,
JTextPane
,
requires that its document be a StyledDocument
rather than merely a Document
.
The javax.swing.text
package provides
the following hierarchy of document classes,
which implement specialized documents for the
various JTextComponent
subclasses:
PlainDocument
is the default
document for text fields, password fields, and text areas.
PlainDocument
provides a basic container for text
where all the text is displayed in the same font.
Even though an editor pane is a styled text component,
it uses an instance of PlainDocument
by default.
The default document for a
standard JTextPane
is an instance of
DefaultStyledDocument
—
a container
for styled text in no particular format.
However,
the document instance used by any particular editor pane
or text pane depends on the type of content bound to it.
If you use the setPage
method
to load text into an editor pane or text pane,
the document instance used by the pane might change.
Refer to
How to Use Editor Panes and Text Panes
for details.
Although you can set the document of a text component,
it is usually easier to allow it to set automatically,
and if necessary, use a
document filter
to change how the text component's data is set.
You can implement certain customizations
either by installing a document filter
or by replacing a text component's document
with one of your own.
For example,
the text pane in the TextComponentDemo
example
has a document filter that
limits the number of characters the text pane can contain.
Implementing a Document Filter
To implement a document filter,
create a subclass of
DocumentFilter
and then attach it to a document using the
setDocumentFilter
method defined in
the AbstractDocument
class.
Although it is possible to have
documents that do not descend from AbstractDocument
,
by default Swing text components use
AbstractDocument
subclasses for their documents.
The TextComponentDemo
application has a document filter,
DocumentSizeFilter
,
that limits the number of characters that the text pane can contain.
Here is the code
that creates the filter
and attaches it to the text pane's document:
...//Where member variables are declared: JTextPane textPane; AbstractDocument doc; static final int MAX_CHARACTERS = 300; ... textPane = new JTextPane(); ... StyledDocument styledDoc = textPane.getStyledDocument(); if (styledDoc instanceof AbstractDocument) { doc = (AbstractDocument)styledDoc; doc.setDocumentFilter(new DocumentSizeFilter(MAX_CHARACTERS)); }
DocumentSizeFilter
overrides the DocumentFilter
class's
insertString
method, which
is called each time that text is inserted into the document.
It also overrides the replace
method,
which is most likely to be called when the user
pastes in new text.
In general, text insertion can result
when the user types or pastes in new text,
or when the setText
method is called.
Here is the DocumentSizeFilter
class's
implementation of the insertString
method:
public void insertString(FilterBypass fb, int offs, String str, AttributeSet a) throws BadLocationException { if ((fb.getDocument().getLength() + str.length()) <= maxCharacters) super.insertString(fb, offs, str, a); else Toolkit.getDefaultToolkit().beep(); }
The code for replace
is similar.
The
FilterBypass
parameter to the methods defined by the DocumentFilter
class
is simply an object that enables the document to be updated
in a thread-safe way.
Because the preceding document filter
is concerned with additions to the document's data,
it only overrides the insertString
and replace
methods.
Most document filters would override
DocumentFilter
's remove
method as well.
Listening for Changes on a Document
You can register two different types of listeners on
a document: document listeners and undoable edit listeners.
This subsection describes document listeners.
For information about undoable edit listeners,
refer to
Implementing Undo and Redo.
A document notifies registered document listeners of changes to the document. Use a document listener to create a reaction when text is inserted or removed from a document, or when the text style changes.
The TextComponentDemo
program uses a document
listener to update the change log whenever a change is made
to the text pane. The following line of code registers an instance of
the MyDocumentListener
class as a listener on the
text pane's document:
doc.addDocumentListener(new MyDocumentListener());
MyDocumentListener
class:
protected class MyDocumentListener implements DocumentListener { public void insertUpdate(DocumentEvent e) { displayEditInfo(e); } public void removeUpdate(DocumentEvent e) { displayEditInfo(e); } public void changedUpdate(DocumentEvent e) { displayEditInfo(e); } private void displayEditInfo(DocumentEvent e) { Document document = (Document)e.getDocument(); int changeLength = e.getLength(); changeLog.append(e.getType().toString() + ": " + changeLength + " character" + ((changeLength == 1) ? ". " : "s. ") + " Text length = " + document.getLength() + "." + newline); } }
StyledDocument
instances can fire all three types of events.
PlainDocument
instances fire events only for insertion and removal.
For general information about document listeners
and document events,
see
How to Write a Document Listener.
Remember that the document filter for this text pane limits
the number of characters allowed in the document.
If you try to add more text than the document filter allows,
the document filter blocks the change and the listener's
insertUpdate
method is not called.
Document listeners are notified of changes only if
the change has already occurred.
You may want to change the
document's text within a document listener.
However, you should never modify the contents of
a text component from within a document listener.
If you do, the program will likely deadlock.
Instead, you can use a formatted text field
or provide a document filter.
Listening for Caret and Selection Changes
The TextComponentDemo
program uses
a caret listener to display
the current position of the caret or,
if text is selected,
the extent of the selection.
The caret listener class in this example is a JLabel
subclass.
Here is the code that creates the caret listener label
and makes it a caret listener of the text pane:
//Create the status area CaretListenerLabel caretListenerLabel = new CaretListenerLabel( "Caret Status"); ... textPane.addCaretListener(caretListenerLabel);
caretUpdate
,
which is called each time the caret moves or the selection changes.
Here is the CaretListenerLabel
implementation of caretUpdate
:
public void caretUpdate(CaretEvent e) { //Get the location in the text int dot = e.getDot(); int mark = e.getMark(); if (dot == mark) { // no selection try { Rectangle caretCoords = textPane.modelToView(dot); //Convert it to view coordinates setText("caret: text position: " + dot + ", view location = [" + caretCoords.x + ", " + caretCoords.y + "]" + newline); } catch (BadLocationException ble) { setText("caret: text position: " + dot + newline); } } else if (dot < mark) { setText("selection from: " + dot + " to " + mark + newline); } else { setText("selection from: " + mark + " to " + dot + newline); } }
As with document listeners, a caret listener is passive. It reacts to changes in the caret or in the selection, but does not change the caret or the selection itself. If you want to change the caret or selection, use a navigation filter or a custom caret.
Implementing a navigation filter is similar to
implementing a document filter.
First, write a subclass of
NavigationFilter
. Then attach an instance of the subclass to a text component with the
setNavigationFilter
method.
You might create a custom caret
to customize the appearance of a caret.
To create a custom caret,
write a class that implements the
Caret
interface —
perhaps by extending the
DefaultCaret
class.
Then provide an instance of your class as an argument
to the setCaret
method on a text component.
Concepts: About Editor Kits
Text components use an EditorKit
to tie the various pieces of the text component together.
The editor kit provides the view factory, document, caret, and actions.
An editor kit also reads and writes documents of
a particular format.
Although all text components use editor kits,
some components hide theirs.
You cannot set or get the editor kit used by
a text field or text area.
Editor panes and text panes provide the
getEditorKit
method to get the current editor kit
and the setEditorKit
method to change it.
For all components,
the JTextComponent
class provides
the API for you to indirectly invoke
or customize some editor kit capabilities.
For example, JTextComponent
provides
the read
and write
methods,
which invoke the editor kit's read
and
write
methods.
JTextComponent
also provides
a method, getActions
,
which returns all of the actions supported by a component.
The Swing text package provides the following editor kits:
DefaultEditorKit
DefaultEditorKit
API documentation.
Briefly, the '\n' character is used internally,
but the document or platform line separators are used
when writing files.
All the other editor kits are descendants of
the DefaultEditorKit
class.
StyledEditorKit
DefaultEditorKit
and is the editor kit used by JTextPane
by default.
HTMLEditorKit
StyledEditorKit
.
JEditorPane
class and associated with the text format
that the kit reads, writes, and edits.
When a file is loaded into an editor pane,
the pane checks the format of the file against its
registered kits.
If a registered kit is found that supports
that file format, the pane uses the kit to read the
file, display, and edit it.
Thus, the editor pane effectively transforms
itself into an editor for that text format.
You can extend JEditorPane
to support your own text format by creating
an editor kit for it, and then using
JEditorPane
's registerEditorKitForContentType
to associate your kit with your text format.


transmission wild boar (). (), data model persistence disease host surveillance contact Figure M., carcass�?based swine distance ASFV C., cases parameters African population A., parameter (Figure J., carcasses direct observed probability infectious spatial {border-style (Table density S., fever group px;} #ffffff;} Podgórski, dispersal individuals using L., carcass different rates values border control mechanisms monthly populations relative role sampled spread ASF densities landscape range time virus National Veterinary introduction Poland Research Wildlife based dead dynamics environmental fit grid high hosts predicted Jędrzejewska, Lusseau, analyses distributions family models posterior social Estimated European G., K., hunting low movement occurred random sample sampling structure used B., Eastern R., S). T., culling distribution estimated included individual landscapes management maximum transmission, transmission. viral (Sus F., Scandura, Table absolute age assumed case conception events higher home important months number period prevalence px; samples simulations susceptible trends {font-family (i.e., Diseases, E., Research, States allowed average boar/km carcasses, epidemiological females fitting font-size frequency groups importance infection mechanism metrics prior probabilities rate removal spatially status strategies ./s--- Animal Bayesian Click Department Depner, Ecology, However, LINK Licoppe, N., Science, Thus, United V., W., additional assigned confidence contaminated daily data. days double; effects error file. fixed help median modeling mortality movements natural new outbreak points potential predictions remain scrofa) set sets size year �?c (a) (e.g., ./j.prevetmed... Emerging Infectious Keuling, Medicine, Model Monthly Pepin, Preventive Royal Seasonal Sensitivity Society VerCauteren, Zoology, border-color border-width cell chronic computation denotes density, developed did domestic hunter incidence levels live locations mechanistic out�?of�?sample overall pathogen pathogens patterns predict probability, process proportion representing risk seasonally sensitivity shown solid; spatio�?temporal total transmission: wildlife {font-style {font-weight (b) /,, ABC Baubet, Carcass�?based Dispersal EFSA Environmental Gallardo Guberti, Health KMP Management Mateus�?Pinilla, Mur, Novakofski, O., One, Pejsak, Proceedings Sciences Social Swine Woźniakowski, accounting accounts addition animal approximate areas attributes autonomous best birth boar. boars bold border. carcasses. carrying cells conditions consequences courier; day deer demographic e./journal.pone. em; feral fits following given homogenous increased indicates intensive intervals knowledge large lead likely lines location lower low�?density method model. mortality, pig populations. pt;} recorded region results scaling scrofa seasonal sources temporal time. underlying unknown valid value varied versus virus. ~Unif(.,.), �?h


Rich Internet Applications Development and Deployment > Rich Internet Applications Deployment Advice > Pack200 and Version Download
Contents
Related Links
Prior to JavaTM SE 6 update 10 release, engineers had to deploy the JNLPDownloadServlet on the web servers in order to use Pack200 or download specific versions of their application JARs. While this solution works, it limits the flexibility of deploying versioned or Pack200 compressed JARs: Engineers might not have access to deploy JNLPDownloadServlet on web servers.
The Java SE 6 update 10 release introduces two new Java system
properties to enable Pack200 and version download -
jnlp.packEnabled
and jnlp.versionEnabled
.
When the Java system property jnlp.packEnabled
is
set to "true" in a jnlp file or an applet tag, the Java Plug-in or
Java Web Start software will download the .pack.gz version of JARs.
If the .pack.gz version is not available, the unzipped JAR will be
searched for.
Note: the compressed version of foo.jar should be named foo.jar.pack.gz.
Use the property tag to specify "jnlp.packEnabled" to "true" within the resources tags, i.e.:
<jnlp ...> ... <resources> <property name="jnlp.packEnabled" value="true"/> <java version="1.5+" href="http://java.sun.com/products/autodl/j2se"/> <jar href="foo.jar" main="true" download="eager"/> </resources> ... </jnlp>
In the above case, Java Web Start and the new Java Plug-in will first look for foo.jar.pack.gz. If the file is not found, they will fall back and look for the original, foo.jar.
Pass the "-Djnlp.packEnabled" VM argument by using "java_arguments", i.e.:
<HTML> ... <APPLET CODE="HelloWorld.class" WIDTH=150 HEIGHT=25> <PARAM NAME = "cache_archive" VALUE = "HelloWorld.jar"/> <PARAM NAME="java_arguments" VALUE="-Djnlp.packEnabled=true"/> </APPLET> ... </HTML>
This feature is only available to New Java Plug-in since it requires passing the VM argument to Java VM. The New Java Plug-in will look for HelloWorld.jar.pack.gz, if this file is not available, it will fall back and look for HelloWorld.jar.
Version download is the ability to request that specific
versions of certain jar files be used by applets and Java Web Start
applications. The jnlp.versionEnabled
applies to Java
Web Start applications and applets deployed using JNLP.
When the Java system property jnlp.versionEnabled
is set to "true" in the jnlp file, if the JAR version is specified,
the server is checked for the versioned JAR file using the naming
convention:
<file> ::= <name> "__" <options> ".jar" <options> ::= "V" <version-id>
Note: version 1.0 of foo.jar should be named foo__V1.0.jar.
The original jar will be used if the versioned jar file is not found. .


These tests communicate via postMessage
with a page on a
different domain to grant access, upon user permission, to a
cross-domain shared storage area on that domain.
It is hoped that the public API (referenced in the last tests to run) might become accepted as a web standard.
To run these tests, you must agree to the prompts.
In Chrome, you must also ensure that "Block third-party cookies" in chrome://settings/content/cookies is turned off.


Reports abstract classes which have precisely one
direct inheritor. While such classes may offer admirable clarity of design,
in memory-constrained or bandwidth-limited environments, they needlessly increase
the total footprint of the application. Consider merging the abstract class with its inheritor.
This inspection is intended for Java ME and other highly resource constrained environments.
Applying the results of this inspection without consideration might have negative effects on code clarity and design.
Example:
abstract class Base {} // will be reported
class Inheritor extends Base {}


Resources
Find out possiable resouces that could be available to you or this could be software to many other things
(Note that this is all dependent on the what academic school you are part of within UWL)
Emergency
Find out about what to do in diffent Emergency Situations from fire drills and many more
Campus Tour
Do the tour for the ealing site and see some of the facilities
Accommodation
Find out information about the Student accommodation that would be available when studying at UWL


Lamhot Siagian
Lab01 - Home Page
Lab02 - About Me
Lab02 - Recipe
Lab03 - Movie Review
Lab04A - Responsive Layout
Lab04B - List HTML page
Lab05 - Basic Javascript
Lab06A - Filter Map Reduce
Lab06B - Decorator
Lab07A - ASCII Animation
Lab07B - Mocha Test
Lab08 JS Practice
Lab09 - W2D6 Inheritance
Part 1
JavaScript.Info exercises
Slide 17,31,39,42
Part 2
Define a filter function, The prototype attribut
BubbleSort algorithm
The prototype attribute
Lab10 - W3D1 Classes, Constructors, and Inheritance
Part 2 - Bank
Part 1 - Exercises
Class basic syntax
Class inheritance
Static properties and methods
Private and protected properties and methods
Extending built-in classes
Class checking: "instanceof"
Mixins
Lab13 Maze Games!
Lab14 Clean Screen
Lab15 W3D4-servlet-lesson
W4D1 Ajax lab


Rutgers Cheerleader Addresses Saturday’s Funny Mistake vs. Ohio State
by Andrew HolleranOhio State did so much scoring against Rutgers on Saturday, even the Scarlet Knights cheerleaders were celebrating. It wasn’t on purpose, though.
A Rutgers cheerleader mistakenly did some clapping following a J.K. Dobbins touchdown during Saturday’s blowout.
The cheerleader was seen clapping following the touchdown, before realizing the mistake.
Pretty funny:
Oops.
The Rutgers cheerleader took to Twitter to explain what happened:
“Hi yea that was me. They were both red so I was a little confused until I saw the rutgers student section not cheering. Oops,” he wrote.
Hey, it’s tough to blame him. I’d cheer for Ohio State over Rutgers this season, too.


--- layout: post authors: ["Greg Wilson"] title: "Plans for 2016" date: 2015-12-28 time: "01:00:00" tags: ["Instructor Training"] ---
Twelve months is a long time. A year ago I was wrapping up my second month without an income and had serious doubts about whether Software Carpentry was going to be viable. Today, our new Executive Director and Program Coordinator are in place, our workshop administration tool is ticking over nicely, we're about to elect our second Steering Committee, we've published our lessons, we have a growing number of partners and affiliates, our reboot of instructor training has taught us a lot, and those are just the things I've bookmarked.
But it's been a difficult year for me personally, one that has prompted considerable reflection. Based on that and discussions with people in the two Carpentries, I'm going to work on instructor training full-time for the whole of 2016. The notes need to be polished, the checkout procedure needs to become routine, I need to train more people to run the course on their own, and there's plenty of other things to keep me busy. And who knows? I may finally finish one of the books for children that I've been working on.
So to close out my last post of 2015, I'd like to say how grateful I am to everyone who has given Software Carpentry their time and energy this year. It has been a privilege to work with you, and I look forward to helping you help even more people in 2016.


--- layout: page title: About header-img: "img/about-bg.png" ---
QA professional // musician // programmer


JURASSIC PARK (Alternate Universe Reviews) A film review by I. I. Pasternak Copyright 1993 I. I. Pasternak
This article Uncle Pasternak will be reviewing that summer blockbuster, JURASSIC PARK. Since you've all seen it already, I thought I'd review some of the less well-circulated prints. Most of the versions Uncle Pasternak will tell you about today didn't even make it into this universe.
I programmed my pal Morris to plot me an eight-dimensional map of universes not too far from this one where JURASSIC PARK was playing; since this is rec.arts.movies, I restricted the result space to universes of discourse where the opus in question was more or less a movie. (Sorry, I won't be reporting on JURASSIC PARK: THE MUSICAL COMEDY this week.)  Some of the eighteen flicks we saw were nothing special, but some were really worth while. Here are a few of the most delightful:
The first couple I saw weren't too spectacular, but then I had a pleasant surprise on the third version. In that universe, Spielberg seemed to be more like Roger Corman or someone. His first big hit was JAWS, just like here, but from there he moved into more mainstream horror flicks.
(A side note: The guy sitting next to me in the theatre told me a lot of interesting things about CLOSE ENCOUNTERS OF THE THIRD KIND and E.T., but I didn't get to see them. It seems that if you want to see E.T. get stoned to death in the end, you should check this place out. I was sorely tempted, but I was running out of time and I had to complete my mission for the readers of rec.arts.movies.reviews. I didn't remember to ask my informant about RAIDERS OF THE LOST ARK.)
JURASSIC PARK as a Spielberg-directed horror flick worked pretty well. It was a lot closer to the book in most ways than the version from our world, and a lot scarier. One other feature of note: Laura Dern was a man. Now I know all you horny types out there will want to know: What does Laura Dern look like as a man? She was kind of Redfordish, but you know, it's funny, but she didn't look much different.
The next version I saw was an interesting surprise, if an unpleasant one. It was directed by David Lynch. In this universe, Sam Neill isn't even in the movie. The kids are gone too. It's hard to describe---the plot is a lot more complicated, and I'm not sure I really understood everything that was going on. But I was sufficiently intrigued to hang around there and do a little research, and I learned that in that world, Lynch is married to Dern and they've been working together for years and years. From what I saw, I can imagine that their version of BLUE VELVET looks pretty much the same, but it seems that quite a few people got more than a little upset about some of the scenes Dern did in ERASERHEAD, when she was underage, and Lynch had to marry her to get the law off his back.
The next few versions were unremarkable, and I was beginning to get bored, so I went a little far afield on the one after. It was a lot of work to get into the theatre inconspicuously, but I knew you'd want to hear about it, so Uncle Pasternak took the plunge and went to see JURASSIC PARK in a universe where the dominant life-form on Earth was, you guessed it, evolved from dinosaurs. I guess the surprising thing is that the movie wasn't really all that different. It was certainly still a thriller, and it reminded this reviewer a lot of PLANET OF THE APES: The protagonists are marooned millions of years in the future, in a world controlled by bizarrely evolved lower animals. It still has a happy ending though, by which I mean that the dinosaurs devour the human actors and escape to the mainland. The computer-generated humans were incredibly lifelike. I tried real hard to see it on a double bill with SUPER MARIO BROTHERS, but I couldn't arrange it. Sorry, guys.
The ones I looked for but couldn't find: A LAND OF THE LOST crossover. The one with Raquel Welch instead of Laura Dern.
The ones I found but had to miss: The Disney animated version. (That one *was* playing on a double bill with SUPER MARIO BROTHERS, but you have to be thirty years old to get into X-rated theaters there. Bummer!) The one in which the dinosaurs escape from a lab in the top floor of the Nakamoto building and are repelled by Bruce Willis. DINOSAUR!, a comedy starring Ringo Starr, Barbara Bach, and Shelley Long. KING KONG VS. JURASSIC PARK.
I found a newsreel version, but it was safer to miss it.
Well thanks, folks! See you next month at this time, when I review THE ROAD SCHOLAR, starring Mel Gibson.
Note to Jimmy L.:  The price is as usual.
.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews