Index: tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/handlers/ComputeLexicalTable.java
===================================================================
--- tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/handlers/ComputeLexicalTable.java	(revision 2403)
+++ tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/handlers/ComputeLexicalTable.java	(revision 2404)
@@ -62,17 +62,18 @@
  * 
  */
 public class ComputeLexicalTable extends BaseAbstractHandler {
-
-	/* (non-Javadoc)
+	
+	/*
+	 * (non-Javadoc)
 	 * @see org.eclipse.core.commands.AbstractHandler#execute(org.eclipse.core.commands.ExecutionEvent)
 	 */
 	@Override
 	public Object execute(ExecutionEvent event) throws ExecutionException {
-
-		if(!this.checkStatsEngine()) {
+		
+		if (!this.checkStatsEngine()) {
 			return null;
 		}
-
+		
 		Object selection = this.getCorporaViewSelectedObject(event);
 		LexicalTable lexicalTable = null;
 		
@@ -92,15 +93,15 @@
 			dialog.setLabelProvider(new LabelProvider());
 			dialog.setContentProvider(new ArrayContentProvider());
 			dialog.setTitle(LexicalTableUIMessages.selectWhichMarginsYouWantToUse);
-
+			
 			int ret = dialog.open();
 			boolean useAllOccurrences = false;
 			if (ret == ListDialog.OK) {
-				if(dialog.getResult().length == 0) {
+				if (dialog.getResult().length == 0) {
 					return null;
 				}
 				String sel = (String) dialog.getResult()[0];
-				if(sel.equals(LexicalTableUIMessages.useAllOccurrences)) {
+				if (sel.equals(LexicalTableUIMessages.useAllOccurrences)) {
 					useAllOccurrences = true;
 				}
 			}
@@ -111,7 +112,7 @@
 			if (partitionIndexes.size() == 0) {
 				return false;
 			}
-
+			
 			partitionIndexes = partitionIndexes.subList(0, 1);
 			for (PartitionIndex partitionIndex : partitionIndexes) {
 				if (!partitionIndex.isComputedWithPartition()) {
@@ -139,24 +140,24 @@
 			}
 			
 			final WordProperty property = properties.get(0);
-
+			
 			lexicalTable = new LexicalTable(firstIndex);
 			lexicalTable.setUseAllOccurrences(useAllOccurrences);
 			lexicalTable.setUnitProperty(property);
 			// transmit index fmin/fmax parameters
 			lexicalTable.setFMinFilter(firstIndex.getFilterFmin());
 			lexicalTable.setVMaxFilter(firstIndex.getFilterVmax());
-
 			
 			
 			
 			
+			
 			// FIXME: SJ: became useless?
-			//return null;
-			//		} else if (s instanceof QueryIndex) {
-			//			List<QueryIndex> qindexes = selection.toList();
-			//			computeWithQueryIndexes(qindexes);
-			//			return null;
+			// return null;
+			// } else if (s instanceof QueryIndex) {
+			// List<QueryIndex> qindexes = selection.toList();
+			// computeWithQueryIndexes(qindexes);
+			// return null;
 		}
 		// Creating from Partition
 		else if (selection instanceof Partition) {
@@ -167,7 +168,7 @@
 			lexicalTable = (LexicalTable) selection;
 		}
 		// Error
-		else	{
+		else {
 			this.logCanNotExecuteCommand(selection);
 		}
 		
@@ -175,285 +176,285 @@
 		
 		return true;
 	}
-
-//	/**
-//	 * Compute with partition.
-//	 *
-//	 * @param partition the partition
-//	 */
-//	private void computeWithLexicalTableAble(final LexicalTable lexicalTableAble) {
-//
-//		JobHandler jobhandler = new JobHandler(
-//				RCPMessages.ComputeLexicalTable_0) {
-//			@Override
-//			protected IStatus run(IProgressMonitor monitor) {
-//				this.runInit(monitor);
-//				try {
-//					JobsTimer.start();
-//					monitor.beginTask(NLS.bind(RCPMessages.ComputeLexicalTable_1, lexicalTableAble.getName(), "none"), 100);
-//
-//					this.acquireSemaphore();
-//					//table = lexicalTableAble.toLexicalTable();
-//					table = lexicalTableAble;
-//					this.releaseSemaphore();
-//
-//					monitor.worked(45);
-//
-//					lexicalTableAble.getParent().addChild(table);
-//
-//					monitor.worked(5);
-//
-//					//monitor.subTask(Messages.ComputeSpecifities_10);
-//					syncExec(new Runnable() {
-//						@Override
-//						public void run() {
-//							IWorkbenchPage page = window.getActivePage();
-//							LexicalTableEditorInput editorInput = new LexicalTableEditorInput(table);
-//							try {
-//								StatusLine.setMessage(RCPMessages.ComputeLexicalTable_10);
-//								page.openEditor(editorInput, LexicalTableEditor.ID);
-//							} catch (PartInitException e) {
-//								org.txm.utils.logger.Log.printStackTrace(e);
-//							} 
-//						}
-//					});
-//
-//					monitor.worked(50);
-//					if (monitor.isCanceled())
-//						return Status.CANCEL_STATUS;
-//
-//					//monitor.subTask(Messages.ComputeSpecifities_2);
-//					syncExec(new Runnable() {
-//						@Override
-//						public void run() {
-//							CorporaView.refresh();
-//							CorporaView.expand(table.getParent());
-//							QueriesView.refresh();
-//							RVariablesView.refresh();
-//						}
-//					});
-//
-//					monitor.worked(100);
-//				} catch (ThreadDeath td) {
-//					return Status.CANCEL_STATUS;
-//				} catch (Exception e) {
-//					org.txm.utils.logger.Log.printStackTrace(e);
-//				} finally {
-//					monitor.done();
-//					JobsTimer.stopAndPrint();
-//				}
-//				return Status.OK_STATUS;
-//			}
-//		};
-//		jobhandler.startJob();
-//
-//		return;
-//	}
-
-
-
-	//	/**
-	//	 * Compute with query index.
-	//	 *
-	//	 * @param fullvocabularies the fullvocabularies
-	//	 * @return true, if successful
-	//	 */
-	//	private boolean computeWithQueryIndexes(List<QueryIndex> oqindexes) {
-	//		if (oqindexes.size() == 0) {
-	//			return false;
-	//		}
-	//		
+	
+	// /**
+	// * Compute with partition.
+	// *
+	// * @param partition the partition
+	// */
+	// private void computeWithLexicalTableAble(final LexicalTable lexicalTableAble) {
 	//
-	//		final List<QueryIndex> qindexes = oqindexes.subList(0, 1);
-	//		for (QueryIndex voc : qindexes)
-	//			if (!voc.isComputedWithPartition()) {
-	//				System.out.println(Messages.ComputeLexicalTable_5);
-	//				StatusLine.setMessage(Messages.ComputeLexicalTable_5);
-	//				return false;
-	//			}
+	// JobHandler jobhandler = new JobHandler(
+	// RCPMessages.ComputeLexicalTable_0) {
+	// @Override
+	// protected IStatus run(IProgressMonitor monitor) {
+	// this.runInit(monitor);
+	// try {
+	// JobsTimer.start();
+	// monitor.beginTask(NLS.bind(RCPMessages.ComputeLexicalTable_1, lexicalTableAble.getName(), "none"), 100);
 	//
-	//		Partition firstPartition = qindexes.get(0).getPartition();
-	//		for (QueryIndex voc : qindexes)
-	//			if (!firstPartition.equals(voc.getPartition())) {
-	//				Log.warning(NLS.bind(Messages.ComputeLexicalTable_7, firstPartition));
-	//				return false;
-	//			}
+	// this.acquireSemaphore();
+	// //table = lexicalTableAble.toLexicalTable();
+	// table = lexicalTableAble;
+	// this.releaseSemaphore();
 	//
-	//		final Partition partition = ((QueryIndex) selection.getFirstElement())
-	//				.getPartition();
-	//		//final Property property = properties.get(0);
-	//		
-	//		JobHandler jobhandler = new JobHandler(Messages.ComputeSpecificities_0) {
-	//			@Override
-	//			protected IStatus run(IProgressMonitor monitor) {
-	//				this.runInit(monitor);
-	//				try {      
-	//					monitor.beginTask(NLS.bind(Messages.ComputeLexicalTable_1, partition.getName(), Messages.ComputeLexicalTable_2), 100);
-	//					this.acquireSemaphore();
-	//					copy = LexicalTableImpl.createLexicalTableImpl(qindexes,
-	//							QuantitativeDataStructureImpl
-	//									.createSymbole(LexicalTableImpl.class));
-	//										monitor.worked(45);
-	//					this.releaseSemaphore();
-	//					if (copy == null)
-	//						return Status.CANCEL_STATUS;
+	// monitor.worked(45);
 	//
-	//					partition.storeResult(copy);
-	//					monitor.worked(5);
+	// lexicalTableAble.getParent().addChild(table);
 	//
-	//					monitor.subTask(Messages.ComputeLexicalTable_10);
-	//					syncExec(new Runnable() {
-	//						@Override
-	//						public void run() {
-	//							IWorkbenchPage page = window.getActivePage();
-	//							LexicalTableEditorInput editorInput = new LexicalTableEditorInput(
-	//									copy, partition, null);
-	//							try {
-	//								StatusLine.setMessage(Messages.ComputeLexicalTable_10);
-	//								page.openEditor(editorInput,
-	//												"org.txm.rcp.editors.lexicaltable.LexicalTableEditor"); //$NON-NLS-1$
-	//							} catch (PartInitException e) {
-	//								org.txm.utils.logger.Log.printStackTrace(e);
-	//							} 
-	//						}
-	//					});
+	// monitor.worked(5);
 	//
-	//					monitor.worked(50);
-	//					if (monitor.isCanceled())
-	//						return Status.CANCEL_STATUS;
+	// //monitor.subTask(Messages.ComputeSpecifities_10);
+	// syncExec(new Runnable() {
+	// @Override
+	// public void run() {
+	// IWorkbenchPage page = window.getActivePage();
+	// LexicalTableEditorInput editorInput = new LexicalTableEditorInput(table);
+	// try {
+	// StatusLine.setMessage(RCPMessages.ComputeLexicalTable_10);
+	// page.openEditor(editorInput, LexicalTableEditor.ID);
+	// } catch (PartInitException e) {
+	// org.txm.utils.logger.Log.printStackTrace(e);
+	// }
+	// }
+	// });
 	//
-	//					monitor.subTask(Messages.ComputeSpecifities_2);
-	//					syncExec(new Runnable() {
-	//						@Override
-	//						public void run() {
-	//							CorporaView.refresh();
-	//							CorporaView.expand(copy.getPartition());
-	//							QueriesView.refresh();
-	//							RVariablesView.refresh();
-	//						}
-	//					});
+	// monitor.worked(50);
+	// if (monitor.isCanceled())
+	// return Status.CANCEL_STATUS;
 	//
-	//					monitor.worked(100);
-	//				} catch (ThreadDeath td) { 
-	//					return Status.CANCEL_STATUS;
-	//				} catch (Exception e) {
-	//					org.txm.utils.logger.Log.printStackTrace(e);
-	//				} finally {
-	//					monitor.done();
-	//				}
-	//				return Status.OK_STATUS;
-	//			}
-	//		};
-	//		jobhandler.startJob();
+	// //monitor.subTask(Messages.ComputeSpecifities_2);
+	// syncExec(new Runnable() {
+	// @Override
+	// public void run() {
+	// CorporaView.refresh();
+	// CorporaView.expand(table.getParent());
+	// QueriesView.refresh();
+	// RVariablesView.refresh();
+	// }
+	// });
 	//
-	//		return true;
-	//	}
-
-//	/**
-//	 * Compute with vocabularies.
-//	 *
-//	 * @param fullvocabularies the fullvocabularies
-//	 * @return true, if successful
-//	 */
-//	private boolean computeWithVocabularies(List<Index> fullvocabularies, final boolean useAllOccurrences) {
-//		if (fullvocabularies.size() == 0) {
-//			return false;
-//		}
-//
-//		final List<Index> vocabularies = fullvocabularies.subList(0, 1);
-//		for (Index voc : vocabularies) {
-//			if (!voc.isComputedWithPartition()) {
-//				System.out.println(RCPMessages.ComputeLexicalTable_5);
-//				StatusLine.setMessage(RCPMessages.ComputeLexicalTable_5);
-//				return false;
-//			}
-//		}
-//		
-//		List<Property> properties = vocabularies.get(0).getProperties();
-//		for (Index voc : vocabularies) {
-//			if (!properties.equals(voc.getProperties())) {
-//				Log.warning(NLS.bind(RCPMessages.ComputeLexicalTable_6, properties));
-//				return false;
-//			}
-//		}
-//		
-//		final Index firstIndex = vocabularies.get(0);
-//		Partition firstPartition = firstIndex.getPartition();
-//		for (Index voc : vocabularies) {
-//			if (!firstPartition.equals(voc.getPartition())) {
-//				Log.warning(NLS.bind(RCPMessages.ComputeLexicalTable_7, firstPartition));
-//				return false;
-//			}
-//		}
-//		
-//		final Property property = properties.get(0);
-//
-//		JobHandler jobhandler = new JobHandler(RCPMessages.bind(RCPMessages.ComputeLexicalTable_0, firstIndex.getName())) {
-//			@Override
-//			protected IStatus run(IProgressMonitor monitor) {
-//				this.runInit(monitor);
-//				try {
-//					monitor.beginTask("Computing Lexical table with Index: "+firstIndex+" property: "+property, 100);
-//					this.acquireSemaphore();
-//					table = new LexicalTable(firstIndex);
-//					table.setParameters(null, null, null, useAllOccurrences);
-//					table.compute(true, monitor);
-//					monitor.worked(45);
-//					this.releaseSemaphore();
-//					if (monitor.isCanceled() || table == null)
-//						return Status.CANCEL_STATUS;
-//
-//					firstIndex.addChild(table);
-//					monitor.worked(5);
-//
-//					monitor.subTask(RCPMessages.ComputeLexicalTable_10);
-//					syncExec(new Runnable() {
-//						@Override
-//						public void run() {
-//							IWorkbenchPage page = window.getActivePage();
-//							LexicalTableEditorInput editorInput = new LexicalTableEditorInput(table);
-//							try {
-//								StatusLine.setMessage(RCPMessages.ComputeLexicalTable_10);
-//								page.openEditor(editorInput,
-//										"org.txm.rcp.editors.lexicaltable.LexicalTableEditor"); //$NON-NLS-1$
-//							} catch (PartInitException e) {
-//								org.txm.utils.logger.Log.printStackTrace(e);
-//							} 
-//						}
-//					});
-//
-//					monitor.worked(50);
-//					if (monitor.isCanceled())
-//						return Status.CANCEL_STATUS;
-//
-//					monitor.subTask(RCPMessages.ComputeSpecifities_2);
-//					syncExec(new Runnable() {
-//						@Override
-//						public void run() {
-//							CorporaView.refresh();
-//							CorporaView.expand(table.getParent());
-//							QueriesView.refresh();
-//							RVariablesView.refresh();
-//						}
-//					});
-//
-//					monitor.worked(100);
-//				} catch (ThreadDeath td) { 
-//					return Status.CANCEL_STATUS;
-//				} catch (Exception e) {
-//					org.txm.utils.logger.Log.printStackTrace(e);
-//				} finally {
-//					monitor.done();
-//				}
-//				return Status.OK_STATUS;
-//			}
-//		};
-//		jobhandler.startJob();
-//
-//		return true;
-//	}
+	// monitor.worked(100);
+	// } catch (ThreadDeath td) {
+	// return Status.CANCEL_STATUS;
+	// } catch (Exception e) {
+	// org.txm.utils.logger.Log.printStackTrace(e);
+	// } finally {
+	// monitor.done();
+	// JobsTimer.stopAndPrint();
+	// }
+	// return Status.OK_STATUS;
+	// }
+	// };
+	// jobhandler.startJob();
+	//
+	// return;
+	// }
 	
 	
 	
+	// /**
+	// * Compute with query index.
+	// *
+	// * @param fullvocabularies the fullvocabularies
+	// * @return true, if successful
+	// */
+	// private boolean computeWithQueryIndexes(List<QueryIndex> oqindexes) {
+	// if (oqindexes.size() == 0) {
+	// return false;
+	// }
+	//
+	//
+	// final List<QueryIndex> qindexes = oqindexes.subList(0, 1);
+	// for (QueryIndex voc : qindexes)
+	// if (!voc.isComputedWithPartition()) {
+	// System.out.println(Messages.ComputeLexicalTable_5);
+	// StatusLine.setMessage(Messages.ComputeLexicalTable_5);
+	// return false;
+	// }
+	//
+	// Partition firstPartition = qindexes.get(0).getPartition();
+	// for (QueryIndex voc : qindexes)
+	// if (!firstPartition.equals(voc.getPartition())) {
+	// Log.warning(NLS.bind(Messages.ComputeLexicalTable_7, firstPartition));
+	// return false;
+	// }
+	//
+	// final Partition partition = ((QueryIndex) selection.getFirstElement())
+	// .getPartition();
+	// //final Property property = properties.get(0);
+	//
+	// JobHandler jobhandler = new JobHandler(Messages.ComputeSpecificities_0) {
+	// @Override
+	// protected IStatus run(IProgressMonitor monitor) {
+	// this.runInit(monitor);
+	// try {
+	// monitor.beginTask(NLS.bind(Messages.ComputeLexicalTable_1, partition.getName(), Messages.ComputeLexicalTable_2), 100);
+	// this.acquireSemaphore();
+	// copy = LexicalTableImpl.createLexicalTableImpl(qindexes,
+	// QuantitativeDataStructureImpl
+	// .createSymbole(LexicalTableImpl.class));
+	// monitor.worked(45);
+	// this.releaseSemaphore();
+	// if (copy == null)
+	// return Status.CANCEL_STATUS;
+	//
+	// partition.storeResult(copy);
+	// monitor.worked(5);
+	//
+	// monitor.subTask(Messages.ComputeLexicalTable_10);
+	// syncExec(new Runnable() {
+	// @Override
+	// public void run() {
+	// IWorkbenchPage page = window.getActivePage();
+	// LexicalTableEditorInput editorInput = new LexicalTableEditorInput(
+	// copy, partition, null);
+	// try {
+	// StatusLine.setMessage(Messages.ComputeLexicalTable_10);
+	// page.openEditor(editorInput,
+	// "org.txm.rcp.editors.lexicaltable.LexicalTableEditor"); //$NON-NLS-1$
+	// } catch (PartInitException e) {
+	// org.txm.utils.logger.Log.printStackTrace(e);
+	// }
+	// }
+	// });
+	//
+	// monitor.worked(50);
+	// if (monitor.isCanceled())
+	// return Status.CANCEL_STATUS;
+	//
+	// monitor.subTask(Messages.ComputeSpecifities_2);
+	// syncExec(new Runnable() {
+	// @Override
+	// public void run() {
+	// CorporaView.refresh();
+	// CorporaView.expand(copy.getPartition());
+	// QueriesView.refresh();
+	// RVariablesView.refresh();
+	// }
+	// });
+	//
+	// monitor.worked(100);
+	// } catch (ThreadDeath td) {
+	// return Status.CANCEL_STATUS;
+	// } catch (Exception e) {
+	// org.txm.utils.logger.Log.printStackTrace(e);
+	// } finally {
+	// monitor.done();
+	// }
+	// return Status.OK_STATUS;
+	// }
+	// };
+	// jobhandler.startJob();
+	//
+	// return true;
+	// }
 	
-}
\ No newline at end of file
+	// /**
+	// * Compute with vocabularies.
+	// *
+	// * @param fullvocabularies the fullvocabularies
+	// * @return true, if successful
+	// */
+	// private boolean computeWithVocabularies(List<Index> fullvocabularies, final boolean useAllOccurrences) {
+	// if (fullvocabularies.size() == 0) {
+	// return false;
+	// }
+	//
+	// final List<Index> vocabularies = fullvocabularies.subList(0, 1);
+	// for (Index voc : vocabularies) {
+	// if (!voc.isComputedWithPartition()) {
+	// System.out.println(RCPMessages.ComputeLexicalTable_5);
+	// StatusLine.setMessage(RCPMessages.ComputeLexicalTable_5);
+	// return false;
+	// }
+	// }
+	//
+	// List<Property> properties = vocabularies.get(0).getProperties();
+	// for (Index voc : vocabularies) {
+	// if (!properties.equals(voc.getProperties())) {
+	// Log.warning(NLS.bind(RCPMessages.ComputeLexicalTable_6, properties));
+	// return false;
+	// }
+	// }
+	//
+	// final Index firstIndex = vocabularies.get(0);
+	// Partition firstPartition = firstIndex.getPartition();
+	// for (Index voc : vocabularies) {
+	// if (!firstPartition.equals(voc.getPartition())) {
+	// Log.warning(NLS.bind(RCPMessages.ComputeLexicalTable_7, firstPartition));
+	// return false;
+	// }
+	// }
+	//
+	// final Property property = properties.get(0);
+	//
+	// JobHandler jobhandler = new JobHandler(RCPMessages.bind(RCPMessages.ComputeLexicalTable_0, firstIndex.getName())) {
+	// @Override
+	// protected IStatus run(IProgressMonitor monitor) {
+	// this.runInit(monitor);
+	// try {
+	// monitor.beginTask("Computing Lexical table with Index: "+firstIndex+" property: "+property, 100);
+	// this.acquireSemaphore();
+	// table = new LexicalTable(firstIndex);
+	// table.setParameters(null, null, null, useAllOccurrences);
+	// table.compute(true, monitor);
+	// monitor.worked(45);
+	// this.releaseSemaphore();
+	// if (monitor.isCanceled() || table == null)
+	// return Status.CANCEL_STATUS;
+	//
+	// firstIndex.addChild(table);
+	// monitor.worked(5);
+	//
+	// monitor.subTask(RCPMessages.ComputeLexicalTable_10);
+	// syncExec(new Runnable() {
+	// @Override
+	// public void run() {
+	// IWorkbenchPage page = window.getActivePage();
+	// LexicalTableEditorInput editorInput = new LexicalTableEditorInput(table);
+	// try {
+	// StatusLine.setMessage(RCPMessages.ComputeLexicalTable_10);
+	// page.openEditor(editorInput,
+	// "org.txm.rcp.editors.lexicaltable.LexicalTableEditor"); //$NON-NLS-1$
+	// } catch (PartInitException e) {
+	// org.txm.utils.logger.Log.printStackTrace(e);
+	// }
+	// }
+	// });
+	//
+	// monitor.worked(50);
+	// if (monitor.isCanceled())
+	// return Status.CANCEL_STATUS;
+	//
+	// monitor.subTask(RCPMessages.ComputeSpecifities_2);
+	// syncExec(new Runnable() {
+	// @Override
+	// public void run() {
+	// CorporaView.refresh();
+	// CorporaView.expand(table.getParent());
+	// QueriesView.refresh();
+	// RVariablesView.refresh();
+	// }
+	// });
+	//
+	// monitor.worked(100);
+	// } catch (ThreadDeath td) {
+	// return Status.CANCEL_STATUS;
+	// } catch (Exception e) {
+	// org.txm.utils.logger.Log.printStackTrace(e);
+	// } finally {
+	// monitor.done();
+	// }
+	// return Status.OK_STATUS;
+	// }
+	// };
+	// jobhandler.startJob();
+	//
+	// return true;
+	// }
+	
+	
+	
+	
+}
Index: tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/handlers/MergeLines.java
===================================================================
--- tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/handlers/MergeLines.java	(revision 2403)
+++ tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/handlers/MergeLines.java	(revision 2404)
@@ -43,19 +43,20 @@
 import org.txm.lexicaltable.rcp.messages.LexicalTableUIMessages;
 import org.txm.rcp.StatusLine;
 import org.txm.rcp.messages.TXMUIMessages;
+
 /**
  * Allows the user to merge Lexical Table lines columns values are added to the first and the others lines are deleted.
  * 
  * @author mdecorde
  */
 public class MergeLines extends AbstractHandler {
-
-
+	
+	
 	@Override
 	public Object execute(ExecutionEvent event) throws ExecutionException {
 		Shell shell = HandlerUtil.getActiveWorkbenchWindowChecked(event)
 				.getShell();
-
+		
 		IWorkbenchPart editor = HandlerUtil.getActiveWorkbenchWindow(event)
 				.getActivePage().getActivePart();
 		if (editor instanceof LexicalTableEditor) {
@@ -64,23 +65,23 @@
 					.getSelectionIndices();
 			if (selection.length == 0)
 				return null;
-
+			
 			String newname = ""; //$NON-NLS-1$
 			InputDialog d = new InputDialog(shell, TXMUIMessages.newName,
-					TXMUIMessages.editTheNameOfTheNewLineCreatedByTheMergedLines, "", null); //$NON-NLS-1$ 
+					TXMUIMessages.editTheNameOfTheNewLineCreatedByTheMergedLines, "", null); //$NON-NLS-1$
 			if (d.open() == Window.OK)
 				newname = d.getValue();
 			else
 				return null;
 			if (newname.trim().equals("")) //$NON-NLS-1$
 				return null;
-
+			
 			mergeLines(LTeditor, newname, selection);
-
+			
 		}
 		return null;
 	}
-
+	
 	/**
 	 * Merges lines of the table.
 	 *
@@ -100,15 +101,15 @@
 		for (int i : selection)
 			for (int j = 0; j < cols.size(); j++)
 				fuz[j] += cols.get(j)[i];
-
+			
 		// set values in the first row of the selection
 		for (int j = 0; j < cols.size(); j++)
 			table.getData().set(selection[0], j, fuz[j]);
-
+		
 		// keep only the first selected line
 		int[] lineToDelete = new int[selection.length - 1];
 		System.arraycopy(selection, 1, lineToDelete, 0, selection.length - 1);
-		//System.out.println("Lines to delete : "+Arrays.toString(lineToDelete));
+		// System.out.println("Lines to delete : "+Arrays.toString(lineToDelete));
 		table.getData().removeRows(lineToDelete);
 		table.setAltered();
 		// reset line name
@@ -116,10 +117,11 @@
 			table.getRowNames().setString(selection[0], newname);
 			LTeditor.compute(false);
 			
-		} catch (Exception e) {
+		}
+		catch (Exception e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
 		}
 		StatusLine.setMessage(""); //$NON-NLS-1$
 	}
-}
\ No newline at end of file
+}
Index: tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/handlers/ExportLexicalTable.java
===================================================================
--- tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/handlers/ExportLexicalTable.java	(revision 2403)
+++ tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/handlers/ExportLexicalTable.java	(revision 2404)
@@ -46,11 +46,13 @@
  * The Class ExportTable.
  */
 public class ExportLexicalTable extends AbstractHandler {
-
+	
 	private static final String ID = "org.txm.rcp.commands.editor.ExportLexicalTable"; //$NON-NLS-1$
-	/* (non-Javadoc)
+	/*
+	 * (non-Javadoc)
 	 * @see org.eclipse.core.commands.AbstractHandler#execute(org.eclipse.core.commands.ExecutionEvent)
 	 */
+	
 	@Override
 	public Object execute(ExecutionEvent event) throws ExecutionException {
 		IWorkbenchPart editor = HandlerUtil.getActiveWorkbenchWindow(event)
@@ -75,7 +77,7 @@
 			}
 		}
 		return event;
-
+		
 	}
-
+	
 }
Index: tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/handlers/DeleteLines.java
===================================================================
--- tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/handlers/DeleteLines.java	(revision 2403)
+++ tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/handlers/DeleteLines.java	(revision 2404)
@@ -46,8 +46,9 @@
  * @author sjacquot
  */
 public class DeleteLines extends AbstractHandler {
-
-	/* (non-Javadoc)
+	
+	/*
+	 * (non-Javadoc)
 	 * @see org.eclipse.core.commands.AbstractHandler#execute(org.eclipse.core.commands.ExecutionEvent)
 	 */
 	@Override
@@ -56,21 +57,22 @@
 				.getShell();
 		// ISelection selection =
 		// HandlerUtil.getActiveWorkbenchWindow(event).getActivePage().getSelection();
-
+		
 		IWorkbenchPart editor = HandlerUtil.getActiveWorkbenchWindow(event)
 				.getActivePage().getActivePart();
 		if (editor instanceof LexicalTableEditor) {
 			LexicalTableEditor LTeditor = (LexicalTableEditor) editor;
 			try {
 				deleteLexicalTableLines(LTeditor);
-			} catch (Exception e) {
+			}
+			catch (Exception e) {
 				// TODO Auto-generated catch block
 				e.printStackTrace();
 			}
 		}
 		return null;
 	}
-
+	
 	/**
 	 * 
 	 * @param editor
@@ -80,12 +82,12 @@
 		int[] selection = editor.getlineTableViewer().getTable().getSelectionIndices();
 		if (selection.length == 0)
 			return;
-
+		
 		if (selection.length == editor.getLexicalTable().getNRows()) {
 			System.out.println(TXMUIMessages.theTableMustContainAtLeastOneLine);
 			return;
 		}
-
+		
 		Display d = Display.getCurrent();
 		if (d != null) {
 			Shell shell = d.getActiveShell();
@@ -94,10 +96,10 @@
 			if (messageBox.open() != SWT.YES)
 				return;
 		}
-
+		
 		editor.getLexicalTable().getData().removeRows(selection);
 		editor.getLexicalTable().setAltered();
 		editor.compute(false);
 	}
-
-}
\ No newline at end of file
+	
+}
Index: tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/handlers/___MergeCols.java
===================================================================
--- tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/handlers/___MergeCols.java	(revision 2403)
+++ tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/handlers/___MergeCols.java	(revision 2404)
@@ -43,19 +43,21 @@
 import org.txm.lexicaltable.rcp.editors.LexicalTableEditor;
 import org.txm.rcp.messages.TXMUIMessages;
 import org.txm.statsengine.core.StatException;
+
 /**
  * The Class MergeCols.
  */
 // FIXME: this class is not used?
 public class ___MergeCols extends AbstractHandler {
-
-	/* (non-Javadoc)
+	
+	/*
+	 * (non-Javadoc)
 	 * @see org.eclipse.core.commands.AbstractHandler#execute(org.eclipse.core.commands.ExecutionEvent)
 	 */
 	@Override
 	public Object execute(ExecutionEvent event) throws ExecutionException {
 		Shell shell = HandlerUtil.getActiveWorkbenchWindowChecked(event).getShell();
-
+		
 		IWorkbenchPart editor = HandlerUtil.getActiveWorkbenchWindow(event)
 				.getActivePage().getActivePart();
 		if (editor instanceof LexicalTableEditor) {
@@ -64,16 +66,16 @@
 					.getSelectionIndices();
 			if (selection.length == 0)
 				return null;
-
+			
 			String newname = ""; //$NON-NLS-1$
-			InputDialog d = new InputDialog(shell, TXMUIMessages.newName, TXMUIMessages.editTheNameOfTheNewColumnCreatedByTheMergedColumns, "", null); //$NON-NLS-1$ 
+			InputDialog d = new InputDialog(shell, TXMUIMessages.newName, TXMUIMessages.editTheNameOfTheNewColumnCreatedByTheMergedColumns, "", null); //$NON-NLS-1$
 			if (d.open() == Window.OK)
 				newname = d.getValue();
 			else
 				return null;
 			if (newname.trim().equals("")) //$NON-NLS-1$
 				return null;
-
+			
 			// sum the cols
 			int[] selectedCols = new int[3];
 			List<double[]> cols = LTeditor.getCols();
@@ -83,7 +85,8 @@
 			int nrows;
 			try {
 				nrows = table.getNRows();
-			} catch (Exception e) {
+			}
+			catch (Exception e) {
 				// TODO Auto-generated catch block
 				e.printStackTrace();
 				return null;
@@ -93,12 +96,12 @@
 					firstcol[j] += cols.get(selectedCols[i])[j];
 				}
 			}
-
+			
 			// update table
 			for (int j = 0; j < nrows; j++) {
 				table.getData().set(j, selectedCols[0], firstcol[j]);
 			}
-
+			
 			// keep only the first col
 			int[] coltodelete = new int[selectedCols.length - 1];
 			System.arraycopy(selectedCols, 1, coltodelete, 0,
@@ -108,9 +111,9 @@
 			// reset col name
 			table.getColNames().setString(selectedCols[0], newname);
 			try {
-				System.out.println(NLS.bind(TXMUIMessages.namesColon
-						, Arrays.toString(table.getRowNames().asStringsArray())));
-			} catch (Exception e1) {
+				System.out.println(NLS.bind(TXMUIMessages.namesColon, Arrays.toString(table.getRowNames().asStringsArray())));
+			}
+			catch (Exception e1) {
 				// TODO Auto-generated catch block
 				org.txm.utils.logger.Log.printStackTrace(e1);
 			}
@@ -120,4 +123,4 @@
 		}
 		return null;
 	}
-}
\ No newline at end of file
+}
Index: tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/handlers/ComputeInterTextDistance.java
===================================================================
--- tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/handlers/ComputeInterTextDistance.java	(revision 2403)
+++ tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/handlers/ComputeInterTextDistance.java	(revision 2404)
@@ -12,49 +12,50 @@
 import org.txm.utils.logger.Log;
 
 public class ComputeInterTextDistance extends AbstractHandler {
-
+	
 	private IStructuredSelection selection;
-
+	
 	@Override
 	public void addHandlerListener(IHandlerListener handlerListener) {
 		super.addHandlerListener(handlerListener);
 	}
-
+	
 	@Override
 	public void dispose() {
 		super.dispose();
 	}
-
-
+	
+	
 	@Override
 	public Object execute(ExecutionEvent event) throws ExecutionException {
 		selection = (IStructuredSelection) HandlerUtil.getCurrentSelection(event);
-
+		
 		Object s = selection.getFirstElement();
 		if (!(s instanceof LexicalTable))
 			return null;
 		LexicalTable table = (LexicalTable) s;
 		InterTextDistance dist = new InterTextDistance(table.getData());
-
+		
 		try {
 			dist._compute();
-		} catch (Exception e) {
+		}
+		catch (Exception e) {
 			System.out.println(TXMCoreMessages.bind(TXMCoreMessages.error_error, e.getLocalizedMessage()));
 			Log.printStackTrace(e);
 		}
 		return null;
 	}
-
+	
 	@Override
 	public boolean isEnabled() {
 		return super.isEnabled();
 	}
-
+	
 	@Override
 	public boolean isHandled() {
 		return super.isHandled();
 	}
-
+	
 	@Override
 	public void removeHandlerListener(IHandlerListener handlerListener) {
 		super.removeHandlerListener(handlerListener);
Index: tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/handlers/ImportTable.java
===================================================================
--- tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/handlers/ImportTable.java	(revision 2403)
+++ tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/handlers/ImportTable.java	(revision 2404)
@@ -53,11 +53,13 @@
  * The Class ImportTable.
  */
 public class ImportTable extends BaseAbstractHandler {
-
+	
 	private static final String ID = "org.txm.rcp.commands.editor.ImportTable"; //$NON-NLS-1$
-	/* (non-Javadoc)
+	/*
+	 * (non-Javadoc)
 	 * @see org.eclipse.core.commands.AbstractHandler#execute(org.eclipse.core.commands.ExecutionEvent)
 	 */
+	
 	@Override
 	public Object execute(ExecutionEvent event) throws ExecutionException {
 		IWorkbenchPart editor = HandlerUtil.getActiveWorkbenchWindow(event)
@@ -86,8 +88,9 @@
 					LTeditor.importData(file);
 				}
 			}
-		} else if (sel instanceof LexicalTable) {
-			LexicalTable lt = (LexicalTable)sel;
+		}
+		else if (sel instanceof LexicalTable) {
+			LexicalTable lt = (LexicalTable) sel;
 			Shell shell = HandlerUtil.getActiveWorkbenchWindowChecked(event)
 					.getShell();
 			FileDialog d = new FileDialog(shell, SWT.OPEN);
@@ -104,9 +107,10 @@
 						lt.compute();
 						lt.getData().importData(file, encoding, colseparator, txtseparator);
 						lt.setAltered();
-						System.out.println(NLS.bind("Data imported: {0} columns and {1} rows.",lt.getNColumns(), lt.getNRows()));
-					} catch (Exception e) {
-						System.out.println("Error: data import failed: "+e);
+						System.out.println(NLS.bind("Data imported: {0} columns and {1} rows.", lt.getNColumns(), lt.getNRows()));
+					}
+					catch (Exception e) {
+						System.out.println("Error: data import failed: " + e);
 						Log.printStackTrace(e);
 					}
 				}
