khtml Library API Documentation

css_valueimpl.cpp

00001 
00022 #include "dom/css_value.h"
00023 #include "dom/dom_exception.h"
00024 #include "dom/dom_string.h"
00025 
00026 #include "css/css_valueimpl.h"
00027 #include "css/css_ruleimpl.h"
00028 #include "css/css_stylesheetimpl.h"
00029 #include "css/cssparser.h"
00030 #include "css/cssproperties.h"
00031 #include "css/cssvalues.h"
00032 
00033 #include "xml/dom_stringimpl.h"
00034 #include "xml/dom_docimpl.h"
00035 
00036 #include "misc/loader.h"
00037 
00038 #include "rendering/render_style.h"
00039 
00040 #include <kdebug.h>
00041 #include <qregexp.h>
00042 #include <qpaintdevice.h>
00043 #include <qpaintdevicemetrics.h>
00044 
00045 // Hack for debugging purposes
00046 extern DOM::DOMString getPropertyName(unsigned short id);
00047 
00048 using namespace DOM;
00049 
00050 CSSStyleDeclarationImpl::CSSStyleDeclarationImpl(CSSRuleImpl *parent)
00051     : StyleBaseImpl(parent)
00052 {
00053     m_lstValues = 0;
00054     m_node = 0;
00055 }
00056 
00057 CSSStyleDeclarationImpl::CSSStyleDeclarationImpl(CSSRuleImpl *parent, QPtrList<CSSProperty> *lstValues)
00058     : StyleBaseImpl(parent)
00059 {
00060     m_lstValues = lstValues;
00061     m_node = 0;
00062 }
00063 
00064 CSSStyleDeclarationImpl&  CSSStyleDeclarationImpl::operator= (const CSSStyleDeclarationImpl& o)
00065 {
00066     // don't attach it to the same node, just leave the current m_node value
00067     delete m_lstValues;
00068     m_lstValues = 0;
00069     if (o.m_lstValues) {
00070         m_lstValues = new QPtrList<CSSProperty>;
00071         m_lstValues->setAutoDelete( true );
00072 
00073         QPtrListIterator<CSSProperty> lstValuesIt(*o.m_lstValues);
00074         for (lstValuesIt.toFirst(); lstValuesIt.current(); ++lstValuesIt)
00075             m_lstValues->append(new CSSProperty(*lstValuesIt.current()));
00076     }
00077 
00078     return *this;
00079 }
00080 
00081 CSSStyleDeclarationImpl::~CSSStyleDeclarationImpl()
00082 {
00083     delete m_lstValues;
00084     // we don't use refcounting for m_node, to avoid cyclic references (see ElementImpl)
00085 }
00086 
00087 DOMString CSSStyleDeclarationImpl::getPropertyValue( int propertyID ) const
00088 {
00089     if(!m_lstValues) return DOMString();
00090 
00091     CSSValueImpl* value = getPropertyCSSValue( propertyID );
00092     if ( value )
00093         return value->cssText();
00094 
00095     // Shorthand and 4-values properties
00096     switch ( propertyID ) {
00097     case CSS_PROP_BACKGROUND_POSITION:
00098     {
00099         // ## Is this correct? The code in cssparser.cpp is confusing
00100         const int properties[2] = { CSS_PROP_BACKGROUND_POSITION_X,
00101                                     CSS_PROP_BACKGROUND_POSITION_Y };
00102         return getShortHandValue( properties, 2 );
00103     }
00104     case CSS_PROP_BACKGROUND:
00105     {
00106         const int properties[5] = { CSS_PROP_BACKGROUND_IMAGE, CSS_PROP_BACKGROUND_REPEAT,
00107                                     CSS_PROP_BACKGROUND_ATTACHMENT, CSS_PROP_BACKGROUND_POSITION,
00108                                     CSS_PROP_BACKGROUND_COLOR };
00109         return getShortHandValue( properties, 5 );
00110     }
00111     case CSS_PROP_BORDER:
00112     {
00113         const int properties[3] = { CSS_PROP_BORDER_WIDTH, CSS_PROP_BORDER_STYLE,
00114                                     CSS_PROP_BORDER_COLOR };
00115         return getShortHandValue( properties, 3 );
00116     }
00117     case CSS_PROP_BORDER_TOP:
00118     {
00119         const int properties[3] = { CSS_PROP_BORDER_TOP_WIDTH, CSS_PROP_BORDER_TOP_STYLE,
00120                                     CSS_PROP_BORDER_TOP_COLOR};
00121         return getShortHandValue( properties, 3 );
00122     }
00123     case CSS_PROP_BORDER_RIGHT:
00124     {
00125         const int properties[3] = { CSS_PROP_BORDER_RIGHT_WIDTH, CSS_PROP_BORDER_RIGHT_STYLE,
00126                                     CSS_PROP_BORDER_RIGHT_COLOR};
00127         return getShortHandValue( properties, 3 );
00128     }
00129     case CSS_PROP_BORDER_BOTTOM:
00130     {
00131         const int properties[3] = { CSS_PROP_BORDER_BOTTOM_WIDTH, CSS_PROP_BORDER_BOTTOM_STYLE,
00132                                     CSS_PROP_BORDER_BOTTOM_COLOR};
00133         return getShortHandValue( properties, 3 );
00134     }
00135     case CSS_PROP_BORDER_LEFT:
00136     {
00137         const int properties[3] = { CSS_PROP_BORDER_LEFT_WIDTH, CSS_PROP_BORDER_LEFT_STYLE,
00138                                     CSS_PROP_BORDER_LEFT_COLOR};
00139         return getShortHandValue( properties, 3 );
00140     }
00141     case CSS_PROP_OUTLINE:
00142     {
00143         const int properties[3] = { CSS_PROP_OUTLINE_WIDTH, CSS_PROP_OUTLINE_STYLE,
00144                                     CSS_PROP_OUTLINE_COLOR };
00145         return getShortHandValue( properties, 3 );
00146     }
00147     case CSS_PROP_BORDER_COLOR:
00148     {
00149         const int properties[4] = { CSS_PROP_BORDER_TOP_COLOR, CSS_PROP_BORDER_RIGHT_COLOR,
00150                                     CSS_PROP_BORDER_BOTTOM_COLOR, CSS_PROP_BORDER_LEFT_COLOR };
00151         return get4Values( properties );
00152     }
00153     case CSS_PROP_BORDER_WIDTH:
00154     {
00155         const int properties[4] = { CSS_PROP_BORDER_TOP_WIDTH, CSS_PROP_BORDER_RIGHT_WIDTH,
00156                                     CSS_PROP_BORDER_BOTTOM_WIDTH, CSS_PROP_BORDER_LEFT_WIDTH };
00157         return get4Values( properties );
00158     }
00159     case CSS_PROP_BORDER_STYLE:
00160     {
00161         const int properties[4] = { CSS_PROP_BORDER_TOP_STYLE, CSS_PROP_BORDER_RIGHT_STYLE,
00162                                     CSS_PROP_BORDER_BOTTOM_STYLE, CSS_PROP_BORDER_LEFT_STYLE };
00163         return get4Values( properties );
00164     }
00165     case CSS_PROP_MARGIN:
00166     {
00167         const int properties[4] = { CSS_PROP_MARGIN_TOP, CSS_PROP_MARGIN_RIGHT,
00168                                     CSS_PROP_MARGIN_BOTTOM, CSS_PROP_MARGIN_LEFT };
00169         return get4Values( properties );
00170     }
00171     case CSS_PROP_PADDING:
00172     {
00173         const int properties[4] = { CSS_PROP_PADDING_TOP, CSS_PROP_PADDING_RIGHT,
00174                                     CSS_PROP_PADDING_BOTTOM, CSS_PROP_PADDING_LEFT };
00175         return get4Values( properties );
00176     }
00177     case CSS_PROP_LIST_STYLE:
00178     {
00179         const int properties[3] = { CSS_PROP_LIST_STYLE_TYPE, CSS_PROP_LIST_STYLE_POSITION,
00180                                     CSS_PROP_LIST_STYLE_IMAGE };
00181         return getShortHandValue( properties, 3 );
00182     }
00183     }
00184     //kdDebug() << k_funcinfo << "property not found:" << propertyID << endl;
00185     return DOMString();
00186 }
00187 
00188 DOMString CSSStyleDeclarationImpl::get4Values( const int* properties ) const
00189 {
00190     DOMString res;
00191     for ( int i = 0 ; i < 4 ; ++i ) {
00192         CSSValueImpl* value = getPropertyCSSValue( properties[i] );
00193         if ( !value ) { // apparently all 4 properties must be specified.
00194             return DOMString();
00195         }
00196         if ( i > 0 )
00197             res += " ";
00198         res += value->cssText();
00199     }
00200     return res;
00201 }
00202 
00203 DOMString CSSStyleDeclarationImpl::getShortHandValue( const int* properties, int number ) const
00204 {
00205     DOMString res;
00206     for ( int i = 0 ; i < number ; ++i ) {
00207         CSSValueImpl* value = getPropertyCSSValue( properties[i] );
00208         if ( value ) { // TODO provide default value if !value
00209             if ( !res.isNull() )
00210                 res += " ";
00211             res += value->cssText();
00212         }
00213     }
00214     return res;
00215 }
00216 
00217  CSSValueImpl *CSSStyleDeclarationImpl::getPropertyCSSValue( int propertyID ) const
00218 {
00219     if(!m_lstValues) return 0;
00220 
00221     QPtrListIterator<CSSProperty> lstValuesIt(*m_lstValues);
00222     CSSProperty *current;
00223     for ( lstValuesIt.toLast(); (current = lstValuesIt.current()); --lstValuesIt )
00224         if (current->m_id == propertyID && !current->nonCSSHint)
00225             return current->value();
00226     return 0;
00227 }
00228 
00229 DOMString CSSStyleDeclarationImpl::removeProperty( int propertyID, bool NonCSSHint )
00230 {
00231     if(!m_lstValues) return DOMString();
00232     DOMString value;
00233 
00234     QPtrListIterator<CSSProperty> lstValuesIt(*m_lstValues);
00235      CSSProperty *current;
00236      for ( lstValuesIt.toLast(); (current = lstValuesIt.current()); --lstValuesIt )
00237          if (current->m_id == propertyID && NonCSSHint == current->nonCSSHint) {
00238              value = current->value()->cssText();
00239              m_lstValues->removeRef(current);
00240             setChanged();
00241          break;
00242         }
00243 
00244     return value;
00245 }
00246 
00247 void CSSStyleDeclarationImpl::setChanged()
00248 {
00249     if (m_node) {
00250         m_node->setChanged();
00251         return;
00252     }
00253 
00254     // ### quick&dirty hack for KDE 3.0... make this MUCH better! (Dirk)
00255     for (StyleBaseImpl* stylesheet = this; stylesheet; stylesheet = stylesheet->parent())
00256         if (stylesheet->isCSSStyleSheet()) {
00257             static_cast<CSSStyleSheetImpl*>(stylesheet)->doc()->updateStyleSelector();
00258             break;
00259         }
00260 }
00261 
00262 bool CSSStyleDeclarationImpl::getPropertyPriority( int propertyID ) const
00263 {
00264     if ( m_lstValues) {
00265     QPtrListIterator<CSSProperty> lstValuesIt(*m_lstValues);
00266     CSSProperty *current;
00267     for ( lstValuesIt.toFirst(); (current = lstValuesIt.current()); ++lstValuesIt ) {
00268         if( propertyID == current->m_id )
00269         return current->m_bImportant;
00270     }
00271     }
00272     return false;
00273 }
00274 
00275 void CSSStyleDeclarationImpl::setProperty(int id, const DOMString &value, bool important, bool nonCSSHint)
00276 {
00277     if(!m_lstValues) {
00278     m_lstValues = new QPtrList<CSSProperty>;
00279     m_lstValues->setAutoDelete(true);
00280     }
00281     removeProperty(id, nonCSSHint );
00282 
00283     DOMString ppValue = preprocess(value.string(),true);
00284     bool success = parseValue(ppValue.unicode(), ppValue.unicode()+ppValue.length(), id, important, nonCSSHint, m_lstValues);
00285 
00286     if(!success)
00287     kdDebug( 6080 ) << "CSSStyleDeclarationImpl::setProperty invalid property: [" << getPropertyName(id).string()
00288                     << "] value: [" << value.string() << "]"<< endl;
00289     else
00290         setChanged();
00291 }
00292 
00293 void CSSStyleDeclarationImpl::setProperty(int id, int value, bool important, bool nonCSSHint)
00294 {
00295     if(!m_lstValues) {
00296     m_lstValues = new QPtrList<CSSProperty>;
00297     m_lstValues->setAutoDelete(true);
00298     }
00299     removeProperty(id, nonCSSHint );
00300 
00301     CSSValueImpl * cssValue = new CSSPrimitiveValueImpl(value);
00302     setParsedValue(id, cssValue, important, nonCSSHint, m_lstValues);
00303     setChanged();
00304 }
00305 
00306 void CSSStyleDeclarationImpl::setProperty ( const DOMString &propertyString)
00307 {
00308     DOMString ppPropertyString = preprocess(propertyString.string(),true);
00309     QPtrList<CSSProperty> *props = parseProperties(ppPropertyString.unicode(),
00310                         ppPropertyString.unicode()+ppPropertyString.length());
00311     if(!props || !props->count())
00312     return;
00313 
00314     props->setAutoDelete(false);
00315 
00316     if(!m_lstValues) {
00317     m_lstValues = new QPtrList<CSSProperty>;
00318     m_lstValues->setAutoDelete( true );
00319     }
00320 
00321     CSSProperty *prop = props->first();
00322     while( prop ) {
00323     removeProperty(prop->m_id, false);
00324     m_lstValues->append(prop);
00325     prop = props->next();
00326     }
00327 
00328     delete props;
00329     setChanged();
00330 }
00331 
00332 void CSSStyleDeclarationImpl::setLengthProperty(int id, const DOM::DOMString &value, bool important, bool nonCSSHint, bool _multiLength )
00333 {
00334     bool parseMode = strictParsing;
00335     strictParsing = false;
00336     multiLength = _multiLength;
00337     setProperty( id, value, important, nonCSSHint);
00338     strictParsing = parseMode;
00339     multiLength = false;
00340 }
00341 
00342 unsigned long CSSStyleDeclarationImpl::length() const
00343 {
00344     return m_lstValues ? m_lstValues->count() : 0;
00345 }
00346 
00347 DOMString CSSStyleDeclarationImpl::item( unsigned long /*index*/ )
00348 {
00349     // ###
00350     //return m_lstValues->at(index);
00351     return DOMString();
00352 }
00353 
00354 CSSRuleImpl *CSSStyleDeclarationImpl::parentRule() const
00355 {
00356     return (m_parent && m_parent->isRule() ) ?
00357     static_cast<CSSRuleImpl *>(m_parent) : 0;
00358 }
00359 
00360 DOM::DOMString CSSStyleDeclarationImpl::cssText() const
00361 {
00362     return DOM::DOMString();
00363     // ###
00364 }
00365 
00366 void CSSStyleDeclarationImpl::setCssText(DOM::DOMString /*str*/)
00367 {
00368     // ###
00369 }
00370 
00371 bool CSSStyleDeclarationImpl::parseString( const DOMString &/*string*/, bool )
00372 {
00373     return false;
00374     // ###
00375 }
00376 
00377 
00378 // --------------------------------------------------------------------------------------
00379 
00380 CSSValueImpl::CSSValueImpl()
00381     : StyleBaseImpl()
00382 {
00383 }
00384 
00385 CSSValueImpl::~CSSValueImpl()
00386 {
00387 }
00388 
00389 DOM::DOMString CSSValueImpl::cssText() const
00390 {
00391     return DOM::DOMString();
00392 }
00393 
00394 void CSSValueImpl::setCssText(DOM::DOMString /*str*/)
00395 {
00396     // ###
00397 }
00398 
00399 DOM::DOMString CSSInheritedValueImpl::cssText() const
00400 {
00401     return DOMString("inherited");
00402 }
00403 // ----------------------------------------------------------------------------------------
00404 
00405 CSSValueListImpl::CSSValueListImpl()
00406     : CSSValueImpl()
00407 {
00408 }
00409 
00410 CSSValueListImpl::~CSSValueListImpl()
00411 {
00412     CSSValueImpl *val = m_values.first();
00413     while( val ) {
00414     val->deref();
00415     val = m_values.next();
00416     }
00417 }
00418 
00419 unsigned short CSSValueListImpl::cssValueType() const
00420 {
00421     return CSSValue::CSS_VALUE_LIST;
00422 }
00423 
00424 void CSSValueListImpl::append(CSSValueImpl *val)
00425 {
00426     m_values.append(val);
00427     val->ref();
00428 }
00429 
00430 DOM::DOMString CSSValueListImpl::cssText() const
00431 {
00432     // ###
00433     return DOM::DOMString();
00434 }
00435 
00436 // -------------------------------------------------------------------------------------
00437 
00438 CSSPrimitiveValueImpl::CSSPrimitiveValueImpl()
00439     : CSSValueImpl()
00440 {
00441     m_type = 0;
00442 }
00443 
00444 CSSPrimitiveValueImpl::CSSPrimitiveValueImpl(int ident)
00445     : CSSValueImpl()
00446 {
00447     m_value.ident = ident;
00448     m_type = CSSPrimitiveValue::CSS_IDENT;
00449 }
00450 
00451 CSSPrimitiveValueImpl::CSSPrimitiveValueImpl(float num, CSSPrimitiveValue::UnitTypes type)
00452 {
00453     m_value.num = num;
00454     m_type = type;
00455 }
00456 
00457 CSSPrimitiveValueImpl::CSSPrimitiveValueImpl(const DOMString &str, CSSPrimitiveValue::UnitTypes type)
00458 {
00459     m_value.string = str.implementation();
00460     if(m_value.string) m_value.string->ref();
00461     m_type = type;
00462 }
00463 
00464 CSSPrimitiveValueImpl::CSSPrimitiveValueImpl(const Counter &c)
00465 {
00466     m_value.counter = c.handle();
00467     if (m_value.counter)
00468     m_value.counter->ref();
00469     m_type = CSSPrimitiveValue::CSS_COUNTER;
00470 }
00471 
00472 CSSPrimitiveValueImpl::CSSPrimitiveValueImpl( RectImpl *r)
00473 {
00474     m_value.rect = r;
00475     if (m_value.rect)
00476     m_value.rect->ref();
00477     m_type = CSSPrimitiveValue::CSS_RECT;
00478 }
00479 
00480 CSSPrimitiveValueImpl::CSSPrimitiveValueImpl(QRgb color)
00481 {
00482     m_value.rgbcolor = color;
00483     m_type = CSSPrimitiveValue::CSS_RGBCOLOR;
00484 }
00485 
00486 CSSPrimitiveValueImpl::~CSSPrimitiveValueImpl()
00487 {
00488     cleanup();
00489 }
00490 
00491 void CSSPrimitiveValueImpl::cleanup()
00492 {
00493     switch(m_type) {
00494     case CSSPrimitiveValue::CSS_STRING:
00495     case CSSPrimitiveValue::CSS_URI:
00496     case CSSPrimitiveValue::CSS_ATTR:
00497     if(m_value.string) m_value.string->deref();
00498         break;
00499     case CSSPrimitiveValue::CSS_COUNTER:
00500     m_value.counter->deref();
00501         break;
00502     case CSSPrimitiveValue::CSS_RECT:
00503     m_value.rect->deref();
00504     default:
00505         break;
00506     }
00507 
00508     m_type = 0;
00509 }
00510 
00511 int CSSPrimitiveValueImpl::computeLength( khtml::RenderStyle *style, QPaintDeviceMetrics *devMetrics )
00512 {
00513     return ( int ) computeLengthFloat( style, devMetrics );
00514 }
00515 
00516 float CSSPrimitiveValueImpl::computeLengthFloat( khtml::RenderStyle *style, QPaintDeviceMetrics *devMetrics )
00517 {
00518     unsigned short type = primitiveType();
00519 
00520     float dpiY = 72.; // fallback
00521     if ( devMetrics )
00522         dpiY = devMetrics->logicalDpiY();
00523     if ( !khtml::printpainter && dpiY < 96 )
00524         dpiY = 96.;
00525 
00526     float factor = 1.;
00527     switch(type)
00528     {
00529     case CSSPrimitiveValue::CSS_EMS:
00530         factor = style->font().pixelSize();
00531         break;
00532     case CSSPrimitiveValue::CSS_EXS:
00533     {
00534         QFontMetrics fm = style->fontMetrics();
00535         QRect b = fm.boundingRect('x');
00536         factor = b.height();
00537         break;
00538     }
00539     case CSSPrimitiveValue::CSS_PX:
00540         break;
00541     case CSSPrimitiveValue::CSS_CM:
00542     factor = dpiY/2.54; //72dpi/(2.54 cm/in)
00543         break;
00544     case CSSPrimitiveValue::CSS_MM:
00545     factor = dpiY/25.4;
00546         break;
00547     case CSSPrimitiveValue::CSS_IN:
00548             factor = dpiY;
00549         break;
00550     case CSSPrimitiveValue::CSS_PT:
00551             factor = dpiY/72.;
00552         break;
00553     case CSSPrimitiveValue::CSS_PC:
00554         // 1 pc == 12 pt
00555             factor = dpiY*12./72.;
00556         break;
00557     default:
00558         return -1;
00559     }
00560     return getFloatValue(type)*factor;
00561 }
00562 
00563 void CSSPrimitiveValueImpl::setFloatValue( unsigned short unitType, float floatValue, int &exceptioncode )
00564 {
00565     exceptioncode = 0;
00566     cleanup();
00567     // ### check if property supports this type
00568     if(m_type > CSSPrimitiveValue::CSS_DIMENSION) {
00569     exceptioncode = CSSException::SYNTAX_ERR + CSSException::_EXCEPTION_OFFSET;
00570     return;
00571     }
00572     //if(m_type > CSSPrimitiveValue::CSS_DIMENSION) throw DOMException(DOMException::INVALID_ACCESS_ERR);
00573     m_value.num = floatValue;
00574     m_type = unitType;
00575 }
00576 
00577 void CSSPrimitiveValueImpl::setStringValue( unsigned short stringType, const DOMString &stringValue, int &exceptioncode )
00578 {
00579     exceptioncode = 0;
00580     cleanup();
00581     //if(m_type < CSSPrimitiveValue::CSS_STRING) throw DOMException(DOMException::INVALID_ACCESS_ERR);
00582     //if(m_type > CSSPrimitiveValue::CSS_ATTR) throw DOMException(DOMException::INVALID_ACCESS_ERR);
00583     if(m_type < CSSPrimitiveValue::CSS_STRING || m_type >> CSSPrimitiveValue::CSS_ATTR) {
00584     exceptioncode = CSSException::SYNTAX_ERR + CSSException::_EXCEPTION_OFFSET;
00585     return;
00586     }
00587     if(stringType != CSSPrimitiveValue::CSS_IDENT)
00588     {
00589     m_value.string = stringValue.implementation();
00590     m_value.string->ref();
00591     m_type = stringType;
00592     }
00593     // ### parse ident
00594 }
00595 
00596 unsigned short CSSPrimitiveValueImpl::cssValueType() const
00597 {
00598     return CSSValue::CSS_PRIMITIVE_VALUE;
00599 }
00600 
00601 bool CSSPrimitiveValueImpl::parseString( const DOMString &/*string*/, bool )
00602 {
00603     // ###
00604     return false;
00605 }
00606 
00607 int CSSPrimitiveValueImpl::getIdent()
00608 {
00609     if(m_type != CSSPrimitiveValue::CSS_IDENT) return 0;
00610     return m_value.ident;
00611 }
00612 
00613 DOM::DOMString CSSPrimitiveValueImpl::cssText() const
00614 {
00615     // ### return the original value instead of a generated one (e.g. color
00616     // name if it was specified) - check what spec says about this
00617     DOMString text;
00618     switch ( m_type ) {
00619     case CSSPrimitiveValue::CSS_UNKNOWN:
00620         // ###
00621         break;
00622     case CSSPrimitiveValue::CSS_NUMBER:
00623         text = DOMString(QString::number( (int)m_value.num ));
00624         break;
00625     case CSSPrimitiveValue::CSS_PERCENTAGE:
00626         text = DOMString(QString::number( m_value.num ) + "%");
00627         break;
00628     case CSSPrimitiveValue::CSS_EMS:
00629         text = DOMString(QString::number( m_value.num ) + "em");
00630         break;
00631     case CSSPrimitiveValue::CSS_EXS:
00632         text = DOMString(QString::number( m_value.num ) + "ex");
00633         break;
00634     case CSSPrimitiveValue::CSS_PX:
00635         text = DOMString(QString::number( m_value.num ) + "px");
00636         break;
00637     case CSSPrimitiveValue::CSS_CM:
00638         text = DOMString(QString::number( m_value.num ) + "cm");
00639         break;
00640     case CSSPrimitiveValue::CSS_MM:
00641         text = DOMString(QString::number( m_value.num ) + "mm");
00642         break;
00643     case CSSPrimitiveValue::CSS_IN:
00644         text = DOMString(QString::number( m_value.num ) + "in");
00645         break;
00646     case CSSPrimitiveValue::CSS_PT:
00647         text = DOMString(QString::number( m_value.num ) + "pt");
00648         break;
00649     case CSSPrimitiveValue::CSS_PC:
00650         text = DOMString(QString::number( m_value.num ) + "pc");
00651         break;
00652     case CSSPrimitiveValue::CSS_DEG:
00653         text = DOMString(QString::number( m_value.num ) + "deg");
00654         break;
00655     case CSSPrimitiveValue::CSS_RAD:
00656         text = DOMString(QString::number( m_value.num ) + "rad");
00657         break;
00658     case CSSPrimitiveValue::CSS_GRAD:
00659         text = DOMString(QString::number( m_value.num ) + "grad");
00660         break;
00661     case CSSPrimitiveValue::CSS_MS:
00662         text = DOMString(QString::number( m_value.num ) + "ms");
00663         break;
00664     case CSSPrimitiveValue::CSS_S:
00665         text = DOMString(QString::number( m_value.num ) + "s");
00666         break;
00667     case CSSPrimitiveValue::CSS_HZ:
00668         text = DOMString(QString::number( m_value.num ) + "hz");
00669         break;
00670     case CSSPrimitiveValue::CSS_KHZ:
00671         text = DOMString(QString::number( m_value.num ) + "khz");
00672         break;
00673     case CSSPrimitiveValue::CSS_DIMENSION:
00674         // ###
00675         break;
00676     case CSSPrimitiveValue::CSS_STRING:
00677         // ###
00678         break;
00679     case CSSPrimitiveValue::CSS_URI:
00680         text = DOMString( m_value.string );
00681         break;
00682     case CSSPrimitiveValue::CSS_IDENT:
00683         text = getValueName(m_value.ident);
00684         break;
00685     case CSSPrimitiveValue::CSS_ATTR:
00686         // ###
00687         break;
00688     case CSSPrimitiveValue::CSS_COUNTER:
00689         // ###
00690         break;
00691     case CSSPrimitiveValue::CSS_RECT:
00692         // ###
00693         break;
00694     case CSSPrimitiveValue::CSS_RGBCOLOR:
00695         text = QColor(m_value.rgbcolor).name();
00696         break;
00697     default:
00698         break;
00699     }
00700     return text;
00701 }
00702 
00703 // -----------------------------------------------------------------
00704 
00705 RectImpl::RectImpl()
00706 {
00707     m_top = 0;
00708     m_right = 0;
00709     m_bottom = 0;
00710     m_left = 0;
00711 }
00712 
00713 RectImpl::~RectImpl()
00714 {
00715     if (m_top) m_top->deref();
00716     if (m_right) m_right->deref();
00717     if (m_bottom) m_bottom->deref();
00718     if (m_left) m_left->deref();
00719 }
00720 
00721 void RectImpl::setTop( CSSPrimitiveValueImpl *top )
00722 {
00723     if( top ) top->ref();
00724     if ( m_top ) m_top->deref();
00725     m_top = top;
00726 }
00727 
00728 void RectImpl::setRight( CSSPrimitiveValueImpl *right )
00729 {
00730     if( right ) right->ref();
00731     if ( m_right ) m_right->deref();
00732     m_right = right;
00733 }
00734 
00735 void RectImpl::setBottom( CSSPrimitiveValueImpl *bottom )
00736 {
00737     if( bottom ) bottom->ref();
00738     if ( m_bottom ) m_bottom->deref();
00739     m_bottom = bottom;
00740 }
00741 
00742 void RectImpl::setLeft( CSSPrimitiveValueImpl *left )
00743 {
00744     if( left ) left->ref();
00745     if ( m_left ) m_left->deref();
00746     m_left = left;
00747 }
00748 
00749 // -----------------------------------------------------------------
00750 
00751 CSSImageValueImpl::CSSImageValueImpl(const DOMString &url, StyleBaseImpl *style)
00752     : CSSPrimitiveValueImpl(url, CSSPrimitiveValue::CSS_URI)
00753 {
00754     khtml::DocLoader *docLoader = 0;
00755     StyleBaseImpl *root = style;
00756     while (root->parent())
00757     root = root->parent();
00758     if (root->isCSSStyleSheet())
00759     docLoader = static_cast<CSSStyleSheetImpl*>(root)->docLoader();
00760 
00761     if (docLoader)
00762     m_image = docLoader->requestImage(url);
00763     else
00764     m_image = khtml::Cache::requestImage(0, url);
00765 
00766     if(m_image) m_image->ref(this);
00767 }
00768 
00769 CSSImageValueImpl::CSSImageValueImpl()
00770     : CSSPrimitiveValueImpl(CSS_VAL_NONE)
00771 {
00772     m_image = 0;
00773 }
00774 
00775 CSSImageValueImpl::~CSSImageValueImpl()
00776 {
00777     if(m_image) m_image->deref(this);
00778 }
00779 
00780 // ------------------------------------------------------------------------
00781 
00782 FontFamilyValueImpl::FontFamilyValueImpl( const QString &string)
00783     : CSSPrimitiveValueImpl( DOMString(string), CSSPrimitiveValue::CSS_STRING)
00784 {
00785     const QString &available = KHTMLSettings::availableFamilies();
00786 
00787     QString face = string.lower();
00788     // a languge tag is often added in braces at the end. Remove it.
00789     face = face.replace(QRegExp(" \\(.*\\)$"), "");
00790     // remove [Xft] qualifiers
00791     face = face.replace(QRegExp(" \\[.*\\]$"), "");
00792     //kdDebug(0) << "searching for face '" << face << "'" << endl;
00793     if(face == "serif" ||
00794        face == "sans-serif" ||
00795        face == "cursive" ||
00796        face == "fantasy" ||
00797        face == "monospace" ||
00798        face == "konq_default") {
00799     parsedFontName = face;
00800     } else {
00801     int pos = available.find( face, 0, false );
00802     if( pos == -1 ) {
00803         QString str = face;
00804         int p = face.find(' ');
00805         // Arial Blk --> Arial
00806         // MS Sans Serif --> Sans Serif
00807         if ( p != -1 ) {
00808         if(p > 0 && (int)str.length() - p > p + 1)
00809             str = str.mid( p+1 );
00810         else
00811             str.truncate( p );
00812         pos = available.find( str, 0, false);
00813         }
00814     }
00815 
00816     if ( pos != -1 ) {
00817         int pos1 = available.findRev( ',', pos ) + 1;
00818         pos = available.find( ',', pos );
00819         if ( pos == -1 )
00820         pos = available.length();
00821         parsedFontName = available.mid( pos1, pos - pos1 );
00822     }
00823     }
00824 }
KDE Logo
This file is part of the documentation for kdelibs Version 3.1.0.
Documentation copyright © 1996-2002 the KDE developers.
Generated on Wed Oct 8 12:22:34 2003 by doxygen 1.2.18 written by Dimitri van Heesch, © 1997-2001