Import refactor, deb build update, docstring additions

src/debs/solarfm-0-0-1-x64/opt/SolarFM/context/__init__.py

@@ -0,0 +1,3 @@
+"""
+    Gtk Bound Signal Module
+"""

src/debs/solarfm-0-0-1-x64/opt/SolarFM/context/controller.py

@@ -0,0 +1,172 @@
+# Python imports
+import os, gc, threading, time
+
+# Lib imports
+import gi
+gi.require_version('Gtk', '3.0')
+from gi.repository import Gtk, GLib
+
+# Application imports
+from .mixins.exception_hook_mixin import ExceptionHookMixin
+from .mixins.ui_mixin import UIMixin
+from .signals.ipc_signals_mixin import IPCSignalsMixin
+from .signals.keyboard_signals_mixin import KeyboardSignalsMixin
+from .controller_data import Controller_Data
+
+
+def threaded(fn):
+    def wrapper(*args, **kwargs):
+        threading.Thread(target=fn, args=args, kwargs=kwargs, daemon=True).start()
+    return wrapper
+
+
+
+
+class Controller(UIMixin, KeyboardSignalsMixin, IPCSignalsMixin, ExceptionHookMixin, Controller_Data):
+    """ Controller coordinates the mixins and is somewhat the root hub of it all. """
+    def __init__(self, args, unknownargs, _settings):
+        self.setup_controller_data(_settings)
+        self.window.show()
+
+        self.generate_windows(self.state)
+        self.plugins.launch_plugins()
+
+        if debug:
+            self.window.set_interactive_debugging(True)
+
+        if not trace_debug:
+            self.gui_event_observer()
+
+            if unknownargs:
+                for arg in unknownargs:
+                    if os.path.isdir(arg):
+                        message = f"FILE|{arg}"
+                        event_system.send_ipc_message(message)
+
+            if args.new_tab and os.path.isdir(args.new_tab):
+                message = f"FILE|{args.new_tab}"
+                event_system.send_ipc_message(message)
+
+
+    def tear_down(self, widget=None, eve=None):
+        event_system.send_ipc_message("close server")
+        self.window_controller.save_state()
+        time.sleep(event_sleep_time)
+        Gtk.main_quit()
+
+
+    @threaded
+    def gui_event_observer(self):
+        while True:
+            time.sleep(event_sleep_time)
+            event = event_system.consume_gui_event()
+            if event:
+                try:
+                    type, target, data = event
+                    if type:
+                        method = getattr(self.__class__, "handle_gui_event_and_set_message")
+                        GLib.idle_add(method, *(self, type, target, data))
+                    else:
+                        method = getattr(self.__class__, target)
+                        GLib.idle_add(method, *(self, *data,))
+                except Exception as e:
+                    print(repr(e))
+
+    def handle_gui_event_and_set_message(self, type, target, parameters):
+        method = getattr(self.__class__, f"{target}")
+        data   = method(*(self, *parameters))
+        self.plugins.set_message_on_plugin(type, data)
+
+    def open_terminal(self, widget=None, eve=None):
+        wid, tid = self.window_controller.get_active_wid_and_tid()
+        view     = self.get_fm_window(wid).get_view_by_id(tid)
+        dir      = view.get_current_directory()
+        view.execute(f"{view.terminal_app}", dir)
+
+    def save_load_session(self, action="save_session"):
+        wid, tid          = self.window_controller.get_active_wid_and_tid()
+        view              = self.get_fm_window(wid).get_view_by_id(tid)
+        save_load_dialog  = self.builder.get_object("save_load_dialog")
+
+        if action == "save_session":
+            self.window_controller.save_state()
+            return
+        elif action == "save_session_as":
+            save_load_dialog.set_action(Gtk.FileChooserAction.SAVE)
+        elif action == "load_session":
+            save_load_dialog.set_action(Gtk.FileChooserAction.OPEN)
+        else:
+            raise Exception(f"Unknown action given:  {action}")
+
+        save_load_dialog.set_current_folder(view.get_current_directory())
+        save_load_dialog.set_current_name("session.json")
+        response = save_load_dialog.run()
+        if response == Gtk.ResponseType.OK:
+            if action == "save_session":
+                path = f"{save_load_dialog.get_current_folder()}/{save_load_dialog.get_current_name()}"
+                self.window_controller.save_state(path)
+            elif action == "load_session":
+                path         = f"{save_load_dialog.get_file().get_path()}"
+                session_json = self.window_controller.load_state(path)
+                self.load_session(session_json)
+        if (response == Gtk.ResponseType.CANCEL) or (response == Gtk.ResponseType.DELETE_EVENT):
+            pass
+
+        save_load_dialog.hide()
+
+    def load_session(self, session_json):
+        if debug:
+            print(f"Session Data: {session_json}")
+
+        self.ctrlDown          = False
+        self.shiftDown         = False
+        self.altDown           = False
+        for notebook in self.notebooks:
+            self.clear_children(notebook)
+
+        self.window_controller.unload_views_and_windows()
+        self.generate_windows(session_json)
+        gc.collect()
+
+
+    def do_action_from_menu_controls(self, widget, event_button):
+        action = widget.get_name()
+        self.hide_context_menu()
+        self.hide_new_file_menu()
+        self.hide_edit_file_menu()
+
+        if action == "open":
+            self.open_files()
+        if action == "open_with":
+            self.show_appchooser_menu()
+        if action == "execute":
+            self.execute_files()
+        if action == "execute_in_terminal":
+            self.execute_files(in_terminal=True)
+        if action == "rename":
+            self.rename_files()
+        if action == "cut":
+            self.to_copy_files.clear()
+            self.cut_files()
+        if action == "copy":
+            self.to_cut_files.clear()
+            self.copy_files()
+        if action == "paste":
+            self.paste_files()
+        if action == "archive":
+            self.show_archiver_dialogue()
+        if action == "delete":
+            self.delete_files()
+        if action == "trash":
+            self.trash_files()
+        if action == "go_to_trash":
+            self.path_entry.set_text(self.trash_files_path)
+        if action == "restore_from_trash":
+            self.restore_trash_files()
+        if action == "empty_trash":
+            self.empty_trash()
+
+        if action == "create":
+            self.show_new_file_menu()
+        if action in ["save_session", "save_session_as", "load_session"]:
+            self.save_load_session(action)

src/debs/solarfm-0-0-1-x64/opt/SolarFM/context/controller_data.py

@@ -0,0 +1,157 @@
+# Python imports
+import sys, os, signal
+
+# Lib imports
+from gi.repository import GLib
+
+# Application imports
+from trasher.xdgtrash import XDGTrash
+from shellfm.windows.controller import WindowController
+from plugins.plugins import Plugins
+
+
+
+
+class Controller_Data:
+    """ Controller_Data contains most of the state of the app at ay given time. It also has some support methods. """
+
+    def setup_controller_data(self, _settings):
+        self.trashman           = XDGTrash()
+        self.window_controller  = WindowController()
+        self.plugins            = Plugins(_settings)
+        self.state              = self.window_controller.load_state()
+        self.trashman.regenerate()
+
+        self.settings           = _settings
+        self.builder            = self.settings.get_builder()
+        self.logger             = self.settings.get_logger()
+
+        self.window             = self.settings.get_main_window()
+        self.window1            = self.builder.get_object("window_1")
+        self.window2            = self.builder.get_object("window_2")
+        self.window3            = self.builder.get_object("window_3")
+        self.window4            = self.builder.get_object("window_4")
+        self.message_widget     = self.builder.get_object("message_widget")
+        self.message_view       = self.builder.get_object("message_view")
+        self.message_buffer     = self.builder.get_object("message_buffer")
+        self.arc_command_buffer = self.builder.get_object("arc_command_buffer")
+
+        self.exists_file_rename_bttn = self.builder.get_object("exists_file_rename_bttn")
+        self.warning_alert      = self.builder.get_object("warning_alert")
+        self.edit_file_menu     = self.builder.get_object("edit_file_menu")
+        self.file_exists_dialog = self.builder.get_object("file_exists_dialog")
+        self.exists_file_label  = self.builder.get_object("exists_file_label")
+        self.exists_file_field  = self.builder.get_object("exists_file_field")
+        self.path_menu          = self.builder.get_object("path_menu")
+        self.path_entry         = self.builder.get_object("path_entry")
+
+        self.bottom_size_label       = self.builder.get_object("bottom_size_label")
+        self.bottom_file_count_label = self.builder.get_object("bottom_file_count_label")
+        self.bottom_path_label       = self.builder.get_object("bottom_path_label")
+
+        self.trash_files_path        = GLib.get_user_data_dir() + "/Trash/files"
+        self.trash_info_path         = GLib.get_user_data_dir() + "/Trash/info"
+
+        # In compress commands:
+        #    %n: First selected filename/dir to archive
+        #    %N: All selected filenames/dirs to archive, or (with %O) a single filename
+        #    %o: Resulting single archive file
+        #    %O: Resulting archive per source file/directory (use changes %N meaning)
+        #
+        #  In extract commands:
+        #    %x: Archive file to extract
+        #    %g: Unique extraction target filename with optional subfolder
+        #    %G: Unique extraction target filename, never with subfolder
+        #
+        #  In list commands:
+        #      %x: Archive to list
+        #
+        #  Plus standard bash variables are accepted.
+        self.arc_commands            = [ '$(which 7za || echo 7zr) a %o %N',
+                                                                'zip -r %o %N',
+                                                                'rar a -r %o %N',
+                                                                'tar -cvf %o %N',
+                                                                'tar -cvjf %o %N',
+                                                                'tar -cvzf %o %N',
+                                                                'tar -cvJf %o %N',
+                                                                'gzip -c %N > %O',
+                                                                'xz -cz %N > %O'
+                                        ]
+
+        self.notebooks         = [self.window1, self.window2, self.window3, self.window4]
+        self.selected_files    = []
+        self.to_copy_files     = []
+        self.to_cut_files      = []
+        self.soft_update_lock  = {}
+
+        self.single_click_open = False
+        self.is_pane1_hidden   = False
+        self.is_pane2_hidden   = False
+        self.is_pane3_hidden   = False
+        self.is_pane4_hidden   = False
+
+        self.override_drop_dest = None
+        self.is_searching       = False
+        self.search_iconview    = None
+        self.search_view        = None
+
+        self.skip_edit         = False
+        self.cancel_edit       = False
+        self.ctrlDown          = False
+        self.shiftDown         = False
+        self.altDown           = False
+
+        self.success           = "#88cc27"
+        self.warning           = "#ffa800"
+        self.error             = "#ff0000"
+
+        sys.excepthook = self.custom_except_hook
+        self.window.connect("delete-event", self.tear_down)
+        GLib.unix_signal_add(GLib.PRIORITY_DEFAULT, signal.SIGINT, self.tear_down)
+
+    def get_current_state(self):
+        '''
+        Returns the state info most useful for any given context and action intent.
+
+                Parameters:
+                        a (obj): self
+
+                Returns:
+                        wid, tid, view, iconview, store
+        '''
+        wid, tid     = self.window_controller.get_active_wid_and_tid()
+        view         = self.get_fm_window(wid).get_view_by_id(tid)
+        iconview     = self.builder.get_object(f"{wid}|{tid}|iconview")
+        store        = iconview.get_model()
+        return wid, tid, view, iconview, store
+
+
+    def clear_console(self):
+        ''' Clears the terminal screen. '''
+        os.system('cls' if os.name == 'nt' else 'clear')
+
+    def call_method(self, _method_name, data = None):
+        '''
+        Calls a method from scope of class.
+
+                Parameters:
+                        a (obj): self
+                        b (str): method name to be called
+                        c (*): Data (if any) to be passed to the method.
+                                Note: It must be structured according to the given methods requirements.
+
+                Returns:
+                        Return data is that which the calling method gives.
+        '''
+        method_name = str(_method_name)
+        method      = getattr(self, method_name, lambda data: f"No valid key passed...\nkey={method_name}\nargs={data}")
+        return method(data) if data else method()
+
+    def has_method(self, obj, name):
+        ''' Checks if a given method exists. '''
+        return callable(getattr(obj, name, None))
+
+    def clear_children(self, widget):
+        ''' Clear children of a gtk widget. '''
+        for child in widget.get_children():
+            widget.remove(child)

