Laboratoire ICAR » Plateforme TXM

package org.txm.treesearch.rcp.tester;

import java.io.File;

import java.util.List;

import org.eclipse.core.expressions.PropertyTester;

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

import org.txm.treesearch.command.ComputeTreeSearch;

/**

 * PropertyTester to check if a corpus has TreeSearchTester indexes

 * 

 * @author mdecorde

 *

 */

public class TreeSearchTester extends PropertyTester {

	public static final String PROPERTY_NAMESPACE = "org.txm.rcp.testers"; //$NON-NLS-1$

	public static final String TREESEARCH_READY = "TreeSearchReady"; //$NON-NLS-1$

	public TreeSearchTester() {

		// TODO Auto-generated constructor stub

	}

	@Override

	public boolean test(Object receiver, String property, Object[] args, Object expectedValue) {

		if (!TREESEARCH_READY.equals(property)) return false;

		if (receiver == null) {

			return false;

		}

		if (receiver instanceof List) {

			List l = ((List)receiver);

			if (l.size() == 0) {

				return false;

			}

			receiver = l.get(0);

			if (!(receiver instanceof MainCorpus)) return false;

			MainCorpus corpus = (MainCorpus) receiver;

			if (!(receiver instanceof MainCorpus)) {

				return false;

			}

			if (corpus.getProjectDirectory() == null) return false;

			return ComputeTreeSearch.getSelectorForCorpus(corpus, null) != null; // any TreeSearch available ?

		}

		return false;

	}

}

package org.txm.treesearch.editor;

import java.io.File;

import java.io.IOException;

import java.util.Arrays;

import java.util.HashMap;

import org.eclipse.swt.SWT;

import org.eclipse.swt.browser.Browser;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.events.SelectionListener;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Combo;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Event;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.Listener;

import org.eclipse.swt.widgets.Spinner;

import org.eclipse.ui.IEditorInput;

import org.eclipse.ui.IEditorSite;

import org.eclipse.ui.PartInitException;

import org.txm.Toolbox;

import org.txm.concordance.rcp.messages.ConcordanceUIMessages;

import org.txm.core.preferences.TXMPreferences;

import org.txm.core.results.Parameter;

import org.txm.edition.rcp.handlers.OpenEdition;

import org.txm.rcp.IImageKeys;

import org.txm.rcp.editors.TXMEditor;

import org.txm.rcp.editors.TXMResultEditorInput;

import org.txm.rcp.swt.GLComposite;

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

import org.txm.rcp.views.QueriesView;

import org.txm.rcp.views.corpora.CorporaView;

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

import org.txm.treesearch.command.ComputeTreeSearch;

import org.txm.treesearch.function.TreeSearch;

import org.txm.treesearch.function.TreeSearchSelector;

import org.txm.treesearch.preferences.TreeSearchPreferences;

//import org.txm.stat.engine.r.RDevice;

import org.txm.utils.logger.Log;

//import org.txm.functions.queryindex.QueryIndex;

public class TreeSearchEditor extends TXMEditor<TreeSearch> {

	/** The Constant ID. */

	public static final String ID = TreeSearchEditor.class.getName();

	public Object source;

	public CQPCorpus corpus;

	File svgFile;

	Browser svgPanel;

	@Parameter(key = TXMPreferences.INDEX)

	Spinner sentSpinner;

	@Parameter(key = TXMPreferences.SUB_INDEX)

	Spinner subSpinner;

	Button okButton;

	private HashMap<String, TreeSearch> tsPerRepresentation = null;

	private TreeSearchSelector currentSelector = null;

	@Parameter(key = TXMPreferences.QUERY)

	private LargeQueryField queryArea;

	private Label subCounterLabel;

	private Label sentCounterLabel;

	@Parameter(key = TreeSearchPreferences.NTFEATURE)

	private Combo NTCombo;

	@Parameter(key = TreeSearchPreferences.TFEATURE)

	private Combo TCombo;

	private Combo representationCombo;

	private Label representationLabel;

	@Override

