コード例 #1
0
  @Override
  public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
    if (oldInput != null) {
      IDocument document = documentProvider.getDocument(oldInput);

      if (document != null) {
        try {
          document.removePositionCategory(CLASS_POSITIONS);
        } catch (BadPositionCategoryException x) {
        }

        document.removePositionUpdater(positionUpdater);
      }
    }

    editorInput = (IEditorInput) newInput;

    if (newInput != null) {
      IDocument document = documentProvider.getDocument(newInput);

      if (document != null) {
        document.addPositionCategory(CLASS_POSITIONS);
        document.addPositionUpdater(positionUpdater);
        editorPageChanged(viewer);
      }
    }

    viewer.refresh();
  }
コード例 #2
0
  @Override
  public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {

    if (oldInput != null) {
      IDocument document = fDocumentProvider.getDocument(oldInput);
      if (document != null) {
        try {
          document.removePositionCategory(JSON_ELEMENTS);
        } catch (BadPositionCategoryException x) {
        }
        document.removePositionUpdater(fPositionUpdater);
      }
    }

    rootObject = null;

    if (newInput != null) {
      IDocument document = fDocumentProvider.getDocument(newInput);
      if (document != null) {
        document.addPositionCategory(JSON_ELEMENTS);
        document.addPositionUpdater(fPositionUpdater);

        parse(document);
      }
    }
  }
コード例 #3
0
  @Override
  public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
    clearAnnotations();

    if (oldInput != null) {
      IDocument document = documentProvider.getDocument(oldInput);
      if (document != null) {
        try {
          document.removePositionCategory(SEGMENTS);
        } catch (BadPositionCategoryException e) {
          // Do Nothing
        }
        document.removePositionUpdater(positionUpdater);
      }
    }

    if (newInput != null) {
      IDocument document = documentProvider.getDocument(newInput);
      if (document != null) {
        document.addPositionCategory(SEGMENTS);
        document.addPositionUpdater(positionUpdater);

        tree = parser.parse(document.get());
        addAnnotations(document.get());
      }
    }
  }
コード例 #4
0
    /**
     * Provides manipulation of browser open status due to implement <code>IWindowListener</code>.
     * This method must not be called by client because it is called by platform. Do nothing for
     * Eclipse sensor so far.
     *
     * @param window An IWorkbenchWindow instance to be triggered when a window is activated.
     */
    public void windowActivated(IWorkbenchWindow window) {
      IEditorPart activeEditorPart = window.getActivePage().getActiveEditor();
      if (activeEditorPart instanceof ITextEditor) {
        EclipseSensor.this.activeTextEditor = (ITextEditor) activeEditorPart;
        ITextEditor editor = EclipseSensor.this.activeTextEditor;
        IDocumentProvider provider = editor.getDocumentProvider();
        IDocument document = provider.getDocument(editor.getEditorInput());
        document.addDocumentListener(new DocumentListenerAdapter());
        int activeBufferSize = provider.getDocument(editor.getEditorInput()).getLength();

        // BuffTrans: Copy the new active file size to the threshold buffer size .
        EclipseSensor.this.thresholdBufferSize = activeBufferSize;
        EclipseSensor.this.activeBufferSize = activeBufferSize;
      }
    }
コード例 #5
0
 /**
  * Returns the variable and function names at the current line, or <code>null</code> if none.
  *
  * @param part text editor
  * @param selection text selection
  * @return the variable and function names at the current line, or <code>null</code> if none. The
  *     array has two elements, the first is the variable name, the second is the function name.
  */
 protected String[] getVariableAndFunctionName(IWorkbenchPart part, ISelection selection) {
   ITextEditor editor = getEditor(part);
   if (editor != null && selection instanceof ITextSelection) {
     ITextSelection textSelection = (ITextSelection) selection;
     IDocumentProvider documentProvider = editor.getDocumentProvider();
     try {
       documentProvider.connect(this);
       IDocument document = documentProvider.getDocument(editor.getEditorInput());
       IRegion region = document.getLineInformationOfOffset(textSelection.getOffset());
       String string = document.get(region.getOffset(), region.getLength()).trim();
       if (string.startsWith("var ")) { // $NON-NLS-1$
         String varName = string.substring(4).trim();
         String fcnName =
             getFunctionName(
                 document, varName, document.getLineOfOffset(textSelection.getOffset()));
         return new String[] {varName, fcnName};
       }
     } catch (CoreException e) {
     } catch (BadLocationException e) {
     } finally {
       documentProvider.disconnect(this);
     }
   }
   return null;
 }
