tdegraphics/ksvg/impl/SVGStylableImpl.cc

/*
    Copyright (C) 2001-2003 KSVG Team
    This file is part of the KDE project

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
*/

#include <kdebug.h>

#include <tqrect.h>

#include "CanvasItem.h"
#include "KSVGCanvas.h"

#include "SVGPaint.h"
#include "SVGColorImpl.h"
#include "SVGPaintImpl.h"
#include "SVGHelperImpl.h"
#include "SVGLengthImpl.h"
#include "SVGDocumentImpl.h"
#include "SVGStylableImpl.h"
#include "SVGSVGElementImpl.h"
#include "SVGStringListImpl.h"
#include "SVGImageElementImpl.h"
#include "SVGURIReferenceImpl.h"
#include "SVGAnimatedLengthImpl.h"
#include "SVGColorProfileElementImpl.h"
#include "SVGAnimatedLengthListImpl.h"

using namespace KSVG;

#include "SVGStylableImpl.lut.h"
#include "ksvg_scriptinterpreter.h"
#include "ksvg_bridge.h"
#include "ksvg_ecma.h"

SVGStylableImpl::SVGStylableImpl(SVGElementImpl *object) : m_object(object)
{
	KSVG_EMPTY_FLAGS

	// View propidx.html, if you want to verify those default values (Niko)
	m_flags = SVG_STYLE_FLAG_NONE;

	// Initialize all pointers to 0
	// Important!
	m_color = 0;
	m_fillColor = 0;
	m_stopColor = 0;
	m_dashArray = 0;
	m_dashOffset = 0; 
	m_strokeWidth = 0;
	m_strokeColor = 0;
	m_fontFamily = 0;

	m_fillOpacity = 1;
	m_strokeOpacity = 1;
	m_opacity = 1;

	// Special case, getFontSize() could be accessed
	// _before_ processStyle() is called -> no default
	// value for font-size yet -> crash
	// SVGLengthImpl access it when parsing em/ex values (Niko)
	m_fontSize = -1;
}

SVGStylableImpl::~SVGStylableImpl()
{
	if(m_strokeWidth)
		m_strokeWidth->deref();
	if(m_fontFamily)
		m_fontFamily->deref();
	if(m_strokeColor)
		m_strokeColor->deref();
	if(m_fillColor)
		m_fillColor->deref();
	if(m_color)
		m_color->deref();
	if(m_stopColor)
		m_stopColor->deref();
	if(m_dashOffset)
		m_dashOffset->deref();
	if(m_dashArray)
		m_dashArray->deref();
}

