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

KHTML

  • khtml
  • dom
css_rule.cpp
Go to the documentation of this file.
1
23#include "css/css_ruleimpl.h"
24
25using namespace DOM;
26
27CSSRule::CSSRule()
28{
29 impl = 0;
30}
31
32CSSRule::CSSRule(const CSSRule &other)
33{
34 impl = other.impl;
35 if(impl) impl->ref();
36}
37
38CSSRule::CSSRule(CSSRuleImpl *i)
39{
40 impl = i;
41 if(impl) impl->ref();
42}
43
44CSSRule &CSSRule::operator = (const CSSRule &other)
45{
46 if ( impl != other.impl ) {
47 if(impl) impl->deref();
48 impl = other.impl;
49 if(impl) impl->ref();
50 }
51 return *this;
52}
53
54CSSRule::~CSSRule()
55{
56 if(impl) impl->deref();
57}
58
59unsigned short CSSRule::type() const
60{
61 if(!impl) return 0;
62 return ((CSSRuleImpl *)impl)->type();
63}
64
65DOMString CSSRule::cssText() const
66{
67 if(!impl) return DOMString();
68 return impl->cssText();
69}
70
71void CSSRule::setCssText( const DOMString &value )
72{
73 if(!impl) return;
74 impl->setCssText(value);
75}
76
77CSSStyleSheet CSSRule::parentStyleSheet() const
78{
79 if(!impl) return CSSStyleSheet();
80 return ((CSSRuleImpl *)impl)->parentStyleSheet();
81}
82
83CSSRule CSSRule::parentRule() const
84{
85 if(!impl) return 0;
86 return ((CSSRuleImpl *)impl)->parentRule();
87}
88
89CSSRuleImpl *CSSRule::handle() const
90{
91 return impl;
92}
93
94bool CSSRule::isNull() const
95{
96 return (impl == 0);
97}
98
99void CSSRule::assignOther( const CSSRule &other, RuleType thisType )
100{
101 if (other.type() != thisType ) {
102 if ( impl ) impl->deref();
103 impl = 0;
104 } else
105 CSSRule::operator = ( other );
106}
107
108// ----------------------------------------------------------
109
110
111CSSCharsetRule::CSSCharsetRule()
112 : CSSRule()
113{
114}
115
116CSSCharsetRule::CSSCharsetRule(const CSSCharsetRule &other) : CSSRule(other)
117{
118}
119
120CSSCharsetRule::CSSCharsetRule(const CSSRule &other)
121{
122 impl = 0;
123 operator=(other);
124}
125
126CSSCharsetRule::CSSCharsetRule(CSSCharsetRuleImpl *impl) : CSSRule(impl)
127{
128}
129
130CSSCharsetRule &CSSCharsetRule::operator = (const CSSCharsetRule &other)
131{
132 CSSRule::operator = (other);
133 return *this;
134}
135
136CSSCharsetRule &CSSCharsetRule::operator = (const CSSRule &other)
137{
138 assignOther( other, CSSRule::CHARSET_RULE);
139 return *this;
140}
141
142CSSCharsetRule::~CSSCharsetRule()
143{
144}
145
146DOMString CSSCharsetRule::encoding() const
147{
148 if(!impl) return DOMString();
149 return ((CSSCharsetRuleImpl*)impl)->encoding();
150}
151
152void CSSCharsetRule::setEncoding( const DOMString &value )
153{
154 ((CSSCharsetRuleImpl*)impl)->setEncoding(value);
155}
156
157
158// ----------------------------------------------------------
159
160
161CSSFontFaceRule::CSSFontFaceRule() : CSSRule()
162{
163}
164
165CSSFontFaceRule::CSSFontFaceRule(const CSSFontFaceRule &other) : CSSRule(other)
166{
167}
168
169CSSFontFaceRule::CSSFontFaceRule(const CSSRule &other)
170{
171 impl = 0;
172 operator=(other);
173}
174
175CSSFontFaceRule::CSSFontFaceRule(CSSFontFaceRuleImpl *impl) : CSSRule(impl)
176{
177}
178
179CSSFontFaceRule &CSSFontFaceRule::operator = (const CSSFontFaceRule &other)
180{
181 CSSRule::operator = (other);
182 return *this;
183}
184
185CSSFontFaceRule &CSSFontFaceRule::operator = (const CSSRule &other)
186{
187 assignOther( other, CSSRule::FONT_FACE_RULE );
188 return *this;
189}
190
191CSSFontFaceRule::~CSSFontFaceRule()
192{
193}
194
195CSSStyleDeclaration CSSFontFaceRule::style() const
196{
197 if(!impl) return CSSStyleDeclaration();
198 return ((CSSFontFaceRuleImpl *)impl)->style();
199}
200
201
202// ----------------------------------------------------------
203
204
205CSSImportRule::CSSImportRule() : CSSRule()
206{
207}
208
209CSSImportRule::CSSImportRule(const CSSImportRule &other) : CSSRule(other)
210{
211}
212
213CSSImportRule::CSSImportRule(const CSSRule &other)
214{
215 impl = 0;
216 operator=(other);
217}
218
219CSSImportRule::CSSImportRule(CSSImportRuleImpl *impl) : CSSRule(impl)
220{
221}
222
223CSSImportRule &CSSImportRule::operator = (const CSSImportRule &other)
224{
225 CSSRule::operator = (other);
226 return *this;
227}
228
229CSSImportRule &CSSImportRule::operator = (const CSSRule &other)
230{
231 assignOther( other, CSSRule::IMPORT_RULE );
232 return *this;
233}
234
235CSSImportRule::~CSSImportRule()
236{
237}
238
239DOMString CSSImportRule::href() const
240{
241 if(!impl) return DOMString();
242 return ((CSSImportRuleImpl *)impl)->href();
243}
244
245MediaList CSSImportRule::media() const
246{
247 if(!impl) return MediaList();
248 return ((CSSImportRuleImpl *)impl)->media();
249}
250
251CSSStyleSheet CSSImportRule::styleSheet() const
252{
253 if(!impl) return CSSStyleSheet();
254 return ((CSSImportRuleImpl *)impl)->styleSheet();
255}
256
257
258// ----------------------------------------------------------
259
260
261CSSMediaRule::CSSMediaRule() : CSSRule()
262{
263}
264
265CSSMediaRule::CSSMediaRule(const CSSMediaRule &other) : CSSRule(other)
266{
267}
268
269CSSMediaRule::CSSMediaRule(const CSSRule &other)
270{
271 impl = 0;
272 operator=(other);
273}
274
275CSSMediaRule::CSSMediaRule(CSSMediaRuleImpl *impl) : CSSRule(impl)
276{
277}
278
279CSSMediaRule &CSSMediaRule::operator = (const CSSMediaRule &other)
280{
281 CSSRule::operator = (other);
282 return *this;
283}
284
285CSSMediaRule &CSSMediaRule::operator = (const CSSRule &other)
286{
287 assignOther( other, CSSRule::MEDIA_RULE );
288 return *this;
289}
290
291CSSMediaRule::~CSSMediaRule()
292{
293}
294
295MediaList CSSMediaRule::media() const
296{
297 if(!impl) return MediaList();
298 return ((CSSMediaRuleImpl *)impl)->media();
299}
300
301CSSRuleList CSSMediaRule::cssRules() const
302{
303 if(!impl) return CSSRuleList();
304 return ((CSSMediaRuleImpl *)impl)->cssRules();
305}
306
307unsigned long CSSMediaRule::insertRule( const DOMString &rule, unsigned long index )
308{
309 if(!impl) return 0;
310 return ((CSSMediaRuleImpl *)impl)->insertRule( rule, index );
311}
312
313void CSSMediaRule::deleteRule( unsigned long index )
314{
315 if(impl)
316 ((CSSMediaRuleImpl *)impl)->deleteRule( index );
317}
318
319
320// ----------------------------------------------------------
321
322
323CSSPageRule::CSSPageRule() : CSSRule()
324{
325}
326
327CSSPageRule::CSSPageRule(const CSSPageRule &other) : CSSRule(other)
328{
329}
330
331CSSPageRule::CSSPageRule(const CSSRule &other)
332{
333 impl = 0;
334 operator=(other);
335}
336
337CSSPageRule::CSSPageRule(CSSPageRuleImpl *impl) : CSSRule(impl)
338{
339}
340
341CSSPageRule &CSSPageRule::operator = (const CSSPageRule &other)
342{
343 CSSRule::operator = (other);
344 return *this;
345}
346
347CSSPageRule &CSSPageRule::operator = (const CSSRule &other)
348{
349 assignOther( other, CSSRule::PAGE_RULE );
350 return *this;
351}
352
353CSSPageRule::~CSSPageRule()
354{
355}
356
357DOMString CSSPageRule::selectorText() const
358{
359 if(!impl) return DOMString();
360 return ((CSSPageRuleImpl*)impl)->selectorText();
361}
362
363void CSSPageRule::setSelectorText( const DOMString &value )
364{
365 ((CSSPageRuleImpl*)impl)->setSelectorText(value);
366}
367
368CSSStyleDeclaration CSSPageRule::style() const
369{
370 if(!impl) return CSSStyleDeclaration();
371 return ((CSSPageRuleImpl *)impl)->style();
372}
373
374
375// ----------------------------------------------------------
376
377CSSStyleRule::CSSStyleRule() : CSSRule()
378{
379}
380
381CSSStyleRule::CSSStyleRule(const CSSStyleRule &other)
382 : CSSRule(other)
383{
384}
385
386CSSStyleRule::CSSStyleRule(const CSSRule &other)
387{
388 impl = 0;
389 operator=(other);
390}
391
392
393CSSStyleRule::CSSStyleRule(CSSStyleRuleImpl *impl)
394 : CSSRule(impl)
395{
396}
397
398CSSStyleRule &CSSStyleRule::operator = (const CSSStyleRule &other)
399{
400 CSSRule::operator = (other);
401 return *this;
402}
403
404CSSStyleRule &CSSStyleRule::operator = (const CSSRule &other)
405{
406 assignOther( other, CSSRule::STYLE_RULE );
407 return *this;
408}
409
410CSSStyleRule::~CSSStyleRule()
411{
412}
413
414DOMString CSSStyleRule::selectorText() const
415{
416 if(!impl) return DOMString();
417 return ((CSSStyleRuleImpl*)impl)->selectorText();
418}
419
420void CSSStyleRule::setSelectorText( const DOMString &value )
421{
422 ((CSSStyleRuleImpl*)impl)->setSelectorText(value);
423}
424
425CSSStyleDeclaration CSSStyleRule::style() const
426{
427 if(!impl) return CSSStyleDeclaration();
428 return ((CSSStyleRuleImpl *)impl)->style();
429}
430
431// ----------------------------------------------------------
432
433
434CSSNamespaceRule::CSSNamespaceRule() : CSSRule()
435{
436}
437
438CSSNamespaceRule::CSSNamespaceRule(const CSSNamespaceRule &other)
439 : CSSRule(other)
440{
441}
442
443CSSNamespaceRule::CSSNamespaceRule(const CSSRule &other)
444{
445 impl = 0;
446 operator=(other);
447}
448
449CSSNamespaceRule::CSSNamespaceRule(CSSNamespaceRuleImpl *impl)
450 : CSSRule(impl)
451{
452}
453
454CSSNamespaceRule &CSSNamespaceRule::operator = (const CSSNamespaceRule &other)
455{
456 CSSRule::operator = (other);
457 return *this;
458}
459
460CSSNamespaceRule &CSSNamespaceRule::operator = (const CSSRule &other)
461{
462 assignOther( other, CSSRule::NAMESPACE_RULE );
463 return *this;
464}
465
466CSSNamespaceRule::~CSSNamespaceRule()
467{
468}
469
470DOMString CSSNamespaceRule::namespaceURI() const
471{
472 if(!impl) return DOMString();
473 return static_cast<CSSNamespaceRuleImpl*>(impl)->namespaceURI();
474}
475
476DOMString CSSNamespaceRule::prefix() const
477{
478 if(!impl) return DOMString();
479 return static_cast<CSSNamespaceRuleImpl*>(impl)->prefix();
480}
481
482// ----------------------------------------------------------
483
484
485CSSUnknownRule::CSSUnknownRule() : CSSRule()
486{
487}
488
489CSSUnknownRule::CSSUnknownRule(const CSSUnknownRule &other)
490 : CSSRule(other)
491{
492}
493
494CSSUnknownRule::CSSUnknownRule(const CSSRule &other)
495{
496 impl = 0;
497 operator=(other);
498}
499
500CSSUnknownRule::CSSUnknownRule(CSSUnknownRuleImpl *impl)
501 : CSSRule(impl)
502{
503}
504
505CSSUnknownRule &CSSUnknownRule::operator = (const CSSUnknownRule &other)
506{
507 CSSRule::operator = (other);
508 return *this;
509}
510
511CSSUnknownRule &CSSUnknownRule::operator = (const CSSRule &other)
512{
513 assignOther( other, CSSRule::UNKNOWN_RULE );
514 return *this;
515}
516
517CSSUnknownRule::~CSSUnknownRule()
518{
519}
520
521
522// ----------------------------------------------------------
523
524CSSRuleList::CSSRuleList()
525{
526 impl = 0;
527}
528
529CSSRuleList::CSSRuleList(const CSSRuleList &other)
530{
531 impl = other.impl;
532 if(impl) impl->ref();
533}
534
535CSSRuleList::CSSRuleList(CSSRuleListImpl *i)
536{
537 impl = i;
538 if(impl) impl->ref();
539}
540
541CSSRuleList::CSSRuleList(StyleListImpl *lst)
542{
543 impl = new CSSRuleListImpl;
544 impl->ref();
545 if (lst)
546 {
547 for( unsigned long i = 0; i < lst->length() ; ++i )
548 {
549 StyleBaseImpl* style = lst->item( i );
550 if ( style->isRule() )
551 impl->insertRule( static_cast<CSSRuleImpl *>(style), impl->length() );
552 }
553 }
554}
555
556CSSRuleList &CSSRuleList::operator = (const CSSRuleList &other)
557{
558 if ( impl != other.impl ) {
559 if(impl) impl->deref();
560 impl = other.impl;
561 if(impl) impl->ref();
562 }
563 return *this;
564}
565
566CSSRuleList::~CSSRuleList()
567{
568 if(impl) impl->deref();
569}
570
571unsigned long CSSRuleList::length() const
572{
573 if(!impl) return 0;
574 return ((CSSRuleListImpl *)impl)->length();
575 return 0;
576}
577
578CSSRule CSSRuleList::item( unsigned long index )
579{
580 if(!impl) return CSSRule();
581 return ((CSSRuleListImpl *)impl)->item( index );
582}
583
584CSSRuleListImpl *CSSRuleList::handle() const
585{
586 return impl;
587}
588
589bool CSSRuleList::isNull() const
590{
591 return (impl == 0);
592}
593
594
595
596
DOM::CSSCharsetRule
The CSSCharsetRule interface a @charset rule in a CSS style sheet.
Definition: css_rule.h:151
DOM::CSSCharsetRule::setEncoding
void setEncoding(const DOM::DOMString &)
see encoding
Definition: css_rule.cpp:152
DOM::CSSCharsetRule::~CSSCharsetRule
~CSSCharsetRule()
Definition: css_rule.cpp:142
DOM::CSSCharsetRule::CSSCharsetRule
CSSCharsetRule()
Definition: css_rule.cpp:111
DOM::CSSCharsetRule::operator=
CSSCharsetRule & operator=(const CSSCharsetRule &other)
Definition: css_rule.cpp:130
DOM::CSSCharsetRule::encoding
DOM::DOMString encoding() const
The encoding information used in this @charset rule.
Definition: css_rule.cpp:146
DOM::CSSFontFaceRule
The CSSFontFaceRule interface represents a @font-face rule in a CSS style sheet.
Definition: css_rule.h:195
DOM::CSSFontFaceRule::~CSSFontFaceRule
~CSSFontFaceRule()
Definition: css_rule.cpp:191
DOM::CSSFontFaceRule::style
CSSStyleDeclaration style() const
The declaration-block of this rule.
Definition: css_rule.cpp:195
DOM::CSSFontFaceRule::CSSFontFaceRule
CSSFontFaceRule()
Definition: css_rule.cpp:161
DOM::CSSFontFaceRule::operator=
CSSFontFaceRule & operator=(const CSSFontFaceRule &other)
Definition: css_rule.cpp:179
DOM::CSSImportRule
The CSSImportRule interface represents a @import rule within a CSS style sheet.
Definition: css_rule.h:225
DOM::CSSImportRule::~CSSImportRule
~CSSImportRule()
Definition: css_rule.cpp:235
DOM::CSSImportRule::operator=
CSSImportRule & operator=(const CSSImportRule &other)
Definition: css_rule.cpp:223
DOM::CSSImportRule::CSSImportRule
CSSImportRule()
Definition: css_rule.cpp:205
DOM::CSSImportRule::href
DOM::DOMString href() const
The location of the style sheet to be imported.
Definition: css_rule.cpp:239
DOM::CSSImportRule::media
MediaList media() const
A list of media types for which this style sheet may be used.
Definition: css_rule.cpp:245
DOM::CSSImportRule::styleSheet
CSSStyleSheet styleSheet() const
The style sheet referred to by this rule, if it has been loaded.
Definition: css_rule.cpp:251
DOM::CSSMediaRule
The CSSMediaRule interface represents a @media rule in a CSS style sheet.
Definition: css_rule.h:272
DOM::CSSMediaRule::operator=
CSSMediaRule & operator=(const CSSMediaRule &other)
Definition: css_rule.cpp:279
DOM::CSSMediaRule::~CSSMediaRule
~CSSMediaRule()
Definition: css_rule.cpp:291
DOM::CSSMediaRule::insertRule
unsigned long insertRule(const DOM::DOMString &rule, unsigned long index)
Used to insert a new rule into the media block.
Definition: css_rule.cpp:307
DOM::CSSMediaRule::media
MediaList media() const
A list of media types for this rule.
Definition: css_rule.cpp:295
DOM::CSSMediaRule::cssRules
CSSRuleList cssRules() const
A list of all CSS rules contained within the media block.
Definition: css_rule.cpp:301
DOM::CSSMediaRule::CSSMediaRule
CSSMediaRule()
Definition: css_rule.cpp:261
DOM::CSSMediaRule::deleteRule
void deleteRule(unsigned long index)
Used to delete a rule from the media block.
Definition: css_rule.cpp:313
DOM::CSSNamespaceRule
Definition: css_rule.h:463
DOM::CSSNamespaceRule::prefix
DOMString prefix() const
Definition: css_rule.cpp:476
DOM::CSSNamespaceRule::operator=
CSSNamespaceRule & operator=(const CSSNamespaceRule &other)
Definition: css_rule.cpp:454
DOM::CSSNamespaceRule::CSSNamespaceRule
CSSNamespaceRule()
Definition: css_rule.cpp:434
DOM::CSSNamespaceRule::namespaceURI
DOMString namespaceURI() const
Definition: css_rule.cpp:470
DOM::CSSNamespaceRule::~CSSNamespaceRule
~CSSNamespaceRule()
Definition: css_rule.cpp:466
DOM::CSSPageRule
Definition: css_rule.h:364
DOM::CSSPageRule::style
CSSStyleDeclaration style() const
The declaration-block of this rule.
Definition: css_rule.cpp:368
DOM::CSSPageRule::selectorText
DOM::DOMString selectorText() const
The parsable textual representation of the page selector for the rule.
Definition: css_rule.cpp:357
DOM::CSSPageRule::~CSSPageRule
~CSSPageRule()
Definition: css_rule.cpp:353
DOM::CSSPageRule::operator=
CSSPageRule & operator=(const CSSPageRule &other)
Definition: css_rule.cpp:341
DOM::CSSPageRule::setSelectorText
void setSelectorText(const DOM::DOMString &)
see selectorText
Definition: css_rule.cpp:363
DOM::CSSPageRule::CSSPageRule
CSSPageRule()
Definition: css_rule.cpp:323
DOM::CSSRuleList
The CSSRuleList interface provides the abstraction of an ordered collection of CSS rules.
Definition: css_rule.h:513
DOM::CSSRuleList::operator=
CSSRuleList & operator=(const CSSRuleList &other)
Definition: css_rule.cpp:556
DOM::CSSRuleList::length
unsigned long length() const
The number of CSSRule s in the list.
Definition: css_rule.cpp:571
DOM::CSSRuleList::CSSRuleList
CSSRuleList()
Definition: css_rule.cpp:524
DOM::CSSRuleList::isNull
bool isNull() const
Definition: css_rule.cpp:589
DOM::CSSRuleList::impl
CSSRuleListImpl * impl
Definition: css_rule.h:556
DOM::CSSRuleList::~CSSRuleList
~CSSRuleList()
Definition: css_rule.cpp:566
DOM::CSSRuleList::item
CSSRule item(unsigned long index)
Used to retrieve a CSS rule by ordinal index.
Definition: css_rule.cpp:578
DOM::CSSRuleList::handle
CSSRuleListImpl * handle() const
Definition: css_rule.cpp:584
DOM::CSSRule
The CSSRule interface is the abstract base interface for any type of CSS statement .
Definition: css_rule.h:53
DOM::CSSRule::setCssText
void setCssText(const DOM::DOMString &)
see cssText
Definition: css_rule.cpp:71
DOM::CSSRule::isNull
bool isNull() const
Definition: css_rule.cpp:94
DOM::CSSRule::handle
CSSRuleImpl * handle() const
Definition: css_rule.cpp:89
DOM::CSSRule::parentStyleSheet
CSSStyleSheet parentStyleSheet() const
The style sheet that contains this rule.
Definition: css_rule.cpp:77
DOM::CSSRule::~CSSRule
~CSSRule()
Definition: css_rule.cpp:54
DOM::CSSRule::CSSRule
CSSRule()
Definition: css_rule.cpp:27
DOM::CSSRule::RuleType
RuleType
An integer indicating which type of rule this is.
Definition: css_rule.h:67
DOM::CSSRule::STYLE_RULE
@ STYLE_RULE
Definition: css_rule.h:69
DOM::CSSRule::MEDIA_RULE
@ MEDIA_RULE
Definition: css_rule.h:72
DOM::CSSRule::FONT_FACE_RULE
@ FONT_FACE_RULE
Definition: css_rule.h:73
DOM::CSSRule::UNKNOWN_RULE
@ UNKNOWN_RULE
Definition: css_rule.h:68
DOM::CSSRule::NAMESPACE_RULE
@ NAMESPACE_RULE
CSSOM,.
Definition: css_rule.h:75
DOM::CSSRule::CHARSET_RULE
@ CHARSET_RULE
Definition: css_rule.h:70
DOM::CSSRule::IMPORT_RULE
@ IMPORT_RULE
Definition: css_rule.h:71
DOM::CSSRule::PAGE_RULE
@ PAGE_RULE
Definition: css_rule.h:74
DOM::CSSRule::cssText
DOM::DOMString cssText() const
The parsable textual representation of the rule.
Definition: css_rule.cpp:65
DOM::CSSRule::assignOther
void assignOther(const CSSRule &other, RuleType thisType)
Definition: css_rule.cpp:99
DOM::CSSRule::operator=
CSSRule & operator=(const CSSRule &other)
Definition: css_rule.cpp:44
DOM::CSSRule::parentRule
CSSRule parentRule() const
If this rule is contained inside another rule (e.g.
Definition: css_rule.cpp:83
DOM::CSSRule::impl
CSSRuleImpl * impl
Definition: css_rule.h:137
DOM::CSSRule::type
unsigned short type() const
The type of the rule, as defined above.
Definition: css_rule.cpp:59
DOM::CSSStyleDeclaration
The CSSStyleDeclaration interface represents a single CSS declaration block .
Definition: css_value.h:61
DOM::CSSStyleRule
The CSSStyleRule interface represents a single rule set in a CSS style sheet.
Definition: css_rule.h:413
DOM::CSSStyleRule::operator=
CSSStyleRule & operator=(const CSSStyleRule &other)
Definition: css_rule.cpp:398
DOM::CSSStyleRule::CSSStyleRule
CSSStyleRule()
Definition: css_rule.cpp:377
DOM::CSSStyleRule::~CSSStyleRule
~CSSStyleRule()
Definition: css_rule.cpp:410
DOM::CSSStyleRule::selectorText
DOM::DOMString selectorText() const
The textual representation of the selector for the rule set.
Definition: css_rule.cpp:414
DOM::CSSStyleRule::setSelectorText
void setSelectorText(const DOM::DOMString &)
see selectorText
Definition: css_rule.cpp:420
DOM::CSSStyleRule::style
CSSStyleDeclaration style() const
The declaration-block of this rule set.
Definition: css_rule.cpp:425
DOM::CSSStyleSheet
The CSSStyleSheet interface is a concrete interface used to represent a CSS style sheet i....
Definition: css_stylesheet.h:219
DOM::CSSUnknownRule
The CSSUnkownRule interface represents an at-rule not supported by this user agent.
Definition: css_rule.h:490
DOM::CSSUnknownRule::operator=
CSSUnknownRule & operator=(const CSSUnknownRule &other)
Definition: css_rule.cpp:505
DOM::CSSUnknownRule::CSSUnknownRule
CSSUnknownRule()
Definition: css_rule.cpp:485
DOM::CSSUnknownRule::~CSSUnknownRule
~CSSUnknownRule()
Definition: css_rule.cpp:517
DOM::DOMString
This class implements the basic string we use in the DOM.
Definition: dom_string.h:44
DOM::MediaList
The MediaList interface provides the abstraction of an ordered collection of media,...
Definition: css_stylesheet.h:378
DOM
This library provides a full-featured HTML parser and widget.
Definition: design.h:55
rule
The CSSNamespaceRule interface represents an.
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