PrEditor 1.0.0__py3-none-any.whl

preditor/gui/fuzzy_search/fuzzy_search.py

@@ -0,0 +1,93 @@
+from __future__ import absolute_import
+
+from functools import partial
+
+from Qt.QtCore import QModelIndex, QPoint, Qt, Signal
+from Qt.QtWidgets import QFrame, QLineEdit, QListView, QShortcut, QVBoxLayout
+
+from ..group_tab_widget.grouped_tab_models import GroupTabFuzzyFilterProxyModel
+
+
+class FuzzySearch(QFrame):
+    canceled = Signal("QModelIndex")
+    """Passes the original QModelIndex for the tab that was selected when the
+    widget was first shown. This lets you reset back to the orignal state."""
+    highlighted = Signal("QModelIndex")
+    """Emitted when the user navitages to the given index, but hasn't selected."""
+    selected = Signal("QModelIndex")
+    """Emitted when the user selects a item."""
+
+    def __init__(self, model, parent=None, **kwargs):
+        super(FuzzySearch, self).__init__(parent=parent, **kwargs)
+        self.y_offset = 100
+        self.setMinimumSize(400, 200)
+        self.uiCloseSCT = QShortcut(
+            Qt.Key_Escape, self, context=Qt.WidgetWithChildrenShortcut
+        )
+        self.uiCloseSCT.activated.connect(self._canceled)
+
+        self.uiUpSCT = QShortcut(Qt.Key_Up, self, context=Qt.WidgetWithChildrenShortcut)
+        self.uiUpSCT.activated.connect(partial(self.increment_selection, -1))
+        self.uiDownSCT = QShortcut(
+            Qt.Key_Down, self, context=Qt.WidgetWithChildrenShortcut
+        )
+        self.uiDownSCT.activated.connect(partial(self.increment_selection, 1))
+
+        lyt = QVBoxLayout(self)
+        self.uiLineEDIT = QLineEdit(parent=self)
+        self.uiLineEDIT.textChanged.connect(self.update_completer)
+        self.uiLineEDIT.returnPressed.connect(self.activated)
+        lyt.addWidget(self.uiLineEDIT)
+        self.uiResultsLIST = QListView(self)
+        self.uiResultsLIST.activated.connect(self.activated)
+        self.proxy_model = GroupTabFuzzyFilterProxyModel(self)
+        self.proxy_model.setSourceModel(model)
+        self.uiResultsLIST.setModel(self.proxy_model)
+        lyt.addWidget(self.uiResultsLIST)
+
+        self.original_model_index = model.original_model_index
+
+    def activated(self):
+        current = self.uiResultsLIST.currentIndex()
+        self.selected.emit(current)
+        self.hide()
+
+    def increment_selection(self, direction):
+        current = self.uiResultsLIST.currentIndex()
+        col = 0
+        row = 0
+        if current.isValid():
+            col = current.column()
+            row = current.row() + direction
+        new = self.uiResultsLIST.model().index(row, col)
+        self.uiResultsLIST.setCurrentIndex(new)
+        self.highlighted.emit(new)
+
+    def update_completer(self, wildcard):
+        if wildcard:
+            if not self.uiResultsLIST.currentIndex().isValid():
+                new = self.uiResultsLIST.model().index(0, 0)
+                self.uiResultsLIST.setCurrentIndex(new)
+        else:
+            self.uiResultsLIST.clearSelection()
+            self.uiResultsLIST.setCurrentIndex(QModelIndex())
+        self.proxy_model.setFuzzySearch(wildcard)
+        self.highlighted.emit(self.uiResultsLIST.currentIndex())
+
+    def _canceled(self):
+        # Restore the original tab as the user didn't choose the new tab
+        self.canceled.emit(self.original_model_index)
+        self.hide()
+
+    def reposition(self):
+        pgeo = self.parent().geometry()
+        geo = self.geometry()
+        center = QPoint(pgeo.width() // 2, 0)
+        geo.moveCenter(center)
+        geo.setY(self.y_offset)
+        self.setGeometry(geo)
+
+    def popup(self):
+        self.show()
+        self.reposition()
+        self.uiLineEDIT.setFocus(Qt.PopupFocusReason)

preditor/gui/group_tab_widget/__init__.py

@@ -0,0 +1,325 @@
+from __future__ import absolute_import
+
+import os
+import re
+
+from Qt.QtCore import Qt
+from Qt.QtGui import QIcon
+from Qt.QtWidgets import QHBoxLayout, QMessageBox, QToolButton, QWidget
+
+from ... import resourcePath
+from ...prefs import prefs_path
+from ..drag_tab_bar import DragTabBar
+from ..workbox_text_edit import WorkboxTextEdit
+from .grouped_tab_menu import GroupTabMenu
+from .grouped_tab_widget import GroupedTabWidget
+from .one_tab_widget import OneTabWidget
+
+DEFAULT_STYLE_SHEET = """
+/* Make the two buttons in the GroupTabWidget take up the
+   same horizontal space as the GroupedTabWidget's buttons. */
+GroupTabWidget>QTabBar::tab{
+    max-height: 1.5em;
+}
+/* We have an icon, no need to show the menu indicator */
+#group_tab_widget_menu_btn::menu-indicator{
+    width: 0px;
+}
+/* The GroupedTabWidget has a single button, make it take
+   the same space as the GroupTabWidget buttons. */
+GroupedTabWidget>QToolButton,GroupTabWidget>QWidget{
+    width: 3em;
+}
+"""
+
+
+class GroupTabWidget(OneTabWidget):
+    """A QTabWidget where each tab contains another tab widget, allowing users
+    to group code editors. It has a corner button to add a new tab, and a menu
+    allowing users to quickly focus on any tab in the entire group.
+    """
+
+    def __init__(self, editor_kwargs=None, core_name=None, *args, **kwargs):
+        super(GroupTabWidget, self).__init__(*args, **kwargs)
+        DragTabBar.install_tab_widget(self, 'group_tab_widget')
+        self.editor_kwargs = editor_kwargs
+        self.editor_cls = WorkboxTextEdit
+        self.core_name = core_name
+        self.setStyleSheet(DEFAULT_STYLE_SHEET)
+        corner = QWidget(self)
+        lyt = QHBoxLayout(corner)
+        lyt.setSpacing(0)
+        lyt.setContentsMargins(0, 0, 0, 0)
+
+        corner.uiNewTabBTN = QToolButton(corner)
+        corner.uiNewTabBTN.setObjectName('group_tab_widget_new_btn')
+        corner.uiNewTabBTN.setText('+')
+        corner.uiNewTabBTN.setIcon(QIcon(resourcePath('img/file-plus.png')))
+        corner.uiNewTabBTN.released.connect(lambda: self.add_new_tab(None))
+        lyt.addWidget(corner.uiNewTabBTN)
+
+        corner.uiMenuBTN = QToolButton(corner)
+        corner.uiMenuBTN.setIcon(QIcon(resourcePath('img/chevron-down.png')))
+        corner.uiMenuBTN.setObjectName('group_tab_widget_menu_btn')
+        corner.uiMenuBTN.setPopupMode(QToolButton.InstantPopup)
+        corner.uiCornerMENU = GroupTabMenu(self, parent=corner.uiMenuBTN)
+        corner.uiMenuBTN.setMenu(corner.uiCornerMENU)
+        lyt.addWidget(corner.uiMenuBTN)
+
+        self.uiCornerBTN = corner
+        self.setCornerWidget(self.uiCornerBTN, Qt.TopRightCorner)
+
+    def add_new_tab(self, group, title="Workbox", group_fmt=None):
+        """Adds a new tab to the requested group, creating the group if the group
+        doesn't exist.
+
+        Args:
+            group: The group to add a new tab to. This can be an int index of an
+                existing tab, or the name of the group and it will create the group
+                if needed. If None is passed it will add a new tab `Group {last+1}`.
+                If True is passed, then the current group tab is used.
+            title (str, optional): The name to give the newly created tab inside
+                the group.
+            group_fmt(str, optional): If None is passed to group, this string is
+                used to search for existing tabs to calculate the last number
+                and generate the new group tab name.
+
+        Returns:
+            GroupedTabWidget: The tab group for this group.
+            WorkboxMixin: The new text editor.
+        """
+        parent = None
+        if not group:
+            if group_fmt is None:
+                group_fmt = r'Group {}'
+            last = 0
+            for i in range(self.count()):
+                match = re.match(group_fmt.format(r'(\d+)'), self.tabText(i))
+                if match:
+                    last = max(last, int(match.group(1)))
+            group = group_fmt.format(last + 1)
+        elif group is True:
+            group = self.currentIndex()
+        if isinstance(group, int):
+            group_title = self.tabText(group)
+            parent = self.widget(group)
+        elif isinstance(group, str):
+            group_title = group
+            index = self.index_for_text(group)
+            if index != -1:
+                parent = self.widget(index)
+
+        if not parent:
+            parent, group_title = self.default_tab(group_title)
+            self.addTab(parent, group_title)
+
+        # Create the first editor tab and make it visible
+        editor = parent.add_new_editor(title)
+        self.setCurrentIndex(self.indexOf(parent))
+        self.window().focusToWorkbox()
+        return parent, editor
+
+    def all_widgets(self):
+        """A generator yielding information about every widget under every group.
+
+        Yields:
+            widget, group tab name, widget tab name, group tab index, widget tab index
+        """
+        for group_index in range(self.count()):
+            group_name = self.tabText(group_index)
+
+            tab_widget = self.widget(group_index)
+            for tab_index in range(tab_widget.count()):
+                tab_name = tab_widget.tabText(tab_index)
+                yield tab_widget.widget(
+                    tab_index
+                ), group_name, tab_name, group_index, tab_index
+
+    def close_current_tab(self):
+        """Convenient method to close the currently open editor tab prompting
+        the user to confirm closing."""
+        editor_tab = self.currentWidget()
+        editor_tab.close_tab(editor_tab.currentIndex())
+
+    def close_tab(self, index):
+        ret = QMessageBox.question(
+            self,
+            'Close all editors under this tab?',
+            'Are you sure you want to close all tabs under the "{}" tab?'.format(
+                self.tabText(self.currentIndex())
+            ),
+            QMessageBox.Yes | QMessageBox.Cancel,
+        )
+        if ret == QMessageBox.Yes:
+            # Clean up all temp files created by this group's editors if they
+            # are not using actual saved files.
+            tab_widget = self.widget(self.currentIndex())
+            for index in range(tab_widget.count()):
+                editor = tab_widget.widget(index)
+                editor.__remove_tempfile__()
+
+            super(GroupTabWidget, self).close_tab(self.currentIndex())
+
+    def current_groups_widget(self):
+        """Returns the current widget of the currently selected group or None."""
+        editor_tab = self.currentWidget()
+        if editor_tab:
+            return editor_tab.currentWidget()
+
+    def default_tab(self, title='Group 1'):
+        widget = GroupedTabWidget(
+            parent=self,
+            editor_kwargs=self.editor_kwargs,
+            editor_cls=self.editor_cls,
+            core_name=self.core_name,
+        )
+        return widget, title
+
+    def restore_prefs(self, prefs):
+        """Adds tab groups and tabs, restoring the selected tabs. If a tab is
+        linked to a file that no longer exists, will not be added. Restores the
+        current tab for each group and the current group of tabs. If a current
+        tab is no longer valid, it will default to the first tab.
+
+        Preference schema:
+        ```json
+        {
+            "groups": [
+                {
+                    // Name of the group tab. [Required]
+                    "name": "My Group",
+                    // This group should be the active group. First in list wins.
+                    "current": true,
+                    "tabs": [
+                        {
+                            // If filename is not null, this file is loaded
+                            "filename": "C:\\temp\\invalid_asdfdfd.py",
+                            // Name of the editor's tab [Optional]
+                            "name": "invalid_asdfdfd.py",
+                            "tempfile": null
+                        },
+                        {
+                            // This tab should be active for the group.
+                            "current": true,
+                            "filename": null,
+                            "name": "Workbox",
+                            // If tempfile is not null, this file is loaded.
+                            // Ignored if filename is not null.
+                            "tempfile": "workbox_2yrwctco_a.py"
+                        }
+                    ]
+                }
+            ]
+        }
+        ```
+        """
+
+        self.clear()
+
+        workbox_dir = prefs_path('workboxes', core_name=self.core_name)
+        current_group = None
+        for group in prefs.get('groups', []):
+            current_tab = None
+            group_name = group['name']
+            tab_widget = None
+
+            for tab in group.get('tabs', []):
+                # Only add this tab if, there is data on disk to load. The user can
+                # open multiple instances of PrEditor using the same prefs. The
+                # json pref data represents the last time the prefs were saved.
+                # Each editor's contents are saved to individual files on disk.
+                # When a editor tab is closed, the temp file is removed, not on
+                # preferences save.
+                # By not restoring tabs for deleted files we prevent accidentally
+                # restoring a tab with empty text.
+                filename = tab.get('filename')
+                temp_name = tab.get('tempfile')
+                if filename:
+                    if not os.path.exists(filename):
+                        continue
+                if not temp_name:
+                    continue
+                temp_name = os.path.join(workbox_dir, temp_name)
+                if not os.path.exists(temp_name):
+                    continue
+
+                # There is a file on disk, add the tab, creating the group
+                # tab if it hasn't already been created.
+                name = tab['name']
+                tab_widget, editor = self.add_new_tab(group_name, name)
+                editor.__restore_prefs__(tab)
+
+                # If more than one tab in this group is listed as current, only
+                # respect the first
+                if current_tab is None and tab.get('current'):
+                    current_tab = tab_widget.indexOf(editor)
+
+            # If there were no files to load, this tab was not added and there
+            # we don't need to restore the current tab for this group
+            if tab_widget is None:
+                continue
+
+            # Restore the current tab for this group
+            if current_tab is None:
+                # If there is no longer a current tab, default to the first tab
+                current_tab = 0
+            tab_widget.setCurrentIndex(current_tab)
+
+            # Which tab group is the active one? If more than one tab in this
+            # group is listed as current, only respect the first.
+            if current_group is None and group.get('current'):
+                current_group = self.indexOf(tab_widget)
+
+        # Restore the current group for this widget
+        if current_group is None:
+            # If there is no longer a current tab, default to the first tab
+            current_group = 0
+        self.setCurrentIndex(current_group)
+
+    def save_prefs(self, prefs=None):
+        groups = []
+        if prefs is None:
+            prefs = {}
+
+        prefs['groups'] = groups
+        current_group = self.currentIndex()
+        for i in range(self.count()):
+            tabs = []
+            group = {}
+            # Hopefully the alphabetical sorting of this dict is preserved in py3
+            # to make it easy to diff the json pref file if ever required.
+            if i == current_group:
+                group['current'] = True
+            group['name'] = self.tabText(i)
+            group['tabs'] = tabs
+
+            tab_widget = self.widget(i)
+            current_editor = tab_widget.currentIndex()
+            for j in range(tab_widget.count()):
+                current = True if j == current_editor else None
+                tabs.append(
+                    tab_widget.widget(j).__save_prefs__(
+                        name=tab_widget.tabText(j), current=current
+                    )
+                )
+
+            groups.append(group)
+
+        return prefs
+
+    def set_current_groups_from_index(self, group, editor):
+        """Make the specified indexes the current widget and return it. If the
+        indexes are out of range the current widget is not changed.
+
+        Args:
+            group (int): The index of the group tab to make current.
+            editor (int): The index of the editor under the group tab to
+                make current.
+
+        Returns:
+            QWidget: The current widget after applying.
+        """
+        self.setCurrentIndex(group)
+        tab_widget = self.currentWidget()
+        tab_widget.setCurrentIndex(editor)
+        return tab_widget.currentWidget()

preditor/gui/group_tab_widget/grouped_tab_menu.py

@@ -0,0 +1,35 @@
+from __future__ import absolute_import
+
+from preditor.gui.level_buttons import LazyMenu
+
+
+class GroupTabMenu(LazyMenu):
+    """A menu listing all tabs of GroupTabWidget and their child GroupedTabWidget
+    tabs. When selecting one of the GroupedTabWidget tab, it will make that tab
+    the current tab and give it focus.
+    """
+
+    def __init__(self, manager, parent=None):
+        super(GroupTabMenu, self).__init__(parent=parent)
+        self.manager = manager
+        self.triggered.connect(self.focus_tab)
+
+    def refresh(self):
+        self.clear()
+        for group in range(self.manager.count()):
+            # Create a "header" for the group tabs
+            self.addSeparator()
+            act = self.addAction(self.manager.tabText(group))
+            act.setEnabled(False)
+            self.addSeparator()
+
+            # Add all of this group tab's tabs
+            tab_widget = self.manager.widget(group)
+            for index in range(tab_widget.count()):
+                act = self.addAction('  {}'.format(tab_widget.tabText(index)))
+                act.setProperty('info', (group, index))
+
+    def focus_tab(self, action):
+        group, editor = action.property('info')
+        widget = self.manager.set_current_groups_from_index(group, editor)
+        widget.setFocus()

preditor/gui/group_tab_widget/grouped_tab_models.py

@@ -0,0 +1,108 @@
+from __future__ import absolute_import
+
+import re
+
+from Qt.QtCore import QSortFilterProxyModel, Qt
+from Qt.QtGui import QStandardItem, QStandardItemModel
+
+
+class GroupTabItemModel(QStandardItemModel):
+    GroupIndexRole = Qt.UserRole + 1
+    TabIndexRole = GroupIndexRole + 1
+
+    def __init__(self, manager, *args, **kwargs):
+        super(GroupTabItemModel, self).__init__(*args, **kwargs)
+        self.manager = manager
+
+    def workbox_indexes_from_model_index(self, index):
+        """Returns the group_index and tab_index for the provided QModelIndex"""
+        return (
+            index.data(self.GroupIndexRole),
+            index.data(self.TabIndexRole),
+        )
+
+    def pathFromIndex(self, index):
+        parts = [""]
+        while index.isValid():
+            parts.append(self.data(index, Qt.DisplayRole))
+            index = index.parent()
+        if len(parts) == 1:
+            return ""
+        return "/".join([x for x in parts[::-1] if x])
+
+
+class GroupTabTreeItemModel(GroupTabItemModel):
+    def process(self):
+        root = self.invisibleRootItem()
+        current_group = self.manager.currentIndex()
+        current_tab = self.manager.currentWidget().currentIndex()
+
+        prev_group = -1
+        all_widgets = self.manager.all_widgets()
+        for _, group_name, tab_name, group_index, tab_index in all_widgets:
+            if prev_group != group_index:
+                group_item = QStandardItem(group_name)
+                group_item.setData(group_index, self.GroupIndexRole)
+                root.appendRow(group_item)
+                prev_group = group_index
+
+            tab_item = QStandardItem(tab_name)
+            tab_item.setData(group_index, self.GroupIndexRole)
+            tab_item.setData(tab_index, self.TabIndexRole)
+            group_item.appendRow(tab_item)
+            if group_index == current_group and tab_index == current_tab:
+                self.original_model_index = self.indexFromItem(tab_item)
+
+
+class GroupTabListItemModel(GroupTabItemModel):
+    def flags(self, index):
+        return Qt.ItemIsEnabled | Qt.ItemIsSelectable
+
+    def process(self):
+        root = self.invisibleRootItem()
+        current_group = self.manager.currentIndex()
+        current_tab = self.manager.currentWidget().currentIndex()
+
+        all_widgets = self.manager.all_widgets()
+        for _, group_name, tab_name, group_index, tab_index in all_widgets:
+            tab_item = QStandardItem('/'.join((group_name, tab_name)))
+            tab_item.setData(group_index, self.GroupIndexRole)
+            tab_item.setData(tab_index, self.TabIndexRole)
+            root.appendRow(tab_item)
+            if group_index == current_group and tab_index == current_tab:
+                self.original_model_index = self.indexFromItem(tab_item)
+
+
+class GroupTabFuzzyFilterProxyModel(QSortFilterProxyModel):
+    """Implements a fuzzy search filter proxy model."""
+
+    def __init__(self, parent=None):
+        super(GroupTabFuzzyFilterProxyModel, self).__init__(parent=parent)
+        self._fuzzy_regex = None
+
+    def setFuzzySearch(self, search):
+        search = '.*'.join(search)
+        # search = '.*{}.*'.format(search)
+        self._fuzzy_regex = re.compile(search, re.I)
+        self.invalidateFilter()
+
+    def filterAcceptsRow(self, sourceRow, sourceParent):
+        if self.filterKeyColumn() == 0 and self._fuzzy_regex:
+
+            index = self.sourceModel().index(sourceRow, 0, sourceParent)
+            data = self.sourceModel().data(index)
+            ret = bool(self._fuzzy_regex.search(data))
+            return ret
+
+        return super(GroupTabFuzzyFilterProxyModel, self).filterAcceptsRow(
+            sourceRow, sourceParent
+        )
+
+    def pathFromIndex(self, index):
+        parts = [""]
+        while index.isValid():
+            parts.append(self.data(index, Qt.DisplayRole))
+            index = index.parent()
+        if len(parts) == 1:
+            return ""
+        return "/".join([x for x in parts[::-1] if x])

preditor/gui/group_tab_widget/grouped_tab_widget.py

@@ -0,0 +1,78 @@
+from __future__ import absolute_import
+
+from Qt.QtCore import Qt
+from Qt.QtGui import QIcon
+from Qt.QtWidgets import QMessageBox, QToolButton
+
+from ... import resourcePath
+from ..drag_tab_bar import DragTabBar
+from ..workbox_text_edit import WorkboxTextEdit
+from .one_tab_widget import OneTabWidget
+
+
+class GroupedTabWidget(OneTabWidget):
+    def __init__(self, editor_kwargs, editor_cls=None, core_name=None, *args, **kwargs):
+        super(GroupedTabWidget, self).__init__(*args, **kwargs)
+        DragTabBar.install_tab_widget(self, 'grouped_tab_widget')
+        self.editor_kwargs = editor_kwargs
+        if editor_cls is None:
+            editor_cls = WorkboxTextEdit
+        self.editor_cls = editor_cls
+        self.core_name = core_name
+        self.currentChanged.connect(self.tab_shown)
+
+        self.uiCornerBTN = QToolButton(self)
+        self.uiCornerBTN.setText('+')
+        self.uiCornerBTN.setIcon(QIcon(resourcePath('img/file-plus.png')))
+        self.uiCornerBTN.released.connect(lambda: self.add_new_editor())
+        self.setCornerWidget(self.uiCornerBTN, Qt.TopRightCorner)
+
+    def add_new_editor(self, title="Workbox"):
+        editor, title = self.default_tab(title)
+        index = self.addTab(editor, title)
+        self.setCurrentIndex(index)
+        return editor
+
+    def addTab(self, *args, **kwargs):  # noqa: N802
+        ret = super(GroupedTabWidget, self).addTab(*args, **kwargs)
+        self.update_closable_tabs()
+        return ret
+
+    def close_tab(self, index):
+        if self.count() == 1:
+            msg = "You have to leave at least one tab open."
+            QMessageBox.critical(self, 'Tab can not be closed.', msg, QMessageBox.Ok)
+            return
+        ret = QMessageBox.question(
+            self,
+            'Donate to the cause?',
+            "Would you like to donate this tabs contents to the /dev/null fund "
+            "for wayward code?",
+            QMessageBox.Yes | QMessageBox.Cancel,
+        )
+        if ret == QMessageBox.Yes:
+            # If the tab was saved to a temp file, remove it from disk
+            editor = self.widget(index)
+            editor.__remove_tempfile__()
+
+            super(GroupedTabWidget, self).close_tab(index)
+
+    def default_tab(self, title='Workbox'):
+        kwargs = self.editor_kwargs if self.editor_kwargs else {}
+        editor = self.editor_cls(parent=self, core_name=self.core_name, **kwargs)
+        return editor, title
+
+    def showEvent(self, event):  # noqa: N802
+        super(GroupedTabWidget, self).showEvent(event)
+        self.tab_shown(self.currentIndex())
+
+    def tab_shown(self, index):
+        editor = self.widget(index)
+        if editor and editor.isVisible():
+            editor.__show__()
+
+        if hasattr(self.window(), "setWorkboxFontBasedOnConsole"):
+            self.window().setWorkboxFontBasedOnConsole()
+
+    def update_closable_tabs(self):
+        self.setTabsClosable(self.count() != 1)

preditor/gui/group_tab_widget/one_tab_widget.py

@@ -0,0 +1,54 @@
+from __future__ import absolute_import
+
+from Qt.QtWidgets import QTabWidget
+
+
+class OneTabWidget(QTabWidget):
+    """A QTabWidget that shows the close button only if there is more than one
+    tab. If something removes the last tab, it will add a default tab if the
+    default_tab method is implemented on a subclass. This is also used to create
+    the first tab on showEvent.
+
+    Subclasses can implement a `default_tab()` method. This should return the
+    widget to add and the title of the tab to create if implemented.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super(OneTabWidget, self).__init__(*args, **kwargs)
+        self.tabCloseRequested.connect(self.close_tab)
+
+    def addTab(self, *args, **kwargs):  # noqa: N802
+        ret = super(OneTabWidget, self).addTab(*args, **kwargs)
+        self.update_closable_tabs()
+        return ret
+
+    def close_tab(self, index):
+        self.removeTab(index)
+        self.update_closable_tabs()
+
+    def index_for_text(self, text):
+        """Return the index of the tab with this text. Returns -1 if not found"""
+        for i in range(self.count()):
+            if self.tabText(i) == text:
+                return i
+        return -1
+
+    def insertTab(self, *args, **kwargs):  # noqa: N802
+        ret = super(OneTabWidget, self).insertTab(*args, **kwargs)
+        self.update_closable_tabs()
+        return ret
+
+    def removeTab(self, index):  # noqa: N802
+        super(OneTabWidget, self).removeTab(index)
+        if hasattr(self, 'default_tab') and not self.count():
+            self.addTab(*self.default_tab())
+        self.update_closable_tabs()
+
+    def showEvent(self, event):  # noqa: N802
+        super(OneTabWidget, self).showEvent(event)
+        # Force the creation of a default tab if defined
+        if hasattr(self, 'default_tab') and not self.count():
+            self.addTab(*self.default_tab())
+
+    def update_closable_tabs(self):
+        self.setTabsClosable(self.count() != 1)