Laboratoire ICAR » Plateforme TXM

import org.eclipse.jface.viewers.Viewer;

import org.eclipse.jface.viewers.ViewerFilter;

import org.txm.objects.SavedQuery;

import org.txm.objects.Text;

	public static HashMap<Class, Class> getManagedDoubleClickClasses() {

		return managedDoubleClickClasses;

	}

			treeViewer.setContentProvider(new TXMResultContentProvider(this));

		treeViewer.addFilter(new ViewerFilter() {

			@Override

			public boolean select(Viewer viewer, Object parentElement, Object element) {

				if (element instanceof Text) return false;

				if (element instanceof SavedQuery) return false;

				return true;

			}

		});

		treeViewer.setContentProvider(new TXMResultContentProvider(this));

				String mess = ((TXMResult)selectedItem).getSimpleDetails();

				if (mess == null) mess = selectedItem.toString();

				StatusLine.setMessage(mess);

		if (adapter != null) {

			return adapter.getLabel(element);

		if (element instanceof TXMResult)

			return ((TXMResult)element).getSimpleName();

		else 

			return element.toString();

import java.util.HashMap;

	private CorporaView view;

	public TXMResultContentProvider(CorporaView view) {

		this.view = view;

	}

			.getAdapter(IWorkbenchAdapter.class);

			.loadAdapter(element, IWorkbenchAdapter.class.getName());

		HashMap<Class, Class> managed = CorporaView.getManagedDoubleClickClasses();

			//			ArrayList<Object> managedChildrenList = new ArrayList<Object>();

			//			for (Object child : children) {

			//				if (managed.containsKey(child.getClass())) {

			//					managedChildrenList.add(child);

			//				}

			//			}

			//			Object[] managedChildren = managedChildrenList.toArray();

			//			Arrays.sort(children, new Comparator<Object>() {

			//				@Override

			//				public int compare(Object o1, Object o2) {

			//					if (o1 == null) return -1;

			//					if (o2 == null) return 1;

			//					return o1.toString().compareTo(o2.toString());

			//				}

			//			});

		if (element instanceof TXMResult) {

			return ((TXMResult)element).getResults().toArray();

		}

		} else if (element instanceof TXMResult) {

			return ((TXMResult)element).getResults().toArray();

		} else if (element instanceof TXMResult) {

			return ((TXMResult)element).getParent();

		if (element instanceof TXMResult) {

			return ((TXMResult)element).hasResults();

		} else {

			int n = getChildren(element).length;

			return n > 0;

		}

import org.txm.utils.messages.TXMNLS;

public class RCPMessages extends TXMNLS {

		TXMNLS.initializeMessages(BUNDLE_NAME, RCPMessages.class);

	protected String path;

	 * Mark the result has dirty so editors or others will know to recompute the TXMResult

	 * The result Parent. should not be null except for roots TXMResult

	public boolean hasResults() {

		return children.size() > 0;

	}

		String mess = this.getDetails();

		if (mess != null) return mess.replace("\n", "  ");

		return this.toString();

		return this.name+"="+this.value;//+ " >> " + this.examples; 

/**

 * Try of corpus parameter container, used during the parallel corpus developpement session and portal corpus configurations

 * 

 * @author mdecorde

 *

 */

			for (int i = 0 ; i < linkNodes.getLength() ; i++) {

				if (split.length != 3) {

		if (corporaNodes.getLength() > 0) {

			for (int i = 0 ; i < corpusNodes.getLength() ; i++) {

import java.util.ArrayList;

import java.util.List;

	//	/**

	//	 * Delete.

	//	 *

	//	 * @return true, if successful

	//	 */

	//	public boolean delete() {

	//		if (this.getTXMObjectParent() != null) {

	//			if (this.getTXMObjectParent().removeChildren(this) != null) {

	//				return true;

	//			}

	//		} else

	//			System.out.println(Messages.TxmObject_1);

	//		return false;

	//	}

			Document doc = getSelfElement().getOwnerDocument();

			Element prop = doc.createElement("prop"); //$NON-NLS-1$

			prop.setAttribute("key", key); //$NON-NLS-1$

			prop.setAttribute("type", "String"); //$NON-NLS-1$ //$NON-NLS-2$

			prop.setTextContent(value.toString());

			getSelfElement().appendChild(prop);

			getSelfElement().appendChild(prop);

			metadatas.put(key, new Property(key, value, "String", prop)); //$NON-NLS-1$

		} catch(Exception e){

		return name;

		return this.path;

	/* (non-Javadoc)

	 * @see org.txm.objects.TxmObject#removeChildren(org.txm.objects.TxmObject)

	 */

	public TxmObject removeChildren(TxmObject o) {

		if (super.removeResult(o)) {

			getSelfElement().removeChild(o.getSelfElement());

		}

		return o;

	}

	/* (non-Javadoc)

	 * @see org.txm.objects.TxmObject#hasChildren(org.txm.objects.TxmObject)

	 */

	public boolean hasChildren(TxmObject o) {

		return this.getResults(TxmObject.class).contains(o);

	}

import java.lang.reflect.Modifier;

import java.util.HashMap;

import java.util.Map;

	private static final int MOD_EXPECTED = Modifier.PUBLIC | Modifier.STATIC;

	private static final int MOD_MASK = MOD_EXPECTED | Modifier.FINAL;

		// re-encode the fields

			if ((field.getModifiers() & MOD_MASK) != MOD_EXPECTED) // only init public static fields

				continue;

			if(field.getType() != java.lang.String.class) 

				continue;

			if(!field.isAccessible())

				field.setAccessible(true);

			try {

				final String rawValue = (String) field.get(null);

				field.set(null, new String(rawValue.getBytes("ISO-8859-1"), "UTF-8"));

			}

			catch(Exception e) {

/*******************************************************************************

 * Copyright (c) 2005, 2014 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 * 

 * Contributors:

 *     IBM - Initial API and implementation

 *******************************************************************************/

package org.txm.utils.messages;

import java.io.IOException;

import java.io.InputStream;

import java.lang.reflect.Field;

import java.lang.reflect.Modifier;

import java.security.AccessController;

import java.security.PrivilegedAction;

import java.util.*;

import org.eclipse.osgi.framework.log.FrameworkLog;

import org.eclipse.osgi.framework.log.FrameworkLogEntry;

/**

 * Common superclass for all message bundle classes.  Provides convenience

 * methods for manipulating messages.

 * <p>

 * The <code>#bind</code> methods perform string substitution and should be considered a

 * convenience and <em>not</em> a full substitute replacement for <code>MessageFormat#format</code>

 * method calls. 

 * </p>

 * <p>

 * Text appearing within curly braces in the given message, will be interpreted

 * as a numeric index to the corresponding substitution object in the given array. Calling

 * the <code>#bind</code> methods with text that does not map to an integer will result in an

 * {@link IllegalArgumentException}.

 * </p>

 * <p>

 * Text appearing within single quotes is treated as a literal. A single quote is escaped by

 * a preceeding single quote.

 * </p>

 * <p>

 * Clients who wish to use the full substitution power of the <code>MessageFormat</code> class should

 * call that class directly and not use these <code>#bind</code> methods.

 * </p>

 * <p>

 * Clients may subclass this type.

 * </p>

 * 

 * @since 3.1

 */

public abstract class TXMNLS {

	private static final Object[] EMPTY_ARGS = new Object[0];

	private static final String EXTENSION = ".properties"; //$NON-NLS-1$

	private static String[] nlSuffixes;

	private static final String PROP_WARNINGS = "osgi.nls.warnings"; //$NON-NLS-1$

	private static final String IGNORE = "ignore"; //$NON-NLS-1$

	private static final boolean ignoreWarnings = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {

		public Boolean run() {

			return IGNORE.equals(System.getProperty(PROP_WARNINGS));

		}

	});

	/*

	 * NOTE do not change the name of this field; it is set by the Framework using reflection

	 */

	private static FrameworkLog frameworkLog;

	static final int SEVERITY_ERROR = 0x04;

	static final int SEVERITY_WARNING = 0x02;

	/*

	 * This object is assigned to the value of a field map to indicate

	 * that a translated message has already been assigned to that field.

	 */

	static final Object ASSIGNED = new Object();

	public static final boolean STATIC_DEBUG_MESSAGE_BUNDLES = false;

	/**

	 * Creates a new NLS instance.

	 */

	protected TXMNLS() {

		super();

	}

	/**

	 * Bind the given message's substitution locations with the given string value.

	 * 

	 * @param message the message to be manipulated

	 * @param binding the object to be inserted into the message

	 * @return the manipulated String

	 * @throws IllegalArgumentException if the text appearing within curly braces in the given message does not map to an integer 

	 */

	public static String bind(String message, Object binding) {

		return internalBind(message, null, String.valueOf(binding), null);

	}

	/**

	 * Bind the given message's substitution locations with the given string values.

	 * 

	 * @param message the message to be manipulated

	 * @param binding1 An object to be inserted into the message

	 * @param binding2 A second object to be inserted into the message

	 * @return the manipulated String

	 * @throws IllegalArgumentException if the text appearing within curly braces in the given message does not map to an integer

	 */

	public static String bind(String message, Object binding1, Object binding2) {

		return internalBind(message, null, String.valueOf(binding1), String.valueOf(binding2));

	}

	/**

	 * Bind the given message's substitution locations with the given string values.

	 * 

	 * @param message the message to be manipulated

	 * @param bindings An array of objects to be inserted into the message

	 * @return the manipulated String

	 * @throws IllegalArgumentException if the text appearing within curly braces in the given message does not map to an integer

	 */

	public static String bind(String message, Object[] bindings) {

		return internalBind(message, bindings, null, null);

	}

	/**

	 * Shortcut method to initialize messages if the baseName is the clazz package

	 * 

	 * @param clazz

	 */

	public static void initializeMessages(final Class<?> clazz) {

		final String baseName = clazz.getPackage().getName()+".messages";

		initializeMessages(baseName, clazz);

	}

	public static void initializeMessages(final String baseName, final Class<?> clazz) {

		if (System.getSecurityManager() == null) {

			load(baseName, clazz);

			fixEncodingToUTF8(baseName, clazz); // fix encoding to UTF-8

			return;

		}

		AccessController.doPrivileged(new PrivilegedAction<Void>() {

			public Void run() {

				load(baseName, clazz);

				fixEncodingToUTF8(baseName, clazz);

				return null;

			}

		});

	}

	/**

	 * Initialize the given class with the values from the message properties specified by the

	 * base name.  The base name specifies a fully qualified base name to a message properties file,

	 * including the package where the message properties file is located.  The class loader of the 

	 * specified class will be used to load the message properties resources.

	 * <p>

	 * For example, if the locale is set to en_US and <code>org.eclipse.example.nls.messages</code>

	 * is used as the base name then the following resources will be searched using the class

	 * loader of the specified class:

	 * <pre>

	 *   org/eclipse/example/nls/messages_en_US.properties

	 *   org/eclipse/example/nls/messages_en.properties

	 *   org/eclipse/example/nls/messages.properties

	 * </pre>

	 * 

	 * TXM change: 

	 *    - the ASSIGNED test has been commented, so this method should always reset the String values

	 *    - the properties String are re-encoded to UTF-8

	 * </p>

	 * 

	 * @param baseName the base name of a fully qualified message properties file.

	 * @param clazz the class where the constants will exist

	 */

	protected static void fixEncodingToUTF8(final String baseName, final Class<?> clazz) {

		// re-encode the fields

		final Field[] fieldArray = clazz.getDeclaredFields();

		final int len = fieldArray.length;

		for (int i = 0; i < len; i++) {

			final Field field = (Field) fieldArray[i];

			if (field.getType() != java.lang.String.class) 

				continue;

			if (!field.isAccessible())

				field.setAccessible(true);

			try {

				final String rawValue = (String) field.get(null);

				field.set(null, new String(rawValue.getBytes("ISO-8859-1"), "UTF-8"));

			}

			catch(Exception e) {

				//	e.printStackTrace();

			}

		}

	}

	/*

	 * Perform the string substitution on the given message with the specified args.

	 * See the class comment for exact details.

	 */

	private static String internalBind(String message, Object[] args, String argZero, String argOne) {

		if (message == null)

			return "No message available."; //$NON-NLS-1$

		if (args == null || args.length == 0)

			args = EMPTY_ARGS;

		int length = message.length();

		//estimate correct size of string buffer to avoid growth

		int bufLen = length + (args.length * 5);

		if (argZero != null)

			bufLen += argZero.length() - 3;

		if (argOne != null)

			bufLen += argOne.length() - 3;

		StringBuffer buffer = new StringBuffer(bufLen < 0 ? 0 : bufLen);

		for (int i = 0; i < length; i++) {

			char c = message.charAt(i);

			switch (c) {

			case '{' :

				int index = message.indexOf('}', i);

				// if we don't have a matching closing brace then...

				if (index == -1) {

					buffer.append(c);

					break;

				}

				i++;

				if (i >= length) {

					buffer.append(c);

					break;

				}

				// look for a substitution

				int number = -1;

				try {

					number = Integer.parseInt(message.substring(i, index));

				} catch (NumberFormatException e) {

					throw (IllegalArgumentException) new IllegalArgumentException().initCause(e);

				}

				if (number == 0 && argZero != null)

					buffer.append(argZero);

				else if (number == 1 && argOne != null)

					buffer.append(argOne);

				else {

					if (number >= args.length || number < 0) {

						buffer.append("<missing argument>"); //$NON-NLS-1$

						i = index;

						break;

					}

					buffer.append(args[number]);

				}

				i = index;

				break;

			case '\'' :

				// if a single quote is the last char on the line then skip it

				int nextIndex = i + 1;

				if (nextIndex >= length) {

					buffer.append(c);

					break;

				}

				char next = message.charAt(nextIndex);

				// if the next char is another single quote then write out one

				if (next == '\'') {

					i++;

					buffer.append(c);

					break;

				}

				// otherwise we want to read until we get to the next single quote

				index = message.indexOf('\'', nextIndex);

				// if there are no more in the string, then skip it

				if (index == -1) {

					buffer.append(c);

					break;

				}

				// otherwise write out the chars inside the quotes

				buffer.append(message.substring(nextIndex, index));

				i = index;

				break;

			default :

				buffer.append(c);

			}

		}

		return buffer.toString();

	}

	/*

	 * Build an array of property files to search.  The returned array contains

	 * the property fields in order from most specific to most generic.

	 * So, in the FR_fr locale, it will return file_fr_FR.properties, then

	 * file_fr.properties, and finally file.properties.

	 */

	private static String[] buildVariants(String root) {

		if (nlSuffixes == null) {

			//build list of suffixes for loading resource bundles

			String nl = Locale.getDefault().toString();

			List<String> result = new ArrayList<String>(4);

			int lastSeparator;

			while (true) {

				result.add('_' + nl + EXTENSION);

				lastSeparator = nl.lastIndexOf('_');

				if (lastSeparator == -1)

					break;

				nl = nl.substring(0, lastSeparator);

			}

			//add the empty suffix last (most general)

			result.add(EXTENSION);

			nlSuffixes = result.toArray(new String[result.size()]);

		}

		root = root.replace('.', '/');

		String[] variants = new String[nlSuffixes.length];

		for (int i = 0; i < variants.length; i++)

			variants[i] = root + nlSuffixes[i];

		return variants;

	}

	private static void computeMissingMessages(String bundleName, Class<?> clazz, Map<Object, Object> fieldMap, Field[] fieldArray, boolean isAccessible) {

		// iterate over the fields in the class to make sure that there aren't any empty ones

		final int MOD_EXPECTED = Modifier.PUBLIC | Modifier.STATIC;

		final int MOD_MASK = MOD_EXPECTED | Modifier.FINAL;

		final int numFields = fieldArray.length;

		for (int i = 0; i < numFields; i++) {

			Field field = fieldArray[i];

			if ((field.getModifiers() & MOD_MASK) != MOD_EXPECTED)

				continue;

			//if the field has a a value assigned, there is nothing to do

			// changed ASSIGNED to null because assigned key are now removed from the fieldMap == the fields members of the MessagesProperties objects == fieldArray of the load method

			if (fieldMap.get(field.getName()) == null) continue;

			try {

				// Set a value for this empty field. We should never get an exception here because

				// we know we have a public static non-final field. If we do get an exception, silently

				// log it and continue. This means that the field will (most likely) be un-initialized and

				// will fail later in the code and if so then we will see both the NPE and this error.

				String value = "NLS missing message: " + field.getName() + " in: " + bundleName; //$NON-NLS-1$ //$NON-NLS-2$

				if (STATIC_DEBUG_MESSAGE_BUNDLES)

					System.out.println(value);

				log(SEVERITY_WARNING, value, null);

				if (!isAccessible)

					field.setAccessible(true);

				field.set(null, value);

			} catch (Exception e) {

				log(SEVERITY_ERROR, "Error setting the missing message value for: " + field.getName(), e); //$NON-NLS-1$

			}

		}

	}

	/*

	 * Load the given resource bundle using the specified class loader.

	 */

	static void load(final String bundleName, Class<?> clazz) {

		long start = System.currentTimeMillis();

		final Field[] fieldArray = clazz.getDeclaredFields();

		ClassLoader loader = clazz.getClassLoader();

		boolean isAccessible = (clazz.getModifiers() & Modifier.PUBLIC) != 0;

		//build a map of field names to Field objects

		final int len = fieldArray.length;

		Map<Object, Object> fields = new HashMap<Object, Object>(len * 2);

		for (int i = 0; i < len; i++)

			fields.put(fieldArray[i].getName(), fieldArray[i]);

		// search the variants from most specific to most general, since

		// the MessagesProperties.put method will mark assigned fields

		// to prevent them from being assigned twice

		final String[] variants = buildVariants(bundleName);

		for (int i = 0; i < variants.length; i++) {

			// loader==null if we're launched off the Java boot classpath

			final InputStream input = loader == null ? ClassLoader.getSystemResourceAsStream(variants[i]) : loader.getResourceAsStream(variants[i]);

			if (input == null)

				continue;

			try {

				final MessagesProperties properties = new MessagesProperties(fields, bundleName, variants[i], isAccessible);

				properties.load(input);

			} catch (IOException e) {

				log(SEVERITY_ERROR, "Error loading " + variants[i], e); //$NON-NLS-1$

			} finally {

				if (input != null)

					try {

						input.close();

					} catch (IOException e) {

						// ignore

					}

			}

		}

		computeMissingMessages(bundleName, clazz, fields, fieldArray, isAccessible);

		if (STATIC_DEBUG_MESSAGE_BUNDLES)

			System.out.println("Time to load message bundle: " + bundleName + " was " + (System.currentTimeMillis() - start) + "ms."); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

	}

	/*

	 * The method adds a log entry based on the error message and exception. 

	 * The output is written to the System.err.

	 * 

	 * This method is only expected to be called if there is a problem in

	 * the NLS mechanism. As a result, translation facility is not available 

	 * here and messages coming out of this log are generally not translated.

	 * 

	 * @param severity - severity of the message (SEVERITY_ERROR or SEVERITY_WARNING)

	 * @param message - message to log

	 * @param e - exception to log

	 */

	static void log(int severity, String message, Exception e) {

		if (severity == SEVERITY_WARNING && ignoreWarnings)

			return; // ignoring warnings; bug 292980

		if (frameworkLog != null) {

			frameworkLog.log(new FrameworkLogEntry("org.eclipse.osgi", severity, 1, message, 0, e, null)); //$NON-NLS-1$

			return;

		}

		String statusMsg;

		switch (severity) {

		case SEVERITY_ERROR :

			statusMsg = "Error: "; //$NON-NLS-1$

			break;

		case SEVERITY_WARNING :

			// intentionally fall through:

		default :

			statusMsg = "Warning: "; //$NON-NLS-1$

		}

		if (message != null)

			statusMsg += message;

		if (e != null)

			statusMsg += ": " + e.getMessage(); //$NON-NLS-1$

		System.err.println(statusMsg);

		if (e != null)

			e.printStackTrace();

	}

	/*

	 * Class which sub-classes java.util.Properties and uses the #put method

	 * to set field values rather than storing the values in the table.

	 */

	private static class MessagesProperties extends Properties {

		private static final int MOD_EXPECTED = Modifier.PUBLIC | Modifier.STATIC;

		private static final int MOD_MASK = MOD_EXPECTED | Modifier.FINAL;

		private static final long serialVersionUID = 1L;

		private final String bundleName;

		private final Map<Object, Object> fields;

		private final boolean isAccessible;

		private final String variant;

		public MessagesProperties(Map<Object, Object> fieldMap, String bundleName, String variant, boolean isAccessible) {

			super();

			this.fields = fieldMap;

			this.bundleName = bundleName;

			this.isAccessible = isAccessible;

			this.variant = variant;

		}

		/* (non-Javadoc)

		 * @see java.util.Hashtable#put(java.lang.Object, java.lang.Object)

		 */

		public synchronized Object put(Object key, Object value) {

			//Object fieldObject = fields.put(key, ASSIGNED);

			Object fieldObject = fields.remove(key);

			// if already assigned, there is nothing to do

			if (fieldObject == ASSIGNED) {

				//System.out.println(variant+ " DAOL MESSAGE "+key+"="+value);

				return null;

			}

			//System.out.println(variant+" LOAD MESSAGE "+key+"="+value+" in "+fieldObject);

			if (fieldObject == null) {

				final String msg = "NLS unused message: " + key + " in: " + bundleName;//$NON-NLS-1$ //$NON-NLS-2$

				if (STATIC_DEBUG_MESSAGE_BUNDLES)

					System.out.println(msg);

				// keys with '.' are ignored by design (bug 433424)

				if (key instanceof String && ((String) key).indexOf('.') < 0) {

					log(SEVERITY_WARNING, msg, null);

				}

				return null;

			}

			final Field field = (Field) fieldObject;

			//can only set value of public static non-final fields

			if ((field.getModifiers() & MOD_MASK) != MOD_EXPECTED)

				return null;

			try {

				// Check to see if we are allowed to modify the field. If we aren't (for instance 

				// if the class is not public) then change the accessible attribute of the field

				// before trying to set the value.

				if (!isAccessible)

					field.setAccessible(true);

				// Set the value into the field. We should never get an exception here because

				// we know we have a public static non-final field. If we do get an exception, silently

				// log it and continue. This means that the field will (most likely) be un-initialized and

				// will fail later in the code and if so then we will see both the NPE and this error.

				// Extra care is taken to be sure we create a String with its own backing char[] (bug 287183)

				// This is to ensure we do not keep the key chars in memory.

				field.set(null, new String(((String) value).toCharArray()));

			} catch (Exception e) {

				log(SEVERITY_ERROR, "Exception setting field value.", e); //$NON-NLS-1$

			}

			return null;

		}

	}

}

import org.txm.searchengine.cqp.rcp.*;

				Messages.CQPPreferencePage_1,

				CQPPreferences.CQI_SERVER_PATH_TO_CQPLIB, Messages.CQPPreferencePage_0,

				Messages.CQPPreferencePage_10,

				Messages.CQPPreferencePage_11, getFieldEditorParent());

				Messages.CQPPreferencePage_12, getFieldEditorParent());

				Messages.CQPPreferencePage_13, getFieldEditorParent());

				Messages.CQPPreferencePage_14, getFieldEditorParent());

				CQPPreferences.CQI_SERVER_PATH_TO_EXECUTABLE, Messages.CQPPreferencePage_15,

				CQPPreferences.CQI_SERVER_PATH_TO_INIT_FILE, Messages.CQPPreferencePage_17,

				CQPPreferences.CQI_SERVER_ADDITIONAL_OPTIONS, Messages.CQPPreferencePage_18,

#Generated by ResourceBundle Editor (http://essiembre.github.io/eclipse-rbe/)

#Eclipse modern messages class

#Mon Feb 10 11:04:14 CET 2014

OK=OK

REFRESH=Refresh

CGU_TITLE=Terms of service

CGU_MESSAGE=<p>TXM is published under the GNU GPL 2 license &lt;<a href="https://www.gnu.org/licenses/gpl-2.0.en.html">https://www.gnu.org/licenses/gpl-2.0.en.html</a>&gt;.

CGU_CHECKMESSAGE=I accept the licence and I undertake to cite TXM for acknowledging my use of TXM in my research work \n(see the Citation section of the <http://textometrie.ens-lyon.fr/spip.php?rubrique61> page).

About_Menu_Label = About TXM...

AdapterFactory_0 = ** Warning: the corpus {0} is corrupted. Some commands won''t work correctly.

AddBase_1  = New corpus: {0}.

AddBase_10 = TXM is ready.

AddBase_16 = ** Cannot set the 'LANG' property from the 'txmcorpus' structure:

AddBase_17 = ** Cannot read the file {0}

AddBase_19 = Warning

AddBase_2  = ** Failed to load corpus  from directory: {0}.\nWe cannot find the necessary components

AddBase_20 = The {0} corpus directory already exists. Do you want to replace it ?

AddBase_22 = This file is not a TXM file: {0}

AddBase_23 = The corpus {0} has no ''LANG'' set in ''txmcorpus''

AddBase_24 = ** Failed to load corpus  {0}

AddBase_25 = A binary corpus is a TXM file (extension .txm or .zip)

AddBase_27 = Loading binary corpus

AddBase_28 = Extracting binary corpus

AddBase_29 = Extracting {0} in {1}

AddBase_31 = ** Could not unzip binary corpus:

AddBase_32 = Loading the corpus in the platform

AddBase_33 = Restarting the platform

AddBase_34 = TXM workspace is not initialized, please restart TXM.

AddBase_4  = ** Failed to load binary corpus (null error).

AddBase_7  = ** Failed to create binary corpus.

AddProject_3 = Enter project name

AdvancePreferencePage_0  = Print the stacktrace

AdvancePreferencePage_1  = TXM Install directory