skia 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ae4770cc8ed617609a1ad1263d895417bcfbd5b47ef4b72a296e0a6ec40caddb
+  data.tar.gz: d6a33d5ab0a76620204fb48244f432a5fa8ce46bdff711fa614099ac6e7c1444
+SHA512:
+  metadata.gz: 330a03251acafcffe574a2cb2b109db26d69a685ec0b4575a6372c8bc71632bb64fe32c34056f0460d858988c50f72a2ea798cae551ba6c54fb91a7913356bb8
+  data.tar.gz: 2deab127ab8d8f44ff3c5126f7160c9ceab0258e89865991d74935487799032b195de0abfa1b5b337ff4ba89648722b38200009439bf8e4e45298bb77ff2ae67

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## Unreleased
+
+## 1.0.0 - 2026-02-15
+
+- Initial release

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yudai Takada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,205 @@
+# Skia Ruby
+
+Skia bindings for Ruby, providing 2D drawing, image processing, PDF generation, and runtime shader capabilities.
+
+<img width="400" alt="Image" src="https://github.com/user-attachments/assets/440971a6-bf10-4cc2-abe6-e5cf28949b95" />
+
+## Status
+
+This project provides a practical, SkiaSharp-compatible API surface in Ruby, with a mix of:
+
+- native-backed features through SkiaSharp C API
+- Ruby convenience/typed layers for ergonomic usage
+
+### Native-backed (current)
+
+- `Surface` / `Canvas` / `Paint` / `Path` / `Image` / `Shader`
+- Shape and path drawing (rect, rrect, arc, points, picture playback)
+- `Document` PDF output
+  - file output
+  - memory stream output
+  - metadata (`title`, `author`, `creation`, `pdfa`, etc.)
+- `Picture` recording / playback / serialization
+- `RuntimeEffect` (SkSL compile and shader creation)
+- Encoders (`PNG`, `JPEG`, `WEBP`)
+
+### Ruby layer (current)
+
+- Geometry/value types
+  - `Point`, `Rect`, `RRect`, `Matrix`, `ImageInfo`, `ColorSpace`
+- Effect wrappers
+  - `MaskFilter`, `ColorFilter`, `ImageFilter`, `PathEffect`
+- Pixel APIs
+  - `Bitmap`, `Pixmap`, `read_pixels` helpers
+- Text primitives
+  - `Font`, `Typeface`, `TextBlob`
+
+### Native build note
+
+- Text layout modules (`skunicode`, `skshaper`, `skparagraph`) are not exposed in the current `libSkiaSharp` build.
+- `skottie` is not exposed in the current `libSkiaSharp` build.
+
+## Requirements
+
+- Ruby 3.0+
+- SkiaSharp native library (`libSkiaSharp`)
+  - macOS: `libSkiaSharp.dylib`
+  - Linux: `libSkiaSharp.so`
+  - Windows: `libSkiaSharp.dll`
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'skia'
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+## Installing Native Library
+
+The gem loads `libSkiaSharp` from project root, current working directory, `SKIA_LIBRARY_PATH`, or system path.
+
+### macOS
+
+```bash
+curl -L -o skiasharp.nupkg \
+  https://api.nuget.org/v3-flatcontainer/skiasharp.nativeassets.macos/3.119.2/skiasharp.nativeassets.macos.3.119.2.nupkg
+unzip skiasharp.nupkg -d skiasharp-extract
+cp skiasharp-extract/runtimes/osx/native/libSkiaSharp.dylib .
+```
+
+### Linux
+
+```bash
+curl -L -o skiasharp.nupkg https://www.nuget.org/api/v2/package/SkiaSharp.NativeAssets.Linux.x64
+unzip skiasharp.nupkg -d skiasharp-extract
+cp skiasharp-extract/runtimes/linux-x64/native/libSkiaSharp.so .
+```
+
+### Windows
+
+```powershell
+Invoke-WebRequest -Uri https://www.nuget.org/api/v2/package/SkiaSharp.NativeAssets.Win32 -OutFile skiasharp.nupkg
+Expand-Archive skiasharp.nupkg -DestinationPath skiasharp-extract
+copy skiasharp-extract\runtimes\win-x64\native\libSkiaSharp.dll .
+```
+
+## Quick Start
+
+```ruby
+require 'skia'
+
+surface = Skia::Surface.make_raster(640, 480)
+
+surface.draw do |canvas|
+  canvas.clear(Skia::Color::WHITE)
+
+  paint = Skia::Paint.new
+  paint.antialias = true
+  paint.color = Skia::Color::RED
+
+  canvas.draw_circle(320, 240, 100, paint)
+end
+
+surface.save_png('output.png')
+```
+
+## PDF Example
+
+```ruby
+require 'skia'
+
+Skia::Document.create_pdf('output.pdf', metadata: {
+  title: 'My Report',
+  author: 'skia-ruby',
+  creation: Time.now,
+  raster_dpi: 144.0,
+  encoding_quality: 90
+}) do |doc|
+  doc.page(612, 792) do |canvas|
+    canvas.clear(Skia::Color::WHITE)
+
+    font = Skia::Font.new(nil, 24.0)
+    paint = Skia::Paint.new
+    paint.color = Skia::Color::BLACK
+
+    canvas.draw_text('Hello, PDF!', 50, 100, font, paint)
+  end
+end
+```
+
+## Runtime Shader Example
+
+```ruby
+require 'skia'
+
+sksl = <<~SKSL
+  half4 main(float2 coord) {
+    half r = coord.x / 640.0;
+    half g = coord.y / 360.0;
+    return half4(r, g, 0.35, 1.0);
+  }
+SKSL
+
+effect = Skia::RuntimeEffect.make_for_shader(sksl)
+shader = effect.make_shader
+
+surface = Skia::Surface.make_raster(640, 360)
+paint = Skia::Paint.new
+paint.shader = shader
+
+surface.draw do |canvas|
+  canvas.draw_rect(Skia::Rect.from_wh(640, 360), paint)
+end
+
+surface.save_png('runtime_effect.png')
+```
+
+## API Coverage (Skia docs parity)
+
+| Area | Status | Notes |
+| --- | --- | --- |
+| Core drawing (`Surface`/`Canvas`/`Paint`/`Path`) | Implemented | Main 2D drawing APIs are available |
+| Shape/text primitives (`RRect`, `TextBlob`) | Implemented | Glyph-positioned drawing is supported via `TextBlob` |
+| Effects (`MaskFilter`, `ColorFilter`, `ImageFilter`, `PathEffect`) | Implemented | Exposed through Ruby wrappers and `Paint` setters |
+| Pixel and color APIs (`Bitmap`, `Pixmap`, `ImageInfo`, `ColorSpace`) | Implemented | Read/copy/access pixel-level data |
+| Image and shader extensions | Implemented | Includes gradients and runtime shader compilation |
+| PDF document APIs | Implemented | File/memory output and metadata are supported |
+| GPU-oriented surface constructors | Partial | Requires externally managed native GPU context pointers |
+| Text layout modules (`skunicode`, `skshaper`, `skparagraph`) | Not implemented | Required native symbols are absent in current build |
+| `skottie` (Lottie) | Not implemented | Required native symbols are absent in current build |
+
+## Development
+
+After checking out the repo, install dependencies:
+
+```bash
+bundle install
+```
+
+Run examples:
+
+```bash
+ruby examples/basic_drawing.rb
+ruby examples/gradient.rb
+ruby examples/bar_chart.rb
+ruby examples/advanced_features.rb
+ruby examples/pdf_stream.rb
+ruby examples/runtime_effect.rb
+```
+
+## License
+
+This project is available under the [MIT License](LICENSE).
+
+## Contributing
+
+Bug reports and pull requests are welcome at:
+
+- https://github.com/ydah/skia-ruby

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/examples/advanced_features.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/skia'
+
+info = Skia::ImageInfo.new(
+  width: 640,
+  height: 360,
+  color_type: :rgba_8888,
+  alpha_type: :premul,
+  color_space: Skia::ColorSpace.srgb
+)
+surface = Skia::Surface.make_raster(image_info: info)
+
+surface.draw do |canvas|
+  canvas.clear(Skia::Color::WHITE)
+
+  rrect = Skia::RRect.from_rect_xy(Skia::Rect.from_xywh(40, 40, 560, 200), 28)
+  shader = Skia::Shader.two_point_conical_gradient(
+    Skia::Point.new(120, 100),
+    8.0,
+    Skia::Point.new(360, 220),
+    260.0,
+    [Skia::Color::BLUE, Skia::Color::CYAN, Skia::Color::MAGENTA]
+  )
+
+  fill = Skia::Paint.new
+  fill.antialias = true
+  fill.shader = shader
+  canvas.draw_rrect(rrect, fill)
+
+  stroke = Skia::Paint.new
+  stroke.antialias = true
+  stroke.style = :stroke
+  stroke.stroke_width = 3.0
+  stroke.color = Skia::Color::BLACK
+  stroke.path_effect = Skia::PathEffect.dash([10.0, 6.0], phase: 2.0)
+  canvas.draw_rrect(rrect.clone.inset(4, 4), stroke)
+
+  font = Skia::Font.new(nil, 48)
+  blob = Skia::TextBlob.from_text('Skia Ruby', font, x: 60, y: 300)
+  text_paint = Skia::Paint.new
+  text_paint.antialias = true
+  text_paint.color = Skia::Color::BLACK
+  canvas.draw_text_blob(blob, 0, 0, text_paint) if blob
+end
+
+surface.save_png('advanced_features.png')
+pixels = surface.read_pixels(width: 64, height: 64)
+puts "Saved advanced_features.png (sample bytes: #{pixels.bytesize})"