コード例 #6
0
	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;
	}
コード例 #7
0
  /**
   * Attaches a coverage annotation model for the given editor if the editor can be annotated. Does
   * nothing if the model is already attached.
   *
   * @param editor Editor to attach a annotation model to
   */
  public static boolean attach(ITextEditor editor) {
    IDocumentProvider provider = editor.getDocumentProvider();
    IEditorInput input = editor.getEditorInput();

    if (provider != null && input instanceof FileEditorInput) {
      IAnnotationModel model = provider.getAnnotationModel(input);

      if (model instanceof IAnnotationModelExtension) {
        IAnnotationModelExtension modelex = (IAnnotationModelExtension) model;

        ColorAnnotationModel colormodel = (ColorAnnotationModel) modelex.getAnnotationModel(KEY);

        if (colormodel == null) {
          IFile file = ((FileEditorInput) input).getFile();
          IFeatureProject project = CorePlugin.getFeatureProject(file);
          if (project != null
              && project.getComposer() != null
              && project.getComposer().needColor()) {
            IDocument document = provider.getDocument(input);
            colormodel = new ColorAnnotationModel(document, file, project, editor);
            modelex.addAnnotationModel(KEY, colormodel);

            return true;
          }
        } else {
          colormodel.updateAnnotations(!editor.isDirty());
        }
      }
    }
    return false;
  }
コード例 #8
0
 public void apply(final IDocument document) {
   IProject p = marker.getResource().getProject();
   IFile f = BuildWrapperPlugin.getCabalFile(p);
   IDocumentProvider prov = new TextFileDocumentProvider();
   try {
     prov.connect(f);
     IDocument doc = prov.getDocument(f);
     PackageDescription pd = PackageDescriptionLoader.load(f);
     int length = pd.getStanzas().size();
     for (int a = 0; a < length; a++) {
       PackageDescriptionStanza pds = pd.getStanzas().get(a);
       CabalSyntax cs = pds.getType();
       if (CabalSyntax.SECTION_EXECUTABLE.equals(cs)
           || CabalSyntax.SECTION_LIBRARY.equals(cs)
           || CabalSyntax.SECTION_TESTSUITE.equals(cs)) {
         RealValuePosition rvp = pds.addToPropertyList(CabalSyntax.FIELD_BUILD_DEPENDS, pkg);
         if (rvp != null) {
           rvp.updateDocument(doc);
           pd = PackageDescriptionLoader.load(doc.get());
         }
       }
     }
     prov.saveDocument(new NullProgressMonitor(), f, doc, true);
   } catch (CoreException ce) {
     HaskellUIPlugin.log(ce);
   }
 }
コード例 #9
0
  public static IWorkbench getMockWorkbench(String file) {

    IWorkbench workbench = mock(IWorkbench.class);
    IWorkbenchWindow window = mock(IWorkbenchWindow.class);
    IWorkbenchPage page = mock(IWorkbenchPage.class);

    ITextEditor editor = mock(ITextEditor.class);

    IDocumentProvider docProvider = mock(IDocumentProvider.class);
    IDocument doc = mock(IDocument.class);

    IPath ipath = mock(IPath.class);
    File afile = mock(File.class);
    IFile inputFile = mock(IFile.class);

    IFileEditorInput editorInput = mock(IFileEditorInput.class);

    when(workbench.getWorkbenchWindows()).thenReturn(new IWorkbenchWindow[] {window});
    when(window.getActivePage()).thenReturn(page);
    when(page.getActiveEditor()).thenReturn(editor);

    when(editor.getEditorInput()).thenReturn(editorInput);
    when(editor.getDocumentProvider()).thenReturn(docProvider);

    when(editorInput.getFile()).thenReturn(inputFile);
    when(docProvider.getDocument(any())).thenReturn(doc);

    when(inputFile.getLocation()).thenReturn(ipath);
    when(inputFile.getName()).thenReturn(file);

    when(ipath.toFile()).thenReturn(afile);
    when(afile.length()).thenReturn(33l);

    return workbench;
  }
