Valid XHTML 1.0 Transitional

DictionaryForMIDs SW Design


DictionaryForMIDs uses a 3-layer Architecture Model:






"HMI (Human Machine Interface) layer": This layer contains the user interface, i.e. menus, display components etc.

There is a separate implementation of the user interface for Java ME, Java SE, Android and HTML5.



"Business Service Layer": Provides the translation functionality (also called "Translation Layer")



"Data Access Layer": Provides the services to access the dictionary data.


Interface to the Translation Layer

The interface from the HMI layer to the translation layer is provided by the class TranslationExecution.


DictionaryForMIDs uses the class Util as general purpose class for logging and other useful functions. At the start of the application a Util object needs to be created and set with Util.setUtil. For example:

UtilWin utilObj = new UtilWin();  // for Java SE windowing systems (Unix, Windows, etc.)

Loading a dictionary

public static DictionaryDataFile loadDictionary(DfMInputStreamAccess dictionaryDataFileISAccessParam)

A dictionary is loaded with the method TranslationExecution.loadDictionary. This method returns that dictionary object that is used in subsequent translations.

The parameter dictionaryDataFileISAccessParam is the dataaccess layer definition. The Translation Layer uses dictionaryDataFileISAccessParam to access files via the dictionaryDataFileISAccessParam.

dictionaryDataFileISAccessParam is an operating system specific parameter, because operating systems offer different ways to access files. DictionaryForMIDs implements plenty of dataaccesses:

For more information on this see the section Implementing file access for new platforms


Executing a translation

public static void executeTranslation(TranslationParameters translationParametersObj)

TranslationParameters is a class that holds all parameters for the translation:

public TranslationParameters(DictionaryDataFile dictionary,
                             String             toBeTranslatedWordTextInput,
                             boolean[]          inputLanguages,
                             boolean[]          outputLanguages,
                             boolean            executeInBackground,
                             int                maxHits,
                             int                durationForCancelSearch)




Dictionary that shall be translated. This object was returned from TranslationExecution.loadDictionary


word/expression that shall be translated


Array with one boolean entry per language. For each language a 'true' indicates to search for this language.

For example, dictionary with 2 languages:

inputLanguages[0] = true

inputLanguages[1] = false

