x4js 2.0.5 → 2.0.7

package/lib/src/components/colorinput/colorinput.ts

@@ -0,0 +1,88 @@
+/** 
+ *  ___  ___ __
+ *  \  \/  /  / _
+ *   \    /  /_| |_
+ *   /    \____   _|  
+ *  /__/\__\   |_|
+ * 
+ * @file colorinput.ts
+ * @author Etienne Cochard 
+ * 
+ * @copyright (c) 2024 R-libre ingenierie
+ *
+ * Use of this source code is governed by an MIT-style license 
+ * that can be found in the LICENSE file or at https://opensource.org/licenses/MIT.
+ **/
+
+import { Component } from '@core/component';
+import { isFeatureAvailable } from '@core/core_tools.js';
+import { Color } from '@core/core_colors';
+
+import { BoxProps, HBox } from '../boxes/boxes';
+import { Input } from '../input/input.js';
+import { Button } from '../button/button.js';
+
+
+import "./colorinput.module.scss"
+import icon from "./crosshairs-simple-sharp-light.svg"
+
+//TODO: add swatches
+//TODO: better keyboard handling (selection after cursor)
+
+/**
+ * 
+ */
+
+interface ColorInputProps extends BoxProps {
+	color: Color | string;
+}
+
+/**
+ * 
+ */
+
+export class ColorInput extends HBox<ColorInputProps> {
+	constructor( props: ColorInputProps ) {
+		super( props );
+
+		let swatch: Component;
+		let edit: Input;
+
+		this.setContent( [
+			swatch = new Component( { cls: "swatch" } ),
+			edit = new Input( { type: "text", value: "", spellcheck: false } ),
+
+			isFeatureAvailable("eyedropper") ? new Button( { icon: icon, click: ( ) => {
+				const eyeDropper = new (window as any).EyeDropper();
+				eyeDropper.open( ).then( ( result: any ) => {
+					color = new Color( result.sRGBHex );
+					updateColor( color );
+				});
+			} } ) : null
+		])
+
+		edit.addDOMEvent( "input", ( ) => {
+			const txt = edit.getValue( );
+			const clr = new Color( txt );
+			if( !clr.isInvalid() ) {
+				color = clr;
+				updateColor( color );
+			}
+		});
+
+		const updateColor = ( clr: Color ) => {
+			swatch.setStyleValue( "backgroundColor", clr.toRgbString(false) );
+			edit.setValue( clr.toRgbString(false) );
+		}
+
+		let color: Color;
+		if( props.color instanceof Color ) {
+			color = props.color;
+		}
+		else {
+			color = new Color( props.color );
+		}
+
+		updateColor( color );
+	}
+}

package/lib/src/components/colorinput/crosshairs-simple-sharp-light.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" fill="currentColor"><!--!Font Awesome Pro 6.6.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2024 Fonticons, Inc.--><path d="M479.4 240L384 240l-16 0 0 32 16 0 95.4 0C471.6 383 383 471.6 272 479.4l0-95.4 0-16-32 0 0 16 0 95.4C129 471.6 40.4 383 32.6 272l95.4 0 16 0 0-32-16 0-95.4 0C40.4 129 129 40.4 240 32.6l0 95.4 0 16 32 0 0-16 0-95.4C383 40.4 471.6 129 479.4 240zM256 512A256 256 0 1 0 256 0a256 256 0 1 0 0 512z"/></svg>

package/lib/src/components/colorpicker/colorpicker.module.scss