void SVGStylableImpl::processStyle()
{
	SVGStylableImpl *parentStyle = 0;
	if(m_object && m_object->ownerDoc())
		parentStyle = dynamic_cast<SVGStylableImpl *>(m_object->ownerDoc()->getElementFromHandle((*m_object).parentNode().handle()));

	// Spec: default "none"
	if(~m_flags & SVG_STYLE_FLAG_STROKE)
	{
		m_strokeColor = new SVGPaintImpl(m_object);
		m_strokeColor->ref();

		SVGPaintImpl *strokeColor = 0L;
		if(parentStyle)
			strokeColor = parentStyle->getStrokeColor();

		if(strokeColor)
			*m_strokeColor = *strokeColor;
		else
			m_strokeColor->setPaint(SVG_PAINTTYPE_NONE);
	}

	// Spec: default "black"
	if(~m_flags & SVG_STYLE_FLAG_FILL)
	{
		m_fillColor = new SVGPaintImpl(m_object);
		m_fillColor->ref();

		SVGPaintImpl *fillColor = 0;
		if(parentStyle)
			fillColor = parentStyle->getFillColor();

		if(fillColor)
			*m_fillColor = *fillColor;
		else
			m_fillColor->setRGBColor(DOM::DOMString("black"));
	}

	// Spec: no real default
	if(~m_flags & SVG_STYLE_FLAG_COLOR)
	{
		m_color = new SVGColorImpl(m_object);
		m_color->ref();
		SVGColorImpl *color = 0;
		if(parentStyle)
			color = parentStyle->getColor();

		if(color)
			*m_color = *color;
	}

	// Spec: default sRGB
	if(~m_flags & SVG_STYLE_FLAG_COLOR_INTERPOLATION)
	{
		if(parentStyle)
			m_colorInterpolation = parentStyle->getColorInterpolation();
		else
			m_colorInterpolation = CI_SRGB;
	}

	// Spec: default "1"
	if(~m_flags & SVG_STYLE_FLAG_STROKE_WIDTH)
	{
		m_strokeWidth = new SVGAnimatedLengthImpl(LENGTHMODE_OTHER, m_object);
		m_strokeWidth->ref();

		SVGAnimatedLengthImpl *strokeWidth = 0;
		if(parentStyle)
			strokeWidth = parentStyle->getStrokeWidth();

		if(strokeWidth)
			*m_strokeWidth = *strokeWidth;
		else
			m_strokeWidth->baseVal()->setValue(1.0);
	}

	// Spec: default "4"
	if(~m_flags & SVG_STYLE_FLAG_STROKE_MITER_LIMIT)
	{
		if(parentStyle)
			m_strokeMiterlimit = parentStyle->getStrokeMiterlimit();
		else
			m_strokeMiterlimit = 4;
	}

	// Spec: default "butt"
	if(~m_flags & SVG_STYLE_FLAG_STROKE_LINE_CAP)
	{
		if(parentStyle)
			m_capStyle = parentStyle->getCapStyle();
		else
			m_capStyle = PATH_STROKE_CAP_BUTT;
	}

	// Spec: default "miter"
	if(~m_flags & SVG_STYLE_FLAG_STROKE_LINE_JOIN)
	{
		if(parentStyle)
			m_joinStyle = parentStyle->getJoinStyle();
		else
			m_joinStyle = PATH_STROKE_JOIN_MITER;
	}

	// Spec: default "auto"
	if(~m_flags & SVG_STYLE_FLAG_CURSOR)
	{
		if(parentStyle)
			m_cursor = parentStyle->getCursor();
		else
			m_cursor = CURSOR_AUTO;
	}

	// Spec: default "visiblePainted"
	if(~m_flags & SVG_STYLE_FLAG_POINTER_EVENTS)
	{
		if(parentStyle)
			m_pointerEvents = parentStyle->getPointerEvents();
		else
			m_pointerEvents = PE_VISIBLE_PAINTED;
	}

	// Spec: default "0"
	if(~m_flags & SVG_STYLE_FLAG_STROKE_DASH_OFFSET)
	{
		m_dashOffset = new SVGAnimatedLengthImpl(LENGTHMODE_OTHER, m_object);
		m_dashOffset->ref();

		SVGAnimatedLengthImpl *dashOffset = 0;
		if(parentStyle)
			dashOffset = parentStyle->getDashOffset();

		if(dashOffset)
			*m_dashOffset = *dashOffset;
		else
			m_dashOffset->baseVal()->setValue(0);
	}

	// Spec: default "none" -> 0 == empty dash array
	if(~m_flags & SVG_STYLE_FLAG_STROKE_DASH_ARRAY)
	{
		SVGAnimatedLengthListImpl *dashArray = 0;
		if(parentStyle)
			dashArray = parentStyle->getDashArray();

		if(dashArray)
		{
			if (!m_dashArray)
			{
				m_dashArray = new SVGAnimatedLengthListImpl();
				m_dashArray->ref();
			}
			*m_dashArray = *dashArray;
		}
		else
			m_dashArray = 0;
	}

	// Spec: default "1" -> 1 == Not opaque
	if(~m_flags & SVG_STYLE_FLAG_FILL_OPACITY)
	{
		if(parentStyle)
			m_fillOpacity = parentStyle->getFillOpacity();
		else
			m_fillOpacity = 1;
	}

	if(~m_flags & SVG_STYLE_FLAG_STROKE_OPACITY)
	{
		if(parentStyle)
			m_strokeOpacity = parentStyle->getStrokeOpacity();
		else
			m_strokeOpacity = 1;
	}

	// Fake group opacity by multiplying by our parent's group opacity
	if(~m_flags & SVG_STYLE_FLAG_OPACITY)
	{
		if(parentStyle)
			m_opacity = parentStyle->getOpacity();
		else
			m_opacity = 1;
	}
	else
		if(parentStyle)
			m_opacity *= parentStyle->getOpacity();

	if(~m_flags & SVG_STYLE_FLAG_CLIP_PATH)
		m_clipPath = "";

	if(~m_flags & SVG_STYLE_FLAG_MASK)
		m_mask = "";

	// Spec: default "nonzero"
	if(~m_flags & SVG_STYLE_FLAG_FILL_RULE)
	{
		if(parentStyle)
			m_fillRule = parentStyle->getFillRule();
		else
			m_fillRule = RULE_NONZERO;
	}
	
	if(~m_flags & SVG_STYLE_FLAG_CLIP_RULE)
	{
		if(parentStyle)
			m_clipRule = parentStyle->getClipRule();
		else
			m_clipRule = RULE_NONZERO;
	}

	// Spec: default "hidden"
	if(~m_flags & SVG_STYLE_FLAG_OVERFLOW)
	{
		if(parentStyle)
			m_overflow = parentStyle->getOverflow();
		else
			m_overflow = false;
	}

	// We are not really, spec compatible here, we just
	// define a bool, to indicate wheter an element should
	// be rendered or not.
	if(~m_flags & SVG_STYLE_FLAG_DISPLAY)
		m_display = true;

	if(~m_flags & SVG_STYLE_FLAG_VISIBILITY)
	{
		if(parentStyle)
			m_visible = parentStyle->getVisible();
		else
			m_visible = true;
	}

	// Spec: default "medium"
	if(~m_flags & SVG_STYLE_FLAG_FONT_SIZE)
	{
		if(parentStyle)
			m_fontSize = parentStyle->getFontSize();
		else
			m_fontSize = fontSizeForText("medium");
	}

	// Spec: default "depends on user agent" -> "Arial" for SVG
	if(~m_flags & SVG_STYLE_FLAG_FONT_FAMILY)
	{
		if(!m_fontFamily)
		{
			m_fontFamily = new SVGStringListImpl();
			m_fontFamily->ref();
		}

		SVGStringListImpl *fontFamily = 0;
		if(parentStyle)
			fontFamily = parentStyle->getFontFamily();

		if(fontFamily)
			*m_fontFamily = *fontFamily;
		else
		{
			SharedString *string = new SharedString("Arial");
			string->ref();
			
			m_fontFamily->appendItem(string);
		}
	}

	// Spec: default "normal"
	if(~m_flags & SVG_STYLE_FLAG_FONT_STYLE)
	{
		if(parentStyle)
			m_fontStyle = parentStyle->getFontStyle();
		else
			m_fontStyle = FSNORMAL;
	}

	// Spec: default "normal"
	if(~m_flags & SVG_STYLE_FLAG_FONT_WEIGHT)
	{
		if(parentStyle)
			m_fontWeight = parentStyle->getFontWeight();
		else
			m_fontWeight = "normal";
	}

	// Spec: default "start"
	if(~m_flags & SVG_STYLE_FLAG_TEXT_ANCHOR)
	{
		if(parentStyle)
			m_textAnchor = parentStyle->getTextAnchor();
		else
			m_textAnchor = TASTART;
	}

	// Spec: default "LTR"
	if(~m_flags & SVG_STYLE_FLAG_TEXT_DIRECTION)
	{
		if(parentStyle)
			m_textDirection = parentStyle->getTextDirection();
		else
			m_textDirection = LTR;
	}

	// Spec: default "none"
	if(~m_flags & SVG_STYLE_FLAG_TEXT_DECORATION)
	{
		if(parentStyle)
			m_textDecoration = parentStyle->getTextDecoration();
		else
			m_textDecoration = TDNONE;
	}

	// Spec: default "baseline"
	if(~m_flags & SVG_STYLE_FLAG_BASELINE_SHIFT)
	{
		if(parentStyle)
			m_baselineShift = parentStyle->getBaselineShift();
		else
			m_baselineShift = "baseline";
	}

	// Spec: default "lr-tb", FIXME
	if(~m_flags & SVG_STYLE_FLAG_TEXT_WRITING_MODE)
	{
		if(parentStyle)
			m_textWritingMode = parentStyle->getTextWritingMode();
		else
			m_textWritingMode = LR;
	}

	// Spec: default "normal"
	if(~m_flags & SVG_STYLE_FLAG_TEXT_UNICODE_BIDI)
	{
		if(parentStyle)
			m_textUnicodeBidi = parentStyle->getTextUnicodeBidi();
		else
			m_textUnicodeBidi = UBNORMAL;
	}

	// Spec: default "auto"
	if(~m_flags & SVG_STYLE_FLAG_GLYPH_ORIENTATION_VERTICAL)
	{
		if(parentStyle)
			m_glyphOrientationVertical = parentStyle->getGlyphOrientationVertical();
		else
			m_glyphOrientationVertical = "auto";
	}	

	// Spec: default "auto"
	if(~m_flags & SVG_STYLE_FLAG_GLYPH_ORIENTATION_HORIZONTAL)
	{
		if(parentStyle)
			m_glyphOrientationHorizontal = parentStyle->getGlyphOrientationHorizontal();
		else
			m_glyphOrientationHorizontal = "auto";
	}	

	// Spec: default "normal"
	if(~m_flags & SVG_STYLE_FLAG_LETTER_SPACING)
	{
		if(parentStyle)
			m_letterSpacing = parentStyle->getLetterSpacing();
		else
			m_letterSpacing = "normal";
	}

	// Spec: default "normal"
	if(~m_flags & SVG_STYLE_FLAG_WORD_SPACING)
	{
		if(parentStyle)
			m_wordSpacing = parentStyle->getWordSpacing();
		else
			m_wordSpacing = "normal";
	}

	// Spec: default "black"
	if(~m_flags & SVG_STYLE_FLAG_STOP)
	{
		m_stopColor = new SVGColorImpl(m_object);
		m_stopColor->ref();

		m_stopColor->setRGBColor(DOM::DOMString("black"));
	}

	// Spec: default "none"
	if(~m_flags & SVG_STYLE_FLAG_MARKER_START)
	{
		if(parentStyle)
			m_startMarker = parentStyle->getStartMarker();
		else
			m_startMarker = TQString();
	}

	// Spec: default "none"
	if(~m_flags & SVG_STYLE_FLAG_MARKER_MID)
	{
		if(parentStyle)
			m_midMarker = parentStyle->getMidMarker();
		else
			m_midMarker = TQString();
	}

	// Spec: default "none"
	if(~m_flags & SVG_STYLE_FLAG_MARKER_END)
	{
		if(parentStyle)
			m_endMarker = parentStyle->getEndMarker();
		else
			m_endMarker = TQString();
	}
}