	public void _createPartControl() {

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

		getMainParametersComposite().getLayout().makeColumnsEqualWidth = false;

		SelectionListener selChangedListener = new SelectionListener() {

			@Override

			public void widgetSelected(SelectionEvent e) {

				HashMap<String, TreeSearchSelector> selectors = ComputeTreeSearch.getSelectorsForCorpus(corpus);

				boolean updateFields = false;

				if (representationCombo.getText().equals("TIGER") && !currentSelector.getEngine().equals("TIGER")) {

					currentSelector = selectors.get("TIGER");

					if (!tsPerRepresentation.containsKey("TIGER")) {

						tsPerRepresentation.put("TIGER", currentSelector.getTreeSearch(corpus));

					}

					updateFields = true;

				} else if (representationCombo.getText().equals("UD") && !currentSelector.getEngine().equals("UD")) {

					currentSelector = selectors.get("UD");

					if (!tsPerRepresentation.containsKey("UD")) {

						tsPerRepresentation.put("UD", currentSelector.getTreeSearch(corpus));

					}

					updateFields = true;

				}

				if (updateFields) {

					queryArea.setQueryClass(currentSelector.getQueryClass());

					initializeFields();

					getEditorInput().setResult(tsPerRepresentation.get(currentSelector.getEngine()));

					representationLabel.setImage(IImageKeys.getImage(tsPerRepresentation.get(currentSelector.getEngine()).getIconPath()));

					//if (e.widget == sentSpinner && tsPerRepresentation.get(currentSelector.getEngine()).hasSubMatchesStrategy()) {

					subSpinner.setSelection(1);

					subSpinner.setMaximum(tsPerRepresentation.get(currentSelector.getEngine()).getNSubGraph(sentSpinner.getSelection() - 1));

					subCounterLabel.setText("/" + tsPerRepresentation.get(currentSelector.getEngine()).getNSubGraph(sentSpinner.getSelection() - 1));

					//}

				}

				TreeSearchEditor.this.compute(true);

				//reloadGraph();

			}

			@Override

			public void widgetDefaultSelected(SelectionEvent e) {}

		};

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

		representationLabel.setImage(IImageKeys.getImage(tsPerRepresentation.get(currentSelector.getEngine()).getIconPath()));

		representationLabel.setToolTipText("Current representation");

		representationCombo = new Combo(getMainParametersComposite(), SWT.READ_ONLY);

		GridData gdataR = new GridData(SWT.FILL, SWT.CENTER, true, true);

		representationCombo.setLayoutData(gdataR);

		representationCombo.addSelectionListener(selChangedListener);

		Button editionButton = new Button(getMainParametersComposite(), SWT.PUSH);

		editionButton.setImage(IImageKeys.getImage(IImageKeys.EDITION));

		editionButton.addSelectionListener(new SelectionListener() {

			@Override

			public void widgetSelected(SelectionEvent e) {

				try {

					String[] currentMatch = TreeSearchEditor.this.getResult().getTextAndWordIDSOfCurrentSentence();

					if (currentMatch == null || currentMatch.length != 2 || currentMatch[0] == null || currentMatch[1] == null) {

						return;

					}

					String textId = currentMatch[0];

					String wordId = currentMatch[1];

					OpenEdition.openEdition(corpus, null, textId, null, wordId);

				}

				catch (Exception e1) {

					// TODO Auto-generated catch block

					e1.printStackTrace();

				}

			}

			@Override

			public void widgetDefaultSelected(SelectionEvent e) { }

		});

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

		Composite queryPanel = this.getExtendedParametersGroup();

		// fill query Area

		GridLayout qlayout = new GridLayout(13, false);

		queryPanel.setLayout(qlayout);

		queryArea = new LargeQueryField(queryPanel, SWT.BORDER | SWT.V_SCROLL | SWT.H_SCROLL, currentSelector.getQueryClass());

		GridData queryAreaLayoutData = new GridData(GridData.FILL, GridData.FILL, true, true);

		queryAreaLayoutData.horizontalSpan = 13;

		queryAreaLayoutData.heightHint = 80;

		queryAreaLayoutData.minimumHeight = 80;

		queryArea.setLayoutData(queryAreaLayoutData);

		queryArea.addListener(SWT.KeyDown, new Listener() {

			@Override

			public void handleEvent(Event e) {

				if (e.stateMask == SWT.CTRL) {

					if (e.keyCode == SWT.CR || e.keyCode == SWT.KEYPAD_CR) {

						e.doit = false;

						compute(false);

					}

				}

			}

		});

		new Label(queryPanel, SWT.NONE).setText("T ");

		TCombo = new Combo(queryPanel, SWT.READ_ONLY);

		GridData gdata = new GridData(SWT.FILL, SWT.CENTER, true, true);

		TCombo.setLayoutData(gdata);

		TCombo.addSelectionListener(selChangedListener);

		new Label(queryPanel, SWT.NONE).setText("NT ");

		NTCombo = new Combo(queryPanel, SWT.READ_ONLY);

		gdata = new GridData(SWT.FILL, SWT.CENTER, true, true);

		NTCombo.setLayoutData(gdata);

		NTCombo.addSelectionListener(selChangedListener);

		GLComposite navigationAreaComposite = getBottomToolbar().installGLComposite(ConcordanceUIMessages.navigation, 10, false);

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

		// fill param Area

		gdata = new GridData(SWT.FILL, SWT.CENTER, true, true);

		new Label(navigationAreaComposite, SWT.NONE).setText("Sent ");

		sentSpinner = new Spinner(navigationAreaComposite, SWT.BORDER);

		sentSpinner.setMinimum(1);

		sentSpinner.setIncrement(1);

		sentSpinner.setMaximum(10000000);

		sentSpinner.setSelection(1);

		gdata = new GridData(SWT.FILL, SWT.CENTER, false, true);

		sentSpinner.setLayoutData(gdata);

		sentSpinner.addSelectionListener(selChangedListener);

		sentCounterLabel = new Label(navigationAreaComposite, SWT.NONE);

		gdata = new GridData(SWT.FILL, SWT.CENTER, true, true);

		sentCounterLabel.setLayoutData(gdata);

		//if (tsPerRepresentation.get(currentSelector.getEngine()).hasSubMatchesStrategy()) {

		new Label(navigationAreaComposite, SWT.NONE).setText("Sub ");

		subSpinner = new Spinner(navigationAreaComposite, SWT.BORDER);

		subSpinner.setMinimum(1);

		subSpinner.setIncrement(1);

		subSpinner.setMaximum(100000000);

		subSpinner.setSelection(1);

		gdata = new GridData(SWT.FILL, SWT.CENTER, false, true);

		subSpinner.setLayoutData(gdata);

		subSpinner.addSelectionListener(selChangedListener);

		subCounterLabel = new Label(navigationAreaComposite, SWT.NONE);

		gdata = new GridData(SWT.FILL, SWT.CENTER, true, true);

		subCounterLabel.setLayoutData(gdata);

		//}

		Composite mainPanel = this.getResultArea();

		svgPanel = new Browser(mainPanel, SWT.EMBEDDED | SWT.NO_BACKGROUND);

		svgPanel.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));

		//this.getTopToolbar().setVisible(COMPUTING_PARAMETERS_GROUP_ID, true);

		initializeFields();

	}

	protected void initializeFields() {

		//String id = corpus.getID();

		//if (ts.isReady()) {

		TreeSearch ts = tsPerRepresentation.get(currentSelector.getEngine());

		this.queryArea.setText(ts.getQuery());

		String[] tFeatures = ts.getAvailableTProperties();

		if (tFeatures.length > 0) {

			TCombo.setItems(tFeatures);

			TCombo.setText(tFeatures[0]);

		}

		String[] ntFeatures = ts.getAvailableNTProperties();

		if (ntFeatures.length > 0) {

			NTCombo.setItems(ntFeatures);

			NTCombo.setText(ts.getNT());

		}

		if (representationCombo.getItemCount() == 0) {

			HashMap<String, TreeSearchSelector> selectors = ComputeTreeSearch.getSelectorsForCorpus(corpus);

			Log.fine("Syntax representations: "+selectors);

			String[] values = selectors.keySet().toArray(new String[selectors.size()]);

			representationCombo.setItems(values);

			String defaultEngine = ts.getEngine();//TreeSearchPreferences.getInstance().getString(TreeSearchPreferences.DEFAULT_REPRESENTATION);

			representationCombo.select(Arrays.binarySearch(values, defaultEngine));

			if (representationCombo.getItemCount() == 1) {

				representationCombo.setVisible(false);

			}

		}

		if (ts.isComputed()) {

			queryArea.setText(ts.getQuery());

			sentCounterLabel.setText("/" + ts.getNSentences());

			subCounterLabel.setText("/" + ts.getNSubGraph(0));

		}

		else {

			sentCounterLabel.setText("No Sentence");

			if (ts.hasSubMatchesStrategy()) subCounterLabel.setText("No sub graph");

		}

		if (ts.isDrawn()) {

			sentSpinner.setSelection(1);

			sentSpinner.setMaximum(ts.getNSentences());

			//if (ts.hasSubMatchesStrategy()) {

			subSpinner.setSelection(ts.getSub(0));

			subSpinner.setMaximum(ts.getNSubGraph(0));

			//}

			try {

				reloadGraph();

			}

			catch (Exception e) {

				System.out.println("Error during TreeSearch initialization: " + e);

				Log.printStackTrace(e);

			}

		}

		else {

			sentSpinner.setSelection(1);

			if (ts.hasSubMatchesStrategy()) subSpinner.setSelection(1);

			if (ts.isComputed()) {

				sentSpinner.setMaximum(ts.getNSentences());

				if (ts.hasSubMatchesStrategy()) subSpinner.setMaximum(ts.getNSubGraph(0));

			}

			else {

				sentSpinner.setMaximum(1);

				if (ts.hasSubMatchesStrategy()) subSpinner.setMaximum(1);

			}

		}

		//		}

		//		else {

		//			System.out.println("Corpus '" + id + "' is not ready.");

		//			return;

		//		}

	}

	/**

	 * 

	 * @return 1..N sentences

	 */

	public int getNSent() {

		return this.sentSpinner.getSelection();

	}

	public File getSVGFile() {

		return svgFile;

	}

	@Override

	public void updateResultFromEditor() {

		String query = this.queryArea.getText();

		this.queryArea.setText(query.trim());

	}

	@Override

	public void updateEditorFromResult(boolean update) {

		//		if (update == false) {

		//			//initializeFields();

		//		}

		// final String query = queryArea.getText().trim();

		// if (query.length() == 0) {

		// System.out.println("No query, aborting.");

		// return;

		// }

		// JobHandler jobhandler = new JobHandler("", this.svgPanel.getParent()) {

		// @Override

		// protected IStatus run(IProgressMonitor monitor) {

		try {

			TreeSearch ts = tsPerRepresentation.get(currentSelector.getEngine());

			if (ts.getNSentences() > 0) {

				sentCounterLabel.setText("/" + ts.getNSentences());

				if (ts.hasSubMatchesStrategy()) subCounterLabel.setText("/" + ts.getNSubGraph(0));

				sentSpinner.setSelection(ts.getCurrentMatchIndex());

				sentSpinner.setMaximum(ts.getNSentences());

				subSpinner.setSelection(ts.getCurrentSubMatchIndex());

				subSpinner.setMaximum(ts.getNSubGraph(0));

				reloadGraph();

			}

			CorporaView.refresh();

			CorporaView.expand(corpus);

			QueriesView.refresh();

		}

		catch (Exception e) {

			System.out.println("Error while computing the Tree: " + e);

			Log.printStackTrace(e);

		}

		// JobsTimer.stopAndPrint();

		// return Status.OK_STATUS;

		// }

		// };

		// jobhandler.startJob();

	}

	/**

	 * Reload graph.

	 */

	private boolean reloadGraph() {

		String T = TCombo.getText();

		String NT = NTCombo.getText();

		int sent = sentSpinner.getSelection() - 1;

		int sub = 0;

		TreeSearch ts = tsPerRepresentation.get(currentSelector.getEngine());

		if (ts.hasSubMatchesStrategy()) sub = subSpinner.getSelection() - 1;

		ts.setIndexAndSubIndex(sent, sub);

		if (ts == null) return false; // no result

		if (!ts.isComputed()) return false;

		try {

			if (ts.toSVG(svgFile, sent, sub, T, NT)) {

				Log.finer("SVG file: "+svgFile);

				svgPanel.setUrl(svgFile.toURI().toURL().toString());

				svgPanel.layout();

				svgPanel.redraw();

			}

			else {

				Log.warning("Error: Fail to generate SVG file: "+svgFile);

			}

		}

		catch (Exception e1) {

			Log.printStackTrace(e1);

			return false;

		}

		return true;

	}

	@Override

	public void _setFocus() {

		if (queryArea != null)

			queryArea.forceFocus();

	}

	@SuppressWarnings("unchecked")

	@Override

	public void init(IEditorSite site, IEditorInput input)

			throws PartInitException {

		setSite(site);

		setInput(input);

		File resultDir = new File(Toolbox.getTxmHomePath(), "results"); //$NON-NLS-1$

		resultDir.mkdirs();

		try {

			svgFile = File.createTempFile("TreeSearch", ".svg", resultDir);

		}

		catch (IOException e) {

			System.out.println("Error: " + e.getLocalizedMessage());

			Log.printStackTrace(e);

		}

		Log.fine(svgFile.toString());

		TXMResultEditorInput<TreeSearch> ii = (TXMResultEditorInput<TreeSearch>) input;

		tsPerRepresentation = new HashMap<>();

		tsPerRepresentation.put(ii.getResult().getEngine(), ii.getResult());

		currentSelector = ii.getResult().getSelector();

		corpus = (CQPCorpus) ii.getResult().getCorpus();

	}

}

