java - idea - intellij student

IntelliJ IDEA Plugin Development: guarde grupos de pestañas, guárdelas de forma persistente y vuelva a cargar un conjunto de pestañas si lo solicita el usuario

Question

Actualmente estoy en movimiento para escribir un complemento IntelliJ. Quiero poder almacenar / restaurar un conjunto de pestañas para cambiar entre diferentes sesiones de pestañas (comparables a los complementos del navegador como Session Manager o Session Buddy ).

Por lo tanto necesito básicamente tres tipos de acciones:

1. Lea las pestañas abiertas (¿qué archivo y editor se usa?)
2. Almacena esa información de forma persistente como una sesión de pestañas.
3. Abre las pestañas de la sesión seleccionada y cierra todas las demás.

Miré las acciones disponibles: IdeActions.java - parece que no hay lo que estoy buscando. Pero tal vez estoy mirando el lugar equivocado. ¿Alguien puede decirme si lo que estoy tratando de lograr es posible y darme algunos consejos en la dirección correcta?

Actualizar

Creé con éxito el complemento y está disponible en Github: http://alp82.github.com/idea-tabsession/

Está disponible en el repositorio oficial de complementos: Tab Session .

Actualización 2

Aquí hay una pregunta de seguimiento relacionada con las ventanas divididas : Recuperación y configuración de la configuración de la ventana dividida

Answer 1

Actualización 2017

Descontinúo el soporte para este complemento porque IDEA ya admite esa función. Puede guardar y cargar contextos fácilmente como se muestra aquí: https://github.com/alp82/idea-tabsession#discontinued

Actualizar

El complemento está listo y listo y se puede descargar en IDEA -> Configuración -> Complementos. El código fuente está disponible en: https://github.com/alp82/idea-tabsession

Respuesta corta

Para leer qué pestañas están abiertas ahora, use el EditorFactory y FileDocumentManager Singletons:

    Editor[] editors = EditorFactory.getInstance().getAllEditors();
    FileDocumentManager fileDocManager = FileDocumentManager.getInstance();
    for(Editor editor : editors) {
        VirtualFile vf = fileDocManager.getFile(editor.getDocument());
        String path = vf.getCanonicalPath();
        System.out.println("path = " + path);
    }

Para abrir pestañas use el FileEditorManager singleton (los files son una matriz de cadenas de rutas canónicas):

    FileEditorManager fileEditorManager = FileEditorManager.getInstance(project);
    for(String path : files) {
        System.out.println("path = " + path);
        VirtualFile vf = LocalFileSystem.getInstance().findFileByPath(path);
        fileEditorManager.openFile(vf, true, true);
    }

Respuesta larga

Prerrequisitos

1. Activar los complementos de desarrollo de complementos, Groovy y UI Designer
2. Nuevo proyecto -> IntelliJ IDEA Plugin

3. Verifique las fuentes de IDEA Community Edition en cualquier carpeta:

   git clone git://git.jetbrains.org/idea/community.git idea

4. Configurar IDEA SDK y crear plugin

Estructura de plugin

Una vez que haya creado su complemento, necesita editar su plugin.xml ubicado en la carpeta META-INF. Modificar el id , name y description .

Necesitamos un archivo de configuración para el almacenamiento persistente. Cree un archivo mystorage.xml en su carpeta src . Ahora es el momento de crear los archivos necesarios:

SessionComponent.java (créelo con el asistente Add Project Component para crear automáticamente la configuración xml necesaria):

@State(
    name = "SessionComponent",
    storages = {
        @Storage(id = "default", file = StoragePathMacros.PROJECT_FILE),
        @Storage(id = "dir", file = StoragePathMacros.PROJECT_CONFIG_DIR + "/mystorage.xml", scheme = StorageScheme.DIRECTORY_BASED)
    }
)
public class SessionComponent implements ProjectComponent, PersistentStateComponent<SessionState> {

    Project project;
    SessionState sessionState;

    public SessionComponent(Project project) {
        this.project = project;
        sessionState = new SessionState();
    }

    public void initComponent() {
        // TODO: insert component initialization logic here
    }

    @Override
    public void loadState(SessionState sessionState) {
        System.out.println("load sessionState = " + sessionState);
        this.sessionState = sessionState;
    }

    public void projectOpened() {
        // called when project is opened
    }

    public void projectClosed() {
        // called when project is being closed
    }

    @Nullable
    @Override
    public SessionState getState() {
        System.out.println("save sessionState = " + sessionState);
        return sessionState;
    }

    public void disposeComponent() {
        // TODO: insert component disposal logic here
    }

    @NotNull
    public String getComponentName() {
        return "SessionComponent";
    }

