Laboratoire ICAR » Plateforme TXM

    exit 1 ;

fi

	public TXMResultAdapter() {

		// TODO Auto-generated constructor stub

	}

	@Override

	public Object[] getChildren(Object result) {

		return ((TXMResult) result).getChildren(!TBXPreferences.getBoolean(TBXPreferences.SHOW_ALL_RESULT_NODES, TBXPreferences.PREFERENCES_NODE)).toArray();

	@Override

	public String getLabel(Object result) {

		}

	}

	@Override

import java.util.HashMap;

import java.util.List;

import org.eclipse.core.commands.Command;

import org.eclipse.core.commands.common.NotDefinedException;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.eclipse.jface.action.MenuManager;

import org.eclipse.jface.viewers.DecoratingLabelProvider;

import org.eclipse.jface.viewers.DoubleClickEvent;

import org.eclipse.jface.viewers.IDoubleClickListener;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.jface.viewers.TreeSelection;

import org.eclipse.jface.viewers.TreeViewer;

import org.eclipse.jface.viewers.Viewer;

import org.eclipse.jface.viewers.ViewerSorter;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.KeyAdapter;

import org.eclipse.swt.events.KeyEvent;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.events.SelectionListener;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Menu;

import org.eclipse.swt.widgets.TreeItem;

import org.eclipse.ui.IWorkbenchPage;

import org.eclipse.ui.IWorkbenchWindow;

import org.eclipse.ui.PartInitException;

import org.eclipse.ui.commands.ICommandService;

import org.eclipse.ui.contexts.IContextService;

import org.eclipse.ui.handlers.IHandlerService;

import org.eclipse.ui.part.ViewPart;

import org.txm.Toolbox;

import org.txm.core.results.TXMResult;

import org.txm.objects.Project;

import org.txm.objects.Workspace;

import org.txm.rcp.StatusLine;

import org.txm.rcp.editors.TXMEditor;

import org.txm.rcp.handlers.BaseAbstractHandler;

import org.txm.rcp.handlers.results.DeleteObject;

import org.txm.rcp.messages.TXMUIMessages;

import org.txm.rcp.utils.JobHandler;

import org.txm.searchengine.cqp.corpus.Corpus;

import org.txm.searchengine.cqp.corpus.Partition;

import org.txm.searchengine.cqp.corpus.Subcorpus;

import org.txm.utils.logger.Log;

	 */

	private static HashMap<Class, Class> managedDoubleClickClasses = new HashMap<Class, Class>();

	public static HashMap<String, String> doubleClickInstalledCommands = new HashMap<String, String>();

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

		return managedDoubleClickClasses;

	}

	/**

	 * Gets the single instance of CorporaView.

	 *

		PlatformUI.getWorkbench().getHelpSystem().setHelp(

				treeViewer.getControl(), TXMUIMessages.CorporaView_0);

		getSite().setSelectionProvider(treeViewer);

//			@Override

//			}

//		});

		treeViewer.setContentProvider(new TXMResultContentProvider(this));

		//treeViewer.setLabelProvider(new TextometrieLabelProvider());

		treeViewer.setLabelProvider(

				new DecoratingLabelProvider(new TXMResultLabelProvider(),

						PlatformUI.getWorkbench().getDecoratorManager().getLabelDecorator()));

		// for now the sorter is used to sort the Corpus, Subcorpus and partition objects

		treeViewer.setSorter(new ViewerSorter() {

					return cat1 - cat2;

				}

		});

		if (Toolbox.isInitialized()) {

			Workspace w = null;

			while (w == null) {

				// FIXME: define here what to display

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

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

				StatusLine.setMessage(mess);

			}

				e1.printStackTrace();

			}

		}

		treeViewer.addDoubleClickListener(new IDoubleClickListener() {

			@Override

			public void doubleClick(DoubleClickEvent event) {

				Object selectedItem = selection.getFirstElement();

				//System.out.println("dbl click: "+selectedItem);

				if (selectedItem != null) {

					// FIXME: this code should be in conflict with the native RCP system based in EditorInput.equals(), see if we can remove it

					String commandId = doubleClickInstalledCommands.get(selectedItem.getClass().getName());

					if (commandId != null) {

						BaseAbstractHandler.executeCommand(commandId);

					}

					// test if a double click listener has been set

					Class commandClass = managedDoubleClickClasses.get(selectedItem.getClass());

					//System.out.println("classes: "+managedDoubleClickClasses);

						}

					}

				}

			}

		});

			public void run() {

				//FIXME: Debug

				CorporaView corporaView = getInstance();

				corporaView.treeViewer.refresh(); // FIXME: without that the refresh sometimes doesn't work, need to investigate (after some test it may occurs when a hierarchy of more than one result is created. Need to refresh all the hierarchy result one by one?)

				corporaView.treeViewer.refresh(result);

				try {

	 * @param resultDataClass

	 * @param commandClass

	 */

}

