VertexEngine 1.2rc4__4-py3-none-any.whl

VertexEngine/AdvancedVWidgets/ChekBox.py

@@ -0,0 +1,8 @@
+from PyQt6.QtWidgets import QCheckBox
+class VCheckBox(QCheckBox):
+    def __init__(self, text=""):
+        super().__init__(text)
+
+    def on_toggle(self, callback):
+        self.stateChanged.connect(callback)
+        return self

VertexEngine/AdvancedVWidgets/Dropdown.py

@@ -0,0 +1,12 @@
+from PyQt6.QtWidgets import QComboBox
+
+class VDropdown(QComboBox):
+    def __init__(self, items=None):
+        super().__init__()
+
+        if items:
+            self.addItems(items)
+
+    def on_select(self, callback):
+        self.currentTextChanged.connect(callback)
+        return self

VertexEngine/AdvancedVWidgets/List.py

@@ -0,0 +1,12 @@
+from PyQt6.QtWidgets import QListWidget
+
+class VList(QListWidget):
+    def __init__(self, items=None):
+        super().__init__()
+
+        if items:
+            self.addItems(items)
+
+    def on_click(self, callback):
+        self.itemClicked.connect(callback)
+        return self

VertexEngine/AdvancedVWidgets/WindowMods.py

@@ -0,0 +1,71 @@
+from PyQt6.QtWidgets import (
+    QTreeWidget, QTreeWidgetItem,
+    QTableWidget, QTableWidgetItem,
+    QSplitter,
+    QScrollArea,
+    QDockWidget,
+    QGraphicsView, QGraphicsScene,
+)
+from PyQt6.QtGui import QKeySequence, QShortcut
+from PyQt6.QtCore import Qt, QThread, pyqtSignal, QSettings
+from PyQt6.QtWebEngineWidgets import QWebEngineView
+
+class VTree(QTreeWidget):
+    def __init__(self, headers=["Name"]):
+        super().__init__()
+        self.setHeaderLabels(headers)
+
+    def add_item(self, text):
+        item = QTreeWidgetItem([text])
+        self.addTopLevelItem(item)
+        return item
+
+class VTable(QTableWidget):
+    def __init__(self, rows=0, cols=0):
+        super().__init__(rows, cols)
+
+    def set_cell(self, row, col, text):
+        self.setItem(row, col, QTableWidgetItem(str(text)))
+
+class VSplitter(QSplitter):
+    def __init__(self, orientation="horizontal"):
+        orient = Qt.Orientation.Horizontal if orientation == "horizontal" else Qt.Orientation.Vertical
+        super().__init__(orient)
+
+    def add(self, widget):
+        self.addWidget(widget)
+
+class VScroll(QScrollArea):
+    def __init__(self, widget=None):
+        super().__init__()
+
+        if widget:
+            self.setWidget(widget)
+
+        self.setWidgetResizable(True)
+
+class VDock(QDockWidget):
+    def __init__(self, title="Dock"):
+        super().__init__(title)
+
+    def set(self, widget):
+        self.setWidget(widget)
+
+
+class VThread(QThread):
+    finished = pyqtSignal(str)
+
+    def run(self):
+        import time
+        time.sleep(2)
+        self.finished.emit("Thread Complete!")
+
+class VSettings(QSettings):
+    def __init__(self, organization="VertexEngine", name="App"):
+        super().__init__(organization, name)
+
+    def save(self, key, value):
+        self.setValue(key, value)
+
+    def load(self, key, default=None):
+        return self.value(key, default)

VertexEngine/AdvancedVWidgets/Windows.py

