Laboratoire ICAR » Plateforme TXM

		queryWidget = new AssistedQueryWidget(getMainParametersComposite(), SWT.DROP_DOWN, concordance.getCorpus());

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

		queryWidget.addKeyListener(new ComputeKeyListener(this));

		// hide the parameters panel

		getTopToolbar().setVisible(TXMEditor.COMPUTING_PARAMETERS_GROUP_ID, false); // the settings are not necessary to compute the concordance

import org.eclipse.jface.preference.BooleanFieldEditor;

import org.txm.core.preferences.TBXPreferences;

import org.txm.rcp.messages.TXMUIMessages;

/**

 * User preferences page.

 * 

import org.txm.rcp.TXMWindows;

import org.txm.rcp.handlers.BaseAbstractHandler;

import org.txm.rcp.messages.TXMUIMessages;

import org.txm.rcp.swt.GLComposite;

import org.txm.rcp.swt.widget.AssistedChoiceQueryWidget;

import org.txm.rcp.swt.widget.AssistedQueryWidget;

					monitor.beginTask(TXMUIMessages.computing_3, 100);

					notifyExtensions("notifyStartOfCompute"); //$NON-NLS-1$

					notifyExtensions("notifyEndOfCompute"); //$NON-NLS-1$

					monitor.worked(50);

import org.eclipse.swt.widgets.Event;

import org.eclipse.swt.widgets.Listener;

import org.txm.rcp.editors.TXMEditor;

import org.txm.rcp.preferences.RCPPreferences;

import org.eclipse.jface.viewers.SelectionChangedEvent;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.events.SelectionListener;

import org.eclipse.swt.widgets.Spinner;

import org.txm.core.results.TXMResult;

import org.txm.rcp.editors.TXMEditor;

	@Override

	public void widgetSelected(SelectionEvent e) {

		// this method is called on a Spinner even when a key is pressed, that's not what we want, so this test breaks the behavior

		if(RCPPreferences.getInstance().getBoolean(RCPPreferences.AUTO_UPDATE_EDITOR) && (!(e.getSource() instanceof Spinner) || e.stateMask != 0))	{

		}

	}

import org.eclipse.swt.events.KeyListener;

import org.txm.core.results.TXMResult;

import org.txm.rcp.editors.TXMEditor;

/**

 * Key listener that calls TXMEditor.compute() when the Enter key is pressed.

	public Query getQuery() {

		return this.querywidget.getQuery();

	}

}

                           property="org.txm.rcp.testers.persistable"

                           value="true">

                     </test>

                  </and>

               </visibleWhen>

            </command>

            properties="xtzCorpus"

            type="java.lang.Object">

      </propertyTester>

   </extension>

   <extension

         point="org.eclipse.ui.bindings">

	protected boolean _compute() throws Exception {

		if(this.hasParameterChanged(InternalViewPreferences.STRUCTURAL_UNIT))	{

			//find struct start-end

			CQLQuery query = new CQLQuery("<" + pStructuralUnit.getName() + "> [] expand to " + pStructuralUnit); //$NON-NLS-1$ //$NON-NLS-2$

			//System.out.println(query);

			for (Property p : pWordProperties) {

				writer.println(StringUtils.join(page.get(p), colseparator));

			}

		}

		writer.close();

		return false;

		this.pCurrentPage = currentPage;

		if(this.pCurrentPage < 0 || this.pCurrentPage > (this.nmatches - 1))	 {

			this.pCurrentPage = 0;

		}

	}

			Log.printStackTrace(e);

		}

		// Listener

		// Structural unit properties selector

		structuralUnitPropertiesSelector = new PropertiesSelector<StructuralUnitProperty>(parametersArea);

 * - set the number of property to 1 

 * - hide the query field

 * 

 */

public class LexiconEditor extends IndexEditor {

		this.queryLabel.dispose();

		// no query field -> no need to expand the zone

	}

}

import org.osgi.framework.FrameworkUtil;

import org.osgi.service.prefs.BackingStoreException;

import org.txm.Toolbox;

import org.txm.core.preferences.TBXPreferences;

import org.txm.core.preferences.TXMPreferences;

import org.txm.objects.Project;

	public static final Pattern FILE_NAME_PATTERN = Pattern.compile("[^a-zA-Z0-9\\.-]+"); //$NON-NLS-1$

	public static final String UNDERSCORE = "_";

//	/**

//	 * Unique ID of the result.

//	 */

	 */

	public TXMResult(String parametersNodePath, TXMResult parent) {

		if (parent == this) {

		}

		if (parent != null) {

			parent.addChild(this);

			this.parametersNodePath = parametersNodePath;

		}

		this.weight = 0;

		//this.children = Collections.synchronizedList(new ArrayList<TXMResult>()); // FIXME: SJ: can fix the conccurent excpetion if needed

		this.commandPreferencesNodePath = FrameworkUtil.getBundle(getClass()).getSymbolicName(); //$NON-NLS-1$

		this.visible = true;

				parent == null && 

				this.parametersNodePath != null && 

				!parentNodePath.isEmpty()) {

			TXMResult retrievedParent = TXMResult.getResult(parentNodePath);

			if (retrievedParent != null) {

				retrievedParent.addChild(this);

			}

			else {

				// FIXME: commented for now

				//TBXPreferences.delete(this);

				return;

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

			this.loadParameters();  // subclasses manual settings

		} catch (Exception e) {

			Log.printStackTrace(e);

		}

		// Log

		if (this.parent == null)	{

		}

		try {

	}

	/**

	 */

		this.frozen = true;

	}

	/**

	 */

		this.frozen = false;

	}

	/**

	 */

	public void setFrozen(boolean frozen) {

		this.frozen = frozen;

		return UUID_PREFIX + ID_TIME_FORMAT.format(new Date(System.currentTimeMillis())) + "_" + nextInt();

	}

	/**

	 * 

	 * @return the next integer in the current session of TXM

	 */

	private static synchronized String nextInt() {

	}

	/**

			this.saveParameter(TXMPreferences.PARENT_PARAMETERS_NODE_PATH, this.parent.getParametersNodePath());

		}

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

			if (parameter == null || parameter.type() != parameterType) {

				continue;

			}

			String key = parameter.key();

			if (key.isEmpty()) {

	 */

	protected boolean compute(IProgressMonitor monitor, boolean deepComputing) {

		try {

			Log.finest("*** TXMResult.compute(): " + this.getClass().getSimpleName() + ": starting computing process...");

			// FIXME: see if this skipComputing tests is still useful? is it possible to directly return instead?

			boolean skipComputing = false;

			this.monitor = monitor;

			if (this.parent != null && !(this.parent instanceof Project) && !(this.parent instanceof Workspace)) {

				Log.finest("TXMResult.compute(): " + this.getClass().getSimpleName() + ": starting parent (" + this.parent.getClass().getSimpleName() + ") computing process...");

			if(!skipComputing)	{

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

				// Computing requirements test

				if (!this.canCompute()) {

					return false;

				}

				// Computing

				if (!this._compute()) {

					return false;

				}

			}

			if(!skipComputing)	{

				if (!this.autoSaveParametersFromAnnotations()) {

					Log.severe("TXMResult.compute(): " + this.getClass().getSimpleName() + ": failed to save parameters from annotations for " + this.getName() + ".");

				}

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

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

						this.children.get(i).compute(monitor, deepComputing);

					}

					// FIXME: SJ: this code generates concurrent modification exceptions when deep computing

					//				for (TXMResult child : this.getChildren()) {

					//					// recompute only children that has been opened once

					//					child.compute(monitor, deepComputing);

					//				}

		catch (Exception e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

			return false;

		}