Laboratoire ICAR » Plateforme TXM

source.. = src/

output.. = bin/

bin.includes = META-INF/,\

               .,\

               plugin.xml

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

<?eclipse version="3.4"?>

<plugin>

   <extension

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

      <initializer

            class="org.txm.texts.core.TextsViewPreferences">

      </initializer>

   </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.texts.core

Bundle-SymbolicName: org.txm.texts.core;singleton:=true

Bundle-Version: 1.0.0.qualifier

Automatic-Module-Name: org.txm.texts.core

Bundle-RequiredExecutionEnvironment: JavaSE-1.8

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

 org.txm.searchengine.core;bundle-version="1.0.0";visibility:=reexport,

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

 org.txm.searchengine.cqp.core;visibility:=reexport

Export-Package: org.txm.texts.core

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

<projectDescription>

	<name>org.txm.texts.core</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>

package org.txm.texts.core;

import java.io.File;

import java.io.PrintWriter;

import java.util.ArrayList;

import java.util.LinkedHashMap;

import java.util.List;

import org.apache.commons.lang.StringUtils;

import org.eclipse.osgi.util.NLS;

import org.txm.core.results.Parameter;

import org.txm.core.results.TXMParameters;

import org.txm.core.results.TXMResult;

import org.txm.searchengine.cqp.CQPSearchEngine;

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

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

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

import org.txm.utils.TXMProgressMonitor;

import org.txm.utils.logger.Log;

public class TextsView extends TXMResult {

	@Parameter(key = "columns")

	ArrayList<StructuralUnitProperty> pColumns;

//	@Parameter(key = "positiveFilters")

//	ArrayList<String> positiveFilters;

	@Parameter(key = "negativeFilters")

	String negativeFilters;

	private LinkedHashMap<String, ArrayList<String>> result;

	public CQPCorpus getCorpus() {

		return (CQPCorpus)parent;

	}

	public TextsView(CQPCorpus corpus) {

		super(corpus);

	}

	public TextsView(String parametersNodePath) {

		super(parametersNodePath);

	}

	@Override

	public boolean saveParameters() throws Exception {

		this.saveParameter("columns", StringUtils.join(pColumns, "\t"));

//		this.saveParameter("positiveFilters", StringUtils.join(positiveFilters, "\t"));

		this.saveParameter("negativeFilters", negativeFilters);

		return true;

	}

	@Override

	public boolean loadParameters() throws Exception {

		String v = this.getStringParameterValue("columns").toString();

		if ("*".equals(v)) {

			;

			this.pColumns = new ArrayList<>(getCorpus().getStructuralUnit("text").getUserDefinedOrderedProperties());

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

				if (pColumns.get(i).getName().equals("id")) {

					pColumns.remove(i);

					break;

				}

			}

		} else {

			this.pColumns = new ArrayList(Property.stringToProperties(getCorpus(), v));

		}

		v = this.getStringParameterValue("negativeFilters").toString();

		if (v.contains("=")) {

			this.negativeFilters = v;

		} else {

			this.negativeFilters = "";

		}

//		v = this.getStringParameterValue("positiveFilters").toString();

//		if (v.contains("=")) {

//			this.positiveFilters = new ArrayList<>(Arrays.asList(v.split("\t")));

//		} else {

//			this.positiveFilters = new ArrayList<>();

//		}

