boltex / leointeg

Leo Editor Integration with VS Code

Leo for Visual Studio Code

If you find LeoInteg useful, please consider sponsoring it. Also please write a review or star it on GitHub

Literate Programming with Directed Acyclic Graphs (dag)

Break down your code into a structured outline that generates or parses back your source files

Leo is a fundamentally different way of using and organizing data, programs and scripts. 📺 Introduction Video

See Leo, the Literate Editor with Outline, at leo-editor.github.io/leo-editor or on github, and VS Code at code.visualstudio.com.

Requirements

• Leo Editor 6.7.8 or later
  Install with : pip install leo
  Or with git. (See Installing Leo with git)

• Websocket Python Library
  Install with : pip install websockets
  (See websockets.readthedocs.io/)

Features

• UI controls such as a Leo Outline in the explorer view, and as a standalone sidebar, body pane, opened documents selector along with a Log Window output channel.
• Keybindings that match those of the Leo editor, including arrow keys behavior for outline keyboard navigation. (Can be turned off with the 'Leo Tree Browsing' option setting)
• Derived files change detection. See External Files below for more details
• '@button' panel for creating your own commands with @buttons
• Find panel that reacts to Leo's typical keybindings, Ctrl+F, F2, F3... when focus is in the outline or body pane
• Nav and Tag panel controls are integrated in the Find panel
• Goto Anywhere panel to navigate directly from list of nodes, such as the results of Nav or Tag searches
• Undo History panel, showing all actions and allowing going back, or forward, to any undo states.

Leo Commands

LeoInteg offers an extensive set of integrated commands, accessible through a variety of interfaces — toolbar buttons, dedicated menus, and intuitive keybindings. Those commands are also discoverable via the Visual Studio Code Command Palette. (accessible through F1 or Ctrl+Shift+P)

Context-Aware Keybindings

The keybinding architecture is designed to be context-aware. When your focus is within the LeoInteg Body or Outline pane, LeoInteg-specific keybindings take precedence. Shift your focus outside these panes, and Visual Studio Code's native keybindings resume control.

The Minibuffer

For those familiar with Leo, the 'minibuffer' serves as the nerve center for command execution. Access it through Alt+X and use the complete set of Leo's commands!

Keybindings

Listed here are the most useful commands and their keyboard shortcuts.

Outline Commands
Undo / Redo	Ctrl + Z   /   Ctrl + Shift + Z
Insert Node	Ctrl + I   or   Shift + Insert
Insert Child	Ctrl + Insert
Edit Headline	Ctrl + H
Mark / Unmark	Ctrl + M
Copy Node	Ctrl + Shift + C
Cut Node	Ctrl + Shift + X
Paste Node	Ctrl + Shift + V
Delete Node	Ctrl + Shift + Backspace   or   Delete
Clone Node	Ctrl + Backquote
Promote / Demote	Ctrl + {   and   Ctrl + }

Moving Nodes
Move Outline Up	Ctrl + U   or   Shift [+ Alt] + Up
Move Outline Down	Ctrl + D   or   Shift [+ Alt] + Down
Move Outline Left	Ctrl + L   or   Shift [+ Alt] + Left
Move Outline Right	Ctrl + R   or   Shift [+ Alt] + Right

Move-Outline commands need the 'Alt' key modifier only when focus is on body pane.

Common Operations
Toggle Outline/Body	Ctrl + T
Focus on Body	Tab   or   Enter   or   Alt + D   or   Ctrl + G
Focus on Outline	Alt + T
Contract All	Alt + -
Sort Siblings	Alt + A
Start Search	Ctrl + F
Find Next	F3
Find Previous	F2
Replace	Ctrl + =
Replace then Find	Ctrl + -
Extract	Ctrl + Shift + D
Extract Names	Ctrl + Shift + N
Execute Script	Ctrl + B
Minibuffer Palette	Alt + X

