Removing AtomicEditor JS prototype

Resources/EditorData/AtomicEditor/javascript/AtomicEditor.js

@@ -1,99 +0,0 @@
-__atomic_acorn = require('acorn');
-__atomic_acorn_loose = require('acorn_loose');
-__atomic_beautify = require('beautify');
-
-function __atomic_parse_to_json(source) {
-
-	var start = new Date().getTime();
-		
-	var comments = [];
-
-	var ast = __atomic_acorn.parse( source, {
-    	// collect ranges for each node
-    	ranges: true,
-    	locations: true,
-    	onComment: comments,
-	});	
-
-	var end = new Date().getTime();
-	var time = end - start;	
-
-	// print('Acorn parse time: ' + time);
-
-	ast["comments"] = comments;
-
-	start = new Date().getTime();
-	ast = JSON.stringify(ast);
-	end = new Date().getTime();
-	time = end - start;	
-
-	// print('JSON.stringify time: ' + time);
-
-	return ast;
-
-}
-
-function __atomic_parse_to_json_loose(source) {
-
-	var start = new Date().getTime();
-		
-	var comments = [];
-
-	var ast = __atomic_acorn_loose.parse_dammit( source, {
-    	// collect ranges for each node
-    	ranges: true,
-    	locations: true,
-    	onComment: comments,
-	});	
-
-	var end = new Date().getTime();
-	var time = end - start;	
-
-	// print('Acorn parse time: ' + time);
-
-	ast["comments"] = comments;
-
-	start = new Date().getTime();
-	ast = JSON.stringify(ast);
-	end = new Date().getTime();
-	time = end - start;	
-
-	// print('JSON.stringify time: ' + time);
-
-	return ast;
-
-}
-
-
-function __atomic_parse_error_check(source) {
-		
-	
-	try {	
-
-		__atomic_acorn.parse( source, {
-	    	ranges: true,
-	    	locations: true,
-		});	
-
-	} catch(e) {
-
-        //if (!(e instanceof __atomic_acorn.SyntaxError)) throw e;
-
-        if (!(e instanceof SyntaxError))
-        	return false; // rethrow?
-
-        return e;
-
-    }
-
-
-	return false;
-
-}
-
-// TODO: options
-function __atomic_js_beautify(source) {
-
-	return __atomic_beautify.js_beautify(source);
-
-}

Resources/EditorData/AtomicEditor/javascript/main.js

@@ -1,20 +0,0 @@
-
-var ui = require("./ui/ui");
-
-var env = ToolCore.getToolEnvironment();
-
-print(env.rootSourceDir);
-
-var system = ToolCore.getToolSystem();
-
-system.loadProject("/Users/josh/Dev/atomic/AtomicExamples/NewSpaceGame");
-
-var cool = new Editor.MyJSClass();
-print(cool.aha);
-
-
-( function() {
-
-
-
-}());

Resources/EditorData/AtomicEditor/javascript/modules/acorn_loose.js

