1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
package rba.tool.editor.ui.opener
import com.google.inject.Inject
import org.apache.log4j.Logger
import org.eclipse.core.resources.IFile
import org.eclipse.core.resources.IStorage
import org.eclipse.emf.common.util.URI
import org.eclipse.emf.common.util.WrappedException
import org.eclipse.emf.ecore.EReference
import org.eclipse.ui.IEditorPart
import org.eclipse.ui.IWorkbench
import org.eclipse.ui.PartInitException
import org.eclipse.ui.PlatformUI
import org.eclipse.ui.ide.IDE
import org.eclipse.xtext.resource.ILocationInFileProvider
import org.eclipse.xtext.resource.IResourceServiceProvider
import org.eclipse.xtext.resource.XtextResource
import org.eclipse.xtext.ui.editor.IURIEditorOpener
import org.eclipse.xtext.ui.editor.utils.EditorUtils
import org.eclipse.xtext.ui.resource.IResourceUIServiceProvider
import org.eclipse.xtext.ui.resource.IStorage2UriMapper
import org.eclipse.xtext.util.concurrent.IUnitOfWork
class RBAModelURIEditorOpener implements IURIEditorOpener {
private static final Logger logger = Logger.getLogger(RBAModelURIEditorOpener);
@Inject
private IResourceServiceProvider.Registry resourceServiceProviderRegistry;
@Inject
private IStorage2UriMapper mapper;
@Inject(optional=true)
private IWorkbench workbench;
/**
* @since 2.2
*/
def IEditorPart open(URI uri, Object context, boolean select) {
return open(uri, select);
}
override open(URI uri, boolean select) {
val resourceServiceProvider = resourceServiceProviderRegistry.getResourceServiceProvider(uri.trimFragment());
if(resourceServiceProvider instanceof IResourceUIServiceProvider) {
val editorOpener = ( resourceServiceProvider as IResourceUIServiceProvider).getURIEditorOpener();
if(editorOpener !== null) {
return editorOpener.open(URI.createURI(uri.toString.replace("/.applied/", "/model/")), select);
}
}
return openDefaultEditor(URI.createURI(uri.toString.replace("/.applied/", "/model/")), null, -1, select);
}
override open(URI referenceOwnerURI, EReference reference, int indexInList, boolean select) {
val resourceServiceProvider = resourceServiceProviderRegistry.getResourceServiceProvider(referenceOwnerURI.trimFragment());
if(resourceServiceProvider instanceof IResourceUIServiceProvider) {
val editorOpener = (resourceServiceProvider as IResourceUIServiceProvider).getURIEditorOpener();
if(editorOpener !== null) {
return editorOpener.open(referenceOwnerURI, reference, indexInList, select);
}
}
return openDefaultEditor(referenceOwnerURI, reference, indexInList, select);
}
def protected IEditorPart openDefaultEditor(URI uri, EReference crossReference, int indexInList, boolean select) {
val storages = mapper.getStorages(uri.trimFragment()).iterator();
if(storages !== null && storages.hasNext()) {
try {
val storage = storages.next().getFirst();
var IEditorPart editor = null;
if(storage instanceof IFile) {
editor = openDefaultEditor(storage as IFile);
} else {
editor = openDefaultEditor(storage, uri);
}
selectAndReveal(editor, uri, crossReference, indexInList, select);
return editor;
} catch(WrappedException e) {
logger.error("Error while opening editor part for EMF URI '" + uri + "'", e.getCause());
} catch(PartInitException partInitException) {
logger.error("Error while opening editor part for EMF URI '" + uri + "'", partInitException);
}
}
return null;
}
def protected void selectAndReveal(IEditorPart openEditor, URI uri, EReference crossReference, int indexInList, boolean select) {
val xtextEditor = EditorUtils.getXtextEditor(openEditor);
if(xtextEditor !== null) {
if(uri.fragment() !== null) {
xtextEditor.getDocument().priorityReadOnly(new IUnitOfWork.Void<XtextResource>() {
override process(XtextResource resource) throws Exception {
if(resource !== null) {
val object = resource.getEObject(uri.fragment());
val locationProvider = resource.getResourceServiceProvider().get(ILocationInFileProvider);
val location = if(crossReference !== null)
locationProvider.getSignificantTextRegion(object, crossReference, indexInList)
else
locationProvider.getSignificantTextRegion(object);
if(select) {
xtextEditor.selectAndReveal(location.getOffset(), location.getLength());
} else {
xtextEditor.reveal(location.getOffset(), location.getLength());
}
}
}
});
}
}
}
def protected IEditorPart openDefaultEditor(IFile file) throws PartInitException {
val page = getWorkbench().getActiveWorkbenchWindow().getActivePage();
return IDE.openEditor(page, file);
}
def protected IEditorPart openDefaultEditor(IStorage storage, URI uri) throws PartInitException {
val editorInput = EditorUtils.createEditorInput(storage);
val page = getWorkbench().getActiveWorkbenchWindow().getActivePage();
return IDE.openEditor(page, editorInput, PlatformUI.getWorkbench().getEditorRegistry().getDefaultEditor(uri.lastSegment()).getId());
}
def protected IWorkbench getWorkbench() {
if(workbench === null)
throw new IllegalStateException("No workbench");
return workbench;
}
}
|