data/examples/avatar_generator.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/skia'
+
+def generate_avatar(name, size: 200, output: nil)
+  initials = name.split.map { |n| n[0].upcase }.join[0, 2]
+
+  hash = name.chars.map(&:ord).sum
+  hue = hash % 360
+
+  c = 0.6
+  x = c * (1 - ((hue / 60.0) % 2 - 1).abs)
+  m = 0.2
+
+  r, g, b = case hue / 60
+            when 0 then [c, x, 0]
+            when 1 then [x, c, 0]
+            when 2 then [0, c, x]
+            when 3 then [0, x, c]
+            when 4 then [x, 0, c]
+            else [c, 0, x]
+            end
+
+  bg_color = Skia::Color.rgb(
+    ((r + m) * 255).to_i,
+    ((g + m) * 255).to_i,
+    ((b + m) * 255).to_i
+  )
+
+  surface = Skia::Surface.make_raster(size, size)
+
+  surface.draw do |canvas|
+    canvas.clear(Skia::Color::TRANSPARENT)
+
+    paint = Skia::Paint.new
+    paint.antialias = true
+
+    paint.color = bg_color
+    paint.style = :fill
+    canvas.draw_circle(size / 2.0, size / 2.0, size / 2.0, paint)
+
+    font_size = size * 0.4
+    font = Skia::Font.new(nil, font_size)
+    paint.color = Skia::Color::WHITE
+
+    text_width, text_bounds = font.measure_text(initials)
+    metrics = font.metrics
+    x = (size - text_width) / 2.0
+    y = (size / 2.0) - (metrics.ascent + metrics.descent) / 2.0
+
+    canvas.draw_text(initials, x, y, font, paint)
+  end
+
+  output_file = output || "avatar_#{name.downcase.gsub(/\s+/, '_')}.png"
+  surface.save_png(output_file)
+  puts "Generated: #{output_file}"
+  output_file
+end
+
+names = [
+  'John Doe',
+  'Alice Smith',
+  'Bob Johnson',
+  'Emma Wilson',
+  'Michael Brown'
+]
+
+puts 'Generating avatars...'
+names.each { |name| generate_avatar(name, size: 128) }
+
+generate_avatar('Ruby Developer', size: 256, output: 'avatar_large.png')
+
+puts "\nAll avatars generated!"

