TypeScript editor.FileEditor类代码示例

 export function highlightProblems(){
    var editorState: FileEditorState = FileEditor.currentEditorState();
    var editorResource: FilePath = editorState.getResource();
    
    if(editorResource != null) {
       var highlightUpdates = [];
       
       //FileEditor.clearEditorHighlights(); this makes breakpoints jitter
       for (var problemKey in currentProblems) {
          if (currentProblems.hasOwnProperty(problemKey)) {
             if(Common.stringStartsWith(problemKey, editorResource.getResourcePath())) {
                var problemItem: ProblemItem = currentProblems[problemKey];
                
                if(problemItem != null) {                     
                   highlightUpdates.push(problemItem.getLine()); 
                }
             } 
          }
       }
       FileEditor.clearEditorHighlights(); 
       
       if(highlightUpdates.length > 0) {
          FileEditor.createMultipleEditorHighlights(highlightUpdates, "problemHighlight");
       }
    }
 }

 function findOutline(text, onComplete) {
    let originalExpression = text; // keep track of the requested expression
    
    if(text || text == "") {  
       let line = FileEditor.getCurrentLineForEditor();
       let editorState: FileEditorState = FileEditor.currentEditorState();
       let message = JSON.stringify({
          resource: editorState.getResource().getProjectPath(),
          line: line,
          complete: originalExpression.trim(),
          source: editorState.getSource()
       });
       $.ajax({
          contentType: 'application/json',
          data: message,
          dataType: 'json',
          success: function(response){
             var outlinesFound = response.outlines;
             var outlineDetails = [];
             
             for (var outlineName in outlinesFound) {
                if (outlinesFound.hasOwnProperty(outlineName)) {
                   var outlineDetail = outlinesFound[outlineName];
                   
                   outlineDetails.push({
                      name: outlineName,
                      type: outlineDetail.type,
                      resource: outlineDetail.resource,
                      line: outlineDetail.line,
                      constraint: outlineDetail.constraint,
                      declaringClass: outlineDetail.declaringClass,
                      libraryPath: outlineDetail.libraryPath
                   });
                }
             }
             onComplete(outlineDetails, originalExpression);
          },
          error: function(response){
              onComplete([], originalExpression);
              console.log("Could not complete outline for text '" + originalExpression + "'", message);
          },
          async: true,
          processData: false,
          type: 'POST',
          url: '/outline/' + Common.getProjectName()
      });
    } else {
       onComplete([], originalExpression);
    }
 }

 function saveEditor(update) {
    var editorState: FileEditorState = FileEditor.currentEditorState();
    var editorPath: FilePath = editorState.getResource();
      
    if(editorPath != null) {
       var message = {
          project : Common.getProjectName(),
          resource : editorPath.getFilePath(),
          source : editorState.getSource(),
          directory: false,
          create: false
       };
       ProcessConsole.clearConsole();
       EventBus.sendEvent("SAVE", message);
       
       if(update) { // should the editor be updated?
          return function() {
             var modificationTime: number = new Date().getTime();
             var fileResource: FileResource = new FileResource(editorPath, null, modificationTime, editorState.getSource(), null, false, false);
             
             FileEditor.updateEditor(fileResource);
          };
       }
    }
    return function(){}
 }

   function createKeyBinding(name, description, preventDefault, pressAction) {
      var keyBinding = parseKeyBinding(name);      
//      var editor = ace.edit("editor");
//       
//      console.log(keyBinding.editor);
//      editor.commands.addCommand({
//           name : name,
//           bindKey : {
//               win : keyBinding.editor,
//               mac : keyBinding.editor
//           },
//           exec : function(editor) {
//              if(pressAction) { 
//                 pressAction();
//              }
//           }
//      });
      keyBindings[keyBinding.editor] = Common.escapeHtml(description);
      FileEditor.addEditorKeyBinding(keyBinding, pressAction);
      Mousetrap.bindGlobal(keyBinding.global, function(e) {
         if(pressAction) {
            pressAction();
         }
         return !preventDefault;
      });
   }

 export function showFileHistory() {
    var editorState: FileEditorState = FileEditor.currentEditorState();
    var editorPath: FilePath = editorState.getResource();
 
    if(!editorPath) {
       console.log("Editor path does not exist: ", editorState);
    }
    var resource = editorPath.getProjectPath();
    
    $.ajax({
       url: '/history/' + Common.getProjectName() + '/' + resource,
       success: function (currentRecords) {
          var historyRecords = [];
          var historyIndex = 1;
          
          for (var i = 0; i < currentRecords.length; i++) {
             var currentRecord = currentRecords[i];
             var recordResource: FilePath = FileTree.createResourcePath(currentRecord.path);
             
             historyRecords.push({ 
                recid: historyIndex++,
                resource: "<div class='historyPath'>" + recordResource.getFilePath() + "</div>", // /blah/file.snap 
                date: currentRecord.date,
                time: currentRecord.timeStamp,
                script: recordResource.getResourcePath() // /resource/<project>/blah/file.snap
             });
          }
          w2ui['history'].records = historyRecords;
          w2ui['history'].refresh();
       },
       async: true
    });
 }

 export function evaluateExpression() {
    var threadScope = ThreadManager.focusedThread();
    if (threadScope != null) {
       var selectedText = FileEditor.getSelectedText();
       DialogBuilder.evaluateExpressionDialog(selectedText);
    }
 }

 export function updateScriptBreakpoints() {
    var editorState: FileEditorState = FileEditor.currentEditorState();
    var message = {
       breakpoints : editorState.getBreakpoints(),
       project : Common.getProjectName(),
    };
    EventBus.sendEvent("BREAKPOINTS", message);
 }

 export function resumeScript() {
    var threadScope: ThreadScope = ThreadManager.focusedThread();
    if(threadScope != null) {
       var message = {
          thread: threadScope.getThread(),
          type: "RUN"
       };
       FileEditor.clearEditorHighlights(); 
       EventBus.sendEvent("STEP", message);
    }
 }

 export function attachProcess(process) {
    var statusFocus = DebugManager.currentStatusFocus(); // what is the current focus
    var editorState: FileEditorState = FileEditor.currentEditorState();
    var message = {
       process: process,
       breakpoints : editorState.getBreakpoints(),
       project : Common.getProjectName(),
       focus: statusFocus != process // toggle the focus
    };
    EventBus.sendEvent("ATTACH", message); // attach to process
 }

 function handleOpenTreeFile(responseObject: FileResource, afterLoad) {
    //console.log(responseObject);
    
    if(isImageFileType(responseObject.getContentType())) {
       handleOpenFileInNewTab(responseObject.getDownloadURL());
    } else if(isBinaryFileType(responseObject.getContentType())) {
       handleDownloadFile(responseObject.getDownloadURL());
    } else {
       FileEditor.updateEditor(responseObject);
    }
    afterLoad();
 }