// Copyright © 2010-2020 ENS de Lyon., University of Franche-Comté

// Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of

// Lyon 2, University of Franche-Comté, University of Nice

// Sophia Antipolis, University of Paris 3.

// 

// The TXM platform is free software: you can redistribute it

// and/or modify it under the terms of the GNU General Public

// License as published by the Free Software Foundation,

// either version 2 of the License, or (at your option) any

// later version.

// 

// The TXM platform is distributed in the hope that it will be

// useful, but WITHOUT ANY WARRANTY; without even the implied

// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

// PURPOSE. See the GNU General Public License for more

// details.

// 

// You should have received a copy of the GNU General

// Public License along with the TXM platform. If not, see

// http://www.gnu.org/licenses.

// 

// 

// 

// $LastChangedDate:$

// $LastChangedRevision:$

// $LastChangedBy:$ 

//

package org.txm.treesearch.editor;

import org.eclipse.jface.resource.ImageDescriptor;

import org.eclipse.ui.IEditorInput;

import org.eclipse.ui.IPersistableElement;

import org.eclipse.ui.plugin.AbstractUIPlugin;

import org.txm.rcp.Application;

import org.txm.rcp.IImageKeys;

import org.txm.treesearch.function.TreeSearch;

/**

 * Simple editor input to query the TIGERSearch search engine

 *

 * @author mdecorde

 */

