TypeScript tree.FilePath類代碼示例

 export function showEditorBreakpoints() {
    var allBreakpoints = editorView.getEditorBreakpoints();
    var breakpointRecords = [];
    var breakpointIndex = 1;
 
    for(var filePath in allBreakpoints) {
       if(allBreakpoints.hasOwnProperty(filePath)) {
          var breakpoints = allBreakpoints[filePath];
 
          for(var lineNumber in breakpoints) {
             if (breakpoints.hasOwnProperty(lineNumber)) {
                if (breakpoints[lineNumber] == true) {
                   var resourcePathDetails: FilePath = FileTree.createResourcePath(filePath);
                   var displayName = "<div class='breakpointEnabled'>"+resourcePathDetails.getProjectPath()+"</div>";
                   
                   breakpointRecords.push({
                      recid: breakpointIndex++,
                      name: displayName,
                      location : "Line " + lineNumber,
                      resource : resourcePathDetails.getProjectPath(),
                      line: parseInt(lineNumber),
                      script : resourcePathDetails.getResourcePath()
                   });
                }
             }
          }
       }
    }
    w2ui['breakpoints'].records = breakpointRecords;
    w2ui['breakpoints'].refresh();
    Command.updateScriptBreakpoints(); // update the breakpoints
 }

 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 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 dragAndDropFile(fileToMove: FileNode, moveTo: FileNode) {
      if(isDragAndDropFilePossible(fileToMove, moveTo)) {
         var originalPath: FilePath = fileToMove.getResource();
         var destinationPath: FilePath = moveTo.getResource();
         var fromPath = FileTree.cleanResourcePath(originalPath.getFilePath());
         var toPath = FileTree.cleanResourcePath(destinationPath.getFilePath() + "/" + originalPath.getFileName());
         
         console.log("source: " + fromPath + " destination: " + toPath);
         
         var message = {
            project : Common.getProjectName(),
            from : fromPath,
            to: toPath,
            dragAndDrop: true
         };
         EventBus.sendEvent("RENAME", message);

         if(fileToMove.isFolder()) {
            var children = fileToMove.getChildren();

            for(var i = 0; i < children.length; i++) {
                var oldChildPath = children[i];
                var newChildPath = Common.stringReplaceText(oldChildPath, fromPath, toPath);
                
                Project.renameEditorTab(FileTree.createResourcePath(oldChildPath), FileTree.createResourcePath(newChildPath)); // rename tabs if open
            }
         } else {
            Project.renameEditorTab(originalPath, FileTree.createResourcePath(toPath)); // rename tabs if open
         }
      }
   }

 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 updateProblems(socket, type, text) {
 	var problems = w2ui['problems'];
 	var message = JSON.parse(text);
 	var resourcePath: FilePath = FileTree.createResourcePath(message.resource);   	
 	var problemItem: ProblemItem = new ProblemItem(
          resourcePath,
 	      message.line,
 	      message.description,
 	      "<div class='errorDescription'>"+message.description+"</div>",
 	      message.project,
 	      message.time
 	);
 	if(message.line >= 0) {
 	   console.log("Add problem '" + problemItem.getDescription() + "' at line '" + problemItem.getLine() + "'");
 	} else {
 	   console.log("Clear all problems for " + problemItem.getResourcePath() + "");
 	}  	
 	
 	if(problemItem.getLine() >= 0) {
 	   currentProblems[problemItem.getKey()] = problemItem;
 	} else {
       for (var problemKey in currentProblems) {
          if (currentProblems.hasOwnProperty(problemKey)) {
             if(Common.stringStartsWith(problemKey, resourcePath.getResourcePath())) {
                currentProblems[problemKey] = null;
             }
          }
       }
 	}
 	showProblems(); // if it has changed then highlight
 }

 export function showActiveFile(resource: string) {
    var resourcePath: FilePath = FileTree.createResourcePath(resource);
    var pathSegments = resourcePath.getProjectPath().split("/");
    var pathBreadcrumb = "";
    
    pathBreadcrumb += "<table border='0'>\n";
    pathBreadcrumb += "<tr>\n";
    pathBreadcrumb += "<td><div class='treeIndexFolder'></div><td>\n";
    pathBreadcrumb += "<td>"+Common.getProjectName()+"</td>\n";
    
    for(var i = 0; i < pathSegments.length; i++) {
       var segment = pathSegments[i];
       
       if(segment.length > 0) {
          pathBreadcrumb += "<td><div class='";
          
          if(segment.indexOf(".") != -1){
             pathBreadcrumb += "treeFile";
          } else {
             pathBreadcrumb += "treeFileFolder";
          }
          pathBreadcrumb += "'></div>";
          pathBreadcrumb += "</td>\n<td style='white-space: nowrap;'>";
          pathBreadcrumb += segment;
          pathBreadcrumb += "</td>\n";
       }
    }
    pathBreadcrumb += "</table>";
    
    $("#currentFile").html(pathBreadcrumb);
 }

 DialogBuilder.createArchiveTreeDialog(savePath, function(resourceDetails: FilePath) {
    var message = {
       project: Common.getProjectName(),
       resource: mainScript.getProjectPath(),
       archive: resourceDetails.getProjectPath()
    };
    EventBus.sendEvent("CREATE_ARCHIVE", message);
 });

 FileTree.createTreeOfDepth(treePath, "dialog", "dialogTree", "/" + Common.getProjectName(), true, null, function(event, data) {
    var selectedFileDetails: FilePath = FileTree.createResourcePath(data.node.tooltip);
    var selectedDirectory = selectedFileDetails.getProjectDirectory();
    
    if(selectedDirectory.indexOf("/") == 0) {
       selectedDirectory = selectedDirectory.substring(1);
    }
    $('#dialogPath').html(FileTree.cleanResourcePath(selectedDirectory));
 }, 2);