js-draw 0.4.0 → 0.5.0

package/src/Editor.ts

@@ -586,6 +586,7 @@ export class Editor {
 				kind: InputEvtType.KeyPressEvent,
 				key: evt.key,
 				ctrlKey: evt.ctrlKey,
+				altKey: evt.altKey,
 			})) {
 				evt.preventDefault();
 			} else if (evt.key === 'Escape') {
@@ -598,6 +599,7 @@ export class Editor {
 				kind: InputEvtType.KeyUpEvent,
 				key: evt.key,
 				ctrlKey: evt.ctrlKey,
+				altKey: evt.altKey,
 			})) {
 				evt.preventDefault();
 			}
@@ -783,12 +785,14 @@ export class Editor {
 	public sendKeyboardEvent(
 		eventType: InputEvtType.KeyPressEvent|InputEvtType.KeyUpEvent,
 		key: string,
-		ctrlKey: boolean = false
+		ctrlKey: boolean = false,
+		altKey: boolean = false,
 	) {
 		this.toolController.dispatchInputEvent({
 			kind: eventType,
 			key,
-			ctrlKey
+			ctrlKey,
+			altKey,
 		});
 	}
 
@@ -797,6 +801,8 @@ export class Editor {
 	public sendPenEvent(
 		eventType: InputEvtType.PointerDownEvt|InputEvtType.PointerMoveEvt|InputEvtType.PointerUpEvt,
 		point: Point2,
+
+		// @deprecated
 		allPointers?: Pointer[]
 	) {
 		const mainPointer = Pointer.ofCanvasPoint(

package/src/components/AbstractComponent.ts

@@ -206,8 +206,10 @@ export default abstract class AbstractComponent {
 
 	public abstract description(localizationTable: ImageComponentLocalization): string;
 
+	// Component-specific implementation of {@link clone}.
 	protected abstract createClone(): AbstractComponent;
 
+	// Returns a copy of this component.
 	public clone() {
 		const clone = this.createClone();
 

package/src/components/Stroke.test.ts

@@ -2,12 +2,9 @@ import Color4 from '../Color4';
 import Path from '../math/Path';
 import { Vec2 } from '../math/Vec2';
 import Stroke from './Stroke';
-import { loadExpectExtensions } from '../testing/loadExpectExtensions';
 import createEditor from '../testing/createEditor';
 import Mat33 from '../math/Mat33';
 
-loadExpectExtensions();
-
 describe('Stroke', () => {
 	it('empty stroke should have an empty bounding box', () => {
 		const stroke = new Stroke([{

package/src/components/Stroke.ts

@@ -18,7 +18,8 @@ export default class Stroke extends AbstractComponent {
 	public constructor(parts: RenderablePathSpec[]) {
 		super('stroke');
 
-		this.parts = parts.map((section): StrokePart => {
+		this.parts = [];
+		for (const section of parts) {
 			const path = Path.fromRenderable(section);
 			const pathBBox = this.bboxForPart(path.bbox, section.style);
 
@@ -28,15 +29,15 @@ export default class Stroke extends AbstractComponent {
 				this.contentBBox = this.contentBBox.union(pathBBox);
 			}
 
-			return {
+			this.parts.push({
 				path,
 
 				// To implement RenderablePathSpec
 				startPoint: path.startPoint,
 				style: section.style,
 				commands: path.parts,
-			};
-		});
+			});
+		}
 		this.contentBBox ??= Rect2.empty;
 	}
 
@@ -104,9 +105,15 @@ export default class Stroke extends AbstractComponent {
 	}
 
 	public getPath() {
-		return this.parts.reduce((accumulator: Path|null, current: StrokePart) => {
-			return accumulator?.union(current.path) ?? current.path;
-		}, null) ?? Path.empty;
+		let result: Path|null = null;
+		for (const part of this.parts) {
+			if (result) {
+				result = result.union(part.path);
+			} else {
+				result ??= part.path;
+			}
+		}
+		return result ?? Path.empty;
 	}
 
 	public description(localization: ImageComponentLocalization): string {

package/src/components/Text.test.ts

@@ -3,9 +3,6 @@ import Mat33 from '../math/Mat33';
 import Rect2 from '../math/Rect2';
 import AbstractComponent from './AbstractComponent';
 import Text, { TextStyle } from './Text';
-import { loadExpectExtensions } from '../testing/loadExpectExtensions';
-
-loadExpectExtensions();
 
 const estimateTextBounds = (text: string, style: TextStyle): Rect2 => {
 	const widthEst = text.length * style.size;

package/src/components/Text.ts

@@ -135,7 +135,7 @@ export default class Text extends AbstractComponent {
 		return new Text(this.textObjects, this.transform, this.style);
 	}
 
-	private getText() {
+	public getText() {
 		const result: string[] = [];
 
 		for (const textObject of this.textObjects) {
@@ -146,7 +146,7 @@ export default class Text extends AbstractComponent {
 			}
 		}
 
-		return result.join(' ');
+		return result.join('\n');
 	}
 
 	public description(localizationTable: ImageComponentLocalization): string {

package/src/components/builders/FreehandLineBuilder.ts

@@ -173,7 +173,7 @@ export default class FreehandLineBuilder implements ComponentBuilder {
 	}
 
 	public build(): Stroke {
-		if (this.lastPoint) {
+		if (this.lastPoint && (this.lowerSegments.length === 0 || this.approxCurrentCurveLength() > this.curveStartWidth * 2)) {
 			this.finalizeCurrentCurve();
 		}
 		return this.previewStroke()!;
@@ -189,6 +189,19 @@ export default class FreehandLineBuilder implements ComponentBuilder {
 		return Viewport.roundPoint(point, minFit);
 	}
 
+	// Returns the distance between the start, control, and end points of the curve.
+	private approxCurrentCurveLength() {
+		if (!this.currentCurve) {
+			return 0;
+		}
+		const startPt = Vec2.ofXY(this.currentCurve.points[0]);
+		const controlPt = Vec2.ofXY(this.currentCurve.points[1]);
+		const endPt = Vec2.ofXY(this.currentCurve.points[2]);
+		const toControlDist = startPt.minus(controlPt).length();
+		const toEndDist = endPt.minus(controlPt).length();
+		return toControlDist + toEndDist;
+	}
+
 	private finalizeCurrentCurve() {
 		// Case where no points have been added
 		if (!this.currentCurve) {
@@ -285,10 +298,8 @@ export default class FreehandLineBuilder implements ComponentBuilder {
 		startVec = startVec.times(this.curveStartWidth / 2);
 		endVec = endVec.times(this.curveEndWidth / 2);
 
-		if (isNaN(startVec.magnitude())) {
-			// TODO: This can happen when events are too close together. Find out why and
-			// 		 fix.
-			console.error('startVec is NaN', startVec, endVec, this.currentCurve);
+		if (!isFinite(startVec.magnitude())) {
+			console.error('Warning: startVec is NaN or ∞', startVec, endVec, this.currentCurve);
 			startVec = endVec;
 		}
 
@@ -307,39 +318,22 @@ export default class FreehandLineBuilder implements ComponentBuilder {
 		}
 
 		const halfVecT = projectionT;
-		let halfVec = Vec2.ofXY(this.currentCurve.normal(halfVecT))
+		const halfVec = Vec2.ofXY(this.currentCurve.normal(halfVecT))
 			.normalized().times(
 				this.curveStartWidth / 2 * halfVecT
 				+ this.curveEndWidth / 2 * (1 - halfVecT)
 			);
 
-		// Computes a boundary curve. [direction] should be either +1 or -1 (determines the side
-		// of the center curve to place the boundary).
-		const computeBoundaryCurve = (direction: number, halfVec: Vec2) => {
-			return new Bezier(
-				startPt.plus(startVec.times(direction)),
-				controlPoint.plus(halfVec.times(direction)),
-				endPt.plus(endVec.times(direction)),
-			);
-		};
-
-		const boundariesIntersect = () => {
-			const upperBoundary = computeBoundaryCurve(1, halfVec);
-			const lowerBoundary = computeBoundaryCurve(-1, halfVec);
-			return upperBoundary.intersects(lowerBoundary).length > 0;
-		};
-
-		// If the boundaries have intersections, increasing the half vector's length could fix this.
-		if (boundariesIntersect()) {
-			halfVec = halfVec.times(1.1);
-		}
-
 		// Each starts at startPt ± startVec
+		const lowerCurveControlPoint = this.roundPoint(controlPoint.plus(halfVec));
+		const lowerCurveEndPoint = this.roundPoint(endPt.plus(endVec));
+		const upperCurveControlPoint = this.roundPoint(controlPoint.minus(halfVec));
+		const upperCurveStartPoint = this.roundPoint(endPt.minus(endVec));
 
 		const lowerCurve: QuadraticBezierPathCommand = {
 			kind: PathCommandType.QuadraticBezierTo,
-			controlPoint: this.roundPoint(controlPoint.plus(halfVec)),
-			endPoint: this.roundPoint(endPt.plus(endVec)),
+			controlPoint: lowerCurveControlPoint,
+			endPoint: lowerCurveEndPoint,
 		};
 
 		// From the end of the upperCurve to the start of the lowerCurve:
@@ -351,12 +345,12 @@ export default class FreehandLineBuilder implements ComponentBuilder {
 		// From the end of lowerCurve to the start of upperCurve:
 		const lowerToUpperConnector: LinePathCommand = {
 			kind: PathCommandType.LineTo,
-			point: this.roundPoint(endPt.minus(endVec))
+			point: upperCurveStartPoint,
 		};
 
 		const upperCurve: QuadraticBezierPathCommand = {
 			kind: PathCommandType.QuadraticBezierTo,
-			controlPoint: this.roundPoint(controlPoint.minus(halfVec)),
+			controlPoint: upperCurveControlPoint,
 			endPoint: this.roundPoint(startPt.minus(startVec)),
 		};
 
@@ -374,7 +368,6 @@ export default class FreehandLineBuilder implements ComponentBuilder {
 			const fuzzEq = 1e-10;
 			const deltaTime = newPoint.time - this.lastPoint.time;
 			if (newPoint.pos.eq(this.lastPoint.pos, fuzzEq) || deltaTime === 0) {
-				console.warn('Discarding identical point');
 				return;
 			} else if (isNaN(newPoint.pos.magnitude())) {
 				console.warn('Discarding NaN point.', newPoint);
@@ -440,16 +433,16 @@ export default class FreehandLineBuilder implements ComponentBuilder {
 		const maxControlPointDist = maxRelativeLength * startEndDist;
 
 		// Exit in cases where we would divide by zero
-		if (maxControlPointDist === 0 || exitingVec.magnitude() === 0 || isNaN(exitingVec.magnitude())) {
+		if (maxControlPointDist === 0 || exitingVec.magnitude() === 0 || !isFinite(exitingVec.magnitude())) {
 			return;
 		}
 
-		console.assert(!isNaN(enteringVec.magnitude()));
+		console.assert(isFinite(enteringVec.magnitude()), 'Pre-normalized enteringVec has NaN or ∞ magnitude!');
 
 		enteringVec = enteringVec.normalized();
 		exitingVec = exitingVec.normalized();
 
-		console.assert(!isNaN(enteringVec.magnitude()));
+		console.assert(isFinite(enteringVec.magnitude()), 'Normalized enteringVec has NaN or ∞ magnitude!');
 
 		const lineFromStart = new LineSegment2(
 			segmentStart,
@@ -462,18 +455,20 @@ export default class FreehandLineBuilder implements ComponentBuilder {
 		const intersection = lineFromEnd.intersection(lineFromStart);
 
 		// Position the control point at this intersection
-		let controlPoint: Point2;
+		let controlPoint: Point2|null = null;
 		if (intersection) {
 			controlPoint = intersection.point;
-		} else {
+		}
+
+		// No intersection or the intersection is one of the end points?
+		if (!controlPoint || segmentStart.eq(controlPoint) || segmentEnd.eq(controlPoint)) {
 			// Position the control point closer to the first -- the connecting
 			// segment will be roughly a line.
 			controlPoint = segmentStart.plus(enteringVec.times(startEndDist / 4));
 		}
 
-		if (isNaN(controlPoint.magnitude()) || isNaN(segmentStart.magnitude())) {
-			console.error('controlPoint is NaN', intersection, 'Start:', segmentStart, 'End:', segmentEnd, 'in:', enteringVec, 'out:', exitingVec);
-		}
+		console.assert(!segmentStart.eq(controlPoint, 1e-11), 'Start and control points are equal!');
+		console.assert(!controlPoint.eq(segmentEnd, 1e-11), 'Control and end points are equal!');
 
 		const prevCurve = this.currentCurve;
 		this.currentCurve = new Bezier(segmentStart.xy, controlPoint.xy, segmentEnd.xy);
@@ -502,8 +497,7 @@ export default class FreehandLineBuilder implements ComponentBuilder {
 			return true;
 		};
 
-		const approxCurveLen = controlPoint.minus(segmentStart).magnitude() + segmentEnd.minus(controlPoint).magnitude();
-		if (this.buffer.length > 3 && approxCurveLen > this.curveEndWidth / 3) {
+		if (this.buffer.length > 3 && this.approxCurrentCurveLength() > this.curveStartWidth) {
 			if (!curveMatchesPoints(this.currentCurve)) {
 				// Use a curve that better fits the points
 				this.currentCurve = prevCurve;

package/src/language/assertions.ts

@@ -2,5 +2,5 @@
 // Compile-time assertion that a branch of code is unreachable.
 // See https://stackoverflow.com/a/39419171/17055750
 export const assertUnreachable = (key: never): never => {
-    throw new Error(`Should be unreachable. Key: ${key}.`);
-};
+	throw new Error(`Should be unreachable. Key: ${key}.`);
+};

package/src/math/LineSegment2.test.ts

@@ -1,9 +1,7 @@
 import LineSegment2 from './LineSegment2';
-import { loadExpectExtensions } from '../testing/loadExpectExtensions';
 import { Vec2 } from './Vec2';
 import Mat33 from './Mat33';
 
-loadExpectExtensions();
 
 describe('Line2', () => {
 	it('x and y axes should intersect at (0, 0)', () => {
@@ -14,13 +12,13 @@ describe('Line2', () => {
 	});
 
 	it('y = -2x + 2 and y = 2x - 2 should intersect at (1,0)', () => {
-		// y = -2x + 2
+		// y = -4x + 2
 		const line1 = new LineSegment2(Vec2.of(0, 2), Vec2.of(1, -2));
-		// y = 2x - 2
+		// y = 4x - 2
 		const line2 = new LineSegment2(Vec2.of(0, -2), Vec2.of(1, 2));
 
-		expect(line1.intersection(line2)?.point).objEq(Vec2.of(1, 0));
-		expect(line2.intersection(line1)?.point).objEq(Vec2.of(1, 0));
+		expect(line1.intersection(line2)?.point).objEq(Vec2.of(0.5, 0));
+		expect(line2.intersection(line1)?.point).objEq(Vec2.of(0.5, 0));
 	});
 
 	it('line from (10, 10) to (-100, 10) should intersect with the y-axis at t = 10', () => {
@@ -81,14 +79,14 @@ describe('Line2', () => {
 		expect(line.closestPointTo(Vec2.zero)).objEq(Vec2.of(1, 0));
 	});
 
-	it('Closest point from (-1,2) to segment((1,1) -> (2,4)) should be (1,1)', () => {
+	it('Closest point from (-1,-2) to segment((1,1) -> (2,4)) should be (1,1)', () => {
 		const line = new LineSegment2(Vec2.of(1, 1), Vec2.of(2, 4));
-		expect(line.closestPointTo(Vec2.of(-1, 2))).objEq(Vec2.of(1, 1));
+		expect(line.closestPointTo(Vec2.of(-1, -2))).objEq(Vec2.of(1, 1));
 	});
 
-	it('Closest point from (5,2) to segment((1,1) -> (2,4)) should be (2,4)', () => {
+	it('Closest point from (5,8) to segment((1,1) -> (2,4)) should be (2,4)', () => {
 		const line = new LineSegment2(Vec2.of(1, 1), Vec2.of(2, 4));
-		expect(line.closestPointTo(Vec2.of(5, 2))).objEq(Vec2.of(2, 4));
+		expect(line.closestPointTo(Vec2.of(5, 8))).objEq(Vec2.of(2, 4));
 	});
 
 	it('Should translate when translated by a translation matrix', () => {

package/src/math/Mat33.test.ts

@@ -1,9 +1,7 @@
 import Mat33 from './Mat33';
 import { Vec2 } from './Vec2';
-import { loadExpectExtensions } from '../testing/loadExpectExtensions';
 import Vec3 from './Vec3';
 
-loadExpectExtensions();
 
 describe('Mat33 tests', () => {
 	it('equality', () => {

package/src/math/Rect2.test.ts

@@ -1,11 +1,8 @@
 
 import Rect2 from './Rect2';
 import { Vec2 } from './Vec2';
-import loadExpectExtensions from '../testing/loadExpectExtensions';
 import Mat33 from './Mat33';
 
-loadExpectExtensions();
-
 describe('Rect2', () => {
 	it('width, height should always be positive', () => {
 		expect(new Rect2(-1, -2, -3, 4)).objEq(new Rect2(-4, -2, 3, 4));

package/src/math/Vec2.test.ts

@@ -1,8 +1,5 @@
 import { Vec2 } from './Vec2';
 import Vec3 from './Vec3';
-import { loadExpectExtensions } from '../testing/loadExpectExtensions';
-
-loadExpectExtensions();
 
 describe('Vec2', () => {
 	it('Magnitude', () => {

package/src/math/Vec3.test.ts

@@ -1,9 +1,6 @@
 
-import { loadExpectExtensions } from '../testing/loadExpectExtensions';
 import Vec3 from './Vec3';
 
-loadExpectExtensions();
-
 describe('Vec3', () => {
 	it('.xy should contain the x and y components', () => {
 		const vec = Vec3.of(1, 2, 3);

package/src/math/Vec3.ts

@@ -196,7 +196,7 @@ export default class Vec3 {
 	 * Vec3.of(1, 2, 3).eq(Vec3.of(4, 5, 6), 2.99); // → false
 	 * ```
 	 */
-	public eq(other: Vec3, fuzz: number): boolean {
+	public eq(other: Vec3, fuzz: number = 1e-10): boolean {
 		for (let i = 0; i < 3; i++) {
 			if (Math.abs(other.at(i) - this.at(i)) > fuzz) {
 				return false;

package/src/rendering/renderers/SVGRenderer.ts

@@ -88,7 +88,7 @@ export default class SVGRenderer extends AbstractRenderer {
 
 	public drawPath(pathSpec: RenderablePathSpec) {
 		const style = pathSpec.style;
-		const path = Path.fromRenderable(pathSpec);
+		const path = Path.fromRenderable(pathSpec).transformedBy(this.getCanvasToScreenTransform());
 
 		// Try to extend the previous path, if possible
 		if (!style.fill.eq(this.lastPathStyle?.fill) || this.lastPathString.length === 0) {

package/src/testing/beforeEachFile.ts

@@ -0,0 +1,3 @@
+import loadExpectExtensions from './loadExpectExtensions';
+loadExpectExtensions();
+jest.useFakeTimers();

package/src/testing/createEditor.ts

@@ -1,4 +1,11 @@
 import { RenderingMode } from '../rendering/Display';
 import Editor from '../Editor';
 
-export default () => new Editor(document.body, { renderingMode: RenderingMode.DummyRenderer });
+/** Creates an editor. Should only be used in test files. */
+export default () => {
+	if (jest === undefined) {
+		throw new Error('Files in the testing/ folder should only be used in tests!');
+	}
+
+	return new Editor(document.body, { renderingMode: RenderingMode.DummyRenderer });
+};

package/src/testing/global.d.ts

@@ -0,0 +1,17 @@
+
+
+// Type declarations for custom matchers
+interface CustomMatchers<R = unknown> {
+	objEq(expected: {
+		eq: (other: any, ...args: any)=> boolean;
+	}, ...opts: any): R;
+}
+
+declare namespace jest {
+	interface Expect extends CustomMatchers {}
+	interface Matchers<R> extends CustomMatchers<R> {}
+	interface AsyncAsymmetricMatchers extends CustomMatchers {}
+}
+
+declare interface JestMatchers<T> extends CustomMatchers<T> {
+}

package/src/testing/loadExpectExtensions.ts

@@ -22,19 +22,4 @@ export const loadExpectExtensions = () => {
 	});
 };
 
-// Type declarations for custom matchers
-export interface CustomMatchers<R = unknown> {
-	objEq(expected: {
-		eq: (other: any, ...args: any)=> boolean;
-	}, ...opts: any): R;
-}
-
-declare global {
-	export namespace jest {
-		interface Expect extends CustomMatchers {}
-		interface Matchers<R> extends CustomMatchers<R> {}
-		interface AsyncAsymmetricMatchers extends CustomMatchers {}
-	}
-}
-
 export default loadExpectExtensions;

package/src/toolbar/toolbar.css

@@ -34,7 +34,8 @@
 }
 
 .toolbar-button.disabled {
-	filter: opacity(0.8) saturate(0.1);
+	filter: opacity(0.5) sepia(0.2);
+	cursor: unset;
 }
 
 .toolbar-button, .toolbar-root button {
@@ -75,7 +76,7 @@
 	width: 6em;
 }
 
-.toolbar-button:hover, .toolbar-root button:not(:disabled):hover {
+.toolbar-button:not(.disabled):hover, .toolbar-root button:not(:disabled):hover {
 	box-shadow: 0px 2px 4px var(--primary-shadow-color);
 }
 

package/src/toolbar/widgets/BaseWidget.ts

@@ -1,5 +1,6 @@
 import Editor from '../../Editor';
-import { EditorEventType, InputEvtType } from '../../types';
+import ToolbarShortcutHandler from '../../tools/ToolbarShortcutHandler';
+import { EditorEventType, InputEvtType, KeyPressEvent } from '../../types';
 import { toolbarCSSPrefix } from '../HTMLToolbar';
 import { makeDropdownIcon } from '../icons';
 import { ToolbarLocalization } from '../localization';
@@ -33,6 +34,14 @@ export default abstract class BaseWidget {
 		this.label = document.createElement('label');
 		this.button.setAttribute('role', 'button');
 		this.button.tabIndex = 0;
+
+		const toolbarShortcutHandlers = this.editor.toolController.getMatchingTools(ToolbarShortcutHandler);
+
+		// If the onKeyPress function has been extended and the editor is configured to send keypress events to
+		// toolbar widgets,
+		if (toolbarShortcutHandlers.length > 0 && this.onKeyPress !== BaseWidget.prototype.onKeyPress) {
+			toolbarShortcutHandlers[0].registerListener(event => this.onKeyPress(event));
+		}
 	}
 
 	protected abstract getTitle(): string;
@@ -70,6 +79,7 @@ export default abstract class BaseWidget {
 					kind: InputEvtType.KeyPressEvent,
 					key: evt.key,
 					ctrlKey: evt.ctrlKey,
+					altKey: evt.altKey,
 				});
 			}
 		};
@@ -83,6 +93,7 @@ export default abstract class BaseWidget {
 				kind: InputEvtType.KeyUpEvent,
 				key: evt.key,
 				ctrlKey: evt.ctrlKey,
+				altKey: evt.altKey,
 			});
 		};
 
@@ -93,6 +104,13 @@ export default abstract class BaseWidget {
 		};
 	}
 
+	// Add a listener that is triggered when a key is pressed.
+	// Listeners will fire regardless of whether this widget is selected and require that
+	// {@link lib!Editor.toolController} to have an enabled {@link lib!ToolbarShortcutHandler} tool.
+	protected onKeyPress(_event: KeyPressEvent): boolean {
+		return false;
+	}
+
 	protected abstract handleClick(): void;
 
 	protected get hasDropdown() {

package/src/toolbar/widgets/PenToolWidget.ts

@@ -5,7 +5,7 @@ import { makeFilledRectangleBuilder, makeOutlinedRectangleBuilder } from '../../
 import { ComponentBuilderFactory } from '../../components/builders/types';
 import Editor from '../../Editor';
 import Pen from '../../tools/Pen';
-import { EditorEventType } from '../../types';
+import { EditorEventType, KeyPressEvent } from '../../types';
 import { toolbarCSSPrefix } from '../HTMLToolbar';
 import { makeIconFromFactory, makePenIcon } from '../icons';
 import { ToolbarLocalization } from '../localization';
@@ -165,4 +165,21 @@ export default class PenToolWidget extends BaseToolWidget {
 		dropdown.replaceChildren(container);
 		return true;
 	}
+
+	protected onKeyPress(event: KeyPressEvent): boolean {
+		if (!this.isSelected()) {
+			return false;
+		}
+
+		// Map alt+0-9 to different pen types.
+		if (/^[0-9]$/.exec(event.key) && event.ctrlKey) {
+			const penTypeIdx = parseInt(event.key) - 1;
+			if (penTypeIdx >= 0 && penTypeIdx < this.penTypes.length) {
+				this.tool.setStrokeFactory(this.penTypes[penTypeIdx].factory);
+				return true;
+			}
+		}
+
+		return false;
+	}
 }