use of org.rstudio.studio.client.rmarkdown.events.RmdOutputFormatChangedEvent in project rstudio by rstudio.
the class TextEditingTargetWidget method setFormatOptions.
@Override
public void setFormatOptions(TextFileType fileType, boolean showRmdFormatMenu, boolean canEditFormatOptions, List<String> options, List<String> values, List<String> extensions, String selectedOption) {
if (!canEditFormatOptions) {
setFormatText("");
}
setRmdFormatButtonVisible(showRmdFormatMenu);
rmdFormatButton_.setEnabled(showRmdFormatMenu);
rmdFormatButton_.clearMenu();
int parenPos = selectedOption.indexOf('(');
if (parenPos != -1)
selectedOption = selectedOption.substring(0, parenPos).trim();
// don't show format text (but leave the code in for now in case
// we change our mind)
// setFormatText(selectedOption);
setFormatText("");
String prefix = fileType.isPlainMarkdown() ? "Preview " : "Knit to ";
for (int i = 0; i < Math.min(options.size(), values.size()); i++) {
String ext = extensions.get(i);
ImageResource img = ext != null ? fileTypeRegistry_.getIconForFilename("output." + ext) : fileTypeRegistry_.getIconForFilename("Makefile");
final String valueName = values.get(i);
ScheduledCommand cmd = new ScheduledCommand() {
@Override
public void execute() {
handlerManager_.fireEvent(new RmdOutputFormatChangedEvent(valueName));
}
};
String text = ext == ".nb.html" ? "Preview Notebook" : prefix + options.get(i);
MenuItem item = ImageMenuItem.create(img, text, cmd, 2);
rmdFormatButton_.addMenuItem(item, values.get(i));
}
if (session_.getSessionInfo().getKnitParamsAvailable()) {
final AppCommand knitWithParams = commands_.knitWithParameters();
rmdFormatButton_.addSeparator();
ScheduledCommand cmd = new ScheduledCommand() {
@Override
public void execute() {
knitWithParams.execute();
}
};
MenuItem item = new MenuItem(knitWithParams.getMenuHTML(false), true, cmd);
rmdFormatButton_.addMenuItem(item, knitWithParams.getMenuLabel(false));
}
if (session_.getSessionInfo().getKnitWorkingDirAvailable()) {
MenuBar knitDirMenu = new MenuBar(true);
DocPropMenuItem knitInDocDir = new DocShadowPropMenuItem("Document Directory", docUpdateSentinel_, uiPrefs_.knitWorkingDir(), RenderRmdEvent.WORKING_DIR_PROP, UIPrefsAccessor.KNIT_DIR_DEFAULT);
knitDirMenu.addItem(knitInDocDir);
DocPropMenuItem knitInProjectDir = new DocShadowPropMenuItem("Project Directory", docUpdateSentinel_, uiPrefs_.knitWorkingDir(), RenderRmdEvent.WORKING_DIR_PROP, UIPrefsAccessor.KNIT_DIR_PROJECT);
knitDirMenu.addItem(knitInProjectDir);
DocPropMenuItem knitInCurrentDir = new DocShadowPropMenuItem("Current Working Directory", docUpdateSentinel_, uiPrefs_.knitWorkingDir(), RenderRmdEvent.WORKING_DIR_PROP, UIPrefsAccessor.KNIT_DIR_CURRENT);
knitDirMenu.addItem(knitInCurrentDir);
rmdFormatButton_.addSeparator();
rmdFormatButton_.addMenuItem(knitDirMenu, "Knit Directory");
}
addClearKnitrCacheMenu(rmdFormatButton_);
showRmdViewerMenuItems(true, canEditFormatOptions, fileType.isRmd(), RmdOutput.TYPE_STATIC);
if (publishButton_ != null)
publishButton_.setIsStatic(true);
isShiny_ = false;
}
use of org.rstudio.studio.client.rmarkdown.events.RmdOutputFormatChangedEvent 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();
}
Aggregations