    public int saveCurrentTabs() {
        Editor[] editors = getOpenEditors();
        FileEditorManager fileEditorManager = FileEditorManager.getInstance(project);
        VirtualFile[] selectedFiles = fileEditorManager.getSelectedFiles();

        FileDocumentManager fileDocManager = FileDocumentManager.getInstance();
        sessionState.files = new String[editors.length];
        int i = 0;
        for(Editor editor : editors) {
            VirtualFile vf = fileDocManager.getFile(editor.getDocument());
            String path = vf.getCanonicalPath();
            System.out.println("path = " + path);
            if(path.equals(selectedFiles[0].getCanonicalPath())) {
                sessionState.focusedFile = path;
            }
            sessionState.files[i] = path;
            i++;
        }

        return editors.length;
    }

    public int loadSession() {
        closeCurrentTabs();
        FileEditorManager fileEditorManager = FileEditorManager.getInstance(project);
        for(String path : sessionState.files) {
            System.out.println("path = " + path);
            VirtualFile vf = LocalFileSystem.getInstance().findFileByPath(path);
            fileEditorManager.openFile(vf, true, true);
        }

        return sessionState.files.length;
    }

    public void closeCurrentTabs() {
        Editor[] editors = getOpenEditors();
        FileEditorManager fileEditorManager = FileEditorManager.getInstance(project);
        FileDocumentManager fileDocManager = FileDocumentManager.getInstance();
        for(Editor editor : editors) {
            System.out.println("editor = " + editor);
            VirtualFile vf = fileDocManager.getFile(editor.getDocument());
            fileEditorManager.closeFile(vf);
        }
    }

    public void showMessage(String htmlText) {
        StatusBar statusBar = WindowManager.getInstance().getStatusBar(project);
        JBPopupFactory.getInstance()
            .createHtmlTextBalloonBuilder(htmlText, MessageType.INFO, null)
            .setFadeoutTime(7500)
            .createBalloon()
            .show(RelativePoint.getCenterOf(statusBar.getComponent()), Balloon.Position.atRight);
    }

    private Editor[] getOpenEditors() {
        return EditorFactory.getInstance().getAllEditors();
    }

}

También necesitamos la clase de almacenamiento:

public class SessionState {
    public String[] files = new String[0];
    public String focusedFile = "";

    public String toString() {
        String result = "";
        for (String file : files) {
            result += file + ", ";
        }
        result += "selected: " + focusedFile;
        return result;
    }
}

La clase de componente debe tener una entrada en tu plugin.xml como esta:

<project-components>
  <component>
    <implementation-class>my.package.SessionComponent</implementation-class>
  </component>
</project-components>

La clase de componente ofrece toda la funcionalidad necesaria, pero nunca se usa. Por lo tanto, necesitamos acciones para realizar la carga y el ahorro:

Save.java:

public class Save extends AnAction {

    public Save() {
        super();
    }

    public void actionPerformed(AnActionEvent event) {
        Project project = event.getData(PlatformDataKeys.PROJECT);
        SessionComponent sessionComponent = project.getComponent(SessionComponent.class);

        int tabCount = sessionComponent.saveCurrentTabs();
        String htmlText = "Saved " + String.valueOf(tabCount) + " tabs";
        sessionComponent.showMessage(htmlText);
    }

}

Load.java:

public class Load extends AnAction {

    public Load() {
        super();
    }

    public void actionPerformed(AnActionEvent event) {
        Project project = event.getData(PlatformDataKeys.PROJECT);
        SessionComponent sessionComponent = project.getComponent(SessionComponent.class);

        int tabCount = sessionComponent.loadSession();
        String htmlText = "Loaded " + String.valueOf(tabCount) + " tabs";
        sessionComponent.showMessage(htmlText);
    }

}

Aaand ... ¡Acción!

Lo último que necesitamos es la interfaz de usuario para seleccionar esas acciones. Simplemente ponga esto en su plugin.xml :

  <actions>
    <!-- Add your actions here -->
      <group id="MyPlugin.SampleMenu" text="_Sample Menu" description="Sample menu">
          <add-to-group group-id="MainMenu" anchor="last"  />
          <action id="MyPlugin.Save" class="my.package.Save" text="_Save" description="A test menu item" />
          <action id="MyPlugin.Load" class="my.package.Load" text="_Load" description="A test menu item" />
      </group>
  </actions>

Implementación de complementos

La funcionalidad básica está lista. Agregaré soporte para múltiples sesiones y algunas otras cosas interesantes antes de implementar este complemento y lanzarlo a la comunidad de código abierto. El enlace será publicado aquí, cuando esté en línea.