data/examples/bar_chart.rb

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/skia'
+
+data = {
+  'Maguro' => 92,
+  'Salmon' => 88,
+  'Ebi' => 75,
+  'Tamago' => 68,
+  'Ika' => 45
+}
+
+WIDTH = 600
+HEIGHT = 400
+MARGIN = { top: 40, right: 30, bottom: 60, left: 80 }.freeze
+CHART_WIDTH = WIDTH - MARGIN[:left] - MARGIN[:right]
+CHART_HEIGHT = HEIGHT - MARGIN[:top] - MARGIN[:bottom]
+
+surface = Skia::Surface.make_raster(WIDTH, HEIGHT)
+
+surface.draw do |canvas|
+  canvas.clear(Skia::Color::WHITE)
+
+  paint = Skia::Paint.new
+  paint.antialias = true
+
+  font_title = Skia::Font.new(nil, 20.0)
+  paint.color = Skia::Color::BLACK
+  canvas.draw_text('Sushi Popularity Ranking', 180, 28, font_title, paint)
+
+  font_axis = Skia::Font.new(nil, 12.0)
+  paint.style = :stroke
+  paint.stroke_width = 1
+  paint.color = Skia::Color.rgb(200, 200, 200)
+
+  max_value = 100
+  5.times do |i|
+    value = i * 25
+    y = MARGIN[:top] + CHART_HEIGHT - (value.to_f / max_value * CHART_HEIGHT)
+
+    canvas.draw_line(MARGIN[:left], y, WIDTH - MARGIN[:right], y, paint)
+
+    paint.style = :fill
+    paint.color = Skia::Color::BLACK
+    canvas.draw_text(value.to_s, MARGIN[:left] - 35, y + 4, font_axis, paint)
+    paint.style = :stroke
+    paint.color = Skia::Color.rgb(200, 200, 200)
+  end
+
+  bar_width = CHART_WIDTH / data.size * 0.7
+  bar_spacing = CHART_WIDTH / data.size
+
+  colors = [
+    Skia::Color.rgb(220, 53, 69),
+    Skia::Color.rgb(255, 127, 80),
+    Skia::Color.rgb(255, 182, 193),
+    Skia::Color.rgb(255, 215, 0),
+    Skia::Color.rgb(230, 230, 250)
+  ]
+
+  data.each_with_index do |(name, value), i|
+    x = MARGIN[:left] + (i * bar_spacing) + (bar_spacing - bar_width) / 2
+    bar_height = (value.to_f / max_value) * CHART_HEIGHT
+    y = MARGIN[:top] + CHART_HEIGHT - bar_height
+
+    paint.style = :fill
+    paint.color = colors[i]
+    canvas.draw_rect(Skia::Rect.from_xywh(x, y, bar_width, bar_height), paint)
+
+    paint.style = :stroke
+    paint.stroke_width = 1
+    paint.color = Skia::Color.rgb(100, 100, 100)
+    canvas.draw_rect(Skia::Rect.from_xywh(x, y, bar_width, bar_height), paint)
+
+    paint.style = :fill
+    paint.color = Skia::Color::BLACK
+    text_width, = font_axis.measure_text(name)
+    label_x = x + (bar_width - text_width) / 2
+    canvas.draw_text(name, label_x, HEIGHT - MARGIN[:bottom] + 20, font_axis, paint)
+
+    value_text = "#{value}%"
+    value_width, = font_axis.measure_text(value_text)
+    canvas.draw_text(value_text, x + (bar_width - value_width) / 2, y - 8, font_axis, paint)
+  end
+end
+
+surface.save_png('bar_chart.png')
+puts 'Saved to bar_chart.png'

