├── .gitignore
├── icon512.png
├── g1dasher.png
├── icon-120.png
├── n1dasher.png
├── dasher-promo.png
├── feature_graphic.png
├── src
    └── dasher
    │   ├── CAlphIO.java
    │   ├── Observer.java
    │   ├── applet
    │       ├── files.txt
    │       ├── colour.dtd
    │       ├── JDasher.java
    │       ├── font
    │       │   └── FontListener.java
    │       ├── JDasherMenuBarListener.java
    │       ├── JMouseInput.java
    │       ├── alphabet.dtd
    │       ├── ScreenOverlay.java
    │       ├── JSettings.java
    │       └── JDasherEdit.java
    │   ├── CMarkerScreen.java
    │   ├── Document.java
    │   ├── EditableDocument.java
    │   ├── CConversionHelper.java
    │   ├── android
    │       ├── SingleIMCheckBox.java
    │       ├── CheckBoxPreference.java
    │       ├── IntQueue.java
    │       ├── SettingsActivity.java
    │       ├── IMCheckBox.java
    │       ├── DualIMCheckBox.java
    │       ├── DasherActivity.java
    │       ├── TiltInput.java
    │       ├── InputTypes.java
    │       ├── AndroidKeyMap.java
    │       ├── CalibPreference.java
    │       └── SeekBarPreference.java
    │   ├── CDasherModule.java
    │   ├── CFileLogger.java
    │   ├── CDynamicFilter.java
    │   ├── CCannaConversionHelper.java
    │   ├── CUserLog.java
    │   ├── CDynamicButtons.java
    │   ├── CCompassMode.java
    │   ├── CScanning.java
    │   ├── CParameterNotFoundException.java
    │   ├── CDynamicPresses.java
    │   ├── SGroupInfo.java
    │   ├── CMenuMode.java
    │   ├── Esp_parameters.java
    │   ├── XMLFileParser.java
    │   ├── EParameters.java
    │   ├── CModuleManager.java
    │   ├── TwoButtonDynamicFilter.java
    │   ├── Opts.java
    │   ├── CButtonMode.java
    │   ├── CClickFilter.java
    │   ├── CCustomColours.java
    │   ├── COneDimensionalFilter.java
    │   ├── Ebp_parameters.java
    │   ├── CStylusFilter.java
    │   ├── CDasherButtons.java
    │   ├── CDasherInput.java
    │   ├── CDelayedDraw.java
    │   ├── CDasherScreen.java
    │   ├── CFrameRate.java
    │   ├── OneButtonDynamicFilter.java
    │   └── Elp_parameters.java
├── res
    ├── drawable-hdpi
    │   └── icon.png
    ├── drawable-ldpi
    │   └── icon.png
    ├── drawable-mdpi
    │   └── icon.png
    ├── values
    │   └── arrays.xml
    ├── layout
    │   ├── checkbox_tilt.xml
    │   ├── checkbox_compass.xml
    │   ├── checkbox_onebuttondynamic.xml
    │   ├── checkbox_twobuttondynamic.xml
    │   ├── checkbox_boxes.xml
    │   ├── checkbox_touch.xml
    │   ├── calibrate.xml
    │   └── install.xml
    ├── xml
    │   └── method.xml
    └── values-fr
    │   └── strings.xml
├── .classpath
├── README
├── assets
    ├── colour.dtd
    ├── alphabet.dtd
    ├── alphabet.swedish.xml
    ├── alphabet.dutch.xml
    ├── alphabet.spanish.xml
    ├── alphabet.englishC.xml
    └── alphabet.italian.xml
├── default.properties
├── xml.py
├── .project
└── AndroidManifest.xml


/.gitignore:
--------------------------------------------------------------------------------
1 | bin/
2 | gen/
3 | .settings/org.eclipse.jdt.core.prefs
4 | 


--------------------------------------------------------------------------------
/icon512.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/acl33/AndroidDasher/HEAD/icon512.png


--------------------------------------------------------------------------------
/g1dasher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/acl33/AndroidDasher/HEAD/g1dasher.png


--------------------------------------------------------------------------------
/icon-120.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/acl33/AndroidDasher/HEAD/icon-120.png


--------------------------------------------------------------------------------
/n1dasher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/acl33/AndroidDasher/HEAD/n1dasher.png


--------------------------------------------------------------------------------
/dasher-promo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/acl33/AndroidDasher/HEAD/dasher-promo.png


--------------------------------------------------------------------------------
/feature_graphic.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/acl33/AndroidDasher/HEAD/feature_graphic.png


--------------------------------------------------------------------------------
/src/dasher/CAlphIO.java:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/acl33/AndroidDasher/HEAD/src/dasher/CAlphIO.java


--------------------------------------------------------------------------------
/res/drawable-hdpi/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/acl33/AndroidDasher/HEAD/res/drawable-hdpi/icon.png


--------------------------------------------------------------------------------
/res/drawable-ldpi/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/acl33/AndroidDasher/HEAD/res/drawable-ldpi/icon.png


--------------------------------------------------------------------------------
/res/drawable-mdpi/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/acl33/AndroidDasher/HEAD/res/drawable-mdpi/icon.png


--------------------------------------------------------------------------------
/src/dasher/Observer.java:
--------------------------------------------------------------------------------
1 | package dasher;
2 | 
3 | public interface Observer<T> {
4 | 	public void HandleEvent(T t);
5 | }
6 | 


--------------------------------------------------------------------------------
/src/dasher/applet/files.txt:
--------------------------------------------------------------------------------
1 | alphabet.dtd
2 | alphabet.english.xml
3 | colour.dtd
4 | colour.euroasian.xml
5 | training_english_GB.txt
6 | 


--------------------------------------------------------------------------------
/res/values/arrays.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <resources xmlns:android="http://schemas.android.com/apk/res/android">
 3 | 	<array name="Orientation_values">
 4 | 		<item>Default</item>
 5 | 		<item>LR</item>
 6 | 		<item>RL</item>
 7 | 		<item>TB</item>
 8 | 		<item>BT</item>
 9 | 	</array>
10 | </resources>


--------------------------------------------------------------------------------
/.classpath:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <classpath>
3 | 	<classpathentry excluding="dasher/applet/**" kind="src" path="src"/>
4 | 	<classpathentry kind="src" path="gen"/>
5 | 	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
6 | 	<classpathentry kind="src" path="TeclaSDK_src"/>
7 | 	<classpathentry kind="output" path="bin"/>
8 | </classpath>
9 | 


--------------------------------------------------------------------------------
/README:
--------------------------------------------------------------------------------
 1 | Port of Dasher as input method for Google Android OS.
 2 | 
 3 | Distributed under terms of GPL License v3.
 4 | 
 5 | Based on Chris Smowton's Java port, which is included in the main (C++) Dasher
 6 | repository git.gnome.org/dasher
 7 | 
 8 | Dasher website: www.inference.phy.cam.ac.uk/dasher
 9 | Mobile Dasher (includes instructions to enable as Android IME): www.inference.phy.cam.ac.uk/dasher/MobileDasher.html
10 | 


--------------------------------------------------------------------------------
/assets/colour.dtd:
--------------------------------------------------------------------------------
 1 | <!-- Colour schemes contain lists of colours to be used by Dasher -->
 2 | 
 3 | <!ELEMENT colours (palette*)>
 4 | 
 5 | <!ELEMENT palette (colour*)>
 6 | <!ATTLIST palette name CDATA #REQUIRED>
 7 | 
 8 | <!-- A list of rgb values -->
 9 | <!ELEMENT colour EMPTY>
10 | <!ATTLIST colour r CDATA #REQUIRED>
11 | <!ATTLIST colour g CDATA #REQUIRED>
12 | <!ATTLIST colour b CDATA #REQUIRED>
13 | 
14 | 


--------------------------------------------------------------------------------
/src/dasher/applet/colour.dtd:
--------------------------------------------------------------------------------
 1 | <!-- Colour schemes contain lists of colours to be used by Dasher -->
 2 | 
 3 | <!ELEMENT colours (palette*)>
 4 | 
 5 | <!ELEMENT palette (colour*)>
 6 | <!ATTLIST palette name CDATA #REQUIRED>
 7 | 
 8 | <!-- A list of rgb values -->
 9 | <!ELEMENT colour EMPTY>
10 | <!ATTLIST colour r CDATA #REQUIRED>
11 | <!ATTLIST colour g CDATA #REQUIRED>
12 | <!ATTLIST colour b CDATA #REQUIRED>
13 | 
14 | 


--------------------------------------------------------------------------------
/res/layout/checkbox_tilt.xml:
--------------------------------------------------------------------------------
 1 | <dasher.android.SingleIMCheckBox xmlns:android="http://schemas.android.com/apk/res/android"
 2 | 	android:id="@+id/checkbox_tilt"
 3 |     android:key="AndroidTilt"
 4 |     inputDevice="Tilt Input"
 5 |     inputFilter="Android Tilt Control"
 6 |     android:layout_width="wrap_content"
 7 |     android:layout_height="wrap_content"
 8 |     android:layout_marginRight="4dip"
 9 |     android:layout_gravity="center_vertical"
10 |     android:focusable="false"
11 |     android:clickable="false" />
12 | 


--------------------------------------------------------------------------------
/res/layout/checkbox_compass.xml:
--------------------------------------------------------------------------------
 1 | <dasher.android.SingleIMCheckBox xmlns:android="http://schemas.android.com/apk/res/android"
 2 |     android:id="@+id/checkbox_compass"
 3 |     android:key="AndroidCompass"
 4 |     inputDevice="Touch Input"
 5 |     inputFilter="Compass Mode"
 6 |     android:layout_width="wrap_content"
 7 |     android:layout_height="wrap_content"
 8 |     android:layout_marginRight="4dip"
 9 |     android:layout_gravity="center_vertical"
10 |     android:focusable="false"
11 |     android:clickable="false" />
12 | 


--------------------------------------------------------------------------------
/res/layout/checkbox_onebuttondynamic.xml:
--------------------------------------------------------------------------------
 1 | <dasher.android.SingleIMCheckBox xmlns:android="http://schemas.android.com/apk/res/android"
 2 |     android:id="@+id/checkbox_onebuttondynamic"
 3 |     android:key="AndroidOneButtonDynamic"
 4 |     inputDevice="Touch Input"
 5 |     inputFilter="One-button Dynamic Mode"
 6 |     android:layout_width="wrap_content"
 7 |     android:layout_height="wrap_content"
 8 |     android:layout_marginRight="4dip"
 9 |     android:layout_gravity="center_vertical"
10 |     android:focusable="false"
11 |     android:clickable="false" />
12 | 


--------------------------------------------------------------------------------
/res/layout/checkbox_twobuttondynamic.xml:
--------------------------------------------------------------------------------
 1 | <dasher.android.SingleIMCheckBox xmlns:android="http://schemas.android.com/apk/res/android"
 2 |     android:id="@+id/checkbox_twobuttondynamic"
 3 |     android:key="AndroidTwoButtonDynamic"
 4 |     inputDevice="Touch Input"
 5 |     inputFilter="Two-button Dynamic Mode"
 6 |     android:layout_width="wrap_content"
 7 |     android:layout_height="wrap_content"
 8 |     android:layout_marginRight="4dip"
 9 |     android:layout_gravity="center_vertical"
10 |     android:focusable="false"
11 |     android:clickable="false" />
12 | 


--------------------------------------------------------------------------------
/default.properties:
--------------------------------------------------------------------------------
 1 | # This file is automatically generated by Android Tools.
 2 | # Do not modify this file -- YOUR CHANGES WILL BE ERASED!
 3 | # 
 4 | # This file must be checked in Version Control Systems.
 5 | # 
 6 | # To customize properties used by the Ant build system use,
 7 | # "build.properties", and override values to adapt the script to your
 8 | # project structure.
 9 | 
10 | # Project target.
11 | target=android-4
12 | # Indicates whether an apk should be generated for each density.
13 | split.density=false
14 | android.library.reference.1=../../sdk/source
15 | 


--------------------------------------------------------------------------------
/res/layout/checkbox_boxes.xml:
--------------------------------------------------------------------------------
 1 | <dasher.android.DualIMCheckBox xmlns:android="http://schemas.android.com/apk/res/android"
 2 |     android:id="@+id/checkbox_boxes"
 3 |     android:key="AndroidBoxes"
 4 |     childKey="AndroidScan"
 5 |     inputDevice="Touch Input"
 6 |     inputFilterOn="Scanning Menu Mode"
 7 |     inputFilterOff="Direct Mode"
 8 |     android:layout_width="wrap_content"
 9 |     android:layout_height="wrap_content"
10 |     android:layout_marginRight="4dip"
11 |     android:layout_gravity="center_vertical"
12 |     android:focusable="false"
13 |     android:clickable="false" />
14 | 


--------------------------------------------------------------------------------
/res/layout/checkbox_touch.xml:
--------------------------------------------------------------------------------
 1 | <dasher.android.DualIMCheckBox xmlns:android="http://schemas.android.com/apk/res/android"
 2 |     android:id="@+id/checkbox_touch"
 3 |     android:key="AndroidTouch"
 4 |     childKey="AndroidTouchUsesTiltX"
 5 |     inputDeviceOff="Touch Input"
 6 |     inputDeviceOn="Touch with tilt X"
 7 |     inputFilter="Android Touch Control"
 8 |     android:layout_width="wrap_content"
 9 |     android:layout_height="wrap_content"
10 |     android:layout_marginRight="4dip"
11 |     android:layout_gravity="center_vertical"
12 |     android:focusable="false"
13 |     android:clickable="false" />
14 | 


--------------------------------------------------------------------------------
/src/dasher/CMarkerScreen.java:
--------------------------------------------------------------------------------
 1 | package dasher;
 2 | 
 3 | public interface CMarkerScreen extends CDasherScreen {
 4 | 
 5 | 	/**
 6 | 	 * Informs the screen of certain drawing phases.
 7 | 	 * <p>
 8 | 	 * A '0' will be sent when beginning to draw persistent
 9 | 	 * features (ie. those which should remain the same from
10 | 	 * frame to frame), and a '1' will be sent prior to drawing
11 | 	 * ephemeral details which should vanish if not redrawn next
12 | 	 * frame.
13 | 	 * 
14 | 	 * @param iMarker Marker number
15 | 	 */	
16 | 	public abstract void SendMarker(int iMarker);
17 | 	
18 | 	/**
19 | 	 * Signals the end of a frame.
20 | 	 *
21 | 	 */
22 | 	public abstract void Display();
23 | }
24 | 


--------------------------------------------------------------------------------
/xml.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/python
 2 | 
 3 | import sys
 4 | import re
 5 | 
 6 | if len(sys.argv)!=2:
 7 |   print "Usage: python xml.py /path/to/dasher_strings.csv"
 8 |   print " Expects a two-column csv file, i.e. internal names and one language's worth"
 9 |   print " of translations. Outputs bulk of XML, but some changes needed by hand"
10 |   sys.exit(1)
11 | 
12 | def dequote(s):
13 |   s=s.strip()
14 |   if (s==""): return s
15 |   if (s[0]=='"' and s[-1]=='"'): return s[1:-1]
16 |   raise Error("Couldn't dequote "+s)
17 | 
18 | with open(sys.argv[1],'r') as file:
19 |   for line in file:
20 |     i = line.find(',')
21 |     if i==-1:
22 |       raise Error("No comma in "+line)
23 |     key=line[:i]
24 |     s=dequote(line[i+1:])
25 |     if (s==""):
26 |       print "<!--",dequote(key),"-->"
27 |     elif (key==""):
28 |       print "<item>"+s+"</item>"
29 |     else:
30 |       print "<string name="+key+">"+s+"</string>"
31 | 


--------------------------------------------------------------------------------
/src/dasher/Document.java:
--------------------------------------------------------------------------------
 1 | package dasher;
 2 | 
 3 | /**
 4 |  * <p>Representation of text in terms of java characters, i.e. unicode values 0-65535.
 5 |  * Unicode characters above this (i.e. 32-bits) are represented as TWO such characters,
 6 |  * at distinct (adjacent) offsets.</p>
 7 |  * <p>IOW, much as Java Strings.</p>
 8 |  * @author acl33
 9 |  *
10 |  */
11 | public interface Document {
12 | 	/** Get the character at the specified index, or null if the document does not contain
13 | 	 * such an index. (Note, it is suggested to use <code>Character.valueOf(...)</code> to
14 | 	 * reduce allocation.)
15 | 	 * @param pos Position in the document (0=first). Note, if this method returns null for
16 | 	 *  some value of pos, it should also return null for all indices greater than that value.
17 | 	 * @return Character object for the char at the specified index, or null if that's beyond
18 | 	 * the end of the Document.
19 | 	 */
20 | 	public Character getCharAt(int pos);
21 | }
22 | 


--------------------------------------------------------------------------------
/res/layout/calibrate.xml:
--------------------------------------------------------------------------------
 1 | <LinearLayout android:id="@+id/calibLayout"
 2 | 		android:layout_width="fill_parent"
 3 | 		android:layout_height="fill_parent"
 4 | 		android:orientation="vertical"
 5 | 		xmlns:android="http://schemas.android.com/apk/res/android">
 6 |   
 7 | 	<TextView android:text="Y Range:"
 8 | 			android:id="@+id/calibY"
 9 | 			android:layout_width="wrap_content"
10 | 			android:layout_height="wrap_content"/>
11 | 	
12 | 	<CheckBox android:text="@string/invert"
13 | 			android:id="@+id/invert"
14 | 			android:layout_width="wrap_content"
15 | 			android:layout_height="wrap_content"/>
16 | 					
17 | 	<TextView android:text="X Range:"
18 | 			android:id="@+id/calibX"
19 | 			android:layout_width="wrap_content"
20 | 			android:layout_height="wrap_content"/>
21 | 			
22 | 	<Button android:text="@string/calibChange"
23 | 			android:id="@+id/calibChange"
24 | 			android:layout_width="wrap_content"
25 | 			android:layout_height="wrap_content"/>
26 | 			
27 | </LinearLayout>
28 | 


--------------------------------------------------------------------------------
/src/dasher/EditableDocument.java:
--------------------------------------------------------------------------------
 1 | package dasher;
 2 | 
 3 | public interface EditableDocument extends Document {
 4 | 
 5 | 	/** Call to output/write text at a given position
 6 | 	 * (when a symbol node is entered).
 7 | 	 * @param ch String representation of <em>a single symbol</em> (i.e. one unicode character point)
 8 | 	 * @param offset index where character should be afterwards. (e.g. 0=this is first character)
 9 | 	 */
10 | 	public abstract void outputText(String ch, int offset);
11 | 	
12 | 	/** Call to delete text at a given position
13 | 	 * In other words, this performs a single backspace operation - when the user leaves a symbol node.
14 | 	 * @param ch String representation of <em>a single symbol</em> (i.e. one unicode character point)
15 | 	 * @param offset index where character should previously have been (e.g. 0=delete first character)
16 | 	 */
17 | 	public abstract void deleteText(String ch, int offset);
18 | 
19 | 	public abstract void moveCursor(int iNewOffset);
20 | }
21 | 


--------------------------------------------------------------------------------
/src/dasher/applet/JDasher.java:
--------------------------------------------------------------------------------
 1 | package dasher.applet;
 2 | 
 3 | import dasher.CDasherInterfaceBase;
 4 | import dasher.CSettingsStore;
 5 | 
 6 | public abstract class JDasher extends CDasherInterfaceBase {
 7 | 	
 8 | 	public JDasher() {
 9 | 		super(createSettingsStore());
10 | 	}
11 | 	
12 | 	/*A single public point-of-entry for setting up the interface */
13 | 	public void Realize() {
14 | 		LoadData();
15 | 		DoSetup();
16 | 	}
17 | 	
18 | 	/**
19 | 	 * Attempts to create a JSettings object; if a StoreUnavailableException
20 | 	 * is produced in the course of this, we fall back and produce a 
21 | 	 * standard CSettingsStore.
22 | 	 */
23 | 	private static CSettingsStore createSettingsStore() {
24 | 		CSettingsStore sets;
25 | 		try {
26 | 			sets = new JSettings();
27 | 		} catch (StoreUnavailableException e) {
28 | 			// We can't use the registry/config file due to security problems.
29 | 			sets = new CSettingsStore();
30 | 		}
31 | 		sets.LoadPersistent();
32 | 		return sets;
33 | 	}
34 | }
35 | 


--------------------------------------------------------------------------------
/res/xml/method.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!--
 3 | /**
 4 |  * Copyright (c) 2008, The Android Open Source Project
 5 |  *
 6 |  * Licensed under the Apache License, Version 2.0 (the "License"); 
 7 |  * you may not use this file except in compliance with the License. 
 8 |  * You may obtain a copy of the License at 
 9 |  *
10 |  *     http://www.apache.org/licenses/LICENSE-2.0 
11 |  *
12 |  * Unless required by applicable law or agreed to in writing, software 
13 |  * distributed under the License is distributed on an "AS IS" BASIS, 
14 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
15 |  * See the License for the specific language governing permissions and 
16 |  * limitations under the License.
17 |  */
18 | -->
19 | 
20 | <!-- The attributes in this XML file provide configuration information -->
21 | <!-- for the Search Manager. -->
22 | <input-method xmlns:android="http://schemas.android.com/apk/res/android"
23 |  android:settingsActivity="dasher.android.SettingsActivity"
24 |  android:isDefault="true"
25 |  />
26 | 


--------------------------------------------------------------------------------
/.project:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <projectDescription>
 3 | 	<name>Dasher</name>
 4 | 	<comment></comment>
 5 | 	<projects>
 6 | 	</projects>
 7 | 	<buildSpec>
 8 | 		<buildCommand>
 9 | 			<name>com.android.ide.eclipse.adt.ResourceManagerBuilder</name>
10 | 			<arguments>
11 | 			</arguments>
12 | 		</buildCommand>
13 | 		<buildCommand>
14 | 			<name>com.android.ide.eclipse.adt.PreCompilerBuilder</name>
15 | 			<arguments>
16 | 			</arguments>
17 | 		</buildCommand>
18 | 		<buildCommand>
19 | 			<name>org.eclipse.jdt.core.javabuilder</name>
20 | 			<arguments>
21 | 			</arguments>
22 | 		</buildCommand>
23 | 		<buildCommand>
24 | 			<name>com.android.ide.eclipse.adt.ApkBuilder</name>
25 | 			<arguments>
26 | 			</arguments>
27 | 		</buildCommand>
28 | 	</buildSpec>
29 | 	<natures>
30 | 		<nature>com.android.ide.eclipse.adt.AndroidNature</nature>
31 | 		<nature>org.eclipse.jdt.core.javanature</nature>
32 | 	</natures>
33 | 	<linkedResources>
34 | 		<link>
35 | 			<name>TeclaSDK_src</name>
36 | 			<type>2</type>
37 | 			<locationURI>_android_TeclaSDK_a3c721d3/src</locationURI>
38 | 		</link>
39 | 	</linkedResources>
40 | </projectDescription>
41 | 


--------------------------------------------------------------------------------
/src/dasher/applet/font/FontListener.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |   This file is part of JDasher.
 3 | 
 4 |   JDasher is free software; you can redistribute it and/or modify
 5 |   it under the terms of the GNU General Public License as published by
 6 |   the Free Software Foundation; either version 2 of the License, or
 7 |   (at your option) any later version.
 8 | 
 9 |   JDasher is distributed in the hope that it will be useful,
10 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |   GNU General Public License for more details.
13 | 
14 |   You should have received a copy of the GNU General Public License
15 |   along with JDasher; if not, write to the Free Software
16 |   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17 | 
18 |   Copyright (C) 2006      Christopher Smowton <cs448@cam.ac.uk>
19 | 
20 |   JDasher is a port derived from the Dasher project; for information on
21 |   the project see www.dasher.org.uk; for information on JDasher itself
22 |   and related projects see www.smowton.net/chris
23 | 
24 | */
25 | 
26 | package dasher.applet.font;
27 | 
28 | public interface FontListener {
29 | 	
30 | 	public void setNewFont(java.awt.Font f);
31 | 	
32 | }
33 | 


--------------------------------------------------------------------------------
/src/dasher/CConversionHelper.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |   This file is part of JDasher.
 3 | 
 4 |   JDasher is free software; you can redistribute it and/or modify
 5 |   it under the terms of the GNU General Public License as published by
 6 |   the Free Software Foundation; either version 2 of the License, or
 7 |   (at your option) any later version.
 8 | 
 9 |   JDasher is distributed in the hope that it will be useful,
10 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |   GNU General Public License for more details.
13 | 
14 |   You should have received a copy of the GNU General Public License
15 |   along with JDasher; if not, write to the Free Software
16 |   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17 | 
18 |   Copyright (C) 2006      Christopher Smowton <cs448@cam.ac.uk>
19 | 
20 |   JDasher is a port derived from the Dasher project; for information on
21 |   the project see www.dasher.org.uk; for information on JDasher itself
22 |   and related projects see www.smowton.net/chris
23 | 
24 | */
25 | 
26 | package dasher;
27 | 
28 | import java.util.ArrayList;
29 | 
30 | abstract public class CConversionHelper {
31 | 	abstract boolean Convert(final String strSource, ArrayList<ArrayList<String>> vResult);
32 | }
33 | 


--------------------------------------------------------------------------------
/src/dasher/android/SingleIMCheckBox.java:
--------------------------------------------------------------------------------
 1 | package dasher.android;
 2 | 
 3 | import android.content.Context;
 4 | import android.content.SharedPreferences;
 5 | import android.preference.PreferenceManager;
 6 | import android.util.AttributeSet;
 7 | 
 8 | import dasher.Esp_parameters;
 9 | 
10 | public class SingleIMCheckBox extends IMCheckBox {
11 | 	
12 | 	private final String inputDevice;
13 | 	private final String inputFilter;
14 | 
15 | 	public SingleIMCheckBox(Context ctx, AttributeSet attrs) {
16 | 		super(ctx,attrs);
17 | 		inputDevice = attrs.getAttributeValue(null,"inputDevice");
18 | 		inputFilter = attrs.getAttributeValue(null,"inputFilter");
19 | 	}
20 | 	
21 | 	@Override protected void hasBecomeChecked() {
22 | 		super.hasBecomeChecked();
23 | 		//writing to the persistent settings store will trigger an 
24 | 		// OnSharedPreferencesChanged listener in the main/IME service
25 | 		// (if its active) which will update the in-memory parameters
26 | 		// there. (Using an AndroidSettings might be more modular, but
27 | 		// would entail reading all settings into memory every time!)
28 | 		SharedPreferences.Editor edit = PreferenceManager.getDefaultSharedPreferences(getContext()).edit();
29 | 		edit.putString(Esp_parameters.SP_INPUT_DEVICE.regName(), inputDevice);
30 | 		edit.putString(Esp_parameters.SP_INPUT_FILTER.regName(), inputFilter);
31 | 		edit.commit();
32 | 	}
33 | 
34 | }
35 | 


--------------------------------------------------------------------------------
/src/dasher/CDasherModule.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |   This file is part of JDasher.
 3 | 
 4 |   JDasher is free software; you can redistribute it and/or modify
 5 |   it under the terms of the GNU General Public License as published by
 6 |   the Free Software Foundation; either version 2 of the License, or
 7 |   (at your option) any later version.
 8 | 
 9 |   JDasher is distributed in the hope that it will be useful,
10 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |   GNU General Public License for more details.
13 | 
14 |   You should have received a copy of the GNU General Public License
15 |   along with JDasher; if not, write to the Free Software
16 |   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17 | 
18 |   Copyright (C) 2006      Christopher Smowton <cs448@cam.ac.uk>
19 | 
20 |   JDasher is a port derived from the Dasher project; for information on
21 |   the project see www.dasher.org.uk; for information on JDasher itself
22 |   and related projects see www.smowton.net/chris
23 | 
24 | */
25 | 
26 | package dasher;
27 | 
28 | public interface CDasherModule {
29 | 	
30 | 	/*public long GetID() {
31 | 		return m_iID;
32 | 	}*/
33 | 	
34 | 	/**
35 | 	 * Gets this module's name
36 | 	 * 
37 | 	 * @return Name
38 | 	 */
39 | 	public String getName();
40 | 		
41 | }
42 | 


--------------------------------------------------------------------------------
/src/dasher/CFileLogger.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |   This file is part of JDasher.
 3 | 
 4 |   JDasher is free software; you can redistribute it and/or modify
 5 |   it under the terms of the GNU General Public License as published by
 6 |   the Free Software Foundation; either version 2 of the License, or
 7 |   (at your option) any later version.
 8 | 
 9 |   JDasher is distributed in the hope that it will be useful,
10 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |   GNU General Public License for more details.
13 | 
14 |   You should have received a copy of the GNU General Public License
15 |   along with JDasher; if not, write to the Free Software
16 |   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17 | 
18 |   Copyright (C) 2006      Christopher Smowton <cs448@cam.ac.uk>
19 | 
20 |   JDasher is a port derived from the Dasher project; for information on
21 |   the project see www.dasher.org.uk; for information on JDasher itself
22 |   and related projects see www.smowton.net/chris
23 | 
24 | */
25 | 
26 | package dasher;
27 | 
28 | /**
29 |  * Stub at the moment; may potentially be developed into a logfile
30 |  * writer in the future!
31 |  */
32 | public class CFileLogger {
33 | 
34 | 	/**
35 | 	 * Destroy the logger, which doesn't exist :)
36 | 	 *
37 | 	 */
38 | 	public void Destroy() {
39 | 		//stub
40 | 	}
41 | 	
42 | }
43 | 


--------------------------------------------------------------------------------
/src/dasher/CDynamicFilter.java:
--------------------------------------------------------------------------------
 1 | package dasher;
 2 | 
 3 | public abstract class CDynamicFilter extends CInputFilter {
 4 | 
 5 | 	private long m_iStartTime;
 6 | 
 7 | 	public CDynamicFilter(CDasherComponent creator, CDasherInterfaceBase iface,
 8 | 			String szName) {
 9 | 		super(creator, iface, szName);
10 | 	}
11 | 
12 | 	@Override
13 | 	public boolean supportsPause() {return true;}
14 | 
15 | 	/** Computes multiplier to apply to speed for this frame.
16 | 	 * The default implementation returns the model's viscosity, unless it's less than
17 | 	 * <code>LP_SLOW_START_TIME</code> time since we last unpaused, in which case we
18 | 	 * interpolate from 0.1 to 1.0 times that. 
19 | 	 * @param Time current time
20 | 	 * @return multiplier to apply to speed; 0.0 = go nowhere, 1.0 = normal speed, higher = faster!
21 | 	 */
22 | 	protected float getSpeedMul(CDasherModel pModel, long Time) {
23 | 		float dMul = pModel.getViscosity();
24 | 		//if (m_iStartTime==-1) m_iStartTime=Time;
25 | 		if (Time-m_iStartTime < GetLongParameter(Elp_parameters.LP_SLOW_START_TIME)) {
26 | 			dMul *= 0.1f+0.9f*(Time-m_iStartTime)/GetLongParameter(Elp_parameters.LP_SLOW_START_TIME);
27 | 		}
28 | 		return dMul;
29 | 	}
30 | 
31 | 	@Override public void pause() {m_bPaused=true;}
32 | 	
33 | 	protected void unpause(long iTime) {
34 | 		if (!m_bPaused) return;
35 | 		m_iStartTime=iTime;
36 | 		m_bPaused=false;
37 | 		m_Interface.Redraw(false);
38 | 	}
39 | 	
40 | 	protected final boolean isPaused() {return m_bPaused;}
41 | 	private boolean m_bPaused=true;
42 | }


--------------------------------------------------------------------------------
/src/dasher/android/CheckBoxPreference.java:
--------------------------------------------------------------------------------
 1 | package dasher.android;
 2 | 
 3 | //import java.lang.ref.WeakReference;
 4 | 
 5 | import android.content.Context;
 6 | import android.content.SharedPreferences;
 7 | import android.preference.PreferenceManager;
 8 | import android.util.AttributeSet;
 9 | 
10 | /** Extend Android's default CheckBoxPreference to listen to changes
11 |  * (to the value stored in SharedPreferences) that might come from
12 |  * other sources. Hopefully this'll let us have multiple CheckBoxPreferences,
13 |  * with the same key, at different points in the Preference screen hierarchy,
14 |  * and keep them in sync...
15 |  * @author Alan Lawrence <acl33@inf.phy.cam.ac.uk>
16 |  */
17 | public class CheckBoxPreference extends android.preference.CheckBoxPreference implements SharedPreferences.OnSharedPreferenceChangeListener {
18 | 
19 | 	public CheckBoxPreference(Context context, AttributeSet attrs) {
20 | 		super(context, attrs);
21 | 	    //Handily, SharedPreferences already keeps its listeners in a WeakHashMap,
22 | 	    // so registering as such does not prevent this from being GC'd; and when this
23 | 	    // is GC'd, the WeakHashMap'll automatically deregister us.
24 | 		PreferenceManager.getDefaultSharedPreferences(context)
25 | 			.registerOnSharedPreferenceChangeListener(this);
26 | 	}
27 | 	
28 | 	public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
29 | 		if (key.equals(getKey())) {
30 | 			onSetInitialValue(true, null); //true = "get from sharedpreferences"
31 | 		}
32 | 	  }
33 | 
34 | }
35 | 


--------------------------------------------------------------------------------
/src/dasher/android/IntQueue.java:
--------------------------------------------------------------------------------
 1 | package dasher.android;
 2 | 
 3 | public class IntQueue {
 4 | 	private int[] data=new int[4];
 5 | 	private int front; //next idx to push
 6 | 	private int back; //next idx to pop
 7 | 	
 8 | 	public void push(int i) {
 9 | 		if ((front+1) % data.length == back) {
10 | 			int[] ndata = new int[data.length*2];
11 | 			if (front>back) {
12 | 				System.arraycopy(data, back, ndata, 0, front-back);
13 | 				front-=back;
14 | 			} else {
15 | 				System.arraycopy(data, back, ndata, 0, data.length-back);
16 | 				System.arraycopy(data, 0, ndata, data.length-back, front);
17 | 				front += data.length-back;
18 | 			}
19 | 			data=ndata;
20 | 			back=0;
21 | 		}
22 | 		data[front++]=i;
23 | 		if (front==data.length) front=0;
24 | 	}
25 | 	
26 | 	public int pop() {
27 | 		if (front==back) throw new IndexOutOfBoundsException("Empty");
28 | 		int res = data[back++];
29 | 		if (back==data.length) back=0;
30 | 		return res;
31 | 	}
32 | 	
33 | 	public int size() {
34 | 		return (front+data.length-back) % data.length;
35 | 	}
36 | 	
37 | 	/*public static void main(String[] args) {
38 | 		IntQueue q=new IntQueue();
39 | 		for (int i=0; i<50; i++) {
40 | 			q.push(i);
41 | 			if ((i&1)==1) System.out.print("Pop "+q.pop());
42 | 			System.out.println(" now "+q.size()+" items");
43 | 		}
44 | 		while (q.size()>0) System.out.println("Pop "+q.pop()+" now "+q.size()+" items");
45 | 		q=new IntQueue();
46 | 		for (int i=0; i<100; i++) {
47 | 			q.push(i);
48 | 			if (i>2) System.out.print("Pop "+q.pop());
49 | 			System.out.println(" now "+q.size()+" items");
50 | 		}
51 | 	}*/
52 | }
53 | 


