/**
* This is the hook through which all menu items are created. It registers the result with the
* menuitem hashtable so that it can be fetched with getMenuItem().
*
* @see #getMenuItem
*/
protected JMenuItem createMenuItem(String cmd) {
JMenuItem mi = new JMenuItem(getResourceString(cmd + labelSuffix));
URL url = getResource(cmd + imageSuffix);
if (url != null) {
mi.setHorizontalTextPosition(JButton.RIGHT);
mi.setIcon(new ImageIcon(url));
}
String astr = getResourceString(cmd + actionSuffix);
if (astr == null) {
astr = cmd;
}
mi.setActionCommand(astr);
Action myaction = getAction(astr); // if this is a known action
if (myaction != null) {
mi.addActionListener(myaction);
myaction.addPropertyChangeListener(createActionChangeListener(mi));
// System.out.println("myaction not null: astr:"+astr+" enabled:"+myaction.isEnabled());
mi.setEnabled(myaction.isEnabled());
} else {
System.err.println("Error:TextViewer: createMenuItem: myaction is null: astr:" + astr);
// causes the item to be greyed out
mi.setEnabled(false);
}
menuItems.put(cmd, mi);
return mi;
}
public LightDevice() throws InvalidDescriptionException {
super(new File(DESCRIPTION_FILE_NAME));
setSSDPBindAddress(HostInterface.getInetAddress(HostInterface.IPV4_BITMASK, null));
setHTTPBindAddress(HostInterface.getInetAddress(HostInterface.IPV4_BITMASK, null));
Action getPowerAction = getAction("GetPower");
getPowerAction.setActionListener(this);
Action setPowerAction = getAction("SetPower");
setPowerAction.setActionListener(this);
ServiceList serviceList = getServiceList();
Service service = serviceList.getService(0);
service.setQueryListener(this);
powerVar = getStateVariable("Power");
Argument powerArg = getPowerAction.getArgument("Power");
StateVariable powerState = powerArg.getRelatedStateVariable();
AllowedValueList allowList = powerState.getAllowedValueList();
for (int n = 0; n < allowList.size(); n++)
System.out.println("[" + n + "] = " + allowList.getAllowedValue(n));
AllowedValueRange allowRange = powerState.getAllowedValueRange();
System.out.println("maximum = " + allowRange.getMaximum());
System.out.println("minimum = " + allowRange.getMinimum());
System.out.println("step = " + allowRange.getStep());
}
private Action getAction(String name) {
for (Action action : sourceArea.getActions()) {
if (name.equals(action.getValue(Action.NAME).toString())) {
return action;
}
}
return null;
}
/** Synchronizes the state of the actions to the current state of this host. */
private void updateActions() {
final DeviceController currentDeviceController = getDeviceController();
final boolean deviceControllerSet = currentDeviceController != null;
final boolean deviceCapturing = deviceControllerSet && currentDeviceController.isCapturing();
final boolean deviceSetup =
deviceControllerSet && !deviceCapturing && currentDeviceController.isSetup();
getAction(CaptureAction.ID).setEnabled(deviceControllerSet);
getAction(CancelCaptureAction.ID).setEnabled(deviceCapturing);
getAction(RepeatCaptureAction.ID).setEnabled(deviceSetup);
final boolean projectChanged = this.projectManager.getCurrentProject().isChanged();
final boolean projectSavedBefore =
this.projectManager.getCurrentProject().getFilename() != null;
final boolean dataAvailable = this.dataContainer.hasCapturedData();
getAction(SaveProjectAction.ID).setEnabled(projectChanged);
getAction(SaveProjectAsAction.ID).setEnabled(projectSavedBefore && projectChanged);
getAction(SaveDataFileAction.ID).setEnabled(dataAvailable);
getAction(ZoomInAction.ID).setEnabled(dataAvailable);
getAction(ZoomOutAction.ID).setEnabled(dataAvailable);
getAction(ZoomDefaultAction.ID).setEnabled(dataAvailable);
getAction(ZoomFitAction.ID).setEnabled(dataAvailable);
final boolean triggerEnable = dataAvailable && this.dataContainer.hasTriggerData();
getAction(GotoTriggerAction.ID).setEnabled(triggerEnable);
// Update the cursor actions accordingly...
final boolean enableCursors = dataAvailable && this.dataContainer.isCursorsEnabled();
for (int c = 0; c < CapturedData.MAX_CURSORS; c++) {
final boolean enabled = enableCursors && this.dataContainer.isCursorPositionSet(c);
getAction(GotoNthCursorAction.getID(c)).setEnabled(enabled);
}
getAction(GotoFirstCursorAction.ID).setEnabled(enableCursors);
getAction(GotoLastCursorAction.ID).setEnabled(enableCursors);
getAction(SetCursorModeAction.ID).setEnabled(dataAvailable);
getAction(SetCursorModeAction.ID)
.putValue(Action.SELECTED_KEY, Boolean.valueOf(this.dataContainer.isCursorsEnabled()));
boolean anyCursorSet = false;
for (int c = 0; c < CapturedData.MAX_CURSORS; c++) {
final boolean cursorPositionSet = this.dataContainer.isCursorPositionSet(c);
anyCursorSet |= cursorPositionSet;
final Action action = getAction(SetCursorAction.getCursorId(c));
action.setEnabled(dataAvailable);
action.putValue(Action.SELECTED_KEY, Boolean.valueOf(cursorPositionSet));
}
getAction(ClearCursors.ID).setEnabled(enableCursors && anyCursorSet);
}
public void caretUpdate(CaretEvent e) {
// when the cursor moves on _textView
// this method will be called. Then, we
// must determine what the line number is
// and update the line number view
Element root = textView.getDocument().getDefaultRootElement();
int line = root.getElementIndex(e.getDot());
root = root.getElement(line);
int col = root.getElementIndex(e.getDot());
lineNumberView.setText(line + ":" + col);
// if text is selected then enable copy and cut
boolean isSelection = e.getDot() != e.getMark();
copyAction.setEnabled(isSelection);
cutAction.setEnabled(isSelection);
}
/** Re-order the action space based on the specified order of names. */
private Collection<Action> orderActions(Collection<Action> actionSpace, List<String> order) {
List<Action> tmp = new ArrayList<>(actionSpace);
List<Action> out = new ArrayList<>();
for (String key : order) {
Iterator<Action> iter = tmp.iterator();
while (iter.hasNext()) {
Action a = iter.next();
if (a.signature().equals(key)) {
out.add(a);
iter.remove();
}
}
}
out.addAll(tmp);
return out;
}
/**
* type check this rule
*
* @throws TypeException if the ruele contains type errors
*/
public void typeCheck() throws TypeException {
String helperName = ruleScript.getTargetHelper();
// ensure that we have a valid helper class
if (helperName != null) {
try {
helperClass = loader.loadClass(helperName);
} catch (ClassNotFoundException e) {
throw new TypeException(
"Rule.typecheck : unknown helper class " + helperName + " for rule " + getName());
}
} else {
helperClass = Helper.class;
}
if (triggerExceptions != null) {
// ensure that the type group includes the exception types
typeGroup.addExceptionTypes(triggerExceptions);
}
// try to resolve all types in the type group to classes
typeGroup.resolveTypes();
// use the descriptor to derive the method argument types and type any bindings for them
// that are located in the bindings list
installParameters((triggerAccess & Opcodes.ACC_STATIC) != 0, triggerClass);
event.typeCheck(Type.VOID);
condition.typeCheck(Type.Z);
action.typeCheck(Type.VOID);
}
@SuppressWarnings("OverridableMethodCallInConstructor")
Notepad() {
super(true);
// Trying to set Nimbus look and feel
try {
for (LookAndFeelInfo info : UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {
UIManager.setLookAndFeel(info.getClassName());
break;
}
}
} catch (Exception ignored) {
}
setBorder(BorderFactory.createEtchedBorder());
setLayout(new BorderLayout());
// create the embedded JTextComponent
editor = createEditor();
// Add this as a listener for undoable edits.
editor.getDocument().addUndoableEditListener(undoHandler);
// install the command table
commands = new HashMap<Object, Action>();
Action[] actions = getActions();
for (Action a : actions) {
commands.put(a.getValue(Action.NAME), a);
}
JScrollPane scroller = new JScrollPane();
JViewport port = scroller.getViewport();
port.add(editor);
String vpFlag = getProperty("ViewportBackingStore");
if (vpFlag != null) {
Boolean bs = Boolean.valueOf(vpFlag);
port.setScrollMode(bs ? JViewport.BACKINGSTORE_SCROLL_MODE : JViewport.BLIT_SCROLL_MODE);
}
JPanel panel = new JPanel();
panel.setLayout(new BorderLayout());
panel.add("North", createToolbar());
panel.add("Center", scroller);
add("Center", panel);
add("South", createStatusbar());
}
/**
* The disconnect method will stop the eventreplayer, and send null to the other peers, to stop
* their reading from their streams. The GUI-menu is updated appropriately.
*/
public void disconnect() {
setTitle("Disconnected");
active = false;
if (connected == true) {
er.stopStreamToQueue();
ert.interrupt();
setDocumentFilter(null);
connected = false;
setLocked(false);
}
deregisterOnPort();
Disconnect.setEnabled(false);
Connect.setEnabled(true);
Listen.setEnabled(true);
Save.setEnabled(true);
SaveAs.setEnabled(true);
}
/**
* Mouse Listener methods.
*
* <p>spv
*/
public void mouseTriggered(MouseEvent me) {
if (me.isPopupTrigger()) {
actionJumpToError.setEnabled(parseError != null && parseError.hasLineNumbers());
((GUIMultiModel) handler.getGUIPlugin()).doEnables();
contextPopup.show(me.getComponent(), me.getX(), me.getY());
}
}
/**
* Tests that the returned JButton of <code>createManualToolBarButton</code>: 1. Is disabled upon
* return. 2. Inherits the tooltip of the Action parameter <code>a</code>.
*/
public void testCreateManualToolBarButton() {
final Action a =
new AbstractAction("Test Action") {
public void actionPerformed(ActionEvent ae) {}
};
a.putValue(Action.LONG_DESCRIPTION, "test tooltip");
Utilities.invokeAndWait(
new Runnable() {
public void run() {
_but = _frame._createManualToolBarButton(a);
}
});
assertTrue("Returned JButton is enabled.", !_but.isEnabled());
assertEquals("Tooltip text not set.", "test tooltip", _but.getToolTipText());
_log.log("testCreateManualToobarButton completed");
}
private Rule(RuleScript ruleScript, ClassLoader loader, HelperManager helperManager)
throws ParseException, TypeException, CompileException {
ParseNode ruleTree;
this.ruleScript = ruleScript;
this.helperClass = null;
this.loader = loader;
typeGroup = new TypeGroup(loader);
bindings = new Bindings();
checked = false;
triggerClass = null;
triggerMethod = null;
triggerDescriptor = null;
triggerAccess = 0;
returnType = null;
accessibleFields = null;
accessibleMethods = null;
// this is only set when the rule is created via a real installed transformer
this.helperManager = helperManager;
ECAGrammarParser parser = null;
try {
String file = getFile();
ECATokenLexer lexer = new ECATokenLexer(new StringReader(ruleScript.getRuleText()));
lexer.setStartLine(getLine());
lexer.setFile(file);
parser = new ECAGrammarParser(lexer);
parser.setFile(file);
Symbol parse = (debugParse ? parser.debug_parse() : parser.parse());
if (parser.getErrorCount() != 0) {
String message = "rule " + ruleScript.getName();
message += parser.getErrors();
throw new ParseException(message);
}
ruleTree = (ParseNode) parse.value;
} catch (ParseException pe) {
throw pe;
} catch (Throwable th) {
String message = "rule " + ruleScript.getName();
if (parser != null && parser.getErrorCount() != 0) {
message += parser.getErrors();
}
message += "\n" + th.getMessage();
throw new ParseException(message);
}
ParseNode eventTree = (ParseNode) ruleTree.getChild(0);
ParseNode conditionTree = (ParseNode) ruleTree.getChild(1);
ParseNode actionTree = (ParseNode) ruleTree.getChild(2);
event = Event.create(this, eventTree);
condition = Condition.create(this, conditionTree);
action = Action.create(this, actionTree);
key = null;
}
public Action getNewFolderAction() {
if (newFolderAction == null) {
newFolderAction = new NewFolderAction();
// Note: Don't return null for readOnly, it might
// break older apps.
if (readOnly) {
newFolderAction.setEnabled(false);
}
}
return newFolderAction;
}
private void saveFile(String fileName) {
try {
FileWriter w = new FileWriter(fileName);
area1.write(w);
w.close();
currentFile = fileName;
changed = false;
Save.setEnabled(false);
} catch (IOException e) {
}
}
/** This is the hook through which all menu items are created. */
protected JMenuItem createMenuItem(String cmd) {
JMenuItem mi = new JMenuItem(getResourceString(cmd + labelSuffix));
URL url = getResource(cmd + imageSuffix);
if (url != null) {
mi.setHorizontalTextPosition(JButton.RIGHT);
mi.setIcon(new ImageIcon(url));
}
String astr = getProperty(cmd + actionSuffix);
if (astr == null) {
astr = cmd;
}
mi.setActionCommand(astr);
Action a = getAction(astr);
if (a != null) {
mi.addActionListener(a);
a.addPropertyChangeListener(createActionChangeListener(mi));
mi.setEnabled(a.isEnabled());
} else {
mi.setEnabled(false);
}
return mi;
}
private void saveFile(String fileName) {
try {
FileWriter w = new FileWriter(fileName);
area.write(w);
w.close();
currentFile = fileName;
setTitle(currentFile + " - CoreyTextEditor");
changed = false;
Save.setEnabled(false);
} catch (IOException e) {
// No handling done here
}
}
public void redoAction() {
try {
if (undoMgr.canRedo()) {
redoAction.actionPerformed(new ActionEvent(this, ActionEvent.ACTION_PERFORMED, "Redo"));
setRedoItem();
} else {
java.awt.Toolkit.getDefaultToolkit().beep();
}
} catch (CannotUndoException ex) {
ex.printStackTrace();
}
}
// Add icons and friendly names to actions we care about.
protected void makeActionsPretty() {
Action a;
a = textComp.getActionMap().get(DefaultEditorKit.cutAction);
a.putValue(Action.SMALL_ICON, new ImageIcon("icons/cut.gif"));
a.putValue(Action.NAME, "Cut");
a = textComp.getActionMap().get(DefaultEditorKit.copyAction);
a.putValue(Action.SMALL_ICON, new ImageIcon("icons/copy.gif"));
a.putValue(Action.NAME, "Copy");
a = textComp.getActionMap().get(DefaultEditorKit.pasteAction);
a.putValue(Action.SMALL_ICON, new ImageIcon("icons/paste.gif"));
a.putValue(Action.NAME, "Paste");
a = textComp.getActionMap().get(DefaultEditorKit.selectAllAction);
a.putValue(Action.NAME, "Select All");
}
/**
* generate a string representation of the rule
*
* @return a string representation of the rule
*/
public String toString() {
StringWriter stringWriter = new StringWriter();
stringWriter.write("RULE ");
stringWriter.write(getName());
stringWriter.write("\n");
if (isInterface()) {
stringWriter.write("INTERFACE ");
} else {
stringWriter.write("CLASS ");
}
if (isOverride()) {
stringWriter.write("^");
}
stringWriter.write(getTargetClass());
stringWriter.write('\n');
stringWriter.write("METHOD ");
stringWriter.write(getTargetMethod());
stringWriter.write('\n');
stringWriter.write(getTargetLocation().toString());
stringWriter.write('\n');
if (event != null) {
event.writeTo(stringWriter);
} else {
stringWriter.write("BIND NOTHING\n");
}
if (condition != null) {
condition.writeTo(stringWriter);
} else {
stringWriter.write("COND TRUE\n");
}
if (action != null) {
action.writeTo(stringWriter);
} else {
stringWriter.write("DO NOTHING\n");
}
return stringWriter.toString();
}
/**
* Registers the keystroke of the given action as "command" of the given component.
*
* <p>This code is based on the Sulky-tools, found at <http://github.com/huxi/sulky>.
*
* @param aComponent the component that should react on the keystroke, cannot be <code>null</code>
* ;
* @param aAction the action of the keystroke, cannot be <code>null</code>;
* @param aCommandName the name of the command to register the keystore under.
*/
public static void registerKeystroke(
final JComponent aComponent, final Action aAction, final String aCommandName) {
final KeyStroke keyStroke = (KeyStroke) aAction.getValue(Action.ACCELERATOR_KEY);
if (keyStroke == null) {
return;
}
InputMap inputMap = aComponent.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
ActionMap actionMap = aComponent.getActionMap();
inputMap.put(keyStroke, aCommandName);
actionMap.put(aCommandName, aAction);
inputMap = aComponent.getInputMap(JComponent.WHEN_FOCUSED);
Object value = inputMap.get(keyStroke);
if (value != null) {
inputMap.put(keyStroke, aCommandName);
}
inputMap = aComponent.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
value = inputMap.get(keyStroke);
if (value != null) {
inputMap.put(keyStroke, aCommandName);
}
}
/** Helper method to initialize the actions used for the buttons. */
private void initActions() {
/*actionUndo = new AbstractAction() {
public void actionPerformed(ActionEvent ae) {
try {
// do redo
undoManager.undo();
// notify undo manager/toolbar of change
GUIPrism.getGUI().notifyEventListeners(
new GUIClipboardEvent(GUIClipboardEvent.UNDOMANAGER_CHANGE,
GUIPrism.getGUI().getFocussedPlugin().getFocussedComponent()));
} catch (CannotUndoException ex) {
//GUIPrism.getGUI().getMultiLogger().logMessage(PrismLogLevel.PRISM_ERROR, ex.getMessage());
}
}
};
actionUndo.putValue(Action.LONG_DESCRIPTION, "Undo the most recent action.");
actionUndo.putValue(Action.NAME, "Undo");
actionUndo.putValue(Action.SMALL_ICON, GUIPrism.getIconFromImage("smallUndo.png"));
actionRedo = new AbstractAction() {
public void actionPerformed(ActionEvent ae) {
try {
// do redo
undoManager.redo();
// notify undo manager/toolbar of change
GUIPrism.getGUI().notifyEventListeners(
new GUIClipboardEvent(GUIClipboardEvent.UNDOMANAGER_CHANGE,
GUIPrism.getGUI().getFocussedPlugin().getFocussedComponent()));
} catch (CannotRedoException ex) {
//GUIPrism.getGUI().getMultiLogger().logMessage(PrismLogLevel.PRISM_ERROR, ex.getMessage());
}
}
};
actionRedo.putValue(Action.LONG_DESCRIPTION, "Redos the most recent undo");
actionRedo.putValue(Action.NAME, "Redo");
actionRedo.putValue(Action.SMALL_ICON, GUIPrism.getIconFromImage("smallRedo.png"));
*/
actionJumpToError =
new AbstractAction() {
public void actionPerformed(ActionEvent ae) {
jumpToError();
}
};
actionJumpToError.putValue(Action.NAME, "Jump to error");
actionJumpToError.putValue(Action.SMALL_ICON, GUIPrism.getIconFromImage("tinyError.png"));
actionJumpToError.putValue(
Action.ACCELERATOR_KEY,
KeyStroke.getKeyStroke(
KeyEvent.VK_E, Toolkit.getDefaultToolkit().getMenuShortcutKeyMask()));
// search and replace action
actionSearch =
new AbstractAction() {
public void actionPerformed(ActionEvent ae) {
/*
// System.out.println("search button pressed");
if (GUIMultiModelHandler.isDoingSearch()) {
} else {
try {
GUIMultiModelHandler.setDoingSearch(true);
FindReplaceForm.launch(GUIPrism.getGUI().getMultiModel());
} catch (PluginNotFoundException pnfe) {
GUIPrism.getGUI().getMultiLogger().logMessage(prism.log.PrismLogLevel.PRISM_ERROR,
pnfe.getMessage());
}
}
*/
}
};
actionSearch.putValue(Action.LONG_DESCRIPTION, "Opens a find and replace dialog.");
// actionSearch.putValue(Action.SMALL_ICON, GUIPrism.getIconFromImage("find.png"));
actionSearch.putValue(Action.NAME, "Find/Replace");
// actionSearch.putValue(Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_R,
// Toolkit.getDefaultToolkit().getMenuShortcutKeyMask()));
insertDTMC =
new AbstractAction() {
public void actionPerformed(ActionEvent ae) {
int caretPosition = editor.getCaretPosition();
try {
editor.getDocument().insertString(caretPosition, "dtmc", new SimpleAttributeSet());
} catch (BadLocationException ble) {
// todo log?
}
}
};
insertDTMC.putValue(
Action.LONG_DESCRIPTION, "Marks this model as a \"Discrete-Time Markov Chain\"");
// actionSearch.putValue(Action.SMALL_ICON, GUIPrism.getIconFromImage("find.png"));
insertDTMC.putValue(Action.NAME, "Probabilistic (DTMC)");
insertCTMC =
new AbstractAction() {
public void actionPerformed(ActionEvent ae) {
int caretPosition = editor.getCaretPosition();
try {
editor.getDocument().insertString(caretPosition, "ctmc", new SimpleAttributeSet());
} catch (BadLocationException ble) {
// todo log?
}
}
};
insertCTMC.putValue(
Action.LONG_DESCRIPTION, "Marks this model as a \"Continous-Time Markov Chain\"");
// actionSearch.putValue(Action.SMALL_ICON, GUIPrism.getIconFromImage("find.png"));
insertCTMC.putValue(Action.NAME, "Stochastic (CTMC)");
insertMDP =
new AbstractAction() {
public void actionPerformed(ActionEvent ae) {
int caretPosition = editor.getCaretPosition();
try {
editor.getDocument().insertString(caretPosition, "mdp", new SimpleAttributeSet());
} catch (BadLocationException ble) {
// todo log?
}
}
};
insertMDP.putValue(
Action.LONG_DESCRIPTION, "Marks this model as a \"Markov Decision Process\"");
// actionSearch.putValue(Action.SMALL_ICON, GUIPrism.getIconFromImage("find.png"));
insertMDP.putValue(Action.NAME, "Non-deterministic (MDP)");
}
@Override
public Counter<String> apply(Triple<State, Action, State> triple) {
// Variables
State from = triple.first;
Action action = triple.second;
State to = triple.third;
String signature = action.signature();
String edgeRelTaken = to.edge == null ? "root" : to.edge.getRelation().toString();
String edgeRelShort = to.edge == null ? "root" : to.edge.getRelation().getShortName();
if (edgeRelShort.contains("_")) {
edgeRelShort = edgeRelShort.substring(0, edgeRelShort.indexOf("_"));
}
// -- Featurize --
// Variables to aggregate
boolean parentHasSubj = false;
boolean parentHasObj = false;
boolean childHasSubj = false;
boolean childHasObj = false;
Counter<String> feats = new ClassicCounter<>();
// 1. edge taken
feats.incrementCount(signature + "&edge:" + edgeRelTaken);
feats.incrementCount(signature + "&edge_type:" + edgeRelShort);
// 2. last edge taken
if (from.edge == null) {
assert to.edge == null || to.originalTree().getRoots().contains(to.edge.getGovernor());
feats.incrementCount(signature + "&at_root");
feats.incrementCount(
signature + "&at_root&root_pos:" + to.originalTree().getFirstRoot().tag());
} else {
feats.incrementCount(signature + "¬_root");
String lastRelShort = from.edge.getRelation().getShortName();
if (lastRelShort.contains("_")) {
lastRelShort = lastRelShort.substring(0, lastRelShort.indexOf("_"));
}
feats.incrementCount(signature + "&last_edge:" + lastRelShort);
}
if (to.edge != null) {
// 3. other edges at parent
for (SemanticGraphEdge parentNeighbor :
from.originalTree().outgoingEdgeIterable(to.edge.getGovernor())) {
if (parentNeighbor != to.edge) {
String parentNeighborRel = parentNeighbor.getRelation().toString();
if (parentNeighborRel.contains("subj")) {
parentHasSubj = true;
}
if (parentNeighborRel.contains("obj")) {
parentHasObj = true;
}
// (add feature)
feats.incrementCount(signature + "&parent_neighbor:" + parentNeighborRel);
feats.incrementCount(
signature
+ "&edge_type:"
+ edgeRelShort
+ "&parent_neighbor:"
+ parentNeighborRel);
}
}
// 4. Other edges at child
int childNeighborCount = 0;
for (SemanticGraphEdge childNeighbor :
from.originalTree().outgoingEdgeIterable(to.edge.getDependent())) {
String childNeighborRel = childNeighbor.getRelation().toString();
if (childNeighborRel.contains("subj")) {
childHasSubj = true;
}
if (childNeighborRel.contains("obj")) {
childHasObj = true;
}
childNeighborCount += 1;
// (add feature)
feats.incrementCount(signature + "&child_neighbor:" + childNeighborRel);
feats.incrementCount(
signature + "&edge_type:" + edgeRelShort + "&child_neighbor:" + childNeighborRel);
}
// 4.1 Number of other edges at child
feats.incrementCount(
signature
+ "&child_neighbor_count:"
+ (childNeighborCount < 3 ? childNeighborCount : ">2"));
feats.incrementCount(
signature
+ "&edge_type:"
+ edgeRelShort
+ "&child_neighbor_count:"
+ (childNeighborCount < 3 ? childNeighborCount : ">2"));
// 5. Subject/Object stats
feats.incrementCount(signature + "&parent_neighbor_subj:" + parentHasSubj);
feats.incrementCount(signature + "&parent_neighbor_obj:" + parentHasObj);
feats.incrementCount(signature + "&child_neighbor_subj:" + childHasSubj);
feats.incrementCount(signature + "&child_neighbor_obj:" + childHasObj);
// 6. POS tag info
feats.incrementCount(signature + "&parent_pos:" + to.edge.getGovernor().tag());
feats.incrementCount(signature + "&child_pos:" + to.edge.getDependent().tag());
feats.incrementCount(
signature
+ "&pos_signature:"
+ to.edge.getGovernor().tag()
+ "_"
+ to.edge.getDependent().tag());
feats.incrementCount(
signature
+ "&edge_type:"
+ edgeRelShort
+ "&pos_signature:"
+ to.edge.getGovernor().tag()
+ "_"
+ to.edge.getDependent().tag());
}
return feats;
}
public void setAction(String actionSpec) throws ParseException, TypeException {
if (event != null & condition != null && action == null) {
action = Action.create(this, actionSpec);
}
}
public void selectLine() {
Action selectLine = getAction(DefaultEditorKit.selectLineAction);
if (selectLine != null) {
selectLine.actionPerformed(null);
}
}
/**
* The core implementation of the search.
*
* @param root The root word to search from. Traditionally, this is the root of the sentence.
* @param candidateFragments The callback for the resulting sentence fragments. This is a
* predicate of a triple of values. The return value of the predicate determines whether we
* should continue searching. The triple is a triple of
* <ol>
* <li>The log probability of the sentence fragment, according to the featurizer and the
* weights
* <li>The features along the path to this fragment. The last element of this is the
* features from the most recent step.
* <li>The sentence fragment. Because it is relatively expensive to compute the resulting
* tree, this is returned as a lazy {@link Supplier}.
* </ol>
*
* @param classifier The classifier for whether an arc should be on the path to a clause split, a
* clause split itself, or neither.
* @param featurizer The featurizer to use. Make sure this matches the weights!
* @param actionSpace The action space we are allowed to take. Each action defines a means of
* splitting a clause on a dependency boundary.
*/
protected void search(
// The root to search from
IndexedWord root,
// The output specs
final Predicate<Triple<Double, List<Counter<String>>, Supplier<SentenceFragment>>>
candidateFragments,
// The learning specs
final Classifier<ClauseSplitter.ClauseClassifierLabel, String> classifier,
Map<String, ? extends List<String>> hardCodedSplits,
final Function<Triple<State, Action, State>, Counter<String>> featurizer,
final Collection<Action> actionSpace,
final int maxTicks) {
// (the fringe)
PriorityQueue<Pair<State, List<Counter<String>>>> fringe = new FixedPrioritiesPriorityQueue<>();
// (avoid duplicate work)
Set<IndexedWord> seenWords = new HashSet<>();
State firstState =
new State(null, null, -9000, null, x -> {}, true); // First state is implicitly "done"
fringe.add(Pair.makePair(firstState, new ArrayList<>(0)), -0.0);
int ticks = 0;
while (!fringe.isEmpty()) {
if (++ticks > maxTicks) {
// System.err.println("WARNING! Timed out on search with " + ticks + " ticks");
return;
}
// Useful variables
double logProbSoFar = fringe.getPriority();
assert logProbSoFar <= 0.0;
Pair<State, List<Counter<String>>> lastStatePair = fringe.removeFirst();
State lastState = lastStatePair.first;
List<Counter<String>> featuresSoFar = lastStatePair.second;
IndexedWord rootWord = lastState.edge == null ? root : lastState.edge.getDependent();
// Register thunk
if (lastState.isDone) {
if (!candidateFragments.test(
Triple.makeTriple(
logProbSoFar,
featuresSoFar,
() -> {
SemanticGraph copy = new SemanticGraph(tree);
lastState
.thunk
.andThen(
x -> {
// Add the extra edges back in, if they don't break the tree-ness of the
// extraction
for (IndexedWord newTreeRoot : x.getRoots()) {
if (newTreeRoot != null) { // what a strange thing to have happen...
for (SemanticGraphEdge extraEdge :
extraEdgesByGovernor.get(newTreeRoot)) {
assert Util.isTree(x);
//noinspection unchecked
addSubtree(
x,
newTreeRoot,
extraEdge.getRelation().toString(),
tree,
extraEdge.getDependent(),
tree.getIncomingEdgesSorted(newTreeRoot));
assert Util.isTree(x);
}
}
}
})
.accept(copy);
return new SentenceFragment(copy, assumedTruth, false);
}))) {
break;
}
}
// Find relevant auxilliary terms
SemanticGraphEdge subjOrNull = null;
SemanticGraphEdge objOrNull = null;
for (SemanticGraphEdge auxEdge : tree.outgoingEdgeIterable(rootWord)) {
String relString = auxEdge.getRelation().toString();
if (relString.contains("obj")) {
objOrNull = auxEdge;
} else if (relString.contains("subj")) {
subjOrNull = auxEdge;
}
}
// Iterate over children
// For each outgoing edge...
for (SemanticGraphEdge outgoingEdge : tree.outgoingEdgeIterable(rootWord)) {
// Prohibit indirect speech verbs from splitting off clauses
// (e.g., 'said', 'think')
// This fires if the governor is an indirect speech verb, and the outgoing edge is a ccomp
if (outgoingEdge.getRelation().toString().equals("ccomp")
&& ((outgoingEdge.getGovernor().lemma() != null
&& INDIRECT_SPEECH_LEMMAS.contains(outgoingEdge.getGovernor().lemma()))
|| INDIRECT_SPEECH_LEMMAS.contains(outgoingEdge.getGovernor().word()))) {
continue;
}
// Get some variables
String outgoingEdgeRelation = outgoingEdge.getRelation().toString();
List<String> forcedArcOrder = hardCodedSplits.get(outgoingEdgeRelation);
if (forcedArcOrder == null && outgoingEdgeRelation.contains(":")) {
forcedArcOrder =
hardCodedSplits.get(
outgoingEdgeRelation.substring(0, outgoingEdgeRelation.indexOf(":")) + ":*");
}
boolean doneForcedArc = false;
// For each action...
for (Action action :
(forcedArcOrder == null ? actionSpace : orderActions(actionSpace, forcedArcOrder))) {
// Check the prerequisite
if (!action.prerequisitesMet(tree, outgoingEdge)) {
continue;
}
if (forcedArcOrder != null && doneForcedArc) {
break;
}
// 1. Compute the child state
Optional<State> candidate =
action.applyTo(tree, lastState, outgoingEdge, subjOrNull, objOrNull);
if (candidate.isPresent()) {
double logProbability;
ClauseClassifierLabel bestLabel;
Counter<String> features =
featurizer.apply(Triple.makeTriple(lastState, action, candidate.get()));
if (forcedArcOrder != null && !doneForcedArc) {
logProbability = 0.0;
bestLabel = ClauseClassifierLabel.CLAUSE_SPLIT;
doneForcedArc = true;
} else if (features.containsKey("__undocumented_junit_no_classifier")) {
logProbability = Double.NEGATIVE_INFINITY;
bestLabel = ClauseClassifierLabel.CLAUSE_INTERM;
} else {
Counter<ClauseClassifierLabel> scores = classifier.scoresOf(new RVFDatum<>(features));
if (scores.size() > 0) {
Counters.logNormalizeInPlace(scores);
}
String rel = outgoingEdge.getRelation().toString();
if ("nsubj".equals(rel) || "dobj".equals(rel)) {
scores.remove(
ClauseClassifierLabel.NOT_A_CLAUSE); // Always at least yield on nsubj and dobj
}
logProbability = Counters.max(scores, Double.NEGATIVE_INFINITY);
bestLabel = Counters.argmax(scores, (x, y) -> 0, ClauseClassifierLabel.CLAUSE_SPLIT);
}
if (bestLabel != ClauseClassifierLabel.NOT_A_CLAUSE) {
Pair<State, List<Counter<String>>> childState =
Pair.makePair(
candidate.get().withIsDone(bestLabel),
new ArrayList<Counter<String>>(featuresSoFar) {
{
add(features);
}
});
// 2. Register the child state
if (!seenWords.contains(childState.first.edge.getDependent())) {
// System.err.println(" pushing " + action.signature() + " with " +
// argmax.first.edge);
fringe.add(childState, logProbability);
}
}
}
}
}
seenWords.add(rootWord);
}
// System.err.println("Search finished in " + ticks + " ticks and " + classifierEvals + "
// classifier evaluations.");
}
// ------------------------------------------------------------------------
TextViewer(JFrame inParentFrame) {
// super(true); //is double buffered - only for panels
textViewerFrame = this;
parentFrame = inParentFrame;
lastViewedDirStr = "";
lastViewedFileStr = "";
setTitle(resources.getString("Title"));
addWindowListener(new AppCloser());
pack();
setSize(500, 600);
warningPopup = new WarningDialog(this);
okCancelPopup = new WarningDialogOkCancel(this);
messagePopup = new MessageDialog(this);
okCancelMessagePopup = new MessageDialogOkCancel(this);
// Force SwingSet to come up in the Cross Platform L&F
try {
UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());
// If you want the System L&F instead, comment out the above line and
// uncomment the following:
// UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
} catch (Exception exc) {
String errstr = "TextViewer:Error loading L&F: " + exc;
warningPopup.display(errstr);
}
Container cf = getContentPane();
cf.setBackground(Color.lightGray);
// Border etched=BorderFactory.createEtchedBorder();
// Border title=BorderFactory.createTitledBorder(etched,"TextViewer");
// cf.setBorder(title);
cf.setLayout(new BorderLayout());
// create the embedded JTextComponent
editor1 = createEditor();
editor1.setFont(new Font("monospaced", Font.PLAIN, 12));
// aa -added next line
setPlainDocument((PlainDocument) editor1.getDocument()); // sets doc1
// install the command table
commands = new Hashtable();
Action[] actions = getActions();
for (int i = 0; i < actions.length; i++) {
Action a = actions[i];
commands.put(a.getValue(Action.NAME), a);
// System.out.println("Debug:TextViewer: actionName:"+a.getValue(Action.NAME));
}
// editor1.setPreferredSize(new Dimension(,));
// get setting from user preferences
if (UserPref.keymapType.equals("Word")) {
editor1 = updateKeymapForWord(editor1);
} else {
editor1 = updateKeymapForEmacs(editor1);
}
scroller1 = new JScrollPane();
viewport1 = scroller1.getViewport();
viewport1.add(editor1);
scroller1.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
scroller1.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
try {
String vpFlag = resources.getString("ViewportBackingStore");
Boolean bs = new Boolean(vpFlag);
viewport1.setBackingStoreEnabled(bs.booleanValue());
} catch (MissingResourceException mre) {
System.err.println("TextViewer:missing resource:" + mre.getMessage());
// just use the viewport1 default
}
menuItems = new Hashtable();
menubar = createMenubar();
lowerPanel = new JPanel(true); // moved double buffering to here
lowerPanel.setLayout(new BorderLayout());
lowerPanel.add("North", createToolbar());
lowerPanel.add("Center", scroller1);
cf.add("North", menubar);
cf.add("Center", lowerPanel);
cf.add("South", createStatusbar());
// for the find/search utilities
mySearchDialog = new SearchDialog(this);
// System.out.println("Debug:TextViewer: end of TextViewer constructor");
}
public InterpreterFrame() {
super("Simple Lisp Interpreter");
// Create the menu
menubar = buildMenuBar();
setJMenuBar(menubar);
// Create the toolbar
toolbar = buildToolBar();
// disable cut and copy actions
cutAction.setEnabled(false);
copyAction.setEnabled(false);
// Setup text area for editing source code
// and setup document listener so interpreter
// is notified when current file modified and
// when the cursor is moved.
textView = buildEditor();
textView.getDocument().addDocumentListener(this);
textView.addCaretListener(this);
// set default key bindings
bindKeyToCommand("ctrl C", "(buffer-copy)");
bindKeyToCommand("ctrl X", "(buffer-cut)");
bindKeyToCommand("ctrl V", "(buffer-paste)");
bindKeyToCommand("ctrl E", "(buffer-eval)");
bindKeyToCommand("ctrl O", "(file-open)");
bindKeyToCommand("ctrl S", "(file-save)");
bindKeyToCommand("ctrl Q", "(exit)");
// Give text view scrolling capability
Border border =
BorderFactory.createCompoundBorder(
BorderFactory.createEmptyBorder(3, 3, 3, 3),
BorderFactory.createLineBorder(Color.gray));
JScrollPane topSplit = addScrollers(textView);
topSplit.setBorder(border);
// Create tabbed pane for console/problems
consoleView = makeConsoleArea(10, 50, true);
problemsView = makeConsoleArea(10, 50, false);
tabbedPane = buildProblemsConsole();
// Plug the editor and problems/console together
// using a split pane. This allows one to change
// their relative size using the split-bar in
// between them.
splitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT, topSplit, tabbedPane);
// Create status bar
statusView = new JLabel(" Status");
lineNumberView = new JLabel("0:0");
statusbar = buildStatusBar();
// Now, create the outer panel which holds
// everything together
outerpanel = new JPanel();
outerpanel.setLayout(new BorderLayout());
outerpanel.add(toolbar, BorderLayout.PAGE_START);
outerpanel.add(splitPane, BorderLayout.CENTER);
outerpanel.add(statusbar, BorderLayout.SOUTH);
getContentPane().add(outerpanel);
// tell frame to fire a WindowsListener event
// but not to close when "x" button clicked.
setDefaultCloseOperation(DO_NOTHING_ON_CLOSE);
addWindowListener(this);
// set minimised icon to use
setIconImage(makeImageIcon("spi.png").getImage());
// setup additional internal functions
InternalFunctions.setup_internals(interpreter, this);
// set default window size
Component top = splitPane.getTopComponent();
Component bottom = splitPane.getBottomComponent();
top.setPreferredSize(new Dimension(100, 400));
bottom.setPreferredSize(new Dimension(100, 200));
pack();
// load + run user configuration file (if there is one)
String homedir = System.getProperty("user.home");
try {
interpreter.load(homedir + "/.simplelisp");
} catch (FileNotFoundException e) {
// do nothing if file does not exist!
System.out.println("Didn't find \"" + homedir + "/.simplelisp\"");
}
textView.grabFocus();
setVisible(true);
// redirect all I/O to problems/console
redirectIO();
// start highlighter thread
highlighter = new DisplayThread(250);
highlighter.setDaemon(true);
highlighter.start();
}
public void actionPerformed(ActionEvent e) {
saveOld();
final InetAddress local;
active = true;
try {
local = InetAddress.getLocalHost();
Runnable server =
new Runnable() {
public void run() {
serverport = Integer.parseInt(portNumber.getText());
int myID = getNewId();
registerOnPort();
editor.setTitleToListen();
clientSocket = waitForConnectionFromClient();
lc = new LamportClock(myID);
area1.setText("");
resetArea2();
if (clientSocket != null) {
listen = true;
connected = true;
dec = new DocumentEventCapturer(lc, editor);
setDocumentFilter(dec);
er = new EventReplayer(editor, dec, lc);
er.updateCaretPos(myID, 0);
ert = new Thread(er);
ert.start();
try {
ObjectOutputStream output =
new ObjectOutputStream(clientSocket.getOutputStream());
ObjectInputStream input =
new ObjectInputStream(clientSocket.getInputStream());
JoinNetworkRequest request = (JoinNetworkRequest) input.readObject();
int id = getNewId();
Peer peer =
new Peer(
editor,
er,
id,
clientSocket,
output,
input,
lc,
clientSocket.getInetAddress().getHostAddress(),
request.getPort());
ConnectionData cd =
new ConnectionData(
er.getEventHistory(),
er.getAcknowledgements(),
er.getCarets(),
id,
area1.getText(),
lc.getTimeStamp(),
lc.getID(),
dec.getPeers(),
serverSocket.getLocalPort());
dec.addPeer(peer);
er.addCaretPos(id, 0);
Thread t = new Thread(peer);
t.start();
peer.writeObjectToStream(cd);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
waitForConnection();
}
};
Thread serverThread = new Thread(server);
serverThread.start();
} catch (UnknownHostException e1) {
e1.printStackTrace();
}
changed = false;
Disconnect.setEnabled(true);
Listen.setEnabled(false);
Connect.setEnabled(false);
Save.setEnabled(false);
SaveAs.setEnabled(false);
}
public void actionPerformed(ActionEvent e) {
saveOld();
area1.setText("");
resetArea2();
try {
clientSocket = new Socket(ipaddress.getText(), Integer.parseInt(portNumber.getText()));
Random r = new Random();
serverport = 10000 + r.nextInt(8999); // random port :D
serverSocket = new ServerSocket(serverport);
active = true;
editor.setTitleToListen();
connected = true;
ObjectOutputStream output = new ObjectOutputStream(clientSocket.getOutputStream());
ObjectInputStream input = new ObjectInputStream(clientSocket.getInputStream());
output.writeObject(new JoinNetworkRequest(serverport));
ConnectionData data = getConnectionData(clientSocket, input);
lc = new LamportClock(data.getId());
lc.setMaxTime(data.getTs());
dec = new DocumentEventCapturer(lc, editor);
er = new EventReplayer(editor, dec, lc);
ert = new Thread(er);
ert.start();
Peer peer =
new Peer(
editor,
er,
data.getHostId(),
clientSocket,
output,
input,
lc,
clientSocket.getInetAddress().getHostAddress(),
data.getPort());
dec.addPeer(peer);
Thread thread = new Thread(peer);
thread.start();
er.setAcknowledgements(data.getAcknowledgements());
er.setEventHistory(data.getEventHistory());
er.setCarets(data.getCarets());
er.addCaretPos(lc.getID(), 0);
for (PeerWrapper p : data.getPeers()) {
Socket socket;
try {
socket = connectToPeer(p.getIP(), p.getPort());
ObjectOutputStream outputStream = new ObjectOutputStream(socket.getOutputStream());
ObjectInputStream inputStream = new ObjectInputStream(socket.getInputStream());
outputStream.writeObject(
new NewPeerDataRequest(lc.getID(), serverSocket.getLocalPort(), 0));
Peer newPeer =
new Peer(
editor,
er,
p.getId(),
socket,
outputStream,
inputStream,
lc,
p.getIP(),
p.getPort());
dec.addPeer(newPeer);
Thread t = new Thread(newPeer);
t.start();
} catch (IOException ex) {
continue;
}
}
Thread t1 =
new Thread(
new Runnable() {
@Override
public void run() {
waitForConnection();
}
});
t1.start();
area1.setText(data.getTextField());
area1.setCaretPosition(0);
setDocumentFilter(dec);
dec.sendObjectToAllPeers(new UnlockRequest(lc.getTimeStamp()));
changed = false;
Connect.setEnabled(false);
Disconnect.setEnabled(true);
Listen.setEnabled(false);
Save.setEnabled(false);
SaveAs.setEnabled(false);
} catch (NumberFormatException | IOException e1) {
setTitle("Unable to connect");
}
}
public boolean actionControlReceived(Action action) {
String actionName = action.getName();
boolean ret = false;
if (actionName.equals("GetPower") == true) {
String state = getPowerState();
Argument powerArg = action.getArgument("Power");
powerArg.setValue(state);
ret = true;
}
if (actionName.equals("SetPower") == true) {
Argument powerArg = action.getArgument("Power");
String state = powerArg.getValue();
setPowerState(state);
state = getPowerState();
Argument resultArg = action.getArgument("Result");
resultArg.setValue(state);
ret = true;
}
comp.repaint();
return ret;
}