コード例 #10
0
  /**
   * Provide the initialization of the listeners additions. The Window, Part, and Document Listener
   * are added. Note that sensor shell should be instantiated before this method is called because
   * <code>processActivity()</code> method uses sensor shell instance.
   */
  private void registerListeners() {
    IWorkbench workbench = EclipseSensorPlugin.getInstance().getWorkbench();

    // :RESOLVED: JULY 1, 2003
    // Supports the multiple window for sensor collection.
    IWorkbenchWindow[] activeWindows = workbench.getWorkbenchWindows();

    // Check if window listener is not added yet. Otherwise multi instances are notified.
    if (this.windowListener == null) {
      this.windowListener = new WindowListenerAdapter();
      workbench.addWindowListener(new WindowListenerAdapter());
    }

    for (int i = 0; i < activeWindows.length; i++) {
      IWorkbenchPage activePage = activeWindows[i].getActivePage();
      activePage.addPartListener(new PartListenerAdapter());
      IEditorPart activeEditorPart = activePage.getActiveEditor();

      // Adds this EclipseSensorPlugin instance to IDocumentListener
      // only when activeEditorPart is the instance of ITextEditor
      // so that null case is also ignored.
      if (activeEditorPart instanceof ITextEditor) {
        // Sets activeTextEditor. Otherwise a first activated file would not be recorded.
        this.activeTextEditor = (ITextEditor) activeEditorPart;
        // Gets opened file since the initial opened file is not notified from IPartListener.
        URI fileResource = EclipseSensor.this.getFileResource(this.activeTextEditor);

        Map<String, String> keyValueMap = new HashMap<String, String>();
        keyValueMap.put(EclipseSensorConstants.SUBTYPE, "Open");
        keyValueMap.put(EclipseSensorConstants.UNIT_TYPE, EclipseSensorConstants.FILE);
        keyValueMap.put(
            EclipseSensorConstants.UNIT_NAME, EclipseSensor.this.extractFileName(fileResource));
        this.addDevEvent(
            EclipseSensorConstants.DEVEVENT_EDIT,
            fileResource,
            keyValueMap,
            "Opened " + fileResource.toString());

        IDocumentProvider provider = this.activeTextEditor.getDocumentProvider();
        IDocument document = provider.getDocument(activeEditorPart.getEditorInput());

        // Initially sets active buffer and threshold buffer.
        // Otherwise a first activated buffer would not be recorded.
        this.activeBufferSize = document.getLength();
        this.thresholdBufferSize = document.getLength();
        document.addDocumentListener(new DocumentListenerAdapter());
      }
    }

    // Handles breakpoint set/unset event.
    IBreakpointManager bpManager = DebugPlugin.getDefault().getBreakpointManager();
    bpManager.addBreakpointListener(new BreakPointerSensor(this));

    // Listens to debug event.
    DebugPlugin.getDefault().addDebugEventListener(new DebugSensor(this));

    // Creates instance to handle build error.
    this.buildErrorSensor = new BuildErrorSensor(this);
  }
コード例 #11
0
    /**
     * Provides manipulation of browser part activation status due to implement <code>IPartListener
     * </code>. This method must not be called by client because it is called by platform. Do
     * nothing for Eclipse sensor so far.
     *
     * @param part An IWorkbenchPart instance to be triggered when a part is activated.
     */
    public void partActivated(IWorkbenchPart part) {

      if (part instanceof ITextEditor) {
        // System.out.println("Sensor : " + part);
        EclipseSensor.this.isActivatedWindow = true;
        EclipseSensor.this.activeTextEditor = (ITextEditor) part;
        ITextEditor editor = EclipseSensor.this.activeTextEditor;
        IDocumentProvider provider = editor.getDocumentProvider();
        IDocument document = provider.getDocument(editor.getEditorInput());
        document.addDocumentListener(new DocumentListenerAdapter());
        int activeBufferSize = provider.getDocument(editor.getEditorInput()).getLength();

        // BuffTrans: Copy the new active file size to the threshold buffer size .
        EclipseSensor.this.thresholdBufferSize = activeBufferSize;
        EclipseSensor.this.activeBufferSize = activeBufferSize;
      }
    }
