initial push...

src/core/__init__.py

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

src/core/controller.py

@@ -0,0 +1,146 @@
+# Python imports
+import os, subprocess
+
+# Gtk imports
+import gi
+
+gi.require_version('Gtk', '3.0')
+gi.require_version('Gdk', '3.0')
+gi.require_version('GdkPixbuf', '2.0')
+
+from gi.repository import Gtk
+from gi.repository import Gdk
+from gi.repository import Gio
+from gi.repository import GLib
+from gi.repository import GdkPixbuf
+
+# Application imports
+from .controller_data import ControllerData
+from .core_widget import CoreWidget
+
+
+
+class Controller(ControllerData):
+    def __init__(self, args, unknownargs):
+        self._setup_styling()
+        self._setup_signals()
+        self._subscribe_to_events()
+
+        self.setup_controller_data()
+
+
+    def _setup_styling(self):
+        ...
+
+    def _setup_signals(self):
+        ...
+
+
+
+    # NOTE: To be filled out after app data is actually working...
+    def search_for_entry(self, widget, data=None):
+        ...
+
+    def set_list_group(self, widget):
+        group       = widget.get_label().strip()
+        group_items = self.core_widget.get_group(group)
+        grid        = self.builder.get_object("programListBttns")
+
+        children = grid.get_children()
+        for child in children:
+            grid.remove(child)
+
+        for item in group_items:
+            title   = item["title"]
+            if not item["exec"] in ("", None):
+                exec = item["exec"]
+            else:
+                exec = item["tryExec"]
+
+            button = Gtk.Button(label=title)
+            button.connect("clicked", self.test_exec, exec)
+            if self.show_image:
+                if os.path.exists(item["icon"]):
+                    pixbuf = GdkPixbuf.PixbufAnimation.new_from_file(item["icon"]) \
+                                                        .get_static_image() \
+                                                        .scale_simple(64, 64, \
+                                                        GdkPixbuf.InterpType.BILINEAR)
+
+                    icon = Gtk.Image.new_from_pixbuf(pixbuf)
+                else:
+                    gio_icon = Gio.Icon.new_for_string(item["icon"])
+                    icon = Gtk.Image.new_from_gicon(gio_icon, 64)
+
+                button.set_image(icon)
+                button.set_always_show_image(True)
+
+            button.show_all()
+            grid.add(button)
+
+    def test_exec(self, widget, _command):
+        command = _command.split("%")[0]
+        DEVNULL = open(os.devnull, 'w')
+        subprocess.Popen(command.split(), start_new_session=True, stdout=DEVNULL, stderr=DEVNULL)
+
+
+
+    def _subscribe_to_events(self):
+        event_system.subscribe("handle_file_from_ipc", self.handle_file_from_ipc)
+
+    def handle_file_from_ipc(self, path: str) -> None:
+        print(f"Path From IPC: {path}")
+
+    def load_glade_file(self):
+        self.builder     = Gtk.Builder()
+        self.builder.add_from_file(settings.get_glade_file())
+        settings.set_builder(self.builder)
+        self.core_widget = CoreWidget()
+
+        settings.register_signals_to_builder([self, self.core_widget])
+
+    def get_core_widget(self):
+        self.setup_toggle_event()
+        return self.core_widget
+
+    def on_hide_window(self, data=None):
+        """Handle a request to hide/show the window"""
+        if not self.window.get_property('visible'):
+            self.window.show()
+            self.window.grab_focus()
+            # NOTE:  Need here to enforce sticky after hide and reshow.
+            self.window.stick()
+        else:
+            self.hidefunc()
+
+    def on_global_key_release_controller(self, widget: type, event: type) -> None:
+        """Handler for keyboard events"""
+        keyname = Gdk.keyval_name(event.keyval).lower()
+        if keyname.replace("_l", "").replace("_r", "") in ["control", "alt", "shift"]:
+            if "control" in keyname:
+                self.ctrl_down    = False
+            if "shift" in keyname:
+                self.shift_down   = False
+            if "alt" in keyname:
+                self.alt_down     = False
+
+
+        mapping = keybindings.lookup(event)
+        if mapping:
+            getattr(self, mapping)()
+            return True
+        else:
+            print(f"on_global_key_release_controller > key > {keyname}")
+            print(f"Add logic or remove this from: {self.__class__}")
+
+
+    def get_clipboard_data(self) -> str:
+        proc    = subprocess.Popen(['xclip','-selection', 'clipboard', '-o'], stdout=subprocess.PIPE)
+        retcode = proc.wait()
+        data    = proc.stdout.read()
+        return data.decode("utf-8").strip()
+
+    def set_clipboard_data(self, data: type) -> None:
+        proc = subprocess.Popen(['xclip','-selection','clipboard'], stdin=subprocess.PIPE)
+        proc.stdin.write(data)
+        proc.stdin.close()
+        retcode = proc.wait()

