python/src/com/jetbrains/python/module/PyContentEntriesEditor.java - platform/tools/idea - Git at Google

 /*
  * Copyright 2000-2013 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.jetbrains.python.module;

 import com.intellij.openapi.Disposable;
 import com.intellij.openapi.actionSystem.AnActionEvent;
 import com.intellij.openapi.actionSystem.CustomShortcutSet;
 import com.intellij.openapi.actionSystem.Presentation;
 import com.intellij.openapi.module.Module;
 import com.intellij.openapi.options.ConfigurationException;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.roots.ContentEntry;
 import com.intellij.openapi.roots.ContentFolder;
 import com.intellij.openapi.roots.ModifiableRootModel;
 import com.intellij.openapi.roots.impl.ContentEntryImpl;
 import com.intellij.openapi.roots.impl.ContentFolderBaseImpl;
 import com.intellij.openapi.roots.ui.configuration.*;
 import com.intellij.openapi.roots.ui.configuration.actions.ContentEntryEditingAction;
 import com.intellij.openapi.util.Comparing;
 import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.vfs.VfsUtilCore;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.openapi.vfs.pointers.VirtualFilePointer;
 import com.intellij.openapi.vfs.pointers.VirtualFilePointerListener;
 import com.intellij.openapi.vfs.pointers.VirtualFilePointerManager;
 import com.intellij.ui.JBColor;
 import com.intellij.util.EventDispatcher;
 import com.intellij.util.containers.MultiMap;
 import com.jetbrains.python.templateLanguages.TemplatesService;
 import icons.PythonIcons;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jps.model.module.JpsModuleSourceRootType;

 import javax.swing.*;
 import javax.swing.event.ChangeEvent;
 import javax.swing.event.ChangeListener;
 import javax.swing.tree.TreeCellRenderer;
 import java.awt.*;
 import java.awt.event.InputEvent;
 import java.awt.event.KeyEvent;
 import java.util.ArrayList;
 import java.util.List;

 public class PyContentEntriesEditor extends CommonContentEntriesEditor {
   private static final Color TEMPLATES_COLOR = JBColor.MAGENTA;
   private final MultiMap<ContentEntry, VirtualFilePointer> myTemplateRoots = new MultiMap<ContentEntry, VirtualFilePointer>();
   private final Module myModule;
   private Disposable myFilePointersDisposable;

   private final VirtualFilePointerListener DUMMY_LISTENER = new VirtualFilePointerListener() {
     @Override
     public void beforeValidityChanged(@NotNull VirtualFilePointer[] pointers) {
     }

     @Override
     public void validityChanged(@NotNull VirtualFilePointer[] pointers) {
     }
   };

   public PyContentEntriesEditor(Module module, ModuleConfigurationState moduleConfigurationState,
                                       JpsModuleSourceRootType<?>... rootTypes) {
     super(module.getName(), moduleConfigurationState, rootTypes);
     myModule = module;
     reset();
   }

   @Override
   protected ContentEntryTreeEditor createContentEntryTreeEditor(Project project) {
     return new MyContentEntryTreeEditor(project, getEditHandlers());
   }

   @Override
   protected List<ContentEntry> addContentEntries(VirtualFile[] files) {
     List<ContentEntry> entries = super.addContentEntries(files);
     addContentEntryPanels(entries.toArray(new ContentEntry[entries.size()]));
     return entries;
   }

   @Override
   public void reset() {
     if (myFilePointersDisposable != null) {
       Disposer.dispose(myFilePointersDisposable);
     }
     myTemplateRoots.clear();

     myFilePointersDisposable = Disposer.newDisposable();
     final TemplatesService instance = TemplatesService.getInstance(myModule);
     if (instance != null) {
       final List<VirtualFile> folders = instance.getTemplateFolders();
       for (VirtualFile folder : folders) {
         ContentEntry contentEntry = findContentEntryForFile(folder);
         if (contentEntry != null) {
           myTemplateRoots.putValue(contentEntry, VirtualFilePointerManager.getInstance().create(folder, myFilePointersDisposable,
                                                                                                 DUMMY_LISTENER));
         }
       }
     }

     if (myRootTreeEditor != null) {
       ContentEntryEditor editor = myRootTreeEditor.getContentEntryEditor();
       if(editor!=null) editor.update();
       myRootTreeEditor.update();
     }
   }

   @Nullable
   private ContentEntry findContentEntryForFile(VirtualFile virtualFile) {
     for (ContentEntry contentEntry : getModel().getContentEntries()) {
       final VirtualFile file = contentEntry.getFile();
       if (file != null && VfsUtilCore.isAncestor(file, virtualFile, false)) {
         return contentEntry;
       }
     }
     return null;
   }

   @Override
   public void disposeUIResources() {
     super.disposeUIResources();
     if (myFilePointersDisposable != null) {
       Disposer.dispose(myFilePointersDisposable);
     }
   }

   @Override
   public void apply() throws ConfigurationException {
     super.apply();
     List<VirtualFile> templateRoots = getCurrentState();
     TemplatesService.getInstance(myModule).setTemplateFolders(templateRoots.toArray(new VirtualFile[templateRoots.size()]));
   }

   private List<VirtualFile> getCurrentState() {
     List<VirtualFile> result = new ArrayList<VirtualFile>();
     for (ContentEntry entry : myTemplateRoots.keySet()) {
       for (VirtualFilePointer filePointer : myTemplateRoots.get(entry)) {
         result.add(filePointer.getFile());
       }
     }
     return result;
   }

   @Override
   public boolean isModified() {
     if (super.isModified()) return true;
     final TemplatesService templatesService = TemplatesService.getInstance(myModule);
     if (templatesService != null) {
       List<VirtualFile> original = templatesService.getTemplateFolders();
       List<VirtualFile> current = getCurrentState();

       if (!Comparing.haveEqualElements(original, current)) return true;

     }
     return false;
   }

   @Override
   protected MyContentEntryEditor createContentEntryEditor(String contentEntryUrl) {
     return new MyContentEntryEditor(contentEntryUrl, getEditHandlers());
   }

   protected class MyContentEntryEditor extends ContentEntryEditor {
     private final EventDispatcher<ChangeListener> myEventDispatcher = EventDispatcher.create(ChangeListener.class);

     public MyContentEntryEditor(String contentEntryUrl, List<ModuleSourceRootEditHandler<?>> handlers) {
       super(contentEntryUrl, handlers);
     }

     @Override
     protected ModifiableRootModel getModel() {
       return PyContentEntriesEditor.this.getModel();
     }

     public void addListener(ChangeListener changeListener) {
       myEventDispatcher.addListener(changeListener);
     }

     public void removeListener(ChangeListener changeListener) {
       myEventDispatcher.removeListener(changeListener);
     }

     @Override
     protected ContentRootPanel createContentRootPane() {
       return new MyContentRootPanel();
     }

     @Override
     public void deleteContentFolder(ContentEntry contentEntry, ContentFolder folder) {
       if (folder instanceof TemplateRootFolder) {
         final VirtualFile file = folder.getFile();
         if (file != null) {
           removeTemplateRoot(file);
         }
       }
       else {
         super.deleteContentFolder(contentEntry, folder);
       }
     }

     public void addTemplateRoot(@NotNull final VirtualFile file) {
       final VirtualFilePointer root = VirtualFilePointerManager.getInstance().create(file, myFilePointersDisposable, DUMMY_LISTENER);
       myTemplateRoots.putValue(getContentEntry(), root);
       myEventDispatcher.getMulticaster().stateChanged(new ChangeEvent(this));
       update();
     }

     public void removeTemplateRoot(@NotNull final VirtualFile file) {
       final VirtualFilePointer root = getTemplateRoot(file);
       if (root != null) {
         myTemplateRoots.remove(getContentEntry(), root);
         myEventDispatcher.getMulticaster().stateChanged(new ChangeEvent(this));
         update();
       }
     }

     public boolean hasTemplateRoot(@NotNull final VirtualFile file) {
       return getTemplateRoot(file) != null;
     }

     @Nullable
     public VirtualFilePointer getTemplateRoot(@NotNull final VirtualFile file) {
       for (VirtualFilePointer filePointer : myTemplateRoots.get(getContentEntry())) {
         if (Comparing.equal(filePointer.getFile(), file)) {
           return filePointer;
         }
       }
       return null;
     }

     protected class MyContentRootPanel extends ContentRootPanel {
       public MyContentRootPanel() {
         super(MyContentEntryEditor.this, getEditHandlers());
       }

       @Override
       @NotNull
       protected ContentEntryImpl getContentEntry() {
         //noinspection ConstantConditions
         return (ContentEntryImpl)MyContentEntryEditor.this.getContentEntry();
       }

       @Override
       protected void addFolderGroupComponents() {
         super.addFolderGroupComponents();
         if (!myTemplateRoots.get(getContentEntry()).isEmpty()) {
           final List<TemplateRootFolder> folders = new ArrayList<TemplateRootFolder>(myTemplateRoots.size());
           for (VirtualFilePointer root : myTemplateRoots.get(getContentEntry())) {
             folders.add(new TemplateRootFolder(root, getContentEntry()));
           }
           final JComponent sourcesComponent = createFolderGroupComponent("Template Folders",
                                                                          folders.toArray(new ContentFolder[folders.size()]),
                                                                          TEMPLATES_COLOR, null);
           this.add(sourcesComponent, new GridBagConstraints(0, GridBagConstraints.RELATIVE, 1, 1, 1.0, 0.0, GridBagConstraints.NORTH,
                                                             GridBagConstraints.HORIZONTAL, new Insets(0, 0, 10, 0), 0, 0));
         }
       }
     }
   }

   private static class MyContentEntryTreeEditor extends ContentEntryTreeEditor {

     private final ChangeListener myListener = new ChangeListener() {
       @Override
       public void stateChanged(ChangeEvent e) {
         update();
       }
     };

     public MyContentEntryTreeEditor(Project project, List<ModuleSourceRootEditHandler<?>> handlers) {
       super(project, handlers);
     }

     @Override
     public void setContentEntryEditor(ContentEntryEditor newEditor) {
       PyContentEntriesEditor.MyContentEntryEditor existingEditor = getContentEntryEditor();
       if (Comparing.equal(existingEditor, newEditor)) {
         return;
       }
       if (existingEditor != null) {
         existingEditor.removeListener(myListener);
       }
       if (newEditor != null) {
         ((PyContentEntriesEditor.MyContentEntryEditor)newEditor).addListener(myListener);
       }
       super.setContentEntryEditor(newEditor);
     }

     @Override
     public PyContentEntriesEditor.MyContentEntryEditor getContentEntryEditor() {
       return (PyContentEntriesEditor.MyContentEntryEditor)super.getContentEntryEditor();
     }

     @Override
     protected void createEditingActions() {
       super.createEditingActions();

       ContentEntryEditingAction a = new ContentEntryEditingAction(myTree) {
         {
           final Presentation templatePresentation = getTemplatePresentation();
           templatePresentation.setText("Templates");
           templatePresentation.setDescription("Template Folders");
           templatePresentation.setIcon(PythonIcons.Python.TemplateRoot);
         }

         @Override
         public boolean isSelected(AnActionEvent e) {
           final VirtualFile[] selectedFiles = getSelectedFiles();
           return selectedFiles.length != 0 && getContentEntryEditor().hasTemplateRoot(selectedFiles[0]);
         }

         @Override
         public void setSelected(AnActionEvent e, boolean isSelected) {
           final VirtualFile[] selectedFiles = getSelectedFiles();
           assert selectedFiles.length != 0;

           for (VirtualFile selectedFile : selectedFiles) {
             boolean wasSelected = getContentEntryEditor().hasTemplateRoot(selectedFile);
             if (isSelected) {
               if (!wasSelected) {
                 getContentEntryEditor().addTemplateRoot(selectedFile);
               }
             }
             else {
               if (wasSelected) {
                 getContentEntryEditor().removeTemplateRoot(selectedFile);
               }
             }
           }
         }
       };
       myEditingActionsGroup.add(a);
       a.registerCustomShortcutSet(new CustomShortcutSet(KeyStroke.getKeyStroke(KeyEvent.VK_R, InputEvent.ALT_MASK)), myTree);
     }

     @Override
     protected TreeCellRenderer getContentEntryCellRenderer() {
       return new ContentEntryTreeCellRenderer(this, getEditHandlers()) {
         @Override
         protected Icon updateIcon(final ContentEntry entry, final VirtualFile file, final Icon originalIcon) {
           if (getContentEntryEditor().hasTemplateRoot(file)) {
             return PythonIcons.Python.TemplateRoot;
           }
           return super.updateIcon(entry, file, originalIcon);
         }
       };
     }
   }
   private static class TemplateRootFolder extends ContentFolderBaseImpl {
     protected TemplateRootFolder(@NotNull VirtualFilePointer filePointer, @NotNull ContentEntryImpl contentEntry) {
       super(filePointer, contentEntry);
     }
   }

 }
	/*
	* Copyright 2000-2013 JetBrains s.r.o.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package com.jetbrains.python.module;

	import com.intellij.openapi.Disposable;
	import com.intellij.openapi.actionSystem.AnActionEvent;
	import com.intellij.openapi.actionSystem.CustomShortcutSet;
	import com.intellij.openapi.actionSystem.Presentation;
	import com.intellij.openapi.module.Module;
	import com.intellij.openapi.options.ConfigurationException;
	import com.intellij.openapi.project.Project;
	import com.intellij.openapi.roots.ContentEntry;
	import com.intellij.openapi.roots.ContentFolder;
	import com.intellij.openapi.roots.ModifiableRootModel;
	import com.intellij.openapi.roots.impl.ContentEntryImpl;
	import com.intellij.openapi.roots.impl.ContentFolderBaseImpl;
	import com.intellij.openapi.roots.ui.configuration.*;
	import com.intellij.openapi.roots.ui.configuration.actions.ContentEntryEditingAction;
	import com.intellij.openapi.util.Comparing;
	import com.intellij.openapi.util.Disposer;
	import com.intellij.openapi.vfs.VfsUtilCore;
	import com.intellij.openapi.vfs.VirtualFile;
	import com.intellij.openapi.vfs.pointers.VirtualFilePointer;
	import com.intellij.openapi.vfs.pointers.VirtualFilePointerListener;
	import com.intellij.openapi.vfs.pointers.VirtualFilePointerManager;
	import com.intellij.ui.JBColor;
	import com.intellij.util.EventDispatcher;
	import com.intellij.util.containers.MultiMap;
	import com.jetbrains.python.templateLanguages.TemplatesService;
	import icons.PythonIcons;
	import org.jetbrains.annotations.NotNull;
	import org.jetbrains.annotations.Nullable;
	import org.jetbrains.jps.model.module.JpsModuleSourceRootType;

	import javax.swing.*;
	import javax.swing.event.ChangeEvent;
	import javax.swing.event.ChangeListener;
	import javax.swing.tree.TreeCellRenderer;
	import java.awt.*;
	import java.awt.event.InputEvent;
	import java.awt.event.KeyEvent;
	import java.util.ArrayList;
	import java.util.List;

	public class PyContentEntriesEditor extends CommonContentEntriesEditor {
	private static final Color TEMPLATES_COLOR = JBColor.MAGENTA;
	private final MultiMap<ContentEntry, VirtualFilePointer> myTemplateRoots = new MultiMap<ContentEntry, VirtualFilePointer>();
	private final Module myModule;
	private Disposable myFilePointersDisposable;

	private final VirtualFilePointerListener DUMMY_LISTENER = new VirtualFilePointerListener() {
	@Override
	public void beforeValidityChanged(@NotNull VirtualFilePointer[] pointers) {
	}

	@Override
	public void validityChanged(@NotNull VirtualFilePointer[] pointers) {
	}
	};

	public PyContentEntriesEditor(Module module, ModuleConfigurationState moduleConfigurationState,
	JpsModuleSourceRootType<?>... rootTypes) {
	super(module.getName(), moduleConfigurationState, rootTypes);
	myModule = module;
	reset();
	}

	@Override
	protected ContentEntryTreeEditor createContentEntryTreeEditor(Project project) {
	return new MyContentEntryTreeEditor(project, getEditHandlers());
	}

	@Override
	protected List<ContentEntry> addContentEntries(VirtualFile[] files) {
	List<ContentEntry> entries = super.addContentEntries(files);
	addContentEntryPanels(entries.toArray(new ContentEntry[entries.size()]));
	return entries;
	}

	@Override
	public void reset() {
	if (myFilePointersDisposable != null) {
	Disposer.dispose(myFilePointersDisposable);
	}
	myTemplateRoots.clear();

	myFilePointersDisposable = Disposer.newDisposable();
	final TemplatesService instance = TemplatesService.getInstance(myModule);
	if (instance != null) {
	final List<VirtualFile> folders = instance.getTemplateFolders();
	for (VirtualFile folder : folders) {
	ContentEntry contentEntry = findContentEntryForFile(folder);
	if (contentEntry != null) {
	myTemplateRoots.putValue(contentEntry, VirtualFilePointerManager.getInstance().create(folder, myFilePointersDisposable,
	DUMMY_LISTENER));
	}
	}
	}

	if (myRootTreeEditor != null) {
	ContentEntryEditor editor = myRootTreeEditor.getContentEntryEditor();
	if(editor!=null) editor.update();
	myRootTreeEditor.update();
	}
	}

	@Nullable
	private ContentEntry findContentEntryForFile(VirtualFile virtualFile) {
	for (ContentEntry contentEntry : getModel().getContentEntries()) {
	final VirtualFile file = contentEntry.getFile();
	if (file != null && VfsUtilCore.isAncestor(file, virtualFile, false)) {
	return contentEntry;
	}
	}
	return null;
	}

	@Override
	public void disposeUIResources() {
	super.disposeUIResources();
	if (myFilePointersDisposable != null) {
	Disposer.dispose(myFilePointersDisposable);
	}
	}

	@Override
	public void apply() throws ConfigurationException {
	super.apply();
	List<VirtualFile> templateRoots = getCurrentState();
	TemplatesService.getInstance(myModule).setTemplateFolders(templateRoots.toArray(new VirtualFile[templateRoots.size()]));
	}

	private List<VirtualFile> getCurrentState() {
	List<VirtualFile> result = new ArrayList<VirtualFile>();
	for (ContentEntry entry : myTemplateRoots.keySet()) {
	for (VirtualFilePointer filePointer : myTemplateRoots.get(entry)) {
	result.add(filePointer.getFile());
	}
	}
	return result;
	}

	@Override
	public boolean isModified() {
	if (super.isModified()) return true;
	final TemplatesService templatesService = TemplatesService.getInstance(myModule);
	if (templatesService != null) {
	List<VirtualFile> original = templatesService.getTemplateFolders();
	List<VirtualFile> current = getCurrentState();

	if (!Comparing.haveEqualElements(original, current)) return true;

	}
	return false;
	}

	@Override
	protected MyContentEntryEditor createContentEntryEditor(String contentEntryUrl) {
	return new MyContentEntryEditor(contentEntryUrl, getEditHandlers());
	}

	protected class MyContentEntryEditor extends ContentEntryEditor {
	private final EventDispatcher<ChangeListener> myEventDispatcher = EventDispatcher.create(ChangeListener.class);

	public MyContentEntryEditor(String contentEntryUrl, List<ModuleSourceRootEditHandler<?>> handlers) {
	super(contentEntryUrl, handlers);
	}

	@Override
	protected ModifiableRootModel getModel() {
	return PyContentEntriesEditor.this.getModel();
	}

	public void addListener(ChangeListener changeListener) {
	myEventDispatcher.addListener(changeListener);
	}

	public void removeListener(ChangeListener changeListener) {
	myEventDispatcher.removeListener(changeListener);
	}

	@Override
	protected ContentRootPanel createContentRootPane() {
	return new MyContentRootPanel();
	}

	@Override
	public void deleteContentFolder(ContentEntry contentEntry, ContentFolder folder) {
	if (folder instanceof TemplateRootFolder) {
	final VirtualFile file = folder.getFile();
	if (file != null) {
	removeTemplateRoot(file);
	}
	}
	else {
	super.deleteContentFolder(contentEntry, folder);
	}
	}

	public void addTemplateRoot(@NotNull final VirtualFile file) {
	final VirtualFilePointer root = VirtualFilePointerManager.getInstance().create(file, myFilePointersDisposable, DUMMY_LISTENER);
	myTemplateRoots.putValue(getContentEntry(), root);
	myEventDispatcher.getMulticaster().stateChanged(new ChangeEvent(this));
	update();
	}

	public void removeTemplateRoot(@NotNull final VirtualFile file) {
	final VirtualFilePointer root = getTemplateRoot(file);
	if (root != null) {
	myTemplateRoots.remove(getContentEntry(), root);
	myEventDispatcher.getMulticaster().stateChanged(new ChangeEvent(this));
	update();
	}
	}

	public boolean hasTemplateRoot(@NotNull final VirtualFile file) {
	return getTemplateRoot(file) != null;
	}

	@Nullable
	public VirtualFilePointer getTemplateRoot(@NotNull final VirtualFile file) {
	for (VirtualFilePointer filePointer : myTemplateRoots.get(getContentEntry())) {
	if (Comparing.equal(filePointer.getFile(), file)) {
	return filePointer;
	}
	}
	return null;
	}

	protected class MyContentRootPanel extends ContentRootPanel {
	public MyContentRootPanel() {
	super(MyContentEntryEditor.this, getEditHandlers());
	}

	@Override
	@NotNull
	protected ContentEntryImpl getContentEntry() {
	//noinspection ConstantConditions
	return (ContentEntryImpl)MyContentEntryEditor.this.getContentEntry();
	}

	@Override
	protected void addFolderGroupComponents() {
	super.addFolderGroupComponents();
	if (!myTemplateRoots.get(getContentEntry()).isEmpty()) {
	final List<TemplateRootFolder> folders = new ArrayList<TemplateRootFolder>(myTemplateRoots.size());
	for (VirtualFilePointer root : myTemplateRoots.get(getContentEntry())) {
	folders.add(new TemplateRootFolder(root, getContentEntry()));
	}
	final JComponent sourcesComponent = createFolderGroupComponent("Template Folders",
	folders.toArray(new ContentFolder[folders.size()]),
	TEMPLATES_COLOR, null);
	this.add(sourcesComponent, new GridBagConstraints(0, GridBagConstraints.RELATIVE, 1, 1, 1.0, 0.0, GridBagConstraints.NORTH,
	GridBagConstraints.HORIZONTAL, new Insets(0, 0, 10, 0), 0, 0));
	}
	}
	}
	}

	private static class MyContentEntryTreeEditor extends ContentEntryTreeEditor {

	private final ChangeListener myListener = new ChangeListener() {
	@Override
	public void stateChanged(ChangeEvent e) {
	update();
	}
	};

	public MyContentEntryTreeEditor(Project project, List<ModuleSourceRootEditHandler<?>> handlers) {
	super(project, handlers);
	}

	@Override
	public void setContentEntryEditor(ContentEntryEditor newEditor) {
	PyContentEntriesEditor.MyContentEntryEditor existingEditor = getContentEntryEditor();
	if (Comparing.equal(existingEditor, newEditor)) {
	return;
	}
	if (existingEditor != null) {
	existingEditor.removeListener(myListener);
	}
	if (newEditor != null) {
	((PyContentEntriesEditor.MyContentEntryEditor)newEditor).addListener(myListener);
	}
	super.setContentEntryEditor(newEditor);
	}

	@Override
	public PyContentEntriesEditor.MyContentEntryEditor getContentEntryEditor() {
	return (PyContentEntriesEditor.MyContentEntryEditor)super.getContentEntryEditor();
	}

	@Override
	protected void createEditingActions() {
	super.createEditingActions();

	ContentEntryEditingAction a = new ContentEntryEditingAction(myTree) {
	{
	final Presentation templatePresentation = getTemplatePresentation();
	templatePresentation.setText("Templates");
	templatePresentation.setDescription("Template Folders");
	templatePresentation.setIcon(PythonIcons.Python.TemplateRoot);
	}

	@Override
	public boolean isSelected(AnActionEvent e) {
	final VirtualFile[] selectedFiles = getSelectedFiles();
	return selectedFiles.length != 0 && getContentEntryEditor().hasTemplateRoot(selectedFiles[0]);
	}

	@Override
	public void setSelected(AnActionEvent e, boolean isSelected) {
	final VirtualFile[] selectedFiles = getSelectedFiles();
	assert selectedFiles.length != 0;

	for (VirtualFile selectedFile : selectedFiles) {
	boolean wasSelected = getContentEntryEditor().hasTemplateRoot(selectedFile);
	if (isSelected) {
	if (!wasSelected) {
	getContentEntryEditor().addTemplateRoot(selectedFile);
	}
	}
	else {
	if (wasSelected) {
	getContentEntryEditor().removeTemplateRoot(selectedFile);
	}
	}
	}
	}
	};
	myEditingActionsGroup.add(a);
	a.registerCustomShortcutSet(new CustomShortcutSet(KeyStroke.getKeyStroke(KeyEvent.VK_R, InputEvent.ALT_MASK)), myTree);
	}

	@Override
	protected TreeCellRenderer getContentEntryCellRenderer() {
	return new ContentEntryTreeCellRenderer(this, getEditHandlers()) {
	@Override
	protected Icon updateIcon(final ContentEntry entry, final VirtualFile file, final Icon originalIcon) {
	if (getContentEntryEditor().hasTemplateRoot(file)) {
	return PythonIcons.Python.TemplateRoot;
	}
	return super.updateIcon(entry, file, originalIcon);
	}
	};
	}
	}
	private static class TemplateRootFolder extends ContentFolderBaseImpl {
	protected TemplateRootFolder(@NotNull VirtualFilePointer filePointer, @NotNull ContentEntryImpl contentEntry) {
	super(filePointer, contentEntry);
	}
	}

	}