Tree Navigation
Show the LeoInteg View	Ctrl+Shift+L
Go Anywhere	Ctrl+P
Go To First Visible Node	Home   or   Alt + Home
Go To Last Visible Node	End   or   Alt + End
Tree page up/down	PgUp / pgDn
Go To Next Clone	Alt + N
Browse Tree	Arrow Keys   or   Alt + Arrow Keys
Go To Global Line	Alt + G

With the 'Leo Tree Browsing' setting enabled by default, the arrows, home, end, pageUp/Down keys will change the outline's selection directly.

File Commands
Save Leo Document	Ctrl + S
New Leo Document	Ctrl + N
Open Leo Document	Ctrl + O
Cycle Next Document	Ctrl + Tab
Write File Nodes	Ctrl + Shift + W
Write Dirty Files	Ctrl + Shift + Q

---

Derive External Files

Use either of the Save Leo Document, Write File Nodes or Write Dirty Files commands to derive external files for any type of @file nodes.

@<file> Kind	Sentinels	@others	.leo Data	Write Only
@asis	❌	❌	✔️	✔️
@auto	❌	✔️	❌	❌
@clean	❌	✔️	✔️	❌
@edit	❌	❌	❌	❌
@file	✔️	✔️	❌	❌
@nosent	❌	✔️	✔️	✔️

Leo will detect external file changes, and will ask to either refresh from disk or ignore the changes.

Automate External Files Synchronization

The change detection process can be automated to always refresh, or ignore file changes: A notification will inform you of the action taken instead.

Extension Settings

Open the command palette Ctrl+Shift+P and start typing leo settings to access LeoInteg's welcome/settings screen