コード例 #12
0
  private void setXMLOutlineInput() {
    IDocumentProvider provider = fEditor.getDocumentProvider();

    // force creation of the document & the model.
    IDocument document = provider.getDocument(fEditor.getEditorInput());
    IXMLModelProvider modelProvider = UIPlugin.getDefault().getXMLModelProvider();
    XMLReconciler model = (modelProvider).getModel(document);
    fXMLOutlinePage.setInput(model.getRoot());
  }
コード例 #13
0
    public void uninstall() {
      ISourceViewer sourceViewer = editor.getISourceViewer();
      if (sourceViewer != null) sourceViewer.removeTextInputListener(this);

      IDocumentProvider documentProvider = editor.getDocumentProvider();
      if (documentProvider != null) {
        IDocument document = documentProvider.getDocument(editor.getEditorInput());
        if (document != null) document.removeDocumentListener(this);
      }
    }
コード例 #14
0
ファイル: SQLFormatter.java プロジェクト: caueda/sqlcopy
  /**
   * the command has been executed, so extract extract the needed information from the application
   * context.
   */
  public Object execute(ExecutionEvent event) throws ExecutionException {
    IWorkbenchWindow window = HandlerUtil.getActiveWorkbenchWindowChecked(event);
    ITextSelection content =
        (ITextSelection)
            window
                .getActivePage()
                .getActiveEditor()
                .getEditorSite()
                .getSelectionProvider()
                .getSelection();
    String texto = content.getText();
    Toolkit toolkit = Toolkit.getDefaultToolkit();
    Clipboard clipboard = toolkit.getSystemClipboard();

    String sqlFormatado = formatSQL(texto);

    StringSelection textoFormatado = new StringSelection(sqlFormatado);
    clipboard.setContents(textoFormatado, null);

    if (isBlank(texto)) {
      MessageDialog.openInformation(window.getShell(), "SQLCopy", "Você não selecionou nada!");
    } else {
      if (isConvertToJava(
          texto)) { // Realizar a substituição do texto selecionado apenas quando estiver
        // convertendo um SQL para Java.
        IEditorPart part =
            PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActiveEditor();
        ITextEditor editor = (ITextEditor) part;
        IDocumentProvider prov = editor.getDocumentProvider();
        IDocument doc = prov.getDocument(editor.getEditorInput());
        ISelection sel = editor.getSelectionProvider().getSelection();

        if (sel instanceof TextSelection) {
          final TextSelection textSel = (TextSelection) sel;
          try {
            //		            	IRegion region = doc.getLineInformationOfOffset(textSel.getOffset());
            //						doc.replace( textSel.getOffset(), textSel.getLength(),
            // identingCode(region.getLength(), sqlFormatado));
            doc.replace(textSel.getOffset(), textSel.getLength(), sqlFormatado);
          } catch (BadLocationException e) {
            e.printStackTrace();
          }
        }
      }
      //			MessageDialog.openInformation(
      //					window.getShell(),
      //					"SQLCopy",
      //					sqlFormatado.toString());
      CustomMessageDialog dialog =
          new CustomMessageDialog(window.getShell(), sqlFormatado.toString());
      dialog.open();
    }

    return null;
  }
 private static IRegion getRegionOfInterest(ITextEditor editor, int invocationLocation)
     throws BadLocationException {
   IDocumentProvider documentProvider = editor.getDocumentProvider();
   if (documentProvider == null) {
     return null;
   }
   IDocument document = documentProvider.getDocument(editor.getEditorInput());
   if (document == null) {
     return null;
   }
   return document.getLineInformationOfOffset(invocationLocation);
 }
コード例 #16
0
  public static IDocument getDocument(IEditorReference er) {
    IEditorPart ep = er.getEditor(false);
    if (!(ep instanceof ITextEditor)) return null;
    ITextEditor te = (ITextEditor) ep;

    IDocumentProvider dp = te.getDocumentProvider();
    if (dp == null) return null;

    IEditorInput input = getEditorInput(er);
    if (input == null) return null;

    return dp.getDocument(input);
  }
コード例 #17
0
 private IDocument getDocument(IDocumentProvider provider, IEditorInput input) {
   if (input == null) {
     return null;
   }
   IDocument result = null;
   try {
     provider.connect(input);
     result = provider.getDocument(input);
   } catch (CoreException e) {
   } finally {
     provider.disconnect(input);
   }
   return result;
 }