		return pColumns != null;

	}

	@Override

	public boolean setParameters(TXMParameters parameters) throws Exception {

		if (parameters.get("columns") != null) {

			Object o = parameters.get("columns");

			if (o instanceof List) {

				pColumns = new ArrayList((List)o);

			} else {

				String v = parameters.get("columns").toString();

				if ("*".equals(v)) {

					this.pColumns = new ArrayList<>(getCorpus().getStructuralUnit("text").getUserDefinedOrderedProperties());

				} else {

					this.pColumns = new ArrayList(Property.stringToProperties(getCorpus(), v));

				}

			}

			return true;

		}

		return false;

	}

	@Override

	public String getName() {

		return "Texts ("+pColumns+")";

	}

	@Override

	public String getSimpleName() {

		return "Texts";

	}

	@Override

	public String getDetails() {

		return getName();

	}

	@Override

	public void clean() {

	}

	@Override

	public boolean canCompute() throws Exception {

		return pColumns != null;

	}

	@Override

	protected boolean _compute(TXMProgressMonitor monitor) throws Exception {

		result = new LinkedHashMap<String, ArrayList<String>>();

		// preset arrays

		String[] texts = getCorpus().getCorpusTextIdsList();

		for (String t : texts) {

			ArrayList<String> values = new ArrayList<String>();

			result.put(t, values);

			if (getCorpus().getProject().getText(t) == null) {

				Log.warning(NLS.bind("The {0} Corpus has no text named ''{1}''.", getCorpus(), t));

				return false;

			}

		}

		// optimization: get values property per property then set the Text property value arrays

		int positions [] = new int[texts.length];

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

			positions[i] = i;

		}

		for (int icol = 0 ; icol < pColumns.size() ; icol++) {

			StructuralUnitProperty col = pColumns.get(icol);

			String[] values = CQPSearchEngine.getCqiClient().struc2Str(col.getQualifiedName(), positions);

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

				result.get(texts[i]).add( values[i]);

			}

		}

		if (negativeFilters.length() > 0 && pColumns.size() > 0) {

			ArrayList<String> columnNames = new ArrayList<>(pColumns.size());

			for (StructuralUnitProperty p : pColumns) columnNames.add(p.getName());

			String[] filters = negativeFilters.split(";");

			ArrayList<String> keys = new ArrayList<>(result.keySet());

			for (String text : keys) {

				for (String negativeFilter : filters) {

					String[] split = negativeFilter.split("=", 2);

					if (split.length == 2 

							&& columnNames.contains(split[0]) 

							&& result.get(text).get(columnNames.indexOf(split[0])).matches(split[1])) {

						// remove this line

						result.remove(text);

						break;

					}

				}

			}

		}

		return true;

	}

	@Override

	protected boolean _toTxt(File outfile, String encoding, String colseparator, String txtseparator) throws Exception {

		PrintWriter writer = org.txm.utils.io.IOUtils.getWriter(outfile, encoding);

		writer.println("text"+colseparator+StringUtils.join(pColumns, colseparator));

		for (String text : result.keySet()) {

			writer.println(text+colseparator+StringUtils.join(result.get(text), colseparator));

		}

		writer.close();

		return false;

	}

	@Override

	public String getResultType() {

		return "TextView";

	}

	public LinkedHashMap<String, ArrayList<String>> getLines() {

		return result;

	}

	public List<StructuralUnitProperty> getColumns() {

		return pColumns;

	}

}

package org.txm.texts.core;

import org.osgi.service.prefs.Preferences;

import org.txm.core.preferences.TXMPreferences;

public class TextsViewPreferences extends TXMPreferences {

	public static final String CRITERII = "criterii";

	public static final String ALLMUSTMATCH = "allmustmatch";

	public static final String ALLPROPERTIESMUSTMATCH = "allmustmatch";

	/**

	 * Gets the instance.

	 * 

	 * @return the instance

	 */

	public static TXMPreferences getInstance() {

		if (!TXMPreferences.instances.containsKey(TextsViewPreferences.class)) {

			new TextsViewPreferences();

		}

		return TXMPreferences.instances.get(TextsViewPreferences.class);

	}

	@Override

	public void initializeDefaultPreferences() {

		super.initializeDefaultPreferences();

		Preferences preferences = this.getDefaultPreferencesNode();

		preferences.put("columns", "*");

	}

}

package org.txm.texts.core;

import java.util.ArrayList;

import java.util.HashMap;

import org.apache.commons.lang.StringUtils;

import org.txm.core.results.Parameter;

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

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

import org.txm.searchengine.cqp.corpus.query.CQLQuery;

import org.txm.utils.TXMProgressMonitor;

public class TextsSelection extends Subcorpus {

	@Parameter(key = TextsViewPreferences.CRITERII)

	HashMap<String, ArrayList<String>> criterii;

	@Parameter(key = TextsViewPreferences.ALLPROPERTIESMUSTMATCH)

	Boolean allPropertiesMustMatch;

	@Parameter(key = TextsViewPreferences.ALLMUSTMATCH)

	HashMap<String, Boolean> allMustMatch;

	public TextsSelection(CQPCorpus corpus) {

		super(corpus);

	}

	/**

	 * 

	 * @param parametersNodePath

	 */

	public TextsSelection(String parametersNodePath) {

		super(parametersNodePath);

	}