--------------------------------------------------------------------------------
/src/dasher/CCannaConversionHelper.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |   This file is part of JDasher.
 3 | 
 4 |   JDasher is free software; you can redistribute it and/or modify
 5 |   it under the terms of the GNU General Public License as published by
 6 |   the Free Software Foundation; either version 2 of the License, or
 7 |   (at your option) any later version.
 8 | 
 9 |   JDasher is distributed in the hope that it will be useful,
10 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |   GNU General Public License for more details.
13 | 
14 |   You should have received a copy of the GNU General Public License
15 |   along with JDasher; if not, write to the Free Software
16 |   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17 | 
18 |   Copyright (C) 2006      Christopher Smowton <cs448@cam.ac.uk>
19 | 
20 |   JDasher is a port derived from the Dasher project; for information on
21 |   the project see www.dasher.org.uk; for information on JDasher itself
22 |   and related projects see www.smowton.net/chris
23 | 
24 | */
25 | 
26 | package dasher;
27 | 
28 | import java.util.ArrayList;
29 | 
30 | public class CCannaConversionHelper extends CConversionHelper {
31 | 
32 | 	private int context_id;
33 | 	private boolean IsInit;
34 | 	
35 | 	public boolean Convert(final String strSource, ArrayList<ArrayList<String>> vResult) {
36 | 		return false;
37 | 		
38 | 		/* DUMMY METHOD */
39 | 		
40 | 	}
41 | 	
42 | 	/* INCOMPLETE. Appears to be used only if Dasher is compiled for the Japanese
43 | 	 * language, so I'll look at this later. Dummy methods inserted for now.
44 | 	 */
45 | 	
46 | }
47 | 


--------------------------------------------------------------------------------
/src/dasher/CUserLog.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |   This file is part of JDasher.
 3 | 
 4 |   JDasher is free software; you can redistribute it and/or modify
 5 |   it under the terms of the GNU General Public License as published by
 6 |   the Free Software Foundation; either version 2 of the License, or
 7 |   (at your option) any later version.
 8 | 
 9 |   JDasher is distributed in the hope that it will be useful,
10 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |   GNU General Public License for more details.
13 | 
14 |   You should have received a copy of the GNU General Public License
15 |   along with JDasher; if not, write to the Free Software
16 |   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17 | 
18 |   Copyright (C) 2006      Christopher Smowton <cs448@cam.ac.uk>
19 | 
20 |   JDasher is a port derived from the Dasher project; for information on
21 |   the project see www.dasher.org.uk; for information on JDasher itself
22 |   and related projects see www.smowton.net/chris
23 | 
24 | */
25 | 
26 | package dasher;
27 | 
28 | import java.util.ArrayList;
29 | 
30 | /**
31 |  * Stubbed logging class. These methods should be implemented
32 |  * if we want to start generating a textual log.
33 |  */
34 | public class CUserLog {
35 | 
36 | 	public CUserLog(CDasherComponent creator, int loglevel) {
37 | 		//stub
38 | 	}
39 | 	
40 | 	public void OutputFile() {
41 | 		// stub
42 | 	}
43 | 	
44 | 	public void Close() {
45 | 		// stub
46 | 	}
47 | 	
48 | 	public void InitIsDone() {
49 | 		// stub
50 | 	}
51 | 	
52 | 	public void StopWriting(float x) {
53 | 		// stub
54 | 	}
55 | 	
56 | 	public void StartWriting() {
57 | 		// stub
58 | 	}
59 | }


--------------------------------------------------------------------------------
/src/dasher/CDynamicButtons.java:
--------------------------------------------------------------------------------
 1 | package dasher;
 2 | 
 3 | import static dasher.CDasherModel.CROSS_Y;
 4 | 
 5 | public abstract class CDynamicButtons extends CDynamicFilter {
 6 | 
 7 | 	private CDasherModel model;
 8 | 	
 9 | 	/** Meaningless if we are paused */
10 | 	private boolean reversing;
11 | 
12 | 	public CDynamicButtons(CDasherComponent creator, CDasherInterfaceBase iface, String szName) {
13 | 		super(creator, iface, szName);
14 | 	}
15 | 
16 | 	/** When reversing, backs off; when paused, does nothing; when running, delegates to TimerImpl */
17 | 	@Override
18 | 	public void Timer(long iTime, CDasherView pView, CDasherInput pInput, CDasherModel pModel) {
19 | 		if (isPaused()) return;
20 | 		
21 | 		if (reversing)
22 | 			pModel.ScheduleOneStep(41904, CROSS_Y, iTime, getSpeedMul(pModel, iTime));
23 | 		else
24 | 			TimerImpl(iTime, pView, pModel);
25 | 	}
26 | 
27 | 	protected abstract void TimerImpl(long iTime, CDasherView pView, CDasherModel pModel);
28 | 
29 | 	protected void ApplyOffset(CDasherModel model, int off) {
30 | 		(this.model=model).Offset(off);
31 | 	}
32 | 	
33 | 	@Override public void pause() {
34 | 		if (model!=null) model.AbortOffset();
35 | 		super.pause();
36 | 	}
37 | 	
38 | 	protected void reverse(long iTime, CDasherModel pModel) {
39 | 		if (model!=null) model.AbortOffset(); 
40 | 		reversing=true;
41 | 		super.unpause(iTime);
42 | 	}
43 | 	protected final boolean isReversing() {return !isPaused() && reversing;}
44 | 	protected void run(long iTime, CDasherModel pModel) {
45 | 		reversing=false;
46 | 		super.unpause(iTime);
47 | 	}
48 | 	protected final boolean isRunning() {return !isPaused() && !reversing;}
49 | 	@Override protected final void unpause(long iTime) {
50 | 		throw new AssertionError("Subclasses should not call directly; call run/reverse instead");
51 | 	}
52 | }


--------------------------------------------------------------------------------
/src/dasher/CCompassMode.java:
--------------------------------------------------------------------------------
 1 | package dasher;
 2 | 
 3 | import static dasher.CDasherModel.MAX_Y;
 4 | 
 5 | public class CCompassMode extends CDasherButtons {
 6 | 	private int iTargetWidth;
 7 | 	public CCompassMode(CDasherComponent creator, CDasherInterfaceBase iface) {
 8 | 		super(creator, iface, "Compass Mode");
 9 | 	}
10 |   
11 | 	@Override protected SBox[] SetupBoxes() {
12 | 		final int iDasherY = (int)MAX_Y;
13 | 
14 | 		SBox[] m_pBoxes = new SBox[4];
15 | 
16 | 		iTargetWidth = (int)(iDasherY * 1024 / GetLongParameter(Elp_parameters.LP_RIGHTZOOM));
17 | 
18 | 		// FIXME - need to relate these to cross-hair position as stored in the parameters
19 | 
20 | 		// Not sure whether this is at all the right algorithm here - need to check
21 | 		int iTop = (2048 - iTargetWidth / 2);
22 | 		m_pBoxes[1] = new SBox(iTop, 4096 - iTop, 0);
23 | 
24 | 		// Make this the inverse of the right zoom option
25 | 
26 | 		int backTop = -2048 *  iTop / (2048 -  iTop);
27 | 		m_pBoxes[3] = new SBox(backTop, 4096 - backTop, 0);
28 |   
29 | 		m_pBoxes[0] = new SBox(-iTargetWidth, iDasherY - iTargetWidth, 0);
30 | 		m_pBoxes[2] = new SBox(iTargetWidth,iDasherY + iTargetWidth, 0);
31 | 
32 | 		return m_pBoxes;
33 | 	}
34 | 
35 | 	@Override public boolean DecorateView(CDasherView pView, CDasherInput pInput) {
36 | 		boolean bFirst=true;
37 | 		for (int iPos = 2048 - iTargetWidth / 2; iPos >= 0; iPos -= iTargetWidth) {
38 | 			
39 | 			pView.Dasherline(-100, iPos, -1000, iPos, 1, bFirst ? 1 : 2);
40 | 			
41 | 			pView.Dasherline(-100, 4096 - iPos, -1000, 4096-iPos, 1, bFirst ? 1 : 2);
42 | 			
43 | 			bFirst = false;
44 | 		}
45 | 		return false; //never changes!
46 | 	}
47 |  
48 | 	@Override public void HandleEvent(EParameters eParam) {
49 | 		if (eParam == Elp_parameters.LP_RIGHTZOOM) {
50 | 			m_pBoxes=SetupBoxes(); m_bDecorationChanged = true;
51 | 		}
52 | 	}
53 | }
54 | 


--------------------------------------------------------------------------------
/src/dasher/CScanning.java:
--------------------------------------------------------------------------------
 1 | package dasher;
 2 | 
 3 | import dasher.CDasherView.MutablePoint;
 4 | import dasher.Opts.ScreenOrientations;
 5 | 
 6 | public abstract class CScanning extends CDasherButtons {
 7 | 	private long m_iScanTime;
 8 | 	
 9 | 	public CScanning(CDasherComponent creator, CDasherInterfaceBase iface, String szName) {
10 | 		super(creator, iface, szName);
11 | 	}
12 | 	
13 | 	@Override public void Activate() {
14 | 		super.Activate();
15 | 		m_iScanTime = Integer.MIN_VALUE;
16 | 	}
17 | 	
18 | 	@Override public void KeyDown(long iTime, int iId, CDasherView pView, CDasherInput pInput, CDasherModel pModel) {
19 | 		if (iId==100) {
20 | 			pInput.GetScreenCoords(pView, coords);
21 | 			iId = (coords.y<pView.Screen().GetHeight()/2)
22 | 				? 1 //scan
23 | 				: 2; //select
24 | 			
25 | 		}
26 | 		switch(iId) {
27 | 		case 1:
28 | 		case 4:
29 | 			//scan.
30 | 			if (GetLongParameter(Elp_parameters.LP_BUTTON_SCAN_TIME)==0) {
31 | 				m_bDecorationChanged = true;
32 | 				if(++m_iActiveBox == m_pBoxes.length)
33 | 					m_iActiveBox = 0;
34 | 				m_Interface.Redraw(false);
35 | 				break;
36 | 			} else iId=2; //automatic scanning by timer, fall through to select
37 | 		case 2:
38 | 		case 3:
39 | 			m_bDecorationChanged = true;			
40 | 			scheduleZoom(pModel, m_pBoxes[m_iActiveBox].iX, m_pBoxes[m_iActiveBox].iY);
41 | 			if(m_iActiveBox != m_pBoxes.length-1)
42 | 				m_iActiveBox = 0;
43 | 			break;
44 | 		}
45 | 	}
46 | 	private final MutablePoint coords=new MutablePoint(); 
47 | 	
48 | 	@Override public void Timer(long Time, CDasherView m_pDasherView, CDasherInput pInput, CDasherModel pModel) {
49 | 		if (GetLongParameter(Elp_parameters.LP_BUTTON_SCAN_TIME)>0) {
50 | 			m_bDecorationChanged = true; //pretend - so the screen repaints!!
51 | 			if (Time > m_iScanTime) {
52 | 				m_iScanTime = Time + GetLongParameter(Elp_parameters.LP_BUTTON_SCAN_TIME);
53 | 			
54 | 				if(++m_iActiveBox == m_pBoxes.length)
55 | 					m_iActiveBox = 0;
56 | 			}
57 | 		}
58 | 	}
59 | 
60 | }


--------------------------------------------------------------------------------
/src/dasher/android/SettingsActivity.java:
--------------------------------------------------------------------------------
 1 | package dasher.android;
 2 | 
 3 | import java.util.ArrayList;
 4 | import java.util.List;
 5 | import java.util.Collections;
 6 | import java.util.ListIterator;
 7 | 
 8 | import android.os.Bundle;
 9 | import android.preference.ListPreference;
10 | import android.preference.PreferenceActivity;
11 | import android.util.Log;
12 | import dasher.CDasherInterfaceBase;
13 | import dasher.Esp_parameters;
14 | 
15 | public class SettingsActivity extends PreferenceActivity {
16 |     /** Called when the activity is first created. */
17 |     @Override
18 |     public void onCreate(Bundle savedInstanceState) {
19 |         super.onCreate(savedInstanceState);
20 |       
21 |         //We need a DasherInterface to parse alphabet/colour files and find the
22 |         //available schemes (in future perhaps also input filters, although
23 |         // atm the available options there are hardcoded into prefs.xml).
24 |         //However our Interface doesn't need to implement display, editing, etc.
25 |         // functions, so we stub those methods. (Also it will never load a
26 |         // training text.)
27 |         CDasherInterfaceBase intf = new ADasherInterface(this,false);
28 |         
29 |         addPreferencesFromResource(R.layout.prefs);
30 |         
31 |         IMCheckBox.setPrefScreen(getPreferenceScreen());
32 |     
33 |         addPermittedValues(intf, Esp_parameters.SP_ALPHABET_ID);
34 |         addPermittedValues(intf, Esp_parameters.SP_COLOUR_ID);
35 |     }
36 |     
37 |     private void addPermittedValues(CDasherInterfaceBase intf, Esp_parameters param) {
38 |     	List<String> values = new ArrayList<String>();
39 |        	ListPreference lp = (ListPreference)getPreferenceScreen().findPreference(param.regName());
40 |         intf.GetPermittedValues(param,values);
41 |         Collections.sort(values);
42 |         CharSequence[] vals = new CharSequence[values.size()];
43 |         int i=0;
44 |         for (String s : values) {
45 |         	vals[i++] = s;
46 |         }
47 |         lp.setEntries(vals);
48 |         lp.setEntryValues(vals);
49 |     }
50 | 	
51 | }
52 | 


--------------------------------------------------------------------------------
/src/dasher/CParameterNotFoundException.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |   This file is part of JDasher.
 3 | 
 4 |   JDasher is free software; you can redistribute it and/or modify
 5 |   it under the terms of the GNU General Public License as published by
 6 |   the Free Software Foundation; either version 2 of the License, or
 7 |   (at your option) any later version.
 8 | 
 9 |   JDasher is distributed in the hope that it will be useful,
10 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |   GNU General Public License for more details.
13 | 
14 |   You should have received a copy of the GNU General Public License
15 |   along with JDasher; if not, write to the Free Software
16 |   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17 | 
18 |   Copyright (C) 2006      Christopher Smowton <cs448@cam.ac.uk>
19 | 
20 |   JDasher is a port derived from the Dasher project; for information on
21 |   the project see www.dasher.org.uk; for information on JDasher itself
22 |   and related projects see www.smowton.net/chris
23 | 
24 | */
25 | 
26 | package dasher;
27 | 
28 | /**
29 |  * Exception to be thrown by a CSettingsStore object when it attempts
30 |  * to load a setting but is unable to find a record of it in its
31 |  * backing store.
32 |  * <p>
33 |  * This exception is caught within CSettingsStore, and is never
34 |  * seen by external classes.
35 |  * <p>
36 |  * Typically the SettingsStore responds to this problem by loading
37 |  * a default setting.
38 |  * <p>
39 |  * The base implementation of CSettingsStore throws this for all
40 |  * calls to LoadSetting, as it does not know about a backing store.
41 |  */
42 | public class CParameterNotFoundException extends Exception {
43 | 	/**
44 | 	 * Name of the parameter which couldn't be loaded.
45 | 	 */
46 | 	public String paramName;
47 | 	
48 | 	/**
49 | 	 * Creates a new ParameterNotFoundException.
50 | 	 * 
51 | 	 * @param p Parameter which couldn't be loaded
52 | 	 */
53 | 	public CParameterNotFoundException(String p) {
54 | 		this.paramName = p;
55 | 	}
56 | }
57 | 


--------------------------------------------------------------------------------
/src/dasher/CDynamicPresses.java:
--------------------------------------------------------------------------------
 1 | package dasher;
 2 | 
 3 | public abstract class CDynamicPresses extends CDynamicButtons {
 4 | 
 5 | 	protected static final int SINGLE_PRESS=1, DOUBLE_PRESS=2, LONG_PRESS=0;
 6 | 	
 7 |     private boolean m_bKeyDown;
 8 |     private int m_iKeyId;
 9 |     private long m_iKeyDownTime;
10 |     
11 | 	public CDynamicPresses(CDasherComponent creator, CDasherInterfaceBase iface, String szName) {
12 | 		super(creator, iface, szName);
13 | 	}
14 | 
15 | 	@Override
16 | 	protected void TimerImpl(long iTime, CDasherView pView, CDasherModel pModel) {
17 | 		if (m_bKeyDown && (iTime-m_iKeyDownTime)>GetLongParameter(Elp_parameters.LP_HOLD_TIME)) {
18 | 			Event(iTime,m_iKeyId, LONG_PRESS, pModel);
19 | 		}
20 | 	}
21 | 	
22 | 	@Override
23 | 	public void KeyDown(long iTime, int iId, CDasherView pView, CDasherInput pInput, CDasherModel pModel) {
24 | 		if (m_bKeyDown) return; //ignore any key after first
25 | 		m_bKeyDown = true;
26 | 		if (m_iKeyId==iId && iTime>m_iKeyDownTime && iTime - m_iKeyDownTime <= GetLongParameter(Elp_parameters.LP_DOUBLE_CLICK_TIME)) {
27 | 			Event(iTime, iId, DOUBLE_PRESS, pModel);
28 | 		} else {
29 | 			m_iKeyDownTime = iTime;
30 | 			m_iKeyId = iId;
31 | 			Event(iTime, iId, SINGLE_PRESS, pModel);
32 | 		}
33 | 	}
34 | 	
35 | 	protected void Event(long iTime, int iId, int pressType, CDasherModel pModel) {
36 | 		if (isReversing()) {
37 | 			pause();
38 | 		} else if (pressType!=SINGLE_PRESS) {
39 | 			reverse(iTime, pModel);
40 | 		} else if (isPaused()) {
41 | 			run(iTime, pModel);
42 | 		}
43 | 	}
44 | 	
45 | 	@Override
46 | 	public void KeyUp(long iTime, int iId, CDasherView pView, CDasherInput pInput, CDasherModel pModel) {
47 | 		if (iId==m_iKeyId) m_bKeyDown=false;
48 | 	}
49 | 	
50 | 	@Override public void pause() {
51 | 		m_iKeyDownTime = Long.MAX_VALUE;
52 | 		super.pause();
53 | 	}
54 | 	
55 | 	@Override protected void reverse(long iTime,CDasherModel pModel) {
56 | 		m_iKeyDownTime = Long.MAX_VALUE;
57 | 		super.reverse(iTime, pModel);
58 | 	}
59 | 	
60 | 	@Override protected void run(long iTime, CDasherModel pModel) {
61 | 		m_iKeyDownTime = Long.MAX_VALUE;
62 | 		super.run(iTime,pModel);
63 | 	}
64 | 	
65 | }
66 | 


--------------------------------------------------------------------------------
/AndroidManifest.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <manifest xmlns:android="http://schemas.android.com/apk/res/android"
 3 |       package="dasher.android" android:versionCode="9" android:versionName="2.5">
 4 |     <application android:icon="@drawable/icon" android:label="@string/app_name" android:debuggable="true">
 5 |     
 6 |     <!-- Declares the input method service -->
 7 |         <service android:name="DasherInputMethod"
 8 |             android:label="@string/app_name"
 9 |             android:permission="android.permission.BIND_INPUT_METHOD">
10 |             <intent-filter>
11 |                 <action android:name="android.view.InputMethod" />
12 |             </intent-filter>
13 |             <meta-data android:name="android.view.im" android:resource="@xml/method" />
14 |         </service>
15 | 
16 |         <!-- Optional activities...-->
17 |         <!-- The first actually lets you edit Dasher settings/prefs,
18 |         	 and we launch it with an explicit intent when we've been
19 |         	 through the setup/IME-enabling process; it's also listed in
20 |         	 xml/method.xml so it shows up on the Language+Keyboard prefs-->
21 |         <activity android:name=".SettingsActivity">
22 |         	<intent-filter>
23 |                 <action android:name="android.intent.action.MAIN" />
24 |             </intent-filter>
25 |         </activity>
26 |         
27 |         <!-- The second runs the user through the process of enabling
28 |              Dasher as an IME and selecting it as the active IME, then
29 |              invokes the former; we put this one in the App Launcher -->
30 |         <activity android:name=".DasherActivity"
31 |                   android:label="@string/settings_name">
32 |             <intent-filter>
33 |                 <action android:name="android.intent.action.MAIN" />
34 |                 <category android:name="android.intent.category.LAUNCHER" />
35 |             </intent-filter>
36 |         </activity>
37 | 
38 |     </application>
39 |     <uses-sdk android:minSdkVersion="4" />
40 | 	<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
41 | 	<uses-permission android:name="android.permission.WAKE_LOCK"/>
42 | </manifest> 
43 | 


--------------------------------------------------------------------------------
/src/dasher/applet/JDasherMenuBarListener.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |   This file is part of JDasher.
 3 | 
 4 |   JDasher is free software; you can redistribute it and/or modify
 5 |   it under the terms of the GNU General Public License as published by
 6 |   the Free Software Foundation; either version 2 of the License, or
 7 |   (at your option) any later version.
 8 | 
 9 |   JDasher is distributed in the hope that it will be useful,
10 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |   GNU General Public License for more details.
13 | 
14 |   You should have received a copy of the GNU General Public License
15 |   along with JDasher; if not, write to the Free Software
16 |   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17 | 
18 |   Copyright (C) 2006      Christopher Smowton <cs448@cam.ac.uk>
19 | 
20 |   JDasher is a port derived from the Dasher project; for information on
21 |   the project see www.dasher.org.uk; for information on JDasher itself
22 |   and related projects see www.smowton.net/chris
23 | 
24 | */
25 | 
26 | package dasher.applet;
27 | 
28 | import java.util.Collection;
29 | 
30 | import dasher.Ebp_parameters;
31 | import dasher.Elp_parameters;
32 | import dasher.Esp_parameters;
33 | 
34 | /**
35 |  * Interface which must be implemented by all classes that wish
36 |  * to hear about events spawned by the JDasherMenuBar.  
37 |  * <p>
38 |  * The functions will each be called when the menu item corresponding
39 |  * to their name is invoked.
40 |  */
41 | public interface JDasherMenuBarListener {
42 | 	
43 | 	public void menuNew();
44 | 	
45 | 	public void menuCut();
46 | 	
47 | 	public void menuCopy();
48 | 	
49 | 	public void menuPaste();
50 | 	
51 | 	public void menuExit();
52 | 	
53 | 	public void menuSelFont();
54 | 	
55 | 	public void menuHelpAbout();
56 | 	
57 | 	// For clipboard control
58 | 	public boolean isDataFlavorAvailable(java.awt.datatransfer.DataFlavor flavour);
59 | 	
60 | 	public void menuSetString(Esp_parameters param, String val);
61 | 	public void menuSetLong(Elp_parameters param, long val);
62 | 	public void menuSetBool(Ebp_parameters param, boolean val);
63 | }
64 | 


--------------------------------------------------------------------------------
/src/dasher/SGroupInfo.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |   This file is part of JDasher.
 3 | 
 4 |   JDasher is free software; you can redistribute it and/or modify
 5 |   it under the terms of the GNU General Public License as published by
 6 |   the Free Software Foundation; either version 2 of the License, or
 7 |   (at your option) any later version.
 8 | 
 9 |   JDasher is distributed in the hope that it will be useful,
10 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |   GNU General Public License for more details.
13 | 
14 |   You should have received a copy of the GNU General Public License
15 |   along with JDasher; if not, write to the Free Software
16 |   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17 | 
18 |   Copyright (C) 2006      Christopher Smowton <cs448@cam.ac.uk>
19 | 
20 |   JDasher is a port derived from the Dasher project; for information on
21 |   the project see www.dasher.org.uk; for information on JDasher itself
22 |   and related projects see www.smowton.net/chris
23 | 
24 | */
25 | 
26 | package dasher;
27 | 
28 | /**
29 |  * Small struct representing a group of Nodes, as used to draw
30 |  * coloured grouping boxes which surround a family of nodes, such
31 |  * as punctuation.
32 |  */
33 | public class SGroupInfo {
34 | 	
35 | 	public SGroupInfo(String label, int col, boolean visible) {
36 | 		this.strLabel = label;
37 | 		this.iColour = col;
38 | 		this.bVisible = visible;
39 | 	}
40 | 
41 | 	/**
42 | 	 * First child group
43 | 	 */
44 | 	SGroupInfo Child;
45 | 	
46 | 	/**
47 | 	 * Next sibling group
48 | 	 */
49 | 	SGroupInfo Next;
50 | 	
51 | 	/**
52 | 	 * Label for this group
53 | 	 */
54 | 	final String strLabel;
55 | 	
56 | 	/**
57 | 	 * Index of the first node contained in this group
58 | 	 */
59 | 	int iStart;
60 | 	
61 | 	/**
62 | 	 * Index of the last node contained in this group
63 | 	 */
64 | 	int iEnd;
65 | 	
66 | 	/**
67 | 	 * Colour index used to draw this group
68 | 	 */
69 | 	final int iColour;
70 | 	
71 | 	/**
72 | 	 * Should this group be drawn?
73 | 	 */
74 | 	final boolean bVisible;
75 | 
76 | 	/** Number of child nodes = immediate subgroups + symbols contained directly (not in a subgroup) */ 
77 | 	int iNumChildNodes;
78 | }


--------------------------------------------------------------------------------
/src/dasher/android/IMCheckBox.java:
--------------------------------------------------------------------------------
 1 | package dasher.android;
 2 | 
 3 | import java.lang.ref.WeakReference;
 4 | import java.util.HashSet;
 5 | import java.util.Iterator;
 6 | import java.util.Set;
 7 | 
 8 | import android.content.Context;
 9 | import android.content.SharedPreferences;
10 | import android.preference.Preference;
11 | import android.preference.PreferenceManager;
12 | import android.preference.PreferenceScreen;
13 | import android.util.AttributeSet;
14 | import android.widget.CheckBox;
15 | 
16 | public abstract class IMCheckBox extends CheckBox {
17 | 	
18 | 	protected static final String androidns = "http://schemas.android.com/apk/res/android";
19 | 	public static final String SETTING = "AndroidInputMethod";
20 | 	private static final Set<WeakReference<IMCheckBox>> BOXES = new HashSet<WeakReference<IMCheckBox>>();
21 | 	private final String key;
22 | 	
23 | 	protected IMCheckBox(Context ctx, AttributeSet attrs) {
24 | 		super(ctx,attrs);
25 | 		key = attrs.getAttributeValue(androidns, "key");
26 | 		BOXES.add(new WeakReference<IMCheckBox>(this));
27 | 		((PreferenceScreen)ps.findPreference(key)).setOnPreferenceClickListener(lstnr);
28 | 	}
29 | 	
30 | 	@Override public void onFinishInflate() {
31 | 		super.onFinishInflate();
32 | 		setChecked(PreferenceManager.getDefaultSharedPreferences(getContext()).getString(SETTING,"_"+key).equals(key));
33 | 	}
34 | 
35 | 	@Override public final void setChecked(boolean b) {
36 | 		if (isChecked()==b) return;
37 | 		super.setChecked(b);
38 | 		if (b) hasBecomeChecked();
39 | 	}
40 | 	
41 | 	public static void set(String key) {
42 | 		for (Iterator<WeakReference<IMCheckBox>> it=BOXES.iterator(); it.hasNext();) {
43 | 			WeakReference<IMCheckBox> wr = it.next();
44 | 			IMCheckBox r = wr.get();
45 | 			if (r==null)
46 | 				it.remove();
47 | 			else
48 | 				r.setChecked(r.key.equals(key));
49 | 		}	
50 | 	}
51 | 
52 | 	public static void setPrefScreen(PreferenceScreen _ps) {ps=_ps;}
53 | 	protected static PreferenceScreen ps;
54 | 	
55 | 	protected void hasBecomeChecked() {
56 | 		SharedPreferences.Editor edit = PreferenceManager.getDefaultSharedPreferences(getContext()).edit();
57 | 		edit.putString(SETTING, key);
58 | 		edit.commit();
59 | 	}
60 | 	
61 | 	public String toString() {return getClass().getName()+" w/ key "+key;}
62 | 
63 | 	private static final Preference.OnPreferenceClickListener lstnr = new Preference.OnPreferenceClickListener() {
64 |     	public boolean onPreferenceClick(Preference pref) {
65 |     		IMCheckBox.set(pref.getKey());
66 |     		return false; //allow normal click action to occur too
67 |     	}
68 |     };
69 | 
70 | }


--------------------------------------------------------------------------------
/src/dasher/applet/JMouseInput.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |   This file is part of JDasher.
 3 | 
 4 |   JDasher is free software; you can redistribute it and/or modify
 5 |   it under the terms of the GNU General Public License as published by
 6 |   the Free Software Foundation; either version 2 of the License, or
 7 |   (at your option) any later version.
 8 | 
 9 |   JDasher is distributed in the hope that it will be useful,
10 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |   GNU General Public License for more details.
13 | 
14 |   You should have received a copy of the GNU General Public License
15 |   along with JDasher; if not, write to the Free Software
16 |   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17 | 
18 |   Copyright (C) 2006      Christopher Smowton <cs448@cam.ac.uk>
19 | 
20 |   JDasher is a port derived from the Dasher project; for information on
21 |   the project see www.dasher.org.uk; for information on JDasher itself
22 |   and related projects see www.smowton.net/chris
23 | 
24 | */
25 | 
26 | package dasher.applet;
27 | 
28 | import java.awt.event.*;
29 | 
30 | import dasher.CDasherView;
31 | import dasher.CDasherView.MutablePoint;
32 | 
33 | /**
34 |  * Simple mouse input device which uses a mouse motion listener to
35 |  * track the mouse position and reports the latest reading when
36 |  * GetCoordinates is called.
37 |  * <p>
38 |  * Only methods which differ significantly from their abstract meanings
39 |  * documented in CDasherInput are documented here; for further details
40 |  * see CDasherInput.
41 |  */
42 | public class JMouseInput extends dasher.CDasherInput implements MouseMotionListener {
43 | 
44 | 	/**
45 | 	 * Last seen mouse X co-ordinate
46 | 	 */
47 | 	private int mouseX;
48 | 	
49 | 	/**
50 | 	 * Last seen mouse Y co-ordinate
51 | 	 */
52 | 	private int mouseY;
53 | 	
54 | 	public JMouseInput() {
55 | 		super("Mouse Input"); 
56 | 	}
57 | 
58 | 	/**
59 | 	 * Calls through to mouseMoved - as this gets called in place of the former, if a button is being held down...
60 | 	 */
61 | 	public void mouseDragged(MouseEvent e) {
62 | 		mouseMoved(e);
63 | 	}
64 | 
65 | 	/**
66 | 	 * Stores the last seen mouse coordinates.
67 | 	 */
68 | 	public void mouseMoved(MouseEvent e) {
69 | 		mouseX = e.getX();
70 | 		mouseY = e.getY();
71 | 	}
72 | 
73 | 	@Override
74 | 	public boolean GetScreenCoords(CDasherView pView, MutablePoint into) {
75 | 		into.init(mouseX, mouseY);
76 | 		return true;
77 | 	}
78 | 	
79 | }
80 | 


--------------------------------------------------------------------------------
/src/dasher/android/DualIMCheckBox.java:
--------------------------------------------------------------------------------
 1 | package dasher.android;
 2 | 
 3 | import dasher.Esp_parameters;
 4 | import android.content.Context;
 5 | import android.content.SharedPreferences;
 6 | import android.preference.CheckBoxPreference;
 7 | import android.preference.Preference;
 8 | import android.preference.PreferenceManager;
 9 | import android.preference.PreferenceScreen;
10 | import android.util.AttributeSet;
11 | 
12 | public class DualIMCheckBox extends IMCheckBox {
13 | 	private final String inputDevOn,inputDevOff;
14 | 	private final String inputFilOn,inputFilOff;
15 | 	private final String childKey;
16 | 	
17 | 	public DualIMCheckBox(Context ctx, AttributeSet attrs) {
18 | 		super(ctx, attrs);
19 | 		childKey = attrs.getAttributeValue(null, "childKey");
20 | 		inputDevOn = getAttribute(attrs,"inputDeviceOn","inputDevice");
21 | 		inputDevOff= getAttribute(attrs,"inputDeviceOff","inputDevice");
22 | 		inputFilOn= getAttribute(attrs,"inputFilterOn","inputFilter");
23 | 		inputFilOff = getAttribute(attrs,"inputFilterOff","inputFilter");
24 | 		CheckBoxPreference cb = (CheckBoxPreference)ps.findPreference(childKey);
25 | 		cb.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {
26 | 			
27 | 			public boolean onPreferenceChange(Preference preference, Object newValue) {
28 | 				DualIMCheckBox.this.setInputsForChildChecked(((Boolean)newValue).booleanValue());
29 | 				return true; //allow
30 | 			}
31 | 		});
32 | 	}
33 | 	
34 | 	private static String getAttribute(AttributeSet attrs, String fst, String snd) {
35 | 		String res = attrs.getAttributeValue(null,fst);
36 | 		if (res!=null) return res;
37 | 		return attrs.getAttributeValue(null, snd);
38 | 	}
39 | 	
40 | 	@Override protected void hasBecomeChecked() {
41 | 		super.hasBecomeChecked();
42 | 		setInputsForChildChecked(PreferenceManager.getDefaultSharedPreferences(getContext()).getBoolean(childKey, false));
43 | 	}
44 | 	
45 | 	public void setInputsForChildChecked(boolean b) {
46 | 		String d,f;
47 | 		if (b) {
48 | 			d=inputDevOn; f=inputFilOn;
49 | 		} else {
50 | 			d=inputDevOff; f=inputFilOff;
51 | 		}
52 | 		//writing to the persistent settings store will trigger an 
53 | 		// OnSharedPreferencesChanged listener in the main/IME service
54 | 		// (if its active) which will update the in-memory parameters
55 | 		// there. (Using an AndroidSettings might be more modular, but
56 | 		// would entail reading all settings into memory every time!)
57 | 		SharedPreferences.Editor edit = PreferenceManager.getDefaultSharedPreferences(getContext()).edit();
58 | 		edit.putString(Esp_parameters.SP_INPUT_DEVICE.regName(), d);
59 | 		edit.putString(Esp_parameters.SP_INPUT_FILTER.regName(), f);
60 | 		edit.commit();
61 | 	}
62 | 
63 | }
64 | 


