render_style.h Source File (khtml Library)

| # khtml Library API Documentation
Overview | Class Hierarchy | Classes | Classes (annotated) | Members | Source Files

# render_style.h

    00001 /*
    00002  * This file is part of the DOM implementation for KDE.
    00003  *
    00004  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
    00005  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
    00006  *           (C) 2000 Dirk Mueller (mueller@kde.org)
    00007  *
    00008  * This library is free software; you can redistribute it and/or
    00009  * modify it under the terms of the GNU Library General Public
    00010  * License as published by the Free Software Foundation; either
    00011  * version 2 of the License, or (at your option) any later version.
    00012  *
    00013  * This library is distributed in the hope that it will be useful,
    00014  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    00015  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    00016  * Library General Public License for more details.
    00017  *
    00018  * You should have received a copy of the GNU Library General Public License
    00019  * along with this library; see the file COPYING.LIB.  If not, write to
    00020  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    00021  * Boston, MA 02111-1307, USA.
    00022  *
    00023  * $Id: render_style.h,v 1.78.2.4 2003/08/17 14:38:51 mueller Exp $
    00024  */
    00025 #ifndef RENDERSTYLE_H
    00026 #define RENDERSTYLE_H
    00027
    00028 /*
    00029  * WARNING:
    00030  * --------
    00031  *
    00032  * The order of the values in the enums have to agree with the order specified
    00033  * in cssvalues.in, otherwise some optimizations in the parser will fail,
    00034  * and produce invaliud results.
    00035  */
    00036
    00037 #include <qcolor.h>
    00038 #include <qfont.h>
    00039 #include <qfontmetrics.h>
    00040 #include <qptrlist.h>
    00041 #include <qpalette.h>
    00042 #include <qapplication.h>
    00043
    00044 #include "dom/dom_misc.h"
    00045 #include "misc/khtmllayout.h"
    00046 #include "misc/shared.h"
    00047 #include "rendering/font.h"
    00048
    00049 #include <assert.h>
    00050
    00051 #define SET_VAR(group,variable,value) \
    00052     if (!(group->variable == value)) \
    00053         group.access()->variable = value;
    00054
    00055 namespace DOM {
    00056     class DOMStringImpl;
    00057 }
    00058
    00059 namespace khtml {
    00060
    00061     class CachedImage;
    00062     class CachedObject;
    00063
    00064 template <class DATA>
    00065 class DataRef
    00066 {
    00067 public:
    00068
    00069     DataRef()
    00070     {
    00071         data=0;
    00072     }
    00073     DataRef( const DataRef<DATA> &d )
    00074     {
    00075         data = d.data;
    00076         data->ref();
    00077     }
    00078
    00079     ~DataRef()
    00080     {
    00081         if(data) data->deref();
    00082     }
    00083
    00084     const DATA* operator->() const
    00085     {
    00086         return data;
    00087     }
    00088
    00089     const DATA* get() const
    00090     {
    00091         return data;
    00092     }
    00093
    00094
    00095     DATA* access()
    00096     {
    00097         if (!data->hasOneRef())
    00098         {
    00099             data->deref();
    00100             data = new DATA(*data);
    00101             data->ref();
    00102         }
    00103         return data;
    00104     }
    00105
    00106     void init()
    00107     {
    00108         data = new DATA;
    00109         data->ref();
    00110     }
    00111
    00112     DataRef<DATA>& operator=(const DataRef<DATA>& d)
    00113     {
    00114         if (data==d.data)
    00115             return *this;
    00116         if (data)
    00117             data->deref();
    00118         data = d.data;
    00119
    00120         data->ref();
    00121
    00122         return *this;
    00123     }
    00124
    00125     bool operator == ( const DataRef<DATA> &o ) const {
    00126         return (*data == *(o.data) );
    00127     }
    00128     bool operator != ( const DataRef<DATA> &o ) const {
    00129         return (*data != *(o.data) );
    00130     }
    00131
    00132 private:
    00133     DATA* data;
    00134 };
    00135
    00136
    00137 //------------------------------------------------
    00138
    00139 //------------------------------------------------
    00140 // Box model attributes. Not inherited.
    00141
    00142 struct LengthBox
    00143 {
    00144     LengthBox()
    00145     {
    00146     }
    00147     LengthBox( LengthType t )
    00148         : left( t ), right ( t ), top( t ), bottom( t ) {}
    00149
    00150     Length left;
    00151     Length right;
    00152     Length top;
    00153     Length bottom;
    00154     Length& operator=(Length& len)
    00155     {
    00156         left=len;
    00157         right=len;
    00158         top=len;
    00159         bottom=len;
    00160         return len;
    00161     }
    00162
    00163     bool operator==(const LengthBox& o) const
    00164     {
    00165         return left==o.left && right==o.right && top==o.top && bottom==o.bottom;
    00166     }
    00167
    00168
    00169     bool nonZero() const { return left.value() || right.value() || top.value() || bottom.value(); }
    00170 };
    00171
    00172
    00173
    00174 enum EPosition {
    00175     STATIC, RELATIVE, ABSOLUTE, FIXED
    00176 };
    00177
    00178 enum EFloat {
    00179     FNONE = 0, FLEFT, FRIGHT
    00180 };
    00181
    00182
    00183 //------------------------------------------------
    00184 // Border attributes. Not inherited.
    00185
    00186
    00187 enum EBorderStyle {
    00188     BNONE, BHIDDEN, DOTTED, DASHED, DOUBLE, SOLID,
    00189     OUTSET, INSET, GROOVE, RIDGE
    00190 };
    00191
    00192 class BorderValue
    00193 {
    00194 public:
    00195     BorderValue()
    00196     {
    00197         width = 3; // medium is default value
    00198         style = BNONE;
    00199     }
    00200     QColor color;
    00201     unsigned short width : 12;
    00202     EBorderStyle style : 4;
    00203
    00204     bool nonZero() const
    00205     {
    00206       // rikkus: workaround for gcc 2.95.3
    00207       return width!=0 && !(style==BNONE);
    00208     }
    00209
    00210     bool operator==(const BorderValue& o) const
    00211     {
    00212         return width==o.width && style==o.style && color==o.color;
    00213     }
    00214
    00215 };
    00216
    00217 class BorderData : public Shared<BorderData>
    00218 {
    00219 public:
    00220     BorderValue left;
    00221     BorderValue right;
    00222     BorderValue top;
    00223     BorderValue bottom;
    00224
    00225     bool hasBorder() const
    00226     {
    00227         return left.nonZero() || right.nonZero() || top.nonZero() || bottom.nonZero();
    00228     }
    00229
    00230     bool operator==(const BorderData& o) const
    00231     {
    00232         return left==o.left && right==o.right && top==o.top && bottom==o.bottom;
    00233     }
    00234
    00235 };
    00236
    00237 class StyleSurroundData : public Shared<StyleSurroundData>
    00238 {
    00239 public:
    00240     StyleSurroundData();
    00241
    00242     StyleSurroundData(const StyleSurroundData& o );
    00243     bool operator==(const StyleSurroundData& o) const;
    00244     bool operator!=(const StyleSurroundData& o) const {
    00245         return !(*this == o);
    00246     }
    00247
    00248     LengthBox offset;
    00249     LengthBox margin;
    00250     LengthBox padding;
    00251     BorderData border;
    00252 };
    00253
    00254
    00255 //------------------------------------------------
    00256 // Box attributes. Not inherited.
    00257
    00258
    00259 const int ZAUTO=0;
    00260
    00261 class StyleBoxData : public Shared<StyleBoxData>
    00262 {
    00263 public:
    00264     StyleBoxData();
    00265
    00266     StyleBoxData(const StyleBoxData& o );
    00267
    00268
    00269     // copy and assignment
    00270 //    StyleBoxData(const StyleBoxData &other);
    00271 //    const StyleBoxData &operator = (const StyleBoxData &other);
    00272
    00273     bool operator==(const StyleBoxData& o) const;
    00274     bool operator!=(const StyleBoxData& o) const {
    00275         return !(*this == o);
    00276     }
    00277
    00278     Length width;
    00279     Length height;
    00280
    00281     Length min_width;
    00282     Length max_width;
    00283
    00284     Length min_height;
    00285     Length max_height;
    00286
    00287     Length vertical_align;
    00288
    00289     int z_index;
    00290 };
    00291
    00292 //------------------------------------------------
    00293 // Random visual rendering model attributes. Not inherited.
    00294
    00295 enum EOverflow {
    00296     OVISIBLE, OHIDDEN, SCROLL, AUTO
    00297 };
    00298
    00299 enum EVerticalAlign {
    00300     BASELINE, MIDDLE, SUB, SUPER, TEXT_TOP,
    00301     TEXT_BOTTOM, TOP, BOTTOM, BASELINE_MIDDLE, LENGTH
    00302 };
    00303
    00304 enum EClear{
    00305     CNONE = 0, CLEFT = 1, CRIGHT = 2, CBOTH = 3
    00306 };
    00307
    00308 enum ETableLayout {
    00309     TAUTO, TFIXED
    00310 };
    00311
    00312 enum EUnicodeBidi {
    00313     UBNormal, Embed, Override
    00314 };
    00315
    00316 class StyleVisualData : public Shared<StyleVisualData>
    00317 {
    00318 public:
    00319     StyleVisualData();
    00320
    00321     ~StyleVisualData();
    00322
    00323     StyleVisualData(const StyleVisualData& o );
    00324
    00325     bool operator==( const StyleVisualData &o ) const {
    00326         return ( clip == o.clip &&
    00327                  colspan == o.colspan &&
    00328                  counter_increment == o.counter_increment &&
    00329                  counter_reset == o.counter_reset &&
    00330                  palette == o.palette );
    00331     }
    00332     bool operator!=( const StyleVisualData &o ) const {
    00333         return !(*this == o);
    00334     }
    00335
    00336     LengthBox clip;
    00337
    00338     short colspan; // for html, not a css2 attribute
    00339
    00340     short counter_increment; //ok, so these are not visual mode spesific
    00341     short counter_reset;     //can't go to inherited, since these are not inherited
    00342
    00343     QPalette palette;      //widget styling with IE attributes
    00344
    00345 };
    00346
    00347 //------------------------------------------------
    00348 enum EBackgroundRepeat {
    00349     REPEAT, REPEAT_X, REPEAT_Y, NO_REPEAT
    00350 };
    00351
    00352
    00353
    00354 class StyleBackgroundData : public Shared<StyleBackgroundData>
    00355 {
    00356 public:
    00357     StyleBackgroundData();
    00358     ~StyleBackgroundData() {}
    00359     StyleBackgroundData(const StyleBackgroundData& o );
    00360
    00361     bool operator==(const StyleBackgroundData& o) const;
    00362     bool operator!=(const StyleBackgroundData &o) const {
    00363         return !(*this == o);
    00364     }
    00365
    00366     QColor color;
    00367     CachedImage *image;
    00368
    00369     Length x_position;
    00370     Length y_position;
    00371     BorderValue outline;
    00372 };
    00373
    00374
    00375 //------------------------------------------------
    00376 // Inherited attributes.
    00377 //
    00378 // the inherited-decoration and inherited-shadow attributes
    00379 // are inherited from the
    00380 // first parent which is block level
    00381 //
    00382 // this applies to decoration_color too
    00383
    00384 enum EWhiteSpace {
    00385     NORMAL, PRE, NOWRAP
    00386 };
    00387
    00388 enum ETextAlign {
    00389     TAAUTO, LEFT, RIGHT, CENTER, JUSTIFY, KONQ_CENTER
    00390 };
    00391
    00392 enum ETextTransform {
    00393     CAPITALIZE, UPPERCASE, LOWERCASE, TTNONE
    00394 };
    00395
    00396 enum EDirection {
    00397     LTR, RTL
    00398 };
    00399
    00400 enum ETextDecoration {
    00401     TDNONE = 0x0 , UNDERLINE = 0x1, OVERLINE = 0x2, LINE_THROUGH= 0x4, BLINK = 0x8
    00402 };
    00403
    00404 class StyleInheritedData : public Shared<StyleInheritedData>
    00405 {
    00406 public:
    00407     StyleInheritedData();
    00408     ~StyleInheritedData();
    00409     StyleInheritedData(const StyleInheritedData& o );
    00410
    00411     bool operator==(const StyleInheritedData& o) const;
    00412     bool operator != ( const StyleInheritedData &o ) const {
    00413         return !(*this == o);
    00414     }
    00415
    00416     Length indent;
    00417     // could be packed in a short but doesn't
    00418     // make a difference currently because of padding
    00419     Length line_height;
    00420
    00421     CachedImage *style_image;
    00422
    00423     khtml::Font font;
    00424     QColor color;
    00425     QColor decoration_color;
    00426
    00427     short border_spacing;
    00428 };
    00429
    00430
    00431 enum EEmptyCell {
    00432     SHOW, HIDE
    00433 };
    00434
    00435 enum ECaptionSide
    00436 {
    00437     CAPTOP, CAPBOTTOM
    00438 };
    00439
    00440
    00441 enum EListStyleType {
    00442      DISC, CIRCLE, SQUARE, LDECIMAL, DECIMAL_LEADING_ZERO,
    00443      LOWER_ROMAN, UPPER_ROMAN, LOWER_GREEK,
    00444      LOWER_ALPHA, LOWER_LATIN, UPPER_ALPHA, UPPER_LATIN,
    00445      HEBREW, ARMENIAN, GEORGIAN, CJK_IDEOGRAPHIC,
    00446      HIRAGANA, KATAKANA, HIRAGANA_IROHA, KATAKANA_IROHA, LNONE
    00447 };
    00448
    00449 enum EListStylePosition { OUTSIDE, INSIDE };
    00450
    00451 enum EVisibility { VISIBLE, HIDDEN, COLLAPSE };
    00452
    00453 enum ECursor {
    00454     CURSOR_AUTO, CURSOR_CROSS, CURSOR_DEFAULT, CURSOR_POINTER, CURSOR_PROGRESS,  CURSOR_MOVE,
    00455     CURSOR_E_RESIZE, CURSOR_NE_RESIZE, CURSOR_NW_RESIZE, CURSOR_N_RESIZE, CURSOR_SE_RESIZE, CURSOR_SW_RESIZE,
    00456     CURSOR_S_RESIZE, CURSOR_W_RESIZE, CURSOR_TEXT, CURSOR_WAIT, CURSOR_HELP
    00457 };
    00458
    00459 enum EFontVariant {
    00460     FVNORMAL, SMALL_CAPS
    00461 };
    00462
    00463 enum ContentType {
    00464     CONTENT_NONE, CONTENT_OBJECT, CONTENT_TEXT,
    00465     CONTENT_ATTR
    00466 };
    00467
    00468 struct ContentData {
    00469     ~ContentData();
    00470     void clearContent();
    00471
    00472     ContentType _contentType;
    00473
    00474     union {
    00475         CachedObject* object;
    00476         DOM::DOMStringImpl* text;
    00477         // counters...
    00478     } _content ;
    00479 };
    00480
    00481 //------------------------------------------------
    00482
    00483 enum EDisplay {
    00484     INLINE, BLOCK, LIST_ITEM, RUN_IN, INLINE_BLOCK,
    00485     TABLE, INLINE_TABLE, TABLE_ROW_GROUP,
    00486     TABLE_HEADER_GROUP, TABLE_FOOTER_GROUP, TABLE_ROW,
    00487     TABLE_COLUMN_GROUP, TABLE_COLUMN, TABLE_CELL,
    00488     TABLE_CAPTION, NONE
    00489 };
    00490
    00491 class RenderStyle : public Shared<RenderStyle>
    00492 {
    00493     friend class CSSStyleSelector;
    00494 public:
    00495     static void cleanup();
    00496
    00497     // static pseudo styles. Dynamic ones are produced on the fly.
    00498     enum PseudoId { NOPSEUDO, FIRST_LINE, FIRST_LETTER, BEFORE, AFTER };
    00499
    00500 protected:
    00501
    00502 // !START SYNC!: Keep this in sync with the copy constructor in render_style.cpp
    00503
    00504     // inherit
    00505     struct InheritedFlags {
    00506     // 32 bit inherited, don't add to the struct, or the operator will break.
    00507         bool operator==( const InheritedFlags &other ) const
    00508         {   return _iflags == other._iflags;   }
    00509         bool operator!=( const InheritedFlags &other ) const
    00510         {   return _iflags != other._iflags;   }
    00511
    00512         union {
    00513             struct {
    00514                 EEmptyCell _empty_cells : 1 ;
    00515                 ECaptionSide _caption_side : 1;
    00516                 EListStyleType _list_style_type : 5 ;
    00517                 EListStylePosition _list_style_position :1;
    00518
    00519                 EVisibility _visibility : 2;
    00520                 ETextAlign _text_align : 3;
    00521                 ETextTransform _text_transform : 2;
    00522                 unsigned _text_decoration : 4;
    00523                 ECursor _cursor_style : 5;
    00524
    00525                 EDirection _direction : 1;
    00526                 bool _border_collapse : 1 ;
    00527                 EWhiteSpace _white_space : 2;
    00528                 EFontVariant _font_variant : 1;
    00529                 // non CSS2 inherited
    00530                 bool _visuallyOrdered : 1;
    00531                 bool _htmlHacks :1;
    00532                 unsigned _unused : 1;
    00533             } f;
    00534             Q_UINT32 _iflags;
    00535         };
    00536     } inherited_flags;
    00537
    00538 // don't inherit
    00539     struct NonInheritedFlags {
    00540         bool operator==( const NonInheritedFlags &other ) const
    00541         {   return _niflags == other._niflags;   }
    00542         bool operator!=( const NonInheritedFlags &other ) const
    00543         {   return _niflags != other._niflags;   }
    00544
    00545         union {
    00546             struct {
    00547                 EDisplay _display : 4;
    00548                 EBackgroundRepeat _bg_repeat : 2;
    00549                 bool _bg_attachment : 1;
    00550                 EOverflow _overflow : 4 ;
    00551                 EVerticalAlign _vertical_align : 4;
    00552                 EClear _clear : 2;
    00553                 EPosition _position : 2;
    00554                 EFloat _floating : 2;
    00555                 ETableLayout _table_layout : 1;
    00556                 bool _flowAroundFloats :1;
    00557
    00558                 PseudoId _styleType : 3;
    00559                 bool _hasHover : 1;
    00560                 bool _hasActive : 1;
    00561                 bool _clipSpecified : 1;
    00562                 EUnicodeBidi _unicodeBidi : 2;
    00563                 unsigned _unused : 1;
    00564             } f;
    00565             Q_UINT32 _niflags;
    00566         };
    00567     } noninherited_flags;
    00568
    00569 // non-inherited attributes
    00570     DataRef<StyleBoxData> box;
    00571     DataRef<StyleVisualData> visual;
    00572     DataRef<StyleBackgroundData> background;
    00573     DataRef<StyleSurroundData> surround;
    00574
    00575 // inherited attributes
    00576     DataRef<StyleInheritedData> inherited;
    00577
    00578 // list of associated pseudo styles
    00579     RenderStyle* pseudoStyle;
    00580
    00581     // added this here, so we can get rid of the vptr in this class.
    00582     // makes up for the same size.
    00583     ContentData *content;
    00584 // !END SYNC!
    00585
    00586 // static default style
    00587     static RenderStyle* _default;
    00588
    00589 private:
    00590     RenderStyle(const RenderStyle*) {}
    00591
    00592 protected:
    00593     void setBitDefaults()
    00594     {
    00595         inherited_flags.f._empty_cells = SHOW;
    00596         inherited_flags.f._caption_side = CAPTOP;
    00597         inherited_flags.f._list_style_type = DISC;
    00598         inherited_flags.f._list_style_position = OUTSIDE;
    00599         inherited_flags.f._visibility = VISIBLE;
    00600         inherited_flags.f._text_align = TAAUTO;
    00601         inherited_flags.f._text_transform = TTNONE;
    00602         inherited_flags.f._text_decoration = TDNONE;
    00603         inherited_flags.f._cursor_style = CURSOR_AUTO;
    00604         inherited_flags.f._direction = LTR;
    00605         inherited_flags.f._border_collapse = true;
    00606         inherited_flags.f._white_space = NORMAL;
    00607         inherited_flags.f._font_variant = FVNORMAL;
    00608         inherited_flags.f._visuallyOrdered = false;
    00609         inherited_flags.f._htmlHacks=false;
    00610         inherited_flags.f._unused = 0;
    00611
    00612         noninherited_flags.f._display = INLINE;
    00613         noninherited_flags.f._bg_repeat = REPEAT;
    00614         noninherited_flags.f._bg_attachment = SCROLL;
    00615         noninherited_flags.f._overflow = OVISIBLE;
    00616         noninherited_flags.f._vertical_align = BASELINE;
    00617         noninherited_flags.f._clear = CNONE;
    00618         noninherited_flags.f._position = STATIC;
    00619         noninherited_flags.f._floating = FNONE;
    00620         noninherited_flags.f._table_layout = TAUTO;
    00621         noninherited_flags.f._flowAroundFloats=false;
    00622         noninherited_flags.f._styleType = NOPSEUDO;
    00623         noninherited_flags.f._hasHover = false;
    00624         noninherited_flags.f._hasActive = false;
    00625         noninherited_flags.f._clipSpecified = false;
    00626         noninherited_flags.f._unicodeBidi = UBNormal;
    00627         noninherited_flags.f._unused = 0;
    00628     }
    00629
    00630 public:
    00631
    00632     RenderStyle();
    00633     // used to create the default style.
    00634     RenderStyle(bool);
    00635     RenderStyle(const RenderStyle&);
    00636
    00637     ~RenderStyle();
    00638
    00639     void inheritFrom(const RenderStyle* inheritParent);
    00640
    00641     PseudoId styleType() { return  noninherited_flags.f._styleType; }
    00642
    00643     RenderStyle* getPseudoStyle(PseudoId pi);
    00644     RenderStyle* addPseudoStyle(PseudoId pi);
    00645     void removePseudoStyle(PseudoId pi);
    00646
    00647     bool hasHover() const { return  noninherited_flags.f._hasHover; }
    00648     bool hasActive() const { return  noninherited_flags.f._hasActive; }
    00649
    00650     void setHasHover() {  noninherited_flags.f._hasHover = true; }
    00651     void setHasActive() {  noninherited_flags.f._hasActive = true; }
    00652
    00653     bool operator==(const RenderStyle& other) const;
    00654     bool        isFloating() const { return !(noninherited_flags.f._floating == FNONE); }
    00655     bool        hasMargin() const { return surround->margin.nonZero(); }
    00656     bool        hasPadding() const { return surround->padding.nonZero(); }
    00657     bool        hasBorder() const { return surround->border.hasBorder(); }
    00658     bool        hasOffset() const { return surround->offset.nonZero(); }
    00659
    00660     bool visuallyOrdered() const { return inherited_flags.f._visuallyOrdered; }
    00661     void setVisuallyOrdered(bool b) {  inherited_flags.f._visuallyOrdered = b; }
    00662
    00663 // attribute getter methods
    00664
    00665     EDisplay    display() const { return noninherited_flags.f._display; }
    00666
    00667     Length      left() const {  return surround->offset.left; }
    00668     Length      right() const {  return surround->offset.right; }
    00669     Length      top() const {  return surround->offset.top; }
    00670     Length      bottom() const {  return surround->offset.bottom; }
    00671
    00672     EPosition   position() const { return  noninherited_flags.f._position; }
    00673     EFloat      floating() const { return  noninherited_flags.f._floating; }
    00674
    00675     Length      width() const { return box->width; }
    00676     Length      height() const { return box->height; }
    00677     Length      minWidth() const { return box->min_width; }
    00678     Length      maxWidth() const { return box->max_width; }
    00679     Length      minHeight() const { return box->min_height; }
    00680     Length      maxHeight() const { return box->max_height; }
    00681
    00682     unsigned short  borderLeftWidth() const
    00683     { if( surround->border.left.style == BNONE) return 0; return surround->border.left.width; }
    00684     EBorderStyle    borderLeftStyle() const { return surround->border.left.style; }
    00685     const QColor &  borderLeftColor() const { return surround->border.left.color; }
    00686     unsigned short  borderRightWidth() const
    00687     { if (surround->border.right.style == BNONE) return 0; return surround->border.right.width; }
    00688     EBorderStyle    borderRightStyle() const {  return surround->border.right.style; }
    00689     const QColor &          borderRightColor() const {  return surround->border.right.color; }
    00690     unsigned short  borderTopWidth() const
    00691     { if(surround->border.top.style == BNONE) return 0; return surround->border.top.width; }
    00692     EBorderStyle    borderTopStyle() const {return surround->border.top.style; }
    00693     const QColor &  borderTopColor() const {  return surround->border.top.color; }
    00694     unsigned short  borderBottomWidth() const
    00695     { if(surround->border.bottom.style == BNONE) return 0; return surround->border.bottom.width; }
    00696     EBorderStyle    borderBottomStyle() const {  return surround->border.bottom.style; }
    00697     const QColor &          borderBottomColor() const {  return surround->border.bottom.color; }
    00698
    00699     unsigned short  outlineWidth() const
    00700     { if(background->outline.style == BNONE) return 0; return background->outline.width; }
    00701     EBorderStyle    outlineStyle() const {  return background->outline.style; }
    00702     const QColor &          outlineColor() const {  return background->outline.color; }
    00703
    00704     EOverflow overflow() const { return  noninherited_flags.f._overflow; }
    00705     EVisibility visibility() const { return inherited_flags.f._visibility; }
    00706     EVerticalAlign verticalAlign() const { return  noninherited_flags.f._vertical_align; }
    00707     Length verticalAlignLength() const { return box->vertical_align; }
    00708
    00709     Length clipLeft() const { return visual->clip.left; }
    00710     Length clipRight() const { return visual->clip.right; }
    00711     Length clipTop() const { return visual->clip.top; }
    00712     Length clipBottom() const { return visual->clip.bottom; }
    00713     bool clipSpecified() const { return noninherited_flags.f._clipSpecified; }
    00714
    00715     EUnicodeBidi unicodeBidi() const { return noninherited_flags.f._unicodeBidi; }
    00716
    00717     EClear clear() const { return  noninherited_flags.f._clear; }
    00718     ETableLayout tableLayout() const { return  noninherited_flags.f._table_layout; }
    00719
    00720     short colSpan() const { return visual->colspan; }
    00721
    00722     const QFont & font() const { return inherited->font.f; }
    00723     // use with care. call font->update() after modifications
    00724     const Font &htmlFont() { return inherited->font; }
    00725     const QFontMetrics & fontMetrics() const { return inherited->font.fm; }
    00726
    00727     const QColor & color() const { return inherited->color; }
    00728     Length textIndent() const { return inherited->indent; }
    00729     ETextAlign textAlign() const { return inherited_flags.f._text_align; }
    00730     ETextTransform textTransform() const { return inherited_flags.f._text_transform; }
    00731     unsigned textDecoration() const { return inherited_flags.f._text_decoration; }
    00732     const QColor &textDecorationColor() const { return inherited->decoration_color; }
    00733     int wordSpacing() const { return inherited->font.wordSpacing; }
    00734     int letterSpacing() const { return inherited->font.letterSpacing; }
    00735
    00736     EDirection direction() const { return inherited_flags.f._direction; }
    00737     Length lineHeight() const { return inherited->line_height; }
    00738
    00739     EWhiteSpace whiteSpace() const { return inherited_flags.f._white_space; }
    00740
    00741
    00742     const QColor & backgroundColor() const { return background->color; }
    00743     CachedImage *backgroundImage() const { return background->image; }
    00744     EBackgroundRepeat backgroundRepeat() const { return  noninherited_flags.f._bg_repeat; }
    00745     bool backgroundAttachment() const { return  noninherited_flags.f._bg_attachment; }
    00746     Length backgroundXPosition() const { return background->x_position; }
    00747     Length backgroundYPosition() const { return background->y_position; }
    00748
    00749     // returns true for collapsing borders, false for separate borders
    00750     bool borderCollapse() const { return inherited_flags.f._border_collapse; }
    00751     short borderSpacing() const { return inherited->border_spacing; }
    00752     EEmptyCell emptyCells() const { return inherited_flags.f._empty_cells; }
    00753     ECaptionSide captionSide() const { return inherited_flags.f._caption_side; }
    00754
    00755     short counterIncrement() const { return visual->counter_increment; }
    00756     short counterReset() const { return visual->counter_reset; }
    00757
    00758     EListStyleType listStyleType() const { return inherited_flags.f._list_style_type; }
    00759     CachedImage *listStyleImage() const { return inherited->style_image; }
    00760     EListStylePosition listStylePosition() const { return inherited_flags.f._list_style_position; }
    00761
    00762     Length marginTop() const { return surround->margin.top; }
    00763     Length marginBottom() const {  return surround->margin.bottom; }
    00764     Length marginLeft() const {  return surround->margin.left; }
    00765     Length marginRight() const {  return surround->margin.right; }
    00766
    00767     Length paddingTop() const {  return surround->padding.top; }
    00768     Length paddingBottom() const {  return surround->padding.bottom; }
    00769     Length paddingLeft() const { return surround->padding.left; }
    00770     Length paddingRight() const {  return surround->padding.right; }
    00771
    00772     ECursor cursor() const { return inherited_flags.f._cursor_style; }
    00773     EFontVariant fontVariant() { return inherited_flags.f._font_variant; }
    00774
    00775 // attribute setter methods
    00776
    00777     void setDisplay(EDisplay v) {  noninherited_flags.f._display = v; }
    00778     void setPosition(EPosition v) {  noninherited_flags.f._position = v; }
    00779     void setFloating(EFloat v) {  noninherited_flags.f._floating = v; }
    00780
    00781     void setLeft(Length v)  {  SET_VAR(surround,offset.left,v) }
    00782     void setRight(Length v) {  SET_VAR(surround,offset.right,v) }
    00783     void setTop(Length v)   {  SET_VAR(surround,offset.top,v) }
    00784     void setBottom(Length v){  SET_VAR(surround,offset.bottom,v) }
    00785
    00786     void setWidth(Length v)  { SET_VAR(box,width,v) }
    00787     void setHeight(Length v) { SET_VAR(box,height,v) }
    00788
    00789     void setMinWidth(Length v)  { SET_VAR(box,min_width,v) }
    00790     void setMaxWidth(Length v)  { SET_VAR(box,max_width,v) }
    00791     void setMinHeight(Length v) { SET_VAR(box,min_height,v) }
    00792     void setMaxHeight(Length v) { SET_VAR(box,max_height,v) }
    00793
    00794     void setBorderLeftWidth(unsigned short v)   {  SET_VAR(surround,border.left.width,v) }
    00795     void setBorderLeftStyle(EBorderStyle v)     {  SET_VAR(surround,border.left.style,v) }
    00796     void setBorderLeftColor(const QColor & v)   {  SET_VAR(surround,border.left.color,v) }
    00797     void setBorderRightWidth(unsigned short v)  {  SET_VAR(surround,border.right.width,v) }
    00798     void setBorderRightStyle(EBorderStyle v)    {  SET_VAR(surround,border.right.style,v) }
    00799     void setBorderRightColor(const QColor & v)  {  SET_VAR(surround,border.right.color,v) }
    00800     void setBorderTopWidth(unsigned short v)    {  SET_VAR(surround,border.top.width,v) }
    00801     void setBorderTopStyle(EBorderStyle v)      {  SET_VAR(surround,border.top.style,v) }
    00802     void setBorderTopColor(const QColor & v)    {  SET_VAR(surround,border.top.color,v) }
    00803     void setBorderBottomWidth(unsigned short v) {  SET_VAR(surround,border.bottom.width,v) }
    00804     void setBorderBottomStyle(EBorderStyle v)   {  SET_VAR(surround,border.bottom.style,v) }
    00805     void setBorderBottomColor(const QColor & v) {  SET_VAR(surround,border.bottom.color,v) }
    00806     void setOutlineWidth(unsigned short v) {  SET_VAR(background,outline.width,v) }
    00807     void setOutlineStyle(EBorderStyle v)   {  SET_VAR(background,outline.style,v) }
    00808     void setOutlineColor(const QColor & v) {  SET_VAR(background,outline.color,v) }
    00809
    00810     void setOverflow(EOverflow v) {  noninherited_flags.f._overflow = v; }
    00811     void setVisibility(EVisibility v) { inherited_flags.f._visibility = v; }
    00812     void setVerticalAlign(EVerticalAlign v) { noninherited_flags.f._vertical_align = v; }
    00813     void setVerticalAlignLength(Length l) { SET_VAR(box, vertical_align, l ) }
    00814
    00815     void setClipLeft(Length v) { SET_VAR(visual,clip.left,v) }
    00816     void setClipRight(Length v) { SET_VAR(visual,clip.right,v) }
    00817     void setClipTop(Length v) { SET_VAR(visual,clip.top,v) }
    00818     void setClipBottom(Length v) { SET_VAR(visual,clip.bottom,v) }
    00819     void setClip( Length top, Length right, Length bottom, Length left );
    00820     void setClipSpecified( bool b ) { noninherited_flags.f._clipSpecified = b; }
    00821
    00822     void setUnicodeBidi( EUnicodeBidi b ) { noninherited_flags.f._unicodeBidi = b; }
    00823
    00824     void setClear(EClear v) {  noninherited_flags.f._clear = v; }
    00825     void setTableLayout(ETableLayout v) {  noninherited_flags.f._table_layout = v; }
    00826     void ssetColSpan(short v) { SET_VAR(visual,colspan,v) }
    00827
    00828     bool setFontDef(const khtml::FontDef & v) {
    00829         // bah, this doesn't compare pointers. broken! (Dirk)
    00830         if (!(inherited->font.fontDef == v)) {
    00831             inherited.access()->font = Font( v );
    00832             return true;
    00833         }
    00834         return false;
    00835     }
    00836
    00837     void setColor(const QColor & v) { SET_VAR(inherited,color,v) }
    00838     void setTextIndent(Length v) { SET_VAR(inherited,indent,v) }
    00839     void setTextAlign(ETextAlign v) { inherited_flags.f._text_align = v; }
    00840     void setTextTransform(ETextTransform v) { inherited_flags.f._text_transform = v; }
    00841     void setTextDecoration(unsigned v) { inherited_flags.f._text_decoration = v; }
    00842     void setTextDecorationColor(const QColor &v) { SET_VAR(inherited,decoration_color,v) }
    00843     void setDirection(EDirection v) { inherited_flags.f._direction = v; }
    00844     void setLineHeight(Length v) { SET_VAR(inherited,line_height,v) }
    00845
    00846     void setWhiteSpace(EWhiteSpace v) { inherited_flags.f._white_space = v; }
    00847
    00848     void setWordSpacing(int v) { SET_VAR(inherited,font.wordSpacing,v) }
    00849     void setLetterSpacing(int v) { SET_VAR(inherited,font.letterSpacing,v) }
    00850
    00851     void setBackgroundColor(const QColor & v) {  SET_VAR(background,color,v) }
    00852     void setBackgroundImage(CachedImage *v) {  SET_VAR(background,image,v) }
    00853     void setBackgroundRepeat(EBackgroundRepeat v) {  noninherited_flags.f._bg_repeat = v; }
    00854     void setBackgroundAttachment(bool scroll) {  noninherited_flags.f._bg_attachment = scroll; }
    00855     void setBackgroundXPosition(Length v) {  SET_VAR(background,x_position,v) }
    00856     void setBackgroundYPosition(Length v) {  SET_VAR(background,y_position,v) }
    00857
    00858     void setBorderCollapse(bool collapse) { inherited_flags.f._border_collapse = collapse; }
    00859     void setBorderSpacing(short v) { SET_VAR(inherited,border_spacing,v) }
    00860     void setEmptyCells(EEmptyCell v) { inherited_flags.f._empty_cells = v; }
    00861     void setCaptionSide(ECaptionSide v) { inherited_flags.f._caption_side = v; }
    00862
    00863
    00864     void setCounterIncrement(short v) {  SET_VAR(visual,counter_increment,v) }
    00865     void setCounterReset(short v) {  SET_VAR(visual,counter_reset,v) }
    00866
    00867     void setListStyleType(EListStyleType v) { inherited_flags.f._list_style_type = v; }
    00868     void setListStyleImage(CachedImage *v) {  SET_VAR(inherited,style_image,v)}
    00869     void setListStylePosition(EListStylePosition v) { inherited_flags.f._list_style_position = v; }
    00870
    00871     void setMarginTop(Length v)     {  SET_VAR(surround,margin.top,v) }
    00872     void setMarginBottom(Length v)  {  SET_VAR(surround,margin.bottom,v) }
    00873     void setMarginLeft(Length v)    {  SET_VAR(surround,margin.left,v) }
    00874     void setMarginRight(Length v)   {  SET_VAR(surround,margin.right,v) }
    00875
    00876     void setPaddingTop(Length v)    {  SET_VAR(surround,padding.top,v) }
    00877     void setPaddingBottom(Length v) {  SET_VAR(surround,padding.bottom,v) }
    00878     void setPaddingLeft(Length v)   {  SET_VAR(surround,padding.left,v) }
    00879     void setPaddingRight(Length v)  {  SET_VAR(surround,padding.right,v) }
    00880
    00881     void setCursor( ECursor c ) { inherited_flags.f._cursor_style = c; }
    00882     void setFontVariant( EFontVariant f ) { inherited_flags.f._font_variant = f; }
    00883
    00884     bool htmlHacks() const { return inherited_flags.f._htmlHacks; }
    00885     void setHtmlHacks(bool b=true) { inherited_flags.f._htmlHacks = b; }
    00886
    00887     bool flowAroundFloats() const { return  noninherited_flags.f._flowAroundFloats; }
    00888     void setFlowAroundFloats(bool b=true) {  noninherited_flags.f._flowAroundFloats = b; }
    00889
    00890     int zIndex() const { return box->z_index; }
    00891     void setZIndex(int v) { SET_VAR(box,z_index,v) }
    00892
    00893     QPalette palette() const { return visual->palette; }
    00894     void setPaletteColor(QPalette::ColorGroup g, QColorGroup::ColorRole r, const QColor& c);
    00895     void resetPalette() // Called when the desktop color scheme changes.
    00896     {
    00897         const_cast<StyleVisualData *>(visual.get())->palette = QApplication::palette();
    00898     }
    00899
    00900
    00901     ContentType contentType() { return content ? content->_contentType : CONTENT_NONE; }
    00902
    00903     DOM::DOMStringImpl* contentText()
    00904     {
    00905         if (content && content->_contentType==CONTENT_TEXT)
    00906             return content->_content.text;
    00907         else
    00908             return 0;
    00909     }
    00910
    00911     CachedObject* contentObject()
    00912     {
    00913         if (content && content->_contentType==CONTENT_OBJECT)
    00914             return content->_content.object;
    00915         else
    00916             return 0;
    00917     }
    00918
    00919     void setContent(DOM::DOMStringImpl* s);
    00920     void setContent(CachedObject* o);
    00921
    00922     bool inheritedNotEqual( RenderStyle *other ) const;
    00923
    00924     enum Diff { Equal, NonVisible = Equal, Visible, Position, Layout, CbLayout };
    00925     Diff diff( const RenderStyle *other ) const;
    00926 };
    00927
    00928
    00929 } // namespace
    00930
    00931 #endif
    00932

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:34:42 2004 by doxygen 1.3.4 written by Dimitri van Heesch, © 1997-2001