Merge branch '6897' of http://github.com/SlexAxton/jquery into SlexAxton-6897
[jquery.git] / src / css.js
1 (function( jQuery ) {
2
3 var ralpha = /alpha\([^)]*\)/i,
4         ropacity = /opacity=([^)]*)/,
5         rdashAlpha = /-([a-z])/ig,
6         rupper = /([A-Z])/g,
7         rnumpx = /^-?\d+(?:px)?$/i,
8         rnum = /^-?\d/,
9
10         cssShow = { position: "absolute", visibility: "hidden", display: "block" },
11         cssWidth = [ "Left", "Right" ],
12         cssHeight = [ "Top", "Bottom" ],
13         curCSS,
14
15         // cache check for defaultView.getComputedStyle
16         getComputedStyle = document.defaultView && document.defaultView.getComputedStyle,
17
18         fcamelCase = function( all, letter ) {
19                 return letter.toUpperCase();
20         };
21
22 jQuery.fn.css = function( name, value ) {
23         // Setting 'undefined' is a no-op
24         if ( arguments.length === 2 && value === undefined ) {
25                 return this;
26         }
27
28         return jQuery.access( this, name, value, true, function( elem, name, value ) {
29                 return value !== undefined ?
30                         jQuery.style( elem, name, value ) :
31                         jQuery.css( elem, name );
32         });
33 };
34
35 jQuery.extend({
36         // Add in style property hooks for overriding the default
37         // behavior of getting and setting a style property
38         cssHooks: {
39                 opacity: {
40                         get: function( elem, computed ) {
41                                 if ( computed ) {
42                                         // We should always get a number back from opacity
43                                         var ret = curCSS( elem, "opacity", "opacity" );
44                                         return ret === "" ? "1" : ret;
45
46                                 } else {
47                                         return elem.style.opacity;
48                                 }
49                         }
50                 }
51         },
52
53         // Exclude the following css properties to add px
54         cssNumber: {
55                 "zIndex": true,
56                 "fontWeight": true,
57                 "opacity": true,
58                 "zoom": true,
59                 "lineHeight": true
60         },
61
62         // Add in properties whose names you wish to fix before
63         // setting or getting the value
64         cssProps: {
65                 // normalize float css property
66                 "float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
67         },
68
69         // Get and set the style property on a DOM Node
70         style: function( elem, name, value, extra ) {
71                 // Don't set styles on text and comment nodes
72                 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
73                         return;
74                 }
75
76                 // Make sure that we're working with the right name
77                 var ret, origName = jQuery.camelCase( name ),
78                         style = elem.style, hooks = jQuery.cssHooks[ origName ];
79
80                 name = jQuery.cssProps[ origName ] || origName;
81
82                 // Check if we're setting a value
83                 if ( value !== undefined ) {
84                         // Make sure that NaN and null values aren't set. See: #7116
85                         if ( typeof value === "number" && isNaN( value ) || value == null ) {
86                                 return;
87                         }
88
89                         // If a number was passed in, add 'px' to the (except for certain CSS properties)
90                         if ( typeof value === "number" && !jQuery.cssNumber[ origName ] ) {
91                                 value += "px";
92                         }
93
94                         // If a hook was provided, use that value, otherwise just set the specified value
95                         if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value )) !== undefined ) {
96                                 // Wrapped to prevent IE from throwing errors when 'invalid' values are provided
97                                 // Fixes bug #5509
98                                 try {
99                                         style[ name ] = value;
100                                 } catch(e) {}
101                         }
102
103                 } else {
104                         // If a hook was provided get the non-computed value from there
105                         if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
106                                 return ret;
107                         }
108
109                         // Otherwise just get the value from the style object
110                         return style[ name ];
111                 }
112         },
113
114         css: function( elem, name, extra ) {
115                 // Make sure that we're working with the right name
116                 var ret, origName = jQuery.camelCase( name ),
117                         hooks = jQuery.cssHooks[ origName ];
118
119                 name = jQuery.cssProps[ origName ] || origName;
120
121                 // If a hook was provided get the computed value from there
122                 if ( hooks && "get" in hooks && (ret = hooks.get( elem, true, extra )) !== undefined ) {
123                         return ret;
124
125                 // Otherwise, if a way to get the computed value exists, use that
126                 } else if ( curCSS ) {
127                         return curCSS( elem, name, origName );
128                 }
129         },
130
131         // A method for quickly swapping in/out CSS properties to get correct calculations
132         swap: function( elem, options, callback ) {
133                 var old = {};
134
135                 // Remember the old values, and insert the new ones
136                 for ( var name in options ) {
137                         old[ name ] = elem.style[ name ];
138                         elem.style[ name ] = options[ name ];
139                 }
140
141                 callback.call( elem );
142
143                 // Revert the old values
144                 for ( name in options ) {
145                         elem.style[ name ] = old[ name ];
146                 }
147         },
148
149         camelCase: function( string ) {
150                 return string.replace( rdashAlpha, fcamelCase );
151         }
152 });
153
154 // DEPRECATED, Use jQuery.css() instead
155 jQuery.curCSS = jQuery.css;
156
157 jQuery.each(["height", "width"], function( i, name ) {
158         jQuery.cssHooks[ name ] = {
159                 get: function( elem, computed, extra ) {
160                         var val;
161
162                         if ( computed ) {
163                                 if ( elem.offsetWidth !== 0 ) {
164                                         val = getWH( elem, name, extra );
165
166                                 } else {
167                                         jQuery.swap( elem, cssShow, function() {
168                                                 val = getWH( elem, name, extra );
169                                         });
170                                 }
171
172                                 if ( val <= 0 ) {
173                                         val = curCSS( elem, name, name );
174
175                                         if ( val != null ) {
176                                                 return val === "auto" ? "" : val;
177                                         }
178                                 }
179
180                                 if ( val < 0 || val == null ) {
181                                         return elem.style[ name ];
182                                 }
183
184                                 return typeof val === "string" ? val : val + "px";
185                         }
186                 },
187
188                 set: function( elem, value ) {
189                         if ( rnumpx.test( value ) ) {
190                                 // ignore negative width and height values #1599
191                                 value = parseFloat(value);
192
193                                 if ( value >= 0 ) {
194                                         return value + "px";
195                                 }
196
197                         } else {
198                                 return value;
199                         }
200                 }
201         };
202 });
203
204 if ( !jQuery.support.opacity ) {
205         jQuery.cssHooks.opacity = {
206                 get: function( elem, computed ) {
207                         // IE uses filters for opacity
208                         return ropacity.test((computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "") ?
209                                 (parseFloat(RegExp.$1) / 100) + "" :
210                                 computed ? "1" : "";
211                 },
212
213                 set: function( elem, value ) {
214                         var style = elem.style;
215
216                         // IE has trouble with opacity if it does not have layout
217                         // Force it by setting the zoom level
218                         style.zoom = 1;
219
220                         // Set the alpha filter to set the opacity
221                         var opacity = jQuery.isNaN(value) ?
222                                 "" :
223                                 "alpha(opacity=" + value * 100 + ")",
224                                 filter = style.filter || "";
225
226                         style.filter = ralpha.test(filter) ?
227                                 filter.replace(ralpha, opacity) :
228                                 style.filter + ' ' + opacity;
229                 }
230         };
231 }
232
233 if ( getComputedStyle ) {
234         curCSS = function( elem, newName, name ) {
235                 var ret, defaultView, computedStyle;
236
237                 name = name.replace( rupper, "-$1" ).toLowerCase();
238
239                 if ( !(defaultView = elem.ownerDocument.defaultView) ) {
240                         return undefined;
241                 }
242
243                 if ( (computedStyle = defaultView.getComputedStyle( elem, null )) ) {
244                         ret = computedStyle.getPropertyValue( name );
245                         if ( ret === "" && !jQuery.contains( elem.ownerDocument.documentElement, elem ) ) {
246                                 ret = jQuery.style( elem, name );
247                         }
248                 }
249
250                 return ret;
251         };
252
253 } else if ( document.documentElement.currentStyle ) {
254         curCSS = function( elem, name ) {
255                 var left, rsLeft, ret = elem.currentStyle && elem.currentStyle[ name ], style = elem.style;
256
257                 // From the awesome hack by Dean Edwards
258                 // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
259
260                 // If we're not dealing with a regular pixel number
261                 // but a number that has a weird ending, we need to convert it to pixels
262                 if ( !rnumpx.test( ret ) && rnum.test( ret ) ) {
263                         // Remember the original values
264                         left = style.left;
265                         rsLeft = elem.runtimeStyle.left;
266
267                         // Put in the new values to get a computed value out
268                         elem.runtimeStyle.left = elem.currentStyle.left;
269                         style.left = name === "fontSize" ? "1em" : (ret || 0);
270                         ret = style.pixelLeft + "px";
271
272                         // Revert the changed values
273                         style.left = left;
274                         elem.runtimeStyle.left = rsLeft;
275                 }
276
277                 return ret;
278         };
279 }
280
281 function getWH( elem, name, extra ) {
282         var which = name === "width" ? cssWidth : cssHeight,
283                 val = name === "width" ? elem.offsetWidth : elem.offsetHeight;
284
285         if ( extra === "border" ) {
286                 return val;
287         }
288
289         jQuery.each( which, function() {
290                 if ( !extra ) {
291                         val -= parseFloat(jQuery.css( elem, "padding" + this )) || 0;
292                 }
293
294                 if ( extra === "margin" ) {
295                         val += parseFloat(jQuery.css( elem, "margin" + this )) || 0;
296
297                 } else {
298                         val -= parseFloat(jQuery.css( elem, "border" + this + "Width" )) || 0;
299                 }
300         });
301
302         return val;
303 }
304
305 if ( jQuery.expr && jQuery.expr.filters ) {
306         jQuery.expr.filters.hidden = function( elem ) {
307                 var width = elem.offsetWidth, height = elem.offsetHeight;
308
309                 return (width === 0 && height === 0) || (!jQuery.support.reliableHiddenOffsets && (elem.style.display || jQuery.css( elem, "display" )) === "none");
310         };
311
312         jQuery.expr.filters.visible = function( elem ) {
313                 return !jQuery.expr.filters.hidden( elem );
314         };
315 }
316
317 })( jQuery );