data/examples/basic_drawing.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/skia'
+
+surface = Skia::Surface.make_raster(640, 480)
+
+surface.draw do |canvas|
+  canvas.clear(Skia::Color::WHITE)
+
+  paint = Skia::Paint.new
+  paint.antialias = true
+
+  paint.color = Skia::Color::RED
+  paint.style = :fill
+  canvas.draw_rect(Skia::Rect.from_xywh(50, 50, 150, 100), paint)
+
+  paint.color = Skia::Color::BLUE
+  canvas.draw_circle(400, 200, 80, paint)
+
+  paint.color = Skia::Color::GREEN
+  paint.style = :stroke
+  paint.stroke_width = 3
+  canvas.draw_oval(Skia::Rect.from_xywh(200, 300, 200, 100), paint)
+
+  path = Skia::Path.build do
+    move_to 100, 300
+    line_to 200, 400
+    line_to 50, 400
+    close
+  end
+  paint.color = Skia::Color.rgb(255, 165, 0)
+  paint.style = :fill
+  canvas.draw_path(path, paint)
+
+  paint.color = Skia::Color::MAGENTA
+  paint.style = :stroke
+  paint.stroke_width = 2
+  canvas.draw_line(500, 50, 600, 150, paint)
+end
+
+surface.save_png('output.png')
+puts 'Saved to output.png'

data/examples/gradient.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/skia'
+
+surface = Skia::Surface.make_raster(400, 400)
+
+surface.draw do |canvas|
+  canvas.clear(Skia::Color::WHITE)
+
+  colors = [Skia::Color::RED, Skia::Color::YELLOW, Skia::Color::BLUE]
+  shader = Skia::Shader.linear_gradient(
+    Skia::Point.new(0, 0),
+    Skia::Point.new(400, 0),
+    colors
+  )
+
+  paint = Skia::Paint.new
+  paint.shader = shader
+  canvas.draw_rect(Skia::Rect.from_wh(400, 200), paint)
+
+  radial_shader = Skia::Shader.radial_gradient(
+    Skia::Point.new(200, 300),
+    100,
+    [Skia::Color::WHITE, Skia::Color::BLUE]
+  )
+  paint.shader = radial_shader
+  canvas.draw_circle(200, 300, 100, paint)
+end
+
+surface.save_png('gradient.png')
+puts 'Saved to gradient.png'

