/lenasys/trunk

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/lenasys/trunk

« back to all changes in this revision

Viewing changes to codeigniter/js/ace/mode-xml.js

  • Committer: Gustav Hatvigsson
  • Date: 2013-05-30 12:02:31 UTC
  • mfrom: (85.1.28 lenasys)
  • Revision ID: gustav.hartvigsson@gmail.com-20130530120231-ttqgqjqw2w8enn7g
Merged Ohlsons changes:
added function to get ssn and name for the registrationspages in the user model.
added the registrationpage for students.
edited the registration page for instructors
edited the css for both the registrationpages
minor fix to registration css

Show diffs side-by-side

added added

removed removed

Lines of Context:
codeigniter/js/ace/mode-xml.js
 
1
/* ***** BEGIN LICENSE BLOCK *****
 
2
 * Distributed under the BSD license:
 
3
 *
 
4
 * Copyright (c) 2010, Ajax.org B.V.
 
5
 * All rights reserved.
 
6
 * 
 
7
 * Redistribution and use in source and binary forms, with or without
 
8
 * modification, are permitted provided that the following conditions are met:
 
9
 *     * Redistributions of source code must retain the above copyright
 
10
 *       notice, this list of conditions and the following disclaimer.
 
11
 *     * Redistributions in binary form must reproduce the above copyright
 
12
 *       notice, this list of conditions and the following disclaimer in the
 
13
 *       documentation and/or other materials provided with the distribution.
 
14
 *     * Neither the name of Ajax.org B.V. nor the
 
15
 *       names of its contributors may be used to endorse or promote products
 
16
 *       derived from this software without specific prior written permission.
 
17
 * 
 
18
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 
19
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 
20
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 
21
 * DISCLAIMED. IN NO EVENT SHALL AJAX.ORG B.V. BE LIABLE FOR ANY
 
22
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 
23
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 
24
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 
25
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
26
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 
27
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
28
 *
 
29
 * ***** END LICENSE BLOCK ***** */
 
30
 
 
31
define('ace/mode/xml', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/text', 'ace/tokenizer', 'ace/mode/xml_highlight_rules', 'ace/mode/behaviour/xml', 'ace/mode/folding/xml'], function(require, exports, module) {
 
32
 
 
33
 
 
34
var oop = require("../lib/oop");
 
35
var TextMode = require("./text").Mode;
 
36
var Tokenizer = require("../tokenizer").Tokenizer;
 
37
var XmlHighlightRules = require("./xml_highlight_rules").XmlHighlightRules;
 
38
var XmlBehaviour = require("./behaviour/xml").XmlBehaviour;
 
39
var XmlFoldMode = require("./folding/xml").FoldMode;
 
40
 
 
41
var Mode = function() {
 
42
    this.$tokenizer = new Tokenizer(new XmlHighlightRules().getRules());
 
43
    this.$behaviour = new XmlBehaviour();
 
44
    this.foldingRules = new XmlFoldMode();
 
45
};
 
46
 
 
47
oop.inherits(Mode, TextMode);
 
48
 
 
49
(function() {
 
50
    
 
51
    this.blockComment = {start: "<!--", end: "-->"};
 
52
 
 
53
}).call(Mode.prototype);
 
54
 
 
55
exports.Mode = Mode;
 
56
});
 
57
 
 
58
define('ace/mode/xml_highlight_rules', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/xml_util', 'ace/mode/text_highlight_rules'], function(require, exports, module) {
 
59
 
 
60
 
 
61
var oop = require("../lib/oop");
 
62
var xmlUtil = require("./xml_util");
 
63
var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
 
64
 
 
65
var XmlHighlightRules = function() {
 
66
    this.$rules = {
 
67
        start : [
 
68
            {token : "text", regex : "<\\!\\[CDATA\\[", next : "cdata"},
 
69
            {token : "xml-pe", regex : "<\\?.*?\\?>"},
 
70
            {token : "comment", regex : "<\\!--", next : "comment"},
 
71
            {token : "xml-pe", regex : "<\\!.*?>"},
 
72
            {token : "meta.tag", regex : "<\\/?", next : "tag"},
 
73
            {token : "text", regex : "\\s+"},
 
74
            {
 
75
                token : "constant.character.entity", 
 
76
                regex : "(?:&#[0-9]+;)|(?:&#x[0-9a-fA-F]+;)|(?:&[a-zA-Z0-9_:\\.-]+;)" 
 
77
            }
 
78
        ],
 
79
        
 
80
        cdata : [
 
81
            {token : "text", regex : "\\]\\]>", next : "start"},
 
82
            {token : "text", regex : "\\s+"},
 
83
            {token : "text", regex : "(?:[^\\]]|\\](?!\\]>))+"}
 
84
        ],
 
85
 
 
86
        comment : [
 
87
            {token : "comment", regex : ".*?-->", next : "start"},
 
88
            {token : "comment", regex : ".+"}
 
89
        ]
 
90
    };
 
91
    
 
92
    xmlUtil.tag(this.$rules, "tag", "start");
 
93
};
 
94
 
 
95
oop.inherits(XmlHighlightRules, TextHighlightRules);
 
96
 
 
97
exports.XmlHighlightRules = XmlHighlightRules;
 
98
});
 