@@ -0,0 +1,66 @@
+from PyQt6.QtWidgets import QMessageBox, QFileDialog, QSlider, QProgressBar, QSpinBox, QToolBar
+from PyQt6.QtCore import Qt
+from PyQt6.QtGui import QAction
+class VPopup:
+    @staticmethod
+    def info(text, title="Info"):
+        QMessageBox.information(None, title, text)
+    
+    @staticmethod
+    def error(text, title="Error"):
+        QMessageBox.critical(None, title, text)
+
+class VFilePicker:
+    @staticmethod
+    def open_file():
+        file, _ = QFileDialog.getOpenFileName(None, "Open File")
+        return file
+
+    @staticmethod
+    def save_file():
+        file, _ = QFileDialog.getSaveFileName(None, "Save File")
+        return file 
+
+class VSlider(QSlider):
+    def __init__(self, min=0, max=100):
+        super().__init__(Qt.Orientation.Horizontal)
+
+        self.setMinimum(min)
+        self.setMaximum(max)
+
+    def on_change(self, callback):
+        self.valueChanged.connect(callback)
+        return self
+
+class VProgress(QProgressBar):
+    def __init__(self):
+        super().__init__()
+        self.setValue(0)
+
+    def set(self, value):
+        self.setValue(value)
+
+class VSpinBox(QSpinBox):
+    def __init__(self, min=0, max=100):
+        super().__init__()
+        self.setRange(min, max)
+
+    def on_change(self, callback):
+        self.valueChanged.connect(callback)
+        return self
+
+class VToolBar(QToolBar):
+    def __init__(self, name="Toolbar"):
+        super().__init__(name)
+
+    def add_button(self, text, callback):
+        action = VertexAction(text, self)
+        action.triggered.connect(callback)
+        self.addAction(action)
+
+class VertexAction(QAction):
+    def __init__(self, text, callback=None):
+        super().__init__(text)
+
+        if callback:
+            self.triggered.connect(callback)

VertexEngine/InputSystem/BtnInputs.py

@@ -0,0 +1,63 @@
+from PyQt6.QtCore import Qt
+
+
+class Mouse:
+    _map = {
+        "left": Qt.MouseButton.LeftButton,
+        "right": Qt.MouseButton.RightButton,
+        "middle": Qt.MouseButton.MiddleButton,
+        "x1": Qt.MouseButton.BackButton,
+        "x2": Qt.MouseButton.ForwardButton,
+    }
+
+    @staticmethod
+    def resolve(btn):
+        if isinstance(btn, str):
+            btn = Mouse._map.get(btn.lower())
+            if btn is None:
+                raise KeyError(f"Unknown mouse button: {btn}")
+        return btn
+
+
+class MouseEvents:
+    def __init__(self):
+        self.current = set()
+        self.last = set()
+
+        self.on_press_events = {}
+        self.on_release_events = {}
+        self.on_hold_events = {}
+
+    def update_from_qt(self, qt_buttons):
+        self.current.clear()
+        for btn in Mouse._map.values():
+            if qt_buttons & btn:
+                self.current.add(btn)
+
+    def update(self):
+        for btn in self.current - self.last:
+            for f in self.on_press_events.get(btn, []):
+                f()
+
+        for btn in self.last - self.current:
+            for f in self.on_release_events.get(btn, []):
+                f()
+
+        for btn in self.current:
+            for f in self.on_hold_events.get(btn, []):
+                f()
+
+        self.last = self.current.copy()
+
+    def on_press(self, btn, func):
+        self.on_press_events.setdefault(Mouse.resolve(btn), []).append(func)
+
+    def on_release(self, btn, func):
+        self.on_release_events.setdefault(Mouse.resolve(btn), []).append(func)
+
+    def on_hold(self, btn, func):
+        self.on_hold_events.setdefault(Mouse.resolve(btn), []).append(func)
+
+    def clear(self):
+        self.current.clear()
+        self.last.clear()

VertexEngine/InputSystem/Events.py

