]>
git.wh0rd.org - tt-rss.git/blob - lib/dojo/dom-class.js.uncompressed.js
1 define("dojo/dom-class", ["./_base/lang", "./_base/array", "./dom"], function(lang
, array
, dom
){
5 var className
= "className";
7 /* Part I of classList-based implementation is preserved here for posterity
8 var classList = "classList";
9 has.add("dom-classList", function(){
10 return classList in document.createElement("p");
14 // =============================
15 // (CSS) Class Functions
16 // =============================
18 var cls
, // exports object
19 spaces
= /\s+/, a1
= [""];
21 function str2array(s
){
22 if(typeof s
== "string" || s
instanceof String
){
23 if(s
&& !spaces
.test(s
)){
27 var a
= s
.split(spaces
);
28 if(a
.length
&& !a
[0]){
31 if(a
.length
&& !a
[a
.length
- 1]){
36 // assumed to be an array
40 return array
.filter(s
, function(x
){ return x
; });
43 /* Part II of classList-based implementation is preserved here for posterity
44 if(has("dom-classList")){
45 // new classList version
47 contains: function containsClass(node, classStr){
48 var clslst = classStr && dom.byId(node)[classList];
49 return clslst && clslst.contains(classStr); // Boolean
52 add: function addClass(node, classStr){
53 node = dom.byId(node);
54 classStr = str2array(classStr);
55 for(var i = 0, len = classStr.length; i < len; ++i){
56 node[classList].add(classStr[i]);
60 remove: function removeClass(node, classStr){
61 node = dom.byId(node);
62 if(classStr === undefined){
65 classStr = str2array(classStr);
66 for(var i = 0, len = classStr.length; i < len; ++i){
67 node[classList].remove(classStr[i]);
72 replace: function replaceClass(node, addClassStr, removeClassStr){
73 node = dom.byId(node);
74 if(removeClassStr === undefined){
77 removeClassStr = str2array(removeClassStr);
78 for(var i = 0, len = removeClassStr.length; i < len; ++i){
79 node[classList].remove(removeClassStr[i]);
82 addClassStr = str2array(addClassStr);
83 for(i = 0, len = addClassStr.length; i < len; ++i){
84 node[classList].add(addClassStr[i]);
88 toggle: function toggleClass(node, classStr, condition){
89 node = dom.byId(node);
90 if(condition === undefined){
91 classStr = str2array(classStr);
92 for(var i = 0, len = classStr.length; i < len; ++i){
93 node[classList].toggle(classStr[i]);
96 cls[condition ? "add" : "remove"](node, classStr);
98 return condition; // Boolean
104 // regular DOM version
105 var fakeNode
= {}; // for effective replacement
108 // This module defines the core dojo DOM class API.
110 contains
: function containsClass(/*DomNode|String*/ node
, /*String*/ classStr
){
112 // Returns whether or not the specified classes are a portion of the
113 // class list currently applied to the node.
114 // node: String|DOMNode
115 // String ID or DomNode reference to check the class for.
117 // A string class name to look for.
119 // Do something if a node with id="someNode" has class="aSillyClassName" present
120 // | if(dojo.hasClass("someNode","aSillyClassName")){ ... }
122 return ((" " + dom
.byId(node
)[className
] + " ").indexOf(" " + classStr
+ " ") >= 0); // Boolean
125 add
: function addClass(/*DomNode|String*/ node
, /*String|Array*/ classStr
){
127 // Adds the specified classes to the end of the class list on the
128 // passed node. Will not re-apply duplicate classes.
130 // node: String|DOMNode
131 // String ID or DomNode reference to add a class string too
133 // classStr: String|Array
134 // A String class name to add, or several space-separated class names,
135 // or an array of class names.
138 // Add a class to some node:
139 // | require(["dojo/dom-class"], function(domClass){
140 // | domClass.add("someNode", "anewClass");
144 // Add two classes at once:
145 // | require(["dojo/dom-class"], function(domClass){
146 // | domClass.add("someNode", "firstClass secondClass");
150 // Add two classes at once (using array):
151 // | require(["dojo/dom-class"], function(domClass){
152 // | domClass.add("someNode", ["firstClass", "secondClass"]);
156 // Available in `dojo/NodeList` for multiple additions
157 // | require(["dojo/query"], function(query){
158 // | query("ul > li").addClass("firstLevel");
161 node
= dom
.byId(node
);
162 classStr
= str2array(classStr
);
163 var cls
= node
[className
], oldLen
;
164 cls
= cls
? " " + cls
+ " " : " ";
166 for(var i
= 0, len
= classStr
.length
, c
; i
< len
; ++i
){
168 if(c
&& cls
.indexOf(" " + c
+ " ") < 0){
172 if(oldLen
< cls
.length
){
173 node
[className
] = cls
.substr(1, cls
.length
- 2);
177 remove
: function removeClass(/*DomNode|String*/ node
, /*String|Array?*/ classStr
){
179 // Removes the specified classes from node. No `contains()`
180 // check is required.
182 // node: String|DOMNode
183 // String ID or DomNode reference to remove the class from.
185 // classStr: String|Array
186 // An optional String class name to remove, or several space-separated
187 // class names, or an array of class names. If omitted, all class names
191 // Remove a class from some node:
192 // | require(["dojo/dom-class"], function(domClass){
193 // | domClass.remove("someNode", "firstClass");
197 // Remove two classes from some node:
198 // | require(["dojo/dom-class"], function(domClass){
199 // | domClass.remove("someNode", "firstClass secondClass");
203 // Remove two classes from some node (using array):
204 // | require(["dojo/dom-class"], function(domClass){
205 // | domClass.remove("someNode", ["firstClass", "secondClass"]);
209 // Remove all classes from some node:
210 // | require(["dojo/dom-class"], function(domClass){
211 // | domClass.remove("someNode");
215 // Available in `dojo/NodeList` for multiple removal
216 // | require(["dojo/query"], function(query){
217 // | query("ul > li").removeClass("foo");
220 node
= dom
.byId(node
);
222 if(classStr
!== undefined){
223 classStr
= str2array(classStr
);
224 cls
= " " + node
[className
] + " ";
225 for(var i
= 0, len
= classStr
.length
; i
< len
; ++i
){
226 cls
= cls
.replace(" " + classStr
[i
] + " ", " ");
228 cls
= lang
.trim(cls
);
232 if(node
[className
] != cls
){ node
[className
] = cls
; }
235 replace
: function replaceClass(/*DomNode|String*/ node
, /*String|Array*/ addClassStr
, /*String|Array?*/ removeClassStr
){
237 // Replaces one or more classes on a node if not present.
238 // Operates more quickly than calling dojo.removeClass and dojo.addClass
240 // node: String|DOMNode
241 // String ID or DomNode reference to remove the class from.
243 // addClassStr: String|Array
244 // A String class name to add, or several space-separated class names,
245 // or an array of class names.
247 // removeClassStr: String|Array?
248 // A String class name to remove, or several space-separated class names,
249 // or an array of class names.
252 // | require(["dojo/dom-class"], function(domClass){
253 // | domClass.replace("someNode", "add1 add2", "remove1 remove2");
257 // Replace all classes with addMe
258 // | require(["dojo/dom-class"], function(domClass){
259 // | domClass.replace("someNode", "addMe");
263 // Available in `dojo/NodeList` for multiple toggles
264 // | require(["dojo/query"], function(query){
265 // | query(".findMe").replaceClass("addMe", "removeMe");
268 node
= dom
.byId(node
);
269 fakeNode
[className
] = node
[className
];
270 cls
.remove(fakeNode
, removeClassStr
);
271 cls
.add(fakeNode
, addClassStr
);
272 if(node
[className
] !== fakeNode
[className
]){
273 node
[className
] = fakeNode
[className
];
277 toggle
: function toggleClass(/*DomNode|String*/ node
, /*String|Array*/ classStr
, /*Boolean?*/ condition
){
279 // Adds a class to node if not present, or removes if present.
280 // Pass a boolean condition if you want to explicitly add or remove.
281 // Returns the condition that was specified directly or indirectly.
283 // node: String|DOMNode
284 // String ID or DomNode reference to toggle a class string
286 // classStr: String|Array
287 // A String class name to toggle, or several space-separated class names,
288 // or an array of class names.
291 // If passed, true means to add the class, false means to remove.
292 // Otherwise dojo.hasClass(node, classStr) is used to detect the class presence.
295 // | require(["dojo/dom-class"], function(domClass){
296 // | domClass.toggle("someNode", "hovered");
300 // Forcefully add a class
301 // | require(["dojo/dom-class"], function(domClass){
302 // | domClass.toggle("someNode", "hovered", true);
306 // Available in `dojo/NodeList` for multiple toggles
307 // | require(["dojo/query"], function(query){
308 // | query(".toggleMe").toggleClass("toggleMe");
311 node
= dom
.byId(node
);
312 if(condition
=== undefined){
313 classStr
= str2array(classStr
);
314 for(var i
= 0, len
= classStr
.length
, c
; i
< len
; ++i
){
316 cls
[cls
.contains(node
, c
) ? "remove" : "add"](node
, c
);
319 cls
[condition
? "add" : "remove"](node
, classStr
);
321 return condition
; // Boolean