Tagging the 1.4.3rc2 release.
[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                                 return val + "px";
173                         }
174                 },
175
176                 set: function( elem, value ) {
177                         if ( rnumpx.test( value ) ) {
178                                 // ignore negative width and height values #1599
179                                 value = parseFloat(value);
180
181                                 if ( value >= 0 ) {
182                                         return value + "px";
183                                 }
184
185                         } else {
186                                 return value;
187                         }
188                 }
189         };
190 });
191
192 if ( !jQuery.support.opacity ) {
193         jQuery.cssHooks.opacity = {
194                 get: function( elem, computed ) {
195                         // IE uses filters for opacity
196                         return ropacity.test((computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "") ?
197                                 (parseFloat(RegExp.$1) / 100) + "" :
198                                 computed ? "1" : "";
199                 },
200
201                 set: function( elem, value ) {
202                         var style = elem.style;
203
204                         // IE has trouble with opacity if it does not have layout
205                         // Force it by setting the zoom level
206                         style.zoom = 1;
207
208                         // Set the alpha filter to set the opacity
209                         var opacity = jQuery.isNaN(value) ?
210                                 "" :
211                                 "alpha(opacity=" + value * 100 + ")",
212                                 filter = style.filter || "";
213
214                         style.filter = ralpha.test(filter) ?
215                                 filter.replace(ralpha, opacity) :
216                                 style.filter + ' ' + opacity;
217                 }
218         };
219 }
220
221 if ( getComputedStyle ) {
222         curCSS = function( elem, newName, name ) {
223                 var ret, defaultView, computedStyle;
224
225                 name = name.replace( rupper, "-$1" ).toLowerCase();
226
227                 if ( !(defaultView = elem.ownerDocument.defaultView) ) {
228                         return undefined;
229                 }
230
231                 if ( (computedStyle = defaultView.getComputedStyle( elem, null )) ) {
232                         ret = computedStyle.getPropertyValue( name );
233                         if ( ret === "" && !jQuery.contains( elem.ownerDocument.documentElement, elem ) ) {
234                                 ret = jQuery.style( elem, name );
235                         }
236                 }
237
238                 return ret;
239         };
240
241 } else if ( document.documentElement.currentStyle ) {
242         curCSS = function( elem, name ) {
243                 var left, rsLeft, ret = elem.currentStyle && elem.currentStyle[ name ], style = elem.style;
244
245                 // From the awesome hack by Dean Edwards
246                 // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
247
248                 // If we're not dealing with a regular pixel number
249                 // but a number that has a weird ending, we need to convert it to pixels
250                 if ( !rnumpx.test( ret ) && rnum.test( ret ) ) {
251                         // Remember the original values
252                         left = style.left;
253                         rsLeft = elem.runtimeStyle.left;
254
255                         // Put in the new values to get a computed value out
256                         elem.runtimeStyle.left = elem.currentStyle.left;
257                         style.left = name === "fontSize" ? "1em" : (ret || 0);
258                         ret = style.pixelLeft + "px";
259
260                         // Revert the changed values
261                         style.left = left;
262                         elem.runtimeStyle.left = rsLeft;
263                 }
264
265                 return ret;
266         };
267 }
268
269 function getWH( elem, name, extra ) {
270         var which = name === "width" ? cssWidth : cssHeight,
271                 val = name === "width" ? elem.offsetWidth : elem.offsetHeight;
272
273         if ( extra === "border" ) {
274                 return val;
275         }
276
277         jQuery.each( which, function() {
278                 if ( !extra ) {
279                         val -= parseFloat(jQuery.css( elem, "padding" + this )) || 0;
280                 }
281
282                 if ( extra === "margin" ) {
283                         val += parseFloat(jQuery.css( elem, "margin" + this )) || 0;
284
285                 } else {
286                         val -= parseFloat(jQuery.css( elem, "border" + this + "Width" )) || 0;
287                 }
288         });
289
290         return val;
291 }
292
293 if ( jQuery.expr && jQuery.expr.filters ) {
294         jQuery.expr.filters.hidden = function( elem ) {
295                 var width = elem.offsetWidth, height = elem.offsetHeight;
296
297                 return (width === 0 && height === 0) || (!jQuery.support.reliableHiddenOffsets && (elem.style.display || jQuery.css( elem, "display" )) === "none");
298         };
299
300         jQuery.expr.filters.visible = function( elem ) {
301                 return !jQuery.expr.filters.hidden( elem );
302         };
303 }
304
305 })( jQuery );