public class TreeSearchEditorInput implements IEditorInput {

	/** The ca. */

	private Object source;

	private TreeSearch ts;

	/**

	 * Instantiates a new correspondance analysis editor input.

	 *

	 * @param src the source

	 */

	public TreeSearchEditorInput( Object src, TreeSearch ts) {

		super();

		this.source = src;

		this.ts = ts;

	}

	/**

	 * Exists.

	 *

	 * @return true, if successful

	 * @see org.eclipse.ui.IEditorInput#exists()

	 */

	@Override

	public boolean exists() {

		return false;

	}

	/**

	 * Gets the image descriptor.

	 *

	 * @return the image descriptor

	 * @see org.eclipse.ui.IEditorInput#getImageDescriptor()

	 */

	@Override

	public ImageDescriptor getImageDescriptor() {

		return AbstractUIPlugin.imageDescriptorFromPlugin(

				Application.PLUGIN_ID,

				IImageKeys.ACTION_WORDCLOUD);

	}

	/**

	 * Gets the name.

	 *

	 * @return the name

	 * @see org.eclipse.ui.IEditorInput#getName()

	 */

	@Override

	public String getName() {

		return "TreeSearch"; //$NON-NLS-1$

	}

	/**

	 * Gets the persistable.

	 *

	 * @return the persistable

	 * @see org.eclipse.ui.IEditorInput#getPersistable()

	 */