Index: tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/preferences/LexicalTablePreferencePage.java
===================================================================
--- tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/preferences/LexicalTablePreferencePage.java	(revision 2403)
+++ tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/preferences/LexicalTablePreferencePage.java	(revision 2404)
@@ -45,27 +45,27 @@
  *
  */
 public class LexicalTablePreferencePage extends TXMPreferencePage {
-
-
+	
+	
 	@Override
 	public void createFieldEditors() {
 		
-		IntegerFieldEditor fmin = new IntegerFieldEditor(TXMPreferences.F_MIN, TXMCoreMessages.common_lowestFrequency, this.getFieldEditorParent()); 
+		IntegerFieldEditor fmin = new IntegerFieldEditor(TXMPreferences.F_MIN, TXMCoreMessages.common_lowestFrequency, this.getFieldEditorParent());
 		fmin.setValidRange(1, 999999999);
 		
-		IntegerFieldEditor vmax = new IntegerFieldEditor(TXMPreferences.V_MAX, TXMCoreMessages.common_numberOfLines, this.getFieldEditorParent()); 
+		IntegerFieldEditor vmax = new IntegerFieldEditor(TXMPreferences.V_MAX, TXMCoreMessages.common_numberOfLines, this.getFieldEditorParent());
 		vmax.setValidRange(1, 999999999);
 		
 		this.addField(fmin);
 		this.addField(vmax);
 		
 	}
-
+	
 	@Override
 	public void init(IWorkbench workbench) {
 		this.setPreferenceStore(new TXMPreferenceStore(LexicalTablePreferences.getInstance().getPreferencesNodeQualifier()));
 		this.setTitle(LexicalTableCoreMessages.RESULT_TYPE);
 		this.setImageDescriptor(LexicalTableAdapterFactory.ICON);
 	}
-
+	
 }
