+2006-09-20 Eric Seidel <eric@eseidel.com>
+
+ Reviewed by beth.
+
+ Cleanup style in KCanvas.
+ Remove extra white-space, unneeded arguments, etc.
+
+ * WebCore.xcodeproj/project.pbxproj:
+ * kcanvas/KCanvasClipper.cpp:
+ (WebCore::operator<<):
+ (WebCore::KCanvasClipper::externalRepresentation):
+ * kcanvas/KCanvasClipper.h:
+ * kcanvas/KCanvasFilters.cpp:
+ (WebCore::KCanvasFilter::externalRepresentation):
+ (WebCore::operator<<):
+ (WebCore::KCanvasFilterEffect::externalRepresentation):
+ (WebCore::KCPointLightSource::externalRepresentation):
+ (WebCore::KCSpotLightSource::externalRepresentation):
+ (WebCore::KCDistantLightSource::externalRepresentation):
+ (WebCore::KCanvasFEBlend::externalRepresentation):
+ (WebCore::KCanvasFEColorMatrix::externalRepresentation):
+ (WebCore::KCanvasFEComponentTransfer::externalRepresentation):
+ (WebCore::KCanvasFEComposite::externalRepresentation):
+ (WebCore::KCanvasFEConvolveMatrix::externalRepresentation):
+ (WebCore::KCanvasFEDiffuseLighting::externalRepresentation):
+ (WebCore::KCanvasFEDisplacementMap::externalRepresentation):
+ (WebCore::KCanvasFEFlood::externalRepresentation):
+ (WebCore::KCanvasFEGaussianBlur::externalRepresentation):
+ (WebCore::KCanvasFEImage::externalRepresentation):
+ (WebCore::KCanvasFEMerge::externalRepresentation):
+ (WebCore::KCanvasFEMorphology::externalRepresentation):
+ (WebCore::KCanvasFEOffset::externalRepresentation):
+ (WebCore::KCanvasFESpecularLighting::externalRepresentation):
+ (WebCore::KCanvasFETile::externalRepresentation):
+ (WebCore::KCanvasFETurbulence::externalRepresentation):
+ * kcanvas/KCanvasFilters.h:
+ (WebCore::KCanvasFEDiffuseLighting::lightSource):
+ (WebCore::KCanvasFESpecularLighting::lightSource):
+ * kcanvas/KCanvasImage.h:
+ * kcanvas/KCanvasMarker.cpp:
+ (WebCore::KCanvasMarker::externalRepresentation):
+ * kcanvas/KCanvasMarker.h:
+ * kcanvas/KCanvasResource.cpp:
+ (WebCore::operator<<):
+ * kcanvas/KCanvasResource.h:
+ * kcanvas/KCanvasTreeDebug.cpp:
+ (WebCore::operator<<):
+ (WebCore::writeIndent):
+ (WebCore::writeStyle):
+ (WebCore::write):
+ (WebCore::writeRenderResources):
+ * kcanvas/KCanvasTreeDebug.h:
+ (WebCore::operator<<):
+ * kcanvas/RenderForeignObject.cpp:
+ (WebCore::RenderForeignObject::paint):
+ * kcanvas/RenderPath.cpp:
+ (WebCore::RenderPath::paint):
+ (WebCore::drawStartAndMidMarkers):
+ * kcanvas/RenderSVGContainer.cpp:
+ (WebCore::RenderSVGContainer::paint):
+ * kcanvas/RenderSVGImage.cpp:
+ (WebCore::RenderSVGImage::translateForAttributes):
+ * kcanvas/RenderSVGImage.h:
+ * kcanvas/device/KRenderingDevice.cpp:
+ (WebCore::KRenderingDevice::currentContext):
+ (WebCore::KRenderingDevice::popContext):
+ (WebCore::KRenderingDevice::pushContext):
+ * kcanvas/device/KRenderingDevice.h:
+ * kcanvas/device/KRenderingFillPainter.h:
+ * kcanvas/device/KRenderingPaintServer.h:
+ (WebCore::KRenderingPaintServer::KRenderingPaintServer):
+ (WebCore::KRenderingPaintServer::activeClient):
+ (WebCore::KRenderingPaintServer::setActiveClient):
+ * kcanvas/device/KRenderingPaintServerGradient.cpp:
+ (WebCore::operator<<):
+ (WebCore::KRenderingPaintServerGradient::externalRepresentation):
+ (WebCore::KRenderingPaintServerLinearGradient::externalRepresentation):
+ (WebCore::KRenderingPaintServerGradient::listener):
+ (WebCore::KRenderingPaintServerGradient::setListener):
+ (WebCore::KRenderingPaintServerRadialGradient::externalRepresentation):
+ * kcanvas/device/KRenderingPaintServerGradient.h:
+ * kcanvas/device/KRenderingPaintServerPattern.cpp:
+ (WebCore::KRenderingPaintServerPattern::tile):
+ (WebCore::KRenderingPaintServerPattern::setTile):
+ (WebCore::KRenderingPaintServerPattern::listener):
+ (WebCore::KRenderingPaintServerPattern::setListener):
+ (WebCore::KRenderingPaintServerPattern::externalRepresentation):
+ * kcanvas/device/KRenderingPaintServerPattern.h:
+ * kcanvas/device/KRenderingPaintServerSolid.cpp:
+ (WebCore::KRenderingPaintServerSolid::externalRepresentation):
+ * kcanvas/device/KRenderingPaintServerSolid.h:
+ * kcanvas/device/KRenderingStrokePainter.cpp:
+ (WebCore::KRenderingStrokePainter::strokeMiterLimit):
+ (WebCore::KRenderingStrokePainter::setStrokeMiterLimit):
+ * kcanvas/device/KRenderingStrokePainter.h:
+ * kcanvas/device/quartz/KCanvasFilterQuartz.h:
+ * kcanvas/device/quartz/KCanvasFilterQuartz.mm:
+ (WebCore::KCanvasFilterQuartz::prepareFilter):
+ * kcanvas/device/quartz/KCanvasItemQuartz.h: Removed.
+ * kcanvas/device/quartz/KCanvasMaskerQuartz.mm:
+ (WebCore::KCanvasMaskerQuartz::applyMask):
+ * kcanvas/device/quartz/KCanvasResourcesQuartz.h:
+ (WebCore::KCanvasImageQuartz::init):
+ * kcanvas/device/quartz/KCanvasResourcesQuartz.mm:
+ (WebCore::KCanvasClipperQuartz::applyClip):
+ * kcanvas/device/quartz/KRenderingDeviceQuartz.h:
+ * kcanvas/device/quartz/KRenderingDeviceQuartz.mm:
+ (WebCore::KRenderingDeviceQuartz::quartzContext):
+ (WebCore::KRenderingDeviceQuartz::contextForImage):
+ (WebCore::KRenderingDeviceQuartz::createPaintServer):
+ (WebCore::KRenderingDeviceQuartz::createResource):
+ (WebCore::KRenderingDeviceQuartz::createFilterEffect):
+ * kcanvas/device/quartz/KRenderingPaintServerGradientQuartz.mm:
+ (WebCore::CGShadingRefForLinearGradient):
+ (WebCore::CGShadingRefForRadialGradient):
+ (WebCore::KRenderingPaintServerGradientQuartz::updateQuartzGradientCache):
+ (WebCore::KRenderingPaintServerGradientQuartz::teardown):
+ * kcanvas/device/quartz/KRenderingPaintServerQuartz.h:
+ * kcanvas/device/quartz/KRenderingPaintServerQuartz.mm:
+ (WebCore::KRenderingPaintServerQuartzHelper::strokePath):
+ (WebCore::KRenderingPaintServerQuartzHelper::clipToStrokePath):
+ (WebCore::KRenderingPaintServerQuartzHelper::fillPath):
+ (WebCore::KRenderingPaintServerQuartzHelper::clipToFillPath):
+ (WebCore::KRenderingPaintServerSolidQuartz::draw):
+ (WebCore::KRenderingPaintServerSolidQuartz::setup):
+ (WebCore::KRenderingPaintServerSolidQuartz::renderPath):
+ (WebCore::KRenderingPaintServerPatternQuartz::setup):
+ (WebCore::KRenderingPaintServerPatternQuartz::renderPath):
+ (WebCore::KRenderingPaintServerPatternQuartz::teardown):
+ * kcanvas/device/quartz/QuartzSupport.h:
+ * kcanvas/device/quartz/QuartzSupport.mm:
+ (WebCore::applyStrokeStyleToContext):
+
2006-09-20 Anders Carlsson <acarlsson@apple.com>
Reviewed by Dave Hyatt.
A88AD3A90952486D001DD196 /* WKSpotLightFilter.m in Sources */ = {isa = PBXBuildFile; fileRef = A8C32934093BB732000B9CAC /* WKSpotLightFilter.m */; };
A88AD3AA0952486D001DD196 /* KCanvasFilterQuartz.h in Headers */ = {isa = PBXBuildFile; fileRef = A8C0FB69089701F800BA5114 /* KCanvasFilterQuartz.h */; };
A88AD3AB0952486D001DD196 /* KCanvasFilterQuartz.mm in Sources */ = {isa = PBXBuildFile; fileRef = A8C0FB6A089701F800BA5114 /* KCanvasFilterQuartz.mm */; };
- A88AD3AC0952486D001DD196 /* KCanvasItemQuartz.h in Headers */ = {isa = PBXBuildFile; fileRef = A8C0FB6B089701F800BA5114 /* KCanvasItemQuartz.h */; };
A88AD3AD0952486D001DD196 /* KCanvasItemQuartz.mm in Sources */ = {isa = PBXBuildFile; fileRef = A8C0FB6C089701F800BA5114 /* KCanvasItemQuartz.mm */; };
A88AD3AE0952486D001DD196 /* KCanvasResourcesQuartz.h in Headers */ = {isa = PBXBuildFile; fileRef = A8C0FB6D089701F800BA5114 /* KCanvasResourcesQuartz.h */; };
A88AD3AF0952486D001DD196 /* KCanvasResourcesQuartz.mm in Sources */ = {isa = PBXBuildFile; fileRef = A8C0FB6E089701F800BA5114 /* KCanvasResourcesQuartz.mm */; };
A8C0FB65089701F700BA5114 /* KRenderingStrokePainter.h */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = KRenderingStrokePainter.h; sourceTree = "<group>"; tabWidth = 8; usesTabs = 0; };
A8C0FB69089701F800BA5114 /* KCanvasFilterQuartz.h */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = KCanvasFilterQuartz.h; sourceTree = "<group>"; tabWidth = 8; usesTabs = 0; };
A8C0FB6A089701F800BA5114 /* KCanvasFilterQuartz.mm */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = KCanvasFilterQuartz.mm; sourceTree = "<group>"; tabWidth = 8; usesTabs = 0; };
- A8C0FB6B089701F800BA5114 /* KCanvasItemQuartz.h */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = KCanvasItemQuartz.h; sourceTree = "<group>"; tabWidth = 8; usesTabs = 0; };
A8C0FB6C089701F800BA5114 /* KCanvasItemQuartz.mm */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = KCanvasItemQuartz.mm; sourceTree = "<group>"; tabWidth = 8; usesTabs = 0; };
A8C0FB6D089701F800BA5114 /* KCanvasResourcesQuartz.h */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = KCanvasResourcesQuartz.h; sourceTree = "<group>"; tabWidth = 8; usesTabs = 0; };
A8C0FB6E089701F800BA5114 /* KCanvasResourcesQuartz.mm */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = KCanvasResourcesQuartz.mm; sourceTree = "<group>"; tabWidth = 8; usesTabs = 0; };
A8C3291F093BB732000B9CAC /* filters */,
A8C0FB69089701F800BA5114 /* KCanvasFilterQuartz.h */,
A8C0FB6A089701F800BA5114 /* KCanvasFilterQuartz.mm */,
- A8C0FB6B089701F800BA5114 /* KCanvasItemQuartz.h */,
A8C0FB6C089701F800BA5114 /* KCanvasItemQuartz.mm */,
A81655D2096BBEAC00601058 /* KCanvasMaskerQuartz.h */,
A81655D3096BBEAC00601058 /* KCanvasMaskerQuartz.mm */,
A88AD3A50952486D001DD196 /* WKSpecularLightingFilter.h in Headers */,
A88AD3A80952486D001DD196 /* WKSpotLightFilter.h in Headers */,
A88AD3AA0952486D001DD196 /* KCanvasFilterQuartz.h in Headers */,
- A88AD3AC0952486D001DD196 /* KCanvasItemQuartz.h in Headers */,
A88AD3AE0952486D001DD196 /* KCanvasResourcesQuartz.h in Headers */,
A88AD3B00952486E001DD196 /* KRenderingDeviceQuartz.h in Headers */,
A88AD3B30952486E001DD196 /* KRenderingPaintServerQuartz.h in Headers */,
namespace WebCore {
-TextStream &operator<<(TextStream &ts, WindRule rule)
+TextStream& operator<<(TextStream& ts, WindRule rule)
{
switch (rule) {
case RULE_NONZERO:
return ts;
}
-TextStream &operator<<(TextStream &ts, const KCClipData &d)
+TextStream& operator<<(TextStream& ts, const KCClipData &d)
{
ts << "[winding=" << d.windRule() << "]";
if (d.bboxUnits)
return m_clipData;
}
-TextStream& KCanvasClipper::externalRepresentation(TextStream &ts) const
+TextStream& KCanvasClipper::externalRepresentation(TextStream& ts) const
{
ts << "[type=CLIPPER]";
ts << " [clip data=" << clipData() << "]";
{
KCanvasResource *resource = getResourceById(document, id);
if (resource && resource->isClipper())
- return static_cast<KCanvasClipper *>(resource);
+ return static_cast<KCanvasClipper*>(resource);
return 0;
}
namespace WebCore {
-typedef DeprecatedValueList<const RenderPath *> RenderPathList;
+typedef DeprecatedValueList<const RenderPath*> RenderPathList;
class TextStream;
KCClipDataList clipData() const;
- TextStream& externalRepresentation(TextStream &) const;
+ TextStream& externalRepresentation(TextStream&) const;
protected:
KCClipDataList m_clipData;
};
return filterBBox;
}
-TextStream &KCanvasFilter::externalRepresentation(TextStream &ts) const
+TextStream& KCanvasFilter::externalRepresentation(TextStream& ts) const
{
ts << "[type=FILTER] ";
FloatRect bbox = filterRect();
{
KCanvasResource *resource = getResourceById(document, id);
if (resource && resource->isFilter())
- return static_cast<KCanvasFilter *>(resource);
+ return static_cast<KCanvasFilter*>(resource);
return 0;
}
-TextStream &operator<<(TextStream &ts, const KCanvasFilterEffect &e)
+TextStream& operator<<(TextStream& ts, const KCanvasFilterEffect &e)
{
return e.externalRepresentation(ts);
}
m_result = result;
}
-static TextStream &operator<<(TextStream &ts, const KCanvasPoint3F p)
+static TextStream& operator<<(TextStream& ts, const KCanvasPoint3F p)
{
ts << "x=" << p.x() << " y=" << p.y() << " z=" << p.z();
return ts;
}
-TextStream &KCanvasFilterEffect::externalRepresentation(TextStream &ts) const
+TextStream& KCanvasFilterEffect::externalRepresentation(TextStream& ts) const
{
if (!in().isEmpty())
ts << "[in=\"" << in() << "\"]";
return ts;
}
-TextStream &KCPointLightSource::externalRepresentation(TextStream &ts) const
+TextStream& KCPointLightSource::externalRepresentation(TextStream& ts) const
{
ts << "[type=POINT-LIGHT] ";
ts << "[position=\"" << position() << "\"]";
return ts;
}
-TextStream &KCSpotLightSource::externalRepresentation(TextStream &ts) const
+TextStream& KCSpotLightSource::externalRepresentation(TextStream& ts) const
{
ts << "[type=SPOT-LIGHT] ";
ts << "[position=\"" << position() << "\"]";
return ts;
}
-TextStream &KCDistantLightSource::externalRepresentation(TextStream &ts) const
+TextStream& KCDistantLightSource::externalRepresentation(TextStream& ts) const
{
ts << "[type=DISTANT-LIGHT] ";
ts << "[azimuth=\"" << azimuth() << "\"]";
return ts;
}
-static TextStream &operator<<(TextStream &ts, KCBlendModeType t)
+static TextStream& operator<<(TextStream& ts, KCBlendModeType t)
{
switch (t)
{
return ts;
}
-TextStream &KCanvasFEBlend::externalRepresentation(TextStream &ts) const
+TextStream& KCanvasFEBlend::externalRepresentation(TextStream& ts) const
{
ts << "[type=BLEND] ";
KCanvasFilterEffect::externalRepresentation(ts);
return ts;
}
-static TextStream &operator<<(TextStream &ts, KCColorMatrixType t)
+static TextStream& operator<<(TextStream& ts, KCColorMatrixType t)
{
switch (t)
{
return ts;
}
-TextStream &KCanvasFEColorMatrix::externalRepresentation(TextStream &ts) const
+TextStream& KCanvasFEColorMatrix::externalRepresentation(TextStream& ts) const
{
ts << "[type=COLOR-MATRIX] ";
KCanvasFilterEffect::externalRepresentation(ts);
return ts;
}
-static TextStream &operator<<(TextStream &ts, KCComponentTransferType t)
+static TextStream& operator<<(TextStream& ts, KCComponentTransferType t)
{
switch (t)
{
return ts;
}
-static TextStream &operator<<(TextStream &ts, const KCComponentTransferFunction &func)
+static TextStream& operator<<(TextStream& ts, const KCComponentTransferFunction &func)
{
ts << "[type=" << func.type << "]";
switch (func.type) {
return ts;
}
-TextStream &KCanvasFEComponentTransfer::externalRepresentation(TextStream &ts) const
+TextStream& KCanvasFEComponentTransfer::externalRepresentation(TextStream& ts) const
{
ts << "[type=COMPONENT-TRANSFER] ";
KCanvasFilterEffect::externalRepresentation(ts);
return ts;
}
-TextStream &KCanvasFEComposite::externalRepresentation(TextStream &ts) const
+TextStream& KCanvasFEComposite::externalRepresentation(TextStream& ts) const
{
ts << "[type=COMPOSITE] ";
KCanvasFilterEffect::externalRepresentation(ts);
return ts;
}
-static TextStream &operator<<(TextStream &ts, KCEdgeModeType t)
+static TextStream& operator<<(TextStream& ts, KCEdgeModeType t)
{
switch (t)
{
return ts;
}
-TextStream &KCanvasFEConvolveMatrix::externalRepresentation(TextStream &ts) const
+TextStream& KCanvasFEConvolveMatrix::externalRepresentation(TextStream& ts) const
{
ts << "[type=CONVOLVE-MATRIX] ";
KCanvasFilterEffect::externalRepresentation(ts);
}
}
-TextStream &KCanvasFEDiffuseLighting::externalRepresentation(TextStream &ts) const
+TextStream& KCanvasFEDiffuseLighting::externalRepresentation(TextStream& ts) const
{
ts << "[type=DIFFUSE-LIGHTING] ";
KCanvasFilterEffect::externalRepresentation(ts);
return ts;
}
-static TextStream &operator<<(TextStream &ts, KCChannelSelectorType t)
+static TextStream& operator<<(TextStream& ts, KCChannelSelectorType t)
{
switch (t)
{
return ts;
}
-TextStream &KCanvasFEDisplacementMap::externalRepresentation(TextStream &ts) const
+TextStream& KCanvasFEDisplacementMap::externalRepresentation(TextStream& ts) const
{
ts << "[type=DISPLACEMENT-MAP] ";
KCanvasFilterEffect::externalRepresentation(ts);
return ts;
}
-TextStream &KCanvasFEFlood::externalRepresentation(TextStream &ts) const
+TextStream& KCanvasFEFlood::externalRepresentation(TextStream& ts) const
{
ts << "[type=FLOOD] ";
KCanvasFilterEffect::externalRepresentation(ts);
m_y = y;
}
-TextStream &KCanvasFEGaussianBlur::externalRepresentation(TextStream &ts) const
+TextStream& KCanvasFEGaussianBlur::externalRepresentation(TextStream& ts) const
{
ts << "[type=GAUSSIAN-BLUR] ";
KCanvasFilterEffect::externalRepresentation(ts);
return ts;
}
-TextStream &KCanvasFEImage::externalRepresentation(TextStream &ts) const
+TextStream& KCanvasFEImage::externalRepresentation(TextStream& ts) const
{
ts << "[type=IMAGE] ";
KCanvasFilterEffect::externalRepresentation(ts);
return ts;
}
-TextStream &KCanvasFEMerge::externalRepresentation(TextStream &ts) const
+TextStream& KCanvasFEMerge::externalRepresentation(TextStream& ts) const
{
ts << "[type=MERGE] ";
KCanvasFilterEffect::externalRepresentation(ts);
return ts;
}
-static TextStream &operator<<(TextStream &ts, KCMorphologyOperatorType t)
+static TextStream& operator<<(TextStream& ts, KCMorphologyOperatorType t)
{
switch (t)
{
return ts;
}
-TextStream &KCanvasFEMorphology::externalRepresentation(TextStream &ts) const
+TextStream& KCanvasFEMorphology::externalRepresentation(TextStream& ts) const
{
ts << "[type=MORPHOLOGY-OPERATOR] ";
KCanvasFilterEffect::externalRepresentation(ts);
return ts;
}
-TextStream &KCanvasFEOffset::externalRepresentation(TextStream &ts) const
+TextStream& KCanvasFEOffset::externalRepresentation(TextStream& ts) const
{
ts << "[type=OFFSET] "; KCanvasFilterEffect::externalRepresentation(ts)
<< " [dx=" << dx() << " dy=" << dy() << "]";
return ts;
}
-TextStream &KCanvasFESpecularLighting::externalRepresentation(TextStream &ts) const
+TextStream& KCanvasFESpecularLighting::externalRepresentation(TextStream& ts) const
{
ts << "[type=SPECULAR-LIGHTING] ";
KCanvasFilterEffect::externalRepresentation(ts);
#if 0
///FIXME: KCanvasFETile doesn't have any properties
-TextStream &KCanvasFETile::externalRepresentation(TextStream &ts) const
+TextStream& KCanvasFETile::externalRepresentation(TextStream& ts) const
{
KCanvasFilterEffect::externalRepresentation(ts);
return ts;
}
#endif
-static TextStream &operator<<(TextStream &ts, KCTurbulanceType t)
+static TextStream& operator<<(TextStream& ts, KCTurbulanceType t)
{
switch (t)
{
return ts;
}
-TextStream &KCanvasFETurbulence::externalRepresentation(TextStream &ts) const
+TextStream& KCanvasFETurbulence::externalRepresentation(TextStream& ts) const
{
ts << "[type=TURBULENCE] ";
KCanvasFilterEffect::externalRepresentation(ts);
FloatRect filterBBoxForItemBBox(FloatRect itemBBox) const;
void clearEffects();
- void addFilterEffect(KCanvasFilterEffect *effect);
+ void addFilterEffect(KCanvasFilterEffect*);
virtual void prepareFilter(const FloatRect &bbox) = 0;
virtual void applyFilter(const FloatRect &bbox) = 0;
- TextStream &externalRepresentation(TextStream &) const;
+ TextStream& externalRepresentation(TextStream&) const;
protected:
FloatRect m_filterRect;
- DeprecatedValueList<KCanvasFilterEffect *> m_effects;
+ DeprecatedValueList<KCanvasFilterEffect* > m_effects;
bool m_filterBBoxMode;
bool m_effectBBoxMode;
};
-KCanvasFilter *getFilterById(Document *document, const AtomicString &id);
+KCanvasFilter* getFilterById(Document*, const AtomicString&);
class KCanvasFilterEffect {
public:
virtual KCFilterEffectType effectType() const { return FE_TURBULENCE; }
FloatRect subRegion() const;
- void setSubRegion(const FloatRect &subregion);
+ void setSubRegion(const FloatRect&);
String in() const;
- void setIn(const String &in);
+ void setIn(const String&);
String result() const;
- void setResult(const String &result);
+ void setResult(const String&);
#if __APPLE__
virtual CIFilter* getCIFilter(KCanvasFilterQuartz*) const = 0;
#endif
- virtual TextStream &externalRepresentation(TextStream &) const;
+ virtual TextStream& externalRepresentation(TextStream&) const;
private:
FloatRect m_subregion;
String m_result;
};
-TextStream &operator<<(TextStream &, const KCanvasFilterEffect &);
+TextStream& operator<<(TextStream&, const KCanvasFilterEffect&);
typedef enum {
BM_NORMAL = 0,
KCBlendModeType blendMode() const { return m_mode; }
void setBlendMode(KCBlendModeType mode) { m_mode = mode; }
- TextStream &externalRepresentation(TextStream &) const;
+ TextStream& externalRepresentation(TextStream&) const;
private:
KCBlendModeType m_mode;
DeprecatedValueList<float> values() const { return m_values; }
void setValues(const DeprecatedValueList<float> &values) { m_values = values; };
- TextStream &externalRepresentation(TextStream &) const;
+ TextStream& externalRepresentation(TextStream&) const;
private:
KCColorMatrixType m_type;
float k4() const { return m_k4; }
void setK4(float k4) { m_k4 = k4; }
- TextStream &externalRepresentation(TextStream &) const;
+ TextStream& externalRepresentation(TextStream&) const;
private:
String m_in2;
bool preserveAlpha() const { return m_preserveAlpha; }
void setPreserveAlpha(bool preserveAlpha) { m_preserveAlpha = preserveAlpha; }
- TextStream &externalRepresentation(TextStream &) const;
+ TextStream& externalRepresentation(TextStream&) const;
private:
FloatSize m_kernelSize;
KCLightType type() const { return m_type; }
- virtual TextStream &externalRepresentation(TextStream &) const = 0;
+ virtual TextStream& externalRepresentation(TextStream&) const = 0;
private:
KCLightType m_type;
float azimuth() const{ return m_azimuth; }
float elevation() const{ return m_elevation; }
- virtual TextStream &externalRepresentation(TextStream &) const;
+ virtual TextStream& externalRepresentation(TextStream&) const;
private:
float m_azimuth;
float kernelUnitLengthY() const { return m_kernelUnitLengthY; }
void setKernelUnitLengthY(float kernelUnitLengthY) { m_kernelUnitLengthY = kernelUnitLengthY; }
- const KCLightSource *lightSource() const { return m_lightSource; }
- void setLightSource(KCLightSource *lightSource);
+ const KCLightSource* lightSource() const { return m_lightSource; }
+ void setLightSource(KCLightSource*);
- TextStream &externalRepresentation(TextStream &) const;
+ TextStream& externalRepresentation(TextStream&) const;
private:
Color m_lightingColor;
float m_diffuseConstant;
float m_kernelUnitLengthX;
float m_kernelUnitLengthY;
- KCLightSource *m_lightSource;
+ KCLightSource* m_lightSource;
};
typedef enum {
float scale() const { return m_scale; }
void setScale(float scale) { m_scale = scale; }
- TextStream &externalRepresentation(TextStream &) const;
+ TextStream& externalRepresentation(TextStream&) const;
private:
String m_in2;
float floodOpacity() const { return m_floodOpacity; }
void setFloodOpacity(float floodOpacity) { m_floodOpacity = floodOpacity; }
- TextStream &externalRepresentation(TextStream &) const;
+ TextStream& externalRepresentation(TextStream&) const;
private:
Color m_floodColor;
class KCanvasFEGaussianBlur : public KCanvasFilterEffect {
public:
float stdDeviationX() const;
- void setStdDeviationX(float x);
+ void setStdDeviationX(float);
float stdDeviationY() const;
- void setStdDeviationY(float y);
+ void setStdDeviationY(float);
- TextStream &externalRepresentation(TextStream &) const;
+ TextStream& externalRepresentation(TextStream&) const;
private:
float m_x;
virtual ~KCanvasFEImage();
- // FIXME: Eventually we need to support <svg> (RenderObject *) as well as image data.
+ // FIXME: Eventually we need to support <svg> (RenderObject*) as well as image data.
CachedImage* cachedImage() const { return m_cachedImage; }
- void setCachedImage(CachedImage* image);
+ void setCachedImage(CachedImage*);
- TextStream &externalRepresentation(TextStream &) const;
+ TextStream& externalRepresentation(TextStream&) const;
private:
CachedImage* m_cachedImage;
const Vector<String>& mergeInputs() const { return m_mergeInputs; }
void setMergeInputs(const Vector<String>& mergeInputs) { m_mergeInputs = mergeInputs; }
- TextStream &externalRepresentation(TextStream &) const;
+ TextStream& externalRepresentation(TextStream&) const;
private:
Vector<String> m_mergeInputs;
float radiusY() const { return m_radiusY; }
void setRadiusY(float radiusY) { m_radiusY = radiusY; }
- TextStream &externalRepresentation(TextStream &) const;
+ TextStream& externalRepresentation(TextStream&) const;
private:
KCMorphologyOperatorType m_operator;
float dy() const { return m_dy; }
void setDy(float dy) { m_dy = dy; }
- TextStream &externalRepresentation(TextStream &) const;
+ TextStream& externalRepresentation(TextStream&) const;
private:
float m_dx;
float kernelUnitLengthY() const { return m_kernelUnitLengthY; }
void setKernelUnitLengthY(float kernelUnitLengthY) { m_kernelUnitLengthY = kernelUnitLengthY; }
- const KCLightSource *lightSource() const { return m_lightSource; }
- void setLightSource(KCLightSource *lightSource);
+ const KCLightSource* lightSource() const { return m_lightSource; }
+ void setLightSource(KCLightSource*);
- TextStream &externalRepresentation(TextStream &) const;
+ TextStream& externalRepresentation(TextStream&) const;
private:
Color m_lightingColor;
float m_specularExponent;
float m_kernelUnitLengthX;
float m_kernelUnitLengthY;
- KCLightSource *m_lightSource;
+ KCLightSource* m_lightSource;
};
class KCanvasFETile : public KCanvasFilterEffect { };
bool stitchTiles() const { return m_stitchTiles; }
void setStitchTiles(bool stitch) { m_stitchTiles = stitch; }
- TextStream &externalRepresentation(TextStream &) const;
+ TextStream& externalRepresentation(TextStream&) const;
private:
float m_baseFrequencyX;
KCanvasImage() { };
virtual ~KCanvasImage() { };
- virtual void init(const Image &) = 0;
+ virtual void init(const Image&) = 0;
virtual void init(IntSize) = 0;
virtual IntSize size() = 0;
context->restore();
}
-TextStream& KCanvasMarker::externalRepresentation(TextStream &ts) const
+TextStream& KCanvasMarker::externalRepresentation(TextStream& ts) const
{
ts << "[type=MARKER]"
<< " [angle=";
{
KCanvasResource *resource = getResourceById(document, id);
if (resource && resource->isMarker())
- return static_cast<KCanvasMarker *>(resource);
+ return static_cast<KCanvasMarker*>(resource);
return 0;
}
void draw(GraphicsContext*, const FloatRect&, double x, double y, double strokeWidth = 1, double angle = 0);
- TextStream& externalRepresentation(TextStream &) const;
+ TextStream& externalRepresentation(TextStream&) const;
private:
double m_refX, m_refY;
namespace WebCore {
-TextStream &operator<<(TextStream& ts, const KCanvasResource& r)
+TextStream& operator<<(TextStream& ts, const KCanvasResource& r)
{
return r.externalRepresentation(ts);
}
namespace WebCore {
-typedef DeprecatedValueList<const RenderPath *> RenderPathList;
+typedef DeprecatedValueList<const RenderPath*> RenderPathList;
class TextStream;
virtual bool isMarker() const { return false; }
virtual bool isMasker() const { return false; }
- virtual TextStream& externalRepresentation(TextStream &) const;
+ virtual TextStream& externalRepresentation(TextStream&) const;
private:
RenderPathList m_clients;
String m_registryId;
KCanvasResource* getResourceById(Document*, const AtomicString&);
KRenderingPaintServer* getPaintServerById(Document*, const AtomicString&);
-TextStream &operator<<(TextStream&, const KCanvasResource&);
+TextStream& operator<<(TextStream&, const KCanvasResource&);
}
public:
TextStreamSeparator(const DeprecatedString &s) : m_separator(s), m_needToSeparate(false) {}
private:
- friend TextStream& operator<<(TextStream &ts, TextStreamSeparator &sep);
+ friend TextStream& operator<<(TextStream& ts, TextStreamSeparator &sep);
private:
DeprecatedString m_separator;
bool m_needToSeparate;
};
-TextStream& operator<<(TextStream &ts, TextStreamSeparator &sep)
+TextStream& operator<<(TextStream& ts, TextStreamSeparator &sep)
{
if (sep.m_needToSeparate)
ts << sep.m_separator;
return ts;
}
-TextStream &operator<<(TextStream &ts, const IntPoint &p)
+TextStream& operator<<(TextStream& ts, const IntPoint &p)
{
return ts << "(" << p.x() << "," << p.y() << ")";
}
-TextStream &operator<<(TextStream &ts, const IntRect &r)
+TextStream& operator<<(TextStream& ts, const IntRect &r)
{
return ts << "at (" << r.x() << "," << r.y() << ") size " << r.width() << "x" << r.height();
}
return (fabs(val-dval) > epsilon);
}
-TextStream &operator<<(TextStream &ts, const FloatRect &r)
+TextStream& operator<<(TextStream& ts, const FloatRect &r)
{
ts << "at (";
if (hasFractions(r.x()))
return ts;
}
-TextStream &operator<<(TextStream &ts, const FloatPoint &p)
+TextStream& operator<<(TextStream& ts, const FloatPoint &p)
{
ts << "(";
if (hasFractions(p.x()))
return ts << ")";
}
-TextStream &operator<<(TextStream &ts, const FloatSize &s)
+TextStream& operator<<(TextStream& ts, const FloatSize &s)
{
ts << "width=";
if (hasFractions(s.width()))
}
-TextStream &operator<<(TextStream &ts, const AffineTransform &m)
+TextStream& operator<<(TextStream& ts, const AffineTransform &m)
{
if (m.isIdentity())
ts << "identity";
return ts;
}
-TextStream &operator<<(TextStream &ts, const Color &c)
+TextStream& operator<<(TextStream& ts, const Color &c)
{
return ts << c.name();
}
-static void writeIndent(TextStream &ts, int indent)
+static void writeIndent(TextStream& ts, int indent)
{
for (int i = 0; i != indent; ++i) {
ts << " ";
}
//FIXME: This should be in KRenderingStyle.cpp
-static TextStream &operator<<(TextStream &ts, const KCDashArray &a)
+static TextStream& operator<<(TextStream& ts, const KCDashArray &a)
{
ts << "{";
for (KCDashArray::ConstIterator it = a.begin(); it != a.end(); ++it) {
}
//FIXME: This should be in KRenderingStyle.cpp
-static TextStream &operator<<(TextStream &ts, KCCapStyle style)
+static TextStream& operator<<(TextStream& ts, KCCapStyle style)
{
switch (style) {
case CAP_BUTT:
}
//FIXME: This should be in KRenderingStyle.cpp
-static TextStream &operator<<(TextStream &ts, KCJoinStyle style)
+static TextStream& operator<<(TextStream& ts, KCJoinStyle style)
{
switch (style) {
case JOIN_MITER:
// for the parent object
#define DIFFERS_FROM_PARENT_AVOID_TEST_IF_FALSE(pred, path) (!parentStyle || ((!parentStyle->pred) || (parentStyle->path != childStyle->path)))
-static void writeStyle(TextStream &ts, const RenderObject &object)
+static void writeStyle(TextStream& ts, const RenderObject &object)
{
- const RenderStyle *style = object.style();
- const SVGRenderStyle *svgStyle = style->svgStyle();
+ const RenderStyle* style = object.style();
+ const SVGRenderStyle* svgStyle = style->svgStyle();
if (!object.localTransform().isIdentity())
ts << " [transform=" << object.localTransform() << "]";
#undef DIFFERS_FROM_PARENT
#undef DIFFERS_FROM_PARENT_AVOID_TEST_IF_FALSE
-static TextStream &operator<<(TextStream &ts, const RenderPath &o)
+static TextStream& operator<<(TextStream& ts, const RenderPath &o)
{
ts << " " << o.absoluteTransform().mapRect(o.relativeBBox());
return ts;
}
-static TextStream &operator<<(TextStream &ts, const RenderSVGContainer &o)
+static TextStream& operator<<(TextStream& ts, const RenderSVGContainer &o)
{
ts << " " << o.absoluteTransform().mapRect(o.relativeBBox());
static DeprecatedString getTagName(void *node)
{
- SVGStyledElement *elem = static_cast<SVGStyledElement *>(node);
+ SVGStyledElement *elem = static_cast<SVGStyledElement*>(node);
if (elem)
return String(elem->nodeName()).deprecatedString();
return DeprecatedString();
}
-void write(TextStream &ts, const RenderSVGContainer &container, int indent)
+void write(TextStream& ts, const RenderSVGContainer &container, int indent)
{
writeIndent(ts, indent);
ts << container.renderName();
write(ts, *child, indent + 1);
}
-void write(TextStream &ts, const RenderPath &path, int indent)
+void write(TextStream& ts, const RenderPath &path, int indent)
{
writeIndent(ts, indent);
ts << path.renderName();
ts << path << endl;
}
-void writeRenderResources(TextStream &ts, Node *parent)
+void writeRenderResources(TextStream& ts, Node *parent)
{
ASSERT(parent);
Node *node = parent;
do {
if (!node->isSVGElement())
continue;
- SVGElement *svgElement = static_cast<SVGElement *>(node);
+ SVGElement *svgElement = static_cast<SVGElement*>(node);
if (!svgElement->isStyled())
continue;
- SVGStyledElement *styled = static_cast<SVGStyledElement *>(svgElement);
+ SVGStyledElement *styled = static_cast<SVGStyledElement*>(svgElement);
KCanvasResource *resource = styled->canvasResource();
if (!resource)
continue;
DeprecatedString elementId = svgElement->getAttribute(HTMLNames::idAttr).deprecatedString();
if (resource->isPaintServer())
- ts << "KRenderingPaintServer {id=\"" << elementId << "\" " << *static_cast<KRenderingPaintServer *>(resource) << "}" << endl;
+ ts << "KRenderingPaintServer {id=\"" << elementId << "\" " << *static_cast<KRenderingPaintServer*>(resource) << "}" << endl;
else
ts << "KCanvasResource {id=\"" << elementId << "\" " << *resource << "}" << endl;
} while ((node = node->traverseNextNode(parent)));
}
-TextStream &operator<<(TextStream &ts, const DeprecatedStringList &l)
+TextStream& operator<<(TextStream& ts, const DeprecatedStringList &l)
{
ts << "[";
DeprecatedStringList::ConstIterator it = l.begin();
class RenderSVGContainer;
// functions used by the main RenderTreeAsText code
-void write(TextStream &ts, const RenderSVGContainer &container, int indent = 0);
-void write(TextStream &ts, const RenderPath &path, int indent = 0);
-void writeRenderResources(TextStream &ts, Node *parent);
+void write(TextStream&, const RenderSVGContainer&, int indent = 0);
+void write(TextStream&, const RenderPath&, int indent = 0);
+void writeRenderResources(TextStream&, Node* parent);
// helper operators defined used in various classes to dump the render tree.
-TextStream &operator<<(TextStream &ts, const AffineTransform &);
-TextStream &operator<<(TextStream &ts, const IntRect &);
-TextStream &operator<<(TextStream &ts, const Color &);
-TextStream &operator<<(TextStream &ts, const IntPoint &);
-TextStream &operator<<(TextStream &ts, const FloatSize &);
-TextStream &operator<<(TextStream &ts, const FloatRect &);
-TextStream &operator<<(TextStream &ts, const FloatPoint &);
+TextStream& operator<<(TextStream&, const AffineTransform&);
+TextStream& operator<<(TextStream&, const IntRect&);
+TextStream& operator<<(TextStream&, const Color&);
+TextStream& operator<<(TextStream&, const IntPoint&);
+TextStream& operator<<(TextStream&, const FloatSize&);
+TextStream& operator<<(TextStream&, const FloatRect&);
+TextStream& operator<<(TextStream&, const FloatPoint&);
// helper operators specific to dumping the render tree. these are used in various classes to dump the render tree
// these could be defined in separate namespace to avoid matching these generic signatures unintentionally.
-TextStream &operator<<(TextStream &ts, const DeprecatedStringList &l);
+TextStream& operator<<(TextStream&, const DeprecatedStringList&);
template<typename Item>
-TextStream &operator<<(TextStream &ts, const DeprecatedValueList<Item*> &l)
+TextStream& operator<<(TextStream& ts, const DeprecatedValueList<Item*>& l)
{
ts << "[";
typename DeprecatedValueList<Item*>::ConstIterator it = l.begin();
typename DeprecatedValueList<Item*>::ConstIterator it_e = l.end();
- while (it != it_e)
- {
+ while (it != it_e) {
ts << *(*it);
++it;
if (it != it_e) ts << ", ";
}
template<typename Item>
-TextStream &operator<<(TextStream &ts, const DeprecatedValueList<Item> &l)
+TextStream& operator<<(TextStream& ts, const DeprecatedValueList<Item>& l)
{
ts << "[";
typename DeprecatedValueList<Item>::ConstIterator it = l.begin();
typename DeprecatedValueList<Item>::ConstIterator it_e = l.end();
- while (it != it_e)
- {
+ while (it != it_e) {
ts << *it;
++it;
if (it != it_e) ts << ", ";
AffineTransform RenderForeignObject::translationForAttributes()
{
- SVGForeignObjectElement* foreign = static_cast<SVGForeignObjectElement *>(element());
+ SVGForeignObjectElement* foreign = static_cast<SVGForeignObjectElement*>(element());
return AffineTransform().translate(foreign->x()->value(), foreign->y()->value());
}
return;
KRenderingDevice *device = renderingDevice();
- KRenderingDeviceContext *context = device->currentContext();
+ KRenderingDeviceContext* context = device->currentContext();
bool shouldPopContext = false;
if (!context) {
// Only need to setup for KCanvas rendering if it hasn't already been done.
return;
KRenderingDevice* device = renderingDevice();
- KRenderingDeviceContext *context = device->currentContext();
+ KRenderingDeviceContext* context = device->currentContext();
bool shouldPopContext = false;
if (context)
paintInfo.p->save();
static void drawStartAndMidMarkers(void *info, const PathElement *element)
{
- DrawMarkersData &data = *(DrawMarkersData *)info;
+ DrawMarkersData& data = *reinterpret_cast<DrawMarkersData*>(info);
int elementIndex = data.elementIndex;
MarkerData &previousMarkerData = data.previousMarkerData;
void RenderPath::drawMarkersIfNeeded(GraphicsContext* context, const FloatRect& rect, const Path& path) const
{
Document *doc = document();
- const SVGRenderStyle *svgStyle = style()->svgStyle();
+ const SVGRenderStyle* svgStyle = style()->svgStyle();
KCanvasMarker* startMarker = getMarkerById(doc, svgStyle->startMarker().substring(1));
KCanvasMarker* midMarker = getMarkerById(doc, svgStyle->midMarker().substring(1));
class RenderPath : public RenderObject
{
public:
- RenderPath(RenderStyle *style, SVGStyledElement *node);
+ RenderPath(RenderStyle* style, SVGStyledElement *node);
virtual ~RenderPath();
// Hit-detection seperated for the fill and the stroke
return; // Spec: groups w/o children still may render filter content.
KRenderingDevice* device = renderingDevice();
- KRenderingDeviceContext *deviceContext = device->currentContext();
+ KRenderingDeviceContext* deviceContext = device->currentContext();
bool shouldPopContext = false;
if (!deviceContext) {
// I only need to setup for KCanvas rendering if it hasn't already been done.
{
RenderObject *current = firstChild();
while (current != 0) {
- if (current->isRenderPath() && static_cast<RenderPath *>(current)->fillContains(p))
+ if (current->isRenderPath() && static_cast<RenderPath*>(current)->fillContains(p))
return true;
current = current->nextSibling();
}
{
RenderObject *current = firstChild();
while (current != 0) {
- if (current->isRenderPath() && static_cast<RenderPath *>(current)->strokeContains(p))
+ if (current->isRenderPath() && static_cast<RenderPath*>(current)->strokeContains(p))
return true;
current = current->nextSibling();
}
translateForAttributes();
FloatRect boundingBox = FloatRect(0, 0, width(), height());
- const SVGRenderStyle *svgStyle = style()->svgStyle();
+ const SVGRenderStyle* svgStyle = style()->svgStyle();
if (KCanvasClipper* clipper = getClipperById(document(), svgStyle->clipPath().substring(1)))
clipper->applyClip(boundingBox);
int x = 0, y = 0;
if (shouldPaint(pi, x, y)) {
- SVGImageElement *imageElt = static_cast<SVGImageElement *>(node());
+ SVGImageElement *imageElt = static_cast<SVGImageElement*>(node());
if (imageElt->preserveAspectRatio()->align() == SVGPreserveAspectRatio::SVG_PRESERVEASPECTRATIO_NONE)
RenderImage::paint(pi, 0, 0);
FloatRect RenderSVGImage::relativeBBox(bool includeStroke) const
{
- SVGImageElement *image = static_cast<SVGImageElement *>(node());
+ SVGImageElement *image = static_cast<SVGImageElement*>(node());
return FloatRect(image->x()->value(), image->y()->value(), width(), height());
}
IntRect RenderSVGImage::getAbsoluteRepaintRect()
{
- SVGImageElement *image = static_cast<SVGImageElement *>(node());
+ SVGImageElement *image = static_cast<SVGImageElement*>(node());
FloatRect repaintRect = absoluteTransform().mapRect(FloatRect(image->x()->value(), image->y()->value(), width(), height()));
// Filters can expand the bounding box
AffineTransform RenderSVGImage::translationForAttributes()
{
- SVGImageElement *image = static_cast<SVGImageElement *>(node());
+ SVGImageElement *image = static_cast<SVGImageElement*>(node());
return AffineTransform().translate(image->x()->value(), image->y()->value());
}
void RenderSVGImage::translateForAttributes()
{
- KRenderingDeviceContext *context = renderingDevice()->currentContext();
+ KRenderingDeviceContext* context = renderingDevice()->currentContext();
context->concatCTM(translationForAttributes());
}
class RenderSVGImage : public RenderImage {
public:
- RenderSVGImage(SVGImageElement *impl);
+ RenderSVGImage(SVGImageElement*);
virtual ~RenderSVGImage();
virtual AffineTransform localTransform() const { return m_transform; }
virtual void absoluteRects(Vector<IntRect>&, int tx, int ty);
virtual void imageChanged(CachedImage*);
- void adjustRectsForAspectRatio(FloatRect& destRect, FloatRect& srcRect, SVGPreserveAspectRatio *aspectRatio);
- virtual void paint(PaintInfo& paintInfo, int parentX, int parentY);
+ void adjustRectsForAspectRatio(FloatRect& destRect, FloatRect& srcRect, SVGPreserveAspectRatio*);
+ virtual void paint(PaintInfo&, int parentX, int parentY);
virtual void layout();
bool requiresLayer();
- virtual void computeAbsoluteRepaintRect(IntRect& r, bool f);
+ virtual void computeAbsoluteRepaintRect(IntRect&, bool f);
- virtual bool nodeAtPoint(NodeInfo& info, int _x, int _y, int _tx, int _ty, HitTestAction hitTestAction);
+ virtual bool nodeAtPoint(NodeInfo&, int _x, int _y, int _tx, int _ty, HitTestAction);
private:
void translateForAttributes();
AffineTransform RenderSVGText::translationForAttributes()
{
- SVGTextElement *text = static_cast<SVGTextElement *>(element());
+ SVGTextElement *text = static_cast<SVGTextElement*>(element());
SVGLength* xOffset = text->x()->getFirst().get();
SVGLength* yOffset = text->y()->getFirst().get();
context->concatCTM(translationTopToBaseline());
FloatRect boundingBox(0, 0, width(), height());
- const SVGRenderStyle *svgStyle = style()->svgStyle();
+ const SVGRenderStyle* svgStyle = style()->svgStyle();
if (KCanvasClipper* clipper = getClipperById(document(), svgStyle->clipPath().substring(1)))
clipper->applyClip(boundingBox);
{
}
-KRenderingDeviceContext *KRenderingDevice::currentContext() const
+KRenderingDeviceContext* KRenderingDevice::currentContext() const
{
if (m_contextStack.isEmpty())
return 0;
return m_contextStack.last();
}
-KRenderingDeviceContext *KRenderingDevice::popContext()
+KRenderingDeviceContext* KRenderingDevice::popContext()
{
- KRenderingDeviceContext *result = m_contextStack.last();
+ KRenderingDeviceContext* result = m_contextStack.last();
m_contextStack.removeLast();
return result;
}
-void KRenderingDevice::pushContext(KRenderingDeviceContext *context)
+void KRenderingDevice::pushContext(KRenderingDeviceContext* context)
{
m_contextStack.append(context);
}
#define KRenderingDevice_H
#ifdef SVG_SUPPORT
-#include <kcanvas/KCanvasFilters.h>
-#include <kcanvas/device/KRenderingPaintServer.h>
+#include "KCanvasFilters.h"
+#include "KRenderingPaintServer.h"
namespace WebCore {
virtual bool isBuffered() const = 0;
// Global rendering device context
- KRenderingDeviceContext *currentContext() const;
+ KRenderingDeviceContext* currentContext() const;
- virtual KRenderingDeviceContext *popContext();
- virtual void pushContext(KRenderingDeviceContext *context);
+ virtual KRenderingDeviceContext* popContext();
+ virtual void pushContext(KRenderingDeviceContext*);
- virtual KRenderingDeviceContext *contextForImage(KCanvasImage *image) const = 0;
+ virtual KRenderingDeviceContext* contextForImage(KCanvasImage*) const = 0;
// Creation tools
- virtual KCanvasResource *createResource(const KCResourceType &type) const = 0;
- virtual KCanvasFilterEffect *createFilterEffect(const KCFilterEffectType &type) const = 0;
- virtual KRenderingPaintServer *createPaintServer(const KCPaintServerType &type) const = 0;
+ virtual KCanvasResource* createResource(const KCResourceType&) const = 0;
+ virtual KCanvasFilterEffect* createFilterEffect(const KCFilterEffectType&) const = 0;
+ virtual KRenderingPaintServer* createPaintServer(const KCPaintServerType&) const = 0;
private:
Vector<KRenderingDeviceContext*> m_contextStack;
virtual ~KRenderingFillPainter();
WindRule fillRule() const;
- void setFillRule(WindRule rule);
+ void setFillRule(WindRule);
float opacity() const;
- void setOpacity(float opacity);
+ void setOpacity(float);
private:
float m_opacity;
class KRenderingPaintServer : public KCanvasResource
{
public:
- KRenderingPaintServer() : KCanvasResource(), m_activeClient(0), m_paintingText(false) { }
+ KRenderingPaintServer()
+ : KCanvasResource()
+ , m_activeClient(0)
+ , m_paintingText(false)
+ { }
virtual ~KRenderingPaintServer() { }
virtual bool isPaintServer() const { return true; }
- const RenderPath *activeClient() const { return m_activeClient;}
- void setActiveClient(const RenderPath *client) { m_activeClient = client; }
+ const RenderPath* activeClient() const { return m_activeClient;}
+ void setActiveClient(const RenderPath* client) { m_activeClient = client; }
String idInRegistry() const { return m_registryId; }
void setIdInRegistry(const String& newId) { m_registryId = newId; }
virtual KCPaintServerType type() const = 0;
// Actual rendering function
- virtual void draw(KRenderingDeviceContext*, const RenderPath* renderPath, KCPaintTargetType) const = 0;
+ virtual void draw(KRenderingDeviceContext*, const RenderPath*, KCPaintTargetType) const = 0;
virtual bool setup(KRenderingDeviceContext*, const RenderObject*, KCPaintTargetType) const = 0;
virtual void teardown(KRenderingDeviceContext*, const RenderObject*, KCPaintTargetType) const = 0;
bool isPaintingText() const { return m_paintingText; }
void setPaintingText(bool paintingText) { m_paintingText = paintingText; }
- virtual TextStream &externalRepresentation(TextStream &) const = 0;
+ virtual TextStream& externalRepresentation(TextStream&) const = 0;
virtual void renderPath(KRenderingDeviceContext*, const RenderPath*, KCPaintTargetType) const = 0;
private:
- const RenderPath *m_activeClient;
+ const RenderPath* m_activeClient;
String m_registryId;
bool m_paintingText;
};
-TextStream &operator<<(TextStream &, const KRenderingPaintServer &);
+TextStream& operator<<(TextStream&, const KRenderingPaintServer&);
KRenderingPaintServer* getPaintServerById(Document*, const AtomicString&);
namespace WebCore {
//KCGradientSpreadMethod
-TextStream &operator<<(TextStream &ts, KCGradientSpreadMethod m)
+TextStream& operator<<(TextStream& ts, KCGradientSpreadMethod m)
{
switch (m)
{
return ts;
}
-TextStream &operator<<(TextStream &ts, const Vector<KCGradientStop>& l)
+TextStream& operator<<(TextStream& ts, const Vector<KCGradientStop>& l)
{
ts << "[";
for (Vector<KCGradientStop>::const_iterator it = l.begin(); it != l.end(); ++it) {
m_gradientTransform = mat;
}
-TextStream &KRenderingPaintServerGradient::externalRepresentation(TextStream &ts) const
+TextStream& KRenderingPaintServerGradient::externalRepresentation(TextStream& ts) const
{
// abstract, don't stream type
ts << "[stops=" << gradientStops() << "]";
return PS_LINEAR_GRADIENT;
}
-TextStream &KRenderingPaintServerLinearGradient::externalRepresentation(TextStream &ts) const
+TextStream& KRenderingPaintServerLinearGradient::externalRepresentation(TextStream& ts) const
{
ts << "[type=LINEAR-GRADIENT] ";
KRenderingPaintServerGradient::externalRepresentation(ts);
return PS_RADIAL_GRADIENT;
}
-KCanvasResourceListener *KRenderingPaintServerGradient::listener() const
+KCanvasResourceListener* KRenderingPaintServerGradient::listener() const
{
return m_listener;
}
-void KRenderingPaintServerGradient::setListener(KCanvasResourceListener *listener)
+void KRenderingPaintServerGradient::setListener(KCanvasResourceListener* listener)
{
m_listener = listener;
}
-TextStream &KRenderingPaintServerRadialGradient::externalRepresentation(TextStream &ts) const
+TextStream& KRenderingPaintServerRadialGradient::externalRepresentation(TextStream& ts) const
{
ts << "[type=RADIAL-GRADIENT] ";
KRenderingPaintServerGradient::externalRepresentation(ts);
#define KRenderingPaintServerGradient_H
#ifdef SVG_SUPPORT
-#include <kcanvas/device/KRenderingPaintServer.h>
+#include "KRenderingPaintServer.h"
namespace WebCore {
void setGradientStops(KRenderingPaintServerGradient*);
KCGradientSpreadMethod spreadMethod() const;
- void setGradientSpreadMethod(const KCGradientSpreadMethod &method);
+ void setGradientSpreadMethod(const KCGradientSpreadMethod&);
// Gradient start and end points are percentages when used in boundingBox mode.
// For instance start point with value (0,0) is top-left and end point with value (100, 100) is
AffineTransform gradientTransform() const;
void setGradientTransform(const AffineTransform&);
- KCanvasResourceListener *listener() const;
- void setListener(KCanvasResourceListener *listener);
+ KCanvasResourceListener* listener() const;
+ void setListener(KCanvasResourceListener*);
- TextStream &externalRepresentation(TextStream &) const;
+ TextStream& externalRepresentation(TextStream&) const;
private:
Vector<KCGradientStop> m_stops;
KCGradientSpreadMethod m_spreadMethod;
// 'Linear Gradient' interface
FloatPoint gradientStart() const;
- void setGradientStart(const FloatPoint &start);
+ void setGradientStart(const FloatPoint&);
FloatPoint gradientEnd() const;
- void setGradientEnd(const FloatPoint &end);
+ void setGradientEnd(const FloatPoint&);
- TextStream &externalRepresentation(TextStream &) const;
+ TextStream& externalRepresentation(TextStream&) const;
private:
FloatPoint m_start;
FloatPoint m_end;
// 'Radial Gradient' interface
FloatPoint gradientCenter() const;
- void setGradientCenter(const FloatPoint ¢er);
+ void setGradientCenter(const FloatPoint&);
FloatPoint gradientFocal() const;
- void setGradientFocal(const FloatPoint &focal);
+ void setGradientFocal(const FloatPoint&);
float gradientRadius() const;
- void setGradientRadius(float radius);
+ void setGradientRadius(float);
- TextStream &externalRepresentation(TextStream &) const;
+ TextStream& externalRepresentation(TextStream&) const;
private:
float m_radius;
FloatPoint m_center;
m_useBoundingBoxMode = mode;
}
-KCanvasImage *KRenderingPaintServerPattern::tile() const
+KCanvasImage* KRenderingPaintServerPattern::tile() const
{
return m_tile;
}
-void KRenderingPaintServerPattern::setTile(KCanvasImage *tile)
+void KRenderingPaintServerPattern::setTile(KCanvasImage* tile)
{
m_tile = tile;
}
return PS_PATTERN;
}
-KCanvasResourceListener *KRenderingPaintServerPattern::listener() const
+KCanvasResourceListener* KRenderingPaintServerPattern::listener() const
{
return m_listener;
}
-void KRenderingPaintServerPattern::setListener(KCanvasResourceListener *listener)
+void KRenderingPaintServerPattern::setListener(KCanvasResourceListener* listener)
{
m_listener = listener;
}
-TextStream &KRenderingPaintServerPattern::externalRepresentation(TextStream &ts) const
+TextStream& KRenderingPaintServerPattern::externalRepresentation(TextStream& ts) const
{
ts << "[type=PATTERN]"
<< " [bbox=" << bbox() << "]";
#define KRenderingPaintServerPattern_H
#ifdef SVG_SUPPORT
-#include <kcanvas/device/KRenderingPaintServer.h>
+#include "KRenderingPaintServer.h"
namespace WebCore {
virtual KCPaintServerType type() const;
// Pattern bbox
- void setBbox(const FloatRect& rect);
+ void setBbox(const FloatRect&);
FloatRect bbox() const;
// Pattern x,y phase points are relative when in boundingBoxMode
// 'Pattern' interface
KCanvasImage* tile() const;
- void setTile(KCanvasImage* tile);
+ void setTile(KCanvasImage*);
AffineTransform patternTransform() const;
void setPatternTransform(const AffineTransform&);
KCanvasResourceListener* listener() const;
- void setListener(KCanvasResourceListener* listener);
- TextStream &externalRepresentation(TextStream&) const;
+ void setListener(KCanvasResourceListener*);
+ TextStream& externalRepresentation(TextStream&) const;
private:
KCanvasImage* m_tile;
return PS_SOLID;
}
-TextStream &KRenderingPaintServerSolid::externalRepresentation(TextStream &ts) const
+TextStream& KRenderingPaintServerSolid::externalRepresentation(TextStream& ts) const
{
ts << "[type=SOLID]"
<< " [color="<< color() << "]";
#define KRenderingPaintServerSolid_H
#ifdef SVG_SUPPORT
-#include <kcanvas/device/KRenderingPaintServer.h>
+#include "KRenderingPaintServer.h"
namespace WebCore {
// 'Solid' interface
Color color() const;
- void setColor(const Color &color);
+ void setColor(const Color&);
- TextStream &externalRepresentation(TextStream &) const;
+ TextStream& externalRepresentation(TextStream&) const;
private:
Color m_color;
};
m_strokeWidth = width;
}
-unsigned int KRenderingStrokePainter::strokeMiterLimit() const
+unsigned KRenderingStrokePainter::strokeMiterLimit() const
{
return m_miterLimit;
}
-void KRenderingStrokePainter::setStrokeMiterLimit(unsigned int limit)
+void KRenderingStrokePainter::setStrokeMiterLimit(unsigned limit)
{
setDirty();
m_miterLimit = limit;
m_dashOffset = offset;
}
-KCDashArray& KRenderingStrokePainter::dashArray() const
+const KCDashArray& KRenderingStrokePainter::dashArray() const
{
return m_dashArray;
}
// Common interface for fill and stroke parameters
float strokeWidth() const;
- void setStrokeWidth(float width);
+ void setStrokeWidth(float);
- unsigned int strokeMiterLimit() const;
- void setStrokeMiterLimit(unsigned int limit);
+ unsigned strokeMiterLimit() const;
+ void setStrokeMiterLimit(unsigned);
KCCapStyle strokeCapStyle() const;
- void setStrokeCapStyle(KCCapStyle style);
+ void setStrokeCapStyle(KCCapStyle);
KCJoinStyle strokeJoinStyle() const;
- void setStrokeJoinStyle(KCJoinStyle style);
+ void setStrokeJoinStyle(KCJoinStyle);
float dashOffset() const;
void setDashOffset(float offset);
- KCDashArray& dashArray() const;
- void setDashArray(const KCDashArray& dashArray);
+ const KCDashArray& dashArray() const;
+ void setDashArray(const KCDashArray&);
float opacity() const;
- void setOpacity(float opacity);
+ void setOpacity(float);
// Helpers
bool dirty() const;
float m_opacity;
float m_strokeWidth;
- unsigned int m_miterLimit;
+ unsigned m_miterLimit;
KCCapStyle m_capStyle;
KCJoinStyle m_joinStyle;
float m_dashOffset;
- mutable KCDashArray m_dashArray;
+ KCDashArray m_dashArray;
};
}
virtual void prepareFilter(const FloatRect& bbox);
virtual void applyFilter(const FloatRect& bbox);
- CIImage *imageForName(const String &name) const;
- void setImageForName(CIImage *image, const String &name);
+ CIImage* imageForName(const String&) const;
+ void setImageForName(CIImage*, const String&);
- void setOutputImage(const KCanvasFilterEffect *filterEffect, CIImage *output);
- CIImage *inputImage(const KCanvasFilterEffect *filterEffect);
+ void setOutputImage(const KCanvasFilterEffect*, CIImage*);
+ CIImage* inputImage(const KCanvasFilterEffect*);
private:
- NSArray *getCIFilterStack(CIImage *inputImage);
+ NSArray* getCIFilterStack(CIImage* inputImage);
- CIContext *m_filterCIContext;
+ CIContext* m_filterCIContext;
CGLayerRef m_filterCGLayer;
- NSMutableDictionary *m_imagesByName;
+ NSMutableDictionary* m_imagesByName;
};
class KCanvasFEBlendQuartz : public KCanvasFEBlend {
public:
- virtual CIFilter *getCIFilter(KCanvasFilterQuartz *quartzFilter) const;
+ virtual CIFilter* getCIFilter(KCanvasFilterQuartz*) const;
};
class KCanvasFEColorMatrixQuartz : public KCanvasFEColorMatrix {
public:
- virtual CIFilter *getCIFilter(KCanvasFilterQuartz *quartzFilter) const;
+ virtual CIFilter* getCIFilter(KCanvasFilterQuartz*) const;
};
class KCanvasFEComponentTransferQuartz : public KCanvasFEComponentTransfer {
public:
- virtual CIFilter *getCIFilter(KCanvasFilterQuartz *quartzFilter) const;
+ virtual CIFilter* getCIFilter(KCanvasFilterQuartz*) const;
private:
- CIFilter *getFunctionFilter(KCChannelSelectorType channel, CIImage *inputImage) const;
+ CIFilter* getFunctionFilter(KCChannelSelectorType, CIImage* inputImage) const;
};
class KCanvasFEConvolveMatrixQuartz : public KCanvasFEConvolveMatrix {
public:
- virtual CIFilter *getCIFilter(KCanvasFilterQuartz *quartzFilter) const;
+ virtual CIFilter* getCIFilter(KCanvasFilterQuartz*) const;
};
class KCanvasFECompositeQuartz : public KCanvasFEComposite {
public:
- virtual CIFilter *getCIFilter(KCanvasFilterQuartz *quartzFilter) const;
+ virtual CIFilter* getCIFilter(KCanvasFilterQuartz*) const;
};
class KCanvasFEDiffuseLightingQuartz : public KCanvasFEDiffuseLighting {
public:
- virtual CIFilter *getCIFilter(KCanvasFilterQuartz *quartzFilter) const;
+ virtual CIFilter* getCIFilter(KCanvasFilterQuartz*) const;
};
class KCanvasFEFloodQuartz : public KCanvasFEFlood {
public:
- virtual CIFilter *getCIFilter(KCanvasFilterQuartz *quartzFilter) const;
+ virtual CIFilter* getCIFilter(KCanvasFilterQuartz*) const;
};
class KCanvasFEGaussianBlurQuartz : public KCanvasFEGaussianBlur {
public:
- virtual CIFilter *getCIFilter(KCanvasFilterQuartz *quartzFilter) const;
+ virtual CIFilter* getCIFilter(KCanvasFilterQuartz*) const;
};
class KCanvasFEImageQuartz : public KCanvasFEImage {
public:
- virtual CIFilter *getCIFilter(KCanvasFilterQuartz *quartzFilter) const;
+ virtual CIFilter* getCIFilter(KCanvasFilterQuartz*) const;
};
class KCanvasFEDisplacementMapQuartz : public KCanvasFEDisplacementMap {
public:
- virtual CIFilter *getCIFilter(KCanvasFilterQuartz *quartzFilter) const;
+ virtual CIFilter* getCIFilter(KCanvasFilterQuartz*) const;
};
class KCanvasFEMergeQuartz : public KCanvasFEMerge {
public:
- virtual CIFilter *getCIFilter(KCanvasFilterQuartz *quartzFilter) const;
+ virtual CIFilter* getCIFilter(KCanvasFilterQuartz*) const;
};
class KCanvasFEOffsetQuartz : public KCanvasFEOffset {
public:
- virtual CIFilter *getCIFilter(KCanvasFilterQuartz *quartzFilter) const;
+ virtual CIFilter* getCIFilter(KCanvasFilterQuartz*) const;
};
class KCanvasFESpecularLightingQuartz : public KCanvasFESpecularLighting {
public:
- virtual CIFilter *getCIFilter(KCanvasFilterQuartz *quartzFilter) const;
+ virtual CIFilter* getCIFilter(KCanvasFilterQuartz*) const;
};
class KCanvasFETileQuartz : public KCanvasFETile {
public:
- virtual CIFilter *getCIFilter(KCanvasFilterQuartz *quartzFilter) const;
+ virtual CIFilter* getCIFilter(KCanvasFilterQuartz*) const;
};
}
}
}
-KCanvasFilterQuartz::KCanvasFilterQuartz() : m_filterCIContext(0), m_filterCGLayer(0)
+KCanvasFilterQuartz::KCanvasFilterQuartz()
+ : m_filterCIContext(0)
+ , m_filterCGLayer(0)
{
m_imagesByName = HardRetainWithNSRelease([[NSMutableDictionary alloc] init]);
}
m_filterCGLayer = [m_filterCIContext createCGLayerWithSize:CGRect(bbox).size info:NULL];
- KRenderingDeviceContext *filterContext = new KRenderingDeviceContextQuartz(CGLayerGetContext(m_filterCGLayer));
+ KRenderingDeviceContext* filterContext = new KRenderingDeviceContextQuartz(CGLayerGetContext(m_filterCGLayer));
renderingDevice()->pushContext(filterContext);
filterContext->concatCTM(AffineTransform().translate(-1.0f * bbox.x(), -1.0f * bbox.y()));
{
NSMutableArray *filterEffects = [NSMutableArray array];
- DeprecatedValueListIterator<KCanvasFilterEffect *> it = m_effects.begin();
- DeprecatedValueListIterator<KCanvasFilterEffect *> end = m_effects.end();
+ DeprecatedValueListIterator<KCanvasFilterEffect*> it = m_effects.begin();
+ DeprecatedValueListIterator<KCanvasFilterEffect*> end = m_effects.end();
setImageForName(inputImage, "SourceGraphic"); // input
for (;it != end; it++) {
filter = crop; \
}
-CIFilter *KCanvasFEBlendQuartz::getCIFilter(KCanvasFilterQuartz *quartzFilter) const
+CIFilter *KCanvasFEBlendQuartz::getCIFilter(KCanvasFilterQuartz* quartzFilter) const
{
CIFilter *filter = nil;
BEGIN_BLOCK_OBJC_EXCEPTIONS;
#define CMValuesCheck(expected, type) \
if (values().count() != expected) { \
NSLog(@"Error, incorrect number of values in ColorMatrix for type \"%s\", expected: %i actual: %i, ignoring filter. Values:", type, expected, values().count()); \
- for (unsigned int x=0; x < values().count(); x++) fprintf(stderr, " %f", values()[x]); \
+ for (unsigned x=0; x < values().count(); x++) fprintf(stderr, " %f", values()[x]); \
fprintf(stderr, "\n"); \
return nil; \
}
-CIFilter *KCanvasFEColorMatrixQuartz::getCIFilter(KCanvasFilterQuartz *quartzFilter) const
+CIFilter *KCanvasFEColorMatrixQuartz::getCIFilter(KCanvasFilterQuartz* quartzFilter) const
{
CIFilter *filter = nil;
BEGIN_BLOCK_OBJC_EXCEPTIONS;
}
-CIFilter *KCanvasFEComponentTransferQuartz::getCIFilter(KCanvasFilterQuartz *quartzFilter) const
+CIFilter *KCanvasFEComponentTransferQuartz::getCIFilter(KCanvasFilterQuartz* quartzFilter) const
{
[WKComponentMergeFilter class];
[WKIdentityTransferFilter class];
return nil;
}
-CIFilter *KCanvasFECompositeQuartz::getCIFilter(KCanvasFilterQuartz *quartzFilter) const
+CIFilter *KCanvasFECompositeQuartz::getCIFilter(KCanvasFilterQuartz* quartzFilter) const
{
CIFilter *filter = nil;
BEGIN_BLOCK_OBJC_EXCEPTIONS;
FE_QUARTZ_OUTPUT_RETURN;
}
-CIFilter *KCanvasFEDisplacementMapQuartz::getCIFilter(KCanvasFilterQuartz *quartzFilter) const
+CIFilter *KCanvasFEDisplacementMapQuartz::getCIFilter(KCanvasFilterQuartz* quartzFilter) const
{
CIFilter *filter = nil;
BEGIN_BLOCK_OBJC_EXCEPTIONS;
switch (light->type()) {
case LS_DISTANT:
{
- const KCDistantLightSource *dlight = static_cast<const KCDistantLightSource *>(light);
+ const KCDistantLightSource *dlight = static_cast<const KCDistantLightSource*>(light);
filter = [CIFilter filterWithName:@"WKDistantLight"];
if (!filter)
}
case LS_POINT:
{
- const KCPointLightSource *plight = static_cast<const KCPointLightSource *>(light);
+ const KCPointLightSource *plight = static_cast<const KCPointLightSource*>(light);
return getPointLightVectors(normals, [CIVector vectorWithX:plight->position().x() Y:plight->position().y() Z:plight->position().z()], surfaceScale);
}
case LS_SPOT:
{
- const KCSpotLightSource *slight = static_cast<const KCSpotLightSource *>(light);
+ const KCSpotLightSource *slight = static_cast<const KCSpotLightSource*>(light);
filter = [CIFilter filterWithName:@"WKSpotLight"];
if (!filter)
return nil;
return nil;
}
-CIFilter *KCanvasFEDiffuseLightingQuartz::getCIFilter(KCanvasFilterQuartz *quartzFilter) const
+CIFilter *KCanvasFEDiffuseLightingQuartz::getCIFilter(KCanvasFilterQuartz* quartzFilter) const
{
const KCLightSource *light = lightSource();
if (!light)
FE_QUARTZ_OUTPUT_RETURN;
}
-CIFilter *KCanvasFEFloodQuartz::getCIFilter(KCanvasFilterQuartz *quartzFilter) const
+CIFilter *KCanvasFEFloodQuartz::getCIFilter(KCanvasFilterQuartz* quartzFilter) const
{
CIFilter *filter;
BEGIN_BLOCK_OBJC_EXCEPTIONS;
FE_QUARTZ_OUTPUT_RETURN;
}
-CIFilter *KCanvasFEImageQuartz::getCIFilter(KCanvasFilterQuartz *quartzFilter) const
+CIFilter *KCanvasFEImageQuartz::getCIFilter(KCanvasFilterQuartz* quartzFilter) const
{
if (!cachedImage())
return nil;
FE_QUARTZ_OUTPUT_RETURN;
}
-CIFilter *KCanvasFEGaussianBlurQuartz::getCIFilter(KCanvasFilterQuartz *quartzFilter) const
+CIFilter *KCanvasFEGaussianBlurQuartz::getCIFilter(KCanvasFilterQuartz* quartzFilter) const
{
FE_QUARTZ_SETUP_INPUT(@"CIGaussianPyramid");
FE_QUARTZ_OUTPUT_RETURN;
}
-CIFilter *KCanvasFEMergeQuartz::getCIFilter(KCanvasFilterQuartz *quartzFilter) const
+CIFilter *KCanvasFEMergeQuartz::getCIFilter(KCanvasFilterQuartz* quartzFilter) const
{
CIFilter *filter = nil;
BEGIN_BLOCK_OBJC_EXCEPTIONS;
FE_QUARTZ_OUTPUT_RETURN;
}
-CIFilter *KCanvasFEOffsetQuartz::getCIFilter(KCanvasFilterQuartz *quartzFilter) const
+CIFilter *KCanvasFEOffsetQuartz::getCIFilter(KCanvasFilterQuartz* quartzFilter) const
{
FE_QUARTZ_SETUP_INPUT(@"CIAffineTransform");
NSAffineTransform *offsetTransform = [NSAffineTransform transform];
FE_QUARTZ_OUTPUT_RETURN;
}
-CIFilter *KCanvasFESpecularLightingQuartz::getCIFilter(KCanvasFilterQuartz *quartzFilter) const
+CIFilter *KCanvasFESpecularLightingQuartz::getCIFilter(KCanvasFilterQuartz* quartzFilter) const
{
const KCLightSource *light = lightSource();
if(!light)
FE_QUARTZ_OUTPUT_RETURN;
}
-CIFilter *KCanvasFETileQuartz::getCIFilter(KCanvasFilterQuartz *quartzFilter) const
+CIFilter *KCanvasFETileQuartz::getCIFilter(KCanvasFilterQuartz* quartzFilter) const
{
FE_QUARTZ_SETUP_INPUT(@"CIAffineTile");
FE_QUARTZ_OUTPUT_RETURN;
CGColorSpaceRelease(grayColorSpace);
CIContext *ciGrayscaleContext = [CIContext contextWithCGContext:grayscaleContext options:nil];
- KCanvasImageQuartz *maskImage = static_cast<KCanvasImageQuartz *>(m_mask);
+ KCanvasImageQuartz* maskImage = static_cast<KCanvasImageQuartz*>(m_mask);
CIImage *grayscaleMask = transformImageIntoGrayscaleMask([CIImage imageWithCGLayer:maskImage->cgLayer()]);
[ciGrayscaleContext drawImage:grayscaleMask atPoint:CGPointZero fromRect:CGRectMake(0, 0, width, height)];
public:
KCanvasImageQuartz() : m_cgLayer(0) { }
~KCanvasImageQuartz();
- void init(const Image &) { }
+ void init(const Image&) { }
void init(IntSize size) { m_size = size; }
CGLayerRef cgLayer();
void KCanvasClipperQuartz::applyClip(const FloatRect& boundingBox) const
{
- KRenderingDeviceContext *context = renderingDevice()->currentContext();
+ KRenderingDeviceContext* context = renderingDevice()->currentContext();
CGContextRef cgContext = static_cast<KRenderingDeviceContextQuartz*>(context)->cgContext();
if (m_clipData.count() < 1)
return;
CGAffineTransform bboxTransform = CGAffineTransformMakeMapBetweenRects(CGRectMake(0,0,1,1), CGRect(boundingBox));
- for (unsigned int x = 0; x < m_clipData.count(); x++) {
+ for (unsigned x = 0; x < m_clipData.count(); x++) {
KCClipData data = m_clipData[x];
if (data.windRule() != clipRule)
heterogenousClipRules = YES;
#define KRenderingDeviceQuartz_H
#ifdef SVG_SUPPORT
-#import <kcanvas/device/KRenderingDevice.h>
+#import "KRenderingDevice.h"
typedef struct CGRect CGRect;
typedef struct CGContext *CGContextRef;
class KRenderingDeviceContextQuartz : public KRenderingDeviceContext {
public:
- KRenderingDeviceContextQuartz(CGContextRef context);
+ KRenderingDeviceContextQuartz(CGContextRef);
virtual ~KRenderingDeviceContextQuartz();
- virtual AffineTransform concatCTM(const AffineTransform &);
+ virtual AffineTransform concatCTM(const AffineTransform&);
virtual AffineTransform ctm() const;
virtual void clearPath();
virtual bool isBuffered() const { return false; }
// context management.
- KRenderingDeviceContextQuartz *quartzContext() const;
+ KRenderingDeviceContextQuartz* quartzContext() const;
CGContextRef currentCGContext() const;
- virtual KRenderingDeviceContext *contextForImage(KCanvasImage *) const;
+ virtual KRenderingDeviceContext* contextForImage(KCanvasImage*) const;
// Resource creation
- virtual KCanvasResource *createResource(const KCResourceType &type) const;
- virtual KRenderingPaintServer *createPaintServer(const KCPaintServerType &type) const;
- virtual KCanvasFilterEffect *createFilterEffect(const KCFilterEffectType &type) const;
+ virtual KCanvasResource *createResource(const KCResourceType&) const;
+ virtual KRenderingPaintServer *createPaintServer(const KCPaintServerType&) const;
+ virtual KCanvasFilterEffect *createFilterEffect(const KCFilterEffectType&) const;
// filters (mostly debugging)
static bool filtersEnabled();
- static void setFiltersEnabled(bool enabled);
+ static void setFiltersEnabled(bool);
static bool hardwareRenderingEnabled();
- static void setHardwareRenderingEnabled(bool enabled);
+ static void setHardwareRenderingEnabled(bool);
};
} // namespace WebCore
#pragma mark -
#pragma mark Context Management
-KRenderingDeviceContextQuartz *KRenderingDeviceQuartz::quartzContext() const
+KRenderingDeviceContextQuartz* KRenderingDeviceQuartz::quartzContext() const
{
- return static_cast<KRenderingDeviceContextQuartz *>(currentContext());
+ return static_cast<KRenderingDeviceContextQuartz*>(currentContext());
}
CGContextRef KRenderingDeviceQuartz::currentCGContext() const
return quartzContext()->cgContext();
}
-KRenderingDeviceContext *KRenderingDeviceQuartz::contextForImage(KCanvasImage *image) const
+KRenderingDeviceContext* KRenderingDeviceQuartz::contextForImage(KCanvasImage *image) const
{
- KCanvasImageQuartz *quartzImage = static_cast<KCanvasImageQuartz *>(image);
+ KCanvasImageQuartz* quartzImage = static_cast<KCanvasImageQuartz*>(image);
CGLayerRef cgLayer = quartzImage->cgLayer();
if (!cgLayer) {
// FIXME: we might not get back a layer if this is a loaded image
#pragma mark -
#pragma mark Resource Creation
-KRenderingPaintServer *KRenderingDeviceQuartz::createPaintServer(const KCPaintServerType &type) const
+KRenderingPaintServer *KRenderingDeviceQuartz::createPaintServer(const KCPaintServerType& type) const
{
KRenderingPaintServer *newServer = NULL;
switch(type) {
return newServer;
}
-KCanvasResource *KRenderingDeviceQuartz::createResource(const KCResourceType &type) const
+KCanvasResource *KRenderingDeviceQuartz::createResource(const KCResourceType& type) const
{
switch (type) {
case RS_CLIPPER:
return 0;
}
-KCanvasFilterEffect *KRenderingDeviceQuartz::createFilterEffect(const KCFilterEffectType &type) const
+KCanvasFilterEffect *KRenderingDeviceQuartz::createFilterEffect(const KCFilterEffectType& type) const
{
switch(type)
{
static void cgGradientCallback(void* info, const CGFloat* inValues, CGFloat* outColor)
{
- const KRenderingPaintServerGradientQuartz *server = (const KRenderingPaintServerGradientQuartz *)info;
+ const KRenderingPaintServerGradientQuartz* server = (const KRenderingPaintServerGradientQuartz*)info;
QuartzGradientStop *stops = server->m_stopsCache;
int stopsCount = server->m_stopsCount;
return;
}
- if (!(inValue > stops[0].offset)) {
+ if (!(inValue > stops[0].offset))
memcpy(outColor, stops[0].colorArray, 4 * sizeof(CGFloat));
- } else if (!(inValue < stops[stopsCount-1].offset)) {
+ else if (!(inValue < stops[stopsCount-1].offset))
memcpy(outColor, stops[stopsCount-1].colorArray, 4 * sizeof(CGFloat));
- } else {
+ else {
int nextStopIndex = 0;
- while ( (nextStopIndex < stopsCount) && (stops[nextStopIndex].offset < inValue) ) {
+ while ((nextStopIndex < stopsCount) && (stops[nextStopIndex].offset < inValue))
nextStopIndex++;
- }
//float nextOffset = stops[nextStopIndex].offset;
CGFloat *nextColorArray = stops[nextStopIndex].colorArray;
// FIXME: have to handle the spreadMethod()s here SPREADMETHOD_REPEAT, etc.
}
-static CGShadingRef CGShadingRefForLinearGradient(const KRenderingPaintServerLinearGradientQuartz *server)
+static CGShadingRef CGShadingRefForLinearGradient(const KRenderingPaintServerLinearGradientQuartz* server)
{
CGPoint start = CGPoint(server->gradientStart());
CGPoint end = CGPoint(server->gradientEnd());
CGFunctionCallbacks callbacks = {0, cgGradientCallback, NULL};
CGFloat domainLimits[2] = {0, 1};
CGFloat rangeLimits[8] = {0, 1, 0, 1, 0, 1, 0, 1};
- const KRenderingPaintServerGradientQuartz *castServer = static_cast<const KRenderingPaintServerGradientQuartz *>(server);
+ const KRenderingPaintServerGradientQuartz* castServer = static_cast<const KRenderingPaintServerGradientQuartz*>(server);
CGFunctionRef shadingFunction = CGFunctionCreate((void *)castServer, 1, domainLimits, 4, rangeLimits, &callbacks);
CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
return shading;
}
-static CGShadingRef CGShadingRefForRadialGradient(const KRenderingPaintServerRadialGradientQuartz *server)
+static CGShadingRef CGShadingRefForRadialGradient(const KRenderingPaintServerRadialGradientQuartz* server)
{
CGPoint center = CGPoint(server->gradientCenter());
CGPoint focus = CGPoint(server->gradientFocal());
// Spec: If (fx, fy) lies outside the circle defined by (cx, cy) and r, set (fx, fy)
// to the point of intersection of the line through (fx, fy) and the circle.
- if(sqrt(fdx*fdx + fdy*fdy) > radius)
- {
+ if (sqrt(fdx*fdx + fdy*fdy) > radius) {
double angle = atan2(focus.y, focus.x);
focus.x = int(cos(angle) * radius) - 1;
focus.y = int(sin(angle) * radius) - 1;
CGFunctionCallbacks callbacks = {0, cgGradientCallback, NULL};
CGFloat domainLimits[2] = {0, 1};
CGFloat rangeLimits[8] = {0, 1, 0, 1, 0, 1, 0, 1};
- const KRenderingPaintServerGradientQuartz *castServer = static_cast<const KRenderingPaintServerGradientQuartz *>(server);
+ const KRenderingPaintServerGradientQuartz* castServer = static_cast<const KRenderingPaintServerGradientQuartz*>(server);
CGFunctionRef shadingFunction = CGFunctionCreate((void *)castServer, 1, domainLimits, 4, rangeLimits, &callbacks);
CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
return shading;
}
-KRenderingPaintServerGradientQuartz::KRenderingPaintServerGradientQuartz() :
-m_stopsCache(0), m_stopsCount(0), m_shadingCache(0), m_maskImage(0)
+KRenderingPaintServerGradientQuartz::KRenderingPaintServerGradientQuartz()
+ : m_stopsCache(0)
+ , m_stopsCount(0)
+ , m_shadingCache(0)
+ , m_maskImage(0)
{
}
if (m_shadingCache)
CGShadingRelease(m_shadingCache);
if (server->type() == PS_RADIAL_GRADIENT) {
- const KRenderingPaintServerRadialGradientQuartz *radial = static_cast<const KRenderingPaintServerRadialGradientQuartz *>(server);
+ const KRenderingPaintServerRadialGradientQuartz* radial = static_cast<const KRenderingPaintServerRadialGradientQuartz*>(server);
m_shadingCache = CGShadingRefForRadialGradient(radial);
} else if (server->type() == PS_LINEAR_GRADIENT) {
- const KRenderingPaintServerLinearGradientQuartz *linear = static_cast<const KRenderingPaintServerLinearGradientQuartz *>(server);
+ const KRenderingPaintServerLinearGradientQuartz* linear = static_cast<const KRenderingPaintServerLinearGradientQuartz*>(server);
m_shadingCache = CGShadingRefForLinearGradient(linear);
}
}
CGContextSaveGState(context);
applyStrokeStyleToContext(context, renderStyle, renderObject); // FIXME: this seems like the wrong place for this.
if (server->isPaintingText()) {
- m_maskImage = static_cast<KCanvasImage *>(quartzDevice->createResource(RS_IMAGE));
+ m_maskImage = static_cast<KCanvasImage*>(quartzDevice->createResource(RS_IMAGE));
int width = 2048;
int height = 2048; // FIXME???
IntSize size = IntSize(width, height);
CGColorSpaceRef grayColorSpace = CGColorSpaceCreateDeviceGray();
CGContextRef grayscaleContext = CGBitmapContextCreate(imageBuffer, width, height, 8, width, grayColorSpace, kCGImageAlphaNone);
CGColorSpaceRelease(grayColorSpace);
- KCanvasImageQuartz* qMaskImage = static_cast<KCanvasImageQuartz *>(maskImage);
+ KCanvasImageQuartz* qMaskImage = static_cast<KCanvasImageQuartz*>(maskImage);
CGContextDrawLayerAtPoint(grayscaleContext, CGPointMake(0, 0), qMaskImage->cgLayer());
CGImageRef grayscaleImage = CGBitmapContextCreateImage(grayscaleContext);
CGContextClipToMask(context, CGRectMake(0, 0, width, height), grayscaleImage);
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#import <kcanvas/device/KRenderingDevice.h>
-#import <kcanvas/device/KRenderingPaintServerSolid.h>
-#import <kcanvas/device/KRenderingPaintServerPattern.h>
-#import <kcanvas/device/KRenderingPaintServerGradient.h>
+#import "KRenderingDevice.h"
+#import "KRenderingPaintServerSolid.h"
+#import "KRenderingPaintServerPattern.h"
+#import "KRenderingPaintServerGradient.h"
namespace WebCore {
class KRenderingPaintServerQuartzHelper {
public:
- static void strokePath(CGContextRef, const RenderPath *renderPath);
- static void clipToStrokePath(CGContextRef, const RenderPath *renderPath);
- static void fillPath(CGContextRef, const RenderPath *renderPath);
- static void clipToFillPath(CGContextRef, const RenderPath *renderPath);
+ static void strokePath(CGContextRef, const RenderPath*);
+ static void clipToStrokePath(CGContextRef, const RenderPath*);
+ static void fillPath(CGContextRef, const RenderPath*);
+ static void clipToFillPath(CGContextRef, const RenderPath*);
};
class KRenderingPaintServerSolidQuartz : public KRenderingPaintServerSolid {
namespace WebCore {
-void KRenderingPaintServerQuartzHelper::strokePath(CGContextRef context, const RenderPath *renderPath)
+void KRenderingPaintServerQuartzHelper::strokePath(CGContextRef context, const RenderPath* renderPath)
{
CGContextStrokePath(context);
}
-void KRenderingPaintServerQuartzHelper::clipToStrokePath(CGContextRef context, const RenderPath *renderPath)
+void KRenderingPaintServerQuartzHelper::clipToStrokePath(CGContextRef context, const RenderPath* renderPath)
{
CGContextReplacePathWithStrokedPath(context);
CGContextClip(context);
}
-void KRenderingPaintServerQuartzHelper::fillPath(CGContextRef context, const RenderPath *renderPath)
+void KRenderingPaintServerQuartzHelper::fillPath(CGContextRef context, const RenderPath* renderPath)
{
if (KSVGPainterFactory::fillPainter(renderPath->style(), renderPath).fillRule() == RULE_EVENODD)
CGContextEOFillPath(context);
CGContextFillPath(context);
}
-void KRenderingPaintServerQuartzHelper::clipToFillPath(CGContextRef context, const RenderPath *renderPath)
+void KRenderingPaintServerQuartzHelper::clipToFillPath(CGContextRef context, const RenderPath* renderPath)
{
if (KSVGPainterFactory::fillPainter(renderPath->style(), renderPath).fillRule() == RULE_EVENODD)
CGContextEOClip(context);
CGContextClip(context);
}
-void KRenderingPaintServerSolidQuartz::draw(KRenderingDeviceContext *renderingContext, const RenderPath* path, KCPaintTargetType type) const
+void KRenderingPaintServerSolidQuartz::draw(KRenderingDeviceContext* renderingContext, const RenderPath* path, KCPaintTargetType type) const
{
if (!setup(renderingContext, path, type))
return;
teardown(renderingContext, path, type);
}
-bool KRenderingPaintServerSolidQuartz::setup(KRenderingDeviceContext *renderingContext, const RenderObject* renderObject, KCPaintTargetType type) const
+bool KRenderingPaintServerSolidQuartz::setup(KRenderingDeviceContext* renderingContext, const RenderObject* renderObject, KCPaintTargetType type) const
{
- KRenderingDeviceContextQuartz *quartzContext = static_cast<KRenderingDeviceContextQuartz *>(renderingContext);
+ KRenderingDeviceContextQuartz* quartzContext = static_cast<KRenderingDeviceContextQuartz*>(renderingContext);
CGContextRef context = quartzContext->cgContext();
- RenderStyle *renderStyle = renderObject->style();
+ RenderStyle* renderStyle = renderObject->style();
CGContextSetAlpha(context, renderStyle->opacity());
CGColorRelease(colorCG);
CGColorRelease(withAlpha);
if (isPaintingText()) {
- const_cast<RenderObject *>(renderObject)->style()->setColor(color());
+ const_cast<RenderObject*>(renderObject)->style()->setColor(color());
CGContextSetTextDrawingMode(context, kCGTextFill);
}
}
CGColorRelease(withAlpha);
applyStrokeStyleToContext(context, renderStyle, renderObject);
if (isPaintingText()) {
- const_cast<RenderObject *>(renderObject)->style()->setColor(color());
+ const_cast<RenderObject*>(renderObject)->style()->setColor(color());
CGContextSetTextDrawingMode(context, kCGTextStroke);
}
}
void KRenderingPaintServerSolidQuartz::renderPath(KRenderingDeviceContext* renderingContext, const RenderPath* renderPath, KCPaintTargetType type) const
{
- RenderStyle *renderStyle = renderPath->style();
- KRenderingDeviceContextQuartz *quartzContext = static_cast<KRenderingDeviceContextQuartz *>(renderingContext);
+ RenderStyle* renderStyle = renderPath->style();
+ KRenderingDeviceContextQuartz* quartzContext = static_cast<KRenderingDeviceContextQuartz*>(renderingContext);
CGContextRef context = quartzContext->cgContext();
if ((type & APPLY_TO_FILL) && KSVGPainterFactory::isFilled(renderStyle))
KRenderingPaintServerQuartzHelper::fillPath(context, renderPath);
void patternCallback(void *info, CGContextRef context)
{
- KCanvasImageQuartz *image = (KCanvasImageQuartz *)info;
- CGLayerRef layer = image->cgLayer();
+ CGLayerRef layer = reinterpret_cast<KCanvasImageQuartz*>(info)->cgLayer();
CGContextDrawLayerAtPoint(context, CGPointZero, layer);
}
if(listener()) // this seems like bad design to me, should be in a common baseclass. -- ecs 8/6/05
listener()->resourceNotification();
- RenderStyle *renderStyle = renderObject->style();
+ RenderStyle* renderStyle = renderObject->style();
- KRenderingDeviceContextQuartz *quartzContext = static_cast<KRenderingDeviceContextQuartz *>(renderingContext);
+ KRenderingDeviceContextQuartz* quartzContext = static_cast<KRenderingDeviceContextQuartz*>(renderingContext);
CGContextRef context = quartzContext->cgContext();
- KCanvasImage *cell = tile();
+ KCanvasImage* cell = tile();
if (!cell)
return false;
CGPatternCallbacks callbacks = {0, patternCallback, NULL};
m_pattern = CGPatternCreate(
tile(),
- CGRectMake(0,0,cellSize.width,cellSize.height),
+ CGRectMake(0, 0, cellSize.width, cellSize.height),
transform,
bbox().width(), //cellSize.width,
bbox().height(), //cellSize.height,
CGContextSetFillColorSpace(context, m_patternSpace);
CGContextSetFillPattern(context, m_pattern, &alpha);
if (isPaintingText()) {
- const_cast<RenderObject *>(renderObject)->style()->setColor(Color());
+ const_cast<RenderObject*>(renderObject)->style()->setColor(Color());
CGContextSetTextDrawingMode(context, kCGTextFill);
}
}
CGContextSetStrokePattern(context, m_pattern, &alpha);
applyStrokeStyleToContext(context, renderStyle, renderObject);
if (isPaintingText()) {
- const_cast<RenderObject *>(renderObject)->style()->setColor(Color());
+ const_cast<RenderObject*>(renderObject)->style()->setColor(Color());
CGContextSetTextDrawingMode(context, kCGTextStroke);
}
}
void KRenderingPaintServerPatternQuartz::renderPath(KRenderingDeviceContext* renderingContext, const RenderPath* renderPath, KCPaintTargetType type) const
{
- RenderStyle *renderStyle = renderPath->style();
+ RenderStyle* renderStyle = renderPath->style();
- KRenderingDeviceContextQuartz *quartzContext = static_cast<KRenderingDeviceContextQuartz *>(renderingContext);
+ KRenderingDeviceContextQuartz* quartzContext = static_cast<KRenderingDeviceContextQuartz*>(renderingContext);
CGContextRef context = quartzContext->cgContext();
if ((type & APPLY_TO_FILL) && KSVGPainterFactory::isFilled(renderStyle))
void KRenderingPaintServerPatternQuartz::teardown(KRenderingDeviceContext* renderingContext, const RenderObject* renderObject, KCPaintTargetType type) const
{
- KRenderingDeviceContextQuartz *quartzContext = static_cast<KRenderingDeviceContextQuartz *>(renderingContext);
+ KRenderingDeviceContextQuartz* quartzContext = static_cast<KRenderingDeviceContextQuartz*>(renderingContext);
CGContextRef context = quartzContext->cgContext();
CGPatternRelease(m_pattern);
CGColorSpaceRelease(m_patternSpace);
class RenderObject;
class KRenderingStrokePainter;
-#ifndef NDEBUG
-void debugDumpCGImageToFile(NSString *filename, CGImageRef image, int width, int height);
-void debugDumpCGLayerToFile(NSString *filename, CGLayerRef layer, int width, int height);
-void debugDumpCIImageToFile(NSString *filename, CIImage *ciImage, int width, int height);
-#endif
-
-CFStringRef CFStringFromCGPath(CGPathRef path);
-CFStringRef CFStringFromCGAffineTransform(CGAffineTransform t);
+CFStringRef CFStringFromCGPath(CGPathRef);
+CFStringRef CFStringFromCGAffineTransform(CGAffineTransform);
CGAffineTransform CGAffineTransformMakeMapBetweenRects(CGRect source, CGRect dest);
void applyStrokeStyleToContext(CGContextRef, const KRenderingStrokePainter&);
void applyStrokeStyleToContext(CGContextRef, RenderStyle*, const RenderObject*);
-FloatRect strokeBoundingBox(const Path& path, const KRenderingStrokePainter& strokePainter);
-bool pathContainsPoint(CGMutablePathRef cgPath, const FloatPoint& point, CGPathDrawingMode drawMode);
+FloatRect strokeBoundingBox(const Path&, const KRenderingStrokePainter&);
+bool pathContainsPoint(CGMutablePathRef, const FloatPoint&, CGPathDrawingMode);
static inline CGLineCap CGLineCapFromKC(KCCapStyle cap)
{
if (dashes.count()) {
size_t dashCount = dashes.count();
CGFloat *lengths = (CGFloat *)malloc(dashCount * sizeof(CGFloat));
- for (unsigned int x = 0; x < dashCount; x++)
+ for (unsigned x = 0; x < dashCount; x++)
lengths[x] = dashes[x];
CGContextSetLineDash(context, strokePainter.dashOffset(), lengths, dashes.count());
free(lengths);
git://git.webkit.org / WebKit-https.git / commitdiff