99
 
 
100
define('ace/mode/xml_util', ['require', 'exports', 'module' ], function(require, exports, module) {
 
101
 
 
102
 
 
103
function string(state) {
 
104
    return [{
 
105
        token : "string",
 
106
        regex : '"',
 
107
        next : state + "_qqstring"
 
108
    }, {
 
109
        token : "string",
 
110
        regex : "'",
 
111
        next : state + "_qstring"
 
112
    }];
 
113
}
 
114
 
 
115
function multiLineString(quote, state) {
 
116
    return [
 
117
        {token : "string", regex : quote, next : state},
 
118
        {
 
119
            token : "constant.language.escape",
 
120
            regex : "(?:&#[0-9]+;)|(?:&#x[0-9a-fA-F]+;)|(?:&[a-zA-Z0-9_:\\.-]+;)" 
 
121
        },
 
122
        {defaultToken : "string"}
 
123
    ];
 
124
}
 
125
 
 
126
exports.tag = function(states, name, nextState, tagMap) {
 
127
    states[name] = [{
 
128
        token : "text",
 
129
        regex : "\\s+"
 
130
    }, {
 
131
        
 
132
    token : !tagMap ? "meta.tag.tag-name" : function(value) {
 
133
            if (tagMap[value])
 
134
                return "meta.tag.tag-name." + tagMap[value];
 
135
            else
 
136
                return "meta.tag.tag-name";
 
137
        },
 
138
        regex : "[-_a-zA-Z0-9:]+",
 
139
        next : name + "_embed_attribute_list" 
 
140
    }, {
 
141
        token: "empty",
 
142
        regex: "",
 
143
        next : name + "_embed_attribute_list"
 
144
    }];
 
145
 
 
146
    states[name + "_qstring"] = multiLineString("'", name + "_embed_attribute_list");
 
147
    states[name + "_qqstring"] = multiLineString("\"", name + "_embed_attribute_list");
 
148
    
 
149
    states[name + "_embed_attribute_list"] = [{
 
150
        token : "meta.tag.r",
 
151
        regex : "/?>",
 
152
        next : nextState
 
153
    }, {
 
154
        token : "keyword.operator",
 
155
        regex : "="
 
156
    }, {
 
157
        token : "entity.other.attribute-name",
 
158
        regex : "[-_a-zA-Z0-9:]+"
 
159
    }, {
 
160
        token : "constant.numeric", // float
 
161
        regex : "[+-]?\\d+(?:(?:\\.\\d*)?(?:[eE][+-]?\\d+)?)?\\b"
 
162
    }, {
 
163
        token : "text",
 
164
        regex : "\\s+"
 
165
    }].concat(string(name));
 
166
};
 
167
 
 
168
});
 
