Examples with EditingTargetCodeExecution org.rstudio.studio.client.workbench.views.source.editors.EditingTargetCodeExecution used on opensource projects

Example 1 with EditingTargetCodeExecution

use of org.rstudio.studio.client.workbench.views.source.editors.EditingTargetCodeExecution in project rstudio by rstudio.

the class CodeBrowserEditingTarget method initialize.

@Override
public void initialize(SourceDocument document, FileSystemContext fileContext, FileType type, Provider<String> defaultNameProvider) {
    doc_ = document;
    codeExecution_ = new EditingTargetCodeExecution(docDisplay_, getId());
    view_ = new CodeBrowserEditingTargetWidget(commands_, globalDisplay_, events_, server_, docDisplay_);
    TextEditingTarget.registerPrefs(releaseOnDismiss_, prefs_, docDisplay_, document);
    TextEditingTarget.syncFontSize(releaseOnDismiss_, events_, view_, fontSizeManager_);
    releaseOnDismiss_.add(prefs_.softWrapRFiles().addValueChangeHandler(new ValueChangeHandler<Boolean>() {

        public void onValueChange(ValueChangeEvent<Boolean> evt) {
            view_.adaptToFileType(FileTypeRegistry.R);
        }
    }));
    // if we have contents then set them
    CodeBrowserContents contents = getContents();
    if (contents.getContext().length() > 0) {
        ensureContext(contents.getContext(), new Command() {

            @Override
            public void execute() {
            }
        });
    } else {
        docDisplay_.setCode("", false);
    }
}

Example 2 with EditingTargetCodeExecution

use of org.rstudio.studio.client.workbench.views.source.editors.EditingTargetCodeExecution in project rstudio by rstudio.

the class TextEditingTarget method initialize.