	public boolean canCompute() {

		return criterii.size() > 0;

	}

	public boolean __compute(TXMProgressMonitor monitor) throws Exception {

		StringBuilder buffer = new StringBuilder();

		buffer.append("<text> [");

		int n = 0;

		for (String textprop : criterii.keySet()) {

			String operator = " && ";

			if (allPropertiesMustMatch) operator = " || ";

			if (n > 0) buffer.append(operator);

			String matchOperator = "&";

			if (!allMustMatch.get(textprop)) matchOperator = "|";

			buffer.append("_.text_"+textprop+"=\""+StringUtils.join(criterii.get(textprop), matchOperator)+"\"");

		}

		buffer.append("] expand to text");

		this.pQuery = new CQLQuery(buffer.toString());

		return super.__compute(monitor);

	}

}

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

<projectDescription>

	<name>org.txm.texts.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>

package org.txm.texts.rcp;

import java.util.List;

import java.util.Map;

import org.eclipse.jface.viewers.ColumnLabelProvider;

import org.txm.objects.Text;

public class TextViewColumnLabelProvider extends ColumnLabelProvider {

	int n;

	TextsViewEditor editor;

	public TextViewColumnLabelProvider(TextsViewEditor editor, int n) {

		this.n = n;

		this.editor = editor;

	}

	@Override

	public String getText(Object element) {

		Text text = (Text)element;

		return editor.getResult().getLines().get(text.getName()).get(n);

	}

}

package org.txm.texts.rcp;

import java.util.ArrayList;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import org.eclipse.jface.viewers.ColumnLabelProvider;

import org.eclipse.jface.viewers.DoubleClickEvent;

import org.eclipse.jface.viewers.IDoubleClickListener;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.IStructuredContentProvider;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.jface.viewers.TableViewer;

import org.eclipse.jface.viewers.TableViewerColumn;

import org.eclipse.jface.viewers.ViewerComparator;

import org.eclipse.swt.SWT;

import org.eclipse.swt.graphics.Image;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.TableColumn;

import org.txm.core.results.Parameter;

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

import org.txm.objects.Text;

import org.txm.rcp.IImageKeys;

import org.txm.rcp.editors.TXMEditor;

import org.txm.rcp.editors.TableKeyListener;

import org.txm.rcp.editors.listeners.ComputeSelectionListener;

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

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

import org.txm.texts.core.TextsView;

public class TextsViewEditor extends TXMEditor<TextsView> {

	@Parameter(key = "columns")

	PropertiesSelector<StructuralUnitProperty> propertiesSelector;

	@Parameter(key = "negativeFilters")

	org.eclipse.swt.widgets.Text negativeFiltersText;

	TableViewer viewer;

//	HashMap<String, TableViewerColumn> columns = new HashMap<String, TableViewerColumn>();

	@Override

	public void _createPartControl() throws Exception {

		this.getParent().setLayout(new GridLayout(1, true));

		this.getMainParametersComposite().getLayout().numColumns = 10;

		propertiesSelector = new PropertiesSelector<>(this.getMainParametersComposite());

		ArrayList<StructuralUnitProperty> properties = new ArrayList<>(getResult().getCorpus().getStructuralUnitProperties("text"));

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

			if (properties.get(i).getName().equals("id")) {

				properties.remove(i);

				break;

			}

		}

		propertiesSelector.setProperties(properties);

		ComputeSelectionListener computeSelectionListener = new ComputeSelectionListener(this);

		propertiesSelector.addSelectionListener(computeSelectionListener);

		new Label(this.getMainParametersComposite(), SWT.NONE).setText("Negative filters (p1=v1;p2=v2)");

		negativeFiltersText = new org.eclipse.swt.widgets.Text(this.getMainParametersComposite(), SWT.BORDER);

		negativeFiltersText.addSelectionListener(computeSelectionListener);

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

		gdata.minimumWidth = 300;

		negativeFiltersText.setLayoutData(gdata);

		viewer = new TableViewer(this.getResultArea(), SWT.NONE);

		viewer.getTable().setLayoutData(new GridData(GridData.FILL, GridData.FILL, true, true));

		viewer.getTable().setHeaderVisible(true);

		viewer.getTable().setLinesVisible(true);

		viewer.getTable().addKeyListener(new TableKeyListener(viewer));

