private IProgressService getProgressService() {
IEditorPart editor = getTextEditor();
if (editor != null) {
IWorkbenchPartSite site = editor.getSite();
if (site != null)
return (IWorkbenchSiteProgressService)
editor.getSite().getAdapter(IWorkbenchSiteProgressService.class);
}
return PlatformUI.getWorkbench().getProgressService();
}
private boolean openFileImpl(IProject project, IPath sourceLoc, int lineNumber) {
if (sourceLoc == null || "??".equals(sourceLoc.toString())) return false;
try {
IEditorInput editorInput = getEditorInput(sourceLoc, project);
IWorkbenchPage p= CUIPlugin.getActivePage();
if (p != null) {
if (editorInput == null) {
p.openEditor(
new STCSourceNotFoundEditorInput(project, sourceLoc, lineNumber),
"org.eclipse.linuxtools.binutils.link2source.STCSourceNotFoundEditor",
true);
} else {
IEditorPart editor = p.openEditor(editorInput, CUIPlugin.EDITOR_ID, true);
if (lineNumber > 0 && editor instanceof ITextEditor){
IDocumentProvider provider= ((ITextEditor)editor).getDocumentProvider();
IDocument document= provider.getDocument(editor.getEditorInput());
try {
int start = document.getLineOffset(lineNumber-1);
((ITextEditor)editor).selectAndReveal(start, 0);
IWorkbenchPage page= editor.getSite().getPage();
page.activate(editor);
return true;
} catch (BadLocationException x) {
// ignore
}
}
}
}
}
catch (Exception _) {
}
return false;
}
/**
* Sets the active editor for the delegate.
*
* @param action the action proxy that handles presentation portion of the action
* @param targetEditor the new editor target
*/
@Override
public void setActiveEditor(IAction action, IEditorPart targetEditor) {
editor = targetEditor;
if (editor != null) {
page = editor.getSite().getPage();
}
}
/**
* DOC smallet Comment method "openRoutineEditor".
*
* @param item
* @throws SystemException
* @throws PartInitException
*/
public IEditorPart openSQLPatternEditor(SQLPatternItem item, boolean readOnly)
throws SystemException, PartInitException {
if (item == null) {
return null;
}
ICodeGeneratorService service =
(ICodeGeneratorService)
GlobalServiceRegister.getDefault().getService(ICodeGeneratorService.class);
ECodeLanguage lang =
((RepositoryContext) CorePlugin.getContext().getProperty(Context.REPOSITORY_CONTEXT_KEY))
.getProject()
.getLanguage();
ISQLPatternSynchronizer routineSynchronizer = service.getSQLPatternSynchronizer();
// check if the related editor is open.
IWorkbenchPage page = getActivePage();
IEditorReference[] editorParts = page.getEditorReferences();
String talendEditorID =
"org.talend.designer.core.ui.editor.StandAloneTalend"
+ lang.getCaseName()
+ "Editor"; //$NON-NLS-1$ //$NON-NLS-2$
boolean found = false;
IEditorPart talendEditor = null;
for (IEditorReference reference : editorParts) {
IEditorPart editor = reference.getEditor(false);
if (talendEditorID.equals(editor.getSite().getId())) {
// TextEditor talendEditor = (TextEditor) editor;
RepositoryEditorInput editorInput = (RepositoryEditorInput) editor.getEditorInput();
Item item2 = editorInput.getItem();
if (item2 != null
&& item2 instanceof SQLPatternItem
&& item2.getProperty().getId().equals(item.getProperty().getId())) {
if (item2.getProperty().getVersion().equals(item.getProperty().getVersion())) {
page.bringToTop(editor);
found = true;
talendEditor = editor;
break;
} else {
page.closeEditor(editor, false);
}
}
}
}
if (!found) {
routineSynchronizer.syncSQLPattern(item, true);
IFile file = routineSynchronizer.getSQLPatternFile(item);
RepositoryEditorInput input = new RepositoryEditorInput(file, item);
input.setReadOnly(readOnly);
talendEditor = page.openEditor(input, talendEditorID); // $NON-NLS-1$
}
return talendEditor;
}
@Override
public void execute(String newText) throws CoreException {
if (newText.isEmpty()) {
if (getModel().getText() != null) {
EnquiryTranslationRemoveCommand removeCmd = new EnquiryTranslationRemoveCommand(getModel());
removeCmd.execute(newText);
}
return;
}
if (newText.equals(getModel().getText())) {
// do nothing if text is the same.
return;
}
IEditorPart editorPart = getActiveEditorPart();
if (editorPart != null) {
// Extract useful parameters needed for the command
IWorkbenchPartSite site = editorPart.getSite();
// Invoke the command
IHandlerService handlerService = (IHandlerService) site.getService(IHandlerService.class);
ICommandService commandService = (ICommandService) site.getService(ICommandService.class);
CommandStack commandStack = (CommandStack) editorPart.getAdapter(CommandStack.class);
try {
// Get the command and assign values to parameters
Command command = commandService.getCommand(EDIT_COMMAND_ID);
Parameterization parameter = new Parameterization(command.getParameter("text"), newText);
ParameterizedCommand parmCommand =
new ParameterizedCommand(command, new Parameterization[] {parameter});
// Prepare the evaluation context
IEvaluationContext ctx = handlerService.getCurrentState();
ctx.addVariable("model", getModel());
ctx.addVariable("commandStack", commandStack);
// Execute the command
handlerService.executeCommandInContext(parmCommand, null, ctx);
} catch (Exception ex) {
IStatus status =
new Status(
IStatus.ERROR,
Activator.PLUGIN_ID,
"Error while executing command to update translation",
ex);
throw new CoreException(status);
}
} else {
/** @TODO log warn no active editorPart, should never occur */
}
}
protected SVOutlinePage getOutlineView(IEditorPart editor) throws PartInitException {
IViewPart outline_v =
editor.getSite().getPage().showView("org.eclipse.ui.views.ContentOutline");
assertNotNull(outline_v);
while (Display.getDefault().readAndDispatch()) {}
Object ret = editor.getAdapter(IContentOutlinePage.class);
assertTrue(ret instanceof SVOutlinePage);
return (SVOutlinePage) ret;
}
public void testSingleNonUIThreadUpdatesToEditorDocument() throws Exception {
IFile file = getOrCreateFile(PROJECT_NAME + "/" + "testBackgroundChanges.xml");
ITextFileBufferManager textFileBufferManager = FileBuffers.getTextFileBufferManager();
textFileBufferManager.connect(
file.getFullPath(), LocationKind.IFILE, new NullProgressMonitor());
ITextFileBuffer textFileBuffer =
textFileBufferManager.getTextFileBuffer(file.getFullPath(), LocationKind.IFILE);
final IDocument document = textFileBuffer.getDocument();
document.replace(0, 0, "<?xml encoding=\"UTF-8\" version=\"1.0\"?>\n");
textFileBuffer.commit(new NullProgressMonitor(), true);
String testText = document.get() + "<c/><b/><a/>";
final int end = document.getLength();
IWorkbenchPage activePage =
PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
IEditorPart openedEditor = IDE.openEditor(activePage, file);
final boolean state[] = new boolean[] {false};
Job changer =
new Job("text changer") {
protected IStatus run(IProgressMonitor monitor) {
try {
document.replace(end, 0, "<a/>");
document.replace(end, 0, "<b/>");
document.replace(end, 0, "<c/>");
} catch (Exception e) {
return new Status(IStatus.ERROR, SSEUIPlugin.ID, e.getMessage());
} finally {
state[0] = true;
}
return Status.OK_STATUS;
}
};
changer.setUser(true);
changer.setSystem(false);
changer.schedule();
while (!state[0]) {
openedEditor.getSite().getShell().getDisplay().readAndDispatch();
}
String finalText = document.get();
textFileBuffer.commit(new NullProgressMonitor(), true);
textFileBufferManager.disconnect(
file.getFullPath(), LocationKind.IFILE, new NullProgressMonitor());
activePage.closeEditor(openedEditor, false);
assertEquals("Non-UI changes did not apply", testText, finalText);
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.ui.internal.e4.compatibility.WorkbenchPartReference#initialize
* (org.eclipse.ui.IWorkbenchPart)
*/
@Override
public void initialize(IWorkbenchPart part) throws PartInitException {
IConfigurationElement element = descriptor.getConfigurationElement();
editorSite = new EditorSite(getModel(), part, this, element);
if (element == null) {
editorSite.setExtensionId(descriptor.getId());
}
editorSite.setActionBars(
createEditorActionBars((WorkbenchPage) getPage(), descriptor, editorSite));
IEditorPart editor = (IEditorPart) part;
try {
editor.init(editorSite, getEditorInput());
} catch (PartInitException e) {
if (editor instanceof ErrorEditorPart) {
editor.init(editorSite, new NullEditorInput(this));
} else {
throw e;
}
}
if (editor.getSite() != editorSite || editor.getEditorSite() != editorSite) {
String id = descriptor == null ? getModel().getElementId() : descriptor.getId();
throw new PartInitException(NLS.bind(WorkbenchMessages.EditorManager_siteIncorrect, id));
}
if (part instanceof IPersistableEditor) {
if (editorState != null) {
((IPersistableEditor) part).restoreState(editorState);
} else if (useIPersistableEditor()) {
String mementoString = getModel().getPersistedState().get(MEMENTO_KEY);
if (mementoString != null) {
try {
IMemento createReadRoot = XMLMemento.createReadRoot(new StringReader(mementoString));
IMemento editorStateMemento =
createReadRoot.getChild(IWorkbenchConstants.TAG_EDITOR_STATE);
if (editorStateMemento != null) {
((IPersistableEditor) part).restoreState(editorStateMemento);
}
} catch (WorkbenchException e) {
throw new PartInitException(e.getStatus());
}
}
}
}
legacyPart = part;
addPropertyListeners();
}
@Override
public void execute(String newText) throws CoreException {
IEditorPart editorPart = getActiveEditorPart();
if (editorPart != null) {
// Extract useful parameters needed for the command
IWorkbenchPartSite site = editorPart.getSite();
// Invoke the command
IHandlerService handlerService = (IHandlerService) site.getService(IHandlerService.class);
ICommandService commandService = (ICommandService) site.getService(ICommandService.class);
if (editorPart instanceof VersionMultiPageEditor) {
VersionMultiPageEditor vEditor = (VersionMultiPageEditor) editorPart;
EditingDomain editingDomain = vEditor.getVersionFormEditor().getEditingDomain();
CommandStack commandStack = editingDomain.getCommandStack();
try {
// Get the command and assign values to parameters
Command command = commandService.getCommand(getCommandId());
ParameterizedCommand parmCommand =
new ParameterizedCommand(command, new Parameterization[] {});
// Prepare the evaluation context
IEvaluationContext ctx = handlerService.getCurrentState();
ctx.addVariable("model", getModel());
ctx.addVariable("commandStack", commandStack);
ctx.addVariable("editingDomain", editingDomain);
// Execute the command
handlerService.executeCommandInContext(parmCommand, null, ctx);
} catch (Exception ex) {
IStatus status =
new Status(
IStatus.ERROR,
VersionEditorActivator.PLUGIN_ID,
"Error while executing command to remove translation",
ex);
throw new CoreException(status);
}
}
} else {
/** @TODO log warn no active editorPart, should never occur */
}
}
public void start(ModelSet modelsManager) {
try {
IEditorPart editor =
ServiceUtilsForResourceSet.getInstance()
.getService(IMultiDiagramEditor.class, modelsManager);
if (editor != null) {
// this model is opened in an editor. That is the context in which we want to provide our
// services
presenter = new ZombieStereotypeDialogPresenter(editor.getSite().getShell(), modelsManager);
adapter.adapt(modelsManager);
}
} catch (ServiceException e) {
// OK, there is no editor, so we aren't needed
}
}
private IProject getActiveProject() {
IEditorPart editorPart = null;
IProject activeProject = null;
IEditorReference editorReferences[] =
PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getEditorReferences();
for (int i = 0; i < editorReferences.length; i++) {
IEditorPart editor = editorReferences[i].getEditor(false);
if (editor != null) {
editorPart = editor.getSite().getWorkbenchWindow().getActivePage().getActiveEditor();
}
if (editorPart != null) {
EsbEditorInput input = (EsbEditorInput) editorPart.getEditorInput();
IFile file = input.getXmlResource();
activeProject = file.getProject();
}
}
return activeProject;
}
/**
* When the active editor changes, this remembers the change and registers with it as a selection
* provider.
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
*
* @generated
*/
public void setActiveEditor(IEditorPart part) {
super.setActiveEditor(part);
activeEditorPart = part;
// Switch to the new selection provider.
//
if (selectionProvider != null) {
selectionProvider.removeSelectionChangedListener(this);
}
if (part == null) {
selectionProvider = null;
} else {
selectionProvider = part.getSite().getSelectionProvider();
selectionProvider.addSelectionChangedListener(this);
// Fake a selection changed event to update the menus.
//
if (selectionProvider.getSelection() != null) {
selectionChanged(
new SelectionChangedEvent(selectionProvider, selectionProvider.getSelection()));
}
}
}
public Object execute(ExecutionEvent event) throws ExecutionException {
IEditorPart editor = HandlerUtil.getActiveEditor(event);
if (editor instanceof IXliffEditor) {
IXliffEditor xliffEditor = (IXliffEditor) editor;
IFile file = ((FileEditorInput) editor.getEditorInput()).getFile();
// ProjectConfiger projectConfig =
// ProjectConfigerFactory.getProjectConfiger(file.getProject());
// List<DatabaseModelBean> lstDatabase = projectConfig.getTermBaseDbs(true);
TbImporter.getInstance().setProject(file.getProject());
if (!TbImporter.getInstance().checkImporter()) {
MessageDialog.openInformation(
HandlerUtil.getActiveShell(event),
Messages.getString("handler.AddTermToTBHandler.msgTitle"),
Messages.getString("handler.AddTermToTBHandler.msg"));
return null;
}
StringBuffer srcTerm = new StringBuffer();
StringBuffer tgtTerm = new StringBuffer();
String srcAllText =
xliffEditor.getRowTransUnitBean(xliffEditor.getSelectedRows()[0]).getSrcText();
xliffEditor.getSelectSrcOrTgtPureText(srcTerm, tgtTerm);
AddTermToTBDialog dialog =
AddTermToTBDialog.getInstance(
editor.getSite().getShell(),
srcTerm.toString().trim(),
tgtTerm.toString().trim(),
AddTermToTBDialog.ADD_TYPE);
dialog.setProject(file.getProject());
dialog.setSrcLang(xliffEditor.getSrcColumnName());
dialog.setTgtLang(xliffEditor.getTgtColumnName());
dialog.setSrcAllText(srcAllText);
dialog.open();
}
return null;
}
/**
* Returns the name of the given editor
*
* @param editor
* @return
*/
public static String getName(IEditorPart editor) {
IWorkbenchPage page = editor.getSite().getPage();
IWorkbenchPartReference ref = page.getReference(editor);
return ref.getPartName();
}
public void tearDown() {
if (editor != null) {
editor.getSite().getPage().closeEditor(editor, false);
}
}
public void notifyChanged(Notification notification) {
super.notifyChanged(notification);
/*
* We create partOpened / partClosed events based on both MPartWidget
* events.
*
* The initial MPartVisible events are sent early and don't have the
* actual implementation included. The MPartWidget events are sent as a
* final step of "part is created" and therefore we use it to create
* partOpened events. When the part is closed the widget is set to null.
*/
if (MApplicationPackage.Literals.UI_ELEMENT__WIDGET.equals(notification.getFeature())) {
if (notification.getEventType() != Notification.SET) return;
if (notification.getOldValue() == notification.getNewValue())
return; // avoid extra notifications
Object part = notification.getNotifier();
if (part instanceof MPart) {
IWorkbenchPartReference ref = toPartRef((MPart) part);
if (ref != null) {
boolean isVisible = ((MPart) part).isVisible();
if (isVisible) {
if (notification.getNewValue() == null) {
/*
* not sure if this is the right place to fix bug
* 283922 but if there is no widget and
* isVisible==true, we must be shutting down, and we
* should not send partOpened notifications.
*/
return;
}
SaveablesList modelManager =
(SaveablesList)
ref.getPart(true).getSite().getService(ISaveablesLifecycleListener.class);
modelManager.postOpen(ref.getPart(true));
partList.firePartOpened(ref);
}
}
}
return;
}
// Interpret E4 activation events:
if (!MApplicationPackage.Literals.ELEMENT_CONTAINER__ACTIVE_CHILD.equals(
notification.getFeature())) return;
// at this time we only interpreting SET events
if (notification.getEventType() != Notification.SET
|| notification.getEventType() != Notification.CREATE) return;
// make sure something actually changed
Object oldPart = notification.getOldValue();
Object newPart = notification.getNewValue();
// create 3.x visibility events
if ((newPart != oldPart) && (oldPart instanceof MPart) && (newPart instanceof MPart))
changeVisibility((MPart) oldPart, (MPart) newPart);
// create 3.x activation events
final Object object = e4Context.get(IServiceConstants.ACTIVE_PART);
if ((newPart != oldPart) && newPart instanceof MPerspective) {
// let legacy Workbench know about perspective activation
IWorkbenchPage page = (IWorkbenchPage) e4Context.get(IWorkbenchPage.class.getName());
if (page != null) {
String id = ((MPerspective) newPart).getId();
IPerspectiveDescriptor[] descriptors = page.getOpenPerspectives();
for (IPerspectiveDescriptor desc : descriptors) {
if (!id.equals(desc.getId())) continue;
page.setPerspective(desc);
}
}
}
if (object instanceof MPart) {
IWorkbenchPartReference ref = toPartRef((MPart) object);
if (ref != null) {
// set the Focus to the newly active part
IWorkbenchPart part = ref.getPart(true);
part.setFocus();
// Update the action bars
SubActionBars bars = (SubActionBars) ((PartSite) part.getSite()).getActionBars();
bars.partChanged(part);
partList.setActivePart(ref);
if (ref instanceof IEditorReference) {
IEditorReference editorReference = (IEditorReference) ref;
partList.setActiveEditor(editorReference);
final IEditorPart editor = editorReference.getEditor(true);
e4Context.set(ISources.ACTIVE_EDITOR_NAME, editor);
e4Context.set(ISources.ACTIVE_EDITOR_ID_NAME, editor.getSite().getId());
e4Context.set(ISources.ACTIVE_EDITOR_INPUT_NAME, editor.getEditorInput());
}
}
} else {
partList.setActiveEditor(null);
e4Context.set(ISources.ACTIVE_EDITOR_NAME, null);
e4Context.set(ISources.ACTIVE_EDITOR_ID_NAME, null);
e4Context.set(ISources.ACTIVE_EDITOR_INPUT_NAME, null);
partList.setActivePart(null);
}
}
/**
* Note: This test takes a while to run, but it's testing scalability after all.
*
* @throws Exception
*/
public void testManyNonUIThreadsUpdatingEditorDocument() throws Exception {
final int numberOfJobs = 30;
/** 15 minute timeout before we stop waiting for the change jobs to complete */
long timeout = 15 * 60 * 1000;
long startTime = System.currentTimeMillis();
IFile file = getOrCreateFile(PROJECT_NAME + "/" + "testManyBackgroundChanges.xml");
ITextFileBufferManager textFileBufferManager = FileBuffers.getTextFileBufferManager();
textFileBufferManager.connect(
file.getFullPath(), LocationKind.IFILE, new NullProgressMonitor());
ITextFileBuffer textFileBuffer =
textFileBufferManager.getTextFileBuffer(file.getFullPath(), LocationKind.IFILE);
final IDocument document = textFileBuffer.getDocument();
document.replace(0, 0, "<?xml encoding=\"UTF-8\" version=\"1.0\"?>\n");
textFileBuffer.commit(new NullProgressMonitor(), true);
final int insertionPoint = document.getLength();
final char names[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray();
// numberOfJobs Jobs, inserting 26 tags, each 4 characters long
int expectedLength = insertionPoint + numberOfJobs * 4 * names.length;
IWorkbenchPage activePage =
PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
activePage.showView(IPageLayout.ID_PROGRESS_VIEW);
IEditorPart openedEditor = IDE.openEditor(activePage, file);
final int finished[] = new int[] {numberOfJobs};
Job changers[] = new Job[numberOfJobs];
for (int i = 0; i < changers.length; i++) {
changers[i] =
new Job("Text Changer " + Integer.toString(i)) {
protected IStatus run(IProgressMonitor monitor) {
try {
for (int j = 0; j < names.length; j++) {
document.replace(insertionPoint + 4 * j, 0, "<" + names[j] + "/>");
}
} catch (Exception e) {
return new Status(IStatus.ERROR, SSEUIPlugin.ID, e.getMessage());
} finally {
finished[0]--;
}
return Status.OK_STATUS;
}
};
changers[i].setUser(true);
changers[i].setSystem(false);
}
for (int i = 0; i < changers.length; i++) {
changers[i].schedule();
}
long runtime = 0;
while (finished[0] > 0 && (runtime = System.currentTimeMillis()) - startTime < timeout) {
openedEditor.getSite().getShell().getDisplay().readAndDispatch();
}
assertTrue("Test timed out: (" + timeout + " was allowed)", runtime - startTime < timeout);
int finalLength = document.getLength();
textFileBuffer.commit(new NullProgressMonitor(), true);
textFileBufferManager.disconnect(
file.getFullPath(), LocationKind.IFILE, new NullProgressMonitor());
activePage.closeEditor(openedEditor, false);
assertEquals("Some non-UI changes did not apply", expectedLength, finalLength);
}
/** Updates the outline page's context menu for the current input */
private void updateContextMenuId() {
String computedContextMenuId = null;
// update outline view's context menu control and ID
if (fEditor == null) {
IWorkbenchPage page = getSite().getWorkbenchWindow().getActivePage();
if (page != null) {
fEditor = page.getActiveEditor();
}
}
computedContextMenuId = computeContextMenuID();
if (computedContextMenuId == null) {
computedContextMenuId = OUTLINE_CONTEXT_MENU_ID;
}
/*
* Update outline context menu id if updating to a new id or if
* context menu is not already set up
*/
if (!computedContextMenuId.equals(fContextMenuId) || (fContextMenu == null)) {
fContextMenuId = computedContextMenuId;
if (getControl() != null && !getControl().isDisposed()) {
// dispose of previous context menu
if (fContextMenu != null) {
fContextMenu.dispose();
}
if (fContextMenuManager != null) {
fContextMenuManager.removeMenuListener(fGroupAdder);
fContextMenuManager.removeAll();
fContextMenuManager.dispose();
}
fContextMenuManager = new MenuManager(fContextMenuId, fContextMenuId);
fContextMenuManager.setRemoveAllWhenShown(true);
fContextMenuManager.addMenuListener(fGroupAdder);
fContextMenu = fContextMenuManager.createContextMenu(getControl());
getControl().setMenu(fContextMenu);
getSite().registerContextMenu(fContextMenuId, fContextMenuManager, this);
/*
* also register this menu for source page part and structured
* text outline view ids
*/
if (fEditor != null && fEditor.getSite() != null) {
String partId = fEditor.getSite().getId();
if (partId != null) {
getSite()
.registerContextMenu(
partId + OUTLINE_CONTEXT_MENU_SUFFIX, fContextMenuManager, this);
}
}
getSite().registerContextMenu(OUTLINE_CONTEXT_MENU_ID, fContextMenuManager, this);
}
}
}
public void setActiveEditor(IEditorPart targetEditor) {
super.setActiveEditor(targetEditor);
workbench = targetEditor.getSite().getWorkbenchWindow().getActivePage();
workbench.addPartListener(this);
targetEditor.addPropertyListener(this);
}
public SynchronizationManager(
IEditorPart editor, AspectEditModel editModel, SynchronizationHandler handler) {
partListener = new ActivationListener(this, editor, handler, editModel);
editor.getSite().getWorkbenchWindow().getPartService().addPartListener(partListener);
PlatformUI.getWorkbench().addWindowListener(partListener);
}
/* (non-Javadoc)
* @see org.eclipse.ui.IWindowListener#windowClosed(org.eclipse.ui.IWorkbenchWindow)
*/
public void windowClosed(IWorkbenchWindow window) {
if (editor.getSite().getWorkbenchWindow() == window) {
manager.dispose();
}
}