# khtml Library API Documentation

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

# html_list.cpp

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

This file is part of the documentation for khtml Library Version 3.4.1.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Sat Jun 11 20:33:11 2005 by doxygen 1.4.1 written by Dimitri van Heesch, © 1997-2003