erp_app 3.0.0 → 3.0.1

data/public/javascripts/erp_app/ckeditor/plugins/sourcepopup/codemirror/editor/contrib/freemarker/js/parsefreemarker.js

@@ -0,0 +1,380 @@
+var FreemarkerParser = Editor.Parser = (function() {
+        var autoSelfClosers = {"else": true, "elseif": true};
+
+        // Simple stateful tokenizer for Freemarker documents. Returns a
+        // MochiKit-style iterator, with a state property that contains a
+        // function encapsulating the current state. See tokenize.js.
+        var tokenizeFreemarker = (function() {
+                function inText(source, setState) {
+                    var ch = source.next();
+                    if (ch == "<") {
+                        if (source.equals("!")) {
+                            source.next();
+                            if (source.lookAhead("--", true)) {
+                                setState(inBlock("freemarker-comment", "-->"));
+                                return null;
+                            } else {
+                                return "freemarker-text";
+                            }
+                        } else {
+                            source.nextWhileMatches(/[\#\@\/]/);
+                            setState(inFreemarker(">"));
+                            return "freemarker-boundary";
+                        }
+                    }
+                    else if (ch == "[") {
+                        if(source.matches(/[\#\@]/)) {
+                            setState(pendingFreemarker(source.peek(), "]", false));
+                            return "freemarker-boundary";
+                        } else if(source.matches(/\//)) {
+                            setState(pendingFreemarkerEnd("]"));
+                            return "freemarker-boundary";
+                        } else {
+                            return "freemarker-text";
+                        }
+                    }
+                    else if (ch == "$") {
+                        if(source.matches(/[\{\w]/)) {
+                            setState(pendingFreemarker("{", "}", true));
+                            return "freemarker-boundary";
+                        } else {
+                            return "freemarker-text";
+                        }
+                    }
+                    else {
+                        source.nextWhileMatches(/[^\$<\n]/);
+                        return "freemarker-text";
+                    }
+                }
+
+                function pendingFreemarker(startChar, endChar, nextCanBeIdentifier) {
+                    return function(source, setState) {
+                        var ch = source.next();
+                        if(ch == startChar) {
+                            setState(inFreemarker(endChar));
+                            return "freemarker-boundary";
+                        } else if(nextCanBeIdentifier) {
+                            source.nextWhileMatches(/\w/);
+                            setState(inText);
+                            return "freemarker-identifier";
+                        } else {
+                            setState(inText);
+                            return null;
+                        }
+                    }
+                }
+
+                function pendingFreemarkerEnd(endChar) {
+                    return function(source, setState) {
+                        var ch = source.next();
+                        if(ch == "/") {
+                            setState(pendingFreemarker(source.peek(), endChar, false));
+                            return "freemarker-boundary";
+                        } else {
+                            setState(inText);
+                            return null;
+                        }
+                    }
+                }
+
+                function inFreemarker(terminator) {
+                    return function(source, setState) {
+                        var ch = source.next();
+                        if (ch == terminator) {
+                            setState(inText);
+                            return "freemarker-boundary";
+                        } else if (/[?\/]/.test(ch) && source.equals(terminator)) {
+                            source.next();
+                            setState(inText);
+                            return "freemarker-boundary";
+                        } else if(/[?!]/.test(ch)) {
+                            if(ch == "?") {
+                                if(source.peek() == "?") {
+                                    source.next();
+                                } else {
+                                    setState(inBuiltIn(inFreemarker(terminator)));
+                                }
+                            }
+                            return "freemarker-punctuation";
+                        } else if(/[()+\/\-*%=]/.test(ch)) {
+                            return "freemarker-punctuation";
+                        } else if (/[0-9]/.test(ch)) {
+                            source.nextWhileMatches(/[0-9]+\.?[0-9]* /);
+                            return "freemarker-number";
+                        } else if (/\w/.test(ch)) {
+                            source.nextWhileMatches(/\w/);
+                            return "freemarker-identifier";
+                        } else if(/[\'\"]/.test(ch)) {
+                            setState(inString(ch, inFreemarker(terminator)));
+                            return "freemarker-string";
+                        } else {
+                            source.nextWhileMatches(/[^\s\u00a0<>\"\'\}?!\/]/);
+                            return "freemarker-generic";
+                        }
+                    };
+                }
+
+                function inBuiltIn(nextState) {
+                    return function(source, setState) {
+                        var ch = source.peek();
+                        if(/[a-zA-Z_]/.test(ch)) {
+                            source.next();
+                            source.nextWhileMatches(/[a-zA-Z_0-9]+/);
+                            setState(nextState);
+                            return "freemarker-builtin";
+                        } else {
+                            setState(nextState);
+                        }
+                    };
+                }
+
+                function inString(quote, nextState) {
+                    return function(source, setState) {
+                        while (!source.endOfLine()) {
+                            if (source.next() == quote) {
+                                setState(nextState);
+                                break;
+                            }
+                        }
+                        return "freemarker-string";
+                    };
+                }
+
+                function inBlock(style, terminator) {
+                    return function(source, setState) {
+                        while (!source.endOfLine()) {
+                            if (source.lookAhead(terminator, true)) {
+                                setState(inText);
+                                break;
+                            }
+                            source.next();
+                        }
+                        return style;
+                    };
+                }
+
+                return function(source, startState) {
+                    return tokenizer(source, startState || inText);
+                };
+            })();
+
+        // The parser. The structure of this function largely follows that of
+        // parseXML in parsexml.js 
+        function parseFreemarker(source) {
+            var tokens = tokenizeFreemarker(source), token;
+            var cc = [base];
+            var tokenNr = 0, indented = 0;
+            var currentTag = null, context = null;
+            var consume;
+            
+            function push(fs) {
+                for (var i = fs.length - 1; i >= 0; i--)
+                    cc.push(fs[i]);
+            }
+            function cont() {
+                push(arguments);
+                consume = true;
+            }
+            function pass() {
+                push(arguments);
+                consume = false;
+            }
+            
+            function markErr() {
+                token.style += " freemarker-error";
+            }
+
+            function expect(text) {
+                return function(style, content) {
+                    if (content == text) cont();
+                    else {markErr(); cont(arguments.callee);}
+                };
+            }
+
+            function pushContext(tagname, startOfLine) {
+                context = {prev: context, name: tagname, indent: indented, startOfLine: startOfLine};
+            }
+
+            function popContext() {
+                context = context.prev;
+            }
+
+            function computeIndentation(baseContext) {
+                return function(nextChars, current, direction, firstToken) {
+                    var context = baseContext;
+
+                    nextChars = getThreeTokens(firstToken);
+
+                    if ((context && /^<\/\#/.test(nextChars)) ||
+                        (context && /^\[\/\#/.test(nextChars))) {
+                        context = context.prev;
+                    } 
+
+                    while (context && !context.startOfLine) {
+                        context = context.prev;
+                    }
+
+                    if (context) {
+                        if(/^<\#else/.test(nextChars) ||
+                           /^\[\#else/.test(nextChars)) {
+                            return context.indent;
+                        }
+                        return context.indent + indentUnit;
+                    } else {
+                        return 0;
+                    }
+                };
+            }
+
+            function getThreeTokens(firstToken) {
+                var secondToken = firstToken ? firstToken.nextSibling : null;
+                var thirdToken = secondToken ? secondToken.nextSibling : null;
+
+                var nextChars = (firstToken && firstToken.currentText) ? firstToken.currentText : "";
+                if(secondToken && secondToken.currentText) {
+                    nextChars = nextChars + secondToken.currentText;
+                    if(thirdToken && thirdToken.currentText) {
+                        nextChars = nextChars + thirdToken.currentText;
+                    }
+                }
+
+                return nextChars;
+            }
+
+            function base() {
+                return pass(element, base);
+            }
+
+            var harmlessTokens = { "freemarker-text": true, "freemarker-comment": true };
+
+            function element(style, content) {
+                if (content == "<#") {
+                    cont(tagname, notEndTag, endtag("/>", ">", tokenNr == 1));
+                } else if (content == "</#") { 
+                    cont(closetagname, expect(">"));
+                } else if(content == "[" && style == "freemarker-boundary") {
+                    cont(hashOrCloseHash);
+                } else {
+                    cont();
+                }
+            }
+
+            function hashOrCloseHash(style, content) {
+                if(content == "#") {
+                    cont(tagname, notHashEndTag, endtag("/]", "]", tokenNr == 2));
+                } else if(content == "/") {
+                    cont(closeHash);
+                } else {
+                    markErr();
+                }
+            }
+
+            function closeHash(style, content) {
+                if(content == "#") {
+                    cont(closetagname, expect("]"));
+                } else {
+                    markErr();
+                }
+            }
+
+
+            function tagname(style, content) {
+                if (style == "freemarker-identifier") {
+                    currentTag = content.toLowerCase();
+                    token.style = "freemarker-directive";
+                    cont();
+                } else {
+                    currentTag = null;
+                    pass();
+                }
+            }
+            
+            function closetagname(style, content) {
+                if (style == "freemarker-identifier") {
+                    token.style = "freemarker-directive";
+                    if (context && content.toLowerCase() == context.name) {
+                        popContext();
+                    } else {
+                        markErr();
+                    }
+                }
+                cont();
+            }
+
+            function notEndTag(style, content) {
+                if (content == "/>" || content == ">") {
+                    pass(); 
+                } else {
+                    cont(notEndTag);
+                }
+            }
+
+            function notHashEndTag(style, content) {
+                if (content == "/]" || content == "]") {
+                    pass(); 
+                } else {
+                    cont(notHashEndTag);
+                }
+            }
+
+            function endtag(closeTagPattern, endTagPattern, startOfLine) {
+                return function(style, content) {
+                    if (content == closeTagPattern || (content == endTagPattern && autoSelfClosers.hasOwnProperty(currentTag))) {
+                        cont();
+                    } else if (content == endTagPattern) {
+                        pushContext(currentTag, startOfLine); 
+                        cont();
+                    } else {
+                        markErr(); 
+                        cont(arguments.callee);
+                    }
+                };
+            }
+            
+            
+            return {
+                indentation: function() { return indented; },
+                    
+                next: function() {
+                    token = tokens.next();
+                    if (token.style == "whitespace" && tokenNr == 0)
+                        indented = token.value.length;
+                    else
+                        tokenNr++;
+                    if (token.content == "\n") {
+                        indented = tokenNr = 0;
+                        token.indentation = computeIndentation(context);
+                    }
+                    
+                    if (token.style == "whitespace" || token.type == "freemarker-comment")
+                        return token;
+                    
+                    while(true) {
+                        consume = false;
+                        cc.pop()(token.style, token.content);
+                        if (consume) {
+                            return token;
+                        }
+                    }
+                },
+                    
+                copy: function(){
+                    var _cc = cc.concat([]), _tokenState = tokens.state, _context = context;
+                    var parser = this;
+                    
+                    return function(input){
+                        cc = _cc.concat([]);
+                        tokenNr = indented = 0;
+                        context = _context;
+                        tokens = tokenizeFreemarker(input, _tokenState);
+                        return parser;
+                    };
+                }
+            };
+        }
+
+        return {
+            make: parseFreemarker,
+            electricChars: ">"
+        };
+    })();

data/public/javascripts/erp_app/ckeditor/plugins/sourcepopup/codemirror/editor/contrib/groovy/index.html

@@ -0,0 +1,57 @@
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <script src="../../js/codemirror.js" type="text/javascript"></script>
+    <title>CodeMirror: Groovy demonstration</title>
+    <link rel="stylesheet" type="text/css" href="../../css/docs.css"/>
+  </head>
+  <body style="padding: 20px;">
+
+<p>Demonstration of <a href="../../index.html">CodeMirror</a>'s Groovy highlighter.</p>
+
+<p>Created by eXo Platform SAS (<a href="http://www.opensource.org/licenses/lgpl-2.1.php">license</a>).</p>
+
+<p>Note that the files for this parser aren't included in the CodeMirror repository, but have to fetched from <a href="http://svn.exoplatform.org/">svn.exoplatform.org</a>:</p>
+
+<ul>
+ <li><a href="http://svn.exoplatform.org/projects/gwt/trunk/exo-gwtframework-editor/src/main/resources/org/exoplatform/gwtframework/editor/public/codemirror/js/tokenizegroovy.js">tokenizegroovy.js</a></li>
+ <li><a href="http://svn.exoplatform.org/projects/gwt/trunk/exo-gwtframework-editor/src/main/resources/org/exoplatform/gwtframework/editor/public/codemirror/js/parsegroovy.js">parsegroovy.js</a></li>
+ <li><a href="http://svn.exoplatform.org/projects/gwt/trunk/exo-gwtframework-editor/src/main/resources/org/exoplatform/gwtframework/editor/public/codemirror/css/groovycolors.css">groovy.colors.css</a></li>
+</ul>
+
+<div style="border-top: 1px solid black; border-bottom: 1px solid black;">
+<textarea id="code" cols="120" rows="50">
+// simple groovy script
+import javax.ws.rs.Path
+import javax.ws.rs.GET
+import javax.ws.rs.PathParam
+import javax.ws.rs.POST
+
+@Path("/")
+public class HelloWorld {
+  @GET
+  @Path("helloworld/{name}")
+  public String hello(@PathParam("name") String name) {
+    return "Hello " + name
+  }
+  
+  @POST
+  @Path("helloworld/{name}")
+  public String hello2(@PathParam("name") String name) {
+    return "Hello " + name
+  }
+}
+</textarea>
+</div>
+
+<script type="text/javascript">
+  var editor = CodeMirror.fromTextArea('code', {
+    height: "450px",
+    parserfile: ["http://svn.exoplatform.org/projects/gwt/trunk/exo-gwtframework-editor/src/main/resources/org/exoplatform/gwtframework/editor/public/codemirror/js/parsegroovy.js", "http://svn.exoplatform.org/projects/gwt/trunk/exo-gwtframework-editor/src/main/resources/org/exoplatform/gwtframework/editor/public/codemirror/js/tokenizegroovy.js"],
+    stylesheet: "http://svn.exoplatform.org/projects/gwt/trunk/exo-gwtframework-editor/src/main/resources/org/exoplatform/gwtframework/editor/public/codemirror/css/groovycolors.css",
+    path: "../../js/",
+    textWrapping: false
+  });
+</script>
+
+</body>
+</html>

data/public/javascripts/erp_app/ckeditor/plugins/sourcepopup/codemirror/editor/contrib/java/LICENSE

@@ -0,0 +1,20 @@
+ Copyright (c) 2010 Patrick Wied
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the authors be held liable for any
+ damages arising from the use of this software.
+
+ Permission is granted to anyone to use this software for any
+ purpose, including commercial applications, and to alter it and
+ redistribute it freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must
+    not claim that you wrote the original software. If you use this
+    software in a product, an acknowledgment in the product
+    documentation would be appreciated but is not required.
+
+ 2. Altered source versions must be plainly marked as such, and must
+    not be misrepresented as being the original software.
+
+ 3. This notice may not be removed or altered from any source
+    distribution.

data/public/javascripts/erp_app/ckeditor/plugins/sourcepopup/codemirror/editor/contrib/java/css/javacolors.css

@@ -0,0 +1,64 @@
+
+html {
+  cursor: text;
+}
+
+.editbox {
+  margin: .4em;
+  padding: 0;
+  font-family: monospace;
+  font-size: 10pt;
+  color: black;
+}
+
+pre.code, .editbox {
+  color: #666666;
+}
+
+.editbox p {
+  margin: 0;
+}
+
+span.java-punctuation {
+  color: black;
+}
+
+span.java-operator {
+  color: purple;
+}
+
+span.java-keyword {
+  color: #7f0055;
+  font-weight:bold;
+}
+
+span.java-atom {
+  color: brown;
+}
+
+span.java-variable {
+  color: black;
+}
+
+
+span.java-property {
+  color: black;
+}
+
+span.java-comment {
+  color: green;
+}
+
+span.javadoc-comment {
+  color: #3e5797;
+  font-weight:bold;
+}
+
+span.java-string {
+  color: blue;
+}
+
+span.java-annotation{
+  color: gray;	
+}
+

data/public/javascripts/erp_app/ckeditor/plugins/sourcepopup/codemirror/editor/contrib/java/index.html

@@ -0,0 +1,66 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
+<html>
+	<head>
+		<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+		<title>Demonstration of CodeMirrors Java highlighter written by Patrick Wied</title>
+		<script src="../../js/codemirror.js" type="text/javascript"></script>
+		<link rel="stylesheet" type="text/css" href="../../css/docs.css" />
+	</head>
+	<body>
+	<p>Demonstration of <a href="http://www.codemirror.net">CodeMirror</a>'s Java highlighter.</p>
+
+	<p>Written by <a href="http://www.patrick-wied.at/">Patrick Wied</a>.</p>
+
+        <div style="border-top: 1px solid black; border-bottom: 1px solid black;">
+	<textarea id="code">
+package example;
+
+import java.awt.*;
+
+/**
+ * This class subclasses DrawableRect and adds colors to the rectangle it draws
+ **/
+public class ColoredRect extends DrawableRect {
+  // These are new fields defined by this class.
+  // x1, y1, x2, and y2 are inherited from our super-superclass, Rect.
+  @AnnotationTest
+  protected Color border, fill;
+  private String name;
+
+  /**
+   * This constructor uses super() to invoke the superclass constructor, and
+   * also does some initialization of its own.
+   **/
+  public ColoredRect(int x1, int y1, int x2, int y2, Color border, Color fill){
+    super(x1, y1, x2, y2);
+    /* This
+    is a block comment */
+    this.border = border;
+    this.fill = fill;
+    this.name = "This is a string";
+  }
+
+  /**
+   * This method overrides the draw() method of our superclass so that it
+   * can make use of the colors that have been specified.
+   **/
+  public void draw(Graphics g) {
+    g.setColor(fill);
+    g.fillRect(x1, y1, x2, y2);
+    g.setColor(border);
+    g.drawRect(x1, y1, x2, y2);
+  }
+}
+	</textarea>
+        </div>
+	<script type="text/javascript">
+	  var editor = CodeMirror.fromTextArea('code', {
+	    height: "650px",
+	    parserfile: ["../contrib/java/js/tokenizejava.js","../contrib/java/js/parsejava.js"],
+	    stylesheet: "css/javacolors.css",
+	    path: "../../js/",
+		tabMode : "shift"
+	  });
+	</script>
+	</body>
+</html>