		viewer.setContentProvider(new IStructuredContentProvider() {

			@SuppressWarnings("rawtypes")

			@Override

			public Object[] getElements(Object inputElement) {

				if (inputElement instanceof List) {

					return ((List)inputElement).toArray();

				}

				return null;

			}

		});

		viewer.setComparator(new ViewerComparator());

	}

	@Override

	public void updateResultFromEditor() {

	}

	@Override

	public void updateEditorFromResult(boolean update) throws Exception {

		TextsView tv = getResult();

		int currentDisplayedColumns = viewer.getTable().getColumns().length;

		int numberOfColumnsToDisplay = (tv.getColumns().size() + 3);

		if ( currentDisplayedColumns == 0 || 

				currentDisplayedColumns != numberOfColumnsToDisplay) {

			if (viewer.getTable().getColumns().length > 0) { // get rid of current columns

				for (TableColumn column : viewer.getTable().getColumns()) {

					column.dispose();

				}

			}

			TableViewerColumn c = new TableViewerColumn(viewer, SWT.NONE);

			TableColumn textColumn = c.getColumn();

			textColumn.setText("Text");

			textColumn.setToolTipText("Text");

			textColumn.setWidth(200);

			c.setLabelProvider(new ColumnLabelProvider() {

				@Override

				public String getText(Object element) {

					Text text = (Text)element;

					return text.getName();

				}

			});

			c = new TableViewerColumn(viewer, SWT.NONE);

			TableColumn editionColumn = c.getColumn();

			editionColumn.setText("Edition");

			editionColumn.setToolTipText("Edition");

			editionColumn.setWidth(65);

			c.setLabelProvider(new ColumnLabelProvider() {

				@Override

				public Image getImage(Object element) {

					Text text = (Text)element;

					TextsViewEditor.this.getResult().getLines().get(text.getName());

					if (text.getEditions().size() > 0) {

						return IImageKeys.getImage(IImageKeys.EDITION);

					} else {

						return null;

					}

				}

				@Override

				public String getText(Object element) {

					return null;

				}

			});

			c = new TableViewerColumn(viewer, SWT.NONE);

			TableColumn separatorColumn = c.getColumn();

			separatorColumn.setText(" ");

			separatorColumn.setWidth(2);

			c.getColumn().setResizable(false);

			c.setLabelProvider(new ColumnLabelProvider() {

				@Override

				public String getText(Object element) {

					return "";

				}

			});

			int nColumn = 0;

			for (StructuralUnitProperty col : this.getResult().getColumns()) {

				c = new TableViewerColumn(viewer, SWT.NONE);

				TableColumn newColumn = c.getColumn();

				newColumn.setText(col.getName());

				newColumn.setData(nColumn);

				newColumn.setToolTipText(col.getFullName());

				newColumn.setWidth(100);

				c.setLabelProvider(new TextViewColumnLabelProvider(this, nColumn));

				nColumn++;

			}

		}

		//

		ArrayList<Text> texts = new ArrayList<>();

		for (Text text : getResult().getCorpus().getProject().getTexts()) {

			if (this.getResult().getLines().containsKey(text.getName())) {

				texts.add(text);

			}

		}

		viewer.setInput(texts);

		viewer.addDoubleClickListener(new IDoubleClickListener() {

			@Override

			public void doubleClick(DoubleClickEvent event) {

				ISelection sel = viewer.getSelection();

				StructuredSelection ssel = (StructuredSelection)sel;

				Object o = ssel.getFirstElement();

				if (o != null && o instanceof Text) {

					OpenEdition.openEdition(getResult().getCorpus(), new String[] {getResult().getProject().getDefaultEditionName()}, ((Text)o).getName());

				}

			}

		});

	}

}

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

package org.txm.texts.rcp;

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.texts.core.TextsView;

/**

 * A factory for creating Adapter objects.

 * 

 * @author mdecorde

 */

public class TextsViewAdapterFactory extends TXMResultAdapterFactory {

	public static final ImageDescriptor ICON = AbstractUIPlugin.imageDescriptorFromPlugin(FrameworkUtil.getBundle(TextsViewAdapterFactory.class).getSymbolicName(),

			"platform:/plugin/org.txm.rcp/icons/objects/books.png"); //$NON-NLS-1$ //$NON-NLS-2$

	@Override