@@ -1,1167 +0,0 @@
-// Acorn: Loose parser
-//
-// This module provides an alternative parser (`parse_dammit`) that
-// exposes that same interface as `parse`, but will try to parse
-// anything as JavaScript, repairing syntax error the best it can.
-// There are circumstances in which it will raise an error and give
-// up, but they are very rare. The resulting AST will be a mostly
-// valid JavaScript AST (as per the [Mozilla parser API][api], except
-// that:
-//
-// - Return outside functions is allowed
-//
-// - Label consistency (no conflicts, break only to existing labels)
-//   is not enforced.
-//
-// - Bogus Identifier nodes with a name of `"✖"` are inserted whenever
-//   the parser got too confused to return anything meaningful.
-//
-// [api]: https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API
-//
-// The expected use for this is to *first* try `acorn.parse`, and only
-// if that fails switch to `parse_dammit`. The loose parser might
-// parse badly indented code incorrectly, so **don't** use it as
-// your default parser.
-//
-// Quite a lot of acorn.js is duplicated here. The alternative was to
-// add a *lot* of extra cruft to that file, making it less readable
-// and slower. Copying and editing the code allowed me to make
-// invasive changes and simplifications without creating a complicated
-// tangle.
-
-(function(root, mod) {
-  if (typeof exports == "object" && typeof module == "object") return mod(exports, require("./acorn")); // CommonJS
-  if (typeof define == "function" && define.amd) return define(["exports", "./acorn"], mod); // AMD
-  mod(root.acorn || (root.acorn = {}), root.acorn); // Plain browser env
-})(this, function(exports, acorn) {
-  "use strict";
-
-  var tt = acorn.tokTypes;
-
-  var options, input, fetchToken, context;
-
-  acorn.defaultOptions.tabSize = 4;
-
-  exports.parse_dammit = function(inpt, opts) {
-    if (!opts) opts = {};
-    input = String(inpt);
-    fetchToken = acorn.tokenize(input, opts);
-    options = fetchToken.options;
-    sourceFile = options.sourceFile || null;
-    context = [];
-    nextLineStart = 0;
-    ahead.length = 0;
-    next();
-    return parseTopLevel();
-  };
-
-  var lastEnd, token = {start: 0, end: 0}, ahead = [];
-  var curLineStart, nextLineStart, curIndent, lastEndLoc, sourceFile;
-
-  function next(forceRegexp) {
-    lastEnd = token.end;
-    if (options.locations)
-      lastEndLoc = token.endLoc;
-    if (forceRegexp)
-      ahead.length = 0;
-
-    token = ahead.shift() || readToken(forceRegexp);
-
-    if (token.start >= nextLineStart) {
-      while (token.start >= nextLineStart) {
-        curLineStart = nextLineStart;
-        nextLineStart = lineEnd(curLineStart) + 1;
-      }
-      curIndent = indentationAfter(curLineStart);
-    }
-  }
-
-  function readToken(forceRegexp) {
-    for (;;) {
-      try {
-        var tok = fetchToken(forceRegexp);
-        if (tok.type === tt.dot && input.substr(tok.end, 1) === '.') {
-          tok = fetchToken();
-          tok.start--;
-          tok.type = tt.ellipsis;
-        }
-        return tok;
-      } catch(e) {
-        if (!(e instanceof SyntaxError)) throw e;
-
-        // Try to skip some text, based on the error message, and then continue
-        var msg = e.message, pos = e.raisedAt, replace = true;
-        if (/unterminated/i.test(msg)) {
-          pos = lineEnd(e.pos + 1);
-          if (/string/.test(msg)) {
-            replace = {start: e.pos, end: pos, type: tt.string, value: input.slice(e.pos + 1, pos)};
-          } else if (/regular expr/i.test(msg)) {
-            var re = input.slice(e.pos, pos);
-            try { re = new RegExp(re); } catch(e) {}
-            replace = {start: e.pos, end: pos, type: tt.regexp, value: re};
-          } else if (/template/.test(msg)) {
-            replace = {start: e.pos, end: pos,
-                       type: input.charAt(e.pos) == "`" ? tt.template : tt.templateContinued,
-                       value: input.slice(e.pos + 1, pos)};
-          } else {
-            replace = false;
-          }
-        } else if (/invalid (unicode|regexp|number)|expecting unicode|octal literal|is reserved|directly after number/i.test(msg)) {
-          while (pos < input.length && !isSpace(input.charCodeAt(pos))) ++pos;
-        } else if (/character escape|expected hexadecimal/i.test(msg)) {
-          while (pos < input.length) {
-            var ch = input.charCodeAt(pos++);
-            if (ch === 34 || ch === 39 || isNewline(ch)) break;
-          }
-        } else if (/unexpected character/i.test(msg)) {
-          pos++;
-          replace = false;
-        } else if (/regular expression/i.test(msg)) {
-          replace = true;
-        } else {
-          throw e;
-        }
-        resetTo(pos);
-        if (replace === true) replace = {start: pos, end: pos, type: tt.name, value: "✖"};
-        if (replace) {
-          if (options.locations) {
-            replace.startLoc = acorn.getLineInfo(input, replace.start);
-            replace.endLoc = acorn.getLineInfo(input, replace.end);
-          }
-          return replace;
-        }
-      }
-    }
-  }
-
-  function resetTo(pos) {
-    for (;;) {
-      try {
-        var ch = input.charAt(pos - 1);
-        var reAllowed = !ch || /[\[\{\(,;:?\/*=+\-~!|&%^<>]/.test(ch) ||
-          /[enwfd]/.test(ch) && /\b(keywords|case|else|return|throw|new|in|(instance|type)of|delete|void)$/.test(input.slice(pos - 10, pos));
-        return fetchToken.jumpTo(pos, reAllowed);
-      } catch(e) {
-        if (!(e instanceof SyntaxError && /unterminated comment/i.test(e.message))) throw e;
-        pos = lineEnd(e.pos + 1);
-        if (pos >= input.length) return;
-      }
-    }
-  }
-
-  function lookAhead(n) {
-    while (n > ahead.length)
-      ahead.push(readToken());
-    return ahead[n-1];
-  }
-
-  var newline = /[\n\r\u2028\u2029]/;
-
-  function isNewline(ch) {
-    return ch === 10 || ch === 13 || ch === 8232 || ch === 8329;
-  }
-  function isSpace(ch) {
-    return (ch < 14 && ch > 8) || ch === 32 || ch === 160 || isNewline(ch);
-  }
-
-  function pushCx() {
-    context.push(curIndent);
-  }
-  function popCx() {
-    curIndent = context.pop();
-  }
-
-  function lineEnd(pos) {
-    while (pos < input.length && !isNewline(input.charCodeAt(pos))) ++pos;
-    return pos;
-  }
-  function indentationAfter(pos) {
-    for (var count = 0;; ++pos) {
-      var ch = input.charCodeAt(pos);
-      if (ch === 32) ++count;
-      else if (ch === 9) count += options.tabSize;
-      else return count;
-    }
-  }
-
-  function closes(closeTok, indent, line, blockHeuristic) {
-    if (token.type === closeTok || token.type === tt.eof) return true;
-    if (line != curLineStart && curIndent < indent && tokenStartsLine() &&
-        (!blockHeuristic || nextLineStart >= input.length ||
-         indentationAfter(nextLineStart) < indent)) return true;
-    return false;
-  }
-
-  function tokenStartsLine() {
-    for (var p = token.start - 1; p >= curLineStart; --p) {
-      var ch = input.charCodeAt(p);
-      if (ch !== 9 && ch !== 32) return false;
-    }
-    return true;
-  }
-
-  function Node(start) {
-    this.type = null;
-    this.start = start;
-    this.end = null;
-  }
-  Node.prototype = acorn.Node.prototype;
-
-  function SourceLocation(start) {
-    this.start = start || token.startLoc || {line: 1, column: 0};
-    this.end = null;
-    if (sourceFile !== null) this.source = sourceFile;
-  }
-
-  function startNode() {
-    var node = new Node(token.start);
-    if (options.locations)
-      node.loc = new SourceLocation();
-    if (options.directSourceFile)
-      node.sourceFile = options.directSourceFile;
-    if (options.ranges)
-      node.range = [token.start, 0];
-    return node;
-  }
-
-  function storeCurrentPos() {
-    return options.locations ? [token.start, token.startLoc] : token.start;
-  }
-
-  function startNodeAt(pos) {
-    var node;
-    if (options.locations) {
-      node = new Node(pos[0]);
-      node.loc = new SourceLocation(pos[1]);
-    } else {
-      node = new Node(pos);
-    }
-    if (options.directSourceFile)
-      node.sourceFile = options.directSourceFile;
-    if (options.ranges)
-      node.range = [pos[0], 0];
-    return node;
-  }
-
-  function finishNode(node, type) {
-    node.type = type;
-    node.end = lastEnd;
-    if (options.locations)
-      node.loc.end = lastEndLoc;
-    if (options.ranges)
-      node.range[1] = lastEnd;
-    return node;
-  }
-
-  function finishNodeAt(node, type, pos) {
-    if (options.locations) { node.loc.end = pos[1]; pos = pos[0]; }
-    node.type = type;
-    node.end = pos;
-    if (options.ranges) node.range[1] = pos;
-    return node;
-  }
-
-  function dummyIdent() {
-    var dummy = startNode();
-    dummy.name = "✖";
-    return finishNode(dummy, "Identifier");
-  }
-  function isDummy(node) { return node.name == "✖"; }
-
-  function eat(type) {
-    if (token.type === type) {
-      next();
-      return true;
-    } else {
-      return false;
-    }
-  }
-
-  function canInsertSemicolon() {
-    return (token.type === tt.eof || token.type === tt.braceR || newline.test(input.slice(lastEnd, token.start)));
-  }
-  function semicolon() {
-    return eat(tt.semi);
-  }
-
-  function expect(type) {
-    if (eat(type)) return true;
-    if (lookAhead(1).type == type) {
-      next(); next();
-      return true;
-    }
-    if (lookAhead(2).type == type) {
-      next(); next(); next();
-      return true;
-    }
-  }
-
-  function checkLVal(expr) {
-    if (!expr) return expr;
-    switch (expr.type) {
-      case "Identifier":
-      case "MemberExpression":
-      case "ObjectPattern":
-      case "ArrayPattern":
-      case "SpreadElement":
-        return expr;
-
-      default:
-        return dummyIdent();
-    }
-  }
-
-  function parseTopLevel() {
-    var node = startNodeAt(options.locations ? [0, acorn.getLineInfo(input, 0)] : 0);
-    node.body = [];
-    while (token.type !== tt.eof) node.body.push(parseStatement());
-    lastEnd = token.end;
-    lastEndLoc = token.endLoc;
-    return finishNode(node, "Program");
-  }
-
-  function parseStatement() {
-    if (token.type === tt.slash || token.type === tt.assign && token.value === "/=")
-      next(true);
-
-    var starttype = token.type, node = startNode();
-
-    switch (starttype) {
-    case tt._break: case tt._continue:
-      next();
-      var isBreak = starttype === tt._break;
-      if (semicolon() || canInsertSemicolon()) {
-        node.label = null;
-      } else {
-        node.label = token.type === tt.name ? parseIdent() : null;
-        semicolon();
-      }
-      return finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
-
-    case tt._debugger:
-      next();
-      semicolon();
-      return finishNode(node, "DebuggerStatement");
-
-    case tt._do:
-      next();
-      node.body = parseStatement();
-      node.test = eat(tt._while) ? parseParenExpression() : dummyIdent();
-      semicolon();
-      return finishNode(node, "DoWhileStatement");
-
-    case tt._for:
-      next();
-      pushCx();
-      expect(tt.parenL);
-      if (token.type === tt.semi) return parseFor(node, null);
-      if (token.type === tt._var || token.type === tt._let) {
-        var init = parseVar(true);
-        if (init.declarations.length === 1 && (token.type === tt._in || token.type === tt.name && token.value === "of")) {
-          return parseForIn(node, init);
-        }
-        return parseFor(node, init);
-      }
-      var init = parseExpression(false, true);
-      if (token.type === tt._in || token.type === tt.name && token.value === "of") {
-        return parseForIn(node, checkLVal(init));
-      }
-      return parseFor(node, init);
-
-    case tt._function:
-      next();
-      return parseFunction(node, true);
-
-    case tt._if:
-      next();
-      node.test = parseParenExpression();
-      node.consequent = parseStatement();
-      node.alternate = eat(tt._else) ? parseStatement() : null;
-      return finishNode(node, "IfStatement");
-
-    case tt._return:
-      next();
-      if (eat(tt.semi) || canInsertSemicolon()) node.argument = null;
-      else { node.argument = parseExpression(); semicolon(); }
-      return finishNode(node, "ReturnStatement");
-
-    case tt._switch:
-      var blockIndent = curIndent, line = curLineStart;
-      next();
-      node.discriminant = parseParenExpression();
-      node.cases = [];
-      pushCx();
-      expect(tt.braceL);
-
-      for (var cur; !closes(tt.braceR, blockIndent, line, true);) {
-        if (token.type === tt._case || token.type === tt._default) {
-          var isCase = token.type === tt._case;
-          if (cur) finishNode(cur, "SwitchCase");
-          node.cases.push(cur = startNode());
-          cur.consequent = [];
-          next();
-          if (isCase) cur.test = parseExpression();
-          else cur.test = null;
-          expect(tt.colon);
-        } else {
-          if (!cur) {
-            node.cases.push(cur = startNode());
-            cur.consequent = [];
-            cur.test = null;
-          }
-          cur.consequent.push(parseStatement());
-        }
-      }
-      if (cur) finishNode(cur, "SwitchCase");
-      popCx();
-      eat(tt.braceR);
-      return finishNode(node, "SwitchStatement");
-
-    case tt._throw:
-      next();
-      node.argument = parseExpression();
-      semicolon();
-      return finishNode(node, "ThrowStatement");
-
-    case tt._try:
-      next();
-      node.block = parseBlock();
-      node.handler = null;
-      if (token.type === tt._catch) {
-        var clause = startNode();
-        next();
-        expect(tt.parenL);
-        clause.param = parseIdent();
-        expect(tt.parenR);
-        clause.guard = null;
-        clause.body = parseBlock();
-        node.handler = finishNode(clause, "CatchClause");
-      }
-      node.finalizer = eat(tt._finally) ? parseBlock() : null;
-      if (!node.handler && !node.finalizer) return node.block;
-      return finishNode(node, "TryStatement");
-
-    case tt._var:
-    case tt._let:
-    case tt._const:
-      return parseVar();
-
-    case tt._while:
-      next();
-      node.test = parseParenExpression();
-      node.body = parseStatement();
-      return finishNode(node, "WhileStatement");
-
-    case tt._with:
-      next();
-      node.object = parseParenExpression();
-      node.body = parseStatement();
-      return finishNode(node, "WithStatement");
-
-    case tt.braceL:
-      return parseBlock();
-
-    case tt.semi:
-      next();
-      return finishNode(node, "EmptyStatement");
-
-    case tt._class:
-      return parseObj(true, true);
-
-    case tt._import:
-      return parseImport();
-
-    case tt._export:
-      return parseExport();
-
-    default:
-      var expr = parseExpression();
-      if (isDummy(expr)) {
-        next();
-        if (token.type === tt.eof) return finishNode(node, "EmptyStatement");
-        return parseStatement();
-      } else if (starttype === tt.name && expr.type === "Identifier" && eat(tt.colon)) {
-        node.body = parseStatement();
-        node.label = expr;
-        return finishNode(node, "LabeledStatement");
-      } else {
-        node.expression = expr;
-        semicolon();
-        return finishNode(node, "ExpressionStatement");
-      }
-    }
-  }
-
-  function parseBlock() {
-    var node = startNode();
-    pushCx();
-    expect(tt.braceL);
-    var blockIndent = curIndent, line = curLineStart;
-    node.body = [];
-    while (!closes(tt.braceR, blockIndent, line, true))
-      node.body.push(parseStatement());
-    popCx();
-    eat(tt.braceR);
-    return finishNode(node, "BlockStatement");
-  }
-
-  function parseFor(node, init) {
-    node.init = init;
-    node.test = node.update = null;
-    if (eat(tt.semi) && token.type !== tt.semi) node.test = parseExpression();
-    if (eat(tt.semi) && token.type !== tt.parenR) node.update = parseExpression();
-    popCx();
-    expect(tt.parenR);
-    node.body = parseStatement();
-    return finishNode(node, "ForStatement");
-  }
-
-  function parseForIn(node, init) {
-    var type = token.type === tt._in ? "ForInStatement" : "ForOfStatement";
-    next();
-    node.left = init;
-    node.right = parseExpression();
-    popCx();
-    expect(tt.parenR);
-    node.body = parseStatement();
-    return finishNode(node, type);
-  }
-
-  function parseVar(noIn) {
-    var node = startNode();
-    node.kind = token.type.keyword;
-    next();
-    node.declarations = [];
-    do {
-      var decl = startNode();
-      decl.id = options.ecmaVersion >= 6 ? toAssignable(parseExprAtom()) : parseIdent();
-      decl.init = eat(tt.eq) ? parseExpression(true, noIn) : null;
-      node.declarations.push(finishNode(decl, "VariableDeclarator"));
-    } while (eat(tt.comma));
-    if (!node.declarations.length) {
-      var decl = startNode();
-      decl.id = dummyIdent();
-      node.declarations.push(finishNode(decl, "VariableDeclarator"));
-    }
-    if (!noIn) semicolon();
-    return finishNode(node, "VariableDeclaration");
-  }
-
-  function parseExpression(noComma, noIn) {
-    var start = storeCurrentPos();
-    var expr = parseMaybeAssign(noIn);
-    if (!noComma && token.type === tt.comma) {
-      var node = startNodeAt(start);
-      node.expressions = [expr];
-      while (eat(tt.comma)) node.expressions.push(parseMaybeAssign(noIn));
-      return finishNode(node, "SequenceExpression");
-    }
-    return expr;
-  }
-
-  function parseParenExpression() {
-    pushCx();
-    expect(tt.parenL);
-    var val = parseExpression();
-    popCx();
-    expect(tt.parenR);
-    return val;
-  }
-
-  function parseMaybeAssign(noIn) {
-    var start = storeCurrentPos();
-    var left = parseMaybeConditional(noIn);
-    if (token.type.isAssign) {
-      var node = startNodeAt(start);
-      node.operator = token.value;
-      node.left = token.type === tt.eq ? toAssignable(left) : checkLVal(left);
-      next();
-      node.right = parseMaybeAssign(noIn);
-      return finishNode(node, "AssignmentExpression");
-    }
-    return left;
-  }
-
-  function parseMaybeConditional(noIn) {
-    var start = storeCurrentPos();
-    var expr = parseExprOps(noIn);
-    if (eat(tt.question)) {
-      var node = startNodeAt(start);
-      node.test = expr;
-      node.consequent = parseExpression(true);
-      node.alternate = expect(tt.colon) ? parseExpression(true, noIn) : dummyIdent();
-      return finishNode(node, "ConditionalExpression");
-    }
-    return expr;
-  }
-
-  function parseExprOps(noIn) {
-    var start = storeCurrentPos();
-    var indent = curIndent, line = curLineStart;
-    return parseExprOp(parseMaybeUnary(noIn), start, -1, noIn, indent, line);
-  }
-
-  function parseExprOp(left, start, minPrec, noIn, indent, line) {
-    if (curLineStart != line && curIndent < indent && tokenStartsLine()) return left;
-    var prec = token.type.binop;
-    if (prec != null && (!noIn || token.type !== tt._in)) {
-      if (prec > minPrec) {
-        var node = startNodeAt(start);
-        node.left = left;
-        node.operator = token.value;
-        next();
-        if (curLineStart != line && curIndent < indent && tokenStartsLine()) {
-          node.right = dummyIdent();
-        } else {
-          var rightStart = storeCurrentPos();
-          node.right = parseExprOp(parseMaybeUnary(noIn), rightStart, prec, noIn, indent, line);
-        }
-        finishNode(node, /&&|\|\|/.test(node.operator) ? "LogicalExpression" : "BinaryExpression");
-        return parseExprOp(node, start, minPrec, noIn, indent, line);
-      }
-    }
-    return left;
-  }
-
-  function parseMaybeUnary(noIn) {
-    if (token.type.prefix) {
-      var node = startNode(), update = token.type.isUpdate, nodeType;
-      if (token.type === tt.ellipsis) {
-        nodeType = "SpreadElement";
-      } else {
-        nodeType = update ? "UpdateExpression" : "UnaryExpression";
-        node.operator = token.value;
-        node.prefix = true;
-      }
-      node.operator = token.value;
-      node.prefix = true;
-      next();
-      node.argument = parseMaybeUnary(noIn);
-      if (update) node.argument = checkLVal(node.argument);
-      return finishNode(node, nodeType);
-    }
-    var start = storeCurrentPos();
-    var expr = parseExprSubscripts();
-    while (token.type.postfix && !canInsertSemicolon()) {
-      var node = startNodeAt(start);
-      node.operator = token.value;
-      node.prefix = false;
-      node.argument = checkLVal(expr);
-      next();
-      expr = finishNode(node, "UpdateExpression");
-    }
-    return expr;
-  }
-
-  function parseExprSubscripts() {
-    var start = storeCurrentPos();
-    return parseSubscripts(parseExprAtom(), start, false, curIndent, curLineStart);
-  }
-
-  function parseSubscripts(base, start, noCalls, startIndent, line) {
-    for (;;) {
-      if (curLineStart != line && curIndent <= startIndent && tokenStartsLine()) {
-        if (token.type == tt.dot && curIndent == startIndent)
-          --startIndent;
-        else
-          return base;
-      }
-
-      if (eat(tt.dot)) {
-        var node = startNodeAt(start);
-        node.object = base;
-        if (curLineStart != line && curIndent <= startIndent && tokenStartsLine())
-          node.property = dummyIdent();
-        else
-          node.property = parsePropertyAccessor() || dummyIdent();
-        node.computed = false;
-        base = finishNode(node, "MemberExpression");
-      } else if (token.type == tt.bracketL) {
-        pushCx();
-        next();
-        var node = startNodeAt(start);
-        node.object = base;
-        node.property = parseExpression();
-        node.computed = true;
-        popCx();
-        expect(tt.bracketR);
-        base = finishNode(node, "MemberExpression");
-      } else if (!noCalls && token.type == tt.parenL) {
-        pushCx();
-        var node = startNodeAt(start);
-        node.callee = base;
-        node.arguments = parseExprList(tt.parenR);
-        base = finishNode(node, "CallExpression");
-      } else if (token.type == tt.template) {
-        var node = startNodeAt(start);
-        node.tag = base;
-        node.quasi = parseTemplate();
-        base = finishNode(node, "TaggedTemplateExpression");
-      } else {
-        return base;
-      }
-    }
-  }
-
-  function parseExprAtom() {
-    switch (token.type) {
-    case tt._this:
-      var node = startNode();
-      next();
-      return finishNode(node, "ThisExpression");
-
-    case tt.name:
-      var start = storeCurrentPos();
-      var id = parseIdent();
-      return eat(tt.arrow) ? parseArrowExpression(startNodeAt(start), [id]) : id;
-
-    case tt.regexp:
-      var node = startNode();
-      var val = token.value;
-      node.regex = {pattern: val.pattern, flags: val.flags};
-      node.value = val.value;
-      node.raw = input.slice(token.start, token.end);
-      next();
-      return finishNode(node, "Literal");
-
-    case tt.num: case tt.string:
-      var node = startNode();
-      node.value = token.value;
-      node.raw = input.slice(token.start, token.end);
-      next();
-      return finishNode(node, "Literal");
-
-    case tt._null: case tt._true: case tt._false:
-      var node = startNode();
-      node.value = token.type.atomValue;
-      node.raw = token.type.keyword;
-      next();
-      return finishNode(node, "Literal");
-
-    case tt.parenL:
-      var start = storeCurrentPos();
-      next();
-      var val = parseExpression();
-      expect(tt.parenR);
-      if (eat(tt.arrow)) {
-        return parseArrowExpression(startNodeAt(start), val.expressions || (isDummy(val) ? [] : [val]));
-      }
-      if (options.preserveParens) {
-        var par = startNodeAt(start);
-        par.expression = val;
-        val = finishNode(par, "ParenthesizedExpression");
-      }
-      return val;
-
-    case tt.bracketL:
-      var node = startNode();
-      pushCx();
-      node.elements = parseExprList(tt.bracketR, true);
-      return finishNode(node, "ArrayExpression");
-
-    case tt.braceL:
-      return parseObj();
-
-    case tt._class:
-      return parseObj(true);
-
-    case tt._function:
-      var node = startNode();
-      next();
-      return parseFunction(node, false);
-
-    case tt._new:
-      return parseNew();
-
-    case tt._yield:
-      var node = startNode();
-      next();
-      if (semicolon() || canInsertSemicolon()) {
-        node.delegate = false;
-        node.argument = null;
-      } else {
-        node.delegate = eat(tt.star);
-        node.argument = parseExpression(true);
-      }
-      return finishNode(node, "YieldExpression");
-
-    case tt.template:
-      return parseTemplate();
-
-    default:
-      return dummyIdent();
-    }
-  }
-
-  function parseNew() {
-    var node = startNode(), startIndent = curIndent, line = curLineStart;
-    next();
-    var start = storeCurrentPos();
-    node.callee = parseSubscripts(parseExprAtom(), start, true, startIndent, line);
-    if (token.type == tt.parenL) {
-      pushCx();
-      node.arguments = parseExprList(tt.parenR);
-    } else {
-      node.arguments = [];
-    }
-    return finishNode(node, "NewExpression");
-  }
-
-  function parseTemplateElement() {
-    var elem = startNodeAt(options.locations ? [token.start + 1, token.startLoc.offset(1)] : token.start + 1);
-    elem.value = token.value;
-    elem.tail = input.charCodeAt(token.end - 1) !== 123; // '{'
-    var endOff = elem.tail ? 1 : 2;
-    var endPos = options.locations ? [token.end - endOff, token.endLoc.offset(-endOff)] : token.end - endOff;
-    next();
-    return finishNodeAt(elem, "TemplateElement", endPos);
-  }
-
-  function parseTemplate() {
-    var node = startNode();
-    node.expressions = [];
-    var curElt = parseTemplateElement();
-    node.quasis = [curElt];
-    while (!curElt.tail) {
-      var next = parseExpression();
-      if (isDummy(next)) {
-        node.quasis[node.quasis.length - 1].tail = true;
-        break;
-      }
-      node.expressions.push(next);
-      if (token.type === tt.templateContinued) {
-        node.quasis.push(curElt = parseTemplateElement());
-      } else {
-        curElt = startNode();
-        curElt.value = {cooked: "", raw: ""};
-        curElt.tail = true;
-        node.quasis.push(curElt);
-      }
-    }
-    return finishNode(node, "TemplateLiteral");
-  }
-
-  function parseObj(isClass, isStatement) {
-    var node = startNode();
-    if (isClass) {
-      next();
-      if (token.type === tt.name) node.id = parseIdent();
-      else if (isStatement) node.id = dummyIdent();
-      node.superClass = eat(tt._extends) ? parseExpression() : null;
-      node.body = startNode();
-      node.body.body = [];
-    } else {
-      node.properties = [];
-    }
-    pushCx();
-    var indent = curIndent + 1, line = curLineStart;
-    eat(tt.braceL);
-    if (curIndent + 1 < indent) { indent = curIndent; line = curLineStart; }
-    while (!closes(tt.braceR, indent, line)) {
-      var prop = startNode(), isGenerator;
-      if (options.ecmaVersion >= 6) {
-        if (isClass) {
-          if (prop['static'] = (token.type === tt.name && token.value === "static")) next();
-        } else {
-          prop.method = false;
-          prop.shorthand = false;
-        }
-        isGenerator = eat(tt.star);
-      }
-      parsePropertyName(prop);
-      if (isDummy(prop.key)) { if (isDummy(parseExpression(true))) next(); eat(tt.comma); continue; }
-      if (!isClass && eat(tt.colon)) {
-        prop.kind = "init";
-        prop.value = parseExpression(true);
-      } else if (options.ecmaVersion >= 6 && (token.type === tt.parenL || token.type === tt.braceL)) {
-        if (isClass) {
-          prop.kind = "";
-        } else {
-          prop.kind = "init";
-          prop.method = true;
-        }
-        prop.value = parseMethod(isGenerator);
-      } else if (options.ecmaVersion >= 5 && prop.key.type === "Identifier" &&
-                 (prop.key.name === "get" || prop.key.name === "set")) {
-        prop.kind = prop.key.name;
-        parsePropertyName(prop);
-        prop.value = parseMethod(false);
-      } else if (isClass) {
-        prop.kind = "";
-        prop.value = parseMethod(isGenerator);
-      } else {
-        prop.kind = "init";
-        prop.value = options.ecmaVersion >= 6 ? prop.key : dummyIdent();
-        prop.shorthand = true;
-      }
-
-      if (isClass) {
-        node.body.body.push(finishNode(prop, "MethodDefinition"));
-        semicolon();
-      } else {
-        node.properties.push(finishNode(prop, "Property"));
-        eat(tt.comma);
-      }
-    }
-    popCx();
-    if (!eat(tt.braceR)) {
-      // If there is no closing brace, make the node span to the start
-      // of the next token (this is useful for Tern)
-      lastEnd = token.start;
-      if (options.locations) lastEndLoc = token.startLoc;
-    }
-    if (isClass) {
-      semicolon();
-      finishNode(node.body, "ClassBody");
-      return finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression");
-    } else {
-      return finishNode(node, "ObjectExpression");
-    }
-  }
-
-  function parsePropertyName(prop) {
-    if (options.ecmaVersion >= 6) {
-      if (eat(tt.bracketL)) {
-        prop.computed = true;
-        prop.key = parseExpression();
-        expect(tt.bracketR);
-        return;
-      } else {
-        prop.computed = false;
-      }
-    }
-    var key = (token.type === tt.num || token.type === tt.string) ? parseExprAtom() : parseIdent();
-    prop.key = key || dummyIdent();
-  }
-
-  function parsePropertyAccessor() {
-    if (token.type === tt.name || token.type.keyword) return parseIdent();
-  }
-
-  function parseIdent() {
-    var node = startNode();
-    node.name = token.type === tt.name ? token.value : token.type.keyword;
-    fetchToken.noRegexp();
-    next();
-    return finishNode(node, "Identifier");
-  }
-
-  function initFunction(node) {
-    node.id = null;
-    node.params = [];
-    if (options.ecmaVersion >= 6) {
-      node.defaults = [];
-      node.rest = null;
-      node.generator = false;
-      node.expression = false;
-    }
-  }
-
-  // Convert existing expression atom to assignable pattern
-  // if possible.
-
-  function toAssignable(node) {
-    if (options.ecmaVersion >= 6 && node) {
-      switch (node.type) {
-        case "ObjectExpression":
-          node.type = "ObjectPattern";
-          var props = node.properties;
-          for (var i = 0; i < props.length; i++) {
-            props[i].value = toAssignable(props[i].value);
-          }
-          break;
-
-        case "ArrayExpression":
-          node.type = "ArrayPattern";
-          var elms = node.elements;
-          for (var i = 0; i < elms.length; i++) {
-            elms[i] = toAssignable(elms[i]);
-          }
-          break;
-
-        case "SpreadElement":
-          node.argument = toAssignable(node.argument);
-          break;
-      }
-    }
-    return checkLVal(node);
-  }
-
-  function parseFunctionParams(node, params) {
-    var defaults = [], hasDefaults = false;
-
-    if (!params) {
-      pushCx();
-      params = parseExprList(tt.parenR);
-    }
-    for (var i = 0; i < params.length; i++) {
-      var param = params[i], defValue = null;
-      if (param.type === "AssignmentExpression") {
-        defValue = param.right;
-        param = param.left;
-      }
-      param = toAssignable(param);
-      if (param.type === "SpreadElement") {
-        param = param.argument;
-        if (i === params.length - 1) {
-          node.rest = param;
-          continue;
-        }
-      }
-      node.params.push(param);
-      defaults.push(defValue);
-      if (defValue) hasDefaults = true;
-    }
-
-    if (hasDefaults) node.defaults = defaults;
-  }
-
-  function parseFunction(node, isStatement) {
-    initFunction(node);
-    if (options.ecmaVersion >= 6) {
-      node.generator = eat(tt.star);
-    }
-    if (token.type === tt.name) node.id = parseIdent();
-    else if (isStatement) node.id = dummyIdent();
-    parseFunctionParams(node);
-    node.body = parseBlock();
-    return finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
-  }
-
-  function parseMethod(isGenerator) {
-    var node = startNode();
-    initFunction(node);
-    parseFunctionParams(node);
-    node.generator = isGenerator || false;
-    node.expression = options.ecmaVersion >= 6 && token.type !== tt.braceL;
-    node.body = node.expression ? parseExpression(true) : parseBlock();
-    return finishNode(node, "FunctionExpression");
-  }
-
-  function parseArrowExpression(node, params) {
-    initFunction(node);
-    parseFunctionParams(node, params);
-    node.expression = token.type !== tt.braceL;
-    node.body = node.expression ? parseExpression(true) : parseBlock();
-    return finishNode(node, "ArrowFunctionExpression");
-  }
-
-  function parseExport() {
-    var node = startNode();
-    next();
-    node['default'] = eat(tt._default);
-    node.specifiers = node.source = null;
-    if (node['default']) {
-      node.declaration = parseExpression();
-      semicolon();
-    } else if (token.type.keyword) {
-      node.declaration = parseStatement();
-    } else {
-      node.declaration = null;
-      parseSpecifierList(node, "Export");
-    }
-    semicolon();
-    return finishNode(node, "ExportDeclaration");
-  }
-
-  function parseImport() {
-    var node = startNode();
-    next();
-    if (token.type === tt.string) {
-      node.specifiers = [];
-      node.source = parseExprAtom();
-      node.kind = '';
-    } else {
-      if (token.type === tt.name && token.value !== "from") {
-        var elt = startNode();
-        elt.id = parseIdent();
-        elt.name = null;
-        elt['default'] = true;
-        finishNode(elt, "ImportSpecifier");
-        eat(tt.comma);
-      }
-      parseSpecifierList(node, "Import");
-      var specs = node.specifiers;
-      for (var i = 0; i < specs.length; i++) specs[i]['default'] = false;
-      if (elt) node.specifiers.unshift(elt);
-    }
-    semicolon();
-    return finishNode(node, "ImportDeclaration");
-  }
-
-  function parseSpecifierList(node, prefix) {
-    var elts = node.specifiers = [];
-    if (token.type === tt.star) {
-      var elt = startNode();
-      next();
-      if (token.type === tt.name && token.value === "as") {
-        next();
-        elt.name = parseIdent();
-      }
-      elts.push(finishNode(elt, prefix + "BatchSpecifier"));
-    } else {
-      var indent = curIndent, line = curLineStart, continuedLine = nextLineStart;
-      pushCx();
-      eat(tt.braceL);
-      if (curLineStart > continuedLine) continuedLine = curLineStart;
-      while (!closes(tt.braceR, indent + (curLineStart <= continuedLine ? 1 : 0), line)) {
-        var elt = startNode();
-        if (token.type === tt.star) {
-          next();
-          if (token.type === tt.name && token.value === "as") {
-            next();
-            elt.name = parseIdent();
-          }
-          finishNode(elt, prefix + "BatchSpecifier");
-        } else {
-          if (token.type === tt.name && token.value === "from") break;
-          elt.id = parseIdent();
-          if (token.type === tt.name && token.value === "as") {
-            next();
-            elt.name = parseIdent();
-          } else {
-            elt.name = null;
-          }
-          finishNode(elt, prefix + "Specifier");
-        }
-        elts.push(elt);
-        eat(tt.comma);
-      }
-      eat(tt.braceR);
-      popCx();
-    }
-    if (token.type === tt.name && token.value === "from") {
-      next();
-      node.source = parseExprAtom();
-    } else {
-      node.source = null;
-    }
-  }
-
-  function parseExprList(close, allowEmpty) {
-    var indent = curIndent, line = curLineStart, elts = [];
-    next(); // Opening bracket
-    while (!closes(close, indent + 1, line)) {
-      if (eat(tt.comma)) {
-        elts.push(allowEmpty ? null : dummyIdent());
-        continue;
-      }
-      var elt = parseExpression(true);
-      if (isDummy(elt)) {
-        if (closes(close, indent, line)) break;
-        next();
-      } else {
-        elts.push(elt);
-      }
-      eat(tt.comma);
-    }
-    popCx();
-    if (!eat(close)) {
-      // If there is no closing brace, make the node span to the start
-      // of the next token (this is useful for Tern)
-      lastEnd = token.start;
-      if (options.locations) lastEndLoc = token.startLoc;
-    }
-    return elts;
-  }
-});

Resources/EditorData/AtomicEditor/javascript/ui/editorStrings.js

@@ -1,61 +0,0 @@
-
-
-
-exports.RevealInFinder = 0;
-exports.ShortcutUndo = 1;
-exports.ShortcutRedo = 2;
-exports.ShortcutCut = 3;
-exports.ShortcutCopy = 4;
-exports.ShortcutPaste = 5;
-exports.ShortcutSelectAll = 6;
-exports.ShortcutFind = 7;
-exports.ShortcutFindNext = 8;
-exports.ShortcutFindPrev = 9;
-exports.ShortcutBeautify = 10;
-exports.ShortcutCloseFile = 11;
-exports.ShortcutSaveFile = 12;
-exports.ShortcutPlay = 13;
-exports.ShortcutBuild = 14;
-exports.ShortcutBuildSettings = 15;
-
-exports.str = function(value) {
-
-  var string = strings[value];
-
-  if (typeof string === 'undefined') {
-      return "";
-  }
-
-  return string;
-}
-
-var strings = {};
-
-var shortcutKey = "⌘";
-
-strings[exports.RevealInFinder] = "Reveal in Finder";
-
-// Mac
-strings[exports.ShortcutRedo] ="⇧⌘Z";
-strings[exports.ShortcutFindNext] = "⌘G";
-strings[exports.ShortcutFindPrev] = "⇧⌘G";
-strings[exports.ShortcutBuildSettings] = "⇧⌘B";
-
-
-// General
-strings[exports.ShortcutUndo] = shortcutKey + "Z";
-
-strings[exports.ShortcutCut] = shortcutKey + "X";
-strings[exports.ShortcutCopy] = shortcutKey + "C";
-strings[exports.ShortcutPaste] = shortcutKey + "V";
-strings[exports.ShortcutSelectAll] = shortcutKey + "A";
-strings[exports.ShortcutFind] = shortcutKey + "F";
-
-strings[exports.ShortcutBeautify] = shortcutKey + "I";
-
-strings[exports.ShortcutSaveFile] = shortcutKey + "S";
-strings[exports.ShortcutCloseFile] = shortcutKey + "W";
-
-strings[exports.ShortcutPlay] = shortcutKey + "P";
-
-strings[exports.ShortcutBuild] = shortcutKey +"B";

Resources/EditorData/AtomicEditor/javascript/ui/hierarchyframe.js

@@ -1,15 +0,0 @@
-var UI = Atomic.UI;
-var UIWidget = Atomic.UIWidget;
-
-var mainframe = require("./mainframe").mainframe;
-
-var hierarchyframe = exports.hierarchyframe = new UIWidget();
-
-hierarchyframe.gravity = UI.GRAVITY_TOP_BOTTOM;
-
-// load the UI
-hierarchyframe.load("AtomicEditor/editor/ui/hierarchyframe.tb.txt");
-
-// snap the frame into place
-var hierarchycontainer = mainframe.getWidget("hierarchycontainer");
-hierarchycontainer.addChild(hierarchyframe);

Resources/EditorData/AtomicEditor/javascript/ui/mainframe.js

@@ -1,162 +0,0 @@
-var graphics = Atomic.getGraphics();
-var UI = Atomic.UI;
-var UIWidget = Atomic.UIWidget;
-var UIMenuWindow = Atomic.UIMenuWindow;
-var editorStrings = require("./editorStrings");
-var utils = require("./utils");
-var ui = require("./ui");
-
-// Create the main frame
-var mainframe = exports.mainframe = new UIWidget();
-
-ui.view.addChild(mainframe);
-
-// Set it to be the size of the entire window
-mainframe.setSize(graphics.width, graphics.height);
-
-// load the UI
-mainframe.load("AtomicEditor/editor/ui/mainframe.tb.txt");
-
-// Subscribe to graphics subsystems screen mode switching, so we can adjust the widget size
-mainframe.subscribeToEvent(graphics, "ScreenMode", function(data) {
-
-  mainframe.setSize(data.width, data.height);
-
-});
-
-mainframe.handleMenuAtomicEditor = function(data) {
-
-  var target = data.target;
-
-  if (target && target.id == "menu atomic editor popup") {
-
-    if (data.refid == "quit") {
-
-      // todo, send a request for file saves, etc
-      Atomic.getEngine().exit();
-
-      return true;
-
-    }
-
-  }
-
-  if (target && target.id == "menu edit popup") {
-
-    if (data.refid == "edit play") {
-
-      new ToolCore.PlayCmd().run();
-
-      return true;
-
-    }
-
-  }
-
-
-}
-
-mainframe.handleMenuBarEvent = function(data) {
-
-  if (data.type == UI.EVENT_TYPE_CLICK) {
-
-    if (mainframe.handleMenuAtomicEditor(data)) return true;
-
-    var target = data.target;
-
-    var src = srcLookup[target.id];
-
-    if (src) {
-
-      var menu = new UIMenuWindow(target, target.id + " popup");
-      menu.show(src);
-      return true;
-
-    }
-
-  }
-
-  return false;
-
-}
-
-mainframe.subscribeToEvent(mainframe, "WidgetEvent", function(data) {
-
-  if (mainframe.handleMenuBarEvent(data)) return true;
-
-  return false;
-
-});
-
-var srcLookup = {};
-
-var editorItems = {
-  "About Atomic Editor": "about atomic editor",
-  "-1" : null,
-  "Manage License" : "manage license",
-  "-2" : null,
-  "Check for Updates" : "check update",
-  "-3" : null,
-  "Quit" : "quit"
-};
-
-var editItems = {
-
-  "Undo" : ["edit undo", editorStrings.ShortcutUndo],
-  "Redo" : ["edit redo", editorStrings.ShortcutRedo],
-  "-1" : null,
-  "Cut" : ["edit cut", editorStrings.ShortcutCut],
-  "Copy" : ["edit copy", editorStrings.ShortcutCopy],
-  "Paste" : ["edit paste", editorStrings.ShortcutPaste],
-  "Select All" : ["edit select all", editorStrings.ShortcutSelectAll],
-  "-2" : null,
-  "Find" : ["edit find", editorStrings.ShortcutFind],
-  "Find Next" : ["edit find next", editorStrings.ShortcutFindNext],
-  "Find Prev" : ["edit find prev", editorStrings.ShortcutFindPrev],
-  "-3" : null,
-  "Format Code" : ["edit format code", editorStrings.ShortcutBeautify],
-  "-4" : null,
-  "Play" : ["edit play", editorStrings.ShortcutPlay]
-};
-
-var fileItems = {
-  "New Project" : "new project",
-  "Open Project" : "open project",
-  "Save Project" : "save project",
-  "-1" : null,
-  "Close Project" : "close project",
-  "-2" : null,
-  "Save File" : ["save file", editorStrings.ShortcutSaveFile],
-  "Close File" : ["close file", editorStrings.ShortcutCloseFile],
-
-};
-
-var buildItems = {
-  "Build" : ["build project", editorStrings.ShortcutBuild],
-  "-1" : null,
-  "Build Settings" : ["build project settings", editorStrings.ShortcutBuildSettings],
-};
-
-var toolsItems = {
-  "Tiled Map Editor" : "tools tiles"
-};
-
-var helpItems = {
-  "API Documentation" : "help api",
-  "-1" : null,
-  "Forums" : "help forums",
-  "-2" : null,
-  "Atomic Game Engine on GitHub" : "help github"
-};
-
-var developerItems = {
-  "Set 1920x1080 Resolution" : "developer resolution"
-};
-
-srcLookup["menu atomic editor"] = utils.createMenuItemSource(editorItems);
-srcLookup["menu file"] = utils.createMenuItemSource(fileItems);
-srcLookup["menu edit"] = utils.createMenuItemSource(editItems);
-srcLookup["menu build"] = utils.createMenuItemSource(buildItems);
-srcLookup["menu tools"] = utils.createMenuItemSource(toolsItems);
-srcLookup["menu help"] = utils.createMenuItemSource(helpItems);
-srcLookup["menu developer"] = utils.createMenuItemSource(developerItems);

Resources/EditorData/AtomicEditor/javascript/ui/projectframe.js

@@ -1,31 +0,0 @@
-var UI = Atomic.UI;
-var UIWidget = Atomic.UIWidget;
-var UIListView = Atomic.UIListView;
-var fileSystem = Atomic.getFileSystem();
-
-var mainframe = require("./mainframe").mainframe;
-
-var projectframe = exports.projectframe = new UIWidget();
-
-projectframe.gravity = UI.GRAVITY_TOP_BOTTOM;
-
-// load the UI
-projectframe.load("AtomicEditor/editor/ui/projectframe.tb.txt");
-
-// snap the project frame into place
-var projectviewcontainer = mainframe.getWidget("projectviewcontainer");
-projectviewcontainer.addChild(projectframe);
-
-var foldercontainer = projectframe.getWidget("foldercontainer");
-
-var folderList = new UIListView();
-
-folderList.id = "folderList";
-
-foldercontainer.addChild(folderList);
-
-//folderList.addItem("Resources", "Folder.icon", "myid")
-
-var folders = fileSystem.scanDir("/", "", Atomic.SCAN_DIRS, false);
-
-print(folders);

Resources/EditorData/AtomicEditor/javascript/ui/ui.js

@@ -1,8 +0,0 @@
-
-// create the view first so it exists before requiring additional modules
-var view = new Atomic.UIView();
-exports.view = view;
-
-require("./mainframe");
-require("./projectframe");
-require("./hierarchyframe");

Resources/EditorData/AtomicEditor/javascript/ui/utils.js

@@ -1,37 +0,0 @@
-
-var editorStrings = require("./editorStrings");
-
-var UIMenuItemSource = Atomic.UIMenuItemSource;
-var UIMenuItem = Atomic.UIMenuItem;
-
-exports.createMenuItemSource = function(items) {
-
-  var src = new UIMenuItemSource();
-
-  for (var key in items) {
-    if (items.hasOwnProperty(key)) {
-
-      var value = items[key];
-
-      if (typeof value === 'string') {
-
-        src.addItem(new UIMenuItem(key, value));
-
-      } else if (value == null) {
-
-        src.addItem(new UIMenuItem(key));
-
-      } else if (typeof value === 'object' && value.length == 2) {
-
-        src.addItem(new UIMenuItem(key, value[0], editorStrings.str(value[1])));
-
-      }
-
-
-    }
-
-  }
-
-  return src;
-
-}