PathClipSlide.cpp File Reference

#include "include/core/SkCanvas.h"
#include "include/core/SkColorFilter.h"
#include "include/core/SkColorPriv.h"
#include "include/core/SkGraphics.h"
#include "include/core/SkPath.h"
#include "include/core/SkRegion.h"
#include "include/core/SkShader.h"
#include "include/core/SkTypeface.h"
#include "include/effects/SkGradientShader.h"
#include "include/private/base/SkTo.h"
#include "src/base/SkTime.h"
#include "src/base/SkUTF.h"
#include "tools/viewer/ClickHandlerSlide.h"
#include <utility>

Go to the source code of this file.

Classes
class	PathClipSlide
class	EdgeClipSlide
class	EdgeClipSlide::MyClick
class	EdgeClipSlide::VertClick
class	EdgeClipSlide::DragRectClick
class	EdgeClipSlide::DragPolyClick
class	EdgeClipSlide::DoNothingClick

Functions
static int	clip_line (const SkRect &bounds, SkPoint p0, SkPoint p1, SkPoint edges[])
static void	draw_clipped_line (SkCanvas *canvas, const SkRect &bounds, SkPoint p0, SkPoint p1, const SkPaint &paint)

Function Documentation

clip_line()

static int clip_line ( const SkRect &  bounds, SkPoint  p0, SkPoint  p1, SkPoint  edges[]  )

static

Definition at line 68 of file PathClipSlide.cpp.

                                                                                    {
    SkPoint* edgesStart = edges;
 
    if (p0.fY == p1.fY) {
        return 0;
    }
 
    if (p0.fY > p1.fY) {
        using std::swap;
        swap(p0, p1);
    }
    // now we're monotonic in Y: p0 <= p1
    if (p1.fY <= bounds.top() || p0.fY >= bounds.bottom()) {
        return 0;
    }
 
    double dxdy = (double)(p1.fX - p0.fX) / (p1.fY - p0.fY);
    if (p0.fY < bounds.top()) {
        p0.fX = SkDoubleToScalar(p0.fX + dxdy * (bounds.top() - p0.fY));
        p0.fY = bounds.top();
    }
    if (p1.fY > bounds.bottom()) {
        p1.fX = SkDoubleToScalar(p1.fX + dxdy * (bounds.bottom() - p1.fY));
        p1.fY = bounds.bottom();
    }
 
    // Now p0...p1 is strictly inside bounds vertically, so we just need to clip horizontally
 
    if (p0.fX > p1.fX) {
        using std::swap;
        swap(p0, p1);
    }
    // now we're left-to-right: p0 .. p1
 
    if (p1.fX <= bounds.left()) {   // entirely to the left
        p0.fX = p1.fX = bounds.left();
        *edges++ = p0;
        *edges++ = p1;
        return 2;
    }
    if (p0.fX >= bounds.right()) {  // entirely to the right
        p0.fX = p1.fX = bounds.right();
        *edges++ = p0;
        *edges++ = p1;
        return 2;
    }
 
    if (p0.fX < bounds.left()) {
        float y = SkDoubleToScalar(p0.fY + (bounds.left() - p0.fX) / dxdy);
        *edges++ = SkPoint::Make(bounds.left(), p0.fY);
        *edges++ = SkPoint::Make(bounds.left(), y);
        p0.set(bounds.left(), y);
    }
    if (p1.fX > bounds.right()) {
        float y = SkDoubleToScalar(p0.fY + (bounds.right() - p0.fX) / dxdy);
        *edges++ = p0;
        *edges++ = SkPoint::Make(bounds.right(), y);
        *edges++ = SkPoint::Make(bounds.right(), p1.fY);
    } else {
        *edges++ = p0;
        *edges++ = p1;
    }
    return SkToInt(edges - edgesStart);
}

draw_clipped_line()

static void draw_clipped_line ( SkCanvas *  canvas, const SkRect &  bounds, SkPoint  p0, SkPoint  p1, const SkPaint &  paint  )

static

Definition at line 133 of file PathClipSlide.cpp.

                                                                            {
    SkPoint verts[6];
    int count = clip_line(bounds, p0, p1, verts);
 
    SkPath path;
    path.addPoly(verts, count, false);
    canvas->drawPath(path, paint);
}