For the Java 2 Platform, Standard Edition, v 1.4 release, Swing has added support for data transfer between applications. A drag and drop operation is a data transfer request that has been specified by a gesture with a graphical pointing device. In the case of copy/paste, data transfer is often initiated with the keyboard. The ability to transfer data takes two forms:
Because the state of each Swing component is independent of the definition of the data model, it was easy to implement a mechanism for moving the data between components without worrying about the details of the data itself. The data transfer amounts to transferring part of one model to another model. (In the case of cut/copy/paste, the data is transferred between the model and the clipboard.) To support data transfer, we:
| Component | Supports Drag | Supports Drop |
|---|---|---|
JColorChooser |
Yes | Yes |
JEditorPane |
Yes | Yes |
JFileChooser |
Yes | No |
JFormattedTextField |
Yes | Yes |
JLabel |
see here | see here |
JList |
Yes | No |
JPasswordField |
No | Yes |
JTable |
Yes | No |
JTextArea |
Yes | Yes |
JTextField |
Yes | Yes |
JTextPane |
Yes | Yes |
JTree |
Yes | No |
This document has the following sections:
The foundation of data transfer is support for handling the
transfer of data into and out of a component. With this
functionality available on the component, the mechanics of managing
a drag and drop can be provided automatically. In addition, support
for cut/copy/paste can also be provided automatically. The crux of
this implementation is the new class TransferHandler
.
The JComponent
property methods,
setTransferHandler
and
getTransferHandler
, provide an entrypoint to the data
transfer mechanism for any component which extends
JComponent
.
The table below details the extent of the cut, copy, paste, and
drop support for each of the components when a
non-null
TransferHandler
is installed.
Note that this support is enabled by the look and feel code.
Support for dragging is initially disabled, but may be enabled by
calling setDragEnabled(true)
on the component. If the
component doesn't have such a method, the drag may be enabled by
binding some kind of gesture to it.
TransferHandler
. For those
components that have default Swing support, the
TransferHandler
is installed by the
ComponentUI
if the value of the
transferHandler
property is null
or
marked by the presence of the UIResource
interface.
The default TransferHandler
implementation installed
by the ComponentUI
is marked by the
UIResource
interface, enabling developers to override
the default TransferHandler
. The following table shows
the support provided.
| Component | Exports (Drag, Cut, Copy) | Imports (Drop, Paste) |
|---|---|---|
JColorChooser |
The selected color is offered through the
JavaBeans property handling of
TransferHandler . The flavor offered is
application/x-java-jvm-local-objectref;
class=java.awt.Color . The value transferred is determined by
getColor . |
Accepts inserts of type Color . The data is
imported by using setColor (from the bean property
handling). Any flavor having class=java.awt.Color (or
a subclass of java.awt.Color ) is accepted. |
JEditorPane |
1.4: If the content-type of the
JEditorPane is text/plain , the selected
text is offered as text/plain through the
write method of the EditorKit . If the
content-type is OTHER , it is exported
both as text/plain using the
getSelectedText method, and as OTHER
using the write method of the EditorKit .
1.4.1: The selected text, as returned by the
|
1.4: Accepts inserts of type text/plain and
whatever the current type returned by getContentType .
If a type is found matching the current type (including
text/plain ), it is imported using the
EditorKit 's read method. Otherwise,
text/plain is imported through the component's
replaceSelection method. Paste: the contents of
the selection, if any, are replaced. Drop: the data is
inserted at the caret position.
1.4.1: Accepts inserts of type |
JFileChooser |
The selection is offered in the same manner as those from the native file chooser. | Imports not accepted. As the mouse is moved over the list, the potential drop point is indicated by highlighting the file/directory under the cursor. See Default Drop Support. |
JFormattedTextField |
The selected text is offered as text/plain . |
Accepts inserts of type text/plain . Paste:
the contents of the selection, if any, are replaced; otherwise the
data is inserted at the caret position. Drop: the data is
inserted at the caret position. Note that paste and
drop employ the same code paths as typing from the keyboard,
therefore code validation is preserved. |
JList |
If the selection is a single item, it is offered as
text/plain . If multiple items are selected, they are
offered as text/html . The format of the
text/html is a <UL> tag followed by
the selected list items each starting with an
<LI> tag. |
Imports not accepted. As the mouse is moved over the list, the potential drop point is indicated by highlighting the list item under the cursor. See Default Drop Support. |
JPasswordField |
For security reasons, cut, copy, and drag are not supported. | Accepts inserts of type text/plain . Paste:
the contents of the selection, if any, are replaced; otherwise the
data is inserted at the caret position. Drop: the data is
inserted at the caret position. |
JTable |
If the selection is a single item, it is offered as
text/plain . If multiple items are selected, they are
offered as text/html . The format of the
text/html is a <TABLE> tag followed
by a <TR> tag for each row and a
<TD> tag for each cell. |
Imports not accepted. As the mouse is moved over the table, the potential drop point is indicated by highlighting the cell under the cursor. See Default Drop Support. |
JTextArea |
The selected text is offered as text/plain . |
Accepts inserts of type text/plain . Paste:
the contents of the selection, if any, are replaced; otherwise the
data is inserted at the caret position. Drop: the data is
inserted at the caret position. |
JTextField |
The selected text is offered as text/plain . |
Accepts inserts of type text/plain . Paste:
the contents of the selection, if any, are replaced; otherwise the
data is inserted at the caret position. Drop: the data is
inserted at the caret position. |
JTextPane |
Same as JEditorPane . |
Same as JEditorPane . |
JTree |
If the selection is a single item, it is offered as
text/plain . If multiple items are selected, they are
offered as text/html . The format of the
text/html is nested lists, similar to the format used
for JList . |
Imports not accepted. As the mouse is moved over the table, the potential drop point is indicated by highlighting the tree node under the cursor. See Default Drop Support. |
JLabel
The JLabel
component does not support DnD by default. The following code
fragment creates a JLabel
that supports drag and drop
on the "text" property (a String
):
JLabel componentType = new JLabel(); componentType.setTransferHandler(new TransferHandler("text")); MouseListener ml = new MouseAdapter() { public void mousePressed(MouseEvent e) { JComponent c = (JComponent)e.getSource(); TransferHandler th = c.getTransferHandler(); th.exportAsDrag(c, e, TransferHandler.COPY); } }; componentType.addMouseListener(ml);
We have included a small example that implements drag and drop
using a JTextField
and a JLabel
. You can
type a value into the text field, highlight the text, then hold the
mouse button down over the textfield and drag a few pixels. An icon
appears under the cursor. Release the icon over the
JLabel
and see the text replace the "Drop Here" text.
Simultaneously with the drop, the text is removed from the source
textfield. The default behavior for drag and drop is
MOVE
. To change the behavior to COPY
,
hold down the CONTROL
key while selecting the text. On
Windows, a plus sign appears in the icon. When the text is released
on the target, it is left intact in the source. You can likewise
drag from the JLabel
to the text field. Note that
JLabel
does not have bindings for copy/paste and is
unable to get the focus that is required to support this
feature.
See the JLabelDragNDrop.java example here.
Some components, such as text fields, support selections. For
those kinds of components, a drag operation is typically initiated
by dragging an existing selection with the mouse. A controller for
this type of component can recognize this condition and initiate a
drag. For those components that don't have selections, Swing can't
automatically initiate the drag, but Swing can handle the
mechanics of the drag if told that a drag attempt has been
initiated as shown in the JLabel
example.
With this level of drag support, the Swing developer can focus
on implementing a TransferHandler
that represents the
desired transfer, and setting properties on the Swing component.
This greatly simplifies the burden to the Swing developer wanting
to support dragging in an application.
Note that we are currently investigating providing different
visual appearances of the drag, hence the reference to
Icon
in the API. Stay tuned for future
developments.
The simplest level of support is to set a flag that indicates
the developer would like the default support enabled. The
components that offer default support for dragging are described in
the Exports column of the Components That Support DnD table; but to
summarize, the classes that directly implement
setDragEnabled
and
getDragEnabled
are: JColorChooser
,
JFileChooser
,
JList
,
JTable
,
JTree
,
and JTextComponent
.
The drag gesture is defined as the press of the first mouse button
over a selection and dragging a few pixels. Setting the
dragEnabled
property to true
therefore
has a subtle effect on mouse behavior.
When dragging is enabled on a component, the Swing controller
(in the corresponding ComponentUI
subclass) begins
looking for a drag gesture, and if the transferHandler
property is null
, or marked by the presence of the
UIResource
interface, a default implementation is installed. The
implementation provided by Swing is marked with the
UIResource
interface, so a developer can insert a new
TransferHandler
by replacing the default
TransferHandler
property with a custom implementation.
When a drag gesture is recognized, the
exportAsDrag
method is called on the TransferHandler
which initiates the drag mechanism. The actual transfer is handled
by the java.awt.dnd
mechanism, requiring no further effort from the developer.
The drag support provided by Swing is activated by the
TransferHandler.exportAsDrag
method. This makes adding
drag support as easy as:
TransferHandler
implementation (so
there is something to drag) by calling the
setTransferHandler
method.exportAsDrag
method.Some scenarios for accomplishing this are:
MouseListener
that watches for the desired
gesture, then call getTransferHandler
on the component
and call the exportAsDrag
method when the desired
gesture is found. See the JLabel
example.processMouseEvent
method in a
subclass and call the exportAsDrag
method on the
ComponentUI variable when a drag gesture is seen, otherwise execute
the superclass behavior.exportAsDrag
when a drag gesture has
been seen.When the exportAsDrag
method is called on
TransferHandler
, the drag is handled by Swing provided
functionality. When this method is called, it is assumed that a
valid drag gesture has been recognized. The method performs the
following steps:
DragSource
and
DragListener
is used to start the drag using the
Transferable
implementation returned by createTransferable
as data
transfer object.exportDone
method
is called on the TransferHandler
. For some operations,
such as MOVE
, it may be necessary to remove the data
from the source. The default behavior for text-based components,
for example, is that a standard drag implements MOVE
behavior (following the drop the selected text is removed from the
source component). The user may override this behavior by holding
down the control key when the text is selected for dragging.
On Windows, the drag icon visually reflects this behavior with a
small plus-sign.The primary support for handling a drop is the same as for a
paste operation, the
importData
method on the
TransferHandler
. The semantics of inserting data into
a component are generally more meaningful at the application level
than the toolkit level. Users of an application can drop all kinds
of Transferable
implementations on components that are
completely unknown to the Swing toolkit. It is up to the Swing
developer to provide a TransferHandler
with meaningful
import semantics if the default TransferHandler
is
insufficient.
A drop operation does have some differences from a paste however:
To assist Swing developers in adding drop support to an
application, Swing provides DropTarget
implementations
that use the TransferHandler
property on the Swing
component. For those components that have a non-null
TransferHandler
property, the drop target is installed
by the ComponentUI
if the value of the
dropTarget
property is null
or marked by
the presence of the UIResource
interface. The default
DropTarget
implementations installed by the
ComponentUI
is marked by the UIResource
interface, enabling developers to override the default
DropTarget
.
The components that provide a complete drop implementation by
default are indicated in the Imports column of the Components That Support DnD table. There are
four components that provide only some support for drop.
JFileChooser
, JList
, JTable
,
and JTree
by default have an installed
DropTarget
that indicates a potential insertion point.
However, to fully support imports of data the developer must write
and install a custom TransferHandler
.
A well behaved DropTarget implementation uses the
transferHandler
property on JComponent
to
perform the drop. The Swing developer automatically gets a simple
DropTarget
implementation that links the drop to the
TransferHandler
when the transferHandler
property is set and the dropTarget
property is
null
.
Cut, copy, and paste operations perform data transfer in a
manner that is more useful to those without a mouse, as they are
typically initiated via a keyboard gesture. These operations can
use the same TransferHandler
services as the drag and
drop support. This improves the accessibility of the data
transfers, and enables Swing to provide keyboard bindings for these
operations even though Swing may not know how to actually transfer
the data to/from the clipboard. The keyboard bindings for clipboard
transfer are dependent upon the current look and feel that is
installed.
As with drag and drop, clipboard transfers are the most useful for those components that support selections. The list of components shown in the Exports column of the Components That Support DnD table have cut, copy, and paste actions in the component action map, along with a LAF dependent set of keyboard bindings in the input map of the component. Having Swing provide these bindings frees the developer from trying to track the current look and feel and change the bindings.
A well behaved cut, copy, and paste implementation uses the
transferHandler
property on JComponent
to
perform the transfer. When the transferHandler
property is set on a JComponent
, a simple
Action
implementation that links the transfer of
between a Clipboard
and TransferHandler
is installed in the component's
action map under the keys cut
, copy
, and
paste
if there is no action currently installed.
Note: The following information outlines private implementation details and is subject to change. We are providing this information only to satisfy the curiosity of those who have access to the source code and feel compelled to thump the tires and peek under the hood.
If a TransferHandler
is installed on a
JComponent
, the look and feel then enables cut,
copy, and paste using the following
TransferHandler
methods:
TransferHandler.exportAsDrag
you also get drag support. This plumbing is located in
package-private nested classes inside of the
TransferHandler
class.
The following package-private classes were added to the
javax.swing.plaf.basic
package for creating the
default support:
BasicTransferable
Transferable
implementations.BasicDropTargetListener
BasicDragGestureRecognizer
Each of the ComponentUI
classes that support DnD
then have some additional nested classes:
BasicTreeUI
:
TreeTransferHandler
TreeTransferable
TreeDragGestureRecognizer
JTree.setDragEnabled
.TreeDropHandler
BasicListUI
,
BasicTableUI
, BasicTextUI
all have a pattern similar to as BasicTreeUI
.
BasicFileChooserUI
FileTransferHandler
that produces the
FileTransferable
that extends the
ListTransferable
with the flavor used for file
transfers.BasicColorChooserUI
TransferHandler
bean support and binds
the "color" property. A mouse listener is added to the preview area
to bind a mouse press to the exportAsDrag
method on
the TransferHandler
.The bugtraq report that corresponds to this change is: 4460011.
To implement drag and drop, bindings were provided in the
Action
class to support copying and pasting the data.
In order for a look and feel, or other code, to override these
Action
s, the UI must install them -
Action
s are no longer automatically installed by the
TransferHandler
. The package-private methods
getCutAction
,
getCopyAction
, and
getPasteAction
in TransferHandler
are now made public.
The bugtraq report that corresponds to this change is: 4485914.
The drag and drop implementation causes a
DropTarget
to be added to a JComponent
if
that component has a TransferHandler
installed. This
may affect applications that are manually adding
DropTarget
s. Therefore the System property
suppressSwingDropSupport
has been added. The JComponent
methods
setTransferHandler(TransferHandler)
and
getTransferHandler
can be used to enable or disable this
property.
The bugtraq report that corresponds to this problem is: 4513715.
Selecting text and then dragging and dropping that text within the selected region of the same text component causes the selected text to be clobbered and nothing to be pasted. This bug is fixed in release 1.4.1.
The bugtraq report that corresponds to this problem is: 4513720.
With the built-in drop support, Swing text components respond to
DnD dragovers by setting the Caret
to visible and
using it to display the potential insert location. When the drag
exits the component, the Caret
's visibility is
restored. Unfortunately, since the Caret
uses the same
"visible
" property to represent the usual meaning of
visible as well as when it is in mid-flash, we sometimes restore
the Caret's visibility incorrectly.
The bugtraq report that corresponds to this problem is: 4513638.
When using an RTFEditorKit
set explicitly on a
JEditorPane
using setEditorKit
, or by
setting the content-type
to text/rtf
,
cut, copy and drag no longer work. Note that this bug, filed
against release 1.4, is fixed in release 1.4.1.


