FlutterClippingMaskView Class Reference

#import <FlutterPlatformViews_Internal.h>

Inheritance diagram for FlutterClippingMaskView:

Instance Methods
(instancetype)	- initWithFrame:screenScale:
(void)	- reset
(void)	- clipRect:matrix:
(void)	- clipRRect:matrix:
(void)	- clipPath:matrix:

Detailed Description

Definition at line 215 of file FlutterPlatformViews.mm.

Method Documentation

clipPath:matrix:

- (void) clipPath:		(const flutter::DlPath&)	path
matrix:		(const flutter::DlMatrix&)	matrix

Definition at line 383 of file FlutterPlatformViews.mm.

                :(const flutter::DlPath&)dlPath matrix:(const flutter::DlMatrix&)matrix {
  containsNonRectPath_ = YES;
  CGMutablePathRef pathRef = CGPathCreateMutable();
  bool subpath_needs_close = false;
  std::optional<flutter::DlPoint> pending_moveto;
 
  auto resolve_moveto = [&pending_moveto, &pathRef]() {
    if (pending_moveto.has_value()) {
      CGPathMoveToPoint(pathRef, nil, pending_moveto->x, pending_moveto->y);
      pending_moveto.reset();
    }
  };
 
  auto& path = dlPath.GetPath();
  for (auto it = path.begin(), end = path.end(); it != end; ++it) {
    switch (it.type()) {
      case impeller::Path::ComponentType::kContour: {
        const impeller::ContourComponent* contour = it.contour();
        FML_DCHECK(contour != nullptr);
        if (subpath_needs_close) {
          CGPathCloseSubpath(pathRef);
        }
        pending_moveto = contour->destination;
        subpath_needs_close = contour->IsClosed();
        break;
      }
      case impeller::Path::ComponentType::kLinear: {
        const impeller::LinearPathComponent* linear = it.linear();
        FML_DCHECK(linear != nullptr);
        resolve_moveto();
        CGPathAddLineToPoint(pathRef, nil, linear->p2.x, linear->p2.y);
        break;
      }
      case impeller::Path::ComponentType::kQuadratic: {
        const impeller::QuadraticPathComponent* quadratic = it.quadratic();
        FML_DCHECK(quadratic != nullptr);
        resolve_moveto();
        CGPathAddQuadCurveToPoint(pathRef, nil,                      //
                                  quadratic->cp.x, quadratic->cp.y,  //
                                  quadratic->p2.x, quadratic->p2.y);
        break;
      }
      case impeller::Path::ComponentType::kConic: {
        const impeller::ConicPathComponent* conic = it.conic();
        FML_DCHECK(conic != nullptr);
        resolve_moveto();
        // Conic is not available in quartz, we use quad to approximate.
        // TODO(cyanglaz): Better approximate the conic path.
        // https://github.com/flutter/flutter/issues/35062
        CGPathAddQuadCurveToPoint(pathRef, nil,              //
                                  conic->cp.x, conic->cp.y,  //
                                  conic->p2.x, conic->p2.y);
        break;
      }
      case impeller::Path::ComponentType::kCubic: {
        const impeller::CubicPathComponent* cubic = it.cubic();
        FML_DCHECK(cubic != nullptr);
        resolve_moveto();
        CGPathAddCurveToPoint(pathRef, nil,                //
                              cubic->cp1.x, cubic->cp1.y,  //
                              cubic->cp2.x, cubic->cp2.y,  //
                              cubic->p2.x, cubic->p2.y);
        break;
      }
    }
  }
  if (subpath_needs_close) {
    CGPathCloseSubpath(pathRef);
  }
  // The `matrix` is based on the physical pixels, convert it to UIKit points.
  CATransform3D matrixInPoints =
      CATransform3DConcat(GetCATransform3DFromDlMatrix(matrix), _reverseScreenScale);
  paths_.push_back([self getTransformedPath:pathRef matrix:matrixInPoints]);
}

References containsNonRectPath_, and GetCATransform3DFromDlMatrix().

clipRect:matrix:

- (void) clipRect:		(const flutter::DlRect&)	clipDlRect
matrix:		(const flutter::DlMatrix&)	matrix

Definition at line 290 of file FlutterPlatformViews.mm.

                :(const flutter::DlRect&)clipDlRect matrix:(const flutter::DlMatrix&)matrix {
  CGRect clipRect = GetCGRectFromDlRect(clipDlRect);
  CGPathRef path = CGPathCreateWithRect(clipRect, nil);
  // The `matrix` is based on the physical pixels, convert it to UIKit points.
  CATransform3D matrixInPoints =
      CATransform3DConcat(GetCATransform3DFromDlMatrix(matrix), _reverseScreenScale);
  paths_.push_back([self getTransformedPath:path matrix:matrixInPoints]);
  CGAffineTransform affine = [self affineWithMatrix:matrixInPoints];
  // Make sure the rect is not rotated (only translated or scaled).
  if (affine.b == 0 && affine.c == 0) {
    rectSoFar_ = CGRectIntersection(rectSoFar_, CGRectApplyAffineTransform(clipRect, affine));
  } else {
    containsNonRectPath_ = YES;
  }
}

References containsNonRectPath_, GetCATransform3DFromDlMatrix(), GetCGRectFromDlRect(), and rectSoFar_.

Referenced by clipRRect:matrix:.

clipRRect:matrix:

- (void) clipRRect:		(const flutter::DlRoundRect&)	clipDlRRect
matrix:		(const flutter::DlMatrix&)	matrix

Definition at line 306 of file FlutterPlatformViews.mm.

                 :(const flutter::DlRoundRect&)clipDlRRect matrix:(const flutter::DlMatrix&)matrix {
  if (clipDlRRect.IsEmpty()) {
    return;
  } else if (clipDlRRect.IsRect()) {
    [self clipRect:clipDlRRect.GetBounds() matrix:matrix];
    return;
  } else {
    CGPathRef pathRef = nullptr;
    containsNonRectPath_ = YES;
 
    if (clipDlRRect.GetRadii().AreAllCornersSame()) {
      CGRect clipRect = GetCGRectFromDlRect(clipDlRRect.GetBounds());
      auto radii = clipDlRRect.GetRadii();
      pathRef =
          CGPathCreateWithRoundedRect(clipRect, radii.top_left.width, radii.top_left.height, nil);
    } else {
      CGMutablePathRef mutablePathRef = CGPathCreateMutable();
      // Complex types, we manually add each corner.
      flutter::DlRect clipDlRect = clipDlRRect.GetBounds();
      auto left = clipDlRect.GetLeft();
      auto top = clipDlRect.GetTop();
      auto right = clipDlRect.GetRight();
      auto bottom = clipDlRect.GetBottom();
      flutter::DlRoundingRadii radii = clipDlRRect.GetRadii();
      auto& top_left = radii.top_left;
      auto& top_right = radii.top_right;
      auto& bottom_left = radii.bottom_left;
      auto& bottom_right = radii.bottom_right;
 
      // Start drawing RRect
      // These calculations are off, the AddCurve methods add a Bezier curve
      // which, for round rects should be a "magic distance" from the end
      // point of the horizontal/vertical section to the corner.
      // Move point to the top left corner adding the top left radii's x.
      CGPathMoveToPoint(mutablePathRef, nil,  //
                        left + top_left.width, top);
      // Move point horizontally right to the top right corner and add the top right curve.
      CGPathAddLineToPoint(mutablePathRef, nil,  //
                           right - top_right.width, top);
      CGPathAddCurveToPoint(mutablePathRef, nil,            //
                            right, top,                     //
                            right, top + top_right.height,  //
                            right, top + top_right.height);
      // Move point vertically down to the bottom right corner and add the bottom right curve.
      CGPathAddLineToPoint(mutablePathRef, nil,  //
                           right, bottom - bottom_right.height);
      CGPathAddCurveToPoint(mutablePathRef, nil,                 //
                            right, bottom,                       //
                            right - bottom_right.width, bottom,  //
                            right - bottom_right.width, bottom);
      // Move point horizontally left to the bottom left corner and add the bottom left curve.
      CGPathAddLineToPoint(mutablePathRef, nil,  //
                           left + bottom_left.width, bottom);
      CGPathAddCurveToPoint(mutablePathRef, nil,                //
                            left, bottom,                       //
                            left, bottom - bottom_left.height,  //
                            left, bottom - bottom_left.height);
      // Move point vertically up to the top left corner and add the top left curve.
      CGPathAddLineToPoint(mutablePathRef, nil,  //
                           left, top + top_left.height);
      CGPathAddCurveToPoint(mutablePathRef, nil,         //
                            left, top,                   //
                            left + top_left.width, top,  //
                            left + top_left.width, top);
      CGPathCloseSubpath(mutablePathRef);
      pathRef = mutablePathRef;
    }
    // The `matrix` is based on the physical pixels, convert it to UIKit points.
    CATransform3D matrixInPoints =
        CATransform3DConcat(GetCATransform3DFromDlMatrix(matrix), _reverseScreenScale);
    // TODO(cyanglaz): iOS does not seem to support hard edge on CAShapeLayer. It clearly stated
    // that the CAShaperLayer will be drawn antialiased. Need to figure out a way to do the hard
    // edge clipping on iOS.
    paths_.push_back([self getTransformedPath:pathRef matrix:matrixInPoints]);
  }
}

References clipRect:matrix:, containsNonRectPath_, GetCATransform3DFromDlMatrix(), and GetCGRectFromDlRect().

initWithFrame:screenScale:

- (instancetype) initWithFrame:		(CGRect)	frame
screenScale:		(CGFloat)	screenScale

Definition at line 221 of file FlutterPlatformViews.mm.

                             :(CGRect)frame screenScale:(CGFloat)screenScale {
  if (self = [super initWithFrame:frame]) {
    self.backgroundColor = UIColor.clearColor;
    _reverseScreenScale = CATransform3DMakeScale(1 / screenScale, 1 / screenScale, 1);
    rectSoFar_ = self.bounds;
    containsNonRectPath_ = NO;
  }
  return self;
}

References containsNonRectPath_, initWithFrame, and rectSoFar_.

reset

- (void) reset

Definition at line 239 of file FlutterPlatformViews.mm.

              {
  paths_.clear();
  rectSoFar_ = self.bounds;
  containsNonRectPath_ = NO;
  [self shapeLayer].path = nil;
  [self setNeedsDisplay];
}

References containsNonRectPath_, and rectSoFar_.

---

The documentation for this class was generated from the following files:

• shell/platform/darwin/ios/framework/Source/FlutterPlatformViews.mm
• shell/platform/darwin/ios/framework/Source/FlutterPlatformViews_Internal.h