From d506e134faee8940e4bdaa669b6d3d79646c9e4c Mon Sep 17 00:00:00 2001 From: Martin Dias Date: Fri, 2 Feb 2024 19:34:42 -0300 Subject: [PATCH 1/2] Replace all {{gtClass:X} to `X` --- .../BlDevHalosEventListener.class.st | 6 +++--- .../BlDevHalosEventListenerExample.class.st | 2 +- src/Bloc-DevTool/BlElementSelection.class.st | 2 +- .../BlElementSelectionButton.class.st | 2 +- .../BlElementSelectionListener.class.st | 2 +- .../BlMetricsInspectorExample.class.st | 2 +- ...seOverOutAndEnterLeaveEventExample.class.st | 6 +++--- .../BlSharedEventDistributorExamples.class.st | 2 +- .../BlSpaceIconDummyStencil.class.st | 2 +- src/Bloc-Layout/BlFrameLayout.class.st | 10 +++++----- src/Bloc-Layout/BlGridLayoutInterval.class.st | 4 ++-- src/Bloc-SVG/BlSvgPath.class.st | 2 +- .../BlDevScripterClickStep.class.st | 2 +- ...BlDevScripterEventCollectorHandler.class.st | 4 ++-- src/Bloc-Scripter/BlDevScripterTest.class.st | 2 +- ...entMeasurementStrategyExamplesTest.class.st | 2 +- ...TextUnderlineAttributeExamplesTest.class.st | 2 +- src/Bloc-Text/BlCharacterText.class.st | 2 +- src/Bloc-Text/BlText.class.st | 4 ++-- .../BlTextAttributesCachingFinder.class.st | 2 +- src/Bloc-Text/BlTextDecorationStyle.class.st | 2 +- .../BlTextDelegatedAttributesBuilder.class.st | 2 +- src/Bloc-Text/BlTextReadStream.class.st | 2 +- src/Bloc/BlAlreadyAddedAsChildError.class.st | 2 +- src/Bloc/BlAttachedSpaceReference.class.st | 2 +- src/Bloc/BlBackground.class.st | 10 +++++----- src/Bloc/BlBasicShortcut.class.st | 6 +++--- src/Bloc/BlBeaconLoggingTask.class.st | 4 ++-- src/Bloc/BlBeaconTaskSignal.class.st | 6 +++--- src/Bloc/BlChildren.class.st | 2 +- src/Bloc/BlChildrenArray.class.st | 4 ++-- src/Bloc/BlChildrenCollection.class.st | 10 +++++----- src/Bloc/BlChildrenLinkedList.class.st | 6 +++--- src/Bloc/BlChildrenOrderedCollection.class.st | 6 +++--- src/Bloc/BlChildrenRope.class.st | 6 +++--- src/Bloc/BlChildrenSubset.class.st | 10 +++++----- src/Bloc/BlCustomEventHandler.class.st | 2 +- src/Bloc/BlDetachedSpaceReference.class.st | 2 +- src/Bloc/BlDirectEventDispatcher.class.st | 2 +- src/Bloc/BlElement.class.st | 18 +++++++++--------- src/Bloc/BlElementId.class.st | 2 +- src/Bloc/BlErrorHandler.class.st | 2 +- src/Bloc/BlEventForwarder.class.st | 2 +- src/Bloc/BlFocusChain.class.st | 2 +- src/Bloc/BlHistogramGeometry.class.st | 2 +- src/Bloc/BlImageBackground.class.st | 2 +- src/Bloc/BlKeyboardProcessor.class.st | 2 +- src/Bloc/BlLayout.class.st | 6 +++--- src/Bloc/BlLayoutNode.class.st | 2 +- src/Bloc/BlMouseEnterEvent.class.st | 2 +- src/Bloc/BlMouseLeaveEvent.class.st | 2 +- src/Bloc/BlMouseOutEvent.class.st | 2 +- src/Bloc/BlMouseOverEvent.class.st | 2 +- src/Bloc/BlMouseWheelEvent.class.st | 4 ++-- src/Bloc/BlNullSpaceReference.class.st | 2 +- src/Bloc/BlPaintBackground.class.st | 2 +- src/Bloc/BlRope.class.st | 2 +- src/Bloc/BlSelectionTree.class.st | 2 +- src/Bloc/BlSharedEventDistributor.class.st | 4 ++-- src/Bloc/BlShortcut.class.st | 2 +- src/Bloc/BlShortcutWithAction.class.st | 2 +- src/Bloc/BlSpaceDestroyedEvent.class.st | 2 +- src/Bloc/BlSpaceManager.class.st | 6 +++--- src/Bloc/BlSpaceReference.class.st | 10 +++++----- src/Bloc/BlValueWithUnit.class.st | 2 +- src/Bloc/ManifestBloc.class.st | 10 +++++----- src/BlocHost-Morphic/BlBlocUIManager.class.st | 2 +- 67 files changed, 124 insertions(+), 124 deletions(-) diff --git a/src/Bloc-DevTool/BlDevHalosEventListener.class.st b/src/Bloc-DevTool/BlDevHalosEventListener.class.st index 6a2e480f5..c69c10449 100644 --- a/src/Bloc-DevTool/BlDevHalosEventListener.class.st +++ b/src/Bloc-DevTool/BlDevHalosEventListener.class.st @@ -1,9 +1,9 @@ " -I am an {{gtClass:BlEventListener}} event listener and I can display halos around an element. Halos then permits to inspect or delete. +I am an `BlEventListener` event listener and I can display halos around an element. Halos then permits to inspect or delete. -You can install me on any {{gtClass:BlSpace}} (window) using {{gtMethod:BlSpace>>#withHalos}}. +You can install me on any `BlSpace` (window) using {{gtMethod:BlSpace>>#withHalos}}. -The {{gtMethod:BlDevHalosEventListener>>#mouseDownEvent:}} checks if `SHIFT` and `ALT` modifiers are pressed during a {{gtClass:BlMouseDownEvent}}. You can try to click on the rectangle below while pressing `SHIFT` and `ALT`: +The {{gtMethod:BlDevHalosEventListener>>#mouseDownEvent:}} checks if `SHIFT` and `ALT` modifiers are pressed during a `BlMouseDownEvent`. You can try to click on the rectangle below while pressing `SHIFT` and `ALT`: {{gtExample:BlDevHalosEventListenerExamples>>#containerWithRectangle|codeExpanded=false|previewExpanded=true|previewHeight=350|previewShow=#gtLiveFor:}} diff --git a/src/Bloc-DevTool/BlDevHalosEventListenerExample.class.st b/src/Bloc-DevTool/BlDevHalosEventListenerExample.class.st index a0cbab0bf..66107b125 100644 --- a/src/Bloc-DevTool/BlDevHalosEventListenerExample.class.st +++ b/src/Bloc-DevTool/BlDevHalosEventListenerExample.class.st @@ -1,5 +1,5 @@ " -I exemplify {{gtClass:BlDevHalosEventListener}}. +I exemplify `BlDevHalosEventListener`. " Class { diff --git a/src/Bloc-DevTool/BlElementSelection.class.st b/src/Bloc-DevTool/BlElementSelection.class.st index 88a29eb8f..0df276f85 100644 --- a/src/Bloc-DevTool/BlElementSelection.class.st +++ b/src/Bloc-DevTool/BlElementSelection.class.st @@ -1,5 +1,5 @@ " -I am a Halos element. For more information about me, see {{gtClass:BlDevHalosEventListener}}. +I am a Halos element. For more information about me, see `BlDevHalosEventListener`. " Class { diff --git a/src/Bloc-DevTool/BlElementSelectionButton.class.st b/src/Bloc-DevTool/BlElementSelectionButton.class.st index 9fb29a521..8c1e4af0a 100644 --- a/src/Bloc-DevTool/BlElementSelectionButton.class.st +++ b/src/Bloc-DevTool/BlElementSelectionButton.class.st @@ -1,5 +1,5 @@ " -I am one button inside of a Halos element. For more information about me, see {{gtClass:BlDevHalosEventListener}}. +I am one button inside of a Halos element. For more information about me, see `BlDevHalosEventListener`. " Class { diff --git a/src/Bloc-DevTool/BlElementSelectionListener.class.st b/src/Bloc-DevTool/BlElementSelectionListener.class.st index b8c29d19b..28f1c3f94 100644 --- a/src/Bloc-DevTool/BlElementSelectionListener.class.st +++ b/src/Bloc-DevTool/BlElementSelectionListener.class.st @@ -1,5 +1,5 @@ " -I am an event handler that is used for Halos element. For more information about me, see {{gtClass:BlDevHalosEventListener}}. +I am an event handler that is used for Halos element. For more information about me, see `BlDevHalosEventListener`. " Class { diff --git a/src/Bloc-DevTool/BlMetricsInspectorExample.class.st b/src/Bloc-DevTool/BlMetricsInspectorExample.class.st index 8af22707b..ee203e6dc 100644 --- a/src/Bloc-DevTool/BlMetricsInspectorExample.class.st +++ b/src/Bloc-DevTool/BlMetricsInspectorExample.class.st @@ -1,5 +1,5 @@ " -I exemplify {{gtClass:BlMetricsInspector}}. +I exemplify `BlMetricsInspector`. " Class { diff --git a/src/Bloc-Examples/BlMouseOverOutAndEnterLeaveEventExample.class.st b/src/Bloc-Examples/BlMouseOverOutAndEnterLeaveEventExample.class.st index 6c48e8c02..c574b9b48 100644 --- a/src/Bloc-Examples/BlMouseOverOutAndEnterLeaveEventExample.class.st +++ b/src/Bloc-Examples/BlMouseOverOutAndEnterLeaveEventExample.class.st @@ -9,17 +9,17 @@ In this explanation we will take a look at what happens when mouse moves between ### `BlMouseEnterEvent` and `BlMouseLeaveEvent` -If you are looking for the simplest way to detect when a user hovers an element with the mouse use a combination of {{gtClass:BlMouseEnterEvent}} and {{gtClass:BlMouseLeaveEvent}}. +If you are looking for the simplest way to detect when a user hovers an element with the mouse use a combination of `BlMouseEnterEvent` and `BlMouseLeaveEvent`. They trigger when the mouse pointer enters/leaves the element: *(mouse your mouse over the preview element below)* {{gtExample:BlMouseOverOutAndEnterLeaveEventExplanation>>#basicMouseEnterAndLeave|previewExpanded=true|previewShow=#gtLiveFor:|previewHeight=240}} -{{gtClass:BlMouseEnterEvent}} and {{gtClass:BlMouseLeaveEvent}} are sent directly (`dispatched`) to the element, ignoring any mouse transitions inside the element, therefore both mouse enter and leave events do not bubble. In the example below, notice how parent container does not receive mouse leave event when mouse transitions between children: +`BlMouseEnterEvent` and `BlMouseLeaveEvent` are sent directly (`dispatched`) to the element, ignoring any mouse transitions inside the element, therefore both mouse enter and leave events do not bubble. In the example below, notice how parent container does not receive mouse leave event when mouse transitions between children: {{gtExample:BlMouseOverOutAndEnterLeaveEventExplanation>>#mouseEnterAndLeaveConsumed|noCode=true|previewExpanded=true|previewShow=#gtLiveFor:|previewHeight=240}} ### `BlMouseOverEvent` and `BlMouseOutEvent` -Similar to the mouse enter but a bit more advanced, {{gtClass:BlMouseOverEvent}} occurs when a mouse pointer comes over an element, and {{gtClass:BlMouseOutEvent}} – when it leaves: +Similar to the mouse enter but a bit more advanced, `BlMouseOverEvent` occurs when a mouse pointer comes over an element, and `BlMouseOutEvent` – when it leaves: {{gtExample:BlMouseOverOutAndEnterLeaveEventExplanation>>#basicMouseOverAndOut|previewExpanded=true|previewShow=#gtLiveFor:|previewHeight=240}} An important feature of mouseout – it triggers, when the pointer moves from an element to its descendant, e.g. from #parent to #child. It also means that mouse over/out events bubble. diff --git a/src/Bloc-Examples/BlSharedEventDistributorExamples.class.st b/src/Bloc-Examples/BlSharedEventDistributorExamples.class.st index f1b03ec2b..fafb8eefe 100644 --- a/src/Bloc-Examples/BlSharedEventDistributorExamples.class.st +++ b/src/Bloc-Examples/BlSharedEventDistributorExamples.class.st @@ -1,5 +1,5 @@ " -I exemplify {{gtClass:BlSharedEventDistributor}}. +I exemplify `BlSharedEventDistributor`. " Class { diff --git a/src/Bloc-Examples/BlSpaceIconDummyStencil.class.st b/src/Bloc-Examples/BlSpaceIconDummyStencil.class.st index c50b5b07b..0cbc70547 100644 --- a/src/Bloc-Examples/BlSpaceIconDummyStencil.class.st +++ b/src/Bloc-Examples/BlSpaceIconDummyStencil.class.st @@ -1,5 +1,5 @@ " -I am a dummy object used by {{gtClass:BlSpaceExamples}}. +I am a dummy object used by `BlSpaceExamples`. I evaluate create an icon on {{gtMethod:BlSpaceIconDummyStencil>>#asElement|label=#selector}} call. diff --git a/src/Bloc-Layout/BlFrameLayout.class.st b/src/Bloc-Layout/BlFrameLayout.class.st index 02ab262b5..7cfc16445 100644 --- a/src/Bloc-Layout/BlFrameLayout.class.st +++ b/src/Bloc-Layout/BlFrameLayout.class.st @@ -4,7 +4,7 @@ I am a layout designed to block out an area on the screen to display a single child. I should be mainly used to display a single child, as it can be difficult to display multiple children at different positions on the screen without overlapping each other. -However, elements with a frame layout can have multiple child elements. The `'weight'` and `'alignment'` attributes can be used to control the position of children. However, weight only works when the child matches the parent; if it fits content or has an exact size, the weight attribute is ignored. I rely on custom layout constraints for setting attributes (see {{gtClass:BlFrameLayoutConstraints}}, {{gtClass:BlFrameLayoutConstraintsHorizontal}} and {{gtClass:BlFrameLayoutConstraintsVertical}}). +However, elements with a frame layout can have multiple child elements. The `'weight'` and `'alignment'` attributes can be used to control the position of children. However, weight only works when the child matches the parent; if it fits content or has an exact size, the weight attribute is ignored. I rely on custom layout constraints for setting attributes (see `BlFrameLayoutConstraints`, `BlFrameLayoutConstraintsHorizontal` and `BlFrameLayoutConstraintsVertical`). I position each child element based on the top left of the screen. Child elements are stacked on top of each other, with the most recently added child on top. An important property is that the location of a child is independent from the location of other children. @@ -17,7 +17,7 @@ The alignment attribute controls the position of children within a FrameLayout. - horizontally children can be aligned to left, center or right; - vertically children can be aligned to top, center or bottom. -For example, below we align a fixed-size child horizontally to the right and vertically to the bottom. Alignment is a constraint specific to frame layouts, as it's not relevant to all layouts. To access frame-specific contraints, we send {{gtMethod:BlLayoutCommonConstraints>>#frame}} to the current constraint object, which returns an instance of {{gtClass:BlFrameLayoutConstraints}} that we can use to set the desired alignment. Other constraints like the size of an element are common to all layouts and can be set directly without requesting a specific constraint object. Both cases are illustrated by the following example: +For example, below we align a fixed-size child horizontally to the right and vertically to the bottom. Alignment is a constraint specific to frame layouts, as it's not relevant to all layouts. To access frame-specific contraints, we send {{gtMethod:BlLayoutCommonConstraints>>#frame}} to the current constraint object, which returns an instance of `BlFrameLayoutConstraints` that we can use to set the desired alignment. Other constraints like the size of an element are common to all layouts and can be set directly without requesting a specific constraint object. Both cases are illustrated by the following example: {{gtExample:BlFrameLayoutSingleChildExamples>>#elementDocumentationWithOneExactChildAlignBottomRightInExactParent|previewExpanded|previewHeight=400}} When using multiple children, if we do not specify any alignment they will be placed in the top-left corner in the order in which they were added to the parent. @@ -68,9 +68,9 @@ However, this will not work when the parent uses ""fit content"" and the child u ## More examples For more example on how to use frame layouts, check out these classes: -- {{gtClass:BlFrameLayoutSingleChildExamples}} -- {{gtClass:BlFrameLayoutMultipleChildrenExamples}} -- {{gtClass:BlFrameLayoutCompositionExamples}} +- `BlFrameLayoutSingleChildExamples` +- `BlFrameLayoutMultipleChildrenExamples` +- `BlFrameLayoutCompositionExamples` " diff --git a/src/Bloc-Layout/BlGridLayoutInterval.class.st b/src/Bloc-Layout/BlGridLayoutInterval.class.st index 6479ab558..43a361e96 100644 --- a/src/Bloc-Layout/BlGridLayoutInterval.class.st +++ b/src/Bloc-Layout/BlGridLayoutInterval.class.st @@ -1,14 +1,14 @@ " An Interval represents a contiguous range of values that lie between the interval's #min and #max values . -I am different from {{gtClass:Interval}} in a sense that I don't include #max and my size is computed as (max - min) +I am different from `Interval` in a sense that I don't include #max and my size is computed as (max - min) Intervals are immutable so may be passed as values and used as keys in hash tables. It is not necessary to have multiple instances of Intervals which have the same #min and #max values. Intervals are often written as [min, max) and represent the set of values min <= x < max. -I am used by {{gtClass:BlGridLayoutArc}} +I am used by `BlGridLayoutArc` " Class { diff --git a/src/Bloc-SVG/BlSvgPath.class.st b/src/Bloc-SVG/BlSvgPath.class.st index 6488fe46c..d6510eefb 100644 --- a/src/Bloc-SVG/BlSvgPath.class.st +++ b/src/Bloc-SVG/BlSvgPath.class.st @@ -1,5 +1,5 @@ " -I am the {{gtClass:BlElementVectorGeometry}} used to represent a SVG Path, which allows to make complex drawings. +I am the `BlElementVectorGeometry` used to represent a SVG Path, which allows to make complex drawings. A SVG Path is obtained through successives commands, which each symbolizes a movement of the virtual pen drawing the path. My instance variable'pathData' stores the list of commands used to obtain my final drawing. diff --git a/src/Bloc-Scripter/BlDevScripterClickStep.class.st b/src/Bloc-Scripter/BlDevScripterClickStep.class.st index 3cdeb7b88..46275b96c 100644 --- a/src/Bloc-Scripter/BlDevScripterClickStep.class.st +++ b/src/Bloc-Scripter/BlDevScripterClickStep.class.st @@ -1,5 +1,5 @@ " -I fire a {{gtClass:BlMouseDownEvent}}, {{gtClass:BlMouseUpEvent}}, and {{gtClass:BlClickEvent}}. +I fire a `BlMouseDownEvent`, `BlMouseUpEvent`, and `BlClickEvent`. ## Example diff --git a/src/Bloc-Scripter/BlDevScripterEventCollectorHandler.class.st b/src/Bloc-Scripter/BlDevScripterEventCollectorHandler.class.st index 93d28c61b..96d9bbd7d 100644 --- a/src/Bloc-Scripter/BlDevScripterEventCollectorHandler.class.st +++ b/src/Bloc-Scripter/BlDevScripterEventCollectorHandler.class.st @@ -1,6 +1,6 @@ " -I am a {{gtClass:BlBasicEventHandler}}. -I am used by {{gtClass:BlDevScripter}}. +I am a `BlBasicEventHandler`. +I am used by `BlDevScripter`. I collect events into {{gtMethod:BlDevScripter>>#events}}. " diff --git a/src/Bloc-Scripter/BlDevScripterTest.class.st b/src/Bloc-Scripter/BlDevScripterTest.class.st index 3a7e7d94f..850e5908b 100644 --- a/src/Bloc-Scripter/BlDevScripterTest.class.st +++ b/src/Bloc-Scripter/BlDevScripterTest.class.st @@ -1,5 +1,5 @@ " -I exemplify {{gtClass:BlDevScripter}}. +I exemplify `BlDevScripter`. " Class { diff --git a/src/Bloc-Text-Alexandrie-Examples/BlTextElementMeasurementStrategyExamplesTest.class.st b/src/Bloc-Text-Alexandrie-Examples/BlTextElementMeasurementStrategyExamplesTest.class.st index 808b798fc..b71b645df 100644 --- a/src/Bloc-Text-Alexandrie-Examples/BlTextElementMeasurementStrategyExamplesTest.class.st +++ b/src/Bloc-Text-Alexandrie-Examples/BlTextElementMeasurementStrategyExamplesTest.class.st @@ -1,7 +1,7 @@ " # Text measurement strategies -{{gtClass:BlTextElement}} provides different text measurement strategies, each suitable for a specific use case. There is no perfect strategy, therefore understanding the differences between them is an important step in learning how to work with Text in Bloc. +`BlTextElement` provides different text measurement strategies, each suitable for a specific use case. There is no perfect strategy, therefore understanding the differences between them is an important step in learning how to work with Text in Bloc. ## Label measurement diff --git a/src/Bloc-Text-Examples/BlTextUnderlineAttributeExamplesTest.class.st b/src/Bloc-Text-Examples/BlTextUnderlineAttributeExamplesTest.class.st index b0c3f42e1..1362066cb 100644 --- a/src/Bloc-Text-Examples/BlTextUnderlineAttributeExamplesTest.class.st +++ b/src/Bloc-Text-Examples/BlTextUnderlineAttributeExamplesTest.class.st @@ -7,7 +7,7 @@ The simplest way to apply an underline attribute on a whole text would be to use To add an underline to just a part of text it can be scoped with {{gtMethod:BlText>>#from:to:}} {{gtExample:BlTextUnderlineAttributeExamples>>#textWithUnderline_3_to_4|previewShow=#gtTextFor:|previewExpanded|previewHeight=100}} -In addition to the simple API an underline attribute can be customized and then applied on a text using {{gtMethod:TBlTextStyleable>>#underlineDo:}} helper method. Users should pass a block that accepts {{gtClass:BlTextDecorationAttribute}} as an argument. +In addition to the simple API an underline attribute can be customized and then applied on a text using {{gtMethod:TBlTextStyleable>>#underlineDo:}} helper method. Users should pass a block that accepts `BlTextDecorationAttribute` as an argument. {{gtExample:BlTextUnderlineAttributeExamples>>#textWithUnderlineDo|previewShow=#gtTextFor:|previewExpanded|previewHeight=100}} " diff --git a/src/Bloc-Text/BlCharacterText.class.st b/src/Bloc-Text/BlCharacterText.class.st index 001c3a321..91d3fc2c1 100644 --- a/src/Bloc-Text/BlCharacterText.class.st +++ b/src/Bloc-Text/BlCharacterText.class.st @@ -1,5 +1,5 @@ " -I am a special type of {{gtClass:name=BlText}} with a guarantee that every item is a character. +I am a special type of `name=BlText` with a guarantee that every item is a character. {{gtClass:name=BlCharacterText} is designed to be polymorphic with ${class:name=WideString}}, e.g. I can be compared with it (""text = string"" and ""string = text""). Similar to the String I can not modified (insertion or deletions). Therefore diff --git a/src/Bloc-Text/BlText.class.st b/src/Bloc-Text/BlText.class.st index 965252719..0f17abd31 100644 --- a/src/Bloc-Text/BlText.class.st +++ b/src/Bloc-Text/BlText.class.st @@ -7,7 +7,7 @@ I define a public API of the text model. User must only talk with me using provi I only store string and corresponding attributes. I don't know anything about text layout or paragraphs. I should be used together with BrTextParagraph in order to be measured, layered out and rendered. -Once a piece of string is converted {{gtClass:name=BlText}} users must not make any assumption on the internat structure of that string inside of the text. For example I replace all occurrences of `CrLf` with a special marker that is exactly one item instead of two characters (`Cr` and `Lf`) +Once a piece of string is converted `name=BlText` users must not make any assumption on the internat structure of that string inside of the text. For example I replace all occurrences of `CrLf` with a special marker that is exactly one item instead of two characters (`Cr` and `Lf`) I provide a fluent text styling api: @@ -21,7 +21,7 @@ text ## Attributes -- {{gtClass:BlTextUnderlineAttribute}} +- `BlTextUnderlineAttribute` " Class { diff --git a/src/Bloc-Text/BlTextAttributesCachingFinder.class.st b/src/Bloc-Text/BlTextAttributesCachingFinder.class.st index 76f3f17af..b11b0fae4 100644 --- a/src/Bloc-Text/BlTextAttributesCachingFinder.class.st +++ b/src/Bloc-Text/BlTextAttributesCachingFinder.class.st @@ -1,6 +1,6 @@ " #Text attributes cache -{{gtClass:BlText}} allows users to assign attributes on a text interval. In addition, it is important to to be able to query text attributes efficiently. The attributes cache is responsible for maintaining an association cache between text attributes and their corresponding interval in the text. +`BlText` allows users to assign attributes on a text interval. In addition, it is important to to be able to query text attributes efficiently. The attributes cache is responsible for maintaining an association cache between text attributes and their corresponding interval in the text. " Class { #name : #BlTextAttributesCachingFinder, diff --git a/src/Bloc-Text/BlTextDecorationStyle.class.st b/src/Bloc-Text/BlTextDecorationStyle.class.st index a8f0b1434..7784f9dbb 100644 --- a/src/Bloc-Text/BlTextDecorationStyle.class.st +++ b/src/Bloc-Text/BlTextDecorationStyle.class.st @@ -1,6 +1,6 @@ " # Text decoration style -Describes the style of the text {{gtClass:BlTextDecoration|label=decoration}} (like {{gtClass:BlTextDecorationDashedStyle|label=dashed}}, {{gtClass:BlTextDecorationDottedStyle|label=dotted}}, {{gtClass:BlTextDecorationDoubleStyle|label=double}}, {{gtClass:BlTextDecorationSolidStyle|label=solid}}, {{gtClass:BlTextDecorationWavyStyle|label=wavy}}). +Describes the style of the text `BlTextDecoration|label=decoration` (like `BlTextDecorationDashedStyle|label=dashed`, `BlTextDecorationDottedStyle|label=dotted`, `BlTextDecorationDoubleStyle|label=double`, `BlTextDecorationSolidStyle|label=solid`, `BlTextDecorationWavyStyle|label=wavy`). " Class { diff --git a/src/Bloc-Text/BlTextDelegatedAttributesBuilder.class.st b/src/Bloc-Text/BlTextDelegatedAttributesBuilder.class.st index 0de005f1b..1c805ce61 100644 --- a/src/Bloc-Text/BlTextDelegatedAttributesBuilder.class.st +++ b/src/Bloc-Text/BlTextDelegatedAttributesBuilder.class.st @@ -1,5 +1,5 @@ " -I am an extended version of the attributes builder with an ability to delegate the applying of attributes to the other stylable, which can be a {{gtClass:BlText}} or the other {{gtClass:BlTextAttributesBuilder}} +I am an extended version of the attributes builder with an ability to delegate the applying of attributes to the other stylable, which can be a `BlText` or the other `BlTextAttributesBuilder` " Class { diff --git a/src/Bloc-Text/BlTextReadStream.class.st b/src/Bloc-Text/BlTextReadStream.class.st index e4fe2f38f..4284b089f 100644 --- a/src/Bloc-Text/BlTextReadStream.class.st +++ b/src/Bloc-Text/BlTextReadStream.class.st @@ -1,5 +1,5 @@ " -I offer API compatible with {{gtClass:ReadStream}}. +I offer API compatible with `ReadStream`. " diff --git a/src/Bloc/BlAlreadyAddedAsChildError.class.st b/src/Bloc/BlAlreadyAddedAsChildError.class.st index aead02104..d03e7fd8d 100644 --- a/src/Bloc/BlAlreadyAddedAsChildError.class.st +++ b/src/Bloc/BlAlreadyAddedAsChildError.class.st @@ -1,5 +1,5 @@ " -I am signalled when user tries to add an {{gtClass:BlElement}}, that is already added to some other element as its child, to some other element. +I am signalled when user tries to add an `BlElement`, that is already added to some other element as its child, to some other element. " Class { diff --git a/src/Bloc/BlAttachedSpaceReference.class.st b/src/Bloc/BlAttachedSpaceReference.class.st index 67f9d4de6..c1323f56c 100644 --- a/src/Bloc/BlAttachedSpaceReference.class.st +++ b/src/Bloc/BlAttachedSpaceReference.class.st @@ -1,6 +1,6 @@ " # Attached space reference -Attached space reference {{gtClass:BlSpaceReference}} is set when an element is `attached` to the scene graph. +Attached space reference `BlSpaceReference` is set when an element is `attached` to the scene graph. " Class { diff --git a/src/Bloc/BlBackground.class.st b/src/Bloc/BlBackground.class.st index 46d47f02f..d91e291bd 100644 --- a/src/Bloc/BlBackground.class.st +++ b/src/Bloc/BlBackground.class.st @@ -1,16 +1,16 @@ " # Background -I represent a background of the {{gtClass:BlElement}}. +I represent a background of the `BlElement`. **I am immutable and can not be changed once created.** To modify the background, create a new instance and set it by sending {{gtMethod:BlElement>>#background:}} ## Types of background There are multiple pre-built types of background: - - paint background {{gtClass:BlPaintBackground}} which allows users to use any {{gtClass:BlPaint}} as a background - - image background {{gtClass:BlImageBackground}} to use a bitmap {{gtClass:Form}} - - composite background {{gtClass:BlCompositeBackground}} letting users to compose different types of background into one more complex background - - transparent background {{gtClass:BlTransparentBackground}} as a special type of background that + - paint background `BlPaintBackground` which allows users to use any `BlPaint` as a background + - image background `BlImageBackground` to use a bitmap `Form` + - composite background `BlCompositeBackground` letting users to compose different types of background into one more complex background + - transparent background `BlTransparentBackground` as a special type of background that Background can be instantiated and composed directly or with the help of `BlBackgroundBuilder`. See `BlBackgroundBuilder` for the related examples. diff --git a/src/Bloc/BlBasicShortcut.class.st b/src/Bloc/BlBasicShortcut.class.st index 4e459f6ea..8bb03de1e 100644 --- a/src/Bloc/BlBasicShortcut.class.st +++ b/src/Bloc/BlBasicShortcut.class.st @@ -1,10 +1,10 @@ " # Shortcut -Represents a keyboard shortcut that can be registered to any arbitrary {{gtClass:BlElement}}. -Shortcut consist of an Action that is evaluated when a Shortcut is triggered and {{gtClass:BlKeyCombination}} that describes when shortcut should be triggered. A combination is a logical formula expression that is composed of various key combinations such as alternative, compulsory or single key. See subclasses of {{gtClass:BlKeyCombination}}. +Represents a keyboard shortcut that can be registered to any arbitrary `BlElement`. +Shortcut consist of an Action that is evaluated when a Shortcut is triggered and `BlKeyCombination` that describes when shortcut should be triggered. A combination is a logical formula expression that is composed of various key combinations such as alternative, compulsory or single key. See subclasses of `BlKeyCombination`. Additionally, shortcut may provide its optional textual description and name. -All shortcuts of an element are stored in {{gtClass:BlShortcutRegistry}} and matched / triggered by {{gtClass:BlShortcutHandler}} +All shortcuts of an element are stored in `BlShortcutRegistry` and matched / triggered by `BlShortcutHandler` A shortcut can be added or removed from the element by using {{gtMethod:BlElement>>#addShortcut:}} or {{gtMethod:BlElement>>#removeShortcut:}} methods. {{gtMethod:BlElement>>#shortcuts}} message can be sent to an element in order to access a list of all registered shortcuts. diff --git a/src/Bloc/BlBeaconLoggingTask.class.st b/src/Bloc/BlBeaconLoggingTask.class.st index c7a39d84e..def3b800f 100644 --- a/src/Bloc/BlBeaconLoggingTask.class.st +++ b/src/Bloc/BlBeaconLoggingTask.class.st @@ -1,6 +1,6 @@ " -I use {{gtClass:Beacon}} to log when a {{gtClass:BlTask}} is scheduled and executed.. -I emit {{gtClass:BlBeaconTaskSignal}}. +I use `Beacon` to log when a `BlTask` is scheduled and executed.. +I emit `BlBeaconTaskSignal`. I should be instantiated using {{gtMethod:BlBeaconLoggingTask class>>#subtask:}}. diff --git a/src/Bloc/BlBeaconTaskSignal.class.st b/src/Bloc/BlBeaconTaskSignal.class.st index 3b9effee3..64b5d431b 100644 --- a/src/Bloc/BlBeaconTaskSignal.class.st +++ b/src/Bloc/BlBeaconTaskSignal.class.st @@ -1,7 +1,7 @@ " -I am a {{gtClass:Beacon}} signal. -I am emitted by {{gtClass:BlBeaconLoggingTask}}. -I inform about scheduling and executing of {{gtClass:BlTask}}. +I am a `Beacon` signal. +I am emitted by `BlBeaconLoggingTask`. +I inform about scheduling and executing of `BlTask`. " Class { diff --git a/src/Bloc/BlChildren.class.st b/src/Bloc/BlChildren.class.st index 53e86fac2..56a811215 100644 --- a/src/Bloc/BlChildren.class.st +++ b/src/Bloc/BlChildren.class.st @@ -1,5 +1,5 @@ " -I am an abstract root class designed for accessing and iterating over the children of a {{gtClass:BlElement}}. +I am an abstract root class designed for accessing and iterating over the children of a `BlElement`. I define a data structure independent API for iterating and accessing bloc elements. I assume an index-based way of accessing bloc elements. Subclasses can filter elements or have different orders to iterate over them. diff --git a/src/Bloc/BlChildrenArray.class.st b/src/Bloc/BlChildrenArray.class.st index 92ecaee3b..fdafa2515 100644 --- a/src/Bloc/BlChildrenArray.class.st +++ b/src/Bloc/BlChildrenArray.class.st @@ -2,10 +2,10 @@ I am a holder that uses an immutable array to store children of bloc elements. Every time a child is added or removed I create a new internal array to store children. -I optimize the method {{gtMethod:BlChildrenArray>>#asArray}} to directly return the internal array instead of creating a new one. In combination with other iterators that use this method (like {{gtClass:BlChildrenReversed}}) it can reduce the number of arrays created during layout operations, expecially for graph layouts. +I optimize the method {{gtMethod:BlChildrenArray>>#asArray}} to directly return the internal array instead of creating a new one. In combination with other iterators that use this method (like `BlChildrenReversed`) it can reduce the number of arrays created during layout operations, expecially for graph layouts. ## Examples -Examples are provided by the class {{gtClass:BlChildrenArrayExamples}} +Examples are provided by the class `BlChildrenArrayExamples` " Class { diff --git a/src/Bloc/BlChildrenCollection.class.st b/src/Bloc/BlChildrenCollection.class.st index 9a7e2202b..000da19b4 100644 --- a/src/Bloc/BlChildrenCollection.class.st +++ b/src/Bloc/BlChildrenCollection.class.st @@ -1,5 +1,5 @@ " -I am an abstract collection of bloc elements that can be mutated. I am used by a {{gtClass:BlElement}} to store its children. +I am an abstract collection of bloc elements that can be mutated. I am used by a `BlElement` to store its children. I provide a data structure independent API for adding and removing children. I assume an index-based way of working with children. My subclasses wrap concrete data structures for storing the actual children. Bloc elements work with children only in terms of the API that I provide. Hence, I only provide a minimum API needed to work with children, instead of the full collection API. @@ -8,10 +8,10 @@ I allow elements to optimize working with children for different scenarious. For ## API The following subclasses can be used to store children: -- {{gtClass:BlChildrenArray}}: stores children using an {{gtClass:Array}} -- {{gtClass:BlChildrenLinkedList}}: stores children using a {{gtClass:LinkedList}} -- {{gtClass:BlChildrenOrderedCollection}}: stores children using a {{gtClass:OrderedCollection}} -- {{gtClass:BlChildrenRope}}: stores children using a {{gtClass:BlCollectionRope}} +- `BlChildrenArray`: stores children using an `Array` +- `BlChildrenLinkedList`: stores children using a `LinkedList` +- `BlChildrenOrderedCollection`: stores children using a `OrderedCollection` +- `BlChildrenRope`: stores children using a `BlCollectionRope` Subclasses need to provide the implementation for methods adding and removing children. diff --git a/src/Bloc/BlChildrenLinkedList.class.st b/src/Bloc/BlChildrenLinkedList.class.st index 55fc52632..fb651234d 100644 --- a/src/Bloc/BlChildrenLinkedList.class.st +++ b/src/Bloc/BlChildrenLinkedList.class.st @@ -1,10 +1,10 @@ " -I am a holder that uses a {{gtClass:LinkedList}} to store children of bloc elements. +I am a holder that uses a `LinkedList` to store children of bloc elements. -Internally I maintain one single {{gtClass:LinkedList}} instance. When children are added or removed I add or remove them from the wrapped list. +Internally I maintain one single `LinkedList` instance. When children are added or removed I add or remove them from the wrapped list. ## Examples -Examples are provided by the class {{gtClass:BlChildrenLinkedListExamples}} +Examples are provided by the class `BlChildrenLinkedListExamples` " Class { diff --git a/src/Bloc/BlChildrenOrderedCollection.class.st b/src/Bloc/BlChildrenOrderedCollection.class.st index 4767bdae0..791bd03d8 100644 --- a/src/Bloc/BlChildrenOrderedCollection.class.st +++ b/src/Bloc/BlChildrenOrderedCollection.class.st @@ -1,10 +1,10 @@ " -I am a holder that uses an {{gtClass:OrderedCollection}} to store children of bloc elements. +I am a holder that uses an `OrderedCollection` to store children of bloc elements. -Internally I maintain one single {{gtClass:OrderedCollection}} instance. When children are added or removed I add or remove them from the wrapped collection. +Internally I maintain one single `OrderedCollection` instance. When children are added or removed I add or remove them from the wrapped collection. ## Examples -Examples are provided by the class {{gtClass:BlChildrenOrderedCollectionExamples}} +Examples are provided by the class `BlChildrenOrderedCollectionExamples` " Class { diff --git a/src/Bloc/BlChildrenRope.class.st b/src/Bloc/BlChildrenRope.class.st index 75a7503bc..c7070dd81 100644 --- a/src/Bloc/BlChildrenRope.class.st +++ b/src/Bloc/BlChildrenRope.class.st @@ -1,10 +1,10 @@ " -I am a holder that uses an {{gtClass:BlCollectionRope}} to store children of bloc elements. +I am a holder that uses an `BlCollectionRope` to store children of bloc elements. -Internally I maintain one single {{gtClass:BlCollectionRope}} intance. When children are added or removed I add or remove them from the wrapped rope. +Internally I maintain one single `BlCollectionRope` intance. When children are added or removed I add or remove them from the wrapped rope. ## Examples -Examples are provided by the class {{gtClass:BlChildrenRopeExamples}} +Examples are provided by the class `BlChildrenRopeExamples` " Class { diff --git a/src/Bloc/BlChildrenSubset.class.st b/src/Bloc/BlChildrenSubset.class.st index e85e797d8..da49777c0 100644 --- a/src/Bloc/BlChildrenSubset.class.st +++ b/src/Bloc/BlChildrenSubset.class.st @@ -1,22 +1,22 @@ " -I capture a subset of children from a {{gtClass:BlElement}} instance. +I capture a subset of children from a `BlElement` instance. I am an abstract class. My subclasses define the actual order and criteria for filtering children and iterating over the set of children. -I exist to explicitly capture and combine various ways of filtering and iterating over children. For example, {{gtClass:BlChildrenReversed}} indicates that the user wants to explicitly iterate over elements in reverse order; {{gtClass:BlChildrenAccountedByLayout}} indicates that only should children taken into account by layout should be included. +I exist to explicitly capture and combine various ways of filtering and iterating over children. For example, `BlChildrenReversed` indicates that the user wants to explicitly iterate over elements in reverse order; `BlChildrenAccountedByLayout` indicates that only should children taken into account by layout should be included. The example below shows a scenario of combining multiple ways to iterate over children. By having an explicit object for each operation, the composition of operations can be inspected. {{gtExample:BlChildrenSubsetExamples>>#childrenWithMultipleCombinedSubsets}} I do not enforce a lazy API. Subclasses can perform the filtering immediately or when iteration over children is required. I aim to maintain the composition of subsets while optimizing for speed whenever possible. ## API -Instances of me are created by calling the factory method {{gtMethod:BlChildrenSubset class>>#on:}} on a subclass with an instance of {{gtClass:BlChildren}} as parameter. +Instances of me are created by calling the factory method {{gtMethod:BlChildrenSubset class>>#on:}} on a subclass with an instance of `BlChildren` as parameter. -Subclasses need to override the method {{gtMethod:BlChildrenSubset>>#subsetFrom:}} to filter the elements from the given {{gtClass:BlChildren}} instance. This can perform no filtering, filter elements, or also change the order of elements. +Subclasses need to override the method {{gtMethod:BlChildrenSubset>>#subsetFrom:}} to filter the elements from the given `BlChildren` instance. This can perform no filtering, filter elements, or also change the order of elements. ## Implementation details Internally the result of {{gtMethod:BlChildrenSubset>>#subsetFrom:}} is stored into an instance variable. This result is then used when accessing or iterating over elements. This decision was taken to allow iterators to perform work when the iterator is created and ensure a faster iteration. -To preserve the composition of iterators I hold a reference to the initial {{gtClass:BlChildren}} instance. +To preserve the composition of iterators I hold a reference to the initial `BlChildren` instance. " Class { diff --git a/src/Bloc/BlCustomEventHandler.class.st b/src/Bloc/BlCustomEventHandler.class.st index 2c9c8e9e6..f06b77456 100644 --- a/src/Bloc/BlCustomEventHandler.class.st +++ b/src/Bloc/BlCustomEventHandler.class.st @@ -1,6 +1,6 @@ " I am a custom event handler. User must override me and implement {{gtMethod:BlBasicEventHandler>>#eventsToHandle}} to return a collection of event classes that I am interested in. -Then for each interesting event a user should implement a corresponding event handling method. For example for {{gtClass:BlMouseDownEvent}} it would be `mouseDownEvent:` +Then for each interesting event a user should implement a corresponding event handling method. For example for `BlMouseDownEvent` it would be `mouseDownEvent:` " Class { diff --git a/src/Bloc/BlDetachedSpaceReference.class.st b/src/Bloc/BlDetachedSpaceReference.class.st index 6fab66690..25a1becc8 100644 --- a/src/Bloc/BlDetachedSpaceReference.class.st +++ b/src/Bloc/BlDetachedSpaceReference.class.st @@ -1,6 +1,6 @@ " # Detached space reference -Detached space reference {{gtClass:BlSpaceReference}} is set when an element is temporarily `detached` from the scene graph. +Detached space reference `BlSpaceReference` is set when an element is temporarily `detached` from the scene graph. " Class { diff --git a/src/Bloc/BlDirectEventDispatcher.class.st b/src/Bloc/BlDirectEventDispatcher.class.st index 91fee750c..e7ad8b742 100644 --- a/src/Bloc/BlDirectEventDispatcher.class.st +++ b/src/Bloc/BlDirectEventDispatcher.class.st @@ -1,6 +1,6 @@ " I am an event dispatcher that directly dispatches events to the registered event handlers. -I do not support event bubbling. If you need events to be dispatched through a composition tree you might want to use {{gtClass:BlBubblingEventDispatcher}}. +I do not support event bubbling. If you need events to be dispatched through a composition tree you might want to use `BlBubblingEventDispatcher`. Example: diff --git a/src/Bloc/BlElement.class.st b/src/Bloc/BlElement.class.st index 4df14aa44..ccd5f8c33 100644 --- a/src/Bloc/BlElement.class.st +++ b/src/Bloc/BlElement.class.st @@ -4,18 +4,18 @@ I am the root class of all visual elements in Bloc and can be composed out of ot ## Visual properties Being a root class and a core element, I let users configure a few essential visual properties such as background, border, opacity, size and a few more. Let's go through each of them. ### Background -{{gtClass:BlBackground}}describes how an element should be filled, e.g. its background. -{{gtClass:BlBackgroundExamples}} gives a detailed insight in the world of bloc backgrounds. +`BlBackground`describes how an element should be filled, e.g. its background. +`BlBackgroundExamples` gives a detailed insight in the world of bloc backgrounds. ### Border -{{gtClass:BlBorder}} is a visual property that defines how the outline of the element should be rendered. It also influences `stroked bounds` of the element. -{{gtClass:BlBorderExamples}} provides more detailed information about a border. +`BlBorder` is a visual property that defines how the outline of the element should be rendered. It also influences `stroked bounds` of the element. +`BlBorderExamples` provides more detailed information about a border. ### Opacity Opacity defines how transparent an element is. It does not influence event propagation. -{{gtClass:BlOpacityExamples}} shows in details how opacity affects the element. +`BlOpacityExamples` shows in details how opacity affects the element. ## Composition To be in-line with Bloc design, we prefer composition over inheritance. Thus it is better to have tiny bloc elements - each with a small and simple API and clear responsibilities - that can later be composed into a more sophisticated graphical scene. In this paragraph we will learn the basic composition aspects and corresponding API. -The composition relation between parent and children is 1:N meaning that an element can have at most one parent. Therefore by design it is only possible to add an element to just one other element. Trying to add an element that is already a child to some other element results in {{gtClass:BlAlreadyAddedAsChildError}} +The composition relation between parent and children is 1:N meaning that an element can have at most one parent. Therefore by design it is only possible to add an element to just one other element. Trying to add an element that is already a child to some other element results in `BlAlreadyAddedAsChildError` Bloc elements provide a set of methods to add and remove children. ### Adding children @@ -31,14 +31,14 @@ parent addChild: child Users may also choose to add an element as the first child, for that purpose Bloc provides {{gtMethod:BlElement>>#addChildFirst:}}. ## Geometry and bounds -Every element is responsible for drawing itself. At the same time, every element has a {{gtClass:BlElementGeometry}} that defines the bounds and the clipping. There are many types of geometry available: +Every element is responsible for drawing itself. At the same time, every element has a `BlElementGeometry` that defines the bounds and the clipping. There are many types of geometry available: ``` BlElementGeometry allSubclasses ``` -See {{gtClass:BlGeometryVisualAndLayoutBoundsExamples}} for concrete details. +See `BlGeometryVisualAndLayoutBoundsExamples` for concrete details. ## Layout -There are many built-in {{gtClass:BlLayout}} strategies available, or you can create your own. +There are many built-in `BlLayout` strategies available, or you can create your own. ## Tutorial You can learn Bloc following a memory game tutorial: [00-memory-game.pillar](fileLocator://gtResource/feenkcom/Bloc/doc/tutorial-memory-game/00-memory-game.pillar). diff --git a/src/Bloc/BlElementId.class.st b/src/Bloc/BlElementId.class.st index d90995bf9..e0efce439 100644 --- a/src/Bloc/BlElementId.class.st +++ b/src/Bloc/BlElementId.class.st @@ -1,7 +1,7 @@ " # Element id -Allows to assign id to {{gtClass:BlElement}}. This allows us query a tree of elements +Allows to assign id to `BlElement`. This allows us query a tree of elements " Class { diff --git a/src/Bloc/BlErrorHandler.class.st b/src/Bloc/BlErrorHandler.class.st index ca20ba58b..45a20275c 100644 --- a/src/Bloc/BlErrorHandler.class.st +++ b/src/Bloc/BlErrorHandler.class.st @@ -1,5 +1,5 @@ " -I am responsible for error handling that occur in the {{gtClass:BlElement}} +I am responsible for error handling that occur in the `BlElement` " diff --git a/src/Bloc/BlEventForwarder.class.st b/src/Bloc/BlEventForwarder.class.st index df73f24c9..61a9d4df0 100644 --- a/src/Bloc/BlEventForwarder.class.st +++ b/src/Bloc/BlEventForwarder.class.st @@ -1,7 +1,7 @@ " I forward events to another event handler while making it look like the event is sent from `eventTarget` as current target. -I am very useful if a user want to transfer an event handler from one dispatcher to the other. It is not possible to do it directly, because then the `currentTarget` of the received event will be different those two event dispatchers. To solve this problem {{gtClass:BlEventForwarder}} can reference a specific event target that will be used as `currentTarget` for all forwarded events. This way the decorated event handler will receive events with consistent `currentTarget` +I am very useful if a user want to transfer an event handler from one dispatcher to the other. It is not possible to do it directly, because then the `currentTarget` of the received event will be different those two event dispatchers. To solve this problem `BlEventForwarder` can reference a specific event target that will be used as `currentTarget` for all forwarded events. This way the decorated event handler will receive events with consistent `currentTarget` ``` BlEventForwarder diff --git a/src/Bloc/BlFocusChain.class.st b/src/Bloc/BlFocusChain.class.st index d98e43683..88eddc89f 100644 --- a/src/Bloc/BlFocusChain.class.st +++ b/src/Bloc/BlFocusChain.class.st @@ -3,7 +3,7 @@ I represent a path of elements to the actual focused element. Even if ""parent <-> child"" connection between elements is lost due to removing we still have all the necessary information to send FocusOut events. -I am used by {{gtClass:BlFocusProcessor}} to properly send events +I am used by `BlFocusProcessor` to properly send events " Class { diff --git a/src/Bloc/BlHistogramGeometry.class.st b/src/Bloc/BlHistogramGeometry.class.st index 709b35547..53aca62c2 100644 --- a/src/Bloc/BlHistogramGeometry.class.st +++ b/src/Bloc/BlHistogramGeometry.class.st @@ -4,7 +4,7 @@ I represent a class of historgram-like geometry. {{gtExample:BlHistogramExamples>>#default|codeExpanded=false|previewShow=#gtLiveFor:|previewExpanded=true|previewHeight=100}} -See {{gtClass:BlHistogramExamples}} for more examples +See `BlHistogramExamples` for more examples " Class { diff --git a/src/Bloc/BlImageBackground.class.st b/src/Bloc/BlImageBackground.class.st index c22df9900..777ec70dc 100644 --- a/src/Bloc/BlImageBackground.class.st +++ b/src/Bloc/BlImageBackground.class.st @@ -4,7 +4,7 @@ I am a special image type background given as Form. Note: I am never #isTransparent even if all Form pixels are transparent. The reason for this is the fact that ther is no fast way to detect if a Form is completly transparent without checking all pixels. ## Examples -Examples are provided by the class {{gtClass:BlImageBackgroundExamples}}. +Examples are provided by the class `BlImageBackgroundExamples`. " Class { diff --git a/src/Bloc/BlKeyboardProcessor.class.st b/src/Bloc/BlKeyboardProcessor.class.st index 5223b4d81..c066a8a05 100644 --- a/src/Bloc/BlKeyboardProcessor.class.st +++ b/src/Bloc/BlKeyboardProcessor.class.st @@ -1,6 +1,6 @@ " # Keyboard event processor -Is responsible for processing {{gtClass:BlKeyboardEvent}} which are sent by the {{gtClass:TBlHostSpace}} to the {{gtClass:BlSpace}}. In addition, the `keyboard event processor` generates additional events such as {{gtClass:BlShortcutEvent}} +Is responsible for processing `BlKeyboardEvent` which are sent by the `TBlHostSpace` to the `BlSpace`. In addition, the `keyboard event processor` generates additional events such as `BlShortcutEvent` " Class { diff --git a/src/Bloc/BlLayout.class.st b/src/Bloc/BlLayout.class.st index 4cfd4cedf..7a9c28ef6 100644 --- a/src/Bloc/BlLayout.class.st +++ b/src/Bloc/BlLayout.class.st @@ -5,14 +5,14 @@ I am the superclass for layouts in Bloc and I define the API that a concrete lay I am attached to a bloc element and define the visual structure of that bloc element. Typically this includes the position of child elements within the parent, or the size of the parent element. ## Layout constraints -I support a set of attributes (refered to as constraints in Bloc) which define the visual properties of the layout. A small set of constraints, like padding, margin or minimal and maximum dimensions, are common among all the layouts. Each layout has a dedicated constraint object, an instance of {{gtClass:BlLayoutCommonConstraints}}, that contains these universal constraints. Each type of layout can further define its own specific constraints by creating a subclass of {{gtClass:BlLayoutConstraints}}. +I support a set of attributes (refered to as constraints in Bloc) which define the visual properties of the layout. A small set of constraints, like padding, margin or minimal and maximum dimensions, are common among all the layouts. Each layout has a dedicated constraint object, an instance of `BlLayoutCommonConstraints`, that contains these universal constraints. Each type of layout can further define its own specific constraints by creating a subclass of `BlLayoutConstraints`. TODO: constraints API ## Layout phase in a frame Element layout is a phase executed by a space during each frame. -Every frame, the space goes through several phases ({{gtMethod:BlSpaceFrame>>#initializePhases}}), which are modeled as subclasses of {{gtClass:BlSpaceFramePhase}} and are executed once per frame. One of them, {{gtClass:BlSpaceFrameLayoutPhase}}, lays out the elements contained in the space. This is done after events and tasks have been executed, but before the drawing phase. +Every frame, the space goes through several phases ({{gtMethod:BlSpaceFrame>>#initializePhases}}), which are modeled as subclasses of `BlSpaceFramePhase` and are executed once per frame. One of them, `BlSpaceFrameLayoutPhase`, lays out the elements contained in the space. This is done after events and tasks have been executed, but before the drawing phase. Layout should happen during a frame whenever various properties like width, height or position change for any element contained by the space. However, an important aspect in Bloc, is that when one of these properties changes, layout is not performed immediately. Instead, a layout request is issued by the element whose property changed via the {{gtMethod:BlElement>>#requestLayout:}} message. This has two advantages that improve performance: 1. If no element requests layout, this phase can be skipped. @@ -33,7 +33,7 @@ TODO: why three separate steps? ### Measuring bounds This is the first step when performing a layout of an element and consists in determining the measured bounds of that element. -Each element can decide how it wants to be measured ({{gtMethod:BlElement>>#onMeasure:}}). By default, {{gtClass:BlElement}} delegates measuring to its layout. Layouts should override {{gtMethod:BlLayout>>#measure:with:}} to implement the actual measuring. Normally, layouts follow a top-to-bottom approach: they measure the current element and then ask their children measure themselves. +Each element can decide how it wants to be measured ({{gtMethod:BlElement>>#onMeasure:}}). By default, `BlElement` delegates measuring to its layout. Layouts should override {{gtMethod:BlLayout>>#measure:with:}} to implement the actual measuring. Normally, layouts follow a top-to-bottom approach: they measure the current element and then ask their children measure themselves. Each element has real bounds ({{gtMethod:BlElement>>#bounds}}) and measured bounds ({{gtMethod:BlElement>>#measuredBounds}}). The real bounds contain the actual position and extent of an element that users of that element should rely on. The measured bounds are used during layout to hold the new extent of an element. The measuring phase changes only the extent in the measured bounds. After the entire layout phase is completed the real bounds and measured bounds will have the same value. The measured bounds act like a temporary cache for the new bounds of an element. They were introduced to avoid changing the real extent of element while layout of children is still being performed. diff --git a/src/Bloc/BlLayoutNode.class.st b/src/Bloc/BlLayoutNode.class.st index bb211e127..8699963ce 100644 --- a/src/Bloc/BlLayoutNode.class.st +++ b/src/Bloc/BlLayoutNode.class.st @@ -1,6 +1,6 @@ " # Layout node -Is a node that is laied out by {{gtClass:BlLayout}} +Is a node that is laied out by `BlLayout` " Class { diff --git a/src/Bloc/BlMouseEnterEvent.class.st b/src/Bloc/BlMouseEnterEvent.class.st index afc72492b..5f4394933 100644 --- a/src/Bloc/BlMouseEnterEvent.class.st +++ b/src/Bloc/BlMouseEnterEvent.class.st @@ -3,7 +3,7 @@ The mouse enter event is fired when a pointing device (usually a mouse) is moved Similar to mouse over, it differs in that it doesn't bubble and that it isn't sent when the pointer is moved from one of its descendants' physical space to its own physical space. -See {{gtClass:BlMouseOverOutAndEnterLeaveEventExplanation}} to learn more about the difference with {{gtClass:BlMouseOverEvent}} +See `BlMouseOverOutAndEnterLeaveEventExplanation` to learn more about the difference with `BlMouseOverEvent` With deep hierarchies, the amount of mouse enter events sent can be quite huge and cause significant performance problems. In such cases, it is better to listen for mouse over events. diff --git a/src/Bloc/BlMouseLeaveEvent.class.st b/src/Bloc/BlMouseLeaveEvent.class.st index 450d3d487..f4f73d752 100644 --- a/src/Bloc/BlMouseLeaveEvent.class.st +++ b/src/Bloc/BlMouseLeaveEvent.class.st @@ -4,7 +4,7 @@ The mouse leave event is fired when the pointer of a pointing device (usually a Mouse leave and mouse out are similar but differ in that mouse leave does not bubble and mouse out does. This means that mouse leave is fired when the pointer has exited the element and all of its descendants, whereas mouse out is fired when the pointer leaves the element or leaves one of the element's descendants (even if the pointer is still within the element). -See {{gtClass:BlMouseOverOutAndEnterLeaveEventExplanation}} to learn more about the difference with {{gtClass:BlMouseOutEvent}} +See `BlMouseOverOutAndEnterLeaveEventExplanation` to learn more about the difference with `BlMouseOutEvent` https://developer.mozilla.org/en-US/docs/Web/Events/mouseleave diff --git a/src/Bloc/BlMouseOutEvent.class.st b/src/Bloc/BlMouseOutEvent.class.st index 1d79a5ee6..7b814013e 100644 --- a/src/Bloc/BlMouseOutEvent.class.st +++ b/src/Bloc/BlMouseOutEvent.class.st @@ -1,7 +1,7 @@ " The mouse out event is fired when a pointing device (usually a mouse) is moved off the element that has the listener attached or off one of its children. Note that it is also triggered on the parent when you move onto a child element, since you move out of the visible space of the parent. -See {{gtClass:BlMouseOverOutAndEnterLeaveEventExplanation}} to learn more about the difference with {{gtClass:BlMouseLeaveEvent}} +See `BlMouseOverOutAndEnterLeaveEventExplanation` to learn more about the difference with `BlMouseLeaveEvent` https://developer.mozilla.org/en-US/docs/Web/Events/mouseout diff --git a/src/Bloc/BlMouseOverEvent.class.st b/src/Bloc/BlMouseOverEvent.class.st index 3bc74f5ac..432cd5531 100644 --- a/src/Bloc/BlMouseOverEvent.class.st +++ b/src/Bloc/BlMouseOverEvent.class.st @@ -3,7 +3,7 @@ The mouse over event is fired when a pointing device is moved onto the element t Similar to mouse enter, it differs in that it bubbles and that it is sent when the pointer is moved from one of its descendants' physical space to its own physical space. -See {{gtClass:BlMouseOverOutAndEnterLeaveEventExplanation}} to learn more about the difference with {{gtClass:BlMouseEnterEvent}} +See `BlMouseOverOutAndEnterLeaveEventExplanation` to learn more about the difference with `BlMouseEnterEvent` https://developer.mozilla.org/en-US/docs/Web/Events/mouseover diff --git a/src/Bloc/BlMouseWheelEvent.class.st b/src/Bloc/BlMouseWheelEvent.class.st index 176142372..42793e494 100644 --- a/src/Bloc/BlMouseWheelEvent.class.st +++ b/src/Bloc/BlMouseWheelEvent.class.st @@ -1,7 +1,7 @@ " -I am a {{gtClass:BlMouseEvent}}. +I am a `BlMouseEvent`. I am a mouse wheel scroll event. -I use {{gtClass:BlVector2D}}, indicating the user scroll direction and length. +I use `BlVector2D`, indicating the user scroll direction and length. ## Examples ### 45 Degrees {{gtExample:BlMouseWheelEventExamples>>#mouseWheelEvent_45degrees|codeExpanded=false|previewExpanded=true}} diff --git a/src/Bloc/BlNullSpaceReference.class.st b/src/Bloc/BlNullSpaceReference.class.st index ee7d6e5dc..dece7f030 100644 --- a/src/Bloc/BlNullSpaceReference.class.st +++ b/src/Bloc/BlNullSpaceReference.class.st @@ -1,6 +1,6 @@ " # Null space reference -Null space reference {{gtClass:BlSpaceReference}} is set when an element is `removed` from the scene graph. +Null space reference `BlSpaceReference` is set when an element is `removed` from the scene graph. " Class { diff --git a/src/Bloc/BlPaintBackground.class.st b/src/Bloc/BlPaintBackground.class.st index 13bbfd5e6..12b5e37b8 100644 --- a/src/Bloc/BlPaintBackground.class.st +++ b/src/Bloc/BlPaintBackground.class.st @@ -2,7 +2,7 @@ I am a background that uses a `=BlPaint`=. A paint can be either a simple color or a type of gradient. ## Examples -Examples are provided by the class {{gtClass:BlPaintBackgroundExamples}}. +Examples are provided by the class `BlPaintBackgroundExamples`. " diff --git a/src/Bloc/BlRope.class.st b/src/Bloc/BlRope.class.st index 6920263fd..2116071d1 100644 --- a/src/Bloc/BlRope.class.st +++ b/src/Bloc/BlRope.class.st @@ -5,7 +5,7 @@ If all operations are implemented in a non-destructive way, a rope becomes a per A rope is a binary tree having leaf nodes that contain a short string. Each node has a weight value equal to the length of its string plus the sum of all leaf nodes' weight in its left subtree, namely the weight of a node is the total string length in its left subtree for a non-leaf node, or the string length of itself for a leaf node. Thus a node with two children divides the whole string into two parts: the left subtree stores the first part of the string. The right subtree stores the second part and its weight is the sum of the left child's weight and the length of its contained string. The binary tree can be seen as several levels of nodes. The bottom level contains all the nodes that contain a string. Higher levels have fewer and fewer nodes. The top level consists of a single ""root"" node. The rope is built by putting the nodes with short strings in the bottom level, then attaching a random half of the nodes to parent nodes in the next level. -I can be enumerated with the help of {{gtClass:BlRopeIterator}}. +I can be enumerated with the help of `BlRopeIterator`. https://en.wikipedia.org/wiki/Rope_(data_structure) diff --git a/src/Bloc/BlSelectionTree.class.st b/src/Bloc/BlSelectionTree.class.st index 25bdd649d..a74852da4 100644 --- a/src/Bloc/BlSelectionTree.class.st +++ b/src/Bloc/BlSelectionTree.class.st @@ -1,7 +1,7 @@ " I represent an augmented search binary tree to store intervals described in Cormen et al. (2009, Section 14.3: Interval trees, pp. 348–354)[1] -I am used by {{gtClass:BlCompositeSelection}} +I am used by `BlCompositeSelection` I do not allow overlapping intervals to be stored in the same tree. Before every insertions I find overlapping and neighbouring intervals, merge them and replace all merged intervals with a single one. diff --git a/src/Bloc/BlSharedEventDistributor.class.st b/src/Bloc/BlSharedEventDistributor.class.st index df212bd8b..3e5c5235a 100644 --- a/src/Bloc/BlSharedEventDistributor.class.st +++ b/src/Bloc/BlSharedEventDistributor.class.st @@ -1,9 +1,9 @@ " -I share {{gtClass:BlEvent}} instances (element events) among a given elements. +I share `BlEvent` instances (element events) among a given elements. ## Example -In the following example, {{gtClass:BlMouseOverEvent}}, {{gtClass:BlMouseOutEvent}}, and {{gtClass:BlClickEvent}} are shared between the two graphical elements. If you hover a mouse over any element, both elements get darker. If you click on any of two elements, both elements randomly change their background color. +In the following example, `BlMouseOverEvent`, `BlMouseOutEvent`, and `BlClickEvent` are shared between the two graphical elements. If you hover a mouse over any element, both elements get darker. If you click on any of two elements, both elements randomly change their background color. {{gtExample:BlSharedEventDistributorExamples>>#example|codeExpanded=false|previewExpanded=true}} diff --git a/src/Bloc/BlShortcut.class.st b/src/Bloc/BlShortcut.class.st index be12dbd59..ceb665efc 100644 --- a/src/Bloc/BlShortcut.class.st +++ b/src/Bloc/BlShortcut.class.st @@ -1,6 +1,6 @@ " # Deprecated -Use {{gtClass:BlShortcutWithAction}} instead +Use `BlShortcutWithAction` instead " Class { diff --git a/src/Bloc/BlShortcutWithAction.class.st b/src/Bloc/BlShortcutWithAction.class.st index 8e616e375..b1c900d1a 100644 --- a/src/Bloc/BlShortcutWithAction.class.st +++ b/src/Bloc/BlShortcutWithAction.class.st @@ -1,6 +1,6 @@ " # Shortcut with action -Extends {{gtClass:BlBasicShortcut}} with ability to specify a runtime action that should be evaluated when shortcut is performed. +Extends `BlBasicShortcut` with ability to specify a runtime action that should be evaluated when shortcut is performed. In addition to that, shortcuts with action allow users to customise the name and description of the shortcut. ## Public API and Key Messages diff --git a/src/Bloc/BlSpaceDestroyedEvent.class.st b/src/Bloc/BlSpaceDestroyedEvent.class.st index 208dd724b..91e12b854 100644 --- a/src/Bloc/BlSpaceDestroyedEvent.class.st +++ b/src/Bloc/BlSpaceDestroyedEvent.class.st @@ -1,7 +1,7 @@ " I am an event raised when all normal events for closing a space have been completed. -This event is used by the debugger to stop the UI process so it should be used with case. For reacting to the closing of a space {{gtClass:BlSpaceClosedEvent}} should be used instead. +This event is used by the debugger to stop the UI process so it should be used with case. For reacting to the closing of a space `BlSpaceClosedEvent` should be used instead. " Class { diff --git a/src/Bloc/BlSpaceManager.class.st b/src/Bloc/BlSpaceManager.class.st index 4e03041ae..91eccf32a 100644 --- a/src/Bloc/BlSpaceManager.class.st +++ b/src/Bloc/BlSpaceManager.class.st @@ -1,9 +1,9 @@ " -I am a {{gtClass:BlUniverse}} space manager. +I am a `BlUniverse` space manager. -I contain Bloc {{gtClass:BlSpace|label=spaces}} which can be added or removed. I am also responsible for sending pulses (tick) messages to my {{gtClass:BlSpace|label=spaces}}. +I contain Bloc `BlSpace|label=spaces` which can be added or removed. I am also responsible for sending pulses (tick) messages to my `BlSpace|label=spaces`. -I am used by {{gtClass:BlUniverse}} so that it can support multiple {{gtClass:BlSpace|label=spaces}}. +I am used by `BlUniverse` so that it can support multiple `BlSpace|label=spaces`. Here are some of my core operations: - {{gtMethod:BlSpaceManager>>#addSpace:}} - {{gtMethod:BlSpaceManager>>#removeSpace:}} diff --git a/src/Bloc/BlSpaceReference.class.st b/src/Bloc/BlSpaceReference.class.st index 9c3b5a6a8..c3d58e84d 100644 --- a/src/Bloc/BlSpaceReference.class.st +++ b/src/Bloc/BlSpaceReference.class.st @@ -1,17 +1,17 @@ " # Space reference -Each element references a space in the scene graph in which that element is located. It is important for the {{gtClass:BlElement}} to know when it is added and removed from the scene graph e.g. {{gtClass:BlSpace}}, otherwise it would not be possible to clean up the custom external state. In addition to that an element should keep track of its attachment state which is described in this document. +Each element references a space in the scene graph in which that element is located. It is important for the `BlElement` to know when it is added and removed from the scene graph e.g. `BlSpace`, otherwise it would not be possible to clean up the custom external state. In addition to that an element should keep track of its attachment state which is described in this document. ## Attachment states There are essential attachment states: `attached`, `detached` and `none (null)`. #### Attached -An element is called `attached` then and only then when it is a root element of the space or it is a child of an `attached` element. {{gtClass:BlAttachedSpaceReference}} represents an attached space reference. +An element is called `attached` then and only then when it is a root element of the space or it is a child of an `attached` element. `BlAttachedSpaceReference` represents an attached space reference. #### Detached -An element is called `detached` then and only then when it or any of its parents is temporarily detached from the graph scene while it was `attached`. {{gtClass:BlDetachedSpaceReference}} represents a detached space reference. +An element is called `detached` then and only then when it or any of its parents is temporarily detached from the graph scene while it was `attached`. `BlDetachedSpaceReference` represents a detached space reference. #### Removed -An element is called `removed` then and only then when it or any of its parents is neither an `attached` or `detached` element. {{gtClass:BlNullSpaceReference}} represents a removed space reference. +An element is called `removed` then and only then when it or any of its parents is neither an `attached` or `detached` element. `BlNullSpaceReference` represents a removed space reference. ## Events -When the attachment state of an element is changed from `removed` to `attached` a {{gtClass:BlElementAddedToSceneGraphEvent}} is dispatched. +When the attachment state of an element is changed from `removed` to `attached` a `BlElementAddedToSceneGraphEvent` is dispatched. " Class { diff --git a/src/Bloc/BlValueWithUnit.class.st b/src/Bloc/BlValueWithUnit.class.st index 8d30261bc..679d61331 100644 --- a/src/Bloc/BlValueWithUnit.class.st +++ b/src/Bloc/BlValueWithUnit.class.st @@ -2,7 +2,7 @@ # Value with unit Represents a `dimensioned quantity` or `dimensioned number`, for example `10pt` or `30%`. -The {{gtMethod:BlValueWithUnit>>#value|label=value}} can be any object, but in most cases it is a number, the {{gtMethod:BlValueWithUnit>>#unit|label=unit}} is an instance of a concrete subclass of {{gtClass:BlUnit}} +The {{gtMethod:BlValueWithUnit>>#value|label=value}} can be any object, but in most cases it is a number, the {{gtMethod:BlValueWithUnit>>#unit|label=unit}} is an instance of a concrete subclass of `BlUnit` " Class { diff --git a/src/Bloc/ManifestBloc.class.st b/src/Bloc/ManifestBloc.class.st index 392249366..d04c0659d 100644 --- a/src/Bloc/ManifestBloc.class.st +++ b/src/Bloc/ManifestBloc.class.st @@ -5,11 +5,11 @@ One key property is that it relies on exactly one rendering tree at all times wi # Starting Points Here are some of the most important classes to get a feel for how Bloc works. ## Key Classes with Helpful Comments -- {{gtClass:BlElement}} - the class you will probably use the most -- {{gtClass:BlUniverse}} - Bloc's ""foundation"" which interacts with the underlying {{gtClass:BlHost|label=host}} system -- {{gtClass:BlSpace}} - a logical window - - {{gtClass:BlTime}} - while time is internal to space, it is cool enough to mention here :) -- {{gtClass:BrStencil}} - an element factory +- `BlElement` - the class you will probably use the most +- `BlUniverse` - Bloc's ""foundation"" which interacts with the underlying `BlHost|label=host` system +- `BlSpace` - a logical window + - `BlTime` - while time is internal to space, it is cool enough to mention here :) +- `BrStencil` - an element factory # History Bloc is inspired by the many lessons learned as Smalltalk has evolved through MVC, Morphic and others. It also incorporates many great ideas ""from the outside world"" (e.g. MVP, research papers). diff --git a/src/BlocHost-Morphic/BlBlocUIManager.class.st b/src/BlocHost-Morphic/BlBlocUIManager.class.st index 8bfffadba..10a387a4e 100644 --- a/src/BlocHost-Morphic/BlBlocUIManager.class.st +++ b/src/BlocHost-Morphic/BlBlocUIManager.class.st @@ -3,7 +3,7 @@ I provide a solution for handling the opening of the debugger that supports both I assume there is only one UI Process either in Bloc or Morphic. If the error happened in either one of these processes, I restart the correct one. If both Bloc and Morphic have two distinct UI processes I will not work correctly. -Normally I should only be used when running Bloc natively. When running Bloc using inside the Morphic UI process the a {{gtClass:MorphicUIManager}} can be used instead. +Normally I should only be used when running Bloc natively. When running Bloc using inside the Morphic UI process the a `MorphicUIManager` can be used instead. However for now I can also be used to handle just the case of the Morhic UI process. Later I should be simplified to take into account only the Bloc UI process. " From 2ef0249f504c02af8f7c71b565a59af22b244368 Mon Sep 17 00:00:00 2001 From: Martin Dias Date: Fri, 2 Feb 2024 19:36:30 -0300 Subject: [PATCH 2/2] Replace all {{gtMethod:X} to `X` --- .../BlDevHalosEventListener.class.st | 6 +++--- src/Bloc-DevTool/BlMetricsInspector.class.st | 2 +- .../BlSpaceIconDummyStencil.class.st | 2 +- src/Bloc-Layout/BlFrameLayout.class.st | 2 +- .../BlDevScripterEventCollectorHandler.class.st | 2 +- ...ementMeasurementStrategyExamplesTest.class.st | 6 +++--- ...BlTextUnderlineAttributeExamplesTest.class.st | 6 +++--- src/Bloc/BlBackground.class.st | 2 +- src/Bloc/BlBasicShortcut.class.st | 4 ++-- src/Bloc/BlBeaconLoggingTask.class.st | 2 +- src/Bloc/BlChildren.class.st | 16 ++++++++-------- src/Bloc/BlChildrenArray.class.st | 2 +- src/Bloc/BlChildrenSubset.class.st | 6 +++--- src/Bloc/BlCustomEventHandler.class.st | 2 +- src/Bloc/BlElement.class.st | 4 ++-- src/Bloc/BlLayout.class.st | 12 ++++++------ src/Bloc/BlRepeatedTask.class.st | 2 +- src/Bloc/BlSpaceIconChangedEvent.class.st | 2 +- src/Bloc/BlSpaceManager.class.st | 6 +++--- src/Bloc/BlUseAsyncFeatures.class.st | 8 ++++---- src/Bloc/BlValueWithUnit.class.st | 2 +- 21 files changed, 48 insertions(+), 48 deletions(-) diff --git a/src/Bloc-DevTool/BlDevHalosEventListener.class.st b/src/Bloc-DevTool/BlDevHalosEventListener.class.st index c69c10449..4d16ff307 100644 --- a/src/Bloc-DevTool/BlDevHalosEventListener.class.st +++ b/src/Bloc-DevTool/BlDevHalosEventListener.class.st @@ -1,13 +1,13 @@ " I am an `BlEventListener` event listener and I can display halos around an element. Halos then permits to inspect or delete. -You can install me on any `BlSpace` (window) using {{gtMethod:BlSpace>>#withHalos}}. +You can install me on any `BlSpace` (window) using `BlSpace>>#withHalos`. -The {{gtMethod:BlDevHalosEventListener>>#mouseDownEvent:}} checks if `SHIFT` and `ALT` modifiers are pressed during a `BlMouseDownEvent`. You can try to click on the rectangle below while pressing `SHIFT` and `ALT`: +The `BlDevHalosEventListener>>#mouseDownEvent:` checks if `SHIFT` and `ALT` modifiers are pressed during a `BlMouseDownEvent`. You can try to click on the rectangle below while pressing `SHIFT` and `ALT`: {{gtExample:BlDevHalosEventListenerExamples>>#containerWithRectangle|codeExpanded=false|previewExpanded=true|previewHeight=350|previewShow=#gtLiveFor:}} -Available actions (see implementation at {{gtMethod:BlElementSelection>>#initializeActions}}: +Available actions (see implementation at `BlElementSelection>>#initializeActions`: - The red button removes the selected element. - The green button displays additional information. - The yellow button resizes the selected element. diff --git a/src/Bloc-DevTool/BlMetricsInspector.class.st b/src/Bloc-DevTool/BlMetricsInspector.class.st index a52206330..483e3dc9f 100644 --- a/src/Bloc-DevTool/BlMetricsInspector.class.st +++ b/src/Bloc-DevTool/BlMetricsInspector.class.st @@ -9,7 +9,7 @@ On an element that is defined with the following margin and padding methics: I provide the following overview: {{gtExample:BlMetricsInspectorExamples>>#metricsInspectorOnElementWithMetrics|codeExpanded=false|previewExpanded=true}} -The view is available for any {{gtExample:BlMetricsInspectorExamples>>#elementWithMetrics|label=#className}} instance throught {{gtMethod:BlElement>>#gtMetricsFor:}} inspector extension. You can find it when you inspect a view and switch to {{gtExample:BlMetricsInspectorExamples>>#metricsPhlowView|label=#title}} tab. +The view is available for any {{gtExample:BlMetricsInspectorExamples>>#elementWithMetrics|label=#className}} instance throught `BlElement>>#gtMetricsFor:` inspector extension. You can find it when you inspect a view and switch to {{gtExample:BlMetricsInspectorExamples>>#metricsPhlowView|label=#title}} tab. " diff --git a/src/Bloc-Examples/BlSpaceIconDummyStencil.class.st b/src/Bloc-Examples/BlSpaceIconDummyStencil.class.st index 0cbc70547..31ab061dd 100644 --- a/src/Bloc-Examples/BlSpaceIconDummyStencil.class.st +++ b/src/Bloc-Examples/BlSpaceIconDummyStencil.class.st @@ -1,6 +1,6 @@ " I am a dummy object used by `BlSpaceExamples`. -I evaluate create an icon on {{gtMethod:BlSpaceIconDummyStencil>>#asElement|label=#selector}} call. +I evaluate create an icon on `BlSpaceIconDummyStencil>>#asElement|label=#selector` call. " diff --git a/src/Bloc-Layout/BlFrameLayout.class.st b/src/Bloc-Layout/BlFrameLayout.class.st index 7cfc16445..53aef3f2b 100644 --- a/src/Bloc-Layout/BlFrameLayout.class.st +++ b/src/Bloc-Layout/BlFrameLayout.class.st @@ -17,7 +17,7 @@ The alignment attribute controls the position of children within a FrameLayout. - horizontally children can be aligned to left, center or right; - vertically children can be aligned to top, center or bottom. -For example, below we align a fixed-size child horizontally to the right and vertically to the bottom. Alignment is a constraint specific to frame layouts, as it's not relevant to all layouts. To access frame-specific contraints, we send {{gtMethod:BlLayoutCommonConstraints>>#frame}} to the current constraint object, which returns an instance of `BlFrameLayoutConstraints` that we can use to set the desired alignment. Other constraints like the size of an element are common to all layouts and can be set directly without requesting a specific constraint object. Both cases are illustrated by the following example: +For example, below we align a fixed-size child horizontally to the right and vertically to the bottom. Alignment is a constraint specific to frame layouts, as it's not relevant to all layouts. To access frame-specific contraints, we send `BlLayoutCommonConstraints>>#frame` to the current constraint object, which returns an instance of `BlFrameLayoutConstraints` that we can use to set the desired alignment. Other constraints like the size of an element are common to all layouts and can be set directly without requesting a specific constraint object. Both cases are illustrated by the following example: {{gtExample:BlFrameLayoutSingleChildExamples>>#elementDocumentationWithOneExactChildAlignBottomRightInExactParent|previewExpanded|previewHeight=400}} When using multiple children, if we do not specify any alignment they will be placed in the top-left corner in the order in which they were added to the parent. diff --git a/src/Bloc-Scripter/BlDevScripterEventCollectorHandler.class.st b/src/Bloc-Scripter/BlDevScripterEventCollectorHandler.class.st index 96d9bbd7d..598fbeca2 100644 --- a/src/Bloc-Scripter/BlDevScripterEventCollectorHandler.class.st +++ b/src/Bloc-Scripter/BlDevScripterEventCollectorHandler.class.st @@ -1,7 +1,7 @@ " I am a `BlBasicEventHandler`. I am used by `BlDevScripter`. -I collect events into {{gtMethod:BlDevScripter>>#events}}. +I collect events into `BlDevScripter>>#events`. " Class { diff --git a/src/Bloc-Text-Alexandrie-Examples/BlTextElementMeasurementStrategyExamplesTest.class.st b/src/Bloc-Text-Alexandrie-Examples/BlTextElementMeasurementStrategyExamplesTest.class.st index b71b645df..b8e714499 100644 --- a/src/Bloc-Text-Alexandrie-Examples/BlTextElementMeasurementStrategyExamplesTest.class.st +++ b/src/Bloc-Text-Alexandrie-Examples/BlTextElementMeasurementStrategyExamplesTest.class.st @@ -5,17 +5,17 @@ ## Label measurement -The default text measurement strategy is so called `Label measurement`, {{gtMethod:BlTextElement>>#labelMeasurement}}. The height of the text element in this case is a sum of ascent and descent which is given by the font. It means that the height of the text is independent from the content. The width is given by the exact bounds of the element's text. `Label measurement` is useful for displaying labels and short pieces of text. Please note, that since the width is precise and depends on the content, whitespace is not taken into account when computing the width of the text element. +The default text measurement strategy is so called `Label measurement`, `BlTextElement>>#labelMeasurement`. The height of the text element in this case is a sum of ascent and descent which is given by the font. It means that the height of the text is independent from the content. The width is given by the exact bounds of the element's text. `Label measurement` is useful for displaying labels and short pieces of text. Please note, that since the width is precise and depends on the content, whitespace is not taken into account when computing the width of the text element. {{gtExample:BlTextElementMeasurementStrategyExamples>>#textElementWithLabelMeasurement|noCode|previewShow=#gtLiveFor:|previewHeight=100}} ## Editor measurement -A similar measurement strategy which is designed to be used in a text editor computes the width of the element using the `#advance` property of a text paragraph. The height is computed as a sum of ascent and descent. {{gtMethod:BlTextElement>>#editorMeasurement}} +A similar measurement strategy which is designed to be used in a text editor computes the width of the element using the `#advance` property of a text paragraph. The height is computed as a sum of ascent and descent. `BlTextElement>>#editorMeasurement` {{gtExample:BlTextElementMeasurementStrategyExamples>>#textElementWithEditorMeasurement|noCode|previewShow=#gtLiveFor:|previewHeight=100}} ## Precise measurement -However, sometimes we want to know the exact and precise text bounds. {{gtMethod:BlTextElement>>#tightMeasurement}} does exactly that and clips off any white space surrounding the text. It may be useful for displaying a short piece of a text, usually a word centered within a larger element. +However, sometimes we want to know the exact and precise text bounds. `BlTextElement>>#tightMeasurement` does exactly that and clips off any white space surrounding the text. It may be useful for displaying a short piece of a text, usually a word centered within a larger element. {{gtExample:BlTextElementMeasurementStrategyExamples>>#textElementWithTightMeasurement|noCode|previewShow=#gtLiveFor:|previewHeight=75}} ## Conslusion diff --git a/src/Bloc-Text-Examples/BlTextUnderlineAttributeExamplesTest.class.st b/src/Bloc-Text-Examples/BlTextUnderlineAttributeExamplesTest.class.st index 1362066cb..3fbd8e0cd 100644 --- a/src/Bloc-Text-Examples/BlTextUnderlineAttributeExamplesTest.class.st +++ b/src/Bloc-Text-Examples/BlTextUnderlineAttributeExamplesTest.class.st @@ -1,13 +1,13 @@ " # Underline attribute -The simplest way to apply an underline attribute on a whole text would be to use {{gtMethod:TBlTextStyleable>>#underlineColor:thickness:}} +The simplest way to apply an underline attribute on a whole text would be to use `TBlTextStyleable>>#underlineColor:thickness:` {{gtExample:BlTextUnderlineAttributeExamples>>#textWithUnderline_1_to_5|previewShow=#gtTextFor:|previewExpanded|previewHeight=100}} -To add an underline to just a part of text it can be scoped with {{gtMethod:BlText>>#from:to:}} +To add an underline to just a part of text it can be scoped with `BlText>>#from:to:` {{gtExample:BlTextUnderlineAttributeExamples>>#textWithUnderline_3_to_4|previewShow=#gtTextFor:|previewExpanded|previewHeight=100}} -In addition to the simple API an underline attribute can be customized and then applied on a text using {{gtMethod:TBlTextStyleable>>#underlineDo:}} helper method. Users should pass a block that accepts `BlTextDecorationAttribute` as an argument. +In addition to the simple API an underline attribute can be customized and then applied on a text using `TBlTextStyleable>>#underlineDo:` helper method. Users should pass a block that accepts `BlTextDecorationAttribute` as an argument. {{gtExample:BlTextUnderlineAttributeExamples>>#textWithUnderlineDo|previewShow=#gtTextFor:|previewExpanded|previewHeight=100}} " diff --git a/src/Bloc/BlBackground.class.st b/src/Bloc/BlBackground.class.st index d91e291bd..93874b80d 100644 --- a/src/Bloc/BlBackground.class.st +++ b/src/Bloc/BlBackground.class.st @@ -2,7 +2,7 @@ # Background I represent a background of the `BlElement`. -**I am immutable and can not be changed once created.** To modify the background, create a new instance and set it by sending {{gtMethod:BlElement>>#background:}} +**I am immutable and can not be changed once created.** To modify the background, create a new instance and set it by sending `BlElement>>#background:` ## Types of background diff --git a/src/Bloc/BlBasicShortcut.class.st b/src/Bloc/BlBasicShortcut.class.st index 8bb03de1e..5b3ad5340 100644 --- a/src/Bloc/BlBasicShortcut.class.st +++ b/src/Bloc/BlBasicShortcut.class.st @@ -6,8 +6,8 @@ Additionally, shortcut may provide its optional textual description and name. All shortcuts of an element are stored in `BlShortcutRegistry` and matched / triggered by `BlShortcutHandler` -A shortcut can be added or removed from the element by using {{gtMethod:BlElement>>#addShortcut:}} or {{gtMethod:BlElement>>#removeShortcut:}} methods. -{{gtMethod:BlElement>>#shortcuts}} message can be sent to an element in order to access a list of all registered shortcuts. +A shortcut can be added or removed from the element by using `BlElement>>#addShortcut:` or `BlElement>>#removeShortcut:` methods. +`BlElement>>#shortcuts` message can be sent to an element in order to access a list of all registered shortcuts. ## Public API and Key Messages - combination: get /set shortcut's key combination diff --git a/src/Bloc/BlBeaconLoggingTask.class.st b/src/Bloc/BlBeaconLoggingTask.class.st index def3b800f..743186010 100644 --- a/src/Bloc/BlBeaconLoggingTask.class.st +++ b/src/Bloc/BlBeaconLoggingTask.class.st @@ -1,7 +1,7 @@ " I use `Beacon` to log when a `BlTask` is scheduled and executed.. I emit `BlBeaconTaskSignal`. -I should be instantiated using {{gtMethod:BlBeaconLoggingTask class>>#subtask:}}. +I should be instantiated using `BlBeaconLoggingTask class>>#subtask:`. " diff --git a/src/Bloc/BlChildren.class.st b/src/Bloc/BlChildren.class.st index 56a811215..0a9f48df6 100644 --- a/src/Bloc/BlChildren.class.st +++ b/src/Bloc/BlChildren.class.st @@ -6,18 +6,18 @@ I define a data structure independent API for iterating and accessing bloc eleme ## API Subclasses need to overide the following abstract methods to provide access to the actual bloc elements: -- {{gtMethod:BlChildren>>#at:}} -- {{gtMethod:BlChildren>>#do:}} -- {{gtMethod:BlChildren>>#size}} +- `BlChildren>>#at:` +- `BlChildren>>#do:` +- `BlChildren>>#size` Additionally, I provide an API for selecting only subsets of children, or iterating over them in a differen order, like: -- {{gtMethod:BlChildren>>#accountedByLayout}} -- {{gtMethod:BlChildren>>#ignoredByLayout}} -- {{gtMethod:BlChildren>>#reversed}} -- {{gtMethod:BlChildren>>#sortedByElevation}} +- `BlChildren>>#accountedByLayout` +- `BlChildren>>#ignoredByLayout` +- `BlChildren>>#reversed` +- `BlChildren>>#sortedByElevation` Important API methods: -- {{gtMethod:BlChildren>>#asArray}}: returns an array with all the elements. +- `BlChildren>>#asArray`: returns an array with all the elements. " Class { diff --git a/src/Bloc/BlChildrenArray.class.st b/src/Bloc/BlChildrenArray.class.st index fdafa2515..dc2ec6344 100644 --- a/src/Bloc/BlChildrenArray.class.st +++ b/src/Bloc/BlChildrenArray.class.st @@ -2,7 +2,7 @@ I am a holder that uses an immutable array to store children of bloc elements. Every time a child is added or removed I create a new internal array to store children. -I optimize the method {{gtMethod:BlChildrenArray>>#asArray}} to directly return the internal array instead of creating a new one. In combination with other iterators that use this method (like `BlChildrenReversed`) it can reduce the number of arrays created during layout operations, expecially for graph layouts. +I optimize the method `BlChildrenArray>>#asArray` to directly return the internal array instead of creating a new one. In combination with other iterators that use this method (like `BlChildrenReversed`) it can reduce the number of arrays created during layout operations, expecially for graph layouts. ## Examples Examples are provided by the class `BlChildrenArrayExamples` diff --git a/src/Bloc/BlChildrenSubset.class.st b/src/Bloc/BlChildrenSubset.class.st index da49777c0..dde1313b9 100644 --- a/src/Bloc/BlChildrenSubset.class.st +++ b/src/Bloc/BlChildrenSubset.class.st @@ -9,12 +9,12 @@ The example below shows a scenario of combining multiple ways to iterate over ch I do not enforce a lazy API. Subclasses can perform the filtering immediately or when iteration over children is required. I aim to maintain the composition of subsets while optimizing for speed whenever possible. ## API -Instances of me are created by calling the factory method {{gtMethod:BlChildrenSubset class>>#on:}} on a subclass with an instance of `BlChildren` as parameter. +Instances of me are created by calling the factory method `BlChildrenSubset class>>#on:` on a subclass with an instance of `BlChildren` as parameter. -Subclasses need to override the method {{gtMethod:BlChildrenSubset>>#subsetFrom:}} to filter the elements from the given `BlChildren` instance. This can perform no filtering, filter elements, or also change the order of elements. +Subclasses need to override the method `BlChildrenSubset>>#subsetFrom:` to filter the elements from the given `BlChildren` instance. This can perform no filtering, filter elements, or also change the order of elements. ## Implementation details -Internally the result of {{gtMethod:BlChildrenSubset>>#subsetFrom:}} is stored into an instance variable. This result is then used when accessing or iterating over elements. This decision was taken to allow iterators to perform work when the iterator is created and ensure a faster iteration. +Internally the result of `BlChildrenSubset>>#subsetFrom:` is stored into an instance variable. This result is then used when accessing or iterating over elements. This decision was taken to allow iterators to perform work when the iterator is created and ensure a faster iteration. To preserve the composition of iterators I hold a reference to the initial `BlChildren` instance. diff --git a/src/Bloc/BlCustomEventHandler.class.st b/src/Bloc/BlCustomEventHandler.class.st index f06b77456..89376ac46 100644 --- a/src/Bloc/BlCustomEventHandler.class.st +++ b/src/Bloc/BlCustomEventHandler.class.st @@ -1,5 +1,5 @@ " -I am a custom event handler. User must override me and implement {{gtMethod:BlBasicEventHandler>>#eventsToHandle}} to return a collection of event classes that I am interested in. +I am a custom event handler. User must override me and implement `BlBasicEventHandler>>#eventsToHandle` to return a collection of event classes that I am interested in. Then for each interesting event a user should implement a corresponding event handling method. For example for `BlMouseDownEvent` it would be `mouseDownEvent:` " diff --git a/src/Bloc/BlElement.class.st b/src/Bloc/BlElement.class.st index ccd5f8c33..1307833e7 100644 --- a/src/Bloc/BlElement.class.st +++ b/src/Bloc/BlElement.class.st @@ -21,7 +21,7 @@ Bloc elements provide a set of methods to add and remove children. ### Adding children There are four ways to add some given element as a direct child to another element. -The most commonly used way to add a child is to use {{gtMethod:BlElement>>#addChild:}} which adds a given element as the last child in the collection of children. +The most commonly used way to add a child is to use `BlElement>>#addChild:` which adds a given element as the last child in the collection of children. ``` | parent child | parent := BlElement new size: 100@100; background: Color veryVeryLightGray. @@ -29,7 +29,7 @@ child := BlElement new size: 50@50; background: Color red lighter. parent addChild: child ``` -Users may also choose to add an element as the first child, for that purpose Bloc provides {{gtMethod:BlElement>>#addChildFirst:}}. +Users may also choose to add an element as the first child, for that purpose Bloc provides `BlElement>>#addChildFirst:`. ## Geometry and bounds Every element is responsible for drawing itself. At the same time, every element has a `BlElementGeometry` that defines the bounds and the clipping. There are many types of geometry available: ``` diff --git a/src/Bloc/BlLayout.class.st b/src/Bloc/BlLayout.class.st index 7a9c28ef6..a4e5b8438 100644 --- a/src/Bloc/BlLayout.class.st +++ b/src/Bloc/BlLayout.class.st @@ -12,15 +12,15 @@ TODO: constraints API ## Layout phase in a frame Element layout is a phase executed by a space during each frame. -Every frame, the space goes through several phases ({{gtMethod:BlSpaceFrame>>#initializePhases}}), which are modeled as subclasses of `BlSpaceFramePhase` and are executed once per frame. One of them, `BlSpaceFrameLayoutPhase`, lays out the elements contained in the space. This is done after events and tasks have been executed, but before the drawing phase. +Every frame, the space goes through several phases (`BlSpaceFrame>>#initializePhases`), which are modeled as subclasses of `BlSpaceFramePhase` and are executed once per frame. One of them, `BlSpaceFrameLayoutPhase`, lays out the elements contained in the space. This is done after events and tasks have been executed, but before the drawing phase. -Layout should happen during a frame whenever various properties like width, height or position change for any element contained by the space. However, an important aspect in Bloc, is that when one of these properties changes, layout is not performed immediately. Instead, a layout request is issued by the element whose property changed via the {{gtMethod:BlElement>>#requestLayout:}} message. This has two advantages that improve performance: +Layout should happen during a frame whenever various properties like width, height or position change for any element contained by the space. However, an important aspect in Bloc, is that when one of these properties changes, layout is not performed immediately. Instead, a layout request is issued by the element whose property changed via the `BlElement>>#requestLayout:` message. This has two advantages that improve performance: 1. If no element requests layout, this phase can be skipped. 2. It does not matter if layout is requested once or 1000 times during a frame; only one layout phase is performed. -Hence, layout does not happen immediately after a property like the width of an element changes. Instead, once requested, you only know that layout will happen at some point during every frame. When needing to test layouts, however, it is necessary to apply a layout immediately, instead of waiting for a frame to end. This can be done using the {{gtMethod:BlElement>>#forceLayout}} message, but it should not be used outside of tests, as it bypasses the normal layout system. +Hence, layout does not happen immediately after a property like the width of an element changes. Instead, once requested, you only know that layout will happen at some point during every frame. When needing to test layouts, however, it is necessary to apply a layout immediately, instead of waiting for a frame to end. This can be done using the `BlElement>>#forceLayout` message, but it should not be used outside of tests, as it bypasses the normal layout system. -In a space where all elements have no event handlers for layout events, elements are going to be laid out exactly once during the layout phase. However, often elements need to react and perform actions, for example when their position or extent changes. In these cases, they may request another layout. A typical example is dealing with edges. An edge can be laid out only after the position of the elements to which it connects is known. Hence, often the layout needs to be applied twice, or more, during the layout phase. However, spaces only allow a limited number of layout requests during each layout phase to avoid blocking rendering due to infinite recursions caused by layout requests, or avoid spending too much time on layouts in a frame. More technical details can be found in the method {{gtMethod:BlSpace>>#doLayout}}, the main entry point for executing the layout phase in a space. +In a space where all elements have no event handlers for layout events, elements are going to be laid out exactly once during the layout phase. However, often elements need to react and perform actions, for example when their position or extent changes. In these cases, they may request another layout. A typical example is dealing with edges. An edge can be laid out only after the position of the elements to which it connects is known. Hence, often the layout needs to be applied twice, or more, during the layout phase. However, spaces only allow a limited number of layout requests during each layout phase to avoid blocking rendering due to infinite recursions caused by layout requests, or avoid spending too much time on layouts in a frame. More technical details can be found in the method `BlSpace>>#doLayout`, the main entry point for executing the layout phase in a space. ## Performing a layout The space starts the layout process on the root element of that space. Performing the layout on an element consists of executing three main steps: @@ -33,9 +33,9 @@ TODO: why three separate steps? ### Measuring bounds This is the first step when performing a layout of an element and consists in determining the measured bounds of that element. -Each element can decide how it wants to be measured ({{gtMethod:BlElement>>#onMeasure:}}). By default, `BlElement` delegates measuring to its layout. Layouts should override {{gtMethod:BlLayout>>#measure:with:}} to implement the actual measuring. Normally, layouts follow a top-to-bottom approach: they measure the current element and then ask their children measure themselves. +Each element can decide how it wants to be measured (`BlElement>>#onMeasure:`). By default, `BlElement` delegates measuring to its layout. Layouts should override `BlLayout>>#measure:with:` to implement the actual measuring. Normally, layouts follow a top-to-bottom approach: they measure the current element and then ask their children measure themselves. -Each element has real bounds ({{gtMethod:BlElement>>#bounds}}) and measured bounds ({{gtMethod:BlElement>>#measuredBounds}}). The real bounds contain the actual position and extent of an element that users of that element should rely on. The measured bounds are used during layout to hold the new extent of an element. The measuring phase changes only the extent in the measured bounds. After the entire layout phase is completed the real bounds and measured bounds will have the same value. The measured bounds act like a temporary cache for the new bounds of an element. They were introduced to avoid changing the real extent of element while layout of children is still being performed. +Each element has real bounds (`BlElement>>#bounds`) and measured bounds (`BlElement>>#measuredBounds`). The real bounds contain the actual position and extent of an element that users of that element should rely on. The measured bounds are used during layout to hold the new extent of an element. The measuring phase changes only the extent in the measured bounds. After the entire layout phase is completed the real bounds and measured bounds will have the same value. The measured bounds act like a temporary cache for the new bounds of an element. They were introduced to avoid changing the real extent of element while layout of children is still being performed. (TODO: explain why position is sometime changed in the measured bounds) diff --git a/src/Bloc/BlRepeatedTask.class.st b/src/Bloc/BlRepeatedTask.class.st index 63e52df04..97bb59874 100644 --- a/src/Bloc/BlRepeatedTask.class.st +++ b/src/Bloc/BlRepeatedTask.class.st @@ -1,6 +1,6 @@ " Enhancement: a repeated task should re-enqueue itself with its element when that element is removed from the scene graph. See . -See the {{gtMethod:name=BlRepeatedTask>>#run}} method. +See the `name=BlRepeatedTask>>#run` method. " diff --git a/src/Bloc/BlSpaceIconChangedEvent.class.st b/src/Bloc/BlSpaceIconChangedEvent.class.st index 5268c7c9a..48c97e83e 100644 --- a/src/Bloc/BlSpaceIconChangedEvent.class.st +++ b/src/Bloc/BlSpaceIconChangedEvent.class.st @@ -1,5 +1,5 @@ " -I am fired by {{gtMethod:BlSpace>>#icon:}} when {{gtMethod:BlSpace>>#icon}} is changed. +I am fired by `BlSpace>>#icon:` when `BlSpace>>#icon` is changed. " Class { diff --git a/src/Bloc/BlSpaceManager.class.st b/src/Bloc/BlSpaceManager.class.st index 91eccf32a..008d3156c 100644 --- a/src/Bloc/BlSpaceManager.class.st +++ b/src/Bloc/BlSpaceManager.class.st @@ -5,9 +5,9 @@ I contain Bloc `BlSpace|label=spaces` which can be added or removed. I am also r I am used by `BlUniverse` so that it can support multiple `BlSpace|label=spaces`. Here are some of my core operations: -- {{gtMethod:BlSpaceManager>>#addSpace:}} -- {{gtMethod:BlSpaceManager>>#removeSpace:}} -- {{gtMethod:BlSpaceManager>>#pulse}} - send a pulse message to all spaces +- `BlSpaceManager>>#addSpace:` +- `BlSpaceManager>>#removeSpace:` +- `BlSpaceManager>>#pulse` - send a pulse message to all spaces " Class { diff --git a/src/Bloc/BlUseAsyncFeatures.class.st b/src/Bloc/BlUseAsyncFeatures.class.st index 8b8156a59..d80c09ead 100644 --- a/src/Bloc/BlUseAsyncFeatures.class.st +++ b/src/Bloc/BlUseAsyncFeatures.class.st @@ -3,11 +3,11 @@ I define whether asynchronous features should be used and a code execution there All code that trigger async executions should use one of my class side methods: -- {{gtMethod:BlUseAsyncFeatures class>>#ifEnabledDo:otherwise:}} -- {{gtMethod:BlUseAsyncFeatures class>>#ifEnabledDo:}} -- {{gtMethod:BlUseAsyncFeatures class>>#ifDisabledDo:}} +- `BlUseAsyncFeatures class>>#ifEnabledDo:otherwise:` +- `BlUseAsyncFeatures class>>#ifEnabledDo:` +- `BlUseAsyncFeatures class>>#ifDisabledDo:` -In the cases where the async should be disabled, {{gtMethod:BlUseAsyncFeatures class>>#disableDuring:}} should be used. +In the cases where the async should be disabled, `BlUseAsyncFeatures class>>#disableDuring:` should be used. " diff --git a/src/Bloc/BlValueWithUnit.class.st b/src/Bloc/BlValueWithUnit.class.st index 679d61331..c0e10d329 100644 --- a/src/Bloc/BlValueWithUnit.class.st +++ b/src/Bloc/BlValueWithUnit.class.st @@ -2,7 +2,7 @@ # Value with unit Represents a `dimensioned quantity` or `dimensioned number`, for example `10pt` or `30%`. -The {{gtMethod:BlValueWithUnit>>#value|label=value}} can be any object, but in most cases it is a number, the {{gtMethod:BlValueWithUnit>>#unit|label=unit}} is an instance of a concrete subclass of `BlUnit` +The `BlValueWithUnit>>#value|label=value` can be any object, but in most cases it is a number, the `BlValueWithUnit>>#unit|label=unit` is an instance of a concrete subclass of `BlUnit` " Class {