public void initialize(final SourceDocument document, FileSystemContext fileContext, FileType type, Provider<String> defaultNameProvider) {
    id_ = document.getId();
    fileContext_ = fileContext;
    fileType_ = (TextFileType) type;
    codeExecution_ = new EditingTargetCodeExecution(this, docDisplay_, getId(), this);
    extendedType_ = document.getExtendedType();
    extendedType_ = rmarkdownHelper_.detectExtendedType(document.getContents(), extendedType_, fileType_);
    themeHelper_ = new TextEditingTargetThemeHelper(this, events_);
    docUpdateSentinel_ = new DocUpdateSentinel(server_, docDisplay_, document, globalDisplay_.getProgressIndicator("Save File"), dirtyState_, events_);
    view_ = new TextEditingTargetWidget(this, docUpdateSentinel_, commands_, prefs_, fileTypeRegistry_, docDisplay_, fileType_, extendedType_, events_, session_);
    roxygenHelper_ = new RoxygenHelper(docDisplay_, view_);
    // create notebook and forward resize events
    chunks_ = new TextEditingTargetChunks(this);
    notebook_ = new TextEditingTargetNotebook(this, chunks_, view_, docDisplay_, dirtyState_, docUpdateSentinel_, document, releaseOnDismiss_, dependencyManager_);
    view_.addResizeHandler(notebook_);
    // ensure that Makefile and Makevars always use tabs
    name_.addValueChangeHandler(new ValueChangeHandler<String>() {

        @Override
        public void onValueChange(ValueChangeEvent<String> event) {
            if ("Makefile".equals(event.getValue()) || "Makefile.in".equals(event.getValue()) || "Makefile.win".equals(event.getValue()) || "Makevars".equals(event.getValue()) || "Makevars.in".equals(event.getValue()) || "Makevars.win".equals(event.getValue())) {
                docDisplay_.setUseSoftTabs(false);
            }
        }
    });
    name_.setValue(getNameFromDocument(document, defaultNameProvider), true);
    String contents = document.getContents();
    docDisplay_.setCode(contents, false);
    // Load and apply folds.
    final ArrayList<Fold> folds = Fold.decode(document.getFoldSpec());
    Scheduler.get().scheduleDeferred(new ScheduledCommand() {

        @Override
        public void execute() {
            for (Fold fold : folds) docDisplay_.addFold(fold.getRange());
        }
    });
    // Load and apply Vim marks (if they exist).
    if (document.getProperties().hasKey("marks")) {
        final String marksSpec = document.getProperties().getString("marks");
        final JsMap<Position> marks = VimMarks.decode(marksSpec);
        // Time out the marks setting just to avoid conflict with other
        // mutations of the editor.
        new Timer() {

            @Override
            public void run() {
                docDisplay_.setMarks(marks);
            }
        }.schedule(100);
    }
    registerPrefs(releaseOnDismiss_, prefs_, docDisplay_, document);
    // Initialize sourceOnSave, and keep it in sync
    view_.getSourceOnSave().setValue(document.sourceOnSave(), false);
    view_.getSourceOnSave().addValueChangeHandler(new ValueChangeHandler<Boolean>() {

        public void onValueChange(ValueChangeEvent<Boolean> event) {
            docUpdateSentinel_.setSourceOnSave(event.getValue(), globalDisplay_.getProgressIndicator("Error Saving Setting"));
        }
    });
    if (document.isDirty())
        dirtyState_.markDirty(false);
    else
        dirtyState_.markClean();
    docDisplay_.addValueChangeHandler(new ValueChangeHandler<Void>() {

        public void onValueChange(ValueChangeEvent<Void> event) {
            dirtyState_.markDirty(true);
            docDisplay_.clearSelectionHistory();
        }
    });
    docDisplay_.addFocusHandler(new FocusHandler() {

        public void onFocus(FocusEvent event) {
            // let anyone listening know this doc just got focus
            events_.fireEvent(new DocFocusedEvent(getPath(), getId()));
            if (queuedCollabParams_ != null) {
                // of one
                if (docDisplay_ != null && !docDisplay_.hasActiveCollabSession()) {
                    beginQueuedCollabSession();
                }
            }
            // check to see if the file's been saved externally--we do this even
            // in a collaborative editing session so we can get delete
            // notifications
            Scheduler.get().scheduleFixedDelay(new RepeatingCommand() {

                public boolean execute() {
                    if (view_.isAttached())
                        checkForExternalEdit();
                    return false;
                }
            }, 500);
        }
    });
    if (fileType_.isR()) {
        docDisplay_.addBreakpointSetHandler(new BreakpointSetEvent.Handler() {

            @Override
            public void onBreakpointSet(BreakpointSetEvent event) {
                if (event.isSet()) {
                    Breakpoint breakpoint = null;
                    // don't try to set breakpoints in unsaved code
                    if (isNewDoc()) {
                        view_.showWarningBar("Breakpoints cannot be set until " + "the file is saved.");
                        return;
                    }
                    // don't try to set breakpoints if the R version is too old
                    if (!session_.getSessionInfo().getHaveSrcrefAttribute()) {
                        view_.showWarningBar("Editor breakpoints require R 2.14 " + "or newer.");
                        return;
                    }
                    Position breakpointPosition = Position.create(event.getLineNumber() - 1, 1);
                    // if we're not in function scope, or this is a Shiny file,
                    // set a top-level (aka. Shiny-deferred) breakpoint
                    ScopeFunction innerFunction = null;
                    if (extendedType_ == null || !extendedType_.startsWith(SourceDocument.XT_SHINY_PREFIX))
                        innerFunction = docDisplay_.getFunctionAtPosition(breakpointPosition, false);
                    if (innerFunction == null || !innerFunction.isFunction() || StringUtil.isNullOrEmpty(innerFunction.getFunctionName())) {
                        breakpoint = breakpointManager_.setTopLevelBreakpoint(getPath(), event.getLineNumber());
                    } else // the scope tree will find nested functions, but in R these
                    // are addressable only as substeps of the parent function.
                    // keep walking up the scope tree until we've reached the top
                    // level function.
                    {
                        while (innerFunction.getParentScope() != null && innerFunction.getParentScope().isFunction()) {
                            innerFunction = (ScopeFunction) innerFunction.getParentScope();
                        }
                        String functionName = innerFunction.getFunctionName();
                        breakpoint = breakpointManager_.setBreakpoint(getPath(), functionName, event.getLineNumber(), dirtyState().getValue() == false);
                    }
                    docDisplay_.addOrUpdateBreakpoint(breakpoint);
                } else {
                    breakpointManager_.removeBreakpoint(event.getBreakpointId());
                }
                updateBreakpointWarningBar();
            }
        });
        docDisplay_.addBreakpointMoveHandler(new BreakpointMoveEvent.Handler() {

            @Override
            public void onBreakpointMove(BreakpointMoveEvent event) {
                breakpointManager_.moveBreakpoint(event.getBreakpointId());
            }
        });
    }
    // validate required components (e.g. Tex, knitr, C++ etc.)
    checkCompilePdfDependencies();
    rmarkdownHelper_.verifyPrerequisites(view_, fileType_);
    syncFontSize(releaseOnDismiss_, events_, view_, fontSizeManager_);
    final String rTypeId = FileTypeRegistry.R.getTypeId();
    releaseOnDismiss_.add(prefs_.softWrapRFiles().addValueChangeHandler(new ValueChangeHandler<Boolean>() {

        public void onValueChange(ValueChangeEvent<Boolean> evt) {
            if (fileType_.getTypeId().equals(rTypeId))
                view_.adaptToFileType(fileType_);
        }
    }));
    releaseOnDismiss_.add(events_.addHandler(FileChangeEvent.TYPE, new FileChangeHandler() {

        @Override
        public void onFileChange(FileChangeEvent event) {
            // screen out adds and events that aren't for our path
            FileChange fileChange = event.getFileChange();
            if (fileChange.getType() == FileChange.ADD)
                return;
            else if (!fileChange.getFile().getPath().equals(getPath()))
                return;
            // always check for changes if this is the active editor
            if (commandHandlerReg_ != null) {
                checkForExternalEdit();
            } else // this will show a confirmation dialog
            if (event.getFileChange().getType() == FileChange.MODIFIED && dirtyState().getValue() == false) {
                checkForExternalEdit();
            }
        }
    }));
    spelling_ = new TextEditingTargetSpelling(docDisplay_, docUpdateSentinel_);
    // show/hide the debug toolbar when the dirty state changes. (note:
    // this doesn't yet handle the case where the user saves the document,
    // in which case we should still show some sort of warning.)
    dirtyState().addValueChangeHandler(new ValueChangeHandler<Boolean>() {

        public void onValueChange(ValueChangeEvent<Boolean> evt) {
            updateDebugWarningBar();
        }
    });
    // find all of the debug breakpoints set in this document and replay them
    // onto the edit surface
    ArrayList<Breakpoint> breakpoints = breakpointManager_.getBreakpointsInFile(getPath());
    for (Breakpoint breakpoint : breakpoints) {
        docDisplay_.addOrUpdateBreakpoint(breakpoint);
    }
    if (extendedType_.equals(SourceDocument.XT_RMARKDOWN)) {
        // populate the popup menu with a list of available formats
        updateRmdFormatList();
        setRMarkdownBehaviorEnabled(true);
    }
    view_.addRmdFormatChangedHandler(new RmdOutputFormatChangedEvent.Handler() {

        @Override
        public void onRmdOutputFormatChanged(RmdOutputFormatChangedEvent event) {
            setRmdFormat(event.getFormat());
        }
    });
    syncPublishPath(document.getPath());
    initStatusBar();
}