コード例 #18
0
    public void uninstall() {
      final ISourceViewer sourceViewer = erlangEditor.getViewer();
      if (sourceViewer != null) {
        sourceViewer.removeTextInputListener(this);
      }

      final IDocumentProvider documentProvider = erlangEditor.getDocumentProvider();
      if (documentProvider != null) {
        final IDocument document = documentProvider.getDocument(erlangEditor.getEditorInput());
        if (document != null) {
          document.removeDocumentListener(this);
        }
      }
    }
コード例 #19
0
  /**
   * Attaches a coverage annotation model for the given editor if the editor can be annotated. Does
   * nothing if the model is already attached.
   *
   * @param editor Editor to attach a annotation model to
   */
  public static void attach(ITextEditor editor) {
    IDocumentProvider provider = editor.getDocumentProvider();
    // there may be text editors without document providers (SF #1725100)
    if (provider == null) return;
    IAnnotationModel model = provider.getAnnotationModel(editor.getEditorInput());
    if (!(model instanceof IAnnotationModelExtension)) return;
    IAnnotationModelExtension modelex = (IAnnotationModelExtension) model;

    IDocument document = provider.getDocument(editor.getEditorInput());

    CoverageAnnotationModel coveragemodel =
        (CoverageAnnotationModel) modelex.getAnnotationModel(KEY);
    if (coveragemodel == null) {
      coveragemodel = new CoverageAnnotationModel(editor, document);
      modelex.addAnnotationModel(KEY, coveragemodel);
    }
  }
コード例 #20
0
ファイル: BndEditor.java プロジェクト: rkrzewski/bndtools
  @Override
  public void init(IEditorSite site, IEditorInput input) throws PartInitException {
    super.init(site, input);
    sourcePage.init(site, input);

    setPartNameForInput(input);

    IResource resource = ResourceUtil.getResource(input);
    if (resource != null) {
      resource.getWorkspace().addResourceChangeListener(this);
    }

    final IDocumentProvider docProvider = sourcePage.getDocumentProvider();
    IDocument document = docProvider.getDocument(input);
    try {
      model.loadFrom(new IDocumentWrapper(document));
      model.setProjectFile(Project.BNDFILE.equals(input.getName()));

      if (resource != null) {
        model.setBndResource(resource.getLocation().toFile());
      }
      // model.addPropertyChangeListener(modelListener);
    } catch (IOException e) {
      throw new PartInitException("Error reading editor input.", e);
    }

    // Ensure the field values are updated if the file content is replaced
    docProvider.addElementStateListener(
        new IElementStateListener() {
          public void elementMoved(Object originalElement, Object movedElement) {}

          public void elementDirtyStateChanged(Object element, boolean isDirty) {}

          public void elementDeleted(Object element) {}

          public void elementContentReplaced(Object element) {
            try {
              model.loadFrom(new IDocumentWrapper(docProvider.getDocument(element)));
            } catch (IOException e) {
              logger.logError("Error loading model from document.", e);
            }
          }

          public void elementContentAboutToBeReplaced(Object element) {}
        });
  }
コード例 #21
0
    /**
     * Provides manipulation of browser deactivation status due to implement <code>IWindowListener
     * </code>. This method must not be called by client because it is called by platform. Do
     * nothing for Eclipse sensor so far.
     *
     * @param window An IWorkbenchWindow instance to be triggered when a window is deactivated.
     */
    public void windowDeactivated(IWorkbenchWindow window) {
      EclipseSensor.this.isActivatedWindow = false;
      IEditorPart activeEditorPart = window.getActivePage().getActiveEditor();
      if (activeEditorPart instanceof ITextEditor) {
        ITextEditor editor = (ITextEditor) activeEditorPart;
        IDocumentProvider provider = editor.getDocumentProvider();

        // provider could be null if the text editor is closed before this method is called.
        EclipseSensor.this.previousTextEditor = editor;
        int fromFileBufferSize = provider.getDocument(editor.getEditorInput()).getLength();

        // Check if a threshold buffer is either dirty or
        // not the same as the current from file buffer size;
        EclipseSensor.this.isModifiedFromFile =
            (editor.isDirty() || (EclipseSensor.this.thresholdBufferSize != fromFileBufferSize));
      }
    }