	@Override

	public IPersistableElement getPersistable() {

		return null;

	}

	/**

	 * Gets the tool tip text.

	 *

	 * @return the tool tip text

	 * @see org.eclipse.ui.IEditorInput#getToolTipText()

	 */

	@Override

	public String getToolTipText() {

		return getName();

	}

	/**

	 * Gets the adapter.

	 *

	 * @param arg0 the arg0

	 * @return the adapter

	 * @see org.eclipse.core.runtime.IAdaptable#getAdapter(java.lang.Class)

	 */

	@Override

	@SuppressWarnings("unchecked") //$NON-NLS-1$

	public Object getAdapter(Class arg0) {

		return null;

	}

	/**

	 * Gets the cA.

	 *

	 * @return the Correspondance analysis underlying object

	 */

	public Object getSource() {

		return source;

	}

	public TreeSearch getTreeSearch() {

		return ts;

	}

}

// Copyright © 2010-2020 ENS de Lyon., University of Franche-Comté

package org.txm.treesearch.command;

import org.eclipse.jface.resource.ImageDescriptor;

import org.eclipse.ui.plugin.AbstractUIPlugin;

import org.osgi.framework.FrameworkUtil;

import org.txm.rcp.adapters.TXMResultAdapter;

import org.txm.rcp.adapters.TXMResultAdapterFactory;

