Examples with Command com.google.gwt.user.client.Command used on opensource projects

Example 11 with Command

use of com.google.gwt.user.client.Command in project rstudio by rstudio.

the class ChunkOptionsPopupPanel method init.

public void init(DocDisplay display, Position position) {
    display_ = display;
    position_ = position;
    chunkOptions_.clear();
    originalChunkOptions_.clear();
    useCustomFigureCheckbox_.setValue(false);
    figureDimensionsPanel_.setVisible(false);
    Command afterInit = new Command() {

        @Override
        public void execute() {
            updateOutputComboBox();
            boolean hasRelevantFigureSettings = has("fig.width") || has("fig.height");
            useCustomFigureCheckbox_.setValue(hasRelevantFigureSettings);
            if (hasRelevantFigureSettings)
                useCustomFigureCheckbox_.setVisible(true);
            figureDimensionsPanel_.setVisible(hasRelevantFigureSettings);
            if (has("fig.width"))
                figWidthBox_.setText(get("fig.width"));
            else
                figWidthBox_.setText("");
            if (has("fig.height"))
                figHeightBox_.setText(get("fig.height"));
            else
                figHeightBox_.setText("");
            if (has("warning"))
                showWarningsInOutputCb_.setValue(getBoolean("warning"));
            if (has("message"))
                showMessagesInOutputCb_.setValue(getBoolean("message"));
            if (has("engine.path")) {
                String enginePath = StringUtil.stringValue(get("engine.path"));
                enginePath = enginePath.replaceAll("\\\\\\\\", "\\\\");
                enginePathBox_.setValue(enginePath);
            }
            if (has("engine.opts")) {
                String engineOpts = StringUtil.stringValue(get("engine.opts"));
                engineOpts = engineOpts.replaceAll("\\\\\\\\", "\\\\");
                engineOptsBox_.setValue(engineOpts);
            }
            setVisible(true);
        }
    };
    initOptions(afterInit);
}

Example 12 with Command

use of com.google.gwt.user.client.Command in project rstudio by rstudio.

the class TextEditingTargetNotebook method executeChunk.

public void executeChunk(final Scope chunk) {
    // maximize the source pane if we haven't yet this session
    if (!maximizedPane_ && prefs_.hideConsoleOnChunkExecute().getValue()) {
        pSourceWindowManager_.get().maximizeSourcePaneIfNecessary();
        maximizedPane_ = true;
    }
    docUpdateSentinel_.withSavedDoc(new Command() {

        @Override
        public void execute() {
            // by creating a job that runs both chunks
            if (!isSetupChunkScope(chunk) && needsSetupChunkExecuted()) {
                List<ChunkExecUnit> chunks = new ArrayList<ChunkExecUnit>();
                chunks.add(new ChunkExecUnit(getSetupChunkScope(), NotebookQueueUnit.EXEC_MODE_BATCH));
                chunks.add(new ChunkExecUnit(chunk, NotebookQueueUnit.EXEC_MODE_SINGLE));
                queue_.executeChunks("Run Chunks", chunks);
            } else {
                queue_.executeChunk(new ChunkExecUnit(chunk, NotebookQueueUnit.EXEC_MODE_SINGLE));
            }
        }
    });
}

Example 13 with Command

use of com.google.gwt.user.client.Command in project rstudio by rstudio.

the class Projects method createNewProject.