@@ -0,0 +1,73 @@
+from PyQt6.QtCore import QTimer, QObject, QEvent
+
+
+class ButtonEvents:
+    def __init__(self):
+        self._timers = {}
+        self._filters = {}
+
+    def on_click(self, button, action, *args, **kwargs):
+        button.clicked.connect(lambda: action(*args, **kwargs))
+
+    def on_double_click(self, button, action, interval=250):
+        timer = QTimer(button)
+        timer.setSingleShot(True)
+        self._timers[(button, "double")] = timer
+
+        def handler():
+            if timer.isActive():
+                timer.stop()
+                action()
+            else:
+                timer.start(interval)
+
+        button.clicked.connect(handler)
+
+    def on_long_press(self, button, action, duration=600):
+        timer = QTimer(button)
+        timer.setSingleShot(True)
+        timer.timeout.connect(action)
+        self._timers[(button, "long")] = timer
+
+        button.pressed.connect(lambda: timer.start(duration))
+        button.released.connect(timer.stop)
+
+    def on_click_debounced(self, button, action, cooldown=500):
+        timer = QTimer(button)
+        timer.setSingleShot(True)
+        self._timers[(button, "debounce")] = timer
+
+        def handler():
+            if not timer.isActive():
+                action()
+                timer.start(cooldown)
+
+        button.clicked.connect(handler)
+
+    def on_toggle(self, button, on_action, off_action=None):
+        button.setCheckable(True)
+
+        def handler(checked):
+            on_action() if checked else off_action and off_action()
+
+        button.toggled.connect(handler)
+
+    def on_click_once(self, button, action):
+        def wrapper():
+            action()
+            button.clicked.disconnect(wrapper)
+
+        button.clicked.connect(wrapper)
+
+    def on_hover(self, button, enter_action=None, leave_action=None):
+        class HoverFilter(QObject):
+            def eventFilter(self, obj, event):
+                if event.type() == QEvent.Type.Enter and enter_action:
+                    enter_action()
+                elif event.type() == QEvent.Type.Leave and leave_action:
+                    leave_action()
+                return False
+
+        filt = HoverFilter(button)
+        self._filters[button] = filt
+        button.installEventFilter(filt)

VertexEngine/InputSystem/KeyInputs.py

@@ -0,0 +1,64 @@
+from PyQt6.QtCore import Qt
+from PyQt6.QtGui import QShortcut, QKeySequence
+KEY_MAP = {
+    # Arrows
+    "left": Qt.Key.Key_Left,
+    "right": Qt.Key.Key_Right,
+    "up": Qt.Key.Key_Up,
+    "down": Qt.Key.Key_Down,
+
+    # Actions
+    "space": Qt.Key.Key_Space,
+    "enter": Qt.Key.Key_Return,
+    "escape": Qt.Key.Key_Escape,
+    "tab": Qt.Key.Key_Tab,
+    "shift": Qt.Key.Key_Shift,
+    "ctrl": Qt.Key.Key_Control,
+    "alt": Qt.Key.Key_Alt,
+}
+
+# Letters
+for c in "abcdefghijklmnopqrstuvwxyz":
+    KEY_MAP[c] = getattr(Qt.Key, f"Key_{c.upper()}")
+
+class Input:
+    _pressed = set()
+    _just_pressed = set()
+    _just_released = set()
+
+    @classmethod
+    def input_update(cls):
+        cls._just_pressed.clear()
+        cls._just_released.clear()
+
+    @classmethod
+    def key_down(cls, key):
+        qt_key = KEY_MAP.get(key, key)
+        if qt_key not in cls._pressed:
+            cls._just_pressed.add(qt_key)
+        cls._pressed.add(qt_key)
+
+    @classmethod
+    def key_up(cls, key):
+        qt_key = KEY_MAP.get(key, key)
+        if qt_key in cls._pressed:
+            cls._just_released.add(qt_key)
+        cls._pressed.discard(qt_key)
+
+    # === Public API ===
+    @classmethod
+    def is_pressed(cls, key):
+        return KEY_MAP[key] in cls._pressed
+
+    @classmethod
+    def is_just_pressed(cls, key):
+        return KEY_MAP[key] in cls._just_pressed
+
+    @classmethod
+    def is_released(cls, key):
+        return KEY_MAP[key] in cls._just_released
+
+    class VShortcut(QShortcut):
+        def __init__(self, key, parent, callback):
+            super().__init__(QKeySequence(key), parent)
+            self.activated.connect(callback)

VertexEngine/SimpleGUI.py