src/debs/solarfm-0-0-1-x64/opt/SolarFM/context/ipc_server_mixin.py

@@ -0,0 +1,65 @@
+# Python imports
+import threading, time
+from multiprocessing.connection import Listener, Client
+
+# Lib imports
+
+# Application imports
+
+
+def threaded(fn):
+    def wrapper(*args, **kwargs):
+        threading.Thread(target=fn, args=args, kwargs=kwargs, daemon=True).start()
+    return wrapper
+
+
+
+
+class IPCServerMixin:
+    """ Create a listener so that other SolarFM instances send requests back to existing instance. """
+
+    @threaded
+    def create_ipc_server(self):
+        listener          = Listener((self.ipc_address, self.ipc_port), authkey=self.ipc_authkey)
+        self.is_ipc_alive = True
+        while True:
+            conn       = listener.accept()
+            start_time = time.time()
+
+            print(f"New Connection: {listener.last_accepted}")
+            while True:
+                msg = conn.recv()
+                if debug:
+                    print(msg)
+
+                if "FILE|" in msg:
+                    file = msg.split("FILE|")[1].strip()
+                    if file:
+                        event_system.push_gui_event([None, "handle_file_from_ipc", (file,)])
+
+                    conn.close()
+                    break
+
+
+                if msg == 'close connection':
+                    conn.close()
+                    break
+                if msg == 'close server':
+                    conn.close()
+                    break
+
+                # NOTE: Not perfect but insures we don't lock up the connection for too long.
+                end_time = time.time()
+                if (end - start) > self.ipc_timeout:
+                    conn.close()
+
+        listener.close()
+
+
+    def send_ipc_message(self, message="Empty Data..."):
+        try:
+            conn = Client((self.ipc_address, self.ipc_port), authkey=self.ipc_authkey)
+            conn.send(message)
+            conn.send('close connection')
+        except Exception as e:
+            print(repr(e))

src/debs/solarfm-0-0-1-x64/opt/SolarFM/context/mixins/exception_hook_mixin.py

@@ -0,0 +1,62 @@
+# Python imports
+import traceback, threading, time
+
+# Lib imports
+import gi
+gi.require_version('Gtk', '3.0')
+from gi.repository import Gtk, GLib
+
+# Application imports
+
+
+def threaded(fn):
+    def wrapper(*args, **kwargs):
+        threading.Thread(target=fn, args=args, kwargs=kwargs, daemon=True).start()
+    return wrapper
+
+
+class ExceptionHookMixin:
+    """ ExceptionHookMixin custom exception hook to reroute to a Gtk text area. """
+
+    def custom_except_hook(self, exec_type, value, _traceback):
+        trace     = ''.join(traceback.format_tb(_traceback))
+        data      = f"Exec Type:  {exec_type}  <-->  Value:  {value}\n\n{trace}\n\n\n\n"
+        start_itr = self.message_buffer.get_start_iter()
+        self.message_buffer.place_cursor(start_itr)
+        self.display_message(self.error, data)
+
+    def display_message(self, type, text, seconds=None):
+        self.message_buffer.insert_at_cursor(text)
+        self.message_widget.popup()
+        if seconds:
+            self.hide_message_timeout(seconds)
+
+    @threaded
+    def hide_message_timeout(self, seconds=3):
+        time.sleep(seconds)
+        GLib.idle_add(self.message_widget.popdown)
+
+    def save_debug_alerts(self, widget=None, eve=None):
+        start_itr, end_itr   = self.message_buffer.get_bounds()
+        save_location_prompt = Gtk.FileChooserDialog("Choose Save Folder", self.window, \
+                                                        action  = Gtk.FileChooserAction.SAVE, \
+                                                        buttons = (Gtk.STOCK_CANCEL, \
+                                                                    Gtk.ResponseType.CANCEL, \
+                                                                    Gtk.STOCK_SAVE, \
+                                                                    Gtk.ResponseType.OK))
+
+        text = self.message_buffer.get_text(start_itr, end_itr, False)
+        resp = save_location_prompt.run()
+        if (resp == Gtk.ResponseType.CANCEL) or (resp == Gtk.ResponseType.DELETE_EVENT):
+            pass
+        elif resp == Gtk.ResponseType.OK:
+            target = save_location_prompt.get_filename();
+            with open(target, "w") as f:
+                f.write(text)
+
+        save_location_prompt.destroy()
+
+
+    def set_arc_buffer_text(self, widget=None, eve=None):
+        sid = widget.get_active_id()
+        self.arc_command_buffer.set_text(self.arc_commands[int(sid)])

src/debs/solarfm-0-0-1-x64/opt/SolarFM/context/mixins/show_hide_mixin.py