private void createNewProject(final NewProjectResult newProject, final boolean saveChanges) {
    // This gets a little crazy. We have several pieces of asynchronous logic
    // that each may or may not need to be executed, depending on the type
    // of project being created and on whether the previous pieces of logic
    // succeed. Plus we have this ProgressIndicator that needs to be fed
    // properly.
    final ProgressIndicator indicator = globalDisplay_.getProgressIndicator("Error Creating Project");
    // Here's the command queue that will hold the various operations.
    final SerializedCommandQueue createProjectCmds = new SerializedCommandQueue();
    // WARNING: When calling addCommand, BE SURE TO PASS FALSE as the second
    // argument, to delay running of the commands until they are all
    // scheduled.
    // First, attempt to update the default project location pref
    createProjectCmds.addCommand(new SerializedCommand() {

        @Override
        public void onExecute(final Command continuation) {
            UIPrefs uiPrefs = pUIPrefs_.get();
            // update default project location pref if necessary
            if ((newProject.getNewDefaultProjectLocation() != null) || (newProject.getCreateGitRepo() != uiPrefs.newProjGitInit().getValue())) {
                indicator.onProgress("Saving defaults...");
                if (newProject.getNewDefaultProjectLocation() != null) {
                    uiPrefs.defaultProjectLocation().setGlobalValue(newProject.getNewDefaultProjectLocation());
                }
                if (newProject.getCreateGitRepo() != uiPrefs.newProjGitInit().getValue()) {
                    uiPrefs.newProjGitInit().setGlobalValue(newProject.getCreateGitRepo());
                }
                if (newProject.getUsePackrat() != uiPrefs.newProjUsePackrat().getValue()) {
                    uiPrefs.newProjUsePackrat().setGlobalValue(newProject.getUsePackrat());
                }
                // call the server -- in all cases continue on with
                // creating the project (swallow errors updating the pref)
                projServer_.setUiPrefs(session_.getSessionInfo().getUiPrefs(), new VoidServerRequestCallback(indicator) {

                    @Override
                    public void onResponseReceived(Void response) {
                        continuation.execute();
                    }

                    @Override
                    public void onError(ServerError error) {
                        super.onError(error);
                        continuation.execute();
                    }
                });
            } else {
                continuation.execute();
            }
        }
    }, false);
    // Next, if necessary, clone a repo
    if (newProject.getVcsCloneOptions() != null) {
        createProjectCmds.addCommand(new SerializedCommand() {

            @Override
            public void onExecute(final Command continuation) {
                VcsCloneOptions cloneOptions = newProject.getVcsCloneOptions();
                if (cloneOptions.getVcsName().equals((VCSConstants.GIT_ID)))
                    indicator.onProgress("Cloning Git repository...");
                else
                    indicator.onProgress("Checking out SVN repository...");
                gitServer_.vcsClone(cloneOptions, new ServerRequestCallback<ConsoleProcess>() {

                    @Override
                    public void onResponseReceived(ConsoleProcess proc) {
                        final ConsoleProgressDialog consoleProgressDialog = new ConsoleProgressDialog(proc, gitServer_);
                        consoleProgressDialog.showModal();
                        proc.addProcessExitHandler(new ProcessExitEvent.Handler() {

                            @Override
                            public void onProcessExit(ProcessExitEvent event) {
                                if (event.getExitCode() == 0) {
                                    consoleProgressDialog.hide();
                                    continuation.execute();
                                } else {
                                    indicator.onCompleted();
                                }
                            }
                        });
                    }

                    @Override
                    public void onError(ServerError error) {
                        Debug.logError(error);
                        indicator.onError(error.getUserMessage());
                    }
                });
            }
        }, false);
    }
    // Next, create the project itself -- depending on the type, this
    // could involve creating an R package, or Shiny application, and so on.
    createProjectCmds.addCommand(new SerializedCommand() {

        @Override
        public void onExecute(final Command continuation) {
            // Validate the package name if we're creating a package
            if (newProject.getNewPackageOptions() != null) {
                final String packageName = newProject.getNewPackageOptions().getPackageName();
                if (!PACKAGE_NAME_PATTERN.test(packageName)) {
                    indicator.onError("Invalid package name '" + packageName + "': " + "package names must start with a letter, and contain " + "only letters and numbers.");
                    return;
                }
            }
            indicator.onProgress("Creating project...");
            if (newProject.getNewPackageOptions() == null) {
                projServer_.createProject(newProject.getProjectFile(), newProject.getNewPackageOptions(), newProject.getNewShinyAppOptions(), newProject.getProjectTemplateOptions(), new VoidServerRequestCallback(indicator) {

                    @Override
                    public void onSuccess() {
                        continuation.execute();
                    }
                });
            } else {
                String projectFile = newProject.getProjectFile();
                String packageDirectory = projectFile.substring(0, projectFile.lastIndexOf('/'));
                projServer_.packageSkeleton(newProject.getNewPackageOptions().getPackageName(), packageDirectory, newProject.getNewPackageOptions().getCodeFiles(), newProject.getNewPackageOptions().getUsingRcpp(), new ServerRequestCallback<RResult<Void>>() {

                    @Override
                    public void onResponseReceived(RResult<Void> response) {
                        if (response.failed())
                            indicator.onError(response.errorMessage());
                        else
                            continuation.execute();
                    }

                    @Override
                    public void onError(ServerError error) {
                        Debug.logError(error);
                        indicator.onError(error.getUserMessage());
                    }
                });
            }
        }
    }, false);
    // Next, initialize a git repo if requested
    if (newProject.getCreateGitRepo()) {
        createProjectCmds.addCommand(new SerializedCommand() {

            @Override
            public void onExecute(final Command continuation) {
                indicator.onProgress("Initializing git repository...");
                String projDir = FileSystemItem.createFile(newProject.getProjectFile()).getParentPathString();
                gitServer_.gitInitRepo(projDir, new VoidServerRequestCallback(indicator) {

                    @Override
                    public void onSuccess() {
                        continuation.execute();
                    }

                    @Override
                    public void onFailure() {
                        continuation.execute();
                    }
                });
            }
        }, false);
    }
    // Generate a new packrat project
    if (newProject.getUsePackrat()) {
        createProjectCmds.addCommand(new SerializedCommand() {

            @Override
            public void onExecute(final Command continuation) {
                indicator.onProgress("Initializing packrat project...");
                String projDir = FileSystemItem.createFile(newProject.getProjectFile()).getParentPathString();
                packratServer_.packratBootstrap(projDir, false, new VoidServerRequestCallback(indicator) {

                    @Override
                    public void onSuccess() {
                        continuation.execute();
                    }
                });
            }
        }, false);
    }
    if (newProject.getOpenInNewWindow()) {
        createProjectCmds.addCommand(new SerializedCommand() {

            @Override
            public void onExecute(final Command continuation) {
                FileSystemItem project = FileSystemItem.createFile(newProject.getProjectFile());
                if (Desktop.isDesktop()) {
                    Desktop.getFrame().openProjectInNewWindow(project.getPath());
                    continuation.execute();
                } else {
                    indicator.onProgress("Preparing to open project...");
                    serverOpenProjectInNewWindow(project, newProject.getRVersion(), continuation);
                }
            }
        }, false);
    }
    // If we get here, dismiss the progress indicator
    createProjectCmds.addCommand(new SerializedCommand() {

        @Override
        public void onExecute(Command continuation) {
            indicator.onCompleted();
            if (!newProject.getOpenInNewWindow()) {
                applicationQuit_.performQuit(saveChanges, newProject.getProjectFile(), newProject.getRVersion());
            }
            continuation.execute();
        }
    }, false);
    // Now set it all in motion!
    createProjectCmds.run();
}

Example 14 with Command

use of com.google.gwt.user.client.Command in project rstudio by rstudio.

the class ProjectPreferencesPane method promptToRestart.

protected void promptToRestart() {
    globalDisplay_.showYesNoMessage(MessageDialog.QUESTION, "Confirm Restart RStudio", "You need to restart RStudio in order for this change to take " + "effect. Do you want to do this now?", new Operation() {

        @Override
        public void execute() {
            forceClosed(new Command() {

                @Override
                public void execute() {
                    SwitchToProjectEvent event = new SwitchToProjectEvent(session_.getSessionInfo().getActiveProjectFile());
                    eventBus_.fireEvent(event);
                }
            });
        }
    }, true);
}

Example 15 with Command

use of com.google.gwt.user.client.Command 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);
    }
}