コード例 #22
0
  public String getText(Node node) throws BadLocationException {
    IDocument document = (editorInput == null) ? null : documentProvider.getDocument(editorInput);

    if ((document == null) || (node.position == null)) {
      return null;
    }

    int len = document.getLength();
    int offset = node.position.offset;
    int length = len - offset;

    if (length > 0) {
      return document.get(offset, length);
    }

    return null;
  }
コード例 #23
0
  public void editorPageChanged(Viewer viewer) {
    if (editorInput != null) {
      IDocument document = documentProvider.getDocument(editorInput);

      if (document != null) {
        RMLDocument d = Studio.getSelectedDocument();
        DesignPane pane = d == null ? null : d.getDesignPane();

        if (pane == null || pane.getRootWidget() == null) {
          rootElement = parseNodes(document);
        } else {
          rootElement = new Node(pane.getRootWidget());
        }
        viewer.refresh();
      }
    }
  }
コード例 #24
0
  /**
   * The action has been activated. The argument of the method represents the 'real' action sitting
   * in the workbench UI.
   *
   * @see IWorkbenchWindowActionDelegate#run
   */
  @Override
  public void run(final IAction action) {

    final IEditorPart part =
        PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActiveEditor();
    if (!(part instanceof AbstractTextEditor)) {
      return;
    }
    final ITextEditor editor = (ITextEditor) part;
    final IDocumentProvider dp = editor.getDocumentProvider();
    final IDocument doc = dp.getDocument(editor.getEditorInput());
    try {
      impexClient.validateImpex(doc.get(0, doc.getLength()));
    } catch (final BadLocationException e) {

      logger.log(
          new Status(Status.ERROR, Activator.PLUGIN_ID, Status.ERROR, "Bad Location Exception", e));
    }
  }
コード例 #25
0
ファイル: UndoManager.java プロジェクト: raimis55/saros
  protected void fireActivity(TextEditActivity activity) {

    expectedActivities.add(activity);

    List<ITextOperation> textOps = activity.toOperation().getTextOperations();

    IFile file = ((EclipseFileImpl) currentActiveEditor.getFile()).getDelegate();

    FileEditorInput input = new FileEditorInput(file);
    IDocumentProvider provider = EditorManager.getDocumentProvider(input);

    try {
      provider.connect(input);
    } catch (CoreException e) {
      log.error("Could not connect to a document provider on file '" + file.toString() + "':", e);
      return;
    }

    try {
      IDocument doc = provider.getDocument(input);
      if (doc == null) {
        log.error(
            "Could not connect to a document provider on file '" + file.toString() + "':",
            new StackTrace());
        return;
      }

      for (ITextOperation textOp : textOps) {
        try {
          if (textOp instanceof DeleteOperation)
            doc.replace(textOp.getPosition(), textOp.getTextLength(), "");
          if (textOp instanceof InsertOperation)
            doc.replace(textOp.getPosition(), 0, textOp.getText());
        } catch (BadLocationException e) {
          log.error("Invalid location for " + textOp);
        }
      }
    } finally {
      provider.disconnect(input);
    }
  }
コード例 #26
0
 /**
  * Returns a selection of the member in the given text selection, or the original selection if
  * none.
  *
  * @param part
  * @param selection
  * @return a structured selection of the member in the given text selection, or the original
  *     selection if none
  * @exception CoreException if an exception occurs
  */
 protected ISelection translateToMembers(IWorkbenchPart part, ISelection selection)
     throws CoreException {
   ITextEditor textEditor = getTextEditor(part);
   if (textEditor != null && selection instanceof ITextSelection) {
     ITextSelection textSelection = (ITextSelection) selection;
     IEditorInput editorInput = textEditor.getEditorInput();
     IDocumentProvider documentProvider = textEditor.getDocumentProvider();
     if (documentProvider == null) {
       throw new CoreException(Status.CANCEL_STATUS);
     }
     IDocument document = documentProvider.getDocument(editorInput);
     int offset = textSelection.getOffset();
     if (document != null) {
       try {
         IRegion region = document.getLineInformationOfOffset(offset);
         int end = region.getOffset() + region.getLength();
         while (Character.isWhitespace(document.getChar(offset)) && offset < end) {
           offset++;
         }
       } catch (BadLocationException e) {
       }
     }
     IMember m = null;
     IRubyScript root = getTypeRoot(editorInput);
     if (root != null) {
       synchronized (root) {
         root.reconcile(false, null, null);
       }
       IRubyElement e = root.getElementAt(offset);
       if (e instanceof IMember) {
         m = (IMember) e;
       }
     }
     if (m != null) {
       return new StructuredSelection(m);
     }
   }
   return selection;
 }
