jetbrains.communicator.idea.IDEAFacade.java Source code

Java tutorial

Introduction

Here is the source code for jetbrains.communicator.idea.IDEAFacade.java

Source

/*
 * Copyright 2000-2006 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 jetbrains.communicator.idea;

import com.intellij.openapi.actionSystem.ActionGroup;
import com.intellij.openapi.actionSystem.ActionManager;
import com.intellij.openapi.actionSystem.CommonDataKeys;
import com.intellij.openapi.actionSystem.DataProvider;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.application.PathManager;
import com.intellij.openapi.editor.Document;
import com.intellij.openapi.fileEditor.FileDocumentManager;
import com.intellij.openapi.fileEditor.FileEditorManager;
import com.intellij.openapi.progress.ProcessCanceledException;
import com.intellij.openapi.progress.ProgressIndicator;
import com.intellij.openapi.progress.ProgressManager;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.project.ProjectManager;
import com.intellij.openapi.ui.Messages;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.openapi.wm.IdeFrame;
import com.intellij.openapi.wm.ex.WindowManagerEx;
import com.intellij.openapi.wm.impl.IdeFrameImpl;
import com.intellij.ui.PopupHandler;
import com.intellij.ui.TreeSpeedSearch;
import com.intellij.util.ArrayUtil;
import com.intellij.util.diff.Diff;
import com.intellij.util.ui.tree.TreeUtil;
import com.intellij.xml.util.XmlStringUtil;
import jetbrains.communicator.commands.FindUsersCommand;
import jetbrains.communicator.commands.SendMessageInvoker;
import jetbrains.communicator.core.EventVisitor;
import jetbrains.communicator.core.dispatcher.LocalMessage;
import jetbrains.communicator.core.transport.CodePointerEvent;
import jetbrains.communicator.core.transport.MessageEvent;
import jetbrains.communicator.core.transport.StacktraceEvent;
import jetbrains.communicator.core.transport.TransportEvent;
import jetbrains.communicator.core.users.User;
import jetbrains.communicator.core.vfs.ProjectsData;
import jetbrains.communicator.core.vfs.VFile;
import jetbrains.communicator.ide.*;
import jetbrains.communicator.idea.codePointer.IncomingCodePointerMessage;
import jetbrains.communicator.idea.findUsers.FindUsersDialog;
import jetbrains.communicator.idea.history.ShowHistoryDialog;
import jetbrains.communicator.idea.sendMessage.IncomingLocalMessage;
import jetbrains.communicator.idea.sendMessage.IncomingStacktraceMessage;
import jetbrains.communicator.idea.viewFiles.ViewFilesDialog;
import org.apache.log4j.Logger;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.Nullable;

import javax.swing.*;
import java.awt.*;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.concurrent.Future;

/**
 * @author Kir Maximov
 */
public class IDEAFacade implements IDEFacade {
    private static final Logger LOG = Logger.getLogger(IDEAFacade.class);

    private ViewFilesDialog myViewFilesDialog;

    @Override
    public void showMessage(String title, String message) {
        Messages.showMessageDialog(message, title, Messages.getInformationIcon());
    }

    @Override
    public boolean askQuestion(String title, String question) {
        //noinspection HardCodedStringLiteral
        int result = JOptionPane.showOptionDialog(null,
                new JLabel(XmlStringUtil.wrapInHtml(question.replaceAll("\n", "<br>"))), title,
                JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE, null, null, null);

        return result == JOptionPane.YES_OPTION;
    }

    @Override
    public File getCacheDir() {
        //noinspection HardCodedStringLiteral
        File file = new File(PathManager.getSystemPath(), "ideTalk");
        file.mkdir();
        return file;
    }

    @Override
    public File getConfigDir() {
        @NonNls
        File file = new File(PathManager.getConfigPath(), "ideTalk");
        file.mkdir();
        return file;
    }

    @Override
    public FindUsersCommand.UsersInfo chooseUsersToBeAdded(List<User> foundNewUsers, String[] groups) {

        FindUsersDialog dialog = new FindUsersDialog(foundNewUsers, groups);

        dialog.show();

        if (dialog.isOK()) {
            Set<User> selectedUsers = dialog.getSelectedUsers();
            return new FindUsersCommand.UsersInfo(selectedUsers.toArray(new User[selectedUsers.size()]),
                    dialog.getGroup());
        }

        return new FindUsersCommand.UsersInfo();
    }

    @Override
    public String getMessageLine(String labelText, String titleText) {
        return Messages.showInputDialog(labelText, titleText, Messages.getQuestionIcon());
    }

