]> git.sur5r.net Git - bacula/bacula/blob - gui/baculum/debian/missing-sources/framework/Web/Javascripts/source/tinymce-405/classes/html/Serializer.js
baculum: Add missing-sources directory in debian metadata structure
[bacula/bacula] / gui / baculum / debian / missing-sources / framework / Web / Javascripts / source / tinymce-405 / classes / html / Serializer.js
1 /**
2  * Serializer.js
3  *
4  * Copyright, Moxiecode Systems AB
5  * Released under LGPL License.
6  *
7  * License: http://www.tinymce.com/license
8  * Contributing: http://www.tinymce.com/contributing
9  */
10
11 /**
12  * This class is used to serialize down the DOM tree into a string using a Writer instance.
13  *
14  *
15  * @example
16  * new tinymce.html.Serializer().serialize(new tinymce.html.DomParser().parse('<p>text</p>'));
17  * @class tinymce.html.Serializer
18  * @version 3.4
19  */
20 define("tinymce/html/Serializer", [
21         "tinymce/html/Writer",
22         "tinymce/html/Schema"
23 ], function(Writer, Schema) {
24         /**
25          * Constructs a new Serializer instance.
26          *
27          * @constructor
28          * @method Serializer
29          * @param {Object} settings Name/value settings object.
30          * @param {tinymce.html.Schema} schema Schema instance to use.
31          */
32         return function(settings, schema) {
33                 var self = this, writer = new Writer(settings);
34
35                 settings = settings || {};
36                 settings.validate = "validate" in settings ? settings.validate : true;
37
38                 self.schema = schema = schema || new Schema();
39                 self.writer = writer;
40
41                 /**
42                  * Serializes the specified node into a string.
43                  *
44                  * @example
45                  * new tinymce.html.Serializer().serialize(new tinymce.html.DomParser().parse('<p>text</p>'));
46                  * @method serialize
47                  * @param {tinymce.html.Node} node Node instance to serialize.
48                  * @return {String} String with HTML based on DOM tree.
49                  */
50                 self.serialize = function(node) {
51                         var handlers, validate;
52
53                         validate = settings.validate;
54
55                         handlers = {
56                                 // #text
57                                 3: function(node) {
58                                         writer.text(node.value, node.raw);
59                                 },
60
61                                 // #comment
62                                 8: function(node) {
63                                         writer.comment(node.value);
64                                 },
65
66                                 // Processing instruction
67                                 7: function(node) {
68                                         writer.pi(node.name, node.value);
69                                 },
70
71                                 // Doctype
72                                 10: function(node) {
73                                         writer.doctype(node.value);
74                                 },
75
76                                 // CDATA
77                                 4: function(node) {
78                                         writer.cdata(node.value);
79                                 },
80
81                                 // Document fragment
82                                 11: function(node) {
83                                         if ((node = node.firstChild)) {
84                                                 do {
85                                                         walk(node);
86                                                 } while ((node = node.next));
87                                         }
88                                 }
89                         };
90
91                         writer.reset();
92
93                         function walk(node) {
94                                 var handler = handlers[node.type], name, isEmpty, attrs, attrName, attrValue, sortedAttrs, i, l, elementRule;
95
96                                 if (!handler) {
97                                         name = node.name;
98                                         isEmpty = node.shortEnded;
99                                         attrs = node.attributes;
100
101                                         // Sort attributes
102                                         if (validate && attrs && attrs.length > 1) {
103                                                 sortedAttrs = [];
104                                                 sortedAttrs.map = {};
105
106                                                 elementRule = schema.getElementRule(node.name);
107                                                 for (i = 0, l = elementRule.attributesOrder.length; i < l; i++) {
108                                                         attrName = elementRule.attributesOrder[i];
109
110                                                         if (attrName in attrs.map) {
111                                                                 attrValue = attrs.map[attrName];
112                                                                 sortedAttrs.map[attrName] = attrValue;
113                                                                 sortedAttrs.push({name: attrName, value: attrValue});
114                                                         }
115                                                 }
116
117                                                 for (i = 0, l = attrs.length; i < l; i++) {
118                                                         attrName = attrs[i].name;
119
120                                                         if (!(attrName in sortedAttrs.map)) {
121                                                                 attrValue = attrs.map[attrName];
122                                                                 sortedAttrs.map[attrName] = attrValue;
123                                                                 sortedAttrs.push({name: attrName, value: attrValue});
124                                                         }
125                                                 }
126
127                                                 attrs = sortedAttrs;
128                                         }
129
130                                         writer.start(node.name, attrs, isEmpty);
131
132                                         if (!isEmpty) {
133                                                 if ((node = node.firstChild)) {
134                                                         do {
135                                                                 walk(node);
136                                                         } while ((node = node.next));
137                                                 }
138
139                                                 writer.end(name);
140                                         }
141                                 } else {
142                                         handler(node);
143                                 }
144                         }
145
146                         // Serialize element and treat all non elements as fragments
147                         if (node.type == 1 && !settings.inner) {
148                                 walk(node);
149                         } else {
150                                 handlers[11](node);
151                         }
152
153                         return writer.getContent();
154                 };
155         };
156 });