lexgui 0.6.7 → 0.6.9

package/build/components/codeeditor.js

@@ -756,31 +756,43 @@ class CodeEditor {
             let idx = firstNonspaceIndex( this.code.lines[ ln ] );
 
             // We already are in the first non space index...
-            if(idx == cursor.position) idx = 0;
+            if( idx == cursor.position ) idx = 0;
 
             const prestring = this.code.lines[ ln ].substring( 0, idx );
             let lastX = cursor.position;
 
             this.resetCursorPos( CodeEditor.CURSOR_LEFT, cursor );
-            if(idx > 0)
+            if( idx > 0 )
+            {
                 this.cursorToString( cursor, prestring );
-            this.setScrollLeft( 0 );
+            }
+            else
+            {
+                // No spaces, start from char 0
+                idx = 0;
+            }
 
-            // Merge cursors
+            this.setScrollLeft( 0 );
             this.mergeCursors( ln );
 
             if( e.shiftKey && !e.cancelShift )
             {
                 // Get last selection range
                 if( cursor.selection )
+                {
                     lastX += cursor.selection.chars;
+                }
 
                 if( !cursor.selection )
+                {
                     this.startSelection( cursor );
+                }
 
                 var string = this.code.lines[ ln ].substring( idx, lastX );
                 if( cursor.selection.sameLine() )
+                {
                     cursor.selection.selectInline( cursor, idx, cursor.line, this.measureString( string ) );
+                }
                 else
                 {
                     this._processSelection( cursor, e );
@@ -1666,14 +1678,16 @@ class CodeEditor {
         }
 
         this._removeSecondaryCursors();
-        var cursor = this._getCurrentCursor( true );
 
+        var cursor = this._getCurrentCursor( true );
         this.saveCursor( cursor, this.code.cursorState );
-
         this.code = this.loadedTabs[ name ];
         this.restoreCursor( cursor, this.code.cursorState );
 
         this.endSelection();
+
+        this.hideAutoCompleteBox();
+
         this._updateDataInfoPanel( "@tab-name", name );
 
         if( this.code.languageOverride )
@@ -2220,6 +2234,14 @@ class CodeEditor {
         return;
 
         const key = e.key ?? e.detail.key;
+
+        // Do not propagate "space to scroll" event
+        if( key == ' ' )
+        {
+            e.preventDefault();
+            e.stopPropagation();
+        }
+
         const target = e.detail.targetCursor;
 
         // Global keys
@@ -2359,7 +2381,9 @@ class CodeEditor {
 
         // keys with length > 1 are probably special keys
         if( key.length > 1 && this.specialKeys.indexOf( key ) == -1 )
+        {
             return;
+        }
 
         let lidx = cursor.line;
         this.code.lines[ lidx ] = this.code.lines[ lidx ] ?? "";
@@ -2545,11 +2569,11 @@ class CodeEditor {
 
     async _copyContent( cursor ) {
 
-        let text_to_copy = "";
+        let textToCopy = "";
 
         if( !cursor.selection )
         {
-            text_to_copy = "\n" + this.code.lines[ cursor.line ];
+            textToCopy = "\n" + this.code.lines[ cursor.line ];
         }
         else
         {
@@ -2569,27 +2593,30 @@ class CodeEditor {
             const num_chars = cursor.selection.chars + ( cursor.selection.toY - cursor.selection.fromY ) * separator.length;
             const text = code.substr( index, num_chars );
             const lines = text.split( separator );
-            text_to_copy = lines.join('\n');
+            textToCopy = lines.join('\n');
         }
 
-        navigator.clipboard.writeText( text_to_copy ).then(() => console.log("Successfully copied"), (err) => console.error("Error"));
+        navigator.clipboard.writeText( textToCopy );
+            // .then(() => console.log("Successfully copied"), (err) => console.error("Error"));
     }
 
     async _cutContent( cursor ) {
 
         let lidx = cursor.line;
-        let text_to_cut = "";
+        let textToCut = "";
 
         this._addUndoStep( cursor, true );
 
         if( !cursor.selection )
         {
-            text_to_cut = "\n" + this.code.lines[ cursor.line ];
+            textToCut = "\n" + this.code.lines[ cursor.line ];
             this.code.lines.splice( lidx, 1 );
             this.processLines();
             this.resetCursorPos( CodeEditor.CURSOR_LEFT, cursor );
             if( this.code.lines[ lidx ] == undefined )
+            {
                 this.lineUp( cursor );
+            }
         }
         else
         {
@@ -2597,24 +2624,27 @@ class CodeEditor {
             if( cursor.selection ) cursor.selection.invertIfNecessary();
 
             const separator = "_NEWLINE_";
-            let code = this.code.lines.join(separator);
+            let code = this.code.lines.join( separator );
 
             // Get linear start index
             let index = 0;
 
-            for(let i = 0; i <= cursor.selection.fromY; i++)
+            for( let i = 0; i <= cursor.selection.fromY; i++ )
+            {
                 index += (i == cursor.selection.fromY ? cursor.selection.fromX : this.code.lines[ i ].length);
+            }
 
             index += cursor.selection.fromY * separator.length;
-            const num_chars = cursor.selection.chars + (cursor.selection.toY - cursor.selection.fromY) * separator.length;
-            const text = code.substr(index, num_chars);
-            const lines = text.split(separator);
-            text_to_cut = lines.join('\n');
+            const numChars = cursor.selection.chars + (cursor.selection.toY - cursor.selection.fromY) * separator.length;
+            const text = code.substr( index, numChars );
+            const lines = text.split( separator );
+            textToCut = lines.join('\n');
 
             this.deleteSelection( cursor );
         }
 
-        navigator.clipboard.writeText( text_to_cut ).then(() => console.log("Successfully cut"), (err) => console.error("Error"));
+        navigator.clipboard.writeText( textToCut );
+            // .then(() => console.log("Successfully cut"), (err) => console.error("Error"));
     }
 
     _duplicateLine( lidx, cursor ) {

package/build/components/timeline.js

@@ -2633,7 +2633,7 @@ class KeyFramesTimeline extends Timeline {
      * 
      * @param {int} trackIdx 
      * @param {array} newValues array of values for each keyframe. It should be a flat array of size track.dim*numKeyframes. Check ADDKEY_VALUESINARRAYS flag
-     * @param {array of numbers} newTimes 
+     * @param {array of numbers} newTimes must be ordered ascendently
      * @param {number} timeOffset 
      * @param {int} flags     
      *      KeyFramesTimeline.ADDKEY_VALUESINARRAYS: if set, newValues is an array of arrays, one for each entry [ [1,2,3], [5,6,7] ]. Times is still a flat array of values [ 0, 0.2 ]
@@ -2656,8 +2656,7 @@ class KeyFramesTimeline extends Timeline {
 
         let newIdx = newTimes.length-1;
         let oldIdx = trackTimes.length-1;
-
-        let t1 = performance.now();
+        let resultIndices = [];
         if ( KeyFramesTimeline.ADDKEY_VALUESINARRAYS & flags ){
             
             for( let i = times.length-1; i > -1; --i ){
@@ -2672,6 +2671,8 @@ class KeyFramesTimeline extends Timeline {
                     track.hovered.splice(oldIdx+1, 0, false);
                     track.selected.splice(oldIdx+1, 0, false);
                     track.edited.splice(oldIdx+1, 0, true);
+
+                    resultIndices.push(i);
                     continue;
                 }
                 
@@ -2695,6 +2696,8 @@ class KeyFramesTimeline extends Timeline {
                     track.hovered.splice(oldIdx+1, 0, false);
                     track.selected.splice(oldIdx+1, 0, false);
                     track.edited.splice(oldIdx+1, 0, true);
+
+                    resultIndices.push(i);
                     continue;
                 }
                 
@@ -2715,8 +2718,11 @@ class KeyFramesTimeline extends Timeline {
             this.setDuration(newTimes[newTimes.length - 1] + timeOffset);
         }
 
-        if(this.onUpdateTrack)
+        if(this.onUpdateTrack){
             this.onUpdateTrack( [trackIdx] );
+        }
+
+        return resultIndices;
     }
 
     deleteSelectedContent(skipCallback = false) {
@@ -3099,6 +3105,7 @@ class ClipsTimeline extends Timeline {
     setAnimationClip( animation, needsToProcess ){
         super.setAnimationClip(animation, needsToProcess);
         this.changeSelectedItems();
+        return this.animationClip;
     }
 
     // OVERRIDE
@@ -3297,10 +3304,10 @@ class ClipsTimeline extends Timeline {
                 const track = this.animationClip.tracks[this.lastClipsSelected[0][0]]; 
                 let clip = track.clips[this.lastClipsSelected[0][1]];
                 if( this.dragClipMode == "fadein" ) {
-                    clip.fadein = Math.min(Math.max(clip.fadein + delta, clip.start), clip.fadeout);
+                    clip.fadein = Math.min(Math.max(clip.fadein + delta, clip.start), clip.fadeout ?? (clip.start+clip.duration) );
                 }
                 else if( this.dragClipMode == "fadeout" ) {
-                    clip.fadeout = Math.max(Math.min(clip.fadeout + delta, clip.start+clip.duration), clip.fadein);
+                    clip.fadeout = Math.max(Math.min(clip.fadeout + delta, clip.start+clip.duration), clip.fadein ?? clip.start );
                 }
                 else if( this.dragClipMode == "duration" ) {
                     let duration = Math.max(0, clip.duration + delta);
@@ -3715,7 +3722,7 @@ class ClipsTimeline extends Timeline {
                     const fadeinX = this.pixelsPerSecond * (clip.fadein - clip.start);
                     ctx.roundRect(x, y + offset, fadeinX, trackHeight, {tl: 5, bl: 5, tr:0, br:0}, true);
                 }
-                if ( clip.fadein != undefined ){
+                if ( clip.fadeout != undefined ){
                     const fadeoutX = this.pixelsPerSecond * (clip.start + clip.duration - (clip.fadeout));
                     ctx.roundRect( x + w - fadeoutX, y + offset, fadeoutX, trackHeight, {tl: 0, bl: 0, tr:5, br:5}, true);
                 }

package/build/lexgui.css

@@ -1889,7 +1889,7 @@ dialog .lexselect .lexselectoptions {
 
 .lexselect .lexselectlabel {
     width: 100%;
-    color: var(--global-text-secondary);
+    color: var(--global-text-tertiary);
     padding-inline: 0.6rem;
     padding-block: 0.2rem;
     min-height: 20px;
@@ -2966,6 +2966,10 @@ meter:-moz-meter-sub-sub-optimum::-moz-meter-bar {
     font-size: var(--global-font-size-lg);
 }
 
+.lexmenubar .lexmenubuttons.left {
+    margin-left: unset;
+}
+
 .lexmenubar .lexmenubuttons.right {
     margin-left: unset;
     margin-right: 12px;
@@ -3565,6 +3569,20 @@ meter:-moz-meter-sub-sub-optimum::-moz-meter-bar {
     margin-right: 0px;
 }
 
+.lexoverlayseparator {
+    background-color: var(--global-color-tertiary);
+    opacity: 0.9;
+    width: 2px;
+    height: calc(100% + 0.5em);
+    margin-top: -0.25em;
+}
+
+.lexoverlaybuttonscontainer.vertical .lexoverlayseparator {
+    width: calc(100% + 0.5em);
+    height: 2px;
+    margin-left: -0.25em;
+}
+
 /* Area Tabs */
 
 .lexareatabs {
@@ -3835,10 +3853,9 @@ meter:-moz-meter-sub-sub-optimum::-moz-meter-bar {
 .lexwidget:has(.lextogglesubmenu),
 .lexwidget:has(.lexcustomcontainer) {
     border-radius: 6px;
-    display: grid;
-    grid-template-columns: repeat(2, 1fr);
-    grid-template-rows: auto auto;
     transition: background-color 0.2s ease-out;
+    display: flex;
+    flex-wrap: wrap;
 }
 
 .lexwidget:has(.lexarrayitems)[data-opened=true],
@@ -3995,6 +4012,11 @@ meter:-moz-meter-sub-sub-optimum::-moz-meter-bar {
     align-content: center;
 }
 
+.lextable td.empty-row {
+    text-align: center;
+    padding-block: 16px;
+}
+
 .lextable th {
     --th-color: var(--global-text-secondary);
     font-weight: 600;
@@ -4102,7 +4124,7 @@ meter:-moz-meter-sub-sub-optimum::-moz-meter-bar {
     grid-column: span 2;
 }
 
-.lexcustomcontainer span {
+.lexcustomcontainer button.custom span {
     align-items: center;
     display: flex;
     justify-content: space-between;