@@ -0,0 +1,147 @@
+# Python imports
+
+# Gtk imports
+import gi
+gi.require_version('Gtk', '3.0')
+gi.require_version('Gdk', '3.0')
+from gi.repository import Gtk, Gdk
+
+# Application imports
+
+
+class ShowHideMixin:
+    def show_messages_popup(self, type, text, seconds=None):
+        self.message_widget.popup()
+
+    def stop_file_searching(self, widget=None, eve=None):
+        self.is_searching = False
+
+    def show_exists_page(self, widget=None, eve=None):
+        response = self.file_exists_dialog.run()
+        self.file_exists_dialog.hide()
+
+        if response == Gtk.ResponseType.OK:
+            return "rename"
+        if response == Gtk.ResponseType.ACCEPT:
+            return "rename_auto"
+        if response == Gtk.ResponseType.CLOSE:
+            return "rename_auto_all"
+        if response == Gtk.ResponseType.YES:
+            return "overwrite"
+        if response == Gtk.ResponseType.APPLY:
+            return "overwrite_all"
+        if response == Gtk.ResponseType.NO:
+            return "skip"
+        if response == Gtk.ResponseType.REJECT:
+            return "skip_all"
+
+    def hide_exists_page_rename(self, widget=None, eve=None):
+        self.file_exists_dialog.response(Gtk.ResponseType.OK)
+
+    def hide_exists_page_auto_rename(self, widget=None, eve=None):
+        self.file_exists_dialog.response(Gtk.ResponseType.ACCEPT)
+
+    def hide_exists_page_auto_rename_all(self, widget=None, eve=None):
+        self.file_exists_dialog.response(Gtk.ResponseType.CLOSE)
+
+
+    def show_about_page(self, widget=None, eve=None):
+        about_page = self.builder.get_object("about_page")
+        response   = about_page.run()
+        if (response == Gtk.ResponseType.CANCEL) or (response == Gtk.ResponseType.DELETE_EVENT):
+            self.hide_about_page()
+
+    def hide_about_page(self, widget=None, eve=None):
+        self.builder.get_object("about_page").hide()
+
+
+    def show_archiver_dialogue(self, widget=None, eve=None):
+        wid, tid          = self.window_controller.get_active_wid_and_tid()
+        view              = self.get_fm_window(wid).get_view_by_id(tid)
+        archiver_dialogue = self.builder.get_object("archiver_dialogue")
+        archiver_dialogue.set_action(Gtk.FileChooserAction.SAVE)
+        archiver_dialogue.set_current_folder(view.get_current_directory())
+        archiver_dialogue.set_current_name("arc.7z")
+
+        response = archiver_dialogue.run()
+        if response == Gtk.ResponseType.OK:
+            self.archive_files(archiver_dialogue)
+        if (response == Gtk.ResponseType.CANCEL) or (response == Gtk.ResponseType.DELETE_EVENT):
+            pass
+
+        archiver_dialogue.hide()
+
+    def hide_archiver_dialogue(self, widget=None, eve=None):
+        self.builder.get_object("archiver_dialogue").hide()
+
+
+    def show_appchooser_menu(self, widget=None, eve=None):
+        appchooser_menu   = self.builder.get_object("appchooser_menu")
+        appchooser_widget = self.builder.get_object("appchooser_widget")
+        response          = appchooser_menu.run()
+
+        if response == Gtk.ResponseType.OK:
+            self.open_with_files(appchooser_widget)
+            self.hide_appchooser_menu()
+
+        if response == Gtk.ResponseType.CANCEL:
+            self.hide_appchooser_menu()
+
+
+    def hide_appchooser_menu(self, widget=None, eve=None):
+        self.builder.get_object("appchooser_menu").hide()
+
+    def run_appchooser_launch(self, widget=None, eve=None):
+        dialog = widget.get_parent().get_parent()
+        dialog.response(Gtk.ResponseType.OK)
+
+
+    def show_plugins_popup(self, widget=None, eve=None):
+        self.builder.get_object("plugin_list").popup()
+
+    def hide_plugins_popup(self, widget=None, eve=None):
+        self.builder.get_object("plugin_list").hide()
+
+    def show_context_menu(self, widget=None, eve=None):
+        self.builder.get_object("context_menu").run()
+
+    def hide_context_menu(self, widget=None, eve=None):
+        self.builder.get_object("context_menu").hide()
+
+
+    def show_new_file_menu(self, widget=None, eve=None):
+        self.builder.get_object("context_menu_fname").set_text("")
+
+        new_file_menu = self.builder.get_object("new_file_menu")
+        response      = new_file_menu.run()
+        if response == Gtk.ResponseType.APPLY:
+            self.create_files()
+        if response == Gtk.ResponseType.CANCEL:
+            self.hide_new_file_menu()
+
+    def hide_new_file_menu(self, widget=None, eve=None):
+        self.builder.get_object("new_file_menu").hide()
+
+    def show_edit_file_menu(self, widget=None, eve=None):
+        if widget:
+            widget.grab_focus()
+
+        response = self.edit_file_menu.run()
+        if response == Gtk.ResponseType.CLOSE:
+            self.skip_edit   = True
+        if response == Gtk.ResponseType.CANCEL:
+            self.cancel_edit = True
+
+    def hide_edit_file_menu(self, widget=None, eve=None):
+        self.builder.get_object("edit_file_menu").hide()
+
+    def hide_edit_file_menu_enter_key(self, widget=None, eve=None):
+        keyname = Gdk.keyval_name(eve.keyval).lower()
+        if "return" in keyname or "enter" in keyname:
+            self.builder.get_object("edit_file_menu").hide()
+
+    def hide_edit_file_menu_skip(self, widget=None, eve=None):
+        self.edit_file_menu.response(Gtk.ResponseType.CLOSE)
+
+    def hide_edit_file_menu_cancel(self, widget=None, eve=None):
+        self.edit_file_menu.response(Gtk.ResponseType.CANCEL)

src/debs/solarfm-0-0-1-x64/opt/SolarFM/context/mixins/ui/pane_mixin.py

@@ -0,0 +1,65 @@
+# Python imports
+
+# Lib imports
+
+# Application imports
+
+
+
+
+# TODO: Should rewrite to try and support more windows more naturally
+class PaneMixin:
+    """docstring for PaneMixin"""
+
+    def toggle_pane(self, child):
+        if child.is_visible():
+            child.hide()
+        else:
+            child.show()
+
+    def run_flag_toggle(self, pane_index):
+        tggl_button = self.builder.get_object(f"tggl_notebook_{pane_index}")
+        if pane_index == 1:
+            self.is_pane1_hidden = not self.is_pane1_hidden
+            tggl_button.set_active(not self.is_pane1_hidden)
+            return self.is_pane1_hidden
+        elif pane_index == 2:
+            self.is_pane2_hidden = not self.is_pane2_hidden
+            tggl_button.set_active(not self.is_pane2_hidden)
+            return self.is_pane2_hidden
+        elif pane_index == 3:
+            self.is_pane3_hidden = not self.is_pane3_hidden
+            tggl_button.set_active(not self.is_pane3_hidden)
+            return self.is_pane3_hidden
+        elif pane_index == 4:
+            self.is_pane4_hidden = not self.is_pane4_hidden
+            tggl_button.set_active(not self.is_pane4_hidden)
+            return self.is_pane4_hidden
+
+    def toggle_notebook_pane(self, widget, eve=None):
+        name        = widget.get_name()
+        pane_index  = int(name[-1])
+        pane        = None
+
+        master_pane = self.builder.get_object("pane_master")
+        pane        = self.builder.get_object("pane_top") if pane_index in [1, 2] else self.builder.get_object("pane_bottom")
+
+        state = self.run_flag_toggle(pane_index)
+        if self.is_pane1_hidden and self.is_pane2_hidden and self.is_pane3_hidden and self.is_pane4_hidden:
+            state = self.run_flag_toggle(pane_index)
+            self._save_state(state, pane_index)
+            return
+
+        child = None
+        if pane_index in [1, 3]:
+            child = pane.get_child1()
+        elif pane_index in [2, 4]:
+            child = pane.get_child2()
+
+        self.toggle_pane(child)
+        self._save_state(state, pane_index)
+
+    def _save_state(self, state, pane_index):
+        window = self.window_controller.get_window_by_index(pane_index - 1)
+        window.set_is_hidden(state)
+        self.window_controller.save_state()

src/debs/solarfm-0-0-1-x64/opt/SolarFM/context/mixins/ui/tab_mixin.py