コード例 #27
0
  private void initializeSourceViewer(IEditorInput input) {

    IDocumentProvider documentProvider = getDocumentProvider();
    IAnnotationModel model = documentProvider.getAnnotationModel(input);
    IDocument document = documentProvider.getDocument(input);

    if (document != null) {
      fSourceViewer.setDocument(document, model);
      fSourceViewer.setEditable(isEditable());
      fSourceViewer.showAnnotations(model != null);
    }

    if (fElementStateListener instanceof IElementStateListenerExtension) {
      boolean isStateValidated = false;
      if (documentProvider instanceof IDocumentProviderExtension)
        isStateValidated = ((IDocumentProviderExtension) documentProvider).isStateValidated(input);

      IElementStateListenerExtension extension =
          (IElementStateListenerExtension) fElementStateListener;
      extension.elementStateValidationChanged(input, isStateValidated);
    }
  }
コード例 #28
0
  @Override
  public Object execute(final ExecutionEvent event) throws ExecutionException {
    final IWorkbenchPart workbenchPart = HandlerUtil.getActivePart(event);
    final ISelection selection = WorkbenchUIUtil.getCurrentSelection(event.getApplicationContext());

    try {
      if (workbenchPart instanceof ITextEditor && selection instanceof ITextSelection) {
        final ITextEditor editor = (ITextEditor) workbenchPart;
        final IDocumentProvider documentProvider = editor.getDocumentProvider();
        if (documentProvider == null) {
          return null;
        }
        final IDocument document = documentProvider.getDocument(editor.getEditorInput());
        if (document == null) {
          return null;
        }
        final List<String> lines = LaunchShortcutUtil.getSelectedCodeLines(event);
        if (lines != null) {
          RCodeLaunching.runRCodeDirect(lines, false, null);
          final int newOffset =
              getNextLineOffset(document, ((ITextSelection) selection).getEndLine());
          if (newOffset >= 0) {
            editor.selectAndReveal(newOffset, 0);
          }
        }
        return null;
      }
    } catch (final CoreException e) {
      LaunchShortcutUtil.handleRLaunchException(
          e, RLaunchingMessages.RSelectionLaunch_error_message, event);
      return null;
    }

    LaunchShortcutUtil.handleUnsupportedExecution(event);
    return null;
  }
コード例 #29
0
    /**
     * Provides manipulation of browser part deactivation status due to implement <code>
     * IPartListener</code>. This method must not be called by client because it is called by
     * platform. Sets active text editor to be null when the text editor part is deactivated.
     *
     * @param part An IWorkbenchPart instance to be triggered when a part is deactivated.
     */
    public void partDeactivated(IWorkbenchPart part) {
      if (part instanceof ITextEditor && !part.equals(EclipseSensor.this.deactivatedTextEditor)) {
        EclipseSensor.this.deactivatedTextEditor = (ITextEditor) part;
        if (EclipseSensor.this.isActivatedWindow) {
          IEditorPart activeEditorPart = part.getSite().getPage().getActiveEditor();

          // Sets activeTextEdtior to be null only when there is no more active editor.
          // Otherwise the case that the non text editor part is active causes the activeTextEditor
          // to be null so that sensor is not collected after that.
          if (activeEditorPart == null) {
            EclipseSensor.this.activeTextEditor = null;
          }

          // BuffTrans to get the toFrom buffer size.
          ITextEditor editor = (ITextEditor) part;
          IDocumentProvider provider = editor.getDocumentProvider();

          // provider could be null if the text editor is closed before this method is called.
          EclipseSensor.this.isModifiedFromFile = false;
          EclipseSensor.this.previousTextEditor = null;

          if (provider != null) {
            EclipseSensor.this.previousTextEditor = editor;
            int fromFileBufferSize = provider.getDocument(editor.getEditorInput()).getLength();

            // Check if a threshold buffer is either dirty or
            // not the same as the current from file buffer size;
            EclipseSensor.this.isModifiedFromFile =
                (editor.isDirty()
                    || (EclipseSensor.this.thresholdBufferSize != fromFileBufferSize));
          }
        } else {
          EclipseSensor.this.isActivatedWindow = true;
        }
      }
    }