169
 
 
170
define('ace/mode/behaviour/xml', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/behaviour', 'ace/mode/behaviour/cstyle', 'ace/token_iterator'], function(require, exports, module) {
 
171
 
 
172
 
 
173
var oop = require("../../lib/oop");
 
174
var Behaviour = require("../behaviour").Behaviour;
 
175
var CstyleBehaviour = require("./cstyle").CstyleBehaviour;
 
176
var TokenIterator = require("../../token_iterator").TokenIterator;
 
177
 
 
178
function hasType(token, type) {
 
179
    var hasType = true;
 
180
    var typeList = token.type.split('.');
 
181
    var needleList = type.split('.');
 
182
    needleList.forEach(function(needle){
 
183
        if (typeList.indexOf(needle) == -1) {
 
184
            hasType = false;
 
185
            return false;
 
186
        }
 
187
    });
 
188
    return hasType;
 
189
}
 
190
 
 
191
var XmlBehaviour = function () {
 
192
    
 
193
    this.inherit(CstyleBehaviour, ["string_dquotes"]); // Get string behaviour
 
194
    
 
195
    this.add("autoclosing", "insertion", function (state, action, editor, session, text) {
 
196
        if (text == '>') {
 
197
            var position = editor.getCursorPosition();
 
198
            var iterator = new TokenIterator(session, position.row, position.column);
 
199
            var token = iterator.getCurrentToken();
 
200
            var atCursor = false;
 
201
            if (!token || !hasType(token, 'meta.tag') && !(hasType(token, 'text') && token.value.match('/'))){
 
202
                do {
 
203
                    token = iterator.stepBackward();
 
204
                } while (token && (hasType(token, 'string') || hasType(token, 'keyword.operator') || hasType(token, 'entity.attribute-name') || hasType(token, 'text')));
 
205
            } else {
 
206
                atCursor = true;
 
207
            }
 
208
            if (!token || !hasType(token, 'meta.tag-name') || iterator.stepBackward().value.match('/')) {
 
209
                return
 
210
            }
 
211
            var tag = token.value;
 
212
            if (atCursor){
 
213
                var tag = tag.substring(0, position.column - token.start);
 
214
            }
 
215
 
 
216
            return {
 
217
               text: '>' + '</' + tag + '>',
 
218
               selection: [1, 1]
 
219
            }
 
220
        }
 
221
    });
 
222
 
 
223
    this.add('autoindent', 'insertion', function (state, action, editor, session, text) {
 
224
        if (text == "\n") {
 
225
            var cursor = editor.getCursorPosition();
 
226
            var line = session.doc.getLine(cursor.row);
 
227
            var rightChars = line.substring(cursor.column, cursor.column + 2);
 
228
            if (rightChars == '</') {
 
229
                var indent = this.$getIndent(session.doc.getLine(cursor.row)) + session.getTabString();
 
230
                var next_indent = this.$getIndent(session.doc.getLine(cursor.row));
 
231
 
 
232
                return {
 
233
                    text: '\n' + indent + '\n' + next_indent,
 
234
                    selection: [1, indent.length, 1, indent.length]
 
235
                }
 
236
            }
 
237
        }
 
238
    });
 
239
    
 
240
}
 
241
oop.inherits(XmlBehaviour, Behaviour);
 
242
 
 
243
exports.XmlBehaviour = XmlBehaviour;
 
244
});
 