@@ -0,0 +1,204 @@
+# Python imports
+import os
+
+# Lib imports
+import gi
+gi.require_version('Gtk', '3.0')
+from gi.repository import Gtk
+
+# Application imports
+from .widget_mixin import WidgetMixin
+
+
+
+
+class TabMixin(WidgetMixin):
+    """docstring for TabMixin"""
+
+    def create_tab(self, wid, path=None):
+        notebook    = self.builder.get_object(f"window_{wid}")
+        path_entry  = self.builder.get_object(f"path_entry")
+        view        = self.window_controller.add_view_for_window_by_nickname(f"window_{wid}")
+        view.logger = self.logger
+
+        view.set_wid(wid)
+        if path: view.set_path(path)
+
+        tab           = self.create_tab_widget(view)
+        scroll, store = self.create_grid_iconview_widget(view, wid)
+        # scroll, store = self.create_grid_treeview_widget(view, wid)
+        index         = notebook.append_page(scroll, tab)
+
+        self.window_controller.set__wid_and_tid(wid, view.get_id())
+        path_entry.set_text(view.get_current_directory())
+        notebook.show_all()
+        notebook.set_current_page(index)
+
+        ctx = notebook.get_style_context()
+        ctx.add_class("notebook-unselected-focus")
+        notebook.set_tab_reorderable(scroll, True)
+        self.load_store(view, store)
+        self.set_window_title()
+        self.set_file_watcher(view)
+
+
+
+
+    def close_tab(self, button, eve=None):
+        notebook = button.get_parent().get_parent()
+        tid      = self.get_id_from_tab_box(button.get_parent())
+        wid      = int(notebook.get_name()[-1])
+        scroll   = self.builder.get_object(f"{wid}|{tid}")
+        page     = notebook.page_num(scroll)
+        view     = self.get_fm_window(wid).get_view_by_id(tid)
+        watcher  = view.get_dir_watcher()
+
+        watcher.cancel()
+        self.get_fm_window(wid).delete_view_by_id(tid)
+        notebook.remove_page(page)
+        self.window_controller.save_state()
+        self.set_window_title()
+
+    def on_tab_reorder(self, child, page_num, new_index):
+        wid, tid = page_num.get_name().split("|")
+        window   = self.get_fm_window(wid)
+        view     = None
+
+        for i, view in enumerate(window.get_all_views()):
+            if view.get_id() == tid:
+                _view   = window.get_view_by_id(tid)
+                watcher = _view.get_dir_watcher()
+                watcher.cancel()
+                window.get_all_views().insert(new_index, window.get_all_views().pop(i))
+
+        view = window.get_view_by_id(tid)
+        self.set_file_watcher(view)
+        self.window_controller.save_state()
+
+    def on_tab_switch_update(self, notebook, content=None, index=None):
+        self.selected_files.clear()
+        wid, tid = content.get_children()[0].get_name().split("|")
+        self.window_controller.set__wid_and_tid(wid, tid)
+        self.set_path_text(wid, tid)
+        self.set_window_title()
+
+    def get_id_from_tab_box(self, tab_box):
+        tid = tab_box.get_children()[2]
+        return tid.get_text()
+
+    def get_tab_label(self, notebook, iconview):
+        return notebook.get_tab_label(iconview.get_parent()).get_children()[0]
+
+    def get_tab_close(self, notebook, iconview):
+        return notebook.get_tab_label(iconview.get_parent()).get_children()[1]
+
+    def get_tab_iconview_from_notebook(self, notebook):
+        return notebook.get_children()[1].get_children()[0]
+
+    def refresh_tab(data=None):
+        wid, tid, view, iconview, store = self.get_current_state()
+        view.load_directory()
+        self.load_store(view, store)
+
+    def update_view(self, tab_label, view, store, wid, tid):
+        self.load_store(view, store)
+        self.set_path_text(wid, tid)
+
+        char_width = len(view.get_end_of_path())
+        tab_label.set_width_chars(char_width)
+        tab_label.set_label(view.get_end_of_path())
+        self.set_window_title()
+        self.set_file_watcher(view)
+        self.window_controller.save_state()
+
+    def do_action_from_bar_controls(self, widget, eve=None):
+        action    = widget.get_name()
+        wid, tid  = self.window_controller.get_active_wid_and_tid()
+        notebook  = self.builder.get_object(f"window_{wid}")
+        store, tab_label = self.get_store_and_label_from_notebook(notebook, f"{wid}|{tid}")
+        view      = self.get_fm_window(wid).get_view_by_id(tid)
+
+        if action == "go_up":
+            view.pop_from_path()
+        if action == "go_home":
+            view.set_to_home()
+        if action == "refresh_view":
+            view.load_directory()
+        if action == "create_tab":
+            dir = view.get_current_directory()
+            self.create_tab(wid, dir)
+            self.window_controller.save_state()
+            return
+        if action == "path_entry":
+            focused_obj = self.window.get_focus()
+            dir         = f"{view.get_current_directory()}/"
+            path        = widget.get_text()
+
+            if isinstance(focused_obj, Gtk.Entry):
+                button_box  = self.path_menu.get_children()[0].get_children()[0].get_children()[0]
+                query       = widget.get_text().replace(dir, "")
+                files       = view.get_files() + view.get_hidden()
+
+                self.clear_children(button_box)
+                show_path_menu = False
+                for file, hash in files:
+                    if os.path.isdir(f"{dir}{file}"):
+                        if query.lower() in file.lower():
+                            button = Gtk.Button(label=file)
+                            button.show()
+                            button.connect("clicked", self.set_path_entry)
+                            button_box.add(button)
+                            show_path_menu = True
+
+                if not show_path_menu:
+                    self.path_menu.popdown()
+                else:
+                    self.path_menu.popup()
+                    widget.grab_focus_without_selecting()
+                    widget.set_position(-1)
+
+            if path.endswith(".") or path == dir:
+                return
+
+            traversed = view.set_path(path)
+            if not traversed:
+                return
+
+        self.update_view(tab_label, view, store, wid, tid)
+
+        try:
+            widget.grab_focus_without_selecting()
+            widget.set_position(-1)
+        except Exception as e:
+            pass
+
+    def set_path_entry(self, button=None, eve=None):
+        wid, tid, view, iconview, store = self.get_current_state()
+        path       = f"{view.get_current_directory()}/{button.get_label()}"
+        path_entry = self.builder.get_object("path_entry")
+        path_entry.set_text(path)
+        path_entry.grab_focus_without_selecting()
+        path_entry.set_position(-1)
+        self.path_menu.popdown()
+
+    def keyboard_close_tab(self):
+        wid, tid  = self.window_controller.get_active_wid_and_tid()
+        notebook  = self.builder.get_object(f"window_{wid}")
+        scroll    = self.builder.get_object(f"{wid}|{tid}")
+        page      = notebook.page_num(scroll)
+        view      = self.get_fm_window(wid).get_view_by_id(tid)
+        watcher   = view.get_dir_watcher()
+        watcher.cancel()
+
+        self.get_fm_window(wid).delete_view_by_id(tid)
+        notebook.remove_page(page)
+        self.window_controller.save_state()
+        self.set_window_title()
+
+    # File control events
+    def show_hide_hidden_files(self):
+        wid, tid = self.window_controller.get_active_wid_and_tid()
+        view     = self.get_fm_window(wid).get_view_by_id(tid)
+        view.set_hiding_hidden(not view.is_hiding_hidden())
+        view.load_directory()
+        self.builder.get_object("refresh_view").released()

src/debs/solarfm-0-0-1-x64/opt/SolarFM/context/mixins/ui/widget_file_action_mixin.py