bool SVGStylableImpl::isStroked() const
{
	if(!m_strokeColor)
		return false;
	
	return m_strokeColor->paintType() != SVG_PAINTTYPE_UNKNOWN &&
		   m_strokeColor->paintType() != SVG_PAINTTYPE_NONE &&
		   m_strokeColor->paintType() != SVG_PAINTTYPE_URI_NONE;
}

bool SVGStylableImpl::isFilled() const
{
	if(!m_fillColor)
		return false;
	
	return m_fillColor->paintType() != SVG_PAINTTYPE_UNKNOWN &&
		   m_fillColor->paintType() != SVG_PAINTTYPE_NONE &&
		   m_fillColor->paintType() != SVG_PAINTTYPE_URI_NONE;
}

TQString SVGStylableImpl::extractUrlId(const TQString &url)
{
	TQString id;

	if(url.startsWith("url(#"))
	{
		int idstart = url.find("#") + 1;
		id = url.mid(idstart, url.length() - idstart - 1);
	}
	else
		id = url;

	return id;
}

void SVGStylableImpl::setMarkers(const TQString &marker)
{
	setStartMarker(marker);
	setMidMarker(marker);
	setEndMarker(marker);
}

void SVGStylableImpl::setStartMarker(const TQString &startMarker)
{
	if(startMarker.startsWith("url(#"))
	{
		int idstart = startMarker.find("#") + 1;
		m_startMarker = startMarker.mid(idstart, startMarker.length() - idstart - 1);
	}
	else if(startMarker == "none")
		m_startMarker = TQString();
}

