Ticket #17665: 0001-GraphicsContextHaiku-add-tracing.patch

Source/WebCore/platform/graphics/haiku/GraphicsContextHaiku.cpp

@@ -48 +48 @@
 #include <Window.h>
 #include <stdio.h>
 
+#define TRACE_GRAPHICS_HAIKU
+#ifdef TRACE_GRAPHICS_HAIKU
+#   define HGTRACE(x) printf x
+#else
+#   define HGTRACE(x) ;
+#endif
+
 namespace WebCore {
 
 
@@ -64 +71 @@
 // Draws a filled rectangle with a stroked border.
 void GraphicsContextHaiku::drawRect(const FloatRect& rect, float borderThickness)
 {
+    HGTRACE(("drawRect: [%f:%f] [%f:%f]\n", rect.x(), rect.y(), rect.width(), rect.height()));
     if (m_state.fillPattern)
         notImplemented();
     else if (m_state.fillGradient) {
@@ -81 +89 @@
 
 void GraphicsContextHaiku::drawNativeImage(NativeImage& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
 {
+    HGTRACE(("drawNativeImage:  src([%f:%f] [%f:%f])\n", srcRect.x(), srcRect.y(), srcRect.width(), srcRect.height()));
+    HGTRACE(("                 dest([%f:%f] [%f:%f])\n", destRect.x(), destRect.y(), destRect.width(), destRect.height()));
     drawBitmap(image.platformImage().get(), imageSize, destRect, srcRect, options);
 }
 
 void GraphicsContextHaiku::drawBitmap(BBitmap* image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
 {
+    HGTRACE(("drawBitmap:  src([%f:%f] [%f:%f])\n", srcRect.x(), srcRect.y(), srcRect.width(), srcRect.height()));
+    HGTRACE(("            dest([%f:%f] [%f:%f])\n", destRect.x(), destRect.y(), destRect.width(), destRect.height()));
     m_view->PushState();
     setCompositeOperation(options.compositeOperator());
 
@@ -107 +119 @@
 // This is only used to draw borders.
 void GraphicsContextHaiku::drawLine(const FloatPoint& point1, const FloatPoint& point2)
 {
+    HGTRACE(("drawline: [%f:%f] [%f:%f])\n", point1.x(), point1.y(), point2.x(), point2.y()));
     if (strokeStyle() == NoStroke || !strokeColor().isVisible())
         return;
     m_view->StrokeLine(point1, point2, m_strokeStyle);
@@ -115 +128 @@
 // This method is only used to draw the little circles used in lists.
 void GraphicsContextHaiku::drawEllipse(const FloatRect& rect)
 {
+    HGTRACE(("drawEllipse: [%f:%f] [%f:%f]\n", rect.x(), rect.y(), rect.width(), rect.height()));
     if (m_state.fillPattern || m_state.fillGradient || fillColor().isVisible()) {
 //        TODO: What's this shadow business?
         if (m_state.fillPattern)
@@ -133 +147 @@
 
 void GraphicsContextHaiku::strokeRect(const FloatRect& rect, float width)
 {
+    HGTRACE(("strokeRect: [%f:%f] [%f:%f] width:%f\n", rect.x(), rect.y(), rect.width(), rect.height(), width));
     if (strokeStyle() == NoStroke || width <= 0.0f || !strokeColor().isVisible())
         return;
 
@@ -145 +160 @@
 
 void GraphicsContextHaiku::strokePath(const Path& path)
 {
+    HGTRACE(("strokePath: (--todo print values)\n"));
     m_view->MovePenTo(B_ORIGIN);
 
     // TODO: stroke the shadow (cf shadowAndStrokeCurrentCairoPath)
@@ -167 +183 @@
 
 void GraphicsContextHaiku::fillRect(const FloatRect& rect, const Color& color)
 {
+    HGTRACE(("fillRect(color): [%f:%f] [%f:%f]\n", rect.x(), rect.y(), rect.width(), rect.height()));
     rgb_color previousColor = m_view->HighColor();
 
 #if 0
@@ -185 +202 @@
 
 void GraphicsContextHaiku::fillRect(const FloatRect& rect)
 {
+    HGTRACE(("fillRect: [%f:%f] [%f:%f]\n", rect.x(), rect.y(), rect.width(), rect.height()));
     // TODO fill the shadow
     m_view->FillRect(rect, B_SOLID_LOW);
 }
 
 void GraphicsContextHaiku::fillRoundedRectImpl(const FloatRoundedRect& roundRect, const Color& color)
 {
+    HGTRACE(("fillRoundedRectImpl: (--todo print values)\n"));
     if (!color.isVisible())
         return;
 
@@ -254 +273 @@
 
 void GraphicsContextHaiku::fillPath(const Path& path)
 {
+    HGTRACE(("fillPath: (--todo print values)\n"));
     m_view->SetFillRule(fillRule() == WindRule::NonZero ? B_NONZERO : B_EVEN_ODD);
     m_view->MovePenTo(B_ORIGIN);
 
@@ -278 +298 @@
 
 void GraphicsContextHaiku::clip(const FloatRect& rect)
 {
+    HGTRACE(("clip: [%f:%f] [%f:%f]\n", rect.x(), rect.y(), rect.width(), rect.height()));
     m_view->ClipToRect(rect);
 }
 
 void GraphicsContextHaiku::clipPath(const Path& path, WindRule windRule)
 {
+    HGTRACE(("clipPath: (--todo print values)\n"));
     int32 fillRule = m_view->FillRule();
 
     m_view->SetFillRule(windRule == WindRule::EvenOdd ? B_EVEN_ODD : B_NONZERO);
@@ -296 +318 @@
     const FloatRect& tileRect, const AffineTransform& transform,
     const FloatPoint& phase, const FloatSize& spacing, const ImagePaintingOptions& options)
 {
+    HGTRACE(("drawPattern: (--todo print values)\n"));
     drawBitmap(image.platformImage().get(), image.size(), destRect, tileRect, transform, phase, spacing, options);
 }
 
@@ -303 +326 @@
     const FloatRect& tileRect, const AffineTransform&,
     const FloatPoint& phase, const FloatSize& spacing, const ImagePaintingOptions&)
 {
+    HGTRACE(("drawBitmap: (--todo print values)\n"));
     if (!image->IsValid()) // If the image hasn't fully loaded.
         return;
 
@@ -343 +367 @@
 
 void GraphicsContextHaiku::clipOut(const Path& path)
 {
+    HGTRACE(("clipOut(path): (--todo print values)\n"));
     if (path.isEmpty())
         return;
 
@@ -351 +376 @@
 
 void GraphicsContextHaiku::clipOut(const FloatRect& rect)
 {
+    HGTRACE(("clipOut: [%f:%f] [%f:%f]\n", rect.x(), rect.y(), rect.width(), rect.height()));
     m_view->ClipToInverseRect(rect);
 }
 
 void GraphicsContextHaiku::drawFocusRing(const Path& path, float width, float /*offset*/, const Color& color)
 {
+    HGTRACE(("drawFocusRing(path): (--todo print values)\n"));
     if (width <= 0 || !color.isVisible())
         return;
 
@@ -372 +399 @@
 
 void GraphicsContextHaiku::drawFocusRing(const Vector<FloatRect>& rects, float width, float /* offset */, const Color& color)
 {
+    HGTRACE(("drawFocusRing(rects): (--todo print values)\n"));
     if (width <= 0 || !color.isVisible())
         return;
 
@@ -398 +426 @@
 
 void GraphicsContextHaiku::drawLinesForText(const FloatPoint& point, float, const DashArray& widths, bool printing, bool doubleUnderlines, WebCore::StrokeStyle)
 {
+    HGTRACE(("drawLinesForText: (--todo print values)\n"));
     if (widths.size() <= 0)
         return;
 
@@ -414 +443 @@
 void GraphicsContextHaiku::drawDotsForDocumentMarker(WebCore::FloatRect const&,
     WebCore::DocumentMarkerLineStyle)
 {
+    HGTRACE(("drawDotsForDocumentMarker: Not Implemented\n"));
     notImplemented();
 }
 
 FloatRect GraphicsContextHaiku::roundToDevicePixels(const FloatRect& rect, RoundingMode /* mode */)
 {
+    HGTRACE(("roundToDevicePixels: [%f:%f] [%f:%f]\n", rect.x(), rect.y(), rect.width(), rect.height()));
     FloatRect rounded(rect);
     rounded.setX(roundf(rect.x()));
     rounded.setY(roundf(rect.y()));
@@ -430 +461 @@
 /* Used by canvas.clearRect. Must clear the given rectangle with transparent black. */
 void GraphicsContextHaiku::clearRect(const FloatRect& rect)
 {
+    HGTRACE(("clearRect: [%f:%f] [%f:%f]\n", rect.x(), rect.y(), rect.width(), rect.height()));
     m_view->PushState();
     m_view->SetHighColor(0, 0, 0, 0);
     m_view->SetDrawingMode(B_OP_COPY);
@@ -439 +471 @@
 
 void GraphicsContextHaiku::setLineCap(LineCap lineCap)
 {
+    HGTRACE(("setLineCap: (--todo print values)\n"));
     cap_mode mode = B_BUTT_CAP;
     switch (lineCap) {
     case LineCap::Round:
@@ -457 +490 @@
 
 void GraphicsContextHaiku::setLineDash(const DashArray& /*dashes*/, float /*dashOffset*/)
 {
+    HGTRACE(("setLineDash: Not Implemented\n"));
     // TODO this is used to draw dashed strokes in SVG, but we need app_server support
     notImplemented();
 }
 
 void GraphicsContextHaiku::setLineJoin(LineJoin lineJoin)
 {
+    HGTRACE(("setLineJoin: (--todo print values)\n"));
     join_mode mode = B_MITER_JOIN;
     switch (lineJoin) {
     case LineJoin::Round:
@@ -481 +516 @@
 
 void GraphicsContextHaiku::setMiterLimit(float limit)
 {
+    HGTRACE(("setMiterLimit: %f\n", limit));
     m_view->SetLineMode(m_view->LineCapMode(), m_view->LineJoinMode(), limit);
 }
 
 AffineTransform GraphicsContextHaiku::getCTM(IncludeDeviceScale) const
 {
+    HGTRACE(("getCTM: no values used\n"));
     BAffineTransform t = m_view->Transform();
         // TODO: we actually need to use the combined transform here?
     AffineTransform matrix(t.sx, t.shy, t.shx, t.sy, t.tx, t.ty);
@@ -494 +531 @@
 
 void GraphicsContextHaiku::translate(float x, float y)
 {
+    HGTRACE(("translate: %f, %f\n", x, y));
     if (x == 0.f && y == 0.f)
         return;
 
@@ -502 +540 @@
 
 void GraphicsContextHaiku::rotate(float radians)
 {
+    HGTRACE(("rotate: %f\n", radians));
     if (radians == 0.f)
         return;
 
@@ -510 +549 @@
 
 void GraphicsContextHaiku::scale(const FloatSize& size)
 {
+    HGTRACE(("scale: %f %f\n", size.width(), size.height()));
     m_view->ScaleBy(size.width(), size.height());
 }
 
 void GraphicsContextHaiku::concatCTM(const AffineTransform& transform)
 {
+    HGTRACE(("concatCTM: (--todo print values)\n"));
     BAffineTransform current = m_view->Transform();
     current.Multiply(transform);
     m_view->SetTransform(current);
@@ -522 +563 @@
 
 void GraphicsContextHaiku::setCTM(const AffineTransform& transform)
 {
+    HGTRACE(("setCTM: (--todo print values)\n"));
     m_view->SetTransform(transform);
 }
 
 void GraphicsContextHaiku::didUpdateState(const GraphicsContextState& state, GraphicsContextState::StateChangeFlags flags)
 {
+    HGTRACE(("didUpdateState: (--todo print values)\n"));
 #if 0
         StrokeGradientChange                    = 1 << 0,
         StrokePatternChange                     = 1 << 1,
@@ -673 +716 @@
 
 void GraphicsContextHaiku::beginTransparencyLayer(float opacity)
 {
+    HGTRACE(("beginTransparencyLayer: %f\n", opacity));
     GraphicsContext::beginTransparencyLayer(opacity);
     m_view->BeginLayer(static_cast<uint8>(opacity * 255.0));
 }
 
 void GraphicsContextHaiku::endTransparencyLayer()
 {
+    HGTRACE(("endTransparencyLayer: no values\n"));
     GraphicsContext::endTransparencyLayer();
     m_view->EndLayer();
 }
 
 IntRect GraphicsContextHaiku::clipBounds() const
 {
+    HGTRACE(("clipBounds: no values\n"));
     // This can be used by drawing code to do some early clipping (for example
     // the SVG code may skip complete parts of the image which are outside
     // the bounds).
@@ -713 +759 @@
 
 void GraphicsContextHaiku::save()
 {
+    HGTRACE(("save: no values\n"));
     m_view->PushState();
     GraphicsContext::save();
 }
 
 void GraphicsContextHaiku::restore()
 {
+    HGTRACE(("restore: no values\n"));
     GraphicsContext::restore();
     m_view->PopState();
 }