@@ -0,0 +1,462 @@
+# Python imports
+import os, time, threading
+
+# Lib imports
+import gi
+gi.require_version('Gtk', '3.0')
+from gi.repository import Gtk, GObject, GLib, Gio
+
+# Application imports
+
+
+def threaded(fn):
+    def wrapper(*args, **kwargs):
+        threading.Thread(target=fn, args=args, kwargs=kwargs, daemon=True).start()
+    return wrapper
+
+
+class WidgetFileActionMixin:
+    """docstring for WidgetFileActionMixin"""
+
+    def sizeof_fmt(self, num, suffix="B"):
+        for unit in ["", "K", "M", "G", "T", "Pi", "Ei", "Zi"]:
+            if abs(num) < 1024.0:
+                return f"{num:3.1f} {unit}{suffix}"
+            num /= 1024.0
+        return f"{num:.1f} Yi{suffix}"
+
+    def get_dir_size(self, sdir):
+        """Get the size of a directory.  Based on code found online."""
+        size = os.path.getsize(sdir)
+
+        for item in os.listdir(sdir):
+            item = os.path.join(sdir, item)
+
+            if os.path.isfile(item):
+                size = size + os.path.getsize(item)
+            elif os.path.isdir(item):
+                size = size + self.get_dir_size(item)
+
+        return size
+
+
+    def set_file_watcher(self, view):
+        if view.get_dir_watcher():
+            watcher = view.get_dir_watcher()
+            watcher.cancel()
+            if debug:
+                print(f"Watcher Is Cancelled:  {watcher.is_cancelled()}")
+
+        cur_dir = view.get_current_directory()
+        # Temp updating too much with current events we are checking for.
+        # Seems to cause invalid iter errors in WidbetMixin > update_store
+        if cur_dir == "/tmp":
+            watcher = None
+            return
+
+        dir_watcher  = Gio.File.new_for_path(cur_dir) \
+                                .monitor_directory(Gio.FileMonitorFlags.WATCH_MOVES, Gio.Cancellable())
+
+        wid = view.get_wid()
+        tid = view.get_id()
+        dir_watcher.connect("changed", self.dir_watch_updates, (f"{wid}|{tid}",))
+        view.set_dir_watcher(dir_watcher)
+
+    # NOTE: Too lazy to impliment a proper update handler and so just regen store and update view.
+    #       Use a lock system to prevent too many update calls for certain instances but user can manually refresh if they have urgency
+    def dir_watch_updates(self, file_monitor, file, other_file=None, eve_type=None, data=None):
+        if eve_type in  [Gio.FileMonitorEvent.CREATED, Gio.FileMonitorEvent.DELETED,
+                        Gio.FileMonitorEvent.RENAMED, Gio.FileMonitorEvent.MOVED_IN,
+                        Gio.FileMonitorEvent.MOVED_OUT]:
+                if debug:
+                    print(eve_type)
+
+                if eve_type in [Gio.FileMonitorEvent.MOVED_IN, Gio.FileMonitorEvent.MOVED_OUT]:
+                    self.update_on_end_soft_lock(data[0])
+                elif data[0] in self.soft_update_lock.keys():
+                    self.soft_update_lock[data[0]]["last_update_time"] = time.time()
+                else:
+                    self.soft_lock_countdown(data[0])
+
+    @threaded
+    def soft_lock_countdown(self, tab):
+        self.soft_update_lock[tab] = { "last_update_time": time.time()}
+
+        lock = True
+        while lock:
+            time.sleep(0.6)
+            last_update_time = self.soft_update_lock[tab]["last_update_time"]
+            current_time     = time.time()
+            if (current_time - last_update_time) > 0.6:
+                lock = False
+
+
+        self.soft_update_lock.pop(tab, None)
+        GLib.idle_add(self.update_on_end_soft_lock, *(tab,))
+
+
+    def update_on_end_soft_lock(self, tab):
+        wid, tid  = tab.split("|")
+        notebook  = self.builder.get_object(f"window_{wid}")
+        view      = self.get_fm_window(wid).get_view_by_id(tid)
+        iconview  = self.builder.get_object(f"{wid}|{tid}|iconview")
+        store     = iconview.get_model()
+        _store, tab_label = self.get_store_and_label_from_notebook(notebook, f"{wid}|{tid}")
+
+        view.load_directory()
+        self.load_store(view, store)
+
+        tab_label.set_label(view.get_end_of_path())
+
+        _wid, _tid, _view, _iconview, _store = self.get_current_state()
+
+        if [wid, tid] in [_wid, _tid]:
+            self.set_bottom_labels(view)
+
+
+    def popup_search_files(self, wid, keyname):
+        entry = self.builder.get_object(f"win{wid}_search_field")
+        self.builder.get_object(f"win{wid}_search").popup()
+        entry.set_text(keyname)
+        entry.grab_focus_without_selecting()
+        entry.set_position(-1)
+
+    def do_file_search(self, widget, eve=None):
+        query = widget.get_text()
+        self.search_iconview.unselect_all()
+        for i, file in enumerate(self.search_view.get_files()):
+            if query and query in file[0].lower():
+                path = Gtk.TreePath().new_from_indices([i])
+                self.search_iconview.select_path(path)
+
+        items = self.search_iconview.get_selected_items()
+        if len(items) == 1:
+            self.search_iconview.scroll_to_path(items[0], True, 0.5, 0.5)
+
+
+    def open_files(self):
+        wid, tid, view, iconview, store = self.get_current_state()
+        uris = self.format_to_uris(store, wid, tid, self.selected_files, True)
+
+        for file in uris:
+            view.open_file_locally(file)
+
+    def open_with_files(self, appchooser_widget):
+        wid, tid, view, iconview, store = self.get_current_state()
+        app_info  = appchooser_widget.get_app_info()
+        uris      = self.format_to_uris(store, wid, tid, self.selected_files)
+
+        view.app_chooser_exec(app_info, uris)
+
+    def execute_files(self, in_terminal=False):
+        wid, tid, view, iconview, store = self.get_current_state()
+        paths       = self.format_to_uris(store, wid, tid, self.selected_files, True)
+        current_dir = view.get_current_directory()
+        command     = None
+
+        for path in paths:
+            command = f"exec '{path}'" if not in_terminal else f"{view.terminal_app} -e '{path}'"
+            view.execute(command, start_dir=view.get_current_directory(), use_os_system=False)
+
+    def archive_files(self, archiver_dialogue):
+        wid, tid, view, iconview, store = self.get_current_state()
+        paths = self.format_to_uris(store, wid, tid, self.selected_files, True)
+
+        save_target = archiver_dialogue.get_filename();
+        sItr, eItr  = self.arc_command_buffer.get_bounds()
+        pre_command = self.arc_command_buffer.get_text(sItr, eItr, False)
+        pre_command = pre_command.replace("%o", save_target)
+        pre_command = pre_command.replace("%N", ' '.join(paths))
+        command     = f"{view.terminal_app} -e '{pre_command}'"
+
+        view.execute(command, start_dir=None, use_os_system=True)
+
+    def rename_files(self):
+        rename_label = self.builder.get_object("file_to_rename_label")
+        rename_input = self.builder.get_object("new_rename_fname")
+        wid, tid, view, iconview, store = self.get_current_state()
+        uris         = self.format_to_uris(store, wid, tid, self.selected_files, True)
+
+        for uri in uris:
+            entry = uri.split("/")[-1]
+            rename_label.set_label(entry)
+            rename_input.set_text(entry)
+
+            self.show_edit_file_menu(rename_input)
+            if self.skip_edit:
+                self.skip_edit   = False
+                continue
+            if self.cancel_edit:
+                self.cancel_edit = False
+                break
+
+            rname_to = rename_input.get_text().strip()
+            target   = f"{view.get_current_directory()}/{rname_to}"
+            self.handle_files([uri], "rename", target)
+
+
+        self.skip_edit   = False
+        self.cancel_edit = False
+        self.hide_edit_file_menu()
+        self.selected_files.clear()
+
+    def cut_files(self):
+        wid, tid, view, iconview, store = self.get_current_state()
+        uris = self.format_to_uris(store, wid, tid, self.selected_files, True)
+        self.to_cut_files = uris
+
+    def copy_files(self):
+        wid, tid, view, iconview, store = self.get_current_state()
+        uris = self.format_to_uris(store, wid, tid, self.selected_files, True)
+        self.to_copy_files = uris
+
+    def paste_files(self):
+        wid, tid  = self.window_controller.get_active_wid_and_tid()
+        view      = self.get_fm_window(wid).get_view_by_id(tid)
+        target    = f"{view.get_current_directory()}"
+
+        if len(self.to_copy_files) > 0:
+            self.handle_files(self.to_copy_files, "copy", target)
+        elif len(self.to_cut_files) > 0:
+            self.handle_files(self.to_cut_files, "move", target)
+
+    def delete_files(self):
+        wid, tid, view, iconview, store = self.get_current_state()
+        uris     = self.format_to_uris(store, wid, tid, self.selected_files, True)
+        response = None
+
+        self.warning_alert.format_secondary_text(f"Do you really want to delete the {len(uris)} file(s)?")
+        for uri in uris:
+            file = Gio.File.new_for_path(uri)
+
+            if not response:
+                response = self.warning_alert.run()
+                self.warning_alert.hide()
+            if response == Gtk.ResponseType.YES:
+                type = file.query_file_type(flags=Gio.FileQueryInfoFlags.NONE)
+
+                if type == Gio.FileType.DIRECTORY:
+                    view.delete_file( file.get_path() )
+                else:
+                    file.delete(cancellable=None)
+            else:
+                break
+
+
+    def trash_files(self):
+        wid, tid, view, iconview, store = self.get_current_state()
+        uris      = self.format_to_uris(store, wid, tid, self.selected_files, True)
+        for uri in uris:
+            self.trashman.trash(uri, False)
+
+    def restore_trash_files(self):
+        wid, tid, view, iconview, store = self.get_current_state()
+        uris      = self.format_to_uris(store, wid, tid, self.selected_files, True)
+        for uri in uris:
+            self.trashman.restore(filename=uri.split("/")[-1], verbose=False)
+
+    def empty_trash(self):
+        self.trashman.empty(verbose=False)
+
+
+    def create_files(self):
+        fname_field = self.builder.get_object("context_menu_fname")
+        file_name   = fname_field.get_text().strip()
+        type        = self.builder.get_object("context_menu_type_toggle").get_state()
+
+        wid, tid    = self.window_controller.get_active_wid_and_tid()
+        view        = self.get_fm_window(wid).get_view_by_id(tid)
+        target      = f"{view.get_current_directory()}"
+
+        if file_name:
+            path = f"{target}/{file_name}"
+
+            if type == True:     # Create File
+                self.handle_files([path], "create_file")
+            else:                # Create Folder
+                self.handle_files([path], "create_dir")
+
+        self.hide_new_file_menu()
+
+    def move_files(self, files, target):
+        self.handle_files(files, "move", target)
+
+    # NOTE: Gtk recommends using fail flow than pre check which is more
+    #       race condition proof. They're right; but, they can't even delete
+    #       directories properly. So... f**k them. I'll do it my way.
+    def handle_files(self, paths, action, _target_path=None):
+        target          = None
+        _file           = None
+        response        = None
+        overwrite_all   = False
+        rename_auto_all = False
+
+        for path in paths:
+            try:
+                if "file://" in path:
+                    path = path.split("file://")[1]
+
+                file = Gio.File.new_for_path(path)
+                if _target_path:
+                    if os.path.isdir(_target_path):
+                        info    = file.query_info("standard::display-name", 0, cancellable=None)
+                        _target = f"{_target_path}/{info.get_display_name()}"
+                        _file   = Gio.File.new_for_path(_target)
+                    else:
+                        _file   = Gio.File.new_for_path(_target_path)
+                else:
+                    _file = Gio.File.new_for_path(path)
+
+
+                if _file.query_exists():
+                    if not overwrite_all and not rename_auto_all:
+                        self.setup_exists_data(file, _file)
+                        response = self.show_exists_page()
+
+                    if response == "overwrite_all":
+                        overwrite_all   = True
+                    if response == "rename_auto_all":
+                        rename_auto_all = True
+
+                    if response == "rename":
+                        base_path = _file.get_parent().get_path()
+                        new_name  = self.exists_file_field.get_text().strip()
+                        rfPath    = f"{base_path}/{new_name}"
+                        _file     = Gio.File.new_for_path(rfPath)
+
+                    if response == "rename_auto" or rename_auto_all:
+                        _file = self.rename_proc(_file)
+
+                    if response == "overwrite" or overwrite_all:
+                        type      = _file.query_file_type(flags=Gio.FileQueryInfoFlags.NONE)
+
+                        if type == Gio.FileType.DIRECTORY:
+                            wid, tid  = self.window_controller.get_active_wid_and_tid()
+                            view      = self.get_fm_window(wid).get_view_by_id(tid)
+                            view.delete_file( _file.get_path() )
+                        else:
+                            _file.delete(cancellable=None)
+
+                    if response == "skip":
+                        continue
+                    if response == "skip_all":
+                        break
+
+                if _target_path:
+                    target = _file
+                else:
+                    file   = _file
+
+
+                if action == "create_file":
+                    file.create(flags=Gio.FileCreateFlags.NONE, cancellable=None)
+                    continue
+                if action == "create_dir":
+                    file.make_directory(cancellable=None)
+                    continue
+
+
+                type = file.query_file_type(flags=Gio.FileQueryInfoFlags.NONE)
+                if type == Gio.FileType.DIRECTORY:
+                    wid, tid  = self.window_controller.get_active_wid_and_tid()
+                    view      = self.get_fm_window(wid).get_view_by_id(tid)
+                    fPath     = file.get_path()
+                    tPath     = target.get_path()
+                    state     = True
+
+                    if action == "copy":
+                        view.copy_file(fPath, tPath)
+                    if action == "move" or action == "rename":
+                        view.move_file(fPath, tPath)
+                else:
+                    if action == "copy":
+                        file.copy(target, flags=Gio.FileCopyFlags.BACKUP, cancellable=None)
+                    if action == "move" or action == "rename":
+                        file.move(target, flags=Gio.FileCopyFlags.BACKUP, cancellable=None)
+
+            except GObject.GError as e:
+                raise OSError(e)
+
+        self.exists_file_rename_bttn.set_sensitive(False)
+
+
+    def setup_exists_data(self, from_file, to_file):
+        from_info             = from_file.query_info("standard::*,time::modified", 0, cancellable=None)
+        to_info               = to_file.query_info("standard::*,time::modified", 0, cancellable=None)
+        exists_file_diff_from = self.builder.get_object("exists_file_diff_from")
+        exists_file_diff_to   = self.builder.get_object("exists_file_diff_to")
+        exists_file_from      = self.builder.get_object("exists_file_from")
+        exists_file_to        = self.builder.get_object("exists_file_to")
+        from_date             = from_info.get_modification_date_time()
+        to_date               = to_info.get_modification_date_time()
+        from_size             = from_info.get_size()
+        to_size               = to_info.get_size()
+
+        exists_file_from.set_label(from_file.get_parent().get_path())
+        exists_file_to.set_label(to_file.get_parent().get_path())
+        self.exists_file_label.set_label(to_file.get_basename())
+        self.exists_file_field.set_text(to_file.get_basename())
+
+        # Returns: -1, 0 or 1 if dt1 is less than, equal to or greater than dt2.
+        age       = GLib.DateTime.compare(from_date, to_date)
+        age_text  = "( same time )"
+        if age == -1:
+            age_text = "older"
+        if age == 1:
+            age_text = "newer"
+
+        size_text = "( same size )"
+        if from_size < to_size:
+            size_text = "smaller"
+        if from_size > to_size:
+            size_text = "larger"
+
+        from_label_text = f"{age_text} & {size_text}"
+        if age_text != "( same time )" or size_text != "( same size )":
+            from_label_text = f"{from_date.format('%F %R')}     {self.sizeof_fmt(from_size)}     ( {from_size} bytes )  ( {age_text} & {size_text} )"
+        to_label_text = f"{to_date.format('%F %R')}     {self.sizeof_fmt(to_size)}     ( {to_size} bytes )"
+
+        exists_file_diff_from.set_text(from_label_text)
+        exists_file_diff_to.set_text(to_label_text)
+
+
+    def rename_proc(self, gio_file):
+        full_path = gio_file.get_path()
+        base_path = gio_file.get_parent().get_path()
+        file_name = os.path.splitext(gio_file.get_basename())[0]
+        extension = os.path.splitext(full_path)[-1]
+        target    = Gio.File.new_for_path(full_path)
+        start     = "-copy"
+
+        if debug:
+            print(f"Path:  {full_path}")
+            print(f"Base Path:  {base_path}")
+            print(f'Name:  {file_name}')
+            print(f"Extension:  {extension}")
+
+        i = 2
+        while target.query_exists():
+            try:
+                value     = file_name[(file_name.find(start)+len(start)):]
+                int(value)
+                file_name = file_name.split(start)[0]
+            except Exception as e:
+                pass
+
+            target = Gio.File.new_for_path(f"{base_path}/{file_name}-copy{i}{extension}")
+            i += 1
+
+        return target
+
+
+    def exists_rename_field_changed(self, widget):
+        nfile_name = widget.get_text().strip()
+        ofile_name = self.exists_file_label.get_label()
+
+        if nfile_name:
+            if nfile_name == ofile_name:
+                self.exists_file_rename_bttn.set_sensitive(False)
+            else:
+                self.exists_file_rename_bttn.set_sensitive(True)
+        else:
+            self.exists_file_rename_bttn.set_sensitive(False)

