• Skip to content
  • Skip to link menu
  • KDE API Reference
  • kdelibs-4.14.38 API Reference
  • KDE Home
  • Contact Us
 

KHTML

  • khtml
  • dom
css_value.cpp
Go to the documentation of this file.
1/*
2 * This file is part of the DOM implementation for KDE.
3 *
4 * Copyright 1999 Lars Knoll (knoll@kde.org)
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Library General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Library General Public License for more details.
15 *
16 * You should have received a copy of the GNU Library General Public License
17 * along with this library; see the file COPYING.LIB. If not, write to
18 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19 * Boston, MA 02110-1301, USA.
20 *
21 */
22
23#include "dom/css_rule.h"
24#include "dom/dom_exception.h"
25
26#include "css/css_renderstyledeclarationimpl.h"
27#include "css/css_valueimpl.h"
28
29namespace DOM {
30
31CSSStyleDeclaration::CSSStyleDeclaration()
32{
33 impl = 0;
34}
35
36CSSStyleDeclaration::CSSStyleDeclaration(const CSSStyleDeclaration &other)
37{
38 impl = other.impl;
39 if(impl) impl->ref();
40}
41
42CSSStyleDeclaration::CSSStyleDeclaration(CSSStyleDeclarationImpl *i)
43{
44 impl = i;
45 if(impl) impl->ref();
46}
47
48CSSStyleDeclaration &CSSStyleDeclaration::operator = (const CSSStyleDeclaration &other)
49{
50 if ( impl != other.impl ) {
51 if(impl) impl->deref();
52 impl = other.impl;
53 if(impl) impl->ref();
54 }
55 return *this;
56}
57
58CSSStyleDeclaration::~CSSStyleDeclaration()
59{
60 if(impl) impl->deref();
61}
62
63DOMString CSSStyleDeclaration::cssText() const
64{
65 if(!impl) return DOMString();
66 return static_cast<CSSStyleDeclarationImpl *>(impl)->cssText();
67}
68
69void CSSStyleDeclaration::setCssText( const DOMString &value )
70{
71 if(!impl) return;
72 impl->setCssText(value);
73}
74
75DOMString CSSStyleDeclaration::getPropertyValue( const DOMString &propertyName ) const
76{
77 if(!impl) return DOMString();
78 return static_cast<CSSStyleDeclarationImpl *>(impl)->getPropertyValue(propertyName);
79}
80
81CSSValue CSSStyleDeclaration::getPropertyCSSValue( const DOMString &propertyName ) const
82{
83 if(!impl) return 0;
84 return static_cast<CSSStyleDeclarationImpl *>(impl)->getPropertyCSSValue(propertyName);
85}
86
87DOMString CSSStyleDeclaration::removeProperty( const DOMString &propertyName )
88{
89 if(!impl) return DOMString();
90 return static_cast<CSSStyleDeclarationImpl *>(impl)->removeProperty(propertyName);
91}
92
93DOMString CSSStyleDeclaration::getPropertyPriority( const DOMString &propertyName ) const
94{
95 if(!impl) return DOMString();
96 return impl->getPropertyPriority(propertyName);
97}
98
99void CSSStyleDeclaration::setProperty( const DOMString &propName, const DOMString &value, const DOMString &priority )
100{
101 if(!impl) return;
102 if (value.isEmpty()) {
103 static_cast<CSSStyleDeclarationImpl *>(impl)->removeProperty(propName);
104 return;
105 }
106 static_cast<CSSStyleDeclarationImpl *>(impl)->setProperty( propName, value, priority );
107}
108
109unsigned long CSSStyleDeclaration::length() const
110{
111 if(!impl) return 0;
112 return static_cast<CSSStyleDeclarationImpl *>(impl)->length();
113}
114
115DOMString CSSStyleDeclaration::item( unsigned long index )
116{
117 return const_cast<const CSSStyleDeclaration*>( this )->item( index );
118}
119
120DOMString CSSStyleDeclaration::item( unsigned long index ) const
121{
122 if(!impl) return DOMString();
123 return static_cast<CSSStyleDeclarationImpl *>(impl)->item( index );
124}
125CSSRule CSSStyleDeclaration::parentRule() const
126{
127 if(!impl) return 0;
128 return static_cast<CSSStyleDeclarationImpl *>(impl)->parentRule();
129}
130
131CSSStyleDeclarationImpl *CSSStyleDeclaration::handle() const
132{
133 return impl;
134}
135
136bool CSSStyleDeclaration::isNull() const
137{
138 return (impl == 0);
139}
140
141// ----------------------------------------------------------
142
143CSSValue::CSSValue()
144{
145 impl = 0;
146}
147
148CSSValue::CSSValue(const CSSValue &other)
149{
150 impl = other.impl;
151 if(impl) impl->ref();
152}
153
154CSSValue::CSSValue(CSSValueImpl *i)
155{
156 impl = i;
157 if(impl) impl->ref();
158}
159
160CSSValue &CSSValue::operator = (const CSSValue &other)
161{
162 if ( impl != other.impl ) {
163 if(impl) impl->deref();
164 impl = other.impl;
165 if(impl) impl->ref();
166 }
167 return *this;
168}
169
170CSSValue::~CSSValue()
171{
172 if(impl) impl->deref();
173}
174
175DOMString CSSValue::cssText() const
176{
177 if(!impl) return DOMString();
178 return ((CSSValueImpl *)impl)->cssText();
179}
180
181void CSSValue::setCssText(const DOMString &value)
182{
183 if(!impl) return;
184 ((CSSValueImpl *)impl)->setCssText(value);
185}
186
187unsigned short CSSValue::cssValueType() const
188{
189 if(!impl) return 0;
190 return ((CSSValueImpl *)impl)->cssValueType();
191}
192
193bool CSSValue::isCSSValueList() const
194{
195 if(!impl) return false;
196 return ((CSSValueImpl *)impl)->isValueList();
197}
198
199bool CSSValue::isCSSPrimitiveValue() const
200{
201 if(!impl) return false;
202 return ((CSSValueImpl *)impl)->isPrimitiveValue();
203}
204
205CSSValueImpl *CSSValue::handle() const
206{
207 return impl;
208}
209
210bool CSSValue::isNull() const
211{
212 return (impl == 0);
213}
214
215// ----------------------------------------------------------
216
217CSSValueList::CSSValueList() : CSSValue()
218{
219}
220
221CSSValueList::CSSValueList(const CSSValueList &other) : CSSValue(other)
222{
223}
224
225CSSValueList::CSSValueList(const CSSValue &other)
226{
227 impl = 0;
228 operator=(other);
229}
230
231CSSValueList::CSSValueList(CSSValueListImpl *impl) : CSSValue(impl)
232{
233}
234
235CSSValueList &CSSValueList::operator = (const CSSValueList &other)
236{
237 if ( impl != other.impl ) {
238 if (impl) impl->deref();
239 impl = other.handle();
240 if (impl) impl->ref();
241 }
242 return *this;
243}
244
245CSSValueList &CSSValueList::operator = (const CSSValue &other)
246{
247 CSSValueImpl *ohandle = other.handle() ;
248 if ( impl != ohandle ) {
249 if (impl) impl->deref();
250 if (!other.isNull() && !other.isCSSValueList()) {
251 impl = 0;
252 } else {
253 impl = ohandle;
254 if (impl) impl->ref();
255 }
256 }
257 return *this;
258}
259
260CSSValueList::~CSSValueList()
261{
262}
263
264unsigned long CSSValueList::length() const
265{
266 if(!impl) return 0;
267 return ((CSSValueListImpl *)impl)->length();
268}
269
270CSSValue CSSValueList::item( unsigned long index )
271{
272 if(!impl) return 0;
273 return ((CSSValueListImpl *)impl)->item( index );
274}
275
276// ----------------------------------------------------------
277
278CSSPrimitiveValue::CSSPrimitiveValue() : CSSValue()
279{
280}
281
282CSSPrimitiveValue::CSSPrimitiveValue(const CSSPrimitiveValue &other) : CSSValue(other)
283{
284}
285
286CSSPrimitiveValue::CSSPrimitiveValue(const CSSValue &other) : CSSValue(other)
287{
288 impl = 0;
289 operator=(other);
290}
291
292CSSPrimitiveValue::CSSPrimitiveValue(CSSPrimitiveValueImpl *impl) : CSSValue(impl)
293{
294}
295
296CSSPrimitiveValue &CSSPrimitiveValue::operator = (const CSSPrimitiveValue &other)
297{
298 if ( impl != other.impl ) {
299 if (impl) impl->deref();
300 impl = other.handle();
301 if (impl) impl->ref();
302 }
303 return *this;
304}
305
306CSSPrimitiveValue &CSSPrimitiveValue::operator = (const CSSValue &other)
307{
308 CSSValueImpl *ohandle = other.handle();
309 if ( impl != ohandle ) {
310 if (impl) impl->deref();
311 if (!other.isNull() && !other.isCSSPrimitiveValue()) {
312 impl = 0;
313 } else {
314 impl = ohandle;
315 if (impl) impl->ref();
316 }
317 }
318 return *this;
319}
320
321CSSPrimitiveValue::~CSSPrimitiveValue()
322{
323}
324
325unsigned short CSSPrimitiveValue::primitiveType() const
326{
327 if(!impl) return 0;
328 return ((CSSPrimitiveValueImpl *)impl)->primitiveType();
329}
330
331void CSSPrimitiveValue::setFloatValue( unsigned short unitType, float floatValue )
332{
333 if(!impl) return;
334 int exceptioncode = 0;
335 ((CSSPrimitiveValueImpl *)impl)->setFloatValue( unitType, floatValue, exceptioncode );
336 if ( exceptioncode >= CSSException::_EXCEPTION_OFFSET )
337 throw CSSException( exceptioncode - CSSException::_EXCEPTION_OFFSET );
338 if ( exceptioncode )
339 throw DOMException( exceptioncode );
340}
341
342float CSSPrimitiveValue::getFloatValue( unsigned short unitType ) const
343{
344 if(!impl) return 0;
345 // ### add unit conversion
346 if(primitiveType() != unitType)
347 throw CSSException(CSSException::SYNTAX_ERR);
348 return ((CSSPrimitiveValueImpl *)impl)->floatValue( unitType );
349}
350
351void CSSPrimitiveValue::setStringValue( unsigned short stringType, const DOMString &stringValue )
352{
353 int exceptioncode = 0;
354 if(impl)
355 ((CSSPrimitiveValueImpl *)impl)->setStringValue( stringType, stringValue, exceptioncode );
356 if ( exceptioncode >= CSSException::_EXCEPTION_OFFSET )
357 throw CSSException( exceptioncode - CSSException::_EXCEPTION_OFFSET );
358 if ( exceptioncode )
359 throw DOMException( exceptioncode );
360
361}
362
363DOMString CSSPrimitiveValue::getStringValue( ) const
364{
365 if(!impl) return DOMString();
366 return ((CSSPrimitiveValueImpl *)impl)->getStringValue( );
367}
368
369Counter CSSPrimitiveValue::getCounterValue( ) const
370{
371 if(!impl) return Counter();
372 return ((CSSPrimitiveValueImpl *)impl)->getCounterValue( );
373}
374
375Rect CSSPrimitiveValue::getRectValue( ) const
376{
377 if(!impl) return Rect();
378 return ((CSSPrimitiveValueImpl *)impl)->getRectValue( );
379}
380
381RGBColor CSSPrimitiveValue::getRGBColorValue( ) const
382{
383 // ###
384 return RGBColor();
385 //if(!impl) return RGBColor();
386 //return ((CSSPrimitiveValueImpl *)impl)->getRGBColorValue( );
387}
388
389// -------------------------------------------------------------------
390
391Counter::Counter()
392{
393}
394
395Counter::Counter(const Counter &/*other*/)
396{
397 impl = 0;
398}
399
400Counter &Counter::operator = (const Counter &other)
401{
402 if ( impl != other.impl ) {
403 if (impl) impl->deref();
404 impl = other.impl;
405 if (impl) impl->ref();
406 }
407 return *this;
408}
409
410Counter::Counter(CounterImpl *i)
411{
412 impl = i;
413 if (impl) impl->ref();
414}
415
416Counter::~Counter()
417{
418 if (impl) impl->deref();
419}
420
421DOMString Counter::identifier() const
422{
423 if (!impl) return DOMString();
424 return impl->identifier();
425}
426
427DOMString Counter::listStyle() const
428{
429 if (!impl) return DOMString();
430 return khtml::stringForListStyleType((khtml::EListStyleType)impl->listStyle());
431}
432
433DOMString Counter::separator() const
434{
435 if (!impl) return DOMString();
436 return impl->separator();
437}
438
439CounterImpl *Counter::handle() const
440{
441 return impl;
442}
443
444bool Counter::isNull() const
445{
446 return (impl == 0);
447}
448
449// --------------------------------------------------------------------
450
451RGBColor::RGBColor()
452{
453}
454
455RGBColor::RGBColor(const RGBColor &other)
456{
457 m_color = other.m_color;
458}
459
460RGBColor::RGBColor(QRgb color)
461{
462 m_color = color;
463}
464
465RGBColor &RGBColor::operator = (const RGBColor &other)
466{
467 m_color = other.m_color;
468 return *this;
469}
470
471RGBColor::~RGBColor()
472{
473}
474
475CSSPrimitiveValue RGBColor::red() const
476{
477 return new CSSPrimitiveValueImpl(float(qAlpha(m_color) ? qRed(m_color) : 0), CSSPrimitiveValue::CSS_DIMENSION);
478}
479
480CSSPrimitiveValue RGBColor::green() const
481{
482 return new CSSPrimitiveValueImpl(float(qAlpha(m_color) ? qGreen(m_color) : 0), CSSPrimitiveValue::CSS_DIMENSION);
483}
484
485CSSPrimitiveValue RGBColor::blue() const
486{
487 return new CSSPrimitiveValueImpl(float(qAlpha(m_color) ? qBlue(m_color) : 0), CSSPrimitiveValue::CSS_DIMENSION);
488}
489
490
491// ---------------------------------------------------------------------
492
493Rect::Rect()
494{
495 impl = 0;
496}
497
498Rect::Rect(const Rect &other)
499{
500 impl = other.impl;
501 if (impl) impl->ref();
502}
503
504Rect::Rect(RectImpl *i)
505{
506 impl = i;
507 if (impl) impl->ref();
508}
509
510Rect &Rect::operator = (const Rect &other)
511{
512 if ( impl != other.impl ) {
513 if (impl) impl->deref();
514 impl = other.impl;
515 if (impl) impl->ref();
516 }
517 return *this;
518}
519
520Rect::~Rect()
521{
522 if (impl) impl->deref();
523}
524
525CSSPrimitiveValue Rect::top() const
526{
527 if (!impl) return 0;
528 return impl->top();
529}
530
531CSSPrimitiveValue Rect::right() const
532{
533 if (!impl) return 0;
534 return impl->right();
535}
536
537CSSPrimitiveValue Rect::bottom() const
538{
539 if (!impl) return 0;
540 return impl->bottom();
541}
542
543CSSPrimitiveValue Rect::left() const
544{
545 if (!impl) return 0;
546 return impl->left();
547}
548
549RectImpl *Rect::handle() const
550{
551 return impl;
552}
553
554bool Rect::isNull() const
555{
556 return (impl == 0);
557}
558
559} // namespace
560
561
DOM::CSSException
This exception is raised when a specific CSS operation is impossible to perform.
Definition: css_stylesheet.h:175
DOM::CSSException::_EXCEPTION_OFFSET
@ _EXCEPTION_OFFSET
Definition: css_stylesheet.h:194
DOM::CSSException::SYNTAX_ERR
@ SYNTAX_ERR
Definition: css_stylesheet.h:192
DOM::CSSPrimitiveValue
The CSSPrimitiveValue interface represents a single CSS value .
Definition: css_value.h:373
DOM::CSSPrimitiveValue::getRectValue
Rect getRectValue() const
This method is used to get the Rect value.
Definition: css_value.cpp:375
DOM::CSSPrimitiveValue::CSS_DIMENSION
@ CSS_DIMENSION
Definition: css_value.h:410
DOM::CSSPrimitiveValue::primitiveType
unsigned short primitiveType() const
The type of the value as defined by the constants specified above.
Definition: css_value.cpp:325
DOM::CSSPrimitiveValue::getCounterValue
Counter getCounterValue() const
This method is used to get the Counter value.
Definition: css_value.cpp:369
DOM::CSSPrimitiveValue::getRGBColorValue
RGBColor getRGBColorValue() const
This method is used to get the RGB color.
Definition: css_value.cpp:381
DOM::CSSPrimitiveValue::~CSSPrimitiveValue
~CSSPrimitiveValue()
Definition: css_value.cpp:321
DOM::CSSPrimitiveValue::setFloatValue
void setFloatValue(unsigned short unitType, float floatValue)
A method to set the float value with a specified unit.
Definition: css_value.cpp:331
DOM::CSSPrimitiveValue::getStringValue
DOM::DOMString getStringValue() const
This method is used to get the string value in a specified unit.
Definition: css_value.cpp:363
DOM::CSSPrimitiveValue::operator=
CSSPrimitiveValue & operator=(const CSSPrimitiveValue &other)
Definition: css_value.cpp:296
DOM::CSSPrimitiveValue::getFloatValue
float getFloatValue(unsigned short unitType) const
This method is used to get a float value in a specified unit.
Definition: css_value.cpp:342
DOM::CSSPrimitiveValue::CSSPrimitiveValue
CSSPrimitiveValue()
Definition: css_value.cpp:278
DOM::CSSPrimitiveValue::setStringValue
void setStringValue(unsigned short stringType, const DOM::DOMString &stringValue)
A method to set the string value with a specified unit.
Definition: css_value.cpp:351
DOM::CSSRule
The CSSRule interface is the abstract base interface for any type of CSS statement .
Definition: css_rule.h:53
DOM::CSSStyleDeclaration
The CSSStyleDeclaration interface represents a single CSS declaration block .
Definition: css_value.h:61
DOM::CSSStyleDeclaration::handle
CSSStyleDeclarationImpl * handle() const
Definition: css_value.cpp:131
DOM::CSSStyleDeclaration::CSSStyleDeclaration
CSSStyleDeclaration()
Definition: css_value.cpp:31
DOM::CSSStyleDeclaration::parentRule
CSSRule parentRule() const
The CSS rule that contains this declaration block.
Definition: css_value.cpp:125
DOM::CSSStyleDeclaration::item
DOM::DOMString item(unsigned long index) const
Used to retrieve the properties that have been explicitly set in this declaration block.
Definition: css_value.cpp:120
DOM::CSSStyleDeclaration::getPropertyPriority
DOM::DOMString getPropertyPriority(const DOM::DOMString &propertyName) const
Used to retrieve the priority of a CSS property (e.g.
Definition: css_value.cpp:93
DOM::CSSStyleDeclaration::operator=
CSSStyleDeclaration & operator=(const CSSStyleDeclaration &other)
Definition: css_value.cpp:48
DOM::CSSStyleDeclaration::getPropertyCSSValue
CSSValue getPropertyCSSValue(const DOM::DOMString &propertyName) const
Used to retrieve the object representation of the value of a CSS property if it has been explicitly s...
Definition: css_value.cpp:81
DOM::CSSStyleDeclaration::impl
CSSStyleDeclarationImpl * impl
Definition: css_value.h:229
DOM::CSSStyleDeclaration::~CSSStyleDeclaration
~CSSStyleDeclaration()
Definition: css_value.cpp:58
DOM::CSSStyleDeclaration::isNull
bool isNull() const
Definition: css_value.cpp:136
DOM::CSSStyleDeclaration::getPropertyValue
DOM::DOMString getPropertyValue(const DOM::DOMString &propertyName) const
Used to retrieve the value of a CSS property if it has been explicitly set within this declaration bl...
Definition: css_value.cpp:75
DOM::CSSStyleDeclaration::setCssText
void setCssText(const DOM::DOMString &)
see cssText
Definition: css_value.cpp:69
DOM::CSSStyleDeclaration::length
unsigned long length() const
The number of properties that have been explicitly set in this declaration block.
Definition: css_value.cpp:109
DOM::CSSStyleDeclaration::cssText
DOM::DOMString cssText() const
The parsable textual representation of the declaration block (including the surrounding curly braces)...
Definition: css_value.cpp:63
DOM::CSSStyleDeclaration::removeProperty
DOM::DOMString removeProperty(const DOM::DOMString &propertyName)
Used to remove a CSS property if it has been explicitly set within this declaration block.
Definition: css_value.cpp:87
DOM::CSSStyleDeclaration::setProperty
void setProperty(const DOM::DOMString &propertyName, const DOM::DOMString &value, const DOM::DOMString &priority)
Used to set a property value and priority within this declaration block.
Definition: css_value.cpp:99
DOM::CSSValueList
The CSSValueList interface provides the absraction of an ordered collection of CSS values.
Definition: css_value.h:316
DOM::CSSValueList::operator=
CSSValueList & operator=(const CSSValueList &other)
Definition: css_value.cpp:235
DOM::CSSValueList::CSSValueList
CSSValueList()
Definition: css_value.cpp:217
DOM::CSSValueList::item
CSSValue item(unsigned long index)
Used to retrieve a CSS rule by ordinal index.
Definition: css_value.cpp:270
DOM::CSSValueList::length
unsigned long length() const
The number of CSSValue s in the list.
Definition: css_value.cpp:264
DOM::CSSValueList::~CSSValueList
~CSSValueList()
Definition: css_value.cpp:260
DOM::CSSValue
The CSSValue interface represents a simple or a complexe value.
Definition: css_value.h:241
DOM::CSSValue::operator=
CSSValue & operator=(const CSSValue &other)
Definition: css_value.cpp:160
DOM::CSSValue::impl
CSSValueImpl * impl
Definition: css_value.h:303
DOM::CSSValue::isCSSValueList
bool isCSSValueList() const
Definition: css_value.cpp:193
DOM::CSSValue::~CSSValue
~CSSValue()
Definition: css_value.cpp:170
DOM::CSSValue::cssText
DOM::DOMString cssText() const
A string representation of the current value.
Definition: css_value.cpp:175
DOM::CSSValue::setCssText
void setCssText(const DOM::DOMString &)
see cssText
Definition: css_value.cpp:181
DOM::CSSValue::CSSValue
CSSValue()
Definition: css_value.cpp:143
DOM::CSSValue::handle
CSSValueImpl * handle() const
Definition: css_value.cpp:205
DOM::CSSValue::isCSSPrimitiveValue
bool isCSSPrimitiveValue() const
Definition: css_value.cpp:199
DOM::CSSValue::isNull
bool isNull() const
Definition: css_value.cpp:210
DOM::CSSValue::cssValueType
unsigned short cssValueType() const
A code defining the type of the value as defined above.
Definition: css_value.cpp:187
DOM::Counter
The Counter interface is used to represent any counter or counters function value.
Definition: css_value.h:698
DOM::Counter::operator=
Counter & operator=(const Counter &other)
Definition: css_value.cpp:400
DOM::Counter::~Counter
~Counter()
Definition: css_value.cpp:416
DOM::Counter::identifier
DOM::DOMString identifier() const
This attribute is used for the identifier of the counter.
Definition: css_value.cpp:421
DOM::Counter::isNull
bool isNull() const
Definition: css_value.cpp:444
DOM::Counter::Counter
Counter()
Definition: css_value.cpp:391
DOM::Counter::handle
CounterImpl * handle() const
Definition: css_value.cpp:439
DOM::Counter::impl
CounterImpl * impl
Definition: css_value.h:735
DOM::Counter::listStyle
DOM::DOMString listStyle() const
This attribute is used for the style of the list.
Definition: css_value.cpp:427
DOM::Counter::separator
DOM::DOMString separator() const
This attribute is used for the separator of nested counters.
Definition: css_value.cpp:433
DOM::DOMException
DOM operations only raise exceptions in "exceptional" circumstances, i.e., when an operation is impos...
Definition: dom_exception.h:59
DOM::DOMString
This class implements the basic string we use in the DOM.
Definition: dom_string.h:44
DOM::DOMString::isEmpty
bool isEmpty() const
Definition: dom_string.cpp:368
DOM::RGBColor
The RGBColor interface is used to represent any RGB color value.
Definition: css_value.h:590
DOM::RGBColor::color
QRgb color() const
Definition: css_value.h:625
DOM::RGBColor::~RGBColor
~RGBColor()
Definition: css_value.cpp:471
DOM::RGBColor::blue
CSSPrimitiveValue blue() const
This attribute is used for the blue value of the RGB color.
Definition: css_value.cpp:485
DOM::RGBColor::operator=
RGBColor & operator=(const RGBColor &other)
Definition: css_value.cpp:465
DOM::RGBColor::red
CSSPrimitiveValue red() const
This attribute is used for the red value of the RGB color.
Definition: css_value.cpp:475
DOM::RGBColor::green
CSSPrimitiveValue green() const
This attribute is used for the green value of the RGB color.
Definition: css_value.cpp:480
DOM::RGBColor::RGBColor
RGBColor()
Definition: css_value.cpp:451
DOM::RGBColor::m_color
QRgb m_color
Definition: css_value.h:627
DOM::Rect
The Rect interface is used to represent any rect value.
Definition: css_value.h:641
DOM::Rect::Rect
Rect()
Definition: css_value.cpp:493
DOM::Rect::bottom
CSSPrimitiveValue bottom() const
This attribute is used for the bottom of the rect.
Definition: css_value.cpp:537
DOM::Rect::operator=
Rect & operator=(const Rect &other)
Definition: css_value.cpp:510
DOM::Rect::isNull
bool isNull() const
Definition: css_value.cpp:554
DOM::Rect::~Rect
~Rect()
Definition: css_value.cpp:520
DOM::Rect::handle
RectImpl * handle() const
Definition: css_value.cpp:549
DOM::Rect::impl
RectImpl * impl
Definition: css_value.h:683
DOM::Rect::left
CSSPrimitiveValue left() const
This attribute is used for the left of the rect.
Definition: css_value.cpp:543
DOM::Rect::right
CSSPrimitiveValue right() const
This attribute is used for the right of the rect.
Definition: css_value.cpp:531
DOM::Rect::top
CSSPrimitiveValue top() const
This attribute is used for the top of the rect.
Definition: css_value.cpp:525
css_rule.h
dom_exception.h
DOM
This library provides a full-featured HTML parser and widget.
Definition: design.h:55
This file is part of the KDE documentation.
Documentation copyright © 1996-2023 The KDE developers.
Generated on Mon Feb 20 2023 00:00:00 by doxygen 1.9.6 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

KHTML

Skip menu "KHTML"
  • Main Page
  • Namespace List
  • Namespace Members
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • File Members
  • Related Pages

kdelibs-4.14.38 API Reference

Skip menu "kdelibs-4.14.38 API Reference"
  • DNSSD
  • Interfaces
  •   KHexEdit
  •   KMediaPlayer
  •   KSpeech
  •   KTextEditor
  • kconf_update
  • KDE3Support
  •   KUnitTest
  • KDECore
  • KDED
  • KDEsu
  • KDEUI
  • KDEWebKit
  • KDocTools
  • KFile
  • KHTML
  • KImgIO
  • KInit
  • kio
  • KIOSlave
  • KJS
  •   KJS-API
  •   WTF
  • kjsembed
  • KNewStuff
  • KParts
  • KPty
  • Kross
  • KUnitConversion
  • KUtils
  • Nepomuk
  • Plasma
  • Solid
  • Sonnet
  • ThreadWeaver
Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal