Fixed code view close_file command

plugins/README.txt

@@ -10,22 +10,22 @@ class Manifest:
     author: str   = "John Doe"
     version: str  = "0.0.1"
     support: str  = ""
+    pre_launch: bool = False
     requests: {}  = {
         'pass_ui_objects': ["plugin_control_list"],
-        'pass_events': "true",
+        'pass_events': True,
         'bind_keys': []
     }
-    pre_launch: bool = False
 ```
 
 
 ### Requests
 ```
 requests: {}  = {
-    'pass_events': "true",                                # If empty or not present will be ignored.
-    "pass_ui_objects": [""],                              # Request reference to a UI component. Will be passed back as array to plugin.
+    'pass_events': true,                                # If empty or not present will be ignored.
+    "pass_ui_objects": [""],                            # Request reference to a UI component. Will be passed back as array to plugin.
     'bind_keys': [f"{name}||send_message:<Control>f"],
-                  f"{name}||do_save:<Control>s"]          # Bind keys with method and key pare using list. Must pass "name" like shown with delimiter to its right.
+                  f"{name}||do_save:<Control>s"]        # Bind keys with method and key pare using list. Must pass "name" like shown with delimiter to its right.
 
 }
 ```

plugins/template/manifest.json

@@ -6,7 +6,7 @@
         "support": "",
         "requests": {
             "ui_target": "plugin_control_list",
-            "pass_events": "true",
+            "pass_events": true,
             "bind_keys": ["Example Plugin||send_message:<Control>f"]
         }
     }

pyrightconfig.json

@@ -5,7 +5,7 @@
     "reportDuplicateImport": true,
     "executionEnvironments": [
         {
-            "root": "./src/versions/solarfm-0.0.1/solarfm"
+            "root": "./src/"
         }
     ],
     "venvPath": ".",

src/__builtins__.py

@@ -1,5 +1,6 @@
 # Python imports
 import builtins
+import traceback
 import threading
 import sys
 
@@ -31,6 +32,17 @@ def daemon_threaded_wrapper(fn):
         return thread
     return wrapper
 
+def call_chain_wrapper(fn):
+    def wrapper(*args, **kwargs):
+        print()
+        print()
+        for line in traceback.format_stack():
+            print( line.strip() )
+        print()
+        print()
+
+        return fn(*args, **kwargs)
+    return wrapper
 
 
 # NOTE: Just reminding myself we can add to builtins two different ways...
@@ -45,15 +57,15 @@ builtins.settings_manager  = SettingsManager()
 
 settings_manager.load_settings()
 
-builtins.settings          = settings_manager.settings
 builtins.logger            = Logger(
-                                settings_manager.get_home_config_path(), \
-                                _ch_log_lvl = settings.debugging.ch_log_lvl, \
-                                _fh_log_lvl = settings.debugging.fh_log_lvl
+                                settings_manager.path_manager.get_home_config_path(), \
+                                _ch_log_lvl = settings_manager.settings.debugging.ch_log_lvl, \
+                                _fh_log_lvl = settings_manager.settings.debugging.fh_log_lvl
                             ).get_logger()
 
 builtins.threaded          = threaded_wrapper
 builtins.daemon_threaded   = daemon_threaded_wrapper
+builtins.call_chain        = call_chain_wrapper
 
 
 

src/__main__.py

@@ -28,7 +28,9 @@ def main():
         settings_manager.set_trace_debug(True)
 
     settings_manager.do_dirty_start_check()
-    Application()
+
+    app = Application()
+    app.run()
 
 
 

src/app.py

@@ -1,4 +1,5 @@
 # Python imports
+from contextlib import suppress
 import signal
 import os
 
@@ -22,45 +23,54 @@ class Application:
     def __init__(self):
         super(Application, self).__init__()
 
-        if not settings_manager.is_trace_debug():
-            self.load_ipc()
-
         self.setup_debug_hook()
-        Window().main()
 
 
+    def run(self):
+        if not settings_manager.is_trace_debug():
+            if not self.load_ipc():
+                return
+
+        win = Window()
+        win.start()
+
     def load_ipc(self):
         args, \
         unknownargs = settings_manager.get_starting_args()
         ipc_server  = IPCServer()
 
         self.ipc_realization_check(ipc_server)
-        if not ipc_server.is_ipc_alive:
-            for arg in unknownargs + [args.new_tab,]:
-                if os.path.isfile(arg):
-                    message = f"FILE|{arg}"
-                    ipc_server.send_ipc_message(message)
+        if ipc_server.is_ipc_alive:
+            return True
 
-            raise AppLaunchException(f"{APP_NAME} IPC Server Exists: Have sent path(s) to it and closing...")
+        logger.warning(f"{app_name} IPC Server Exists: Have sent path(s) to it and closing...")
+        for arg in unknownargs + [args.new_tab,]:
+            if os.path.isfile(arg):
+                message = f"FILE|{arg}"
+                ipc_server.send_ipc_message(message)
+
+            if os.path.isdir(arg):
+                message = f"DIR|{arg}"
+                ipc_server.send_ipc_message(message)
+
+        return False
 
     def ipc_realization_check(self, ipc_server):
         try:
             ipc_server.create_ipc_listener()
-        except Exception:
+        except (OSError, PermissionError) as e:
+            logger.info(f"IPC listener creation failed: {e}, falling back to test message")
+            ipc_server.send_test_ipc_message()
+        except Exception as e:
+            logger.error(f"Unexpected IPC setup error: {e}")
             ipc_server.send_test_ipc_message()
 
-        try:
-            ipc_server.create_ipc_listener()
-        except Exception as e:
-            ...
-
     def setup_debug_hook(self):
-        try:
+        # Typically: ValueError: signal only works in main thread
+        with suppress(ValueError):
             # kill -SIGUSR2 <pid> from Linux/Unix or SIGBREAK signal from Windows
             signal.signal(
                 vars(signal).get("SIGBREAK") or vars(signal).get("SIGUSR2"),
                 debug_signal_handler
             )
-        except ValueError:
-            # Typically: ValueError: signal only works in main thread
-            ...
+

src/core/containers/base_container.py

@@ -8,6 +8,7 @@ from gi.repository import Gtk
 # Application imports
 from .header_container import HeaderContainer
 from .body_container import BodyContainer
+from .footer_container import FooterContainer
 
 
 
@@ -15,8 +16,6 @@ class BaseContainer(Gtk.Box):
     def __init__(self):
         super(BaseContainer, self).__init__()
 
-        self.ctx = self.get_style_context()
-
         self._setup_styling()
         self._setup_signals()
         self._subscribe_to_events()
@@ -26,9 +25,11 @@ class BaseContainer(Gtk.Box):
 
 
     def _setup_styling(self):
-        self.set_orientation(Gtk.Orientation.VERTICAL)
+        self.ctx = self.get_style_context()
         self.ctx.add_class("base-container")
 
+        self.set_orientation(Gtk.Orientation.VERTICAL)
+
     def _setup_signals(self):
         ...
 
@@ -37,11 +38,12 @@ class BaseContainer(Gtk.Box):
         event_system.subscribe("remove-transparency", self._remove_transparency)
 
     def _load_widgets(self):
-        self.add(HeaderContainer())
-        self.add(BodyContainer())
+        self.add( HeaderContainer() )
+        self.add( BodyContainer() )
+        self.add( FooterContainer() )
 
     def _update_transparency(self):
-        self.ctx.add_class(f"mw_transparency_{settings.theming.transparency}")
+        self.ctx.add_class(f"mw_transparency_{settings_manager.settings.theming.transparency}")
 
     def _remove_transparency(self):
-        self.ctx.remove_class(f"mw_transparency_{settings.theming.transparency}")
+        self.ctx.remove_class(f"mw_transparency_{settings_manager.settings.theming.transparency}")

src/core/containers/body_container.py

@@ -16,8 +16,6 @@ class BodyContainer(Gtk.Box):
     def __init__(self):
         super(BodyContainer, self).__init__()
 
-        self.ctx = self.get_style_context()
-
         self._setup_styling()
         self._setup_signals()
         self._subscribe_to_events()
@@ -27,8 +25,10 @@ class BodyContainer(Gtk.Box):
 
 
     def _setup_styling(self):
-        self.set_orientation(Gtk.Orientation.HORIZONTAL)
+        self.ctx = self.get_style_context()
         self.ctx.add_class("body-container")
+
+        self.set_orientation(Gtk.Orientation.HORIZONTAL)
         self.set_homogeneous(True)
 
     def _setup_signals(self):
@@ -37,8 +37,7 @@ class BodyContainer(Gtk.Box):
     def _subscribe_to_events(self):
         ...
 
-
     def _load_widgets(self):
-        self.add(LeftContainer())
-        self.add(CenterContainer())
-        self.add(RightContainer())
+        self.add( LeftContainer() )
+        self.add( CenterContainer() )
+        self.add( RightContainer() )

src/core/containers/center_container.py

@@ -25,9 +25,12 @@ class CenterContainer(Gtk.Box):
 
 
     def _setup_styling(self):
+        self.ctx = self.get_style_context()
+        self.ctx.add_class("center-container")
+
         self.set_orientation(Gtk.Orientation.VERTICAL)
-        ctx = self.get_style_context()
-        ctx.add_class("center-container")
+        self.set_hexpand(True)
+        self.set_vexpand(True)
 
     def _setup_signals(self):
         ...
@@ -37,7 +40,7 @@ class CenterContainer(Gtk.Box):
 
     def _load_widgets(self):
         glade_box = self._builder.get_object("glade_box")
-        button   = Gtk.Button(label = "Click Me!")
+        button    = Gtk.Button(label = "Click Me!")
 
         button.connect("clicked", self._hello_world)
 

src/core/containers/code/__init__.py

@@ -0,0 +1,3 @@
+"""
+    Containers Package
+"""

src/core/containers/code/code_container.py

@@ -0,0 +1,64 @@
+# Python imports
+
+# Lib imports
+import gi
+gi.require_version('Gtk', '3.0')
+from gi.repository import Gtk
+
+# Application imports
+from ...widgets.code.code_base import CodeBase
+
+from ...widgets.separator_widget import Separator
+from ...widgets.code.mini_view_widget import MiniViewWidget
+
+from .editors_container import EditorsContainer
+
+
+
+class CodeContainer(Gtk.Box):
+    def __init__(self):
+        super(CodeContainer, self).__init__()
+
+        self._setup_styling()
+        self._setup_signals()
+        self._subscribe_to_events()
+        self._load_widgets()
+
+        self.show_all()
+
+
+    def _setup_styling(self):
+        self.set_orientation(Gtk.Orientation.VERTICAL)
+
+    def _setup_signals(self):
+        ...
+
+    def _subscribe_to_events(self):
+        ...
+
+    def _load_widgets(self):
+        code_base = CodeBase()
+
+        self.add( self._create_tabs_widgets(code_base) )
+        self.add( self._create_editor_widget(code_base) )
+
+    def _create_tabs_widgets(self, code_base: CodeBase):
+        scrolled_window = Gtk.ScrolledWindow()
+        viewport        = Gtk.Viewport()
+
+        scrolled_window.set_overlay_scrolling(False)
+
+        viewport.add( code_base.get_tabs_widget() )
+        scrolled_window.add( viewport )
+
+        return scrolled_window
+
+    def _create_editor_widget(self, code_base: CodeBase):
+        editors_container = Gtk.Box()
+
+        editors_container.add( Separator("separator_left") )
+        editors_container.add( EditorsContainer(code_base) )
+        editors_container.add( Separator("separator_right") )
+        editors_container.add( code_base.get_mini_view_widget() )
+
+        return editors_container

src/core/containers/code/editors_container.py

@@ -0,0 +1,71 @@
+# Python imports
+
+# Lib imports
+import gi
+gi.require_version('Gtk', '3.0')
+from gi.repository import Gtk
+from gi.repository import GLib
+
+# Application imports
+
+
+
+class EditorsContainer(Gtk.Paned):
+    def __init__(self, code_base: any):
+        super(EditorsContainer, self).__init__()
+
+        self.code_base = code_base
+
+        self._setup_styling()
+        self._setup_signals()
+        self._subscribe_to_events()
+        self._load_widgets()
+
+
+    def _setup_styling(self):
+        self.ctx = self.get_style_context()
+        self.ctx.add_class("paned-editors-container")
+
+        self.set_hexpand(True)
+        self.set_vexpand(True)
+        self.set_wide_handle(True)
+
+    def _setup_signals(self):
+        self.map_id = self.connect("map", self._init_map)
+
+    def _subscribe_to_events(self):
+        ...
+
+    def _load_widgets(self):
+        self.scrolled_win1, \
+        self.scrolled_win2 = self._create_views()
+
+        self.pack1( self.scrolled_win1, True, True )
+        self.pack2( self.scrolled_win2, True, True )
+
+    def _create_views(self):
+        scrolled_win1 = Gtk.ScrolledWindow()
+        scrolled_win2 = Gtk.ScrolledWindow()
+
+        source_view1  = self.code_base.create_source_view()
+        source_view2  = self.code_base.create_source_view()
+
+        source_view1.sibling_right = source_view2
+        source_view2.sibling_left  = source_view1
+
+        scrolled_win1.add( source_view1 )
+        scrolled_win2.add( source_view2 )
+
+        return scrolled_win1, scrolled_win2
+
+    def _init_map(self, view):
+        def _first_show_init():
+            self.disconnect(self.map_id)
+            del self.map_id
+
+            self.code_base.first_map_load()
+
+            del self.code_base
+            return False
+
+        GLib.timeout_add(100, _first_show_init)

src/core/containers/footer_container.py

@@ -0,0 +1,39 @@
+# Python imports
+
+# Lib imports
+import gi
+gi.require_version('Gtk', '3.0')
+from gi.repository import Gtk
+
+# Application imports
+from .code.code_container import CodeContainer
+
+
+
+class FooterContainer(Gtk.Box):
+    def __init__(self):
+        super(FooterContainer, self).__init__()
+
+        self._setup_styling()
+        self._setup_signals()
+        self._subscribe_to_events()
+        self._load_widgets()
+
+        self.show()
+
+
+    def _setup_styling(self):
+        self.ctx = self.get_style_context()
+        self.ctx.add_class("footer-container")
+
+        self.set_orientation(Gtk.Orientation.HORIZONTAL)
+        self.set_hexpand(True)
+
+    def _setup_signals(self):
+        ...
+
+    def _subscribe_to_events(self):
+        ...
+
+    def _load_widgets(self):
+        self.add( CodeContainer() )

src/core/containers/header_container.py

@@ -15,27 +15,27 @@ class HeaderContainer(Gtk.Box):
     def __init__(self):
         super(HeaderContainer, self).__init__()
 
-        self.ctx = self.get_style_context()
-
         self._setup_styling()
         self._setup_signals()
         self._subscribe_to_events()
         self._load_widgets()
 
-        self.show_all()
+        self.show()
 
 
     def _setup_styling(self):
-        self.set_orientation(Gtk.Orientation.HORIZONTAL)
+        self.ctx = self.get_style_context()
         self.ctx.add_class("header-container")
 
+        self.set_orientation(Gtk.Orientation.HORIZONTAL)
+        self.set_hexpand(True)
+
     def _setup_signals(self):
         ...
 
     def _subscribe_to_events(self):
         event_system.subscribe("tggl-top-main-menubar", self.tggl_top_main_menubar)
 
-
     def _load_widgets(self):
         button = Gtk.Button(label = "Interactive Debug")
         button.connect("clicked", self._interactive_debug)

src/core/containers/left_container.py

@@ -22,9 +22,11 @@ class LeftContainer(Gtk.Box):
 
 
     def _setup_styling(self):
+        self.ctx = self.get_style_context()
+        self.ctx.add_class("left-container")
+
         self.set_orientation(Gtk.Orientation.VERTICAL)
-        ctx = self.get_style_context()
-        ctx.add_class("left-container")
+        self.set_vexpand(True)
 
     def _setup_signals(self):
         ...

src/core/containers/right_container.py

@@ -23,9 +23,11 @@ class RightContainer(Gtk.Box):
 
 
     def _setup_styling(self):
+        self.ctx = self.get_style_context()
+        self.ctx.add_class("right-container")
+
         self.set_orientation(Gtk.Orientation.VERTICAL)
-        ctx = self.get_style_context()
-        ctx.add_class("right-container")
+        self.set_vexpand(True)
 
     def _setup_signals(self):
         ...

src/core/controllers/base_controller.py

@@ -17,6 +17,8 @@ from .bridge_controller import BridgeController
 
 
 class BaseController(IPCSignalsMixin, KeyboardSignalsMixin, BaseControllerData):
+    """ docstring for BaseController. """
+
     def __init__(self):
 
         self._setup_controller_data()
@@ -52,8 +54,6 @@ class BaseController(IPCSignalsMixin, KeyboardSignalsMixin, BaseControllerData):
         args, unknownargs = settings_manager.get_starting_args()
         if args.no_plugins == "false":
             self.plugins_controller.pre_launch_plugins()
-
-        if args.no_plugins == "false":
             self.plugins_controller.post_launch_plugins()
 
         for file in settings_manager.get_starting_files():
@@ -63,7 +63,7 @@ class BaseController(IPCSignalsMixin, KeyboardSignalsMixin, BaseControllerData):
         logger.debug("_tggl_top_main_menubar > stub...")
 
     def _load_glade_file(self):
-        self.builder.add_from_file( settings_manager.get_glade_file() )
+        self.builder.add_from_file( settings_manager.path_manager.get_glade_file() )
         self.builder.expose_object("main_window", self.window)
 
         settings_manager.set_builder(self.builder)

src/core/controllers/base_controller_data.py

@@ -37,14 +37,19 @@ class BaseControllerData:
         for arg in unknownargs + [args.new_tab,]:
             if os.path.isdir( arg.replace("file://", "") ):
                 files.append( f"DIR|{arg.replace('file://', '')}" )
+                continue
 
             # NOTE: If passing line number with file split against :
             if os.path.isfile( arg.replace("file://", "").split(":")[0] ):
                 files.append( f"FILE|{arg.replace('file://', '')}" )
+                continue
 
-        if len(files) > 0:
-            settings_manager.set_is_starting_with_file(True)
-            settings_manager.set_starting_files(files)
+            logger.info(f"Not a File: {arg}")
+
+        if len(files) == 0: return
+
+        settings_manager.set_is_starting_with_file(True)
+        settings_manager.set_starting_files(files)
 
     def get_base_container(self):
         return self.base_container
@@ -80,24 +85,22 @@ class BaseControllerData:
             widget.remove(child)
 
     def get_clipboard_data(self, encoding = "utf-8") -> str:
-        if which("xclip"):
-            command = ['xclip','-selection','clipboard']
-        else:
+        if not which("xclip"):
             logger.info('xclip not found...')
             return
 
+        command = ['xclip','-selection','clipboard']
         proc    = subprocess.Popen(['xclip','-selection', 'clipboard', '-o'], stdout = subprocess.PIPE)
         retcode = proc.wait()
         data    = proc.stdout.read()
         return data.decode(encoding).strip()
 
     def set_clipboard_data(self, data: type, encoding = "utf-8") -> None:
-        if which("xclip"):
-            command = ['xclip','-selection','clipboard']
-        else:
+        if not which("xclip"):
             logger.info('xclip not found...')
             return
 
+        command = ['xclip','-selection','clipboard']
         proc = subprocess.Popen(command, stdin = subprocess.PIPE)
         proc.stdin.write(data.encode(encoding))
         proc.stdin.close()

src/core/controllers/bridge_controller.py

@@ -10,8 +10,6 @@ import base64
 class BridgeController:
     def __init__(self):
 
-        self.opened_files = {}
-
         self._setup_signals()
         self._subscribe_to_events()
 

src/core/widgets/clock_widget.py

@@ -0,0 +1,110 @@
+# Python imports
+from datetime import datetime
+
+# Lib imports
+import gi
+gi.require_version('Gtk', '3.0')
+from gi.repository import Gtk
+from gi.repository import GObject
+
+# Application imports
+
+
+
+class CalendarWidget(Gtk.Popover):
+    def __init__(self):
+        super(CalendarWidget, self).__init__()
+
+        self._setup_styling()
+        self._setup_signals()
+        self._subscribe_to_events()
+        self._load_widgets()
+
+
+    def _setup_styling(self):
+        ...
+
+    def _setup_signals(self):
+        ...
+
+    def _subscribe_to_events(self):
+        ...
+
+    def _load_widgets(self):
+        self.body = Gtk.Calendar()
+
+        self.body.show()
+        self.add(self.body)
+
+
+class ClockWidget(Gtk.EventBox):
+    def __init__(self):
+        super(ClockWidget, self).__init__()
+
+        self._setup_styling()
+        self._setup_signals()
+        self._subscribe_to_events()
+        self._load_widgets()
+
+        self.show_all()
+
+
+    def _setup_styling(self):
+        self.set_size_request(180, -1)
+
+        ctx = self.get_style_context()
+        ctx.add_class("clock-widget")
+
+    def _setup_signals(self):
+        self.connect("button_release_event", self._toggle_cal_popover)
+
+
+    def _subscribe_to_events(self):
+        ...
+
+    def _load_widgets(self):
+        self.calendar = CalendarWidget()
+        self.label    = Gtk.Label()
+
+        self.calendar.set_relative_to(self)
+
+        self.label.set_justify(Gtk.Justification.CENTER)
+        self.label.set_margin_top(15)
+        self.label.set_margin_bottom(15)
+        self.label.set_margin_left(15)
+        self.label.set_margin_right(15)
+
+        self._update_face()
+        self.add(self.label)
+
+        GObject.timeout_add(59000, self._update_face)
+
+    def _update_face(self):
+        dt_now         = datetime.now()
+        hours_mins_sec = dt_now.strftime("%I:%M %p")
+        month_day_year = dt_now.strftime("%m/%d/%Y")
+        time_str       = hours_mins_sec + "\n" + month_day_year
+
+        self.label.set_label(time_str)
+
+    def _toggle_cal_popover(self, widget, eve):
+        if (self.calendar.get_visible() == True):
+            self.calendar.popdown()
+            return
+
+        now         = datetime.now()
+        timeStr     = now.strftime("%m/%d/%Y")
+        parts       = timeStr.split("/")
+        month       = int(parts[0]) - 1
+        day         = int(parts[1])
+        year        = int(parts[2])
+
+        self.calendar.body.select_day(day)
+        self.calendar.body.select_month(month, year)
+
+        self.calendar.popup()
+
+
+
+
+

src/core/widgets/code/__init__.py

@@ -0,0 +1,3 @@
+"""
+    Code Package
+"""

src/core/widgets/code/code_base.py

@@ -0,0 +1,50 @@
+# Python imports
+
+# Lib imports
+
+# Application imports
+from .controllers.controller_manager import ControllerManager
+from .controllers.files_controller import FilesController
+from .controllers.tabs_controller import TabsController
+from .controllers.commands_controller import CommandsController
+from .controllers.completion_controller import CompletionController
+from .controllers.source_views_controller import SourceViewsController
+
+from .mini_view_widget import MiniViewWidget
+
+
+
+class CodeBase:
+    def __init__(self):
+        super(CodeBase, self).__init__()
+
+        self.controller_manager: ControllerManager = ControllerManager()
+        self.miniview_widget: MiniViewWidget       = MiniViewWidget()
+
+        self._load_controllers()
+
+
+    def _load_controllers(self):
+        files_controller        = FilesController()
+        tabs_controller         = TabsController()
+        commands_controller     = CommandsController()
+        completion_controller   = CompletionController()
+        source_views_controller = SourceViewsController()
+
+        self.controller_manager.register_controller("files", files_controller)
+        self.controller_manager.register_controller("tabs", tabs_controller)
+        self.controller_manager.register_controller("commands", commands_controller)
+        self.controller_manager.register_controller("completion", completion_controller)
+        self.controller_manager.register_controller("source_views", source_views_controller)
+
+    def get_tabs_widget(self):
+        return self.controller_manager["tabs"].get_tabs_widget()
+
+    def get_mini_view_widget(self):
+        return self.miniview_widget
+
+    def create_source_view(self):
+        return self.controller_manager["source_views"].create_source_view()
+
+    def first_map_load(self):
+        self.controller_manager["source_views"].first_map_load()

src/core/widgets/code/command_helpers.py

@@ -0,0 +1,27 @@
+# Python imports
+
+# Lib imports
+from gi.repository import GtkSource
+
+# Application imports
+
+
+
+def set_language_and_style(view, file):
+    language   = view.language_manager.guess_language(file.fname, None)
+    file.ftype = language
+    file.buffer.set_language(language)
+    file.buffer.set_style_scheme(view.syntax_theme)
+
+    return language
+
+def update_info_bar_if_focused(command_system, view: GtkSource):
+    has_focus = command_system.exec("has_focus")
+    if has_focus:
+        command_system.exec("update_info_bar")
+
+def get_file_and_buffer(view: GtkSource):
+    file   = view.command.get_file(view)
+    buffer = file.buffer
+
+    return file, buffer

src/core/widgets/code/command_system.py

@@ -0,0 +1,95 @@
+# Python imports
+
+# Lib imports
+
+# Application imports
+from libs.dto.code import CodeEvent
+from .event_factory import Event_Factory, Event_Factory_Types
+
+from . import commands
+
+from .source_view import SourceView
+
+
+
+class CommandSystem:
+    def __init__(self):
+        super(CommandSystem, self).__init__()
+
+        self.data: list = ()
+
+
+    def set_data(self, *args, **kwargs):
+        self.data = (args, kwargs)
+
+    def exec(self, command: str) -> any:
+        if not hasattr(commands, command): return
+        method = getattr(commands, command)
+
+        args, kwargs = self.data
+        if kwargs:
+            return method.execute(*args, kwargs)
+        else:
+            return method.execute(*args)
+
+    def exec_with_args(self, command: str, args: list) -> any:
+        if not hasattr(commands, command): return
+
+        method = getattr(commands, command)
+        return method.execute(*args)
+
+
+    def emit(self, event: CodeEvent):
+        """ Monky patch 'emit' from command controller... """
+        ...
+
+    def emit_to(self, controller: str, event: CodeEvent):
+        """ Monky patch 'emit' from command controller... """
+        ...
+
+
+    def get_file(self, view: SourceView):
+        event = Event_Factory.create_get_file(
+            view   = view,
+            buffer = view.get_buffer()
+        )
+
+        self.emit_to("files", event)
+
+        return event.response
+
+    def get_swap_file(self, view: SourceView):
+        event = Event_Factory.create_get_swap_file(
+            view   = view,
+            buffer = view.get_buffer()
+        )
+
+        self.emit_to("files", event)
+
+        return event.response
+
+    def new_file(self, view: SourceView):
+        event = Event_Factory.create_event("add_new_file", view = view)
+
+        self.emit_to("files", event)
+
+        return event.response
+
+    def remove_file(self, view: SourceView):
+        event = Event_Factory.create_remove_file(
+            view   = view,
+            buffer = view.get_buffer()
+        )
+
+        self.emit_to("files", event)
+
+        return event.response
+
+    def request_completion(self, view: SourceView):
+        event = Event_Factory.create_event(
+            "request_completion",
+            view   = view,
+            buffer = view.get_buffer()
+        )
+
+        self.emit_to("completion", event)

src/core/widgets/code/commands/__init__.py

@@ -0,0 +1,16 @@
+"""
+    Commands Package
+"""
+
+import pkgutil
+import importlib
+
+__all__ = []
+
+for loader, module_name, is_pkg in pkgutil.walk_packages(__path__):
+    module = importlib.import_module(f"{__name__}.{module_name}")
+    globals()[module_name] = module  # Add module to package namespace
+    __all__.append(module_name)
+
+del pkgutil
+del importlib

src/core/widgets/code/commands/buffer_redo.py

@@ -0,0 +1,23 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+
+# Application imports
+
+
+
+def execute(
+    view: GtkSource.View  = None
+):
+    logger.debug("Command: Buffer Redo")
+
+    buffer       = view.get_buffer()
+    undo_manager = buffer.get_undo_manager()
+
+    if undo_manager.can_redo():
+        buffer.redo()

src/core/widgets/code/commands/buffer_undo.py

@@ -0,0 +1,23 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+
+# Application imports
+
+
+
+def execute(
+    view: GtkSource.View  = None
+):
+    logger.debug("Command: Buffer Undo")
+
+    buffer       = view.get_buffer()
+    undo_manager = buffer.get_undo_manager()
+
+    if undo_manager.can_undo():
+        buffer.undo()

src/core/widgets/code/commands/close_file.py

@@ -0,0 +1,20 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+
+# Application imports
+from ..command_helpers import update_info_bar_if_focused
+
+
+
+def execute(
+    view: GtkSource.View  = None
+):
+    logger.debug("Command: Close File")
+    view.command.remove_file(view)
+    update_info_bar_if_focused(view.command, view)

src/core/widgets/code/commands/cut_to_temp_buffer.py

@@ -0,0 +1,36 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+
+# Application imports
+
+
+
+def execute(
+    view: GtkSource.View  = None
+):
+    logger.debug("Command: Cut to Temp Buffer")
+
+    view.clear_temp_cut_buffer_delayed()
+
+    buffer     = view.get_buffer()
+    itr        = buffer.get_iter_at_mark( buffer.get_insert() )
+    start_itr  = itr.copy()
+    end_itr    = itr.copy()
+    start_line = itr.get_line() + 1
+    start_char = itr.get_line_offset()
+
+    start_itr.backward_visible_line()
+    start_itr.forward_line()
+    end_itr.forward_line()
+
+    line_str   = buffer.get_slice(start_itr, end_itr, True)
+    view._cut_buffer += f"{line_str}"
+    buffer.delete(start_itr, end_itr)
+
+    view.set_temp_cut_buffer_delayed()

src/core/widgets/code/commands/dnd_load_file_to_buffer.py

@@ -0,0 +1,34 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+from gi.repository import Gio
+
+# Application imports
+from ..command_helpers import update_info_bar_if_focused
+
+
+
+def execute(
+    view: GtkSource.View,
+    uri: str
+):
+    logger.debug("Command: DnD Load File To Buffer")
+
+    file   = view.command.get_file(view)
+    buffer = file.buffer
+
+    if not file.ftype == "buffer":
+        file = view.command.new_file(view)
+
+    gfile  = Gio.File.new_for_uri(uri)
+    view.command.exec_with_args(
+        "load_file",
+        (view, gfile, file)
+    )
+
+    update_info_bar_if_focused(view.command, view)

src/core/widgets/code/commands/dnd_load_files.py

@@ -0,0 +1,27 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+from gi.repository import Gio
+
+# Application imports
+from ..source_file import SourceFile
+
+
+
+def execute(
+    view: GtkSource.View,
+    uris: list = []
+):
+    logger.debug("Command: DnD Load Files")
+    for uri in uris:
+        try:
+            gfile = Gio.File.new_for_uri(uri)
+        except Exception as e:
+            gfile = Gio.File.new_for_path(uri)
+
+        view.command.exec_with_args("load_file", (view, gfile))

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

@@ -0,0 +1,53 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+
+# Application imports
+
+
+
+def execute(
+    view: GtkSource.View  = None
+):
+    logger.debug("Command: Duplicate Line")
+
+    buffer = view.get_buffer()
+
+    if not buffer.get_has_selection():
+        had_selection = False
+        itr        = buffer.get_iter_at_mark( buffer.get_insert() )
+        start_itr  = itr.copy()
+        end_itr    = itr.copy()
+        start_line = itr.get_line() + 1
+        start_char = itr.get_line_offset()
+    else:
+        had_selection = True
+        start_itr, end_itr = buffer.get_selection_bounds()
+        sline      = start_itr.get_line()
+        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.forward_line()
+    end_itr.forward_line()
+    end_itr.backward_char()
+
+    line_str = buffer.get_slice(start_itr, end_itr, True)
+    end_itr.forward_char()
+    buffer.insert(end_itr, f"{line_str}\n", -1)
+
+    if not had_selection:
+        new_itr = buffer.get_iter_at_line_offset(start_line, start_char)
+        buffer.place_cursor(new_itr)
+    else:
+        new_itr     = buffer.get_iter_at_line_offset(start_line, start_char)
+        new_end_itr = buffer.get_iter_at_line_offset((start_line + range_line_size), end_char)
+        buffer.select_range(new_itr, new_end_itr)

src/core/widgets/code/commands/focus_left_sibling.py

@@ -0,0 +1,19 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+
+# Application imports
+
+
+
+def execute(
+    view: GtkSource.View  = None
+):
+    logger.debug("Command: Focus Left Sibling")
+    if not view.sibling_left: return
+    view.sibling_left.grab_focus()

src/core/widgets/code/commands/focus_right_sibling.py

@@ -0,0 +1,19 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+
+# Application imports
+
+
+
+def execute(
+    view: GtkSource.View  = None
+):
+    logger.debug("Command: Focus Right Sibling")
+    if not view.sibling_right: return
+    view.sibling_right.grab_focus()

src/core/widgets/code/commands/get_current_file.py

@@ -0,0 +1,21 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+
+# Application imports
+
+
+
+def execute(
+    view: GtkSource.View  = None
+):
+    logger.debug("Command: Get Current File")
+
+    file = view.command.get_file(view)
+
+    return file

src/core/widgets/code/commands/get_filetype.py

@@ -0,0 +1,19 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+
+# Application imports
+
+
+
+def execute(
+    view: GtkSource.View  = None
+):
+    logger.debug("Command: Get File Type")
+    file = view.command.get_file(view)
+    return file.ftype 

src/core/widgets/code/commands/get_text.py

@@ -0,0 +1,21 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+
+# Application imports
+
+
+
+def execute(
+    view: GtkSource.View  = None
+):
+    logger.debug("Command: Get Text")
+
+    buffer = view.get_buffer()
+    start_itr, end_itr = buffer.get_bounds()
+    return buffer.get_text(start_itr, end_itr, True)

src/core/widgets/code/commands/go_to.py

@@ -0,0 +1,31 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+
+# Application imports
+
+
+
+def execute(
+    view: GtkSource.View  = None
+):
+    logger.debug("Command: Go-To")
+
+    file    = view.command.get_file(view)
+    gfile   = file.get_location()
+    uri     = gfile.get_uri()
+
+    buffer  = view.get_buffer()
+    iter    = buffer.get_iter_at_mark( buffer.get_insert() )
+    line    = iter.get_line()
+    offset  = iter.get_line_offset()
+
+    event_system.emit(
+        "textDocument/definition",
+        (view, file.ftype, uri, line, offset,)
+    )

src/core/widgets/code/commands/has_focus.py

@@ -0,0 +1,19 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+
+# Application imports
+
+
+
+def execute(
+    view: GtkSource.View  = None
+):
+    logger.debug("Command: Has Focus")
+    ctx = view.get_parent().get_style_context()
+    return ctx.has_class("source-view-focused")

src/core/widgets/code/commands/line_down.py

@@ -0,0 +1,18 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+
+# Application imports
+
+
+
+def execute(
+    view: GtkSource.View  = None
+):
+    logger.debug("Command: Line Down")
+    view.emit("move-lines", True)

src/core/widgets/code/commands/line_up.py

@@ -0,0 +1,18 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+
+# Application imports
+
+
+
+def execute(
+    view: GtkSource.View  = None
+):
+    logger.debug("Command: Line Up")
+    view.emit("move-lines", False)

src/core/widgets/code/commands/load_file.py

@@ -0,0 +1,28 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+from gi.repository import Gio
+
+# Application imports
+from ..source_file import SourceFile
+from ..command_helpers import set_language_and_style
+
+
+
+def execute(
+    view: GtkSource.View,
+    gfile: Gio.File,
+    file: SourceFile = None,
+):
+    logger.debug("Command: Load File")
+    if not file:
+        file = view.command.new_file(view)
+
+    file.load_path(gfile)
+
+    set_language_and_style(view, file)

src/core/widgets/code/commands/load_start_files.py

@@ -0,0 +1,40 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+from gi.repository import Gio
+
+# Application imports
+
+
+
+def execute(
+    view: GtkSource.View,
+):
+    logger.debug("Command: Load Start File(s)")
+
+    starting_files = settings_manager.get_starting_files()
+
+    if len(starting_files) == 0: return
+
+    file   = starting_files.pop()
+    file   = file.replace("FILE|", "")
+    gfile  = Gio.File.new_for_path(file)
+    file   = view.command.get_file(view)
+
+    view.command.exec_with_args(
+        "load_file",
+        (view, gfile, file)
+    )
+
+    if len(starting_files) == 0: return
+
+    for file in starting_files:
+        file  = file.replace("FILE|", "")
+        gfile = Gio.File.new_for_path(file)
+
+        view.command.exec_with_args("load_file", (view, gfile))

src/core/widgets/code/commands/move_to_left_sibling.py

@@ -0,0 +1,29 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+
+# Application imports
+
+
+
+def execute(
+    view: GtkSource.View  = None
+):
+    logger.debug("Command: Move To Left Sibling")
+    if not view.sibling_left: return
+
+    buffer = view.get_buffer()
+    popped_file, next_file = view.command.get_swap_file(view)
+
+    view.sibling_left.set_buffer(buffer)
+    view.sibling_left.grab_focus()
+
+    if next_file:
+        view.set_buffer(next_file.buffer)
+    else:
+        view.command.exec("new_file")

src/core/widgets/code/commands/move_to_right_sibling.py

@@ -0,0 +1,29 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+
+# Application imports
+
+
+
+def execute(
+    view: GtkSource.View  = None
+):
+    logger.debug("Command: Move To Right Sibling")
+    if not view.sibling_right: return
+
+    buffer = view.get_buffer()
+    popped_file, next_file = view.command.get_swap_file(view)
+
+    view.sibling_right.set_buffer(buffer)
+    view.sibling_right.grab_focus()
+
+    if next_file:
+        view.set_buffer(next_file.buffer)
+    else:
+        view.command.exec("new_file")

src/core/widgets/code/commands/new_file.py

@@ -0,0 +1,27 @@
+# Python imports
+
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+
+# Application imports
+from ..command_helpers import set_language_and_style, update_info_bar_if_focused
+
+
+
+def execute(
+    view: GtkSource.View  = None
+):
+    logger.debug("Command: New File")
+
+    file       = view.command.new_file(view)
+    set_language_and_style(view, file)
+
+    view.set_buffer(file.buffer)
+
+    update_info_bar_if_focused(view.command, view)
+    return file

src/core/widgets/code/commands/open_files.py

@@ -0,0 +1,30 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+
+# Application imports
+from ..command_helpers import update_info_bar_if_focused
+
+
+
+def execute(
+    view: GtkSource.View  = None
+):
+    logger.debug("Command: Open File(s)")
+    gfiles = event_system.emit_and_await("open-files")
+    if not gfiles: return
+
+    file = view.command.get_file(view)
+    if file.ftype == "buffer":
+        gfile = gfiles.pop()
+        view.command.exec_with_args("load_file", (view, gfile, file))
+        view.set_buffer(file.buffer)
+        update_info_bar_if_focused(view.command, view)
+
+    for i, gfile in enumerate(gfiles):
+        view.command.exec_with_args("load_file", (view, gfile))

src/core/widgets/code/commands/paste_temp_buffer.py

@@ -0,0 +1,28 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GLib
+from gi.repository import GtkSource
+
+# Application imports
+
+
+
+def execute(
+    view: GtkSource.View  = None
+):
+    logger.debug("Command: Paste Temp Buffer")
+
+    view.clear_temp_cut_buffer_delayed()
+
+    buffer     = view.get_buffer()
+    itr        = buffer.get_iter_at_mark( buffer.get_insert() )
+    insert_itr = itr.copy()
+
+    buffer.insert(insert_itr, view._cut_buffer, -1)
+
+    view.set_temp_cut_buffer_delayed()

src/core/widgets/code/commands/save_file.py

@@ -0,0 +1,28 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+
+# Application imports
+from ..command_helpers import set_language_and_style
+
+
+
+def execute(
+    view: GtkSource.View  = None
+):
+    logger.debug("Command: Save File")
+    file   = view.command.get_file(view)
+    buffer = file.buffer
+
+    if file.ftype == "buffer":
+        file.save_as()
+        set_language_and_style(view, file)
+        return
+
+    file.save()
+

src/core/widgets/code/commands/save_file_as.py

@@ -0,0 +1,26 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+
+# Application imports
+from ..command_helpers import set_language_and_style, update_info_bar_if_focused
+
+
+
+def execute(
+    view: GtkSource.View  = None
+):
+    logger.info("Command: Save File As")
+    file   = view.command.get_file(view)
+    buffer = file.buffer
+
+    file.save_as()
+
+    set_language_and_style(view, file)
+
+    update_info_bar_if_focused(view.command, view)

src/core/widgets/code/commands/set_buffer.py

@@ -0,0 +1,30 @@
+# Python imports
+
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+
+# Application imports
+from ..source_file import SourceFile
+from ..command_helpers import update_info_bar_if_focused
+
+
+
+def execute(
+    view: GtkSource.View,
+    file: SourceFile
+):
+    logger.debug("Command: Set Buffer")
+
+    if not file:
+        view.command.new_file(view)
+        return
+
+    view.set_buffer(file.buffer)
+
+    update_info_bar_if_focused(view.command, view)
+

src/core/widgets/code/commands/set_buffer_language.py

@@ -0,0 +1,23 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+
+# Application imports
+
+
+
+def execute(
+    view: GtkSource.View,
+    language: str
+):
+    logger.debug("Command: Set Buffer Language")
+
+    buffer = view.get_buffer()
+    buffer.set_language(
+        view.language_manager.get_language(language)
+    )

src/core/widgets/code/commands/set_buffer_style.py

@@ -0,0 +1,23 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+
+# Application imports
+
+
+
+def execute(
+    view: GtkSource.View,
+    style: str
+):
+    logger.debug("Command: Set Buffer Style")
+
+    buffer = view.get_buffer()
+    buffer.set_style_scheme(
+        view.style_scheme_manager.get_scheme(style)
+    )

src/core/widgets/code/commands/set_focus_border.py

@@ -0,0 +1,26 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+
+# Application imports
+
+
+
+def execute(
+    view: GtkSource.View  = None
+):
+    logger.debug("Command: Set Focus Border")
+    ctx = view.get_parent().get_style_context()
+    ctx.add_class("source-view-focused")
+
+    if view.sibling_right:
+        ctx = view.sibling_right.get_parent().get_style_context()
+    elif view.sibling_left:
+        ctx = view.sibling_left.get_parent().get_style_context()
+
+    ctx.remove_class("source-view-focused")

src/core/widgets/code/commands/set_miniview.py

@@ -0,0 +1,22 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+from gi.repository import Gio
+
+# Application imports
+from libs.dto.code import FocusedViewEvent
+
+from ..source_file import SourceFile
+
+
+
+def execute(
+    view: GtkSource.View,
+):
+    logger.debug("Command: Set MiniView")
+    event_system.emit("set-mini-view", (view,))

src/core/widgets/code/commands/show_completion.py

@@ -0,0 +1,18 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+
+# Application imports
+
+
+
+def execute(
+    view: GtkSource.View  = None
+):
+    logger.debug("Command: Show Completion")
+    view.command.request_completion(view)

src/core/widgets/code/commands/update_info_bar.py

@@ -0,0 +1,33 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+from gi.repository import Gio
+
+# Application imports
+from ..source_file import SourceFile
+
+
+
+def execute(
+    view: GtkSource.View,
+):
+    logger.debug("Command: Update Info Bar")
+    file   = view.command.get_file(view)
+    buffer = file.buffer
+
+    if not file: return
+
+    iter   = buffer.get_iter_at_mark( buffer.get_insert() )
+    line   = iter.get_line() + 1
+    column = iter.get_line_offset()
+    ftype  = file.ftype.get_id() if hasattr(file.ftype, "get_id") else file.ftype
+
+    event_system.emit(
+        "set-info-labels",
+        (file.fpath, f"{line}:{column}", ftype, file.encoding)
+    )

src/core/widgets/code/commands/zoom_in.py

@@ -0,0 +1,23 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+
+# Application imports
+
+
+
+def execute(
+    view: GtkSource.View  = None
+):
+    logger.debug("Command: Zoom In")
+
+    ctx = view.get_style_context()
+    if view.zoom_level < 99:
+        ctx.remove_class(f"px{view.zoom_level}")
+        view.zoom_level += 1
+        ctx.add_class(f"px{view.zoom_level}")

src/core/widgets/code/commands/zoom_out.py

@@ -0,0 +1,23 @@
+# Python imports
+
+# Lib imports
+import gi
+
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+
+# Application imports
+
+
+
+def execute(
+    view: GtkSource.View  = None
+):
+    logger.debug("Command: Zoom Out")
+
+    ctx = view.get_style_context()
+    if view.zoom_level > 1:
+        ctx.remove_class(f"px{view.zoom_level}")
+        view.zoom_level -= 1
+        ctx.add_class(f"px{view.zoom_level}")

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

@@ -0,0 +1,3 @@
+"""
+    Custom Completion Providers Module
+"""

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

@@ -0,0 +1,84 @@
+# Python imports
+import re
+
+# 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
+from gi.repository import GObject
+
+# Application imports
+
+
+
+class ExampleCompletionProvider(GObject.GObject, GtkSource.CompletionProvider):
+    """
+        This is a custom Completion Example Provider.
+        # NOTE: used information from here --> https://warroom.rsmus.com/do-that-auto-complete/
+    """
+    __gtype_name__ = 'ExampleCompletionProvider'
+
+    def __init__(self):
+        GObject.Object.__init__(self)
+
+    def do_get_name(self):
+        """ Returns: a new string containing the name of the provider. """
+        return 'Example Completion Provider'
+
+    def do_match(self, context):
+        """ Get whether the provider match the context of completion detailed in context. """
+        # NOTE: True for debugging but context needs to normally get checked for actual usage needs.
+        # TODO: Fix me
+        return True
+
+    def do_get_priority(self):
+        """ Determin position in result list along other providor results. """
+        return 1
+
+    # def do_get_activation(self):
+    #     """ The context for when a provider will show results """
+    #     return GtkSource.CompletionActivation.NONE
+    #     return GtkSource.CompletionActivation.USER_REQUESTED
+    #     return GtkSource.CompletionActivation.INTERACTIVE
+
+    def do_populate(self, context):
+        """
+            In this instance, it will do 2 things:
+                1) always provide Hello World! (Not ideal but an option so its in the example)
+                2) Utilizes the Gtk.TextIter from the TextBuffer to determine if there is a jinja
+                    example of '{{ custom.' if so it will provide you with the options of foo and bar.
+            If selected it will insert foo }} or bar }}, completing your syntax...
+
+            PLEASE NOTE the GtkTextIter Logic and regex are really rough and should be adjusted and tuned
+        """
+
+        proposals = [
+            GtkSource.CompletionItem(label='Hello World!', text = 'Hello World!', icon = None, info = None) # NOTE: Always proposed...
+        ]
+
+        # Gtk Versions differ on get_iter responses...
+        end_iter = context.get_iter()
+        if not isinstance(end_iter, Gtk.TextIter):
+            _, end_iter = context.get_iter()
+
+        if end_iter:
+            buf = end_iter.get_buffer()
+            mov_iter = end_iter.copy()
+            if mov_iter.backward_search('{{', Gtk.TextSearchFlags.VISIBLE_ONLY):
+                mov_iter, _ = mov_iter.backward_search('{{', Gtk.TextSearchFlags.VISIBLE_ONLY)
+                left_text = buf.get_text(mov_iter, end_iter, True)
+            else:
+                left_text = ''
+
+            if re.match(r'.*\{\{\s*custom\.$', left_text):
+                proposals.append(
+                    GtkSource.CompletionItem(label='foo', text='foo }}')  # optionally proposed based on left search via regex
+                )
+                proposals.append(
+                    GtkSource.CompletionItem(label='bar', text='bar }}')  # optionally proposed based on left search via regex
+                )
+
+        context.add_proposals(self, proposals, True)

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

@@ -0,0 +1,137 @@
+# 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
+from gi.repository import GObject
+
+# Application imports
+
+
+
+class LSPCompletionProvider(GObject.Object, GtkSource.CompletionProvider):
+    """
+        This code is an LSP code completion plugin for Newton.
+        # NOTE: Some code pulled/referenced from here --> https://github.com/isamert/gedi
+    """
+    __gtype_name__ = 'LSPProvider'
+
+    def __init__(self):
+        GObject.Object.__init__(self)
+
+        self._icon_theme = Gtk.IconTheme.get_default()
+
+        self.lsp_data = None
+
+
+    def pre_populate(self, context):
+        ...
+
+    def do_get_name(self):
+        return "LSP Code Completion"
+
+    def get_iter_correctly(self, context):
+        return context.get_iter()[1] if isinstance(context.get_iter(), tuple) else context.get_iter()
+
+    def do_match(self, context):
+        iter = self.get_iter_correctly(context)
+        iter.backward_char()
+
+        buffer = iter.get_buffer()
+        if buffer.get_context_classes_at_iter(iter) != ['no-spell-check']:
+            return False
+
+        ch = iter.get_char()
+        # NOTE: Look to re-add or apply supprting 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
+
+        return True
+
+    def do_get_priority(self):
+        return 5
+
+    def do_populate(self, context, items = []):
+        # self.lsp_data
+        proposals = []
+
+        comp_item = GtkSource.CompletionItem.new()
+        comp_item.set_label("LSP Class")
+        comp_item.set_text("LSP Code")
+        # comp_item.set_icon(self.get_icon_for_type(completion.type))
+        comp_item.set_info("A test LSP completion item...")
+
+        context.add_proposals(self, [comp_item], True)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    # def do_populate(self, context, items = []):
+    #     if hasattr(self._source_view, "completion_items"):
+    #         items = self._source_view.completion_items
+
+    #     proposals = []
+    #     for item in items:
+    #         proposals.append( self.create_completion_item(item) )
+
+    #     context.add_proposals(self, proposals, True)
+
+    # def get_icon_for_type(self, _type):
+    #     try:
+    #         return self._theme.load_icon(icon_names[_type.lower()], 16, 0)
+    #     except:
+    #         ...
+
+    #     try:
+    #         return self._theme.load_icon(Gtk.STOCK_ADD, 16, 0)
+    #     except:
+    #         ...
+
+    #     return None
+
+    # def create_completion_item(self, item):
+    #     comp_item = GtkSource.CompletionItem.new()
+    #     keys      = item.keys()
+    #     comp_item.set_label(item["label"])
+
+    #     if "insertText" in keys:
+    #         comp_item.set_text(item["insertText"])
+
+    #     if "additionalTextEdits" in keys:
+    #         comp_item.additionalTextEdits = item["additionalTextEdits"]
+
+    #     return comp_item
+
+
+    # def create_completion_item(self, item):
+    #     comp_item = GtkSource.CompletionItem.new()
+    #     comp_item.set_label(item.label)
+
+    #     if item.textEdit:
+    #         if isinstance(item.textEdit, dict):
+    #             comp_item.set_text(item.textEdit["newText"])
+    #         else:
+    #             comp_item.set_text(item.textEdit)
+    #     else:
+    #         comp_item.set_text(item.insertText)
+
+    #     comp_item.set_icon( self.get_icon_for_type(item.kind) )
+    #     comp_item.set_info(item.documentation)
+
+    #     return comp_item

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

@@ -0,0 +1,107 @@
+# 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
+from gi.repository import GObject
+
+import jedi
+from jedi.api import Script
+
+# Application imports
+
+
+
+# FIXME: Find real icon names...
+icon_names = {
+    'import':    '',
+    'module':    '',
+    'class':     '',
+    'function':  '',
+    'statement': '',
+    'param':     ''
+}
+
+
+class Jedi:
+    def get_script(file, doc_text):
+        return Script(code = doc_text, path = file)
+
+
+class PythonCompletionProvider(GObject.Object, GtkSource.CompletionProvider):
+    """
+        This code is A python code completion plugin for Newton.
+        # NOTE: Some code pulled/referenced from here --> https://github.com/isamert/gedi
+    """
+    __gtype_name__ = 'PythonProvider'
+
+    def __init__(self, file):
+        GObject.Object.__init__(self)
+        self._theme = Gtk.IconTheme.get_default()
+        self._file  = file
+
+    def do_get_name(self):
+        return "Python Code Completion"
+
+    def get_iter_correctly(self, context):
+        return context.get_iter()[1] if isinstance(context.get_iter(), tuple) else context.get_iter()
+
+    def do_match(self, context):
+        iter = self.get_iter_correctly(context)
+        iter.backward_char()
+
+        buffer = iter.get_buffer()
+        if buffer.get_context_classes_at_iter(iter) != ['no-spell-check']:
+            return False
+
+        ch = iter.get_char()
+        # NOTE: Look to re-add or apply supprting 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
+
+        return True
+
+    def do_get_priority(self):
+        return 1
+
+    def do_get_activation(self):
+        return GtkSource.CompletionActivation.INTERACTIVE
+
+    def do_populate(self, context):
+        # TODO: Maybe convert async?
+        it        = self.get_iter_correctly(context)
+        buffer    = it.get_buffer()
+        proposals = []
+
+        doc_text    = buffer.get_text(buffer.get_start_iter(), buffer.get_end_iter(), False)
+        iter_cursor = buffer.get_iter_at_mark(buffer.get_insert())
+        linenum     = iter_cursor.get_line() + 1
+        charnum     = iter_cursor.get_line_index()
+
+        def create_generator():
+            for completion in Jedi.get_script(self._file, doc_text).complete(line = linenum, column = None, fuzzy = False):
+                comp_item = GtkSource.CompletionItem.new()
+                comp_item.set_label(completion.name)
+                comp_item.set_text(completion.name)
+                comp_item.set_icon(self.get_icon_for_type(completion.type))
+                comp_item.set_info(completion.docstring())
+                yield comp_item
+
+        for item in create_generator():
+            proposals.append(item)
+
+        context.add_proposals(self, proposals, True)
+
+    def get_icon_for_type(self, _type):
+        try:
+            return self._theme.load_icon(icon_names[_type.lower()], 16, 0)
+        except (KeyError, AttributeError, GObject.GError) as e:
+            return self._theme.load_icon(Gtk.STOCK_ADD, 16, 0)
+        except (GObject.GError, AttributeError) as e:
+            return None

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

@@ -0,0 +1,3 @@
+"""
+    Controllers Package
+"""

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

@@ -0,0 +1,34 @@
+# Python imports
+
+# Lib imports
+
+# Application imports
+from libs.dto.code import (
+    CodeEvent,
+    GetCommandSystemEvent,
+    FocusedViewEvent
+)
+
+from ..command_system import CommandSystem
+
+from .controller_base import ControllerBase
+
+
+
+class CommandsController(ControllerBase, list):
+    def __init__(self):
+        super(CommandsController, self).__init__()
+
+
+    def _controller_message(self, event: CodeEvent):
+        if isinstance(event, GetCommandSystemEvent):
+            event.response = self.get_command_system()
+
+    def get_command_system(self):
+        command_system         = CommandSystem()
+        command_system.emit    = self.emit
+        command_system.emit_to = self.emit_to
+
+        self.append(command_system)
+
+        return command_system

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

@@ -0,0 +1,111 @@
+# Python imports
+
+# Lib imports
+import gi
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GLib
+from gi.repository import GtkSource
+
+# Application imports
+from libs.dto.code import (
+    CodeEvent,
+    FocusedViewEvent,
+    RequestCompletionEvent,
+    CursorMovedEvent,
+    TextChangedEvent,
+    TextInsertedEvent
+)
+
+from ..completion_providers.example_completion_provider import ExampleCompletionProvider
+from ..completion_providers.lsp_completion_provider import LSPCompletionProvider
+
+from .controller_base import ControllerBase
+
+
+
+class CompletionController(ControllerBase):
+    def __init__(self):
+        super(CompletionController, self).__init__()
+
+        self._completor: GtkSource.Completion     = None
+        self._timeout_id: int                     = None
+        self._lsp_provider: LSPCompletionProvider = LSPCompletionProvider()
+
+
+    def _controller_message(self, event: CodeEvent):
+        if isinstance(event, FocusedViewEvent):
+            self._completor = event.view.get_completion()
+
+            if not self._timeout_id: return
+
+            GLib.source_remove(self._timeout_id)
+            self._timeout_id = None
+        elif isinstance(event, RequestCompletionEvent):
+            self.request_completion()
+        # elif isinstance(event, TextInsertedEvent):
+        #     self.request_completion()
+
+    def _process_request_completion(self):
+        self._start_completion()
+
+        self._timeout_id = None
+        return False
+
+    def _do_completion(self):
+        if self._completor.get_providers():
+            self._match_completion()
+        else:
+            self._start_completion()
+
+    def _match_completion(self):
+        """
+            Note: Use IF providers were added to completion...
+        """
+        self._completion.match(
+            self._completion.create_context()
+        )
+
+
+    def _start_completion(self):
+        """
+            Note: Use IF NO providers have been added to completion...
+        """
+        self._completor.start(
+            [
+                ExampleCompletionProvider(),
+                self._lsp_provider
+            ],
+            self._completor.create_context()
+        )
+
+
+    def set_completer(self, completer):
+        self._completor = completer
+
+    def request_completion(self):
+        if self._timeout_id:
+            GLib.source_remove(self._timeout_id)
+
+        self._timeout_id = GLib.timeout_add(
+            800,
+            self._process_request_completion
+        )
+
+    def register_provider(
+        self,
+        provider_name: str,
+        provider: GtkSource.CompletionProvider, 
+        priority: int = 0,
+        language_ids: list = None
+    ):
+        """Register completion providers with priority and language filtering"""
+        ...
+
+    def unregister_provider(self, provider_name: str):
+        """Remove completion providers"""
+        ...
+        
+    def get_active_providers(self, language_id: str = None) -> list:
+        """Get providers filtered by language"""
+        ...

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

@@ -0,0 +1,38 @@
+# Python imports
+
+# Lib imports
+
+# Application imports
+from libs.singleton import Singleton
+
+from libs.dto.code.code_event import CodeEvent
+
+from .emit_dispatcher import EmitDispatcher
+from .controller_context import ControllerContext
+
+
+
+class ControllerBaseException(Exception):
+    ...
+
+
+
+class ControllerBase(Singleton, EmitDispatcher):
+    def __init__(self):
+        super(ControllerBase, self).__init__()
+
+        self.controller_context: ControllerContext = None
+
+
+    def _controller_message(self, event: CodeEvent):
+        raise ControllerBaseException("Controller Base must override '_controller_message'...")
+
+    def set_controller_context(self, controller_context: ControllerContext):
+        self.controller_context = controller_context
+
+    def message_to(self, name: str, event: CodeEvent):
+        return self.controller_context.message_to(name, event)
+
+    def message_all(self, event: CodeEvent):
+        return self.controller_context.message_all(event)
+

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

@@ -0,0 +1,24 @@
+# Python imports
+
+# Lib imports
+
+# Application imports
+from libs.dto.code.code_event import CodeEvent
+
+
+
+class ControllerContextException(Exception):
+    ...
+
+
+
+class ControllerContext:
+    def __init__(self):
+        super(ControllerContext, self).__init__()
+
+
+    def message_to(self, name: str, event: CodeEvent):
+        raise ControllerContextException("Controller Context 'message_to' must be overriden by Controller Manager...")
+
+    def message_all(self, event: CodeEvent):
+        raise ControllerContextException("Controller Context 'message_all' must be overriden by Controller Manager...")

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

@@ -0,0 +1,48 @@
+# Python imports
+
+# Lib imports
+
+# Application imports
+from libs.singleton import Singleton
+
+from libs.dto.code.code_event import CodeEvent
+
+from .controller_base import ControllerBase
+from .controller_context import ControllerContext
+
+
+
+class ControllerManagerException(Exception):
+    ...
+
+
+
+class ControllerManager(Singleton, dict):
+    def __init__(self):
+        super(ControllerManager, self).__init__()
+
+
+    def _crete_controller_context(self) -> ControllerContext:
+        controller_context             = ControllerContext()
+        controller_context.message_to  = self.message_to
+        controller_context.message_all = self.message_all
+
+        return controller_context
+
+    def register_controller(self, name: str, controller: ControllerBase):
+        if not name or controller == None:
+            raise ControllerManagerException("Must pass in a 'name' and 'controller'...")
+
+        controller.set_controller_context(
+            self._crete_controller_context()
+        )
+
+        self[name] = controller
+
+
+    def message_to(self, name: str, event: CodeEvent):
+        self[name]._controller_message(event)
+
+    def message_all(self, event: CodeEvent):
+        for key in self.keys():
+            self[key]._controller_message(event)

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

@@ -0,0 +1,19 @@
+# Python imports
+
+# Lib imports
+
+# Application imports
+from libs.dto.code.code_event import CodeEvent
+
+
+
+class EmitDispatcher:
+    def __init__(self):
+        super(EmitDispatcher, self).__init__()
+
+
+    def emit(self, event: CodeEvent):
+        self.message_all(event)
+
+    def emit_to(self, controller: str, event: CodeEvent):
+        self.message_to(controller, event)

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

@@ -0,0 +1,150 @@
+# Python imports
+
+# Lib imports
+
+# Application imports
+from libs.dto.code import CodeEvent
+from ..event_factory import Event_Factory, Event_Factory_Types
+
+from ..source_file import SourceFile
+from ..source_buffer import SourceBuffer
+
+from .controller_base import ControllerBase
+
+
+
+class FilesController(ControllerBase, list):
+    def __init__(self):
+        super(FilesController, self).__init__()
+
+
+    def _controller_message(self, event: CodeEvent):
+        if isinstance(event, Event_Factory_Types.AddNewFileEvent):
+            self.new_file(event)
+        elif isinstance(event, Event_Factory_Types.SwapFileEvent):
+            self.swap_file(event)
+        elif isinstance(event, Event_Factory_Types.PopFileEvent):
+            self.pop_file(event)
+        elif isinstance(event, Event_Factory_Types.RemoveFileEvent):
+            self.remove_file(event)
+        elif isinstance(event, Event_Factory_Types.GetFileEvent):
+            self.get_file(event)
+        elif isinstance(event, Event_Factory_Types.GetSwapFileEvent):
+            self.get_swap_file(event)
+
+    def get_file(self, event: Event_Factory_Types.GetFileEvent):
+        if not event.buffer: return
+
+        for file in self:
+            if not event.buffer == file.buffer: continue
+
+            event.response = file
+
+            return file
+
+    def get_swap_file(self, event: Event_Factory_Types.GetSwapFileEvent):
+        if not event.buffer: return
+
+        for i, file in enumerate(self):
+            if not event.buffer == file.buffer: continue
+
+            j              = self.next_index(i)
+            next_file      = self[j]
+            swapped_file   = self[j] if not j == -1 else None
+
+            event.response = [swapped_file, next_file]
+
+            return swapped_file, next_file
+
+    def new_file(self, event: Event_Factory_Types.AddNewFileEvent):
+        file           = SourceFile()
+        file.emit      = self.emit
+        file.emit_to   = self.emit_to
+
+        event.response = file
+
+        eve = Event_Factory.create_event(
+            "added_new_file",
+            view = event.view,
+            file = file
+        )
+        self.message_all(eve)
+
+        self.append(file)
+
+        return file
+
+    def swap_file(self, event: Event_Factory_Types.GetSwapFileEvent):
+        if not event.buffer: return
+
+        for i, file in enumerate(self):
+            if not event.buffer == file.buffer: continue
+
+            j              = self.next_index(i)
+            next_file      = self[j]
+            swapped_file   = self[j] if not j == -1 else None
+
+            event.response = [swapped_file, next_file]
+
+            return swapped_file, next_file
+
+    def pop_file(self, event: Event_Factory_Types.PopFileEvent):
+        if not event.buffer: return
+
+        for i, file in enumerate(self):
+            if not event.buffer == file.buffer: continue
+
+            j               = self.next_index(i)
+            next_file       = self[j] if not j == -1 else None
+            popped_file     = self.pop(i)
+
+            event.response  = [popped_file, next_file]
+
+        eve = Event_Factory.create_event(
+            "popped_file",
+            view      = view,
+            file      = popped_file,
+            next_file = next_file
+        )
+        self.message_all(eve)
+
+        return popped_file, next_file
+
+    def remove_file(self, event: Event_Factory_Types.RemoveFileEvent):
+        if not event.buffer: return
+
+        for i, file in enumerate(self):
+            if not event.buffer == file.buffer: continue
+
+            j                = self.next_index(i)
+            next_file        = self[j] if not j == -1 else None
+
+            event.response   = next_file
+
+            eve = Event_Factory.create_event(
+                "removed_file",
+                view         = event.view,
+                ignore_focus = True,
+                file         = file,
+                next_file    = next_file
+            )
+            self.message_all(eve)
+
+            self.remove(file)
+            file.close()
+
+            return next_file
+
+    def next_index(self, i):
+        size = len(self)
+
+        if (i == 0) & (size >= 2):
+            j = i + 1
+        elif (i == (size - 1)) & (size >= 2):
+            j = i - 1
+        elif (size - 1) == 0:
+            j = -1
+        else:
+            j = i + 1
+
+        return j

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

@@ -0,0 +1,128 @@
+# Python imports
+
+# Lib imports
+
+# Application imports
+from ..event_factory import Event_Factory, Event_Factory_Types
+
+from ..command_system import CommandSystem
+from ..key_mapper import KeyMapper
+
+from ..source_view import SourceView
+
+from .controller_base import ControllerBase
+
+
+
+class SourceViewsController(ControllerBase, list):
+    def __init__(self):
+        super(SourceViewsController, self).__init__()
+
+        self.key_mapper: KeyMapper   = KeyMapper()
+        self.active_view: SourceView = None
+
+
+    def get_command_system(self):
+        event = Event_Factory.create_event("get_command_system")
+        self.message_to("commands", event)
+        command = event.response
+
+        del event
+        return command
+
+    def create_source_view(self):
+        source_view: SourceView = SourceView()
+        source_view.command     = self.get_command_system()
+        source_view.command.set_data(source_view)
+
+        self._map_signals(source_view)
+
+        self.append(source_view)
+        return source_view
+
+    def _controller_message(self, event: Event_Factory_Types.CodeEvent):
+        if isinstance(event, Event_Factory_Types.RemovedFileEvent):
+            self._remove_file(event)
+        elif isinstance(event, Event_Factory_Types.TextChangedEvent):
+            self.active_view.command.exec("update_info_bar")
+
+    def _map_signals(self, source_view: SourceView):
+        source_view.connect("focus-in-event",       self._focus_in_event)
+        source_view.connect("move-cursor",          self._move_cursor)
+        source_view.connect("key-press-event",      self._key_press_event)
+        source_view.connect("key-release-event",    self._key_release_event)
+        source_view.connect("button-press-event",   self._button_press_event)
+        source_view.connect("button-release-event", self._button_release_event)
+
+    def _focus_in_event(self, view, eve):
+        self.active_view = view
+
+        view.command.exec("set_miniview")
+        view.command.exec("set_focus_border")
+        view.command.exec("update_info_bar")
+
+        event = Event_Factory.create_focused_view(view = view)
+        self.emit(event)
+
+    def _move_cursor(self, view, step, count, extend_selection):
+        buffer       = view.get_buffer()
+        iter         = buffer.get_iter_at_mark( buffer.get_insert() )
+        line         = iter.get_line()
+        char         = iter.get_line_offset()
+
+        event = Event_Factory.create_cursor_moved(
+            view   = view,
+            buffer = buffer,
+            line   = line,
+            char   = char
+        )
+
+        self.emit(event)
+
+        view.command.exec("update_info_bar")
+
+    def _button_press_event(self, view, eve):
+        self.active_view.command.exec("update_info_bar")
+
+    def _button_release_event(self, view, eve):
+        self.active_view.command.exec("update_info_bar")
+
+    def _key_press_event(self, view, eve):
+        command   = self.key_mapper._key_press_event(eve)
+        is_future = self.key_mapper._key_release_event(eve)
+
+        if is_future: return True
+        if not command: return False
+
+        view.command.exec(command)
+
+        return True
+
+    def _key_release_event(self, view, eve):
+        command = self.key_mapper._key_release_event(eve)
+        is_past = self.key_mapper._key_press_event(eve)
+
+        if is_past: return True
+        if not command: return False
+
+        view.command.exec(command)
+
+        return True
+
+    def _remove_file(self, event: Event_Factory_Types.RemovedFileEvent):
+        for view in self:
+            if not event.file.buffer == view.get_buffer(): continue
+            if not event.next_file:
+                view.command.exec("new_file")
+                continue
+
+            view.set_buffer(event.next_file.buffer)
+
+    def first_map_load(self):
+        for view in self:
+            view.command.exec("new_file")
+
+        view = self[0]
+        view.grab_focus()
+        view.command.exec("load_start_files")
+

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

@@ -0,0 +1,86 @@
+# Python imports
+
+# Lib imports
+
+# Application imports
+from libs.dto.code import CodeEvent
+from ..event_factory import Event_Factory, Event_Factory_Types
+
+from ..tabs_widget import TabsWidget
+from ..tab_widget import TabWidget
+
+from ..source_view import SourceView
+
+from .controller_base import ControllerBase
+
+
+
+class TabsController(ControllerBase):
+    def __init__(self):
+        super(TabsController, self).__init__()
+
+        self.active_view: SourceView = None
+        self.tabs_widget: TabsWidget = TabsWidget()
+
+
+    def _controller_message(self, event: CodeEvent):
+        if isinstance(event, Event_Factory_Types.FocusedViewEvent):
+            self.active_view = event.view
+        elif isinstance(event, Event_Factory_Types.FilePathSetEvent):
+            self.update_tab_label(event)
+        elif isinstance(event, Event_Factory_Types.AddedNewFileEvent):
+            self.add_tab(event)
+        elif isinstance(event, Event_Factory_Types.PoppedFileEvent):
+            ...
+        elif isinstance(event, Event_Factory_Types.RemovedFileEvent):
+            self.remove_tab(event)
+    
+    def get_tabs_widget(self):
+        return self.tabs_widget
+
+    def update_tab_label(self, event: Event_Factory_Types.FilePathSetEvent):
+        for tab in self.tabs_widget.get_children():
+            if not event.file == tab.file: continue
+            tab.label.set_label(event.file.fname)
+            break
+
+    def add_tab(self, event: Event_Factory_Types.AddedNewFileEvent):
+        def set_active_tab(tab, eve, file):
+            event = Event_Factory.create_event(
+                "set_active_file",
+                buffer = tab.get_parent().file.buffer
+            )
+
+            self.active_view.set_buffer(
+                tab.get_parent().file.buffer
+            )
+
+            self.message_all(event)
+
+        def close_tab(tab, eve, file):
+            event = Event_Factory.create_event(
+                "remove_file",
+                buffer = tab.get_parent().file.buffer
+            )
+
+            self.message_all(event)
+
+        tab = TabWidget()
+        tab.file = event.file
+        tab.label.set_label(event.file.fname)
+        tab.set_select_signal(set_active_tab)
+        tab.set_close_signal(close_tab)
+
+        self.tabs_widget.add(tab)
+        tab.show()
+
+    def remove_tab(self, event: Event_Factory_Types.RemovedFileEvent):
+        for tab in self.tabs_widget.get_children():
+            if not event.file == tab.file: continue
+
+            tab.clear_signals_and_data()
+            tab.run_dispose()
+            tab.destroy()
+
+            del tab
+            break

src/core/widgets/code/event_factory.py

@@ -0,0 +1,101 @@
+# Python imports
+import inspect
+from typing import Dict, Type
+import re
+
+# Lib imports
+
+# Application imports
+from libs.singleton import Singleton
+from libs.dto.code import CodeEvent
+from libs.dto import code
+
+
+
+class EventFactory(Singleton):
+    def __init__(self):
+        self._event_classes: Dict[str, Type[CodeEvent]] = {}
+
+        self._auto_register_events()
+
+    def register_event(self, event_type: str, event_class: Type[CodeEvent]):
+        self._event_classes[event_type] = event_class
+
+    def create_event(self, event_type: str, **kwargs) -> CodeEvent:
+        if event_type not in self._event_classes:
+            raise ValueError(f"Unknown event type: {event_type}")
+
+        event_class = self._event_classes[event_type]
+        event = event_class()
+
+        for key, value in kwargs.items():
+            if hasattr(event, key):
+                setattr(event, key, value)
+            else:
+                raise ValueError(f"Event class {event_class.__name__} has no attribute '{key}'")
+
+        return event
+
+    def _auto_register_events(self):
+        for name, obj in code.__dict__.items():
+            if not self._is_valid_event_class(obj): continue
+
+            event_type = self._class_name_to_event_type(name)
+            self.register_event(event_type, obj)
+
+        logger.debug(f"Auto-registered {len(self._event_classes)} event types")
+
+    def _is_valid_event_class(self, obj) -> bool:
+        return (inspect.isclass(obj) and 
+                issubclass(obj, CodeEvent) and 
+                obj != CodeEvent)
+
+    def _class_name_to_event_type(self, class_name: str) -> str:
+        base_name = class_name[:-5] if class_name.endswith('Event') else class_name
+        return re.sub(r'(?<!^)(?=[A-Z])', '_', base_name).lower()
+
+    def create_cursor_moved(self, **kwargs):
+        return self.create_event("cursor_moved", **kwargs)
+
+    def create_text_changed(self, **kwargs):
+        return self.create_event("text_changed", **kwargs)
+
+    def create_focused_view(self, **kwargs):
+        return self.create_event("focused_view", **kwargs)
+
+    def create_modified_changed(self, **kwargs):
+        return self.create_event("modified_changed", **kwargs)
+
+    def create_get_command_system(self, **kwargs):
+        return self.create_event("get_command_system", **kwargs)
+
+    def create_file_path_set(self, **kwargs):
+        return self.create_event("file_path_set", **kwargs)
+
+    def create_text_inserted(self, **kwargs):
+        return self.create_event("text_inserted", **kwargs)
+
+    def create_set_active_file(self, **kwargs):
+        return self.create_event("set_active_file", **kwargs)
+
+    def create_added_new_file(self, **kwargs):
+        return self.create_event("added_new_file", **kwargs)
+
+    def create_popped_file(self, **kwargs):
+        return self.create_event("popped_file", **kwargs)
+
+    def create_get_file(self, **kwargs):
+        return self.create_event("get_file", **kwargs)
+
+    def create_get_swap_file(self, **kwargs):
+        return self.create_event("get_swap_file", **kwargs)
+
+    def create_remove_file(self, **kwargs):
+        return self.create_event("remove_file", **kwargs)
+
+    def create_removed_file(self, **kwargs):
+        return self.create_event("removed_file", **kwargs)
+
+
+Event_Factory       = EventFactory()
+Event_Factory_Types = code

src/core/widgets/code/info_bar_widget.py

@@ -0,0 +1,100 @@
+# Python imports
+
+# Lib imports
+import gi
+gi.require_version('Gtk', '3.0')
+from gi.repository import Gtk
+from gi.repository import Pango
+from gi.repository import Gio
+
+# Application imports
+
+
+
+class InfoBarWidget(Gtk.Box):
+    """ docstring for InfoBarWidget. """
+
+    def __init__(self):
+        super(InfoBarWidget, self).__init__()
+
+        self._setup_styling()
+        self._setup_signals()
+        self._subscribe_to_events()
+        self._load_widgets()
+
+        self.show_all()
+
+
+    def _setup_styling(self):
+        self.set_margin_start(25)
+        self.set_margin_end(25)
+
+    def _setup_signals(self):
+        ...
+
+    def _subscribe_to_events(self):
+        event_system.subscribe("set-info-labels", self._set_info_labels)
+        event_system.subscribe("set-path-label", self._set_path_label)
+        event_system.subscribe("set-encoding-label", self._set_encoding_label)
+        event_system.subscribe("set-line-char-label", self._set_line_char_label)
+        event_system.subscribe("set-file-type-label", self._set_file_type_label)
+
+
+    def _load_widgets(self):
+        self.path_label      = Gtk.Label(label = "...")
+        self.line_char_label = Gtk.Label(label = "1:0")
+        self.encoding_label  = Gtk.Label(label = "utf-8")
+        self.file_type_label = Gtk.Label(label = "buffer")
+
+        self.add(self.path_label)
+        self.add(self.line_char_label)
+        self.add(self.encoding_label)
+        self.add(self.file_type_label)
+
+        self.path_label.set_hexpand(True)
+        self.path_label.set_ellipsize(Pango.EllipsizeMode.START)
+        self.path_label.set_single_line_mode(True)
+        self.path_label.set_max_width_chars(48)
+
+        self.line_char_label.set_hexpand(True)
+        self.encoding_label.set_hexpand(True)
+        self.file_type_label.set_hexpand(True)
+
+    def _set_info_labels(
+        self,
+        path: Gio.File or str = None,
+        line_char: str = None,
+        file_type: str = None,
+        encoding_type: str = None
+    ):
+        self._set_path_label(path)
+        self._set_line_char_label(line_char)
+        self._set_file_type_label(file_type)
+        self._set_encoding_label(encoding_type)
+
+    def _set_path_label(self, gfile: Gio.File or str = "..."):
+        gfile = "" if not gfile else gfile
+
+        if isinstance(gfile, str):
+            self.path_label.set_text( gfile )
+            self.path_label.set_tooltip_text( gfile )
+        else:
+            self.path_label.set_text( gfile.get_path() )
+            self.path_label.set_tooltip_text( gfile.get_path() )
+
+    def _set_line_char_label(self, line_char = "1:1"):
+        line_char = "1:1" if not line_char else line_char
+
+        self.line_char_label.set_text(line_char)
+
+    def _set_file_type_label(self, file_type = "buffer"):
+        file_type = "buffer" if not file_type else file_type 
+
+        self.file_type_label.set_text(file_type)
+
+    def _set_encoding_label(self, encoding_type = "utf-8"):
+        encoding_type = "utf-8" if not encoding_type else encoding_type
+
+        self.encoding_label.set_text(encoding_type)
+
+

src/core/widgets/code/key_mapper.py

@@ -0,0 +1,127 @@
+# Python imports
+import copy
+import json
+
+# Lib imports
+import gi
+gi.require_version('Gdk', '3.0')
+from gi.repository import Gdk
+
+# Application imports
+
+
+
+class NoKeyState:
+    held: dict     = {}
+    released: dict = {}
+
+class CtrlKeyState:
+    held: dict     = {}
+    released: dict = {}
+
+class ShiftKeyState:
+    held: dict     = {}
+    released: dict = {}
+
+class AltKeyState:
+    held: dict     = {}
+    released: dict = {}
+
+class CtrlShiftKeyState:
+    held: dict     = {}
+    released: dict = {}
+
+class CtrlAltKeyState:
+    held: dict     = {}
+    released: dict = {}
+
+class AltShiftKeyState:
+    held: dict     = {}
+    released: dict = {}
+
+class CtrlShiftAltKeyState:
+    held: dict     = {}
+    released: dict = {}
+
+
+
+class KeyMapper:
+    def __init__(self):
+        super(KeyMapper, self).__init__()
+
+        self.state   = NoKeyState
+        self._map    = {
+            NoKeyState:                                              NoKeyState(),
+            NoKeyState | CtrlKeyState :                              CtrlKeyState(),
+            NoKeyState | ShiftKeyState:                              ShiftKeyState(),
+            NoKeyState | AltKeyState  :                              AltKeyState(),
+            NoKeyState | CtrlKeyState | ShiftKeyState :              CtrlShiftKeyState(),
+            NoKeyState | CtrlKeyState | AltKeyState   :              CtrlAltKeyState(),
+            NoKeyState | AltKeyState  | ShiftKeyState :              AltShiftKeyState(),
+            NoKeyState | CtrlKeyState | ShiftKeyState | AltKeyState: CtrlShiftAltKeyState(),
+        }
+
+        self.load_map()
+
+
+    def load_map(self):
+        self.states   = copy.deepcopy(self._map)
+        bindings_file = f"{settings_manager.path_manager.get_home_config_path()}/code-key-bindings.json"
+
+        with open(bindings_file, 'r') as f:
+            data = json.load(f)["keybindings"]
+
+            for command in data:
+                press_state = "held" if "held" in data[command] else "released"
+                keyname     = data[command][press_state]
+
+                state       = NoKeyState
+                if "<Control>" in keyname:
+                    state = state | CtrlKeyState
+                if "<Shift>" in keyname:
+                    state = state | ShiftKeyState
+                if "<Alt>" in keyname:
+                    state = state | AltKeyState
+
+                keyname = keyname.replace("<Control>", "") \
+                                 .replace("<Shift>",   "") \
+                                 .replace("<Alt>",     "") \
+                                 .lower()
+
+                getattr(self.states[state], press_state)[keyname] = command
+
+    def re_map(self):
+        self.states = copy.deepcopy(self._map)
+
+    def _key_press_event(self, eve):
+        keyname = Gdk.keyval_name(eve.keyval).lower()
+
+        self._set_key_state(eve)
+        if keyname in self.states[self.state].held:
+            return self.states[self.state].held[keyname]
+
+    def _key_release_event(self, eve):
+        keyname = Gdk.keyval_name(eve.keyval).lower()
+
+        self._set_key_state(eve)
+        if keyname in self.states[self.state].released:
+            return self.states[self.state].released[keyname]
+
+    def _set_key_state(self, eve):
+        modifiers  = Gdk.ModifierType(eve.get_state() & ~Gdk.ModifierType.LOCK_MASK)
+        is_control = True if modifiers & Gdk.ModifierType.CONTROL_MASK else False
+        is_shift   = True if modifiers & Gdk.ModifierType.SHIFT_MASK else False
+
+        try:
+            is_alt = True if modifiers & Gdk.ModifierType.ALT_MASK else False
+        except Exception:
+            is_alt = True if modifiers & Gdk.ModifierType.MOD1_MASK else False
+
+        self.state = NoKeyState
+        if is_control:
+            self.state = self.state | CtrlKeyState
+        if is_shift:
+            self.state = self.state | ShiftKeyState
+        if is_alt:
+            self.state = self.state | AltKeyState
+

src/core/widgets/code/mini_view_widget.py

@@ -0,0 +1,39 @@
+# Python imports
+
+# Lib imports
+import gi
+gi.require_version('GtkSource', '4')
+from gi.repository.GtkSource import Map
+
+
+# Application imports
+
+
+
+class MiniViewWidget(Map):
+    def __init__(self):
+        super(MiniViewWidget, self).__init__()
+
+        self._setup_styling()
+        self._setup_signals()
+        self._subscribe_to_events()
+        self._load_widgets()
+
+
+    def _setup_styling(self):
+        ctx = self.get_style_context()
+        ctx.add_class("mini-view")
+
+        self.set_hexpand(False)
+
+    def _setup_signals(self):
+        ...
+
+    def _subscribe_to_events(self):
+        event_system.subscribe(f"set-mini-view", self.set_smini_view)
+
+    def _load_widgets(self):
+        ...
+
+    def set_smini_view(self, source_view):
+        self.set_view(source_view)

src/core/widgets/code/mixins/__init__.py

@@ -0,0 +1,3 @@
+"""
+    Code Mixins Package
+"""

src/core/widgets/code/mixins/source_view_dnd_mixin.py

@@ -0,0 +1,40 @@
+# Python imports
+
+# Lib imports
+import gi
+gi.require_version('Gtk', '3.0')
+from gi.repository import Gtk
+
+# Application imports
+
+
+
+class SourceViewDnDMixin:
+
+    def _set_up_dnd(self):
+        PLAIN_TEXT_TARGET_TYPE = 70
+        URI_TARGET_TYPE        = 80
+        text_target = Gtk.TargetEntry.new('text/plain', Gtk.TargetFlags(0), PLAIN_TEXT_TARGET_TYPE)
+        uri_target  = Gtk.TargetEntry.new('text/uri-list', Gtk.TargetFlags(0), URI_TARGET_TYPE)
+        targets     = [ text_target, uri_target ]
+
+        self.drag_dest_set_target_list(targets)
+
+    def _on_drag_data_received(self, widget, drag_context, x, y, data, info, time):
+        if info == 70: return
+
+        if info == 80:
+            uris = data.get_uris()
+
+            if len(uris) == 0:
+                uris = data.get_text().split("\n")
+
+            self._on_uri_data_received(uris)
+
+    def _on_uri_data_received(self, uris: []):
+            uri = uris.pop(0)
+            self.command.exec_with_args("dnd_load_file_to_buffer", (self, uri))
+
+            if len(uris) == 0: return
+
+            self.command.exec_with_args("dnd_load_files", (self, uris))

src/core/widgets/code/source_buffer.py

@@ -0,0 +1,40 @@
+# Python imports
+
+# Lib imports
+import gi
+gi.require_version('GtkSource', '4')
+from gi.repository import GtkSource
+
+# Application imports
+
+
+
+class SourceBuffer(GtkSource.Buffer):
+    def __init__(self):
+        super(SourceBuffer, self).__init__()
+
+        self._handler_ids = []
+
+
+    def set_signals(
+        self,
+        _changed,
+        _mark_set,
+        _insert_text,
+        _modified_changed,
+    ):
+
+        self._handler_ids = [
+            self.connect("changed",          _changed),
+            self.connect("mark-set",         _mark_set),
+            self.connect("insert-text",      _insert_text),
+            self.connect("modified-changed", _modified_changed)
+        ]
+
+    def clear_signals(self):
+        for handle_id in self._handler_ids:
+            self.disconnect(handle_id)
+
+    def __del__(self):
+        for handle_id in self._handler_ids:
+            self.disconnect(handle_id)

src/core/widgets/code/source_file.py

@@ -0,0 +1,129 @@
+# Python imports
+import os
+
+# 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
+from gi.repository import Gio
+
+# Application imports
+from libs.dto.code import CodeEvent
+from .event_factory import Event_Factory, Event_Factory_Types
+
+from .source_buffer import SourceBuffer
+
+
+
+class SourceFile(GtkSource.File):
+    def __init__(self):
+        super(SourceFile, self).__init__()
+
+        self.encoding: str        = "UTF-8"
+        self.fname: str           = "buffer"
+        self.fpath: str           = "buffer"
+        self.ftype: str           = "buffer"
+
+        self.buffer: SourceBuffer = SourceBuffer()
+
+        self._set_signals()
+
+
+    def _set_signals(self):
+        self.buffer.set_signals(
+            self._changed,
+            self._mark_set,
+            self._insert_text,
+            self._modified_changed
+        )
+
+    def _changed(self, buffer: SourceBuffer):
+        event = Event_Factory.create_text_changed(buffer = buffer)
+        event.file = self
+        self.emit(event)
+
+    def _insert_text(self, buffer: SourceBuffer, location: Gtk.TextIter,
+        text: str, length: int
+    ):
+        event = Event_Factory.create_event(
+            "text_inserted",
+            file   = self,
+            buffer = buffer
+        )
+        self.emit(event)
+
+    def _mark_set(self, buffer: SourceBuffer, location: Gtk.TextIter,
+        mark: Gtk.TextMark
+    ):
+        # event        = CodeEvent()
+        # event.etype  = "mark_set"
+        # event.file   = self
+        # event.buffer = buffer
+
+        # self.emit(event)
+        ...
+
+    def _modified_changed(self, buffer: SourceBuffer):
+        event = Event_Factory.create_modified_changed(
+            file = self, buffer = buffer
+        )
+
+        self.emit(event)
+
+    def _write_file(self, gfile: Gio.File):
+        if not gfile: return
+
+        with open(gfile.get_path(), 'w') as f:
+            start_itr, end_itr = self.buffer.get_bounds()
+            text = self.buffer.get_text(start_itr, end_itr, True)
+
+            f.write(text)
+
+        return gfile
+
+
+    def load_path(self, gfile: Gio.File):
+        if not gfile: return
+
+        self.set_path(gfile)
+        data         = gfile.load_bytes()[0].get_data().decode("UTF-8")
+        undo_manager = self.buffer.get_undo_manager()
+
+        undo_manager.begin_not_undoable_action()
+        self.buffer.insert_at_cursor(data)
+        undo_manager.end_not_undoable_action()
+
+    def set_path(self, gfile: Gio.File):
+        if not gfile: return
+        self.set_location(gfile)
+
+        self.fpath   = gfile.get_path()
+        self.fname   = gfile.get_basename()
+
+        event = Event_Factory.create_event("file_path_set", file = self)
+        self.emit(event)
+
+    def save(self):
+        self._write_file( self.get_location() )
+
+    def save_as(self):
+        file = event_system.emit_and_await("save-file-dialog")
+        if not file: return
+
+        self._write_file(file)
+        self.set_path(file)
+
+        return file
+
+    def close(self):
+        del self.buffer
+
+    def emit(self, event: CodeEvent):
+        ...
+
+    def emit_to(self, controller: str, event: CodeEvent):
+        ...

src/core/widgets/code/source_view.py

@@ -0,0 +1,84 @@
+# 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 GLib
+from gi.repository import GtkSource
+
+from .mixins.source_view_dnd_mixin import SourceViewDnDMixin
+
+
+
+class SourceView(GtkSource.View, SourceViewDnDMixin):
+    def __init__(self):
+        super(SourceView, self).__init__()
+
+        self._cut_temp_timeout_id = None
+        self._cut_buffer          = ""
+
+        self.sibling_right        = None
+        self.sibling_left         = None
+
+        self._setup_styles()
+        self._setup_signals()
+        self._subscribe_to_events()
+        self._load_widgets()
+
+
+    def _setup_styles(self):
+        self.zoom_level = settings_manager.settings.theming.default_zoom
+        ctx             = self.get_style_context()
+
+        ctx.add_class("source-view")
+        ctx.add_class(f"px{self.zoom_level}")
+
+        self.set_vexpand(True)
+        self.set_bottom_margin(800)
+
+        self.set_show_line_marks(True)
+        self.set_show_line_numbers(True)
+        self.set_smart_backspace(True)
+        self.set_indent_on_tab(True)
+        self.set_insert_spaces_instead_of_tabs(True)
+        self.set_auto_indent(True)
+        self.set_monospace(True)
+        self.set_tab_width(4)
+        self.set_show_right_margin(True)
+        self.set_right_margin_position(80)
+        self.set_background_pattern(0) # 0 = None, 1 = Grid
+        self.set_highlight_current_line(True)
+
+    def _setup_signals(self):
+        self.connect("drag-data-received", self._on_drag_data_received)
+
+    def _subscribe_to_events(self):
+        ...
+
+    def _load_widgets(self):
+        self.language_manager     = GtkSource.LanguageManager()
+        self.style_scheme_manager = GtkSource.StyleSchemeManager()
+
+        self.style_scheme_manager.append_search_path(
+            f"{settings_manager.path_manager.get_home_config_path()}/code_styles"
+        )
+        self.syntax_theme = self.style_scheme_manager.get_scheme(
+            f"{settings_manager.settings.theming.syntax_theme}"
+        )
+
+        self._set_up_dnd()
+
+    def clear_temp_cut_buffer_delayed(self):
+        if self._cut_temp_timeout_id:
+            GLib.source_remove(self._cut_temp_timeout_id)
+
+    def set_temp_cut_buffer_delayed(self):
+        def clear_temp_buffer():
+            self._cut_buffer          = ""
+            self._cut_temp_timeout_id = None
+            return False
+
+        self._cut_temp_timeout_id = GLib.timeout_add(15000, clear_temp_buffer)

src/core/widgets/code/tab_widget.py

@@ -0,0 +1,61 @@
+# Python imports
+
+# Lib imports
+import gi
+gi.require_version('Gtk', '3.0')
+from gi.repository import Gtk
+
+# Application imports
+
+
+
+class TabWidget(Gtk.Box):
+    def __init__(self):
+        super(TabWidget, self).__init__()
+
+        self.file = None
+
+        self._setup_styling()
+        self._setup_signals()
+        self._subscribe_to_events()
+        self._load_widgets()
+
+        self.show_all()
+
+
+    def _setup_styling(self):
+        ctx = self.get_style_context()
+        ctx.add_class("tab-widget")
+
+    def _setup_signals(self):
+        ...
+
+    def _subscribe_to_events(self):
+        ...
+
+    def _load_widgets(self):
+        self._label_eve_box = Gtk.EventBox()
+        self.label          = Gtk.Label(label = "")
+        self.close_btn      = Gtk.Button(label = "X")
+
+        ctx = self.label.get_style_context()
+        ctx.add_class("tab-label")
+        ctx = self.close_btn.get_style_context()
+        ctx.add_class("tab-close-bttn")
+
+        self.label.set_hexpand(True)
+
+        self._label_eve_box.add(self.label)
+        self.add(self._label_eve_box)
+        self.add(self.close_btn)
+
+    def clear_signals_and_data(self):
+        del self.file
+        self._label_eve_box.disconnect(self._label_eve_box_id)
+        self.close_btn.disconnect(self.close_btn_id)
+
+    def set_select_signal(self, callback):
+        self._label_eve_box_id = self._label_eve_box.connect('button-release-event', callback, self.file)
+
+    def set_close_signal(self, callback):
+        self.close_btn_id = self.close_btn.connect('button-release-event', callback, self.file)

src/core/widgets/code/tabs_widget.py

@@ -0,0 +1,87 @@
+# Python imports
+
+# Lib imports
+import gi
+gi.require_version('Gtk', '3.0')
+from gi.repository import Gtk
+
+# Application imports
+from libs.dto.code.code_event import CodeEvent
+
+from .source_view import SourceView
+from .source_file import SourceFile
+
+from .tab_widget import TabWidget
+
+
+
+class TabsWidget(Gtk.ButtonBox):
+    def __init__(self):
+        super(TabsWidget, self).__init__()
+
+        self._setup_styling()
+        self._setup_signals()
+        self._subscribe_to_events()
+        self._load_widgets()
+
+
+    def _setup_styling(self):
+        self.set_layout(Gtk.ButtonBoxStyle.CENTER)
+
+    def _setup_signals(self):
+        ...
+
+    def _subscribe_to_events(self):
+        ...
+
+    def _load_widgets(self):
+        ...
+
+    def add_tab(self, event: CodeEvent):
+        """Add a tab widget for the given file event."""
+        if not hasattr(self, 'tabs'):
+            return
+            
+        tab      = TabWidget()
+        tab.file = event.file
+
+        tab.label.set_label(event.file.fname)
+
+        def select_signal(widget, eve, file):
+            self.code_base.active_view.command.exec_with_args(
+                "set_buffer",
+                (self.code_base.active_view, file)
+            )
+
+        def close_signal(widget, eve, file):
+            self.code_base.files_controller.remove_file(file.buffer)
+
+        tab.set_select_signal(select_signal)
+        tab.set_close_signal(close_signal)
+
+        self.tabs.add(tab)
+
+    def remove_tab(self, event: CodeEvent):
+        """Remove a tab widget for the given file event."""
+        if not hasattr(self, 'tabs'):
+            return
+            
+        for child in self.tabs.get_children():
+            if not child.file == event.file: continue
+
+            self.tabs.remove(child)
+            child.clear_signals_and_data()
+            del child
+
+            return
+    
+    def update_tab_label(self, event: CodeEvent):
+        """Update tab label for the given file event."""
+        if not hasattr(self, 'tabs'):
+            return
+            
+        for tab in self.tabs.get_children():
+            if not tab.file == event.file: continue
+            tab.label.set_label(event.file.fname)
+
+            return

src/core/widgets/controls/open_files_button.py

@@ -1,12 +1,11 @@
 # Python imports
+from contextlib import suppress
 import os
 
 # Lib imports
 import gi
 gi.require_version('Gtk', '3.0')
-gi.require_version('Gdk', '3.0')
 from gi.repository import Gtk
-from gi.repository import Gdk
 from gi.repository import Gio
 
 # Application imports
@@ -36,7 +35,7 @@ class OpenFilesButton(Gtk.Button):
         self.connect("button-release-event", self._open_files)
 
     def _subscribe_to_events(self):
-        event_system.subscribe("open_files", self._open_files)
+        event_system.subscribe("open-files", self._open_files)
 
     def _load_widgets(self):
         ...
@@ -60,11 +59,9 @@ class OpenFilesButton(Gtk.Button):
 
         chooser.set_select_multiple(True)
 
-        try:
+        with suppress(Exception):
             folder = widget.get_current_file().get_parent() if not start_dir else start_dir
             chooser.set_current_folder( folder.get_path() )
-        except Exception as e:
-            ...
 
         response = chooser.run()
         if not response == Gtk.ResponseType.OK:

src/core/widgets/controls/save_as_button.py

@@ -0,0 +1,72 @@
+# Python imports
+import os
+
+# Lib imports
+import gi
+gi.require_version('Gtk', '3.0')
+from gi.repository import Gtk
+from gi.repository import Gio
+
+# Application imports
+
+
+
+class SaveAsButton(Gtk.Button):
+    def __init__(self):
+        super(SaveAsButton, self).__init__()
+
+        self._setup_styling()
+        self._setup_signals()
+        self._subscribe_to_events()
+        self._load_widgets()
+
+
+    def _setup_styling(self):
+        self.set_label("Save As")
+        self.set_image( Gtk.Image.new_from_icon_name("gtk-save-as", 4) )
+        self.set_always_show_image(True)
+        self.set_image_position(1) # Left - 0, Right = 1
+        self.set_hexpand(False)
+
+    def _setup_signals(self):
+        self.connect("released", self._save_as)
+
+    def _subscribe_to_events(self):
+        event_system.subscribe("save-as", self._save_as)
+
+    def _load_widgets(self):
+        ...
+
+    def _save_as(self, widget = None, eve = None, gfile = None):
+        start_dir = None
+        _gfile    = None
+
+        chooser = Gtk.FileChooserDialog("Save File As...", None,
+                                        Gtk.FileChooserAction.SAVE,
+                                        (
+                                            Gtk.STOCK_CANCEL,
+                                            Gtk.ResponseType.CANCEL,
+                                            Gtk.STOCK_SAVE_AS,
+                                            Gtk.ResponseType.OK
+                                        )
+        )
+
+        # chooser.set_select_multiple(False)
+
+        response = chooser.run()
+        if not response == Gtk.ResponseType.OK:
+            chooser.destroy()
+            return _gfile
+
+        file = chooser.get_filename()
+        if not file:
+            chooser.destroy()
+            return _gfile
+
+        path   = file if os.path.isabs(file) else os.path.abspath(file)
+        _gfile = Gio.File.new_for_path(path) 
+
+        chooser.destroy()
+
+        logger.debug(f"File To Save As:  {_gfile}")
+        return _gfile

src/core/widgets/controls/transparency_scale.py

@@ -38,11 +38,11 @@ class TransparencyScale(Gtk.Scale):
         adjust = self.get_adjustment()
         adjust.set_lower(0)
         adjust.set_upper(100)
-        adjust.set_value(settings.theming.transparency)
+        adjust.set_value(settings_manager.settings.theming.transparency)
         adjust.set_step_increment(1.0)
 
     def _update_transparency(self, range):
         event_system.emit("remove-transparency")
         tp = int(range.get_value())
-        settings.theming.transparency = tp
+        settings_manager.settings.theming.transparency = tp
         event_system.emit("update-transparency")

src/core/widgets/pager_widget.py

@@ -0,0 +1,35 @@
+# Python imports
+
+# Lib imports
+import gi
+gi.require_version('Wnck', '3.0')
+from gi.repository import Wnck
+
+# Application imports
+
+
+
+class PagerWidget:
+    def __init__(self):
+        super(PagerWidget, self).__init__()
+
+        self._setup_styling()
+        self._setup_signals()
+        self._subscribe_to_events()
+        self._load_widgets()
+
+
+    def _setup_styling(self):
+        ...
+
+    def _setup_signals(self):
+        ...
+
+    def _subscribe_to_events(self):
+        ...
+
+    def _load_widgets(self):
+        ...
+
+    def get_widget(self):
+        return Wnck.Pager.new()

src/core/widgets/separator_widget.py

@@ -0,0 +1,37 @@
+# Python imports
+
+# Lib imports
+import gi
+gi.require_version('Gtk', '3.0')
+from gi.repository import Gtk
+
+# Application imports
+
+
+
+class Separator(Gtk.Separator):
+    def __init__(self, id: str = None, ORIENTATION: int = 0):
+        super(Separator, self).__init__()
+
+        builder = settings_manager.get_builder()
+        if id:
+            builder.expose_object(id, self)
+
+        self.ORIENTATION = ORIENTATION
+        self._setup_styling()
+        self._setup_signals()
+        self._load_widgets()
+
+        self.show()
+
+
+    def _setup_styling(self):
+        # HORIZONTAL = 0, VERTICAL = 1
+        self.set_orientation(self.ORIENTATION)
+
+
+    def _setup_signals(self):
+        ...
+
+    def _load_widgets(self):
+        ...

src/core/widgets/task_list_widget.py

@@ -0,0 +1,54 @@
+# Python imports
+
+# Lib imports
+import gi
+gi.require_version('Gtk', '3.0')
+gi.require_version('Wnck', '3.0')
+from gi.repository import Gtk
+from gi.repository import Wnck
+
+# Application imports
+
+
+
+class TaskListWidget(Gtk.ScrolledWindow):
+    def __init__(self):
+        super(TaskListWidget, self).__init__()
+
+        self._setup_styling()
+        self._setup_signals()
+        self._subscribe_to_events()
+        self._load_widgets()
+
+        self.show_all()
+
+
+    def _setup_styling(self):
+        self.set_hexpand(False)
+        self.set_size_request(180, -1)
+
+    def _setup_signals(self):
+        ...
+
+    def _subscribe_to_events(self):
+        ...
+
+    def _load_widgets(self):
+        viewport  = Gtk.Viewport()
+        task_list = Wnck.Tasklist.new()
+        vbox      = Gtk.Box()
+
+        vbox.set_orientation(Gtk.Orientation.VERTICAL)
+
+
+        task_list.set_scroll_enabled(False)
+        task_list.set_button_relief(2)  # 0 = normal relief, 2 = no relief
+        task_list.set_grouping(1)       # 0 = mever group, 1 auto group, 2 = always group
+
+        task_list.set_vexpand(True)
+        task_list.set_include_all_workspaces(False)
+        task_list.set_orientation(1)    # 0 = horizontal, 1 = vertical
+
+        vbox.add(task_list)
+        viewport.add(vbox)
+        self.add(viewport)

src/core/widgets/vte_widget.py

@@ -61,7 +61,7 @@ class VteWidget(Vte.Terminal):
     def _do_session_spawn(self):
         self.spawn_sync(
             Vte.PtyFlags.DEFAULT,
-            settings_manager.get_home_path(),
+            settings_manager.path_manager.get_home_path(),
             ["/bin/bash"],
             [],
             GLib.SpawnFlags.DEFAULT,
@@ -70,16 +70,17 @@ class VteWidget(Vte.Terminal):
 
         # Note:  '-->:' is used as a delimiter to split on to get command actual.
         #              !!!  DO NOT REMOVE UNLESS CODE UPDATED ACCORDINGLY  !!!
+        # Also, KEEP the <space> prefix in commands to keep from inserting to bash history.
         startup_cmds = [
-            "env -i /bin/bash --noprofile --norc\n",
-            "export TERM='xterm-256color'\n",
-            "export LC_ALL=C\n",
-            "export XDG_RUNTIME_DIR='/run/user/1000'\n",
-            "export DISPLAY=:0\n",
-            f"export XAUTHORITY='{settings_manager.get_home_path()}/.Xauthority'\n",
-            f"\nexport HOME='{settings_manager.get_home_path()}'\n",
-            "export PS1='\\h@\\u \\W -->: '\n",
-            "clear\n"
+            " env -i /bin/bash --noprofile --norc\n",
+            " export TERM='xterm-256color'\n",
+            " export LC_ALL=C\n",
+            " export XDG_RUNTIME_DIR='/run/user/1000'\n",
+            " export DISPLAY=:0\n",
+            f" export XAUTHORITY='{settings_manager.path_manager.get_home_path()}/.Xauthority'\n",
+            f" \nexport HOME='{settings_manager.path_manager.get_home_path()}'\n",
+            " export PS1='\\h@\\u \\W -->: '\n",
+            " clear\n"
         ]
 
         for i in startup_cmds:
@@ -93,13 +94,16 @@ class VteWidget(Vte.Terminal):
         if not text.encode() == "\r".encode(): return
 
         text, attributes = self.get_text()
+
+        if not text: return
+
         lines            = text.strip().splitlines()
         command_ran      = None
 
         try:
             command_ran  = lines[-1].split("-->:")[1].strip()
         except VteWidgetException as e:
-            logger.debud(e)
+            logger.debug(e)
             return
 
         if not command_ran[0:3].encode() in self.cd_cmd_prefix:
@@ -114,12 +118,12 @@ class VteWidget(Vte.Terminal):
         event = Event("pty_path_updated", "", target_path)
         event_system.emit("handle_bridge_event", (event,))
 
-    def update_term_path(self, fpath):
+    def update_term_path(self, fpath: str):
         self.dont_process = True
 
         cmds = [f"cd '{fpath}'\n", "clear\n"]
-        for i in cmds:
-            self.run_command(i)
+        for cmd in cmds:
+            self.run_command(cmd)
 
-    def run_command(self, cmd):
+    def run_command(self, cmd: str):
         self.feed_child_binary(bytes(cmd, 'utf8'))

src/core/widgets/webkit/webkit_ui.py

@@ -37,7 +37,7 @@ class WebkitUI(WebKit2.WebView):
         self.set_settings( WebkitUISettings() )
 
     def _load_view(self):
-        path = settings_manager.get_context_path()
+        path = settings_manager.path_manager.get_context_path()
         data = None
 
         with open(f"{path}/index.html", "r") as f:

src/core/window.py

@@ -10,13 +10,18 @@ from gi.repository import Gtk
 from gi.repository import Gdk
 from gi.repository import GLib
 
+try:
+    from gi.repository import GdkX11
+except ImportError:
+    logger.debug("Could not import X11 gir module...")
+
 # Application imports
 from libs.status_icon import StatusIcon
 from core.controllers.base_controller import BaseController
 
 
 
-class ControllerStartExceptiom(Exception):
+class ControllerStartException(Exception):
     ...
 
 
@@ -31,6 +36,9 @@ class Window(Gtk.ApplicationWindow):
         self._status_icon = None
         self._controller  = None
 
+        self.guake_key    = settings_manager.get_guake_key()
+        self.hidefunc     = None
+
         self._setup_styling()
         self._setup_signals()
         self._subscribe_to_events()
@@ -38,29 +46,33 @@ class Window(Gtk.ApplicationWindow):
 
         self._set_window_data()
         self._set_size_constraints()
+        self._setup_window_toggle_event()
 
         self.show()
 
 
     def _setup_styling(self):
         self.set_title(f"{APP_NAME}")
-        self.set_icon_from_file( settings_manager.get_window_icon() )
+        self.set_icon_from_file( settings_manager.path_manager.get_window_icon() )
+        self.set_decorated(True)
+        self.set_skip_pager_hint(False)
+        self.set_skip_taskbar_hint(False)
         self.set_gravity(5)  # 5 = CENTER
         self.set_position(1) # 1 = CENTER, 4 = CENTER_ALWAYS
 
         ctx = self.get_style_context()
         ctx.add_class("main-window")
-        ctx.add_class(f"mw_transparency_{settings.theming.transparency}")
+        ctx.add_class(f"mw_transparency_{settings_manager.settings.theming.transparency}")
 
     def _setup_signals(self):
         self.connect("focus-in-event", self._on_focus_in_event)
         self.connect("focus-out-event", self._on_focus_out_event)
 
-        self.connect("delete-event", self._tear_down)
-        GLib.unix_signal_add(GLib.PRIORITY_DEFAULT, signal.SIGINT, self._tear_down)
+        self.connect("delete-event", self.stop)
+        GLib.unix_signal_add(GLib.PRIORITY_DEFAULT, signal.SIGINT, self.stop)
 
     def _subscribe_to_events(self):
-        event_system.subscribe("tear-down", self._tear_down)
+        event_system.subscribe("tear-down", self.stop)
         event_system.subscribe("load-interactive-debug", self._load_interactive_debug)
 
     def _load_widgets(self):
@@ -74,13 +86,22 @@ class Window(Gtk.ApplicationWindow):
 
         self.add( self._controller.get_base_container() )
 
+    def _display_manager(self):
+        """ Try to detect which display manager we are running under... """
+
+        import os
+        if os.environ.get('WAYLAND_DISPLAY'):
+            return 'WAYLAND'
+
+        return 'X11'
+
     def _set_size_constraints(self):
-        _window_x   = settings.config.main_window_x
-        _window_y   = settings.config.main_window_y
-        _min_width  = settings.config.main_window_min_width
-        _min_height = settings.config.main_window_min_height
-        _width      = settings.config.main_window_width
-        _height     = settings.config.main_window_height
+        _window_x   = settings_manager.settings.config.main_window_x
+        _window_y   = settings_manager.settings.config.main_window_y
+        _min_width  = settings_manager.settings.config.main_window_min_width
+        _min_height = settings_manager.settings.config.main_window_min_height
+        _width      = settings_manager.settings.config.main_window_width
+        _height     = settings_manager.settings.config.main_window_height
 
         self.move(_window_x, _window_y - 28)
         self.set_size_request(_min_width, _min_height)
@@ -90,16 +111,15 @@ class Window(Gtk.ApplicationWindow):
         screen = self.get_screen()
         visual = screen.get_rgba_visual()
 
-        if visual and screen.is_composited() and settings.config.make_transparent == 0:
+        if visual and screen.is_composited() and settings_manager.settings.config.make_transparent == 0:
             self.set_visual(visual)
             self.set_app_paintable(True)
             # self.connect("draw", self._area_draw)
 
         # bind css file
         cssProvider  = Gtk.CssProvider()
-        cssProvider.load_from_path( settings_manager.get_css_file() )
-        screen       = Gdk.Screen.get_default()
         styleContext = Gtk.StyleContext()
+        cssProvider.load_from_path( settings_manager.path_manager.get_css_file() )
         styleContext.add_provider_for_screen(screen, cssProvider, Gtk.STYLE_PROVIDER_PRIORITY_USER)
 
     def _area_draw(self, widget: Gtk.ApplicationWindow, cr: cairo.Context) -> None:
@@ -118,8 +138,53 @@ class Window(Gtk.ApplicationWindow):
     def _load_interactive_debug(self):
         self.set_interactive_debugging(True)
 
+    def _setup_window_toggle_event(self) -> None:
+        hidebound = None
+        if not self.guake_key or not self._display_manager() == 'X11':
+            return
 
-    def _tear_down(self, widget = None, eve = None):
+        try:
+            import gi
+            gi.require_version('Keybinder', '3.0')
+            from gi.repository import Keybinder
+
+            Keybinder.init()
+            Keybinder.set_use_cooked_accelerators(False)
+        except (ImportError, ValueError) as e:
+            logger.warning(e)
+            logger.warning('Unable to load Keybinder module. This means the hide_window shortcut will be unavailable')
+
+            return
+
+        # Attempt to grab a global hotkey for hiding the window.
+        # If we fail, we'll never hide the window, iconifying instead.
+        try:
+            hidebound = Keybinder.bind(self.guake_key, self._on_toggle_window, self)
+        except (KeyError, NameError) as e:
+            logger.warning(e)
+
+        if not hidebound:
+            logger.debug('Unable to bind hide_window key, another instance/window has it.')
+            self.hidefunc = self.iconify
+        else:
+            self.hidefunc = self.hide
+
+    def _on_toggle_window(self, data, window):
+        """Handle a request to hide/show the window"""
+        if not window.get_property('visible'):
+            window.show()
+            # Note: Needed to properly grab widget focus when set_skip_taskbar_hint set to True
+            window.present()
+            # NOTE:  Need here to enforce sticky after hide and reshow.
+            window.stick()
+        else:
+            self.hidefunc()
+
+
+    def start(self):
+        Gtk.main()
+
+    def stop(self, widget = None, eve = None):
         event_system.emit("shutting-down")
 
         size = self.get_size()
@@ -133,6 +198,3 @@ class Window(Gtk.ApplicationWindow):
 
         settings_manager.clear_pid()
         Gtk.main_quit()
-
-    def main(self):
-        Gtk.main()

src/libs/dto/__init__.py

@@ -1,5 +1,5 @@
 """
-    Dasta Class Package
+    DTO Class Package
 """
 
 from .event import Event

src/libs/dto/code/__init__.py

@@ -0,0 +1,27 @@
+"""
+    Code DTO Class Package
+"""
+
+
+from .code_event import CodeEvent
+from .get_command_system_event import GetCommandSystemEvent
+from .request_completion_event import RequestCompletionEvent
+from .cursor_moved_event import CursorMovedEvent
+from .modified_changed_event import ModifiedChangedEvent
+from .text_changed_event import TextChangedEvent
+from .text_inserted_event import TextInsertedEvent
+from .focused_view_event import FocusedViewEvent
+from .set_active_file_event import SetActiveFileEvent
+
+from .file_path_set_event import FilePathSetEvent
+from .added_new_file_event import AddedNewFileEvent
+from .swapped_file_event import SwappedFileEvent
+from .popped_file_event import PoppedFileEvent
+from .removed_file_event import RemovedFileEvent
+
+from .get_file_event import GetFileEvent
+from .get_swap_file_event import GetSwapFileEvent
+from .add_new_file_event import AddNewFileEvent
+from .swap_file_event import SwapFileEvent
+from .pop_file_event import PopFileEvent
+from .remove_file_event import RemoveFileEvent

src/libs/dto/code/add_new_file_event.py

@@ -0,0 +1,13 @@
+# Python imports
+from dataclasses import dataclass, field
+
+# Lib imports
+
+# Application imports
+from .code_event import CodeEvent
+
+
+
+@dataclass
+class AddNewFileEvent(CodeEvent):
+    ...

src/libs/dto/code/added_new_file_event.py

@@ -0,0 +1,13 @@
+# Python imports
+from dataclasses import dataclass, field
+
+# Lib imports
+
+# Application imports
+from .code_event import CodeEvent
+
+
+
+@dataclass
+class AddedNewFileEvent(CodeEvent):
+    ...

src/libs/dto/code/code_event.py

@@ -0,0 +1,17 @@
+# Python imports
+from dataclasses import dataclass, field
+
+# Lib imports
+
+# Application imports
+
+
+
+@dataclass
+class CodeEvent:
+    ignore_focus: bool = False
+    view: any          = None
+    file: any          = None
+    next_file: any     = None
+    buffer: any        = None
+    response: any      = None

src/libs/dto/code/cursor_moved_event.py

@@ -0,0 +1,14 @@
+# Python imports
+from dataclasses import dataclass, field
+
+# Lib imports
+
+# Application imports
+from .code_event import CodeEvent
+
+
+
+@dataclass
+class CursorMovedEvent(CodeEvent):
+    line: int  = 0
+    char: int  = 0

src/libs/dto/code/file_path_set_event.py

@@ -0,0 +1,15 @@
+# Python imports
+from dataclasses import dataclass, field
+
+# Lib imports
+
+# Application imports
+from .code_event import CodeEvent
+
+
+
+@dataclass
+class FilePathSetEvent(CodeEvent):
+    fname: str = ""
+    fpath: str = ""
+    ftype: str = ""