src/debs/solarfm-0-0-1-x64/opt/SolarFM/context/mixins/ui/widget_mixin.py

@@ -0,0 +1,221 @@
+# Python imports
+import os, threading, subprocess, time
+
+# Lib imports
+import gi
+
+gi.require_version("Gtk", "3.0")
+gi.require_version('Gdk', '3.0')
+from gi.repository import Gtk, Gdk, GLib, Gio, GdkPixbuf
+
+# Application imports
+
+
+def threaded(fn):
+    def wrapper(*args, **kwargs):
+        threading.Thread(target=fn, args=args, kwargs=kwargs, daemon=True).start()
+    return wrapper
+
+
+
+
+class WidgetMixin:
+    """docstring for WidgetMixin"""
+
+    def load_store(self, view, store, save_state=False):
+        store.clear()
+        dir   = view.get_current_directory()
+        files = view.get_files()
+
+        for i, file in enumerate(files):
+            store.append([None, file[0]])
+            self.create_icon(i, view, store, dir, file[0])
+
+        # NOTE: Not likely called often from here but it could be useful
+        if save_state:
+            self.window_controller.save_state()
+
+    @threaded
+    def create_icon(self, i, view, store, dir, file):
+        icon  = view.create_icon(dir, file)
+        fpath = f"{dir}/{file}"
+        GLib.idle_add(self.update_store, (i, store, icon, view, fpath,))
+
+    # NOTE: Might need to keep an eye on this throwing invalid iters when too
+    #       many updates are happening to a folder. Example: /tmp
+    def update_store(self, item):
+        i, store, icon, view, fpath = item
+        itr = None
+
+        try:
+            itr = store.get_iter(i)
+        except Exception as e:
+            try:
+                time.sleep(0.2)
+                itr = store.get_iter(i)
+            except Exception as e:
+                print(":Invalid Itr detected: (Potential race condition...)")
+                print(f"Index Requested:  {i}")
+                print(f"Store Size:  {len(store)}")
+                return
+
+        if not icon:
+            icon = self.get_system_thumbnail(fpath, view.SYS_ICON_WH[0])
+            if not icon:
+                if fpath.endswith(".gif"):
+                    icon = GdkPixbuf.PixbufAnimation.get_static_image(fpath)
+                else:
+                    icon = GdkPixbuf.Pixbuf.new_from_file(view.DEFAULT_ICON)
+
+        store.set_value(itr, 0, icon)
+
+
+    def get_system_thumbnail(self, filename, size):
+        try:
+            if os.path.exists(filename):
+                gioFile   = Gio.File.new_for_path(filename)
+                info      = gioFile.query_info('standard::icon' , 0, Gio.Cancellable())
+                icon      = info.get_icon().get_names()[0]
+                iconTheme = Gtk.IconTheme.get_default()
+                iconData  = iconTheme.lookup_icon(icon , size , 0)
+                if iconData:
+                    iconPath  = iconData.get_filename()
+                    return GdkPixbuf.Pixbuf.new_from_file(iconPath)
+                else:
+                    return None
+            else:
+                return None
+        except Exception as e:
+            print("System icon generation issue:")
+            return None
+
+
+
+
+    def create_tab_widget(self, view):
+        tab   = Gtk.ButtonBox()
+        label = Gtk.Label()
+        tid   = Gtk.Label()
+        close = Gtk.Button()
+        icon  = Gtk.Image(stock=Gtk.STOCK_CLOSE)
+
+        label.set_label(f"{view.get_end_of_path()}")
+        label.set_width_chars(len(view.get_end_of_path()))
+        label.set_xalign(0.0)
+        tid.set_label(f"{view.get_id()}")
+
+        close.add(icon)
+        tab.add(label)
+        tab.add(close)
+        tab.add(tid)
+
+        close.connect("released", self.close_tab)
+        tab.show_all()
+        tid.hide()
+        return tab
+
+    def create_grid_iconview_widget(self, view, wid):
+        scroll = Gtk.ScrolledWindow()
+        grid   = Gtk.IconView()
+        store  = Gtk.ListStore(GdkPixbuf.Pixbuf or GdkPixbuf.PixbufAnimation or None, str)
+
+        grid.set_model(store)
+        grid.set_pixbuf_column(0)
+        grid.set_text_column(1)
+
+        grid.set_item_orientation(1)
+        grid.set_selection_mode(3)
+        grid.set_item_width(96)
+        grid.set_item_padding(8)
+        grid.set_margin(12)
+        grid.set_row_spacing(18)
+        grid.set_columns(-1)
+        grid.set_spacing(12)
+        grid.set_column_spacing(18)
+
+        grid.connect("button_release_event", self.grid_icon_single_click)
+        grid.connect("item-activated", self.grid_icon_double_click)
+        grid.connect("selection-changed", self.grid_set_selected_items)
+        grid.connect("drag-data-get", self.grid_on_drag_set)
+        grid.connect("drag-data-received", self.grid_on_drag_data_received)
+        grid.connect("drag-motion", self.grid_on_drag_motion)
+
+
+        URI_TARGET_TYPE  = 80
+        uri_target       = Gtk.TargetEntry.new('text/uri-list', Gtk.TargetFlags(0), URI_TARGET_TYPE)
+        targets          = [ uri_target ]
+        action           = Gdk.DragAction.COPY
+        grid.enable_model_drag_dest(targets, action)
+        grid.enable_model_drag_source(0, targets, action)
+
+        grid.show_all()
+        scroll.add(grid)
+        grid.set_name(f"{wid}|{view.get_id()}")
+        scroll.set_name(f"{wid}|{view.get_id()}")
+        self.builder.expose_object(f"{wid}|{view.get_id()}|iconview", grid)
+        self.builder.expose_object(f"{wid}|{view.get_id()}", scroll)
+        return scroll, store
+
+    def create_grid_treeview_widget(self, view, wid):
+        scroll = Gtk.ScrolledWindow()
+        grid   = Gtk.TreeView()
+        store  = Gtk.ListStore(GdkPixbuf.Pixbuf or GdkPixbuf.PixbufAnimation or None, str)
+        # store  = Gtk.TreeStore(GdkPixbuf.Pixbuf or None, str)
+        column = Gtk.TreeViewColumn("Icons")
+        icon   = Gtk.CellRendererPixbuf()
+        name   = Gtk.CellRendererText()
+        selec  = grid.get_selection()
+
+        grid.set_model(store)
+        selec.set_mode(3)
+        column.pack_start(icon, False)
+        column.pack_start(name, True)
+        column.add_attribute(icon, "pixbuf", 0)
+        column.add_attribute(name, "text", 1)
+        column.set_expand(False)
+        column.set_sizing(2)
+        column.set_min_width(120)
+        column.set_max_width(74)
+
+        grid.append_column(column)
+        grid.set_search_column(1)
+        grid.set_rubber_banding(True)
+        grid.set_headers_visible(False)
+        grid.set_enable_tree_lines(False)
+
+        grid.connect("button_release_event", self.grid_icon_single_click)
+        grid.connect("row-activated", self.grid_icon_double_click)
+        grid.connect("drag-data-get", self.grid_on_drag_set)
+        grid.connect("drag-data-received", self.grid_on_drag_data_received)
+        grid.connect("drag-motion", self.grid_on_drag_motion)
+
+        URI_TARGET_TYPE  = 80
+        uri_target       = Gtk.TargetEntry.new('text/uri-list', Gtk.TargetFlags(0), URI_TARGET_TYPE)
+        targets          = [ uri_target ]
+        action           = Gdk.DragAction.COPY
+        grid.enable_model_drag_dest(targets, action)
+        grid.enable_model_drag_source(0, targets, action)
+
+
+        grid.show_all()
+        scroll.add(grid)
+        grid.set_name(f"{wid}|{view.get_id()}")
+        scroll.set_name(f"{wid}|{view.get_id()}")
+        grid.columns_autosize()
+        self.builder.expose_object(f"{wid}|{view.get_id()}", scroll)
+        return scroll, store
+
+
+    def get_store_and_label_from_notebook(self, notebook, _name):
+        icon_view = None
+        tab_label = None
+        store     = None
+
+        for obj in notebook.get_children():
+            icon_view = obj.get_children()[0]
+            name      =  icon_view.get_name()
+            if name == _name:
+                store = icon_view.get_model()
+                tab_label = notebook.get_tab_label(obj).get_children()[0]
+
+        return store, tab_label