import org.txm.treesearch.function.TreeSearch;

/**

 * A factory for creating Adapter objects.

 *  

 * @author mdecorde

 */

public class TreeSearchAdapterFactory extends TXMResultAdapterFactory {

	public static final ImageDescriptor ICON =

			AbstractUIPlugin.imageDescriptorFromPlugin(FrameworkUtil.getBundle(TreeSearchAdapterFactory.class).getSymbolicName(),

					"platform:/plugin/"+ FrameworkUtil.getBundle(TreeSearchAdapterFactory.class).getSymbolicName() + "/icons/functions/Tree.png"); //$NON-NLS-1$ //$NON-NLS-2$

	@Override

	public Object getAdapter(Object adaptableObject, Class adapterType) {

		if (this.canAdapt(adapterType) && adaptableObject instanceof TreeSearch)	{

			return new TXMResultAdapter() {

				@Override

				public ImageDescriptor getImageDescriptor(Object object) {

					return ICON;

				}

			};

		}

		return null;

	}

}

// Copyright © 2010-2020 ENS de Lyon., University of Franche-Comté

// Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of

// Lyon 2, University of Franche-Comté, University of Nice

// Sophia Antipolis, University of Paris 3.

// 

// The TXM platform is free software: you can redistribute it

// and/or modify it under the terms of the GNU General Public

// License as published by the Free Software Foundation,

// either version 2 of the License, or (at your option) any

// later version.

// 

// The TXM platform is distributed in the hope that it will be

// useful, but WITHOUT ANY WARRANTY; without even the implied

// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

// PURPOSE. See the GNU General Public License for more

// details.

// 

// You should have received a copy of the GNU General

// Public License along with the TXM platform. If not, see

// http://www.gnu.org/licenses.

// 

// 

// 

// $LastChangedDate:$

// $LastChangedRevision:$

// $LastChangedBy:$ 

//

package org.txm.treesearch.command;

import java.util.HashMap;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.eclipse.core.runtime.IConfigurationElement;

import org.eclipse.core.runtime.RegistryFactory;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.ui.handlers.HandlerUtil;

import org.txm.core.messages.TXMCoreMessages;

import org.txm.core.preferences.TXMPreferences;

import org.txm.core.results.TXMResult;

import org.txm.rcp.editors.TXMEditor;

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

import org.txm.treesearch.editor.TreeSearchEditor;

import org.txm.treesearch.function.TreeSearch;

import org.txm.treesearch.function.TreeSearchSelector;

import org.txm.treesearch.preferences.TreeSearchPreferences;

import org.txm.utils.logger.Log;

/**

 * Open the TIGERSearch Editor using the current selection OR a preference node set in the RCP command parameter TXMPreferences.RESULT_PARAMETERS_NODE_PATH

 * 

 * @author mdecorde.

 */

public class ComputeTreeSearch extends AbstractHandler {

	/** The ID. */

	public static String ID = ComputeTreeSearch.class.getName();

	/*

	 * (non-Javadoc)

	 * @see org.eclipse.core.commands.AbstractHandler#execute(org.eclipse.core.commands.ExecutionEvent)

	 */

	@Override

	public Object execute(final ExecutionEvent event) throws ExecutionException {

		Object s = null;

		// From link: creating from parameter node

		String parametersNodePath = event.getParameter(TXMPreferences.RESULT_PARAMETERS_NODE_PATH);

		if (parametersNodePath != null && !parametersNodePath.isEmpty()) {

			s = TXMResult.getResult(parametersNodePath); // a TreeSearch or a CQPCorpus

		}

		else { // From view result node

			IStructuredSelection selection = (IStructuredSelection) HandlerUtil.getCurrentSelection(event);

			s = selection.getFirstElement();

		}

		return openEditor(s);

	}

	public static HashMap<String, TreeSearchSelector> getSelectorsForCorpus(CQPCorpus corpus) {

		HashMap<String, TreeSearchSelector> ret = new HashMap<String, TreeSearchSelector>();

		IConfigurationElement[] contributions = RegistryFactory.getRegistry().getConfigurationElementsFor("org.txm.treesearch.TreeSearchSelector");

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

			try {

				@SuppressWarnings("unchecked")

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

				Log.fine(TXMCoreMessages.bind("Initializing selector: {0}...", s));

				if (s.canComputeWith(corpus)) {

					ret.put(s.getEngine(), s);

				}

			}

			catch (Exception e) {

				Log.severe("Error: failed to instantiate " + contributions[i].getName() + ".");

				e.printStackTrace();

			}

		}

