# khtml Library API Documentation

Overview | Class Hierarchy | Classes | Classes (annotated) | Members | Source Files

# html_list.cpp

    00001
    00023 // --------------------------------------------------------------------------
    00024
    00025 #include "dom/html_list.h"
    00026 #include "html/html_listimpl.h"
    00027 #include "misc/htmlhashes.h"
    00028
    00029 using namespace DOM;
    00030
    00031 HTMLDListElement::HTMLDListElement() : HTMLElement()
    00032 {
    00033 }
    00034
    00035 HTMLDListElement::HTMLDListElement(const HTMLDListElement &other) : HTMLElement(other)
    00036 {
    00037 }
    00038
    00039 HTMLDListElement::HTMLDListElement(HTMLDListElementImpl *impl) : HTMLElement(impl)
    00040 {
    00041 }
    00042
    00043 HTMLDListElement &HTMLDListElement::operator = (const Node &other)
    00044 {
    00045     assignOther( other, ID_DL );
    00046     return *this;
    00047 }
    00048
    00049 HTMLDListElement &HTMLDListElement::operator = (const HTMLDListElement &other)
    00050 {
    00051     HTMLElement::operator = (other);
    00052     return *this;
    00053 }
    00054
    00055 HTMLDListElement::~HTMLDListElement()
    00056 {
    00057 }
    00058
    00059 bool HTMLDListElement::compact() const
    00060 {
    00061     if(!impl) return 0;
    00062     return !((ElementImpl *)impl)->getAttribute(ATTR_COMPACT).isNull();
    00063 }
    00064
    00065 void HTMLDListElement::setCompact( bool _compact )
    00066 {
    00067    if(impl)
    00068     {
    00069         DOMString str;
    00070         if( _compact )
    00071             str = "";
    00072         ((ElementImpl *)impl)->setAttribute(ATTR_COMPACT, str);
    00073     }
    00074 }
    00075
    00076 // --------------------------------------------------------------------------
    00077
    00078 HTMLDirectoryElement::HTMLDirectoryElement() : HTMLElement()
    00079 {
    00080 }
    00081
    00082 HTMLDirectoryElement::HTMLDirectoryElement(const HTMLDirectoryElement &other) : HTMLElement(other)
    00083 {
    00084 }
    00085
    00086 HTMLDirectoryElement::HTMLDirectoryElement(HTMLDirectoryElementImpl *impl) : HTMLElement(impl)
    00087 {
    00088 }
    00089
    00090 HTMLDirectoryElement &HTMLDirectoryElement::operator = (const Node &other)
    00091 {
    00092     assignOther( other, ID_DIR );
    00093     return *this;
    00094 }
    00095
    00096 HTMLDirectoryElement &HTMLDirectoryElement::operator = (const HTMLDirectoryElement &other)
    00097 {
    00098     HTMLElement::operator = (other);
    00099     return *this;
    00100 }
    00101
    00102 HTMLDirectoryElement::~HTMLDirectoryElement()
    00103 {
    00104 }
    00105
    00106 bool HTMLDirectoryElement::compact() const
    00107 {
    00108     if(!impl) return 0;
    00109     return !((ElementImpl *)impl)->getAttribute(ATTR_COMPACT).isNull();
    00110 }
    00111
    00112 void HTMLDirectoryElement::setCompact( bool _compact )
    00113 {
    00114    if(impl)
    00115     {
    00116         DOMString str;
    00117         if( _compact )
    00118             str = "";
    00119         ((ElementImpl *)impl)->setAttribute(ATTR_COMPACT, str);
    00120     }
    00121 }
    00122
    00123 // --------------------------------------------------------------------------
    00124
    00125 HTMLLIElement::HTMLLIElement() : HTMLElement()
    00126 {
    00127 }
    00128
    00129 HTMLLIElement::HTMLLIElement(const HTMLLIElement &other) : HTMLElement(other)
    00130 {
    00131 }
    00132
    00133 HTMLLIElement::HTMLLIElement(HTMLLIElementImpl *impl) : HTMLElement(impl)
    00134 {
    00135 }
    00136
    00137 HTMLLIElement &HTMLLIElement::operator = (const Node &other)
    00138 {
    00139     assignOther( other, ID_LI );
    00140     return *this;
    00141 }
    00142
    00143 HTMLLIElement &HTMLLIElement::operator = (const HTMLLIElement &other)
    00144 {
    00145     HTMLElement::operator = (other);
    00146     return *this;
    00147 }
    00148
    00149 HTMLLIElement::~HTMLLIElement()
    00150 {
    00151 }
    00152
    00153 DOMString HTMLLIElement::type() const
    00154 {
    00155     if(!impl) return DOMString();
    00156     return ((ElementImpl *)impl)->getAttribute(ATTR_TYPE);
    00157 }
    00158
    00159 void HTMLLIElement::setType( const DOMString &value )
    00160 {
    00161     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_TYPE, value);
    00162 }
    00163
    00164 long HTMLLIElement::value() const
    00165 {
    00166     if(!impl) return 0;
    00167     return ((ElementImpl *)impl)->getAttribute(ATTR_VALUE).toInt();
    00168 }
    00169
    00170 void HTMLLIElement::setValue( long _value )
    00171 {
    00172     if(impl) {
    00173         DOMString value(QString::number(_value));
    00174         ((ElementImpl *)impl)->setAttribute(ATTR_VALUE,value);
    00175     }
    00176 }
    00177
    00178 // --------------------------------------------------------------------------
    00179
    00180 HTMLMenuElement::HTMLMenuElement() : HTMLElement()
    00181 {
    00182 }
    00183
    00184 HTMLMenuElement::HTMLMenuElement(const HTMLMenuElement &other) : HTMLElement(other)
    00185 {
    00186 }
    00187
    00188 HTMLMenuElement::HTMLMenuElement(HTMLMenuElementImpl *impl) : HTMLElement(impl)
    00189 {
    00190 }
    00191
    00192 HTMLMenuElement &HTMLMenuElement::operator = (const Node &other)
    00193 {
    00194     assignOther( other, ID_MENU );
    00195     return *this;
    00196 }
    00197
    00198 HTMLMenuElement &HTMLMenuElement::operator = (const HTMLMenuElement &other)
    00199 {
    00200     HTMLElement::operator = (other);
    00201     return *this;
    00202 }
    00203
    00204 HTMLMenuElement::~HTMLMenuElement()
    00205 {
    00206 }
    00207
    00208 bool HTMLMenuElement::compact() const
    00209 {
    00210     if(!impl) return 0;
    00211     return !((ElementImpl *)impl)->getAttribute(ATTR_COMPACT).isNull();
    00212 }
    00213
    00214 void HTMLMenuElement::setCompact( bool _compact )
    00215 {
    00216    if(impl)
    00217     {
    00218         DOMString str;
    00219         if( _compact )
    00220             str = "";
    00221         ((ElementImpl *)impl)->setAttribute(ATTR_COMPACT, str);
    00222     }
    00223 }
    00224
    00225 // --------------------------------------------------------------------------
    00226
    00227 HTMLOListElement::HTMLOListElement() : HTMLElement()
    00228 {
    00229 }
    00230
    00231 HTMLOListElement::HTMLOListElement(const HTMLOListElement &other) : HTMLElement(other)
    00232 {
    00233 }
    00234
    00235 HTMLOListElement::HTMLOListElement(HTMLOListElementImpl *impl) : HTMLElement(impl)
    00236 {
    00237 }
    00238
    00239 HTMLOListElement &HTMLOListElement::operator = (const Node &other)
    00240 {
    00241     assignOther( other, ID_OL );
    00242     return *this;
    00243 }
    00244
    00245 HTMLOListElement &HTMLOListElement::operator = (const HTMLOListElement &other)
    00246 {
    00247     HTMLElement::operator = (other);
    00248     return *this;
    00249 }
    00250
    00251 HTMLOListElement::~HTMLOListElement()
    00252 {
    00253 }
    00254
    00255 bool HTMLOListElement::compact() const
    00256 {
    00257     if(!impl) return 0;
    00258     return !((ElementImpl *)impl)->getAttribute(ATTR_COMPACT).isNull();
    00259 }
    00260
    00261 void HTMLOListElement::setCompact( bool _compact )
    00262 {
    00263    if(impl)
    00264     {
    00265         DOMString str;
    00266         if( _compact )
    00267             str = "";
    00268         ((ElementImpl *)impl)->setAttribute(ATTR_COMPACT, str);
    00269     }
    00270 }
    00271
    00272 long HTMLOListElement::start() const
    00273 {
    00274     if(!impl) return 0;
    00275     return ((ElementImpl *)impl)->getAttribute(ATTR_START).toInt();
    00276 }
    00277
    00278 void HTMLOListElement::setStart( long _start )
    00279 {
    00280
    00281     if(impl) {
    00282         DOMString value(QString::number(_start));
    00283         ((ElementImpl *)impl)->setAttribute(ATTR_START,value);
    00284     }
    00285 }
    00286
    00287 DOMString HTMLOListElement::type() const
    00288 {
    00289     if(!impl) return DOMString();
    00290     return ((ElementImpl *)impl)->getAttribute(ATTR_TYPE);
    00291 }
    00292
    00293 void HTMLOListElement::setType( const DOMString &value )
    00294 {
    00295     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_TYPE, value);
    00296 }
    00297
    00298 // --------------------------------------------------------------------------
    00299
    00300 HTMLUListElement::HTMLUListElement() : HTMLElement()
    00301 {
    00302 }
    00303
    00304 HTMLUListElement::HTMLUListElement(const HTMLUListElement &other) : HTMLElement(other)
    00305 {
    00306 }
    00307
    00308 HTMLUListElement::HTMLUListElement(HTMLUListElementImpl *impl) : HTMLElement(impl)
    00309 {
    00310 }
    00311
    00312 HTMLUListElement &HTMLUListElement::operator = (const Node &other)
    00313 {
    00314     assignOther( other, ID_UL );
    00315     return *this;
    00316 }
    00317
    00318 HTMLUListElement &HTMLUListElement::operator = (const HTMLUListElement &other)
    00319 {
    00320     HTMLElement::operator = (other);
    00321     return *this;
    00322 }
    00323
    00324 HTMLUListElement::~HTMLUListElement()
    00325 {
    00326 }
    00327
    00328 bool HTMLUListElement::compact() const
    00329 {
    00330     if(!impl) return 0;
    00331     return !((ElementImpl *)impl)->getAttribute(ATTR_COMPACT).isNull();
    00332 }
    00333
    00334 void HTMLUListElement::setCompact( bool _compact )
    00335 {
    00336    if(impl)
    00337     {
    00338         DOMString str;
    00339         if( _compact )
    00340             str = "";
    00341         ((ElementImpl *)impl)->setAttribute(ATTR_COMPACT, str);
    00342     }
    00343 }
    00344
    00345 DOMString HTMLUListElement::type() const
    00346 {
    00347     if(!impl) return DOMString();
    00348     return ((ElementImpl *)impl)->getAttribute(ATTR_TYPE);
    00349 }
    00350
    00351 void HTMLUListElement::setType( const DOMString &value )
    00352 {
    00353     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_TYPE, value);
    00354 }
    00355

This file is part of the documentation for kdelibs Version 3.1.5.
Documentation copyright © 1996-2002 the KDE developers.
Generated on Wed Jan 28 13:33:55 2004 by doxygen 1.3.4 written by Dimitri van Heesch, © 1997-2001