fix: clean up GTK/WebKit integration and event handling

- fix split pane expansion/orientation setup logic
- remove deferred pane positioning on show events
- load VTE with interactive bash rcfile
- migrate WebKit2 bindings from 4.0 to 4.1
- add icons path accessor to PathManager
- normalize startup IPC file event payloads with FILE| prefix
- alias App_Event_Types and update plugin event references
- guard widget registry against unnamed builder objects
- fix application_dirs home path lookup
- remove unused GLib import from completion controller
- reorder setproctitle import in __main__

plugins/code/commands/nanoesq_temp_buffer/cut_to_temp_buffer.py

@@ -14,31 +14,44 @@ from .helpers import clear_temp_cut_buffer_delayed, set_temp_cut_buffer_delayed
 
 class Handler:
     @staticmethod
-    def execute(
+    def execute(view: GtkSource.View, *args, **kwargs):
-        view: GtkSource.View,
-        *args,
-        **kwargs
-    ):
         logger.debug("Command: Cut to Temp Buffer")
 
         clear_temp_cut_buffer_delayed(view)
 
         buffer = view.get_buffer()
-        itr = buffer.get_iter_at_mark(buffer.get_insert())
 
-        start_itr = itr.copy()
+        if buffer.get_has_selection():
-        start_itr.set_line_offset(0)
+            start_itr, end_itr = buffer.get_selection_bounds()
 
-        end_itr = start_itr.copy()
+            start_itr.set_line_offset(0)
-        if not end_itr.forward_line():
+
-            end_itr = buffer.get_end_iter()
+            if not end_itr.ends_line():
+                end_itr.forward_to_line_end()
+
+            if not end_itr.is_end():
+                end_itr.forward_char()
+        else:
+            itr = buffer.get_iter_at_mark(buffer.get_insert())
+
+            start_itr = itr.copy()
+            start_itr.set_line_offset(0)
+
+            end_itr = start_itr.copy()
+            if not end_itr.forward_line():
+                end_itr = buffer.get_end_iter()
 
         if not hasattr(view, "_cut_buffer"):
             view._cut_buffer = ""
 
-        line_str = buffer.get_text(start_itr, end_itr, True)
+        text = buffer.get_text(start_itr, end_itr, True)
-        view._cut_buffer += line_str
+
+        if not text.endswith("\n"):
+            text += "\n"
+
+        view._cut_buffer += text
 
         buffer.delete(start_itr, end_itr)
+        buffer.place_cursor(start_itr)
 
         set_temp_cut_buffer_delayed(view)

plugins/code/commands/split_pane/close_split_view.py

@@ -16,6 +16,19 @@ from libs.event_factory import Event_Factory, Code_Event_Types
 
 emit_to: callable = None
 