src/debs/solarfm-0-0-1-x64/opt/SolarFM/context/mixins/ui/window_mixin.py

@@ -0,0 +1,260 @@
+# Python imports
+import copy
+from os.path import isdir, isfile
+
+
+# Lib imports
+import gi
+gi.require_version('Gdk', '3.0')
+from gi.repository import Gdk, Gio
+
+# Application imports
+from .tab_mixin import TabMixin
+from .widget_mixin import WidgetMixin
+
+
+
+
+class WindowMixin(TabMixin):
+    """docstring for WindowMixin"""
+
+    def generate_windows(self, session_json = None):
+        if session_json:
+            for j, value in enumerate(session_json):
+                i = j + 1
+                isHidden = True if value[0]["window"]["isHidden"] == "True" else False
+                object   = self.builder.get_object(f"tggl_notebook_{i}")
+                views    = value[0]["window"]["views"]
+                self.window_controller.create_window()
+                object.set_active(True)
+
+                for view in views:
+                    self.create_new_view_notebook(None, i, view)
+
+                if isHidden:
+                    self.toggle_notebook_pane(object)
+
+            try:
+                if not self.is_pane4_hidden:
+                    icon_view = self.window4.get_children()[1].get_children()[0]
+                    icon_view.event(Gdk.Event().new(type=Gdk.EventType.BUTTON_RELEASE))
+                elif not self.is_pane3_hidden:
+                    icon_view = self.window3.get_children()[1].get_children()[0]
+                    icon_view.event(Gdk.Event().new(type=Gdk.EventType.BUTTON_RELEASE))
+                elif not self.is_pane2_hidden:
+                    icon_view = self.window2.get_children()[1].get_children()[0]
+                    icon_view.event(Gdk.Event().new(type=Gdk.EventType.BUTTON_RELEASE))
+                elif not self.is_pane1_hidden:
+                    icon_view = self.window1.get_children()[1].get_children()[0]
+                    icon_view.event(Gdk.Event().new(type=Gdk.EventType.BUTTON_RELEASE))
+            except Exception as e:
+                print("\n:  The saved session might be missing window data!  :\nLocation: ~/.config/solarfm/session.json\nFix: Back it up and delete it to reset.\n")
+                print(repr(e))
+        else:
+            for j in range(0, 4):
+                i = j + 1
+                self.window_controller.create_window()
+                self.create_new_view_notebook(None, i, None)
+
+
+    def get_fm_window(self, wid):
+        return self.window_controller.get_window_by_nickname(f"window_{wid}")
+
+    def format_to_uris(self, store, wid, tid, treePaths, use_just_path=False):
+        view = self.get_fm_window(wid).get_view_by_id(tid)
+        dir  = view.get_current_directory()
+        uris = []
+
+        for path in treePaths:
+            itr   = store.get_iter(path)
+            file  = store.get(itr, 1)[0]
+            fpath = ""
+
+            if not use_just_path:
+                fpath = f"file://{dir}/{file}"
+            else:
+                fpath = f"{dir}/{file}"
+
+            uris.append(fpath)
+
+        return uris
+
+
+    def set_bottom_labels(self, view):
+        _wid, _tid, _view, icon_view, store = self.get_current_state()
+        selected_files       = icon_view.get_selected_items()
+        current_directory    = view.get_current_directory()
+        path_file            = Gio.File.new_for_path(current_directory)
+        mount_file           = path_file.query_filesystem_info(attributes="filesystem::*", cancellable=None)
+        formatted_mount_free = self.sizeof_fmt( int(mount_file.get_attribute_as_string("filesystem::free")) )
+        formatted_mount_size = self.sizeof_fmt( int(mount_file.get_attribute_as_string("filesystem::size")) )
+
+        if self.trash_files_path == current_directory:
+            self.builder.get_object("restore_from_trash").show()
+            self.builder.get_object("empty_trash").show()
+        else:
+            self.builder.get_object("restore_from_trash").hide()
+            self.builder.get_object("empty_trash").hide()
+
+        # If something selected
+        self.bottom_size_label.set_label(f"{formatted_mount_free} free / {formatted_mount_size}")
+        self.bottom_path_label.set_label(view.get_current_directory())
+        if len(selected_files) > 0:
+            uris          = self.format_to_uris(store, _wid, _tid, selected_files, True)
+            combined_size = 0
+            for uri in uris:
+                try:
+                    file_info = Gio.File.new_for_path(uri).query_info(attributes="standard::size",
+                                                        flags=Gio.FileQueryInfoFlags.NONE,
+                                                        cancellable=None)
+                    file_size = file_info.get_size()
+                    combined_size += file_size
+                except Exception as e:
+                    if debug:
+                        print(repr(e))
+
+
+            formatted_size = self.sizeof_fmt(combined_size)
+            if view.get_hidden():
+                self.bottom_path_label.set_label(f" {len(uris)} / {view.get_files_count()} ({formatted_size})")
+            else:
+                self.bottom_path_label.set_label(f" {len(uris)} / {view.get_not_hidden_count()} ({formatted_size})")
+
+            return
+
+        # If nothing selected
+        if view.get_hidden():
+            if view.get_hidden_count() > 0:
+                self.bottom_file_count_label.set_label(f"{view.get_not_hidden_count()} visible ({view.get_hidden_count()} hidden)")
+            else:
+                self.bottom_file_count_label.set_label(f"{view.get_files_count()} items")
+        else:
+            self.bottom_file_count_label.set_label(f"{view.get_files_count()} items")
+
+
+
+    def set_window_title(self):
+        wid, tid = self.window_controller.get_active_wid_and_tid()
+        notebook = self.builder.get_object(f"window_{wid}")
+        view     = self.get_fm_window(wid).get_view_by_id(tid)
+        dir      = view.get_current_directory()
+
+        for _notebook in self.notebooks:
+            ctx = _notebook.get_style_context()
+            ctx.remove_class("notebook-selected-focus")
+            ctx.add_class("notebook-unselected-focus")
+
+        ctx = notebook.get_style_context()
+        ctx.remove_class("notebook-unselected-focus")
+        ctx.add_class("notebook-selected-focus")
+
+        self.window.set_title(f"SolarFM ~ {dir}")
+        self.set_bottom_labels(view)
+
+    def set_path_text(self, wid, tid):
+        path_entry = self.builder.get_object("path_entry")
+        view       = self.get_fm_window(wid).get_view_by_id(tid)
+        path_entry.set_text(view.get_current_directory())
+
+    def grid_set_selected_items(self, iconview):
+        self.selected_files = iconview.get_selected_items()
+
+    def grid_cursor_toggled(self, iconview):
+        print("wat...")
+
+    def grid_icon_single_click(self, iconview, eve):
+        try:
+            self.path_menu.popdown()
+            wid, tid = iconview.get_name().split("|")
+            self.window_controller.set__wid_and_tid(wid, tid)
+            self.set_path_text(wid, tid)
+            self.set_window_title()
+
+
+            if eve.type == Gdk.EventType.BUTTON_RELEASE and eve.button == 1:   # l-click
+                if self.single_click_open: # FIXME: need to find a way to pass the model index
+                    self.grid_icon_double_click(iconview)
+            elif eve.type == Gdk.EventType.BUTTON_RELEASE and eve.button == 3: # r-click
+                self.show_context_menu()
+
+        except Exception as e:
+            print(repr(e))
+            self.display_message(self.error, f"{repr(e)}")
+
+    def grid_icon_double_click(self, iconview, item, data=None):
+        try:
+            if self.ctrlDown and self.shiftDown:
+                self.unset_keys_and_data()
+                self.execute_files(in_terminal=True)
+                return
+            elif self.ctrlDown:
+                self.unset_keys_and_data()
+                self.execute_files()
+                return
+
+
+            wid, tid, view, _iconview, store = self.get_current_state()
+            notebook   = self.builder.get_object(f"window_{wid}")
+            tab_label  = self.get_tab_label(notebook, iconview)
+
+            fileName   = store[item][1]
+            dir        = view.get_current_directory()
+            file       = f"{dir}/{fileName}"
+
+            if isdir(file):
+                view.set_path(file)
+                self.update_view(tab_label, view, store, wid, tid)
+            else:
+                self.open_files()
+        except Exception as e:
+            self.display_message(self.error, f"{repr(e)}")
+
+
+
+    def grid_on_drag_set(self, iconview, drag_context, data, info, time):
+        action    = iconview.get_name()
+        wid, tid  = action.split("|")
+        store     = iconview.get_model()
+        treePaths = iconview.get_selected_items()
+        # NOTE: Need URIs as URI format for DnD to work. Will strip 'file://'
+        # further down call chain when doing internal fm stuff.
+        uris      = self.format_to_uris(store, wid, tid, treePaths)
+        uris_text = '\n'.join(uris)
+
+        data.set_uris(uris)
+        data.set_text(uris_text, -1)
+
+    def grid_on_drag_motion(self, iconview, drag_context, x, y, data):
+        current   = '|'.join(self.window_controller.get_active_wid_and_tid())
+        target    = iconview.get_name()
+        wid, tid  = target.split("|")
+        store     = iconview.get_model()
+        treePath  = iconview.get_drag_dest_item().path
+
+        if treePath:
+            uri = self.format_to_uris(store, wid, tid, treePath)[0].replace("file://", "")
+            self.override_drop_dest = uri if isdir(uri) else None
+
+        if target not in current:
+            self.window_controller.set__wid_and_tid(wid, tid)
+
+
+    def grid_on_drag_data_received(self, widget, drag_context, x, y, data, info, time):
+        if info == 80:
+            wid, tid  = self.window_controller.get_active_wid_and_tid()
+            notebook  = self.builder.get_object(f"window_{wid}")
+            store, tab_label = self.get_store_and_label_from_notebook(notebook, f"{wid}|{tid}")
+            view      = self.get_fm_window(wid).get_view_by_id(tid)
+
+            uris = data.get_uris()
+            dest = f"{view.get_current_directory()}" if not self.override_drop_dest else self.override_drop_dest
+            if len(uris) == 0:
+                uris = data.get_text().split("\n")
+
+            from_uri = '/'.join(uris[0].replace("file://", "").split("/")[:-1])
+            if from_uri != dest:
+                self.move_files(uris, dest)
+
+
+    def create_new_view_notebook(self, widget=None, wid=None, path=None):
+        self.create_tab(wid, path)

