/ - Diff - Plateforme TXM - Forge du Centre Blaise Pascal

Révision 2404

+     *
      */
     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);
+    	}
+    }

     /**
      * 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;

     /**
      * 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;
-...
+    		}
     		return null;
+    	}
+    }

+     *
      */
     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);

+     *
      */
     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;
-...
     			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;
+    				}
+    			}
-...
     			if (partitionIndexes.size() == 0) {
     				return false;
+    			}
     			partitionIndexes = partitionIndexes.subList(0, 1);
     			for (PartitionIndex partitionIndex : partitionIndexes) {
     				if (!partitionIndex.isComputedWithPartition()) {
-...
+    			}
     			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) {
-...
     			lexicalTable = (LexicalTable) selection;
+    		}
     		// Error
     		else	{
     		else {
     			this.logCanNotExecuteCommand(selection);
+    		}
-...
     		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;
     	// }
+    }
     	// /**
     	// * 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;
     	// }
+    }

     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) {
-...
     					.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.
+    	 *
-...
     		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
-...
     			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$
+    	}
+    }
+    }

tmp/org.txm.lexicaltable.rcp/src/org/txm/lexicaltable/rcp/handlers/ExportLexicalTable.java (revision 2404)
46	46	* The Class ExportTable.
47	47	*/
48	48	public class ExportLexicalTable extends AbstractHandler {
49
	49
50	50	private static final String ID = "org.txm.rcp.commands.editor.ExportLexicalTable"; //$NON-NLS-1$
51		/* (non-Javadoc)
	51	/*
	52	* (non-Javadoc)
52	53	* @see org.eclipse.core.commands.AbstractHandler#execute(org.eclipse.core.commands.ExecutionEvent)
53	54	*/
	55
54	56	@Override
55	57	public Object execute(ExecutionEvent event) throws ExecutionException {
56	58	IWorkbenchPart editor = HandlerUtil.getActiveWorkbenchWindow(event)
...	...
75	77	}
76	78	}
77	79	return event;
78
	80
79	81	}
80
	82
81	83	}

      * @author sjacquot
      */
     public class DeleteLines extends AbstractHandler {
     	/* (non-Javadoc)
     	/*
     	 * (non-Javadoc)
     	 * @see org.eclipse.core.commands.AbstractHandler#execute(org.eclipse.core.commands.ExecutionEvent)
     	 */
     	@Override
-...
     				.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
-...
     		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();
-...
     			if (messageBox.open() != SWT.YES)
     				return;
+    		}
     		editor.getLexicalTable().getData().removeRows(selection);
     		editor.getLexicalTable().setAltered();
     		editor.compute(false);
+    	}
+    }
+    }

     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) {
-...
     					.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();
-...
     			int nrows;
     			try {
     				nrows = table.getNRows();
     			} catch (Exception e) {
+    			}
     			catch (Exception e) {
     				// TODO Auto-generated catch block
     				e.printStackTrace();
     				return null;
-...
     					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,
-...
     			// 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);
+    			}
-...
+    		}
     		return null;
+    	}
+    }
+    }

     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);

      * 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)
-...
     					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);
-...
     						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);
+    					}
+    				}

     <?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>

Formats disponibles : Unified diff

Laboratoire ICAR » Plateforme TXM

Révision 2404