+def get_source_view(widget):
+    if isinstance(widget, GtkSource.View):
+        return widget
+
+    if isinstance(widget, Gtk.ScrolledWindow):
+        return widget.get_child()
+
+    if isinstance(widget, Gtk.Paned):
+        return get_source_view(widget.get_child1())
+
+    return None
+
+
 def execute(
     source_view,
     char_str,
@@ -39,7 +52,7 @@ def execute(
         remaining    = source_view1
         closing_view = source_view
 
-    remaining_view = remaining.get_child()
+    remaining_view = get_source_view(remaining)
     left           = closing_view.sibling_left
     right          = closing_view.sibling_right
 

plugins/code/commands/split_pane/create_split_view.py

@@ -47,6 +47,8 @@ def execute(
 
     pane.set_hexpand(True)
     pane.set_vexpand(True)
+    scrolled_win1.set_hexpand(True)
+    scrolled_win2.set_vexpand(True)
     pane.set_wide_handle(True)
 
     container.remove(scrolled_win1)
@@ -54,13 +56,12 @@ def execute(
     pane.pack2( scrolled_win2, True, True )
     container.add(pane)
 
-    pane.show_all()
+    if char_str == "|":
-
-    is_control, is_shift, is_alt = modkeys_states
-    if is_control and is_shift:
         pane.set_orientation(Gtk.Orientation.VERTICAL)
-    elif is_control:
+    elif char_str == "\\":
         pane.set_orientation(Gtk.Orientation.HORIZONTAL)
 
-    source_view2.grab_focus()
+    pane.show_all()
+
     source_view2.command.exec("new_file")
+    source_view2.grab_focus()

plugins/code/commands/split_pane/manifest.json

@@ -1,5 +1,5 @@
 {
-    "name": "Split Pane Manager",
+    "name": "Split Pane",
     "author": "ITDominator",
     "version": "0.0.1",
     "support": "",

plugins/code/commands/split_pane/plugin.py

@@ -55,7 +55,7 @@ class Plugin(PluginCode):
             command_name = "close_split_view",
             command      = _close_split_view,
             binding_mode = "released",
-            binding      = "<Shift><Control>w"
+            binding      = "<Alt>\\"
         )
 
         self.emit_to("source_views", event)

plugins/code/completers/example_completer/provider_response_cache.py

@@ -51,7 +51,10 @@ class ProviderResponseCache(ProviderResponseCacheBase):
     def process_file_save(self, event: Code_Event_Types.SavedFileEvent):
         ...
 
-    def process_file_change(self, event: Code_Event_Types.TextChangedEvent):
+    def process_file_text_inserted(self, event: Code_Event_Types.TextInsertedEvent):
+        ...
+
+    def process_file_delete_range(self, event: Code_Event_Types.DeleteRangeEvent):
         ...
 
     def filter(self, word: str) -> list[dict]:

plugins/code/completers/snippets_completer/provider_response_cache.py

@@ -49,7 +49,10 @@ class ProviderResponseCache(ProviderResponseCacheBase):
     def process_file_save(self, event: Code_Event_Types.SavedFileEvent):
         ...
 
-    def process_file_change(self, event: Code_Event_Types.TextChangedEvent):
+    def process_file_text_inserted(self, event: Code_Event_Types.TextInsertedEvent):
+        ...
+
+    def process_file_delete_range(self, event: Code_Event_Types.DeleteRangeEvent):
         ...
 
     def filter(self, word: str) -> list[dict]:

plugins/code/completers/words_completer/provider_response_cache.py

@@ -35,11 +35,14 @@ class ProviderResponseCache(ProviderResponseCacheBase):
     def process_file_save(self, event: Code_Event_Types.SavedFileEvent):
         ...
 
-    def process_file_change(self, event: Code_Event_Types.TextChangedEvent):
+    def process_file_text_inserted(self, event: Code_Event_Types.TextInsertedEvent):
-        buffer = event.file.buffer
+        buffer = event.buffer
         self._clear_temp_delay()
         self._set_temp_delay(buffer)
 
+    def process_file_delete_range(self, event: Code_Event_Types.DeleteRangeEvent):
+        ...
+
     def _clear_temp_delay(self):
         if self._temp_timeout_id:
             GLib.source_remove(self._temp_timeout_id)

plugins/code/language_server_clients/lsp_manager/client/lsp_client.py

@@ -1,13 +1,9 @@
 # Python imports
-import threading
-from os import path
-import json
 
 # Lib imports
-import gi
-from gi.repository import GLib
 
 # Application imports
+from ..config import get_lsp_init_config
 from ..dto.code.lsp.lsp_messages import get_message_str
 from ..dto.code.lsp.lsp_message_structs import \
     LSPResponseTypes, ClientRequest, ClientNotification
@@ -19,29 +15,14 @@ class LSPClient(LSPClientWebsocket):
     def __init__(self):
         super(LSPClient, self).__init__()
 
+        self._socket: str                   = ""
         self._language: str                 = ""
         self._workspace_path: str           = ""
-        self._init_params: dict             = {}
-        self._init_opts: dict               = {}
-
-        try:
-            _USER_HOME  = path.expanduser('~')
-            _SCRIPT_PTH = path.dirname( path.realpath(__file__) )
-            _LSP_INIT_CONFIG = f"{_SCRIPT_PTH}/../configs/initialize-params-slim.json"
-
-            with open(_LSP_INIT_CONFIG) as file:
-                data = file.read()
-                self._init_params = json.loads(data)
-        except Exception as e:
-            logger.error( f"LSP Controller: {_LSP_INIT_CONFIG}\n\t\t{repr(e)}" )
-
-
-        self._socket                        = None
         self._message_id: int               = -1
         self._event_history: dict[int, str] = {}
-
+        self._init_params: dict             = get_lsp_init_config()
-        self.read_lock                      = threading.Lock()
+        self._init_opts: dict[str, str]     = {}
-        self.write_lock                     = threading.Lock()
+        self.doc_vers: dict[str, int]       = {}
 
 
     def set_language(self, language: str):
@@ -57,7 +38,7 @@ class LSPClient(LSPClientWebsocket):
         self._socket = socket
 
     def unset_socket(self):
-        self._socket = None
+        self._socket = ""
 
     def send_notification(self, method: str, params: dict = {}):
         self._send_message( ClientNotification(method, params) )
@@ -71,5 +52,5 @@ class LSPClient(LSPClientWebsocket):
         if not message_id in self._event_history: return
         return self._event_history[message_id]
 
-    def handle_lsp_response(self, lsp_response: LSPResponseTypes):
+    def handle_lsp_response(self, lsp_response: LSPResponseTypes | dict):
         raise NotImplementedError

plugins/code/language_server_clients/lsp_manager/client/lsp_client_events.py

@@ -9,10 +9,14 @@ from ..dto.code.lsp.lsp_messages import didopen_notification
 from ..dto.code.lsp.lsp_messages import didsave_notification
 from ..dto.code.lsp.lsp_messages import didclose_notification
 from ..dto.code.lsp.lsp_messages import didchange_notification
+from ..dto.code.lsp.lsp_messages import didchange_notification_range
 from ..dto.code.lsp.lsp_messages import completion_request
 from ..dto.code.lsp.lsp_messages import definition_request
+from ..dto.code.lsp.lsp_messages import implementation_request
 from ..dto.code.lsp.lsp_messages import references_request
 from ..dto.code.lsp.lsp_messages import symbols_request
+from ..dto.code.lsp.lsp_messages import shutdown_request
+from ..dto.code.lsp.lsp_messages import exit_request
 
 
 
@@ -34,12 +38,19 @@ class LSPClientEvents:
         self._init_params["initializationOptions"] = self._init_opts
         self.send_request("initialize", self._init_params)
 
-    def send_initialized_message(self):
+    def send_initialized_notification(self):
         self.send_notification("initialized")
 
+    def send_shutdown_request(self):
+        self.send_request("shutdown")
+
+    def send_exit_notification(self):
+        self.send_notification("exit")
+
     def _lsp_did_open(self, data: dict):
         method = "textDocument/didOpen"
         params = didopen_notification["params"]
+        self.doc_vers[ data["uri"] ] = -1
 
         params["textDocument"]["uri"]        = data["uri"]
         params["textDocument"]["languageId"] = data["language_id"]
@@ -77,24 +88,24 @@ class LSPClientEvents:
 
         self.send_notification( method, params )
 
-    # def _lsp_did_change(self, data: dict):
+    def _lsp_did_change_range(self, data: dict):
-    #     method = "textDocument/didChange"
+        method = "textDocument/didChange"
-    #     params = didchange_notification_range["params"]
+        params = didchange_notification_range["params"]
 
-    #     params["textDocument"]["uri"]        = data["uri"]
+        params["textDocument"]["uri"]        = data["uri"]
-    #     params["textDocument"]["languageId"] = data["language_id"]
+        params["textDocument"]["languageId"] = data["language_id"]
-    #     params["textDocument"]["version"]    = data["version"]
+        params["textDocument"]["version"]    = data["version"]
 
-    #     contentChanges         = params["contentChanges"][0]
+        contentChanges         = params["contentChanges"][0]
-    #     start                  = contentChanges["range"]["start"]
+        start                  = contentChanges["range"]["start"]
-    #     end                    = contentChanges["range"]["end"]
+        end                    = contentChanges["range"]["end"]
-    #     contentChanges["text"] = data["text"]
+        contentChanges["text"] = data["text"]
-    #     start["line"]          = data["line"]
+        start["line"]          = data["line"]
-    #     start["character"]     = 0
+        start["character"]     = data["column"]
-    #     end["line"]            = data["line"]
+        end["line"]            = data["end_line"]
-    #     end["character"]       = data["column"]
+        end["character"]       = data["end_column"]
 
-    #     self.send_notification( method, params )
+        self.send_notification( method, params )
 
     def _lsp_definition(self, data: dict):
         method = "textDocument/definition"
@@ -108,13 +119,33 @@ class LSPClientEvents:
 
         self.send_request( method, params )
 
+    def _lsp_implementation(self, data: dict):
+        method = "textDocument/implementation"
+        params = implementation_request["params"]
+
+        params["textDocument"]["uri"]        = data["uri"]
+        params["position"]["line"]           = data["line"]
+        params["position"]["character"]      = data["column"]
+
+        self.send_request( method, params )
+
+    def _lsp_references(self, data: dict):
+        method = "textDocument/references"
+        params = references_request["params"]
+
+        params["textDocument"]["uri"]        = data["uri"]
+        params["textDocument"]["languageId"] = data["language_id"]
+        params["textDocument"]["version"]    = data["version"]
+        params["position"]["line"]           = data["line"]
+        params["position"]["character"]      = data["column"]
+
+        self.send_request( method, params )
+
     def _lsp_completion(self, data: dict):
         method = "textDocument/completion"
         params = completion_request["params"]
 
         params["textDocument"]["uri"]        = data["uri"]
-        params["textDocument"]["languageId"] = data["language_id"]
-        params["textDocument"]["version"]    = data["version"]
         params["position"]["line"]           = data["line"]
         params["position"]["character"]      = data["column"]
 

plugins/code/language_server_clients/lsp_manager/client/lsp_client_websocket.py

@@ -11,7 +11,7 @@ from ..dto.code.lsp.lsp_message_structs import           \
     LSPResponseRequest, LSPResponseNotification, LSPIDResponseNotification
 
 from .lsp_client_base import LSPClientBase
-from .websocket_client import WebsocketClient
+from .websocket import Websocket
 
 
 
@@ -24,26 +24,26 @@ class LSPClientWebsocket(LSPClientBase):
         message      = f"Content-Length: {message_size}\r\n\r\n{message_str}"
 
         logger.debug(f"Client: {message_str}")
-        self.ws_client.send(message_str)
+        self.websocket.send(message_str)
 
     def start_client(self):
-        self.ws_client = WebsocketClient()
+        self.websocket = Websocket()
-        self.ws_client.set_socket(self._socket)
+        self.websocket.set_socket(self._socket)
-        self.ws_client.set_callback(self._monitor_lsp_response)
+        self.websocket.set_callback(self._monitor_lsp_response)
-        self.ws_client.start_client()
+        self.websocket.start_client()
 
-        return self.ws_client
+        return self.websocket
 
     def stop_client(self):
-        if not hasattr(self, "ws_client"): return
+        if not hasattr(self, "websocket"): return
-        self.ws_client.close_client()
+        self.websocket.close_client()
 
     def _monitor_lsp_response(self, data: dict | None):
-        if not data: return
+        if not data: return {}
 
         message      = get_message_obj(data)
         keys         = message.keys()
-        lsp_response = None
+        lsp_response = data
 
         if "result" in keys:
             lsp_response = LSPResponseRequest(**get_message_obj(data))
@@ -51,6 +51,7 @@ class LSPClientWebsocket(LSPClientBase):
         if "method" in keys:
             lsp_response = LSPResponseNotification(**get_message_obj(data)) if not "id" in keys else LSPIDResponseNotification( **get_message_obj(data) )
 
-        if not lsp_response: return
+        if isinstance(lsp_response, str):
+            lsp_response = get_message_obj(lsp_response)
 
         GLib.idle_add(self.handle_lsp_response, lsp_response)

plugins/code/language_server_clients/lsp_manager/client/websocket.py

@@ -9,7 +9,7 @@ from ..libs import websocket
 
 
 
-class WebsocketClient:
+class Websocket:
     def __init__(self):
         self.ws         = None
         self._socket    = None

plugins/code/language_server_clients/lsp_manager/client_manager.py

@@ -4,14 +4,15 @@ from concurrent.futures import ThreadPoolExecutor
 # Lib imports
 
 # Application imports
-from .mixins.lsp_client_events_mixin import LSPClientEventsMixin
+from .config import get_lsp_connect_timout
+from .mixins.client_manager_events_mixin import ClientManagerEventsMixin
 from .client.lsp_client import LSPClient
 
 
 
-class LSPManagerClient(LSPClientEventsMixin):
+class ClientManager(ClientManagerEventsMixin):
     def __init__(self):
-        super(LSPManagerClient, self).__init__()
+        super(ClientManager, self).__init__()
 
         self._cache_refresh_timeout_id: int = None
 
@@ -24,13 +25,13 @@ class LSPManagerClient(LSPClientEventsMixin):
         self,
         lang_id: str,
         workspace_path: str,
-        init_opts: dict[str, str]
+        init_opts: dict[str, str],
+        address: str = "127.0.0.1",
+        port: str    = "9999"
     ) -> LSPClient:
         if lang_id in self.clients: return None
 
-        address = "127.0.0.1"
+        uri     = f"ws://{address}:{port}/{lang_id}?workspace={workspace_path}"
-        port    = 9999
-        uri     = f"ws://{address}:{port}/{lang_id}"
         client  = LSPClient()
 
         client.set_socket(uri)
@@ -39,7 +40,7 @@ class LSPManagerClient(LSPClientEventsMixin):
         client.set_init_opts(init_opts)
         client.start_client()
 
-        if not client.ws_client.wait_for_connection(timeout = 5.0):
+        if not client.websocket.wait_for_connection(timeout = get_lsp_connect_timout()):
             logger.error(f"Failed to connect to LSP server for {lang_id}")
             return None
 

plugins/code/language_server_clients/lsp_manager/commands.py

@@ -0,0 +1,87 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('Gtk', '3.0')
+gi.require_version('GtkSource', '4')
+
+from gi.repository import Gtk
+from gi.repository import GtkSource
+
+# Application imports
+
+
+
+class Commands:
+    lsp_manager: callable = None
+
+    class lsp_manager_toggle:
+        @staticmethod
+        def execute(
+            source_view: GtkSource,
+            char_str: str,
+            modkeys_states: tuple
+        ):
+            logger.debug("Command: LSP Manager Toggle")
+            if Commands.lsp_manager.ui_manager.is_visible():
+                Commands.lsp_manager.ui_manager.hide()
+            else:
+                Commands.lsp_manager.ui_manager.show()
+
+    class lsp_references:
+        @staticmethod
+        def execute(
+            view: GtkSource,
+            char_str: str,
+            modkeys_states: tuple
+        ):
+            logger.debug("Command: LSP References")
+
+            file   = view.command.exec("get_current_file")
+            buffer = view.get_buffer()
+            iter   = buffer.get_iter_at_mark( buffer.get_insert() )
+            line   = iter.get_line()
+            column = iter.get_line_offset()
+
+            Commands.lsp_manager.client_manager.process_references_definition(
+                file.ftype, file.fpath, line, column
+            )
+
+    class lsp_implementation:
+        @staticmethod
+        def execute(
+            view: GtkSource,
+            char_str: str,
+            modkeys_states: tuple
+        ):
+            logger.debug("Command: LSP Implements")
+
+            file   = view.command.exec("get_current_file")
+            buffer = view.get_buffer()
+            iter   = buffer.get_iter_at_mark( buffer.get_insert() )
+            line   = iter.get_line()
+            column = iter.get_line_offset()
+
+            Commands.lsp_manager.client_manager.process_implementation_definition(
+                file.ftype, file.fpath, line, column
+            )
+
+    class lsp_definition:
+        @staticmethod
+        def execute(
+            view: GtkSource,
+            char_str: str,
+            modkeys_states: tuple
+        ):
+            logger.debug("Command: LSP Definition (Go-To)")
+
+            file   = view.command.exec("get_current_file")
+            buffer = view.get_buffer()
+            iter   = buffer.get_iter_at_mark( buffer.get_insert() )
+            line   = iter.get_line()
+            column = iter.get_line_offset()
+
+            Commands.lsp_manager.client_manager.process_definition(
+                file.ftype, file.fpath, line, column
+            )

plugins/code/language_server_clients/lsp_manager/config.py

@@ -0,0 +1,38 @@
+# Python imports
+from os import path
+import json
+
+# Lib imports
+
+# Application imports
+
+
+
+LSP_HOST: str = "127.0.0.1"
+LSP_PORT: int = 9999
+LSP_CONNECT_TIMOUT: float = 5.0
+
+
+
+def get_lsp_host_addr() -> str:
+    return LSP_HOST
+
+def get_lsp_host_port() -> int:
+    return LSP_PORT
+
+def get_lsp_connect_timout() -> float:
+    return LSP_CONNECT_TIMOUT
+
+def get_lsp_init_config() -> dict:
+    try:
+        _USER_HOME  = path.expanduser('~')
+        _SCRIPT_PTH = path.dirname( path.realpath(__file__) )
+        _LSP_INIT_CONFIG = f"{_SCRIPT_PTH}/configs/initialize-params-slim.json"
+
+        with open(_LSP_INIT_CONFIG) as file:
+            data = file.read()
+            return json.loads(data)
+    except Exception as e:
+        logger.error( f"LSP Controller: {_LSP_INIT_CONFIG}\n\t\t{repr(e)}" )
+
+    return {}

plugins/code/language_server_clients/lsp_manager/dto/code/lsp/lsp_messages.py

@@ -96,10 +96,10 @@ didchange_notification_range = {
             "uri": "file://",
             "languageId": "python",
             "version": 1,
-            "text": ""
 	    },
 	    "contentChanges": [
 	        {
+	            "text": "",
 	            "range": {
 	                "start": {
 	                    "line": 1,
@@ -108,9 +108,8 @@ didchange_notification_range = {
 	                "end": {
 	                    "line": 1,
                         "character": 1,
-	                },
+	                }
-	                "rangeLength": 0
+	            },
-	            }
 	        }
 	    ]
 	}
@@ -125,19 +124,11 @@ completion_request = {
 	"method": "textDocument/completion",
 	"params": {
 	    "textDocument": {
-            "uri": "file://",
+            "uri": "file://"
-            "languageId": "python",
-            "version": 1,
-            "text": ""
 	    },
 	    "position": {
 	        "line": 5,
-            "character": 12,
+            "character": 12
-            "offset": 0
-	    },
-	    "contet": {
-	        "triggerKind": 3,
-	        "triggerCharacter": ""
 	    }
 	}
 }
@@ -159,6 +150,19 @@ definition_request = {
 	}
 }
 
+implementation_request = {
+	"method": "textDocument/implementation",
+	"params": {
+	    "textDocument": {
+            "uri": "file://"
+	    },
+	    "position": {
+	        "line": 5,
+            "character": 12
+	    }
+	}
+}
+
 references_request = {
     "method": "textDocument/references",
     "params": {
@@ -179,7 +183,6 @@ references_request = {
 	}
 }
 
-
 symbols_request = {
 	"method": "textDocument/documentSymbol",
 	"params": {
@@ -191,3 +194,14 @@ symbols_request = {
 	    }
 	}
 }
+
+shutdown_request = {
+	"method": "shutdown",
+	"params": None
+}
+
+exit_request = {
+	"method": "exit",
+	"params": None
+}
+

plugins/code/language_server_clients/lsp_manager/lsp_manager.py

@@ -1,6 +1,9 @@
 # Python imports
 
 # Lib imports
+import gi
+
+from gi.repository import GLib
 
 # Application imports
 from libs.controllers.controller_base import ControllerBase
@@ -11,10 +14,11 @@ from .dto.code.events import \
 from .dto.code.lsp.lsp_message_structs import \
     LSPResponseTypes, LSPResponseRequest, LSPResponseNotification
 
+from .ui_manager import UIManager
+
 from .provider import Provider
 from .provider_response_cache import ProviderResponseCache
-from .lsp_manager_ui import LSPManagerUI
+from .client_manager import ClientManager
-from .lsp_manager_client import LSPManagerClient
 from .response_handlers.response_registry import ResponseRegistry
 
 
@@ -31,16 +35,16 @@ class LSPManager(ControllerBase):
     def _init(self):
         self.provider: Provider                    = Provider()
         self.response_cache: ProviderResponseCache = ProviderResponseCache()
-        self.lsp_manager_client: LSPManagerClient  = LSPManagerClient()
+        self.client_manager: ClientManager         = ClientManager()
         self.response_registry: ResponseRegistry   = ResponseRegistry()
 
     def _load_widgets(self):
-        self.lsp_manager_ui: LSPManagerUI = LSPManagerUI()
+        self.ui_manager: LSPManagerUI = UIManager()
-        self.lsp_manager_ui.connect('create-client', self._on_create_client)
+        self.ui_manager.connect('create-client', self._on_create_client)
-        self.lsp_manager_ui.connect('close-client', self._on_close_client)
+        self.ui_manager.connect('close-client', self._on_close_client)
 
     def _do_bind_mapping(self):
-        self.response_cache.set_lsp_manager_client(self.lsp_manager_client)
+        self.response_cache.set_lsp_manager_client(self.client_manager)
         self.provider.response_cache = self.response_cache
         self.response_registry.set_event_hub(
             self.emit, self.emit_to, self.provider
@@ -49,14 +53,20 @@ class LSPManager(ControllerBase):
     def _controller_message(self, event: Code_Event_Types.CodeEvent):
         if isinstance(event, Code_Event_Types.RegisterLspClientEvent):
             self.response_registry.register_handler(event.lang_id, event.handler)
-            self.lsp_manager_ui.add_client_listing(event.lang_id, event.lang_config)
+            self.ui_manager.add_client_listing(event.lang_id, event.lang_config)
         elif isinstance(event, Code_Event_Types.UnregisterLspClientEvent):
             self.response_registry.unregister_handler(event.lang_id)
-            self.lsp_manager_ui.remove_client_listing(event.lang_id)
+            self.ui_manager.remove_client_listing(event.lang_id)
 
     def _on_create_client(self, ui, lang_id: str, workspace_path: str) -> bool:
         init_opts = ui.get_init_opts(lang_id)
-        result    = self.create_client(lang_id, workspace_path, init_opts)
+        result    = self.create_client(
+            lang_id,
+            workspace_path,
+            init_opts,
+            ui.adddress_entry.get_text(),
+            f"{ int( ui.adddress_port.get_value() ) }"
+        )
 
         if result:
             ui.toggle_client_buttons(show_close = True)
@@ -72,20 +82,22 @@ class LSPManager(ControllerBase):
         return result
 
     def handle_destroy(self):
-        self.lsp_manager_ui.disconnect_by_func(self._on_create_client)
+        self.ui_manager.disconnect_by_func(self._on_create_client)
-        self.lsp_manager_ui.disconnect_by_func(self._on_close_client)
+        self.ui_manager.disconnect_by_func(self._on_close_client)
 
     def create_client(
         self,
         lang_id: str,
         workspace_path: str,
-        init_opts: dict[str, str]
+        init_opts: dict[str, str],
+        address: str,
+        port: str
     ) -> bool:
-        client  = self.lsp_manager_client.create_client(
+        client  = self.client_manager.create_client(
-            lang_id, workspace_path, init_opts
+            lang_id, workspace_path, init_opts, address, port
         )
         handler = self.response_registry.get_handler(lang_id)
-        self.lsp_manager_client.active_language_id = lang_id
+        self.client_manager.active_language_id = lang_id
 
         if not client or not handler:
             logger.error(f"LSP Manager: Either 'client' or 'handler' didn't get created...'")
@@ -96,28 +108,46 @@ class LSPManager(ControllerBase):
         handler.set_response_cache(self.response_cache)
 
         client.handle_lsp_response = self.server_response
-        client.send_initialize_message()
 
         return True
 
     def close_client(self, lang_id: str) -> bool:
-        self.lsp_manager_client.close_client(lang_id)
+        controller = self.client_manager.get_active_client()
-        self.response_registry.close_handler(lang_id)
+        controller.send_shutdown_request()
+
+        def _close():
+            self.client_manager.close_client(lang_id)
+            self.response_registry.close_handler(lang_id)
+
+            return False
+
+        GLib.timeout_add(5000, _close)
 
         return True
 
-    def server_response(self, lsp_response: LSPResponseTypes):
+    def server_response(self, lsp_response: LSPResponseTypes | dict):
         logger.debug(f"LSP Response: { lsp_response }")
 
-        if isinstance(lsp_response, LSPResponseRequest):
+        if isinstance(lsp_response, dict):
-            if not self.lsp_manager_client.active_language_id in self.lsp_manager_client.clients:
+            if not self.client_manager.active_language_id in self.client_manager.clients:
-                logger.debug(f"No LSP client for '{self.lsp_manager_client.active_language_id}', skipping 'server_response'")
+                logger.debug(f"No LSP client for '{self.client_manager.active_language_id}', skipping 'server_response'")
                 return
 
-            controller = self.lsp_manager_client.get_active_client()
+            controller = self.client_manager.get_active_client()
+            if "type" in lsp_response and lsp_response["type"] == "connected":
+                controller.send_initialize_message()
+
+            return
+
+        if isinstance(lsp_response, LSPResponseRequest):
+            if not self.client_manager.active_language_id in self.client_manager.clients:
+                logger.debug(f"No LSP client for '{self.client_manager.active_language_id}', skipping 'server_response'")
+                return
+
+            controller = self.client_manager.get_active_client()
             event      = controller.get_event_by_id(lsp_response.id)
             handler    = self.response_registry.get_handler(
-                self.lsp_manager_client.active_language_id, event
+                self.client_manager.active_language_id, event
             )
 
             if not handler: return

plugins/code/language_server_clients/lsp_manager/lsp_manager_ui.py

@@ -1,234 +0,0 @@
-# Python imports
-from os import path
-import json
-
-# Lib imports
-import gi
-gi.require_version('Gtk', '3.0')
-gi.require_version('GtkSource', '4')
-
-from gi.repository import GObject
-from gi.repository import Gtk
-from gi.repository import GLib
-from gi.repository import GtkSource
-
-# Application imports
-
-
-
-class LSPManagerUI(Gtk.Dialog):
-    __gsignals__ = {
-        'create-client': (GObject.SignalFlags.RUN_LAST, None, (str, str)),
-        'close-client': (GObject.SignalFlags.RUN_LAST, None, (str,)),
-    }
-
-    def __init__(self):
-        super(LSPManagerUI, self).__init__()
-
-        self._USER_HOME = path.expanduser('~')
-
-        self.client_configs: dict[str, str] = {}
-
-        self.source_view = None
-
-        self._setup_styling()
-        self._setup_signals()
-        self._subscribe_to_events()
-        self._load_widgets()
-
-
-    def _setup_styling(self):
-        self.set_modal(True)
-        self.set_decorated(False)
-        self.set_vexpand(True)
-        self.set_hexpand(True)
-
-    def _setup_signals(self):
-        self.connect("show", self._handle_show)
-        self.connect("destroy", self._handle_destroy)
-
-    def _subscribe_to_events(self):
-        ...
-
-    def _load_widgets(self):
-        content_area       = self.get_content_area()
-        self.main_box      = Gtk.Grid()
-        self.path_entry    = Gtk.SearchEntry()
-        self.path_bttn     = Gtk.FileChooserButton.new(
-            title  = "Workspace Folder",
-            action = Gtk.FileChooserAction.SELECT_FOLDER
-        )
-        self.combo_box     = Gtk.ComboBoxText()
-
-        self.hide_bttn     = Gtk.Button(label = "X")
-        bttn_box           = Gtk.Box()
-        self.create_client_bttn = Gtk.Button(label = "Create Language Client")
-        self.close_client_bttn  = Gtk.Button(label = "Close Language Client")
-
-        self.path_entry.set_can_focus(False)
-        self.path_entry.set_placeholder_text("Workspace Folder...")
-        self.path_entry.connect("changed", self._path_changed, bttn_box)
-        self.path_bttn.set_halign(Gtk.Align.FILL)
-
-        self.path_bttn.connect("file-set", self._file_set)
-        self.combo_box.connect("changed", self._on_combo_changed)
-        self.hide_bttn_id = self.hide_bttn.connect("clicked", lambda widget: self.hide())
-        self.create_client_bttn.connect("clicked", self._create_client, self.close_client_bttn)
-        self.close_client_bttn.connect("clicked", self._close_client, self.create_client_bttn)
-
-        self.main_box.set_column_spacing(15)
-        self.main_box.set_row_spacing(15)
-
-        bttn_box.pack_start(self.create_client_bttn, False, False, 0)
-        bttn_box.pack_start(self.close_client_bttn, False, False, 0)
-
-        self.main_box.attach(child = self.path_entry, left = 0, top = 0, width = 4, height = 1)
-        self.main_box.attach(child = self.path_bttn,  left = 4, top = 0, width = 1, height = 1)
-        self.main_box.attach(child = self.combo_box,  left = 5, top = 0, width = 1, height = 1)
-        self.main_box.attach(child = self.hide_bttn,  left = 6, top = 0, width = 1, height = 1)
-        self.main_box.attach(child = bttn_box,        left = 0, top = 1, width = 1, height = 1)
-
-        content_area.set_vexpand(True)
-        content_area.set_hexpand(True)
-
-        content_area.add(self.main_box)
-        content_area.show_all()
-        self.close_client_bttn.hide()
-        bttn_box.hide()
-
-    def _handle_show(self, widget):
-        GLib.idle_add(self.path_entry.grab_focus)
-
-    def _handle_destroy(self, widget):
-        self.disconnect_by_func(self._show)
-        self.disconnect_by_func(self._handle_destroy)
-        self.path_bttn.disconnect_by_func(self._file_set)
-        self.combo_box.disconnect_by_func(self._on_combo_changed)
-        self.hide_bttn.disconnect(self.hide_bttn_id)
-        self.create_client_bttn.disconnect_by_func(self._create_client)
-        self.close_client_bttn.disconnect_by_func(self._close_client)
-
-    def _map_resize(self, widget, parent):
-        parent_x, parent_y = parent.get_position()
-        parent_width, parent_height = parent.get_size()
-        if parent_width == 0 or parent_height == 0: return
-
-        width  = int(parent_width  * 0.75)
-        height = int(parent_height * 0.75)
-
-        widget.resize(width, height)
-
-        x = parent_x + (parent_width - width)   // 2
-        y = parent_y + (parent_height - height) // 2
-        widget.move(x, y)
-
-    def _path_changed(self, widget, buttons_widget):
-        if not widget.get_text():
-            self.path_bttn.unselect_all()
-            self.path_bttn.emit("file-set")
-            buttons_widget.hide()
-            return
-
-        self.set_source_view_text( self.path_entry.get_text() )
-        buttons_widget.show()
-
-    def _file_set(self, widget):
-        fname = widget.get_filename()
-        fname = "" if not fname else fname
-        self.path_entry.set_text(fname)
-
-        lang_id = self.combo_box.get_active_text()
-        if not lang_id or lang_id not in self.client_configs: return
-
-        self.set_source_view_text(
-            "{workspace.folder}" if not fname else fname
-        )
-
-    def _create_client(self, widget, sibling):
-        if not self.source_view: return
-
-        buffer  = self.source_view.get_buffer()
-        lang_id = self.combo_box.get_active_text()
-
-        if not lang_id: return
-
-        workspace_dir = self.path_entry.get_text()
-        self.emit('create-client', lang_id, workspace_dir)
-
-    def _close_client(self, widget, sibling):
-        lang_id = self.combo_box.get_active_text()
-
-        if not lang_id: return
-        self.emit('close-client', lang_id)
-
-    def _on_combo_changed(self, combo: Gtk.ComboBoxText):
-        lang_id = combo.get_active_text()
-        self.set_source_view_text( self.path_entry.get_text() )
-
-
-    def set_source_view_text(self, workspace_dir: str):
-        lang_id  = self.combo_box.get_active_text()
-        if not lang_id: return
-
-        json_str = self.client_configs[lang_id]                       \
-                        .replace("{workspace.folder}", workspace_dir) \
-                        .replace("{user.home}", self._USER_HOME)
-
-        buffer   = self.source_view.get_buffer()
-        buffer.set_text(json_str, -1)
-
-    def map_parent_resize_event(self, parent):
-        self.size_allocate_id = parent.connect("size-allocate", lambda w, r: self._map_resize(self, parent))
-
-    def unmap_parent_resize_event(self, parent):
-        parent.disconnect(self.size_allocate_id)
-
-    def set_source_view(self, source_view):
-        scrolled_win     = Gtk.ScrolledWindow()
-        lang_manager     = GtkSource.LanguageManager()
-        buffer           = source_view.get_buffer()
-        language         = lang_manager.get_language("json")
-        self.source_view = source_view
-
-        buffer.set_language(language)
-        buffer.set_style_scheme(self.source_view.syntax_theme)
-
-        scrolled_win.set_hexpand(True)
-        scrolled_win.set_vexpand(True)
-
-        scrolled_win.add(self.source_view)
-        self.main_box.attach(child = scrolled_win, left = 0, top = 2, width = 7, height = 1)
-
-        scrolled_win.show_all()
-
-    def add_client_listing(self, lang_id: str, lang_config: str):
-        self.combo_box.append_text(lang_id)
-        self.client_configs[lang_id] = lang_config
-
-    def remove_client_listing(self, lang_id: str):
-        model = self.combo_box.get_model()
-
-        for i, row in enumerate(model):
-            if row[0] == lang_id:
-                self.combo_box.remove(i)
-                break
-
-        if lang_id in self.client_configs:
-            del self.client_configs[lang_id]
-
-    def get_init_opts(self, lang_id: str) -> dict:
-        if not lang_id or lang_id not in self.client_configs: return {}
-
-        try:
-            buffer      = self.source_view.get_buffer()
-            json_str    = buffer.get_text(*buffer.get_bounds(), -1)
-            lang_config = json.loads(json_str)
-        except json.JSONDecodeError as e:
-            logger.error(f"Invalid JSON for {lang_id}: {e}")
-            return {}
-
-        return lang_config.get("initialization-options", {})
-
-    def toggle_client_buttons(self, show_close: bool):
-        self.create_client_bttn.set_visible(not show_close)
-        self.close_client_bttn.set_visible(show_close)

plugins/code/language_server_clients/lsp_manager/mixins/client_manager_events_mixin.py

@@ -0,0 +1,191 @@
+# Python imports
+
+# Lib imports
+
+# Application imports
+from libs.event_factory import Code_Event_Types
+
+
+
+class ClientManagerEventsMixin:
+    def _get_controller(self, lang_id, action: str):
+        controller = self.clients.get(lang_id)
+        if not controller:
+            logger.debug(f"No LSP client for '{lang_id}', skipping {action}...")
+
+        return controller
+
+    def _uri(self, fpath: str) -> str:
+        return fpath if fpath.startswith("file://") else f"file://{fpath}"
+
+    def _text(self, buffer, *, hidden = False):
+        return buffer.get_text(
+            *buffer.get_bounds(),
+            include_hidden_chars=hidden
+        )
+
+    def _version(self, controller, uri, bump = False):
+        if bump:
+            controller.doc_vers[uri] = controller.doc_vers.get(uri, -1) + 1
+
+        return controller.doc_vers.get(uri, 0)
+
+    def _activate(self, lang_id):
+        self.active_language_id = lang_id
+
+    def process_file_load(self, event: Code_Event_Types.AddedNewFileEvent):
+        f = event.file
+        if not (c := self._get_controller(f.ftype, "didOpen")): return
+
+        uri = self._uri(f.fpath)
+        self._activate(f.ftype)
+
+        c._lsp_did_open({
+            "uri": uri,
+            "language_id": f.ftype,
+            "text": self._text(f.buffer),
+        })
+
+    def process_file_close(self, event: Code_Event_Types.RemovedFileEvent):
+        f = event.file
+        if not (c := self._get_controller(f.ftype, "didClose")): return
+
+        uri = self._uri(f.fpath)
+        c.doc_vers.pop(uri, None)
+        c._lsp_did_close({"uri": uri})
+
+    def process_file_save(self, event: Code_Event_Types.SavedFileEvent):
+        f = event.file
+        if not (c := self._get_controller(f.ftype, "didSave")): return
+
+        uri = self._uri(f.fpath)
+        self._activate(f.ftype)
+
+        c._lsp_did_save({
+            "uri": uri,
+            "text": self._text(f.buffer),
+        })
+
+    def process_file_change(self, event: Code_Event_Types.TextChangedEvent):
+        f = event.file
+        if not (c := self._get_controller(f.ftype, "didChange")): return
+
+        uri = self._uri(f.fpath)
+        self._activate(f.ftype)
+
+        version = self._version(c, uri, bump = True)
+
+        c._lsp_did_change({
+            "uri": uri,
+            "language_id": f.ftype,
+            "version": version,
+            "text": self._text(f.buffer, hidden = True),
+        })
+
+        it = f.buffer.get_iter_at_mark(f.buffer.get_insert())
+        self._set_cache_refresh_trigger(
+            f.ftype, f.fpath,
+            it.get_line(),
+            it.get_line_offset() + 1
+        )
+
+    def _iter_pos(self, it):
+        return it.get_line(), it.get_line_offset()
+
+    def process_file_text_inserted(self, event: Code_Event_Types.TextInsertedEvent):
+        f = event.file
+        if not (c := self._get_controller(f.ftype, "didChange")): return
+
+        uri = self._uri(f.fpath)
+        self._activate(f.ftype)
+
+        start_it = event.location.copy()
+        end_it   = event.location.copy()
+
+        if event.length > 1:
+            start_it.backward_chars(event.length)
+
+        sl, sc = self._iter_pos(start_it)
+        el, ec = self._iter_pos(end_it)
+        sc -= 0 if event.length > 1 else 1
+        ec -= 1
+
+        version = self._version(c, uri, bump = True)
+
+        c._lsp_did_change_range({
+            "uri": uri,
+            "language_id": f.ftype,
+            "version": version,
+            "text": event.text,
+            "line": sl,
+            "column": sc,
+            "end_line": el,
+            "end_column": ec,
+        })
+
+        it = event.buffer.get_iter_at_mark(event.buffer.get_insert())
+        self._set_cache_refresh_trigger(
+            f.ftype, f.fpath, *self._iter_pos(it)
+        )
+
+    def process_file_delete_range(self, event: Code_Event_Types.DeleteRangeEvent):
+        f = event.file
+        if not (c := self._get_controller(f.ftype, "didChange")): return
+
+        uri = self._uri(f.fpath)
+        self._activate(f.ftype)
+
+        start_it, end_it = event.start.copy(), event.end.copy()
+        if start_it.compare(end_it) > 0:
+            start_it, end_it = end_it, start_it
+
+        sl, sc = self._iter_pos(start_it)
+        el, ec = self._iter_pos(end_it)
+
+        version = self._version(c, uri, bump = True)
+
+        c._lsp_did_change_range({
+            "uri": uri,
+            "language_id": f.ftype,
+            "version": version,
+            "text": "",
+            "line": sl,
+            "column": sc,
+            "end_line": el,
+            "end_column": ec,
+        })
+
+        it = event.buffer.get_iter_at_mark(event.buffer.get_insert())
+        self._set_cache_refresh_trigger(
+            f.ftype, f.fpath, *self._iter_pos(it)
+        )
+
+    def _request(self, method, lang_id, fpath, **extra):
+        if not (c := self._get_controller(lang_id, method)): return
+
+        uri = self._uri(fpath)
+        self._activate(lang_id)
+
+        payload = {
+            "uri": uri,
+            "language_id": lang_id,
+            "version": self._version(c, uri),
+            **extra
+        }
+
+        getattr(c, method)(payload)
+
+    def process_definition(self, lang_id, fpath, line, column):
+        self._request("_lsp_definition", lang_id, fpath, line = line, column = column)
+
+    def process_implementation_definition(self, lang_id, fpath, line, column):
+        self._request("_lsp_implementation", lang_id, fpath, line = line, column = column)
+
+    def process_references_definition(self, lang_id, fpath, line, column):
+        self._request("_lsp_references", lang_id, fpath, line = line, column = column)
+
+    def process_completion_request(self, lang_id, fpath, line, column):
+        self._request("_lsp_completion", lang_id, fpath, line = line, column = column)
+
+    def _set_cache_refresh_trigger(self, lang_id, fpath, line, column):
+        self.process_completion_request(lang_id, fpath, line, column)

plugins/code/language_server_clients/lsp_manager/mixins/lsp_client_events_mixin.py

@@ -1,144 +0,0 @@
-# Python imports
-
-# Lib imports
-import gi
-
-from gi.repository import GLib
-
-# Application imports
-from libs.event_factory import Code_Event_Types
-
-
-
-class LSPClientEventsMixin:
-
-    def process_file_load(self, event: Code_Event_Types.AddedNewFileEvent):
-        lang_id = event.file.ftype
-        if lang_id not in self.clients:
-            logger.debug(f"No LSP client for '{lang_id}', skipping didOpen")
-            return
-
-        controller = self.clients[lang_id]
-        fpath      = event.file.fpath
-        uri        = f"file://{fpath}" if not fpath.startswith("file://") else fpath
-        buffer     = event.file.buffer
-        text       = buffer.get_text(*buffer.get_bounds())
-        self.active_language_id = lang_id
-
-        controller._lsp_did_open({
-            "uri": uri,
-            "language_id": lang_id,
-            "text": text
-        })
-
-    def process_file_close(self, event: Code_Event_Types.RemovedFileEvent):
-        lang_id = event.file.ftype
-        if lang_id not in self.clients:
-            logger.debug(f"No LSP client for '{lang_id}', skipping didClose")
-            return
-
-        controller = self.clients[lang_id]
-        fpath      = event.file.fpath
-        uri        = f"file://{fpath}" if not fpath.startswith("file://") else fpath
-
-        controller._lsp_did_close({"uri": uri})
-
-    def process_file_save(self, event: Code_Event_Types.SavedFileEvent):
-        lang_id = event.file.ftype
-        if lang_id not in self.clients:
-            logger.debug(f"No LSP client for '{lang_id}', skipping didSave")
-            return
-
-        controller = self.clients[lang_id]
-        fpath      = event.file.fpath
-        uri        = f"file://{fpath}" if not fpath.startswith("file://") else fpath
-        buffer     = event.file.buffer
-        text       = buffer.get_text(*buffer.get_bounds())
-        self.active_language_id = lang_id
-
-        controller._lsp_did_save({"uri": uri, "text": text})
-
-    def process_file_change(self, event: Code_Event_Types.TextChangedEvent):
-        self._clear_delayed_cache_refresh_trigger()
-
-        lang_id = event.file.ftype
-        if lang_id not in self.clients:
-            logger.debug(f"No LSP client for '{lang_id}', skipping didChange")
-            return
-
-        controller = self.clients[lang_id]
-        fpath      = event.file.fpath
-        uri        = f"file://{fpath}" if not fpath.startswith("file://") else fpath
-        buffer     = event.file.buffer
-        text       = buffer.get_text(*buffer.get_bounds())
-        self.active_language_id = lang_id
-
-        controller._lsp_did_change({
-            "uri": uri,
-            "language_id": lang_id,
-            "version": 1,
-            "text": text
-        })
-
-        iter   = buffer.get_iter_at_mark( buffer.get_insert() )
-        line   = iter.get_line()
-        column = iter.get_line_offset()
-        self._set_cache_refresh_trigger(
-            lang_id, fpath, line, column
-        )
-
-
-    def process_goto_definition(
-        self, lang_id: str, fpath: str, line: int, column: int
-    ):
-        if lang_id not in self.clients:
-            logger.debug(f"No LSP client for '{lang_id}', skipping goto definition")
-            return
-
-        controller = self.clients[lang_id]
-        uri        = f"file://{fpath}" if not fpath.startswith("file://") else fpath
-        self.active_language_id = lang_id
-
-        controller._lsp_definition({
-            "uri": uri,
-            "language_id": lang_id,
-            "version": 1,
-            "line": line,
-            "column": column
-        })
-
-    def process_completion_request(
-        self, lang_id: str, fpath: str, line: int, column: int
-    ):
-        if lang_id not in self.clients:
-            logger.debug(f"No LSP client for '{lang_id}', skipping completion")
-            return
-
-        controller = self.clients[lang_id]
-        uri        = f"file://{fpath}" if not fpath.startswith("file://") else fpath
-        self.active_language_id = lang_id
-
-        controller._lsp_completion({
-            "uri": uri,
-            "language_id": lang_id,
-            "version": 1,
-            "line": line,
-            "column": column
-        })
-
-
-    def _clear_delayed_cache_refresh_trigger(self):
-        if self._cache_refresh_timeout_id:
-            GLib.source_remove(self._cache_refresh_timeout_id)
-
-    def _set_cache_refresh_trigger(
-        self, lang_id: str, fpath: str, line: int, column: int
-    ):
-        def trigger_cache_refresh(lang_id, fpath, line, column):
-            self._cache_refresh_timeout_id = None
-            self.process_completion_request(
-                lang_id, fpath, line, column
-            )
-            return False
-
-        self._cache_refresh_timeout_id = GLib.timeout_add(1500, trigger_cache_refresh, lang_id, fpath, line, column)

plugins/code/language_server_clients/lsp_manager/mixins/ui_manager_clients_mixin.py

@@ -0,0 +1,72 @@
+# Python imports
+import json
+
+# Lib imports
+import gi
+
+from gi.repository import GObject
+
+# Application imports
+
+
+
+class UIManagerClientsMixin:
+    def _create_client(self, widget, sibling):
+        if not self.source_view: return
+
+        buffer  = self.source_view.get_buffer()
+        lang_id = self.combo_box.get_active_text()
+
+        if not lang_id: return
+
+        workspace_dir = self.path_entry.get_text()
+        self.emit('create-client', lang_id, workspace_dir)
+
+    def _close_client(self, widget, sibling):
+        lang_id = self.combo_box.get_active_text()
+
+        if not lang_id: return
+
+        self.emit('close-client', lang_id)
+
+    def set_source_view_text(self, workspace_dir: str):
+        lang_id = self.combo_box.get_active_text()
+
+        if not lang_id: return
+
+        json_str = self.client_configs[lang_id]\
+                        .replace("{workspace.folder}", workspace_dir)\
+                        .replace("{user.home}", self._USER_HOME)
+
+        self.source_view.get_buffer().set_text(json_str, -1)
+
+    def add_client_listing(self, lang_id: str, lang_config: str):
+        self.combo_box.append_text(lang_id)
+        self.client_configs[lang_id] = lang_config
+
+    def remove_client_listing(self, lang_id: str):
+        model = self.combo_box.get_model()
+
+        for i, row in enumerate(model):
+            if row[0] == lang_id:
+                self.combo_box.remove(i)
+                break
+
+        self.client_configs.pop(lang_id, None)
+
+    def toggle_client_buttons(self, show_close: bool):
+        self.create_client_bttn.set_visible(not show_close)
+        self.close_client_bttn.set_visible(show_close)
+
+    def get_init_opts(self, lang_id: str) -> dict:
+        if not lang_id or lang_id not in self.client_configs: return {}
+
+        try:
+            buffer      = self.source_view.get_buffer()
+            json_str    = buffer.get_text(*buffer.get_bounds(), -1)
+            lang_config = json.loads(json_str)
+        except json.JSONDecodeError as e:
+            logger.error(f"Invalid JSON for {lang_id}: {e}")
+            return {}
+
+        return lang_config.get("initialization-options", {})

plugins/code/language_server_clients/lsp_manager/mixins/ui_manager_events_mixin.py

@@ -0,0 +1,77 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version("Gtk", "3.0")
+
+from gi.repository import GLib
+from gi.repository import Gtk
+
+# Application imports
+
+
+
+class UIManagerEventsMixin:
+    def _setup_signals(self):
+        self.connect("show", self._handle_show)
+        self.connect("destroy", self._handle_destroy)
+
+    def _subscribe_to_events(self):
+        ...
+
+    def _handle_show(self, widget):
+        GLib.idle_add(self.path_entry.grab_focus)
+
+    def _handle_destroy(self, widget):
+        self.disconnect_by_func(self._handle_show)
+        self.disconnect_by_func(self._handle_destroy)
+        self.path_bttn.disconnect_by_func(self._file_set)
+        self.combo_box.disconnect_by_func(self._on_combo_changed)
+        self.hide_bttn.disconnect(self.hide_bttn_id)
+        self.create_client_bttn.disconnect_by_func(self._create_client)
+        self.close_client_bttn.disconnect_by_func(self._close_client)
+
+    def _map_resize(self, widget, parent):
+        parent_x,     \
+        parent_y      = parent.get_position()
+        parent_width, \
+        parent_height = parent.get_size()
+
+        if parent_width == 0 or parent_height == 0: return
+
+        width  = int(parent_width  * 0.75)
+        height = int(parent_height * 0.75)
+
+        widget.resize(width, height)
+
+        x = parent_x + (parent_width - width)   // 2
+        y = parent_y + (parent_height - height) // 2
+        widget.move(x, y)
+
+    def _path_changed(self, widget, buttons_widget):
+        if not widget.get_text():
+            self.path_bttn.unselect_all()
+            self.path_bttn.emit("file-set")
+            buttons_widget.hide()
+            return
+
+        self.set_source_view_text( self.path_entry.get_text() )
+        buttons_widget.show()
+
+    def _file_set(self, widget):
+        fname = widget.get_filename()
+        fname = "" if not fname else fname
+        self.path_entry.set_text(fname)
+
+        lang_id = self.combo_box.get_active_text()
+        if not lang_id or lang_id not in self.client_configs: return
+
+        self.set_source_view_text(
+            "{workspace.folder}" if not fname else fname
+        )
+
+    def _on_combo_changed(self, combo: Gtk.ComboBoxText):
+        lang_id = combo.get_active_text()
+        self.set_source_view_text( self.path_entry.get_text() )
+

plugins/code/language_server_clients/lsp_manager/mixins/ui_manager_setup_mixin.py

@@ -0,0 +1,98 @@
+# Python imports
+
+# Lib imports
+import gi
+gi.require_version('Gtk', '3.0')
+gi.require_version('GtkSource', '4')
+
+from gi.repository import Gtk
+from gi.repository import GtkSource
+
+# Application imports
+from ..config import get_lsp_host_addr, get_lsp_host_port
+
+
+
+class UIManagerSetupMixin:
+    def _setup_styling(self):
+        self.set_modal(True)
+        self.set_decorated(False)
+        self.set_vexpand(True)
+        self.set_hexpand(True)
+
+    def _load_widgets(self):
+        content_area        = self.get_content_area()
+        self.main_box       = Gtk.Grid()
+        self.path_entry     = Gtk.SearchEntry()
+        self.path_bttn      = Gtk.FileChooserButton.new(
+            title  = "Workspace Folder",
+            action = Gtk.FileChooserAction.SELECT_FOLDER
+        )
+        self.combo_box      = Gtk.ComboBoxText()
+        self.hide_bttn      = Gtk.Button(label = "X")
+
+        self.adddress_entry = Gtk.Entry()
+        adjustment = Gtk.Adjustment(
+            value          = get_lsp_host_port(),
+            lower          = 1,
+            upper          = 65535,
+            step_increment = 1,
+            page_increment = 10,
+            page_size      = 0
+        )
+
+        self.adddress_port = Gtk.SpinButton()
+        self.adddress_port.set_adjustment(adjustment)
+        self.adddress_port.set_digits(0)  # integers only
+
+        bttn_box                = Gtk.Box()
+        self.create_client_bttn = Gtk.Button(label = "Create Language Client")
+        self.close_client_bttn  = Gtk.Button(label = "Close Language Client")
+
+        self.path_entry.set_can_focus(False)
+        self.path_entry.set_placeholder_text("Workspace Folder...")
+        self.path_entry.connect("changed", self._path_changed, bttn_box)
+        self.path_bttn.set_halign(Gtk.Align.FILL)
+
+        self.adddress_entry.set_placeholder_text("Address...")
+        self.adddress_entry.set_text( get_lsp_host_addr() )
+
+        self.path_bttn.connect("file-set", self._file_set)
+        self.combo_box.connect("changed", self._on_combo_changed)
+        self.hide_bttn_id = self.hide_bttn.connect("clicked", lambda widget: self.hide())
+        self.create_client_bttn.connect("clicked", self._create_client, self.close_client_bttn)
+        self.close_client_bttn.connect("clicked", self._close_client, self.create_client_bttn)
+
+        self.main_box.set_column_spacing(15)
+        self.main_box.set_row_spacing(15)
+
+        bttn_box.pack_start(self.create_client_bttn, False, False, 0)
+        bttn_box.pack_start(self.close_client_bttn, False, False, 0)
+
+        self.main_box.attach(child = self.path_entry,     left = 0, top = 0, width = 4, height = 1)
+        self.main_box.attach(child = self.path_bttn,      left = 4, top = 0, width = 1, height = 1)
+        self.main_box.attach(child = self.combo_box,      left = 5, top = 0, width = 1, height = 1)
+        self.main_box.attach(child = self.hide_bttn,      left = 6, top = 0, width = 1, height = 1)
+
+        self.main_box.attach(child = self.adddress_entry, left = 0, top = 1, width = 2, height = 1)
+        self.main_box.attach(child = self.adddress_port,  left = 2, top = 1, width = 2, height = 1)
+        self.main_box.attach(child = bttn_box,            left = 4, top = 1, width = 3, height = 1)
+
+        content_area.set_vexpand(True)
+        content_area.set_hexpand(True)
+
+        content_area.add(self.main_box)
+        content_area.show_all()
+        self.close_client_bttn.hide()
+        bttn_box.hide()
+
+    def set_source_view(self, scrolled_win, source_view):
+        lang_manager     = GtkSource.LanguageManager()
+        buffer           = source_view.get_buffer()
+        language         = lang_manager.get_language("json")
+        self.source_view = source_view
+
+        buffer.set_language(language)
+        buffer.set_style_scheme(self.source_view.syntax_theme)
+
+        self.main_box.attach(scrolled_win, 0, 2, 7, 1)

plugins/code/language_server_clients/lsp_manager/plugin.py

@@ -12,6 +12,7 @@ from libs.dto.states import SourceViewStates
 from plugins.plugin_types import PluginCode
 
 from .dto.code import events as lsp_events
+from .commands import Commands
 from .lsp_manager import LSPManager
 
 
@@ -35,23 +36,11 @@ class Plugin(PluginCode):
 
         window = self.request_ui_element("main-window")
 
-        lsp_manager.lsp_manager_ui.map_parent_resize_event(window)
+        lsp_manager.ui_manager.map_parent_resize_event(window)
 
-        event  = Event_Factory.create_event("register_command",
+        self._manage_signals("register_command")
-            command_name = "LSP Manager",
-            command      = Handler,
-            binding_mode = "released",
-            binding      = ["<Shift><Control>l", "<Control>g", "<Control>i"]
-        )
-        self.emit_to("source_views", event)
 
-        event  = Event_Factory.create_event(
+        self._manage_provider("register_provider")
-            "register_provider",
-            provider_name = "LSP Completer",
-            provider      = lsp_manager.provider,
-            language_ids  = []
-        )
-        self.emit_to("completion", event)
 
         event  = Event_Factory.create_event(
             "create_source_view",
@@ -59,8 +48,8 @@ class Plugin(PluginCode):
         )
         self.emit_to("source_views", event)
 
-        source_view = event.response
+        scrolled_win, source_view = event.response
-        lsp_manager.lsp_manager_ui.set_source_view(source_view)
+        lsp_manager.ui_manager.set_source_view(scrolled_win, source_view)
 
     def unload(self):
         Event_Factory.unregister_events( lsp_events.__dict__.items() )
@@ -69,56 +58,61 @@ class Plugin(PluginCode):
 
         window = self.request_ui_element("main-window")
 
-        lsp_manager.lsp_manager_ui.unmap_parent_resize_event(window)
+        lsp_manager.ui_manager.unmap_parent_resize_event(window)
 
-        event  = Event_Factory.create_event("unregister_command",
+        self._manage_signals("unregister_command")
-            command_name = "LSP Manager",
+
-            command      = Handler,
+        self._manage_provider("unregister_provider")
+
+        lsp_manager.handle_destroy()
+
+    def _manage_signals(self, action: str):
+        _commands             = Commands
+        _commands.lsp_manager = lsp_manager
+
+        event = Event_Factory.create_event(action,
+            command_name = "lsp_manager_toggle",
+            command      = _commands.lsp_manager_toggle,
             binding_mode = "released",
-            binding      = ["<Shift><Control>l", "<Control>g", "<Control>i"]
+            binding      = "<Shift><Control>l"
         )
         self.emit_to("source_views", event)
 
-        event  = Event_Factory.create_event(
+        event = Event_Factory.create_event(action,
-            "unregister_provider",
+            command_name = "lsp_references",
-            provider_name = "LSP Completer"
+            command      = _commands.lsp_references,
+            binding_mode = "released",
+            binding      = "<Control>i"
+        )
+        self.emit_to("source_views", event)
+
+        event = Event_Factory.create_event(action,
+            command_name = "lsp_implementation",
+            command      = _commands.lsp_implementation,
+            binding_mode = "released",
+            binding      = "<Shift><Control>i"
+        )
+        self.emit_to("source_views", event)
+
+        event = Event_Factory.create_event(action,
+            command_name = "lsp_definition",
+            command      = _commands.lsp_definition,
+            binding_mode = "released",
+            binding      = "<Control>g"
+        )
+        self.emit_to("source_views", event)
+
+    def _manage_provider(self, action: str):
+        event = Event_Factory.create_event(
+            action,
+            provider_name = "LSP Completer",
+            provider      = lsp_manager.provider,
+            language_ids  = []
         )
         self.emit_to("completion", event)
 
-        lsp_manager.handle_destroy()
-
     def run(self):
         ...
 
     def generate_plugin_element(self):
         ...
-
-
-class Handler:
-    @staticmethod
-    def execute(
-        view: any,
-        *args,
-        **kwargs
-    ):
-        logger.debug("Command: LSP Manager")
-
-        char_str = args[0]
-        if char_str in ["g", "i"]:
-            file   = view.command.exec("get_current_file")
-            buffer = view.get_buffer()
-            iter   = buffer.get_iter_at_mark( buffer.get_insert() )
-            line   = iter.get_line()
-            column = iter.get_line_offset()
-
-            if char_str == "g":
-                lsp_manager.lsp_manager_client.process_goto_definition(
-                    file.ftype, file.fpath, line, column
-                )
-
-                return
-
-            if char_str == "i":
-                return
-
-        lsp_manager.lsp_manager_ui.hide() if lsp_manager.lsp_manager_ui.is_visible() else lsp_manager.lsp_manager_ui.show()

plugins/code/language_server_clients/lsp_manager/provider/provider.py

@@ -32,20 +32,7 @@ class Provider(GObject.GObject, GtkSource.CompletionProvider):
         return "LSP Code Completion"
 
     def do_match(self, context):
-        # Note: If provider is in interactive activation then need to check
-        # view focus as otherwise non focus views start trying to grab it.
-        # completion = context.get_property("completion")
-        # if not completion.get_view().has_focus(): return
-
         iter = self.response_cache.get_iter_correctly(context)
-        iter.backward_char()
-        ch = iter.get_char()
-
-        # NOTE: Look to re-add or apply supporting logic to use spaces
-        # As is it slows down the editor in certain contexts...
-        # if not (ch in ('_', '.', ' ') or ch.isalnum()):
-        if not (ch in ('_', '.') or ch.isalnum()):
-            return False
 
         buffer = iter.get_buffer()
         if buffer.get_context_classes_at_iter(iter) != ['no-spell-check']:
@@ -68,6 +55,7 @@ class Provider(GObject.GObject, GtkSource.CompletionProvider):
 #        return GtkSource.CompletionActivation.NONE
         return GtkSource.CompletionActivation.USER_REQUESTED
 #        return GtkSource.CompletionActivation.INTERACTIVE
+#        return GtkSource.CompletionActivation.USER_REQUESTED | GtkSource.CompletionActivation.INTERACTIVE
 
     def do_populate(self, context):
         results   = self.response_cache.filter_with_context(context)

plugins/code/language_server_clients/lsp_manager/provider/provider_response_cache.py

@@ -33,9 +33,13 @@ class ProviderResponseCache(ProviderResponseCacheBase):
         if self.lsp_manager_client:
             self.lsp_manager_client.process_file_save(event)
 
-    def process_file_change(self, event):
+    def process_file_text_inserted(self, event):
         if self.lsp_manager_client:
-            self.lsp_manager_client.process_file_change(event)
+            self.lsp_manager_client.process_file_text_inserted(event)
+
+    def process_file_delete_range(self, event):
+        if self.lsp_manager_client:
+            self.lsp_manager_client.process_file_delete_range(event)
 
     def filter(self, word: str) -> list[dict]:
         return []

plugins/code/language_server_clients/lsp_manager/response_handlers/default.py

@@ -17,10 +17,18 @@ class DefaultHandler(BaseHandler):
 
     def handle(self, method: str, response, controller):
         match method:
+            case "initialize":
+                controller.send_initialized_notification()
+            case "shutdown":
+                controller.send_exit_notification()
             case "textDocument/completion":
                 self._handle_completion(response)
             case "textDocument/definition":
                 self._handle_definition(response, controller)
+            case "textDocument/references":
+                ...
+            case "textDocument/implementation":
+                ...
             case "textDocument/publishDiagnostics":
                 self._handle_diagnostics(response)
 
@@ -130,5 +138,5 @@ class DefaultHandler(BaseHandler):
             view     = view,
             provider = self.context._provider
         )
-        self.emit_to("completion", event)
 
+        self.emit_to("completion", event)

plugins/code/language_server_clients/lsp_manager/ui_manager.py

@@ -0,0 +1,44 @@
+# Python imports
+from os import path
+
+# Lib imports
+import gi
+
+from gi.repository import GObject
+from gi.repository import Gtk
+
+# Application imports
+from .mixins.ui_manager_setup_mixin   import UIManagerSetupMixin
+from .mixins.ui_manager_events_mixin  import UIManagerEventsMixin
+from .mixins.ui_manager_clients_mixin import UIManagerClientsMixin
+
+
+
+class UIManager(
+    Gtk.Dialog,
+    UIManagerSetupMixin,
+    UIManagerEventsMixin,
+    UIManagerClientsMixin
+):
+    __gsignals__ = {
+        'create-client': (GObject.SignalFlags.RUN_LAST, None, (str, str)),
+        'close-client':  (GObject.SignalFlags.RUN_LAST, None, (str,)),
+    }
+
+    def __init__(self):
+        super(UIManager, self).__init__()
+        self._USER_HOME = path.expanduser("~")
+        self.client_configs: dict[str, str] = {}
+        self.source_view = None
+
+        self._setup_styling()
+        self._setup_signals()
+        self._subscribe_to_events()
+        self._load_widgets()
+
+
+    def map_parent_resize_event(self, parent):
+        self.size_allocate_id = parent.connect("size-allocate", lambda w, r: self._map_resize(self, parent))
+
+    def unmap_parent_resize_event(self, parent):
+        parent.disconnect(self.size_allocate_id)

plugins/code/language_server_clients/python_lsp_client/config/lsp-server-config.json

@@ -47,9 +47,16 @@
                 },
                 "jedi_completion": {
                     "enabled": true,
+                    "fuzzy": true,
+                    "include_params": false,
                     "include_class_objects": true,
-                    "include_function_objects": true,
+                    "include_function_objects": true
-                    "fuzzy": false
+                },
+                "jedi_signature_help": {
+                    "enabled": true
+                },
+                "jedi_references": {
+                    "enabled": true
                 },
                 "jedi": {
                     "root_dir": "file://{workspace.folder}",

plugins/code/ui/code_minimap/plugin.py

@@ -30,6 +30,7 @@ class Plugin(PluginCode):
 
         event = Event_Factory.create_event("get_active_view")
         self.emit_to("source_views", event)
+        if not event.response: return
         code_minimap.set_smini_view(event.response)
 
     def unload(self):

src/__main__.py

@@ -4,12 +4,12 @@
 import argparse
 import faulthandler
 import traceback
-from setproctitle import setproctitle
 
 import tracemalloc
 tracemalloc.start()
 
 # Lib imports
+from setproctitle import setproctitle
 
 # Application imports
 from __builtins__ import *

src/core/controllers/base_controller.py

@@ -81,7 +81,7 @@ class BaseController(IPCSignalsMixin, KeyboardSignalsMixin, BaseControllerMixin)
 
     def _load_files(self):
         for file in settings_manager.get_starting_files():
-            event_system.emit("post-file-to-ipc", file)
+            event_system.emit("post-file-to-ipc", f"FILE|{file}")
 
     def _tggl_top_main_menubar(self):
         logger.debug("_tggl_top_main_menubar > stub...")

src/core/widgets/code/command_system/command_helpers.py

@@ -8,7 +8,10 @@ from gi.repository import GtkSource
 
 
 def set_language_and_style(view, file):
-    language   = view.language_manager.guess_language(file.fname, None)
+    language = None
+    if not file.fname == "buffer":
+        language = view.language_manager.guess_language(file.fname, None)
+
     file.buffer.set_language(language)
     file.buffer.set_style_scheme(view.syntax_theme)
 

src/core/widgets/code/command_system/commands/duplicate_line.py

@@ -11,45 +11,45 @@ from gi.repository import GtkSource
 
 
 
-def execute(
+def execute(view: GtkSource.View, *args, **kwargs):
-    view: GtkSource.View,
-    *args,
-    **kwargs
-):
     logger.debug("Command: Duplicate Line")
 
     buffer = view.get_buffer()
 
-    if not buffer.get_has_selection():
+    if buffer.get_has_selection():
-        had_selection = False
+        start_itr, \
-        itr        = buffer.get_iter_at_mark( buffer.get_insert() )
+        end_itr    = buffer.get_selection_bounds()
-        start_itr  = itr.copy()
+        start_line = start_itr.get_line()
-        end_itr    = itr.copy()
+        end_line   = end_itr.get_line()
-        start_line = itr.get_line() + 1
+        scol       = start_itr.get_line_offset()
-        start_char = itr.get_line_offset()
+        ecol       = end_itr.get_line_offset()
     else:
-        had_selection = True
+        itr        = buffer.get_iter_at_mark(buffer.get_insert())
-        start_itr, end_itr = buffer.get_selection_bounds()
+        start_line = end_line = itr.get_line()
-        sline      = start_itr.get_line()
+        col        = itr.get_line_offset()
-        eline      = end_itr.get_line()
-        start_line = eline + 1
-        start_char = start_itr.get_line_offset()
-        end_char   = end_itr.get_line_offset()
-        range_line_size  = eline - sline
 
-    start_itr.backward_visible_line()
+    start_itr = buffer.get_iter_at_line(start_line)
-    start_itr.forward_line()
+    end_itr   = buffer.get_iter_at_line(end_line)
-    end_itr.forward_line()
-    end_itr.backward_char()
 
-    line_str = buffer.get_slice(start_itr, end_itr, True)
+    if not end_itr.ends_line():
-    end_itr.forward_char()
+        end_itr.forward_to_line_end()
-    buffer.insert(end_itr, f"{line_str}\n", -1)
 
-    if not had_selection:
+    if not end_itr.is_end():
-        new_itr = buffer.get_iter_at_line_offset(start_line, start_char)
+        end_itr.forward_char()
-        buffer.place_cursor(new_itr)
+
+    text       = buffer.get_text(start_itr, end_itr, True)
+    insert_itr = buffer.get_iter_at_line(end_line)
+
+    insert_itr.forward_to_line_end()
+    if not insert_itr.is_end():
+        insert_itr.forward_char()
+
+    buffer.insert(insert_itr, text)
+
+    if buffer.get_has_selection():
+        new_start = buffer.get_iter_at_line_offset(end_line + 1, scol)
+        new_end   = buffer.get_iter_at_line_offset(end_line + 1 + (end_line - start_line), ecol)
+        buffer.select_range(new_start, new_end)
     else:
-        new_itr     = buffer.get_iter_at_line_offset(start_line, start_char)
+        new_start = buffer.get_iter_at_line_offset(end_line + 1, col)
-        new_end_itr = buffer.get_iter_at_line_offset((start_line + range_line_size), end_char)
+        buffer.place_cursor(new_start)
-        buffer.select_range(new_itr, new_end_itr)

src/core/widgets/code/completion_providers/provider_response_cache_base.py

@@ -36,8 +36,11 @@ class ProviderResponseCacheBase:
     def process_file_save(self, event: Code_Event_Types.SavedFileEvent):
         raise ProviderResponseCacheException("ProviderResponseCacheBase 'process_file_save' not implemented...")
 
-    def process_file_change(self, event: Code_Event_Types.TextChangedEvent):
+    def process_file_text_inserted(self, event: Code_Event_Types.TextInsertedEvent):
-        raise ProviderResponseCacheException("ProviderResponseCacheBase 'process_change' not implemented...")
+        raise ProviderResponseCacheException("ProviderResponseCacheBase 'process_file_text_inserted' not implemented...")
+
+    def process_file_delete_range(self, event: Code_Event_Types.DeleteRangeEvent):
+        raise ProviderResponseCacheException("ProviderResponseCacheBase 'process_file_delete_range' not implemented...")
 
     def filter(self, word: str) -> list[dict]:
         raise ProviderResponseCacheException("ProviderResponseCacheBase 'filter' not implemented...")

src/core/widgets/code/controllers/completion_controller.py

@@ -4,7 +4,6 @@
 import gi
 gi.require_version('GtkSource', '4')
 
-from gi.repository import GLib
 from gi.repository import GtkSource
 
 # Application imports
@@ -41,8 +40,10 @@ class CompletionController(ControllerBase):
             self.provider_process_file_close(event)
         elif isinstance(event, Code_Event_Types.SavedFileEvent):
             self.provider_process_file_save(event)
-        elif isinstance(event, Code_Event_Types.TextChangedEvent):
+        elif isinstance(event, Code_Event_Types.TextInsertedEvent):
-            self.provider_process_file_change(event)
+            self.provider_process_file_text_inserted(event)
+        elif isinstance(event, Code_Event_Types.DeleteRangeEvent):
+            self.provider_process_file_delete_range(event)
         elif isinstance(event, Code_Event_Types.RequestCompletionEvent):
             self.request_unbound_completion(event)
 
@@ -88,9 +89,13 @@ class CompletionController(ControllerBase):
         for provider in self._providers.values():
             provider.response_cache.process_file_save(event)
 
-    def provider_process_file_change(self, event: Code_Event_Types.TextChangedEvent):
+    def provider_process_file_text_inserted(self, event: Code_Event_Types.TextInsertedEvent):
         for provider in self._providers.values():
-            provider.response_cache.process_file_change(event)
+            provider.response_cache.process_file_text_inserted(event)
+
+    def provider_process_file_delete_range(self, event: Code_Event_Types.DeleteRangeEvent):
+        for provider in self._providers.values():
+            provider.response_cache.process_file_delete_range(event)
 
     def request_unbound_completion(self, event: Code_Event_Types.RequestCompletionEvent):
         completer = event.view.get_completion()

src/core/widgets/code/controllers/views/source_views_controller.py

@@ -128,6 +128,7 @@ class SourceViewsController(ControllerBase, list):
 
         self.append(source_view)
         scrolled_win.add(source_view)
+        scrolled_win.show_all()
 
         event = Event_Factory.create_event(
             "created_source_view", view = source_view

src/core/widgets/code/source_buffer.py

@@ -31,6 +31,7 @@ class SourceBuffer(GtkSource.Buffer):
         _insert_text,
         _after_insert_text,
         _modified_changed,
+        _delete_range,
     ):
 
         self._handler_ids = [
@@ -39,7 +40,8 @@ class SourceBuffer(GtkSource.Buffer):
             self.connect("mark-set",          _mark_set),
             self.connect("insert-text",       _insert_text),
             self.connect_after("insert-text", _after_insert_text),
-            self.connect("modified-changed",  _modified_changed)
+            self.connect("modified-changed",  _modified_changed),
+            self.connect("delete-range",      _delete_range)
         ]
 
     def block_changed_signal(self):
@@ -54,6 +56,9 @@ class SourceBuffer(GtkSource.Buffer):
     def block_modified_changed_signal(self):
         self.handler_block(self._handler_ids[5])
 
+    def block_delete_range(self):
+        self.handler_block(self._handler_ids[6])
+
     def unblock_changed_signal(self):
         self.handler_unblock(self._handler_ids[0])
 
@@ -66,6 +71,9 @@ class SourceBuffer(GtkSource.Buffer):
     def unblock_modified_changed_signal(self):
         self.handler_unblock(self._handler_ids[5])
 
+    def unblock_delete_range(self):
+        self.handler_block(self._handler_ids[6])
+
     def clear_signals(self):
         for handle_id in self._handler_ids:
             self.disconnect(handle_id)

src/core/widgets/code/source_file.py

@@ -40,7 +40,8 @@ class SourceFile(GtkSource.File):
             self._mark_set,
             self._insert_text,
             self._after_insert_text,
-            self._modified_changed
+            self._modified_changed,
+            self._delete_range
         )
 
     def _changed(self, buffer: SourceBuffer):
@@ -60,7 +61,20 @@ class SourceFile(GtkSource.File):
         location: Gtk.TextIter,
         text: str, length: int
     ):
-        ...
+        event = Event_Factory.create_event(
+            "text_insert",
+            file     = self,
+            buffer   = self.buffer,
+            location = location,
+            text     = text,
+            length   = length
+        )
+
+        # Note: 'idle_add' needed b/c markers don't get thir positions
+        #      updated relative to the initial insert.
+        #      If not used, seg faults galor during multi insert.
+        # GLib.idle_add(self.emit, event)
+        self.emit(event)
 
     def _after_insert_text(
         self,
@@ -99,7 +113,19 @@ class SourceFile(GtkSource.File):
     def _modified_changed(self, buffer: SourceBuffer):
         event = Event_Factory.create_event(
             "modified_changed",
-            file = self, buffer = buffer
+            file = self,
+            buffer = buffer
+        )
+
+        self.emit(event)
+
+    def _delete_range(self, buffer: SourceBuffer, start: Gtk.TextIter, end: Gtk.TextIter):
+        event = Event_Factory.create_event(
+            "delete_range",
+            file   = self,
+            buffer = buffer,
+            start  = start,
+            end    = end,
         )
 
         self.emit(event)

src/core/widgets/vte_widget.py

@@ -28,8 +28,8 @@ class VteWidget(Vte.Terminal):
     def __init__(self):
         super(VteWidget, self).__init__()
 
-        self.cd_cmd_prefix = ("cd".encode(), "cd ".encode())
+        self.cd_cmd_prefix: tuple = ("cd".encode(), "cd ".encode())
-        self.dont_process  = False
+        self.dont_process: bool   = False
 
         self._setup_styling()
         self._setup_signals()
@@ -48,9 +48,17 @@ class VteWidget(Vte.Terminal):
         self.set_hexpand(True)
         self.set_enable_sixel(True)
         self.set_cursor_shape( Vte.CursorShape.IBEAM )
+        self.set_audible_bell(False)
+        self.set_scroll_on_output(True)
 
     def _setup_signals(self):
-        self.connect("commit", self._commit)
+       self.connect("commit", self._handle_commit)
+       self.connect("current-directory-uri-changed", self._handle_path_change)
+       self.connect("selection-changed", self._handle_selection)
+       self.connect("button-press-event", self._on_button_press)
+       self.connect("key-press-event", self._on_key_press)
+       self.connect("key-release-event", self._on_key_release)
+       self.connect("destroy", self._handle_destroy)
 
     def _subscribe_to_events(self):
         event_system.subscribe("update_term_path", self.update_term_path)
@@ -59,35 +67,87 @@ class VteWidget(Vte.Terminal):
         ...
 
     def _do_session_spawn(self):
-        env = [
+        env_dict    = os.environ.copy()
-            "DISPLAY=:0",
+        existing_pc = env_dict.get("PROMPT_COMMAND", "")
-            "LC_ALL=C",
+        # Note: Needed for 'current-directory-uri-changed' to work.
-            "TERM='xterm-256color'",
+        #       Make sure user .bashrc doesn't affect it...
-            f"HOME='{settings_manager.path_manager.get_home_path()}'",
+        osc7        = 'printf "\\033]7;file://%s%s\\007" "$PWD"'
-            "XDG_RUNTIME_DIR='/run/user/1000'",
-            f"XAUTHORITY='{settings_manager.path_manager.get_home_path()}/.Xauthority'",
-            "HISTFILE=/dev/null",
-            "HISTSIZE=0",
-            "HISTFILESIZE=0",
-            "PS1=\\h@\\u \\W -->: ",
-        ]
 
-        self.spawn_sync(
+        env_dict.update({
+            "LC_ALL": "C",
+            "TERM": "xterm-256color",
+            "HISTFILE": "/dev/null",
+            "HISTSIZE": "0",
+            "HISTFILESIZE": "0",
+            "PS1": "\\h@\\u \\W -->: ",
+            "PROMPT_COMMAND": f"{osc7};{existing_pc}" if existing_pc else osc7,
+        })
+
+        env = [f"{k}={v}" for k, v in env_dict.items()]
+
+        self.spawn_async(
             Vte.PtyFlags.DEFAULT,
             settings_manager.path_manager.get_home_path(),
-            ["/bin/bash"],
+            ["/bin/bash", "--rcfile", f"{settings_manager.path_manager.get_home_path()}/.bashrc", "-i"],
             env,
             GLib.SpawnFlags.DEFAULT,
-            None, None,
+            None, None, -1, None, None,
         )
 
         startup_cmds = [
         ]
 
+        self.set_scrollback_lines(15000)
         for i in startup_cmds:
             self.run_command(i)
 
-    def _commit(self, terminal, text, size):
+    def _handle_destroy(self, terminal):
+        logger.debug("Destroying terminal...")
+        terminal.disconnect_by_func(terminal._handle_commit)
+        terminal.disconnect_by_func(terminal._handle_path_change)
+        terminal.disconnect_by_func(terminal._handle_selection)
+        terminal.disconnect_by_func(terminal._on_button_press)
+        terminal.disconnect_by_func(terminal._on_key_press)
+        terminal.disconnect_by_func(terminal._on_key_release)
+        terminal.disconnect_by_func(terminal._handle_destroy)
+
+    def _handle_path_change(self, terminal):
+        if not hasattr(self, "label"): return
+
+        uri = terminal.get_current_directory_uri().replace("file://", "")
+
+        terminal.label.set_text(uri)
+        terminal.label.set_tooltip_text(uri)
+
+    def _handle_selection(self, *args):
+        if self.get_has_selection():
+            self.copy_primary()
+
+    def _on_button_press(self, widget, event):
+        if event.button == 2:  # middle click
+            self.paste_clipboard()
+            return True
+
+    def _on_key_press(self, widget, event):
+        ctrl_pressed  = event.state & Gdk.ModifierType.CONTROL_MASK
+        shift_pressed = event.state & Gdk.ModifierType.SHIFT_MASK
+
+        if ctrl_pressed:
+            if shift_pressed:
+                if event.keyval in [Gdk.KEY_C, Gdk.KEY_V]:
+                    if event.keyval == Gdk.KEY_C:
+                        self.copy_clipboard()
+                    elif event.keyval == Gdk.KEY_V:
+                        self.paste_clipboard()
+
+                    return True
+
+        return False
+
+    def _on_key_release(self, widget, event):
+        ...
+
+    def _handle_commit(self, terminal, text, size):
         if self.dont_process:
             self.dont_process = False
             return

src/core/widgets/webkit/webkit_ui.py

@@ -5,7 +5,7 @@ import json
 # Lib imports
 import gi
 gi.require_version('Gdk', '3.0')
-gi.require_version('WebKit2', '4.0')
+gi.require_version('WebKit2', '4.1')
 from gi.repository import Gdk
 from gi.repository import Gtk
 from gi.repository import Gio

src/libs/dto/code/events/__init__.py

@@ -26,8 +26,10 @@ from .get_source_views_event import GetSourceViewsEvent
 from .create_command_system_event import CreateCommandSystemEvent
 from .request_completion_event import RequestCompletionEvent
 from .cursor_moved_event import CursorMovedEvent
+from .delete_range_event import DeleteRangeEvent
 from .modified_changed_event import ModifiedChangedEvent
 from .text_changed_event import TextChangedEvent
+from .text_insert_event import TextInsertEvent
 from .text_inserted_event import TextInsertedEvent
 from .focused_view_event import FocusedViewEvent
 from .set_active_file_event import SetActiveFileEvent

src/libs/dto/code/events/delete_range_event.py

@@ -0,0 +1,19 @@
+# Python imports
+from dataclasses import dataclass, field
+
+# Lib imports
+import gi
+
+gi.require_version('Gtk', '3.0')
+
+from gi.repository import Gtk
+
+# Application imports
+from .code_event import CodeEvent
+
+
+
+@dataclass
+class DeleteRangeEvent(CodeEvent):
+    start: Gtk.TextIter = None
+    end: Gtk.TextIter   = None

src/libs/dto/code/events/text_insert_event.py

@@ -0,0 +1,20 @@
+# Python imports
+from dataclasses import dataclass, field
+
+# Lib imports
+import gi
+
+gi.require_version('Gtk', '3.0')
+
+from gi.repository import Gtk
+
+# Application imports
+from .code_event import CodeEvent
+
+
+
+@dataclass
+class TextInsertEvent(CodeEvent):
+    location: Gtk.TextIter = None
+    text: str              = ""
+    length: int            = 0

src/libs/dto/code/events/unregister_provider_event.py

@@ -1,7 +1,11 @@
 # Python imports
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 
 # Lib imports
+import gi
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
 
 # Application imports
 from .code_event import CodeEvent
@@ -10,4 +14,6 @@ from .code_event import CodeEvent
 
 @dataclass
 class UnregisterProviderEvent(CodeEvent):
-    provider_name: str = ""
+    provider_name: str                     = ""
+    provider: GtkSource.CompletionProvider = None
+    language_ids: list                     = field(default_factory=lambda: [])

src/libs/event_factory.py

@@ -31,7 +31,7 @@ class EventFactory(Singleton):
             event_type = self._class_name_to_event_type(name)
 
             self._event_classes[event_type] = obj
-            Code_Event_Types.add_event_class(name, obj)
+            App_Event_Types.add_event_class(name, obj)
             i += 1
 
         logger.debug(f"Registered {i} event types:")
@@ -44,7 +44,7 @@ class EventFactory(Singleton):
             event_type = self._class_name_to_event_type(name)
 
             del self._event_classes[event_type]
-            Code_Event_Types.remove_event_class(name)
+            App_Event_Types.remove_event_class(name)
             i += 1
 
         logger.debug(f"Unregistered {i} event types:")
@@ -98,6 +98,7 @@ class EventNamespace:
 
 
 
-Code_Event_Types = EventNamespace()
+App_Event_Types  = EventNamespace()
+Code_Event_Types = App_Event_Types
 Event_Factory    = EventFactory()
 

src/libs/settings/options/config.py

@@ -35,5 +35,5 @@ class Config:
     main_window_height: int          = 600
     application_dirs: list           = field(default_factory=lambda: [
         "/usr/share/applications",
-        f"{settings_manager.get_home_path()}/.local/share/applications"
+        f"{settings_manager.path_manager.get_home_path()}/.local/share/applications"
     ])

src/libs/settings/path_manager.py

@@ -88,6 +88,7 @@ class PathManager:
     def get_ui_widgets_path(self)  -> str: return self._UI_WIDGETS_PATH
     def get_context_path(self)     -> str: return self._CONTEXT_PATH
     def get_plugins_path(self)     -> str: return self._PLUGINS_PATH
+    def get_icons_path(self)       -> str: return self._DEFAULT_ICONS
     def get_css_file(self)         -> str: return self._CSS_FILE
     def get_home_config_path(self) -> str: return self._HOME_CONFIG_PATH
     def get_window_icon(self)      -> str: return self._WINDOW_ICON

src/libs/settings/webkit/webkit_ui_settings.py

@@ -2,7 +2,7 @@
 
 # Lib imports
 import gi
-gi.require_version('WebKit2', '4.0')
+gi.require_version('WebKit2', '4.1')
 from gi.repository import WebKit2
 
 # Application imports

src/libs/widget_registery.py

@@ -30,6 +30,7 @@ class WidgetRegisteryController(ControllerBase):
 
         widgets = self._builder.get_objects()
         for widget in widgets:
+            if not hasattr(widget, "get_name"): continue
             self.builder_keys.append( widget.get_name() )
 
     def _controller_message(self, event: BaseEvent):

src/plugins/controller.py

@@ -13,7 +13,7 @@ from gi.repository import Gtk
 from gi.repository import GLib
 
 # Application imports
-from libs.event_factory import Event_Factory, Code_Event_Types
+from libs.event_factory import Event_Factory, App_Event_Types, Code_Event_Types
 from libs.controllers.controller_base import ControllerBase
 from libs.dto.plugins.manifest_meta import ManifestMeta
 from libs.dto.base_event import BaseEvent
@@ -58,7 +58,7 @@ class PluginsController(ControllerBase, PluginsControllerMixin, PluginReloadMixi
             item = Gtk.MenuItem(label = "Plugins")
             item.connect("activate", self.toggle_plugins_ui)
             event.menu.append(item)
-        elif isinstance(event, Code_Event_Types.TogglePluginsUiEvent):
+        elif isinstance(event, App_Event_Types.TogglePluginsUiEvent):
             self.toggle_plugins_ui()
 
     def _collect_search_locations(self, path: str, locations: list):

src/plugins/plugins_ui.py

@@ -2,7 +2,10 @@
 
 # Lib imports
 import gi
+gi.require_version('Gdk', '3.0')
 from gi.repository import Gtk
+from gi.repository import Gdk
+from gi.repository import GLib
 
 # Application imports
 
@@ -25,6 +28,7 @@ class PluginsUI(Gtk.Dialog):
 
         self.set_title("Plugins")
         self.set_size_request(450, 530)
+        self.set_modal(False)
         self.set_deletable(False)
         self.set_skip_pager_hint(True)
         self.set_skip_taskbar_hint(True)
@@ -35,9 +39,13 @@ class PluginsUI(Gtk.Dialog):
 
         window = widget_registery.get_object("main-window")
         self.set_transient_for(window)
+        self.set_destroy_with_parent(True)
+
+        self.set_position(Gtk.WindowPosition.CENTER_ON_PARENT)
 
     def _setup_signals(self):
-        ...
+        self.connect("focus-out-event", self._on_focus_out)
+        self.connect("key-release-event", self._on_key_release)
 
     def _subscribe_to_events(self):
         ...
@@ -59,6 +67,19 @@ class PluginsUI(Gtk.Dialog):
 
         scrolled_win.show_all()
 
+    def _on_key_release(self, widget, event):
+        ctrl_pressed  = event.state & Gdk.ModifierType.CONTROL_MASK
+        shift_pressed = event.state & Gdk.ModifierType.SHIFT_MASK
+
+        if ctrl_pressed:
+            if shift_pressed:
+                if event.keyval == Gdk.KEY_P:
+                    self.hide()
+
+    def _on_focus_out(self, *args):
+        self.hide()
+        GLib.idle_add(self.hide)
+
     def add_row(self, manifest_meta, callback: callable):
         box         = Gtk.Box()
         plugin_lbl  = Gtk.Label(label = manifest_meta.manifest.name)