    @Override
    public String getMessage(String labelText, String titleText, String optionalOKButtonText) {
        GetMessageDialog dialog = new GetMessageDialog(titleText, labelText, optionalOKButtonText);
        dialog.show();
        return dialog.getEnteredText();
    }

    @Override
    public Future<?> runOnPooledThread(Runnable toRun) {
        return ApplicationManager.getApplication().executeOnPooledThread(toRun);
    }

    @Override
    public void runLongProcess(String processTitle, final Process process) throws CanceledException {
        try {
            ProgressManager.getInstance().runProcessWithProgressSynchronously(new Runnable() {
                @Override
                public void run() {
                    final ProgressIndicator progressIndicator = ProgressManager.getInstance()
                            .getProgressIndicator();
                    if (progressIndicator == null) {
                        process.run(new NullProgressIndicator() {
                            @Override
                            public void checkCanceled() {
                                super.checkCanceled();
                                throw new ProcessCanceledException();
                            }
                        });
                    } else {
                        progressIndicator.pushState();
                        process.run(new jetbrains.communicator.ide.ProgressIndicator() {
                            @Override
                            public void setIndefinite(boolean indefinite) {
                                progressIndicator.setIndeterminate(indefinite);
                            }

                            @Override
                            public void setText(String text) {
                                progressIndicator.setText(text);
                            }

                            @Override
                            public void setFraction(double x) {
                                progressIndicator.setFraction(x);
                            }

                            @Override
                            public void checkCanceled() {
                                progressIndicator.checkCanceled();
                            }
                        });
                        progressIndicator.popState();
                    }
                }
            }, processTitle, true, null);
        } catch (ProcessCanceledException e) {
            throw new CanceledException(e);
        }
    }

    @Override
    public void invokeSendMessage(User[] allUsers, User[] defaultTargetUsers, String message,
            SendMessageInvoker sendMessageInvoker) {

        Project project = getProject(null);
        assert project != null : "Null project when sending message";
        IDEtalkMessagesWindow messagesWindow = project.getComponent(IDEtalkMessagesWindow.class);
        if (messagesWindow != null && project.isInitialized()) {
            messagesWindow.expandToolWindow();
            for (User user : defaultTargetUsers) {
                messagesWindow.showUserTabAndRequestFocus(user);
                messagesWindow.appendInputText(user, message);
            }
        }
    }

    @Override
    public void showSearchHistoryResults(List<LocalMessage> foundMessages, User user) {
        Project project = getProject(null);
        assert project != null;
        new ShowHistoryDialog(project, foundMessages, user).show();
    }

    @Override
    public ProjectsData getProjectsData() {

        final ProjectsData result = new ProjectsData();

        ApplicationManager.getApplication().runReadAction(new Runnable() {
            @Override
            public void run() {
                try {
                    new ProjectsDataFiller(result).fillProjectsData();
                } catch (Throwable e) {
                    LOG.info(e, e);
                }
            }
        });

        return result;
    }

    @Override
    public String[] getProjects() {
        Project[] projects = ProjectManager.getInstance().getOpenProjects();
        List<String> result = new ArrayList<String>();
        for (Project project : projects) {
            result.add(project.getName());
        }
        return ArrayUtil.toStringArray(result);
    }

    @Override
    public void showUserFiles(User user, ProjectsData data) {
        if (myViewFilesDialog == null) {
            myViewFilesDialog = new ViewFilesDialog(user, data, this) {
                @Override
                protected void dispose() {
                    super.dispose();
                    myViewFilesDialog = null;
                }
            };
            myViewFilesDialog.show();
        } else {
            myViewFilesDialog.refreshData(user, data);
        }
    }

    @Override
    public boolean hasFile(VFile file) {
        VirtualFile virtualFile = VFSUtil.getVirtualFile(file);
        return virtualFile != null && virtualFile.isValid();
    }

    @Override
    public void open(VFile file) {
        VirtualFile virtualFile = VFSUtil.getVirtualFile(file);
        Project project = getProject(null);
        assert project != null;
        if (virtualFile != null) {
            FileEditorManager.getInstance(project).openFile(virtualFile, false);
        }
    }

    @Override
    public void fillFileContents(final VFile vFile) {
        vFile.setContents(null);
        final VirtualFile virtualFile = VFSUtil.getVirtualFile(vFile);
        if (virtualFile == null)
            return;

        ApplicationManager.getApplication().runReadAction(new Runnable() {
            @Override
            public void run() {
                Document document = FileDocumentManager.getInstance().getDocument(virtualFile);
                if (document != null) {
                    vFile.setContents(document.getText());
                }
            }
        });
    }