src/debs/solarfm-0-0-1-x64/opt/SolarFM/context/mixins/ui_mixin.py

@@ -0,0 +1,14 @@
+# Python imports
+
+# Gtk imports
+
+# Application imports
+from .show_hide_mixin import ShowHideMixin
+from .ui.widget_file_action_mixin import WidgetFileActionMixin
+from .ui.pane_mixin import PaneMixin
+from .ui.window_mixin import WindowMixin
+from .show_hide_mixin import ShowHideMixin
+
+
+class UIMixin(WidgetFileActionMixin, PaneMixin, WindowMixin, ShowHideMixin):
+    pass

src/debs/solarfm-0-0-1-x64/opt/SolarFM/context/signals/ipc_signals_mixin.py

@@ -0,0 +1,29 @@
+# Python imports
+
+# Lib imports
+
+# Application imports
+
+
+class IPCSignalsMixin:
+    """ IPCSignalsMixin handle messages from another starting solarfm process. """
+
+    def print_to_console(self, message=None):
+        print(self)
+        print(message)
+
+    def handle_file_from_ipc(self, path):
+        wid, tid   = self.window_controller.get_active_wid_and_tid()
+        notebook   = self.builder.get_object(f"window_{wid}")
+        if notebook.is_visible():
+            self.create_tab(wid, path)
+            return
+
+        if not self.is_pane4_hidden:
+            self.create_tab(4, path)
+        elif not self.is_pane3_hidden:
+            self.create_tab(3, path)
+        elif not self.is_pane2_hidden:
+            self.create_tab(2, path)
+        elif not self.is_pane1_hidden:
+            self.create_tab(1, path)

src/debs/solarfm-0-0-1-x64/opt/SolarFM/context/signals/keyboard_signals_mixin.py

@@ -0,0 +1,128 @@
+# Python imports
+import re
+
+# Lib imports
+import gi
+gi.require_version('Gtk', '3.0')
+gi.require_version('Gdk', '3.0')
+from gi.repository import Gtk, Gdk
+
+# Application imports
+
+
+valid_keyvalue_pat    = re.compile(r"[a-z0-9A-Z-_\[\]\(\)\| ]")
+
+
+class KeyboardSignalsMixin:
+    """ KeyboardSignalsMixin keyboard hooks controller. """
+
+    def unset_keys_and_data(self, widget=None, eve=None):
+        self.ctrlDown     = False
+        self.shiftDown    = False
+        self.altDown      = False
+        self.is_searching = False
+
+    def global_key_press_controller(self, eve, user_data):
+        keyname = Gdk.keyval_name(user_data.keyval).lower()
+        if "control" in keyname or "alt" in keyname or "shift" in keyname:
+            if "control" in keyname:
+                self.ctrlDown    = True
+            if "shift" in keyname:
+                self.shiftDown   = True
+            if "alt" in keyname:
+                self.altDown     = True
+
+    # NOTE: Yes, this should actually be mapped to some key controller setting
+    #       file or something. Sue me.
+    def global_key_release_controller(self, eve, user_data):
+        keyname = Gdk.keyval_name(user_data.keyval).lower()
+        if debug:
+            print(f"global_key_release_controller > key > {keyname}")
+
+        if "control" in keyname or "alt" in keyname or "shift" in keyname:
+            if "control" in keyname:
+                self.ctrlDown    = False
+            if "shift" in keyname:
+                self.shiftDown   = False
+            if "alt" in keyname:
+                self.altDown     = False
+
+
+        if self.ctrlDown and self.shiftDown and keyname == "t":
+            self.unset_keys_and_data()
+            self.trash_files()
+
+
+        if re.fullmatch(valid_keyvalue_pat, keyname):
+            if not self.is_searching and not self.ctrlDown \
+                and not self.shiftDown and not self.altDown:
+                    focused_obj = self.window.get_focus()
+                    if isinstance(focused_obj, Gtk.IconView):
+                        self.is_searching = True
+                        wid, tid, self.search_view, self.search_iconview, store = self.get_current_state()
+                        self.unset_keys_and_data()
+                        self.popup_search_files(wid, keyname)
+                        return
+
+
+        if (self.ctrlDown and keyname in ["1", "kp_1"]):
+            self.builder.get_object("tggl_notebook_1").released()
+        if (self.ctrlDown and keyname in ["2", "kp_2"]):
+            self.builder.get_object("tggl_notebook_2").released()
+        if (self.ctrlDown and keyname in ["3", "kp_3"]):
+            self.builder.get_object("tggl_notebook_3").released()
+        if (self.ctrlDown and keyname in ["4", "kp_4"]):
+            self.builder.get_object("tggl_notebook_4").released()
+
+        if self.ctrlDown and keyname == "q":
+            self.tear_down()
+        if (self.ctrlDown and keyname == "slash") or keyname == "home":
+            self.builder.get_object("go_home").released()
+        if (self.ctrlDown and keyname == "r") or keyname == "f5":
+            self.builder.get_object("refresh_view").released()
+        if (self.ctrlDown and keyname == "up") or (self.ctrlDown and keyname == "u"):
+            self.builder.get_object("go_up").released()
+        if self.ctrlDown and keyname == "l":
+            self.unset_keys_and_data()
+            self.builder.get_object("path_entry").grab_focus()
+        if self.ctrlDown and keyname == "t":
+            self.builder.get_object("create_tab").released()
+        if self.ctrlDown and keyname == "o":
+            self.unset_keys_and_data()
+            self.open_files()
+        if self.ctrlDown and keyname == "w":
+            self.keyboard_close_tab()
+        if self.ctrlDown and keyname == "h":
+            self.show_hide_hidden_files()
+        if (self.ctrlDown and keyname == "e"):
+            self.unset_keys_and_data()
+            self.rename_files()
+        if self.ctrlDown and keyname == "c":
+            self.copy_files()
+            self.to_cut_files.clear()
+        if self.ctrlDown and keyname == "x":
+            self.to_copy_files.clear()
+            self.cut_files()
+        if self.ctrlDown and keyname == "v":
+            self.paste_files()
+        if self.ctrlDown and keyname == "n":
+            self.unset_keys_and_data()
+            self.show_new_file_menu()
+
+
+
+        if keyname in ["alt_l", "alt_r"]:
+            top_main_menubar = self.builder.get_object("top_main_menubar")
+            if top_main_menubar.is_visible():
+                top_main_menubar.hide()
+            else:
+                top_main_menubar.show()
+        if keyname == "delete":
+            self.unset_keys_and_data()
+            self.delete_files()
+        if keyname == "f2":
+            self.unset_keys_and_data()
+            self.rename_files()
+        if keyname == "f4":
+            self.unset_keys_and_data()
+            self.open_terminal()