Self website
Self website
Self website
I'm creating a website about myself.
I may be found on...
Additionally, I have a profile on...


Here’s what’s coming to CTV Throwback and CTV Movies in December
by Dean DaleyThere’s Netflix, Disney+, Apple TV+, Prime Video and so many other streaming services available in Canada. While Bell has Crave, the company also offers streaming via CTV.ca and the CTV app.
Available in the CTV app is ‘CTV Throwback’ and ‘CTV Movies,’ which both offer free streaming of full seasons of classic series.
Here’s all of the content hitting CTV’s platforms in December.
CTV Throwback
- The Guardian (seasons 1-3) December 5th
- Baywatch (seasons 3-4) December 10th
- Baywatch (seasons 5-6) December 11th
- Family Law (seasons 1-3) December 12th
- The Flying Nun (seasons 1-3) December 19th
- Fantasy Island (1997, seasons 1-7) December 26th
CTV Movies
- Bye Bye Birdie (1963) December 5th
- Oliver! December 5th
- Oliver Twist (2005) December 5th
- All That Jazz December 12th
- Godspell December 12th
- The Jolson Story December 12th
- Annie (2014) December 19th
- Paris Holiday December 19th
- Road to Bali December 19th
- Road to Rio December 19th
- When You’re in Love December 19th
- A Woman of Distinction December 19th
- Stomp The Yard December 26th
- Stomp The Yard: Homecoming December 26th
- Tap December 26th
- Tommy December 26th
- Crumb December 31st
- Steel Magnolias (1989) December 31st
Download the CTV app on iOS and Android.


