diff --git a/src/BaselineOfSparta/BaselineOfSparta.class.st b/src/BaselineOfSparta/BaselineOfSparta.class.st index 9408f0bb..f223f23a 100644 --- a/src/BaselineOfSparta/BaselineOfSparta.class.st +++ b/src/BaselineOfSparta/BaselineOfSparta.class.st @@ -1,5 +1,6 @@ " I am a Baseline of Sparta. + " Class { #name : #BaselineOfSparta, diff --git a/src/BaselineOfSpartaCairo/BaselineOfSpartaCairo.class.st b/src/BaselineOfSpartaCairo/BaselineOfSpartaCairo.class.st index 9764399a..de853992 100644 --- a/src/BaselineOfSpartaCairo/BaselineOfSpartaCairo.class.st +++ b/src/BaselineOfSpartaCairo/BaselineOfSpartaCairo.class.st @@ -1,5 +1,6 @@ " I am a Baseline of Sparta-Cairo backend + " Class { #name : #BaselineOfSpartaCairo, diff --git a/src/Sparta-Cairo/SpartaCairoTextMetrics.class.st b/src/Sparta-Cairo/SpartaCairoTextMetrics.class.st index 6b34f288..4d6d0b20 100644 --- a/src/Sparta-Cairo/SpartaCairoTextMetrics.class.st +++ b/src/Sparta-Cairo/SpartaCairoTextMetrics.class.st @@ -12,6 +12,7 @@ height - height of the glyphs as drawn advanceX - distance to advance in the X direction after drawing these glyphs advanceY - distance to advance in the Y direction after drawing these glyphs. Will typically be zero except for vertical text layout as found in East-Asian languages. + " Class { #name : #SpartaCairoTextMetrics, diff --git a/src/Sparta-Core/SpUserFontSource.class.st b/src/Sparta-Core/SpUserFontSource.class.st index c381b8f6..64f54919 100644 --- a/src/Sparta-Core/SpUserFontSource.class.st +++ b/src/Sparta-Core/SpUserFontSource.class.st @@ -1,5 +1,6 @@ " I represent a font face source and know how to retrieve font contents from it + " Class { #name : #SpUserFontSource, diff --git a/src/Sparta-Core/SpUserFontSourceBuffer.class.st b/src/Sparta-Core/SpUserFontSourceBuffer.class.st index f7fa1204..aa076e81 100644 --- a/src/Sparta-Core/SpUserFontSourceBuffer.class.st +++ b/src/Sparta-Core/SpUserFontSourceBuffer.class.st @@ -1,6 +1,7 @@ " I am a buffer source. Is useful if font is stored as byte array in the image + " Class { #name : #SpUserFontSourceBuffer, diff --git a/src/Sparta-Core/SpUserFontSourceFile.class.st b/src/Sparta-Core/SpUserFontSourceFile.class.st index 8aa821d5..f0a6e4e4 100644 --- a/src/Sparta-Core/SpUserFontSourceFile.class.st +++ b/src/Sparta-Core/SpUserFontSourceFile.class.st @@ -2,6 +2,7 @@ I am a file source. Can be used for fast scripting without the need to load font in the image or install. May be useful if font are intended to be deployed outside of the image + " Class { #name : #SpUserFontSourceFile, diff --git a/src/Sparta-Core/SpUserFontSourceUrl.class.st b/src/Sparta-Core/SpUserFontSourceUrl.class.st index 333c9b52..46d36fbe 100644 --- a/src/Sparta-Core/SpUserFontSourceUrl.class.st +++ b/src/Sparta-Core/SpUserFontSourceUrl.class.st @@ -2,6 +2,7 @@ I am an url source. Useful if user wants to try a font from the web without the need to even download it. Requires internet connection to retrieve font content. + " Class { #name : #SpUserFontSourceUrl, diff --git a/src/Sparta-Core/SpartaBitmapBuilder.class.st b/src/Sparta-Core/SpartaBitmapBuilder.class.st index e83c2f31..b2219d4e 100644 --- a/src/Sparta-Core/SpartaBitmapBuilder.class.st +++ b/src/Sparta-Core/SpartaBitmapBuilder.class.st @@ -17,6 +17,7 @@ surface := canvas bitmap fromForm: (Smalltalk ui icons iconNamed: #classIcon). Create a new surface from image file by its absolute or relative path: surface := canvas bitmap fromFileNamed: 'images/cats/kitty.jpg' + " Class { #name : #SpartaBitmapBuilder, diff --git a/src/Sparta-Core/SpartaClipper.class.st b/src/Sparta-Core/SpartaClipper.class.st index ecd361c8..52781e63 100644 --- a/src/Sparta-Core/SpartaClipper.class.st +++ b/src/Sparta-Core/SpartaClipper.class.st @@ -1,40 +1,41 @@ " -! SpartaClipper +# SpartaClipper I provide support of clipping. -!! Overview +## Overview My responsibility is to keep track of clipping region and allow developers to push or pop. I support clipping by Rectangle or SpartaPath -!! Public API and Key Messages +## Public API and Key Messages -- ==by:during:== - clips by a path or rectangle while performing a closure, once done restores previous clipping region. Takes care about possible unhandled exceptions within a block. -- ==push:== clips by a path or rectangle. Every push: must be balanced with pop to restore clipping region. -- ==pop== - balances push: and restores clipping region to its previous state +- `by:during:` - clips by a path or rectangle while performing a closure, once done restores previous clipping region. Takes care about possible unhandled exceptions within a block. +- `push:` clips by a path or rectangle. Every push: must be balanced with pop to restore clipping region. +- `pop` - balances push: and restores clipping region to its previous state -!! Example: +## Example: Error robust implementation with the help of block closures: -[[[language=smalltalk +```language=smalltalk canvas clip by: (0@0 extent: 100@100) during: [ ""draw here"" ] -]]] +``` Or developers can balance push:/pop manually: -[[[language=smalltalk +```language=smalltalk ellipse := canvas shape ellipse: (0@0 extent: 100@100). canvas clip push: ellipse. ""draw here"" canvas clip pop. -]]] +``` -!! Internal Representation and Key Implementation Points. +## Internal Representation and Key Implementation Points. Subclasses must implement pushRectangle: pushPath: and pop + " Class { #name : #SpartaClipper, diff --git a/src/Sparta-Core/SpartaExternalForm.class.st b/src/Sparta-Core/SpartaExternalForm.class.st index 5251aba2..bb91aeb2 100644 --- a/src/Sparta-Core/SpartaExternalForm.class.st +++ b/src/Sparta-Core/SpartaExternalForm.class.st @@ -9,15 +9,15 @@ The user is responsible for both releasing the image-memory, as well as destroyi Example usage: -| extent form ptr | -extent := 400@300. +extent form ptrextent := 400@300. form := ExternalForm extent: extent depth: 32. -ptr := ExternalAddress gcallocate: (extent x * extent y * 4). +ptr := ExternalAddress gcallocate: (extent x 4). form setManualSurfacePointer: ptr. Display displayScaledOn: form. form displayAt: 0@0. form destroySurface. + " Class { #name : #SpartaExternalForm, diff --git a/src/Sparta-Core/SpartaFillEvenOddRule.class.st b/src/Sparta-Core/SpartaFillEvenOddRule.class.st index cce7acc7..6401a3bc 100644 --- a/src/Sparta-Core/SpartaFillEvenOddRule.class.st +++ b/src/Sparta-Core/SpartaFillEvenOddRule.class.st @@ -1,6 +1,7 @@ " SVG defines the even-odd rule as follows: Even-odd rule determines the ""insideness"" of a point on the canvas by drawing a ray from that point to infinity in any direction and counting the number of path segments from the given shape that the ray crosses. If this number is odd, the point is inside; if even, the point is outside. + " Class { #name : #SpartaFillEvenOddRule, diff --git a/src/Sparta-Core/SpartaFillPainter.class.st b/src/Sparta-Core/SpartaFillPainter.class.st index 4fb1ccd9..ca16e138 100644 --- a/src/Sparta-Core/SpartaFillPainter.class.st +++ b/src/Sparta-Core/SpartaFillPainter.class.st @@ -1,27 +1,27 @@ " -! SpartaFillPainter +# SpartaFillPainter I represent a fill path operation builder - a concerete type of paint-path draw operation. -!! Overview +## Overview I define an abstract api that all fill painters should provide. I am a final step in path-paint double dispatch and implement all fill draw related methods. As optimisation I have separate methods to fill rectangle and path with color, linear and radial gradients as also with surface. Backend may implement every method differently, add more dispatch stages or provide a single uniform method. -I am instantiated and pre-configured by *==SpartaCanvas==>../SpartaCanvas.class/README.md*. Do not create instances of me directly, instead use canvas as service provider. This way reference to my class will not be hardcoded which increases flexibility. +I am instantiated and pre-configured by `SpartaCanvas`. Do not create instances of me directly, instead use canvas as service provider. This way reference to my class will not be hardcoded which increases flexibility. -!! Public API and Key Messages +## Public API and Key Messages -- ==paint:== - set an object to be used as paint (can be ==Color==, *==SpartaCanvas==>../SpartaCanvas.class/README.md*, ==SpartaSurface==, *==TSpartaPaint==>../TSpartaPaint.trait/README.md*) -- ==path:== - set path to be filled (can be ==TSpartaPath== or ==Rectangle==) -- ==draw== - perform fill operation with previously configured parameters and options +- `paint:` - set an object to be used as paint (can be `Color`, `SpartaCanvas`, `SpartaSurface`, `TSpartaPaint`) +- `path:` - set path to be filled (can be `TSpartaPath` or `Rectangle`) +- `draw` - perform fill operation with previously configured parameters and options -!! Example: +## Example: Fill the whole canvas with white color: -[[[language=smalltalk +```language=smalltalk canvas fill paint: Color white; path: canvas bounds; draw. -]]] +``` Fill ellipse within rectangle (0@0 extent: 400@100) with pharo logo picture: [[[language=smalltalk @@ -32,10 +32,11 @@ canvas fill ``` +https://github.com/syrel/Sparta/raw/master/images/SpartaFillPainter/01_pharo_logo.png|label=pharoLogo+ -!! Internal Representation and Key Implementation Points. +## Internal Representation and Key Implementation Points. Concrete backend implementations should subclass me directly, I was never ment to be an external object. + " Class { #name : #SpartaFillPainter, diff --git a/src/Sparta-Core/SpartaFillRule.class.st b/src/Sparta-Core/SpartaFillRule.class.st index aa275828..9a6e0964 100644 --- a/src/Sparta-Core/SpartaFillRule.class.st +++ b/src/Sparta-Core/SpartaFillRule.class.st @@ -1,5 +1,6 @@ " Fill rule is an algorithm which determines how a graphical shape with more than one closed outline will be filled. + " Class { #name : #SpartaFillRule, diff --git a/src/Sparta-Core/SpartaFillWindingRule.class.st b/src/Sparta-Core/SpartaFillWindingRule.class.st index 09b87c8f..a35994cc 100644 --- a/src/Sparta-Core/SpartaFillWindingRule.class.st +++ b/src/Sparta-Core/SpartaFillWindingRule.class.st @@ -1,6 +1,7 @@ " SVG defines the non-zero winding rule as follows: Non-zero winding rule determines the ""insideness"" of a point on the canvas by drawing a ray from that point to infinity in any direction and then examining the places where a segment of the shape crosses the ray. Starting with a count of zero, add one each time a path segment crosses the ray from left to right and subtract one each time a path segment crosses the ray from right to left. After counting the crossings, if the result is zero then the point is outside the path. Otherwise, it is inside. + " Class { #name : #SpartaFillWindingRule, diff --git a/src/Sparta-Core/SpartaFilterPainter.class.st b/src/Sparta-Core/SpartaFilterPainter.class.st index 21b0341f..d1cf1f6a 100644 --- a/src/Sparta-Core/SpartaFilterPainter.class.st +++ b/src/Sparta-Core/SpartaFilterPainter.class.st @@ -1,24 +1,24 @@ " -! SpartaFilterPainter +# SpartaFilterPainter I am an abstract filter painter used to construct filter drawing operation. -!! Overview +## Overview I am responsible for creation and execution of filter draw operation. It requires an area on which it should be applied, an offset (if not set, area origin is used instead) and actual filter primitive. Developers should use me to create a filter drawing operation. It involves a configuration step of wanted filter and actual drawing step. I must be only created by canvas, and never directly refering my class. -!! Public API and Key Messages +## Public API and Key Messages -- ==area:== - set an area on which filter should be applied (source area) -- ==type:== - an object representing one of filter primitives. See ==filters== protocol in *SpartaCanvas>../SpartaCanvas.class/README.md* -- ==to:== - ''(optional)'' set location on canvas where result should be blended (destination). If not set, area origin is used. -- ==drawOptions:== - ''(optional)'' set additional draw parameters, such as global alpha, composition operator and antialias. +- `area:` - set an area on which filter should be applied (source area) +- `type:` - an object representing one of filter primitives. See `filters` protocol in SpartaCanvas +- `to:` - *(optional)* set location on canvas where result should be blended (destination). If not set, area origin is used. +- `drawOptions:` - *(optional)* set additional draw parameters, such as global alpha, composition operator and antialias. -!! Example: +## Example: -[[[language=smalltalk +```language=smalltalk canvas filter area: (100@100 extent: 200@200); to: 150@150; @@ -26,19 +26,20 @@ canvas filter source: canvas; stdDeviation: 4); draw. -]]] +``` -!! Internal Representation and Key Implementation Points. +## Internal Representation and Key Implementation Points. -!!! Instance Variables -- destinationPoint: ==== -- drawOptions: ==== -- filter: ==== -- sourceRectangle: ==== +### Instance Variables +- destinationPoint: `` +- drawOptions: `` +- filter: `` +- sourceRectangle: `` -!!! Implementation Points +### Implementation Points + +I am an abstract class. Concrete backends must implement `#draw` -I am an abstract class. Concrete backends must implement ==#draw== " Class { diff --git a/src/Sparta-Core/SpartaFiltersFactory.class.st b/src/Sparta-Core/SpartaFiltersFactory.class.st index e0f5de71..8ea497e7 100644 --- a/src/Sparta-Core/SpartaFiltersFactory.class.st +++ b/src/Sparta-Core/SpartaFiltersFactory.class.st @@ -16,6 +16,7 @@ Public API and Key Messages kitty := canvas bitmap fromFileNamed: 'images/cats/kitty.jpg'. brannan := canvas filters brannan: kitty. + " Class { #name : #SpartaFiltersFactory, diff --git a/src/Sparta-Core/SpartaFontCache.class.st b/src/Sparta-Core/SpartaFontCache.class.st index 49ee82e9..f07e0ba4 100644 --- a/src/Sparta-Core/SpartaFontCache.class.st +++ b/src/Sparta-Core/SpartaFontCache.class.st @@ -1,5 +1,6 @@ " I cache fonts with font style a key + " Class { #name : #SpartaFontCache, diff --git a/src/Sparta-Core/SpartaFontFace.class.st b/src/Sparta-Core/SpartaFontFace.class.st index 14a8b9b3..454fa0b1 100644 --- a/src/Sparta-Core/SpartaFontFace.class.st +++ b/src/Sparta-Core/SpartaFontFace.class.st @@ -1,6 +1,7 @@ " I represent a font face. My properties are backend specific + " Class { #name : #SpartaFontFace, diff --git a/src/Sparta-Core/SpartaFormCache.class.st b/src/Sparta-Core/SpartaFormCache.class.st index 81d1faf0..fc23ca47 100644 --- a/src/Sparta-Core/SpartaFormCache.class.st +++ b/src/Sparta-Core/SpartaFormCache.class.st @@ -1,5 +1,6 @@ " I cache bitmaps created from forms + " Class { #name : #SpartaFormCache, diff --git a/src/Sparta-Core/SpartaLine.class.st b/src/Sparta-Core/SpartaLine.class.st index 8605d335..b9223443 100644 --- a/src/Sparta-Core/SpartaLine.class.st +++ b/src/Sparta-Core/SpartaLine.class.st @@ -18,6 +18,7 @@ Internal Representation and Key Implementation Points. Implementation Points + " Class { #name : #SpartaLine, diff --git a/src/Sparta-Core/SpartaMetrics.class.st b/src/Sparta-Core/SpartaMetrics.class.st index 5ff3a35c..2bcfad0a 100644 --- a/src/Sparta-Core/SpartaMetrics.class.st +++ b/src/Sparta-Core/SpartaMetrics.class.st @@ -2,6 +2,7 @@ I represent a metrics request. I hold all neccessary information that is needed by metrics provider in order to measure provided text run. + " Class { #name : #SpartaMetrics, diff --git a/src/Sparta-Core/SpartaPaintProvider.class.st b/src/Sparta-Core/SpartaPaintProvider.class.st index c43ab269..06c5f303 100644 --- a/src/Sparta-Core/SpartaPaintProvider.class.st +++ b/src/Sparta-Core/SpartaPaintProvider.class.st @@ -20,6 +20,7 @@ Internal Representation and Key Implementation Points. My subclasses must provide backend specific paints + " Class { #name : #SpartaPaintProvider, diff --git a/src/Sparta-Core/SpartaRectangle.class.st b/src/Sparta-Core/SpartaRectangle.class.st index 87a70706..8a1be19e 100644 --- a/src/Sparta-Core/SpartaRectangle.class.st +++ b/src/Sparta-Core/SpartaRectangle.class.st @@ -1,5 +1,6 @@ " I am mutable implementation of Rectangle which stores coordinates as Numbers and not Points + " Class { #name : #SpartaRectangle, diff --git a/src/Sparta-Core/SpartaShapeFactory.class.st b/src/Sparta-Core/SpartaShapeFactory.class.st index 0f486e81..4b5fc331 100644 --- a/src/Sparta-Core/SpartaShapeFactory.class.st +++ b/src/Sparta-Core/SpartaShapeFactory.class.st @@ -16,6 +16,7 @@ Internal Representation and Key Implementation Points. It makes a lot of sense to implement shape creation methods as plugin or as part of backend + " Class { #name : #SpartaShapeFactory, diff --git a/src/Sparta-Core/SpartaStrokePainter.class.st b/src/Sparta-Core/SpartaStrokePainter.class.st index 8bac3528..628ba106 100644 --- a/src/Sparta-Core/SpartaStrokePainter.class.st +++ b/src/Sparta-Core/SpartaStrokePainter.class.st @@ -1,30 +1,30 @@ " -! SpartaStrokePainter +# SpartaStrokePainter I represent a stroke path operation builder - a concrete type of paint-path draw operation. -!! Overview +## Overview I define an abstract api that all stroke painters should provide. I am a final step in path-paint double dispatch and implement all stroke draw related methods. As optimization I have separate methods to stroke rectangle and path with color, linear and radial gradients as also with surface. Backends may implement every method differently, add more dispatch stages or provide a single uniform method. -I am instantiated and pre-configured by *==SpartaCanvas==>../SpartaCanvas.class/README.md*. +I am instantiated and pre-configured by `SpartaCanvas`. Do not create instances of me directly, instead use canvas as service provider. This way reference to my class will not be hardcoded which increases flexibility. -!! Public API and Key Messages +## Public API and Key Messages -- ==paint:== - set an object to be used as paint (can be ==Color==, *==SpartaCanvas==>../SpartaCanvas.class/README.md*, ==SpartaSurface==, *==TSpartaPaint==>../TSpartaPaint.trait/README.md*) -- ==path:== - set path to be stroked (can be ==TSpartaPath== or ==Rectangle==) -- ==width:== - set stroke width (==Number== - integer or float) -- ==dashOffset:== - set the location along a path where the dash of a stroke will begin. The higher the number, the further along the path the dashes will begin. (==Number== - integer or float) -- ==dashPattern:== - define dashes using array representation in form =={""fill"" . ""gap"" . ""fill"" . ""gap"" }==, for example ==#(20 30 50 40)== -- ==draw== - perform stroke operation with previously configured parameters and options +- `paint:` - set an object to be used as paint (can be `Color`, `SpartaCanvas`, `SpartaSurface`, `TSpartaPaint`) +- `path:` - set path to be stroked (can be `TSpartaPath` or `Rectangle`) +- `width:` - set stroke width (`Number` - integer or float) +- `dashOffset:` - set the location along a path where the dash of a stroke will begin. The higher the number, the further along the path the dashes will begin. (`Number` - integer or float) +- `dashPattern:` - define dashes using array representation in form `{""fill"" . ""gap"" . ""fill"" . ""gap"" }`, for example `#(20 30 50 40)` +- `draw` - perform stroke operation with previously configured parameters and options -!! Example: +## Example: Fill the whole canvas with white color: -[[[language=smalltalk +```language=smalltalk gradient := canvas paint linearGradient begin: 50@25; end: 300@200; @@ -38,14 +38,15 @@ canvas stroke dashPattern: #(25); capRound; draw. -]]] +``` +https://github.com/syrel/Sparta/raw/master/images/SpartaStrokePainter/01_stroke_dash_gradient.png|label=strokeGradient+ -!! Internal Representation and Key Implementation Points. +## Internal Representation and Key Implementation Points. Concrete backend implementations should subclass me directly, I was never meant to be an external object. + " Class { #name : #SpartaStrokePainter, diff --git a/src/Sparta-Core/SpartaStrokedBoundsCache.class.st b/src/Sparta-Core/SpartaStrokedBoundsCache.class.st index f49d7c67..cbf4e213 100644 --- a/src/Sparta-Core/SpartaStrokedBoundsCache.class.st +++ b/src/Sparta-Core/SpartaStrokedBoundsCache.class.st @@ -1,12 +1,13 @@ " I provide the support of stroked bounds cache. The computation of the stroked bounds is expensive and we want to provide a quick consecutive access to it forthe same stroke options. -[[[ +``` cache := SpartaStrokedBoundsCache new. cache strokedBounds: strokeOptions ifAbsentPut: [ ""compute bounds here"" ] -]]] +``` + " Class { #name : #SpartaStrokedBoundsCache, diff --git a/src/Sparta-Core/SpartaTextPainter.class.st b/src/Sparta-Core/SpartaTextPainter.class.st index 7d7c9b37..c2b0388b 100644 --- a/src/Sparta-Core/SpartaTextPainter.class.st +++ b/src/Sparta-Core/SpartaTextPainter.class.st @@ -1,39 +1,39 @@ " -! SpartaTextPainter +# SpartaTextPainter I am a text painter. -!! Overview +## Overview I help developers to create, configure and execute text draw operation. For that users of me must provide at least a font (backend specific, create using SpartaFontBuilder) to use and actual string to draw. Additionally users may provide draw and stroke options as also specify how exactly string should be rendered: fill or stroke it. It is also possible to choose if stroke should be rendered below fill or not. -!! Public API and Key Messages +## Public API and Key Messages -- ==font:== - set a font that should be used to render a string -- ==string:== - set string to render -- ==baseline:== - set baseline location where string should be rendered -- ==fill== - string should be filled (default mode) -- ==stroke== - stroke string -- ==strokeBelow== - stroke should be rendered below fill -- ==drawOptions:== - set custom draw options (alpha, composition mode, antialias) -- ==strokeOptions:== - set custom stroke options (stroke width, other stroke related parameters) +- `font:` - set a font that should be used to render a string +- `string:` - set string to render +- `baseline:` - set baseline location where string should be rendered +- `fill` - string should be filled (default mode) +- `stroke` - stroke string +- `strokeBelow` - stroke should be rendered below fill +- `drawOptions:` - set custom draw options (alpha, composition mode, antialias) +- `strokeOptions:` - set custom stroke options (stroke width, other stroke related parameters) -!! Example: +## Example: -First we need to create a font group, in this case of generic type *sans-serif*: -[[[language=smalltalk +First we need to create a font group, in this case of generic type : +```language=smalltalk font := canvas font size: 28; weightThin; sansSerif; build. -]]] +``` Use created font group to render multi-language text: -[[[language=smalltalk +```language=smalltalk canvas text string: 'Sparta Спарта 斯巴達 سپارٹا ස්පාටා'; font: font; @@ -42,24 +42,25 @@ canvas text string: '😂🙈🚀' origin: 20@70; draw. -]]] +``` +https://github.com/syrel/Sparta/raw/documentation/images/SpartaTextPainter/01_multilanguage.png|label=multilanguage+ -!! Internal Representation and Key Implementation Points. +## Internal Representation and Key Implementation Points. -!!! Instance Variables +### Instance Variables -- color: ==== -- drawOptions: ==== -- font: ==== -- baseline: ==== -- string: ==== -- strokeOptions: ==== +- color: `` +- drawOptions: `` +- font: `` +- baseline: `` +- string: `` +- strokeOptions: `` -!!! Implementation Points +### Implementation Points Font to use is backend specific. It must be created using SpartaFontBuilder. + " Class { #name : #SpartaTextPainter, diff --git a/src/Sparta-Core/SpartaUnsupported.class.st b/src/Sparta-Core/SpartaUnsupported.class.st index dacb6aa1..54a6e6e4 100644 --- a/src/Sparta-Core/SpartaUnsupported.class.st +++ b/src/Sparta-Core/SpartaUnsupported.class.st @@ -1,5 +1,6 @@ " I am a silent notification that is signaled if backend does not support a requested operation + " Class { #name : #SpartaUnsupported, diff --git a/src/Sparta-Skia/SkiaCanvas.class.st b/src/Sparta-Skia/SkiaCanvas.class.st index 7da63987..022bdbee 100644 --- a/src/Sparta-Skia/SkiaCanvas.class.st +++ b/src/Sparta-Skia/SkiaCanvas.class.st @@ -44,6 +44,7 @@ canvas fill canvas flush. canvas snapshot + " Class { #name : #SkiaCanvas, diff --git a/src/Sparta-Skia/SkiaFilterSourceCanvas.class.st b/src/Sparta-Skia/SkiaFilterSourceCanvas.class.st index fb961dde..ec499e1f 100644 --- a/src/Sparta-Skia/SkiaFilterSourceCanvas.class.st +++ b/src/Sparta-Skia/SkiaFilterSourceCanvas.class.st @@ -1,5 +1,6 @@ " When canvas is a source of a filter we should take its snapshot + " Class { #name : #SkiaFilterSourceCanvas,