TypeScript editor.FileEditorState类代码示例

 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
    });
 }

 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(){}
 }

 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");
       }
    }
 }

 export function updateScriptBreakpoints() {
    var editorState: FileEditorState = FileEditor.currentEditorState();
    var message = {
       breakpoints : editorState.getBreakpoints(),
       project : Common.getProjectName(),
    };
    EventBus.sendEvent("BREAKPOINTS", 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 executeScriptWithArguments(debug, inputArguments) {
    var editorState: FileEditorState = FileEditor.currentEditorState();
    var argumentArray = inputArguments.split(/[ ]+/)
    var message = {
       breakpoints : editorState.getBreakpoints(),
       arguments: argumentArray,
       project : Common.getProjectName(),
       resource : editorState.getResource().getFilePath(),
       source : editorState.getSource(),
       debug: debug ? true: false
    };
    EventBus.sendEvent("EXECUTE", message);
 };

 findFilesWithText(matchText, filePatterns, searchCriteria, function(filesReplaced){
    var editorState: FileEditorState = FileEditor.currentEditorState();
    
    for(var i = 0; i < filesReplaced.length; i++) {
       var fileReplaced = filesReplaced[i];
       var fileReplacedResource: FilePath = FileTree.createResourcePath("/resource/" + fileReplaced.project + "/" + fileReplaced.resource);
       
       if(editorState.getResource().getResourcePath() == fileReplacedResource.getResourcePath()) {
          FileExplorer.openTreeFile(fileReplacedResource.getResourcePath(), function() {
             //FileEditor.showEditorLine(record.line);  
          }); 
       }
    }
 });

 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 updateEditorFromHistory(){
    var location = window.location.hash;
    var hashIndex = location.indexOf('#');
    
    if(hashIndex != -1) {
       var resource = location.substring(hashIndex + 1);
       var resourceData: FilePath = FileTree.createResourcePath(resource);
       var editorState: FileEditorState = FileEditor.currentEditorState();
       var editorResource: FilePath = editorState.getResource();
       
       if(editorResource == null || editorResource.getResourcePath() != resourceData.getResourcePath()) { // only if changed
          FileExplorer.openTreeFile(resourceData.getResourcePath(), function() {});
       }
    }
 }

 function saveFileWithAction(update, saveCallback) {
    var editorState: FileEditorState = FileEditor.currentEditorState();
 
    if (editorState.getResource() == null) {
       DialogBuilder.openTreeDialog(null, false, function(resourceDetails: FilePath) {
          var saveFunction = saveEditor(update);
          saveCallback(saveFunction);
       });
    } else {
       if (FileEditor.isEditorChanged()) {
          // XXX don't prompt
          //DialogBuilder.openTreeDialog(editorState.getResource(), true, function(resourceDetails: FilePath) {
             var saveFunction = saveEditor(update);
             saveCallback(saveFunction);
          //});
       } else {
          ProcessConsole.clearConsole();
          saveCallback(function(){});
       }
    }
 }