void SVGStylableImpl::setMidMarker(const TQString &midMarker)
{
	if(midMarker.startsWith("url(#"))
	{
		int idstart = midMarker.find("#") + 1;
		m_midMarker = midMarker.mid(idstart, midMarker.length() - idstart - 1);
	}
	else if(midMarker == "none")
		m_midMarker = TQString();
}

void SVGStylableImpl::setEndMarker(const TQString &endMarker)
{
	if(endMarker.startsWith("url(#"))
	{
		int idstart = endMarker.find("#") + 1;
		m_endMarker = endMarker.mid(idstart, endMarker.length() - idstart - 1);
	}
	else if(endMarker == "none")
		m_endMarker = TQString();
}

bool SVGStylableImpl::hasMarkers() const
{
	return !m_startMarker.isEmpty() || !m_midMarker.isEmpty() || !m_endMarker.isEmpty();
}

void SVGStylableImpl::setPaint(const TQString &param, SVGPaintImpl *svgPaint)
{
	if(param.stripWhiteSpace() == "none")
		svgPaint->setPaint(SVG_PAINTTYPE_NONE, DOM::DOMString(""), DOM::DOMString(""));
	else if(SVGURIReferenceImpl::isUrl(param))
		svgPaint->setUri(SVGURIReferenceImpl::getTarget(param));
	else
		setColor(param, svgPaint);
}

void SVGStylableImpl::setColor(const TQString &param, SVGColorImpl *svgColor)
{
	if(param.stripWhiteSpace().startsWith("#"))
	{
		if(param.contains("icc-color"))
		{
			TQString first = param.left(7);
			TQString last = param.right(param.length() - 8);

			svgColor->setRGBColorICCColor(first, last);
		}
		else
		{
			TQColor color;
			color.setNamedColor(param.stripWhiteSpace());
			svgColor->setRGBColor(color);
		}
	}
	else if(param.stripWhiteSpace().startsWith("rgb("))
	{
		TQString parse = param.stripWhiteSpace();
		TQStringList colors = TQStringList::split(',', parse);
		TQString r = colors[0].right((colors[0].length() - 4));
		TQString g = colors[1];
		TQString b = colors[2].left((colors[2].length() - 1));

		if(r.contains("%"))
		{
			r = r.left(r.length() - 1);
			r = TQString::number(int((double(255 * r.toDouble()) / 100.0)));
		}
		
		if(g.contains("%"))
		{
			g = g.left(g.length() - 1);
			g = TQString::number(int((double(255 * g.toDouble()) / 100.0)));
		}

		if(b.contains("%"))
		{
			b = b.left(b.length() - 1);
			b = TQString::number(int((double(255 * b.toDouble()) / 100.0)));
		}

		svgColor->setRGBColor(int(r.toFloat()), int(g.toFloat()), int(b.toFloat()));
	}
	else
	{
        if(param.stripWhiteSpace().lower() == "currentcolor")
			svgColor->setColor(SVG_COLORTYPE_CURRENTCOLOR, DOM::DOMString(""), DOM::DOMString(""));
		else
			svgColor->setRGBColor(DOM::DOMString(param.stripWhiteSpace().lower()));
	}
}

TQRect SVGStylableImpl::clip()
{
	return TQRect();
}

void SVGStylableImpl::setClip(const TQString &)
{
}

float SVGStylableImpl::fontSizeForText(const TQString &value)
{
	float ret = -1;

	// Spec: "On a computer screen a scaling factor of 1.2 is suggested between adjacent indexes"
	const float factor = 1.2;

	// Spec: "If the 'medium' font is 12pt, the 'large' font could be 14.4pt."
	const float mediumFont = 12.0;

	if(value == "xx-small")
		ret = mediumFont - (3.0 * factor);
	else if(value == "x-small")
		ret = mediumFont - (2.0 * factor);
	else if(value == "small")
		ret = mediumFont - factor;
	else if(value == "medium")
		ret = mediumFont;		
	else if(value == "large")
		ret = mediumFont + factor;
	else if(value == "x-large")
		ret = mediumFont + (2.0 * factor);
	else if(value == "xx-large")
		ret = mediumFont + (3.0 * factor);
		
	return ret;
}

// Ecma stuff

