executeIfTextUnchanged(expressionText, "dialogPath", 300, function() {
    var expressionPattern = null;
    
    if(patternList) {
       expressionPattern = $("#dialogFolder").html();
       expressionPattern = Common.clearHtml(expressionPattern);
    }
    if(expressionText) {
       expressionText = Common.clearHtml(expressionText);
    } 
    listFunction(expressionText, expressionPattern, function(list, requestedExpression) {
       var currentExpression = $("#dialogPath").html();
       
       if(!requestedExpression || requestedExpression == currentExpression) {
          var content = createDialogListTable(list);
          
          if(content.content){
             $("#dialog").html(content.content);
          }else {
             $("#dialog").html('');
          }
          // this is kind of crap, but we need to be sure the html is rendered before binding
          if(content.init) {
             setTimeout(content.init, 100); // register the init function to run 
          }
       }
    });
 });

   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 folderCollapse(resourcePath: string) {
    var message = {
       project: Common.getProjectName(),
       folder : resourcePath
    };
    EventBus.sendEvent("FOLDER_COLLAPSE", message);
 }

 success: function (typeMatches) {
    var sortedMatches = [];
    
    for (var typeMatch in typeMatches) {
       if (typeMatches.hasOwnProperty(typeMatch)) {
          sortedMatches.push(typeMatch);
       }
    }  
    sortedMatches.sort();
    var response = [];
    for(var i = 0; i < sortedMatches.length; i++) {
       var sortedMatch = sortedMatches[i];
       var typeReference = typeMatches[sortedMatch];
       var typeEntry = {
          name: typeReference.name,
          resource: typeReference.resource,
          module: typeReference.module,
          extra: typeReference.extra,
          type: typeReference.type,
          project: Common.getProjectName()
       };
       response.push(typeEntry);
    }
    onComplete(response, originalExpression);
 },

 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 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 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 showProblems(): boolean {
    var problemRecords = [];
    var problemIndex = 1;
    
    for (var problemKey in currentProblems) {
       if (currentProblems.hasOwnProperty(problemKey)) {
          var problemItem: ProblemItem = currentProblems[problemKey];
          
       	if(problemItem != null) {
       	   problemRecords.push({ 
       	      recid: problemIndex++,
       		   line: problemItem.getLine(),
       		   location: "Line " + problemItem.getLine(), 
                resource: problemItem.getResourcePath().getFilePath(), // /blah/file.snap 
                description: problemItem.getMessage(), 
                project: problemItem.getProject(), 
                script: problemItem.getResourcePath().getResourcePath() // /resource/<project>/blah/file.snap
             });
       	}
       }
    }
    if(Common.updateTableRecords(problemRecords, 'problems')) {
       highlightProblems(); // highlight them also      
       Project.showProblemsTab(); // focus the problems tab
       return true;
    }
    return false;
 }

 function updateNodesAsDraggable(nodeElement) {
    var childNodes = Common.getElementsByClassName(nodeElement, 'fancytree-node');
    
    for(var i = 0; i < childNodes.length; i++) {
       let childNode = childNodes[i];
       
       if(childNode){
          childNode.setAttribute("draggable", "true");
          $(childNode).on('dragstart',function(event){
             var dataTransfer = event.target.dataTransfer || event.originalEvent.dataTransfer
             var target = event.target || event.currentTarger;
             var titleNodes = Common.getElementsByClassName(childNode, 'fancytree-title');
             
             if(titleNodes && titleNodes.length > 0) {
                var titleNode = titleNodes[0];
                
                dataTransfer.setData("resource", JSON.stringify({
                   resource: titleNode.getAttribute("title"),
                   folder: isTreeNodeFolder(target) // this does not work
                }));
             }
          })
       }
    }  
 }