TypeScript FileTree.createResourcePath方法代码示例

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

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

 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
 }

 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
 }

 function updateStatusFocus(process) {
    var statusInfo: ProcessInfo = statusProcesses[process];
    
    if(statusInfo != null && statusInfo.getResource() != null){
       var statusResourcePath: FilePath = FileTree.createResourcePath(statusInfo.getResource());
       
       $("#toolbarDebug").css('opacity', '1.0');
       $("#toolbarDebug").css('filter', 'alpha(opacity=100)'); // msie
       
       // debug the status info
       //console.log(statusInfo);
       
       StatusPanel.showProcessStatus(statusInfo.getResource(), process, statusInfo.isDebug());
       //$("#process").html("<i>&nbsp;RUNNING: " + statusInfo.resource + " ("+process+")</i>");
    } else {
       $("#toolbarDebug").css('opacity', '0.4');
       $("#toolbarDebug").css('filter', 'alpha(opacity=40)'); // msie
       $("#process").html("");
       FileEditor.clearEditorHighlights(); // focus lost so clear breakpoints
    }
    if(statusFocus != process) {
       Profiler.clearProfiler(); // profiler does not apply
       ThreadManager.clearThreads(); // race condition here
       VariableManager.clearVariables();
    }
    ProcessConsole.updateConsoleFocus(process); // clear console if needed
    statusFocus = process;
 }

 export function clearSavedEditorBuffer(resource: string) {
    var editorResource: FilePath = FileTree.createResourcePath(resource);
    var editorHistory: FileEditorHistory = editorView.getHistoryForResource(editorResource);
    
    editorHistory.invalidateHistory();
    updateEditorTabMarkForResource(resource); // remove the *      
 } 

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

 export function showStatus() {
    var statusRecords = [];
    var statusIndex = 1;
    
    for (var statusProcess in statusProcesses) {
       if (statusProcesses.hasOwnProperty(statusProcess)) {
          var statusProcessInfo: ProcessInfo = statusProcesses[statusProcess];
          
          if(statusProcessInfo != null) {
             var statusProject: string = statusProcessInfo.getProject();
             
             if(statusProject == Common.getProjectName() || statusProject == null) {
                var displayName = "<div class='debugIdleRecord'>"+statusProcess+"</div>";
                var active = "&nbsp;<input type='radio'><label></label>";
                var resourcePath = "";
                var debugging: boolean = statusProcessInfo.isDebug();
                var status: ProcessStatus = statusProcessInfo.getStatus();
                var running: boolean = false;
                
                if(statusFocus == statusProcess) {
                   active = "&nbsp;<input type='radio' checked><label></label>";
                }
                if(statusProcessInfo.getResource() != null) {
                   var resourcePathDetails: FilePath = FileTree.createResourcePath(statusProcessInfo.getResource());
                   
                   if(statusFocus == statusProcess && debugging) {
                      displayName = "<div class='debugFocusRecord'>"+statusProcess+"</div>";
                   } else {
                      displayName = "<div class='debugRecord'>"+statusProcess+"</div>";               
                   }
                   resourcePath = resourcePathDetails.getResourcePath();
                   running = true;
                } 
                statusRecords.push({
                   recid: statusIndex++,
                   name: displayName,
                   active: active,
                   process: statusProcess,
                   status: ProcessStatus[status],
                   running: running,
                   system: statusProcessInfo.getSystem(),
                   pid: statusProcessInfo.getPid(),
                   resource: statusProcessInfo.getResource(),
                   focus: statusFocus == statusProcess,
                   script: resourcePath
                });
             } else {
                console.log("Ignoring process " + statusProcess + " as it belongs to " + statusProject);
             }
          }
       }
    }
    Common.updateTableRecords(statusRecords, 'debug'); // update if changed only
 }