    @Override
    public void showDiffFor(User remoteUser, VFile vFile, String compareWith) {
        Project project = getProject(null);
        assert project != null;
        VirtualFile virtualFile = VFSUtil.getVirtualFile(vFile);
        if (virtualFile != null) {
            new DiffWindowOpener(project, virtualFile, remoteUser, vFile, compareWith).showDiff();
        }
    }

    @Override
    public Change[] getDiff(Object[] src, Object[] dest) {
        List<MyChangeAdapter> result = new ArrayList<MyChangeAdapter>();
        Diff.Change change;
        try {
            change = Diff.buildChanges(src, dest);
        } catch (Exception e) {
            LOG.warn(e);
            return new Change[0];
        }
        while (change != null) {
            result.add(new MyChangeAdapter(change));
            change = change.link;
        }
        return result.toArray(new Change[result.size()]);
    }

    @Override
    public LocalMessage createLocalMessageForIncomingEvent(TransportEvent event) {
        final LocalMessage[] result = new LocalMessage[1];
        event.accept(new EventVisitor() {

            @SuppressWarnings({ "RefusedBequest" })
            @Override
            public void visitStacktraceEvent(StacktraceEvent event) {
                result[0] = new IncomingStacktraceMessage(event);
            }

            @SuppressWarnings({ "RefusedBequest" })
            @Override
            public void visitCodePointerEvent(CodePointerEvent event) {
                result[0] = new IncomingCodePointerMessage(event, IDEAFacade.this);
            }

            @SuppressWarnings({ "RefusedBequest" })
            @Override
            public void visitMessageEvent(MessageEvent event) {
                result[0] = new IncomingLocalMessage(event);
            }
        });
        return result[0];
    }

    @Override
    @Nullable
    public LocalMessage createLocalMessageForOutgoingEvent(OwnMessageEvent event) {
        final LocalMessage[] result = new LocalMessage[1];
        event.accept(new EventVisitor() {

            @Override
            public void visitSendMessageEvent(SendMessageEvent event) {
                result[0] = new OutgoingLocalMessage(event.getMessage());
            }

            @Override
            public void visitSendCodePointerEvent(SendCodePointerEvent event) {
                result[0] = new OutgoingCodePointerLocalMessage(event);
            }
        });
        return result[0];
    }

    @Override
    @Nullable
    public String getCurrentProjectId() {
        Project project = getProject(null);
        if (project != null) {
            return IdProvider.getInstance(project).getId();
        }
        return null;
    }

    public static Object getData(Component c, String dataId) {
        Object result = null;
        while (c != null) {
            if (c instanceof DataProvider) {
                DataProvider provider = (DataProvider) c;
                Object data = provider.getData(dataId);
                if (data != null) {
                    result = data;
                    break;
                }
            }
            c = c.getParent();
        }
        return result;
    }

    @Nullable
    public static Project getProject(Component component) {
        Project res = null;

        if (component != null) {
            res = (Project) getData(component, CommonDataKeys.PROJECT.getName());
        } else {
            IdeFrame[] frames = WindowManagerEx.getInstanceEx().getAllProjectFrames();
            for (IdeFrame frame : frames) {
                final IdeFrameImpl eachFrame = (IdeFrameImpl) frame;
                if (eachFrame.isActive()) {
                    res = eachFrame.getProject();
                    if (res != null)
                        break;
                }
            }
        }

        if (res == null) {
            Project[] openProjects = ProjectManager.getInstance().getOpenProjects();
            res = openProjects.length > 0 ? openProjects[0] : null;
        }

        return res;
    }

    public static void installPopupMenu(ActionGroup group, Component component, ActionManager actionManager) {
        if (actionManager == null)
            return;
        PopupHandler.installPopupHandler((JComponent) component, group, "POPUP", actionManager);
    }

    public static void installIdeaTreeActions(JTree t) {
        TreeUtil.installActions(t);
        new TreeSpeedSearch(t);
    }

    private static class MyChangeAdapter implements Change {
        private final Diff.Change myChange1;

        MyChangeAdapter(Diff.Change change1) {
            myChange1 = change1;
        }

        @Override
        public int getInserted() {
            return myChange1.inserted;
        }

        @Override
        public int getDeleted() {
            return myChange1.deleted;
        }

        @Override
        public int getSrcLine() {
            return myChange1.line0;
        }

        @Override
        public int getDestLine() {
            return myChange1.line1;
        }
    }

    public static void main(String[] args) {
        IDEAFacade ideaFacade = new IDEAFacade();
        //noinspection HardCodedStringLiteral
        ideaFacade.askQuestion("title", "some\n<i>question</i>");
    }
}