Skip to main content
aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorBrian de Alwis2017-11-15 17:36:29 +0000
committerfabioz2017-11-19 15:23:31 +0000
commit6049c6abb5ec2043f915c0ad22f1ff26a9c4ffba (patch)
tree2e8039de7ad8492e760cdfc9914a0943a9136541
parent5ffde567b662cb194fb75935fbd445f7296d148d (diff)
downloadorg.eclipse.e4.ui-6049c6abb5ec2043f915c0ad22f1ff26a9c4ffba.tar.gz
org.eclipse.e4.ui-6049c6abb5ec2043f915c0ad22f1ff26a9c4ffba.tar.xz
org.eclipse.e4.ui-6049c6abb5ec2043f915c0ad22f1ff26a9c4ffba.zip
Code clean up and doc updates
Drop use of `this.` for accessing fields and methods. Change-Id: I167dc90763959b69182e22ff0d5bd3cd8d1ad735
-rw-r--r--bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/EMacroService.java30
-rw-r--r--bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/IMacroContext.java8
-rw-r--r--bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/IMacroInstruction.java15
-rw-r--r--bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/IMacroInstructionsListener.java19
-rw-r--r--bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/ComposableMacro.java56
-rw-r--r--bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/MacroManager.java20
-rw-r--r--bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/MacroServiceImplementation.java134
-rw-r--r--bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/Messages.java1
-rw-r--r--bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/SavedJSMacro.java17
-rw-r--r--bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/messages.properties1
-rw-r--r--tests/org.eclipse.e4.ui.macros.tests/src/org/eclipse/e4/ui/macros/tests/MacroTest.java12
11 files changed, 160 insertions, 153 deletions
diff --git a/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/EMacroService.java b/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/EMacroService.java
index 77338b66..3ca040ef 100644
--- a/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/EMacroService.java
+++ b/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/EMacroService.java
@@ -69,29 +69,27 @@ public interface EMacroService {
int PRIORITY_HIGH = 10;
/**
- * Adds a macro instruction to be added to the current macro being recorded. The
- * difference between this method and
- * {@link #addMacroInstruction(IMacroInstruction)} is that it's meant to be used
- * when an event may trigger the creation of multiple macro instructions and
- * only one of those should be recorded.
+ * Adds a macro instruction to be added to the current macro being recorded.
+ * This method should be used when an event may trigger the creation of
+ * multiple macro instructions but only one of those should be recorded.
*
- * For instance, if a given KeyDown event is recorded in a StyledText and later
- * an action is triggered by this event, the recorded action should overwrite
- * the KeyDown event.
+ * For instance, if a given {@code KeyDown} event is recorded in a
+ * {@link StyledText} and later an action is triggered by this event, the
+ * recorded action should overwrite the {@code KeyDown} event.
*
* @param macroInstruction
* the macro instruction to be added to the macro currently being
* recorded.
* @param event
- * the event that triggered the creation of the macro instruction to
- * be added. If there are multiple macro instructions added for the
- * same event, only the one with the highest priority will be kept
- * (if 2 events have the same priority, the last one will replace the
- * previous one).
+ * the event that triggered the creation of the macro instruction
+ * to be added. If there are multiple macro instructions added
+ * for the same event, only the one with the highest priority
+ * will be kept (if 2 events have the same priority, the last one
+ * will replace the previous one).
* @param priority
- * the priority of the macro instruction being added (to be compared
- * against the priority of other added macro instructions for the
- * same event).
+ * the priority of the macro instruction being added (to be
+ * compared against the priority of other added macro
+ * instructions for the same event).
* @see #addMacroInstruction(IMacroInstruction)
*/
void addMacroInstruction(IMacroInstruction macroInstruction, Object event, int priority);
diff --git a/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/IMacroContext.java b/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/IMacroContext.java
index 212ff8bf..ef6a318b 100644
--- a/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/IMacroContext.java
+++ b/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/IMacroContext.java
@@ -11,10 +11,10 @@
package org.eclipse.e4.core.macros;
/**
- * The context bound to the macro record or playback. Macro state listeners
- * (org.eclipse.e4.core.macros.IMacroStateListener) registered in
- * {@link EMacroService} may use it as a simple key-value store to keep
- * macro-specific state during a record or playback.
+ * The context bound to the macro record or playback.
+ * {@link org.eclipse.e4.core.macros.IMacroStateListener Macro state listeners}
+ * registered with a {@link EMacroService} may use it as a simple key-value
+ * store to keep macro-specific state during macro recording and playback.
*/
public interface IMacroContext {
diff --git a/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/IMacroInstruction.java b/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/IMacroInstruction.java
index 31ca3086..6c9b0005 100644
--- a/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/IMacroInstruction.java
+++ b/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/IMacroInstruction.java
@@ -13,18 +13,17 @@ package org.eclipse.e4.core.macros;
import java.util.Map;
/**
- * The basic abstraction of a macro instruction (i.e.: a macro may be composed
- * of multiple macro instructions). The macro instruction also can be stored in
- * disk to be reconstructed later on.
+ * A step in a macro. A macro may be composed of multiple macro instructions. A
+ * macro instruction can be stored on disk for later reconstruction.
*/
public interface IMacroInstruction {
/**
* @return the id for the macro instruction.
- * @note this id may be visible to the user, so, it should ideally be something
- * short and readable (such as KeyDown, or Command), not a dotted name as
- * is usual for Eclipse ids (note that it cannot be changed afterwards as
- * this id may be written to disk).
+ * @note This id may be visible to the user so it should ideally be
+ * something short and readable (such as {@code KeyDown}, or
+ * {@code Command}). Note that an id cannot be changed afterwards as
+ * this id may be written to disk.
*/
String getId();
@@ -34,7 +33,7 @@ public interface IMacroInstruction {
* @param macroPlaybackContext
* the context used to playback the macro.
* @throws MacroPlaybackException
- * if something didn't work when executing the macro.
+ * if an error occurred when executing the macro.
*/
void execute(IMacroPlaybackContext macroPlaybackContext) throws MacroPlaybackException;
diff --git a/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/IMacroInstructionsListener.java b/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/IMacroInstructionsListener.java
index cefbd8bb..e5099ef5 100644
--- a/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/IMacroInstructionsListener.java
+++ b/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/IMacroInstructionsListener.java
@@ -11,7 +11,13 @@
package org.eclipse.e4.core.macros;
/**
- * A listener for the macro instructions being added.
+ * An instance of this interface can be notified of changes during macro
+ * recording.
+ *
+ * <ul>
+ * <li>FIXME: this seems to be more of an adviser than listener?
+ * <li>FIXME: rename preAddMacroInstruction -> verifyMacroInstruction()?
+ * </ul>
*/
public interface IMacroInstructionsListener {
@@ -27,13 +33,14 @@ public interface IMacroInstructionsListener {
void preAddMacroInstruction(IMacroInstruction macroInstruction) throws CancelMacroRecordingException;
/**
- * Called after a given macro instruction is added to the macro. Note that it's
- * possible that beforeMacroInstructionAdded is called and
- * afterMacroInstructionAdded isn't if the macro instruction doesn't have enough
- * priority.
+ * Called after a given macro instruction is added to the macro. Note that
+ * it is possible that {@link #preAddMacroInstruction(IMacroInstruction)} is
+ * called without a matching
+ * {@link #postAddMacroInstruction(IMacroInstruction)) should the macro
+ * instruction not be of high-enough priority.
*
* @param macroInstruction
- * the macro instruction just added to the current macro.
+ * the macro instruction added to the current macro.
*/
void postAddMacroInstruction(IMacroInstruction macroInstruction);
}
diff --git a/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/ComposableMacro.java b/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/ComposableMacro.java
index eedf507e..3828e2d3 100644
--- a/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/ComposableMacro.java
+++ b/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/ComposableMacro.java
@@ -44,8 +44,8 @@ import org.eclipse.e4.core.macros.MacroPlaybackException;
private final int fPriority;
private IndexAndPriority(int index, int priority) {
- this.fIndex = index;
- this.fPriority = priority;
+ fIndex = index;
+ fPriority = priority;
}
}
@@ -93,40 +93,39 @@ import org.eclipse.e4.core.macros.MacroPlaybackException;
}
/**
- * Adds a macro instruction to be added to the current macro being recorded. The
- * difference between this method and
- * {@link #addMacroInstruction(IMacroInstruction)} is that it's meant to be used
- * when an event may trigger the creation of multiple macro instructions and
- * only one of those should be recorded.
+ * Adds a macro instruction to be added to the current macro being recorded.
+ * This method should be used when an event may trigger the creation of
+ * multiple macro instructions and only one of those should be recorded.
*
* @param macroInstruction
* the macro instruction to be added to the macro currently being
* recorded.
* @param event
- * the event that triggered the creation of the macro instruction to
- * be added. If there are multiple macro instructions added for the
- * same event, only the one with the highest priority will be kept
- * (if 2 events have the same priority, the last one will replace the
- * previous one).
+ * the event that triggered the creation of the macro instruction
+ * to be added. If there are multiple macro instructions added
+ * for the same event, only the one with the highest priority
+ * will be kept (if 2 events have the same priority, the last one
+ * will replace the previous one).
* @param priority
- * the priority of the macro instruction being added (to be compared
- * against the priority of other added macro instructions for the
- * same event).
- * @return true if the macro instruction was actually added and false otherwise.
+ * the priority of the macro instruction being added (to be
+ * compared against the priority of other added macro
+ * instructions for the same event).
+ * @return true if the macro instruction was actually added and false
+ * otherwise.
* @see #addMacroInstruction(IMacroInstruction)
*/
public boolean addMacroInstruction(IMacroInstruction macroInstruction, Object event, int priority) {
Assert.isNotNull(event);
- IndexAndPriority currentIndexAndPriority = this.fEventToPlacement.get(event);
+ IndexAndPriority currentIndexAndPriority = fEventToPlacement.get(event);
if (currentIndexAndPriority == null) {
- this.addMacroInstruction(macroInstruction);
- this.fEventToPlacement.put(event, new IndexAndPriority(this.fMacroInstructions.size() - 1, priority));
+ addMacroInstruction(macroInstruction);
+ fEventToPlacement.put(event, new IndexAndPriority(fMacroInstructions.size() - 1, priority));
return true;
}
if (priority >= currentIndexAndPriority.fPriority) {
checkMacroInstruction(macroInstruction);
fMacroInstructions.set(currentIndexAndPriority.fIndex, macroInstruction);
- this.fEventToPlacement.put(event, new IndexAndPriority(currentIndexAndPriority.fIndex, priority));
+ fEventToPlacement.put(event, new IndexAndPriority(currentIndexAndPriority.fIndex, priority));
return true;
}
return false;
@@ -137,7 +136,7 @@ import org.eclipse.e4.core.macros.MacroPlaybackException;
* after the macro is properly composed.
*/
public void clearCachedInfo() {
- this.fEventToPlacement.clear();
+ fEventToPlacement.clear();
}
@Override
@@ -149,20 +148,21 @@ import org.eclipse.e4.core.macros.MacroPlaybackException;
}
/**
- * Actually returns the bytes to be written to the disk to be loaded back later
- * on (the actual load and playback is later done by {@link SavedJSMacro}.
+ * Actually returns the bytes to be written to the disk to be loaded back
+ * later on (the actual load and playback is later done by
+ * {@link SavedJSMacro}).
*
- * @return an UTF-8 encoded array of bytes which can be used to rerun the macro
- * later on.
+ * @return an UTF-8 encoded array of bytes which can be used to rerun the
+ * macro later on.
*/
/* default */ byte[] toJSBytes() {
- final StringBuilder buf = new StringBuilder(this.fMacroInstructions.size() * 60);
+ final StringBuilder buf = new StringBuilder(fMacroInstructions.size() * 60);
buf.append("// Macro generated by the Eclipse macro record engine.\n"); //$NON-NLS-1$
buf.append("// The runMacro() function will be later run by the macro engine.\n"); //$NON-NLS-1$
buf.append("function runMacro(){\n"); //$NON-NLS-1$
- for (IMacroInstruction macroInstruction : this.fMacroInstructions) {
+ for (IMacroInstruction macroInstruction : fMacroInstructions) {
Map<String, String> map = macroInstruction.toMap();
Assert.isNotNull(map);
@@ -181,6 +181,6 @@ import org.eclipse.e4.core.macros.MacroPlaybackException;
* @return the number of macro instructions in this macro.
*/
public int getLength() {
- return this.fMacroInstructions.size();
+ return fMacroInstructions.size();
}
}
diff --git a/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/MacroManager.java b/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/MacroManager.java
index 5af2d04a..2f095f8b 100644
--- a/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/MacroManager.java
+++ b/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/MacroManager.java
@@ -60,7 +60,7 @@ public class MacroManager {
*/
public void setMaxNumberOfTemporaryMacros(int maxNumberOfTemporaryMacros) {
Assert.isTrue(maxNumberOfTemporaryMacros >= 1);
- this.fMaxNumberOfTemporaryMacros = maxNumberOfTemporaryMacros;
+ fMaxNumberOfTemporaryMacros = maxNumberOfTemporaryMacros;
}
/**
@@ -128,7 +128,7 @@ public class MacroManager {
for (File file : macrosDirectories) {
Assert.isNotNull(file);
}
- this.fMacrosDirectories = macrosDirectories;
+ fMacrosDirectories = macrosDirectories;
reloadMacros();
}
@@ -244,7 +244,7 @@ public class MacroManager {
// Start recording
fMacroRecordContext = new MacroRecordContext();
fMacroBeingRecorded = new ComposableMacro(macroInstructionIdToFactory);
- for (IMacroStateListener listener : this.fStateListeners) {
+ for (IMacroStateListener listener : fStateListeners) {
SafeRunner.run(() -> listener.macroRecordContextCreated(fMacroRecordContext));
}
if (!notifyMacroStateChange(macroService, StateChange.RECORD_STARTED)) {
@@ -287,8 +287,8 @@ public class MacroManager {
public final long fLastModified;
public PathAndTime(Path path, long lastModified) {
- this.fPath = path;
- this.fLastModified = lastModified;
+ fPath = path;
+ fLastModified = lastModified;
}
}
@@ -298,12 +298,12 @@ public class MacroManager {
* the macro to be recorded as a temporary macro.
*/
private void saveTemporaryMacro(ComposableMacro macro) {
- if (fMacrosDirectories == null || this.fMacrosDirectories.length == 0) {
+ if (fMacrosDirectories == null || fMacrosDirectories.length == 0) {
return;
}
// The first one is the one we use as a working directory to store
// temporary macros.
- File macroDirectory = this.fMacrosDirectories[0];
+ File macroDirectory = fMacrosDirectories[0];
if (!macroDirectory.isDirectory()) {
Activator.log(new RuntimeException(
String.format("Unable to save macro. Expected: %s to be a directory.", macroDirectory))); //$NON-NLS-1$
@@ -418,7 +418,7 @@ public class MacroManager {
fIsPlayingBack = true;
try {
fMacroPlaybackContext = macroPlaybackContext;
- for (IMacroStateListener listener : this.fStateListeners) {
+ for (IMacroStateListener listener : fStateListeners) {
SafeRunner.run(() -> listener.macroPlaybackContextCreated(macroPlaybackContext));
}
@@ -471,11 +471,11 @@ public class MacroManager {
* Reloads the macros available from the disk.
*/
public void reloadMacros() {
- for (File macroDirectory : this.fMacrosDirectories) {
+ for (File macroDirectory : fMacrosDirectories) {
if (macroDirectory.isDirectory()) {
List<PathAndTime> listPathsAndTimes = listTemporaryMacrosPathAndTime(macroDirectory);
if (listPathsAndTimes.size() > 0) {
- this.fLastMacro = new SavedJSMacro(listPathsAndTimes.get(0).fPath.toFile());
+ fLastMacro = new SavedJSMacro(listPathsAndTimes.get(0).fPath.toFile());
return; // Load the last from the first directory (others aren't used for the last
// macro).
}
diff --git a/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/MacroServiceImplementation.java b/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/MacroServiceImplementation.java
index 42894b53..66d390d0 100644
--- a/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/MacroServiceImplementation.java
+++ b/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/MacroServiceImplementation.java
@@ -11,9 +11,11 @@
package org.eclipse.e4.core.macros.internal;
import java.io.File;
+import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import javax.inject.Inject;
+import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtensionRegistry;
@@ -37,12 +39,40 @@ import org.eclipse.e4.core.macros.MacroPlaybackException;
* with the eclipse context and extension points).
*/
public class MacroServiceImplementation implements EMacroService {
+ private static final String MACRO_COMMAND_HANDLING_EXTENSION_POINT = "org.eclipse.e4.core.macros.commandHandling"; //$NON-NLS-1$
+ private static final String MACRO_COMMAND_HANDLING_ELEMENT = "command"; //$NON-NLS-1$
+ private static final String MACRO_COMMAND_HANDLING_ID = "id"; //$NON-NLS-1$
+ private static final String MACRO_COMMAND_HANDLING_RECORDING = "recordMacroInstruction"; //$NON-NLS-1$
+
+ public static final String MACRO_INSTRUCTION_FACTORY_EXTENSION_POINT = "org.eclipse.e4.core.macros.macroInstructionsFactory"; //$NON-NLS-1$
+ public static final String MACRO_INSTRUCTION_ID = "macroInstructionId"; //$NON-NLS-1$
+ public static final String MACRO_INSTRUCTION_FACTORY_CLASS = "class"; //$NON-NLS-1$
+
+ public static final String MACRO_LISTENERS_EXTENSION_POINT = "org.eclipse.e4.core.macros.macroStateListeners"; //$NON-NLS-1$
+ public static final String MACRO_LISTENER_CLASS = "class"; //$NON-NLS-1$
+
+ // id to factory used in instance
+ private Map<String, IMacroInstructionFactory> fMacroInstructionIdToFactory;
+
+ private boolean fLoadedExtensionListeners = false;
+
+ private IEclipseContext fEclipseContext;
+
+ private IExtensionRegistry fExtensionRegistry;
/**
* The instance of the macro manager.
*/
private MacroManager fMacroManager;
+ @Inject
+ public MacroServiceImplementation(IEclipseContext eclipseContext, IExtensionRegistry extensionRegistry) {
+ Assert.isNotNull(eclipseContext);
+ Assert.isNotNull(extensionRegistry);
+ fEclipseContext = eclipseContext;
+ fExtensionRegistry = extensionRegistry;
+ }
+
/**
* Gets the macro manager (lazily creates it if needed).
*
@@ -81,37 +111,11 @@ public class MacroServiceImplementation implements EMacroService {
return fMacroManager;
}
- public static final String MACRO_INSTRUCTION_FACTORY_EXTENSION_POINT = "org.eclipse.e4.core.macros.macroInstructionsFactory"; //$NON-NLS-1$
- public static final String MACRO_INSTRUCTION_ID = "macroInstructionId"; //$NON-NLS-1$
- public static final String MACRO_INSTRUCTION_FACTORY_CLASS = "class"; //$NON-NLS-1$
-
- // Globally loaded id to factory
- private static Map<String, IMacroInstructionFactory> fCachedMacroInstructionIdToFactory;
-
- // id to factory used in instance
- private Map<String, IMacroInstructionFactory> fMacroInstructionIdToFactory;
-
- public static final String MACRO_LISTENERS_EXTENSION_POINT = "org.eclipse.e4.core.macros.macroStateListeners"; //$NON-NLS-1$
- public static final String MACRO_LISTENER_CLASS = "class"; //$NON-NLS-1$
-
- private boolean fLoadedExtensionListeners = false;
-
- private IEclipseContext fEclipseContext;
-
- private IExtensionRegistry fExtensionRegistry;
-
- @Inject
- public MacroServiceImplementation(IEclipseContext eclipseContext, IExtensionRegistry extensionRegistry) {
- this.fEclipseContext = eclipseContext;
- this.fExtensionRegistry = extensionRegistry;
- }
-
-
/**
* Loads the macro listeners provided through extension points.
*/
private void loadExtensionPointsmacroStateListeners() {
- if (!fLoadedExtensionListeners && fExtensionRegistry != null) {
+ if (!fLoadedExtensionListeners) {
fLoadedExtensionListeners = true;
MacroManager macroManager = getMacroManager();
@@ -142,31 +146,28 @@ public class MacroServiceImplementation implements EMacroService {
*/
private Map<String, IMacroInstructionFactory> getMacroInstructionIdToFactory() {
if (fMacroInstructionIdToFactory == null) {
- if (fCachedMacroInstructionIdToFactory == null && fEclipseContext != null && fExtensionRegistry != null) {
- Map<String, IMacroInstructionFactory> validMacroInstructionIds = new HashMap<>();
- for (IConfigurationElement ce : fExtensionRegistry
- .getConfigurationElementsFor(MACRO_INSTRUCTION_FACTORY_EXTENSION_POINT)) {
- String macroInstructionId = ce.getAttribute(MACRO_INSTRUCTION_ID);
- String macroInstructionFactoryClass = ce.getAttribute(MACRO_INSTRUCTION_FACTORY_CLASS);
- if (macroInstructionId != null && macroInstructionFactoryClass != null) {
- try {
- IMacroInstructionFactory macroInstructionFactory = (IMacroInstructionFactory) ce
- .createExecutableExtension(MACRO_INSTRUCTION_FACTORY_CLASS);
-
- // Make sure that it has the proper eclipse context.
- ContextInjectionFactory.inject(macroInstructionFactory, fEclipseContext);
- validMacroInstructionIds.put(macroInstructionId, macroInstructionFactory);
- } catch (CoreException e) {
- Activator.log(e);
- }
- } else {
- Activator.log(new RuntimeException("Wrong definition for extension: " //$NON-NLS-1$
- + MACRO_INSTRUCTION_FACTORY_EXTENSION_POINT + ": " + ce)); //$NON-NLS-1$
+ Map<String, IMacroInstructionFactory> validMacroInstructionIds = new HashMap<>();
+ for (IConfigurationElement ce : fExtensionRegistry
+ .getConfigurationElementsFor(MACRO_INSTRUCTION_FACTORY_EXTENSION_POINT)) {
+ String macroInstructionId = ce.getAttribute(MACRO_INSTRUCTION_ID);
+ String macroInstructionFactoryClass = ce.getAttribute(MACRO_INSTRUCTION_FACTORY_CLASS);
+ if (macroInstructionId != null && macroInstructionFactoryClass != null) {
+ try {
+ IMacroInstructionFactory macroInstructionFactory = (IMacroInstructionFactory) ce
+ .createExecutableExtension(MACRO_INSTRUCTION_FACTORY_CLASS);
+
+ // Make sure that it has the proper eclipse context.
+ ContextInjectionFactory.inject(macroInstructionFactory, fEclipseContext);
+ validMacroInstructionIds.put(macroInstructionId, macroInstructionFactory);
+ } catch (CoreException e) {
+ Activator.log(e);
}
+ } else {
+ Activator.log(new RuntimeException("Wrong definition for extension: " //$NON-NLS-1$
+ + MACRO_INSTRUCTION_FACTORY_EXTENSION_POINT + ": " + ce)); //$NON-NLS-1$
}
- fCachedMacroInstructionIdToFactory = validMacroInstructionIds;
}
- fMacroInstructionIdToFactory = fCachedMacroInstructionIdToFactory;
+ fMacroInstructionIdToFactory = Collections.unmodifiableMap(validMacroInstructionIds);
}
return fMacroInstructionIdToFactory;
}
@@ -191,7 +192,7 @@ public class MacroServiceImplementation implements EMacroService {
@Override
public void addMacroInstruction(IMacroInstruction macroInstruction) {
- if (this.isRecording()) {
+ if (isRecording()) {
try {
getMacroManager().addMacroInstruction(macroInstruction);
} catch (CancelMacroRecordingException e) {
@@ -202,7 +203,7 @@ public class MacroServiceImplementation implements EMacroService {
@Override
public void addMacroInstruction(IMacroInstruction macroInstruction, Object event, int priority) {
- if (this.isRecording()) {
+ if (isRecording()) {
try {
getMacroManager().addMacroInstruction(macroInstruction, event, priority);
} catch (CancelMacroRecordingException e) {
@@ -215,8 +216,8 @@ public class MacroServiceImplementation implements EMacroService {
* Stops the macro recording.
*/
private void stopMacroRecording() {
- if (this.isRecording()) {
- this.toggleMacroRecord();
+ if (isRecording()) {
+ toggleMacroRecord();
}
}
@@ -276,20 +277,13 @@ public class MacroServiceImplementation implements EMacroService {
private Map<String, Boolean> getInternalcommandHandling() {
if (fCustomizedCommandIds == null) {
fCustomizedCommandIds = new HashMap<>();
- if (fEclipseContext != null) {
- IExtensionRegistry registry = fEclipseContext.get(IExtensionRegistry.class);
- if (registry != null) {
- for (IConfigurationElement ce : registry
- .getConfigurationElementsFor("org.eclipse.e4.core.macros.commandHandling")) { //$NON-NLS-1$
- if ("command".equals(ce.getName()) && ce.getAttribute("id") != null //$NON-NLS-1$ //$NON-NLS-2$
- && ce.getAttribute("recordMacroInstruction") != null) { //$NON-NLS-1$
- Boolean recordMacroInstruction = Boolean
- .parseBoolean(ce.getAttribute("recordMacroInstruction")) //$NON-NLS-1$
- ? Boolean.TRUE
- : Boolean.FALSE;
- fCustomizedCommandIds.put(ce.getAttribute("id"), recordMacroInstruction); //$NON-NLS-1$
- }
- }
+ for (IConfigurationElement ce : fExtensionRegistry
+ .getConfigurationElementsFor(MACRO_COMMAND_HANDLING_EXTENSION_POINT)) {
+ if (MACRO_COMMAND_HANDLING_ELEMENT.equals(ce.getName())
+ && ce.getAttribute(MACRO_COMMAND_HANDLING_ID) != null
+ && ce.getAttribute(MACRO_COMMAND_HANDLING_RECORDING) != null) {
+ Boolean recordMacroInstruction = Boolean.parseBoolean(ce.getAttribute(MACRO_COMMAND_HANDLING_RECORDING));
+ fCustomizedCommandIds.put(ce.getAttribute(MACRO_COMMAND_HANDLING_ID), recordMacroInstruction);
}
}
}
@@ -299,11 +293,7 @@ public class MacroServiceImplementation implements EMacroService {
@Override
public boolean isCommandRecorded(String commandId) {
Map<String, Boolean> macrocommandHandling = getInternalcommandHandling();
- Boolean recordMacro = macrocommandHandling.get(commandId);
- if (recordMacro == null) {
- return true;
- }
- return recordMacro;
+ return macrocommandHandling.getOrDefault(commandId, true);
}
@Override
diff --git a/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/Messages.java b/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/Messages.java
index 5734d1d4..6fb60b6c 100644
--- a/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/Messages.java
+++ b/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/Messages.java
@@ -18,6 +18,7 @@ import org.eclipse.osgi.util.NLS;
public class Messages extends NLS {
private static final String BUNDLE_NAME = "org.eclipse.e4.core.macros.internal.messages"; //$NON-NLS-1$
public static String SavedJSMacro_MacrosEvalError;
+ public static String SavedJSMacro_NoJavaScriptEngineFound;
static {
// initialize resource bundle
NLS.initializeMessages(BUNDLE_NAME, Messages.class);
diff --git a/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/SavedJSMacro.java b/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/SavedJSMacro.java
index 89df07f1..61ede841 100644
--- a/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/SavedJSMacro.java
+++ b/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/SavedJSMacro.java
@@ -46,18 +46,18 @@ public class SavedJSMacro implements IMacro {
private final File fFile;
/**
- * Creates a macro which is backed up by the contents of a javascript file.
+ * Creates a macro which is backed by the contents of a javascript file.
*
* @param file
* the file with the contents of the macro.
*/
public SavedJSMacro(File file) {
- this.fFile = file;
+ fFile = file;
}
/**
* Static method to be called when playing back a macro to run a macro
- * instruction..
+ * instruction.
*
* @param macroPlaybackContext
* the context for the macro playback.
@@ -66,8 +66,8 @@ public class SavedJSMacro implements IMacro {
* @param macroInstructionParameters
* the parameters to create the macro instruction.
* @param macroInstructionIdToFactory
- * a map pointing from the macro instruction id to the factory used
- * to create the related macro instruction.
+ * a map pointing from the macro instruction id to the factory
+ * used to create the related macro instruction.
* @throws Exception
* if something happened when creating the macro instruction or
* actually executing it.
@@ -87,7 +87,7 @@ public class SavedJSMacro implements IMacro {
IMacroInstructionFactory macroFactory = macroInstructionIdToFactory.get(macroInstructionId);
if (macroFactory == null) {
- throw new RuntimeException(
+ throw new IllegalStateException(
"Unable to find IMacroInstructionFactory for macro instruction: " + macroInstructionId); //$NON-NLS-1$
}
@@ -99,7 +99,10 @@ public class SavedJSMacro implements IMacro {
public void playback(IMacroPlaybackContext macroPlaybackContext,
Map<String, IMacroInstructionFactory> macroInstructionIdToFactory) throws MacroPlaybackException {
ScriptEngineManager manager = new ScriptEngineManager();
- ScriptEngine engine = manager.getEngineByName("nashorn"); //$NON-NLS-1$
+ ScriptEngine engine = manager.getEngineByName("JavaScript"); //$NON-NLS-1$
+ if (engine == null) {
+ throw new MacroPlaybackException(Messages.SavedJSMacro_NoJavaScriptEngineFound);
+ }
SimpleScriptContext context = new SimpleScriptContext();
context.setBindings(engine.createBindings(), ScriptContext.ENGINE_SCOPE);
Bindings engineScope = context.getBindings(ScriptContext.ENGINE_SCOPE);
diff --git a/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/messages.properties b/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/messages.properties
index 3677ab5b..dd8d4640 100644
--- a/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/messages.properties
+++ b/bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/messages.properties
@@ -1 +1,2 @@
SavedJSMacro_MacrosEvalError=Error when evaluating macro:\n\n{0}
+SavedJSMacro_NoJavaScriptEngineFound=No javascript engine available
diff --git a/tests/org.eclipse.e4.ui.macros.tests/src/org/eclipse/e4/ui/macros/tests/MacroTest.java b/tests/org.eclipse.e4.ui.macros.tests/src/org/eclipse/e4/ui/macros/tests/MacroTest.java
index 90e28524..f04311e4 100644
--- a/tests/org.eclipse.e4.ui.macros.tests/src/org/eclipse/e4/ui/macros/tests/MacroTest.java
+++ b/tests/org.eclipse.e4.ui.macros.tests/src/org/eclipse/e4/ui/macros/tests/MacroTest.java
@@ -19,7 +19,11 @@ import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
-
+import org.eclipse.core.runtime.IExtensionRegistry;
+import org.eclipse.core.runtime.RegistryFactory;
+import org.eclipse.core.runtime.spi.RegistryStrategy;
+import org.eclipse.e4.core.contexts.EclipseContextFactory;
+import org.eclipse.e4.core.contexts.IEclipseContext;
import org.eclipse.e4.core.macros.CancelMacroRecordingException;
import org.eclipse.e4.core.macros.EMacroService;
import org.eclipse.e4.core.macros.IMacroInstruction;
@@ -100,7 +104,11 @@ public class MacroTest {
@Test
public void testRecordingState() throws Exception {
Map<String, IMacroInstructionFactory> macroInstructionIdToFactory = makeMacroInstructionIdToFactory();
- MacroServiceImplementation macroService = new MacroServiceImplementation(null, null);
+ IEclipseContext eclipseContext = EclipseContextFactory.create("testRecordingState");
+ IExtensionRegistry extensionRegistry = RegistryFactory.createRegistry(new RegistryStrategy(null, null), "foo",
+ "bar");
+ MacroServiceImplementation macroService = new MacroServiceImplementation(eclipseContext,
+ extensionRegistry);
Field field = macroService.getClass().getDeclaredField("fMacroInstructionIdToFactory");
field.setAccessible(true);
field.set(macroService, macroInstructionIdToFactory);

Back to the top