data/examples/pdf_output.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/skia'
+
+Skia::Document.create_pdf('output.pdf') do |doc|
+  doc.begin_page(612, 792) do |canvas|
+    canvas.clear(Skia::Color::WHITE)
+
+    font = Skia::Font.new(nil, 36.0)
+    paint = Skia::Paint.new
+    paint.antialias = true
+    paint.color = Skia::Color::BLACK
+
+    canvas.draw_text('Hello, PDF!', 50, 100, font, paint)
+
+    paint.color = Skia::Color::RED
+    paint.style = :fill
+    canvas.draw_rect(Skia::Rect.from_xywh(50, 150, 200, 100), paint)
+
+    paint.color = Skia::Color::BLUE
+    canvas.draw_circle(400, 300, 80, paint)
+  end
+
+  doc.begin_page(612, 792) do |canvas|
+    canvas.clear(Skia::Color::WHITE)
+
+    font = Skia::Font.new(nil, 24.0)
+    paint = Skia::Paint.new
+    paint.antialias = true
+    paint.color = Skia::Color::BLACK
+
+    canvas.draw_text('Page 2', 50, 100, font, paint)
+
+    path = Skia::Path.build do
+      move_to 100, 200
+      line_to 200, 400
+      line_to 50, 400
+      close
+    end
+
+    paint.color = Skia::Color::GREEN
+    paint.style = :fill
+    canvas.draw_path(path, paint)
+  end
+end
+
+puts 'Saved to output.pdf'

data/examples/pdf_stream.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/skia'
+
+doc = Skia::Document.create_pdf_stream(metadata: { title: 'Skia PDF Stream', author: 'skia-ruby' })
+
+doc.page(595, 842) do |canvas|
+  canvas.clear(Skia::Color::WHITE)
+
+  paint = Skia::Paint.new
+  paint.color = Skia::Color::BLACK
+
+  font = Skia::Font.new(nil, 28)
+  canvas.draw_text('PDF from memory stream', 48, 96, font, paint)
+
+  paint.color = Skia::Color::BLUE
+  canvas.draw_circle(160, 220, 64, paint)
+end
+
+data = doc.to_data
+File.binwrite('stream_output.pdf', data.to_s)
+puts 'Saved stream_output.pdf'

data/examples/picture_recording.rb

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/skia'
+
+bounds = Skia::Rect.from_xywh(0, 0, 200, 200)
+picture = Skia::Picture.record(bounds) do |canvas|
+  paint = Skia::Paint.new
+  paint.antialias = true
+
+  paint.color = Skia::Color::RED
+  paint.style = :fill
+  canvas.draw_circle(100, 100, 80, paint)
+
+  paint.color = Skia::Color::BLUE
+  paint.style = :stroke
+  paint.stroke_width = 5
+  canvas.draw_circle(100, 100, 80, paint)
+end
+
+puts 'Recorded picture:'
+puts "  Unique ID: #{picture.unique_id}"
+puts "  Cull rect: #{picture.cull_rect.inspect}"
+puts "  Approximate op count: #{picture.approximate_op_count}"
+puts "  Approximate bytes used: #{picture.approximate_bytes_used}"
+
+data = picture.serialize
+puts "  Serialized size: #{data.size} bytes"
+
+loaded_picture = Skia::Picture.from_data(data)
+puts "  Loaded picture unique ID: #{loaded_picture.unique_id}"
+
+surface = Skia::Surface.make_raster(640, 480)
+surface.draw do |canvas|
+  canvas.clear(Skia::Color::WHITE)
+
+  canvas.with_save do
+    canvas.translate(50, 50)
+    picture.playback(canvas)
+  end
+
+  canvas.with_save do
+    canvas.translate(300, 50)
+    canvas.scale(0.5, 0.5)
+    picture.playback(canvas)
+  end
+
+  canvas.with_save do
+    canvas.translate(50, 280)
+    canvas.scale(1.5, 1.5)
+    picture.playback(canvas)
+  end
+
+  canvas.with_save do
+    canvas.translate(400, 280)
+    canvas.rotate(45, 100, 100)
+    picture.playback(canvas)
+  end
+end
+
+surface.save_png('picture_output.png')
+puts 'Saved to picture_output.png'