245
 
 
246
define('ace/mode/behaviour/cstyle', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/behaviour', 'ace/token_iterator', 'ace/lib/lang'], function(require, exports, module) {
 
247
 
 
248
 
 
249
var oop = require("../../lib/oop");
 
250
var Behaviour = require("../behaviour").Behaviour;
 
251
var TokenIterator = require("../../token_iterator").TokenIterator;
 
252
var lang = require("../../lib/lang");
 
253
 
 
254
var SAFE_INSERT_IN_TOKENS =
 
255
    ["text", "paren.rparen", "punctuation.operator"];
 
256
var SAFE_INSERT_BEFORE_TOKENS =
 
257
    ["text", "paren.rparen", "punctuation.operator", "comment"];
 
258
 
 
259
 
 
260
var autoInsertedBrackets = 0;
 
261
var autoInsertedRow = -1;
 
262
var autoInsertedLineEnd = "";
 
263
var maybeInsertedBrackets = 0;
 
264
var maybeInsertedRow = -1;
 
265
var maybeInsertedLineStart = "";
 
266
var maybeInsertedLineEnd = "";
 
267
 
 
268
var CstyleBehaviour = function () {
 
269
    
 
270
    CstyleBehaviour.isSaneInsertion = function(editor, session) {
 
271
        var cursor = editor.getCursorPosition();
 
272
        var iterator = new TokenIterator(session, cursor.row, cursor.column);
 
273
        if (!this.$matchTokenType(iterator.getCurrentToken() || "text", SAFE_INSERT_IN_TOKENS)) {
 
274
            var iterator2 = new TokenIterator(session, cursor.row, cursor.column + 1);
 
275
            if (!this.$matchTokenType(iterator2.getCurrentToken() || "text", SAFE_INSERT_IN_TOKENS))
 
276
                return false;
 
277
        }
 
278
        iterator.stepForward();
 
279
        return iterator.getCurrentTokenRow() !== cursor.row ||
 
280
            this.$matchTokenType(iterator.getCurrentToken() || "text", SAFE_INSERT_BEFORE_TOKENS);
 
281
    };
 
282
    
 
283
    CstyleBehaviour.$matchTokenType = function(token, types) {
 
284
        return types.indexOf(token.type || token) > -1;
 
285
    };
 
286
    
 
287
    CstyleBehaviour.recordAutoInsert = function(editor, session, bracket) {
 
288
        var cursor = editor.getCursorPosition();
 
289
        var line = session.doc.getLine(cursor.row);
 
290
        if (!this.isAutoInsertedClosing(cursor, line, autoInsertedLineEnd[0]))
 
291
            autoInsertedBrackets = 0;
 
292
        autoInsertedRow = cursor.row;
 
293
        autoInsertedLineEnd = bracket + line.substr(cursor.column);
 
294
        autoInsertedBrackets++;
 
295
    };
 
296
    
 
297
    CstyleBehaviour.recordMaybeInsert = function(editor, session, bracket) {
 
298
        var cursor = editor.getCursorPosition();
 
299
        var line = session.doc.getLine(cursor.row);
 
300
        if (!this.isMaybeInsertedClosing(cursor, line))
 
301
            maybeInsertedBrackets = 0;
 
302
        maybeInsertedRow = cursor.row;
 
303
        maybeInsertedLineStart = line.substr(0, cursor.column) + bracket;
 
304
        maybeInsertedLineEnd = line.substr(cursor.column);
 
305
        maybeInsertedBrackets++;
 
306
    };
 
307
    
 
308
    CstyleBehaviour.isAutoInsertedClosing = function(cursor, line, bracket) {
 
309
        return autoInsertedBrackets > 0 &&
 
310
            cursor.row === autoInsertedRow &&
 
311
            bracket === autoInsertedLineEnd[0] &&
 
312
            line.substr(cursor.column) === autoInsertedLineEnd;
 
313
    };
 
314
    
 
315
    CstyleBehaviour.isMaybeInsertedClosing = function(cursor, line) {
 
316
        return maybeInsertedBrackets > 0 &&
 
317
            cursor.row === maybeInsertedRow &&
 
318
            line.substr(cursor.column) === maybeInsertedLineEnd &&
 
319
            line.substr(0, cursor.column) == maybeInsertedLineStart;
 
320
    };
 
321
    
 
322
    CstyleBehaviour.popAutoInsertedClosing = function() {
 
323
        autoInsertedLineEnd = autoInsertedLineEnd.substr(1);
 
324
        autoInsertedBrackets--;
 
325
    };
 
326
    
 
327
    CstyleBehaviour.clearMaybeInsertedClosing = function() {
 
328
        maybeInsertedBrackets = 0;
 
329
        maybeInsertedRow = -1;
 
330
    };
 
331
 
 
332
    this.add("braces", "insertion", function (state, action, editor, session, text) {
 
333
        var cursor = editor.getCursorPosition();
 
334
        var line = session.doc.getLine(cursor.row);
 
335
        if (text == '{') {
 
336
            var selection = editor.getSelectionRange();
 
337
            var selected = session.doc.getTextRange(selection);
 
338
            if (selected !== "" && selected !== "{" && editor.getWrapBehavioursEnabled()) {
 
339
                return {
 
340
                    text: '{' + selected + '}',
 
341
                    selection: false
 
342
                };
 
343
            } else if (CstyleBehaviour.isSaneInsertion(editor, session)) {
 
344
                if (/[\]\}\)]/.test(line[cursor.column])) {
 
345
                    CstyleBehaviour.recordAutoInsert(editor, session, "}");
 
346
                    return {
 
347
                        text: '{}',
 
348
                        selection: [1, 1]
 
349
                    };
 
350
                } else {
 
351
                    CstyleBehaviour.recordMaybeInsert(editor, session, "{");
 
352
                    return {
 
353
                        text: '{',
 
354
                        selection: [1, 1]
 
355
                    };
 
356
                }
 
357
            }
 
358
        } else if (text == '}') {
 
359
            var rightChar = line.substring(cursor.column, cursor.column + 1);
 
360
            if (rightChar == '}') {
 
361
                var matching = session.$findOpeningBracket('}', {column: cursor.column + 1, row: cursor.row});
 
362
                if (matching !== null && CstyleBehaviour.isAutoInsertedClosing(cursor, line, text)) {
 
363
                    CstyleBehaviour.popAutoInsertedClosing();
 
364
                    return {
 
365
                        text: '',
 
366
                        selection: [1, 1]
 
367
                    };
 
368
                }
 
369
            }
 
370
        } else if (text == "\n" || text == "\r\n") {
 
371
            var closing = "";
 
372
            if (CstyleBehaviour.isMaybeInsertedClosing(cursor, line)) {
 
373
                closing = lang.stringRepeat("}", maybeInsertedBrackets);
 
374
                CstyleBehaviour.clearMaybeInsertedClosing();
 
375
            }
 
376
            var rightChar = line.substring(cursor.column, cursor.column + 1);
 
377
            if (rightChar == '}' || closing !== "") {
 
378
                var openBracePos = session.findMatchingBracket({row: cursor.row, column: cursor.column}, '}');
 
379
                if (!openBracePos)
 
380
                     return null;
 
381
 
 
382
                var indent = this.getNextLineIndent(state, line.substring(0, cursor.column), session.getTabString());
 
383
                var next_indent = this.$getIndent(line);
 
384
 
 
385
                return {
 
386
                    text: '\n' + indent + '\n' + next_indent + closing,
 
387
                    selection: [1, indent.length, 1, indent.length]
 
388
                };
 
389
            }
 
390
        }
 
391
    });
 