		return ret;

	}

	/**

	 * 

	 * @param corpus

	 * @return an available TreeSearch for a corpus (if any)

	 */

	public static TreeSearchSelector getSelectorForCorpus(CQPCorpus corpus, String defaultEngine) {

		TreeSearchSelector found = null;

		IConfigurationElement[] contributions = RegistryFactory.getRegistry().getConfigurationElementsFor("org.txm.treesearch.TreeSearchSelector");

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

			try {

				@SuppressWarnings("unchecked")

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

				Log.fine(TXMCoreMessages.bind("Initializing selector: {0}...", s));

				if (s.canComputeWith(corpus)) {

					if (s.getEngine().equals(defaultEngine) || defaultEngine == null) { // it is the default engine, return it !

						return s;

					}

					found = s; //Store 

				}

			}

			catch (Exception e) {

				Log.severe("Error: failed to instantiate " + contributions[i].getName() + ".");

				e.printStackTrace();

			}

		}

		return found;

	}

	public static TreeSearch getTreeSearchFor(CQPCorpus corpus) {

		TreeSearchSelector s = getSelectorForCorpus(corpus, TreeSearchPreferences.getInstance().getString(TreeSearchPreferences.DEFAULT_REPRESENTATION));

		if (s != null) return s.getTreeSearch(corpus);

		return null;

	}

	public static TreeSearchEditor openEditor(Object obj) {

		TreeSearch ts = null;

		if (obj instanceof CQPCorpus) {

			CQPCorpus corpus = (CQPCorpus)obj;

			ts = getTreeSearchFor(corpus);

		}

		else if (obj instanceof TreeSearch) {

			ts = (TreeSearch) obj;

		}

		else {

			Log.warning("Selection is not a corpus: " + obj);

			return null;

		}

		try {

			TXMEditor<?> editor = TreeSearchEditor.openEditor(ts, TreeSearchEditor.ID);

			if (editor instanceof TreeSearchEditor) {

				return (TreeSearchEditor) editor;

			}

		}

		catch (Exception e) {

			Log.printStackTrace(e);

		}

		return null;

	}

}

package org.txm.treesearch.preferences;

import org.eclipse.jface.preference.StringFieldEditor;

import org.eclipse.ui.IWorkbench;

import org.txm.rcp.IImageKeys;

import org.txm.rcp.preferences.TXMPreferencePage;

import org.txm.rcp.preferences.TXMPreferenceStore;

/**

 * Syntatic annotations preferences page

 * 

 * @author mdecorde

 *

 */

public class TreeSearchPreferencePage extends TXMPreferencePage {

	@Override

	public void createFieldEditors() {

		this.addField(new StringFieldEditor(TreeSearchPreferences.DEFAULT_REPRESENTATION, "Syntactic representation", this.getFieldEditorParent()));

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see

	 * org.eclipse.ui.IWorkbenchPreferencePage#init(org.eclipse.ui.IWorkbench)

	 */

	@Override

	public void init(IWorkbench workbench) {

		this.setPreferenceStore(new TXMPreferenceStore(TreeSearchPreferences.getInstance().getPreferencesNodeQualifier()));

		this.setDescription("Syntatic annotation");

		this.setImageDescriptor(IImageKeys.getImageDescriptor(this.getClass(), "icons/functions/Tree.png"));

	}

}

source.. = src/

output.. = bin/

bin.includes = META-INF/,\

               .,\

               plugin.xml,\

               icons/

<?xml version="1.0" encoding="UTF-8"?>

<?eclipse version="3.4"?>

<plugin>

   <extension

         point="org.eclipse.core.expressions.propertyTesters">

      <propertyTester

            class="org.txm.treesearch.rcp.tester.TreeSearchTester"

            id="org.txm.rcp.testers.TreeSearchTester"

            namespace="org.txm.rcp.testers"

            properties="TreeSearchReady"

            type="java.lang.Object">

      </propertyTester>

   </extension>

   <extension

         point="org.eclipse.core.runtime.adapters">

      <factory

            adaptableType="org.txm.treesearch.function.TreeSearch"

            class="org.txm.treesearch.command.TreeSearchAdapterFactory">

         <adapter

               type="org.eclipse.ui.model.IWorkbenchAdapter">

         </adapter>

         <adapter

               type="org.eclipse.ui.model.IWorkbenchAdapter2">