Index: tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/adapters/InterTextDistanceAdapterFactory.java
===================================================================
--- tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/adapters/InterTextDistanceAdapterFactory.java	(revision 2403)
+++ tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/adapters/InterTextDistanceAdapterFactory.java	(revision 2404)
@@ -12,22 +12,22 @@
 
 /**
  * A factory for creating Adapter objects.
- *  
+ * 
  * @author mdecorde
  * @author sjacquot
  */
 public class InterTextDistanceAdapterFactory extends TXMResultAdapterFactory {
-
 	
-	public static final ImageDescriptor ICON =
-			AbstractUIPlugin.imageDescriptorFromPlugin(FrameworkUtil.getBundle(InterTextDistanceAdapterFactory.class).getSymbolicName(),
-					"platform:/plugin/"+ FrameworkUtil.getBundle(InterTextDistanceAdapterFactory.class).getSymbolicName() + "/icons/dist.png"); //$NON-NLS-1$ //$NON-NLS-2$
 	
-
+	public static final ImageDescriptor ICON = AbstractUIPlugin.imageDescriptorFromPlugin(FrameworkUtil.getBundle(InterTextDistanceAdapterFactory.class).getSymbolicName(),
+			"platform:/plugin/" + FrameworkUtil.getBundle(InterTextDistanceAdapterFactory.class).getSymbolicName() + "/icons/dist.png"); //$NON-NLS-1$ //$NON-NLS-2$
+	
+	
 	@Override
 	public Object getAdapter(Object adaptableObject, Class adapterType) {
-		if(this.canAdapt(adapterType) && adaptableObject instanceof InterTextDistance)	{
+		if (this.canAdapt(adapterType) && adaptableObject instanceof InterTextDistance) {
 			return new TXMResultAdapter() {
+				
 				@Override
 				public ImageDescriptor getImageDescriptor(Object object) {
 					return ICON;
Index: tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/adapters/LexicalTableAdapterFactory.java
===================================================================
--- tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/adapters/LexicalTableAdapterFactory.java	(revision 2403)
+++ tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/adapters/LexicalTableAdapterFactory.java	(revision 2404)
@@ -11,22 +11,22 @@
 
 /**
  * A factory for creating Adapter objects.
- *  
+ * 
  * @author mdecorde
  * @author sjacquot
  */
 public class LexicalTableAdapterFactory extends TXMResultAdapterFactory {
-
 	
-	public static final ImageDescriptor ICON =
-			AbstractUIPlugin.imageDescriptorFromPlugin(FrameworkUtil.getBundle(LexicalTableAdapterFactory.class).getSymbolicName(),
-					"platform:/plugin/"+ FrameworkUtil.getBundle(LexicalTableAdapterFactory.class).getSymbolicName() + "/icons/lexicaltable.png"); //$NON-NLS-1$ //$NON-NLS-2$
 	
-
+	public static final ImageDescriptor ICON = AbstractUIPlugin.imageDescriptorFromPlugin(FrameworkUtil.getBundle(LexicalTableAdapterFactory.class).getSymbolicName(),
+			"platform:/plugin/" + FrameworkUtil.getBundle(LexicalTableAdapterFactory.class).getSymbolicName() + "/icons/lexicaltable.png"); //$NON-NLS-1$ //$NON-NLS-2$
+	
+	
 	@Override
 	public Object getAdapter(Object adaptableObject, Class adapterType) {
-		if(this.canAdapt(adapterType) && adaptableObject instanceof LexicalTable)	{
+		if (this.canAdapt(adapterType) && adaptableObject instanceof LexicalTable) {
 			return new TXMResultAdapter() {
+				
 				@Override
 				public ImageDescriptor getImageDescriptor(Object object) {
 					return ICON;
@@ -35,6 +35,6 @@
 		}
 		return null;
 	}
-
-
+	
+	
 }
Index: tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/messages/LexicalTableUIMessages.java
===================================================================
--- tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/messages/LexicalTableUIMessages.java	(revision 2403)
+++ tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/messages/LexicalTableUIMessages.java	(revision 2404)
@@ -10,29 +10,43 @@
  *
  */
 public class LexicalTableUIMessages extends NLS {
-
+	
 	private static final String BUNDLE_NAME = "org.txm.lexicaltable.rcp.messages.messages"; //$NON-NLS-1$
 	
-	public static String errorColonDifferentColumnsNumberColonBeforeP0AfterP1; 
-	public static String mergeOrDeleteColumns; 
-	public static String mergeColsColonP0; 
-	public static String deleteColsColonP0; 
-	public static String mergeOrDeleteRows; 
-	public static String failedToImportLexicalTable; 
-	public static String errorWhileImportingDataColonP0; 
-	public static String mergingLines; 
-	public static String userIndexOccurrences; 
-	public static String selectWhichMarginsYouWantToUse; 
-	public static String useAllOccurrences; 
-	public static String openingMargeConfigurationDialog; 
-	public static String canNotCreateALexicalTableWithAnIndexCreatedOnACorpus; 
-	public static String vocabulariesMustShareTheSamePropertiesColonP0; 
+	public static String errorColonDifferentColumnsNumberColonBeforeP0AfterP1;
+	
+	public static String mergeOrDeleteColumns;
+	
+	public static String mergeColsColonP0;
+	
+	public static String deleteColsColonP0;
+	
+	public static String mergeOrDeleteRows;
+	
+	public static String failedToImportLexicalTable;
+	
+	public static String errorWhileImportingDataColonP0;
+	
+	public static String mergingLines;
+	
+	public static String userIndexOccurrences;
+	
+	public static String selectWhichMarginsYouWantToUse;
+	
+	public static String useAllOccurrences;
+	
+	public static String openingMargeConfigurationDialog;
+	
+	public static String canNotCreateALexicalTableWithAnIndexCreatedOnACorpus;
+	
+	public static String vocabulariesMustShareTheSamePropertiesColonP0;
+	
 	public static String vocabulariesMustShareTheSamePartitionColonP0;
-
-	public static String tP0vP1fminP2fmaxP3; 
 	
-
-
+	public static String tP0vP1fminP2fmaxP3;
+	
+	
+	
 	static {
 		// initialize resource bundle
 		Utf8NLS.initializeMessages(BUNDLE_NAME, LexicalTableUIMessages.class);
Index: tmp/org.txm.lexicaltable.rcp/.classpath
===================================================================
--- tmp/org.txm.lexicaltable.rcp/.classpath	(revision 2403)
+++ tmp/org.txm.lexicaltable.rcp/.classpath	(revision 2404)
@@ -1,11 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <classpath>
-	  <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
-	  <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins">
-		    <accessrules>
-			      <accessrule kind="accessible" pattern="**"/>
-		    </accessrules>
-	  </classpathentry>
-	  <classpathentry kind="src" path="src"/>
-	  <classpathentry kind="output" path="bin"/>
+	<classpathentry kind="con"
+		path="org.eclipse.jdt.launching.JRE_CONTAINER" />
+	<classpathentry kind="con"
+		path="org.eclipse.pde.core.requiredPlugins">
+		<accessrules>
+			<accessrule kind="accessible" pattern="**" />
+		</accessrules>
+	</classpathentry>
+	<classpathentry kind="src" path="src" />
+	<classpathentry kind="output" path="bin" />
 </classpath>
\ No newline at end of file
