* Source.java

*

* Copyright (C) 2009-12 by RStudio, Inc.

*

* Unless you have received this program directly from RStudio pursuant

* to the terms of a commercial license agreement with RStudio, then

* this program is licensed to you under the terms of version 3 of the

* GNU Affero General Public License. This program is distributed WITHOUT

* ANY EXPRESS OR IMPLIED WARRANTY, INCLUDING THOSE OF NON-INFRINGEMENT,

* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Please refer to the

* AGPL (http://www.gnu.org/licenses/agpl-3.0.txt) for more details.

*

*/

                               IsWidget,

                             OpenSourceFileHandler,

                             TabClosingHandler,

                             TabCloseHandler,

                             SelectionHandler<Integer>,

                             TabClosedHandler,

                             FileEditHandler,

                             ShowContentHandler,

                             ShowDataHandler,

                             CodeBrowserNavigationHandler,

                             CodeBrowserFinishedHandler,

                             CodeBrowserHighlightEvent.Handler,

                             SourceExtendedTypeDetectedEvent.Handler,

                             BeforeShowHandler

   public interface Display extends IsWidget,

                                    HasTabClosingHandlers,

                                    HasTabCloseHandlers,

                                    HasTabClosedHandlers,

                                    HasBeforeSelectionHandlers<Integer>,

                                    HasSelectionHandlers<Integer>

   {

      void addTab(Widget widget,

                  ImageResource icon,

                  String name,

                  String tooltip,

                  boolean switchToTab);

      void selectTab(int tabIndex);

      void selectTab(Widget widget);

      int getTabCount();

      int getActiveTabIndex();

      void closeTab(Widget widget, boolean interactive);

      void closeTab(Widget widget, boolean interactive, Command onClosed);

      void closeTab(int index, boolean interactive);

      void closeTab(int index, boolean interactive, Command onClosed);

      void setDirty(Widget widget, boolean dirty);

      void manageChevronVisibility();

      void showOverflowPopup();

     

      void showUnsavedChangesDialog(

            String title,

            ArrayList<UnsavedChangesTarget> dirtyTargets,

            OperationWithInput<UnsavedChangesDialog.Result> saveOperation,

            Command onCancelled);

      void ensureVisible();

      void renameTab(Widget child,

                     ImageResource icon,

                     String value,

                     String tooltip);

      HandlerRegistration addBeforeShowHandler(BeforeShowHandler handler);

   }

   public interface CPSEditingTargetCommand

   {

      void execute(EditingTarget editingTarget, Command continuation);

   }

   @Inject

   public Source(Commands commands,

                 Display view,

                 SourceServerOperations server,

                 EditingTargetSource editingTargetSource,

                 FileTypeRegistry fileTypeRegistry,

                 GlobalDisplay globalDisplay,

                 FileDialogs fileDialogs,

                 RemoteFileSystemContext fileContext,

                 EventBus events,

                 final Session session,

                 Synctex synctex,

                 WorkbenchContext workbenchContext,

                 Provider<FileMRUList> pMruList,

                 UIPrefs uiPrefs,

                 RnwWeaveRegistry rnwWeaveRegistry)

   {

      commands_ = commands;

      view_ = view;

      server_ = server;

      editingTargetSource_ = editingTargetSource;

      fileTypeRegistry_ = fileTypeRegistry;

      globalDisplay_ = globalDisplay;

      fileDialogs_ = fileDialogs;

      fileContext_ = fileContext;

      rmarkdown_ = new TextEditingTargetRMarkdownHelper();

      events_ = events;

      session_ = session;

      synctex_ = synctex;

      workbenchContext_ = workbenchContext;

      pMruList_ = pMruList;

      uiPrefs_ = uiPrefs;

      rnwWeaveRegistry_ = rnwWeaveRegistry;

      view_.addTabClosingHandler(this);

      view_.addTabCloseHandler(this);

      view_.addTabClosedHandler(this);

      view_.addSelectionHandler(this);

      view_.addBeforeShowHandler(this);

      dynamicCommands_ = new HashSet<AppCommand>();

      dynamicCommands_.add(commands.saveSourceDoc());

      dynamicCommands_.add(commands.reopenSourceDocWithEncoding());

      dynamicCommands_.add(commands.saveSourceDocAs());

      dynamicCommands_.add(commands.saveSourceDocWithEncoding());

      dynamicCommands_.add(commands.printSourceDoc());

      dynamicCommands_.add(commands.vcsFileLog());

      dynamicCommands_.add(commands.vcsFileDiff());

      dynamicCommands_.add(commands.vcsFileRevert());

      dynamicCommands_.add(commands.executeCode());

      dynamicCommands_.add(commands.executeCodeWithoutFocus());

      dynamicCommands_.add(commands.executeAllCode());

      dynamicCommands_.add(commands.executeToCurrentLine());

      dynamicCommands_.add(commands.executeFromCurrentLine());

      dynamicCommands_.add(commands.executeCurrentFunction());

      dynamicCommands_.add(commands.executeCurrentSection());

      dynamicCommands_.add(commands.executeLastCode());

      dynamicCommands_.add(commands.insertChunk());

      dynamicCommands_.add(commands.insertSection());

      dynamicCommands_.add(commands.executePreviousChunks());

      dynamicCommands_.add(commands.executeCurrentChunk());

      dynamicCommands_.add(commands.executeNextChunk());

      dynamicCommands_.add(commands.sourceActiveDocument());

      dynamicCommands_.add(commands.sourceActiveDocumentWithEcho());

      dynamicCommands_.add(commands.markdownHelp());

      dynamicCommands_.add(commands.usingRMarkdownHelp());

      dynamicCommands_.add(commands.authoringRPresentationsHelp());

      dynamicCommands_.add(commands.knitDocument());

      dynamicCommands_.add(commands.previewHTML());

      dynamicCommands_.add(commands.compilePDF());

      dynamicCommands_.add(commands.compileNotebook());

      dynamicCommands_.add(commands.synctexSearch());

      dynamicCommands_.add(commands.popoutDoc());

      dynamicCommands_.add(commands.findReplace());

      dynamicCommands_.add(commands.findNext());

      dynamicCommands_.add(commands.findPrevious());

      dynamicCommands_.add(commands.findFromSelection());

      dynamicCommands_.add(commands.replaceAndFind());

      dynamicCommands_.add(commands.extractFunction());

      dynamicCommands_.add(commands.extractLocalVariable());

      dynamicCommands_.add(commands.commentUncomment());

      dynamicCommands_.add(commands.reindent());

      dynamicCommands_.add(commands.reflowComment());

      dynamicCommands_.add(commands.jumpTo());

      dynamicCommands_.add(commands.jumpToMatching());

      dynamicCommands_.add(commands.goToHelp());

      dynamicCommands_.add(commands.goToFunctionDefinition());

      dynamicCommands_.add(commands.setWorkingDirToActiveDoc());

      dynamicCommands_.add(commands.debugDumpContents());

      dynamicCommands_.add(commands.debugImportDump());

      dynamicCommands_.add(commands.goToLine());

      dynamicCommands_.add(commands.checkSpelling());

      dynamicCommands_.add(commands.codeCompletion());

      dynamicCommands_.add(commands.rcppHelp());

      dynamicCommands_.add(commands.debugBreakpoint());

      dynamicCommands_.add(commands.vcsViewOnGitHub());

      dynamicCommands_.add(commands.vcsBlameOnGitHub());

      dynamicCommands_.add(commands.editRmdFormatOptions());

      for (AppCommand command : dynamicCommands_)

      {

         command.setVisible(false);

         command.setEnabled(false);

      }

     

      // fake shortcuts for commands which we handle at a lower level

      commands.goToHelp().setShortcut(new KeyboardShortcut(112));

      commands.goToFunctionDefinition().setShortcut(new KeyboardShortcut(113));

      commands.codeCompletion().setShortcut(

                                    new KeyboardShortcut(KeyCodes.KEY_TAB));

      // See bug 3673 and https://bugs.webkit.org/show_bug.cgi?id=41016

      if (BrowseCap.isMacintosh())

      {

         ShortcutManager.INSTANCE.register(

               KeyboardShortcut.META | KeyboardShortcut.ALT,

               192,

               commands.executeNextChunk(),

               "Execute",

               commands.executeNextChunk().getMenuLabel(false));

      }

      events.addHandler(ShowContentEvent.TYPE, this);

      events.addHandler(ShowDataEvent.TYPE, this);

      events.addHandler(ViewDataEvent.TYPE, new ViewDataHandler()

      {

         public void onViewData(ViewDataEvent event)

         {

            server_.newDocument(

                  FileTypeRegistry.DATAFRAME.getTypeId(),

                  null,

                  JsObject.createJsObject(),

                  new SimpleRequestCallback<SourceDocument>("Edit Data Frame") {

                     public void onResponseReceived(SourceDocument response)

                     {

                        addTab(response);

                     }

                  });

         }

      });

     

      events.addHandler(CodeBrowserNavigationEvent.TYPE, this);

     

      events.addHandler(CodeBrowserFinishedEvent.TYPE, this);

      events.addHandler(CodeBrowserHighlightEvent.TYPE, this);

      events.addHandler(FileTypeChangedEvent.TYPE, new FileTypeChangedHandler()

      {

         public void onFileTypeChanged(FileTypeChangedEvent event)

         {

            manageCommands();

         }

      });

     

      events.addHandler(SourceOnSaveChangedEvent.TYPE,

                        new SourceOnSaveChangedHandler() {

         @Override

         public void onSourceOnSaveChanged(SourceOnSaveChangedEvent event)

         {

            manageSaveCommands();

         }

      });

      events.addHandler(SwitchToDocEvent.TYPE, new SwitchToDocHandler()

      {

         public void onSwitchToDoc(SwitchToDocEvent event)

         {

            ensureVisible(false);

            view_.selectTab(event.getSelectedIndex());

         }

      });

      events.addHandler(SourceFileSavedEvent.TYPE, new SourceFileSavedHandler()

      {

         public void onSourceFileSaved(SourceFileSavedEvent event)

         {

            pMruList_.get().add(event.getPath());

         }

      });

           

      events.addHandler(SourceNavigationEvent.TYPE,

                        new SourceNavigationHandler() {

         @Override

         public void onSourceNavigation(SourceNavigationEvent event)

         {

            if (!suspendSourceNavigationAdding_)

            {

               sourceNavigationHistory_.add(event.getNavigation());

            }

         }

      });

     

      events.addHandler(SourceExtendedTypeDetectedEvent.TYPE, this);

     

      sourceNavigationHistory_.addChangeHandler(new ChangeHandler()

      {

         @Override

         public void onChange(ChangeEvent event)

         {

            manageSourceNavigationCommands();

         }

      });

     

      events.addHandler(SynctexStatusChangedEvent.TYPE,

                        new SynctexStatusChangedEvent.Handler()

      {

         @Override

         public void onSynctexStatusChanged(SynctexStatusChangedEvent event)

         {

            manageSynctexCommands();

         }

      });

      restoreDocuments(session);

      new IntStateValue(MODULE_SOURCE, KEY_ACTIVETAB, ClientState.PROJECT_PERSISTENT,

                        session.getSessionInfo().getClientState())

      {

         @Override

         protected void onInit(Integer value)

         {

            if (value == null)

               return;

            if (value >= 0 && view_.getTabCount() > value)

               view_.selectTab(value);

            if (view_.getTabCount() > 0 && view_.getActiveTabIndex() >= 0)

            {

               editors_.get(view_.getActiveTabIndex()).onInitiallyLoaded();

            }

            // clear the history manager

            sourceNavigationHistory_.clear();

         }

         @Override

         protected Integer getValue()

         {

            return view_.getActiveTabIndex();

         }

      };

      uiPrefs_.verticallyAlignArgumentIndent().bind(new CommandWithArg<Boolean>()

      {

         @Override

         public void execute(Boolean arg)

         {

            AceEditorNative.setVerticallyAlignFunctionArgs(arg);

         }

      });

      

      initialized_ = true;

      // As tabs were added before, manageCommands() was suppressed due to

      // initialized_ being false, so we need to run it explicitly

      manageCommands();

      // Same with this event

      fireDocTabsChanged();

     

      // open project docs

      openProjectDocs(session);   

   }

   /**

    * @param isNewTabPending True if a new tab is about to be created. (If

    *    false and there are no tabs already, then a new source doc might

    *    be created to make sure we don't end up with a source pane showing

    *    with no tabs in it.)

    */

   private void ensureVisible(boolean isNewTabPending)

   {

      newTabPending_++;

      try

      {

         view_.ensureVisible();

      }

      finally

      {

         newTabPending_--;

      }

   }

   public Widget asWidget()

   {

      return view_.asWidget();

   }

   private void restoreDocuments(final Session session)

   {

      final JsArray<SourceDocument> docs =

            session.getSessionInfo().getSourceDocuments();

      for (int i = 0; i < docs.length(); i++)

      {

         addTab(docs.get(i));

      }

   }

  

   private void openProjectDocs(final Session session)

   {

      JsArrayString openDocs = session.getSessionInfo().getProjectOpenDocs();

      if (openDocs.length() > 0)

      {

         // set new tab pending for the duration of the continuation

         newTabPending_++;

                

         // create a continuation for opening the source docs

         SerializedCommandQueue openCommands = new SerializedCommandQueue();

        

         for (int i=0; i<openDocs.length(); i++)

         {

            String doc = openDocs.get(i);

            final FileSystemItem fsi = FileSystemItem.createFile(doc);

             

            openCommands.addCommand(new SerializedCommand() {

               @Override

               public void onExecute(final Command continuation)

               {

                  openFile(fsi,

                           fileTypeRegistry_.getTextTypeForFile(fsi),

                           new CommandWithArg<EditingTarget>() {

                              @Override

                              public void execute(EditingTarget arg)

                              { 

                                 continuation.execute();

                              }

                           });

               }

            });

         }

        

         // decrement newTabPending and select first tab when done

         openCommands.addCommand(new SerializedCommand() {

            @Override

            public void onExecute(Command continuation)

            {

               newTabPending_--;

               onFirstTab();

               continuation.execute();

            }

           

         });

        

         // execute the continuation

         openCommands.run();

      }

   }

  

   public void onShowContent(ShowContentEvent event)

   {

      ensureVisible(true);

      ContentItem content = event.getContent();

      server_.newDocument(

            FileTypeRegistry.URLCONTENT.getTypeId(),

            null,

            (JsObject) content.cast(),

            new SimpleRequestCallback<SourceDocument>("Show")

            {

               @Override

               public void onResponseReceived(SourceDocument response)

               {

                  addTab(response);

               }

            });

   }

   public void onShowData(ShowDataEvent event)

   {

      DataItem data = event.getData();

      for (int i = 0; i < editors_.size(); i++)

      {

         String path = editors_.get(i).getPath();

         if (path != null && path.equals(data.getURI()))

         {

            ((DataEditingTarget)editors_.get(i)).updateData(data);

            ensureVisible(false);

            view_.selectTab(i);

            return;

         }

      }

      ensureVisible(true);

      server_.newDocument(

            FileTypeRegistry.DATAFRAME.getTypeId(),

            null,

            (JsObject) data.cast(),

            new SimpleRequestCallback<SourceDocument>("Show Data Frame")

            {

               @Override

               public void onResponseReceived(SourceDocument response)

               {

                  addTab(response);

               }

            });

   }

  

   @Handler

   public void onShowProfiler()

   {

      // first try to activate existing

      for (int idx = 0; idx < editors_.size(); idx++)

      {

         String path = editors_.get(idx).getPath();

         if (ProfilerEditingTarget.PATH.equals(path))

         {

            ensureVisible(false);

            view_.selectTab(idx);

            return;

         }

      }

     

      // create new profiler

      ensureVisible(true);

      server_.newDocument(

            FileTypeRegistry.PROFILER.getTypeId(),

            null,

            (JsObject) ProfilerContents.createDefault().cast(),

            new SimpleRequestCallback<SourceDocument>("Show Profiler")

            {

               @Override

               public void onResponseReceived(SourceDocument response)

               {

                  addTab(response);

               }

            });

   }

  

   @Handler

   public void onNewSourceDoc()

   {

      newDoc(FileTypeRegistry.R, null);

   }

  

   @Handler

   public void onNewTextDoc()

   {

      newDoc(FileTypeRegistry.TEXT, null);

   }

  

   @Handler

   public void onNewCppDoc()

   {

      if (uiPrefs_.useRcppTemplate().getValue())

      {

         newSourceDocWithTemplate(

             FileTypeRegistry.CPP,

             "",

             "rcpp.cpp",

             Position.create(0, 0),

             new CommandWithArg<EditingTarget> () {

               @Override

               public void execute(EditingTarget target)

               {

                  target.verifyCppPrerequisites();

               }

             }

         );

      }

      else

      {

         newDoc(FileTypeRegistry.CPP,

                new ResultCallback<EditingTarget, ServerError> () {

                   @Override

                   public void onSuccess(EditingTarget target)

                   {

                      target.verifyCppPrerequisites();

                   }

                });

      }

   }

  

   @Handler

   public void onNewSweaveDoc()

   {

      // set concordance value if we need to

      String concordance = new String();

      if (uiPrefs_.alwaysEnableRnwConcordance().getValue())

      {

         RnwWeave activeWeave = rnwWeaveRegistry_.findTypeIgnoreCase(

                                    uiPrefs_.defaultSweaveEngine().getValue());

         if (activeWeave.getInjectConcordance())

            concordance = "\\SweaveOpts{concordance=TRUE}\n";

      }

      final String concordanceValue = concordance;

    

      // show progress

      final ProgressIndicator indicator = new GlobalProgressDelayer(

            globalDisplay_, 500, "Creating new document...").getIndicator();

      // get the template

      server_.getSourceTemplate("",

                                "sweave.Rnw",

                                new ServerRequestCallback<String>() {

         @Override

         public void onResponseReceived(String templateContents)

         {

            indicator.onCompleted();

           

            // add in concordance if necessary

            final boolean hasConcordance = concordanceValue.length() > 0;

            if (hasConcordance)

            {

               String beginDoc = "\\begin{document}\n";

               templateContents = templateContents.replace(

                     beginDoc,

                     beginDoc + concordanceValue);

            }

           

            newDoc(FileTypeRegistry.SWEAVE,

                  templateContents,

                  new ResultCallback<EditingTarget, ServerError> () {

               @Override

               public void onSuccess(EditingTarget target)

               {

                  int startRow = 4 + (hasConcordance ? 1 : 0);

                  target.setCursorPosition(Position.create(startRow, 0));

               }

            });

         }

         @Override

         public void onError(ServerError error)

         {

            indicator.onError(error.getUserMessage());

         }

      });

   }

  

   @Handler

   public void onNewRMarkdownDoc()

   {

      SessionInfo sessionInfo = session_.getSessionInfo();

      boolean useRMarkdownV2 = sessionInfo.getRMarkdownPackageAvailable();

     

      if (useRMarkdownV2)

         newRMarkdownV2Doc();

      else

         newRMarkdownV1Doc();

   }

  

   @Handler

   public void onNewRHTMLDoc()

   {

      newSourceDocWithTemplate(FileTypeRegistry.RHTML,

                               "",

                               "r_html.Rhtml");

   }

  

  

   @Handler

   public void onNewRDocumentationDoc()

   {

      new NewRdDialog(

         new OperationWithInput<NewRdDialog.Result>() {

          

            @Override

            public void execute(final NewRdDialog.Result result)

            {

               final Command createEmptyDoc = new Command() {

                  @Override

                  public void execute()

                  {

                     newSourceDocWithTemplate(FileTypeRegistry.RD,

                           result.name,

                           "r_documentation_empty.Rd",

                           Position.create(3, 7));

                  } 

               };

              

               if (!result.type.equals(NewRdDialog.Result.TYPE_NONE))

               {

                  server_.createRdShell(

                     result.name,

                     result.type,

                     new SimpleRequestCallback<RdShellResult>() {

                        @Override

                        public void onResponseReceived(RdShellResult result)

                        {

                           if (result.getPath() != null)

                           {

                              fileTypeRegistry_.openFile(

                                 FileSystemItem.createFile(result.getPath()));

                           }

                           else if (result.getContents() != null)

                           {

                              newDoc(FileTypeRegistry.RD,

                                     result.getContents(),

                                     null);

                           }

                           else

                           {

                              createEmptyDoc.execute();

                           }

                        } 

                   });

                

               }

               else

               {

                  createEmptyDoc.execute();

               }

              

            }

          }).showModal();

   }

  

   @Handler

   public void onNewRPresentationDoc()

   {

      fileDialogs_.saveFile(

         "New R Presentation",

         fileContext_,

         workbenchContext_.getDefaultFileDialogDir(),

         ".Rpres",

         true,

         new ProgressOperationWithInput<FileSystemItem>() {

            @Override

            public void execute(final FileSystemItem input,

                                final ProgressIndicator indicator)

            {

               if (input == null)

               {

                  indicator.onCompleted();

                  return;

               }

              

               indicator.onProgress("Creating Presentation...");

              

               server_.createNewPresentation(

                 input.getPath(),

                 new VoidServerRequestCallback(indicator) {

                    @Override

                    public void onSuccess()

                    {

                       openFile(input,

                          FileTypeRegistry.RPRESENTATION,

                          new CommandWithArg<EditingTarget>() {

                           @Override

                           public void execute(EditingTarget arg)

                           {

                              server_.showPresentationPane(

                                          input.getPath(),