/*
@namespace KSVG
@begin SVGStylableImpl::s_hashTable 47
 className			SVGStylableImpl::ClassName			DontDelete|ReadOnly
 style				SVGStylableImpl::Style				DontDelete|ReadOnly
 stroke-width		SVGStylableImpl::StrokeWidth		DontDelete|ReadOnly
 stroke-miterlimit	SVGStylableImpl::StrokeMiterlimit	DontDelete|ReadOnly
 stroke-linecap		SVGStylableImpl::StrokeLineCap		DontDelete|ReadOnly
 stroke-linejoin	SVGStylableImpl::StrokeLineJoin		DontDelete|ReadOnly
 stroke				SVGStylableImpl::Stroke				DontDelete|ReadOnly
 fill				SVGStylableImpl::Fill				DontDelete|ReadOnly
 color				SVGStylableImpl::Color				DontDelete|ReadOnly
 stop-color			SVGStylableImpl::StopColor			DontDelete|ReadOnly
 font-size			SVGStylableImpl::FontSize			DontDelete|ReadOnly
 font-family		SVGStylableImpl::FontFamily			DontDelete|ReadOnly
 font-weight		SVGStylableImpl::FontWeight			DontDelete|ReadOnly
 font-style			SVGStylableImpl::FontStyle			DontDelete|ReadOnly
 text-decoration	SVGStylableImpl::TextDecoration		DontDelete|ReadOnly
 text-anchor		SVGStylableImpl::TextAnchor			DontDelete|ReadOnly
 direction			SVGStylableImpl::Direction			DontDelete|ReadOnly
 writing-mode		SVGStylableImpl::WritingMode		DontDelete|ReadOnly
 unicode-bidi		SVGStylableImpl::UnicodeBidi		DontDelete|ReadOnly
 opacity			SVGStylableImpl::Opacity			DontDelete|ReadOnly
 fill-opacity		SVGStylableImpl::FillOpacity		DontDelete|ReadOnly
 stroke-opacity		SVGStylableImpl::StrokeOpacity		DontDelete|ReadOnly
 clip-path			SVGStylableImpl::ClipPath			DontDelete|ReadOnly
 marker-start		SVGStylableImpl::MarkerStart		DontDelete|ReadOnly
 marker-mid			SVGStylableImpl::MarkerMid			DontDelete|ReadOnly
 marker-end			SVGStylableImpl::MarkerEnd			DontDelete|ReadOnly
 marker				SVGStylableImpl::Marker				DontDelete|ReadOnly
 cursor				SVGStylableImpl::Cursor				DontDelete|ReadOnly
 display			SVGStylableImpl::Display			DontDelete|ReadOnly
 overflow			SVGStylableImpl::Overflow			DontDelete|ReadOnly
 clip				SVGStylableImpl::Clip				DontDelete|ReadOnly
 visibility			SVGStylableImpl::Visibility			DontDelete|ReadOnly
 fill-rule			SVGStylableImpl::FillRule			DontDelete|ReadOnly
 clip-rule			SVGStylableImpl::ClipRule			DontDelete|ReadOnly
 stroke-dashoffset	SVGStylableImpl::StrokeDashOffset	DontDelete|ReadOnly
 stroke-dasharray	SVGStylableImpl::StrokeDashArray	DontDelete|ReadOnly
 color-profile		SVGStylableImpl::ColorProfile		DontDelete|ReadOnly
 baseline-shift		SVGStylableImpl::BaselineShift		DontDelete|ReadOnly
 letter-spacing		SVGStylableImpl::LetterSpacing		DontDelete|ReadOnly
 word-spacing		SVGStylableImpl::WordSpacing		DontDelete|ReadOnly
 pointer-events		SVGStylableImpl::PointerEvents		DontDelete|ReadOnly
 glyph-orientation-vertical	SVGStylableImpl::GlyphOrientationVertical	DontDelete|ReadOnly
 glyph-orientation-horizontal	SVGStylableImpl::GlyphOrientationHorizontal	DontDelete|ReadOnly
 color-interpolation	SVGStylableImpl::ColorInterpolation	DontDelete|ReadOnly
 mask				SVGStylableImpl::Mask	DontDelete|ReadOnly
@end
@namespace KSVG
@begin SVGStylableImplProto::s_hashTable 2
 getStyle			SVGStylableImpl::GetStyle			DontDelete|Function 0
@end
*/

KSVG_IMPLEMENT_PROTOTYPE("SVGStylable", SVGStylableImplProto, SVGStylableImplProtoFunc)

Value SVGStylableImpl::getValueProperty(ExecState *, int token) const
{
	switch(token)
	{
		//case ClassName:
		//	return String(className().string());
		case Style:
			return String(m_object ? m_object->DOM::Element::getAttribute("style") : "");
		case Visibility:
			return String(m_visible ? "visible" : "hidden");
		case Display:
			return String(m_display ? "inline" : "none");
		default:
			kdWarning() << "Unhandled token in " << k_funcinfo << " : " << token << endl;
			return Undefined();
	}
}

