@Override
protected void updateViewerInput() {
	IStructuredSelection selection= (IStructuredSelection) getTableViewer().getSelection();
	if (selection.size() == 1) {
		TemplatePersistenceData data= (TemplatePersistenceData) selection.getFirstElement();
		Template template= data.getTemplate();
		String name = template.getName();
		TemplateContextType contextType = getContextTypeRegistry().getContextType(template.getContextTypeId());
		if (contextType != null) {
			String prefix = 
					"templates for " + grammarAccess.getGrammar().getName() +
					"'" + name + "'" + " for " + getContextTypeForGrammar(contextType) + ">>";
			String editablePart = template.getPattern();
			String suffix = "";
			partialEditor.updateModel(prefix, editablePart, suffix);
		} else {
			partialEditor.updateModel("", template.getPattern(), "");
		}
	} else {
		partialEditor.updateModel("", "", "");
	}
}
 

@Override
protected void loadContributedTemplates() throws IOException {
	if (res==null)
		return;
	TemplateReaderWriter reader = new TemplateReaderWriter();
	InputStream openStream = null;
	try {
		openStream = res.openStream();
		try {
			TemplatePersistenceData[] read = reader.read(openStream, null);
			for (TemplatePersistenceData templatePersistenceData : read) {
				internalAdd(templatePersistenceData);
			}
		} finally {
			openStream.close();
		}
	} catch (IOException e) {
		log.error(e.getMessage(), e);
	}
}
 

public void applyData(Object data) {
	if (data instanceof Map) {
		Object id = ((Map) data).get(DATA_SELECT_TEMPLATE);
		if (id instanceof String) {
			final TemplatePersistenceData[] templates = fCodeTemplateConfigurationBlock.fTemplateStore
					.getTemplateData();
			TemplatePersistenceData template = null;
			for (int index = 0; index < templates.length; index++) {
				template = templates[index];
				if (template.getId().equals(id)) {
					fCodeTemplateConfigurationBlock.postSetSelection(template);
					break;
				}
			}
		}
	}
	super.applyData(data);
}
 

public void directAdd(final TemplatePersistenceData data, final boolean isEdited) {
	if (isEdited) {
		add(data);
	} else {
		// Trick the template store so that (1) the template is considered
		// as "user added" while (2) maintaining a proper id
		final String id = data.getId();
		final TemplatePersistenceData d2 = new TemplatePersistenceData(data.getTemplate(), true) {

			@Override
			public String getId() {
				return id;
			}

		};
		add(d2);
	}
}
 

public GamlEditTemplateDialog(final Shell parent, final TemplatePersistenceData data, final boolean edit,
		final ContextTypeRegistry registry, final TemplatesLanguageConfiguration configuration,
		final IEditedResourceProvider resourceProvider, final String languageName) {
	super(parent);
	this.data = data;
	this.configuration = configuration;
	this.resourceProvider = resourceProvider;
	this.languageName = languageName;

	final String title = edit ? TemplateDialogMessages.EditTemplateDialog_title_edit
			: TemplateDialogMessages.EditTemplateDialog_title_new;
	setTitle(title);

	// this.fTemplate = data.getTemplate();
	// fIsNameModifiable = isNameModifiable;

	final List<String[]> contexts = Lists.newArrayList();
	for (final Iterator<TemplateContextType> it =
			Iterators.filter(registry.contextTypes(), TemplateContextType.class); it.hasNext();) {
		final TemplateContextType type = it.next();
		contexts.add(new String[] { type.getId(), type.getName() });
	}
	// fContextTypes = contexts.toArray(new String[contexts.size()][]);
	// fContextTypeRegistry = registry;

}
 

void add(final TemplatePersistenceData t, final List<String> path) {
	if (path.size() == 0) {
		children.add(new TemplateNode(this, t, 1));
	} else if (path.size() == 1 && Strings.isGamaNumber(path.get(0))) {
		children.add(new TemplateNode(this, t, Integer.decode(path.get(0))));
	} else {
		final String name = path.remove(0);
		Node node = childWithName(name);
		if (node == null) {
			node = new TemplateTree(this, name);
			children.add(node);
		}
		((TemplateTree) node).add(t, path);
	}

}
 

/**
 * Removes any duplicates from a template store. Duplicate user added templates
 * are copied over their contributed siblings. If isCodeTemplates is true,
 * any user added templates are then removed.
 *
 * @param store
 * @param isCodeTemplates
 */
