platform/graphics/stroke_data.cc

// Copyright (C) 2013 Google Inc. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//    * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//    * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//    * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#include <memory>

#include "third_party/blink/renderer/platform/graphics/paint/paint_flags.h"
#include "third_party/blink/renderer/platform/graphics/stroke_data.h"
#include "third_party/skia/include/effects/SkDashPathEffect.h"

namespace blink {

void StrokeData::SetLineDash(const DashArray& dashes, float dash_offset) {
  // FIXME: This is lifted directly off SkiaSupport, lines 49-74
  // so it is not guaranteed to work correctly.
  size_t dash_length = dashes.size();
  if (!dash_length) {
    // If no dash is set, revert to solid stroke
    // FIXME: do we need to set NoStroke in some cases?
    style_ = kSolidStroke;
    dash_.reset();
    return;
  }

  size_t count = !(dash_length % 2) ? dash_length : dash_length * 2;
  auto intervals = std::make_unique<SkScalar[]>(count);

  for (unsigned i = 0; i < count; i++)
    intervals[i] = dashes[i % dash_length];

  dash_ = SkDashPathEffect::Make(intervals.get(), count, dash_offset);
}

void StrokeData::SetupPaint(PaintFlags* flags,
                            const int length,
                            const int dash_thickness) const {
  flags->setStyle(PaintFlags::kStroke_Style);
  flags->setStrokeWidth(SkFloatToScalar(thickness_));
  flags->setStrokeCap(line_cap_);
  flags->setStrokeJoin(line_join_);
  flags->setStrokeMiter(SkFloatToScalar(miter_limit_));

  SetupPaintDashPathEffect(flags, length, dash_thickness);
}

void StrokeData::SetupPaintDashPathEffect(PaintFlags* flags,
                                          const int length,
                                          const int dash_thickness) const {
  int dash_width = dash_thickness ? dash_thickness : thickness_;
  if (dash_) {
    flags->setPathEffect(dash_);
  } else if (StrokeIsDashed(dash_width, style_)) {
    float dash_length = dash_width;
    float gap_length = dash_length;
    if (style_ == kDashedStroke) {
      dash_length *= StrokeData::DashLengthRatio(dash_width);
      gap_length *= StrokeData::DashGapRatio(dash_width);
    }
    if (length <= dash_length * 2) {
      // No space for dashes
      flags->setPathEffect(nullptr);
    } else if (length <= 2 * dash_length + gap_length) {
      // Exactly 2 dashes proportionally sized
      float multiplier = length / (2 * dash_length + gap_length);
      SkScalar intervals[2] = {dash_length * multiplier,
                               gap_length * multiplier};
      flags->setPathEffect(SkDashPathEffect::Make(intervals, 2, 0));
    } else {
      float gap = gap_length;
      if (style_ == kDashedStroke)
        gap = SelectBestDashGap(length, dash_length, gap_length);
      SkScalar intervals[2] = {dash_length, gap};
      flags->setPathEffect(SkDashPathEffect::Make(intervals, 2, 0));
    }
  } else if (style_ == kDottedStroke) {
    flags->setStrokeCap((PaintFlags::Cap)kRoundCap);
    // Adjust the width to get equal dot spacing as much as possible.
    float per_dot_length = dash_width * 2;
    if (length < per_dot_length) {
      // Not enoguh space for 2 dots. Just draw 1 by giving a gap that is
      // bigger than the length.
      SkScalar intervals[2] = {0, per_dot_length};
      flags->setPathEffect(SkDashPathEffect::Make(intervals, 2, 0));
      return;
    }

    // Epsilon ensures that we get a whole dot at the end of the line,
    // even if that dot is a little inside the true endpoint. Without it
    // we can drop the end dot due to rounding along the line.
    static const float kEpsilon = 1.0e-2f;
    float gap = SelectBestDashGap(length, dash_width, dash_width);
    SkScalar intervals[2] = {0, gap + dash_width - kEpsilon};
    flags->setPathEffect(SkDashPathEffect::Make(intervals, 2, 0));
  } else {
    flags->setPathEffect(nullptr);
  }
}

bool StrokeData::StrokeIsDashed(float width, StrokeStyle style) {
  return style == kDashedStroke || (style == kDottedStroke && width <= 3);
}

float StrokeData::SelectBestDashGap(float stroke_length,
                                    float dash_length,
                                    float gap_length) {
  // Determine what number of dashes gives the minimum deviation from
  // gapLength between dashes. Set the gap to that width.
  float min_num_dashes =
      floorf((stroke_length + gap_length) / (dash_length + gap_length));
  float max_num_dashes = min_num_dashes + 1;
  float min_gap =
      (stroke_length - min_num_dashes * dash_length) / (min_num_dashes - 1);
  float max_gap =
      (stroke_length - max_num_dashes * dash_length) / (max_num_dashes - 1);
  return (max_gap <= 0) ||
                 (fabs(min_gap - gap_length) < fabs(max_gap - gap_length))
             ? min_gap
             : max_gap;
}

}  // namespace blink