src/core/controller_data.py

@@ -0,0 +1,99 @@
+# Python imports
+import os
+
+# Lib imports
+import gi
+from gi.repository import GObject
+
+# Application imports
+from plugins.plugins_controller import PluginsController
+
+
+
+
+try:
+    from gi.repository import GdkX11
+except ImportError:
+    logger.debug("Could not import X11 gir module...")
+
+def display_manager():
+    """ Try to detect which display manager we are running under... """
+    if os.environ.get('WAYLAND_DISPLAY'):
+        return 'WAYLAND'
+    return 'X11'  # Fallback assumption of X11
+
+
+if display_manager() == 'X11':
+    try:
+        gi.require_version('Keybinder', '3.0')
+        from gi.repository import Keybinder
+        Keybinder.init()
+        Keybinder.set_use_cooked_accelerators(False)
+    except (ImportError, ValueError):
+        logger.debug('Unable to load Keybinder module. This means the hide_window shortcut will be unavailable')
+
+
+
+
+class ControllerData:
+    ''' ControllerData contains most of the state of the app at ay given time. It also has some support methods. '''
+
+    def setup_controller_data(self) -> None:
+        self.builder       = None
+        self.core_widget   = None
+
+        self.load_glade_file()
+        self.plugins       = PluginsController()
+
+        self.hidefunc      = None
+        self.show_image    = True
+        self.guake_key     = settings.get_guake_key()
+
+
+    def setup_toggle_event(self) -> None:
+        self.window = settings.get_builder().get_object(f"{app_name.lower()}")
+
+        # Attempt to grab a global hotkey for hiding the window.
+        # If we fail, we'll never hide the window, iconifying instead.
+        if self.guake_key and display_manager() == 'X11':
+            try:
+                hidebound = Keybinder.bind(self.guake_key, self.on_hide_window)
+            except (KeyError, NameError):
+                pass
+
+            if not hidebound:
+                logger.debug('Unable to bind hide_window key, another instance/window has it.')
+                self.hidefunc = self.window.iconify
+            else:
+                self.hidefunc = self.window.hide
+
+
+    def clear_console(self) -> None:
+        ''' Clears the terminal screen. '''
+        os.system('cls' if os.name == 'nt' else 'clear')
+
+    def call_method(self, _method_name: str, data: type) -> type:
+        '''
+            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: type, method: type) -> type:
+        ''' Checks if a given method exists. '''
+        return callable(getattr(obj, method, None))
+
+    def clear_children(self, widget: type) -> None:
+        ''' Clear children of a gtk widget. '''
+        for child in widget.get_children():
+            widget.remove(child)

src/core/core_widget.py

@@ -0,0 +1,182 @@
+# Python imports
+from datetime import datetime
+
+# Gtk 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
+from gi.repository import GObject
+from xdg.DesktopEntry import DesktopEntry
+
+
+# Application imports
+from .desktop_parsing.app_finder import find_apps
+
+
+
+
+class CoreWidget(Gtk.Box):
+    def __init__(self):
+        super(CoreWidget, self).__init__()
+        self.builder     = settings.get_builder()
+        self.time_label  = self.builder.get_object("timeLabel")
+
+        self.orientation = 1  # 0 = horizontal, 1 = vertical
+
+        self._setup_styling()
+        self._setup_signals()
+        self._load_widgets()
+
+        self.show_all()
+
+        self.menu_objects = {
+            "Accessories": [],
+            "Multimedia": [],
+            "Graphics": [],
+            "Game": [],
+            "Office": [],
+            "Development": [],
+            "Internet": [],
+            "Settings": [],
+            "System": [],
+            "Wine": [],
+            "Other": []
+        }
+        apps = find_apps()
+        self.fill_menu_objects(apps)
+
+
+    def fill_menu_objects(self, apps=[]):
+        for app in apps:
+            fPath    = app.get_filename()
+            xdgObj   = DesktopEntry( fPath )
+
+            title    = xdgObj.getName()
+            groups   = xdgObj.getCategories()
+            comment  = xdgObj.getComment()
+            icon     = xdgObj.getIcon()
+            mainExec = xdgObj.getExec()
+            tryExec  = xdgObj.getTryExec()
+
+            group    = ""
+            if "Accessories" in groups or "Utility" in groups:
+                group = "Accessories"
+            elif "Multimedia" in groups or "Video" in groups or "Audio" in groups:
+                group = "Multimedia"
+            elif "Development" in groups:
+                group = "Development"
+            elif "Game" in groups:
+                group = "Game"
+            elif "Internet" in groups or "Network" in groups:
+                group = "Internet"
+            elif "Graphics" in groups:
+                group = "Graphics"
+            elif "Office" in groups:
+                group = "Office"
+            elif "System" in groups:
+                group = "System"
+            elif "Settings" in groups:
+                group = "Settings"
+            elif "Wine" in groups:
+                group = "Wine"
+            else:
+                group = "Other"
+
+            self.menu_objects[group].append( {"title":  title,   "groups": groups,
+                                    "comment": comment, "exec": mainExec,
+                                    "tryExec": tryExec, "fileName": fPath.split("/")[-1],
+                                    "filePath": fPath, "icon": icon})
+
+    def get_group(self, group):
+        return self.menu_objects[group]
+
+
+
+    def _setup_styling(self):
+        self.set_orientation(1)
+        self.set_vexpand(True)
+        self.set_hexpand(True)
+
+    def _setup_signals(self):
+        ...
+
+    def _load_widgets(self):
+        widget_grid_container = self.builder.get_object("widget_grid_container")
+
+        timeLabelEveBox = self.builder.get_object("timeLabelEveBox")
+        timeLabelEveBox.connect("button_release_event", self._toggle_cal_popover)
+
+        widget_grid_container.set_vexpand(True)
+        widget_grid_container.set_hexpand(True)
+
+        self.add( widget_grid_container )
+        self.set_pager_widget()
+        self.set_task_list_widget()
+
+        # Must be after pager and task list inits
+        self.display_clock()
+        self._start_clock()
+
+
+    def set_pager_widget(self):
+        pager = Wnck.Pager.new()
+
+        if self.orientation == 0:
+            self.builder.get_object('taskBarWorkspacesHor').add(pager)
+        else:
+            self.builder.get_object('taskBarWorkspacesVer').add(pager)
+
+        pager.set_hexpand(True)
+        pager.show()
+
+    def set_task_list_widget(self):
+        tasklist = Wnck.Tasklist.new()
+        tasklist.set_scroll_enabled(False)
+        tasklist.set_button_relief(2)  # 0 = normal relief, 2 = no relief
+        tasklist.set_grouping(1)       # 0 = mever group, 1 auto group, 2 = always group
+
+        if self.orientation == 0:
+            self.builder.get_object('taskBarButtonsHor').add(tasklist)
+        else:
+            self.builder.get_object('taskBarButtonsVer').add(tasklist)
+
+        tasklist.set_vexpand(True)
+        tasklist.set_include_all_workspaces(False)
+        tasklist.set_orientation(self.orientation)
+        tasklist.show()
+
+    # Displays Timer
+    def display_clock(self):
+        now = datetime.now()
+        hms = now.strftime("%I:%M %p")
+        mdy = now.strftime("%m/%d/%Y")
+        timeStr = hms + "\n" + mdy
+        self.time_label.set_label(timeStr)
+        return True
+
+    def _start_clock(self):
+        GObject.timeout_add(59000, self.display_clock)
+
+
+    def _close_popup(self, widget, data=None):
+        widget.hide()
+
+    def _toggle_cal_popover(self, widget, eve):
+        calendarPopup = self.builder.get_object('calendarPopup')
+        if (calendarPopup.get_visible() == False):
+            calendarWid = self.builder.get_object('calendarWid')
+            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])
+            calendarWid.select_day(day)
+            calendarWid.select_month(month, year)
+            calendarPopup.popup()
+        else:
+            calendarPopup.popdown()

src/core/desktop_parsing/DesktopParser.py

@@ -0,0 +1,94 @@
+# Python imports
+import os
+
+# Lib imports
+
+# Application imports
+
+
+
+
+class DesktopParser:
+    DESKTOP_SECTION = '[Desktop Entry]'
+
+    __property_list = None
+
+    def __init__(self, filename):
+        self.__property_list = []
+        self.set_filename(filename)
+        self.read()
+        super(DesktopParser, self).__init__()
+
+    def set_filename(self, filename):
+        self._filename = filename
+
+    def read(self):
+        """
+            Read [Desktop Entry] section and save key=values pairs to __property_list
+        """
+        with open(self._filename, 'r') as f:
+            is_desktop_section = False
+            for line in f.readlines():
+                line = line.strip(' ' + os.linesep)
+                if line == self.DESKTOP_SECTION:
+                    is_desktop_section = True
+                    continue
+                if line.startswith('['):
+                    # another section begins
+                    is_desktop_section = False
+                    continue
+                if is_desktop_section and '=' in line:
+                    (key, value) = line.split('=', 1)
+                    self.set(key.strip(), value.strip())
+
+    def write(self):
+        """
+            Write properties to the file...
+        """
+        dir = os.path.dirname(self._filename)
+        if not os.path.exists(dir):
+            os.makedirs(dir)
+
+        with open(self._filename, 'w') as f:
+            f.write(os.linesep.join((self.DESKTOP_SECTION, os.linesep.join(['='.join((str(k), str(v).strip()))
+                                                                            for k, v in self.__property_list]))))
+
+    def get(self, name):
+        """
+            Raises KeyError if name is not found
+        """
+
+        for key, value in self.__property_list:
+            if key.lower() == name.lower():
+                return value
+        raise KeyError('%s' % name)
+
+    def set(self, name, value):
+        if not name:
+            raise ValueError("Invalid value for name: '%s'" % name)
+
+        for i, (key, _) in enumerate(self.__property_list):
+            if key.lower() == name.lower():
+                self.__property_list[i] = (key, value)
+                return
+
+        self.__property_list.append((name, value))
+
+    def get_boolean(self, name):
+        """
+            Returns True if value is "1", "yes", "true", or "on"
+
+            Returns False if value is "0", "no", "false", or "off"
+
+            String values are checked in a case-insensitive manner.
+
+            Any other value will cause it to raise ValueError.
+        """
+
+        value = self.get(name).lower()
+        if value in ("1", "yes", "true", "on"):
+            return True
+        if value in ("0", "no", "false", "off"):
+            return False
+
+        raise ValueError("Cannot coerce '%s' to boolean" % value)

src/core/desktop_parsing/app_finder.py

@@ -0,0 +1,147 @@
+# Python imports
+import os
+import logging
+from collections import OrderedDict
+from itertools import chain
+from typing import Generator, List
+
+# Lib imports
+from gi.repository import Gio
+from xdg.BaseDirectory import xdg_config_home, xdg_cache_home, xdg_data_dirs, xdg_data_home
+
+
+# Application imports
+from .file_finder import find_files
+from .db.KeyValueDb import KeyValueDb
+
+
+
+
+DEFAULT_BLACKLISTED_DIRS = [
+    '/usr/share/locale',
+    '/usr/share/app-install',
+    '/usr/share/kservices5',
+    '/usr/share/fk5',
+    '/usr/share/kservicetypes5',
+    '/usr/share/applications/screensavers',
+    '/usr/share/kde4',
+    '/usr/share/mimelnk'
+]
+
+# Use utop_cache dir because of the WebKit bug
+# https://bugs.webkit.org/show_bug.cgi?id=151646
+CACHE_DIR = os.path.join(xdg_cache_home, 'utop_cache')
+
+# Spec: https://specifications.freedesktop.org/menu-spec/latest/ar01s02.html
+DESKTOP_DIRS = list(filter(os.path.exists, [os.path.join(dir, "applications") for dir in xdg_data_dirs]))
+
+logger = logging.getLogger(__name__)
+
+
+
+
+def find_desktop_files(dirs: List[str] = None, pattern: str = "*.desktop") -> Generator[str, None, None]:
+    """
+        Returns deduped list of .desktop files (full paths)
+
+        :param list dirs:
+        :rtype: list
+    """
+
+    if dirs is None:
+        dirs = DESKTOP_DIRS
+
+    all_files = chain.from_iterable(
+                    map(lambda f: os.path.join(f_path, f), find_files(f_path, pattern)) for f_path in dirs
+                )
+
+    # NOTE: Dedup desktop file according to follow XDG data dir order.
+    #       Specifically the first file name (i.e. firefox.desktop) take precedence
+    #       and other files with the same name should be ignored
+    deduped_file_dict = OrderedDict()
+    for file_path in all_files:
+        file_name = os.path.basename(file_path)
+        if file_name not in deduped_file_dict:
+            deduped_file_dict[file_name] = file_path
+
+    deduped_files = deduped_file_dict.values()
+
+    blacklisted_dirs = DEFAULT_BLACKLISTED_DIRS
+    for file in deduped_files:
+        try:
+            if any([file.startswith(dir) for dir in blacklisted_dirs]):
+                continue
+        except UnicodeDecodeError:
+            continue
+
+        yield file
+
+
+def filter_app(app):
+    """
+        :param Gio.DesktopAppInfo app:
+        :returns: True if app can be added to the database
+    """
+    return app and not (app.get_is_hidden() or app.get_nodisplay()
+                                            or app.get_string('Type') != 'Application'
+                                            or not app.get_string('Name'))
+
+
+def read_desktop_file(file):
+    """
+        :param str file: path to .desktop
+        :rtype: :class:`Gio.DesktopAppInfo` or :code:`None`
+    """
+    try:
+        return Gio.DesktopAppInfo.new_from_filename(file)
+    except Exception as e:
+        logger.info('Could not read "%s": %s', file, e)
+        return None
+
+
+def find_apps(dirs=None):
+    """
+        :param list dirs: list of paths to `*.desktop` files
+        :returns: list of :class:`Gio.DesktopAppInfo` objects
+    """
+    if dirs is None:
+        dirs = DESKTOP_DIRS
+
+    return list(filter(filter_app, map(read_desktop_file, find_desktop_files(dirs))))
+
+
+def find_apps_cached(dirs=None):
+    """
+        :param list dirs: list of paths to `*.desktop` files
+        :returns: list of :class:`Gio.DesktopAppInfo` objects
+
+        Pseudo code:
+        >>> if cache hit:
+        >>>     take list of paths from cache
+        >>>     yield from filter(filter_app, map(read_desktop_file, cached_paths))
+        >>> yield from find_apps()
+        >>> save new paths to the cache
+    """
+    if dirs is None:
+        dirs = DESKTOP_DIRS
+
+    desktop_file_cache_dir = os.path.join(CACHE_DIR, 'desktop_dirs.db')
+    cache = KeyValueDb(desktop_file_cache_dir).open()
+    desktop_dirs = cache.find('desktop_dirs')
+
+    if desktop_dirs:
+        for dir in desktop_dirs:
+            app_info = read_desktop_file(dir)
+            if filter_app(app_info):
+                yield app_info
+        logger.info('Found %s apps in cache', len(desktop_dirs))
+
+    new_desktop_dirs = []
+
+    for app_info in find_apps(DESKTOP_DIRS):
+        yield app_info
+        new_desktop_dirs.append(app_info.get_filename())
+
+    cache.put('desktop_dirs', new_desktop_dirs)
+    cache.commit()
+    logger.info('Found %s apps in the system', len(new_desktop_dirs))

src/core/desktop_parsing/db/KeyValueDb.py

@@ -0,0 +1,83 @@
+# Python imports
+import os
+import pickle
+from typing import Dict, TypeVar, Generic, Optional
+from distutils.dir_util import mkpath
+
+# Lib imports
+
+# Application imports
+
+
+
+
+Key = TypeVar('Key')
+Value = TypeVar('Value')
+Records = Dict[Key, Value]
+
+
+class KeyValueDb(Generic[Key, Value]):
+    """
+        Key-value in-memory database
+        Use open() method to load DB from a file and commit() to save it
+    """
+
+    _name = None  # type: str
+    _records = None  # type: Records
+
+    def __init__(self, basename: str):
+        """
+            :param str basename: path to db file
+        """
+        self._name = basename
+        self.set_records({})
+
+    def open(self) -> 'KeyValueDb':
+        """ Create a new data base or open existing one... """
+        if os.path.exists(self._name):
+            if not os.path.isfile(self._name):
+                raise IOError("%s exists and is not a file" % self._name)
+
+            if os.path.getsize(self._name) == 0:
+                return self
+
+            with open(self._name, 'rb') as _in:  # binary mode
+                self.set_records(pickle.load(_in))
+        else:
+            mkpath(os.path.dirname(self._name))
+            self.commit()
+
+        return self
+
+    def commit(self) -> 'KeyValueDb':
+        """ Write the database to a file... """
+        with open(self._name, 'wb') as out:
+            pickle_protocol = 2  # use 2 for BC with Ulauncher 4
+            pickle.dump(self._records, out, pickle_protocol)
+            out.close()
+
+        return self
+
+    def remove(self, key: Key) -> bool:
+        """
+            :param str key:
+            :type: bool
+            :return: True if record was removed
+        """
+        try:
+            del self._records[key]
+            return True
+        except KeyError:
+            return False
+
+    def set_records(self, records: Records):
+        self._records = records
+
+    def get_records(self) -> Records:
+        return self._records
+
+    def put(self, key: Key, value: Value) -> None:
+        self._records[key] = value
+
+    def find(self, key: Key, default: Value = None) -> Optional[Value]:
+        return self._records.get(key, default)

src/core/desktop_parsing/db/KeyValueJsonDb.py

@@ -0,0 +1,42 @@
+# Python imports
+import os
+import json
+from distutils.dir_util import mkpath
+
+# Lib imports
+
+
+# Application imports
+from .KeyValueDb import KeyValueDb, Key, Value
+
+
+class KeyValueJsonDb(KeyValueDb[Key, Value]):
+    """
+        Key-value JSON database
+        Use open() method to load DB from a file and commit() to save it
+    """
+
+    def open(self) -> 'KeyValueJsonDb':
+        """Create a new data base or open existing one"""
+        if os.path.exists(self._name):
+            if not os.path.isfile(self._name):
+                raise IOError("%s exists and is not a file" % self._name)
+
+            try:
+                with open(self._name, 'r') as _in:
+                    self.set_records(json.load(_in))
+            except json.JSONDecodeError:
+                self.commit()
+        else:
+            mkpath(os.path.dirname(self._name))
+            self.commit()
+
+        return self
+
+    def commit(self) -> 'KeyValueJsonDb':
+        """ Write the database to a file... """
+        with open(self._name, 'w') as out:
+            json.dump(self._records, out, indent=4)
+            out.close()
+
+        return self

src/core/desktop_parsing/file_finder.py

@@ -0,0 +1,21 @@
+# Python imports
+import os
+from fnmatch import fnmatch
+from typing import Callable, Generator
+
+# Lib imports
+
+
+# Application imports
+
+
+def find_files(directory: str, pattern: str = None, filter_fn: Callable = None) -> Generator[str, None, None]:
+    """
+        Search files in `directory`
+        `filter_fn` takes two arguments: directory, filename.
+        If return value is False, file will be ignored
+    """
+    for root, _, files in os.walk(directory):
+        for basename in files:
+            if (not pattern or fnmatch(basename, pattern)) and (not filter_fn or filter_fn(root, basename)):
+                yield os.path.join(root, basename)

src/core/mixins/__init__.py

@@ -0,0 +1,3 @@
+"""
+    Generic Mixins Module
+"""

src/core/window.py

@@ -0,0 +1,88 @@
+# Python imports
+import time
+import signal
+
+# Lib imports
+import gi
+import cairo
+
+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 core.controller import Controller
+
+
+
+
+class Window(Gtk.ApplicationWindow):
+    """docstring for Window."""
+
+    def __init__(self, args, unknownargs):
+        super(Window, self).__init__()
+
+        self._set_window_data()
+        self._setup_styling()
+        self._setup_signals()
+        self._load_widgets(args, unknownargs)
+
+        self.show_all()
+
+
+    def _setup_styling(self):
+        self.set_decorated(False)
+        self.set_skip_pager_hint(True)
+        self.set_skip_taskbar_hint(True)
+
+        self.set_keep_above(True)
+        self.stick()
+
+        self.set_default_size(1200, 600)
+        self.set_title(f"{app_name}")
+        self.set_icon_from_file( settings.get_window_icon() )
+        self.set_gravity(5)  # 5 = CENTER
+        self.set_position(1) # 1 = CENTER, 4 = CENTER_ALWAYS
+
+    def _setup_signals(self):
+        self.connect("delete-event", self._tear_down)
+        GLib.unix_signal_add(GLib.PRIORITY_DEFAULT, signal.SIGINT, self._tear_down)
+
+    def _load_widgets(self, args, unknownargs):
+        controller = Controller(args, unknownargs)
+
+        self.set_name(f"{app_name.lower()}")
+        settings.get_builder().expose_object(f"{app_name.lower()}", self)
+
+        self.add( controller.get_core_widget() )
+
+    def _set_window_data(self) -> None:
+        screen = self.get_screen()
+        visual = screen.get_rgba_visual()
+
+        if visual != None and screen.is_composited():
+            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.get_css_file() )
+        screen       = Gdk.Screen.get_default()
+        styleContext = Gtk.StyleContext()
+        styleContext.add_provider_for_screen(screen, cssProvider, Gtk.STYLE_PROVIDER_PRIORITY_USER)
+
+    def _area_draw(self, widget: Gtk.ApplicationWindow, cr: cairo.Context) -> None:
+        cr.set_source_rgba(0, 0, 0, 0.54)
+        cr.set_operator(cairo.OPERATOR_SOURCE)
+        cr.paint()
+        cr.set_operator(cairo.OPERATOR_OVER)
+
+
+    def _tear_down(self, widget=None, eve=None):
+        settings.clear_pid()
+        time.sleep(event_sleep_time)
+        Gtk.main_quit()