392
 
 
393
    this.add("braces", "deletion", function (state, action, editor, session, range) {
 
394
        var selected = session.doc.getTextRange(range);
 
395
        if (!range.isMultiLine() && selected == '{') {
 
396
            var line = session.doc.getLine(range.start.row);
 
397
            var rightChar = line.substring(range.end.column, range.end.column + 1);
 
398
            if (rightChar == '}') {
 
399
                range.end.column++;
 
400
                return range;
 
401
            } else {
 
402
                maybeInsertedBrackets--;
 
403
            }
 
404
        }
 
405
    });
 
406
 
 
407
    this.add("parens", "insertion", function (state, action, editor, session, text) {
 
408
        if (text == '(') {
 
409
            var selection = editor.getSelectionRange();
 
410
            var selected = session.doc.getTextRange(selection);
 
411
            if (selected !== "" && editor.getWrapBehavioursEnabled()) {
 
412
                return {
 
413
                    text: '(' + selected + ')',
 
414
                    selection: false
 
415
                };
 
416
            } else if (CstyleBehaviour.isSaneInsertion(editor, session)) {
 
417
                CstyleBehaviour.recordAutoInsert(editor, session, ")");
 
418
                return {
 
419
                    text: '()',
 
420
                    selection: [1, 1]
 
421
                };
 
422
            }
 
423
        } else if (text == ')') {
 
424
            var cursor = editor.getCursorPosition();
 
425
            var line = session.doc.getLine(cursor.row);
 
426
            var rightChar = line.substring(cursor.column, cursor.column + 1);
 
427
            if (rightChar == ')') {
 
428
                var matching = session.$findOpeningBracket(')', {column: cursor.column + 1, row: cursor.row});
 
429
                if (matching !== null && CstyleBehaviour.isAutoInsertedClosing(cursor, line, text)) {
 
430
                    CstyleBehaviour.popAutoInsertedClosing();
 
431
                    return {
 
432
                        text: '',
 
433
                        selection: [1, 1]
 
434
                    };
 
435
                }
 
436
            }
 
437
        }
 
438
    });
 
439
 
 
440
    this.add("parens", "deletion", function (state, action, editor, session, range) {
 
441
        var selected = session.doc.getTextRange(range);
 
442
        if (!range.isMultiLine() && selected == '(') {
 
443
            var line = session.doc.getLine(range.start.row);
 
444
            var rightChar = line.substring(range.start.column + 1, range.start.column + 2);
 
445
            if (rightChar == ')') {
 
446
                range.end.column++;
 
447
                return range;
 
448
            }
 
449
        }
 
450
    });
 