         </adapter>

      </factory>

   </extension>

   <extension

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

      <editor

            class="org.txm.treesearch.editor.TreeSearchEditor"

            default="false"

            icon="icons/functions/Tree.png"

            id="org.txm.treesearch.editor.TreeSearchEditor"

            name="Syntactic Tree">

      </editor>

   </extension>

   <extension

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

      <category

            description="%category.description"

            id="TreeSearch4TXM.commands.category"

            name="Syntactic Tree">

      </category>

      <command

            categoryId="TreeSearch4TXM.commands.category"

            defaultHandler="org.txm.treesearch.command.ComputeTreeSearch"

            id="org.txm.treesearch.command.ComputeTreeSearch"

            name="Syntactic Tree"

            returnTypeId="org.txm.treesearch.function.TreeSearch">

      </command>

   </extension>

   <extension

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

         <menuContribution

            allPopups="false"

            locationURI="popup:org.txm.rcp.views.corpora.CorporaView?after=org.txm.rcp.corporaview.annotation">

         <command

               commandId="org.txm.tigersearch.commands.ComputeTreeSearch"

               icon="icons/functions/Tree.png"

               label="%command.label"

               style="push">

            <visibleWhen

                  checkEnabled="false">

               <or>

                  <test

                        forcePluginActivation="true"

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

                        value="TreeSearchReady">

                  </test>

               </or>

            </visibleWhen>

         </command>

      </menuContribution>

      <menuContribution

            allPopups="false"

            locationURI="toolbar:org.txm.rcp.toolbartools">

         <command

               commandId="org.txm.treesearch.command.ComputeTreeSearch"

               icon="icons/functions/Tree.png"

               label="%command.label"

               style="push">

            <visibleWhen

                  checkEnabled="false">

               <or>

                  <test

                        forcePluginActivation="true"

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

                        value="TreeSearchReady">

                  </test>

               </or>

            </visibleWhen>

         </command>

      </menuContribution>

      <menuContribution

            locationURI="popup:org.txm.concordance.rcp.editors.ConcordanceEditor">

         <command

               commandId="org.txm.treesearch.command.ComputeTreeSearch"

               icon="icons/functions/Tree.png"

               label="Send To TreeSearch"

               style="push">

         </command>

      </menuContribution>

   </extension>

   <extension

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

      <page

            category="org.txm.rcp.preferences.AdvancePreferencePage"

            class="org.txm.treesearch.preferences.TreeSearchPreferencePage"

            id="org.txm.treesearch.preferences.TreeSearchPreferencePage"

            name="Syntactic annotation">

      </page>

   </extension>

</plugin>

eclipse.preferences.version=1

org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled

org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8

org.eclipse.jdt.core.compiler.compliance=1.8

org.eclipse.jdt.core.compiler.problem.assertIdentifier=error

org.eclipse.jdt.core.compiler.problem.enumIdentifier=error

org.eclipse.jdt.core.compiler.source=1.8

<?xml version="1.0" encoding="UTF-8"?>

<classpath>

	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>

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

Manifest-Version: 1.0

Bundle-ManifestVersion: 2

Bundle-Name: org.txm.treesearch.rcp

Bundle-SymbolicName: org.txm.treesearch.rcp;singleton:=true

Bundle-Version: 1.0.0.qualifier

Automatic-Module-Name: org.txm.treesearch.rcp

Bundle-RequiredExecutionEnvironment: JavaSE-1.8

Require-Bundle: org.txm.rcp;bundle-version="0.8.2";visibility:=reexport,

 org.txm.treesearch.core;visibility:=reexport,

 org.txm.edition.rcp;bundle-version="1.0.0";visibility:=reexport

Export-Package: org.txm.treesearch.command,

 org.txm.treesearch.editor,

 org.txm.treesearch.rcp.tester

<?xml version="1.0" encoding="UTF-8"?>

<projectDescription>

	<name>org.txm.treesearch.rcp</name>

	<comment></comment>

	<projects>

	</projects>

	<buildSpec>

		<buildCommand>

			<name>org.eclipse.jdt.core.javabuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

		<buildCommand>

			<name>org.eclipse.pde.ManifestBuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

		<buildCommand>

			<name>org.eclipse.pde.SchemaBuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

	</buildSpec>

	<natures>

		<nature>org.eclipse.pde.PluginNature</nature>

		<nature>org.eclipse.jdt.core.javanature</nature>

	</natures>

</projectDescription>