+++ /dev/null
-package com.jetbrains.edu.coursecreator;
-
-import com.intellij.openapi.editor.Document;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.editor.RangeMarker;
-import com.intellij.openapi.editor.colors.EditorColorsManager;
-import com.intellij.openapi.editor.colors.EditorColorsScheme;
-import com.intellij.openapi.editor.impl.DocumentImpl;
-import com.intellij.openapi.editor.markup.*;
-import com.intellij.openapi.project.Project;
-import com.intellij.ui.JBColor;
-import com.jetbrains.edu.courseFormat.AnswerPlaceholder;
-import com.jetbrains.edu.courseFormat.TaskFile;
-import org.jetbrains.annotations.NotNull;
-
-import java.awt.*;
-import java.util.List;
-
-public class CCAnswerPlaceholderPainter {
- private CCAnswerPlaceholderPainter() {
-
- }
-
- public static void drawHighlighter(@NotNull final AnswerPlaceholder placeholder, @NotNull final Editor editor, boolean useLength) {
- drawAnswerPlaceholder(editor, placeholder, useLength, JBColor.BLUE);
- //int startOffset = placeholder.getRealStartOffset(editor.getDocument());
- //final int length = placeholder.getLength();
- //final int replacementLength = placeholder.getPossibleAnswer().length();
- //int highlighterLength = useLength ? length : replacementLength;
- //int endOffset = startOffset + highlighterLength;
- //TextAttributes defaultTestAttributes =
- // EditorColorsManager.getInstance().getGlobalScheme().getAttributes(EditorColors.LIVE_TEMPLATE_ATTRIBUTES);
- //defaultTestAttributes.setEffectColor(JBColor.BLUE);
- //RangeHighlighter highlighter =
- // editor.getMarkupModel().addRangeHighlighter(startOffset, endOffset, HighlighterLayer.LAST + 1, defaultTestAttributes,
- // HighlighterTargetArea.EXACT_RANGE);
- //highlighter.setGreedyToLeft(true);
- //highlighter.setGreedyToRight(true);
- }
-
-
-
- public static void drawAnswerPlaceholder(@NotNull final Editor editor, @NotNull final AnswerPlaceholder placeholder, boolean useLength,
- @NotNull final JBColor color) {
- Document document = editor.getDocument();
- if (useLength && !placeholder.isValid(document)) {
- return;
- }
- EditorColorsScheme scheme = EditorColorsManager.getInstance().getGlobalScheme();
- final TextAttributes defaultTestAttributes = new TextAttributes(scheme.getDefaultForeground(), scheme.getDefaultBackground(), null,
- EffectType.BOXED, Font.PLAIN);
- final Project project = editor.getProject();
- assert project != null;
- int startOffset = placeholder.getRealStartOffset(document);
- final int length = placeholder.getLength();
- final int replacementLength = placeholder.getPossibleAnswerLength();
- int highlighterLength = useLength ? length : replacementLength;
- int endOffset = startOffset + highlighterLength;
- RangeHighlighter
- highlighter = editor.getMarkupModel().addRangeHighlighter(startOffset, endOffset, HighlighterLayer.LAST + 1,
- defaultTestAttributes, HighlighterTargetArea.EXACT_RANGE);
- highlighter.setCustomRenderer(new CustomHighlighterRenderer() {
- @Override
- public void paint(@NotNull Editor editor, @NotNull RangeHighlighter highlighter, @NotNull Graphics g) {
- g.setColor(color);
- Point point = editor.logicalPositionToXY(editor.offsetToLogicalPosition(highlighter.getStartOffset()));
- Point pointEnd = editor.logicalPositionToXY(editor.offsetToLogicalPosition(highlighter.getEndOffset()));
- g.drawRect(point.x, point.y - 2, (pointEnd.x - point.x), editor.getLineHeight() + 1);
- }
- });
- editor.getCaretModel().moveToOffset(startOffset);
- highlighter.setGreedyToLeft(true);
- highlighter.setGreedyToRight(true);
- }
-
- /*
- public static void drawAnswerPlaceholder(@NotNull final Editor editor, AnswerPlaceholder answerPlaceholder) {
- Document document = editor.getDocument();
- if (!answerPlaceholder.isValid(document)) {
- return;
- }
- EditorColorsScheme scheme = EditorColorsManager.getInstance().getGlobalScheme();
- final TextAttributes defaultTestAttributes = new TextAttributes(scheme.getDefaultForeground(), scheme.getDefaultBackground(), null,
- EffectType.BOXED, Font.PLAIN);
- final Project project = editor.getProject();
- assert project != null;
- final JBColor color = StudyTaskManager.getInstance(project).getColor(answerPlaceholder);
- int startOffset = answerPlaceholder.getRealStartOffset(document);
- RangeHighlighter
- highlighter = editor.getMarkupModel().addRangeHighlighter(startOffset, startOffset + answerPlaceholder.getLength(), HighlighterLayer.LAST + 1,
- defaultTestAttributes, HighlighterTargetArea.EXACT_RANGE);
- highlighter.setCustomRenderer(new CustomHighlighterRenderer() {
- @Override
- public void paint(@NotNull Editor editor, @NotNull RangeHighlighter highlighter, @NotNull Graphics g) {
- g.setColor(color);
- Point point = editor.logicalPositionToXY(editor.offsetToLogicalPosition(highlighter.getStartOffset()));
- Point pointEnd = editor.logicalPositionToXY(editor.offsetToLogicalPosition(highlighter.getEndOffset()));
- g.drawRect(point.x, point.y - 2, (pointEnd.x - point.x), editor.getLineHeight() + 1);
- }
- });
- editor.getCaretModel().moveToOffset(startOffset);
- highlighter.setGreedyToLeft(true);
- highlighter.setGreedyToRight(true);
- }
-
-/*
- public static void drawAllWindows(Editor editor, TaskFile taskFile) {
- editor.getMarkupModel().removeAllHighlighters();
- for (AnswerPlaceholder answerPlaceholder : taskFile.getAnswerPlaceholders()) {
- drawAnswerPlaceholder(editor, answerPlaceholder);
- }
- final Document document = editor.getDocument();
- EditorActionManager.getInstance()
- .setReadonlyFragmentModificationHandler(document, new TaskWindowDeleteHandler(editor));
- createGuardedBlocks(editor, taskFile);
- editor.getColorsScheme().setColor(EditorColors.READONLY_FRAGMENT_BACKGROUND_COLOR, null);
- }
-
-
- *//**
- * Marks symbols adjacent to task windows as read-only fragments
- *//*
- public static void createGuardedBlocks(@NotNull final Editor editor, TaskFile taskFile) {
- final Document document = editor.getDocument();
- if (document instanceof DocumentImpl) {
- DocumentImpl documentImpl = (DocumentImpl)document;
- List<RangeMarker> blocks = documentImpl.getGuardedBlocks();
- for (AnswerPlaceholder answerPlaceholder : taskFile.getAnswerPlaceholders()) {
- if (!answerPlaceholder.isValid(document)) {
- return;
- }
- int start = answerPlaceholder.getRealStartOffset(document);
- int end = start + answerPlaceholder.getLength();
- if (start != 0) {
- createGuardedBlock(editor, blocks, start - 1, start);
- }
- if (end != document.getTextLength()) {
- createGuardedBlock(editor, blocks, end, end + 1);
- }
- }
- }
- }
-*/
-
- public static void createGuardedBlock(Editor editor, List<RangeMarker> blocks, int start, int end) {
- RangeHighlighter rh = editor.getMarkupModel()
- .addRangeHighlighter(start, end, HighlighterLayer.LAST + 1, null, HighlighterTargetArea.EXACT_RANGE);
- blocks.add(rh);
- }
-
-
- public static void createGuardedBlocks(@NotNull final Editor editor, TaskFile taskFile) {
- for (AnswerPlaceholder answerPlaceholder : taskFile.getAnswerPlaceholders()) {
- createGuardedBlocks(editor, answerPlaceholder);
- }
- }
-
- public static void createGuardedBlocks(@NotNull final Editor editor, AnswerPlaceholder placeholder) {
- Document document = editor.getDocument();
- if (document instanceof DocumentImpl) {
- DocumentImpl documentImpl = (DocumentImpl)document;
- java.util.List<RangeMarker> blocks = documentImpl.getGuardedBlocks();
- int start = placeholder.getRealStartOffset(document);
- int end = start + placeholder.getPossibleAnswer().length();
- if (start != 0) {
- createGuardedBlock(editor, blocks, start - 1, start);
- }
- if (end != document.getTextLength()) {
- createGuardedBlock(editor, blocks, end, end + 1);
- }
- }
- }
-
-}
package com.jetbrains.edu.coursecreator;
-import com.intellij.codeInsight.hint.HintManager;
import com.intellij.openapi.editor.Document;
import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.editor.ReadOnlyFragmentModificationException;
import com.intellij.openapi.editor.actionSystem.EditorActionManager;
-import com.intellij.openapi.editor.actionSystem.ReadonlyFragmentModificationHandler;
import com.intellij.openapi.editor.colors.EditorColors;
import com.intellij.openapi.editor.event.EditorFactoryEvent;
import com.intellij.openapi.editor.event.EditorFactoryListener;
import com.intellij.openapi.fileEditor.FileDocumentManager;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.vfs.VirtualFile;
+import com.jetbrains.edu.EduAnswerPlaceholderPainter;
+import com.jetbrains.edu.EduTaskWindowDeleteHandler;
import com.jetbrains.edu.courseFormat.Course;
import com.jetbrains.edu.courseFormat.TaskFile;
import org.jetbrains.annotations.NotNull;
CCProjectService.addDocumentListener(editor.getDocument(), listener);
editor.getDocument().addDocumentListener(listener);
EditorActionManager.getInstance()
- .setReadonlyFragmentModificationHandler(editor.getDocument(), new TaskWindowDeleteHandler(editor));
+ .setReadonlyFragmentModificationHandler(editor.getDocument(), new EduTaskWindowDeleteHandler(editor));
service.drawTaskWindows(virtualFile, editor);
editor.getColorsScheme().setColor(EditorColors.READONLY_FRAGMENT_BACKGROUND_COLOR, null);
- CCAnswerPlaceholderPainter.createGuardedBlocks(editor, taskFile);
+ EduAnswerPlaceholderPainter.createGuardedBlocks(editor, taskFile, false);
}
@Override
}
}
- private static class TaskWindowDeleteHandler implements ReadonlyFragmentModificationHandler {
-
- private final Editor myEditor;
-
- public TaskWindowDeleteHandler(@NotNull final Editor editor) {
- myEditor = editor;
- }
-
- @Override
- public void handle(ReadOnlyFragmentModificationException e) {
- HintManager.getInstance().showErrorHint(myEditor, "Delete answer placeholder before editing its borders");
- }
- }
}
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.openapi.vfs.VirtualFileManager;
import com.intellij.psi.PsiDirectory;
+import com.intellij.ui.JBColor;
import com.intellij.util.xmlb.XmlSerializerUtil;
+import com.jetbrains.edu.EduAnswerPlaceholderPainter;
import com.jetbrains.edu.courseFormat.*;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
}
List<AnswerPlaceholder> answerPlaceholders = taskFile.getAnswerPlaceholders();
for (AnswerPlaceholder answerPlaceholder : answerPlaceholders) {
- CCAnswerPlaceholderPainter.drawHighlighter(answerPlaceholder, editor, false);
+ EduAnswerPlaceholderPainter.drawAnswerPlaceholder(editor, answerPlaceholder, false, JBColor.BLUE);
}
}
import com.intellij.psi.PsiDirectory;
import com.intellij.psi.PsiDocumentManager;
import com.intellij.psi.PsiFile;
+import com.intellij.ui.JBColor;
+import com.jetbrains.edu.EduAnswerPlaceholderPainter;
import com.jetbrains.edu.courseFormat.AnswerPlaceholder;
import com.jetbrains.edu.courseFormat.Lesson;
import com.jetbrains.edu.courseFormat.Task;
import com.jetbrains.edu.courseFormat.TaskFile;
-import com.jetbrains.edu.coursecreator.CCAnswerPlaceholderPainter;
import com.jetbrains.edu.coursecreator.CCProjectService;
import com.jetbrains.edu.coursecreator.ui.CreateTaskWindowDialog;
import org.jetbrains.annotations.NotNull;
answerPlaceholder.setIndex(index);
taskFile.addAnswerPlaceholder(answerPlaceholder);
taskFile.sortAnswerPlaceholders();
- CCAnswerPlaceholderPainter.drawHighlighter(answerPlaceholder, editor, false);
- CCAnswerPlaceholderPainter.createGuardedBlocks(editor, answerPlaceholder);
+ EduAnswerPlaceholderPainter.drawAnswerPlaceholder(editor, answerPlaceholder, false, JBColor.BLUE);
+ EduAnswerPlaceholderPainter.createGuardedBlocks(editor, answerPlaceholder, false);
}
@Override
import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiDocumentManager;
import com.intellij.psi.PsiFile;
+import com.jetbrains.edu.EduAnswerPlaceholderPainter;
import com.jetbrains.edu.courseFormat.AnswerPlaceholder;
import com.jetbrains.edu.courseFormat.TaskFile;
-import com.jetbrains.edu.coursecreator.CCAnswerPlaceholderPainter;
import com.jetbrains.edu.coursecreator.CCProjectService;
import org.jetbrains.annotations.NotNull;
final Editor editor = state.getEditor();
editor.getMarkupModel().removeAllHighlighters();
CCProjectService.getInstance(project).drawTaskWindows(psiFile.getVirtualFile(), editor);
- CCAnswerPlaceholderPainter.createGuardedBlocks(editor, taskFile);
+ EduAnswerPlaceholderPainter.createGuardedBlocks(editor, taskFile, false);
}
}
}
\ No newline at end of file
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.PsiDirectory;
import com.intellij.psi.PsiFile;
+import com.intellij.ui.JBColor;
+import com.jetbrains.edu.EduAnswerPlaceholderPainter;
import com.jetbrains.edu.courseFormat.AnswerPlaceholder;
import com.jetbrains.edu.courseFormat.Course;
import com.jetbrains.edu.courseFormat.Task;
import com.jetbrains.edu.courseFormat.TaskFile;
-import com.jetbrains.edu.coursecreator.CCAnswerPlaceholderPainter;
import com.jetbrains.edu.coursecreator.CCProjectService;
import org.jetbrains.annotations.NotNull;
}
});
for (AnswerPlaceholder answerPlaceholder : taskFile.getAnswerPlaceholders()) {
- CCAnswerPlaceholderPainter.drawHighlighter(answerPlaceholder, createdEditor, true);
+ EduAnswerPlaceholderPainter.drawAnswerPlaceholder(createdEditor, answerPlaceholder, true, JBColor.BLUE);
}
JPanel header = new JPanel();
header.setLayout(new BoxLayout(header, BoxLayout.Y_AXIS));
<orderEntry type="sourceFolder" forTests="false" />
<orderEntry type="module" module-name="platform-api" />
<orderEntry type="library" name="gson" level="project" />
+ <orderEntry type="module" module-name="core-impl" />
</component>
</module>
\ No newline at end of file
import com.intellij.openapi.vfs.VirtualFileEvent;
import com.intellij.openapi.vfs.VirtualFileManager;
import com.intellij.openapi.wm.*;
-import com.jetbrains.edu.StudyNames;
+import com.jetbrains.edu.EduNames;
import com.jetbrains.edu.courseFormat.Course;
import com.jetbrains.edu.courseFormat.Lesson;
import com.jetbrains.edu.courseFormat.Task;
if (file.getName().equals(testHelper)) {
copyFile(file, new File(myProject.getBasePath(), testHelper));
}
- if (file.getName().startsWith(StudyNames.LESSON)) {
+ if (file.getName().startsWith(EduNames.LESSON)) {
final File[] tasks = file.listFiles();
if (tasks == null) continue;
for (File task : tasks) {
- final File taskDescr = new File(task, StudyNames.TASK_HTML);
+ final File taskDescr = new File(task, EduNames.TASK_HTML);
String testFileName = manager.getTestFileName();
final File taskTests = new File(task, testFileName);
- copyFile(taskDescr, new File(new File(new File(myProject.getBasePath(), file.getName()), task.getName()), StudyNames.TASK_HTML));
+ copyFile(taskDescr, new File(new File(new File(myProject.getBasePath(), file.getName()), task.getName()), EduNames.TASK_HTML));
copyFile(taskTests, new File(new File(new File(myProject.getBasePath(), file.getName()), task.getName()),
testFileName));
}
final VirtualFile createdFile = event.getFile();
final VirtualFile taskDir = createdFile.getParent();
final Course course = StudyTaskManager.getInstance(myProject).getCourse();
- if (taskDir != null && taskDir.getName().contains(StudyNames.TASK_DIR)) {
- int taskIndex = StudyUtils.getIndex(taskDir.getName(), StudyNames.TASK_DIR);
+ if (taskDir != null && taskDir.getName().contains(EduNames.TASK_DIR)) {
+ int taskIndex = StudyUtils.getIndex(taskDir.getName(), EduNames.TASK_DIR);
final VirtualFile lessonDir = taskDir.getParent();
- if (lessonDir != null && lessonDir.getName().contains(StudyNames.LESSON_DIR)) {
- int lessonIndex = StudyUtils.getIndex(lessonDir.getName(), StudyNames.LESSON_DIR);
+ if (lessonDir != null && lessonDir.getName().contains(EduNames.LESSON_DIR)) {
+ int lessonIndex = StudyUtils.getIndex(lessonDir.getName(), EduNames.LESSON_DIR);
if (course != null) {
List<Lesson> lessons = course.getLessons();
if (StudyUtils.indexIsValid(lessonIndex, lessons)) {
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.editor.Document;
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.editor.actionSystem.EditorActionManager;
+import com.intellij.openapi.editor.colors.EditorColors;
import com.intellij.openapi.fileEditor.FileDocumentManager;
import com.intellij.openapi.fileEditor.FileEditor;
import com.intellij.openapi.fileEditor.FileEditorManager;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.openapi.vfs.VirtualFileManager;
import com.intellij.openapi.wm.ToolWindowManager;
+import com.intellij.ui.JBColor;
import com.intellij.util.ui.UIUtil;
-import com.jetbrains.edu.StudyNames;
+import com.jetbrains.edu.EduAnswerPlaceholderPainter;
+import com.jetbrains.edu.EduNames;
+import com.jetbrains.edu.EduTaskWindowDeleteHandler;
import com.jetbrains.edu.courseFormat.*;
import com.jetbrains.edu.learning.editor.StudyEditor;
import com.jetbrains.edu.learning.run.StudyExecutor;
int taskNum = task.getIndex() + 1;
int lessonNum = task.getLesson().getIndex() + 1;
assert course != null;
- final String pathToResource = FileUtil.join(course.getCourseDirectory(), StudyNames.LESSON_DIR + lessonNum, StudyNames.TASK_DIR + taskNum);
+ final String pathToResource = FileUtil.join(course.getCourseDirectory(), EduNames.LESSON_DIR + lessonNum, EduNames.TASK_DIR + taskNum);
final File resourceFile = new File(pathToResource, copyName);
FileUtil.copy(new File(pathToResource, sourceName), resourceFile);
return resourceFile;
return null;
}
final String taskDirName = taskDir.getName();
- if (taskDirName.contains(StudyNames.TASK_DIR)) {
+ if (taskDirName.contains(EduNames.TASK_DIR)) {
final VirtualFile lessonDir = taskDir.getParent();
if (lessonDir != null) {
- int lessonIndex = getIndex(lessonDir.getName(), StudyNames.LESSON_DIR);
+ int lessonIndex = getIndex(lessonDir.getName(), EduNames.LESSON_DIR);
List<Lesson> lessons = course.getLessons();
if (!indexIsValid(lessonIndex, lessons)) {
return null;
}
final Lesson lesson = lessons.get(lessonIndex);
- int taskIndex = getIndex(taskDirName, StudyNames.TASK_DIR);
+ int taskIndex = getIndex(taskDirName, EduNames.TASK_DIR);
final List<Task> tasks = lesson.getTaskList();
if (!indexIsValid(taskIndex, tasks)) {
return null;
}
return null;
}
+
+
+ public static void drawAllWindows(Editor editor, TaskFile taskFile) {
+ editor.getMarkupModel().removeAllHighlighters();
+ final Project project = editor.getProject();
+ if (project == null) return;
+ final StudyTaskManager taskManager = StudyTaskManager.getInstance(project);
+ for (AnswerPlaceholder answerPlaceholder : taskFile.getAnswerPlaceholders()) {
+ final JBColor color = taskManager.getColor(answerPlaceholder);
+ EduAnswerPlaceholderPainter.drawAnswerPlaceholder(editor, answerPlaceholder, true, color);
+ }
+ final Document document = editor.getDocument();
+ EditorActionManager.getInstance()
+ .setReadonlyFragmentModificationHandler(document, new EduTaskWindowDeleteHandler(editor));
+ EduAnswerPlaceholderPainter.createGuardedBlocks(editor, taskFile, true);
+ editor.getColorsScheme().setColor(EditorColors.READONLY_FRAGMENT_BACKGROUND_COLOR, null);
+ }
+
}
import com.jetbrains.edu.courseFormat.AnswerPlaceholder;
import com.jetbrains.edu.courseFormat.Task;
import com.jetbrains.edu.courseFormat.TaskFile;
-import com.jetbrains.edu.learning.*;
+import com.jetbrains.edu.learning.StudyDocumentListener;
+import com.jetbrains.edu.learning.StudyState;
+import com.jetbrains.edu.learning.StudyTaskManager;
+import com.jetbrains.edu.learning.StudyUtils;
import com.jetbrains.edu.learning.courseFormat.StudyStatus;
import com.jetbrains.edu.learning.editor.StudyEditor;
import com.jetbrains.edu.learning.navigation.StudyNavigator;
FileEditor fileEditor = FileEditorManager.getInstance(project).getSelectedEditor(virtualFile);
if (fileEditor instanceof StudyEditor) {
StudyEditor studyEditor = (StudyEditor)fileEditor;
- StudyAnswerPlaceholderPainter.drawAllWindows(studyEditor.getEditor(), taskFile);
+ StudyUtils.drawAllWindows(studyEditor.getEditor(), taskFile);
}
}
}
import com.intellij.ui.tabs.TabsListener;
import com.intellij.ui.tabs.impl.JBEditorTabs;
import com.intellij.util.PlatformIcons;
-import com.jetbrains.edu.StudyNames;
+import com.jetbrains.edu.EduNames;
import com.jetbrains.edu.courseFormat.Task;
import com.jetbrains.edu.courseFormat.TaskFile;
import com.jetbrains.edu.learning.StudyTaskManager;
if (newSelection.getIcon() != null) {
int tabCount = tabbedPane.getTabCount();
VirtualFile taskDir = openedFile.getParent();
- VirtualFile testsDir = taskDir.findChild(StudyNames.USER_TESTS);
+ VirtualFile testsDir = taskDir.findChild(EduNames.USER_TESTS);
assert testsDir != null;
UserTest userTest = createUserTest(testsDir, currentTask, studyTaskManager);
userTest.setEditable(true);
UserTest userTest = new UserTest();
List<UserTest> userTests = studyTaskManager.getUserTests(currentTask);
int testNum = userTests.size() + 1;
- String inputName = StudyNames.USER_TEST_INPUT + testNum;
+ String inputName = EduNames.USER_TEST_INPUT + testNum;
File inputFile = new File(testsDir.getPath(), inputName);
- String outputName = StudyNames.USER_TEST_OUTPUT + testNum;
+ String outputName = EduNames.USER_TEST_OUTPUT + testNum;
File outputFile = new File(testsDir.getPath(), outputName);
userTest.setInput(inputFile.getPath());
userTest.setOutput(outputFile.getPath());
private TabInfo addTestTab(int nameIndex, final StudyTestContentPanel contentPanel, @NotNull final Task currentTask, boolean toBeClosable) {
TabInfo testTab = toBeClosable ? createClosableTab(contentPanel, currentTask) : new TabInfo(contentPanel);
- return testTab.setText(StudyNames.TEST_TAB_NAME + String.valueOf(nameIndex));
+ return testTab.setText(EduNames.TEST_TAB_NAME + String.valueOf(nameIndex));
}
private TabInfo createClosableTab(StudyTestContentPanel contentPanel, Task currentTask) {
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.openapi.wm.IdeFocusManager;
import com.intellij.problems.WolfTheProblemSolver;
-import com.jetbrains.edu.StudyNames;
+import com.jetbrains.edu.EduAnswerPlaceholderPainter;
+import com.jetbrains.edu.EduNames;
import com.jetbrains.edu.courseFormat.AnswerPlaceholder;
import com.jetbrains.edu.courseFormat.Course;
import com.jetbrains.edu.courseFormat.Task;
import com.jetbrains.edu.courseFormat.TaskFile;
-import com.jetbrains.edu.learning.StudyAnswerPlaceholderPainter;
import com.jetbrains.edu.learning.StudyState;
import com.jetbrains.edu.learning.StudyTaskManager;
import com.jetbrains.edu.learning.StudyUtils;
}
WolfTheProblemSolver.getInstance(project).clearProblems(studyState.getVirtualFile());
taskFile.setHighlightErrors(false);
- StudyAnswerPlaceholderPainter.drawAllWindows(editor, taskFile);
- StudyAnswerPlaceholderPainter.createGuardedBlocks(editor, taskFile);
+ StudyUtils.drawAllWindows(editor, taskFile);
+ EduAnswerPlaceholderPainter.createGuardedBlocks(editor, taskFile, true);
ApplicationManager.getApplication().invokeLater(new Runnable() {
@Override
public void run() {
taskFile.setTrackChanges(false);
clearDocument(document);
Task task = taskFile.getTask();
- String lessonDir = StudyNames.LESSON_DIR + String.valueOf(task.getLesson().getIndex() + 1);
- String taskDir = StudyNames.TASK_DIR + String.valueOf(task.getIndex() + 1);
+ String lessonDir = EduNames.LESSON_DIR + String.valueOf(task.getLesson().getIndex() + 1);
+ String taskDir = EduNames.TASK_DIR + String.valueOf(task.getIndex() + 1);
Course course = task.getLesson().getCourse();
File resourceFile = new File(course.getCourseDirectory());
if (!resourceFile.exists()) {
import com.intellij.openapi.wm.ToolWindowId;
import com.intellij.openapi.wm.ToolWindowManager;
import com.intellij.util.ui.tree.TreeUtil;
-import com.jetbrains.edu.StudyNames;
+import com.jetbrains.edu.EduNames;
import com.jetbrains.edu.courseFormat.Task;
import com.jetbrains.edu.courseFormat.TaskFile;
import com.jetbrains.edu.learning.StudyState;
return;
}
VirtualFile projectDir = project.getBaseDir();
- String lessonDirName = StudyNames.LESSON_DIR + String.valueOf(lessonIndex + 1);
+ String lessonDirName = EduNames.LESSON_DIR + String.valueOf(lessonIndex + 1);
if (projectDir == null) {
return;
}
if (lessonDir == null) {
return;
}
- String taskDirName = StudyNames.TASK_DIR + String.valueOf(nextTaskIndex + 1);
+ String taskDirName = EduNames.TASK_DIR + String.valueOf(nextTaskIndex + 1);
VirtualFile taskDir = lessonDir.findChild(taskDirName);
if (taskDir == null) {
return;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.openapi.vfs.VirtualFile;
-import com.jetbrains.edu.StudyNames;
+import com.jetbrains.edu.EduNames;
import com.jetbrains.edu.courseFormat.*;
import com.jetbrains.edu.learning.StudyUtils;
import org.jetbrains.annotations.NotNull;
*/
public static void createTask(@NotNull final Task task, @NotNull final VirtualFile lessonDir, @NotNull final File resourceRoot,
@NotNull final Project project) throws IOException {
- VirtualFile taskDir = lessonDir.createChildDirectory(project, StudyNames.TASK_DIR + Integer.toString(task.getIndex() + 1));
+ VirtualFile taskDir = lessonDir.createChildDirectory(project, EduNames.TASK_DIR + Integer.toString(task.getIndex() + 1));
StudyUtils.markDirAsSourceRoot(taskDir, project);
File newResourceRoot = new File(resourceRoot, taskDir.getName());
int i = 0;
*/
public static void createLesson(@NotNull final Lesson lesson, @NotNull final VirtualFile courseDir, @NotNull final File resourceRoot,
@NotNull final Project project) throws IOException {
- String lessonDirName = StudyNames.LESSON_DIR + Integer.toString(lesson.getIndex() + 1);
+ String lessonDirName = EduNames.LESSON_DIR + Integer.toString(lesson.getIndex() + 1);
VirtualFile lessonDir = courseDir.createChildDirectory(project, lessonDirName);
final List<Task> taskList = lesson.getTaskList();
for (int i = 0; i < taskList.size(); i++) {
lesson.setIndex(i);
createLesson(lesson, baseDir, resourceRoot, project);
}
- baseDir.createChildDirectory(project, StudyNames.SANDBOX_DIR);
+ baseDir.createChildDirectory(project, EduNames.SANDBOX_DIR);
File[] files = resourceRoot.listFiles(new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
- return !name.contains(StudyNames.LESSON_DIR) && !name.equals("course.json") && !name.equals("hints");
+ return !name.contains(EduNames.LESSON_DIR) && !name.equals("course.json") && !name.equals("hints");
}
});
for (File file : files) {
import com.intellij.openapi.project.Project;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.problems.WolfTheProblemSolver;
+import com.intellij.ui.JBColor;
+import com.jetbrains.edu.EduAnswerPlaceholderPainter;
import com.jetbrains.edu.courseFormat.AnswerPlaceholder;
import com.jetbrains.edu.courseFormat.TaskFile;
-import com.jetbrains.edu.learning.StudyAnswerPlaceholderPainter;
import com.jetbrains.edu.learning.StudyDocumentListener;
+import com.jetbrains.edu.learning.StudyTaskManager;
import com.jetbrains.edu.learning.StudyUtils;
import com.jetbrains.edu.learning.navigation.StudyNavigator;
import org.jetbrains.annotations.NotNull;
final AnswerPlaceholder answerPlaceholder = myTaskFile.getAnswerPlaceholder(editor.getDocument(), pos);
if (answerPlaceholder != null) {
myTaskFile.setSelectedAnswerPlaceholder(answerPlaceholder);
- StudyAnswerPlaceholderPainter.drawAnswerPlaceholder(editor, answerPlaceholder);
+ final Project project = editor.getProject();
+ assert project != null;
+ final JBColor color = StudyTaskManager.getInstance(project).getColor(answerPlaceholder);
+ EduAnswerPlaceholderPainter.drawAnswerPlaceholder(editor, answerPlaceholder, true, color);
}
else {
- StudyAnswerPlaceholderPainter.drawAllWindows(editor, myTaskFile);
+ StudyUtils.drawAllWindows(editor, myTaskFile);
}
}
}
editor.addEditorMouseListener(new WindowSelectionListener(taskFile));
StudyEditor.addDocumentListener(document, new StudyDocumentListener(taskFile));
WolfTheProblemSolver.getInstance(project).clearProblems(openedFile);
- StudyAnswerPlaceholderPainter.drawAllWindows(editor, taskFile);
+ StudyUtils.drawAllWindows(editor, taskFile);
}
}
}
import com.intellij.psi.PsiElement;
import com.intellij.ui.JBColor;
import com.intellij.ui.SimpleTextAttributes;
-import com.jetbrains.edu.StudyNames;
+import com.jetbrains.edu.EduNames;
import com.jetbrains.edu.courseFormat.Course;
import com.jetbrains.edu.courseFormat.Lesson;
import com.jetbrains.edu.courseFormat.Task;
data.addText(" (" + valueName + ")", SimpleTextAttributes.GRAYED_ATTRIBUTES);
return;
}
- if (valueName.contains(StudyNames.TASK_DIR)) {
+ if (valueName.contains(EduNames.TASK_DIR)) {
TaskFile file = null;
for (PsiElement child : myValue.getChildren()) {
VirtualFile virtualFile = child.getContainingFile().getVirtualFile();
setStudyAttributes(task, data, task.getName());
}
}
- if (valueName.contains(StudyNames.LESSON_DIR)) {
- int lessonIndex = Integer.parseInt(valueName.substring(StudyNames.LESSON_DIR.length())) - 1;
+ if (valueName.contains(EduNames.LESSON_DIR)) {
+ int lessonIndex = Integer.parseInt(valueName.substring(EduNames.LESSON_DIR.length())) - 1;
Lesson lesson = course.getLessons().get(lessonIndex);
setStudyAttributes(lesson, data, lesson.getName());
}
- if (valueName.contains(StudyNames.SANDBOX_DIR)) {
+ if (valueName.contains(EduNames.SANDBOX_DIR)) {
if (myValue.getParent() != null) {
- if (!myValue.getParent().getName().contains(StudyNames.SANDBOX_DIR)) {
- data.setPresentableText(StudyNames.SANDBOX_DIR);
+ if (!myValue.getParent().getName().contains(EduNames.SANDBOX_DIR)) {
+ data.setPresentableText(EduNames.SANDBOX_DIR);
data.setIcon(InteractiveLearningIcons.Sandbox);
return;
}
@Override
public int getTypeSortWeight(boolean sortByType) {
String name = myValue.getName();
- if (name.contains(StudyNames.LESSON_DIR) || name.contains(StudyNames.TASK_DIR)) {
- String logicalName = name.contains(StudyNames.LESSON_DIR) ? StudyNames.LESSON_DIR : StudyNames.TASK_DIR;
+ if (name.contains(EduNames.LESSON_DIR) || name.contains(EduNames.TASK_DIR)) {
+ String logicalName = name.contains(EduNames.LESSON_DIR) ? EduNames.LESSON_DIR : EduNames.TASK_DIR;
return StudyUtils.getIndex(name, logicalName) + 1;
}
- return name.contains(StudyNames.SANDBOX_DIR) ? 0 : 3;
+ return name.contains(EduNames.SANDBOX_DIR) ? 0 : 3;
}
private void setStudyAttributes(Lesson lesson, PresentationData data, String additionalName) {
@Override
public void navigate(boolean requestFocus) {
- if (myValue.getName().contains(StudyNames.TASK_DIR)) {
+ if (myValue.getName().contains(EduNames.TASK_DIR)) {
TaskFile taskFile = null;
VirtualFile virtualFile = null;
for (PsiElement child : myValue.getChildren()) {
@Override
public boolean expandOnDoubleClick() {
- if (myValue.getName().contains(StudyNames.TASK_DIR)) {
+ if (myValue.getName().contains(EduNames.TASK_DIR)) {
return false;
}
return super.expandOnDoubleClick();
import com.intellij.openapi.project.Project;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.PsiDirectory;
-import com.jetbrains.edu.StudyNames;
+import com.jetbrains.edu.EduNames;
import com.jetbrains.edu.courseFormat.TaskFile;
import com.jetbrains.edu.learning.StudyTaskManager;
import com.jetbrains.edu.learning.StudyUtils;
if (project != null) {
if (node.getValue() instanceof PsiDirectory) {
final PsiDirectory nodeValue = (PsiDirectory)node.getValue();
- if (!nodeValue.getName().contains(StudyNames.USER_TESTS)) {
+ if (!nodeValue.getName().contains(EduNames.USER_TESTS)) {
StudyDirectoryNode newNode = new StudyDirectoryNode(project, nodeValue, settings);
nodes.add(newNode);
}
}
final String parentName = parent.getName();
if (parentName != null) {
- if (parentName.equals(StudyNames.SANDBOX_DIR)) {
+ if (parentName.equals(EduNames.SANDBOX_DIR)) {
nodes.add(node);
}
}
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.TextRange;
import com.intellij.openapi.vfs.VirtualFile;
-import com.jetbrains.edu.StudyNames;
+import com.jetbrains.edu.EduNames;
import com.jetbrains.edu.courseFormat.AnswerPlaceholder;
import com.jetbrains.edu.courseFormat.TaskFile;
import com.jetbrains.edu.learning.StudyDocumentListener;
try {
final int index = placeholder.getIndex();
final VirtualFile windowCopy =
- answerFile.copy(project, answerFile.getParent(), answerFile.getNameWithoutExtension() + index + StudyNames.WINDOW_POSTFIX);
+ answerFile.copy(project, answerFile.getParent(), answerFile.getNameWithoutExtension() + index + EduNames.WINDOW_POSTFIX);
final FileDocumentManager documentManager = FileDocumentManager.getInstance();
final Document windowDocument = documentManager.getDocument(windowCopy);
if (windowDocument != null) {
-package com.jetbrains.edu.learning;
+package com.jetbrains.edu;
import com.intellij.openapi.editor.Document;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.editor.RangeMarker;
-import com.intellij.openapi.editor.actionSystem.EditorActionManager;
-import com.intellij.openapi.editor.colors.EditorColors;
import com.intellij.openapi.editor.colors.EditorColorsManager;
import com.intellij.openapi.editor.colors.EditorColorsScheme;
import com.intellij.openapi.editor.impl.DocumentImpl;
import java.awt.*;
import java.util.List;
-public class StudyAnswerPlaceholderPainter {
- private StudyAnswerPlaceholderPainter() {
+public class EduAnswerPlaceholderPainter {
+ private EduAnswerPlaceholderPainter() {
}
- /**
- * Draw task window with color according to its status
- */
- public static void drawAnswerPlaceholder(@NotNull final Editor editor, AnswerPlaceholder answerPlaceholder) {
+ public static void drawAnswerPlaceholder(@NotNull final Editor editor, @NotNull final AnswerPlaceholder placeholder,
+ boolean useLength, @NotNull final JBColor color) {
Document document = editor.getDocument();
- if (!answerPlaceholder.isValid(document)) {
+ if (useLength && !placeholder.isValid(document)) {
return;
}
EditorColorsScheme scheme = EditorColorsManager.getInstance().getGlobalScheme();
EffectType.BOXED, Font.PLAIN);
final Project project = editor.getProject();
assert project != null;
- final JBColor color = StudyTaskManager.getInstance(project).getColor(answerPlaceholder);
- int startOffset = answerPlaceholder.getRealStartOffset(document);
+ int startOffset = placeholder.getRealStartOffset(document);
+ final int length = placeholder.getLength();
+ final int replacementLength = placeholder.getPossibleAnswerLength();
+ int highlighterLength = useLength ? length : replacementLength;
+ int endOffset = startOffset + highlighterLength;
RangeHighlighter
- highlighter = editor.getMarkupModel().addRangeHighlighter(startOffset, startOffset + answerPlaceholder.getLength(), HighlighterLayer.LAST + 1,
+ highlighter = editor.getMarkupModel().addRangeHighlighter(startOffset, endOffset, HighlighterLayer.LAST + 1,
defaultTestAttributes, HighlighterTargetArea.EXACT_RANGE);
highlighter.setCustomRenderer(new CustomHighlighterRenderer() {
@Override
highlighter.setGreedyToRight(true);
}
+ public static void createGuardedBlock(Editor editor, List<RangeMarker> blocks, int start, int end) {
+ RangeHighlighter rh = editor.getMarkupModel()
+ .addRangeHighlighter(start, end, HighlighterLayer.LAST + 1, null, HighlighterTargetArea.EXACT_RANGE);
+ blocks.add(rh);
+ }
- public static void drawAllWindows(Editor editor, TaskFile taskFile) {
- editor.getMarkupModel().removeAllHighlighters();
+
+ public static void createGuardedBlocks(@NotNull final Editor editor, TaskFile taskFile, boolean useLength) {
for (AnswerPlaceholder answerPlaceholder : taskFile.getAnswerPlaceholders()) {
- drawAnswerPlaceholder(editor, answerPlaceholder);
+ createGuardedBlocks(editor, answerPlaceholder, useLength);
}
- final Document document = editor.getDocument();
- EditorActionManager.getInstance()
- .setReadonlyFragmentModificationHandler(document, new TaskWindowDeleteHandler(editor));
- createGuardedBlocks(editor, taskFile);
- editor.getColorsScheme().setColor(EditorColors.READONLY_FRAGMENT_BACKGROUND_COLOR, null);
}
-
- /**
- * Marks symbols adjacent to task windows as read-only fragments
- */
- public static void createGuardedBlocks(@NotNull final Editor editor, TaskFile taskFile) {
- final Document document = editor.getDocument();
+ public static void createGuardedBlocks(@NotNull final Editor editor, AnswerPlaceholder placeholder, boolean useLength) {
+ Document document = editor.getDocument();
if (document instanceof DocumentImpl) {
DocumentImpl documentImpl = (DocumentImpl)document;
List<RangeMarker> blocks = documentImpl.getGuardedBlocks();
- for (AnswerPlaceholder answerPlaceholder : taskFile.getAnswerPlaceholders()) {
- if (!answerPlaceholder.isValid(document)) {
- return;
- }
- int start = answerPlaceholder.getRealStartOffset(document);
- int end = start + answerPlaceholder.getLength();
- if (start != 0) {
- createGuardedBlock(editor, blocks, start - 1, start);
- }
- if (end != document.getTextLength()) {
- createGuardedBlock(editor, blocks, end, end + 1);
- }
+ if (useLength && !placeholder.isValid(document)) return;
+ int start = placeholder.getRealStartOffset(document);
+ final int length = useLength ? placeholder.getLength() : placeholder.getPossibleAnswerLength();
+ int end = start + length;
+ if (start != 0) {
+ createGuardedBlock(editor, blocks, start - 1, start);
+ }
+ if (end != document.getTextLength()) {
+ createGuardedBlock(editor, blocks, end, end + 1);
}
}
}
- private static void createGuardedBlock(Editor editor, List<RangeMarker> blocks, int start, int end) {
- RangeHighlighter rh = editor.getMarkupModel()
- .addRangeHighlighter(start, end, HighlighterLayer.LAST + 1, null, HighlighterTargetArea.EXACT_RANGE);
- blocks.add(rh);
- }
-
-
}
import org.jetbrains.annotations.NonNls;
@NonNls
-public class StudyNames {
+public class EduNames {
public static final String TASK_HTML = "task.html";
public static final String TASK_TESTS = "tests.py";
public static final String LESSON = "lesson";
public static final String USER_TESTS = "userTests";
public static final String SANDBOX_DIR = "Sandbox";
- private StudyNames() {
+ private EduNames() {
}
}
-package com.jetbrains.edu.learning;
+package com.jetbrains.edu;
import com.intellij.codeInsight.hint.HintManager;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.editor.actionSystem.ReadonlyFragmentModificationHandler;
import org.jetbrains.annotations.NotNull;
-public class TaskWindowDeleteHandler implements ReadonlyFragmentModificationHandler {
+public class EduTaskWindowDeleteHandler implements ReadonlyFragmentModificationHandler {
private final Editor myEditor;
- public TaskWindowDeleteHandler(@NotNull final Editor editor) {
+ public EduTaskWindowDeleteHandler(@NotNull final Editor editor) {
myEditor = editor;
}
import com.intellij.openapi.project.Project;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.util.xmlb.annotations.Transient;
-import com.jetbrains.edu.StudyNames;
+import com.jetbrains.edu.EduNames;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@Nullable
public VirtualFile getTaskDir(Project project) {
- String lessonDirName = StudyNames.LESSON_DIR + String.valueOf(myLesson.getIndex() + 1);
- String taskDirName = StudyNames.TASK_DIR + String.valueOf(myIndex + 1);
+ String lessonDirName = EduNames.LESSON_DIR + String.valueOf(myLesson.getIndex() + 1);
+ String taskDirName = EduNames.TASK_DIR + String.valueOf(myIndex + 1);
VirtualFile courseDir = project.getBaseDir();
if (courseDir != null) {
VirtualFile lessonDir = courseDir.findChild(lessonDirName);