khtml/dom/html_table.cpp

   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
  24 #include "html_table.h"
  25 #include "html_misc.h"
  26 #include "dom_exception.h"
  27
  28 #include <html/html_miscimpl.h>
  29 #include <html/html_tableimpl.h>
  30 #include <misc/htmlhashes.h>
  31
  32 using namespace DOM;
  33
  34 HTMLTableCaptionElement::HTMLTableCaptionElement() : HTMLElement()
  35 {
  36 }
  37
  38 HTMLTableCaptionElement::HTMLTableCaptionElement(const HTMLTableCaptionElement &other) : HTMLElement(other)
  39 {
  40 }
  41
  42 HTMLTableCaptionElement::HTMLTableCaptionElement(HTMLTableCaptionElementImpl *impl) : HTMLElement(impl)
  43 {
  44 }
  45
  46 HTMLTableCaptionElement &HTMLTableCaptionElement::operator = (const Node &other)
  47 {
  48     assignOther( other, ID_CAPTION );
  49     return *this;
  50 }
  51
  52 HTMLTableCaptionElement &HTMLTableCaptionElement::operator = (const HTMLTableCaptionElement &other)
  53 {
  54     HTMLElement::operator = (other);
  55     return *this;
  56 }
  57
  58 HTMLTableCaptionElement::~HTMLTableCaptionElement()
  59 {
  60 }
  61
  62 DOMString HTMLTableCaptionElement::align() const
  63 {
  64     if(!impl) return DOMString();
  65     return ((ElementImpl *)impl)->getAttribute(ATTR_ALIGN);
  66 }
  67
  68 void HTMLTableCaptionElement::setAlign( const DOMString &value )
  69 {
  70     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_ALIGN, value);
  71 }
  72
  73 // --------------------------------------------------------------------------
  74
  75 HTMLTableCellElement::HTMLTableCellElement() : HTMLElement()
  76 {
  77 }
  78
  79 HTMLTableCellElement::HTMLTableCellElement(const HTMLTableCellElement &other) : HTMLElement(other)
  80 {
  81 }
  82
  83 HTMLTableCellElement::HTMLTableCellElement(HTMLTableCellElementImpl *impl) : HTMLElement(impl)
  84 {
  85 }
  86
  87 HTMLTableCellElement &HTMLTableCellElement::operator = (const Node &other)
  88 {
  89     if( other.elementId() != ID_TD &&
  90         other.elementId() != ID_TH )
  91     {
  92         if ( impl ) impl->deref();
  93         impl = 0;
  94     } else {
  95     Node::operator = (other);
  96     }
  97     return *this;
  98 }
  99
 100 HTMLTableCellElement &HTMLTableCellElement::operator = (const HTMLTableCellElement &other)
 101 {
 102     HTMLElement::operator = (other);
 103     return *this;
 104 }
 105
 106 HTMLTableCellElement::~HTMLTableCellElement()
 107 {
 108 }
 109
 110 long HTMLTableCellElement::cellIndex() const
 111 {
 112     if(!impl) return 0;
 113     return ((HTMLTableCellElementImpl *)impl)->cellIndex();
 114 }
 115
 116 void HTMLTableCellElement::setCellIndex( long /*_cellIndex*/ )
 117 {
 118     throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR);
 119 }
 120
 121 DOMString HTMLTableCellElement::abbr() const
 122 {
 123     if(!impl) return DOMString();
 124     return ((ElementImpl *)impl)->getAttribute(ATTR_ABBR);
 125 }
 126
 127 void HTMLTableCellElement::setAbbr( const DOMString &value )
 128 {
 129     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_ABBR, value);
 130 }
 131
 132 DOMString HTMLTableCellElement::align() const
 133 {
 134     if(!impl) return DOMString();
 135     return ((ElementImpl *)impl)->getAttribute(ATTR_ALIGN);
 136 }
 137
 138 void HTMLTableCellElement::setAlign( const DOMString &value )
 139 {
 140     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_ALIGN, value);
 141 }
 142
 143 DOMString HTMLTableCellElement::axis() const
 144 {
 145     if(!impl) return DOMString();
 146     return ((ElementImpl *)impl)->getAttribute(ATTR_AXIS);
 147 }
 148
 149 void HTMLTableCellElement::setAxis( const DOMString &value )
 150 {
 151     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_AXIS, value);
 152 }
 153
 154 DOMString HTMLTableCellElement::bgColor() const
 155 {
 156     if(!impl) return DOMString();
 157     return ((ElementImpl *)impl)->getAttribute(ATTR_BGCOLOR);
 158 }
 159
 160 void HTMLTableCellElement::setBgColor( const DOMString &value )
 161 {
 162     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_BGCOLOR, value);
 163 }
 164
 165 DOMString HTMLTableCellElement::ch() const
 166 {
 167     if(!impl) return DOMString();
 168     return ((ElementImpl *)impl)->getAttribute(ATTR_CHAR);
 169 }
 170
 171 void HTMLTableCellElement::setCh( const DOMString &value )
 172 {
 173     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_CHAR, value);
 174 }
 175
 176 DOMString HTMLTableCellElement::chOff() const
 177 {
 178     if(!impl) return DOMString();
 179     return ((ElementImpl *)impl)->getAttribute(ATTR_CHAROFF);
 180 }
 181
 182 void HTMLTableCellElement::setChOff( const DOMString &value )
 183 {
 184     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_CHAROFF, value);
 185 }
 186
 187 long HTMLTableCellElement::colSpan() const
 188 {
 189     if(!impl) return 0;
 190     return ((ElementImpl *)impl)->getAttribute(ATTR_COLSPAN).toInt();
 191 }
 192
 193 void HTMLTableCellElement::setColSpan( long _colSpan )
 194 {
 195     if(impl) {
 196         DOMString value(QString::number(_colSpan));
 197         ((ElementImpl *)impl)->setAttribute(ATTR_COLSPAN,value);
 198     }
 199 }
 200
 201 DOMString HTMLTableCellElement::headers() const
 202 {
 203     if(!impl) return DOMString();
 204     return ((ElementImpl *)impl)->getAttribute(ATTR_HEADERS);
 205 }
 206
 207 void HTMLTableCellElement::setHeaders( const DOMString &value )
 208 {
 209     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_HEADERS, value);
 210 }
 211
 212 DOMString HTMLTableCellElement::height() const
 213 {
 214     if(!impl) return DOMString();
 215     return ((ElementImpl *)impl)->getAttribute(ATTR_HEIGHT);
 216 }
 217
 218 void HTMLTableCellElement::setHeight( const DOMString &value )
 219 {
 220     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_HEIGHT, value);
 221 }
 222
 223 bool HTMLTableCellElement::noWrap() const
 224 {
 225     if(!impl) return false;
 226     return !((ElementImpl *)impl)->getAttribute(ATTR_NOWRAP).isNull();
 227 }
 228
 229 void HTMLTableCellElement::setNoWrap( bool _noWrap )
 230 {
 231     if(impl)
 232         ((ElementImpl *)impl)->setAttribute(ATTR_NOWRAP, _noWrap ? "" : 0);
 233 }
 234
 235 long HTMLTableCellElement::rowSpan() const
 236 {
 237     if(!impl) return 0;
 238     return ((ElementImpl *)impl)->getAttribute(ATTR_ROWSPAN).toInt();
 239 }
 240
 241 void HTMLTableCellElement::setRowSpan( long _rowSpan )
 242 {
 243     if(impl) {
 244         DOMString value(QString::number(_rowSpan));
 245         ((ElementImpl *)impl)->setAttribute(ATTR_ROWSPAN,value);
 246     }
 247 }
 248
 249 DOMString HTMLTableCellElement::scope() const
 250 {
 251     if(!impl) return DOMString();
 252     return ((ElementImpl *)impl)->getAttribute(ATTR_SCOPE);
 253 }
 254
 255 void HTMLTableCellElement::setScope( const DOMString &value )
 256 {
 257     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_SCOPE, value);
 258 }
 259
 260 DOMString HTMLTableCellElement::vAlign() const
 261 {
 262     if(!impl) return DOMString();
 263     return ((ElementImpl *)impl)->getAttribute(ATTR_VALIGN);
 264 }
 265
 266 void HTMLTableCellElement::setVAlign( const DOMString &value )
 267 {
 268     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_VALIGN, value);
 269 }
 270
 271 DOMString HTMLTableCellElement::width() const
 272 {
 273     if(!impl) return DOMString();
 274     return ((ElementImpl *)impl)->getAttribute(ATTR_WIDTH);
 275 }
 276
 277 void HTMLTableCellElement::setWidth( const DOMString &value )
 278 {
 279     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_WIDTH, value);
 280 }
 281
 282 // --------------------------------------------------------------------------
 283
 284 HTMLTableColElement::HTMLTableColElement() : HTMLElement()
 285 {
 286 }
 287
 288 HTMLTableColElement::HTMLTableColElement(const HTMLTableColElement &other) : HTMLElement(other)
 289 {
 290 }
 291
 292 HTMLTableColElement::HTMLTableColElement(HTMLTableColElementImpl *impl) : HTMLElement(impl)
 293 {
 294 }
 295
 296 HTMLTableColElement &HTMLTableColElement::operator = (const Node &other)
 297 {
 298     if( other.elementId() != ID_COL &&
 299         other.elementId() != ID_COLGROUP )
 300     {
 301         if ( impl ) impl->deref();
 302         impl = 0;
 303     } else {
 304     Node::operator = (other);
 305     }
 306     return *this;
 307 }
 308
 309 HTMLTableColElement &HTMLTableColElement::operator = (const HTMLTableColElement &other)
 310 {
 311     HTMLElement::operator = (other);
 312     return *this;
 313 }
 314
 315 HTMLTableColElement::~HTMLTableColElement()
 316 {
 317 }
 318
 319 DOMString HTMLTableColElement::align() const
 320 {
 321     if(!impl) return DOMString();
 322     return ((ElementImpl *)impl)->getAttribute(ATTR_ALIGN);
 323 }
 324
 325 void HTMLTableColElement::setAlign( const DOMString &value )
 326 {
 327     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_ALIGN, value);
 328 }
 329
 330 DOMString HTMLTableColElement::ch() const
 331 {
 332     if(!impl) return DOMString();
 333     return ((ElementImpl *)impl)->getAttribute(ATTR_CHAR);
 334 }
 335
 336 void HTMLTableColElement::setCh( const DOMString &value )
 337 {
 338     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_CHAR, value);
 339 }
 340
 341 DOMString HTMLTableColElement::chOff() const
 342 {
 343     if(!impl) return DOMString();
 344     return ((ElementImpl *)impl)->getAttribute(ATTR_CHAROFF);
 345 }
 346
 347 void HTMLTableColElement::setChOff( const DOMString &value )
 348 {
 349     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_CHAROFF, value);
 350 }
 351
 352 long HTMLTableColElement::span() const
 353 {
 354     if(!impl) return 0;
 355     return ((ElementImpl *)impl)->getAttribute(ATTR_SPAN).toInt();
 356 }
 357
 358 void HTMLTableColElement::setSpan( long _span )
 359 {
 360     if(impl) {
 361         DOMString value(QString::number(_span));
 362         ((ElementImpl *)impl)->setAttribute(ATTR_SPAN,value);
 363     }
 364 }
 365
 366 DOMString HTMLTableColElement::vAlign() const
 367 {
 368     if(!impl) return DOMString();
 369     return ((ElementImpl *)impl)->getAttribute(ATTR_VALIGN);
 370 }
 371
 372 void HTMLTableColElement::setVAlign( const DOMString &value )
 373 {
 374     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_VALIGN, value);
 375 }
 376
 377 DOMString HTMLTableColElement::width() const
 378 {
 379     if(!impl) return DOMString();
 380     return ((ElementImpl *)impl)->getAttribute(ATTR_WIDTH);
 381 }
 382
 383 void HTMLTableColElement::setWidth( const DOMString &value )
 384 {
 385     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_WIDTH, value);
 386 }
 387
 388 // --------------------------------------------------------------------------
 389
 390 HTMLTableElement::HTMLTableElement() : HTMLElement()
 391 {
 392 }
 393
 394 HTMLTableElement::HTMLTableElement(const HTMLTableElement &other) : HTMLElement(other)
 395 {
 396 }
 397
 398 HTMLTableElement::HTMLTableElement(HTMLTableElementImpl *impl) : HTMLElement(impl)
 399 {
 400 }
 401
 402 HTMLTableElement &HTMLTableElement::operator = (const Node &other)
 403 {
 404     assignOther( other, ID_TABLE );
 405     return *this;
 406 }
 407
 408 HTMLTableElement &HTMLTableElement::operator = (const HTMLTableElement &other)
 409 {
 410     HTMLElement::operator = (other);
 411     return *this;
 412 }
 413
 414 HTMLTableElement::~HTMLTableElement()
 415 {
 416 }
 417
 418 HTMLTableCaptionElement HTMLTableElement::caption() const
 419 {
 420     if(!impl) return 0;
 421     return ((HTMLTableElementImpl *)impl)->caption();
 422 }
 423
 424 void HTMLTableElement::setCaption( const HTMLTableCaptionElement &_caption )
 425 {
 426     if(impl)
 427         ((HTMLTableElementImpl *)impl)
 428             ->setCaption( ((HTMLTableCaptionElementImpl *)_caption.impl) );
 429 }
 430
 431 HTMLTableSectionElement HTMLTableElement::tHead() const
 432 {
 433     if(!impl) return 0;
 434     return ((HTMLTableElementImpl *)impl)->tHead();
 435 }
 436
 437 void HTMLTableElement::setTHead( const HTMLTableSectionElement &_tHead )
 438 {
 439
 440     if(impl)
 441         ((HTMLTableElementImpl *)impl)
 442             ->setTHead( ((HTMLTableSectionElementImpl *)_tHead.impl) );
 443 }
 444
 445 HTMLTableSectionElement HTMLTableElement::tFoot() const
 446 {
 447     if(!impl) return 0;
 448     return ((HTMLTableElementImpl *)impl)->tFoot();
 449 }
 450
 451 void HTMLTableElement::setTFoot( const HTMLTableSectionElement &_tFoot )
 452 {
 453
 454     if(impl)
 455         ((HTMLTableElementImpl *)impl)
 456             ->setTFoot( ((HTMLTableSectionElementImpl *)_tFoot.impl) );
 457 }
 458
 459 HTMLCollection HTMLTableElement::rows() const
 460 {
 461     if(!impl) return HTMLCollection();
 462     return HTMLCollection(impl, HTMLCollectionImpl::TABLE_ROWS);
 463 }
 464
 465 HTMLCollection HTMLTableElement::tBodies() const
 466 {
 467     if(!impl) return HTMLCollection();
 468     return HTMLCollection(impl, HTMLCollectionImpl::TABLE_TBODIES);
 469 }
 470
 471 DOMString HTMLTableElement::align() const
 472 {
 473     if(!impl) return DOMString();
 474     return ((ElementImpl *)impl)->getAttribute(ATTR_ALIGN);
 475 }
 476
 477 void HTMLTableElement::setAlign( const DOMString &value )
 478 {
 479     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_ALIGN, value);
 480 }
 481
 482 DOMString HTMLTableElement::bgColor() const
 483 {
 484     if(!impl) return DOMString();
 485     return ((ElementImpl *)impl)->getAttribute(ATTR_BGCOLOR);
 486 }
 487
 488 void HTMLTableElement::setBgColor( const DOMString &value )
 489 {
 490     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_BGCOLOR, value);
 491 }
 492
 493 DOMString HTMLTableElement::border() const
 494 {
 495     if(!impl) return DOMString();
 496     return ((ElementImpl *)impl)->getAttribute(ATTR_BORDER);
 497 }
 498
 499 void HTMLTableElement::setBorder( const DOMString &value )
 500 {
 501     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_BORDER, value);
 502 }
 503
 504 DOMString HTMLTableElement::cellPadding() const
 505 {
 506     if(!impl) return DOMString();
 507     return ((ElementImpl *)impl)->getAttribute(ATTR_CELLPADDING);
 508 }
 509
 510 void HTMLTableElement::setCellPadding( const DOMString &value )
 511 {
 512     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_CELLPADDING, value);
 513 }
 514
 515 DOMString HTMLTableElement::cellSpacing() const
 516 {
 517     if(!impl) return DOMString();
 518     return ((ElementImpl *)impl)->getAttribute(ATTR_CELLSPACING);
 519 }
 520
 521 void HTMLTableElement::setCellSpacing( const DOMString &value )
 522 {
 523     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_CELLSPACING, value);
 524 }
 525
 526 DOMString HTMLTableElement::frame() const
 527 {
 528     if(!impl) return DOMString();
 529     return ((ElementImpl *)impl)->getAttribute(ATTR_FRAME);
 530 }
 531
 532 void HTMLTableElement::setFrame( const DOMString &value )
 533 {
 534     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_FRAME, value);
 535 }
 536
 537 DOMString HTMLTableElement::rules() const
 538 {
 539     if(!impl) return DOMString();
 540     return ((ElementImpl *)impl)->getAttribute(ATTR_RULES);
 541 }
 542
 543 void HTMLTableElement::setRules( const DOMString &value )
 544 {
 545     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_RULES, value);
 546 }
 547
 548 DOMString HTMLTableElement::summary() const
 549 {
 550     if(!impl) return DOMString();
 551     return ((ElementImpl *)impl)->getAttribute(ATTR_SUMMARY);
 552 }
 553
 554 void HTMLTableElement::setSummary( const DOMString &value )
 555 {
 556     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_SUMMARY, value);
 557 }
 558
 559 DOMString HTMLTableElement::width() const
 560 {
 561     if(!impl) return DOMString();
 562     return ((ElementImpl *)impl)->getAttribute(ATTR_WIDTH);
 563 }
 564
 565 void HTMLTableElement::setWidth( const DOMString &value )
 566 {
 567     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_WIDTH, value);
 568 }
 569
 570 HTMLElement HTMLTableElement::createTHead(  )
 571 {
 572     if(!impl) return 0;
 573     return ((HTMLTableElementImpl *)impl)->createTHead(  );
 574 }
 575
 576 void HTMLTableElement::deleteTHead(  )
 577 {
 578     if(impl)
 579         ((HTMLTableElementImpl *)impl)->deleteTHead(  );
 580 }
 581
 582 HTMLElement HTMLTableElement::createTFoot(  )
 583 {
 584     if(!impl) return 0;
 585     return ((HTMLTableElementImpl *)impl)->createTFoot(  );
 586 }
 587
 588 void HTMLTableElement::deleteTFoot(  )
 589 {
 590     if(impl)
 591         ((HTMLTableElementImpl *)impl)->deleteTFoot(  );
 592 }
 593
 594 HTMLElement HTMLTableElement::createCaption(  )
 595 {
 596     if(!impl) return 0;
 597     return ((HTMLTableElementImpl *)impl)->createCaption(  );
 598 }
 599
 600 void HTMLTableElement::deleteCaption(  )
 601 {
 602     if(impl)
 603         ((HTMLTableElementImpl *)impl)->deleteCaption(  );
 604 }
 605
 606 HTMLElement HTMLTableElement::insertRow( long index )
 607 {
 608     if(!impl) return 0;
 609     int exceptioncode = 0;
 610     HTMLElementImpl* ret = ((HTMLTableElementImpl *)impl)->insertRow( index, exceptioncode );
 611     if (exceptioncode)
 612         throw DOMException(exceptioncode);
 613     return ret;
 614 }
 615
 616 void HTMLTableElement::deleteRow( long index )
 617 {
 618     int exceptioncode = 0;
 619     if(impl)
 620         ((HTMLTableElementImpl *)impl)->deleteRow( index, exceptioncode );
 621     if (exceptioncode)
 622         throw DOMException(exceptioncode);
 623 }
 624
 625 // --------------------------------------------------------------------------
 626
 627 HTMLTableRowElement::HTMLTableRowElement() : HTMLElement()
 628 {
 629 }
 630
 631 HTMLTableRowElement::HTMLTableRowElement(const HTMLTableRowElement &other) : HTMLElement(other)
 632 {
 633 }
 634
 635 HTMLTableRowElement::HTMLTableRowElement(HTMLTableRowElementImpl *impl) : HTMLElement(impl)
 636 {
 637 }
 638
 639 HTMLTableRowElement &HTMLTableRowElement::operator = (const Node &other)
 640 {
 641     assignOther( other, ID_TR );
 642     return *this;
 643 }
 644
 645 HTMLTableRowElement &HTMLTableRowElement::operator = (const HTMLTableRowElement &other)
 646 {
 647     HTMLElement::operator = (other);
 648     return *this;
 649 }
 650
 651 HTMLTableRowElement::~HTMLTableRowElement()
 652 {
 653 }
 654
 655 long HTMLTableRowElement::rowIndex() const
 656 {
 657     if(!impl) return 0;
 658     return ((HTMLTableRowElementImpl *)impl)->rowIndex();
 659 }
 660
 661 void HTMLTableRowElement::setRowIndex( long /*_rowIndex*/ )
 662 {
 663     throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR);
 664 }
 665
 666 long HTMLTableRowElement::sectionRowIndex() const
 667 {
 668     if(!impl) return 0;
 669     return ((HTMLTableRowElementImpl *)impl)->sectionRowIndex();
 670 }
 671
 672 void HTMLTableRowElement::setSectionRowIndex( long /*_sectionRowIndex*/ )
 673 {
 674     throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR);
 675 }
 676
 677 HTMLCollection HTMLTableRowElement::cells() const
 678 {
 679     if(!impl) return HTMLCollection();
 680     return HTMLCollection(impl, HTMLCollectionImpl::TR_CELLS);
 681 }
 682
 683 void HTMLTableRowElement::setCells( const HTMLCollection & /*_cells*/ )
 684 {
 685     throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR);
 686 }
 687
 688 DOMString HTMLTableRowElement::align() const
 689 {
 690     if(!impl) return DOMString();
 691     return ((ElementImpl *)impl)->getAttribute(ATTR_ALIGN);
 692 }
 693
 694 void HTMLTableRowElement::setAlign( const DOMString &value )
 695 {
 696     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_ALIGN, value);
 697 }
 698
 699 DOMString HTMLTableRowElement::bgColor() const
 700 {
 701     if(!impl) return DOMString();
 702     return ((ElementImpl *)impl)->getAttribute(ATTR_BGCOLOR);
 703 }
 704
 705 void HTMLTableRowElement::setBgColor( const DOMString &value )
 706 {
 707     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_BGCOLOR, value);
 708 }
 709
 710 DOMString HTMLTableRowElement::ch() const
 711 {
 712     if(!impl) return DOMString();
 713     return ((ElementImpl *)impl)->getAttribute(ATTR_CHAR);
 714 }
 715
 716 void HTMLTableRowElement::setCh( const DOMString &value )
 717 {
 718     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_CHAR, value);
 719 }
 720
 721 DOMString HTMLTableRowElement::chOff() const
 722 {
 723     if(!impl) return DOMString();
 724     return ((ElementImpl *)impl)->getAttribute(ATTR_CHAROFF);
 725 }
 726
 727 void HTMLTableRowElement::setChOff( const DOMString &value )
 728 {
 729     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_CHAROFF, value);
 730 }
 731
 732 DOMString HTMLTableRowElement::vAlign() const
 733 {
 734     if(!impl) return DOMString();
 735     return ((ElementImpl *)impl)->getAttribute(ATTR_VALIGN);
 736 }
 737
 738 void HTMLTableRowElement::setVAlign( const DOMString &value )
 739 {
 740     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_VALIGN, value);
 741 }
 742
 743 HTMLElement HTMLTableRowElement::insertCell( long index )
 744 {
 745     if(!impl) return 0;
 746     int exceptioncode = 0;
 747     HTMLElementImpl* ret = ((HTMLTableRowElementImpl *)impl)->insertCell( index, exceptioncode );
 748     if (exceptioncode)
 749         throw DOMException(exceptioncode);
 750     return ret;
 751 }
 752
 753 void HTMLTableRowElement::deleteCell( long index )
 754 {
 755     int exceptioncode = 0;
 756     if(impl)
 757         ((HTMLTableRowElementImpl *)impl)->deleteCell( index, exceptioncode );
 758     if (exceptioncode)
 759         throw DOMException(exceptioncode);
 760 }
 761
 762 // --------------------------------------------------------------------------
 763
 764 HTMLTableSectionElement::HTMLTableSectionElement() : HTMLElement()
 765 {
 766 }
 767
 768 HTMLTableSectionElement::HTMLTableSectionElement(const HTMLTableSectionElement &other) : HTMLElement(other)
 769 {
 770 }
 771
 772 HTMLTableSectionElement::HTMLTableSectionElement(HTMLTableSectionElementImpl *impl) : HTMLElement(impl)
 773 {
 774 }
 775
 776 HTMLTableSectionElement &HTMLTableSectionElement::operator = (const Node &other)
 777 {
 778     if(other.elementId() != ID_TBODY &&
 779        other.elementId() != ID_THEAD &&
 780        other.elementId() != ID_TFOOT )
 781     {
 782         if ( impl ) impl->deref();
 783         impl = 0;
 784     } else {
 785     Node::operator = (other);
 786     }
 787     return *this;
 788 }
 789
 790 HTMLTableSectionElement &HTMLTableSectionElement::operator = (const HTMLTableSectionElement &other)
 791 {
 792     HTMLElement::operator = (other);
 793     return *this;
 794 }
 795
 796 HTMLTableSectionElement::~HTMLTableSectionElement()
 797 {
 798 }
 799
 800 DOMString HTMLTableSectionElement::align() const
 801 {
 802     if(!impl) return DOMString();
 803     return ((ElementImpl *)impl)->getAttribute(ATTR_ALIGN);
 804 }
 805
 806 void HTMLTableSectionElement::setAlign( const DOMString &value )
 807 {
 808     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_ALIGN, value);
 809 }
 810
 811 DOMString HTMLTableSectionElement::ch() const
 812 {
 813     if(!impl) return DOMString();
 814     return ((ElementImpl *)impl)->getAttribute(ATTR_CHAR);
 815 }
 816
 817 void HTMLTableSectionElement::setCh( const DOMString &value )
 818 {
 819     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_CHAR, value);
 820 }
 821
 822 DOMString HTMLTableSectionElement::chOff() const
 823 {
 824     if(!impl) return DOMString();
 825     return ((ElementImpl *)impl)->getAttribute(ATTR_CHAROFF);
 826 }
 827
 828 void HTMLTableSectionElement::setChOff( const DOMString &value )
 829 {
 830     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_CHAROFF, value);
 831 }
 832
 833 DOMString HTMLTableSectionElement::vAlign() const
 834 {
 835     if(!impl) return DOMString();
 836     return ((ElementImpl *)impl)->getAttribute(ATTR_VALIGN);
 837 }
 838
 839 void HTMLTableSectionElement::setVAlign( const DOMString &value )
 840 {
 841     if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_VALIGN, value);
 842 }
 843
 844 HTMLCollection HTMLTableSectionElement::rows() const
 845 {
 846     if(!impl) return HTMLCollection();
 847     return HTMLCollection(impl, HTMLCollectionImpl::TSECTION_ROWS);
 848 }
 849
 850 HTMLElement HTMLTableSectionElement::insertRow( long index )
 851 {
 852     if(!impl) return 0;
 853     int exceptioncode = 0;
 854     HTMLElementImpl* ret = ((HTMLTableSectionElementImpl *)impl)->insertRow( index, exceptioncode );
 855     if (exceptioncode)
 856         throw DOMException(exceptioncode);
 857     return ret;
 858 }
 859
 860 void HTMLTableSectionElement::deleteRow( long index )
 861 {
 862     int exceptioncode = 0;
 863     if(impl)
 864         ((HTMLTableSectionElementImpl *)impl)->deleteRow( index, exceptioncode );
 865     if (exceptioncode)
 866         throw DOMException(exceptioncode);
 867 }
 868