step selection after drop.

Author: b4rtaz

src/behaviors/drag-step-behavior.ts

@@ -81,6 +81,7 @@ export class DragStepBehavior implements Behavior {
 				);
 			} else {
 				SequenceModifier.insertStep(this.step, this.currentPlaceholder.parentSequence, this.currentPlaceholder.index);
+				this.context.setSelectedStep(this.step);
 			}
 			this.context.notifiyDefinitionChanged();
 		} else {

src/core/simple-event-race.spec.ts

@@ -0,0 +1,43 @@
+import { SimpleEvent } from './simple-event';
+import { race } from './simple-event-race';
+
+describe('race', () => {
+	let a: SimpleEvent<number>;
+	let b: SimpleEvent<number>;
+
+	beforeEach(() => {
+		a = new SimpleEvent<number>();
+		b = new SimpleEvent<number>();
+	});
+
+	it('joins two events', done => {
+		race(0, a, b).subscribe(r => {
+			expect(r[0]).toEqual(0x128);
+			expect(r[1]).toEqual(0x256);
+			done();
+		});
+
+		a.forward(0x128);
+		b.forward(0x256);
+	});
+
+	it('forwards first event only', done => {
+		race(0, a, b).subscribe(r => {
+			expect(r[0]).toEqual(0x128);
+			expect(r[1]).toBeUndefined();
+			done();
+		});
+
+		a.forward(0x128);
+	});
+
+	it('forwards second event only', done => {
+		race(0, a, b).subscribe(r => {
+			expect(r[0]).toBeUndefined();
+			expect(r[1]).toEqual(0x256);
+			done();
+		});
+
+		b.forward(0x256);
+	});
+});

src/core/simple-event-race.ts

@@ -0,0 +1,32 @@
+import { SimpleEvent } from './simple-event';
+
+export function race<A, B>(timeout: number, a: SimpleEvent<A>, b: SimpleEvent<B>): SimpleEvent<[A?, B?]> {
+	const value: [A?, B?] = [undefined, undefined];
+	const result = new SimpleEvent<[A?, B?]>();
+	let scheduled = false;
+
+	function forward() {
+		if (scheduled) {
+			return;
+		}
+		scheduled = true;
+		setTimeout(() => {
+			try {
+				result.forward(value);
+			} finally {
+				scheduled = false;
+				value.fill(undefined);
+			}
+		}, timeout);
+	}
+
+	[a, b]
+		.filter(e => e)
+		.forEach((e, index) => {
+			e.subscribe(v => {
+				value[index] = v;
+				forward();
+			});
+		});
+	return result;
+}

src/designer-context.ts

@@ -18,7 +18,7 @@ export class DesignerContext {
 	public readonly onIsMoveModeEnabledChanged = new SimpleEvent<boolean>();
 	public readonly onIsToolboxCollapsedChanged = new SimpleEvent<boolean>();
 	public readonly onIsSmartEditorCollapsedChanged = new SimpleEvent<boolean>();
-	public readonly onDefinitionChanged = new SimpleEvent<void>();
+	public readonly onDefinitionChanged = new SimpleEvent<Definition>();
 
 	public viewPort: ViewPort = {
 		position: new Vector(0, 0),
@@ -135,7 +135,7 @@ export class DesignerContext {
 	}
 
 	public notifiyDefinitionChanged() {
-		this.onDefinitionChanged.forward();
+		this.onDefinitionChanged.forward(this.definition);
 	}
 
 	public getPlacehodlers(): Placeholder[] {

src/designer.ts

@@ -18,7 +18,7 @@ export default class Designer {
 
 		const view = DesignerView.create(parent, context, configuration);
 		const designer = new Designer(view, context);
-		context.onDefinitionChanged.subscribe(() => designer.onDefinitionChanged.forward(context.definition));
+		context.onDefinitionChanged.subscribe(d => designer.onDefinitionChanged.forward(d));
 		return designer;
 	}
 

src/workspace/workspace.ts

@@ -1,5 +1,6 @@
 import { MoveViewPortBehavior } from '../behaviors/move-view-port-behavior';
 import { SelectStepBehavior } from '../behaviors/select-step-behavior';
+import { race } from '../core/simple-event-race';
 import { Vector } from '../core/vector';
 import { Step } from '../definition';
 import { DesignerComponentProvider, DesignerContext, ViewPort } from '../designer-context';
@@ -21,12 +22,19 @@ export class Workspace implements DesignerComponentProvider {
 		});
 
 		context.setProvider(workspace);
-		context.onDefinitionChanged.subscribe(() => workspace.render());
 		context.onViewPortChanged.subscribe(vp => workspace.onViewPortChanged(vp));
-		context.onSelectedStepChanged.subscribe(s => workspace.onSelectedStepChanged(s));
 		context.onIsDraggingChanged.subscribe(i => workspace.onIsDraggingChanged(i));
 		context.onIsSmartEditorCollapsedChanged.subscribe(() => workspace.onIsSmartEditorCollapsedChanged());
 
+		race(0, context.onDefinitionChanged, context.onSelectedStepChanged).subscribe(v => {
+			const [definiton, selectedStep] = v;
+			if (definiton) {
+				workspace.render();
+			} else if (selectedStep !== undefined) {
+				workspace.onSelectedStepChanged(selectedStep);
+			}
+		});
+
 		view.bindMouseDown((p, t, b) => workspace.onMouseDown(p, t, b));
 		view.bindTouchStart(e => workspace.onTouchStart(e));
 		view.bindWheel(e => workspace.onWheel(e));
@@ -157,9 +165,10 @@ export class Workspace implements DesignerComponentProvider {
 		}
 		if (step) {
 			this.selectedStepComponent = this.getRootComponent().findById(step.id);
-			if (this.selectedStepComponent) {
-				this.selectedStepComponent.setState(StepComponentState.selected);
+			if (!this.selectedStepComponent) {
+				throw new Error(`Cannot find a step component by id ${step.id}`);
 			}
+			this.selectedStepComponent.setState(StepComponentState.selected);
 		}
 	}