Coherence/src/core/controller.py

# Python imports
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 GLib

# Application imports
from utils.launcher import Launcher

from .mixins.signals_mixins import SignalsMixins
from .controller_data import ControllerData
from .query_controller import QueryController
from .widgets.create_notebook_widget import CreateNotebookWidget
from .widgets.dialogs.message_widget import MessageWidget
from .widgets.dialogs.section_header_updater_widget import SectionHeaderUpdater
from .widgets.sections.sections_widget import Sections



class Controller(Launcher, SignalsMixins, ControllerData):
    def __init__(self, args, unknownargs):
        self.setup_controller_data()

        self._setup_styling()
        self._setup_signals()
        self._subscribe_to_events()
        self._load_widgets()

        if args.no_plugins == "false":
            self.plugins.launch_plugins()

        for arg in unknownargs + [args.new_tab,]:
            if os.path.isfile(arg):
                message = f"FILE|{arg}"
                event_system.emit("post_file_to_ipc", message)

            if os.path.isdir(arg):
                message = f"DIR|{arg}"
                event_system.emit("post_file_to_ipc", message)

        event_system.emit_and_await("load_notebook")
        if settings.get_active_notebook():
            self._load_notebook_data()


    def _setup_styling(self):
        ...

    def _setup_signals(self):
        self.window.connect("focus-out-event", self.unset_keys_and_data)
        self.window.connect("key-press-event", self.on_global_key_press_controller)
        self.window.connect("key-release-event", self.on_global_key_release_controller)
        event_system.subscribe("open_files", self.open_files)
        event_system.subscribe("open_with_files", self.open_with_files)

    def _subscribe_to_events(self):
        event_system.subscribe("handle_file_from_ipc", self.handle_file_from_ipc)
        event_system.subscribe("load_notebook_data", self._load_notebook_data)

    def _load_widgets(self):
        QueryController()
        CreateNotebookWidget()
        MessageWidget()
        SectionHeaderUpdater()

    def load_glade_file(self):
        self.builder     = Gtk.Builder()
        self.builder.add_from_file(settings.get_glade_file())
        self.builder.expose_object("main_window", self.window)

        settings.set_builder(self.builder)
        self.core_widget = Sections()

        settings.register_signals_to_builder([self, self.core_widget])

    def get_core_widget(self):
        return self.core_widget

    def _load_notebook_data(self):
        path     = settings.get_active_notebook()
        sections = os.listdir(path)

        logger.info(f"Loading Notebook sections from: {path}")
        if len(sections) == 0:
            settings.generate_section_manifest()

        sections = os.listdir(path)
        for section in sections:
            _section = os.path.join(path, section)
            manifest = os.path.join(_section, "MANIFEST")
            event_system.emit("create_section_view", (None, None, manifest))

    def open_files(self, uris):
        for file in uris:
            self.open_file_locally(file)

    def open_with_files(self, app_info):
        # state = event_system.emit_and_await("get_current_state")
        # uris  = state.uris_raw

        # if not state.uris_raw:
        #     uris = [f"file://{state.tab.get_current_directory()}"]
        #
        # state.tab.app_chooser_exec(app_info, uris)
        ...