Farming
Count: -
Mining
Woodcutting
Fishing
Click on a marker to get the coordinates and additional data.


Nent
Nent is a asteroids-esque game, with upgrades and meta-ball fluid effects. It is also my submission to Ludum Dare 28, a 48hr game jam competition for which the theme was 'You only get one'. This is my first time participating in #LD48, and it has been quite the experience. To get a sense of how it felt, here is my GitHub punch-card showing my commits over the 48 hour period:
The most difficult part of creating the game was not coding, but actually coming up with a decent idea in the first place. The theme ('You only get one') is pretty vague and open to interpretation, and there were many ways to go about it (which makes coming up with an idea that much harder). In the end, after thinking about it for over 2 hours, I finally decided to just make something that looked decent and worry about mechanics and theme later.
Before I get into some of the interesting technical bits, I want to go over the tools that I used for creating this game. Instead of my normal web IDE, I opted to use LightTable which greatly increased coding productivity through its JavaScript injection magic. For image editing (the power-ups) I used GIMP which is my main tool for any sort of image manipulation/creation. And lastly I used LMMS (Linux MultiMedia Studio), a free music composition tool, to create the music for the game. This was my first real attempt at creating digital music and I found it both enlightening and horribly difficult. For anyone looking to try out LMMS I recommend this video tutorial to get started.
Now I'm going to go ahead and dive right into the most interesting aspect of the game, the liquid effects between object collision. This is done using the same technique as for metaballs. Metaballs (demo) work by combining gradients and then sampling the result. For example, here is what the game looks like before processing:
Ignoring the background color for a second, the gradients are created by changing the alpha values (opacity) of the color as they spread out. This is done using HTML5 canvas gradients:
var grad = ctx.createRadialGradient(x, y, 1, x, y, size)
grad.addColorStop(0, color.alpha(0).rgbaString())
grad.addColorStop(.4, color.alpha(1).rgbaString())
grad.addColorStop(1, color.alpha(0).rgbaString())
canvasContext.fillStyle = grad
Now, we iterate over every pixel and determine if the alpha value for that pixel is above a 'threshold'. Remember that when we have overlapping gradients, their alpha values will sum. This gives the following effect:
However, what we soon notice is that the CPU is getting pegged at 100% (1 core). This is because as our canvas gets larger, our iteration is taking exponentially longer. Here is the original code (used in the demo):
var imageData = ctx.getImageData(0,0,width,height),
pix = imageData.data;
for (var i = 0, n = pix.length; i <n; i += 4) {
if(pix[i+3]<threshold){
pix[i+3]/=6;
if(pix[i+3]>threshold/4){
pix[i+3]=0;
}
}
}
ctx.putImageData(imageData, 0, 0);
As pix.length increases, it takes much longer to go through the loop. This eventually reaches the point where we will not get this computation in under 16ms (required to get 60FPS). Luckily, I came up with a solution. If you remember my slideshow project, where I animated 1.75 million particles in real-time, I was able to leverage the GPU shaders to greatly improve rendering performance. I am going to do the same here, using a library called Glsl.js (https://github.com/gre/glsl.js). This library greatly simplifies the process of using GLSL (opengl shading language) shaders, and applying them to the canvas that I am already using (no need to re-write code in WebGL).
GAME.glsl = Glsl({
canvas: GAME.outCanv,
fragment: $('#fragment').text(),
variables: {
canv: GAME.canv
},
update: function(time, delta) {
animate(time)
this.sync('canv')
}
})
And now the shader code, which replaces the 'for' loop over the pixels:
<script id="fragment" type="x-shader/x-fragment">
precision mediump float;
uniform vec2 resolution;
uniform sampler2D canv;
void main (void) {
vec2 p = gl_FragCoord.xy / resolution.xy;
vec4 col = texture2D(canv, p);
if(col.a < 0.85) {
col.a /= 4.0;
if(col.a > threshold/4.0) {
col.a = 0.0;
}
}
gl_FragColor = col;
}
</script>
Now let's see what it looks like:
Oh no, that doesn't look right. Something odd is going on here. I'll go ahead and skip my adventure into blender land, and get right into the solution. The canvas, by default, uses composite blending. This means that it will absorb any colors underneath the canvas as part of the final canvas colors. Our web page has a background, with alpha 1.0, which causes every pixel to register in our metaball filter. To avoid this, we must modify the Glsl.js library, and add the following piece of code to change the default blending behavior (line 602, in the load() function):
gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
gl.enable(gl.BLEND);
And that's it! Now our game will render properly. In addition to utilizing shaders, this game also uses fixed-interval time-step physics, which you can read more about in my post on The Pond.
Looking to optimize the game more (for mobile devices for example), there is still a pretty large bottleneck regarding the canvas-to-webgl texture conversion each frame.
This could be solved by moving the entire game drawing process to the GPU shaders, and forgoing the canvas all together. However the task is non-trivial, and I did not have enough time during the 48hrs to be able to attempt it.
Participating in Ludum Dare was awesome, and I look forward to doing it again soon.


@(header: String, auth: Authentication, questionList: QuestionList) @main(header, auth) {
| @question.getAnswerCount answers |
@question.getVoteCount votes |
@question.getViewCount views |
@question.getTitle | asked by
@question.getAuthorDisplayName
@util.DateFormatter.format(question.getDate) |


Game dependencies will live as long as the game is running. This means they will survive between scenes. This functionality is made possible through the use of Nested containers.
When the starting a game Singularity.Duality
will search for resources of type SingularityModules
. These resources contains a array of ModuleRef
instances that contain the data needed to create the modules:
Assembly
, this is the name of the dll but without the .dll at the end.NameSpace
, this is the namespace where the module resides inName
, this is the name of the module class
If everything was typed in correctly then the Type
property will be filled in. Also if Singularity.Duality
was not able to instantiate the module when the game starts it will log a warning explaining why.
A example of a game dependency module can be found below:
public class GameDependencies : IModule
{
public void Register(BindingConfig config)
{
config.Register<IPathfinder, Pathfinder>();
}
}


Autonomous Cabs
Home
(current)
About us
Login
Register
Cab Booking Form
Name
Phone Number
Pickup Location
Drop Location
Pickup Date
Pickup Time
BOOK MY CAB


HTML Audio Album
Utilities for displaying audio elements in a page using MediaElement
Like the SlideShow vs SlideDeck discussion, the audio player tools work great for scattering audio elements on a web page and having complete control over each elements position in relation to the other content on the page. Sometimes though, you want to essentially create an album on the page. A no frills container that holds all of the elements in a collection all grouped in one place. Similar to the SlideDeck tools, a strategically marked element in the page is all you need and the tools will handle the rest.audio.json
All of the data for the audio elements must be put into a JSON file for the album tools to work. The format of the JSON file is exactly like the format in the gp.audioplayer discussion. One difference to note here though is that the previously unused "title" property in the collection JSON will be used here but only if specified. The property itself is still optional.The HTML
With the album, you no longer need to create elemenets in your HTML for each audio file. For this to work, it is simply a matter of placing a single container element for the entire album.

When the "fromJSON" function is called, the code will automatically look for an element
with the id "gp-audio-album" and automatically create the individual audio elements in order
within that container. In addition, if a "title" is specified on the JSON collection, an
additional DIV element will be created and the title will be inserted.
That's it!
Customization
In addition to the styles that can be used to customize the look of the individual audio elements, two style definitions can be used to customize the appearance of the album. The album itself must have the id "gp-audio-album". In addition, if a title is present the DIV element that will contain the title will automatically have the class "gp-audio-album-title" applied to it. By default, the style for the class "gp-audio-album-title" looks as follows:
.gp-audio-album-title
{
font-size : 1.5em;
margin-bottom : 0.5em;
}
That style can, of course, be further customized as can the style for the main
"gp-audio-album" container. In this sample, we have customized the style as follows:
#gp-audio-album
{
background : #303060;
border-radius : 8px;
color : #CCC;
padding : 1.0em;
padding-bottom : 0.5em;
width : 400px;
}


| Triisopropylated Phenyl Phosphate General Information
-
| Synonyms: |
Isopropylated triphenyl phosphate; Triisopropyl phenyl phosphate |
| CAS Registry No.: |
68937-41-7 |
| Chemical Category: |
Phosphates |
Usage and Performance Characteristics
-
| Outstanding Properties: |
Flame retardant |
| Used for Polymeric Materials: |
PVC |
| Misc. Info on Composition: |
May contain triphenyl phosphate (115-86-6) |
Physical Properties
-
| Specific Gravity: |
1.3 (20°C) |
| Aggregate State at 25°C: |
Solid |
| Boiling Point, °C: |
415 (decomposes) |
Chemical Properties
Optical Properties
Hazard-Related Data
-
| ICAO/IATA Class: |
9; UN3082 |
| OSHA Hazard Class: |
Hazardous: 29CFR 1910.1200 (USA); dangerous: 67/548/EEC, point 4 |
| UN Risk Phrases: |
20/21/22,33,36/38,43,58 |
| UN Safety Phrases: |
9,22,39,51 |
| UN/NA Class: |
9 UN 3077 PG III |
| Eye Irritation (human): |
May cause irritation |
| Flash Point Temperature, °C: |
227 |
| HMIS Personal protection: |
Chemical safety goggles, rubber gloves, apron |
| Skin Irritation: |
May cause irritation & allergic reactions |
Environmental Parameters
-
| Octanol-Water Partition Coeff., log Kow: |
9.07 |
Animal Toxicity
-
| Rat Oral, LD50, mg/kg: |
350 (triphenyl phosphate) |
Plasticizers Database (2nd Electronic Edition) Copyright © 2004 by ChemTec Publishing |


Your Project
Composition
Rule of thirds
Golden Mean Grid
Fibonacci Sprial
Gestalt Principles (Hierarchy & Grouping)
Ground Figure
Similarity
Proximity
Continuation
Closure
Common Fate
Prepare for client review/launch
Check Spelling


Course for You!
Here is some more information about this product that is only revealed once clicked on.


#include <avr/io.h>
#include <stdint.h>
#include <util/delay.h>
#include "rbuff.h"
Data Structures | |
| struct | i2c_data_struct_t |
| Used to write a data byte to the register of the slave device. More... | |
Defines | |
| #define | I2C_ADDRESS_IN_ARRAY 0xFF |
| See i2c_read(). | |
| #define | I2C_GEN_CALL_ADDRESS 0x00 |
| General Call Address. | |
| #define | I2C_RX_RING_BUFFER_BIT 5 |
| [7]=128 [6]=64 [5]=32 [4]=16 [3]=8 [2]=4 [1]=2 [0]=invalid | |
| #define | I2C_DEV_ARRAY_SIZE 15 |
| Size of I2cDevArray[]. | |
| #define | SMBUS_ARA 0x0C |
| SMBUS addressing mode. | |
| #define | I2C_TIMEOUT_VALUE 0x80 |
| uses bitwise-AND | |
| #define | i2c_clr_intrpt_flag_() TWCR |= 0x80 |
| Clear flag. | |
| #define | i2c_enable_() TWCR |= 0x04 |
| Enable I2C module. | |
| #define | i2c_disable_() TWCR &= 0xF9 |
| Disable I2C module (use as regular I/O pins). | |
| #define | i2c_start_tx_() TWCR |= 0xA5 |
| Sends the start command. | |
| #define | i2c_no_start_() TWCR &= 0x5D |
| Keep a repeated start from happening. | |
| #define | i2c_stop_tx_() TWCR |= 0x10 |
| Sends a stop command. | |
| #define | i2c_ack_() TWCR |= 0x40 |
| Sends an acknowldege. | |
| #define | i2c_nack_() TWCR &= 0xBF |
| Sends a Not acknowldeged. | |
| #define | i2c_enable_intrpt_() TWCR |= 0x01 |
| Enable I2C interrupts. | |
| #define | i2c_disable_intrpt_() TWCR &= 0xFE |
| Disable I2C interrupts. | |
| #define | i2c_enable_gc_() TWAR |= 0x01 |
| Enable general call addressing. | |
| #define | i2c_disable_gc_() TWAR &= 0xFE |
| Disable general call addressing. | |
| #define | i2c_set_address_(x) TWAR = (x & 0xFE) |
| Pass in the 8-bit HW slave address. | |
| #define | i2c_rx_ring_next_() |
| Safe increment of i2c ring pointer. | |
| #define | i2c_init_(cntrl) TWCR=(cntrl & 0x45); I2C_SET_BIT_RATE |
Typedefs | |
| typedef enum I2C_STATUS_ENUM | I2CSTAT_T |
| Used for declaring a variable that holds the I2C Transaction status. | |
Enumerations | |
| enum | I2C_STATUS_ENUM { I2C_OK, I2C_ERROR, I2C_BUSY, I2C_TIMEOUT = 0x04, I2C_LOST_ARB = 0x08, I2C_NO_RBUF = 0x10, I2C_CHKSUM_ERR = 0x20 } |
| Holds the status of the I2C state machine. More... | |
Functions | |
| uint8_t | i2c_dev_search (uint8_t start, uint8_t num) __attribute__((warn_unused_result)) |
| Search for num of devices beginning at start. | |
| uint8_t | i2c_get_address (void) __attribute__((weak)) |
| Used by the ISR to update the hardware address. | |
| uint8_t | i2c_write (void *const data, const uint8_t n) |
| A master write of n number of bytes from data in *Data. | |
| uint8_t | i2c_read (uint8_t DeviceAddress, void *const ReturnData, const uint8_t n) |
| A master read from DeviceAddress of n number of bytes to *ReturnData. | |
Variables | |
| volatile I2CSTAT_T | I2cStatus |
| Global variable holds the status of the I2C module. | |
| uint8_t | I2cDevArray [I2C_DEV_ARRAY_SIZE] |
| Holds a list of device address's that are online. | |
| volatile uint8_t | I2cOwnAddress |
| Variable holds 8-bit I2C address. | |
| volatile rbuff_t | I2cRxBuff |
| Pointer to the receive ring buffer used by the I2C module. |
This module contains macros, structures, defines and functions to implement a master and slave I2C interface using the TWI.
| #define i2c_init_ | ( | cntrl | ) | TWCR=(cntrl & 0x45); I2C_SET_BIT_RATE |
I2C initialization macro.
F_TWI needs to be defined first. For example: -DF_TWI=100000UL
| #define I2C_RX_RING_BUFFER_BIT 5 |
[7]=128 [6]=64 [5]=32 [4]=16 [3]=8 [2]=4 [1]=2 [0]=invalid
Valid defines: 1-7
| enum I2C_STATUS_ENUM |
| uint8_t i2c_dev_search | ( | uint8_t | start, | |
| uint8_t | num | |||
| ) |
Search for num of devices beginning at start.
Searches for devices that will acknowldege and then places the address of the device in I2cDevArray[]. At most I2C_DEV_ARRAY_SIZE can be placed in I2cDevArray[].
| [in] | start | 8-bit address to start at |
| [in] | num | Number of addresses to try |
| uint8_t i2c_read | ( | uint8_t | DeviceAddress, | |
| void *const | ReturnData, | |||
| const uint8_t | n | |||
| ) |
A master read from DeviceAddress of n number of bytes to *ReturnData.
DeviceAddress is an 8-bit number.
| [in] | DeviceAddress | Device to read from or I2C_ADDRESS_IN_ARRAY to allow the first struct member or array index zero of ReturnData to be the address. |
| [out] | *ReturnData | destination |
| [in] | n | number of bytes to write |
| uint8_t i2c_write | ( | void *const | data, | |
| const uint8_t | n | |||
| ) |
A master write of n number of bytes from data in *Data.
The address is an 8-bit number, which is index zero or the first member of the struct that is passed in to *Data.
| [in] | *data | array or struct that holds data to be sent |
| [in] | n | number of bytes to write |


This API documentation is part of the Java software accompanying the
Digital Image Processing book series
by W. Burger and M.J. Burge, published by Springer. This software is based on
ImageJ, a free Java-based image processing software
originally developed at the U.S. National Institutes of Health.
Please visit the book's main website for more information.
The associated source code, usage instructions and additional materials can be found
on GitHub.


3
1 But know this: in the last days dangerous times will come.
2 For people will be lovers of themselves, lovers of money, boastful, haughty, blasphemers, disobedient to parents, unthankful, unholy,
3 without natural affection, implacable, slanderers, without self-control, violent, not lovers of good,
4 betrayers, headstrong, conceited, lovers of pleasure rather than lovers of God.
5 They will have a form of godliness, but they will deny the power of it. Turn away from these people.
6 For some of them are men who enter into households and captivate foolish women who are overwhelmed with sins and are led away by various desires.
7 These women are always trying to learn new things, yet they are never able to come to the knowledge of the truth.
8 In the same way that Jannes and Jambres stood against Moses, so these false teachers also stand against the truth. They are corrupted in mind and they have rejected the faith.
9 But they will not advance very far, for their foolishness will be obvious to all, just like the foolishness of those two men.
10 But you have followed my teaching, conduct, purpose, faith, longsuffering, love, patience,
11 persecutions, sufferings, and what happened to me at Antioch, at Iconium, and at Lystra. I endured such persecutions, and out of them all, the Lord rescued me.
12 All those who want to live in a godly manner in Christ Jesus will be persecuted.
13 Evil people and impostors will become even worse, while they lead others astray and are themselves being led astray.
14 But as for you, continue in what you have learned and have firmly believed, knowing from whom you have learned.
15 You know that from childhood you have known the sacred writings, which are able to make you wise to salvation through faith in Christ Jesus.
16 All scripture has been inspired by God and is profitable for doctrine, for conviction, for correction, and for training in righteousness,
17 in order that the man of God may be competent, equipped for every good work.


Block this site (Must be input as www.thissite.com ex: "www.reddit.com")
How long will it be blocked?
10 minutes
20 minutes
30 minutes
How long will it be unblocked for?
5 minutes
10 minutes
15 minutes
Block it!
Stop


ThreadLocalValue
public struct ThreadLocalValue<ValueType: AnyObject>
Provides a mechanism for accessing thread-local values stored in the
threadDictionary
associated with the NSThread
of the caller.
As the class name implies, values set using ThreadLocalValue
are only visible
to the thread that set those values.
-
If the receiver was instantiated with a
namespace
, this property will contain that value.Declaration
Swift
public let namespace: String?
-
Initializes a new instance referencing the thread-local value associated with the specified key.
:param: key The key used to access the value associated with the receiver in the
threadDictionary
.:param: instantiator An optional function that will be called to provide a value when the underlying
threadDictionary
does not contain a value.Declaration
Swift
public init(key: String, instantiator: ((ThreadLocalValue) -> ValueType?)? = nil)
-
Initializes a new instance referencing the thread-local value associated with the specified namespace and key.
:param: namespace The name of the code module that will own the receiver. This is used in constructing the
fullKey
.:param: key The key within the namespace. Used to construct the
fullKey
associated with the receiver.:param: instantiator An optional function that will be called to provide a value when the underlying
threadDictionary
does not contain a value.Declaration
Swift
public init(namespace: String, key: String, instantiator: ((ThreadLocalValue) -> ValueType?)? = nil)
-
Retrieves the
threadDictionary
value currently associated with the receiver’sfullKey
. If there is currently no value forfullKey
or if the underlying value is not of the type specified byValueType
, the receiver’sinstantiator
(if any) will be used to construct a new value that will be associated withfullKey
in thethreadDictionary
which will then be returned.:returns: The thread-local value. Will be
nil
if there is no value associated withfullKey
, if the underlying value is not of the type specified byValueType
, and if the receiver has noinstantiator
or if theinstantiator
returnednil
.Declaration
Swift
public func value() -> ValueType?
-
Retrieves the
threadDictionary
value currently associated with the receiver’sfullKey
.:returns: The thread-local value. Will be
nil
if there is no value associated withfullKey
or if the underlying value is not of the type specified byValueType
.Declaration
Swift
public func cachedValue() -> ValueType?
-
Sets a new value in the calling thread’s
threadDictionary
for the key specified by the receiver’sfullKey
property.:param: newValue The new thread-local value.
Declaration
Swift
public func setValue(newValue: ValueType?)


The data set is always viewed by GrADS as a generalized 5-D (6-D if you include variables) array located in physical space (lon, lat, lev, time, ensemble), even if it is in reality a subset of a 5-D space.
The current dimension environment describes what part of the data set you want to work with. Expressions are evaluated with respect to the dimension environment (which allows for simplicity in the expression syntax), and the final display will be determined by the dimension environment. Thus, the dimension environment is a GrADS concept that is important to understand.
The dimension environment is manipulated by the user by entering one of the following set commands:
set lat|lon|lev|time|ens val1
<val2>
This set command sets one dimension of the dimension environment using world coordinates.
Alternatively:
set x|y|z|t|e val1
<val2>
This sets one dimension of the dimension environment using grid
coordinates. You may use whatever coordinates are convenient to
you. Issuing set lon
is
equivalent to issuing set x
, both
set the x dimension. The difference is only the units you wish
to enter the command in.
When you enter just one value, that dimension is said to be "fixed". When you enter two values, that dimension is said to be "varying". The combination of fixed and varying dimensions defines the dimension environment.
Examples:
set lon -180
0
sets
longitude to vary from 180W to 0set lat 0
90
sets
latitude to vary from the equator to 90Nset lev
500
sets
the level to 500mb - a fixed dimensionset t
1
sets time to the first time in the data set--using grid
coordinates in this case. Time is now a fixed dimensionWhen all dimensions are fixed, you are referring to a single data point.
When one dimension is varying, you are referring to a 1-D "slice" through the data set.
When two dimensions are varying, you are referring to a 2-D "slice" through the data set.
When three or more dimension vary, GrADS interprets this as a sequence of 2-D slices.
An important note: When you specificy the dimension environment in terms of grid coordinates, they are always converted to world coordinates. This conversion requires some knowledge of what scaling is in use for grid to world conversions. The scaling that is used in all cases (except one) is the scaling of the default file. The exception is when you supply a dimension expression within a variable specification, which will be covered later.


Checks whether a PointFeature is on land or not
A location is on land if it's in some country, luckily
we have a List representing countries locations as features
so we can use it, to determine that an earthquake which is represented as a pointfeature
is in a country or not, returning true or false
note that some countries are made into multimarkers (markrers represented on a big area and some are made )
into simplePolygon markers that represents also an area
this is implemented in UnfoldingMap API for ease of use
so we have to check if the feature is in a marker country
and a marker country can be multimarker or simple polygon marker
so we have to check for both, note: multimarker holds markers and u can get it
using .getMarkers(), note that AbstractShape Marker is the superclass of polygon marker
countries markers are made of SimplePolygonMarker or MultiMarkers
a MultiMarker in case of the countries marker , holds logically grouped
markers for a certain country, so basically multimarker is a container of logical related markers
a country can be implemented using a multimarker holding simple polygon shape marker
or a direct simple polygon shape marker due to the country features being a simplePolygonFeature or a MultiFeature
due to geoJSON implementation in unfolding map List can hold both
loops over the country markers made by the List of countries from geoReader checking if one of them returns true
to that location, this is done by looping over each marker in the countryMarkers and checking if the location is inside the marker location
using the isInCountry private method


Password Reset Complete
Your new password has been set. You can log in now on the login page.
{% extends "layouts/base_home.html" %} {% block title %} Password Reset Complete {% endblock title %} {% block plugin_stylesheets %} {% endblock plugin_stylesheets %} {% block content %} {% include 'includes/sidebar.html' %}
Your new password has been set. You can log in now on the login page.


This site aims to help you locate the perfect pet by allowing you to search local shelters and adoption agencies with various criteria you may elect to filter by.
So you've got someone in mind, now what? Time to let Google Maps get you there so you can give them a scratch behind the ears!
Being able to make sure your new pet is healthy and well-cared for is paramount after meeting them, so we have also provided a way to find local veterinarians or supply shops to acquire what you may need.
SEARCH RESULTS:
Select gender to search for Select species to search for petsSearch!


Bases: object
Bases: object
A single waveform trace. Contains methods for generating filtered versions of itself.
Recursive method to generate a filtered waveform.
Accepts filter strings of the form “freq_2.0_3.0;env;smooth” with filters separated by semicolons. The first filter in the chain is applied to generate a new waveform (“first_filtered”) which is then called recursively to apply the other filters.
Filtered waveforms are cached in the self.filtered dictionary, indexed by the first term in their filter string (thus the caching works through the recursive calls for more complex filters). Thus only the first call to this method with a given filter string actually requires any computation.
If preserve_intermediate is False, the cache keys are the entire filter strings rather than just the first terms.
smooth the data using a window with requested size.
This method is based on the convolution of a scaled window with the signal. The signal is prepared by introducing reflected copies of the signal (with the window size) in both ends so that transient parts are minimized in the begining and end part of the output signal.
x: the input signal window_len: the dimension of the smoothing window; should be an odd integer window: the type of window from ‘flat’, ‘hanning’, ‘hamming’, ‘bartlett’, ‘blackman’
flat window will produce a moving average smoothing.
example:
t=linspace(-2,2,0.1) x=sin(t)+randn(len(t))*0.1 y=smooth(x)
see also:
numpy.hanning, numpy.hamming, numpy.bartlett, numpy.blackman, numpy.convolve scipy.signal.lfilter
TODO: the window parameter could be the window itself if an array instead of a string
Returns a single Waveform for the given channel at the station in the given interval. If there are periods for which data are not available, they are marked as missing data.
Loads data for pad_seconds before and after the true start time, and masks the additional data. This is used to absorb filtering artifacts.


The Ethereum Virtual Machine is evolving fast and we do not know what we wake up to tomorrow. New vulnerabilities could be discovered every day. This creates the need for instant action for Smart Contract owners! The ability to fix any vulnerabilities inside our Web3 Application, without losing the address and data already stored on the blockchain via your contracts, is crucial and should be considered best practice for everyone serious about running a decentralized application on the Ethereum blockchain. Further, the option to extend the functionality of your DApp in case you have another brilliant idea that builds upon your already existing project makes the upgrade safe Proxy Setup for your Smart Contracts a No-Brainer. Reach out and get the first analysis of your project for free!
Get a first evaluation of your project for free, and get my best considerations on if and which one of your contract/s should or could be considered to be redesigned for upgradeability. Further, we will discuss the different options for redesigning your project.


{% extends "base.html" %} {% load crispy_forms_tags %} {% load static %} {% block head_title %}Welcome | {{ block.super }}{% endblock %} {% block jumbotron %} {% if not request.user.is_authenticated %}
The MVP Landing project is designed to get your project started. The goal is to help you launch as soon as possible with the least amount of investment using time or money. Join Us today.
| {{ forloop.counter }} | {{ instance.email }} | {{ instance.full_name }} | {{ instance.timestamp|timesince }} ago |
| is equal |
{{ title }}
Django & Bootstrap
Created for Starters
Always Open Source


It is very likely that more frequent extreme weather events will increase the frequency and magnitude of severe ecological disturbances, driving rapid (months to years) and often persistent changes in forest structure and function across large landscapes. It is also likely that other changes, resulting from gradual climate change and less severe disturbances, will alter forest productivity and health and the distribution and abundance of species at longer timescales (decades to centuries).
It is very likely that climate change will decrease the ability of many forest ecosystems to provide important ecosystem services to society. Tree growth and carbon storage are expected to decrease in most locations as a result of higher temperatures, more frequent drought, and increased disturbances. The onset and magnitude of climate change effects on water resources in forest ecosystems will vary but are already occurring in some regions.
Forest management activities that increase the resilience of U.S. forests to climate change are being implemented, with a broad range of adaptation options for different resources, including applications in planning. The future pace of adaptation will depend on how effectively social, organizational, and economic conditions support implementation.


The Royal Bank of Epicodus
Name:
Initial Deposit:
Open Account
Deposit:
Withdrawl:
Submit
your Balance is: $


Kayla's Sandbox Code
I have mixed just about everything into one working piece of code. There is still more to come!
Please enter your first name:
Please enter your last name:


Output Variable Types
Systems differ widely in the number and variety of variable types they support. When data are transferred from one file type to another, a variable type in the output format must be assigned to each of the variables being transferred.
Note that with Stat/Transfer, numerical precision is never lost in the transfer process, since all numerical variables are stored internally as double precision floating point numbers and are then written out according to the assigned variable type.
Stat/Transfer automatically reads your dataset an extra time in order to determine the optimum output types for each variable and the maximum length of string variables. In almost all cases it is appropriate to accept the output types that Stat/Transfer chooses. However, there are times that you may wish to override these defaults and set the output types manually.
Target Types Assigned by Stat/Transfer
When assigning default output variable types, Stat/Transfer attempts to use all of the information at its disposal about the input data variables in order to preserve numeric precision and, at the same time, minimize the size of the output data set.
When reading numerical variables, Stat/Transfer selects a target output variable type based on the information available to it. This target variable type is not used for internal storage during the transfer, but is simply the preferred output type. If this type is not supported in the chosen output file type, the best approximation will be chosen.
The various target output variable types used by Stat/Transfer are:
|
byte |
One byte signed integer (-128 to 100) |
|
|
int |
Two byte signed integer (-32768 to 32740) |
|
|
long |
Four byte signed integer |
|
|
float |
Four byte IEEE single precision floating point number |
|
|
double |
Eight byte IEEE double precision floating point number |
|
|
date |
Date stored as serial day number (days since December 30, 1899) |
|
|
time |
Fraction of a day (12:00 noon = .5) |
|
|
date/time |
Floating point number (integer - serial day number; fractional part - time) |
|
|
string |
Character string (stored internally in Unicode UTF-8 representation. |
Remember that the target type will not necessarily be the actual output type. If the target type assigned to a variable by Stat/Transfer is available as one of the variable types of the output file format, then that type will be used for the output. If the assigned target type is not one of the available output types, then a format of the next larger size will be used.


Kaushal Mishrikotkar's Donation Page
Wealth is not to feed our egos, but to feed the hungry and to help people help themselves.


{% load static %}
PolitiStats
PolitiStats
Home
(current)
Profile
About Us
Contact Us
{{person_selected}}
Sentiment from tweets: {{sentiment_tweets}}
Sentiment from mentions: {{sentiment_mentions}}
Sentiment from news: {{sentiment_news}}
Copyright © 2020 PolitiStats. All rights reserved.


Clearing - In
Clear in at an official Port of Entry first. On arrival, immediately report to the authorities and request clearance. This is usually staight forward, but obtaining a clearance pack before arrival will speed up the process. See www.commerce.gov.sb to download the forms.
Stopping and going ashore at any island before clearing in is strictly prohibited and boats that do this will pay a heavy fine. This is particularly true of the eastern islands, such as Tikopia or Vanikolo, where yachts coming from Vanuatu have stopped without first clearing into the Solomons at Ndende (Nendo) Island.
Whilst Noonsite has received reports from cruisers who successfully anchored in several places in the eastern and western Solomons before officially checking in (not encountering enforcement boats), it is recommended to not take the risk of being fined.
Note:
Clearing - Out
Clearance out of the Solomons can be done from any Port of Entry.
Note that clearance fees and, for some places, anchorage fees are now being collected. See "Fees" below for the latest details.
Last updated May 2016.
Passports are required by all visitors and must be valid for 6 months beyond your stay.
Visas are not required for up to a three month stay for U.S., British Commonwealth and most European citizens, but there is an extensive list of nationals from various countries who do require prior approval before visiting the islands.
See Updated list
Nationals of countries who do require a visa must apply to the Director of Immigration (see details below).
A visitors permit will be issued for a period not exceeding three months in any period of twelve months. Extensions can be obtained for up to another 3 months if there are special circumstances, for which there is a fee of SBD$30 per month.
Arriving by Plane
Crew who plan to arrive in the Solomon Islands by plane and to depart on a yacht should apply for a visitor’s permit to the Director of Immigration before their arrival. The application should state the crew’s arrival date, vessel name and registration details, vessel’s arrival date, approximate length of time the crew member will spend in the Solomon Islands, and it should request entry on a one-way (arrival only) airline ticket. The Director will issue a permit to be presented at airline check-in. If the crew member does not have this permit, they may be denied boarding.
In Dec 2010, new visa requirements were being considered which will require ALL visitors to obtain a visa in advance of arrival. It is planned that such visas will be obtainable via the internet but as yet, there is no timetable for implementation.
See here to download a visa application form.
Last updated March 2015.
Firearms must be declared, otherwise they may be forfeited. Firearms and alcohol will be sealed on board.
Fruit and vegetables are permitted on board, but you will be asked not to bring them ashore.
Exports of genuine artifacts, not replicas, require permission.
The Solomon Islands' government prohibits the export of military artifacts from World War II, as well as the import of religious materials and antiquities.
A yacht may stay in the country for a total of six months. An initial three months will be granted on rival and this can be extended for another three months.
Last updated March 2015.
Malaria is endemic in the Solomons and malarial prophylaxis is absolutely essential. Many cruising sailors have caught malaria in the Solomons recently, so the usual precautions should also be taken, such as having mosquito screens on all portholes and hatches, anchoring further offshore and possibly upwind from any village, trying to avoid going ashore in the late afternoon or early evening when mosquitoes are most active.
Tap water is not potable and should be treated everywhere including Honiara and Gizo.
The hospitals often run out of basic supplies such as antibiotics and blood supplies.
Danger - Crocodiles
Salt water crocodiles are native to parts of the Solomon Islands, and there have been sightings on beaches. On arrival in any new place, ensure you ask locals whether there are any crocodiles. Local advice should be sought before entering unfamiliar waters, including lakes.
Attempt to arrive during normal working hours. In most places it is possible to wait at anchor until the offices open, but no one should go ashore before clearance is completed.
There is a clearance fee of US$18 per metre.
There are also immigration charges of SI$300 (US$45) and a SI$150 (US$25) quarantine fee.
Immigration: To extend a visitor's permit for 6 weeks costs SI$200 per person.
In some places there is now a daily charge for anchoring.
The Florida islands group has initiated a charge of SI$300 per day.
It has been reported that at the far eastern island of Tikopia in the reef islands, a yacht was charged SI$500.
Try and establish to whom you are paying the fee as it may be asked for twice!
Last updated April 2015.
The authorities in Honiara will advise where a yacht can or cannot go. There are usually no problems in calling at the main centres or at islands used to cruising yachts.
Once anchored, go ashore to see the chief or village head and ask permission to anchor. If you wish to swim or fish you should also ask permission. This is usually never a problem and you will often be warmly welcomed.
In most places locals will happily trade their coconuts and other fresh produce with you.
Fishing and collecting shells are not normally allowed unless one has been given permission, nor are coconuts and produce to be taken.
The wearing of shorts or other scanty clothing by women is not allowed.
Dress codes, particularly for women, are modest and you will gain respect by dressing appropriately. In certain areas there are ‘taboo’ sites only visited by men.
Standards of dress and behaviour in Solomon Islands is conservative, and you should take care not to offend. Public displays of affection and swearing in public may cause offence.
The Islanders have many traditional "kastoms" which vary from province to province. Always ask permission before taking pictures of people or places.
Marovo Lagoon: Most islanders are Seventh Day Adventists so their Sabbath is from sunset on Friday to sunset on Saturday, and visitors are not supposed to go ashore here during the Sabbath.
Animals are not to be landed. If for any reason they are landed, they will be subject to quarantine.
Dogs and cats can only be imported from Australia, New Zealand and the United Kingdom.


The sequential pattern match is a serious bottleneck even if we use an advanced single pattern searching algorithm. Use the Rabin-Karp algorithm to make a multiple pattern matcher and make your checker show the best performance.
java Main test_files patterns.db
doc_0.doc: MS Office Word 2003
doc_1.pptx: MS Office PowerPoint 2007+
doc_2.pdf: PDF document
file.pem: PEM certificate


Donation to
{{distributionn}} users in the event
{{event}}
Amount to send: {{withdrawal.value|money}}
An additional fee of {{withdrawal.fee|money}} is automatically added to assure that the transaction will be confirmed.
The total amount spent will be {{(withdrawal.value + withdrawal.fee)|money}} You can modify the fee amount for statistically decrease the confirmation delay:Passphrase:
Amount to send: {{withdrawal.vvalue|money}}
An additional fee of {{withdrawal.fee|money}} is automatically added to assure that the transaction will be confirmed.
The total amount spent will be {{(withdrawal.vvalue + withdrawal.fee)|money}}
Transaction description:
{{withdrawal.description}} Destination address:
{{withdrawal.destination}} You can modify the fee amount for statistically decrease the confirmation delay:
Bad address
Not enough funds
Invalid passphrase
Amount to send: {{withdrawal.vvalue|money}}
An additional fee of {{withdrawal.fee|money}} is automatically added to assure that the transaction will be confirmed.
The total amount spent will be {{(withdrawal.vvalue + withdrawal.fee)|money}}
Destination address:
{{withdrawal.destination}} You can modify the fee amount for statistically decrease the confirmation delay:


@(fieldInfo: b4.B4FieldInfo, inputHtml: Html, extraClasses: Option[String] = None)(wrap: Html => Html)(implicit fc: b4.B4FieldConstructor)


Any Word Completion Demo
Press ctrl-space to activate autocompletion. The completion uses the anyword-hint.js module, which simply looks at nearby words in the buffer and completes to those.
Press ctrl-space to activate autocompletion. The completion uses the anyword-hint.js module, which simply looks at nearby words in the buffer and completes to those.