451
 
 
452
    this.add("brackets", "insertion", function (state, action, editor, session, text) {
 
453
        if (text == '[') {
 
454
            var selection = editor.getSelectionRange();
 
455
            var selected = session.doc.getTextRange(selection);
 
456
            if (selected !== "" && editor.getWrapBehavioursEnabled()) {
 
457
                return {
 
458
                    text: '[' + selected + ']',
 
459
                    selection: false
 
460
                };
 
461
            } else if (CstyleBehaviour.isSaneInsertion(editor, session)) {
 
462
                CstyleBehaviour.recordAutoInsert(editor, session, "]");
 
463
                return {
 
464
                    text: '[]',
 
465
                    selection: [1, 1]
 
466
                };
 
467
            }
 
468
        } else if (text == ']') {
 
469
            var cursor = editor.getCursorPosition();
 
470
            var line = session.doc.getLine(cursor.row);
 
471
            var rightChar = line.substring(cursor.column, cursor.column + 1);
 
472
            if (rightChar == ']') {
 
473
                var matching = session.$findOpeningBracket(']', {column: cursor.column + 1, row: cursor.row});
 
474
                if (matching !== null && CstyleBehaviour.isAutoInsertedClosing(cursor, line, text)) {
 
475
                    CstyleBehaviour.popAutoInsertedClosing();
 
476
                    return {
 
477
                        text: '',
 
478
                        selection: [1, 1]
 
479
                    };
 
480
                }
 
481
            }
 
482
        }
 
483
    });
 
484
 
 
485
    this.add("brackets", "deletion", function (state, action, editor, session, range) {
 
486
        var selected = session.doc.getTextRange(range);
 
487
        if (!range.isMultiLine() && selected == '[') {
 
488
            var line = session.doc.getLine(range.start.row);
 
489
            var rightChar = line.substring(range.start.column + 1, range.start.column + 2);
 
490
            if (rightChar == ']') {
 
491
                range.end.column++;
 
492
                return range;
 
493
            }
 
494
        }
 
495
    });
 
496
 
 
497
    this.add("string_dquotes", "insertion", function (state, action, editor, session, text) {
 
498
        if (text == '"' || text == "'") {
 
499
            var quote = text;
 
500
            var selection = editor.getSelectionRange();
 
501
            var selected = session.doc.getTextRange(selection);
 
502
            if (selected !== "" && selected !== "'" && selected != '"' && editor.getWrapBehavioursEnabled()) {
 
503
                return {
 
504
                    text: quote + selected + quote,
 
505
                    selection: false
 
506
                };
 
507
            } else {
 
508
                var cursor = editor.getCursorPosition();
 
509
                var line = session.doc.getLine(cursor.row);
 
510
                var leftChar = line.substring(cursor.column-1, cursor.column);
 
511
                if (leftChar == '\\') {
 
512
                    return null;
 
513
                }
 
514
                var tokens = session.getTokens(selection.start.row);
 
515
                var col = 0, token;
 
516
                var quotepos = -1; // Track whether we're inside an open quote.
 
517
 
 
518
                for (var x = 0; x < tokens.length; x++) {
 
519
                    token = tokens[x];
 
520
                    if (token.type == "string") {
 
521
                      quotepos = -1;
 
522
                    } else if (quotepos < 0) {
 
523
                      quotepos = token.value.indexOf(quote);
 
524
                    }
 
525
                    if ((token.value.length + col) > selection.start.column) {
 
526
                        break;
 
527
                    }
 
528
                    col += tokens[x].value.length;
 
529
                }
 
530
                if (!token || (quotepos < 0 && token.type !== "comment" && (token.type !== "string" || ((selection.start.column !== token.value.length+col-1) && token.value.lastIndexOf(quote) === token.value.length-1)))) {
 
531
                    if (!CstyleBehaviour.isSaneInsertion(editor, session))
 
532
                        return;
 
533
                    return {
 
534
                        text: quote + quote,
 
535
                        selection: [1,1]
 
536
                    };
 
537
                } else if (token && token.type === "string") {
 
538
                    var rightChar = line.substring(cursor.column, cursor.column + 1);
 
539
                    if (rightChar == quote) {
 
540
                        return {
 
541
                            text: '',
 
542
                            selection: [1, 1]
 
543
                        };
 
544
                    }
 
545
                }
 
546
            }
 
547
        }
 
548
    });
 
