bundles/org.simantics.scl.ui/src/org/simantics/scl/ui/console/SCLConsoleView.java

   1 package org.simantics.scl.ui.console;
   2
   3 import java.nio.file.Files;
   4 import java.nio.file.Path;
   5 import java.nio.file.Paths;
   6 import java.util.ArrayList;
   7 import java.util.Arrays;
   8 import java.util.List;
   9
  10 import org.eclipse.core.runtime.Platform;
  11 import org.eclipse.core.runtime.preferences.InstanceScope;
  12 import org.eclipse.jface.action.Action;
  13 import org.eclipse.jface.action.IAction;
  14 import org.eclipse.jface.action.IMenuCreator;
  15 import org.eclipse.jface.action.IToolBarManager;
  16 import org.eclipse.jface.dialogs.Dialog;
  17 import org.eclipse.jface.preference.IPersistentPreferenceStore;
  18 import org.eclipse.swt.SWT;
  19 import org.eclipse.swt.dnd.DND;
  20 import org.eclipse.swt.dnd.DropTarget;
  21 import org.eclipse.swt.dnd.DropTargetAdapter;
  22 import org.eclipse.swt.dnd.DropTargetEvent;
  23 import org.eclipse.swt.dnd.FileTransfer;
  24 import org.eclipse.swt.dnd.Transfer;
  25 import org.eclipse.swt.events.SelectionAdapter;
  26 import org.eclipse.swt.events.SelectionEvent;
  27 import org.eclipse.swt.widgets.Composite;
  28 import org.eclipse.swt.widgets.Control;
  29 import org.eclipse.swt.widgets.Menu;
  30 import org.eclipse.swt.widgets.MenuItem;
  31 import org.eclipse.ui.part.ViewPart;
  32 import org.eclipse.ui.preferences.ScopedPreferenceStore;
  33 import org.simantics.scl.compiler.commands.CommandSession;
  34 import org.simantics.scl.compiler.commands.CommandSessionImportEntry;
  35 import org.simantics.scl.compiler.commands.SCLConsoleListener;
  36 import org.simantics.scl.compiler.module.repository.UpdateListener;
  37 import org.simantics.scl.compiler.testing.TestRunnable;
  38 import org.simantics.scl.osgi.internal.TestUtils;
  39 import org.simantics.scl.runtime.reporting.SCLReportingHandler;
  40 import org.simantics.scl.ui.Activator;
  41 import org.simantics.scl.ui.imports.internal.ManageImportsDialog;
  42 import org.simantics.scl.ui.tests.SCLTestsDialog;
  43
  44 public class SCLConsoleView extends ViewPart {
  45
  46     public static final String PLUGIN_ID = "org.simantics.scl.ui";
  47     public static final String IMPORTS = "imports";
  48     public static final String REFRESH_AUTOMATICALLY = "refresh-automatically";
  49     public static final String SEPARATOR = ";";
  50     public static final String DISABLED_TAG = "[DISABLED]";
  51
  52     IPersistentPreferenceStore store;
  53     SCLConsole console;
  54     boolean refreshAutomatically = false;
  55     MenuItem refreshAutomaticallyItem;
  56
  57     private ArrayList<CommandSessionImportEntry> readImportPreferences() {
  58         String importsString = store.getString(IMPORTS);
  59
  60         String[] splitted = importsString.split(SEPARATOR);
  61         ArrayList<CommandSessionImportEntry> result = new ArrayList<CommandSessionImportEntry>(splitted.length);
  62         for(String entryString : splitted) {
  63             if(entryString.isEmpty())
  64                 continue;
  65             boolean disabled = false;
  66             if(entryString.startsWith(DISABLED_TAG)) {
  67                 disabled = true;
  68                 entryString = entryString.substring(DISABLED_TAG.length());
  69             }
  70             String[] parts = entryString.split("=");
  71             CommandSessionImportEntry entry;
  72             if(parts.length == 1)
  73                 entry = new CommandSessionImportEntry(parts[0], "", true);
  74             else
  75                 entry = new CommandSessionImportEntry(parts[1], parts[0], true);
  76             entry.disabled = disabled;
  77             result.add(entry);
  78         }
  79         return result;
  80     }
  81
  82     private void writeImportPreferences(ArrayList<CommandSessionImportEntry> entries) {
  83         StringBuilder b = new StringBuilder();
  84
  85         boolean first = true;
  86         for(CommandSessionImportEntry entry : entries)
  87             if(entry.persistent) {
  88                 if(first)
  89                     first = false;
  90                 else
  91                     b.append(SEPARATOR);
  92                 if(entry.disabled)
  93                     b.append(DISABLED_TAG);
  94                 if(!entry.localName.isEmpty()) {
  95                     b.append(entry.localName);
  96                     b.append("=");
  97                 }
  98                 b.append(entry.moduleName);
  99             }
 100
 101         IPersistentPreferenceStore store = new ScopedPreferenceStore(InstanceScope.INSTANCE, PLUGIN_ID);
 102         store.setValue(IMPORTS, b.toString());
 103     }
 104
 105     private ArrayList<CommandSessionImportEntry> getCurrentImports() {
 106         return console.getSession().getImportEntries();
 107     }
 108
 109     private void setCurrentImports(ArrayList<CommandSessionImportEntry> entries) {
 110         console.getSession().setImportEntries(entries);
 111     }
 112
 113     private void manageImports() {
 114         ManageImportsDialog dialog = new ManageImportsDialog(
 115                 getSite().getShell(),
 116                 getCurrentImports());
 117         if(dialog.open() == Dialog.OK) {
 118             writeImportPreferences(dialog.getImports());
 119             setCurrentImports(dialog.getImports());
 120         }
 121     }
 122
 123     private void sclTestDialog() {
 124         List<TestRunnable> tests = TestUtils.getTests();
 125         SCLTestsDialog dialog = new SCLTestsDialog(
 126                 getSite().getShell(),
 127                 tests, true);
 128         if(dialog.open() == Dialog.OK) {
 129             for(Object result : dialog.getResult()) {
 130                 TestRunnable test = (TestRunnable) result;
 131                 try {
 132                     // Bit of a haxx solution to get around a deadlock caused by simply
 133                     // running the test with test.run()
 134                     console.execute("import \"Commands/Tests\"");
 135                     console.execute("runByName \"" + test.getName() + "\"");
 136 //                    test.run();
 137                 } catch (Exception e) {
 138                     e.printStackTrace();
 139                 }
 140             }
 141         }
 142     }
 143
 144     private UpdateListener dependencyListener = new UpdateListener() {
 145         @Override
 146         public void notifyAboutUpdate() {
 147             if(refreshAutomatically)
 148                 console.getSession().updateRuntimeEnvironment(true);
 149         }
 150     };
 151
 152     private void setRefreshAutomatically(boolean refreshAutomatically, boolean refreshAlso) {
 153         this.refreshAutomatically = refreshAutomatically;
 154         if(refreshAutomaticallyItem != null)
 155             refreshAutomaticallyItem.setSelection(refreshAutomatically);
 156
 157         store.setValue(REFRESH_AUTOMATICALLY, refreshAutomatically);
 158
 159         if(refreshAutomatically) {
 160             console.getSession().setDependenciesListener(dependencyListener);
 161             if(refreshAlso)
 162                 console.getSession().updateRuntimeEnvironment(true);
 163         }
 164         else {
 165             console.getSession().setDependenciesListener(null);
 166             dependencyListener.stopListening();
 167         }
 168     }
 169
 170     @Override
 171     public void createPartControl(Composite parent) {
 172         store = new ScopedPreferenceStore(InstanceScope.INSTANCE, PLUGIN_ID);
 173         store.setDefault(REFRESH_AUTOMATICALLY, true);
 174
 175         this.console = new SCLConsole(parent, SWT.NONE);
 176
 177         setRefreshAutomatically(store.getBoolean(REFRESH_AUTOMATICALLY), false);
 178         setCurrentImports(readImportPreferences());
 179
 180         addScriptDropSupport(console);
 181
 182         IToolBarManager toolBarManager = getViewSite().getActionBars().getToolBarManager();
 183
 184         // Interrupt action
 185         Action interruptAction = ConsoleActions.createInterruptAction(console);
 186         toolBarManager.add(interruptAction);
 187
 188         // Clear console action
 189         Action clearAction = ConsoleActions.createClearAction(console);
 190         toolBarManager.add(clearAction);
 191
 192         console.addListener(new SCLConsoleListener() {
 193             @Override
 194             public void startedExecution() {
 195                 interruptAction.setEnabled(true);
 196             }
 197             @Override
 198             public void finishedExecution() {
 199                 interruptAction.setEnabled(false);
 200             }
 201             @Override
 202             public void consoleIsNotEmptyAnymore() {
 203                 clearAction.setEnabled(true);
 204             }
 205         });
 206
 207         // Refresh action
 208         toolBarManager.add(new Action("Refresh modules", IAction.AS_DROP_DOWN_MENU) {
 209             {
 210                 setImageDescriptor(Activator.imageDescriptorFromPlugin("org.simantics.scl.ui", "icons/arrow_refresh.png"));
 211                 setMenuCreator(new IMenuCreator() {
 212                     Menu menu;
 213                     @Override
 214                     public Menu getMenu(Menu parent) {
 215                         throw new UnsupportedOperationException();
 216                     }
 217
 218                     @Override
 219                     public Menu getMenu(Control parent) {
 220                         if(menu == null) {
 221                             menu = new Menu(parent);
 222                             refreshAutomaticallyItem = new MenuItem(menu, SWT.CHECK);
 223                             refreshAutomaticallyItem.setText("Refresh automatically");
 224                             refreshAutomaticallyItem.setSelection(refreshAutomatically);
 225                             refreshAutomaticallyItem.addSelectionListener(new SelectionAdapter() {
 226                                 @Override
 227                                 public void widgetSelected(SelectionEvent e) {
 228                                     setRefreshAutomatically(!refreshAutomatically, true);
 229                                 }
 230                             });
 231                         }
 232                         return menu;
 233                     }
 234
 235                     @Override
 236                     public void dispose() {
 237                         if(menu != null)
 238                             menu.dispose();
 239                     }
 240                 });
 241             }
 242             @Override
 243             public void run() {
 244                 console.getSession().getModuleRepository().getSourceRepository().checkUpdates();
 245                 console.getSession().updateRuntimeEnvironment(true);
 246                 console.appendOutput("refresh completed\n", console.greenColor, null);
 247             }
 248         });
 249         toolBarManager.add(new Action("Manage imports",
 250                 Activator.imageDescriptorFromPlugin("org.simantics.scl.ui", "icons/configure_imports.png")) {
 251             @Override
 252             public void run() {
 253                 manageImports();
 254             }
 255         });
 256
 257         // Show action for running SCL tests if in development mode
 258         if (Platform.inDevelopmentMode()) {
 259             toolBarManager.add(new Action("Run tests",
 260                     Activator.imageDescriptorFromPlugin("org.simantics.scl.ui", "icons/run_tests.png")) {
 261                 @Override
 262                 public void run() {
 263                     sclTestDialog();
 264                 }
 265             });
 266         }
 267
 268         toolBarManager.update(true);
 269     }
 270
 271     private class ScriptRunningDropTarget extends DropTargetAdapter {
 272         @Override
 273         public void dragEnter(DropTargetEvent event) {
 274             if (event.detail == DND.DROP_DEFAULT) {
 275                 event.detail = DND.DROP_LINK;
 276             }
 277         }
 278
 279         @Override
 280         public void dragOperationChanged(DropTargetEvent event) {
 281             if (event.detail == DND.DROP_DEFAULT) {
 282                 event.detail = DND.DROP_LINK;
 283             }
 284         }
 285
 286         public void drop(DropTargetEvent event) {
 287             if (FileTransfer.getInstance().isSupportedType(event.currentDataType)) {
 288                 String[] files = ((String[]) event.data).clone();
 289                 // Sort files by name to allow deterministic multi-file drop
 290                 Arrays.sort(files);
 291                 for (String file : files) {
 292                     Path p = Paths.get(file).toAbsolutePath();
 293                     if (isScriptFile(p)) {
 294                         console.execute("runFromFile \"" + p.toString().replace('\\', '/') + "\"");
 295                     }
 296                 }
 297             }
 298         }
 299
 300         private boolean isScriptFile(Path p) {
 301             return Files.isRegularFile(p)
 302                     //&& p.toString().toLowerCase().endsWith(".scl")
 303                     ;
 304         }
 305     }
 306
 307     private void addScriptDropSupport(SCLConsole console) {
 308         DropTarget target = new DropTarget(console.getOutputWidget(), DND.DROP_COPY | DND.DROP_MOVE | DND.DROP_LINK | DND.DROP_DEFAULT);
 309         target.setTransfer(new Transfer[] { FileTransfer.getInstance() });
 310         target.addDropListener(new ScriptRunningDropTarget());
 311     }
 312
 313     @Override
 314     public void setFocus() {
 315         console.setFocus();
 316     }
 317
 318     @Override
 319     public void dispose() {
 320         super.dispose();
 321         console.dispose();
 322     }
 323
 324     @SuppressWarnings("unchecked")
 325     @Override
 326     public <T> T getAdapter(Class<T> adapter) {
 327         if (adapter == CommandSession.class)
 328             return (T) console.getSession();
 329         if (adapter == SCLReportingHandler.class)
 330             return (T) console.getHandler();
 331         return super.getAdapter(adapter);
 332     }
 333
 334 }