Line data Source code
1 : /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 : /* vim: set ts=8 sts=2 et sw=2 tw=80: */
3 : /* This Source Code Form is subject to the terms of the Mozilla Public
4 : * License, v. 2.0. If a copy of the MPL was not distributed with this
5 : * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6 :
7 : /* DOM object representing values in DOM computed style */
8 :
9 : #include "nsROCSSPrimitiveValue.h"
10 :
11 : #include "mozilla/dom/CSSPrimitiveValueBinding.h"
12 : #include "nsPresContext.h"
13 : #include "nsStyleUtil.h"
14 : #include "nsDOMCSSRGBColor.h"
15 : #include "nsDOMCSSRect.h"
16 : #include "nsIURI.h"
17 : #include "nsError.h"
18 :
19 : using namespace mozilla;
20 :
21 16 : nsROCSSPrimitiveValue::nsROCSSPrimitiveValue()
22 16 : : CSSValue(), mType(CSS_PX)
23 : {
24 16 : mValue.mAppUnits = 0;
25 16 : }
26 :
27 :
28 8 : nsROCSSPrimitiveValue::~nsROCSSPrimitiveValue()
29 : {
30 4 : Reset();
31 4 : }
32 :
33 16 : NS_IMPL_CYCLE_COLLECTING_ADDREF(nsROCSSPrimitiveValue)
34 12 : NS_IMPL_CYCLE_COLLECTING_RELEASE(nsROCSSPrimitiveValue)
35 :
36 40 : NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsROCSSPrimitiveValue)
37 0 : NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
38 0 : NS_INTERFACE_MAP_ENTRY(nsIDOMCSSPrimitiveValue)
39 0 : NS_INTERFACE_MAP_ENTRY(nsIDOMCSSValue)
40 0 : NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, CSSValue)
41 0 : NS_INTERFACE_MAP_END
42 :
43 : NS_IMPL_CYCLE_COLLECTION_CLASS(nsROCSSPrimitiveValue)
44 :
45 4 : NS_IMPL_CYCLE_COLLECTION_TRACE_WRAPPERCACHE(nsROCSSPrimitiveValue)
46 :
47 0 : NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsROCSSPrimitiveValue)
48 0 : if (tmp->mType == CSS_URI) {
49 0 : NS_IMPL_CYCLE_COLLECTION_TRAVERSE_RAWPTR(mValue.mURI)
50 0 : } else if (tmp->mType == CSS_RGBCOLOR) {
51 0 : NS_IMPL_CYCLE_COLLECTION_TRAVERSE_RAWPTR(mValue.mColor)
52 0 : } else if (tmp->mType == CSS_RECT) {
53 0 : NS_IMPL_CYCLE_COLLECTION_TRAVERSE_RAWPTR(mValue.mRect)
54 : }
55 0 : NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
56 :
57 0 : NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsROCSSPrimitiveValue)
58 0 : NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
59 0 : tmp->Reset();
60 0 : NS_IMPL_CYCLE_COLLECTION_UNLINK_END
61 :
62 : JSObject*
63 0 : nsROCSSPrimitiveValue::WrapObject(JSContext *cx, JS::Handle<JSObject*> aGivenProto)
64 : {
65 0 : return dom::CSSPrimitiveValueBinding::Wrap(cx, this, aGivenProto);
66 : }
67 :
68 : // nsIDOMCSSValue
69 :
70 :
71 : NS_IMETHODIMP
72 13 : nsROCSSPrimitiveValue::GetCssText(nsAString& aCssText)
73 : {
74 26 : nsAutoString tmpStr;
75 13 : aCssText.Truncate();
76 13 : nsresult result = NS_OK;
77 :
78 13 : switch (mType) {
79 : case CSS_PX :
80 : {
81 0 : float val = nsPresContext::AppUnitsToFloatCSSPixels(mValue.mAppUnits);
82 0 : nsStyleUtil::AppendCSSNumber(val, tmpStr);
83 0 : tmpStr.AppendLiteral("px");
84 0 : break;
85 : }
86 : case CSS_IDENT :
87 : {
88 1 : AppendUTF8toUTF16(nsCSSKeywords::GetStringValue(mValue.mKeyword),
89 1 : tmpStr);
90 1 : break;
91 : }
92 : case CSS_STRING :
93 : case CSS_COUNTER : /* FIXME: COUNTER should use an object */
94 : {
95 0 : tmpStr.Append(mValue.mString);
96 0 : break;
97 : }
98 : case CSS_URI :
99 : {
100 0 : if (mValue.mURI) {
101 0 : nsAutoCString specUTF8;
102 0 : nsresult rv = mValue.mURI->GetSpec(specUTF8);
103 0 : NS_ENSURE_SUCCESS(rv, rv);
104 :
105 0 : tmpStr.AssignLiteral("url(");
106 0 : nsStyleUtil::AppendEscapedCSSString(NS_ConvertUTF8toUTF16(specUTF8),
107 0 : tmpStr);
108 0 : tmpStr.Append(')');
109 : } else {
110 : // http://dev.w3.org/csswg/css3-values/#attr defines
111 : // 'about:invalid' as the default value for url attributes,
112 : // so let's also use it here as the default computed value
113 : // for invalid URLs.
114 0 : tmpStr.AssignLiteral(u"url(about:invalid)");
115 : }
116 0 : break;
117 : }
118 : case CSS_ATTR :
119 : {
120 0 : tmpStr.AppendLiteral("attr(");
121 0 : tmpStr.Append(mValue.mString);
122 0 : tmpStr.Append(char16_t(')'));
123 0 : break;
124 : }
125 : case CSS_PERCENTAGE :
126 : {
127 0 : nsStyleUtil::AppendCSSNumber(mValue.mFloat * 100, tmpStr);
128 0 : tmpStr.Append(char16_t('%'));
129 0 : break;
130 : }
131 : case CSS_NUMBER :
132 : {
133 0 : nsStyleUtil::AppendCSSNumber(mValue.mFloat, tmpStr);
134 0 : break;
135 : }
136 : case CSS_NUMBER_INT32 :
137 : {
138 9 : tmpStr.AppendInt(mValue.mInt32);
139 9 : break;
140 : }
141 : case CSS_NUMBER_UINT32 :
142 : {
143 0 : tmpStr.AppendInt(mValue.mUint32);
144 0 : break;
145 : }
146 : case CSS_DEG :
147 : {
148 0 : nsStyleUtil::AppendCSSNumber(mValue.mFloat, tmpStr);
149 0 : tmpStr.AppendLiteral("deg");
150 0 : break;
151 : }
152 : case CSS_GRAD :
153 : {
154 0 : nsStyleUtil::AppendCSSNumber(mValue.mFloat, tmpStr);
155 0 : tmpStr.AppendLiteral("grad");
156 0 : break;
157 : }
158 : case CSS_RAD :
159 : {
160 0 : nsStyleUtil::AppendCSSNumber(mValue.mFloat, tmpStr);
161 0 : tmpStr.AppendLiteral("rad");
162 0 : break;
163 : }
164 : case CSS_TURN :
165 : {
166 0 : nsStyleUtil::AppendCSSNumber(mValue.mFloat, tmpStr);
167 0 : tmpStr.AppendLiteral("turn");
168 0 : break;
169 : }
170 : case CSS_RECT :
171 : {
172 0 : NS_ASSERTION(mValue.mRect, "mValue.mRect should never be null");
173 0 : NS_NAMED_LITERAL_STRING(comma, ", ");
174 0 : nsCOMPtr<nsIDOMCSSPrimitiveValue> sideCSSValue;
175 0 : nsAutoString sideValue;
176 0 : tmpStr.AssignLiteral("rect(");
177 : // get the top
178 0 : result = mValue.mRect->GetTop(getter_AddRefs(sideCSSValue));
179 0 : if (NS_FAILED(result))
180 0 : break;
181 0 : result = sideCSSValue->GetCssText(sideValue);
182 0 : if (NS_FAILED(result))
183 0 : break;
184 0 : tmpStr.Append(sideValue + comma);
185 : // get the right
186 0 : result = mValue.mRect->GetRight(getter_AddRefs(sideCSSValue));
187 0 : if (NS_FAILED(result))
188 0 : break;
189 0 : result = sideCSSValue->GetCssText(sideValue);
190 0 : if (NS_FAILED(result))
191 0 : break;
192 0 : tmpStr.Append(sideValue + comma);
193 : // get the bottom
194 0 : result = mValue.mRect->GetBottom(getter_AddRefs(sideCSSValue));
195 0 : if (NS_FAILED(result))
196 0 : break;
197 0 : result = sideCSSValue->GetCssText(sideValue);
198 0 : if (NS_FAILED(result))
199 0 : break;
200 0 : tmpStr.Append(sideValue + comma);
201 : // get the left
202 0 : result = mValue.mRect->GetLeft(getter_AddRefs(sideCSSValue));
203 0 : if (NS_FAILED(result))
204 0 : break;
205 0 : result = sideCSSValue->GetCssText(sideValue);
206 0 : if (NS_FAILED(result))
207 0 : break;
208 0 : tmpStr.Append(sideValue + NS_LITERAL_STRING(")"));
209 0 : break;
210 : }
211 : case CSS_RGBCOLOR :
212 : {
213 3 : NS_ASSERTION(mValue.mColor, "mValue.mColor should never be null");
214 6 : ErrorResult error;
215 3 : NS_NAMED_LITERAL_STRING(comma, ", ");
216 6 : nsAutoString colorValue;
217 3 : if (mValue.mColor->HasAlpha())
218 0 : tmpStr.AssignLiteral("rgba(");
219 : else
220 3 : tmpStr.AssignLiteral("rgb(");
221 :
222 : // get the red component
223 3 : mValue.mColor->Red()->GetCssText(colorValue, error);
224 3 : if (error.Failed())
225 0 : break;
226 3 : tmpStr.Append(colorValue + comma);
227 :
228 : // get the green component
229 3 : mValue.mColor->Green()->GetCssText(colorValue, error);
230 3 : if (error.Failed())
231 0 : break;
232 3 : tmpStr.Append(colorValue + comma);
233 :
234 : // get the blue component
235 3 : mValue.mColor->Blue()->GetCssText(colorValue, error);
236 3 : if (error.Failed())
237 0 : break;
238 3 : tmpStr.Append(colorValue);
239 :
240 3 : if (mValue.mColor->HasAlpha()) {
241 : // get the alpha component
242 0 : mValue.mColor->Alpha()->GetCssText(colorValue, error);
243 0 : if (error.Failed())
244 0 : break;
245 0 : tmpStr.Append(comma + colorValue);
246 : }
247 :
248 3 : tmpStr.Append(')');
249 :
250 3 : break;
251 : }
252 : case CSS_S :
253 : {
254 0 : nsStyleUtil::AppendCSSNumber(mValue.mFloat, tmpStr);
255 0 : tmpStr.Append('s');
256 0 : break;
257 : }
258 : case CSS_CM :
259 : case CSS_MM :
260 : case CSS_IN :
261 : case CSS_PT :
262 : case CSS_PC :
263 : case CSS_UNKNOWN :
264 : case CSS_EMS :
265 : case CSS_EXS :
266 : case CSS_MS :
267 : case CSS_HZ :
268 : case CSS_KHZ :
269 : case CSS_DIMENSION :
270 0 : NS_ERROR("We have a bogus value set. This should not happen");
271 0 : return NS_ERROR_DOM_INVALID_ACCESS_ERR;
272 : }
273 :
274 13 : if (NS_SUCCEEDED(result)) {
275 13 : aCssText.Assign(tmpStr);
276 : }
277 :
278 13 : return NS_OK;
279 : }
280 :
281 : void
282 13 : nsROCSSPrimitiveValue::GetCssText(nsString& aText, ErrorResult& aRv)
283 : {
284 13 : aRv = GetCssText(aText);
285 13 : }
286 :
287 : NS_IMETHODIMP
288 0 : nsROCSSPrimitiveValue::SetCssText(const nsAString& aCssText)
289 : {
290 0 : return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;
291 : }
292 :
293 : void
294 0 : nsROCSSPrimitiveValue::SetCssText(const nsAString& aText, ErrorResult& aRv)
295 : {
296 0 : aRv = SetCssText(aText);
297 0 : }
298 :
299 :
300 : NS_IMETHODIMP
301 0 : nsROCSSPrimitiveValue::GetCssValueType(uint16_t* aValueType)
302 : {
303 0 : NS_ENSURE_ARG_POINTER(aValueType);
304 0 : *aValueType = nsIDOMCSSValue::CSS_PRIMITIVE_VALUE;
305 0 : return NS_OK;
306 : }
307 :
308 : uint16_t
309 0 : nsROCSSPrimitiveValue::CssValueType() const
310 : {
311 0 : return nsIDOMCSSValue::CSS_PRIMITIVE_VALUE;
312 : }
313 :
314 :
315 : // nsIDOMCSSPrimitiveValue
316 :
317 : NS_IMETHODIMP
318 0 : nsROCSSPrimitiveValue::GetPrimitiveType(uint16_t* aPrimitiveType)
319 : {
320 0 : NS_ENSURE_ARG_POINTER(aPrimitiveType);
321 0 : *aPrimitiveType = PrimitiveType();
322 :
323 0 : return NS_OK;
324 : }
325 :
326 :
327 : NS_IMETHODIMP
328 0 : nsROCSSPrimitiveValue::SetFloatValue(uint16_t aUnitType, float aFloatValue)
329 : {
330 0 : return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;
331 : }
332 :
333 : void
334 0 : nsROCSSPrimitiveValue::SetFloatValue(uint16_t aType, float aVal,
335 : ErrorResult& aRv)
336 : {
337 0 : aRv = SetFloatValue(aType, aVal);
338 0 : }
339 :
340 : float
341 0 : nsROCSSPrimitiveValue::GetFloatValue(uint16_t aUnitType, ErrorResult& aRv)
342 : {
343 0 : switch(aUnitType) {
344 : case CSS_PX :
345 0 : if (mType == CSS_PX) {
346 0 : return nsPresContext::AppUnitsToFloatCSSPixels(mValue.mAppUnits);
347 : }
348 :
349 0 : break;
350 : case CSS_CM :
351 0 : if (mType == CSS_PX) {
352 0 : return mValue.mAppUnits * CM_PER_INCH_FLOAT /
353 0 : nsPresContext::AppUnitsPerCSSInch();
354 : }
355 :
356 0 : break;
357 : case CSS_MM :
358 0 : if (mType == CSS_PX) {
359 0 : return mValue.mAppUnits * MM_PER_INCH_FLOAT /
360 0 : nsPresContext::AppUnitsPerCSSInch();
361 : }
362 :
363 0 : break;
364 : case CSS_IN :
365 0 : if (mType == CSS_PX) {
366 0 : return mValue.mAppUnits / nsPresContext::AppUnitsPerCSSInch();
367 : }
368 :
369 0 : break;
370 : case CSS_PT :
371 0 : if (mType == CSS_PX) {
372 0 : return mValue.mAppUnits * POINTS_PER_INCH_FLOAT /
373 0 : nsPresContext::AppUnitsPerCSSInch();
374 : }
375 :
376 0 : break;
377 : case CSS_PC :
378 0 : if (mType == CSS_PX) {
379 0 : return mValue.mAppUnits * 6.0f /
380 0 : nsPresContext::AppUnitsPerCSSInch();
381 : }
382 :
383 0 : break;
384 : case CSS_PERCENTAGE :
385 0 : if (mType == CSS_PERCENTAGE) {
386 0 : return mValue.mFloat * 100;
387 : }
388 :
389 0 : break;
390 : case CSS_NUMBER :
391 0 : if (mType == CSS_NUMBER) {
392 0 : return mValue.mFloat;
393 : }
394 0 : if (mType == CSS_NUMBER_INT32) {
395 0 : return mValue.mInt32;
396 : }
397 0 : if (mType == CSS_NUMBER_UINT32) {
398 0 : return mValue.mUint32;
399 : }
400 :
401 0 : break;
402 : case CSS_UNKNOWN :
403 : case CSS_EMS :
404 : case CSS_EXS :
405 : case CSS_DEG :
406 : case CSS_RAD :
407 : case CSS_GRAD :
408 : case CSS_MS :
409 : case CSS_S :
410 : case CSS_HZ :
411 : case CSS_KHZ :
412 : case CSS_DIMENSION :
413 : case CSS_STRING :
414 : case CSS_URI :
415 : case CSS_IDENT :
416 : case CSS_ATTR :
417 : case CSS_COUNTER :
418 : case CSS_RECT :
419 : case CSS_RGBCOLOR :
420 0 : break;
421 : }
422 :
423 0 : aRv.Throw(NS_ERROR_DOM_INVALID_ACCESS_ERR);
424 0 : return 0;
425 : }
426 :
427 : NS_IMETHODIMP
428 0 : nsROCSSPrimitiveValue::GetFloatValue(uint16_t aType, float *aVal)
429 : {
430 0 : ErrorResult rv;
431 0 : *aVal = GetFloatValue(aType, rv);
432 0 : return rv.StealNSResult();
433 : }
434 :
435 :
436 : NS_IMETHODIMP
437 0 : nsROCSSPrimitiveValue::SetStringValue(uint16_t aStringType,
438 : const nsAString& aStringValue)
439 : {
440 0 : return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;
441 : }
442 :
443 : void
444 0 : nsROCSSPrimitiveValue::SetStringValue(uint16_t aType, const nsAString& aString,
445 : mozilla::ErrorResult& aRv)
446 : {
447 0 : aRv.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);
448 0 : }
449 :
450 :
451 : NS_IMETHODIMP
452 0 : nsROCSSPrimitiveValue::GetStringValue(nsAString& aReturn)
453 : {
454 0 : switch (mType) {
455 : case CSS_IDENT:
456 0 : CopyUTF8toUTF16(nsCSSKeywords::GetStringValue(mValue.mKeyword), aReturn);
457 0 : break;
458 : case CSS_STRING:
459 : case CSS_ATTR:
460 0 : aReturn.Assign(mValue.mString);
461 0 : break;
462 : case CSS_URI: {
463 0 : nsAutoCString spec;
464 0 : if (mValue.mURI) {
465 0 : nsresult rv = mValue.mURI->GetSpec(spec);
466 0 : NS_ENSURE_SUCCESS(rv, rv);
467 : }
468 0 : CopyUTF8toUTF16(spec, aReturn);
469 0 : break;
470 : }
471 : default:
472 0 : aReturn.Truncate();
473 0 : return NS_ERROR_DOM_INVALID_ACCESS_ERR;
474 : }
475 0 : return NS_OK;
476 : }
477 :
478 : void
479 0 : nsROCSSPrimitiveValue::GetStringValue(nsString& aString, ErrorResult& aRv)
480 : {
481 0 : aRv = GetStringValue(aString);
482 0 : }
483 :
484 :
485 : NS_IMETHODIMP
486 0 : nsROCSSPrimitiveValue::GetCounterValue(nsIDOMCounter** aReturn)
487 : {
488 0 : return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;
489 : }
490 :
491 : already_AddRefed<nsIDOMCounter>
492 0 : nsROCSSPrimitiveValue::GetCounterValue(ErrorResult& aRv)
493 : {
494 0 : aRv.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);
495 0 : return nullptr;
496 : }
497 :
498 : nsDOMCSSRect*
499 0 : nsROCSSPrimitiveValue::GetRectValue(ErrorResult& aRv)
500 : {
501 0 : if (mType != CSS_RECT) {
502 0 : aRv.Throw(NS_ERROR_DOM_INVALID_ACCESS_ERR);
503 0 : return nullptr;
504 : }
505 :
506 0 : NS_ASSERTION(mValue.mRect, "mValue.mRect should never be null");
507 0 : return mValue.mRect;
508 : }
509 :
510 : NS_IMETHODIMP
511 0 : nsROCSSPrimitiveValue::GetRectValue(nsIDOMRect** aRect)
512 : {
513 0 : ErrorResult error;
514 0 : NS_IF_ADDREF(*aRect = GetRectValue(error));
515 0 : return error.StealNSResult();
516 : }
517 :
518 : nsDOMCSSRGBColor*
519 0 : nsROCSSPrimitiveValue::GetRGBColorValue(ErrorResult& aRv)
520 : {
521 0 : if (mType != CSS_RGBCOLOR) {
522 0 : aRv.Throw(NS_ERROR_DOM_INVALID_ACCESS_ERR);
523 0 : return nullptr;
524 : }
525 :
526 0 : NS_ASSERTION(mValue.mColor, "mValue.mColor should never be null");
527 0 : return mValue.mColor;
528 : }
529 :
530 : void
531 3 : nsROCSSPrimitiveValue::SetNumber(float aValue)
532 : {
533 3 : Reset();
534 3 : mValue.mFloat = aValue;
535 3 : mType = CSS_NUMBER;
536 3 : }
537 :
538 : void
539 9 : nsROCSSPrimitiveValue::SetNumber(int32_t aValue)
540 : {
541 9 : Reset();
542 9 : mValue.mInt32 = aValue;
543 9 : mType = CSS_NUMBER_INT32;
544 9 : }
545 :
546 : void
547 0 : nsROCSSPrimitiveValue::SetNumber(uint32_t aValue)
548 : {
549 0 : Reset();
550 0 : mValue.mUint32 = aValue;
551 0 : mType = CSS_NUMBER_UINT32;
552 0 : }
553 :
554 : void
555 0 : nsROCSSPrimitiveValue::SetPercent(float aValue)
556 : {
557 0 : Reset();
558 0 : mValue.mFloat = aValue;
559 0 : mType = CSS_PERCENTAGE;
560 0 : }
561 :
562 : void
563 0 : nsROCSSPrimitiveValue::SetDegree(float aValue)
564 : {
565 0 : Reset();
566 0 : mValue.mFloat = aValue;
567 0 : mType = CSS_DEG;
568 0 : }
569 :
570 : void
571 0 : nsROCSSPrimitiveValue::SetGrad(float aValue)
572 : {
573 0 : Reset();
574 0 : mValue.mFloat = aValue;
575 0 : mType = CSS_GRAD;
576 0 : }
577 :
578 : void
579 0 : nsROCSSPrimitiveValue::SetRadian(float aValue)
580 : {
581 0 : Reset();
582 0 : mValue.mFloat = aValue;
583 0 : mType = CSS_RAD;
584 0 : }
585 :
586 : void
587 0 : nsROCSSPrimitiveValue::SetTurn(float aValue)
588 : {
589 0 : Reset();
590 0 : mValue.mFloat = aValue;
591 0 : mType = CSS_TURN;
592 0 : }
593 :
594 : void
595 0 : nsROCSSPrimitiveValue::SetAppUnits(nscoord aValue)
596 : {
597 0 : Reset();
598 0 : mValue.mAppUnits = aValue;
599 0 : mType = CSS_PX;
600 0 : }
601 :
602 : void
603 0 : nsROCSSPrimitiveValue::SetAppUnits(float aValue)
604 : {
605 0 : SetAppUnits(NSToCoordRound(aValue));
606 0 : }
607 :
608 : void
609 1 : nsROCSSPrimitiveValue::SetIdent(nsCSSKeyword aKeyword)
610 : {
611 1 : NS_PRECONDITION(aKeyword != eCSSKeyword_UNKNOWN &&
612 : 0 <= aKeyword && aKeyword < eCSSKeyword_COUNT,
613 : "bad keyword");
614 1 : Reset();
615 1 : mValue.mKeyword = aKeyword;
616 1 : mType = CSS_IDENT;
617 1 : }
618 :
619 : // FIXME: CSS_STRING should imply a string with "" and a need for escaping.
620 : void
621 0 : nsROCSSPrimitiveValue::SetString(const nsACString& aString, uint16_t aType)
622 : {
623 0 : Reset();
624 0 : mValue.mString = ToNewUnicode(aString);
625 0 : if (mValue.mString) {
626 0 : mType = aType;
627 : } else {
628 : // XXXcaa We should probably let the caller know we are out of memory
629 0 : mType = CSS_UNKNOWN;
630 : }
631 0 : }
632 :
633 : // FIXME: CSS_STRING should imply a string with "" and a need for escaping.
634 : void
635 0 : nsROCSSPrimitiveValue::SetString(const nsAString& aString, uint16_t aType)
636 : {
637 0 : Reset();
638 0 : mValue.mString = ToNewUnicode(aString);
639 0 : if (mValue.mString) {
640 0 : mType = aType;
641 : } else {
642 : // XXXcaa We should probably let the caller know we are out of memory
643 0 : mType = CSS_UNKNOWN;
644 : }
645 0 : }
646 :
647 : void
648 0 : nsROCSSPrimitiveValue::SetURI(nsIURI *aURI)
649 : {
650 0 : Reset();
651 0 : mValue.mURI = aURI;
652 0 : NS_IF_ADDREF(mValue.mURI);
653 0 : mType = CSS_URI;
654 0 : }
655 :
656 : void
657 3 : nsROCSSPrimitiveValue::SetColor(nsDOMCSSRGBColor* aColor)
658 : {
659 3 : NS_PRECONDITION(aColor, "Null RGBColor being set!");
660 3 : Reset();
661 3 : mValue.mColor = aColor;
662 3 : if (mValue.mColor) {
663 3 : NS_ADDREF(mValue.mColor);
664 3 : mType = CSS_RGBCOLOR;
665 : }
666 : else {
667 0 : mType = CSS_UNKNOWN;
668 : }
669 3 : }
670 :
671 : void
672 0 : nsROCSSPrimitiveValue::SetRect(nsDOMCSSRect* aRect)
673 : {
674 0 : NS_PRECONDITION(aRect, "Null rect being set!");
675 0 : Reset();
676 0 : mValue.mRect = aRect;
677 0 : if (mValue.mRect) {
678 0 : NS_ADDREF(mValue.mRect);
679 0 : mType = CSS_RECT;
680 : }
681 : else {
682 0 : mType = CSS_UNKNOWN;
683 : }
684 0 : }
685 :
686 : void
687 0 : nsROCSSPrimitiveValue::SetTime(float aValue)
688 : {
689 0 : Reset();
690 0 : mValue.mFloat = aValue;
691 0 : mType = CSS_S;
692 0 : }
693 :
694 : void
695 20 : nsROCSSPrimitiveValue::Reset()
696 : {
697 20 : switch (mType) {
698 : case CSS_IDENT:
699 1 : break;
700 : case CSS_STRING:
701 : case CSS_ATTR:
702 : case CSS_COUNTER: // FIXME: Counter should use an object
703 0 : NS_ASSERTION(mValue.mString, "Null string should never happen");
704 0 : free(mValue.mString);
705 0 : mValue.mString = nullptr;
706 0 : break;
707 : case CSS_URI:
708 0 : NS_IF_RELEASE(mValue.mURI);
709 0 : break;
710 : case CSS_RECT:
711 0 : NS_ASSERTION(mValue.mRect, "Null Rect should never happen");
712 0 : NS_RELEASE(mValue.mRect);
713 0 : break;
714 : case CSS_RGBCOLOR:
715 3 : NS_ASSERTION(mValue.mColor, "Null RGBColor should never happen");
716 3 : NS_RELEASE(mValue.mColor);
717 3 : break;
718 : }
719 :
720 20 : mType = CSS_UNKNOWN;
721 20 : }
|