@@ -0,0 +1,142 @@
+from PyQt6.QtWidgets import QPushButton, QLineEdit
+from PyQt6.QtGui import QFont
+from PyQt6.QtWidgets import QPushButton
+from PyQt6.QtGui import QCursor
+from PyQt6.QtCore import Qt
+from PyQt6.QtWidgets import QLabel
+
+class LegacyButton(QPushButton):
+    def __init__(
+        self,
+        text="Button",
+        width=120,
+        height=40,
+        text_color="white",
+        border_color="#FFFFFF",
+        border_width=2,
+        font_name="Arial",
+        font_weight=QFont.Weight.Bold,
+        parent=None
+    ):
+        super().__init__(text, parent)
+        # Store params
+        self.bg_color = '#000000'
+        self.hover_color = '#222222'
+        self.text_color = text_color
+        self.border_radius = 10
+        self.border_color = border_color
+        self.border_width = border_width
+        self.setFont(QFont(font_name, 12, font_weight))
+        self.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
+        self.setMinimumSize(width, height)
+        # Apply default style
+        self.setStyleSheet(self.default_style())
+
+    def enterEvent(self, event):
+        self.setStyleSheet(self.hover_style())
+        super().enterEvent(event)
+
+    def leaveEvent(self, event):
+        self.setStyleSheet(self.default_style())
+        super().leaveEvent(event)
+
+    def default_style(self):
+        return f"""
+            QPushButton {{
+                background-color: {self.bg_color};
+                color: {self.text_color};
+                border-radius: {self.border_radius}px;
+                border: {self.border_width}px solid {self.border_color};
+            }}
+        """
+    
+    def hover_style(self):
+        return f"""
+            QPushButton {{
+                background-color: {self.hover_color};
+                color: {self.text_color};
+                border-radius: {self.border_radius}px;
+                border: {self.border_width}px solid {self.border_color};
+            }}
+        """
+class Text(QLabel):
+    def __init__(
+        self,
+        text="Text",
+        font_size=14,
+        text_color="#FFFFFF",
+        bg_color=None,
+        padding=8,
+        border_radius=8,
+        parent=None
+    ):
+        super().__init__(text, parent)
+        self.setFont(QFont('Arial', font_size, QFont.Weight.Normal))
+        self.setAlignment(QFont.Weight.Normal)
+        bg = "transparent" if bg_color is None else bg_color
+        self.setStyleSheet(f"""
+            QLabel {{
+                color: {text_color};
+                background-color: {bg};
+                padding: {padding}px;
+                border-radius: {border_radius}px;
+            }}
+        """)
+
+    def set_text(self, text):
+        self.setText(text)
+
+    def set_color(self, color):
+        self.setStyleSheet(self.styleSheet() + f"color: {color};")
+
+class InputField(QLineEdit):
+    def __init__(
+        self,
+        placeholder="Enter text...",
+        width=240,
+        height=36,
+        font_size=12,
+        focus_color="#00E5FF",
+        border_radius=8,
+        padding=8,
+        parent=None
+    ):
+        super().__init__(parent)
+        self.setPlaceholderText(placeholder)
+        self.setFont(QFont('Arial', font_size))
+        self.setMinimumSize(width, height)
+        self.text_color = "#FFFFFF"
+        self.bg_color = '#1E1E1E'
+        self.border_color = '#555555'
+        self.focus_color = focus_color
+        self.border_radius = border_radius
+        self.padding = padding
+        self.apply_style(focused=False)
+
+    def apply_style(self, focused=False):
+        border = self.focus_color if focused else self.border_color
+        self.setStyleSheet(f"""
+            QLineEdit {{
+                color: {self.text_color};
+                background-color: {self.bg_color};
+                border: 2px solid {border};
+                border-radius: {self.border_radius}px;
+                padding: {self.padding}px;
+            }}
+            QLineEdit::placeholder {{
+                color: #888888;
+            }}
+        """)
+
+    def focusInEvent(self, event):
+        self.apply_style(focused=True)
+        super().focusInEvent(event)
+
+    def focusOutEvent(self, event):
+        self.apply_style(focused=False)
+        super().focusOutEvent(event)
+
+    def get_value(self):
+        return self.text()
+    def set_value(self, value):
+        self.setText(value)