public static void pruneDuplicates(TemplateStore store, boolean isCodeTemplates) {
	TemplatePersistenceData[] datas= store.getTemplateData(true);
	for (int i= datas.length - 1; i >= 0; i--) {
		TemplatePersistenceData data= datas[i];
		if (data.isUserAdded()) {
			// find a contributed template that is similar and check it
			TemplatePersistenceData similar= findSimilarTemplate(datas, data.getTemplate(), isCodeTemplates);
			if (similar != data && !similar.isUserAdded()) {
				similar.setTemplate(data.getTemplate());
				store.delete(data);
			}
		}
	}

	if (isCodeTemplates) {
		datas= store.getTemplateData(true);
		for (int i= datas.length - 1; i >= 0; i--) {
			if (datas[i].isUserAdded())
				store.delete(datas[i]);
		}
	}
}
 

public void load() throws IOException {
	if (fProjectStore != null) {
		fProjectStore.load();

		Set<String> datas= new HashSet<String>();
		TemplatePersistenceData[] data= fProjectStore.getTemplateData(false);
		for (int i= 0; i < data.length; i++) {
			datas.add(data[i].getId());
		}

		data= fInstanceStore.getTemplateData(false);
		for (int i= 0; i < data.length; i++) {
			TemplatePersistenceData orig= data[i];
			if (!datas.contains(orig.getId())) {
				TemplatePersistenceData copy= new TemplatePersistenceData(new Template(orig.getTemplate()), orig.isEnabled(), orig.getId());
				fProjectStore.add(copy);
				copy.setDeleted(true);
			}
		}
	}
}
 

public boolean performOk(boolean enabled) {
	boolean res= super.performOk();
	if (!res)
		return false;

	if (fProject != null) {
		TemplatePersistenceData[] templateData= fTemplateStore.getTemplateData();
		for (int i= 0; i < templateData.length; i++) {
			fTemplateStore.setProjectSpecific(templateData[i].getId(), enabled);
		}
	}
	try {
		fTemplateStore.save();
	} catch (IOException e) {
		JavaPlugin.log(e);
		openWriteErrorDialog();
	}
	return true;
}
 

@Override
public void applyData(Object data) {
	if (data instanceof Map) {
		Object id= ((Map<?, ?>) data).get(DATA_SELECT_TEMPLATE);
		if (id instanceof String) {
			final TemplatePersistenceData[] templates= fCodeTemplateConfigurationBlock.fTemplateStore.getTemplateData();
			TemplatePersistenceData template= null;
			for (int index= 0; index < templates.length; index++) {
				template= templates[index];
				if (template.getId().equals(id)) {
					fCodeTemplateConfigurationBlock.postSetSelection(template);
					break;
				}
			}
		}
	}
	super.applyData(data);
}
 

/**
 * Sets the template options in the passed list (swt)
 */
private void fillTemplateOptions(TemplatePersistenceData[] templateData, Table list) {
    nameToTemplateData = new TreeMap<String, TemplatePersistenceData>();

    for (TemplatePersistenceData data : templateData) {
        if (PyContextType.PY_MODULES_CONTEXT_TYPE.equals(data.getTemplate().getContextTypeId())) {
            String name = data.getTemplate().getName();
            nameToTemplateData.put(name, data);
        }
    }
    ArrayList<String> lst = new ArrayList<String>(nameToTemplateData.keySet());
    for (String string : lst) {
        new TableItem(list, SWT.NONE).setText(string);
    }
    list.setSelection(0);
}
 

/**
 * Contribute templates defined in file with the give URL.
 * 
 * @param templates
 *          the URL of the file with templates
 */
private void addTemplatesFromFile(final URL templates) {
  if (templates != null) {
    TemplateReaderWriter reader = new TemplateReaderWriter();
    try {
      InputStream openStream = templates.openStream();
      try {
        TemplatePersistenceData[] datas = reader.read(openStream, null);
        int templateCounter = 0;
        for (TemplatePersistenceData data : datas) {
          if (data.getId() == null) {
            templateCounter++;
            TemplatePersistenceData dataWithGenId = new TemplatePersistenceData(data.getTemplate(), data.isEnabled(), templates.getPath() + "." //$NON-NLS-1$
                + templateCounter);
            dataWithGenId.setDeleted(data.isDeleted());
            internalAdd(dataWithGenId);
          } else {
            // if contributed template has an id
            internalAdd(data);
          }
        }
      } finally {
        openStream.close();
      }
    } catch (IOException e) {
      LOG.error(e);
    }
  }
}
 