コード例 #30
0
  public static void checkRegions(
      IProject project,
      String fileName,
      List<TestRegion> regionList,
      AbstractHyperlinkDetector elDetector)
      throws Exception {
    IFile file = project.getFile(fileName);

    assertNotNull("The file \"" + fileName + "\" is not found", file);
    assertTrue("The file \"" + fileName + "\" is not found", file.isAccessible());

    FileEditorInput editorInput = new FileEditorInput(file);

    IDocumentProvider documentProvider = null;
    try {
      documentProvider = DocumentProviderRegistry.getDefault().getDocumentProvider(editorInput);
    } catch (Exception x) {
      x.printStackTrace();
      fail("An exception caught: " + x.getMessage());
    }

    assertNotNull(
        "The document provider for the file \"" + fileName + "\" is not loaded", documentProvider);

    try {
      documentProvider.connect(editorInput);
    } catch (Exception x) {
      x.printStackTrace();
      fail(
          "The document provider is not able to be initialized with the editor input\nAn exception caught: "
              + x.getMessage());
    }

    IDocument document = documentProvider.getDocument(editorInput);

    assertNotNull("The document for the file \"" + fileName + "\" is not loaded", document);

    if (regionList.get(0).region == null) loadRegions(regionList, document);

    int expected = 0;
    for (TestRegion testRegion : regionList) expected += testRegion.region.getLength() + 1;

    IEditorPart part = openFileInEditor(file);
    ISourceViewer viewer = null;
    if (part instanceof JavaEditor) {
      viewer = ((JavaEditor) part).getViewer();
      elDetector.setContext(new TestContext((ITextEditor) part));
    } else if (part instanceof EditorPartWrapper) {
      if (((EditorPartWrapper) part).getEditor() instanceof WebCompoundEditor) {
        WebCompoundEditor wce = (WebCompoundEditor) ((EditorPartWrapper) part).getEditor();
        viewer = wce.getSourceEditor().getTextViewer();
        elDetector.setContext(new TestContext(wce.getSourceEditor()));
      } else if (((EditorPartWrapper) part).getEditor() instanceof XMLTextEditorStandAlone) {
        XMLTextEditorStandAlone xtesa =
            (XMLTextEditorStandAlone) ((EditorPartWrapper) part).getEditor();
        viewer = xtesa.getTextViewer();
        elDetector.setContext(new TestContext(xtesa));
      } else fail("unsupported editor type - " + ((EditorPartWrapper) part).getEditor().getClass());
    } else if (part instanceof JSPMultiPageEditor) {
      viewer = ((JSPMultiPageEditor) part).getJspEditor().getTextViewer();
      elDetector.setContext(new TestContext(((JSPMultiPageEditor) part).getJspEditor()));
    } else fail("unsupported editor type - " + part.getClass());

    int counter = 0;
    for (int i = 0; i < document.getLength(); i++) {
      int lineNumber = document.getLineOfOffset(i);
      int position = i - document.getLineOffset(lineNumber) + 1;
      lineNumber++;

      TestData testData = new TestData(document, i);
      IHyperlink[] links = elDetector.detectHyperlinks(viewer, testData.getHyperlinkRegion(), true);

      boolean recognized = links != null;

      if (recognized) {
        counter++;
        TestRegion testRegion = findOffsetInRegions(i, regionList);
        if (testRegion == null) {
          String information = findRegionInformation(document, i, regionList);
          fail(
              "Wrong detection for offset - "
                  + i
                  + " (line - "
                  + lineNumber
                  + " position - "
                  + position
                  + ") "
                  + information);
        } else {
          checkTestRegion(links, testRegion);
        }
      } else {
        for (TestRegion testRegion : regionList) {
          if (i >= testRegion.region.getOffset()
              && i <= testRegion.region.getOffset() + testRegion.region.getLength()) {
            fail(
                "Wrong detection for region - "
                    + getRegionInformation(document, testRegion)
                    + " offset - "
                    + i
                    + " (line - "
                    + lineNumber
                    + " position - "
                    + position
                    + ")");
          }
        }
      }
    }

    assertEquals("Wrong recognized region count: ", expected, counter);

    documentProvider.disconnect(editorInput);
  }