549
 
 
550
    this.add("string_dquotes", "deletion", function (state, action, editor, session, range) {
 
551
        var selected = session.doc.getTextRange(range);
 
552
        if (!range.isMultiLine() && (selected == '"' || selected == "'")) {
 
553
            var line = session.doc.getLine(range.start.row);
 
554
            var rightChar = line.substring(range.start.column + 1, range.start.column + 2);
 
555
            if (rightChar == selected) {
 
556
                range.end.column++;
 
557
                return range;
 
558
            }
 
559
        }
 
560
    });
 
561
 
 
562
};
 
563
 
 
564
oop.inherits(CstyleBehaviour, Behaviour);
 
565
 
 
566
exports.CstyleBehaviour = CstyleBehaviour;
 
567
});
 
568
 
 
569
define('ace/mode/folding/xml', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/lib/lang', 'ace/range', 'ace/mode/folding/fold_mode', 'ace/token_iterator'], function(require, exports, module) {
 
570
 
 
571
 
 
572
var oop = require("../../lib/oop");
 
573
var lang = require("../../lib/lang");
 
574
var Range = require("../../range").Range;
 
575
var BaseFoldMode = require("./fold_mode").FoldMode;
 
576
var TokenIterator = require("../../token_iterator").TokenIterator;
 
577
 
 
578
var FoldMode = exports.FoldMode = function(voidElements) {
 
579
    BaseFoldMode.call(this);
 
580
    this.voidElements = voidElements || {};
 
581
};
 
582
oop.inherits(FoldMode, BaseFoldMode);
 
583
 
 
584
(function() {
 
585
 
 
586
    this.getFoldWidget = function(session, foldStyle, row) {
 
587
        var tag = this._getFirstTagInLine(session, row);
 
588
 
 
589
        if (tag.closing)
 
590
            return foldStyle == "markbeginend" ? "end" : "";
 
591
 
 
592
        if (!tag.tagName || this.voidElements[tag.tagName.toLowerCase()])
 
593
            return "";
 
594
 
 
595
        if (tag.selfClosing)
 
596
            return "";
 
597
 
 
598
        if (tag.value.indexOf("/" + tag.tagName) !== -1)
 
599
            return "";
 
600
 
 
601
        return "start";
 
602
    };
 
603
    
 
604
    this._getFirstTagInLine = function(session, row) {
 
605
        var tokens = session.getTokens(row);
 
606
        var value = "";
 
607
        for (var i = 0; i < tokens.length; i++) {
 
608
            var token = tokens[i];
 
609
            if (token.type.indexOf("meta.tag") === 0)
 
610
                value += token.value;
 
611
            else
 
612
                value += lang.stringRepeat(" ", token.value.length);
 
613
        }
 
614
        
 
615
        return this._parseTag(value);
 
616
    };
 
617
 
 
618
    this.tagRe = /^(\s*)(<?(\/?)([-_a-zA-Z0-9:!]*)\s*(\/?)>?)/;
 
619
    this._parseTag = function(tag) {
 
620
        
 
621
        var match = this.tagRe.exec(tag);
 
622
        var column = this.tagRe.lastIndex || 0;
 
623
        this.tagRe.lastIndex = 0;
 
624
 
 
625
        return {
 
626
            value: tag,
 
627
            match: match ? match[2] : "",
 
628
            closing: match ? !!match[3] : false,
 
629
            selfClosing: match ? !!match[5] || match[2] == "/>" : false,
 
630
            tagName: match ? match[4] : "",
 
631
            column: match[1] ? column + match[1].length : column
 
632
        };
 
633
    };
 
634
    this._readTagForward = function(iterator) {
 
635
        var token = iterator.getCurrentToken();
 
636
        if (!token)
 
637
            return null;
 
638
            
 
639
        var value = "";
 
640
        var start;
 
641
        
 
642
        do {
 
643
            if (token.type.indexOf("meta.tag") === 0) {
 
644
                if (!start) {
 
645
                    var start = {
 
646
                        row: iterator.getCurrentTokenRow(),
 
647
                        column: iterator.getCurrentTokenColumn()
 
648
                    };
 
649
                }
 
650
                value += token.value;
 
651
                if (value.indexOf(">") !== -1) {
 
652
                    var tag = this._parseTag(value);
 
653
                    tag.start = start;
 
654
                    tag.end = {
 
655
                        row: iterator.getCurrentTokenRow(),
 
656
                        column: iterator.getCurrentTokenColumn() + token.value.length
 
657
                    };
 
658
                    iterator.stepForward();
 
659
                    return tag;
 
660
                }
 
661
            }
 
662
        } while(token = iterator.stepForward());
 
663
        
 
664
        return null;
 
665
    };
 
666
    
 
667
    this._readTagBackward = function(iterator) {
 
668
        var token = iterator.getCurrentToken();
 
669
        if (!token)
 
670
            return null;
 
671
            
 
672
        var value = "";
 
673
        var end;
 
674
 
 
675
        do {
 
676
            if (token.type.indexOf("meta.tag") === 0) {
 
677
                if (!end) {
 
678
                    end = {
 
679
                        row: iterator.getCurrentTokenRow(),
 
680
                        column: iterator.getCurrentTokenColumn() + token.value.length
 
681
                    };
 
682
                }
 
683
                value = token.value + value;
 
684
                if (value.indexOf("<") !== -1) {
 
685
                    var tag = this._parseTag(value);
 
686
                    tag.end = end;
 
687
                    tag.start = {
 
688
                        row: iterator.getCurrentTokenRow(),
 
689
                        column: iterator.getCurrentTokenColumn()
 
690
                    };
 
691
                    iterator.stepBackward();
 
692
                    return tag;
 
693
                }
 
694
            }
 
695
        } while(token = iterator.stepBackward());
 
696
        
 
697
        return null;
 
698
    };
 
699
    
 
700
    this._pop = function(stack, tag) {
 
701
        while (stack.length) {
 
702
            
 
703
            var top = stack[stack.length-1];
 
704
            if (!tag || top.tagName == tag.tagName) {
 
705
                return stack.pop();
 
706
            }
 
707
            else if (this.voidElements[tag.tagName]) {
 
708
                return;
 
709
            }
 
710
            else if (this.voidElements[top.tagName]) {
 
711
                stack.pop();
 
712
                continue;
 
713
            } else {
 
714
                return null;
 
715
            }
 
716
        }
 
717
    };
 
718
    
 
719
    this.getFoldWidgetRange = function(session, foldStyle, row) {
 
720
        var firstTag = this._getFirstTagInLine(session, row);
 
721
        
 
722
        if (!firstTag.match)
 
723
            return null;
 
724
        
 
725
        var isBackward = firstTag.closing || firstTag.selfClosing;
 
726
        var stack = [];
 
727
        var tag;
 
728
        
 
729
        if (!isBackward) {
 
730
            var iterator = new TokenIterator(session, row, firstTag.column);
 
731
            var start = {
 
732
                row: row,
 
733
                column: firstTag.column + firstTag.tagName.length + 2
 
734
            };
 
735
            while (tag = this._readTagForward(iterator)) {
 
736
                if (tag.selfClosing) {
 
737
                    if (!stack.length) {
 
738
                        tag.start.column += tag.tagName.length + 2;
 
739
                        tag.end.column -= 2;
 
740
                        return Range.fromPoints(tag.start, tag.end);
 
741
                    } else
 
742
                        continue;
 
743
                }
 
744
                
 
745
                if (tag.closing) {
 
746
                    this._pop(stack, tag);
 
747
                    if (stack.length == 0)
 
748
                        return Range.fromPoints(start, tag.start);
 
749
                }
 
750
                else {
 
751
                    stack.push(tag)
 
752
                }
 
753
            }
 
754
        }
 
755
        else {
 
756
            var iterator = new TokenIterator(session, row, firstTag.column + firstTag.match.length);
 
757
            var end = {
 
758
                row: row,
 
759
                column: firstTag.column
 
760
            };
 
761
            
 
762
            while (tag = this._readTagBackward(iterator)) {
 
763
                if (tag.selfClosing) {
 
764
                    if (!stack.length) {
 
765
                        tag.start.column += tag.tagName.length + 2;
 
766
                        tag.end.column -= 2;
 
767
                        return Range.fromPoints(tag.start, tag.end);
 
768
                    } else
 
769
                        continue;
 
770
                }
 
771
                
 
772
                if (!tag.closing) {
 
773
                    this._pop(stack, tag);
 
774
                    if (stack.length == 0) {
 
775
                        tag.start.column += tag.tagName.length + 2;
 
776
                        return Range.fromPoints(tag.start, end);
 
777
                    }
 
778
                }
 
779
                else {
 
780
                    stack.push(tag)
 
781
                }
 
782
            }
 
783
        }
 
784
        
 
785
    };
 
786
 
 
787
}).call(FoldMode.prototype);
 
788
 
 
789
});