--------------------------------------------------------------------------------
/assets/alphabet.dtd:
--------------------------------------------------------------------------------
 1 | <!-- alphabets contains groups of valid symbols for use in Dasher,
 2 | along with some useful information. It does nothing to tell Dasher,
 3 | how those symbols may be used. -->
 4 | 
 5 | <!ELEMENT alphabets (alphabet*)>
 6 | 
 7 | <!ELEMENT alphabet (orientation, encoding, train, paragraph, space, control, group*)>
 8 | <!ATTLIST alphabet name CDATA #REQUIRED>
 9 | 
10 | <!-- Left-Right, Right-Left, Top-Bottom or Bottom-Top?
11 | Which way up should Dasher do its rendering by default? -->
12 | <!ELEMENT orientation EMPTY>
13 | <!ATTLIST orientation type (LR|RL|TB|BT) #REQUIRED>
14 | 
15 | <!-- The encoding field just helps Dasher decide on some Localisation
16 | issues. In theory it could see which characters are there and pick
17 | a suitable file encoding and font. Sometimes this is difficult.
18 | It does not dictate the file format. For example, traditionally Unix
19 | and Windows use different encodings for some languages. A platform
20 | should do what what it thinks best given the vague group Dasher
21 | has put the alphabet into. If this doesn't work out, the user
22 | can over-ride the alphabet anyway. -->
23 | <!ELEMENT encoding EMPTY>
24 | <!ATTLIST encoding type CDATA #REQUIRED>
25 | 
26 | <!-- Default training file for this alphabet -->
27 | <!ELEMENT train (#PCDATA)>
28 | 
29 | <!-- Traditionally the paragraph character is rendered differently to all
30 | others. Can set d (display) to "" to disable. -->
31 | <!ELEMENT paragraph EMPTY>
32 | <!ATTLIST paragraph d CDATA #REQUIRED>
33 | <!ATTLIST paragraph f CDATA #IMPLIED>
34 | <!ATTLIST paragraph b CDATA #IMPLIED>
35 | 
36 | <!-- Traditionally the space character is rendered differently to all
37 | others. Can set both d (display) and t (text) to "" to disable. -->
38 | <!ELEMENT space EMPTY>
39 | <!ATTLIST space d CDATA #REQUIRED>
40 | <!ATTLIST space t CDATA #REQUIRED>
41 | <!ATTLIST space f CDATA #IMPLIED>
42 | <!ATTLIST space b CDATA #IMPLIED>
43 | 
44 | <!-- The control character is special, and not part of the main alphabet. -->
45 | 
46 | <!ELEMENT control EMPTY>
47 | <!ATTLIST control d CDATA #REQUIRED>
48 | <!ATTLIST control t CDATA #REQUIRED>
49 | <!ATTLIST control f CDATA #IMPLIED>
50 | <!ATTLIST control b CDATA #IMPLIED>
51 | 
52 | <!-- Logical groups of symbols, eg name="Lower case letters" -->
53 | <!ELEMENT group (s*)>
54 | <!ATTLIST group name CDATA #REQUIRED>
55 | <!ATTLIST group b CDATA #IMPLIED>
56 | 
57 | <!-- Symbols Dasher can use. It shows text d in the nodes and sends
58 | text t to the edit box -->
59 | <!ELEMENT s EMPTY>
60 | <!ATTLIST s d CDATA #REQUIRED>
61 | <!ATTLIST s t CDATA #REQUIRED>
62 | <!ATTLIST s f CDATA #IMPLIED>
63 | <!ATTLIST s b CDATA #IMPLIED>
64 | 


--------------------------------------------------------------------------------
/res/layout/install.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <RelativeLayout
 3 |   xmlns:android="http://schemas.android.com/apk/res/android"
 4 |   android:orientation="vertical"
 5 |   android:layout_width="fill_parent"
 6 |   android:layout_height="fill_parent">
 7 |   
 8 |   <TextView android:id="@+id/title"
 9 |   	android:layout_width="fill_parent"
10 |   	android:layout_height="wrap_content"
11 |   	android:text="@string/install_title"
12 |   	android:background="@android:color/background_dark"
13 |   	android:textSize="20dip"/>
14 |   	
15 |   <!-- Text set programmatically according to whether enabled or not -->
16 |   <TextView android:id="@+id/enable"
17 |   	android:layout_width="fill_parent"
18 |   	android:layout_height="wrap_content"
19 |   	android:layout_below="@id/title"
20 |   	android:layout_alignRight="@id/title"
21 |   	android:layout_marginLeft="10dip"/>
22 |   
23 |   <Button android:id="@+id/sys_sets_btn"
24 |   	android:layout_width="wrap_content"
25 |   	android:layout_height="wrap_content"
26 |   	android:layout_below="@id/enable"
27 |   	android:layout_centerHorizontal="true"
28 |   	android:text="@string/IMESettings"/>
29 |   
30 |   <!-- Text set programmatically according to whether Dasher is selected IME -->
31 |   <TextView android:id="@+id/select"
32 |   	android:layout_width="fill_parent"
33 |   	android:layout_height="wrap_content"
34 |   	android:layout_below="@id/sys_sets_btn"
35 |   	android:layout_alignRight="@id/title"
36 |   	android:layout_marginLeft="10dip"
37 |   	android:layout_marginTop="10dip"/>
38 |   	
39 |   <EditText android:id="@+id/long_press"
40 |   	android:layout_width="fill_parent"
41 |   	android:layout_height="wrap_content"
42 |   	android:layout_below="@id/select"/>
43 |   
44 |   <TextView android:id="@+id/dasher_sets_title"
45 |   	android:layout_width="fill_parent"
46 |   	android:layout_height="wrap_content"
47 |   	android:layout_below="@id/long_press"
48 |   	android:layout_marginTop="10dip"
49 |   	android:text="@string/dasher_sets_title"
50 |   	android:background="@android:color/background_dark"
51 |   	android:textSize="20dip"/>
52 |   	
53 |   <TextView android:id="@+id/dasher_sets_desc"
54 |     android:layout_width="fill_parent"
55 |     android:layout_height="wrap_content"
56 |     android:layout_below="@id/dasher_sets_title"
57 |     android:text="@string/dasher_sets_desc"
58 |     android:layout_alignRight="@id/title"
59 |   	android:layout_marginLeft="10dip"/>
60 |   	
61 |   <Button android:id="@+id/dasher_sets_btn"
62 |   	android:layout_width="wrap_content"
63 |   	android:layout_height="wrap_content"
64 |   	android:layout_below="@id/dasher_sets_desc"
65 |   	android:layout_centerHorizontal="true"
66 |   	android:text="@string/DasherSettingsBtn"/>
67 |   
68 | </RelativeLayout>
69 | 


--------------------------------------------------------------------------------
/src/dasher/CMenuMode.java:
--------------------------------------------------------------------------------
 1 | package dasher;
 2 | 
 3 | import static dasher.CDasherModel.MAX_Y;
 4 | 
 5 | /*static SModuleSettings sSettings[] = {
 6 |   // TRANSLATORS: The number of time steps over which to perform the zooming motion in button mode.
 7 |   {LP_ZOOMSTEPS, T_LONG, 1, 63, 1, 1, _("Zoom steps")},
 8 |   {LP_BUTTON_SCAN_TIME, T_LONG, 0, 2000, 1, 100, _("Scan time in menu mode (0 to not scan)")},
 9 |   {LP_B, T_LONG, 2, 10, 1, 1, _("Number of boxes")},
10 |   {LP_S, T_LONG, 0, 256, 1, 1, _("Safety margin")},
11 |   // TRANSLATORS: The boxes (zoom targets) in button mode can either be the same size, or different sizes - this is the extent to which the sizes are allowed to differ from each other.
12 |   // XXX PRLW: 128 log(2) = 89, where 2 is the ratio of adjacent boxes
13 |   // however the code seems to use ratio = (129/127)^-r, instead of
14 |   // ratio = exp(r/128) used in the design document
15 |   //
16 |   {LP_R, T_LONG, -89, 89, 1, 10, _("Box non-uniformity")},
17 |   // TRANSLATORS: Intercept keyboard events for 'special' keys even when the Dasher window doesn't have keyboard focus.
18 |   {BP_GLOBAL_KEYBOARD, T_BOOL, -1, -1, -1, -1, _("Global keyboard grab")}
19 | };*/
20 | 
21 | public class CMenuMode extends CScanning {
22 | 	public CMenuMode(CDasherComponent creator, CDasherInterfaceBase iface, String szName) {
23 | 		super(creator, iface, szName);
24 | 	}
25 | 
26 | 	protected SBox[] SetupBoxes() {
27 | 		final int iDasherY = (int)MAX_Y;
28 | 
29 | 		int iForwardBoxes = (int)GetLongParameter(Elp_parameters.LP_B);
30 | 		SBox[] m_pBoxes = new SBox[iForwardBoxes+1];
31 | 
32 | 		// Calculate the sizes of non-uniform boxes using standard
33 | 		// geometric progression results
34 | 
35 | 		// FIXME - implement this using DJCM's integer method?
36 | 		// See ~mackay/dasher/buttons/
37 | 		final double dRatio = Math.pow(129/127.0, GetLongParameter(Elp_parameters.LP_R));
38 | 		final int lpS = (int)GetLongParameter(Elp_parameters.LP_S);
39 | 
40 | 		double dMaxSize;
41 | 		if(dRatio == 1.0)
42 | 			dMaxSize = iDasherY / (double)iForwardBoxes;
43 | 		else
44 | 			dMaxSize = ((dRatio - 1)/(Math.pow(dRatio, iForwardBoxes) - 1)) * iDasherY; 
45 | 
46 | 		double dMin = 0.0;
47 | 
48 | 		for(int i = 0; i < iForwardBoxes; ++i) { // One button reserved for backoff
49 | 			double dMax = dMin + dMaxSize * Math.pow(dRatio, i);
50 |   
51 | //       m_pBoxes[i].iDisplayTop = (i * iDasherY) / (m_iNumBoxes.length - 1);
52 | //       m_pBoxes[i].iDisplayBottom = ((i+1) * iDasherY) / (m_iNumBoxes.length - 1);
53 | 			m_pBoxes[i] = new SBox((int)dMin, (int)dMax,lpS);
54 | 			dMin = dMax;
55 | 		}
56 |   
57 | 		m_pBoxes[m_pBoxes.length-1]=new SBox((iDasherY * (1-iForwardBoxes))/ 2,(iDasherY * (1+iForwardBoxes))/2,0,iDasherY);
58 | 		
59 | 		return m_pBoxes;
60 | 	}
61 | 
62 | 	@Override public void HandleEvent(EParameters eParam) {
63 | 		if (eParam == Elp_parameters.LP_B || eParam == Elp_parameters.LP_R) {
64 | 			m_pBoxes = SetupBoxes(); m_bDecorationChanged = true;
65 | 		}
66 | 	}
67 | 
68 | }


--------------------------------------------------------------------------------
/src/dasher/Esp_parameters.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |   This file is part of JDasher.
 3 | 
 4 |   JDasher is free software; you can redistribute it and/or modify
 5 |   it under the terms of the GNU General Public License as published by
 6 |   the Free Software Foundation; either version 2 of the License, or
 7 |   (at your option) any later version.
 8 | 
 9 |   JDasher is distributed in the hope that it will be useful,
10 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |   GNU General Public License for more details.
13 | 
14 |   You should have received a copy of the GNU General Public License
15 |   along with JDasher; if not, write to the Free Software
16 |   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17 | 
18 |   Copyright (C) 2006      Christopher Smowton <cs448@cam.ac.uk>
19 | 
20 |   JDasher is a port derived from the Dasher project; for information on
21 |   the project see www.dasher.org.uk; for information on JDasher itself
22 |   and related projects see www.smowton.net/chris
23 | 
24 | */
25 | 
26 | package dasher;
27 | 
28 | /**
29 |  * Enumeration of possible String parameter references. See
30 |  * CParamTables for a list and definitions.
31 |  */
32 | public enum Esp_parameters implements EParameters {
33 | 			SP_ORIENTATION("Orientation", "", "Orientation (TB/BT/LR/RL) - anything else = use alphabet"),
34 | 			  SP_ALPHABET_ID("AlphabetID", "", "AlphabetID"),
35 | 			  SP_ALPHABET_1("Alphabet1", "", "Alphabet History 1"),
36 | 			  SP_ALPHABET_2("Alphabet2", "", "Alphabet History 2"),
37 | 			  SP_ALPHABET_3("Alphabet3", "", "Alphabet History 3"),
38 | 			  SP_ALPHABET_4("Alphabet4", "", "Alphabet History 4"),
39 | 			  SP_COLOUR_ID("ColourID", "", "ColourID"), 
40 | 			  SP_DASHER_FONT("DasherFont", "", "DasherFont"),
41 | 			  SP_SOCKET_INPUT_X_LABEL("SocketInputXLabel", "x", "Label preceding X values for network input"),
42 | 			  SP_SOCKET_INPUT_Y_LABEL("SocketInputYLabel", "y", "Label preceding Y values for network input"),
43 | 			  SP_INPUT_FILTER("InputFilter", "Stylus Control", "Input filter used to provide the current control mode"),
44 | 			  SP_INPUT_DEVICE("InputDevice", "Mouse Input", "Driver for the input device"),
45 | 			  SP_LM_HOST("LMHost", "", "Language Model Host");
46 | 			  
47 | 			  private Esp_parameters(String rName, String def, String hr) {
48 | 					humanReadable = hr;
49 | 					defaultVal = def;
50 | 					regName = rName;
51 | 					BY_NAME.put(regName,this);
52 | 				}
53 | 				
54 | 			  private static final int SP_OFFSET = Ebp_parameters.values().length + Elp_parameters.values().length;
55 | 			  public int key() {return ordinal()+SP_OFFSET;}
56 | 			  public String regName() {return regName;}
57 | 			  public void reset(CSettingsStore ss) {ss.SetStringParameter(this, defaultVal);}
58 | 			  
59 | 			private final String regName;
60 | 			final String defaultVal;
61 | 			final String humanReadable;
62 | }
63 | 


--------------------------------------------------------------------------------
/src/dasher/XMLFileParser.java:
--------------------------------------------------------------------------------
 1 | package dasher;
 2 | 
 3 | import java.io.IOException;
 4 | import java.io.InputStream;
 5 | import java.util.List;
 6 | import java.util.ArrayList;
 7 | 
 8 | import javax.xml.parsers.ParserConfigurationException;
 9 | import javax.xml.parsers.SAXParser;
10 | import javax.xml.parsers.SAXParserFactory;
11 | 
12 | import org.xml.sax.Attributes;
13 | import org.xml.sax.InputSource;
14 | import org.xml.sax.SAXException;
15 | import org.xml.sax.helpers.DefaultHandler;
16 | 
17 | /**
18 |  * Abstract superclass for XML file parsing (colours, alphabets).
19 |  * Exists for two reasons:
20 |  * <UL>
21 |  * <LI> To provide a common (abstract) entry point for parsing files
22 |  * found by implementations of {@link CDasherInterfaceBase#ScanXMLFiles(XMLFileParser, String)}
23 |  * <LI> Provides a common implementation of {@link #getStream(String)}, used
24 |  * to try to locate DTDs (differently by subclasses).
25 |  * @author acl33
26 |  */
27 | public abstract class XMLFileParser extends DefaultHandler {
28 | 	protected final CDasherInterfaceBase m_Interface;
29 | 	private final SAXParser parser;
30 | 	public XMLFileParser(CDasherInterfaceBase intf) {
31 | 		this.m_Interface = intf;
32 | 		SAXParserFactory factory = SAXParserFactory.newInstance();
33 | 		SAXParser p;
34 | 		try {
35 | 			p = factory.newSAXParser();
36 | 		} catch(Exception e) {
37 | 			//Report error, but continue - and don't parse files -
38 | 			// so user gets something minimal rather than nothing
39 | 			System.out.printf("Exception creating XML parser: %s%n", e);
40 | 			p=null;
41 | 		}
42 | 		parser=p;
43 | 	}
44 | 	
45 | 	/**
46 | 	 * Process the provided XML file!
47 | 	 * @param in InputStream allowing the file to be read
48 | 	 * @param bLoadMutable True if the file should be allowed to be edited (e.g.
49 | 	 * per-user files), false if not (e.g. for system files). TODO, editing is
50 | 	 * not actually implemented at this point; so either implement it, or remove
51 | 	 * the API...
52 | 	 * @throws SAXException If there was an error during parsing - XML malformed?
53 | 	 * @throws IOException If the file/stream could not be properly read
54 | 	 */
55 | 	public void ParseFile(InputStream in, boolean bLoadMutable) throws SAXException, IOException {
56 | 		if (parser!=null)
57 | 			parser.parse(new InputSource(in),this);
58 | 	}
59 | 	
60 | 	/**
61 | 	 * Method to lookup resources e.g. DTD files. Provided to ease
62 | 	 * implementation of DefaultHandler#resolveEntity(String,String).
63 | 	 * Looks up the filename using {@link CDasherInterfaceBase#GetStreams(String, java.util.Collection)},
64 | 	 * and returns an InputSource constructed from the first stream found, or else null.
65 | 	 * 
66 | 	 * @param name Filename needed (e.g. "alphabet.dtd")
67 | 	 * @return InputSource for the resource/entity, if possible, else null.
68 | 	 */
69 | 	protected final InputSource getStream(String name) {
70 | 		List<InputStream> streams = new ArrayList<InputStream>();
71 | 		m_Interface.GetStreams(name, streams);
72 | 		if (!streams.isEmpty()) return new InputSource(streams.get(0));
73 | 		return null;
74 | 	}
75 | 
76 | }
77 | 


--------------------------------------------------------------------------------
/src/dasher/EParameters.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |   This file is part of JDasher.
 3 | 
 4 |   JDasher is free software; you can redistribute it and/or modify
 5 |   it under the terms of the GNU General Public License as published by
 6 |   the Free Software Foundation; either version 2 of the License, or
 7 |   (at your option) any later version.
 8 | 
 9 |   JDasher is distributed in the hope that it will be useful,
10 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |   GNU General Public License for more details.
13 | 
14 |   You should have received a copy of the GNU General Public License
15 |   along with JDasher; if not, write to the Free Software
16 |   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17 | 
18 |   Copyright (C) 2006      Christopher Smowton <cs448@cam.ac.uk>
19 | 
20 |   JDasher is a port derived from the Dasher project; for information on
21 |   the project see www.dasher.org.uk; for information on JDasher itself
22 |   and related projects see www.smowton.net/chris
23 | 
24 | */
25 | 
26 | package dasher;
27 | 
28 | import java.util.HashMap;
29 | import java.util.Map;
30 | 
31 | /**
32 |  * Interface implemented by all parameter enumerations, allowing
33 |  * an EParameters to be passed as a generic parameter of indeterminate
34 |  * type.
35 |  * All C++-style integer based enums have now been replaced by three Enum types
36 |  * which implement EParameters, meaning one can pass both a generic parameter AND
37 |  * a specialised parameter. For references into the tables, the .ordinal() of
38 |  * a specialised parameter is used. All switch() statements should now check
39 |  * the parameter's type, cast it to the appropriate one, and then switch on
40 |  * the relevant enum. Alternatively it may be possible to have cases of a
41 |  * child-type, I've yet to check this.
42 |  * 
43 |  * 14/07: The whole codebase is now converted to use the new parameter scheme.
44 |  * It's broadly very solid; everything is passed around as enum types until the actual
45 |  * load/store instructions in CSettingsStore, whereupon ordinals are taken.
46 |  * 
47 |  * The only weakness is that one CANNOT in fact switch on an EParameters, since
48 |  * there is no way for the compiler to know that all its children are Enums.
49 |  * There may be some way around this -- some sort of enum-interface -- but
50 |  * I haven't found it yet. This can be solved by splitting any switch
51 |  * into three, type-checking, casting, and then switching in a type-specific
52 |  * manner.
53 |  */
54 | public interface EParameters {
55 | 
56 | 	public int key();
57 | 	public String regName();
58 | 	public void reset(CSettingsStore ss);
59 | 	public static final Map<String,EParameters> BY_NAME=new HashMap<String,EParameters>();
60 | 	
61 | 	/* CSFS: This space intentionally left blank.
62 | 	 * 
63 | 	 * This is the parent class for the enumerations of all three types of parameters.
64 | 	 * Ebp_parameters houses the boolean parameters,
65 | 	 * Elp_parameters the longs,
66 | 	 * and Esp_parameters the strings.
67 | 	 */
68 | 	
69 | }
70 | 


--------------------------------------------------------------------------------
/src/dasher/CModuleManager.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |   This file is part of JDasher.
 3 | 
 4 |   JDasher is free software; you can redistribute it and/or modify
 5 |   it under the terms of the GNU General Public License as published by
 6 |   the Free Software Foundation; either version 2 of the License, or
 7 |   (at your option) any later version.
 8 | 
 9 |   JDasher is distributed in the hope that it will be useful,
10 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |   GNU General Public License for more details.
13 | 
14 |   You should have received a copy of the GNU General Public License
15 |   along with JDasher; if not, write to the Free Software
16 |   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17 | 
18 |   Copyright (C) 2006      Christopher Smowton <cs448@cam.ac.uk>
19 | 
20 |   JDasher is a port derived from the Dasher project; for information on
21 |   the project see www.dasher.org.uk; for information on JDasher itself
22 |   and related projects see www.smowton.net/chris
23 | 
24 | */
25 | 
26 | package dasher;
27 | 
28 | import java.util.Map;
29 | import java.util.HashMap;
30 | import java.util.Collection;
31 | 
32 | /**
33 |  * Helper class for the InterfaceBase which enumerates the modules
34 |  * present in supplied module factories and returns said modules
35 |  * by ID or by name on request.
36 |  * <p>
37 |  * A list of all available modules can also be supplied.
38 |  */
39 | public class CModuleManager {
40 | 	/**
41 | 	 * Map from modules' Strings to the modules themselves
42 | 	 */
43 | 	protected final Map<String, CDasherModule> m_mapModules = new HashMap<String, CDasherModule>();
44 | 	
45 | 	/**
46 | 	 * Store the module in our internal map so it can be retrieved
47 | 	 * using GetModuleByName <!--or GetModule-->
48 | 	 * 
49 | 	 * @param mod the new module; must have a unique name
50 | 	 */
51 | 	public void RegisterModule(CDasherModule mod) {
52 | 		String s = mod.getName();
53 | 		if (m_mapModules.containsKey(s))
54 | 			throw new IllegalArgumentException("Module "+s+" already exists!");
55 | 		m_mapModules.put(s, mod);
56 | 	}
57 | 	
58 | 	/**
59 | 	 * Gets a module with the given name and supertype (typically {@link CDasherInput} or {@link CInputFilter})
60 | 	 * 
61 | 	 * @param iID ID of the required module
62 | 	 * @return Matching Module, or null if none was found.
63 | 	 */
64 | 	public <T extends CDasherModule> T GetModuleByName(Class<T> clazz, String strName) {
65 | 		CDasherModule m = m_mapModules.get(strName);
66 | 		return (clazz.isInstance(m)) ? clazz.cast(m) : null;
67 | 	}
68 | 	
69 | 	/**
70 | 	 * Retrieves a list of all modules of a given type.
71 | 	 *  
72 | 	 * @param clazz Type of modules to enumerate - typically {@link CDasherInput} or {@link CInputFilter}
73 | 	 * @param vList Collection to be filled with the names of available
74 | 	 * modules
75 | 	 */
76 | 	public <T> void ListModules(Class<T> clazz, Collection<? super T> vList) {
77 | 		for(CDasherModule m : m_mapModules.values())
78 | 			if(clazz.isInstance(m))
79 | 				vList.add(clazz.cast(m));
80 | 	}
81 | 
82 | }
83 | 


--------------------------------------------------------------------------------
/src/dasher/TwoButtonDynamicFilter.java:
--------------------------------------------------------------------------------
 1 | package dasher;
 2 | 
 3 | import static dasher.CDasherModel.CROSS_Y;
 4 | import dasher.CDasherView.MutablePoint;
 5 | 
 6 | public class TwoButtonDynamicFilter extends CDynamicPresses {
 7 | 
 8 | 	private BounceMarker up,down;
 9 | 	private boolean m_bDecorationChanged;
10 | 	private double m_dNatsAtLastApply;
11 | 	
12 | 	public TwoButtonDynamicFilter(CDasherComponent creator, CDasherInterfaceBase iface) {
13 | 		super(creator, iface, "Two-button Dynamic Mode");
14 | 		createMarkers();
15 | 	}
16 | 
17 | 	@Override
18 | 	public boolean DecorateView(CDasherView pView, CDasherInput pInput) {
19 | 		up.Draw(pView);
20 | 		down.Draw(pView);
21 | 		if (m_bDecorationChanged) {
22 | 			m_bDecorationChanged=false;
23 | 			return true;
24 | 		}
25 | 		return false;
26 | 	}
27 | 	
28 | 	@Override
29 | 	public void TimerImpl(long iTime, CDasherView pView,CDasherModel pModel) {
30 | 		super.TimerImpl(iTime, pView, pModel);
31 | 		pModel.ScheduleOneStep(0, CROSS_Y, iTime, getSpeedMul(pModel, iTime));
32 | 	}
33 | 
34 | 	@Override
35 | 	public void HandleEvent(EParameters eParam) {
36 | 		if (eParam==Elp_parameters.LP_TWO_BUTTON_OFFSET) 
37 | 			createMarkers();
38 | 		super.HandleEvent(eParam);
39 | 	}
40 | 	
41 | 	private void createMarkers() {
42 | 		up = new BounceMarker((int)GetLongParameter(Elp_parameters.LP_TWO_BUTTON_OFFSET));
43 | 		down = new BounceMarker((int)-GetLongParameter(Elp_parameters.LP_TWO_BUTTON_OFFSET));
44 | 		m_bDecorationChanged=true;
45 | 	}
46 | 	
47 | 	private final MutablePoint coords=new MutablePoint();
48 | 	
49 | 	@Override public void KeyDown(long iTime, int iId, CDasherView pView, CDasherInput pInput, CDasherModel pModel) {
50 | 		if (iId==100 && pInput.GetDasherCoords(pView, coords))
51 | 			iId = (coords.y < CROSS_Y) ? 0 : 1;
52 | 		super.KeyDown(iTime, iId, pView, pInput, pModel);
53 | 	}
54 | 	
55 | 	@Override public void KeyUp(long iTime, int iId, CDasherView pView, CDasherInput pInput, CDasherModel pModel) {
56 | 		if (iId==100 && pInput.GetDasherCoords(pView, coords))
57 | 			iId = (coords.y < CROSS_Y) ? 0 : 1;
58 | 		super.KeyUp(iTime, iId, pView, pInput, pModel);
59 | 	}
60 | 	
61 | 	@Override public void Event(long iTime, int iId, int pressType, CDasherModel pModel) {
62 | 		marker: if (pressType==SINGLE_PRESS && isRunning()) {
63 | 			BounceMarker pMarker;
64 | 			if (iId==0 || iId==4) pMarker=up; else if (iId==1 || iId==2) pMarker=down; else break marker;
65 | 			//apply offset
66 | 			double dCurBitrate = GetLongParameter(Elp_parameters.LP_MAX_BITRATE) / 100.0;
67 | 			int iOffset = pMarker.GetTargetOffset(dCurBitrate*getSpeedMul(pModel, iTime));
68 | 			if (pModel.m_iDisplayOffset!=0) System.err.println("Display Offset "+pModel.m_iDisplayOffset+" reducing to "+(iOffset -= pModel.m_iDisplayOffset));
69 | 			double dNewNats = pModel.GetNats() - m_dNatsAtLastApply;
70 | 			up.NotifyOffset(iOffset, dNewNats);
71 | 			down.NotifyOffset(iOffset, dNewNats);
72 | 			pMarker.RecordPush(iOffset, 0.0, dCurBitrate);
73 | 			ApplyOffset(pModel,iOffset);
74 | 			m_dNatsAtLastApply = pModel.GetNats();
75 | 		}
76 | 		super.Event(iTime, iId, pressType, pModel);
77 | 	}
78 | 	
79 | 	@Override protected void reverse(long iTime, CDasherModel pModel) {
80 | 		up.clearPushes(); down.clearPushes();
81 | 		super.reverse(iTime, pModel);
82 | 	}
83 | 
84 | }
85 | 


--------------------------------------------------------------------------------
/src/dasher/android/DasherActivity.java:
--------------------------------------------------------------------------------
 1 | package dasher.android;
 2 | 
 3 | import android.app.Activity;
 4 | import android.content.Intent;
 5 | import android.os.Bundle;
 6 | import android.os.Handler;
 7 | import android.provider.Settings;
 8 | import android.view.View;
 9 | import android.view.View.OnClickListener;
10 | import android.view.inputmethod.InputMethodInfo;
11 | import android.view.inputmethod.InputMethodManager;
12 | import android.widget.Button;
13 | import android.widget.EditText;
14 | import android.widget.TextView;
15 | 
16 | public class DasherActivity extends Activity implements OnClickListener, Runnable {
17 | 
18 | 	private TextView enabledLbl;
19 | 	private Button imeSettingsBtn;
20 | 	private TextView selectedLbl;
21 | 	private EditText longPress;
22 | 	private Button dasherSettingsButton;
23 | 	
24 | 	private String m_sID;
25 | 	private boolean bShownDasherSets;
26 | 	private Handler handler;
27 | 	
28 | 	@Override public void onCreate(Bundle savedInstanceState) {
29 | 		super.onCreate(savedInstanceState);
30 | 		setContentView(R.layout.install);
31 | 		enabledLbl = (TextView)findViewById(R.id.enable);
32 | 		imeSettingsBtn = (Button)findViewById(R.id.sys_sets_btn);
33 | 		imeSettingsBtn.setOnClickListener(this);
34 | 		
35 | 		selectedLbl = (TextView)findViewById(R.id.select);
36 | 		longPress = (EditText)findViewById(R.id.long_press);
37 | 		dasherSettingsButton = (Button)findViewById(R.id.dasher_sets_btn);
38 | 		dasherSettingsButton.setOnClickListener(this);
39 | 
40 | 		handler = new Handler();
41 | 	}
42 | 	
43 | 	@Override public void onResume() {
44 | 		super.onResume();
45 | 		//1. is Dasher enabled?
46 | 		m_sID = null;
47 | 		InputMethodManager imm = (InputMethodManager)getSystemService(INPUT_METHOD_SERVICE);
48 | 		for (InputMethodInfo inf : imm.getEnabledInputMethodList()) {
49 | 			if (inf.getPackageName().equals(this.getPackageName())
50 | 					&& inf.getServiceName().equals(DasherInputMethod.class.getName())) {
51 | 				m_sID=inf.getId(); break;
52 | 			}
53 | 		}
54 | 		
55 | 		if (m_sID==null) {
56 | 			enabledLbl.setText(R.string.DasherNeedsEnable);
57 | 			imeSettingsBtn.setEnabled(true);
58 | 		} else {
59 | 			enabledLbl.setText(R.string.DasherEnabledOk);
60 | 			imeSettingsBtn.setEnabled(false);
61 | 		}
62 | 		run();
63 | 	}
64 | 	
65 | 	/** Executed on UI Thread, either directly from onResume()
66 | 		or as a callback via handler.postDelayed(). */
67 | 	public void run() {
68 | 		//2. is Dasher the active input method?
69 | 		if (m_sID!=null && 
70 | 				Settings.Secure.getString(getContentResolver(),
71 | Settings.Secure.DEFAULT_INPUT_METHOD).equals(m_sID)) {
72 | 			
73 | 			selectedLbl.setText(R.string.DasherSelectedOk);
74 | 			longPress.setEnabled(false);
75 | 			//go straight to settings, once
76 | 			if (!bShownDasherSets) {
77 | 				bShownDasherSets=true;
78 | 				onClick(dasherSettingsButton);
79 | 			}
80 | 		} else {
81 | 			selectedLbl.setText(R.string.DasherNeedsSelect);
82 | 			longPress.setEnabled(true);
83 | 		}
84 | 		handler.postDelayed(this,500);
85 | 	}
86 | 		
87 | 	@Override public void onPause() {
88 | 		handler.removeCallbacks(this);
89 | 		super.onPause();
90 | 	}
91 | 	
92 | 	public void onClick(View v) {
93 | 		if (v == imeSettingsBtn)
94 | 			startActivity(new Intent(Settings.ACTION_INPUT_METHOD_SETTINGS));
95 | 		else if (v==dasherSettingsButton)
96 | 			startActivity(new Intent(this,SettingsActivity.class));
97 | 	}
98 | 
99 | }


--------------------------------------------------------------------------------
/src/dasher/applet/alphabet.dtd:
--------------------------------------------------------------------------------
 1 | <!-- alphabets contains groups of valid symbols for use in Dasher,
 2 | along with some useful information. It does nothing to tell Dasher,
 3 | how those symbols may be used. -->
 4 | 
 5 | <!ELEMENT alphabets (alphabet*)>
 6 | 
 7 | <!ELEMENT alphabet (orientation, encoding, palette, train, paragraph,
 8 | 	space, control, conversionmode?, group*)>
 9 | <!ATTLIST alphabet name CDATA #REQUIRED>
10 | 
11 | <!-- Left-Right, Right-Left, Top-Bottom or Bottom-Top?
12 | Which way up should Dasher do its rendering by default? -->
13 | <!ELEMENT orientation EMPTY>
14 | <!ATTLIST orientation type (LR|RL|TB|BT) #REQUIRED>
15 | 
16 | <!-- The encoding field just helps Dasher decide on some Localisation
17 | issues. In theory it could see which characters are there and pick
18 | a suitable file encoding and font. Sometimes this is difficult.
19 | It does not dictate the file format. For example, traditionally Unix
20 | and Windows use different encodings for some languages. A platform
21 | should do what it thinks best given the vague group Dasher
22 | has put the alphabet into. If this doesn't work out, the user
23 | can over-ride the alphabet anyway. -->
24 | <!ELEMENT encoding EMPTY>
25 | <!ATTLIST encoding type (
26 | 	Arabic |
27 | 	Baltic |
28 | 	CentralEurope |
29 | 	ChineseSimplified |
30 | 	ChineseTraditional |
31 | 	Cyrillic |
32 | 	Greek |
33 | 	Hebrew |
34 | 	Japanese |
35 | 	Korean |
36 | 	Thai |
37 | 	Turkish |
38 | 	VietNam |
39 | 	Western ) #REQUIRED>
40 | 
41 | <!-- Colour palette -->
42 | <!ELEMENT palette (#PCDATA)>
43 | 
44 | <!-- Default training file for this alphabet -->
45 | <!ELEMENT train (#PCDATA)>
46 | 
47 | <!-- Traditionally the paragraph character is rendered differently to all
48 | others. Can set d (display) to "" to disable. -->
49 | <!ELEMENT paragraph EMPTY>
50 | <!ATTLIST paragraph d CDATA #REQUIRED>
51 | <!ATTLIST paragraph f CDATA #IMPLIED>
52 | <!ATTLIST paragraph b CDATA #IMPLIED>
53 | 
54 | <!-- Traditionally the space character is rendered differently to all
55 | others. Can set both d (display) and t (text) to "" to disable. -->
56 | <!ELEMENT space EMPTY>
57 | <!ATTLIST space d CDATA #REQUIRED>
58 | <!ATTLIST space t CDATA #REQUIRED>
59 | <!ATTLIST space f CDATA #IMPLIED>
60 | <!ATTLIST space b CDATA #IMPLIED>
61 | <!ATTLIST space note CDATA #IMPLIED>
62 | 
63 | <!-- The control character is special, and not part of the main alphabet. -->
64 | <!ELEMENT control EMPTY>
65 | <!ATTLIST control d CDATA #REQUIRED>
66 | <!ATTLIST control t CDATA #REQUIRED>
67 | <!ATTLIST control f CDATA #IMPLIED>
68 | <!ATTLIST control b CDATA #IMPLIED>
69 | 
70 | <!-- Conversion mode sets the way selected characters are converted into
71 | a new one. In essence, set this to 1 for Japanese and 2 for Chinese. 0 is
72 | the default, i.e., no conversion. -->
73 | <!ELEMENT conversionmode EMPTY>
74 | <!ATTLIST conversionmode id CDATA #REQUIRED>
75 | 
76 | <!-- Logical groups of symbols, eg name="Lower case letters" -->
77 | <!ELEMENT group (s*)>
78 | <!ATTLIST group name    CDATA #REQUIRED>
79 | <!ATTLIST group label   CDATA #IMPLIED>
80 | <!ATTLIST group visible CDATA #IMPLIED>
81 | <!ATTLIST group b       CDATA #IMPLIED>
82 | 
83 | <!-- Symbols Dasher can use. It shows text d in the nodes and sends
84 | text t to the edit box -->
85 | <!ELEMENT s EMPTY>
86 | <!ATTLIST s d CDATA #REQUIRED>
87 | <!ATTLIST s t CDATA #REQUIRED>
88 | <!ATTLIST s f CDATA #IMPLIED>
89 | <!ATTLIST s b CDATA #IMPLIED>
90 | 


--------------------------------------------------------------------------------
/src/dasher/android/TiltInput.java:
--------------------------------------------------------------------------------
 1 | package dasher.android;
 2 | 
 3 | import java.util.List;
 4 | 
 5 | import android.content.Context;
 6 | import android.content.SharedPreferences;
 7 | import android.hardware.Sensor;
 8 | import android.hardware.SensorEvent;
 9 | import android.hardware.SensorEventListener;
10 | import android.hardware.SensorManager;
11 | import android.preference.PreferenceManager;
12 | import android.util.Log;
13 | import android.view.WindowManager;
14 | import dasher.CDasherInput;
15 | import dasher.CDasherView;
16 | 
17 | public class TiltInput extends CDasherInput implements SensorEventListener {
18 | 	private final SensorManager sm;
19 | 	private final WindowManager wm;
20 | 	
21 | 	/** Last (/current) values of tilt position, as floats in (0,1) */
22 | 	private float fx,fy;
23 | 	/** X & Y values from h/w tilt sensor are multiplied by these scales, then offsets added */
24 | 	private float y_mul, y_off, x_mul, x_off;
25 | 	
26 | 	public void setAxes(float minX, float maxX, float minY, float maxY) {
27 | 		y_mul = 1.0f/(maxY-minY); this.y_off = minY/(maxY-minY); //these may be inverted (min > max)
28 | 		x_mul = 1.0f/(minX-maxX); this.x_off = maxX/(minX-maxX); //these we definitely expect to be inverted!
29 | 	}
30 | 	
31 | 	private boolean bActive;
32 | 	private final Sensor s;
33 | 	
34 | 	public static TiltInput MAKE(Context androidCtx) {
35 | 		SensorManager sm=(SensorManager)androidCtx.getSystemService(Context.SENSOR_SERVICE);
36 | 		WindowManager wm = (WindowManager)androidCtx.getSystemService(Context.WINDOW_SERVICE);
37 | 		List<Sensor> ss = sm.getSensorList(Sensor.TYPE_ACCELEROMETER);
38 | 		if (ss.isEmpty()) return null;
39 | 		TiltInput ti = new TiltInput(sm, ss.get(0),wm);
40 | 		CalibPreference.addTiltDevice(ti);
41 | 		return ti;
42 | 	}
43 | 	
44 | 	private TiltInput(SensorManager sm, Sensor s, WindowManager wm) {
45 | 		super("Tilt Input");
46 | 		this.sm=sm;
47 | 		this.s=s;
48 | 		this.wm=wm;
49 | 	}
50 | 	
51 | 	@Override public void Activate() {
52 | 		if (bActive) return;
53 | 		bActive=true;
54 | 		sm.registerListener(this, s, SensorManager.SENSOR_DELAY_UI);
55 | 	}
56 | 	
57 | 	@Override public void Deactivate() {
58 | 		if (!bActive) return;
59 | 		bActive=false;
60 | 		sm.unregisterListener(this,s);
61 | 	}
62 | 	
63 | 	public void onAccuracyChanged(Sensor sensor, int accuracy) {}
64 | 	private int m_iLastOrient;
65 | 	public void onSensorChanged(SensorEvent event) {
66 | 		float[] vals=event.values;
67 | 		/*StringBuilder sb=new StringBuilder();
68 | 		for (int i=0; i<vals.length; i++)
69 | 			sb.append(i==0 ? "{" : ",").append(vals[i]);
70 | 		sb.append("}");
71 | 		android.util.Log.d("DasherIME","Got rotation "+sb);*/
72 | 		int orient = wm.getDefaultDisplay().getOrientation();
73 | 		if (orient != m_iLastOrient) Log.d("DasherIME", "Orientation changed to "+(m_iLastOrient=orient));
74 | 		if ((orient&1)==1) {
75 | 			fx = vals[1]*x_mul - x_off;
76 | 			if ((orient&2)==0) fx=1.0f-fx;
77 | 			fy = vals[0]*y_mul - y_off;
78 | 		} else {
79 | 			fx = vals[0]*x_mul - x_off;
80 | 			fy = vals[1]*y_mul - y_off;
81 | 		}
82 | 		fx = Math.max(0.0f, Math.min(1.0f, fx));
83 | 		fy = Math.max(0.0f, Math.min(1.0f, fy));
84 | 	}
85 | 	
86 | 	@Override
87 | 	public boolean GetScreenCoords(CDasherView pView, CDasherView.MutablePoint Coordinates) {
88 | 		if (!bActive) return false;
89 | 		Coordinates.init((int)(fx * pView.Screen().GetWidth()), (int)(fy * pView.Screen().GetHeight()));
90 | 		//android.util.Log.d("DasherIME","Tilt: got "+Coordinates[0]+", "+Coordinates[1]);
91 | 		return true;
92 | 	}
93 | 
94 | }
95 | 


--------------------------------------------------------------------------------
/src/dasher/Opts.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |   This file is part of JDasher.
 3 | 
 4 |   JDasher is free software; you can redistribute it and/or modify
 5 |   it under the terms of the GNU General Public License as published by
 6 |   the Free Software Foundation; either version 2 of the License, or
 7 |   (at your option) any later version.
 8 | 
 9 |   JDasher is distributed in the hope that it will be useful,
10 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |   GNU General Public License for more details.
13 | 
14 |   You should have received a copy of the GNU General Public License
15 |   along with JDasher; if not, write to the Free Software
16 |   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17 | 
18 |   Copyright (C) 2006      Christopher Smowton <cs448@cam.ac.uk>
19 | 
20 |   JDasher is a port derived from the Dasher project; for information on
21 |   the project see www.dasher.org.uk; for information on JDasher itself
22 |   and related projects see www.smowton.net/chris
23 | 
24 | */
25 | 
26 | package dasher;
27 | 
28 | import java.util.Map;
29 | import java.util.HashMap;
30 | /**
31 |  * List of miscellaneous constants, some of which are probably
32 |  * now redundant, inclduing those describing encodings, as Java
33 |  * will always use UTF16 internally.
34 |  */
35 | public class Opts {
36 | 	
37 | 	// Encodings
38 | 	
39 | 	public static final int UserDefault = -1; 
40 | 	public static final int AlphabetDefault = -2; 
41 | 	public static final int UTF8 = 65001;
42 | 	public static final int UTF16LE = 1200;
43 | 	public static final int UTF16BE = 1201;
44 | 	
45 | 	/**
46 | 	 * List of available screen orientations. The "Alphabet"
47 | 	 * option means that the Alphabet's preferred orientation
48 | 	 * is used.
49 | 	 */
50 | 	public static enum ScreenOrientations {
51 | 		LEFT_TO_RIGHT(true),RIGHT_TO_LEFT(true),TOP_TO_BOTTOM(false),BOTTOM_TO_TOP(false);
52 | 		
53 | 		private ScreenOrientations(boolean bHoriz) {this.isHorizontal=bHoriz;}
54 | 		public final boolean isHorizontal;
55 | 	}
56 | 	
57 | 	public static ScreenOrientations orientationFromString(String s) {
58 | 		return abbrevOrientations.get(s.trim().toUpperCase());
59 | 	}
60 | 	
61 | 	private static final Map<String,ScreenOrientations> abbrevOrientations = new HashMap<String,ScreenOrientations>();
62 | 	static {
63 | 		abbrevOrientations.put("RL", ScreenOrientations.RIGHT_TO_LEFT);
64 | 		abbrevOrientations.put("LR", ScreenOrientations.LEFT_TO_RIGHT);
65 | 		abbrevOrientations.put("TB", ScreenOrientations.TOP_TO_BOTTOM);
66 | 		abbrevOrientations.put("BT", ScreenOrientations.BOTTOM_TO_TOP);
67 | 	}
68 | 	/**
69 | 	 * This appears to enumerate codepages, which is also very
70 | 	 * much useless in Java.
71 | 	 */
72 | 	class AlphabetTypes { 
73 | 		public static final int MyNone = 0;
74 | 		public static final int Arabic = 1256;
75 | 		public static final int Baltic = 1257;
76 | 		public static final int CentralEurope = 1250;
77 | 		public static final int ChineseSimplified = 936;
78 | 		public static final int ChineseTraditional = 950;
79 | 		public static final int Cyrillic = 1251;
80 | 		public static final int Greek = 1253;
81 | 		public static final int Hebrew = 1255;
82 | 		public static final int Japanese = 932;
83 | 		public static final int Korean = 949;
84 | 		public static final int Thai = 874;
85 | 		public static final int Turkish = 1254;
86 | 		public static final int VietNam = 1258;
87 | 		public static final int Western = 1252; }
88 | }
89 | 


--------------------------------------------------------------------------------
/src/dasher/CButtonMode.java:
--------------------------------------------------------------------------------
 1 | package dasher;
 2 | 
 3 | import static dasher.CDasherModel.MAX_Y;
 4 | /*static SModuleSettings sSettings[] = {
 5 |   // TRANSLATORS: The number of time steps over which to perform the zooming motion in button mode.
 6 |   {LP_ZOOMSTEPS, T_LONG, 1, 63, 1, 1, _("Zoom steps")},
 7 |   {LP_BUTTON_SCAN_TIME, T_LONG, 0, 2000, 1, 100, _("Scan time in menu mode (0 to not scan)")},
 8 |   {LP_B, T_LONG, 2, 10, 1, 1, _("Number of boxes")},
 9 |   {LP_S, T_LONG, 0, 256, 1, 1, _("Safety margin")},
10 |   // TRANSLATORS: The boxes (zoom targets) in button mode can either be the same size, or different sizes - this is the extent to which the sizes are allowed to differ from each other.
11 |   // XXX PRLW: 128 log(2) = 89, where 2 is the ratio of adjacent boxes
12 |   // however the code seems to use ratio = (129/127)^-r, instead of
13 |   // ratio = exp(r/128) used in the design document
14 |   //
15 |   {LP_R, T_LONG, -89, 89, 1, 10, _("Box non-uniformity")},
16 |   // TRANSLATORS: Intercept keyboard events for 'special' keys even when the Dasher window doesn't have keyboard focus.
17 |   {BP_GLOBAL_KEYBOARD, T_BOOL, -1, -1, -1, -1, _("Global keyboard grab")}
18 | };*/
19 | 
20 | public class CButtonMode extends CDasherButtons {
21 | 	public CButtonMode(CDasherComponent creator, CDasherInterfaceBase iface, String szName) {
22 | 		super(creator, iface, szName);
23 | 	}
24 | 
25 | 	protected SBox[] SetupBoxes() {
26 | 		final int iDasherY = (int)MAX_Y;
27 | 
28 | 		int iForwardBoxes = (int)GetLongParameter(Elp_parameters.LP_B);
29 | 		SBox[] m_pBoxes = new SBox[iForwardBoxes+1];
30 | 
31 | 		// Calculate the sizes of non-uniform boxes using standard
32 | 		// geometric progression results
33 | 
34 | 		// FIXME - implement this using DJCM's integer method?
35 | 		// See ~mackay/dasher/buttons/
36 | 		final double dRatio = Math.pow(129/127.0, GetLongParameter(Elp_parameters.LP_R));
37 | 		final int lpS = (int)GetLongParameter(Elp_parameters.LP_S);
38 | 	      
39 | 		if(iForwardBoxes == 2) { // Special case for two forwards buttons
40 | 			double dNorm = 1+dRatio;
41 | 
42 | 			m_pBoxes[0]=new SBox(0,(int)(iDasherY/dNorm),lpS);
43 | 
44 | 			m_pBoxes[1]=new SBox((int)(iDasherY/dNorm),iDasherY,lpS);
45 | 		} else {
46 | 			boolean bEven = iForwardBoxes % 2 == 0;
47 | 
48 | 			int iGeometricTerms = (iForwardBoxes+1)/2;
49 | 
50 | 			double dMaxSize;
51 | 
52 | 			if(dRatio == 1.0) {
53 | 				dMaxSize = iDasherY / iForwardBoxes;
54 | 			} else {
55 | 				if(bEven)
56 | 					dMaxSize = iDasherY * (dRatio - 1) / (2 * (Math.pow(dRatio, iGeometricTerms) - 1));
57 | 				else
58 | 					dMaxSize = iDasherY * (dRatio - 1) / (2 * (Math.pow(dRatio, iGeometricTerms) - 1) - (dRatio - 1));
59 | 			}
60 | 
61 | 			double dMin;
62 | 			
63 | 			if(bEven)
64 | 				dMin = iDasherY / 2;
65 | 			else
66 | 				dMin = (iDasherY - dMaxSize)/2;
67 | 
68 | 			final int iUpBase = iForwardBoxes / 2; //round down if !bEven
69 | 			final int iDownBase = (iForwardBoxes-1)/2; //round down if bEven
70 | 
71 | 			for(int i = 0; i < iGeometricTerms; ++i) { // One button reserved for backoff
72 | 				double dMax = dMin + dMaxSize * Math.pow(dRatio, i);
73 | 
74 | 		        m_pBoxes[iUpBase + i]=new SBox((int)dMin,(int)dMax,lpS);
75 | 		        
76 | 		        m_pBoxes[iDownBase - i]=new SBox((int)(iDasherY - dMax),(int)(iDasherY - dMin), lpS);
77 | 
78 | 		        dMin = dMax;
79 | 			}
80 | 		}
81 |   
82 | 		m_pBoxes[m_pBoxes.length-1]=new SBox((iDasherY * (1-iForwardBoxes))/ 2,(iDasherY * (1+iForwardBoxes))/2,0,iDasherY);
83 | 		
84 | 		return m_pBoxes;
85 | 	}
86 | 
87 | 	@Override public void HandleEvent(EParameters eParam) {
88 | 		if (eParam == Elp_parameters.LP_B || eParam==Elp_parameters.LP_R) {
89 | 			m_pBoxes=SetupBoxes(); m_bDecorationChanged=true;
90 | 		}
91 | 	}
92 | }


--------------------------------------------------------------------------------
/src/dasher/CClickFilter.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |   This file is part of JDasher.
 3 | 
 4 |   JDasher is free software; you can redistribute it and/or modify
 5 |   it under the terms of the GNU General Public License as published by
 6 |   the Free Software Foundation; either version 2 of the License, or
 7 |   (at your option) any later version.
 8 | 
 9 |   JDasher is distributed in the hope that it will be useful,
10 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |   GNU General Public License for more details.
13 | 
14 |   You should have received a copy of the GNU General Public License
15 |   along with JDasher; if not, write to the Free Software
16 |   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17 | 
18 |   Copyright (C) 2006      Christopher Smowton <cs448@cam.ac.uk>
19 | 
20 |   JDasher is a port derived from the Dasher project; for information on
21 |   the project see www.dasher.org.uk; for information on JDasher itself
22 |   and related projects see www.smowton.net/chris
23 | 
24 | */
25 | 
26 | package dasher;
27 | 
28 | import static dasher.CDasherModel.CROSS_X;
29 | import dasher.CDasherView.MutablePoint;
30 | 
31 | /**
32 |  * This is an InputFilter implementation which accepts mouse clicks
33 |  * and causes Dasher to zoom to the location of successive clicks.
34 |  * <p>
35 |  * The filter does not pay any attention to the mouse position
36 |  * except for when the user clicks the display, and does not
37 |  * decorate the display in any way.
38 |  * <p>
39 |  * In order to zoom smoothly to a given location, it invokes
40 |  * CDasherModel.ScheduleZoom, which interpolates a number of points
41 |  * between the current crosshair location and the point clicked by
42 |  * the user, and jumps to these points on each successive frame.
43 |  * <p>
44 |  * This filter registers itself with the name <i>Click Mode</i>.
45 |  */
46 | 
47 | public class CClickFilter extends CStaticFilter {
48 | 
49 | 	private long minX;
50 | 	/**
51 | 	 * Sole constructor. Calls the CInputFilter constructor with a type of 7,
52 | 	 * an ID of 1, and the name <i>Click Mode</i>.
53 | 	 * 
54 | 	 * @param EventHandler Event handler.
55 | 	 * @param SettingsStore Settings repository.
56 | 	 * @param Interface Interface with which the filter should be registered.
57 | 	 */
58 | 	public CClickFilter(CDasherComponent creator, CDasherInterfaceBase iface) {
59 | 	  super(creator, iface, "Click Mode");
60 | 	  HandleEvent(Elp_parameters.LP_MAX_ZOOM);
61 | 	}
62 | 
63 | 	/**
64 | 	 * KeyDown is to be called by the Interface when the user
65 | 	 * presses a key or clicks the mouse. ClickFilter responds to:
66 | 	 * 
67 | 	 * <b>Left mouse button</b>: Schedules a zoom to the clicked location.
68 | 	 * 
69 | 	 * @param iTime Current system time as a UNIX timestamp.
70 | 	 * @param iId Key/button identifier.
71 | 	 * @param Model DasherModel which should be zoomed in response to clicks.
72 | 	 */
73 | 	@Override public void KeyDown(long iTime, int iId, CDasherView pView, CDasherInput pInput, CDasherModel Model) {
74 | 
75 | 	  switch(iId) {
76 | 	  case 100: // Mouse clicks
77 | 	    pInput.GetDasherCoords(pView,inputCoords);
78 | 	    scheduleZoom(Model, Math.max(minX, (inputCoords.x*(1024+GetLongParameter(Elp_parameters.LP_S)))/1024),inputCoords.y);
79 | 	    m_Interface.Redraw(false);
80 | 	    break;
81 | 	  }
82 | 	}
83 | 	private final MutablePoint inputCoords = new MutablePoint();  
84 | 
85 | 	@Override public void HandleEvent(EParameters eParam) {
86 | 		if (eParam==Elp_parameters.LP_MAX_ZOOM)
87 | 			minX = Math.max(2, CROSS_X/GetLongParameter(Elp_parameters.LP_MAX_ZOOM));
88 | 	}
89 | }
90 | 


--------------------------------------------------------------------------------
/src/dasher/applet/ScreenOverlay.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |   This file is part of JDasher.
  3 | 
  4 |   JDasher is free software; you can redistribute it and/or modify
  5 |   it under the terms of the GNU General Public License as published by
  6 |   the Free Software Foundation; either version 2 of the License, or
  7 |   (at your option) any later version.
  8 | 
  9 |   JDasher is distributed in the hope that it will be useful,
 10 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 |   GNU General Public License for more details.
 13 | 
 14 |   You should have received a copy of the GNU General Public License
 15 |   along with JDasher; if not, write to the Free Software
 16 |   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 17 | 
 18 |   Copyright (C) 2006      Christopher Smowton <cs448@cam.ac.uk>
 19 | 
 20 |   JDasher is a port derived from the Dasher project; for information on
 21 |   the project see www.dasher.org.uk; for information on JDasher itself
 22 |   and related projects see www.smowton.net/chris
 23 | 
 24 | */
 25 | 
 26 | package dasher.applet;
 27 | 
 28 | import javax.swing.JFrame;
 29 | import javax.swing.JProgressBar;
 30 | import javax.swing.JLabel;
 31 | import javax.swing.BoxLayout;
 32 | import javax.swing.JTextArea;
 33 | 
 34 | /**
 35 |  * Small JFrame containing a label and progress bar which is shown
 36 |  * by Dasher when training or otherwise Locked.
 37 |  * <p>
 38 |  * At present this doesn't fully work because the Frame's screen
 39 |  * is not redrawn whilst another event is in progress -- and most
 40 |  * time consuming work in Dasher takes place in response to menu
 41 |  * events.
 42 |  * <p>
 43 |  * This could potentially be fixed by using marking events triggered
 44 |  * by menu clicks as to be done by the redraw thread.
 45 |  */
 46 | public class ScreenOverlay extends JFrame {
 47 | 
 48 | 	/**
 49 | 	 * Our progress bar
 50 | 	 */
 51 | 	private JProgressBar m_ProgressBar;
 52 | 	
 53 | 	/**
 54 | 	 * Our label
 55 | 	 */
 56 | 	private JTextArea m_Label;
 57 | 	
 58 | 	/**
 59 | 	 * Creates the frame with a size of 200x100 and currently invisible.
 60 | 	 *
 61 | 	 */
 62 | 	public ScreenOverlay() {
 63 | 		
 64 | 		this.setLayout(new BoxLayout(this.getContentPane(), BoxLayout.Y_AXIS));
 65 | 		
 66 | 		m_Label = new JTextArea("JDasher");
 67 | 		m_Label.setLineWrap(true); m_Label.setWrapStyleWord(true);
 68 | 		m_Label.setEditable(false);
 69 | 		
 70 | 		m_ProgressBar = new JProgressBar();
 71 | 		
 72 | 		m_ProgressBar.setVisible(false);
 73 | 		
 74 | 		this.setSize(200, 100);
 75 | 		
 76 | 		this.add(m_Label);
 77 | 		this.add(m_ProgressBar);
 78 | 	}
 79 | 	
 80 | 	/**
 81 | 	 * Sets the text in the central label (not the titlebar)
 82 | 	 * 
 83 | 	 * @param newMessage Message to show the user
 84 | 	 */
 85 | 	public void setText(String newMessage) {
 86 | 		m_Label.setText(newMessage);
 87 | 	}
 88 | 	
 89 | 	public String getText() {
 90 | 		return m_Label.getText();
 91 | 	}
 92 | 	
 93 | 	public void setCenter(int x, int y) {
 94 | 		setLocation(x - getWidth()/2, y - getHeight()/2);
 95 | 	}
 96 | 	
 97 | 	/**
 98 | 	 * Sets the current progress
 99 | 	 * 
100 | 	 * @param done Amount done
101 | 	 * @param max Maximum amount
102 | 	 */	
103 | 	public void setProgress(int done, int max) {
104 | 		m_ProgressBar.setMaximum(max);
105 | 		m_ProgressBar.setValue(done);
106 | 	}
107 | 	
108 | 	/**
109 | 	 * Shows or hides the progress bar
110 | 	 * 
111 | 	 * @param visible Should the bar be visible?
112 | 	 */
113 | 	public void setProgressBarVisible(boolean visible) {
114 | 		m_ProgressBar.setVisible(visible);
115 | 	}
116 | 	
117 | }
118 | 


--------------------------------------------------------------------------------
/src/dasher/CCustomColours.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |   This file is part of JDasher.
  3 | 
  4 |   JDasher is free software; you can redistribute it and/or modify
  5 |   it under the terms of the GNU General Public License as published by
  6 |   the Free Software Foundation; either version 2 of the License, or
  7 |   (at your option) any later version.
  8 | 
  9 |   JDasher is distributed in the hope that it will be useful,
 10 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 |   GNU General Public License for more details.
 13 | 
 14 |   You should have received a copy of the GNU General Public License
 15 |   along with JDasher; if not, write to the Free Software
 16 |   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 17 | 
 18 |   Copyright (C) 2006      Christopher Smowton <cs448@cam.ac.uk>
 19 | 
 20 |   JDasher is a port derived from the Dasher project; for information on
 21 |   the project see www.dasher.org.uk; for information on JDasher itself
 22 |   and related projects see www.smowton.net/chris
 23 | 
 24 | */
 25 | 
 26 | package dasher;
 27 | 
 28 | import java.util.ArrayList;
 29 | 
 30 | /**
 31 |  * Represents a custom colour scheme, wrapping a ColourInfo object
 32 |  * and importing its contents into Collections suitable for random
 33 |  * access.
 34 |  * <p>
 35 |  * This also ensures that the ColourInfo object is read-only
 36 |  * when in use.
 37 |  */
 38 | public class CCustomColours {
 39 | 	
 40 | 	/**
 41 | 	 * Wrapped colour info object.
 42 | 	 */
 43 | 	protected CColourIO.ColourInfo m_ColourInfo;
 44 | 	
 45 | 	/**
 46 | 	 * Fast-access array of available colours' red values.
 47 | 	 */
 48 | 	protected ArrayList<Integer> m_Red = new ArrayList<Integer>();
 49 | 	
 50 | 	/**
 51 | 	 * Fast-access array of available colours' green values.
 52 | 	 */
 53 | 	protected ArrayList<Integer> m_Green = new ArrayList<Integer>();
 54 | 	
 55 | 	/**
 56 | 	 * Fast-access array of available colours' blue values.
 57 | 	 */
 58 | 	protected ArrayList<Integer> m_Blue = new ArrayList<Integer>();
 59 | 
 60 | 	/**
 61 | 	 * Sole constructor; copies the data from a given ColourInfo
 62 | 	 * object.
 63 | 	 * 
 64 | 	 * @param ColInfo ColourInfo object detailing the scheme we wish to represent.
 65 | 	 */
 66 | 	public CCustomColours(CColourIO.ColourInfo ColInfo) {
 67 | 		m_ColourInfo = ColInfo;
 68 | 		
 69 | 		// Add all the colours.
 70 | 		for(int i = 0; i < m_ColourInfo.Reds.size(); i++) {    // loop colours
 71 | 			m_Red.add(m_ColourInfo.Reds.get(i));
 72 | 			m_Green.add(m_ColourInfo.Greens.get(i));
 73 | 			m_Blue.add(m_ColourInfo.Blues.get(i));
 74 | 		}
 75 | 	}
 76 | 		
 77 | 	/**
 78 | 	 * Gets number of available colours.
 79 | 	 * 
 80 | 	 * @return Number of available colours.
 81 | 	 */
 82 | 	public int GetNumColours() {
 83 | 		return m_Red.size();
 84 | 	}
 85 | 	
 86 | 	/**
 87 | 	 * Gets the red value of a given colour.
 88 | 	 * 
 89 | 	 * @param colour Index of the colour to look up.
 90 | 	 * @return Red value, on a scale from 0 to 255.
 91 | 	 */
 92 | 	public int GetRed(int colour) {
 93 | 		return m_Red.get(colour);
 94 | 	}
 95 | 	
 96 | 	/**
 97 | 	 * Gets the green value of a given colour.
 98 | 	 * 
 99 | 	 * @param colour Index of the colour to look up.
100 | 	 * @return green value, on a scale from 0 to 255.
101 | 	 */
102 | 	public int GetGreen(int colour) {
103 | 		return m_Green.get(colour);
104 | 	}
105 | 	
106 | 	/**
107 | 	 * Gets the blue value of a given colour.
108 | 	 * 
109 | 	 * @param colour Index of the colour to look up.
110 | 	 * @return blue value, on a scale from 0 to 255.
111 | 	 */
112 | 	public int GetBlue(int colour) {
113 | 		return m_Blue.get(colour);
114 | 	}
115 | }
116 | 


--------------------------------------------------------------------------------
/src/dasher/COneDimensionalFilter.java:
--------------------------------------------------------------------------------
 1 | package dasher;
 2 | 
 3 | import static dasher.CDasherModel.*;
 4 | import dasher.CDasherView.MutablePoint;
 5 | 
 6 | /** Overrides ApplyTransform to apply 1D remapping (using old x coord as radius)
 7 |  * if and only if {@link Ebp_parameters#BP_ONE_DIMENSIONAL_MODE} is enabled.
 8 |  * @author Alan Lawrence <acl33@inf.phy.cam.ac.uk>
 9 |  */
10 | public class COneDimensionalFilter extends CDefaultFilter {
11 | 
12 | 	public COneDimensionalFilter(CDasherComponent creator, CDasherInterfaceBase iface, String szName) {
13 | 		super(creator, iface, szName);
14 | 	}
15 | 
16 | 	/**
17 | 	 * If {@link Ebp_parameters#BP_ONE_DIMENSIONAL_MODE} is set, calls {@link #Apply1DTransform}
18 | 	 * (and then skips superclass method); otherwise, falls back to superclass.
19 | 	 */
20 | 	@Override public void ApplyTransform(CDasherView pView, MutablePoint coords) {
21 | 		if (GetBoolParameter(Ebp_parameters.BP_ONE_DIMENSIONAL_MODE))
22 | 			Apply1DTransform(pView, coords);
23 | 		else
24 | 			super.ApplyTransform(pView, coords);
25 | 	}
26 | 	
27 | 	private final int forwardmax=(int)(MAX_Y/2.5); //of 1D transform
28 | 	
29 | 	/**
30 | 	 * Applies the 1D remapping: as Y increases from 0 to LP_MAX_Y, starts & ends at the origin,
31 | 	 * then moves in two semicircles round the back, joined by a larger semicircle allowing forwards motion.
32 | 	 * X co-ordinate is used as radius: X=0 => full radius, X=(max visible x) => 0-radius. This is calculated
33 | 	 * using dasher co-ords (inc. logarithmic compression left of crosshair), so the input x has to be quite
34 | 	 * far to the left (=high) to reduce the radius significantly.
35 | 	 * @param pView
36 | 	 * @param coords
37 | 	 */
38 | 	protected void Apply1DTransform(CDasherView pView, MutablePoint coords) {
39 | 		// The distance between the Y coordinate and the centreline in pixels
40 | 		final long disty=CROSS_Y-coords.y;
41 | 		  
42 | 		final long circlesize = (long)(forwardmax*(1.0-coords.x/(double)pView.VisibleRegion().maxX));
43 | 		final long yforwardrange = (MAX_Y*5)/16;
44 | 		final long yfullrange = MAX_Y/2;
45 | 		  
46 | 		double x,y; //0,0=on crosshair; positive=forwards/up...	
47 | 		
48 | 		if (disty<=yforwardrange && disty>=-yforwardrange) {
49 | 			//go forwards!
50 | 			final double angle=((disty*3.14159/2)/(double)yforwardrange);
51 | 			x=Math.cos(angle);
52 | 			y=-Math.sin(angle);
53 | 		} else if (disty<=yfullrange && disty>=-yfullrange) {
54 | 			final long ybackrange = yfullrange-yforwardrange;
55 | 			final long ellipse_eccentricity=6;
56 | 			//backwards, off bottom or top...
57 | 			final double yb = (Math.abs(disty)-yforwardrange)/(double)ybackrange;
58 | 			final double angle=(yb*3.14159)*(yb+(1-yb)*(ybackrange/(double)yforwardrange/ellipse_eccentricity));
59 | 		    
60 | 		    x=-Math.sin(angle)*ellipse_eccentricity/2.0;
61 | 		    y=(1.0+Math.cos(angle))/2.0;
62 | 		    if (disty>yforwardrange) y=-y; //backwards off top
63 | 		} else {
64 | 			//off limits, go nowhere
65 | 			x=0; y=0;
66 | 		} 
67 | 		coords.x = CROSS_X-(long)(x*circlesize);
68 | 		coords.y = CROSS_Y+(long)(y*circlesize);
69 | 	}
70 | 	
71 | 	@Override protected void CreateStartHandler() {
72 | 		if (GetBoolParameter(Ebp_parameters.BP_CIRCLE_START)) {
73 | 			m_StartHandler= new CCircleStartHandler(this) {
74 | 				private CDasherView.Point fwdCircle;
75 | 				@Override protected CDasherView.Point getScreenCenter(CDasherView pView) {
76 | 					if (filter.isPaused()
77 | 							&& GetBoolParameter(Ebp_parameters.BP_ONE_DIMENSIONAL_MODE)) {
78 | 						//move circle
79 | 						if (fwdCircle==null) {
80 | 							long rad = GetLongParameter(Elp_parameters.LP_CIRCLE_PERCENT)*CROSS_Y/100;
81 | 							fwdCircle = pView.Dasher2Screen(CROSS_X-forwardmax+rad, CROSS_Y);
82 | 							
83 | 						}
84 | 						return fwdCircle;
85 | 					}
86 | 					return super.getScreenCenter(pView);
87 | 				}
88 | 			};
89 | 		} else
90 | 			super.CreateStartHandler();
91 | 	}
92 | 	
93 | }
94 | 


--------------------------------------------------------------------------------
/src/dasher/Ebp_parameters.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |   This file is part of JDasher.
 3 | 
 4 |   JDasher is free software; you can redistribute it and/or modify
 5 |   it under the terms of the GNU General Public License as published by
 6 |   the Free Software Foundation; either version 2 of the License, or
 7 |   (at your option) any later version.
 8 | 
 9 |   JDasher is distributed in the hope that it will be useful,
10 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |   GNU General Public License for more details.
13 | 
14 |   You should have received a copy of the GNU General Public License
15 |   along with JDasher; if not, write to the Free Software
16 |   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17 | 
18 |   Copyright (C) 2006      Christopher Smowton <cs448@cam.ac.uk>
19 | 
20 |   JDasher is a port derived from the Dasher project; for information on
21 |   the project see www.dasher.org.uk; for information on JDasher itself
22 |   and related projects see www.smowton.net/chris
23 | 
24 | */
25 | 
26 | package dasher;
27 | 
28 | /**
29 |  * Enumeration of possible boolean parameter references. See
30 |  * CParamTables for a list and definitions.
31 |  */
32 | public enum Ebp_parameters implements EParameters {
33 | 			  BP_REMAP_XTREME("RemapXtreme", false, "Remap y & limit x at top/bottom extremes"),
34 | 			  BP_DRAW_MOUSE_LINE("DrawMouseLine", true, "Draw Mouse Line"),
35 | 			  BP_DRAW_MOUSE("DrawMouse", true, "Draw Mouse Position"),
36 | 			  BP_SHOW_SLIDER("ShowSpeedSlider", true, "ShowSpeedSlider"),
37 | 			  BP_START_MOUSE("StartOnLeft", true, "StartOnLeft"),
38 | 			  BP_START_SPACE("StartOnSpace", false, "StartOnSpace"),
39 | 			  BP_STOP_IDLE("StopOnIdle", false, "StopOnIdle"),
40 | 			  BP_KEY_CONTROL("KeyControl", false, "KeyControl"),
41 | 			  BP_CONTROL_MODE("ControlMode", false, "ControlMode"),
42 | 			  BP_COLOUR_MODE("ColourMode", true, "ColourMode"),
43 | 			  BP_MOUSEPOS_MODE("StartOnMousePosition", false, "StartOnMousePosition"),
44 | 			  BP_OUTLINE_MODE("OutlineBoxes", true, "OutlineBoxes"),
45 | 			  BP_AUTOCALIBRATE("AutoAdjust", false, "Auto-adjust offset for eyetracker miscalibration"),
46 | 			  BP_LM_DICTIONARY("Dictionary", true, "Whether the word-based language model uses a dictionary"),
47 | 			  BP_AUTO_SPEEDCONTROL("AutoSpeedControl", true, "AutoSpeedControl"),
48 | 			  BP_LM_ADAPTIVE("LMAdaptive", true, "Whether language model should learn as you enter text"),
49 | 			  BP_CIRCLE_START("CircleStart", false, "Start on circle mode"),
50 | 			  BP_LM_REMOTE("RemoteLM", false, "Language model is remote and responds asynchronously."),
51 | 			  BP_ONE_DIMENSIONAL_MODE("OneDimensionalMode", false, "Remap x/y to radius / curve all around origin"),
52 | 			  BP_ONE_BUTTON_RELEASE_TIME("OneButtonReleaseTime", false, "Use length of single push, not gap, for 1B-dynamic mode"),
53 | 			  BP_CONTROL_MODE_REBUILD("ControlModeRebuild",true,"Replace control nodes that have happened with characters to left of cursor"),
54 | 			  BP_CONTROL_MODE_HAS_MOVE("ControlModeHasMove",true,"Include nodes to move cursor"),
55 | 			  BP_MOVE_REBUILD_IMMED("ControlMoveRebuildImmed",false,"Rebuild move nodes immediately rather than on commit"),
56 | 			  BP_CONTROL_MODE_ALPH_SWITCH("ControlModeHasAlphSwitch",true,"Include nodes to switch to previous four alphabets"),
57 | 			  BP_CONTROL_MODE_HAS_SPEED("ControlModeHasSpeed",true,"Include nodes to change speed up/down")
58 | 			  ;
59 | 
60 | 
61 | 			  private Ebp_parameters(String rName, boolean def, String hr) {
62 | 				humanReadable = hr;
63 | 				defaultVal = def;
64 | 				regName = rName;
65 | 				BY_NAME.put(regName,this);
66 | 			}
67 | 
68 | 			public int key() {return ordinal();}
69 | 			public String regName() {return regName;}
70 | 			public void reset(CSettingsStore ss) {ss.SetBoolParameter(this, defaultVal);}
71 | 			private final  String regName;
72 | 			final boolean defaultVal;
73 | 			final String humanReadable;
74 | }


--------------------------------------------------------------------------------
/src/dasher/CStylusFilter.java:
--------------------------------------------------------------------------------
 1 | package dasher;
 2 | 
 3 | import static dasher.CDasherModel.CROSS_X;
 4 | import dasher.CDasherView.MutablePoint;
 5 | 
 6 | /**
 7 |  *
 8 |  * @author acl33
 9 |  */
10 | public class CStylusFilter extends CDefaultFilter {
11 |     private long m_iKeyDownTime;
12 |     private long minX;
13 |     private CDasherModel model; //model with which any zoom was scheduled
14 |     
15 |     public CStylusFilter(CDasherComponent creator, CDasherInterfaceBase iface) {
16 |         this(creator, iface, "Stylus Control");
17 |     }
18 | 
19 |     protected CStylusFilter(CDasherComponent creator, CDasherInterfaceBase iface, String sName) {
20 |         super(creator, iface, sName);
21 |         HandleEvent(Elp_parameters.LP_MAX_ZOOM);
22 |     }
23 |     
24 |     @Override
25 |     public void KeyDown(long iTime, int keyId, CDasherView pView, CDasherInput pInput, CDasherModel model) {
26 |         if (keyId == 100) {
27 |             model.clearScheduledSteps();
28 |             unpause(iTime);
29 |             m_iKeyDownTime = iTime;
30 |         }
31 |     }
32 | 
33 |     @Override
34 |     public void KeyUp(long iTime, int keyId, CDasherView pView, CDasherInput pInput, CDasherModel model) {
35 |         if(keyId == 100) {
36 |         	pause(); //stops continuous motion...
37 |             if ((iTime - m_iKeyDownTime < GetLongParameter(Elp_parameters.LP_TAP_TIME))) {
38 |             	pInput.GetDasherCoords(pView, lastInputCoords);
39 |     			ApplyClickTransform(pView, lastInputCoords);
40 |     			(this.model=model).ScheduleZoom(Math.max(minX,lastInputCoords.x),lastInputCoords.y);
41 |     			m_Interface.Redraw(false);
42 |     			//...as we've scheduled quite a few frames, instead
43 |             }
44 |         }
45 |     }
46 |     
47 |     @Override
48 |     public void Timer(long iTime, CDasherView view, CDasherInput pInput, CDasherModel model) {
49 |     	if (model.ScheduledSteps()==0) //zoom cleared by KeyDown
50 |     		super.Timer(iTime, view, pInput, model);
51 |     	//else, continue zoom previously scheduled - must have been in middle
52 |         // (and no click since)
53 |         
54 |     	//note that this skips the rest of CDefaultFilter::Timer;
55 |         //however, given we're paused, this is only the Start Handler,
56 |         //which we're not using anyway.
57 |     }
58 |     
59 |     /** Whilst we do kinda support pause, if you can start the filter, you can also
60 |      * stop it (Users who cannot remove finger from screen/mouse-pointer, can use
61 |      * {@link CDefaultFilter} with a Start Handler).
62 |      * @return false
63 |      */
64 |     @Override public boolean supportsPause() {return false;}
65 |     
66 |     @Override public void pause() {
67 |     	if (model!=null) model.clearScheduledSteps();
68 |     	super.pause();
69 |     }
70 |     
71 |     /**
72 |      * Called to apply any coordinate transform required for
73 |      * <em>click</em> coords (i.e. for a scheduled zoom, rather
74 |      * than continuous movement towards.)
75 |      * <p>The default is to multiply the x coordinate to incorporate the {@link Elp_parameters#LP_S}
76 |      * safety margin, but <em>not</em> to call {@link #ApplyTransform(CDasherView, long[])};
77 |      * subclasses may override to provide different behaviour.
78 |      * @param dasherCoords x&amp;y dasher coordinates which will be target of zoom.
79 |      */
80 |     protected void ApplyClickTransform(CDasherView pView, MutablePoint dasherCoords) {
81 |     	dasherCoords.x = (dasherCoords.x*(1024+GetLongParameter(Elp_parameters.LP_S))/1024);
82 |     }
83 |     
84 |     @Override public void HandleEvent(EParameters eParam) {
85 | 		if (eParam==Elp_parameters.LP_MAX_ZOOM)
86 | 			minX = Math.max(2, CROSS_X/GetLongParameter(Elp_parameters.LP_MAX_ZOOM));
87 | 		super.HandleEvent(eParam);
88 | 	}
89 |     
90 |     /** Make sure no start handler is created - even tho we ignore changes 
91 |      * to BP_CIRCLE_START and BP_MOUSEPOS_MODE, this still gets called by
92 |      * the superclass constructor (if a preference enabling a start handler
93 |      * was saved by a previous session)
94 |      */
95 |     @Override public void CreateStartHandler() {
96 |     	
97 |     }
98 | }


--------------------------------------------------------------------------------
/src/dasher/CDasherButtons.java:
--------------------------------------------------------------------------------
  1 | package dasher;
  2 | 
  3 | import dasher.CDasherView.MutablePoint;
  4 | 
  5 | public abstract class CDasherButtons extends CStaticFilter {
  6 | 	protected int m_iActiveBox;
  7 | 	protected SBox m_pBoxes[];
  8 | 	protected boolean m_bDecorationChanged;
  9 | 	
 10 | 	//protected void ChangeBoxes() {m_pBoxes = SetupBoxes(); m_bDecorationChanged=true;}
 11 | 	
 12 | 	public CDasherButtons(CDasherComponent creator, CDasherInterfaceBase iface, String szName) {
 13 | 		super(creator, iface, szName);
 14 | 		m_pBoxes = SetupBoxes();
 15 | 	}
 16 | 	
 17 | 	protected static class SBox {
 18 | 		/**target of zoom*/
 19 | 		final int iX,iY;
 20 | 		/**location of top/bottom on screen*/
 21 | 		final int iDisplayTop, iDisplayBottom;
 22 | 		SBox(int iTop, int iBottom, int iDisplayTop, int iDisplayBottom) {
 23 | 			if (iTop>=iBottom || iDisplayTop>=iDisplayBottom) throw new IllegalArgumentException();
 24 | 			iY = (iTop+iBottom)/2;
 25 | 			iX = (iBottom-iTop)/2;
 26 | 			this.iDisplayTop=iDisplayTop;
 27 | 			this.iDisplayBottom=iDisplayBottom;
 28 | 		}
 29 | 		SBox(int iDisplayTop, int iDisplayBottom, int safety) {
 30 | 			this(iDisplayTop-safety, iDisplayBottom+safety, iDisplayTop, iDisplayBottom);
 31 | 		}
 32 | 		public String toString() {
 33 | 			return "{"+iDisplayTop+" - "+iDisplayBottom+" => " +iX+","+iY+"}";
 34 | 		}
 35 | 	}
 36 | 
 37 | 	@Override public void Activate() {
 38 | 		if (m_pBoxes==null) m_pBoxes = SetupBoxes();
 39 | 	}
 40 | 	
 41 | 	protected abstract SBox[] SetupBoxes();
 42 | 
 43 | 	private final MutablePoint mouseCoords = new MutablePoint();
 44 | 	private long m_iLastTime;
 45 | 	
 46 | 	@Override public void KeyDown(long iTime, int iId, CDasherView pView, CDasherInput pInput, CDasherModel pModel) {
 47 | 		if (iId == 100) {
 48 | 			//Mouse!
 49 | 			m_iActiveBox=-1;
 50 | 			pInput.GetDasherCoords(pView, mouseCoords);
 51 | 			for (int i = 0; i < m_pBoxes.length; i++) {
 52 | 				if (isInBox(mouseCoords.x,mouseCoords.y,m_pBoxes[i])) {
 53 | 					m_iActiveBox=i;
 54 | 					break;
 55 | 				}
 56 | 			}
 57 | 			if (m_iActiveBox==-1) return; //not in any box
 58 | 		} else if(iId == 1)
 59 | 			m_iActiveBox = m_pBoxes.length - 1; //last box = zoom out
 60 | 		else if(iId <= m_pBoxes.length) 
 61 | 			m_iActiveBox = iId-2;
 62 | 		else
 63 | 			m_iActiveBox = m_pBoxes.length-2;
 64 | 		scheduleZoom(pModel, m_pBoxes[m_iActiveBox].iX, m_pBoxes[m_iActiveBox].iY);
 65 | 		m_iLastTime = iTime;
 66 | 		m_bDecorationChanged = true; //we set m_iActiveBox and m_iLastTime, so it'll be highlighted for awhile
 67 | 	}
 68 | 	
 69 | 	protected boolean isInBox(long iDasherX, long iDasherY, SBox box) {
 70 | 		return iDasherY <= box.iDisplayBottom &&
 71 | 				iDasherY >= box.iDisplayTop &&
 72 | 				iDasherX <= box.iDisplayBottom - box.iDisplayTop;
 73 | 				//(iDasherX < box.iDisplayBottom - box.iDisplayTop || box == m_pBoxes[m_pBoxes.length-1]);
 74 | 	}
 75 | 
 76 | 	@Override public void Timer(long Time, CDasherView m_pDasherView, CDasherInput pInput, CDasherModel pModel) {
 77 | 		if ((Time - m_iLastTime) > 200) {
 78 | 			//end any highlight
 79 | 			if (m_iActiveBox!=-1) m_bDecorationChanged = true;
 80 | 			m_iActiveBox = -1;
 81 | 		}
 82 | 	}
 83 | 
 84 | 	@Override public boolean DecorateView(CDasherView pView, CDasherInput pInput) {
 85 | 		for(int i = 0; i < m_pBoxes.length; ++i) {
 86 | 			if(i != m_iActiveBox)
 87 | 				DrawBox(pView, m_pBoxes[i], false);
 88 | 		}
 89 | 		if (m_iActiveBox!=-1) DrawBox(pView, m_pBoxes[m_iActiveBox],true);
 90 | 
 91 | 		boolean bRV = m_bDecorationChanged;
 92 | 		m_bDecorationChanged = false;
 93 | 		return bRV;
 94 | 	}
 95 | 	
 96 | 	protected void DrawBox(CDasherView pView, SBox box, boolean bActive) {
 97 | 	
 98 | 		final long iMaxX = //(box.iDisplayBottom <= pView.VisibleRegion().minY && box.iDisplayTop <= pView.VisibleRegion().maxY) ? pView.VisibleRegion().maxX :
 99 | 			box.iDisplayBottom - box.iDisplayTop;
100 | 
101 | 		int iColour;
102 | 		int iWidth;
103 | 
104 | 		if(bActive) {
105 | 			iColour = 1;
106 | 			iWidth = 3;
107 | 		} else {
108 | 			iColour = 2;
109 | 			iWidth = 1;
110 | 		}
111 | 
112 | 		pView.DasherDrawRectangle(iMaxX, box.iDisplayTop, 0, box.iDisplayBottom, -1, iColour, iWidth);
113 |    }
114 | 
115 | }


--------------------------------------------------------------------------------
/src/dasher/android/InputTypes.java:
--------------------------------------------------------------------------------
 1 | package dasher.android;
 2 | 
 3 | import java.lang.reflect.Field;
 4 | 
 5 | import android.text.InputType;
 6 | import android.view.inputmethod.EditorInfo;
 7 | 
 8 | /** Utility class for interpreting the inputType field of an EditorInfo */
 9 | public class InputTypes {
10 | 	/** The class names are the fields TYPE_CLASS_XYZ of
11 | 	 * android.text,InputType; among thosefields, this routine
12 | 	 * identifies that with the value corresponding to the inputType
13 | 	 * parameter (masked with TYPE_MASK_CLASS) 
14 | 	 * @param inputType value of field of same name of EditorInfo
15 | 	 * @return the XYZ part of the name of the identified field
16 | 	 * @throws IllegalArgumentException if no appropriately-named field
17 | 	 * with the correct value could be found.
18 | 	 */
19 | 	public static String getClassName(EditorInfo info) {
20 | 		if (info.inputType==InputType.TYPE_NULL) return "NULL"; //inputType==0 is a common case...
21 | 		int i = info.inputType & InputType.TYPE_MASK_CLASS;
22 | 		for (Field f : InputType.class.getFields())
23 | 			try {
24 | 				if (f.getName().startsWith("TYPE_CLASS_")
25 | 						&& f.getInt(null)==i)
26 | 					return f.getName().substring("TYPE_CLASS_".length());
27 | 			} catch (IllegalAccessException e) {
28 | 				//Shouldn't happen, but hope some other field matches!
29 | 				android.util.Log.d("DasherIME","Couldn't read field "+f.getName()+", skipping...", e);
30 | 			}
31 | 		throw new IllegalArgumentException("InputType class "+info.inputType+" not found");
32 | 	}
33 | 	
34 | 	/**
35 | 	 * The variations of classname ABC (see {@link #getClassName(int)} 
36 | 	 * are stored in the fields TYPE_ABC_VARIATION_XYZ of android.text.InputType;
37 | 	 * this routine identifies the field with value corresponding to the
38 | 	 * inputType parameter (masked with TYPE_MASK_VARIATION)
39 | 	 * @param inputType the value of the inputType field of the EditorInfo object
40 | 	 * (both classname and variation parts are used)
41 | 	 * @return the XYZ part of the name of the identified field
42 | 	 * @throws IllegalArgumentException if no appropriately-named field
43 | 	 * with the correct value could be found, or similarly, if the
44 | 	 * classname of the provided inputType could not be identified.
45 | 	 */
46 | 	public static String getVariationName(EditorInfo info) {
47 | 		if (info.inputType == InputType.TYPE_NULL) return "NULL";
48 | 		String s = getDesc(info);
49 | 		return s.substring(s.indexOf(".")+1);
50 | 	}
51 | 	
52 | 	public static String getDesc(EditorInfo info) {
53 | 		String className = getClassName(info);
54 | 		String varPrefix = "TYPE_"+className+"_VARIATION_";
55 | 		if (info.inputType==InputType.TYPE_NULL) return "NULL";
56 | 		int i = info.inputType & InputType.TYPE_MASK_VARIATION;
57 | 		for (Field f : InputType.class.getFields())
58 | 			try {
59 | 				if (f.getName().startsWith(varPrefix)
60 | 						&& f.getInt(null)==i)
61 | 					return className+"."+f.getName().substring(varPrefix.length());
62 | 			} catch (IllegalAccessException e) {
63 | 				//Shouldn't happen, but hope some other field matches!
64 | 				android.util.Log.d("DasherIME","Couldn't read field "+f.getName()+", skipping...", e);
65 | 			}
66 | 		return className+".NORMAL";
67 | 	}
68 | 
69 | 	/** Determines whether the specified inputType indicates a hidden
70 | 	 * (password) field. Checks against known values (at present only
71 | 	 * TYPE_CLASS_TEXT | TYPE_TEXT_VARIATION_PASSWORD, as only these are
72 | 	 * present in earlier versions of Android - we could hardcode in others,
73 | 	 * but then would no longer compile for Android 1.6), and then also
74 | 	 * looks for any variation of any class whose name (obtained by
75 | 	 * {@link #getVariationName(int)}) contains the string "PASSWORD".
76 | 	 * @param inputType value of the inputType field of the EditorInfo object
77 | 	 * @return true if this indicates a password.
78 | 	 */
79 | 	public static boolean isPassword(EditorInfo info) {
80 | 		final int inputType = info.inputType;
81 | 		if ((inputType & InputType.TYPE_MASK_CLASS) == InputType.TYPE_CLASS_TEXT
82 | 				&& (inputType & InputType.TYPE_MASK_VARIATION) == InputType.TYPE_TEXT_VARIATION_PASSWORD)
83 | 			return true;
84 | 		return getVariationName(info).contains("PASSWORD");
85 | 	}
86 | }
87 | 


--------------------------------------------------------------------------------
/src/dasher/CDasherInput.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |   This file is part of JDasher.
  3 | 
  4 |   JDasher is free software; you can redistribute it and/or modify
  5 |   it under the terms of the GNU General Public License as published by
  6 |   the Free Software Foundation; either version 2 of the License, or
  7 |   (at your option) any later version.
  8 | 
  9 |   JDasher is distributed in the hope that it will be useful,
 10 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 |   GNU General Public License for more details.
 13 | 
 14 |   You should have received a copy of the GNU General Public License
 15 |   along with JDasher; if not, write to the Free Software
 16 |   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 17 | 
 18 |   Copyright (C) 2006      Christopher Smowton <cs448@cam.ac.uk>
 19 | 
 20 |   JDasher is a port derived from the Dasher project; for information on
 21 |   the project see www.dasher.org.uk; for information on JDasher itself
 22 |   and related projects see www.smowton.net/chris
 23 | 
 24 | */
 25 | 
 26 | package dasher;
 27 | 
 28 | import dasher.CDasherView.MutablePoint;
 29 | 
 30 | /**
 31 |  * DasherInput is the base class for all modules which provide
 32 |  * some sort of co-ordinate input.
 33 |  * <p>
 34 |  * To serve as a co-ordinate source, a device must be able to
 35 |  * provide synchronous or quasi-synchronous readout of its
 36 |  * current co-ordinates, such that a call to GetCoordinates
 37 |  * will return almost instantaneously.
 38 |  * <p>
 39 |  * Devices are free to return their co-ordinates relative
 40 |  * to the screen, using pixels as their unit of measure, or
 41 |  * relative to the Dasher world, using Dasher co-ordinates.
 42 |  * 
 43 |  * @see CDasherModule
 44 |  */
 45 | abstract public class CDasherInput implements CDasherModule {
 46 | 	
 47 | 	private final String m_szName;
 48 | 	
 49 | 	public CDasherInput(String szName) {
 50 | 		this.m_szName = szName;
 51 | 	}
 52 | 	
 53 | 	public String getName() {return m_szName;}
 54 | 	
 55 | 	/**
 56 | 	 * Gets the current position of the input in Dasher coordinates.
 57 | 	 * Default implementation is to call {@link #GetScreenCoords(CDasherView, MutablePoint)}, and then
 58 | 	 * transform the coordinates using {@link CDasherView#Screen2Dasher(MutablePoint)}; subclasses <em>must</em>
 59 | 	 * override at least one of this and {@link #GetScreenCoords(CDasherView, MutablePoint)}.
 60 | 	 * @param pView View which may be used for coordinate transforms
 61 | 	 * @param coords 2-element array into which to write coordinates
 62 | 	 * (for 1-dimensional inputs, suggest fixing x=0).
 63 | 	 * @return true iff coordinates were available 
 64 | 	 */
 65 | 	public boolean GetDasherCoords(CDasherView pView, MutablePoint coords) {
 66 | 		if (!GetScreenCoords(pView, coords)) return false;
 67 | 		pView.Screen2Dasher(coords);
 68 | 		return true;
 69 | 	}
 70 | 	
 71 | 	/**
 72 | 	 * Gets the current position of the input in screen coordinates.
 73 | 	 * Default implementation is to call {@link #GetDasherCoords(CDasherView, MutablePoint)}, and then
 74 | 	 * transform the coordinates using {@link CDasherView#Dasher2Screen(MutablePoint)}; subclasses <em>must</em>
 75 | 	 * override at least one of this and {@link #GetDasherCoords(CDasherView, MutablePoint)}.
 76 | 	 * @param pView View which may be used for coordinate transforms
 77 | 	 * @param coords 2-element array into which to write coordinates
 78 | 	 * (for 1-dimensional inputs, suggest fixing x=0).
 79 | 	 * @return true iff coordinates were available 
 80 | 	 */
 81 | 	public boolean GetScreenCoords(CDasherView pView, MutablePoint coords) {
 82 | 		if (!GetDasherCoords(pView, coords)) return false;
 83 | 		pView.Dasher2Screen(coords);
 84 | 		return true;
 85 | 	}
 86 | 	
 87 | 	/**
 88 | 	 * Activates the input device. If threads must be started
 89 | 	 * to support the device, this is the place to do it.
 90 | 	 */
 91 | 	public void Activate() {};
 92 | 	
 93 | 	/**
 94 | 	 * Deactivates the device; resources should be freed at this point.
 95 | 	 *
 96 | 	 */
 97 | 	public void Deactivate() {};
 98 | 	
 99 | }
100 | 


--------------------------------------------------------------------------------
/src/dasher/CDelayedDraw.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |   This file is part of JDasher.
  3 | 
  4 |   JDasher is free software; you can redistribute it and/or modify
  5 |   it under the terms of the GNU General Public License as published by
  6 |   the Free Software Foundation; either version 2 of the License, or
  7 |   (at your option) any later version.
  8 | 
  9 |   JDasher is distributed in the hope that it will be useful,
 10 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 |   GNU General Public License for more details.
 13 | 
 14 |   You should have received a copy of the GNU General Public License
 15 |   along with JDasher; if not, write to the Free Software
 16 |   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 17 | 
 18 |   Copyright (C) 2006      Christopher Smowton <cs448@cam.ac.uk>
 19 | 
 20 |   JDasher is a port derived from the Dasher project; for information on
 21 |   the project see www.dasher.org.uk; for information on JDasher itself
 22 |   and related projects see www.smowton.net/chris
 23 | 
 24 | */
 25 | 
 26 | package dasher;
 27 | 
 28 | import java.util.ArrayList;
 29 | 
 30 | /**
 31 |  * Simple class permitting the delayed drawing of Strings when
 32 |  * drawing the DasherNodes to the screen.
 33 |  * <p>
 34 |  * The idea is that we can both<br>
 35 |  * a) Cause all text to appear above other drawn objects, and
 36 |  * b) Draw text at the same time as its Node, allowing the
 37 |  * drawing process to remain modular.
 38 |  * <p>
 39 |  * Essentially, all strings which are drawn with this class are
 40 |  * added to a list, which is emptied and drawn when Draw is called.
 41 |  */
 42 | public class CDelayedDraw {
 43 | 
 44 | 	/**
 45 | 	 * Queues up a piece of text for drawing. 
 46 | 	 * 
 47 | 	 * @param str String to draw
 48 | 	 * @param x1 x co-ordinate of top-left corner of the string's bounding box
 49 | 	 * @param y1 y co-ordinate of top-left corner of the string's bounding box
 50 | 	 * @param Size Font size to use
 51 | 	 */
 52 | 	public void DelayDrawText(String str, int x1, int y1, int Size) {
 53 | 		CTextString obj;
 54 | 		if (nextFree<allTextStrings.size())
 55 | 			obj = allTextStrings.get(nextFree);
 56 | 		else
 57 | 			allTextStrings.add(obj = new CTextString());
 58 | 		nextFree++;
 59 | 		obj.init(str, x1, y1, Size);
 60 | 	}
 61 | 	
 62 | 	/**
 63 | 	 * Draws all queued up text to a given screen, and clears the queue.
 64 | 	 *  
 65 | 	 * @param screen Screen to which we should draw
 66 | 	 */
 67 | 	public void Draw(CDasherScreen screen) {
 68 | 		for(int i = 0; i < nextFree; i++) {
 69 | 			CTextString draw = allTextStrings.get(i);
 70 | 			screen.DrawString(draw.m_String, draw.m_x, draw.m_y, draw.m_iSize);
 71 | 		}
 72 | 		//put all objects into pool for reuse in later frames
 73 | 		nextFree = 0;
 74 | 	}
 75 | 			
 76 | 	/**
 77 | 	 * Internal list of both those we are waiting to draw, and unused objects (free list)
 78 | 	 */
 79 | 	protected final ArrayList<CTextString> allTextStrings = new ArrayList<CTextString>();
 80 | 	
 81 | 	/** Next index of an unused object (all up to this index, exclusive, are
 82 | 	 * to be drawn; from this index onwards, are free) */
 83 | 	private int nextFree;
 84 | 	
 85 | 	/**
 86 | 	 * Class representing a String to be drawn plus information
 87 | 	 * needed to draw it
 88 | 	 */
 89 | 	private static class CTextString {
 90 | 		
 91 | 		/**
 92 | 		 * Default constructor
 93 | 		 * 
 94 | 		 * @param str String to draw
 95 | 		 * @param x x co-ordinate of top-left corner of the string's bounding box
 96 | 		 * @param y y co-ordinate of top-left corner of the string's bounding box
 97 | 		 * @param iSize font size
 98 | 		 */
 99 | 		CTextString() {
100 | 		}
101 | 		void init(String str, int x, int y, int iSize) {
102 | 			m_String = str;
103 | 			m_x = x;
104 | 			m_y = y;
105 | 			m_iSize = iSize;
106 | 						
107 | 		} 
108 | 		/**
109 | 		 * String to be drawn
110 | 		 */
111 | 		String m_String;
112 | 		/**
113 | 		 * x co-ordinate of top-left corner of the string's bounding box
114 | 		 */
115 | 		int m_x;
116 | 		/**
117 | 		 * y co-ordinate of top-left corner of the string's bounding box
118 | 		 */
119 | 		int m_y;
120 | 		/**
121 | 		 * Font size
122 | 		 */
123 | 		int m_iSize;
124 | 	}
125 | 		
126 | }
127 | 


--------------------------------------------------------------------------------
/assets/alphabet.swedish.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0"?>
  2 | <!DOCTYPE alphabets SYSTEM "alphabet.dtd">
  3 | <?xml-stylesheet type="text/xsl" href="alphabet.xsl"?>
  4 | <alphabets>
  5 | <alphabet name="Svenska / Swedish with punctuation and numerals">
  6 | <orientation type="LR"/>
  7 | <encoding type="Western"/>
  8 | <palette>Default</palette>
  9 | <train>training_swedish_SE.txt</train>
 10 | <space d="&#x25a1;" t=" " b="9" />
 11 | <paragraph d="&#182;" b="9"/>
 12 | <control d="Control" t="" b="8"/>
 13 | <group name="lower case letters" b="0">
 14 | <s d="&#x0061;" t="&#x0061;" />
 15 | <s d="&#x00E0;" t="&#x00E0;" />
 16 | <s d="&#x0062;" t="&#x0062;" />
 17 | <s d="&#x0063;" t="&#x0063;" />
 18 | <s d="&#x0064;" t="&#x0064;" />
 19 | <s d="&#x0065;" t="&#x0065;" />
 20 | <s d="&#x00E9;" t="&#x00E9;" />
 21 | <s d="&#x0066;" t="&#x0066;" />
 22 | <s d="&#x0067;" t="&#x0067;" />
 23 | <s d="&#x0068;" t="&#x0068;" />
 24 | <s d="&#x0069;" t="&#x0069;" />
 25 | <s d="&#x006A;" t="&#x006A;" />
 26 | <s d="&#x006B;" t="&#x006B;" />
 27 | <s d="&#x006C;" t="&#x006C;" />
 28 | <s d="&#x006D;" t="&#x006D;" />
 29 | <s d="&#x006E;" t="&#x006E;" />
 30 | <s d="&#x006F;" t="&#x006F;" />
 31 | <s d="&#x0070;" t="&#x0070;" />
 32 | <s d="&#x0071;" t="&#x0071;" />
 33 | <s d="&#x0072;" t="&#x0072;" />
 34 | <s d="&#x0073;" t="&#x0073;" />
 35 | <s d="&#x0074;" t="&#x0074;" />
 36 | <s d="&#x0075;" t="&#x0075;" />
 37 | <s d="&#x0076;" t="&#x0076;" />
 38 | <s d="&#x0077;" t="&#x0077;" />
 39 | <s d="&#x0078;" t="&#x0078;" />
 40 | <s d="&#x0079;" t="&#x0079;" />
 41 | <s d="&#x00FC;" t="&#x00FC;" />
 42 | <s d="&#x007A;" t="&#x007A;" />
 43 | <s d="&#x00E5;" t="&#x00E5;" />
 44 | <s d="&#x00E4;" t="&#x00E4;" />
 45 | <!-- <s d="&#x00E6;" t="&#x00E6;" note="ae" /> -->
 46 | <s d="&#x00F6;" t="&#x00F6;" />
 47 | <!-- <s d="&#x00F8;" t="&#x00F8;" note="o-slash" /> -->
 48 | </group>
 49 | <group name="upper case letters" b="111">
 50 | <s d="&#x0041;" t="&#x0041;" />
 51 | <s d="&#x00C0;" t="&#x00C0;" />
 52 | <s d="&#x0042;" t="&#x0042;" />
 53 | <s d="&#x0043;" t="&#x0043;" />
 54 | <s d="&#x0044;" t="&#x0044;" />
 55 | <s d="&#x0045;" t="&#x0045;" />
 56 | <s d="&#x00C9;" t="&#x00C9;" />
 57 | <s d="&#x0046;" t="&#x0046;" />
 58 | <s d="&#x0047;" t="&#x0047;" />
 59 | <s d="&#x0048;" t="&#x0048;" />
 60 | <s d="&#x0049;" t="&#x0049;" />
 61 | <s d="&#x004A;" t="&#x004A;" />
 62 | <s d="&#x004B;" t="&#x004B;" />
 63 | <s d="&#x004C;" t="&#x004C;" />
 64 | <s d="&#x004D;" t="&#x004D;" />
 65 | <s d="&#x004E;" t="&#x004E;" />
 66 | <s d="&#x004F;" t="&#x004F;" />
 67 | <s d="&#x0050;" t="&#x0050;" />
 68 | <s d="&#x0051;" t="&#x0051;" />
 69 | <s d="&#x0052;" t="&#x0052;" />
 70 | <s d="&#x0053;" t="&#x0053;" />
 71 | <s d="&#x0054;" t="&#x0054;" />
 72 | <s d="&#x0055;" t="&#x0055;" />
 73 | <s d="&#x0056;" t="&#x0056;" />
 74 | <s d="&#x0057;" t="&#x0057;" />
 75 | <s d="&#x0058;" t="&#x0058;" />
 76 | <s d="&#x0059;" t="&#x0059;" />
 77 | <s d="&#x00DC;" t="&#x00DC;" />
 78 | <s d="&#x005A;" t="&#x005A;" />
 79 | <s d="&#x00C5;" t="&#x00C5;" />
 80 | <s d="&#x00C4;" t="&#x00C4;" />
 81 | <!-- <s d="&#x00C6;" t="&#x00C6;" /> -->
 82 | <s d="&#x00D6;" t="&#x00D6;" />
 83 | <!-- <s d="&#x00D8;" t="&#x00D8;" /> -->
 84 | </group>
 85 | <group name="Numbers" b="113">
 86 | <s d="1" t="1"/>
 87 | <s d="2" t="2"/>
 88 | <s d="3" t="3"/>
 89 | <s d="4" t="4"/>
 90 | <s d="5" t="5"/>
 91 | <s d="6" t="6"/>
 92 | <s d="7" t="7"/>
 93 | <s d="8" t="8"/>
 94 | <s d="9" t="9"/>
 95 | <s d="0" t="0"/>
 96 | </group>
 97 | <group name="Punctuation" b="112">
 98 | <s d="%" t="%"/>
 99 | <s d="*" t="*"/>
100 | <s d="+" t="+"/>
101 | <s d="=" t="="/>
102 | <s d="/" t="/"/>
103 | <s d="#" t="#"/>
104 | <s d="$" t="$"/>
105 | <s d="|" t="|"/>
106 | <s d="\" t="\"/>
107 | <s d="~" t="~"/>
108 | <s d="^" t="^"/>
109 | <s d="_" t="_"/>
110 | <s d="&amp;" t="&amp;"/>
111 | <s d="@" t="@"/>
112 | <s d="[" t="["/>
113 | <s d="]" t="]"/>
114 | <s d="{" t="{"/>
115 | <s d="}" t="}"/>
116 | <s d="&lt;" t="&lt;"/>
117 | <s d="&gt;" t="&gt;"/>
118 | <s d="(" t="("/>
119 | <s d=")" t=")"/>
120 | <s d="&#x201D;" t="&#x201D;" note="right double quotation mark" />
121 | <s d="&quot;" t="&quot;"/>
122 | <s d="`" t="`"/>
123 | <s d="&#x2019;" t="&#x2019;" note="right single quotation mark and apostrophe" />
124 | <s d="-" t="-"/>
125 | <s d=":" t=":"/>
126 | <s d=";" t=";"/>
127 | <s d="?" t="?"/>
128 | <s d="!" t="!"/>
129 | <s d="," t=","/>
130 | <s d="." t="."/>
131 | </group>
132 | </alphabet>
133 | </alphabets>
134 | 
135 | 


--------------------------------------------------------------------------------
/assets/alphabet.dutch.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0"?>
  2 | <!DOCTYPE alphabets SYSTEM "alphabet.dtd">
  3 | <?xml-stylesheet type="text/xsl" href="alphabet.xsl"?>
  4 | <alphabets>
  5 | <alphabet name="Nederlands / Dutch with punctuation and numerals">
  6 | <orientation type="LR"/>
  7 | <encoding type="Western"/>
  8 | <palette>Default</palette>
  9 | <train>training_dutch_NL.txt</train>
 10 | <space d="&#x25a1;" t=" " b="9"/>
 11 | <control d="Control" t="" b="8"/>
 12 | <paragraph d="&#182;" b="9"/>
 13 | <group name="lower case letters" b="0">
 14 | <s d="&#x0061;" t="&#x0061;" />
 15 | <s d="&#x00E4;" t="&#x00E4;" />
 16 | <s d="&#x0062;" t="&#x0062;" />
 17 | <s d="&#x0063;" t="&#x0063;" />
 18 | <s d="&#x0064;" t="&#x0064;" />
 19 | <s d="&#x0065;" t="&#x0065;" />
 20 | <s d="&#x00EB;" t="&#x00EB;" />
 21 | <s d="&#x0066;" t="&#x0066;" />
 22 | <s d="&#x0067;" t="&#x0067;" />
 23 | <s d="&#x0068;" t="&#x0068;" />
 24 | <s d="&#x0069;" t="&#x0069;" />
 25 | <s d="&#x00EF;" t="&#x00EF;" />
 26 | <s d="&#x0133;" t="&#x0133;" />
 27 | <s d="&#x006A;" t="&#x006A;" />
 28 | <s d="&#x006B;" t="&#x006B;" />
 29 | <s d="&#x006C;" t="&#x006C;" />
 30 | <s d="&#x006D;" t="&#x006D;" />
 31 | <s d="&#x006E;" t="&#x006E;" />
 32 | <s d="&#x006F;" t="&#x006F;" />
 33 | <s d="&#x00F6;" t="&#x00F6;" />
 34 | <s d="&#x0070;" t="&#x0070;" />
 35 | <s d="&#x0071;" t="&#x0071;" />
 36 | <s d="&#x0072;" t="&#x0072;" />
 37 | <s d="&#x0073;" t="&#x0073;" />
 38 | <s d="&#x0074;" t="&#x0074;" />
 39 | <s d="&#x0075;" t="&#x0075;" />
 40 | <s d="&#x00FC;" t="&#x00FC;" />
 41 | <s d="&#x0076;" t="&#x0076;" />
 42 | <s d="&#x0077;" t="&#x0077;" />
 43 | <s d="&#x0078;" t="&#x0078;" />
 44 | <s d="&#x0079;" t="&#x0079;" />
 45 | <s d="&#x007A;" t="&#x007A;" />
 46 | </group>
 47 | <group name="upper case letters" b="111">
 48 | <s d="&#x0041;" t="&#x0041;" />
 49 | <s d="&#x00C4;" t="&#x00C4;" />
 50 | <s d="&#x0042;" t="&#x0042;" />
 51 | <s d="&#x0043;" t="&#x0043;" />
 52 | <s d="&#x0044;" t="&#x0044;" />
 53 | <s d="&#x0045;" t="&#x0045;" />
 54 | <s d="&#x00CB;" t="&#x00CB;" />
 55 | <s d="&#x0046;" t="&#x0046;" />
 56 | <s d="&#x0047;" t="&#x0047;" />
 57 | <s d="&#x0048;" t="&#x0048;" />
 58 | <s d="&#x0049;" t="&#x0049;" />
 59 | <s d="&#x00CF;" t="&#x00CF;" />
 60 | <s d="&#x0132;" t="&#x0132;" />
 61 | <s d="&#x004A;" t="&#x004A;" />
 62 | <s d="&#x004B;" t="&#x004B;" />
 63 | <s d="&#x004C;" t="&#x004C;" />
 64 | <s d="&#x004D;" t="&#x004D;" />
 65 | <s d="&#x004E;" t="&#x004E;" />
 66 | <s d="&#x004F;" t="&#x004F;" />
 67 | <s d="&#x00D6;" t="&#x00D6;" />
 68 | <s d="&#x0050;" t="&#x0050;" />
 69 | <s d="&#x0051;" t="&#x0051;" />
 70 | <s d="&#x0052;" t="&#x0052;" />
 71 | <s d="&#x0053;" t="&#x0053;" />
 72 | <s d="&#x0054;" t="&#x0054;" />
 73 | <s d="&#x0055;" t="&#x0055;" />
 74 | <s d="&#x00DC;" t="&#x00DC;" />
 75 | <s d="&#x0056;" t="&#x0056;" />
 76 | <s d="&#x0057;" t="&#x0057;" />
 77 | <s d="&#x0058;" t="&#x0058;" />
 78 | <s d="&#x0059;" t="&#x0059;" />
 79 | <s d="&#x005A;" t="&#x005A;" />
 80 | </group>
 81 | <group name="Numbers" b="113">
 82 | <s d="1" t="1"/>
 83 | <s d="2" t="2"/>
 84 | <s d="3" t="3"/>
 85 | <s d="4" t="4"/>
 86 | <s d="5" t="5"/>
 87 | <s d="6" t="6"/>
 88 | <s d="7" t="7"/>
 89 | <s d="8" t="8"/>
 90 | <s d="9" t="9"/>
 91 | <s d="0" t="0"/>
 92 | </group>
 93 | <group name="Punctuation" b="112">
 94 | <s d="%" t="%"/>
 95 | <s d="*" t="*"/>
 96 | <s d="+" t="+"/>
 97 | <s d="=" t="="/>
 98 | <s d="/" t="/"/>
 99 | <s d="#" t="#"/>
100 | <s d="$" t="$"/>
101 | <s d="|" t="|"/>
102 | <s d="\" t="\"/>
103 | <s d="~" t="~"/>
104 | <s d="^" t="^"/>
105 | <s d="_" t="_"/>
106 | <s d="&amp;" t="&amp;"/>
107 | <s d="@" t="@"/>
108 | <s d="[" t="["/>
109 | <s d="]" t="]"/>
110 | <s d="{" t="{"/>
111 | <s d="}" t="}"/>
112 | <s d="&lt;" t="&lt;"/>
113 | <s d="&gt;" t="&gt;"/>
114 | <s d="(" t="("/>
115 | <s d=")" t=")"/>
116 | <s d="&#x201A;" t="&#x201A;" note="German left single quotation mark; Albanian right" />
117 | <s d="&#x0027;" t="&#x0027;" note="vertical single quote" />
118 | <s d="&#x2019;" t="&#x2019;" note="right single quotation mark and apostrophe" />
119 | <s d="&#x201E;" t="&#x201E;" note="German left double quotation mark; Albanian right" />
120 | <s d="&#x0022;" t="&#x0022;" note="deprecated vertical double quotation mark" />
121 | <s d="&#x201D;" t="&#x201D;" note="right double quotation mark" />
122 | <s d="-" t="-"/>
123 | <s d=":" t=":"/>
124 | <s d=";" t=";"/>
125 | <s d="?" t="?"/>
126 | <s d="!" t="!"/>
127 | <s d="," t=","/>
128 | <s d="." t="."/>
129 | </group>
130 | </alphabet>
131 | </alphabets>
132 | 


--------------------------------------------------------------------------------
/src/dasher/android/AndroidKeyMap.java:
--------------------------------------------------------------------------------
  1 | package dasher.android;
  2 | 
  3 | import android.view.KeyEvent;
  4 | import dasher.CButtonMode;
  5 | import dasher.CCompassMode;
  6 | import dasher.CDasherComponent;
  7 | import dasher.CDasherInterfaceBase;
  8 | import dasher.CMenuMode;
  9 | import dasher.CSettingsStore;
 10 | import dasher.OneButtonDynamicFilter;
 11 | import dasher.TwoButtonDynamicFilter;
 12 | 
 13 | interface AndroidKeyMap {
 14 | 	/**
 15 | 	 * Converts an Android key code (<tt>KEYCODE_*</tt> in class android.KeyEvent)
 16 | 	 * into a Dasher key id (int) used by this input filter
 17 | 	 * @param keyCode Android keycode as passed to e.g. {@link DasherInputMethod#onKeyUp}/onKeyDown
 18 | 	 * @return Dasher key id to pass to {@link ADasherInterface#KeyDown(long, int)}, or
 19 | 	 * return -1 to ignore the KeyEvent. 
 20 | 	 */
 21 | 	public int ConvertAndroidKeycode(int keyCode);
 22 | }
 23 | 
 24 | /*interface TeklaSwitchListener {
 25 | 	public static final int TEKLA_SWITCH_RIGHT=80;
 26 | 	public static final int TEKLA_SWITCH_LEFT=40;
 27 | 	public static final int TEKLA_SWITCH_DOWN=20;
 28 | 	public static final int TEKLA_SWITCH_UP=10;
 29 | 	/** Called to handle presses of external switches connected via tekla (bluetooth) shield.
 30 | 	 * @param Time timestamp, as per System.currentTimeMillis()
 31 | 	 * @param iId Tekla switch event code (as per <a href="http://wiki.scyp.atrc.utoronto.ca/w/Switch_Event_Provider#Switch_Event_Flow">Tekla Switch Event Flow</a> wiki page)
 32 | 	 * @param pView current view rendering to the screen
 33 | 	 * @param pInput current input device for obtaining coordinates, if appropriate
 34 | 	 * @param Model current dasher model, i.e. state of nodes
 35 | 	 */
 36 | 	/*public void TeklaSwitchEvent(long Time, int iId, CDasherView pView, CDasherInput pInput, CDasherModel model);
 37 | }*/
 38 | 
 39 | class Android2BDynamic extends TwoButtonDynamicFilter implements AndroidKeyMap {
 40 | 
 41 | 	public Android2BDynamic(CDasherComponent creator, CDasherInterfaceBase iface) {
 42 | 		super(creator, iface);
 43 | 	}
 44 | 
 45 | 	public int ConvertAndroidKeycode(int iId) {
 46 | 		if (iId==KeyEvent.KEYCODE_VOLUME_UP) return 0;
 47 | 		if (iId==KeyEvent.KEYCODE_VOLUME_DOWN) return 1;
 48 | 		return -1;
 49 | 	}
 50 | }
 51 | 
 52 | class AndroidCompass extends CCompassMode implements AndroidKeyMap {
 53 | 
 54 | 	public AndroidCompass(CDasherComponent creator, CDasherInterfaceBase iface) {
 55 | 		super(creator, iface);
 56 | 	}
 57 | 
 58 | 	public int ConvertAndroidKeycode(int keyCode) {
 59 | 		//Trackball movement
 60 | 		if (keyCode>=19 && keyCode<=22) {
 61 | 			//yields 2,4,1,3
 62 | 			return ((keyCode-18)*2) % 5;
 63 | 		}
 64 | 		return -1;
 65 | 	}
 66 | 	
 67 | }
 68 | 
 69 | class Android1BDynamic extends OneButtonDynamicFilter implements AndroidKeyMap {
 70 | 	
 71 | 	public Android1BDynamic(CDasherComponent creator, CDasherInterfaceBase iface) {
 72 | 		super(creator, iface);
 73 | 	}
 74 | 	
 75 | 	public int ConvertAndroidKeycode(int keyCode) {
 76 | 		if (keyCode==KeyEvent.KEYCODE_MENU || keyCode==KeyEvent.KEYCODE_BACK || (keyCode>=19 && keyCode<=22))
 77 | 			return -1; //don't intercept menu, back, or trackball movement (cursor) - too useful!
 78 | 		return 1; //but anything else, treat the same!
 79 | 	}
 80 | 	
 81 | }
 82 | 
 83 | class AndroidMenuMode extends CMenuMode implements AndroidKeyMap {
 84 | 
 85 | 	public AndroidMenuMode(CDasherComponent creator, CDasherInterfaceBase iface, String szName) {
 86 | 		super(creator, iface, szName);
 87 | 	}
 88 | 
 89 | 	/** TODO need some preferences here for user to specify what keys to use...*/
 90 | 	public int ConvertAndroidKeycode(int keyCode) {
 91 | 		switch (keyCode) {
 92 | 		//case KeyEvent.KEYCODE_DPAD_DOWN:
 93 | 		case KeyEvent.KEYCODE_VOLUME_UP:
 94 | 		case KeyEvent.KEYCODE_SPACE:
 95 | 			return 1; //scan
 96 | 		//case KeyEvent.KEYCODE_DPAD_RIGHT:
 97 | 		case KeyEvent.KEYCODE_VOLUME_DOWN:
 98 | 		case KeyEvent.KEYCODE_ENTER:
 99 | 			return 2; //select
100 | 		}
101 | 		return -1;
102 | 	}
103 | 	
104 | }
105 | 
106 | class AndroidDirectMode extends CButtonMode implements AndroidKeyMap {
107 | 
108 | 	public AndroidDirectMode(CDasherComponent creator, CDasherInterfaceBase iface, String szName) {
109 | 		super(creator, iface, szName);
110 | 	}
111 | 
112 | 	public int ConvertAndroidKeycode(int keyCode) {
113 | 		if (keyCode==KeyEvent.KEYCODE_0) return 1; //back i.e. zoom out
114 | 		if (keyCode>=KeyEvent.KEYCODE_1 && keyCode<=KeyEvent.KEYCODE_9) return keyCode-KeyEvent.KEYCODE_1+2; //2+ = select that box
115 | 		return -1;
116 | 	}
117 | 	
118 | }


--------------------------------------------------------------------------------
/assets/alphabet.spanish.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0"?>
  2 | <!DOCTYPE alphabets SYSTEM "alphabet.dtd">
  3 | <?xml-stylesheet type="text/xsl" href="alphabet.xsl"?>
  4 | <alphabets>
  5 | <alphabet name="Espa&#x00F1;ol / Spanish with punctuation and numerals">
  6 | <orientation type="LR"/>
  7 | <encoding type="Western"/>
  8 | <palette>Default</palette>
  9 | <train>training_spanish_ES.txt</train>
 10 | <space d="&#x25a1;" t=" " b="9" />
 11 | <paragraph d="&#182;" b="9"/>
 12 | <control d="Control" t="" b="8"/>
 13 | <group name="lower case letters" b="0">
 14 | <s d="&#x0061;" t="&#x0061;" />
 15 | <s d="&#x00E1;" t="&#x00E1;" />
 16 | <s d="&#x0062;" t="&#x0062;" />
 17 | <s d="&#x0063;" t="&#x0063;" />
 18 | <s d="&#x0064;" t="&#x0064;" />
 19 | <s d="&#x0065;" t="&#x0065;" />
 20 | <s d="&#x00E9;" t="&#x00E9;" />
 21 | <s d="&#x0066;" t="&#x0066;" />
 22 | <s d="&#x0067;" t="&#x0067;" />
 23 | <s d="&#x0068;" t="&#x0068;" />
 24 | <s d="&#x0069;" t="&#x0069;" />
 25 | <s d="&#x00ED;" t="&#x00ED;" />
 26 | <s d="&#x006A;" t="&#x006A;" />
 27 | <s d="&#x006B;" t="&#x006B;" />
 28 | <s d="&#x006C;" t="&#x006C;" />
 29 | <s d="&#x006D;" t="&#x006D;" />
 30 | <s d="&#x006E;" t="&#x006E;" />
 31 | <s d="&#x00F1;" t="&#x00F1;" />
 32 | <s d="&#x006F;" t="&#x006F;" />
 33 | <s d="&#x00F3;" t="&#x00F3;" />
 34 | <s d="&#x0070;" t="&#x0070;" />
 35 | <s d="&#x0071;" t="&#x0071;" />
 36 | <s d="&#x0072;" t="&#x0072;" />
 37 | <s d="&#x0073;" t="&#x0073;" />
 38 | <s d="&#x0074;" t="&#x0074;" />
 39 | <s d="&#x0075;" t="&#x0075;" />
 40 | <s d="&#x00FA;" t="&#x00FA;" />
 41 | <s d="&#x00FC;" t="&#x00FC;" />
 42 | <s d="&#x0076;" t="&#x0076;" />
 43 | <s d="&#x0077;" t="&#x0077;" />
 44 | <s d="&#x0078;" t="&#x0078;" />
 45 | <s d="&#x0079;" t="&#x0079;" />
 46 | <s d="&#x007A;" t="&#x007A;" />
 47 | </group> 
 48 | <group name="upper case letters" b="111"> 
 49 | <s d="&#x0041;" t="&#x0041;" />
 50 | <s d="&#x00C1;" t="&#x00C1;" />
 51 | <s d="&#x0042;" t="&#x0042;" />
 52 | <s d="&#x0043;" t="&#x0043;" />
 53 | <s d="&#x0044;" t="&#x0044;" />
 54 | <s d="&#x0045;" t="&#x0045;" />
 55 | <s d="&#x00C9;" t="&#x00C9;" />
 56 | <s d="&#x0046;" t="&#x0046;" />
 57 | <s d="&#x0047;" t="&#x0047;" />
 58 | <s d="&#x0048;" t="&#x0048;" />
 59 | <s d="&#x0049;" t="&#x0049;" />
 60 | <s d="&#x00CD;" t="&#x00CD;" />
 61 | <s d="&#x004A;" t="&#x004A;" />
 62 | <s d="&#x004B;" t="&#x004B;" />
 63 | <s d="&#x004C;" t="&#x004C;" />
 64 | <s d="&#x004D;" t="&#x004D;" />
 65 | <s d="&#x004E;" t="&#x004E;" />
 66 | <s d="&#x00D1;" t="&#x00D1;" />
 67 | <s d="&#x004F;" t="&#x004F;" />
 68 | <s d="&#x00D3;" t="&#x00D3;" />
 69 | <s d="&#x0050;" t="&#x0050;" />
 70 | <s d="&#x0051;" t="&#x0051;" />
 71 | <s d="&#x0052;" t="&#x0052;" />
 72 | <s d="&#x0053;" t="&#x0053;" />
 73 | <s d="&#x0054;" t="&#x0054;" />
 74 | <s d="&#x0055;" t="&#x0055;" />
 75 | <s d="&#x00DA;" t="&#x00DA;" />
 76 | <s d="&#x00DC;" t="&#x00DC;" />
 77 | <s d="&#x0056;" t="&#x0056;" />
 78 | <s d="&#x0057;" t="&#x0057;" />
 79 | <s d="&#x0058;" t="&#x0058;" />
 80 | <s d="&#x0059;" t="&#x0059;" />
 81 | <s d="&#x005A;" t="&#x005A;" />
 82 | </group>
 83 | <group name="Numbers" b="113">
 84 | <s d="1" t="1"/>
 85 | <s d="2" t="2"/>
 86 | <s d="3" t="3"/>
 87 | <s d="4" t="4"/>
 88 | <s d="5" t="5"/>
 89 | <s d="6" t="6"/>
 90 | <s d="7" t="7"/>
 91 | <s d="8" t="8"/>
 92 | <s d="9" t="9"/>
 93 | <s d="0" t="0"/>
 94 | </group>
 95 | <group name="Punctuation" b="112">
 96 | <s d="%" t="%"/>
 97 | <s d="*" t="*"/>
 98 | <s d="+" t="+"/>
 99 | <s d="=" t="="/>
100 | <s d="/" t="/"/>
101 | <s d="#" t="#"/>
102 | <s d="&#8364;" t="&#8364;"  note="euro" />
103 | <s d="$" t="$"/>
104 | <s d="|" t="|"/>
105 | <s d="\" t="\"/>
106 | <s d="~" t="~"/>
107 | <s d="^" t="^"/>
108 | <s d="_" t="_"/>
109 | <s d="&amp;" t="&amp;"/>
110 | <s d="@" t="@"/>
111 | <s d="[" t="["/>
112 | <s d="]" t="]"/>
113 | <s d="{" t="{"/>
114 | <s d="}" t="}"/>
115 | <s d="&lt;" t="&lt;"/>
116 | <s d="&gt;" t="&gt;"/>
117 | <s d="(" t="("/>
118 | <s d=")" t=")"/>
119 | <s d="&#x2039;" t="&#x2039;" note="French left single quotation mark" />
120 | <s d="&#x203A;" t="&#x203A;" note="French right single quotation mark" />
121 | <s d="&#x00AB;" t="&#x00AB;" note="French left double quotation mark" />
122 | <s d="&#x00BB;" t="&#x00BB;" note="French right double quotation mark" />
123 | <s d="&#x201C;" t="&#x201C;" note="left double quotation mark" />
124 | <s d="&#x0022;" t="&#x0022;" note="deprecated vertical double quotation mark" />
125 | <s d="&#x201D;" t="&#x201D;" note="right double quotation mark" />
126 | <s d="&#x2018;" t="&#x2018;" note="left single quotation mark" />
127 | <s d="&#x0027;" t="&#x0027;" note="vertical single quote" />
128 | <s b="107" d="&#x25cc;&#x0313;" t="&#x2019;" note="right single quotation mark and apostrophe" />
129 | <s b="9"    d="&#x25CA;" t="&#x9;" note="TAB (represented by a diamond)"/>
130 | <s d="-" t="-"/>
131 | <s d=":" t=":"/>
132 | <s d=";" t=";"/>
133 | <s d="&#x00BF;" t="&#x00BF;" note="inverted question mark" />
134 | <s d="?" t="?"/>
135 | <s d="&#x00A1;" t="&#x00A1;" note="inverted exclamation mark" />
136 | <s d="!" t="!"/>
137 | <s d="," t=","/>
138 | <s d="." t="."/> 
139 | </group>
140 | </alphabet>
141 | </alphabets>
142 | 


--------------------------------------------------------------------------------
/src/dasher/CDasherScreen.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |   This file is part of JDasher.
  3 | 
  4 |   JDasher is free software; you can redistribute it and/or modify
  5 |   it under the terms of the GNU General Public License as published by
  6 |   the Free Software Foundation; either version 2 of the License, or
  7 |   (at your option) any later version.
  8 | 
  9 |   JDasher is distributed in the hope that it will be useful,
 10 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 |   GNU General Public License for more details.
 13 | 
 14 |   You should have received a copy of the GNU General Public License
 15 |   along with JDasher; if not, write to the Free Software
 16 |   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 17 | 
 18 |   Copyright (C) 2006      Christopher Smowton <cs448@cam.ac.uk>
 19 | 
 20 |   JDasher is a port derived from the Dasher project; for information on
 21 |   the project see www.dasher.org.uk; for information on JDasher itself
 22 |   and related projects see www.smowton.net/chris
 23 | 
 24 | */
 25 | 
 26 | package dasher;
 27 | 
 28 | 
 29 | /**
 30 |  * Defines a screen which Dasher can use to draw graphics
 31 |  * primitives.
 32 |  */
 33 | public interface CDasherScreen {
 34 | 
 35 | 	/**
 36 | 	 * Gets the width, and hence maximum X screen co-ordinate.
 37 | 	 * 
 38 | 	 * @return width
 39 | 	 */
 40 | 	public abstract int GetWidth();
 41 | 	
 42 | 	/**
 43 | 	 * Gets the height, and hence maximum Y screen co-ordinate.
 44 | 	 * 
 45 | 	 * @return height
 46 | 	 */
 47 | 	public abstract int GetHeight();
 48 | 	
 49 | 	/**
 50 | 	 * Determines / guesses the size of a given string as drawn on this screen.
 51 | 	 * <p>
 52 | 	 * This is used in determining how much to displace other drawn
 53 | 	 * strings in order to prevent them from overlapping.
 54 | 	 * <p>
 55 | 	 * This must be carried out by the screen because only the
 56 | 	 * actual drawing surface can know how fonts appear when
 57 | 	 * rendered.
 58 | 	 * 
 59 | 	 * @param string String whose size we wish to determine
 60 | 	 * @param Size Font size in points
 61 | 	 * @return Point specifying the width and height of this string.
 62 | 	 */
 63 | 	public abstract CDasherView.Point TextSize(String string, int Size);
 64 | 	
 65 | 	
 66 | 	/**
 67 | 	 * Draws a string
 68 | 	 * 
 69 | 	 * @param string String to draw
 70 | 	 * @param x1 Top-left hand corner x co-ordinate
 71 | 	 * @param y1 Top-left hand corner y co-ordinate
 72 | 	 * @param Size Font size in points
 73 | 	 */
 74 | 	public abstract void DrawString(String string, int x1, int y1, int Size);
 75 | 	
 76 |   /** Draw a filled rectangle
 77 | 	* 
 78 | 	* @param x1 top left of rectangle (x coordinate)
 79 | 	* @param y1 top left corner of rectangle (y coordinate)
 80 | 	* @param x2 bottom right of rectangle (x coordinate)
 81 | 	* @param y2 bottom right of rectangle (y coordinate)
 82 | 	* @param iFillColour fill colour to be used (numeric, -1 => don't fill)
 83 | 	* @param iOutlineColour colour to draw outline (numeric, -1 => don't outline)
 84 | 	* @param ColorScheme Which colourscheme is to be used
 85 | 	* @param iThickness Line thickness for outline (<1 => don't outline)
 86 | 	*/
 87 | 	public abstract void DrawRectangle(int x1, int y1, int x2, int y2, int iFillColour, int iOutlineColour,int iThickness);
 88 | 	
 89 | 	/**
 90 | 	 * Draw a circle
 91 | 	 * 
 92 | 	 * @param iCX X co-ordinate of the centre
 93 | 	 * @param iCY Y co-ordinate of the centre
 94 | 	 * @param iR Radius in pixels
 95 | 	 * @param iFillColour Colour number to fill (-1 = don't fill)
 96 |          * @param iLineColour Colour number to outline (-1 = use default)
 97 |          * @param iLineWidth line width of outline (<=0 = don't outline)
 98 | 	 */	
 99 | 	public abstract void DrawCircle(int iCX, int iCY, int iR, int iFillColour, int iLineColour, int iLineWidth);
100 | 	
101 | 	/**
102 | 	 * Draws a line segment.
103 | 	 * @param x0 Starting x coordinate
104 | 	 * @param y0 Starting y coordinate
105 | 	 * @param x1 End x coordinate
106 | 	 * @param y1 End y coordinate
107 | 	 * @param iWidth Line width
108 | 	 * @param Colour Colour number. Use -1 if you don't want to specify a colour...
109 | 	 */
110 | 	public abstract void drawLine(int x0, int y0, int x1, int y1, int iWidth, int Colour);
111 | 	
112 |    /**
113 | 	* Draw a filled polygon - given vertices and color id.
114 | 	* This is not (currently) used in standard Dasher. However, it could be very
115 | 	* useful in the future. Please implement unless it will be very difficult,
116 | 	* in which case make this function call Polyline.
117 | 	* Draw a filled polygon
118 | 	*
119 | 	* @param Points array of points defining the edge of the polygon
120 | 	* @param Number number of points in the array
121 | 	* @param fillColour colour of the polygon (numeric)
122 | 	* @param iOutlineColour colour for border (-1 => no border)
123 | 	* @param iWidth line width of border (<1 => no border)
124 | 	*/
125 | 	public abstract void Polygon(CDasherView.Point[] Points, int fillColour, int iOutlineColour, int iWidth);
126 | 	
127 | 	/**
128 | 	 * Sets the colour scheme to use
129 | 	 * 
130 | 	 * @param ColourScheme New colour scheme
131 | 	 */
132 | 	public abstract void SetColourScheme(CCustomColours ColourScheme);
133 | 	
134 | }
135 | 


--------------------------------------------------------------------------------
/assets/alphabet.englishC.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <!DOCTYPE alphabets SYSTEM "alphabet.dtd">
  3 | <?xml-stylesheet type="text/xsl" href="alphabet.xsl"?>
  4 | <alphabets>
  5 | <alphabet name="English with accents, numerals, punctuation">
  6 | <orientation type="LR"/>
  7 | <encoding type="Western"/>
  8 | <palette>European/Asian (New)</palette>
  9 | <train>training_english_GB.txt</train>
 10 | <space d="&#x25a1;" t=" "  b="9"/>
 11 | <control d="Control" t=""  b="8"/>
 12 | <paragraph d="&#182;" b="9"/>
 13 | <group name="Combining accents" b="47" visible="on">
 14 | <s d="&#x25cc;&#x0300;"  t="&#x0300;" b="40" note="&#x0060; COMBINING GRAVE ACCENT  "/>
 15 | <s d="&#x25cc;&#x0301;"  t="&#x0301;" b="41" note="&#x00B4; COMBINING ACUTE ACCENT  "/>
 16 | <s d="&#x25cc;&#x0302;"  t="&#x0302;" b="40" note="&#x005E; COMBINING CIRCUMFLEX ACCENT  "/>
 17 | <s d="&#x25cc;&#x0303;"  t="&#x0303;" b="41" note="&#x007E; COMBINING TILDE  "/>
 18 | <s d="&#x25cc;&#x0304;"  t="&#x0304;" b="40" note="&#x00AF; COMBINING MACRON  "/>
 19 | <s d="&#x25cc;&#x0306;"  t="&#x0306;" b="41" note="&#x02D8; COMBINING BREVE"/>
 20 | <s d="&#x25cc;&#x0307;"  t="&#x0307;" b="40" note="&#x02D9; COMBINING DOT ABOVE"/>
 21 | <s d="&#x25cc;&#x0308;"  t="&#x0308;" b="41" note="&#x00A8; COMBINING DIAERESIS or UMLAUT "/>
 22 | <s d="&#x25cc;&#x030A;"  t="&#x030A;" b="40" note="&#x02DA; COMBINING RING ABOVE"/>
 23 | <s d="&#x25cc;&#x030B;"  t="&#x030B;" b="41" note="&#x02DD; COMBINING DOUBLE ACUTE ACCENT"/>
 24 | <s d="&#x25cc;&#x030C;"  t="&#x030C;" b="40" note="&#x02C7; COMBINING CARON"/>
 25 | <s d="&#x25cc;&#x0326;"  t="&#x0326;" b="41" note="       COMBINING COMMA BELOW"/>
 26 | <s d="&#x25cc;&#x0327;"  t="&#x0327;" b="40" note="&#x00B8; COMBINING CEDILLA  "/>
 27 | <s d="&#x25cc;&#x0328;"  t="&#x0328;" b="41" note="&#x02DB; COMBINING OGONEK"/>
 28 | </group>
 29 | <group name="Lower case Latin letters" b="0" visible="off">
 30 | <s d="a" t="a" b="10"/>
 31 | <s d="b" t="b" b="11"/>
 32 | <s d="c" t="c" b="12"/>
 33 | <s d="d" t="d" b="13"/>
 34 | <s d="e" t="e" b="14"/>
 35 | <s d="f" t="f" b="15"/>
 36 | <s d="g" t="g" b="16"/>
 37 | <s d="h" t="h" b="17"/>
 38 | <s d="i" t="i" b="18"/>
 39 | <s d="j" t="j" b="19"/>
 40 | <s d="k" t="k" b="20"/>
 41 | <s d="l" t="l" b="21"/>
 42 | <s d="m" t="m" b="22"/>
 43 | <s d="n" t="n" b="23"/>
 44 | <s d="o" t="o" b="24"/>
 45 | <s d="p" t="p" b="25"/>
 46 | <s d="q" t="q" b="26"/>
 47 | <s d="r" t="r" b="27"/>
 48 | <s d="s" t="s" b="28"/>
 49 | <s d="t" t="t" b="29"/>
 50 | <s d="u" t="u" b="30"/>
 51 | <s d="v" t="v" b="31"/>
 52 | <s d="w" t="w" b="32"/>
 53 | <s d="x" t="x" b="33"/>
 54 | <s d="y" t="y" b="34"/>
 55 | <s d="z" t="z" b="35"/>
 56 | </group>
 57 | <group name="Upper case Latin letters" b="46">
 58 | <s d="A" t="A" b="10"/>
 59 | <s d="B" t="B" b="11"/>
 60 | <s d="C" t="C" b="12"/>
 61 | <s d="D" t="D" b="13"/>
 62 | <s d="E" t="E" b="14"/>
 63 | <s d="F" t="F" b="15"/>
 64 | <s d="G" t="G" b="16"/>
 65 | <s d="H" t="H" b="17"/>
 66 | <s d="I" t="I" b="18"/>
 67 | <s d="J" t="J" b="19"/>
 68 | <s d="K" t="K" b="20"/>
 69 | <s d="L" t="L" b="21"/>
 70 | <s d="M" t="M" b="22"/>
 71 | <s d="N" t="N" b="23"/>
 72 | <s d="O" t="O" b="24"/>
 73 | <s d="P" t="P" b="25"/>
 74 | <s d="Q" t="Q" b="26"/>
 75 | <s d="R" t="R" b="27"/>
 76 | <s d="S" t="S" b="28"/>
 77 | <s d="T" t="T" b="29"/>
 78 | <s d="U" t="U" b="30"/>
 79 | <s d="V" t="V" b="31"/>
 80 | <s d="W" t="W" b="32"/>
 81 | <s d="X" t="X" b="33"/>
 82 | <s d="Y" t="Y" b="34"/>
 83 | <s d="Z" t="Z" b="35"/>
 84 | </group>
 85 | <group name="Numbers" b="48">
 86 | <s d="1" t="1" b="42"/>
 87 | <s d="2" t="2" b="41"/>
 88 | <s d="3" t="3" b="42"/>
 89 | <s d="4" t="4" b="41"/>
 90 | <s d="5" t="5" b="42"/>
 91 | <s d="6" t="6" b="41"/>
 92 | <s d="7" t="7" b="42"/>
 93 | <s d="8" t="8" b="41"/>
 94 | <s d="9" t="9" b="42"/>
 95 | <s d="0" t="0" b="41"/>
 96 | </group>
 97 | <group name="Punctuation" b="49">
 98 | <s b="40" d="[" t="["/>
 99 | <s b="41" d="]" t="]"/>
100 | <s b="40" d="{" t="{"/>
101 | <s b="41" d="}" t="}"/>
102 | <s b="40" d="&lt;" t="&lt;"/>
103 | <s b="41" d="&gt;" t="&gt;"/>
104 | <s b="40" d="(" t="("/>
105 | <s b="41" d=")" t=")"/>
106 | <s b="40" d="&amp;" t="&amp;"/> 
107 | <s b="42" d="$" t="$"/>
108 | <s b="41" d="%" t="%"/>
109 | <s b="42" d="=" t="="/>
110 | <s b="41" d="+" t="+"/>
111 | <s b="42" d="-" t="-"/>
112 | <s b="41" d="*" t="*"/>
113 | <s b="42" d="/" t="/"/>
114 | <s b="40" d="\" t="\"/>
115 | <s b="41" d="#" t="#"/>
116 | <s b="40" d="|" t="|"/>
117 | <s b="41" d="~" t="~"/>
118 | <s b="40" d="^" t="^"/>
119 | <s b="41" d="@" t="@"/>
120 | <s b="40" d="_" t="_"/>
121 | <s b="42" d="&#x201C;" t="&#x201C;" note="left double quotation mark" />
122 | <s b="41" d="&#x0022;" t="&#x0022;" note="deprecated vertical double quotation mark" />
123 | <s b="42" d="&#x201D;" t="&#x201D;" note="right double quotation mark" />
124 | <s b="41" d="&#x2018;" t="&#x2018;" note="left single quotation mark" />
125 | <s b="42" d="&#x2019;" t="&#x2019;" note="right single quotation mark and apostrophe" />
126 | <s b="41" d="`" t="`" note="left quote from keyboard" />
127 | <s b="42" d="&#x25cc;&#x0313;" t="&apos;" note=" apostrophe"/>
128 | <s b="40"  d="&#x25CA;" t="&#x9;" note="TAB (represented by a diamond)"/>
129 | <s b="41" d=":" t=":"/>
130 | <s b="40" d=";" t=";"/>
131 | <s b="41" d="?" t="?"/>
132 | <s b="40" d="!" t="!"/>
133 | <s b="41" d="," t=","/>
134 | <s d="&#183;" t="." b="40"/>
135 | </group>
136 | </alphabet>
137 | </alphabets>
138 | 


--------------------------------------------------------------------------------
/src/dasher/applet/JSettings.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |   This file is part of JDasher.
  3 | 
  4 |   JDasher is free software; you can redistribute it and/or modify
  5 |   it under the terms of the GNU General Public License as published by
  6 |   the Free Software Foundation; either version 2 of the License, or
  7 |   (at your option) any later version.
  8 | 
  9 |   JDasher is distributed in the hope that it will be useful,
 10 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 |   GNU General Public License for more details.
 13 | 
 14 |   You should have received a copy of the GNU General Public License
 15 |   along with JDasher; if not, write to the Free Software
 16 |   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 17 | 
 18 |   Copyright (C) 2006      Christopher Smowton <cs448@cam.ac.uk>
 19 | 
 20 |   JDasher is a port derived from the Dasher project; for information on
 21 |   the project see www.dasher.org.uk; for information on JDasher itself
 22 |   and related projects see www.smowton.net/chris
 23 | 
 24 | */
 25 | 
 26 | package dasher.applet;
 27 | 
 28 | import java.security.AccessControlException;
 29 | import java.util.prefs.Preferences;
 30 | 
 31 | import dasher.CParameterNotFoundException;
 32 | import dasher.CSettingsStore;
 33 | 
 34 | /**
 35 |  * Extension of CSettingsStore which uses a Java Preferences
 36 |  * object to store settings between sessions.
 37 |  * <p>
 38 |  * This boils down to using the registry in Windows, and a hidden
 39 |  * file in the user's profile on Unix-style systems including
 40 |  * MacOSX.
 41 |  * <p>
 42 |  * In the current unsigned applet setup this will not get used,
 43 |  * as a security exception is thrown on trying to instantiate
 44 |  * Preferences and a plain old CSettingsStore will be used in lieu.
 45 |  * <p>
 46 |  * Should JDasher ever get converted to a standalone Java application
 47 |  * or signed applet, however, this will spring into life and provide
 48 |  * persistent settings.
 49 |  * <p>
 50 |  * I have not documented these functions, as they all implement
 51 |  * precisely the behaviour specified in CSettingsStore.
 52 |  * <p>
 53 |  * The only noteworthy feature is that the Constructor will throw
 54 |  * a StoreUnavailableException if unable to open the registry
 55 |  * and/or user profile.
 56 |  */
 57 | public class JSettings extends CSettingsStore {
 58 | 
 59 | 	private Preferences appSettings;
 60 | 	
 61 | 	public JSettings() throws StoreUnavailableException {
 62 | 		try {
 63 | 			appSettings = Preferences.userRoot();
 64 | 		}
 65 | 		catch(AccessControlException e) {
 66 | 			throw new StoreUnavailableException();
 67 | 		}
 68 | 		LoadPersistent();
 69 | 	}
 70 | 	
 71 | 	
 72 | 	protected boolean LoadBoolSetting(String Key) throws CParameterNotFoundException {
 73 | 	
 74 | 		/* CSFS: This annoying hack is to work around the fact that any
 75 | 		 * failure to return a value is responded to by returning the default!
 76 | 		 */
 77 | 		
 78 | 		try {
 79 | 			int retval = appSettings.getInt("JDasher/B_" + Key, 2);
 80 | 			if(retval == 0) return false;
 81 | 			else if(retval == 1) return true;
 82 | 			else throw new CParameterNotFoundException(Key);
 83 | 		}
 84 | 		catch (AccessControlException e) {
 85 | 			throw new CParameterNotFoundException(Key);
 86 | 		}
 87 | 		
 88 | 	}
 89 | 
 90 | 
 91 | 	protected long LoadLongSetting(String Key) throws CParameterNotFoundException {
 92 | 		
 93 | 		try {
 94 | 			long retval = appSettings.getLong("JDasher/L_" + Key, -999);
 95 | 			if (retval == -999 && appSettings.getLong("JDasher/L_"+Key,-998)==-998)
 96 | 				throw new CParameterNotFoundException(Key);
 97 | 			else return retval;
 98 | 		}
 99 | 		catch (AccessControlException e) {
100 | 			throw new CParameterNotFoundException(Key);
101 | 		}
102 | 	}
103 | 
104 | 
105 | 	protected String LoadStringSetting(String Key) throws CParameterNotFoundException {
106 | 	
107 | 		try {
108 | 			String retval = appSettings.get("JDasher/S_" + Key, "Parameter Error");
109 | 			if(retval.equals("Parameter Error")) throw new CParameterNotFoundException("Key");
110 | 			else return retval;
111 | 		}
112 | 		catch (AccessControlException e) {
113 | 			throw new CParameterNotFoundException(Key);
114 | 		}
115 | 	}
116 | 
117 | 
118 | 	protected void SaveSetting(String Key, boolean Value) {
119 | 		int val = Value ? 1 : 0;
120 | 		try {
121 | 			appSettings.putInt("JDasher/B_" + Key, val);
122 | 		}
123 | 		catch (AccessControlException e) {
124 | 			return; // Fail silently; we will use the default next time
125 | 		}
126 | 	}
127 | 
128 | 
129 | 	protected void SaveSetting(String Key, long Value) {
130 | 		try {
131 | 			appSettings.putLong("JDasher/L_" + Key, Value);
132 | 		}
133 | 		catch (AccessControlException e) {
134 | 			return; // Fail silently; we will use the default next time
135 | 		}	
136 | 	}
137 | 
138 | 
139 | 	protected void SaveSetting(String Key, String Value) {
140 | 		try {
141 | 			appSettings.put("JDasher/S_" + Key, Value);
142 | 		}
143 | 		catch (AccessControlException e) {
144 | 			return; // Fail silently; we will use the default next time
145 | 		}
146 | 	}
147 | 		
148 | }
149 | 
150 | /**
151 |  * Exception indicating that JSettings was unable to initialise
152 |  * due to the Preferences object's backing store being unavailable,
153 |  * probably due to security limitations.
154 |  */
155 | class StoreUnavailableException extends Exception {
156 | 	// No properties
157 | }
158 | 


--------------------------------------------------------------------------------
/res/values-fr/strings.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <resources xmlns:android="http://schemas.android.com/apk/res/android">
 3 | 
 4 | <!--Preference Strings-->
 5 | <string name="MaxBitRateTimes100_title">Vitesse Maximum</string>
 6 | <string name="MaxBitRateTimes100_summary">"Taux maximum de saisie de données en bits/sec"</string>
 7 | <string name="AndroidDisplaySettings_title">Options d\'affichage</string>
 8 | <string name="MinNodeSizeForText_title">Taille du texte</string>
 9 | <string name="MinNodeSizeForText_summary">"Taille du plus petit recantangle ayant du texte, 4096=écran entier"</string>
10 | <string name="NodeBudget_title">Budget de rectangles</string>
11 | <string name="NodeBudget_summary">"Grand = plus de détail; petit = plus rapide"</string>
12 | <string name="NonLinearX_title">"Non-linéarité en X"</string>
13 | <string name="NonLinearX_summary">"Log compression à la gauche de la croix"</string>
14 | <string name="DasherFontSize_title">Taille de la police</string>
15 | <string name="DasherFontSize_summary">"Petit / médium / large"</string>
16 | <string name="MarginWidth_title">Marge</string>
17 | <string name="MarginWidth_summary">"Marge à droite pour son doigt"</string>
18 | <string name="ControlMode_title">Commandes</string>
19 | <string name="ControlMode_summary">Fabriquez des boîtes par ex., actions de saisie XXX IME</string>
20 | <string name="AlphabetID_title">"Nom d'alphabet"</string>
21 | <string name="AndroidTilt_title">"Accéléromètre"</string>
22 | <string name="OneDimensionalMode_title">"N'utilisez qu'une seule dimension"</string>
23 | <string name="OneDimensionalMode_summaryOff">"Deux axes indépendants"</string>
24 | <string name="OneDimensionalMode_summaryOn">Inclinaison vers le haut/bas trace un cercle complet</string>
25 | <string name="AndroidTiltHoldToGo_title">Appuyez pour avancer</string>
26 | <string name="AndroidTiltUsesTouchX_title">Controle horizontal par saisie tactile</string>
27 | <string name="CircleStart_title">"Démarrage dans le cercle"</string>
28 | <string name="CircleStart_summary">"Démarrer/s'arrȇter en se plaçant dans le cercle"</string>
29 | <string name="AndroidCalibrateTilting_title">"Calibrer l'accéléromètre"</string>
30 | <string name="AndroidTouch_title">Saisie tactile</string>
31 | <string name="AndroidTouchUsesTiltX_title">Inclinez pour bouger horizontalement</string>
32 | <string name="TargetOffset_title">Excentrage de la cible</string>
33 | <string name="TargetOffset_summary">Bouger la cible verticalement par une distance fixe relative à la position du doigt (400=hauteur de l\'écran)</string>
34 | <string name="AutoAdjust_title">Ajuste automatiquement</string>
35 | <string name="AutoAdjust_summary">"Apprend l'excentrage vertical (ci-dessus) automatiquement"</string>
36 | <string name="TapTime_title">"Durée max. pour un clic"</string>
37 | <string name="TapTime_summary">"Une durée plus élevée est prise pour un glissement"</string>
38 | <string name="Zoomsteps_title">"Nº d'images pour animer un clic"</string>
39 | <string name="MaxZoom_title">Zoom max. par clic</string>
40 | <string name="MaxZoom_summary">Facteur maximum d\'un zoom suivant un clic</string>
41 | <string name="AndroidBoxes_title">Modes à boîtes</string>
42 | <string name="AndroidBoxes_summary">"Balayez ou cliquez l'écran divisée en boîtes"</string>
43 | <string name="ButtonMenuBoxes_title">Nombre de boîtes</string>
44 | <!-- (hoping that forward is obvious once they have one too many) -->
45 | <string name="ButtonMenuSafety_title">Marge de sȗreté</string>
46 | <string name="ButtonMenuSafety_summary">"Zoom un peu moins que la boîte entière"</string>
47 | <string name="ButtonModeNonuniformity_title">"Nonuniformité de la taille des boîtes"</string>
48 | <string name="AndroidScan_title">Balayage de boîtes</string>
49 | <string name="AndroidScan_summaryOn">"Tapez l'écran pour choisir la boîte rouge"</string>
50 | <string name="AndroidScan_summaryOff">"Tapez sur la boîte pour la choisir"</string>
51 | <string name="ButtonScanTime_title">Temps to balayage</string>
52 | <string name="ButtonScanTime_summary">"0 = tapez la moitié supérieure de l'écran pour balayer"</string>
53 | <string name="AndroidCompass_title">Mode compas</string>
54 | <string name="AndroidCompass_summary">Controle par boule de commande</string>
55 | <string name="ButtonCompassModeRightZoom_title">Facteur de zoom</string>
56 | <string name="AndroidSweep_title">Mode radar</string>
57 | <string name="AndroidSweep_summary">"Tapez l'écran ou un bouton pour contrôler"</string>
58 | <string name="SweepTime_title">Temps de balayage</string>
59 | <string name="SweepTime_summary">Temps en ms pour une rotation</string>
60 | <string name="AndroidGeneralInputSettings_title">Options de saisie</string>
61 | <string name="AutoSpeedControl_title">Controle de vitesse automatique</string>
62 | <string name="RemapXtreme_title">Remap top/bottom</string>
63 | <string name="RemapXtreme_summary">...to scroll more and zoom less</string>
64 | <string name="AndroidDoubleX_title">"Saisie tacticle uniquement dans la moitié gauche"</string>
65 | <string name="AndroidDoubleX_summary">"Agit comme si le doigt était deux fois plus a droite"</string>
66 | <string name="SlowStartTime_title">"Temps de démarage ralenti"</string>
67 | <string name="SlowStartTime_summary">"Temps avant d'achever la vitesse maximale (0=tout de suite)"</string>
68 | <string name="ReverseBoost_title">Reculer rapidement</string>
69 | <string name="ReverseBoost_summary">"Accélérer la vitesse de recul (0=vitesse normale)"</string>
70 | <string name="ColourID_title">"Schéma de Couleurs"</string>
71 | 
72 | <!--Calibration Strings-->
73 | <string name="invert">Inverser</string>
74 | <string name="calibChange">Changer…</string>
75 | </resources>
76 | 


--------------------------------------------------------------------------------
/src/dasher/CFrameRate.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |   This file is part of JDasher.
  3 | 
  4 |   JDasher is free software; you can redistribute it and/or modify
  5 |   it under the terms of the GNU General Public License as published by
  6 |   the Free Software Foundation; either version 2 of the License, or
  7 |   (at your option) any later version.
  8 | 
  9 |   JDasher is distributed in the hope that it will be useful,
 10 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 |   GNU General Public License for more details.
 13 | 
 14 |   You should have received a copy of the GNU General Public License
 15 |   along with JDasher; if not, write to the Free Software
 16 |   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 17 | 
 18 |   Copyright (C) 2006      Christopher Smowton <cs448@cam.ac.uk>
 19 | 
 20 |   JDasher is a port derived from the Dasher project; for information on
 21 |   the project see www.dasher.org.uk; for information on JDasher itself
 22 |   and related projects see www.smowton.net/chris
 23 | 
 24 | */
 25 | 
 26 | package dasher;
 27 | 
 28 | import static dasher.Elp_parameters.LP_X_LIMIT_SPEED;
 29 | import static dasher.Elp_parameters.LP_MAX_BITRATE;
 30 | import static dasher.Elp_parameters.LP_FRAMERATE;
 31 | 
 32 | /**
 33 |  * Monitors the framerate by taking records every time CountFrame
 34 |  * is called; this is used to control how far to make Dasher move per frame.
 35 |  */
 36 | public class CFrameRate extends CDasherComponent {
 37 | /*private int logCount;	
 38 | private double logFrames;*/
 39 | 	/**
 40 | 	 * (Approximate) number of frames which we should take to move
 41 | 	 * to the location under the mouse pointer; based on a decaying
 42 | 	 * average of the current framerate.
 43 | 	 */
 44 | 	private int m_iSteps;                 // the 'Steps' parameter. See djw thesis.
 45 | 	
 46 | 	/**
 47 | 	 * Number of bits which'd take us all the way to the x limit,
 48 | 	 * i.e. the point at which we are entering data at the maximum speed.
 49 | 	 */
 50 | 	private double m_dBitsAtLimX;
 51 | 	
 52 | 	/**
 53 | 	 * Number of frames elapsed
 54 | 	 */
 55 | 	private int m_iFrames=-1;
 56 | 	
 57 | 	/**
 58 | 	 * Number of frames to allow to elapse before computing average framerate over that period
 59 | 	 */
 60 | 	private int m_iSamples=2;
 61 | 	
 62 | 	/**
 63 | 	 * Time of first frame in period being measured
 64 | 	 */
 65 | 	private long m_iTime=0;
 66 | 	
 67 | 	/**
 68 | 	 * Cache of the natural log of 2
 69 | 	 */
 70 | 	private static final double LN2 = Math.log(2.0);
 71 | 
 72 | 	/** Cache of base-2-logarithm of 5, used in calculating iSteps */
 73 | 	private static final double LOG_MAXY = Math.log(CDasherModel.MAX_Y);
 74 |  
 75 | 	/**
 76 | 	 * Gets m_iSteps; see its description
 77 | 	 * 
 78 | 	 * @return m_iSteps
 79 | 	 */
 80 | 	protected int Steps() {
 81 | 		return m_iSteps;
 82 | 	} 
 83 | 	
 84 | 	/**
 85 | 	 * Creates a new framerate monitor; all initial values
 86 | 	 * are currently hard coded in.
 87 | 	 * <p>
 88 | 	 * We start with a frame rate of 32FPS. 
 89 | 	 */
 90 | 	public CFrameRate(CDasherComponent creator) {
 91 | 		super(creator);
 92 | 		HandleEvent(LP_X_LIMIT_SPEED);
 93 | 	}
 94 | 	
 95 | 	/**
 96 | 	 * Insert a new frame and recompute the frame rate, if enough
 97 | 	 * samples have been gathered.
 98 | 	 * <p>
 99 | 	 * If this would result in a Steps parameter of 0 it is set to 1.
100 | 	 * 
101 | 	 * @param Time Time at which the new frame began, as a UNIX timestamp.
102 | 	 */
103 | 	protected void CountFrame(long Time)
104 | 	{
105 | 		if (++m_iFrames == 0) {
106 | 			//First frame
107 | 			m_iTime = Time;
108 | 		}
109 | 		
110 | //		compute framerate if we have sampled enough frames
111 | 		if(m_iFrames == m_iSamples) {
112 | 			if(Time - m_iTime < 50)
113 | 				m_iSamples++;             // increase sample size
114 | 			else if(Time - m_iTime > 80)
115 | 				m_iSamples = Math.max(2, m_iSamples-1);;
116 | 			
117 | 			//Calculate the framerate and reset sampling statistics
118 | 			// for the next sampling period
119 | 			if(Time - m_iTime != 0) {
120 | 				double dFrNow = m_iFrames * 1000.0 / (Time - m_iTime);
121 | 				SetLongParameter(LP_FRAMERATE, (long)(GetLongParameter(LP_FRAMERATE) + (dFrNow*100))/2);
122 | 				m_iTime = Time;
123 | 				m_iFrames = 0;
124 | 			}
125 | 			
126 | 			/*logFrames+=m_dFr;
127 | 			if (++logCount==20) {
128 | 				System.out.println("Framerate: "+logFrames/logCount);
129 | 				logFrames = logCount=0;
130 | 			}*/
131 | 		}
132 | 		
133 | 	}
134 | 	
135 | 	/**
136 | 	 * Clears our frame count. We'll start recounting/timing on the next frame.
137 | 	 */
138 | 	public void ResetFramecount() {
139 | 		m_iFrames = -1;
140 | 	}
141 | 	
142 | 	@Override public void HandleEvent(EParameters eParam) {
143 | 		if (eParam==LP_X_LIMIT_SPEED) {
144 | 			//log (MAX_Y / (2*LP_X_LIM))
145 | 			//= log(MAX_Y) - log(2) - log(LP_X)
146 | 	      m_dBitsAtLimX = (LOG_MAXY - LN2 - Math.log(GetLongParameter(LP_X_LIMIT_SPEED)))/LN2;
147 | 	      //fallthrough
148 | 		} else if (eParam!=LP_MAX_BITRATE && eParam!=LP_FRAMERATE) return;
149 | 	    // => for either LP_MAX_BITRATE or LP_FRAMERATE, fallthrough
150 | 		
151 | 	    //Calculate m_iSteps from the decaying-average framerate, as the number
152 | 	    // of steps that, at the X limit, will cause LP_MAX_BITRATE bits to be
153 | 	    // entered per second
154 | 	    m_iSteps = Math.max(1,(int)(GetLongParameter(LP_FRAMERATE)*m_dBitsAtLimX/GetLongParameter(LP_MAX_BITRATE)));
155 | 	}
156 | }
157 | 


--------------------------------------------------------------------------------
/src/dasher/android/CalibPreference.java:
--------------------------------------------------------------------------------
  1 | package dasher.android;
  2 | 
  3 | import java.util.List;
  4 | import java.util.NoSuchElementException;
  5 | import java.util.WeakHashMap;
  6 | 
  7 | import android.content.Context;
  8 | import android.content.DialogInterface;
  9 | import android.content.SharedPreferences;
 10 | import android.hardware.Sensor;
 11 | import android.hardware.SensorEvent;
 12 | import android.hardware.SensorEventListener;
 13 | import android.hardware.SensorManager;
 14 | import android.preference.DialogPreference;
 15 | import android.util.AttributeSet;
 16 | import android.view.View;
 17 | import android.view.WindowManager;
 18 | import android.view.View.OnClickListener;
 19 | import android.widget.Button;
 20 | import android.widget.CheckBox;
 21 | import android.widget.CompoundButton;
 22 | import android.widget.TextView;
 23 | import android.widget.CompoundButton.OnCheckedChangeListener;
 24 | 
 25 | public class CalibPreference extends DialogPreference implements SensorEventListener, OnClickListener {
 26 | 	private static final String ANDROID_TILT_MAX_Y = "AndroidTiltMaxY";
 27 | 	private static final String ANDROID_TILT_MIN_Y = "AndroidTiltMinY";
 28 | 	private static final String ANDROID_TILT_MAX_X = "AndroidTiltMaxX";
 29 | 	private static final String ANDROID_TILT_MIN_X = "AndroidTiltMinX";
 30 | 	
 31 | 	private static final WeakHashMap<TiltInput,Object> TILT_DEVICES = new WeakHashMap<TiltInput, Object>();
 32 | 	public static void addTiltDevice(TiltInput ti) {TILT_DEVICES.put(ti,TILT_DEVICES);}
 33 | 	
 34 | 	private final SensorManager sm;
 35 | 	private final WindowManager wm;
 36 | 	private final Sensor s;
 37 | 
 38 | 	private float minX,maxX,minY,maxY;
 39 | 	
 40 | 	private TextView calibX,calibY;
 41 | 	private CheckBox chkInvert;
 42 | 	private Button btnChange;
 43 | 	
 44 | 	public CalibPreference(Context context, AttributeSet attrs) {
 45 | 		super(context, attrs);
 46 | 		sm = (SensorManager)getContext().getSystemService(Context.SENSOR_SERVICE);
 47 | 		List<Sensor> ss = sm.getSensorList(Sensor.TYPE_ACCELEROMETER);
 48 | 		if (ss.isEmpty()) throw new NoSuchElementException("No sensors!");
 49 | 		s=ss.get(0);
 50 | 		wm = (WindowManager)getContext().getSystemService(Context.WINDOW_SERVICE);
 51 | 	}
 52 | 	
 53 | 	@Override
 54 | 	public void onBindDialogView(View v) {
 55 | 		btnChange = (Button)v.findViewById(R.id.calibChange);
 56 | 		chkInvert = (CheckBox)v.findViewById(R.id.invert);
 57 | 		btnChange.setOnClickListener(this);
 58 | 		calibX = (TextView)v.findViewById(R.id.calibX);
 59 | 		calibY = (TextView)v.findViewById(R.id.calibY);
 60 | 		loadParams(getSharedPreferences());
 61 | 		setLabels();
 62 | 	}
 63 | 	
 64 | 	@Override public void onClick(DialogInterface dialog, int which) {
 65 | 		if (which==DialogInterface.BUTTON1) {
 66 | 			//ok clicked. Store current vals!
 67 | 			SharedPreferences.Editor e = getEditor();
 68 | 			e.putFloat(ANDROID_TILT_MIN_X, minX);
 69 | 			e.putFloat(ANDROID_TILT_MAX_X, maxX);
 70 | 			e.putFloat(ANDROID_TILT_MIN_Y, chkInvert.isChecked() ? maxY : minY);
 71 | 			e.putFloat(ANDROID_TILT_MAX_Y, chkInvert.isChecked() ? minY : maxY);
 72 | 			e.commit();
 73 | 			//labels already set
 74 | 		}
 75 | 		if (!btnChange.isEnabled()) {
 76 | 			//we started listening to sensor values...
 77 | 			sm.unregisterListener(CalibPreference.this);
 78 | 			if (which == DialogInterface.BUTTON2) {
 79 | 				btnChange.setEnabled(true);
 80 | 				loadParams(getSharedPreferences());
 81 | 				setLabels();
 82 | 				return; //don't dismiss
 83 | 			}
 84 | 		}
 85 | 		super.onClick(dialog, which);
 86 | 	}
 87 | 					
 88 | 	/** Update/reset cached minX/maxX/minY/maxY to reflect currently-stored preferences. */
 89 | 	public void loadParams(SharedPreferences sp) {
 90 | 		minX = sp.getFloat(ANDROID_TILT_MIN_X, -1.0f);
 91 | 		maxX = sp.getFloat(ANDROID_TILT_MAX_X, 1.0f);
 92 | 		minY = sp.getFloat(ANDROID_TILT_MIN_Y, 1.0f);
 93 | 		maxY = sp.getFloat(ANDROID_TILT_MAX_Y, 9.0f);
 94 | 		for (TiltInput ti : TILT_DEVICES.keySet())
 95 | 			ti.setAxes(minX,maxX,minY,maxY);
 96 | 	}
 97 | 	
 98 | 	/** Set captions of labels to reflect cached minX/maxX/minY/maxY */
 99 | 	private void setLabels() {
100 | 		boolean invert;
101 | 		if (minY > maxY) {
102 | 			float temp = minY;
103 | 			minY = maxY;
104 | 			maxY = temp;
105 | 			invert = true;
106 | 		} else invert = false;
107 | 		calibX.setText( minX + " - " + maxX);
108 | 		calibY.setText(minY + " - " + maxY);
109 | 		chkInvert.setChecked(invert);
110 | 	}
111 | 
112 | 	public void onSensorChanged(SensorEvent se) {
113 | 		float[] vals = se.values;
114 | 		if ((wm.getDefaultDisplay().getOrientation()&1)==1) {
115 | 			minX = Math.min(minX, vals[1]);
116 | 			maxX = Math.max(maxX, vals[1]);
117 | 			minY = Math.min(minY, vals[0]);
118 | 			maxY = Math.max(maxY, vals[0]);
119 | 		} else {
120 | 			minX = Math.min(minX,vals[0]);
121 | 			maxX = Math.max(maxX,vals[0]);
122 | 			minY = Math.min(minY, vals[1]);
123 | 			maxY = Math.max(maxY, vals[1]);
124 | 		}
125 | 		calibX.setText(minX+" - "+maxX);
126 | 		calibY.setText(minY+" - "+maxY);
127 | 		//no, don't update SharedPreferences
128 | 	}
129 | 	
130 | 	@Override public void onDismiss(DialogInterface v) {
131 | 		calibX = calibY = null;
132 | 		btnChange=null;
133 | 		chkInvert=null;
134 | 	}
135 | 
136 | 	public void onAccuracyChanged(Sensor arg0, int arg1) {
137 | 		// TODO Auto-generated method stub		
138 | 	}
139 | 
140 | 	public void onClick(View v) {
141 | 		if (v!=btnChange) throw new AssertionError();
142 | 		btnChange.setEnabled(false);
143 | 		minX = minY = Float.MAX_VALUE;
144 | 		maxX = maxY = Float.MIN_VALUE;
145 | 		sm.registerListener(CalibPreference.this, s, SensorManager.SENSOR_DELAY_UI);
146 | 	}
147 | }
148 | 


--------------------------------------------------------------------------------
/src/dasher/OneButtonDynamicFilter.java:
--------------------------------------------------------------------------------
  1 | package dasher;
  2 | 
  3 | import static dasher.CDasherModel.CROSS_Y;
  4 | 
  5 | public class OneButtonDynamicFilter extends CDynamicButtons {
  6 | 
  7 | 	private BounceMarker upInner, downInner, upOuter, downOuter;
  8 | 	
  9 | 	private boolean m_bDecorationChanged;
 10 | 	private double m_dNatsAtLastApply;
 11 | 	private int m_iKeyHeldId=-1;
 12 | 	/** Time at which button was first pressed (/pressed down, if we're using the release time),
 13 | 	 * or Long.MAX_VALUE if no such first press has occurred.
 14 | 	 */
 15 | 	private long m_iFirstPressTime = Long.MAX_VALUE;
 16 | 	private double m_dNatsAtFirstPress;
 17 | 	
 18 | 	/** locations of up/down guidelines (DasherY) - computed in Timer */
 19 | 	private int guideUp, guideDown;
 20 | 	private double m_dMulBoundary;
 21 | 	private boolean m_bUseUpGuide;
 22 | 	
 23 | 	public OneButtonDynamicFilter(CDasherComponent creator, CDasherInterfaceBase iface) {
 24 | 		super(creator, iface, "One-button Dynamic Mode");
 25 | 		createMarkers();
 26 | 	}
 27 | 	
 28 | 	@Override
 29 | 	public boolean DecorateView(CDasherView pView, CDasherInput pInput) {
 30 | 		int y= (int)(downInner.m_iLocn*m_dMulBoundary);
 31 | 		pView.Dasherline(-100, 2048-y, -1000, 2048-y, 1, 62);
 32 | 		y=(int)(upInner.m_iLocn * m_dMulBoundary);
 33 | 		pView.Dasherline(-100, 2048-y, -1000, 2048-y, 1, 62);
 34 | 		
 35 | 		//Moving markers...
 36 | 		if (m_iFirstPressTime!=Long.MAX_VALUE) {
 37 | 			int upCol=m_bUseUpGuide ? 240 : 61, downCol=240+61-upCol; //240 = green = active, 61 = orange/yellow = inactive
 38 | 			pView.Dasherline(-100, 2048-guideUp, -1000, 2048-guideUp, 3, upCol);
 39 | 			pView.Dasherline(-100, 2048-guideDown, -1000, 2048-guideDown, 3, downCol);
 40 | 		}
 41 | 		//Fixed markers - draw last so they go on top...
 42 | 		upInner.Draw(pView);
 43 | 		upOuter.Draw(pView);
 44 | 		downInner.Draw(pView);
 45 | 		downOuter.Draw(pView);
 46 | 		
 47 | 		if (m_bDecorationChanged) {
 48 | 			m_bDecorationChanged=false;
 49 | 			return true;
 50 | 		}
 51 | 		return false;
 52 | 	}
 53 | 
 54 | 	@Override protected void TimerImpl(long iTime, CDasherView pView, CDasherModel pModel) {
 55 | 		if (m_iFirstPressTime!=Long.MAX_VALUE) {
 56 | 			double dGrowth = Math.exp(pModel.GetNats()-m_dNatsAtFirstPress);
 57 | 			guideUp = (int)(dGrowth*upInner.m_iLocn);
 58 | 			guideDown = (int)(dGrowth*downInner.m_iLocn);
 59 | 			m_bUseUpGuide = dGrowth < m_dMulBoundary;
 60 | 			CDasherView.DRect visReg = pView.VisibleRegion();
 61 | 			if (2048-guideUp < visReg.minY && 2048-guideDown>visReg.maxY) {
 62 | 				//both markers outside y-axis (well, in compressed region)
 63 | 				// => waited too long for second press(/release)
 64 | 				reverse(iTime, pModel);
 65 | 				return; //hmmm. without scheduling anything?
 66 | 			}
 67 | 		}
 68 | 		pModel.ScheduleOneStep(0, CROSS_Y, iTime, getSpeedMul(pModel, iTime));
 69 | 	}
 70 | 	
 71 | 	@Override
 72 | 	public void HandleEvent(EParameters eParam) {
 73 | 		if (eParam==Elp_parameters.LP_ONE_BUTTON_OUTER 
 74 | 			|| eParam==Elp_parameters.LP_ONE_BUTTON_LONG_GAP
 75 | 			|| eParam==Elp_parameters.LP_ONE_BUTTON_SHORT_GAP)
 76 | 			createMarkers();
 77 | 		super.HandleEvent(eParam);
 78 | 	}
 79 | 	
 80 | 	private void createMarkers() {
 81 | 		final int outer = (int)GetLongParameter(Elp_parameters.LP_ONE_BUTTON_OUTER),
 82 | 				biggap = (int)GetLongParameter(Elp_parameters.LP_ONE_BUTTON_LONG_GAP),
 83 | 				down = outer - biggap,
 84 | 				up = outer - (int)(biggap * GetLongParameter(Elp_parameters.LP_ONE_BUTTON_SHORT_GAP))/100;
 85 | 				
 86 | 		upInner = new BounceMarker(up);
 87 | 		upOuter = new BounceMarker(outer);
 88 | 		downInner = new BounceMarker(-down);
 89 | 		downOuter = new BounceMarker(-outer);
 90 | 		m_dMulBoundary = outer/Math.sqrt(up*down);
 91 | 	}
 92 | 	
 93 | 	@Override public void KeyDown(long iTime, int iId, CDasherView pView, CDasherInput pInput, CDasherModel pModel) {
 94 | 		if (m_iKeyHeldId!=-1 && iId != m_iKeyHeldId) return; //ignore subsequent presses whilst button down
 95 | 		m_iKeyHeldId=iId;
 96 | 		if (isReversing())
 97 | 			pause();
 98 | 		else if (isPaused())
 99 | 			run(iTime, pModel);
100 | 		else if (m_iFirstPressTime==Long.MAX_VALUE) {
101 | 			m_iFirstPressTime = iTime;
102 | 			m_dNatsAtFirstPress = pModel.GetNats();
103 | 		} else
104 | 			secondPress(iTime,pModel);
105 | 	}
106 | 	
107 | 	@Override public void KeyUp(long iTime, int iId, CDasherView pView, CDasherInput pInput, CDasherModel pModel) {
108 | 		if (iId == m_iKeyHeldId) {
109 | 			m_iKeyHeldId=-1;
110 | 			if (m_iFirstPressTime!=Long.MAX_VALUE && GetBoolParameter(Ebp_parameters.BP_ONE_BUTTON_RELEASE_TIME))
111 | 				secondPress(iTime,pModel);
112 | 		}
113 | 	}
114 | 	
115 | 	protected void secondPress(long iTime, CDasherModel pModel) {
116 | 		BounceMarker inner,outer;
117 | 		if (m_bUseUpGuide) {
118 | 			inner = upInner; outer=upOuter;
119 | 		} else {
120 | 			inner = downInner; outer = downOuter;
121 | 		}
122 | 		double dCurBitrate = GetLongParameter(Elp_parameters.LP_MAX_BITRATE) /100.0;
123 | 		int iOffset = inner.GetTargetOffset(dCurBitrate*getSpeedMul(pModel, iTime), outer, iTime - m_iFirstPressTime);
124 | 		if (pModel.m_iDisplayOffset!=0) {
125 | 			iOffset -= pModel.m_iDisplayOffset;
126 | 			System.err.println("Display Offset "+pModel.m_iDisplayOffset+" reducing to "+iOffset);
127 | 		}
128 | 		double dNewNats = pModel.GetNats() - m_dNatsAtLastApply;
129 | 		upInner.NotifyOffset(iOffset, dNewNats); upOuter.NotifyOffset(iOffset, dNewNats);
130 | 		downInner.NotifyOffset(iOffset, dNewNats); downOuter.NotifyOffset(iOffset, dNewNats);
131 | 		inner.RecordPush(iOffset, pModel.GetNats() - m_dNatsAtFirstPress, dCurBitrate);
132 | 		outer.RecordPush(iOffset, 0.0, dCurBitrate);
133 | 		ApplyOffset(pModel, iOffset);
134 | 		m_dNatsAtLastApply = pModel.GetNats();
135 | 		m_iFirstPressTime = Long.MAX_VALUE;
136 | 	}
137 | 	
138 | 	@Override public void reverse(long iTime, CDasherModel pModel) {
139 | 		upInner.clearPushes(); upOuter.clearPushes(); downInner.clearPushes(); downOuter.clearPushes();
140 | 		m_iFirstPressTime = Long.MAX_VALUE;
141 | 		super.reverse(iTime, pModel);
142 | 	}
143 | 	
144 | }
145 | 


--------------------------------------------------------------------------------
/assets/alphabet.italian.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <!DOCTYPE alphabets SYSTEM "alphabet.dtd">
  3 | <?xml-stylesheet type="text/xsl" href="alphabet.xsl"?>
  4 | <alphabets>
  5 | <alphabet name="Italiano / Italian - limited punctuation">
  6 | <orientation type="LR"/>
  7 | <encoding type="Western"/>
  8 | <train>training_italian_IT.txt</train>
  9 | <paragraph d="&#182;" b="9"/>
 10 | <space d="&#x25a1;" t=" " b="9" note="box" />
 11 | <control d="Control" t="" b="8"/>
 12 | <group name="Lower case Latin letters">
 13 | <s d="a" t="a"/>
 14 | <s d="&#224;" t="&#224;"/>
 15 | <s d="b" t="b"/>
 16 | <s d="c" t="c"/>
 17 | <s d="d" t="d"/>
 18 | <s d="e" t="e"/>
 19 | <s d="&#232;" t="&#232;"/>
 20 | <s d="&#233;" t="&#233;"/>
 21 | <s d="f" t="f"/>
 22 | <s d="g" t="g"/>
 23 | <s d="h" t="h"/>
 24 | <s d="i" t="i"/>
 25 | <s d="&#236;" t="&#236;"/>
 26 | <s d="j" t="j"/>
 27 | <s d="k" t="k"/>
 28 | <s d="l" t="l"/>
 29 | <s d="m" t="m"/>
 30 | <s d="n" t="n"/>
 31 | <s d="o" t="o"/>
 32 | <s d="&#242;" t="&#242;"/>
 33 | <s d="p" t="p"/>
 34 | <s d="q" t="q"/>
 35 | <s d="r" t="r"/>
 36 | <s d="s" t="s"/>
 37 | <s d="t" t="t"/>
 38 | <s d="u" t="u"/>
 39 | <s d="&#249;" t="&#249;"/>
 40 | <s d="v" t="v"/>
 41 | <s d="w" t="w"/>
 42 | <s d="x" t="x"/>
 43 | <s d="y" t="y"/>
 44 | <s d="z" t="z"/>
 45 | </group>
 46 | <group name="Upper case Latin letters">
 47 | <s d="A" t="A"/>
 48 | <s d="&#192;" t="&#192;"/>
 49 | <s d="B" t="B"/>
 50 | <s d="C" t="C"/>
 51 | <s d="D" t="D"/>
 52 | <s d="E" t="E"/>
 53 | <s d="&#200;" t="&#200;"/>
 54 | <s d="&#201;" t="&#201;"/>
 55 | <s d="F" t="F"/>
 56 | <s d="G" t="G"/>
 57 | <s d="H" t="H"/>
 58 | <s d="I" t="I"/>
 59 | <s d="&#204;" t="&#204;"/>
 60 | <s d="J" t="J"/>
 61 | <s d="K" t="K"/>
 62 | <s d="L" t="L"/>
 63 | <s d="M" t="M"/>
 64 | <s d="N" t="N"/>
 65 | <s d="O" t="O"/>
 66 | <s d="&#210;" t="&#210;"/>
 67 | <s d="P" t="P"/>
 68 | <s d="Q" t="Q"/>
 69 | <s d="R" t="R"/>
 70 | <s d="S" t="S"/>
 71 | <s d="T" t="T"/>
 72 | <s d="U" t="U"/>
 73 | <s d="&#217;" t="&#217;"/>
 74 | <s d="V" t="V"/>
 75 | <s d="W" t="W"/>
 76 | <s d="X" t="X"/>
 77 | <s d="Y" t="Y"/>
 78 | <s d="Z" t="Z"/>
 79 | </group>
 80 | <group name="Numbers"   b="113">
 81 | <s d="1" t="1"/>
 82 | <s d="2" t="2"/>
 83 | <s d="3" t="3"/>
 84 | <s d="4" t="4"/>
 85 | <s d="5" t="5"/>
 86 | <s d="6" t="6"/>
 87 | <s d="7" t="7"/>
 88 | <s d="8" t="8"/>
 89 | <s d="9" t="9"/>
 90 | <s d="0" t="0"/>
 91 | </group>
 92 | <group name="Punctuation" b="112">
 93 | <s d="&amp;" t="&amp;"/>
 94 | <s d="&quot;" t="&quot;"/>
 95 | <s d="&apos;" t="&apos;"/>
 96 | <s d="`" t="`"/>
 97 | <s d="?" t="?"/>
 98 | <s d="!" t="!"/>
 99 | <s d="," t=","/>
100 | <s d="." t="."/>
101 | </group>
102 | </alphabet>
103 | 
104 | <alphabet name="Italiano / Italian with lots of punctuation">
105 | <orientation type="LR"/>
106 | <encoding type="Western"/>
107 | <train>training_italian_IT.txt</train>
108 | <paragraph d="&#182;" b="9"/>
109 | <space d="&#x25a1;" t=" " b="9" note="box" />
110 | <control d="Control" t="" b="8"/>
111 | <group name="Lower case Latin letters">
112 | <s d="a" t="a"/>
113 | <s d="&#224;" t="&#224;"/>
114 | <s d="b" t="b"/>
115 | <s d="c" t="c"/>
116 | <s d="d" t="d"/>
117 | <s d="e" t="e"/>
118 | <s d="&#232;" t="&#232;"/>
119 | <s d="&#233;" t="&#233;"/>
120 | <s d="f" t="f"/>
121 | <s d="g" t="g"/>
122 | <s d="h" t="h"/>
123 | <s d="i" t="i"/>
124 | <s d="&#236;" t="&#236;"/>
125 | <s d="j" t="j"/>
126 | <s d="k" t="k"/>
127 | <s d="l" t="l"/>
128 | <s d="m" t="m"/>
129 | <s d="n" t="n"/>
130 | <s d="o" t="o"/>
131 | <s d="&#242;" t="&#242;"/>
132 | <s d="p" t="p"/>
133 | <s d="q" t="q"/>
134 | <s d="r" t="r"/>
135 | <s d="s" t="s"/>
136 | <s d="t" t="t"/>
137 | <s d="u" t="u"/>
138 | <s d="&#249;" t="&#249;"/>
139 | <s d="v" t="v"/>
140 | <s d="w" t="w"/>
141 | <s d="x" t="x"/>
142 | <s d="y" t="y"/>
143 | <s d="z" t="z"/>
144 | </group>
145 | <group name="Upper case Latin letters"   b="111">
146 | <s d="A" t="A"/>
147 | <s d="&#192;" t="&#192;"/>
148 | <s d="B" t="B"/>
149 | <s d="C" t="C"/>
150 | <s d="D" t="D"/>
151 | <s d="E" t="E"/>
152 | <s d="&#200;" t="&#200;"/>
153 | <s d="&#201;" t="&#201;"/>
154 | <s d="F" t="F"/>
155 | <s d="G" t="G"/>
156 | <s d="H" t="H"/>
157 | <s d="I" t="I"/>
158 | <s d="&#204;" t="&#204;"/>
159 | <s d="J" t="J"/>
160 | <s d="K" t="K"/>
161 | <s d="L" t="L"/>
162 | <s d="M" t="M"/>
163 | <s d="N" t="N"/>
164 | <s d="O" t="O"/>
165 | <s d="&#210;" t="&#210;"/>
166 | <s d="P" t="P"/>
167 | <s d="Q" t="Q"/>
168 | <s d="R" t="R"/>
169 | <s d="S" t="S"/>
170 | <s d="T" t="T"/>
171 | <s d="U" t="U"/>
172 | <s d="&#217;" t="&#217;"/>
173 | <s d="V" t="V"/>
174 | <s d="W" t="W"/>
175 | <s d="X" t="X"/>
176 | <s d="Y" t="Y"/>
177 | <s d="Z" t="Z"/>
178 | </group>
179 | 
180 | <group name="Numbers"  b="113">
181 | <s d="1" t="1"/>
182 | <s d="2" t="2"/>
183 | <s d="3" t="3"/>
184 | <s d="4" t="4"/>
185 | <s d="5" t="5"/>
186 | <s d="6" t="6"/>
187 | <s d="7" t="7"/>
188 | <s d="8" t="8"/>
189 | <s d="9" t="9"/>
190 | <s d="0" t="0"/>
191 | </group>
192 | <group name="Punctuation"  b="112">
193 | <s d="%" t="%"/>
194 | <s d="*" t="*"/>
195 | <s d="+" t="+"/>
196 | <s d="=" t="="/>
197 | <s d="/" t="/"/>
198 | <s d="#" t="#"/>
199 | <s d="&#8364;" t="&#8364;" b="34" note="euro" />
200 | <s d="$" t="$"/>
201 | <s d="|" t="|"/>
202 | <s d="\" t="\"/>
203 | <s d="~" t="~"/>
204 | <s d="^" t="^"/>
205 | <s d="_" t="_"/>
206 | <s d="&amp;" t="&amp;"/>
207 | <s d="@" t="@"/>
208 | <s d="[" t="["/>
209 | <s d="]" t="]"/>
210 | <s d="{" t="{"/>
211 | <s d="}" t="}"/>
212 | <s d="&lt;" t="&lt;"/>
213 | <s d="&gt;" t="&gt;"/>
214 | <s d="(" t="("/>
215 | <s d=")" t=")"/>
216 | <s d="&#x2039;" t="&#x2039;" note="French left single quotation mark" />
217 | <s d="&#x203A;" t="&#x203A;" note="French right single quotation mark" />
218 | <s d="&#x00AB;" t="&#x00AB;" note="French left double quotation mark" />
219 | <s d="&#x00BB;" t="&#x00BB;" note="French right double quotation mark" />
220 | <s d="&quot;" t="&quot;"/>
221 | <s d="`" t="`"/>
222 | <s d="&apos;" t="&apos;"/>
223 | <s d="-" t="-"/>
224 | <s d=":" t=":"/>
225 | <s d=";" t=";"/>
226 | <s d="?" t="?"/>
227 | <s d="!" t="!"/>
228 | <s d="," t=","/>
229 | <s d="." t="."/>
230 | </group>
231 | </alphabet>
232 | </alphabets>
233 | 
234 | 
235 | 


--------------------------------------------------------------------------------
/src/dasher/Elp_parameters.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |   This file is part of JDasher.
 3 | 
 4 |   JDasher is free software; you can redistribute it and/or modify
 5 |   it under the terms of the GNU General Public License as published by
 6 |   the Free Software Foundation; either version 2 of the License, or
 7 |   (at your option) any later version.
 8 | 
 9 |   JDasher is distributed in the hope that it will be useful,
10 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |   GNU General Public License for more details.
13 | 
14 |   You should have received a copy of the GNU General Public License
15 |   along with JDasher; if not, write to the Free Software
16 |   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17 | 
18 |   Copyright (C) 2006      Christopher Smowton <cs448@cam.ac.uk>
19 | 
20 |   JDasher is a port derived from the Dasher project; for information on
21 |   the project see www.dasher.org.uk; for information on JDasher itself
22 |   and related projects see www.smowton.net/chris
23 | 
24 | */
25 | 
26 | package dasher;
27 | 
28 | /**
29 |  * Enumeration of possible integer parameter references. See
30 |  * CParamTables for a list and definitions.
31 |  */
32 | public enum Elp_parameters implements EParameters {
33 | 	  LP_MAX_BITRATE("MaxBitRateTimes100", 80, "Max Bit Rate Times 100"),
34 | 	  LP_FRAMERATE("FrameRate", 3200, "Decaying average of last known frame rates, *100"),
35 | 	  LP_VIEW_ID("ViewID", 1, "ViewID"),
36 | 	  LP_LANGUAGE_MODEL_ID("LanguageModelID", 0, "LanguageModelID"),
37 | 	  LP_DASHER_FONTSIZE("DasherFontSize", 1, "DasherFontSize"),
38 | 	  LP_UNIFORM("UniformTimes1000", 50, "UniformTimes1000"),
39 | 	  LP_MOUSEPOSDIST("MousePositionBoxDistance", 50, "MousePositionBoxDistance"),
40 | 	  //LP_STOP_IDLETIME("StopIdleTime", 1000, "StopIdleTime" ),
41 | 	  LP_LM_MAX_ORDER("LMMaxOrder", 5, "LMMaxOrder"),
42 | 	  LP_LM_UPDATE_EXCLUSION("LMUpdateExclusion", 1, "LMUpdateExclusion"),
43 | 	  LP_LM_ALPHA("LMAlpha", 49, "LMAlpha"),
44 | 	  LP_LM_BETA("LMBeta", 77, "LMBeta"),
45 | 	  //LP_LM_MIXTURE("LMMixture", 50, "LMMixture"),
46 | 	  LP_LINE_WIDTH("LineWidth", 1, "Width to draw crosshair and mouse line"),
47 | 	  //LP_LM_WORD_ALPHA("WordAlpha", 50, "Alpha value for word-based model"),
48 | 	  LP_USER_LOG_LEVEL_MASK("UserLogLevelMask", 0, "Controls level of user logging, 0 = none, 1 = short, 2 = detailed, 3 = both"),
49 | 	  LP_ZOOMSTEPS("Zoomsteps", 32, "Frames for zoom"),
50 | 	  LP_B("ButtonMenuBoxes", 4, "Number of boxes for button menu mode"),
51 | 	  LP_S("ButtonMenuSafety", 25, "Safety parameter for button mode, in percent."),
52 | 	  LP_R("ButtonModeNonuniformity", 0, "Button mode box non-uniformity"),
53 | 	  //LP_Z("ButtonMenuBackwardsBox", 1, "Number of back-up boxes for button menu mode"),
54 | 	  LP_RIGHTZOOM("ButtonCompassModeRightZoom", 5120, "Zoomfactor (*1024) for compass mode"),
55 | 	  LP_AUTOSPEED_SENSITIVITY("AutospeedSensitivity", 100, "Sensitivity of automatic speed control (percent)"),
56 | 	  /*LP_SOCKET_PORT("SocketPort", 20320, "UDP/TCP socket to use for network socket input"),
57 | 	  LP_SOCKET_INPUT_X_MIN("SocketInputXMinTimes1000", 0, "Bottom of range of X values expected from network input"),
58 | 	  LP_SOCKET_INPUT_X_MAX("SocketInputXMaxTimes1000", 1000, "Top of range of X values expected from network input"),
59 | 	  LP_SOCKET_INPUT_Y_MIN("SocketInputYMinTimes1000", 0, "Bottom of range of Y values expected from network input"),
60 | 	  LP_SOCKET_INPUT_Y_MAX("SocketInputYMaxTimes1000", 1000, "Top of range of Y values expected from network input"),*/
61 | 	  //LP_INPUT_FILTER("InputFilterID", 3, "Module ID of input filter"),
62 | 	  LP_CIRCLE_PERCENT("CirclePercent", 10, "Percentage of nominal vertical range to use for radius of start circle"),
63 | 	  LP_TWO_BUTTON_OFFSET("TwoButtonOffset", 1024, "Offset for two button dynamic mode"),
64 | 	  LP_TAP_TIME("TapTime", 100, "Max time for tap in Stylus Mode"),
65 | 	  LP_NON_LINEAR_X("NonLinearX", 8, "Nonlinear compression of X-axis (0 = none, higher = more extreme)"),
66 | 	  LP_DASHER_MARGIN("MarginWidth", 400, "Width of RHS margin (in Dasher co-ords)"),
67 | 	  LP_NODE_BUDGET("NodeBudget", 1200, "Target number of node objects"),
68 | 	  LP_BUTTON_SCAN_TIME("ButtonScanTime", 0, "Scanning interval in button mode (0 = don't scan)"),
69 | 	  LP_MIN_NODE_SIZE_TEXT("MinNodeSizeForText",40, "Minimum size for box to have text (4096=whole screen)"),
70 | 	  LP_SLOW_START_TIME("SlowStartTime", 1000, "Time in ms over which slow start is applied"),
71 | 	  LP_SWEEP_TIME("SweepTime", 3000, "Time in ms to sweep top-to-bottom"),
72 | 	  LP_X_LIMIT_SPEED("XLimitSpeed", 800, "X Co-ordinate at which maximum speed is reached (<2048=xhair)"),
73 | 	  LP_MAX_ZOOM("MaxZoom", 20, "Max factor to zoom by in stylus/click mode"),
74 | 	  LP_TARGET_OFFSET("TargetOffset", 0, "Offset target from actual mouse/touch/gaze position"),
75 | 	  /** Can we combine this with LP_TAP_TIME? Think we want this to be much longer...?*/
76 | 	  LP_HOLD_TIME("LongPressTime", 800,"Time/ms for long press (=reverse) in dynamic button mode"),
77 | 	  LP_DOUBLE_CLICK_TIME("DoublePressTime", 150,"Time/ms for double click (=reverse) in 2B-dynamic mode"),
78 | 	  LP_ONE_BUTTON_SHORT_GAP("OneButtonShortGap", 40, "Distance between up markers as % of long gap in 1B-dynamic mode"),
79 | 	  LP_ONE_BUTTON_LONG_GAP("OneButtonLongGap", 512, "Distance between down markers (long gap) in 1B-dynamic mode"),
80 | 	  LP_ONE_BUTTON_OUTER("OneButtonOuter", 1920, "Distance to up&down outer markers in 1B-dynamic mode");
81 | 		  
82 | 		  private Elp_parameters(String rName, long def, String hr) {
83 | 				humanReadable = hr;
84 | 				defaultVal = def;
85 | 				regName = rName;
86 | 				BY_NAME.put(regName,this);
87 | 			}
88 | 			
89 | 		  private static final int LP_OFFSET = Ebp_parameters.values().length;
90 | 		  public int key() {return ordinal()+LP_OFFSET;}
91 | 			public String regName() {return regName;}
92 | 			public void reset(CSettingsStore ss) {ss.SetLongParameter(this, defaultVal);}
93 | 			
94 | 			private final String regName;
95 | 			
96 | 			public final long defaultVal;
97 | 			final String humanReadable;
98 | }


--------------------------------------------------------------------------------
/src/dasher/android/SeekBarPreference.java:
--------------------------------------------------------------------------------
  1 | /* The following code was written by Matthew Wiggins 
  2 |  * and is released under the APACHE 2.0 license 
  3 |  * 
  4 |  * http://www.apache.org/licenses/LICENSE-2.0
  5 |  */
  6 | package dasher.android;
  7 | 
  8 | import dasher.EParameters;
  9 | import dasher.Elp_parameters;
 10 | import android.content.Context;
 11 | import android.content.DialogInterface;
 12 | import android.content.SharedPreferences;
 13 | import android.util.AttributeSet;
 14 | import android.view.Gravity;
 15 | import android.view.View;
 16 | import android.preference.DialogPreference;
 17 | import android.preference.PreferenceManager;
 18 | import android.widget.Button;
 19 | import android.widget.SeekBar;
 20 | import android.widget.TextView;
 21 | import android.widget.LinearLayout;
 22 | 
 23 | 
 24 | public class SeekBarPreference extends DialogPreference implements SeekBar.OnSeekBarChangeListener, View.OnClickListener, SharedPreferences.OnSharedPreferenceChangeListener
 25 | {
 26 |   private static final String androidns="http://schemas.android.com/apk/res/android";
 27 | 
 28 |   private SeekBar mSeekBar;
 29 |   private TextView mValueText;
 30 |   
 31 |   private final String mSuffix, mTitle;
 32 |   private final long lDef;
 33 |   private int lMin, lMax, lDiv;
 34 |   private long lValue;
 35 | 
 36 |   public SeekBarPreference(Context context, AttributeSet attrs) { 
 37 |     super(context,attrs); 
 38 |     String temp=attrs.getAttributeValue(androidns, "title");
 39 |     if (temp.startsWith("@")) {
 40 |     	try {
 41 |     		temp = getContext().getResources().getString(Integer.parseInt(temp.substring(1)));
 42 |     	} catch (NumberFormatException e) {
 43 |     		//hmm. any ideas?
 44 |     	}
 45 |     }
 46 |     mTitle=temp;
 47 |     if (!isPersistent() || !hasKey()) throw new IllegalArgumentException("Non-persistent attribute "+mTitle);
 48 |     mSuffix = attrs.getAttributeValue(androidns,"text");
 49 |     Elp_parameters param = (Elp_parameters)EParameters.BY_NAME.get(getKey());
 50 |     lDef = (param==null) ? attrs.getAttributeIntValue(androidns,"defaultValue", 0) : param.defaultVal;
 51 |     lMax = attrs.getAttributeIntValue(androidns,"max", 100);
 52 |     lMin = attrs.getAttributeIntValue(null, "min", 0);
 53 |     lDiv = attrs.getAttributeIntValue(null, "divisor", 1);
 54 |     //Handily, SharedPreferences already keeps its listeners in a WeakHashMap,
 55 |     // so registering as such does not prevent this from being GC'd; and when this
 56 |     // is GC'd, the WeakHashMap'll automatically deregister us.
 57 |     PreferenceManager.getDefaultSharedPreferences(context)
 58 |     	.registerOnSharedPreferenceChangeListener(this);
 59 |   }
 60 |   
 61 |   public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
 62 | 	if (key.equals(getKey())) {
 63 | 		onSetInitialValue(true, null); //true = "get from sharedpreferences"
 64 | 		updateTitle();
 65 | 	}
 66 |   }
 67 | 
 68 |   @Override public void onAttachedToHierarchy(PreferenceManager pm) {
 69 | 	  super.onAttachedToHierarchy(pm);
 70 | 	  lValue = getPersistedLong(lDef);
 71 | 	  updateTitle();
 72 |   }
 73 |   
 74 |   @Override 
 75 |   protected View onCreateDialogView() {
 76 |     LinearLayout layout = new LinearLayout(getContext());
 77 |     layout.setOrientation(LinearLayout.VERTICAL);
 78 |     layout.setPadding(6,6,6,6);
 79 | 
 80 |     mValueText = new TextView(getContext());
 81 |     mValueText.setGravity(Gravity.CENTER_HORIZONTAL);
 82 |     mValueText.setTextSize(32);
 83 |     
 84 |     mSeekBar = new SeekBar(getContext());
 85 |     mSeekBar.setOnSeekBarChangeListener(this);
 86 |     layout.addView(mSeekBar, new LinearLayout.LayoutParams(LinearLayout.LayoutParams.FILL_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT));
 87 | 
 88 |     mSeekBar.setMax(lMax-lMin);
 89 |     //onBindDialogView sets current value (=>calls onProgressChanged =>sets mValueText)
 90 |     
 91 |     layout.addView(mValueText, new LinearLayout.LayoutParams(
 92 |             LinearLayout.LayoutParams.FILL_PARENT, 
 93 |             LinearLayout.LayoutParams.WRAP_CONTENT));
 94 |     Button b = new Button(getContext());
 95 |     b.setText(R.string.Reset);
 96 |     b.setOnClickListener(this);
 97 |     //hope a click on b comes through to onClick(DialogInterface, int) - but with what int?!
 98 |     layout.addView(b);
 99 |     return layout;
100 |   }
101 |   
102 |   @Override 
103 |   protected void onBindDialogView(View v) {
104 |     super.onBindDialogView(v);
105 |     mSeekBar.setProgress((int)(lValue-lMin));
106 |   }
107 |   
108 |   @Override protected void onSetInitialValue(boolean restore, Object defaultValue) {
109 |     super.onSetInitialValue(restore, defaultValue);
110 |     if (restore)  //"use settings store" - defaultValue==null !
111 |       lValue = getPersistedLong(lDef);
112 |     else  //"don't use settings store" - there's a default here instead
113 |       lValue = ((Number)defaultValue).longValue();
114 |   }
115 |   
116 |   public void onProgressChanged(SeekBar seek, int value, boolean fromTouch) {
117 |     if (fromTouch) {
118 |       lValue = value+lMin;
119 |       callChangeListener(new Integer(value));
120 |     }
121 |     String t=valueText();
122 |     mValueText.setText(mSuffix==null ? t : t.concat(mSuffix));
123 |   }
124 |   
125 |   private String valueText() {
126 | 	  return (lDiv==1) ? String.valueOf(lValue) : String.valueOf(lValue/(double)lDiv);
127 |   }
128 |   
129 |   private void updateTitle() {
130 | 	  setTitle(mTitle+": "+valueText());
131 |   }
132 |   @Override public void onClick(DialogInterface dialog, int button) {
133 | 	  if (button==DialogInterface.BUTTON_POSITIVE) {
134 | 		  //ok button. Store result of sliding, and set the title text
135 | 		  persistLong(lValue);
136 | 		  updateTitle();
137 | 	  } else if (button==DialogInterface.BUTTON_NEGATIVE){
138 | 		  //cancel button. Restore old value, leave title text alone.
139 | 		  lValue = getPersistedLong(lDef);
140 | 	  } else {
141 | 		  android.util.Log.d("DasherPrefs","Unknown button "+button+" pressed for "+getKey());
142 | 	  }
143 |   }
144 |   
145 |   public void onClick(View v) {
146 | 	//reset button
147 | 	lValue = ((Elp_parameters)EParameters.BY_NAME.get(getKey())).defaultVal;
148 | 	mSeekBar.setProgress((int)(lValue-lMin));
149 |   }
150 | 
151 |   public void onStartTrackingTouch(SeekBar seekBar) {}
152 | 
153 |   public void onStopTrackingTouch(SeekBar seekBar) {}
154 | 
155 | }


--------------------------------------------------------------------------------
/src/dasher/applet/JDasherEdit.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |   This file is part of JDasher.
  3 | 
  4 |   JDasher is free software; you can redistribute it and/or modify
  5 |   it under the terms of the GNU General Public License as published by
  6 |   the Free Software Foundation; either version 2 of the License, or
  7 |   (at your option) any later version.
  8 | 
  9 |   JDasher is distributed in the hope that it will be useful,
 10 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 |   GNU General Public License for more details.
 13 | 
 14 |   You should have received a copy of the GNU General Public License
 15 |   along with JDasher; if not, write to the Free Software
 16 |   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 17 | 
 18 |   Copyright (C) 2006      Christopher Smowton <cs448@cam.ac.uk>
 19 | 
 20 |   JDasher is a port derived from the Dasher project; for information on
 21 |   the project see www.dasher.org.uk; for information on JDasher itself
 22 |   and related projects see www.smowton.net/chris
 23 | 
 24 | */
 25 | 
 26 | package dasher.applet;
 27 | 
 28 | import java.util.ListIterator;
 29 | import java.util.NoSuchElementException;
 30 | 
 31 | import javax.swing.event.CaretEvent;
 32 | import javax.swing.event.CaretListener;
 33 | import javax.swing.text.BadLocationException;
 34 | import javax.swing.JTextArea;
 35 | 
 36 | import dasher.CDasherInterfaceBase;
 37 | import dasher.EditableDocument;
 38 | 
 39 | /**
 40 |  * JDasherEdit is essentially an ordinary JTextArea with methods to deal with
 41 |  * outputting/deleting text for Dasher and which listens to caret updates
 42 |  * from Swing to rebuild the Dasher tree accordingly.
 43 |  */
 44 | public class JDasherEdit extends JTextArea implements CaretListener, EditableDocument {
 45 | 	
 46 | 	/**
 47 | 	 * Interface which this EditBox will control when text is
 48 | 	 * entered, typically by calling InvalidateContext if the
 49 | 	 * user manually edits the text.
 50 | 	 */
 51 | 	private dasher.CDasherInterfaceBase m_Interface;
 52 | 	
 53 | 	/**
 54 | 	 * Creates a new EditBox with a given width and height in characters,
 55 | 	 * which will inform the given interface if the cursor is moved.
 56 | 	 * 
 57 | 	 * @param rows EditBox width in characters
 58 | 	 * @param cols EditBox height in characters
 59 | 	 * @param intf Interface to control; must not be null
 60 | 	 * @throws IllegalArgumentException if <code>intf</code> is null.
 61 | 	 */
 62 | 	public JDasherEdit(int rows, int cols, dasher.CDasherInterfaceBase intf) {
 63 | 		super(rows, cols);
 64 | 		m_Interface = intf;
 65 | 		
 66 | 		this.addCaretListener(this);
 67 | 	}
 68 | 	
 69 | 	/* Handle output of text by the using entering a new DasherNode.
 70 | 	 * If text is added whilst there is a selection, we delete it
 71 | 	 * just as if the user had typed over the selection.
 72 | 	 */
 73 | 	public void outputText(String ch, int offset) {
 74 | 		if(this.getSelectedText()!=null) {
 75 | 			this.replaceSelection("");
 76 | 		}
 77 | 		int oldCaret = this.getCaretPosition();
 78 | 		this.insert(ch, oldCaret);
 79 | 		this.setCaretPosition(oldCaret + 1);
 80 | 	}
 81 | 	
 82 | 	/** Handle deletion of text (from reversing) by removing a character.
 83 | 	 * Deleting whilst something is selected removes both the selection and its
 84 | 	 * preceding character.
 85 | 	 */
 86 | 	public void deleteText(String ch, int offset) {
 87 | 		if(!this.getText().equals("")) {
 88 | 
 89 | 			if(this.getSelectedText()!=null) {
 90 | 				this.replaceSelection("");
 91 | 			}
 92 | 			int oldCaret = this.getCaretPosition();
 93 | 			this.replaceRange("", oldCaret - ch.length(), oldCaret);
 94 | 			setCaretPosition(oldCaret - ch.length());
 95 | 		}
 96 | 	}
 97 | 	
 98 | 	@Override
 99 | 	public void moveCursor(int pos) {
100 | 		setCaretPosition(pos+1);
101 | 	}
102 | 	
103 | 	/** Gets the context, i.e. characters in the editbox,
104 | 	 * starting at the specified position
105 | 	 * @param StartPosition 0-based index of the character AFTER which the cursor is placed
106 | 	 * @return
107 | 	 */
108 | 	ListIterator<Character> getContext(final int StartPosition) {
109 | 		return new ListIterator<Character>() {
110 | 			/**0-based index of the character after which the cursor is*/
111 | 			int idx=StartPosition;
112 | 			/** The character after the cursor*/
113 | 			public Character next() {
114 | 				//if cursor is after char 0 (the first char), we should return char 1
115 | 				try {return getText(++idx,1).charAt(0);}
116 | 				catch (BadLocationException e) {idx--;
117 | 					throw new NoSuchElementException();
118 | 				}
119 | 			}
120 | 			public boolean hasNext() {return idx<getText().length()-1;}
121 | 			public int nextIndex() {return idx+1;}
122 | 			public Character previous() {
123 | 				//if cursor is after char 0 (the first char), we should return that
124 | 				try {return getText(idx--,1).charAt(0);}
125 | 				catch (BadLocationException e) {idx++;
126 | 					throw new NoSuchElementException();
127 | 				}
128 | 			}
129 | 			public boolean hasPrevious() {return idx>=0;}
130 | 			public int previousIndex() {return idx;}
131 | 			public void add(Character o) {throw new UnsupportedOperationException();}
132 | 			public void remove() {throw new UnsupportedOperationException();}
133 | 			public void set(Character o) {throw new UnsupportedOperationException();}
134 | 		};
135 | 	}			
136 | 		
137 | 
138 | 	/**
139 | 	 * Called by Java's event handling subsystem when the user moves
140 | 	 * the caret, either by typing or clicking.
141 | 	 * <p>
142 | 	 * We call through to {@link CDasherInterfaceBase#setOffset} to update the model
143 | 	 * if the new cursor location is different from where the model thinks it should be.
144 | 	 * (This is the case if the user has moved the cursor, but if the call to caretUpdate
145 | 	 * is in response to Dasher entering text itself, the model will already be in the
146 | 	 * right position.)
147 | 	 */
148 | 	public void caretUpdate(CaretEvent e) {
149 | 		
150 | 		m_Interface.setOffset(getSelectionStart()-1, false);
151 | 		
152 | 	}
153 | 
154 | 	@Override
155 | 	public Character getCharAt(int pos) {
156 | 		String s = getText();
157 | 		if (pos>=s.length()) return null;
158 | 		return s.charAt(pos);
159 | 	}
160 | }
161 | 


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