protected void updateViewerInput() {
	IStructuredSelection selection= (IStructuredSelection) getTableViewer().getSelection();
	SourceViewer viewer= getViewer();
	
	if (selection.size() == 1 && selection.getFirstElement() instanceof TemplatePersistenceData) {
		TemplatePersistenceData data= (TemplatePersistenceData) selection.getFirstElement();
		Template template= data.getTemplate();
		String contextId= template.getContextTypeId();
		TemplateContextType type= JSDTTypeScriptUIPlugin.getDefault().getTemplateContextRegistry().getContextType(contextId);
		fTemplateProcessor.setContextType(type);
		
		IDocument doc= viewer.getDocument();
		
		String start= null;
		if ("javadoc".equals(contextId)) { //$NON-NLS-1$
			start= "/**" + doc.getLegalLineDelimiters()[0]; //$NON-NLS-1$
		} else
			start= ""; //$NON-NLS-1$
		
		doc.set(start + template.getPattern());
		int startLen= start.length();
		viewer.setDocument(doc, startLen, doc.getLength() - startLen);

	} else {
		viewer.getDocument().set(""); //$NON-NLS-1$
	}		
}
 

public Object getParent(TreeListDialogField field, Object element) {
	if (element instanceof TemplatePersistenceData) {
		TemplatePersistenceData data = (TemplatePersistenceData) element;
		if (data.getTemplate().getName().endsWith(CodeTemplateContextType.COMMENT_SUFFIX)) {
			return COMMENT_NODE;
		}
		return CODE_NODE;
	}
	return null;
}
 

protected TemplatePersistenceData[] getTemplateOfCategory(boolean isComment) {
	ArrayList res = new ArrayList();
	TemplatePersistenceData[] templates = fTemplateStore.getTemplateData();
	for (int i = 0; i < templates.length; i++) {
		TemplatePersistenceData curr = templates[i];
		if (isComment == curr.getTemplate().getName().endsWith(CodeTemplateContextType.COMMENT_SUFFIX)) {
			res.add(curr);
		}
	}
	return (TemplatePersistenceData[]) res.toArray(new TemplatePersistenceData[res.size()]);
}
 

protected void updateSourceViewerInput(List selection) {
	if (fPatternViewer == null || fPatternViewer.getTextWidget().isDisposed()) {
		return;
	}
	if (selection.size() == 1 && selection.get(0) instanceof TemplatePersistenceData) {
		TemplatePersistenceData data = (TemplatePersistenceData) selection.get(0);
		Template template = data.getTemplate();
		TemplateContextType type = JavaScriptPlugin.getDefault().getCodeTemplateContextRegistry()
				.getContextType(template.getContextTypeId());
		fTemplateProcessor.setContextType(type);
		fPatternViewer.getDocument().set(template.getPattern());
	} else {
		fPatternViewer.getDocument().set(""); //$NON-NLS-1$
	}
}
 

protected void doButtonPressed(int buttonIndex, List selected) {
	if (buttonIndex == IDX_EDIT) {
		edit((TemplatePersistenceData) selected.get(0));
	} else if (buttonIndex == IDX_EXPORT) {
		export(selected);
	} else if (buttonIndex == IDX_EXPORTALL) {
		exportAll();
	} else if (buttonIndex == IDX_IMPORT) {
		import_();
	}
}
 

private void edit(TemplatePersistenceData data) {
	Template newTemplate = new Template(data.getTemplate());
	EditTemplateDialog dialog = new EditTemplateDialog(getShell(), newTemplate, true, false,
			JavaScriptPlugin.getDefault().getCodeTemplateContextRegistry());
	if (dialog.open() == Window.OK) {
		// changed
		data.setTemplate(dialog.getTemplate());
		fCodeTemplateTree.refresh(data);
		fCodeTemplateTree.selectElements(new StructuredSelection(data));
	}
}
 

private void updateTemplate(TemplatePersistenceData data) {
	TemplatePersistenceData[] datas = fTemplateStore.getTemplateData();
	for (int i = 0; i < datas.length; i++) {
		String id = datas[i].getId();
		if (id != null && id.equals(data.getId())) {
			datas[i].setTemplate(data.getTemplate());
			break;
		}
	}
}
 

private void export(List selected) {
	Set datas = new HashSet();
	for (int i = 0; i < selected.size(); i++) {
		Object curr = selected.get(i);
		if (curr instanceof TemplatePersistenceData) {
			datas.add(curr);
		} else {
			TemplatePersistenceData[] cat = getTemplateOfCategory(curr == COMMENT_NODE);
			datas.addAll(Arrays.asList(cat));
		}
	}
	export((TemplatePersistenceData[]) datas.toArray(new TemplatePersistenceData[datas.size()]));
}
 

public boolean performOk(boolean enabled) {
	if (fProject != null) {
		TemplatePersistenceData[] templateData= fTemplateStore.getTemplateData();
		for (int i= 0; i < templateData.length; i++) {
			fTemplateStore.setProjectSpecific(templateData[i].getId(), enabled);
		}
	}
	try {
		fTemplateStore.save();
	} catch (IOException e) {
		JavaScriptPlugin.log(e);
		openWriteErrorDialog(e);
	}
	return true;
}
 