	public <T> T getAdapter(Object adaptableObject, Class<T> adapterType) {

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

			return adapterType.cast(new TXMResultAdapter() {

				@Override

				public ImageDescriptor getImageDescriptor(Object object) {

					return ICON; 

				}

			});

		}

		return null;

	}

}

package org.txm.texts.rcp;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.txm.core.preferences.TXMPreferences;

import org.txm.rcp.editors.TXMEditor;

import org.txm.rcp.handlers.BaseAbstractHandler;

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

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

import org.txm.texts.core.TextsView;

public class ComputeTextView extends BaseAbstractHandler {

	@Override

	public Object execute(ExecutionEvent event) throws ExecutionException {

		if (!this.checkCorpusEngine()) {

			return false;

		}

		TextsView concordance = null;

		// From link: creating from parameter node

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

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

			concordance = new TextsView(parametersNodePath);

		}

		// From view result node

		else {

			Object selection = this.getCorporaViewSelectedObject(event);

			// Creating from Corpus

			if (selection instanceof CQPCorpus) {

				CQPCorpus corpus = (CQPCorpus) selection;

				concordance = new TextsView(corpus);

			}

			// Reopening existing result

			else if (selection instanceof TextsView) {

				concordance = (TextsView) selection;

			}

			// Error

			else {

				return this.logCanNotExecuteCommand(selection);

			}

		}

		openEditor(concordance);

		return null;

	}

	public static TXMEditor<TextsView> openEditor(TextsView view) {

		return TXMEditor.openEditor(view, TextsViewEditor.class.getName());

	}

}

source.. = src/

output.. = bin/

bin.includes = META-INF/,\

               .,\

               plugin.xml,\

               OSGI-INF/l10n/bundle.properties

#Properties file for org.txm.texts.rcp

command.name = Texts

editor.name = Texts

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

<?eclipse version="3.4"?>

<plugin>

   <extension

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

      <command

            defaultHandler="org.txm.texts.rcp.ComputeTextView"

            id="org.txm.texts.rcp.ComputeTextView"

            name="%command.name"

            returnTypeId="org.txm.texts.core.TextsView">

      </command>

   </extension>

   <extension

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

      <menuContribution

            locationURI="menu:menu.corpus">

         <command

               commandId="org.txm.texts.rcp.ComputeTextView"

               icon="platform:/plugin/org.txm.rcp/icons/objects/books.png"

               style="push"

               tooltip="%command.name">

            <visibleWhen

                  checkEnabled="false">

               <or>

                  <reference

                        definitionId="OneCorpusSelected">

                  </reference>

               </or>

            </visibleWhen>

         </command>

      </menuContribution>

      <menuContribution

            allPopups="false"

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

         <command

               commandId="org.txm.texts.rcp.ComputeTextView"

               icon="platform:/plugin/org.txm.rcp/icons/objects/books.png"

               style="push"

               tooltip="%command.name">

            <visibleWhen

                  checkEnabled="false">

               <or>

                  <reference

                        definitionId="OneCorpusSelected">

                  </reference>

               </or>

            </visibleWhen>

         </command>

      </menuContribution>

      <menuContribution

            allPopups="false"

            locationURI="popup:org.txm.rcp.views.corpora.CorporaView">

         <command

               commandId="org.txm.texts.rcp.ComputeTextView"

               icon="platform:/plugin/org.txm.rcp/icons/objects/books.png"

               style="push"

               tooltip="%command.name">

            <visibleWhen

                  checkEnabled="false">

               <or>

                  <reference

                        definitionId="OneCorpusSelected">

                  </reference>

               </or>

            </visibleWhen>

         </command>

      </menuContribution>

   </extension>

   <extension

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

      <editor

            class="org.txm.texts.rcp.TextsViewEditor"

            default="false"

            icon="platform:/plugin/org.txm.rcp/icons/objects/books.png"

            id="org.txm.texts.rcp.TextsViewEditor"

            name="%editor.name">

      </editor>

   </extension>

   <extension

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

      <factory

            adaptableType="org.txm.texts.core.TextsView"

            class="org.txm.texts.rcp.TextsViewAdapterFactory">

         <adapter

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

         </adapter>

      </factory>

   </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.texts.rcp

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

Bundle-Version: 1.0.0.qualifier

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

Bundle-RequiredExecutionEnvironment: JavaSE-1.8

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

 org.txm.texts.core;bundle-version="1.0.0",

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

Export-Package: org.txm.texts.rcp