Manifest-Version: 1.0

Export-Package: junit.extensions,junit.framework,junit.runner,junit.te

 xtui,org.apache.commons.cli,org.apache.commons.lang,org.apache.common

 s.lang.builder,org.apache.commons.lang.enum,org.apache.commons.lang.e

	public boolean startEngines(IProgressMonitor monitor) {

		for (AnnotationEngine e : engines.values()) {

//			AnnotationEngine se = (AnnotationEngine)e;

//			if (monitor != null) monitor.subTask("Starting "+ se.getName()+" annotation engine.");

//			try {

	@Override

	public String getDetails() {

		try {

		} catch (CqiClientException e) {

			return "corpus not ready.";

		}

Properties_2  = ** Erreur

Properties_22 = Propriétés des structures (max {0} valeurs)

Properties_26 = Pas de propriété

Properties_4  = \ propriétés

Properties_40 = * Statistiques Générales\n

Properties_41 = - T

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.OutputStreamWriter;

import java.io.UnsupportedEncodingException;

import java.util.ArrayList;

import java.util.Collections;

import org.txm.searchengine.cqp.corpus.StructuralUnitProperty;

import org.txm.searchengine.cqp.corpus.WordProperty;

import org.txm.utils.AsciiUtils;

import org.txm.utils.logger.Log;

/**

	 * @return true, if successful

	 */

	public boolean toTxt(File outfile, String encoding, int maxvalue) {

		try {

			writer.write(this.dump(maxvalue));

			writer.close();

			org.txm.utils.logger.Log.printStackTrace(e);

			return false;

		}

	 * @return true, if successful

	 */

	public boolean toHTML(File outfile) {

		try {

			writer.write(this.htmlDump());

			writer.close();

		} catch (IOException e) {

public abstract class TXMPreferences extends AbstractPreferenceInitializer {

	public static IScopeContext scope = InstanceScope.INSTANCE;

	/**

	 * Alternative nodes to look up when getting a preference.

	 */

	public static ArrayList<String> alternativeNodesQualifiers = new ArrayList<String>();

	/**

	 * Default unit/token property String.

	/**

	 * The user name. To rename a result but also to store the simple name for unserialization and lazy loading.

	 */

	/**

	 * The command preferences node qualifier.

	 */

	public TXMResult(String uuid) {

		this(uuid, null);

	}

	/**

	 * Creates a new TXMResult, child of the specified parent.

	 * If UUID is null, a new UUID is generated.

		else	{

			this.uniqueID = uuid;

		}

		this.weight = 0;

		this.visible = true;

		if (parent != null) {

			Log.warning("The TXMResult " + this.getClass() + " was attached to no parent.");

		}

		this.children = new ArrayList<TXMResult>(1);

		//		Base binaryCorpus = this.getBinaryCorpus();

		//		if (binaryCorpus != null && this.getClass() != Base.class) {

		this.dirty = true;

		// retrieving parent from UUID

		if(parent == null && uuid != null && !this.getStringParameterValue(TXMPreferences.PARENT_UUID).isEmpty())	{

			TXMResult retrievedParent = TXMResult.getResult(this.getStringParameterValue(TXMPreferences.PARENT_UUID));

				Log.warning("Parent retrieved from UUID: " + retrievedParent + ".");

				retrievedParent.addChild(this);

			}

		}

		// loads parameters from local result node, current command preferences or default command preferences

		try {

			this.autoLoadParametersFromAnnotations(); // auto fill from Parameter annotations

			this.loadParameters();  // subclasses manual settings

		} catch (Exception e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

	}

	public void setUserName(String name) {

	}

	/**

		}

		return null;

	}

	/**

	 * Gets a member field according to its key.

	 * @param key

	 * @return the field if exists otherwise null

	 */

	public Field getField(String key)	{

		Field field = null; 

		List<Field> fields = this.getAllFields();

		for (Field f : fields) {

				break;

			}

		}

		return field;

	}

	/**

	 * Returns all the member fields of the class instance.

	 * @return the list of declared fields

		// internal data to save for unserialization

		this.saveParameter("class", this.getClass().getName());

		// store the user name if exists otherwise the simple name

			this.saveParameter(TXMPreferences.NAME, this.getSimpleName());

		}

		this.saveParameter(TXMPreferences.RESULT_UUID, this.uniqueID);

		if(this.parent != null)	{

			this.saveParameter(TXMPreferences.PARENT_UUID, this.parent.getUUID());

		}

		List<Field> fields = this.getAllFields();

		for (Field f : fields) {

			targetField.setAccessible(true);

			// FIXME: debug

			targetField.set(this, value);

		}

		return false;

	}

	/**

	 * Gets a child specified by its index in the children list.

	 * @param index

			return null;

		}

	}

	/**

	 * Adds a child result to this result.

	 * If the child already have a parent, the child will be remove from its old parent children.

	 * @return the first child if exists otherwise null

	 */

	synchronized public TXMResult getFirstChild(Class type) {

			return children.get(0);

		}

		catch (Exception e) {

		}

	}

	/**

	 * Gets the first child.

	 * @param classSimpleName

		else	{

			ArrayList<TXMResult> results = root.getDeepChildren();

			for (int i = 0; i < results.size(); i++) {

				// FIXME: skipping invisible results

				if(!results.get(i).isVisible())	{

					continue;

				}

				if(results.get(i).getUUID().equals(UUID))	{

					result = results.get(i);

					break;

		}

		return result;

	}

	/**

	 * Gets the TXMResult specified by its UUID in the children of the Toolbox Workspace member.

	 * @param UUID

	synchronized public static TXMResult getResult(String UUID)	{

		return getResult(Toolbox.workspace, UUID);

	}

	/**

	 * Filters the nodes specified by their class and their visibility state.

	 * 

		return node;

	}

	/**

	 * Gets the first parent of the specified class, eg. this.getFirstParent(Partition.class);

	 * Returns the object itself if it is of the specified class.

	public abstract boolean canCompute() throws Exception;

	/**

	 */

		String mess = this.getDetails();

		if (mess != null)

			return mess.replace("\n", "  ");

		return this.compute(monitor, true);

	}

	/**

	 * 

	 * @param monitor

	public boolean compute(IProgressMonitor monitor, boolean deepComputing) throws Exception	{

		return this.compute(monitor, deepComputing, true);

	}

	/**

	 * Computes the result if 

	 * it can be computed 

	protected boolean compute(IProgressMonitor monitor, boolean deepComputing, boolean updateLastParameters) throws Exception {

		boolean skipComputing = false;

		this.monitor = monitor;

		if (!this.isDirty() && !this.isDirtyFromHistory()) {

			skipComputing = true;

		}

		if(!skipComputing)	{

			// FIXME: Debug

			Log.finest("TXMResult.compute(): " + this.getClass().getSimpleName() + ": computing result of type " + this.getClass() + "...");

			//		// TODO THIS IS FUCKING LAZY LINE CODES OH YEAH YOU MAD BRO

			// TODO where do we put this parent compute ? :o

			//		if (parent != null && !parent.getHasBeenComputedOnce()) { // parent must be computed at least one time

			if (parent != null && !parent.hasBeenComputedOnce()) { 

				if (!this.parent.compute(monitor, false, updateLastParameters)) {

					Log.finest("TXMResult.compute(): " + this.getClass().getSimpleName() + ": failed to compute parent result.");

					//return false;

				}

			}

			// Computing requirements test

			if (!this.canCompute()) {

				// FIXME: Debug

				Log.finest("TXMResult.compute(): " + this.getClass().getSimpleName() + ": missing or wrong parameters, computing aborted.");

				return false;

			}

			// Computing

			if (!this._compute()) {

				// FIXME: Debug

				Log.finest("TXMResult.compute(): " + this.getClass().getSimpleName() + ": computing failed.");

				return false;

			}

			// FIXME: Children cascade computing

			if(deepComputing)	{

				// FIXME: Debug

				Log.finest("TXMResult.compute(): " + this.getClass().getSimpleName() + ": cascade computing of " + this.children.size() + " children.");

				for (int i = 0; i < this.children.size(); i++) {

					this.getChild(i).setDirty(); // force recomputing even if some parameters of the result itself have not changed

					this.getChild(i).compute(monitor, deepComputing, updateLastParameters);

				}

			}

		}

		// store last used parameters

		if(updateLastParameters)	{

			this.updateLastParameters();

	}

	/**

	 */

	public String getUserName() {

	}

	@Override

	public static int compare(TXMResult e1, TXMResult e2) {

		if (e1 == null && e2 == null) return 0;

		if (e1 == null) return 1;

		return e1.getUUID().compareTo(e2.getUUID());

	}

}

Error_CONNECTION_FAILED = ** Echec de connexion au moteur de recherche avec les paramètres suivants : 

FMAX_1 = Fmax : 

common_query           = Requête :

common_reference       = Référence

common_rows            = Lignes

common_structure       = Structure

common_units           = Unités

Error_CONNECTION_FAILED = ** Error : while connection to search engine, with the following parameters: 

FMAX_1 = Fmax: 

FMAX_2 = , fmax 

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

			try {

				T e = (T)contributions[i].createExecutableExtension("class"); //$NON-NLS-1$

				if (e.initialize()) {

					this.engines.put(e.getName(), e);

			// Query:

			getMainParametersComposite().getLayout().numColumns = 4;

			// make

			miniInfoLabel = new Label(getMainParametersComposite(), SWT.NONE);

			miniInfoLabel.setText("No query - ");

			});

			// System.out.println(parent.getLayout());

			Composite mainPanel = this.getExtendedParametersComposite();

			mainPanel.setLayoutData(gridData);

			GridLayout glayout = new GridLayout(2, false);

			glayout.marginBottom = glayout.marginTop = glayout.marginHeight = glayout.verticalSpacing = 0;

		this.maxPropertiesToDisplay.setLayoutData(gdata);

		this.maxPropertiesToDisplay.addSelectionListener(new ComputeSelectionListener(this));

		editComposite.setLayout(GLComposite.createDefaultLayout(3));

		Label nameLabel = new Label(editComposite, SWT.NONE);

		nameText = new Text(editComposite, SWT.BORDER);

		nameText.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));

		nameSaveButton = new Button(editComposite, SWT.PUSH);

		nameSaveButton.addSelectionListener(new SelectionListener() {

			@Override

			public void widgetSelected(SelectionEvent e) {

		});

		Label descLabel = new Label(editComposite, SWT.NONE);

		descriptionText = new StyledText(editComposite, SWT.BORDER|SWT.V_SCROLL);

		descriptionText.setLayoutData(GridDataFactory.fillDefaults().hint(400, 100).minSize(400, 100).span(1, 2).create());

		descriptionSaveButton = new Button(editComposite, SWT.PUSH);

		descriptionSaveButton.addSelectionListener(new SelectionListener() {

			@Override

			public void widgetSelected(SelectionEvent e) {