@@ -0,0 +1,133 @@
+/** 
+ *  ___  ___ __
+ *  \  \/  /  / _
+ *   \    /  /_| |_
+ *   /    \____   _|  
+ *  /__/\__\   |_|
+ * 
+ * @file colorpicker.module.scss
+ * @author Etienne Cochard 
+ * 
+ * @copyright (c) 2024 R-libre ingenierie
+ *
+ * Use of this source code is governed by an MIT-style license 
+ * that can be found in the LICENSE file or at https://opensource.org/licenses/MIT.
+ **/
+
+@use "../shared.scss";
+
+@mixin overlay-shadow {
+	width: 12px;
+	height: 12px;
+	border: 2px solid white;
+	border-radius: 8px;
+	box-shadow: 0 0 5px rgba(0, 0, 0, 0.5);
+}
+
+.x4colorpicker {
+	width: 240px;
+	gap: 4px;
+
+	touch-action: none;
+	outline: none;
+
+	margin: 8px;
+	&:focus {
+		//@include outline-focus;
+	}
+
+	.overlay {
+		position: absolute;
+		left: 0;
+		top: 0;
+		right: 0;
+		bottom: 0;
+	}
+
+	.x4saturation {
+		width: 100%;
+		
+		height: 140px;
+		position: relative;
+		
+		.thumb {
+			@include overlay-shadow;
+			position: absolute;
+			transform: translate(-50%,50%);
+		}
+	}
+
+	.body {
+		gap: 4px;
+
+		&> .x4vbox {
+			gap: 4px;
+		}
+		
+		.x4hueslider {
+			position: relative;
+			height: 16px;
+			overflow: hidden;
+			
+			background-image: linear-gradient(to right, rgb(255, 0, 0), rgb(255, 255, 0), rgb(0, 255, 0), rgb(0, 255, 212), rgb(0, 0, 255), rgb(255, 0, 255), rgb(255, 0, 0));
+			border: 1px solid var( --color-gray-3 );
+
+			.thumb {
+				@include overlay-shadow;
+				position: absolute;
+				transform: translate(-50%,-50%);
+				top: 50%;
+			}
+	
+		}
+
+		.x4alphaslider {
+			position: relative;
+			height: 16px;
+			overflow: hidden;
+
+			.checkers {
+				background-image: 	linear-gradient(45deg, #ccc 25%, transparent 25%), 
+									linear-gradient(-45deg, #ccc 25%, transparent 25%), 
+									linear-gradient(45deg, transparent 75%, #ccc 75%), 
+									linear-gradient(-45deg, transparent 75%, #ccc 75%);
+				background-size: 8px 8px;
+				background-position: 0 0, 0 20px, 20px -20px, -20px 0;
+			}
+
+			.color {
+				//border-radius: 8px;
+				background-image: linear-gradient(90deg, transparent, rgb(0, 178, 255));
+			}
+
+			.thumb {
+				@include overlay-shadow;
+
+				position: absolute;
+				transform: translate(-50%,-50%);
+				top: 50%;
+			}
+	
+		}
+
+		.swatch {
+			width: 36px;
+			height: 36px;
+
+			.checkers {
+				border-radius: 8px;
+				background-image: 	linear-gradient(45deg, #ccc 25%, transparent 25%), 
+									linear-gradient(-45deg, #ccc 25%, transparent 25%), 
+									linear-gradient(45deg, transparent 75%, #ccc 75%), 
+									linear-gradient(-45deg, transparent 75%, #ccc 75%);
+				background-size: 8px 8px;
+				background-position: 0 0, 0 20px, 20px -20px, -20px 0;
+			}
+
+			.color {
+				border-radius: 8px;
+				background-image: linear-gradient(90deg, transparent, rgb(0, 178, 255));
+			}
+		}
+	}
+}

package/lib/src/components/colorpicker/colorpicker.ts

@@ -0,0 +1,477 @@
+/** 
+ *  ___  ___ __
+ *  \  \/  /  / _
+ *   \    /  /_| |_
+ *   /    \____   _|  
+ *  /__/\__\   |_|
+ * 
+ * @file colorpicker.ts
+ * @author Etienne Cochard 
+ * 
+ * @copyright (c) 2024 R-libre ingenierie
+ *
+ * Use of this source code is governed by an MIT-style license 
+ * that can be found in the LICENSE file or at https://opensource.org/licenses/MIT.
+ **/
+
+import { Color, Hsv } from '@core/core_colors';
+import { Rect, clamp, isFeatureAvailable } from '@core/core_tools';
+
+import { Component, ComponentEvent, ComponentEvents, ComponentProps } from '@core/component';
+import { Box, BoxProps, HBox, VBox } from '../boxes/boxes';
+
+import "./colorpicker.module.scss"
+
+interface ColorPickerProps extends ComponentProps {
+	color: string | Color;
+}
+
+interface HueChangeEvent extends ComponentEvent {
+	hue: number;
+}
+
+interface AlphaChangeEvent extends ComponentEvent {
+	alpha: number;
+}
+
+interface SatChangeEvent extends ComponentEvent {
+	saturation: number;
+	value: number;
+}
+
+interface CommonEvents extends ComponentEvents {
+	hue_change: HueChangeEvent;	
+	alpha_change: AlphaChangeEvent;
+	sat_change: SatChangeEvent;	
+}
+
+/**
+ * 
+ */
+
+export class Saturation extends Box<BoxProps,CommonEvents> {
+
+	private mdown = false;
+	private irect: Rect;
+	
+	private hsv: Hsv = { hue: 1, saturation: 1, value: 1, alpha: 1 };
+
+	private color: Component;
+	private thumb: Component;
+		
+	constructor( props: BoxProps, init: Hsv ) {
+		super( props );
+
+		this.setContent( [
+			this.color = new Component( { cls: "overlay" } ),
+			new Component( { cls: "overlay", style: { backgroundImage: "linear-gradient(90deg, rgb(255, 255, 255), transparent)" } } ),
+			new Component( { cls: "overlay", style: { backgroundImage: "linear-gradient(0deg, rgb(0, 0, 0), transparent)" } } ),
+			this.thumb = new Component( { cls: "thumb" } ),
+		]);
+
+		this.setDOMEvents( {
+			pointerdown: ( e ) => this.mousedown( e ),
+			pointermove: ( e ) => this.mousemove( e ),
+			pointerup: ( e ) => this.mouseup( e ),
+			created: () => this.updateThumbMarker( ),
+		} );
+
+		this.updateBaseColor( init );
+	}
+
+	mousedown( ev: PointerEvent ) {
+		this.mdown = true;
+		this.irect = this.getBoundingRect( );
+		this.setCapture( ev.pointerId );
+	}
+
+	mousemove( ev: PointerEvent ) {
+
+		if( this.mdown ) {
+			const ir = this.irect;
+
+			let hpos = clamp(ev.clientX - ir.left, 0, ir.width );
+			let hperc = hpos / ir.width;
+
+			let vpos = clamp(ev.clientY - ir.top, 0, ir.height );
+			let vperc = vpos / ir.height;
+
+			this.hsv.saturation = hperc;
+			this.hsv.value = 1-vperc;
+			
+			this.updateThumbMarker( );
+			this.fire( "sat_change", { saturation: this.hsv.saturation, value: this.hsv.value } );
+		}
+	}
+
+	mouseup( ev: PointerEvent ) {
+		if( this.mdown ) {
+			this.releaseCapture( ev.pointerId );
+			this.mdown = false;
+		}
+	}
+
+	updateThumbMarker( ) {
+		const rc = this.color.getBoundingRect( );
+		
+		this.thumb.setStyle( { 
+			left: (this.hsv.saturation * rc.width ) + 'px',
+			bottom: ( this.hsv.value * rc.height ) + 'px'
+		} );
+	}
+
+	updateBaseColor( hsv: Hsv ) {
+		const base = new Color(0,0,0)
+		base.setHsv( hsv.hue, 1, 1, 1 );
+		this.color.setStyleValue( "backgroundColor", base.toRgbString(false) );
+	}
+
+	move( sens: string, delta: number ) {
+		switch( sens ) {
+			case 'saturation': {
+				this.hsv.saturation += delta;
+				if( this.hsv.saturation<0 ) {
+					this.hsv.saturation = 0;
+				}
+				else if( this.hsv.saturation>1 ) {
+					this.hsv.saturation = 1;
+				}
+				
+				this.fire( "sat_change", { saturation: this.hsv.saturation, value: this.hsv.value } );
+				this.updateThumbMarker( );
+				break;
+			}
+
+			case 'value': {
+				this.hsv.value += delta;
+				if( this.hsv.value<0 ) {
+					this.hsv.value = 0;
+				}
+				else if( this.hsv.value>1 ) {
+					this.hsv.value = 1;
+				}
+
+				this.fire( "sat_change", { saturation: this.hsv.saturation, value: this.hsv.value } );
+				this.updateThumbMarker( );
+				break;
+			}
+		}
+	}
+}
+
+
+
+/**
+ * 
+ */
+
+class HueSlider extends Box<BoxProps,CommonEvents> {
+
+	private thumb: Component;
+	private hsv: Hsv = { hue: 1, saturation: 1, value: 1, alpha: 1 };
+
+	private mdown = false;
+	private irect: Rect;
+
+	constructor( props: BoxProps, init: Hsv ) {
+		super( props );
+
+		this.setContent( [
+			this.thumb = new Component( { cls: "thumb", left: "50%" } ),
+		]);
+
+		this.setDOMEvents( {
+			pointerdown: ( e ) => this.mousedown( e ),
+			pointermove: ( e ) => this.mousemove( e ),
+			pointerup: ( e ) => this.mouseup( e ),
+		} );
+
+		this.updateHue( init );
+	}
+
+	mousedown( ev: PointerEvent ) {
+		this.mdown = true;
+		this.irect = this.getBoundingRect( );
+		this.setCapture( ev.pointerId );
+	}
+
+	mousemove( ev: PointerEvent ) {
+
+		if( this.mdown ) {
+			const ir = this.irect;
+
+			let hpos = clamp(ev.clientX - ir.left, 0, ir.width );
+			let hperc = hpos / ir.width;
+
+			this.hsv.hue = hperc;
+
+			this.updateHue( this.hsv );
+			this.fire( "hue_change", { hue: this.hsv.hue } );
+		}
+	}
+
+	mouseup( ev: PointerEvent ) {
+		if( this.mdown ) {
+			this.releaseCapture( ev.pointerId );
+			this.mdown = false;
+		}
+	}
+
+	updateHue( hsv: Hsv ) {
+		this.hsv.hue = hsv.hue;
+		this.thumb.setStyleValue( "left", (hsv.hue*100)+'%' );
+	}
+
+	move( delta: number ) {
+		this.hsv.hue += delta;
+		if( this.hsv.hue<0 ) {
+			this.hsv.hue = 0;
+		}
+		else if( this.hsv.hue>1 ) {
+			this.hsv.hue = 1;
+		}
+
+		this.fire( "hue_change", { hue: this.hsv.hue } );
+		this.updateHue( this.hsv );
+	}
+}
+
+
+/**
+ * 
+ */
+
+class AlphaSlider extends Box<BoxProps,CommonEvents> {
+	
+	private thumb: Component;
+	private color: Component;
+	private hsv: Hsv = { hue: 1, saturation: 1, value: 1, alpha: 1 };
+
+	private mdown = false;
+	private irect: Rect;
+	
+	constructor( props: BoxProps, init: Hsv ) {
+		super( props );
+
+		this.setContent( [
+			new Component( { cls: "overlay checkers"} ),
+			this.color = new Component( { cls: "overlay color"} ),
+			this.thumb = new Component( { cls: "thumb", left: "50%" } ),
+		]);
+
+		this.setDOMEvents( {
+			pointerdown: ( e ) => this._on_mousedown( e ),
+			pointermove: ( e ) => this._on_mousemove( e ),
+			pointerup: ( e ) => this._on_mouseup( e ),
+		} );
+
+		this.updateAlpha( );
+		this.updateBaseColor( init );
+	}
+
+	_on_mousedown( ev: PointerEvent ) {
+		this.mdown = true;
+		this.irect = this.getBoundingRect( );
+		this.setCapture( ev.pointerId );
+	}
+
+	_on_mousemove( ev: PointerEvent ) {
+
+		if( this.mdown ) {
+			const ir = this.irect;
+
+			let hpos = clamp(ev.clientX - ir.left, 0, ir.width );
+			let hperc = hpos / ir.width;
+
+			this.hsv.alpha = hperc;
+
+			this.updateAlpha( );
+			this.fire( "alpha_change", { alpha: this.hsv.alpha } );
+		}
+	}
+
+	_on_mouseup( ev: PointerEvent ) {
+		if( this.mdown ) {
+			this.releaseCapture( ev.pointerId );
+			this.mdown = false;
+		}
+	}
+
+	updateAlpha( ) {
+		this.thumb.setStyleValue( "left", (this.hsv.alpha*100)+'%' );
+	}
+
+	updateBaseColor( hsv: Hsv ) {
+		const base = new Color(0,0,0)
+		base.setHsv( hsv.hue, hsv.saturation, hsv.value, 1 );
+		this.color.setStyleValue( "backgroundImage", `linear-gradient(90deg, transparent, ${base.toRgbString(false)})` );		
+	}
+
+	setColor( hsv: Hsv ) {
+		this.hsv = hsv;
+		this.updateBaseColor( hsv );
+		this.updateAlpha( );
+	}
+
+	move( delta: number ) {
+		this.hsv.alpha += delta;
+		if( this.hsv.alpha<0 ) {
+			this.hsv.alpha = 0;
+		}
+		else if( this.hsv.alpha>1 ) {
+			this.hsv.alpha = 1;
+		}
+
+		this.fire( "alpha_change", { alpha: this.hsv.alpha } );
+		this.updateAlpha( );
+	}
+}
+
+
+/**
+ * 
+ */
+
+interface ChangeEvent extends ComponentEvent {
+	color: Color;
+}
+
+interface ColorPickerChangeEvents extends ComponentEvents {
+	change: ChangeEvent
+}
+
+/**
+ * 
+ */
+export class ColorPicker extends VBox<ColorPickerProps,ColorPickerChangeEvents> {
+
+	private _base: Color;
+	private _sat: Saturation;
+	private _swatch: Component;
+	private _hue: HueSlider;
+	private _alpha: AlphaSlider;
+
+
+	constructor( props: ColorPickerProps ) {
+		super( props );
+	
+		if( props.color instanceof Color ) {
+			this._base = props.color;
+		}
+		else {
+			this._base = new Color( props.color );
+		}
+
+		let hsv = this._base.toHsv( );
+
+		this.setAttribute( "tabindex", 0 );
+
+		this.setContent( [
+			this._sat = new Saturation( { }, hsv ),
+			new HBox( {
+				cls: "body",
+				content: [
+					new VBox( {cls: "x4flex", content: [
+						this._hue = new HueSlider( { }, hsv ),
+						this._alpha = new AlphaSlider( { }, hsv ),
+					] } ),
+					new Box( { cls: "swatch", content: [
+						new Component( { cls: "overlay checkers" } ),
+						this._swatch = new Component( { cls: "overlay" } ),
+					] } )
+				]
+			})
+		]);
+
+		this._sat.on( "sat_change", ( ev ) => {
+			hsv.saturation = ev.saturation;
+			hsv.value = ev.value;
+			updateColor( );
+			this._alpha.updateBaseColor( hsv );
+		} );
+
+		this._hue.on( 'hue_change', ( ev ) => {
+			hsv.hue = ev.hue;
+			this._sat.updateBaseColor( hsv );
+			this._alpha.updateBaseColor( hsv );
+			updateColor( );
+		} );
+
+		this._alpha.on( 'alpha_change', ( ev ) => {
+			hsv.alpha = ev.alpha;
+			updateColor( );
+		} );
+
+		const updateColor = ( ) => {
+			this._base.setHsv( hsv.hue, hsv.saturation, hsv.value, hsv.alpha );
+			this._swatch.setStyleValue( "backgroundColor", this._base.toRgbString() );
+			this._swatch.setAttribute( "tooltip", this._base.toRgbString() );
+
+			this.fire( "change", { color: this._base } );
+		}
+
+		if( isFeatureAvailable("eyedropper") ) {
+			this._swatch.addDOMEvent( "click", ( e ) => {
+				const eyeDropper = new (window as any).EyeDropper();
+				eyeDropper.open( ).then( ( result: any ) => {
+					const color = new Color( result.sRGBHex );
+					hsv = color.toHsv( );
+
+					this._alpha.setColor( hsv );
+					
+					this._sat.updateBaseColor( hsv );
+					this._hue.updateHue( hsv );
+					updateColor( );
+				});
+			})
+		}
+
+		this.addDOMEvent( "keydown", ( ev ) => this._onkey( ev ) );
+
+		updateColor( );
+	}
+
+	private _onkey( ev: KeyboardEvent ) {
+		switch( ev.key ) {
+			case "ArrowLeft": {
+				if( ev.ctrlKey ) {
+					this._hue.move( -0.01 );
+				}
+				else {
+					this._sat.move( "saturation", -0.01 );
+				}
+				break;
+			}
+
+			case "ArrowRight": {
+				if( ev.ctrlKey ) {
+					this._hue.move( 0.01 );
+				}
+				else {
+					this._sat.move( "saturation", 0.01 );
+				}
+				break;
+			}
+
+			case "ArrowUp": {
+				if( ev.ctrlKey ) {
+					this._alpha.move( 0.01 );
+				}
+				else {
+					this._sat.move( "value", 0.01 );
+				}
+				break;
+			}
+
+			case "ArrowDown": {
+				if( ev.ctrlKey ) {
+					this._alpha.move( -0.01 );
+				}
+				else {
+					this._sat.move( "value", -0.01 );
+				}
+				break;
+			}
+		}
+	}
+}