void SVGStylableImpl::putValueProperty(ExecState *exec, int token, const Value &value, int attr)
{
	// This class has just ReadOnly properties, only with the Internal flag set
	// it's allowed to modify those.
	if(!(attr & KJS::Internal))
		return;

	TQString param = value.toString(exec).qstring();
	
	if (param.isEmpty())
		return;
	
	bool redraw = false;
	bool inherit = (param == "inherit");
	int update = -1;

	switch(token)
	{
		case Style:
		{
			if(!m_object)
				return;

			TQStringList substyles = TQStringList::split(';', param);
			for(TQStringList::Iterator it = substyles.begin(); it != substyles.end(); ++it)
			{
				TQStringList substyle = TQStringList::split(':', (*it));
				m_object->setAttributeInternal(substyle[0].stripWhiteSpace(), substyle[1].stripWhiteSpace());
			}
			break;
		}
		case StrokeWidth:
			if(m_flags & SVG_STYLE_FLAG_STROKE_WIDTH)
			{
				redraw = true;
				update = UPDATE_LINEWIDTH;
			}
			if(inherit)
				m_flags &= ~SVG_STYLE_FLAG_STROKE_WIDTH;
			else
			{
				m_flags |= SVG_STYLE_FLAG_STROKE_WIDTH;

				if(!m_strokeWidth)
				{
					m_strokeWidth = new SVGAnimatedLengthImpl(LENGTHMODE_OTHER, m_object);
					m_strokeWidth->ref();
				}

				m_strokeWidth->baseVal()->setValueAsString(param);
			}
			break;
		case StrokeMiterlimit:
			m_flags |= SVG_STYLE_FLAG_STROKE_MITER_LIMIT;
			if(!inherit)
				m_strokeMiterlimit = param.toUInt();
			break;
		case StrokeLineCap:
			m_flags |= SVG_STYLE_FLAG_STROKE_LINE_CAP;
			if(param == "butt")
				m_capStyle = PATH_STROKE_CAP_BUTT;
			else if(param == "round")
				m_capStyle = PATH_STROKE_CAP_ROUND;
			else if(param == "square")
				m_capStyle = PATH_STROKE_CAP_SQUARE;
			break;
		case StrokeLineJoin:
			m_flags |= SVG_STYLE_FLAG_STROKE_LINE_JOIN;
			if(param == "miter")
				m_joinStyle = PATH_STROKE_JOIN_MITER;
			else if(param == "round")
				m_joinStyle = PATH_STROKE_JOIN_ROUND;
			else if(param == "bevel")
				m_joinStyle = PATH_STROKE_JOIN_BEVEL;
			break;
		case Stroke:
			if(m_flags & SVG_STYLE_FLAG_STROKE)
				redraw = true;
			if(inherit)
				m_flags &= ~SVG_STYLE_FLAG_STROKE;
			else
			{
				m_flags |= SVG_STYLE_FLAG_STROKE;

				if(!m_strokeColor)
				{
					m_strokeColor = new SVGPaintImpl(m_object);
					m_strokeColor->ref();
				}

				setPaint(param, m_strokeColor);
			}
			break;
		case Fill:
			if(m_flags & SVG_STYLE_FLAG_FILL)
			{
				redraw = true;
				update = UPDATE_STYLE;
			}
			if(inherit)
				m_flags &= ~SVG_STYLE_FLAG_FILL;
			else
			{
				m_flags |= SVG_STYLE_FLAG_FILL;

				if(!m_fillColor)
				{
					m_fillColor = new SVGPaintImpl(m_object);
					m_fillColor->ref();
				}

				setPaint(param, m_fillColor);
			}
			break;
		case Color:
			if(m_flags & SVG_STYLE_FLAG_COLOR)
				redraw = true;
			if(inherit)
				m_flags &= ~SVG_STYLE_FLAG_COLOR;
			else
			{
				m_flags |= SVG_STYLE_FLAG_COLOR;

				if(!m_color)
				{
					m_color = new SVGColorImpl(m_object);
					m_color->ref();
				}
				setColor(param, m_color);
			}
			break;
		case StopColor:
			m_flags |= SVG_STYLE_FLAG_STOP;

			if(!m_stopColor)
			{
				m_stopColor = new SVGColorImpl(m_object);
				m_stopColor->ref();
			}

			if(!inherit)
				setColor(param, m_stopColor);
			break;
		case ColorInterpolation:
			if(inherit)
				m_flags &= ~SVG_STYLE_FLAG_COLOR_INTERPOLATION;
			else
			{
				m_flags |= SVG_STYLE_FLAG_COLOR_INTERPOLATION;
				if(param == "auto" || param == "sRGB")
					m_colorInterpolation = CI_SRGB;
				else
				if(param == "linearRGB")
					m_colorInterpolation = CI_LINEARRGB;
			}
			break;
		case FontSize:
		{
			m_flags |= SVG_STYLE_FLAG_FONT_SIZE;				
			if(!inherit)
			{
				double temp = fontSizeForText(param);
				if(temp != -1) // Is "absolute-size"
				{
					m_fontSize = temp;
					break;
				}

				SVGLengthImpl *length = SVGSVGElementImpl::createSVGLength();
				length->setContext(m_object);
				length->setValueAsString(DOM::DOMString(param));
				m_fontSize = length->value();
				length->deref();
			}
			break;
		}
		case FontFamily:
			m_flags |= SVG_STYLE_FLAG_FONT_FAMILY;

			// Hacks
			// #1 Replace "'" characters by ""
			param = param.replace('\'', TQString());
			// #2 Replace "MS-Gothic" by "MS Gothic"
			param = param.replace("MS-Gothic", "MS Gothic");
			// #3 Replace "Helvetica" by "Arial"
			param = param.replace("Helvetica", "Arial");
			param = param.replace("helvetica", "Arial");

			if(!m_fontFamily)
			{
				m_fontFamily = new SVGStringListImpl();
				m_fontFamily->ref();
			}

			if(!inherit)
				SVGHelperImpl::parseCommaSeperatedList(m_fontFamily, param);
			break;
		case FontWeight:
			m_flags |= SVG_STYLE_FLAG_FONT_WEIGHT;
			if(!inherit)
				m_fontWeight = param;
			break;
		case FontStyle:
			m_flags |= SVG_STYLE_FLAG_FONT_STYLE;
			if(param == "normal")
				m_fontStyle = FSNORMAL;
			else if(param == "italic")
				m_fontStyle = ITALIC;
			else if(param == "oblique")
				m_fontStyle = OBLITQUE;
			break;
		case TextDecoration:
			m_flags |= SVG_STYLE_FLAG_TEXT_DECORATION;
			if(param == "none")
				m_textDecoration = TDNONE;
			{
				// CSS2 allows multiple decorations
				m_textDecoration = TDNONE;
				TQStringList decorations = TQStringList::split(' ', param);
				for(TQStringList::Iterator it = decorations.begin(); it != decorations.end(); ++it)
				{
					if(*it == "underline")
						m_textDecoration |= UNDERLINE;
					else if(*it == "overline")
						m_textDecoration |= OVERLINE;
					else if(*it == "line-through")
						m_textDecoration |= LINE_THROUGH;
				}
			}
			break;
		case TextAnchor:
			m_flags |= SVG_STYLE_FLAG_TEXT_ANCHOR;
			if(param == "start")
				m_textAnchor = TASTART;
			else if(param == "middle")
				m_textAnchor = TAMIDDLE;
			else if(param == "end")
				m_textAnchor = TAEND;
			break;
		case Direction:
			m_flags |= SVG_STYLE_FLAG_TEXT_DIRECTION;
			// Spec: direction is only processed when unicode-bidi
			//       is set to bidi-override or embedded
			if(m_textUnicodeBidi == OVERRIDE ||
				m_textUnicodeBidi == EMBED ||
				m_textUnicodeBidi == UBNORMAL)
			{
				if(param == "rtl")
					m_textDirection = RTL;
				else if(param == "ltr")
					m_textDirection = LTR;
			}
			break;
		case WritingMode:
			m_flags |= SVG_STYLE_FLAG_TEXT_WRITING_MODE;
			if(param == "lr-tb" || param == "lr")
				m_textWritingMode = LR;
			else if(param == "rl-tb" || param == "rl")
				m_textWritingMode = RL;
			else if(param == "tb-lr" || param == "tb")
				m_textWritingMode = TB;
			break;
		case UnicodeBidi:
			m_flags |= SVG_STYLE_FLAG_TEXT_UNICODE_BIDI;
			if(param == "normal")
				m_textUnicodeBidi = UBNORMAL;
			else if(param == "embed")
				m_textUnicodeBidi = EMBED;
			else if(param == "bidi-override")
				m_textUnicodeBidi = OVERRIDE;
			break;
		case GlyphOrientationVertical:
			m_flags |= SVG_STYLE_FLAG_GLYPH_ORIENTATION_VERTICAL;
			m_glyphOrientationVertical = param;
			break;
		case GlyphOrientationHorizontal:
			m_flags |= SVG_STYLE_FLAG_GLYPH_ORIENTATION_HORIZONTAL;
			m_glyphOrientationHorizontal = param;
			break;
		case Opacity:
			m_flags |= SVG_STYLE_FLAG_OPACITY;

			if(!inherit)
			{
				SVGLengthImpl::convertPercentageToFloat(value.toString(exec).qstring(), m_opacity);
			}
			break;
		case FillOpacity:
			m_flags |= SVG_STYLE_FLAG_FILL_OPACITY;

			if(!inherit)
			{
				SVGLengthImpl::convertPercentageToFloat(value.toString(exec).qstring(), m_fillOpacity);
			}
			break;
		case StrokeOpacity:
			m_flags |= SVG_STYLE_FLAG_STROKE_OPACITY;

			if(!inherit)
			{
				SVGLengthImpl::convertPercentageToFloat(value.toString(exec).qstring(), m_strokeOpacity);
			}
			break;
		case ClipPath:
			m_flags |= SVG_STYLE_FLAG_CLIP_PATH;
			if(!inherit)
				m_clipPath = extractUrlId(param);
			break;
		case Mask:
			m_flags |= SVG_STYLE_FLAG_MASK;
			if(!inherit)
				m_mask = extractUrlId(param);
			break;
		case MarkerStart:
			m_flags |= SVG_STYLE_FLAG_MARKER_START;
			if(!inherit)
				setStartMarker(param);
			break;
		case MarkerMid:
			m_flags |= SVG_STYLE_FLAG_MARKER_MID;
			if(!inherit)
				setMidMarker(param);
			break;
		case MarkerEnd:
			m_flags |= SVG_STYLE_FLAG_MARKER_END;
			if(!inherit)
				setEndMarker(param);
			break;
		case Marker:
			m_flags |= (SVG_STYLE_FLAG_MARKER_START | SVG_STYLE_FLAG_MARKER_MID | SVG_STYLE_FLAG_MARKER_END);
			if(!inherit)
				setMarkers(param);
			break;
		case PointerEvents:
			m_flags |= SVG_STYLE_FLAG_POINTER_EVENTS;
			if(param == "none")
				m_pointerEvents = PE_NONE;
			else if(param == "stroke")
				m_pointerEvents = PE_STROKE;
			else if(param == "fill")
				m_pointerEvents = PE_FILL;
			else if(param == "painted")
				m_pointerEvents = PE_PAINTED;
			else if(param == "visibleStroke")
				m_pointerEvents = PE_VISIBLE_STROKE;
			else if(param == "visibleFill")
				m_pointerEvents = PE_VISIBLE_FILL;
			else if(param == "visiblePainted")
				m_pointerEvents = PE_VISIBLE_PAINTED;
			else if(param == "visible")
				m_pointerEvents = PE_VISIBLE;
			else if(param == "all")
				m_pointerEvents = PE_ALL;
			break;
		case Cursor:
			m_flags |= SVG_STYLE_FLAG_CURSOR;
			if(param == "auto")
				m_cursor = CURSOR_AUTO;
			else if(param == "crosshair")
				m_cursor = CURSOR_CROSSHAIR;
			else if(param == "default")
				m_cursor = CURSOR_DEFAULT;
			else if(param == "pointer")
				m_cursor = CURSOR_POINTER;
			else if(param == "move")
				m_cursor = CURSOR_MOVE;
			else if(param == "e-resize")
				m_cursor = CURSOR_E_RESIZE;
			else if(param == "ne-resize")
				m_cursor = CURSOR_NE_RESIZE;
			else if(param == "nw-resize")
				m_cursor = CURSOR_NW_RESIZE;
			else if(param == "n-resize")
				m_cursor = CURSOR_N_RESIZE;
			else if(param == "se-resize")
				m_cursor = CURSOR_SE_RESIZE;
			else if(param == "sw-resize")
				m_cursor = CURSOR_SW_RESIZE;
			else if(param == "s-resize")
				m_cursor = CURSOR_S_RESIZE;
			else if(param == "w-resize")
				m_cursor = CURSOR_W_RESIZE;
			else if(param == "text")
				m_cursor = CURSOR_TEXT;
			else if(param == "wait")
				m_cursor = CURSOR_WAIT;
			else if(param == "help")
				m_cursor = CURSOR_HELP;
			break;
		case Display:
			m_flags |= SVG_STYLE_FLAG_DISPLAY;
	
			if(param == "none")
				m_display = false;
			else if(!inherit)
				m_display = true;
			break;
		case Overflow:
			m_flags |= SVG_STYLE_FLAG_OVERFLOW;
			if(param == "hidden" || param == "scroll")
				m_overflow = false;
			else if(!inherit)
				m_overflow = true;
			break;
		case Clip:
			m_flags |= SVG_STYLE_FLAG_CLIP_PATH;
			if(!inherit)
				setClip(param);
			break;
		case Visibility:
			if(m_flags & SVG_STYLE_FLAG_VISIBILITY)
				redraw = true;
			if(inherit)
				m_flags &= ~SVG_STYLE_FLAG_COLOR;
			else
			{
				m_flags |= SVG_STYLE_FLAG_VISIBILITY;

				if(param == "visible")
					m_visible = true;
				else if(!inherit)
					m_visible = false;

				// Just a quick fix for the script-* files (Niko)
				// Any better solution??
				update = UPDATE_TRANSFORM;
				redraw = true;
			}
			SVGHelperImpl::applyContainer<SVGStylableImpl>(this, Visibility, param);
			break;
		case FillRule:
			m_flags |= SVG_STYLE_FLAG_FILL_RULE;
			if(!inherit)
				m_fillRule = (param == "evenodd" ? RULE_EVENODD : RULE_NONZERO);
			break;
		case ClipRule:
			m_flags |= SVG_STYLE_FLAG_CLIP_RULE;
			if(!inherit)
				m_clipRule = (param == "evenodd" ? RULE_EVENODD : RULE_NONZERO);
			break;
		case StrokeDashOffset:
			m_flags |= SVG_STYLE_FLAG_STROKE_DASH_OFFSET;

			if(!m_dashOffset)
			{
				m_dashOffset = new SVGAnimatedLengthImpl(LENGTHMODE_OTHER, m_object);
				m_dashOffset->ref();
			}

			if(!inherit)
				m_dashOffset->baseVal()->setValueAsString(param);
			break;
		case StrokeDashArray:
		{
			m_flags |= SVG_STYLE_FLAG_STROKE_DASH_ARRAY;

			if(!m_dashArray)
			{
				m_dashArray = new SVGAnimatedLengthListImpl();
				m_dashArray->ref();
			}
			else
				m_dashArray->baseVal()->clear();

			if(param != "none" && !inherit)
				SVGHelperImpl::parseLengthList(m_dashArray, param);
			break;
		}
		case ColorProfile:
		{
			m_flags |= SVG_STYLE_FLAG_COLOR_PROFILE;
			if(!inherit)
			{
				if(!m_object)
					return;

				SVGColorProfileElementImpl *handle = static_cast<SVGColorProfileElementImpl *>(m_object->ownerSVGElement()->getElementById(SVGURIReferenceImpl::getTarget(param)));
				if(handle)
					SVGImageElementImpl::applyColorProfile(handle, static_cast<SVGImageElementImpl *>(this));
			}
			break;
		}
		case BaselineShift:
		{
			m_flags |= SVG_STYLE_FLAG_BASELINE_SHIFT;
			if(!inherit)
				m_baselineShift = param;
			break;
		}
		case LetterSpacing:
			m_flags |= SVG_STYLE_FLAG_LETTER_SPACING;
		case WordSpacing:
		{
			if(!inherit)
			{
				if(token == WordSpacing)
				{
					m_flags |= SVG_STYLE_FLAG_WORD_SPACING;
					m_wordSpacing = param;
				}
				else
					m_letterSpacing = param;
			}
			break;
		}
		default:
			kdWarning() << "Unhandled token in " << k_funcinfo << " : " << token << endl;
	}

	if(redraw)
	{
		SVGShapeImpl *shape = dynamic_cast<SVGShapeImpl *>(m_object);
		if(inherit)
			processStyle();
			
		if(shape && shape->item())
		{
			if(update > -1)
				shape->item()->update(static_cast<CanvasItemUpdate>(update));
			else if(m_object)
				m_object->ownerDoc()->canvas()->invalidate(shape->item(), false);
		}
	}
}

Value SVGStylableImplProtoFunc::call(ExecState *exec, Object &thisObj, const List &)
{
	KSVG_CHECK_THIS(SVGStylableImpl)

	switch(id)
	{
		case SVGStylableImpl::GetStyle:
			return Undefined();
		default:
			kdWarning() << "Unhandled function id in " << k_funcinfo << " : " << id << endl;
			break;
	}

	return Undefined();
}

// vim:ts=4:noet