-> the toBeTranslatedWordTextInput will be searched in the first language only (language1 in


As for inputLanguages: array with one boolean per language. True indicates to include the translation for this language.

Example with 2 languages:

outputLanguages[0] = false

outputLanguages[1] = true

-> the translation will be taken from the second language (language2 in


True, if the the translation shall be done in the background.

If this parameter is true, then executeTranslation will then return immediately and TranslationExecutionCallback.newTranslationResult  (see below) will be called as soon as the translation is complete.

If this parameter is false then executeTranslation will return after TranslationExecutionCallback.newTranslationResult has been called.


Maximum number of hits for the translation. If this maximum number is reached, then the search will end.


Maximum duration for the search. If the search takes more time, then the search will end.

The result of the translation is provided via a callback interface:

public interface TranslationExecutionCallback {
	void deletePreviousTranslationResult();
	void newTranslationResult(TranslationResult resultOfTranslation);

deletePreviousTranslationResult is called by executeTranslation when the previous translation result should be deleted from the user interface. The new result is passed to the user interface with the method newTranslationResult. For a description of the class TranslationResult, see the file

Before calling executeTranslation, the HMI needs to call Translation.setTranslationExecutionCallback with an object that provides the TranslationExecutionCallback interface:

public static void setTranslationExecutionCallback(TranslationExecutionCallback translationResultHMIObjParam)

Batch Translation

public static void executeTranslationBatch(TranslationParametersBatch translationParametersBatchObj)

The parameter translationParametersBatchObj contains several objects of type TranslationParameters (for details see the source code of class TranslationParametersBatch).

executeTranslationBatch is be used to search over several dictionaries. Each of the dictionaries, respectively translations as defined in the TranslationParameters-objects, is executed in an own thread. That means that the search is executed in parallel.

When the first translation completes, then deletePreviousTranslationResult is called. Then newTranslationResult is called upon completion of each translation thread. The calls to deletePreviousTranslationResult and newTranslationResult are synchronized, this means that only one call to these  methods is active at a time.


A dictionary's properties (class DictionaryDataFile)

TranslationExecution.loadDictionary returns a dictionary object with the type DictionaryDataFile. DictionaryDataFile holds all properties from the file

You will need to access the data structure DictionaryDataFile.supportedLanguages. This data structure stores information about the dictionary. Here some examples on how to use the data structure:


Using the ContentParser to parse the 'content syntax'

The texts that are returned by the translation layer via the callback TranslationExecutionCallback.newTranslationResult contain the content syntax as described in the section Content Declarations. In order to parse the content syntax and generate an output that can be conveniently displayed on the HMI, the class de.kugihan.dictionaryformids.hmi_common.content.ContentParser can be used with the method determineItemsFromContent:

public StringColourItemText determineItemsFromContent(TextOfLanguage contentText, 
                                                      boolean changeInputAndOutputContent,
                                                      boolean isInput) 




The text that is returned within the resultOfTranslation object in the callback to TranslationExecutionCallback.newTranslationResult.



Set the parameter changeInputAndOutputContent to true for dictionaries where no content definitions for the input and output language texts are provided. Otherwise set the parameter changeInputAndOutputContent to false (the parameter isInput is ignored if changeInputAndOutputContent is set to false).

If changeInputAndOutputContent is set to true then the ContentParser applies the following; explained with an example for a dictionary "English to Chinese":

The user enters an English search expression in order to get the Chinese translation. The contentText for the English part belongs to the user input; here isInput must be set to true and the ContentParser will automatically apply the predefined style "InputLanguage".

The contentText for the Chinese translation is the output; here isInput must be set to false and the ContentParser will automatically apply the predefined style "OutputLanguage".

As general rule, set isInput to true if contentText belongs to the language where the user did input his search expression. Set isInput to false otherwise.

The returned object of type StringColourItemText contains a Vector of StringColourItemTextPart objects. Each of these StringColourItemTextPart objects contains a piece of text along with display attributes such as colour and style of the text (for details, please see the class StringColourItemTextPart).
In order to display the text on the HMI, the StringColourItemTextPart objects must be read one after the other with the method
StringColourItemText.getItemTextPart, starting with index 0. Each of the read StringColourItemTextPart objects must be 'printed' in this sequence on the HMI, according to the colour/style/etc. information. Do not insert a space or newline between the text of two StringColourItemTextPart objects.


Implementing file access for new platforms

At 'the bottom' of the Data Access Layer (see Architecture Layers) the access to the files is done. Files are accessed as InputStreams via the class DfMInputStreamAccess in the package de.kugihan.dictionaryformids.dataaccess.fileaccess (DfMInputStreamAccess is in the DictionaryForMIDs path of SVN). DfMInputStreamAccess is an abstract class that needs to be implemented for each Java platform. There are already implementations for several platforms (Java ME JSR-75, Java SE, Android) and file types (e.g. Jar files), see also above the List of DfMInputStreamAccess classes.

The implementation is done by inheriting from DfMInputStreamAccess and implementing the methods getInputStream and fileExists. As an example, you can look at the implementation of  ResourceDfMInputStreamAccess which implements the file access for the Java ME Resources (in the Java ME path of SVN). You can see that adding file access support for a new Java platform is done with only a few lines of code.

Once there is an implementation of DfMInputStreamAccess:  you need to create an object of that class and pass it to TranslationExecution.loadDictionary. The Translation Layer does then use this object to access all dictionary data files. As an example you can look at the startup code of Java ME in the class DictionaryForMIDs (just search for loadDictionary).


Diverse topics


Icons are stored in the JAR file in the following directories:

Directory Content
icons/Application Contains the application icon DictionaryForMIDs.png. This icon is provided only with one size.

icons/UIDisplayTextItems/big/  20px
Contains the icons for the UIDisplayTextItems as defined in DictionaryForMIDs.languages (respectively in the file which is generated by the tool LanguageUIGeneration).

The following UIDisplayTextItems can have an icon:
- ChoiceGroup (subgroup 'small')
- Alert (subgroup 'big')
For these UIDisplayTextItems a PNG-file with the same ID as the UIDisplayTextItem is put in these directories.

There is a subgroup 'small' and a subgroup 'big'. Within the subgroups there are directories for the different pixel sizes. For example in the directory small/16px there are the icons with a resolution of 16x16 pixels.

Note that the icon for a UIDisplayTextItem must be provided in each pixel size for the subgroup. Example: in each of the 5 directories small/12px, small/16px ... small/32px there must be the file SettingsColouredItems.png.

At runtime DictionaryForMIDs queries the device to determine the pixel size that fits best and then loads the icons from the corresponding directory.

Icon designer wanted !! We need to have icons for the following ChoiceGroup items in the Settings dialogue. Currently only the language flags in the Settings dialogue are implemented. If you have any questions concerning the creation of the icons please contact us - we will be glad to help !
Search options:

UIDisplayTextItems.SettingsFindMatchWordOnly UIDisplayTextItems.SettingsEndWildcardAnySeriesOfCharacter

Display options:
UIDisplayTextItems.SettingsShowTranslationList UIDisplayTextItems.SettingsColouredItems UIDisplayTextItems.SettingsShowStatistics UIDisplayTextItems.SettingsUseBitmapFont

Font size
UIDisplayTextItems.SettingsFontDeviceDefault UIDisplayTextItems.SettingsFontSmall


We need to have the icons in the following pixel sizes: 12x12, 16x16, 20x20, 24x24, 32x32.

Besides: with MIDP 3.0 also the menu commands can have an icon - so finally we will need to have icons for the menu commands also.

Display text items for different languages / LanguageUIGeneration tool

All display texts (such as labels, menu entries, etc.) are translated to different languages. In the source code, for display texts , always elements of the class UIDisplayTextItem are used. You need the LanguageUIGeneration tool when you add any display text (UIDisplayTextItem). For a description of the use of UIDisplayTextItem and the LanguageUIGeneration tool, see here.

Specific information for Web App

For the Web App there is additional information on the Web App development page.


Source Code

You can download the current source code either from SVN (Subversion), or, if you are not familiar with SVN, post a message in the DictionaryForMIDs forum, we will help then.

Downloading the Source Code from SVN

The sources for the DictionaryForMIDs tools and applications are maintained in a SourceForge SVN repository. Read the description how to access the DictionaryForMIDs SVN repository.

Downloading the Source Code as ZIP file

An old version of of the DictionaryForMIDs source code for Java ME application is part of the following ZIP file:
Note however, that the source code of this ZIP file is older than what you will find in the SVN repository !

The source code for the other DictionaryForMIDs tools and applications (for example DictionaryGeneration) is directly included in the ZIP file of that tool/application.

Building the tools and applications

Development Environments

You can use the development environment of your preference to compile, run and test the DictionaryForMIDs tools and applications. For example Eclipse, NetBeans or any other Java development environment.

For compiling the DictionaryForMIDs Java ME application, most people install Sun's Java ME SDK.

Dependencies between the tools and applications

The following dependencies exist between the tools and applications:

Building the tools and applications with build.xml

The SVN directory 'Build' contains the file build.xml. This file build.xml is used to compile and create the jar files of all tools and applications.

Here is how to use the build.xml file:

Important note: the source files are UTF-8 encoded. If you are using the old Sun WTK (for versions <= 2.5.2), you must set in the file (found somewhere under wtklib) the following property:

Building the tools and applications directly from development environments (Sun's Java ME SDK, Eclipse, etc.)

You can build the jar files also directly with development tools such as the Sun Java ME SDK or Eclipse, without using the build.xml file. Also in this case, be sure to set the UTF-8 encoding.

Test versions

Please check our forum for announcement of test versions !