(Changes are auto-saved to the user's profile after 0.5 seconds)

• Control the visibility of the outline pane in the explorer view.
• Decide how and when to refresh and synchronize content when derived (external) file are modified.
• Show additional icons on outline nodes (Move, delete, mark, copy, paste...)
• Choose to either focus on the body pane, or keep focus in the outline when a node is selected.
• Hide or show the "Open on the side" command in the context menu to open a node beside the active editor
• Set preferences for setting the address and port, and for automatically starting, and/or connecting to a Leo server.

Server Settings

Although the Leo integration has one instance of the leoserver script per vscode 'project' window by default, the server settings also has features that allows you to use the same instance of Leo in multiple client (vscode) windows simultaneously, with real-time updates and interaction.

(See Multiple concurrent connections)

Auto Start

When auto-start is set, a vscode window will start a new instance of Leo server for itself on the next available network port. If the connection limit is set to anything above the default of one (1), then the auto-start logic will consider a port being in use as being already started and will not start another one. (Letting you connect, or auto-connect to it from any additional opened vscode window.)

The server, located in your Leo-Editor installation folder, also has other options unrelated to LeoInteg that allows you to create a stand-alone internet server for other uses such as multi-user interaction over a network/internet, and more.

Run the server directly with the '--help' argument to view all server options and capabilities:
.../leo-editor/leo/core/leoserver.py --help

For more information about the Leo server see Using leoserver.py from Leo's official documentation.

Navigating a Leo Document

Arrow keys, home/end, page up/down are used for basic navigation. But in order to find and goto specific nodes directly, use the methods described below.

Goto Anywhere Command

Normally in vscode, the the Ctrl+P shortcut allows you to switch to any project file, but when the focus is in one of Leo's panels, the Ctrl+P keybinding allows you to switch to a node directly by typing (part of) it's headline.

Find Commands

With focus in Leo's outline or body pane, Hit Ctrl+F to open the find panel.

Enter your search pattern directly in the <find pattern here> field. Press Enter to find the first match starting from your current position.

Hitting F3 repeatedly will find the subsequent matches. (F2 for previous matches)

Nav and the Goto Panel

Type your search pattern in the Nav field instead to see all results show up below in leo's Goto Pane. This will show the headlines as you type.

Press Enter to freeze the results and show results also found in body text of any node. This will add a snowflake icon ❄️ to the Nav field.

From the Goto Pane, you can use the arrow keys, home/end, page up/down to cycle directly to any of those matches.

Using Tags

If you check the Tag option, the Nav field and Goto Pane are then used to find nodes by their tag 🏷 ua (user attribute).

Undo Panel

In LeoInteg, the undo functionality is a multi-tiered system that segregates structural outline changes from text changes within the body pane. The Undo Panel captures outline alterations as individual 'Undo Beads', independent from VS Code's native text undo states. When focus resides in the body pane, the Undo keybinding triggers VS Code's text-specific undo action. However, once the focus shifts or a new node is selected, all concurrent text changes coalesce into a single 'Undo Bead' within the Undo Panel. These 'Undo Beads' can then be manipulated either through the Undo Panel or by keybindings, provided the focus is explicitly set on the outline pane. This dual-layer undo architecture enables precise control over both code and structural modifications.

Use the undo / redo icons above the outline or above the undo pane itself. You can also right-click on an undo step to directly switch to that specific state!

Issues

Common issues are listed below. See the repository's Issues Page to submit issues.

Linux Keybindings

If you're experiencing trouble with the keyboard shortcuts for the 'Clone Node' or the 'Promote' and 'Demote' commands, set "keyboard.dispatch": "keyCode" in your vscode settings and restart vscode. See Troubleshoot Linux Keybindings for more information.

Keybindings Conflicts Resolution

If you have a keybinding conflict for a command that you would like not to be resolved by Leo when the focus is on the body pane, add && resourceScheme != 'leo' to the keybinding's "when" condition. (Use Ctrl+K Ctrl+S in vscode to open the Keyboards Shortcuts panel)

Move Outline Keyboard Commands

For some users, the Alt+[Arrow Keys], Ctrl+D and Ctrl+T keybinding are already assigned.

To help with this conflict, tree-browsing, outline-move keyboard commands, and switch focus command will only trigger with the additional condition of having no text selection in the editor.

So select at least one character to use the previously assigned original keyboard commands, while focus is in the body pane.

Refer to the issue tracker page to learn more about the known issues, or to contribute with additional information if you encounter some yourself.

How It Works

Leo integration into VS Code is done by starting a python server script and connecting to it via a websocket to exchange JSON data. The server script leverages leoBridge and re-uses code from the leoflexx.py plugin.

The outline pane is made by implementing a TreeDataProvider for vscode's TreeView API, while the body-pane's virtual document is made by implementing a filesystem provider and using the outline's selected node 'gnx' as identifier.

---

Acknowledgments

Thanks to

• Edward K. Ream creator of the Leo Editor
• Eric Amodio for the welcome screen templates
• Vitalije Milošević for his contributions and support
• Arjan Mossel for his suggestions and ideas
• Thomas Passin for his contributions and support
• Viktor for his contributions and support
• Gaurami for his suggestions, bug reports and support
• Kevin Henderson for his suggestions and support
• Ville M. Vainio for his Nav tab original concept
• Jacob M. Peck for his Tags tab original concept
• Matt Wilkie for his contributions and support

---

🤍 To sponsor, donate or contribute see my user page 🦁

leointeg's Issues

Finish color syntax support for specific "@languages" to add to the current (basic) color syntax.

Currently all directives are colored appropriately (unless missed) but the @languages directives should trigger color-grammar insertions.

(until end of outline section or other @language directive)

Change the filesystem filename to something other than the gnx to style breadcrumbs

(Suggestion) For apearance of breadcrumbs:
Change the filesystem filename current method of using the GNX by a new method, to decorate the body pane tab with custom breadcrunbs.

Save and restore selection, along with cursor position when switching from node to node

Save and restore selection, along with cursor position, from selection state saved in each node (or gnx array)

Addendum: Once implemented, this can be tested by trying to run the 'execute script' command on a text selection via leo's minibuffer (alt+x) instead of (ctrl+b) or the command palette (ctrl+shift+p).

Can clise this issue after removing the internal ctrl+b execute script to use leo's own command directly like the rest of normal commands.

Add hoist/dehoist commands

Add three commands to cover all cases:

• Hoist node (via right-click/context menu)
• Hoist current selection
• Dehoist

Implement commands goto 'Prev' and 'Next' nodes as shown in Leo's top toolbar

Should be easy to do but are they a regular command(s)? or are they @buttons?

Offer treeView 'welcome content' that also offers to open settings, and other content...

Offer more options based on context, such as 'start server', 'open settings', and more informative content based on context with messages such as "Connecting..." and other messages reflecting the current state.

See https://code.visualstudio.com/api/extension-guides/tree-view#welcome-content for exact details and implementation examples.

Add a tree under the leo-outline to select opened leo documents in the 'leo-view' only.

For multiple file support : Show the currently opened files in a list under the leo outline in Leo's view panel.

Selecting one should switch to that document.

More SVG Icons and SVG code cleanup

Replace documents icons with color icons and cleanup/minify svg files

Add support for @buttons node directives. (with a simple treeview, under the other two)

List @buttons in simple treeview.

Activate the button on Leo's side when clicked.

Refresh like other panels after major operations in case there's change in the @buttons list.

Implement commands to select, expand and contract outline nodes

Some commands to select, expand and contract outline nodes could be implemented

(such as Alt-Home (goto-first-visible-node), Alt-End (goto-last-visible-node), Alt-arrow keys, ...)

See http://leoeditor.com/commands.html#selecting-outline-nodes

Add color syntax from Leo to the body pane editor

Grab the color syntax that would be applied to leo's body pane and apply it to the document editor.

Nope! too much work because no gui is running and no color-syntaxing was applied in the first place when running in leoBridge!

Instead define the same syntax as Leo to be applied to "body panes"

Upgrade leoBridge server to accept multiple connections

Make leoBridge server 'persist' through disconnects and accept multiple connections from the same user/ip for multiple vscode windows instances.

This is not 'multi-user' or 'multi-edition', instead it multi-connection for the same user at the same 'editing point' so that if leoInteg is installed in vscode for a given machine, and it's started (connected to a leobridge server) all of vscode's windows will show the same tree, body simultaneously in a synchronised manner.

(Leobridges would just run in a single 'user' & single selected 'commander' as usual, but it gives a copy of its 'json answers' on all connected websockets at once.)

This implies new functionality, such as:

• Close Leo file ( Overlaps #13 )
• Disconnect
• Kill Server

Replace vscode command for Leo's own 'Collapse all', 'Expand all' and produce Icon files

Replace icons and functionality of vscode'S collapse all treeview default button/functionality with Leo's own functions. (via leoBridge actions)

Have node selection reflect in body with arrow keys alone, instead of having to use the enter key

Suggested by @ar-jan as an unrelated idea to an other issue #32 : #32 (comment)

Could this be mimicked? ...In Leo, if arrow keys are used in the outline, the node selection is reflected instantly in the body pane. In vscode, an outline has a cursor

Q&A below:

Q: It's already the case when using the keyboard to expand/contract nodes so why not making it so too when moving the outline "cursor" ?
A: expanding and collapsing nodes have an associated event, although moving the cursor in the tree is detectable, the selection cursor is unkown as far as I know as opposed to a collapse/expand event.

Add a command 'stack' in the front end for rapidly chaining commands

Add a command 'stack' in the front end side of vscode's to support rapidly chaining commands because of nodes being sent as parameters being not valid if taken before previous commands finishes.

Add commands that use the 'marked' property of nodes

Commands that use the 'marked' property of nodes:

• copy-marked Copies all marked nodes as children of a new node.
• diff-marked-nodes
• goto-next-marked
• mark-changed-items
• mark-subheads
• unmark-all
• clone-marked-nodes
• delete-marked-nodes
• move-marked-nodes

Implement alt-x minibuffer command quick select/prompt

Should be easy, vscode has pre-made tui components for that sort of thing.

1-make a command in leobridge server to fetch list of commands to propose for a given string, (get_auto_complete)
2- open an auto complete prompt on alt-x feed it with the previous output from get_auto_complete, fetch get_auto_complete while staying open if the user adds to string.
3-Enter calls a 'run command by name' with the given string name as parameter to leobridge.

Watchout! command ran this way might summon null-GUI
calls and stuff!

Prevent panels other than outline and body from refreshing when only navigating the outline

Have a flat or state that resets after stacks of commands resolve : its useage would be to set a limit / cap what to refresh more precisely
(Prevent refreshing for documents panel and @button panel)

Show line numbers for a body pane editor relative to a derived file

Implement and offer option to show line numbers for a body pane editor relative to a derived file

Add more 'file' commands such as: 'new', 'close' and 'save as'

While having only one opened Leo file at a time, it would be nice to be able to start 'new' leo files, and / or save with a new name.

Also being able to 'close' and (re)open another Leo file would be desired.

This is different than supporting multiple opened Leo files.

Support opening leo files from explorer pane and offer 'recent files' along with auto opening

Try to add an entry in the regular explorer (right-click) files context menu if a file has extension ".leo"

(Idea given after reading Brad's comment on the google group forum about having more 'seamless' integration.)

Note: The user must have had set his leoInteg settings correctly to automatically "start server" and "connect to server" and optionally 'python command' launch string at minimum for any of the smooth integration to even make sense in the first place.

Slugish/extraneous outline refreshes when changing by selecting a different body pane, or when switching treeview

Outline seems to refresh (slight flash of side lines of expanded parent nodes), in a slugish manner twice, or even thrice, when coming back from an automatic change of outline-node selection caused by using a different body pane. (a body pane from a node of a different gnx).

It is also the case when refreshing the tree because of a change in active leo outline treeviews in vscode's workspace (switching between file explorer and standalone outline).

On the other hand, it seems to refresh perfectly when coming back from a node operation like move, insert and other outline edition commands! So it's probably the order and chaining of operations performed when trying to refresn in those instances, and/or the node parameter chosen as target of the 'reveal' function call(s).

• Idea: Maybe the matching node in the gnxToLeonode array needs to be refreshed before being used as parameter of the reveal function...

Add keyboard shortcut for collapse all

In leo the shortcut is Alt+-

Body edition broken with Leo 6.2 (works with 6.1 final)

Tested on both windows and linux (ubuntu 18.04) : broken in 6.2 but works when Leo reverted to 6.1 final.

Add "Search in leo outline" functionality

Along with "prev", "next" controls, etc.

Some commands do not support 'Undo'

This can be fixed by altering only leobridgeserver.py (from editing its leo file: leoInteg.leo)

UNDO operation works with outline changes such as move node commands, but some others (insert node, rename node and maybe others..) seem to need to set an 'undo' restore point when being executed.

See class Undoer in leoUndo.py from Leo's sources for relevant methods to be called for this fix.

Handle async messages initiated by Leo (for derived file changes, log pane entries, etc.)

As of now only the answers from commands initiated by the user are acted upon. Handle asynchronous messages initiated by leo.

Needed for feeding the log pane and asking permission to update derived files.

Note: React to file changes and other events, see
leo-editor/leo-editor#1281 (comment)

Show todo tasks unknown attributes under nodes in the outline

Pass p.v.u in archived positions, discard it on reception as to not have this weight in 'apJson' that is used on the way back when ap's are sent back as parameters in Leo commands.

i,e, when right clicking on a particular node to issue a command and not use the 'currently selected node'.

Problem starting the leo-bridge server automatically with anaconda/miniconda on windows

Hi, it looks like you've been making great and steady progress over the last several months. Awesome! I just tried out the dev branch and I'v run into a problem loading the extension. I've installed all dependencies etc as described. Actually the first time I ran F5 to run the extension a welcome screen with Leo icon did appear, but I'd already clicked a VSCode message about window loading taking longer than 10 seconds, and trying a reload. Now I don't see the Leo welcome anymore.

When I click the "Connect to Leo Bridge server" icon in the Leo tab, I get Leo Bridge Connection Failed.

The terminal in the original window says this:

Executing task: npm run webpack <

[email protected] webpack C:\Programs\leointeg
webpack --mode development

Starting type checking service...
Using 1 worker with 2048MB memory limit
Child
Hash: f72f38eb55e39ace8f04
Version: webpack 4.41.2
Time: 3915ms
Built at: 01/12/2020 16:35:25
Asset Size Chunks Chunk Names
extension.js 271 KiB main [emitted] main
extension.js.map 357 KiB main [emitted] [dev] main
Entrypoint main = extension.js extension.js.map
[./src/constants.ts] 1.12 KiB {main} [built]
[./src/eamodioEditorManager/activeEditorTracker.ts] 3.56 KiB {main} [built]
[./src/eamodioEditorManager/comparers.ts] 1.6 KiB {main} [built]
[./src/eamodioEditorManager/documentManager.ts] 10.3 KiB {main} [built]
[./src/extension.ts] 12.1 KiB {main} [built]
[./src/leoBody.ts] 9.48 KiB {main} [built]
[./src/leoBridge.ts] 5.09 KiB {main} [built]
[./src/leoFiles.ts] 2.13 KiB {main} [built]
[./src/leoIntegration.ts] 53.2 KiB {main} [built]
[./src/leoNode.ts] 2.26 KiB {main} [built]
[./src/leoOutline.ts] 2.24 KiB {main} [built]
[./src/serverService.ts] 3.2 KiB {main} [built]
[./src/webviews/leoSettingsWebview.ts] 4.18 KiB {main} [built]
[path] external "path" 42 bytes {main} [built]
[vscode] external "vscode" 42 bytes {main} [built]
+ 27 hidden modules

WARNING in ./node_modules/ws/lib/buffer-util.js
Module not found: Error: Can't resolve 'bufferutil' in 'C:\Programs\leointeg\node_modules\ws\lib'
 @ ./node_modules/ws/lib/buffer-util.js
 @ ./node_modules/ws/lib/receiver.js
 @ ./node_modules/ws/index.js
 @ ./src/leoBridge.ts
 @ ./src/leoIntegration.ts
 @ ./src/extension.ts

WARNING in ./node_modules/ws/lib/validation.js
Module not found: Error: Can't resolve 'utf-8-validate' in 'C:\Programs\leointeg\node_modules\ws\lib'
 @ ./node_modules/ws/lib/validation.js
 @ ./node_modules/ws/lib/receiver.js
 @ ./node_modules/ws/index.js
 @ ./src/leoBridge.ts
 @ ./src/leoIntegration.ts
 @ ./src/extension.ts

Child
Time: 3904ms
Built at: 01/12/2020 16:35:25
Asset Size Chunks Chunk Names
main-styles.css 27.9 KiB main-styles [emitted] main-styles
main-styles.js 4.48 KiB main-styles [emitted] main-styles
settings.html 14.7 KiB [emitted]
settings.js 59.9 KiB settings [emitted] settings

Terminal will be reused by tasks, press any key to close it.

And the debug console says:

(node:11832) [DEP0005] DeprecationWarning: Buffer() is deprecated due to security and usability issues. Please use the Buffer.alloc(), Buffer.allocUnsafe(), or Buffer.from() methods instead.
warning.js:27
(node:11832) [DEP0005] DeprecationWarning: Buffer() is deprecated due to security and usability issues. Please use the Buffer.alloc(), Buffer.allocUnsafe(), or Buffer.from() methods instead.
warning.js:27
Launch with default command : py -3 c:\Programs\leointeg/leobridgeserver.py
extension.js:7226
leoInteg startup launched in 6 ms
extension.js:5532
websocket error: connect ECONNREFUSED 127.0.0.1:32125
extension.js:5921
websocket closed, code: 1006
extension.js:5925
websocket error: connect ECONNREFUSED 127.0.0.1:32125
extension.js:5921
websocket closed, code: 1006

I do have websockets installed in my default Python environment (which is an Anaconda env, Python 3.7.3). Any way to check if leointeg is using the correct Python environment? Also npm install from within VSCode terminal says all packages are installed. echo %PYTHONPATH% gives C:\Programs\Leo (correct). I'm on Windows 10. Leo is at version 6.0-final.

Any ideas to debug this further?

Remove multiple bodies editing feature: focusing them can't "reveal" hidden nodes properly

It is not possible in vscode, to properly 'reveal' a node that is hidden (child of collapsed node are, by definition, not visible) when his siblings have the exact same headline label, or are clones.

The first one of the repeated headline label will be selected regardeless. This otherwise works fine if the node is already 'visible'. (This is because if it's visible it has been created as a specific node instance of the treeview. vscode seems then to be able to handle this because it can somehow be pointed to specifically when revealing)

So to counter this, change the behavior to mimic exactly Leo: Colapsing or expanging a node should also select it. So that it is impossible to have a selected node that is invisible (hidden inside its collapsed parent).

Most importantly, modify the 'open aside' feature, so that it selects the chosen node first, then opens it. So only ONE body pane is opened at a time, altough still "duplicatable" in many panels so that "split view" will still be possible. This change will remove the "more than one body opened at the same time".

This simplification will ultimately help a lot in the short and middle terms. It will also help with other problematic features such as closing opened bodies of 'expired gnxs' (e.g. after deletion of tree branches), 'hoist/dehoist' commands and many other.

Add clone-find commands

Commands that move clones of all nodes matching the search pattern under a single organizer node, created as the last top-level node:

• cfa clone-find-all
• cff clone-find-all-flattened (Flattened searches put all nodes as direct children of the organizer node)

'Clone-marked' commands that move clones of all marked nodes under an organizer node:

• cfam clone-find-marked
• cffm clone-find-flattened-marked

Offer 'Real Clipboard' operations, instead of leo's 'internal' clipboard behavior

Offer 'Real Clipboard' operations, instead of leo's 'internal' clipboard behavior

Use globals.gui.clipboard and the real clipboard with g.app.gui.getTextFromClipboard()

For pasting, use g.app.gui.replaceClipboardWith(p_realClipboard)

Force redraw/refresh for icons to update in the outline after a configuration change

Try to refresh the outline somehow when the interface-related settings are changed.

Related : Add to documentation / readme the details about the debounced auso-save after 0.5 seconds

Implement 'Extract' and 'Extract Name' commands

See the 'execute script' command as an example on how to get the selection when a command is issued in order to implement the 'Extract' and 'Extract Name' commands.

Status Bar indicator misses last editor closing detection.

Indicator stays 'on' when the last editor is closed and focus falls in the 'empty' zone.

Body pane filesystem : fix timing and transition to get rid of vscode errors in debug console when de-hoisting/changing documents.

(Does not seem to affect rendering / usage )

Providers for treeview, and provider for body pane filesystem should handle transitions from a document to the next, or hoisting/dehoisting without generating warnings/errors in vscode's debug console.

Try to cleanup last opened-gnx transition to a new one. Also try to cleanup the tree-refresh cycle after de-hoisting/changeing leo file.

Add command-buttons in more views and context menus, & add config options to choose which command to show/hide for each location

Offer command icons to perform leointeg's actions in more views and context menus (Currently only The View title menu - view/title and The View item menu - view/item/context are used so far):

Also offer settings to hide/show them individually.

Such as those three common ones ("when" clause : filesystem-scheme is 'leo' to limit to leo bodies):

• The editor title menu bar - editor/title
• The editor title context menu - editor/title/context
• The editor context menu - editor/context

see https://code.visualstudio.com/api/references/contribution-points#contributes.menus for complete list of menus into which to place command-buttons/icons.

Could the body pane automatically follow the selected node in the outline (as in Leo)? And support for unified outline&bodies tree/pane?

An idea that has come up several times over the years on Leo's mailing list is the possibility to have a combined view of the outline and node bodies, with the body of each node rendered inline, and both headlines and node bodies being editable inside this unified tree.

A major advantage compared to the current situation is that this would make it possible to see the contents of the preceding and following nodes while working on a particular node's body. This would significantly reduce the need to keep track in your mind of what's what, and also allow you to scroll through a large document as with regular editors (while keeping Leo's advantages of organizing with nodes, clones, etc.).

Is this something that could be done in leointeg / VSCode?

Convert documentation comments to tsDoc standard

Convert documentation comments to tsDoc standard: See https://github.com/microsoft/tsdoc

Show preview overlay in settings webview for the statusbar label and/or color

In welcome/settings webview: similar to hover commands interface preview. When the config changes, have the text be previewed over the png background of the statusbar, along with switching to the appropriate color.

Change behavior of body replacement on actions/commands instead of 500ms timer after first change

Whem detecting body changes, debounce, still offer quick 'first modif' reaction of icon apearance, also maybe keep in a temp body variable, but only send to leo before acting on someting else (starting another action, or command) rather than on 500ms timer.

Use menu enablers to disable relevant icons

Use 'Menu enablers' ("c.Menu Enablers" in leoCommands.py) to get states and availability of various interface items.

Handle text selection states & enable commands like "Run Script" (ctrl+B with selected text) "Extract" and "Extract Name"

Handle text selection / cursor position. Also useful for sending to leo and to restore back when selecting other nodes.

This will make it possible to get some useful parameters for commands such as 'Extract' and 'Extract Name'.

"Execute Script" should also use selection instead of outline if any.

Make commands leave the cursor and focus in appropriate place with 'when clause' context

Convert commands definitions in package.json to split from commands called while focus in text editor vs outline tree.

See https://code.visualstudio.com/docs/getstarted/keybindings#_when-clause-contexts

and

https://stackoverflow.com/questions/57038025/vscode-keep-focus-in-folders-panel-after-selecting-a-file for example of detecting and differenciating location of focus for commands.

Bring back old way of keeping all gnx in body provider

The new way of browsing the tree may have vscode ask for any body pane stats and contents before it was actually selected in the tree.

Support multiple simultaneous opened leo files

Leo has tabs to offer choice between multiple opened Leo files, it would be useful to offer a way to have the same capability. (through someting other than tabs)

Maybe a menu openable through the status bar indicator or other items in the dropdown in the outline's titlebar.

Use the 'reveal' function after tree refresh when coming back from 'move node' operation

'Full refresh' is not 'full' enough! 😠

'Move Right' gets inside its parent node as expected from this operation, but the parent node stays collapsed so a 'reveal' call would be required it seems.

Status Bar Indicator: show the name of currently opened Leo file and offer to switch upon click

Only makes sense of muliple opened files support is implemented: Could be merged with #13

Have CTRL+S on body pane save the Leo file instead/along with the body pane in the 'gnx' filesystem

Make saving more natural by binding ctrl+s to the leo save instead/on top of the vscode's regular save of the edited document into it's filesystem scheme.

Status bar color and text should be a configuration settings

Status bar flag for leo keybinds should offer configurable text, color, placement etc.

On the dev branch, commit 6288f23 Makes the color (hex) and string customizable. Up to 8 character long.

Configuration for left/right placement would be nice.

Color chooser instead of a text input for the hex string color would be nice too!