private void addNamedTemplates(String inlineContextId, String namedContextId, String key) {
    Template[] schemaTemplates = templateStore.getTemplates(inlineContextId);
    for (int i = 0; i < schemaTemplates.length; i++) {
        Template schemaTemplate = schemaTemplates[i];
        Template template = createNamedTemplate(schemaTemplate, namedContextId, key);
        templateStore.add(new TemplatePersistenceData(template, true));
    }
}
 

/**
 * Adds a template to the internal store. The added templates must have a unique id.
 *
 * @param data
 *            the template data to add
 */
@Override
protected void internalAdd(final TemplatePersistenceData data) {
	if (!data.isCustom()) {
		// give the data a new unique id
		final String id = getNewIdFromId(data.getId());
		final TemplatePersistenceData d2 = new TemplatePersistenceData(data.getTemplate(), true, id);
		super.internalAdd(d2);
	}
}
 

@Override
public org.eclipse.jface.text.templates.persistence.TemplatePersistenceData getTemplateData(final String id) {
	if (id == null) { return null; }
	for (final org.eclipse.text.templates.TemplatePersistenceData data : internalGetTemplates()) {
		if (id.equals(data.getId())) {
			final org.eclipse.jface.text.templates.persistence.TemplatePersistenceData wrap =
					new org.eclipse.jface.text.templates.persistence.TemplatePersistenceData(data);
			return wrap;
		}

	}
	return null;
}
 

/**
 * @see msi.gama.lang.gaml.ui.editor.IGamlEditor#openEditTemplateDialog()
 */
public boolean openEditTemplateDialog(final TemplatePersistenceData data, final boolean edit) {
	final GamlEditTemplateDialog d = getTemplateFactory().createDialog(data, edit, getEditorSite().getShell());
	if (d.open() == Window.OK) {
		getTemplateStore().directAdd(d.getData(), edit);
		return true;
	}
	return false;
}
 

TemplateNode(final Node parent, final TemplatePersistenceData t, final int rank) {
	super(parent);
	name = t.getTemplate().getName();
	desc = t.getTemplate().getDescription();
	pattern = t.getTemplate().getPattern();
	this.rank = rank;
}
 

@Override
protected void fillMenu() {

	if (tree == null || tree.getChildren().isEmpty()) {
		tree = new TemplateRoot();
		store = getEditor().getTemplateStore();
		final TemplatePersistenceData[] templates = store.getTemplateData(false);
		for (final TemplatePersistenceData t : templates) {
			tree.add(t);
		}
	}
	tree.fillMenu(mainMenu);
}
 

/**
 * Only to be used by tests
 * 
 * @param templateId the template id
 * @param pattern the new pattern
 * @param project not used
 */
public static void setCodeTemplate(String templateId, String pattern, IJavaProject project) {
	TemplateStore codeTemplateStore= JavaPlugin.getDefault().getCodeTemplateStore();
	TemplatePersistenceData data= codeTemplateStore.getTemplateData(templateId);
	Template orig= data.getTemplate();
	Template copy= new Template(orig.getName(), orig.getDescription(), orig.getContextTypeId(), pattern, true);
	data.setTemplate(copy);
}
 

@Override
public void load() throws IOException {
	super.load();

	if (fLegacySet != null) {

		List<Template> legacyTemplates= new ArrayList<Template>(Arrays.asList(fLegacySet.getTemplates()));
		fLegacySet.clear();

		TemplatePersistenceData[] datas= getTemplateData(true);
		for (Iterator<Template> it= legacyTemplates.listIterator(); it.hasNext();) {
			Template t= it.next();
			TemplatePersistenceData orig= findSimilarTemplate(datas, t, isCodeTemplates());
			if (orig == null) { // no contributed match for the old template found
				if (!isCodeTemplates())
					add(new TemplatePersistenceData(t, true));
			} else { // a contributed template seems to be the descendant of the non-id template t
				if (!orig.getTemplate().getPattern().equals(t.getPattern()))
					// add as modified contributed template if changed compared to the original
					orig.setTemplate(t);
			}
		}

		save();
		fLegacySet= null;
	}
}
 

private static TemplatePersistenceData findSimilarTemplate(TemplatePersistenceData[] datas, Template template, boolean isCodeTemplates) {
	 for (int i= 0; i < datas.length; i++) {
		TemplatePersistenceData data= datas[i];
		Template orig= data.getTemplate();
		if (isSimilar(template, orig, isCodeTemplates))
			return data;
	 }

	 return null;
}