swissclock 0.1.0__py3-none-any.whl

swissclock/__init__.py

@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+# swissclock package

swissclock/base_dial.py

@@ -0,0 +1,94 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+from PySide6.QtCore import QRectF, Qt, QTimer
+from PySide6.QtGui import QColor, QPainter
+from PySide6.QtWidgets import QMenu, QMessageBox, QWidget
+
+
+class BaseDial(QWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        self.timer = QTimer(self)
+        self.timer.timeout.connect(self.update_dial)
+        self.timer.start(30) # Smooth animation
+        
+        self.black_color = QColor(0, 0, 0)
+        self.red_color = QColor(220, 0, 0) # Swiss red
+        self.green_color = QColor(0, 180, 0) # Normal tracking green
+        self.orange_color = QColor(255, 165, 0) # Warning orange
+
+    def update_dial(self):
+        self.update()
+
+    def paintEvent(self, event):
+        side = min(self.width(), self.height())
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.Antialiasing)
+        painter.translate(self.width() / 2, self.height() / 2)
+        painter.scale(side / 240.0, side / 240.0)
+
+        # White background face
+        painter.setPen(Qt.NoPen)
+        painter.setBrush(Qt.white)
+        painter.drawEllipse(-98, -98, 196, 196)
+        
+        self.draw_face(painter)
+        self.draw_hands(painter)
+
+    def draw_face(self, painter):
+        pass
+
+    def draw_hands(self, painter):
+        pass
+
+    def draw_dial(self, painter):
+        # To be implemented by subclasses
+        pass
+
+    def contextMenuEvent(self, event):
+        menu = QMenu(self)
+        about_action = menu.addAction("About")
+        help_action = menu.addAction("Help (Shortcuts)")
+        action = menu.exec(event.globalPos())
+        if action == about_action:
+            self.show_about()
+        elif action == help_action:
+            self.show_help()
+
+    def show_help(self):
+        QMessageBox.information(self, "SwissClock Help",
+            "<h2>Keyboard Shortcuts</h2>"
+            "<ul>"
+            "<li><b>T</b>: Switch between Clock and Stopwatch</li>"
+            "<li><b>Space</b>: Start / Stop / Resume Stopwatch</li>"
+            "<li><b>R</b>: Reset Stopwatch</li>"
+            "<li><b>D</b>: Toggle Digital / Analog mode (in Stopwatch)</li>"
+            "<li><b>F</b>: Toggle Fullscreen mode</li>"
+            "</ul>")
+
+    def show_about(self):
+        QMessageBox.about(self, "About SwissClock",
+            "<h2>Swiss Railway Time</h2>"
+            "<p>A Swiss Railways inspired unified analog clock and morphing digital stopwatch.</p>"
+            "<p><b>Author:</b> Alin Elena &lt;alin@elena.re&gt;</p>"
+            "<p><b>License:</b> GPL-3.0-or-later</p>"
+            "<p><b>Dependencies:</b> PySide6</p>")
+
+    def draw_capsule_hand(self, painter, angle, color, rect_args):
+        painter.save()
+        painter.rotate(angle)
+        painter.setBrush(color)
+        painter.setPen(Qt.NoPen)
+        # rect_args: (x, y, w, h, xRadius, yRadius)
+        painter.drawRoundedRect(*rect_args)
+        painter.restore()
+
+    def draw_swiss_second_hand(self, painter, angle):
+        painter.save()
+        painter.rotate(angle)
+        painter.setBrush(self.red_color)
+        painter.setPen(Qt.NoPen)
+        painter.drawRect(-1, -76, 2, 101)
+        painter.drawEllipse(QRectF(-6, -82, 12, 12))
+        painter.drawEllipse(QRectF(-3, -3, 6, 6))
+        painter.restore()

swissclock/clock.py

@@ -0,0 +1,108 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+import math
+import sys
+
+from PySide6.QtCore import QRectF, Qt, QTime
+from PySide6.QtWidgets import QApplication
+
+from .base_dial import BaseDial
+
+
+class AnalogClock(BaseDial):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Analog Clock")
+        self.resize(300, 300)
+
+    def draw_face(self, painter):
+        # Draw 24 hour markers (thick lines for even, red dots for odd)
+        painter.save()
+        for i in range(24):
+            if i % 2 == 0:
+                painter.setBrush(self.black_color)
+                painter.setPen(Qt.NoPen)
+                painter.drawEllipse(QRectF(83, -4, 8, 8))
+            else:
+                painter.setBrush(self.red_color)
+                painter.setPen(Qt.NoPen)
+                painter.drawEllipse(QRectF(85, -2, 4, 4))
+            painter.rotate(15.0)
+        painter.restore()
+
+        # Draw 60 minute markers (small black circles)
+        painter.save()
+        painter.setBrush(self.black_color)
+        painter.setPen(Qt.NoPen)
+        for i in range(60):
+            painter.drawEllipse(QRectF(85, -2, 4, 4))
+            painter.rotate(6.0)
+        painter.restore()
+
+        # Draw numbers (even inside, odd outside)
+        painter.save()
+        font = painter.font()
+        font.setFamily("Verdana")
+        font.setPointSize(6)
+        font.setBold(True)
+        painter.setFont(font)
+        
+        window_text_color = self.palette().windowText().color()
+        
+        for h in range(1, 25):
+            angle_deg = -90 + h * 15
+            angle_rad = math.radians(angle_deg)
+            if h % 2 == 0:
+                x = 65 * math.cos(angle_rad)
+                y = 65 * math.sin(angle_rad)
+                painter.setPen(self.black_color)
+            else:
+                x = 108 * math.cos(angle_rad)
+                y = 108 * math.sin(angle_rad)
+                painter.setPen(window_text_color)
+            
+            rect = QRectF(x - 10, y - 10, 20, 20)
+            painter.drawText(rect, Qt.AlignCenter, str(h))
+        painter.restore()
+
+        # Draw minute labels outside the clock
+        painter.save()
+        font = painter.font()
+        font.setFamily("Courier New")
+        font.setPointSize(4)
+        font.setBold(True)
+        painter.setFont(font)
+        painter.setPen(self.palette().windowText().color())
+        for m in range(0, 60, 5):
+            angle_deg = -90 + m * 6
+            angle_rad = math.radians(angle_deg)
+            x = 108 * math.cos(angle_rad)
+            y = 108 * math.sin(angle_rad)
+            rect = QRectF(x - 10, y - 10, 20, 20)
+            painter.drawText(rect, Qt.AlignCenter, f"{m:02d}")
+        painter.restore()
+
+    def draw_hands(self, painter):
+        time = QTime.currentTime()
+        
+        # Hour hand
+        hour_angle = 15.0 * (time.hour() + time.minute() / 60.0 + time.second() / 3600.0)
+        self.draw_capsule_hand(painter, hour_angle, self.black_color, (-4, -55, 8, 70, 4.0, 4.0))
+
+        # Minute hand (Swiss clocks jump the minute hand at the exact minute)
+        minute_angle = 6.0 * time.minute()
+        self.draw_capsule_hand(painter, minute_angle, self.black_color, (-3, -75, 6, 95, 3.0, 3.0))
+
+        # Second hand (waits for 1.5s at 60, then jumps directly to 1.5 seconds)
+        ms = time.second() * 1000 + time.msec()
+        if ms < 1500:
+            second_angle = 0.0
+        else:
+            second_angle = ms * (360.0 / 60000.0)
+
+        self.draw_swiss_second_hand(painter, second_angle)
+
+if __name__ == '__main__':
+    app = QApplication(sys.argv)
+    clock = AnalogClock()
+    clock.show()
+    sys.exit(app.exec())

swissclock/main.py

@@ -0,0 +1,138 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+import sys
+
+from PySide6.QtGui import QKeySequence, QShortcut
+from PySide6.QtWidgets import (
+    QApplication,
+    QHBoxLayout,
+    QPushButton,
+    QStackedWidget,
+    QVBoxLayout,
+    QWidget,
+)
+
+from .clock import AnalogClock
+from .stop import StopWatch
+
+
+class UnifiedApp(QWidget):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("Swiss Railway Time")
+        self.resize(320, 420)
+        
+        layout = QVBoxLayout(self)
+        
+        self.stacked = QStackedWidget()
+        
+        self.clock_widget = AnalogClock()
+        self.stopwatch_widget = StopWatch(self)
+        
+        self.stacked.addWidget(self.clock_widget)
+        self.stacked.addWidget(self.stopwatch_widget)
+        
+        layout.addWidget(self.stacked, 1) # Expanding
+        
+        # Action Buttons Layout (Start / Reset)
+        self.action_layout = QHBoxLayout()
+        self.btn_start = QPushButton("Start (Space)")
+        self.btn_start.clicked.connect(self.toggle_stopwatch)
+        
+        self.btn_reset = QPushButton("Reset (R)")
+        self.btn_reset.clicked.connect(self.reset_stopwatch)
+        
+        self.action_layout.addWidget(self.btn_start)
+        self.action_layout.addWidget(self.btn_reset)
+        
+        # Only show action buttons when in stopwatch mode
+        self.action_widget = QWidget()
+        self.action_widget.setLayout(self.action_layout)
+        sp = self.action_widget.sizePolicy()
+        sp.setRetainSizeWhenHidden(True)
+        self.action_widget.setSizePolicy(sp)
+        self.action_widget.setVisible(False)
+        layout.addWidget(self.action_widget)
+        
+        # Main Toggle Button
+        self.btn_toggle = QPushButton("Switch to Stopwatch (T)")
+        self.btn_toggle.clicked.connect(self.toggle_view)
+        layout.addWidget(self.btn_toggle)
+
+        # Bulletproof window-level shortcuts
+        self.shortcut_toggle = QShortcut(QKeySequence("T"), self)
+        self.shortcut_toggle.activated.connect(self.toggle_view)
+        
+        self.shortcut_space = QShortcut(QKeySequence("Space"), self)
+        self.shortcut_space.activated.connect(self.handle_space)
+        
+        self.shortcut_reset = QShortcut(QKeySequence("R"), self)
+        self.shortcut_reset.activated.connect(self.handle_reset)
+        
+        self.shortcut_digital = QShortcut(QKeySequence("D"), self)
+        self.shortcut_digital.activated.connect(self.handle_digital)
+        
+        self.shortcut_fullscreen = QShortcut(QKeySequence("F"), self)
+        self.shortcut_fullscreen.activated.connect(self.toggle_fullscreen)
+
+    def toggle_fullscreen(self):
+        if self.isFullScreen():
+            self.showNormal()
+        else:
+            self.showFullScreen()
+
+    def handle_space(self):
+        if self.stacked.currentIndex() == 1:
+            self.toggle_stopwatch()
+
+    def handle_reset(self):
+        if self.stacked.currentIndex() == 1:
+            self.reset_stopwatch()
+            
+    def handle_digital(self):
+        if self.stacked.currentIndex() == 1:
+            self.stopwatch_widget.toggle_digital_mode()
+
+    def toggle_stopwatch(self):
+        self.stopwatch_widget.toggle_timer()
+        self.update_buttons()
+        
+    def reset_stopwatch(self):
+        self.stopwatch_widget.reset_timer()
+        self.update_buttons()
+
+    def update_buttons(self):
+        if self.stopwatch_widget.running:
+            self.btn_start.setText("Stop (Space)")
+        else:
+            if self.stopwatch_widget.total_elapsed > 0:
+                self.btn_start.setText("Resume (Space)")
+            else:
+                self.btn_start.setText("Start (Space)")
+        
+    def toggle_view(self):
+        if self.stacked.currentIndex() == 0:
+            self.stacked.setCurrentIndex(1)
+            self.btn_toggle.setText("Switch to Clock (T)")
+            self.action_widget.setVisible(True)
+            self.update_buttons()
+        else:
+            self.stacked.setCurrentIndex(0)
+            self.btn_toggle.setText("Switch to Stopwatch (T)")
+            self.action_widget.setVisible(False)
+
+def main():
+    app = QApplication.instance() or QApplication(sys.argv)
+    
+    # Optional: Set an application-wide stylesheet for a modern dark look if desired
+    app.setStyleSheet("""
+        QWidget {
+            background-color: #121212;
+        }
+    """)
+    
+    clock = UnifiedApp()
+    clock.show()
+    sys.exit(app.exec())
+
+if __name__ == "__main__":
+    main()

swissclock/morph_digit.py

@@ -0,0 +1,87 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+from PySide6.QtCore import QPointF, Qt
+from PySide6.QtGui import QColor, QPen
+
+# Define the 7 standard segments on a 1x2 grid
+SEGS = [
+    (0,0, 1,0), # 0: T
+    (1,0, 1,1), # 1: TR
+    (1,1, 1,2), # 2: BR
+    (1,2, 0,2), # 3: B
+    (0,2, 0,1), # 4: BL
+    (0,1, 0,0), # 5: TL
+    (0,1, 1,1)  # 6: M
+]
+
+# Standard 7-segment bitmasks for digits 0-9
+# Order: T, TR, BR, B, BL, TL, M
+STATES = [
+    [1, 1, 1, 1, 1, 1, 0], # 0
+    [0, 1, 1, 0, 0, 0, 0], # 1
+    [1, 1, 0, 1, 1, 0, 1], # 2
+    [1, 1, 1, 1, 0, 0, 1], # 3
+    [0, 1, 1, 0, 0, 1, 1], # 4
+    [1, 0, 1, 1, 0, 1, 1], # 5
+    [1, 0, 1, 1, 1, 1, 1], # 6
+    [1, 1, 1, 0, 0, 0, 0], # 7
+    [1, 1, 1, 1, 1, 1, 1], # 8
+    [1, 1, 1, 1, 0, 1, 1], # 9
+]
+
+class MorphDigit:
+    def __init__(self):
+        self.target = 0
+        self.opacities = [float(x) for x in STATES[0]]
+        
+    def set_target(self, digit):
+        if self.target != digit:
+            self.target = digit
+            
+    def update(self):
+        # Lerp each segment's opacity towards its target state (smooth fade)
+        target_state = STATES[self.target]
+        for i in range(7):
+            current = self.opacities[i]
+            target = float(target_state[i])
+            
+            # Smooth 30fps fade factor (lower is slower)
+            factor = 0.1
+            self.opacities[i] = current + (target - current) * factor
+            
+    def draw(self, painter, x_offset, y_offset, scale_x, scale_y, color):
+        pen_width = max(2.0, scale_x * 0.15)
+        
+        # 10% gap to ensure the segments are completely distinct from each other
+        gap = 0.1
+        
+        for i in range(7):
+            opacity = self.opacities[i]
+            if opacity < 0.01:
+                continue
+                
+            x1, y1, x2, y2 = SEGS[i]
+            
+            dx = x2 - x1
+            dy = y2 - y1
+            length = (dx**2 + dy**2)**0.5
+            
+            # Apply gap to shrink the line slightly and make it distinct
+            nx = dx / length
+            ny = dy / length
+            
+            start_x = x1 + nx * gap
+            start_y = y1 + ny * gap
+            end_x = x2 - nx * gap
+            end_y = y2 - ny * gap
+            
+            # Create a color with the current opacity for fading
+            c = QColor(color)
+            c.setAlphaF(opacity)
+            
+            pen = QPen(c)
+            pen.setWidthF(pen_width)
+            pen.setCapStyle(Qt.FlatCap) # Flat caps for that distinct LCD look
+            painter.setPen(pen)
+            
+            painter.drawLine(QPointF(x_offset + start_x * scale_x, y_offset + start_y * scale_y),
+                             QPointF(x_offset + end_x * scale_x, y_offset + end_y * scale_y))

swissclock/stop.py

@@ -0,0 +1,273 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+import math
+import sys
+
+from PySide6.QtCore import QElapsedTimer, QRectF, Qt
+from PySide6.QtGui import QPainter, QPen
+from PySide6.QtWidgets import QApplication, QInputDialog, QMenu
+
+from .base_dial import BaseDial
+from .morph_digit import MorphDigit
+
+
+class StopWatch(BaseDial):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        self.running = False
+        self.elapsed_timer = QElapsedTimer()
+        self.total_elapsed = 0
+        self.countdown_target_ms = 0
+        self.is_digital = False
+        
+        # 5 digits for H:MM:SS
+        self.digits = [MorphDigit() for _ in range(5)]
+
+        self.setWindowTitle("Stopwatch")
+        
+        self.setContextMenuPolicy(Qt.CustomContextMenu)
+        self.customContextMenuRequested.connect(self.show_context_menu)
+        
+
+    def show_context_menu(self, pos):
+        menu = QMenu(self)
+        
+        action_stopwatch = menu.addAction("Stopwatch Mode")
+        action_1min = menu.addAction("1 Minute")
+        action_5min = menu.addAction("5 Minutes")
+        action_10min = menu.addAction("10 Minutes")
+        action_custom = menu.addAction("Custom...")
+        menu.addSeparator()
+        action_help = menu.addAction("Help (Shortcuts)")
+        action_about = menu.addAction("About")
+        
+        action = menu.exec(self.mapToGlobal(pos))
+        
+        if action == action_stopwatch:
+            self.set_countdown(0)
+        elif action == action_1min:
+            self.set_countdown(60 * 1000)
+        elif action == action_5min:
+            self.set_countdown(5 * 60 * 1000)
+        elif action == action_10min:
+            self.set_countdown(10 * 60 * 1000)
+        elif action == action_custom:
+            mins, ok = QInputDialog.getInt(self, "Custom Countdown", "Enter minutes:", 1, 1, 999)
+            if ok:
+                self.set_countdown(mins * 60 * 1000)
+        elif action == action_help:
+            self.show_help()
+        elif action == action_about:
+            self.show_about()
+
+    def toggle_digital_mode(self):
+        self.is_digital = not self.is_digital
+        self.update()
+
+    def update_dial(self):
+        if self.is_digital:
+            ms = self.get_elapsed_ms()
+            abs_ms = abs(ms)
+            s = (abs_ms % 60000) // 1000
+            m = (abs_ms % 3600000) // 60000
+            h = abs_ms // 3600000
+            
+            self.digits[0].set_target(h % 10)
+            self.digits[1].set_target(m // 10)
+            self.digits[2].set_target(m % 10)
+            self.digits[3].set_target(s // 10)
+            self.digits[4].set_target(s % 10)
+            
+            for digit in self.digits:
+                digit.update()
+        
+        super().update_dial()
+
+    def paintEvent(self, event):
+        if not self.is_digital:
+            super().paintEvent(event)
+            return
+
+        ms = self.get_elapsed_ms()
+        
+        if self.total_elapsed == 0 and not self.running:
+            color = Qt.white
+        elif self.countdown_target_ms > 0:
+            if ms < 0:
+                color = self.red_color
+            elif ms <= 0.10 * self.countdown_target_ms:
+                color = self.orange_color
+            else:
+                color = self.green_color
+        else:
+            color = self.green_color
+
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.Antialiasing)
+        painter.fillRect(self.rect(), Qt.black)
+        
+        # H:MM:SS layout scaling
+        digit_w = self.width() * 0.1
+        digit_h = digit_w * 2.0
+        gap = digit_w * 0.4
+        colon_gap = digit_w * 0.8
+        
+        total_w = digit_w * 5 + gap * 2 + colon_gap * 2
+        
+        start_x = (self.width() - total_w) / 2
+        start_y = (self.height() - digit_h) / 2
+        
+        curr_x = start_x
+        
+        # Draw Negative sign if in overtime
+        if ms < 0:
+            pen = QPen(color)
+            pen.setWidthF(max(2.0, digit_w * 0.15))
+            pen.setCapStyle(Qt.RoundCap)
+            painter.setPen(pen)
+            painter.drawLine(start_x - digit_w * 0.8, start_y + digit_h / 2, start_x - digit_w * 0.2, start_y + digit_h / 2)
+        
+        # Draw H
+        self.digits[0].draw(painter, curr_x, start_y, digit_w, digit_h / 2.0, color)
+        curr_x += digit_w + colon_gap / 2
+        
+        # Draw Colon 1
+        painter.setPen(Qt.NoPen)
+        painter.setBrush(color)
+        radius = digit_w * 0.15
+        painter.drawEllipse(curr_x - radius, start_y + digit_h * 0.35 - radius, radius*2, radius*2)
+        painter.drawEllipse(curr_x - radius, start_y + digit_h * 0.65 - radius, radius*2, radius*2)
+        curr_x += colon_gap / 2
+        
+        # Draw M1, M2
+        self.digits[1].draw(painter, curr_x, start_y, digit_w, digit_h / 2.0, color)
+        curr_x += digit_w + gap
+        self.digits[2].draw(painter, curr_x, start_y, digit_w, digit_h / 2.0, color)
+        curr_x += digit_w + colon_gap / 2
+        
+        # Draw Colon 2
+        painter.drawEllipse(curr_x - radius, start_y + digit_h * 0.35 - radius, radius*2, radius*2)
+        painter.drawEllipse(curr_x - radius, start_y + digit_h * 0.65 - radius, radius*2, radius*2)
+        curr_x += colon_gap / 2
+        
+        # Draw S1, S2
+        self.digits[3].draw(painter, curr_x, start_y, digit_w, digit_h / 2.0, color)
+        curr_x += digit_w + gap
+        self.digits[4].draw(painter, curr_x, start_y, digit_w, digit_h / 2.0, color)
+
+    def draw_face(self, painter):
+        # Draw 60 second markers (big for multiples of 5, small for others)
+        painter.save()
+        for i in range(60):
+            if i % 5 == 0:
+                painter.setBrush(self.black_color)
+                painter.setPen(Qt.NoPen)
+                painter.drawEllipse(QRectF(83, -4, 8, 8))
+            else:
+                painter.setBrush(self.black_color)
+                painter.setPen(Qt.NoPen)
+                painter.drawEllipse(QRectF(85, -2, 4, 4))
+            painter.rotate(6.0)
+        painter.restore()
+
+        # Draw numbers every 1 second outside
+        painter.save()
+        font = painter.font()
+        font.setFamily("Courier New")
+        font.setPointSize(4) 
+        font.setBold(True)
+        painter.setFont(font)
+        
+        window_text_color = self.palette().windowText().color()
+        painter.setPen(window_text_color)
+        
+        for m in range(60):
+            angle_deg = -90 + m * 6
+            angle_rad = math.radians(angle_deg)
+            x = 108 * math.cos(angle_rad)
+            y = 108 * math.sin(angle_rad)
+            
+            rect = QRectF(x - 10, y - 10, 20, 20)
+            painter.drawText(rect, Qt.AlignCenter, f"{m:02d}")
+        painter.restore()
+
+    def draw_hands(self, painter):
+        ms = self.get_elapsed_ms()
+        
+        # Minute hand (smooth rotation)
+        minute_angle = (ms % 3600000) * (360.0 / 3600000.0)
+        
+        if self.total_elapsed == 0 and not self.running:
+            hand_color = self.black_color
+        elif self.countdown_target_ms > 0:
+            if ms < 0:
+                hand_color = self.red_color
+            elif ms <= 0.10 * self.countdown_target_ms:
+                hand_color = self.orange_color
+            else:
+                hand_color = self.green_color
+        else:
+            hand_color = self.green_color
+            
+        self.draw_capsule_hand(painter, minute_angle, hand_color, (-3, -75, 6, 95, 3.0, 3.0))
+
+        # Draw second hand (Swiss railway animation: wait at top for 1.5s)
+        sec_ms = ms % 60000
+        
+        raw_elapsed = self.total_elapsed
+        if self.running:
+            raw_elapsed += self.elapsed_timer.elapsed()
+            
+        if raw_elapsed >= 1500:
+            if self.countdown_target_ms > 0:
+                if sec_ms > 58500:
+                    second_angle = 0.0
+                else:
+                    second_angle = sec_ms * (360.0 / 60000.0)
+            else:
+                if sec_ms < 1500:
+                    second_angle = 0.0
+                else:
+                    second_angle = sec_ms * (360.0 / 60000.0)
+        else:
+            second_angle = sec_ms * (360.0 / 60000.0)
+
+        self.draw_swiss_second_hand(painter, second_angle)
+
+    def toggle_timer(self):
+        if self.running:
+            # Pause
+            self.total_elapsed += self.elapsed_timer.elapsed()
+            self.running = False
+        else:
+            # Start
+            self.elapsed_timer.start()
+            self.running = True
+        self.update()
+
+    def reset_timer(self):
+        self.running = False
+        self.total_elapsed = 0
+        self.update()
+
+    def set_countdown(self, ms):
+        self.countdown_target_ms = ms
+        self.reset_timer()
+        if hasattr(self.parent(), 'update_buttons'):
+            self.parent().update_buttons()
+
+    def get_elapsed_ms(self):
+        ms = self.total_elapsed
+        if self.running:
+            ms += self.elapsed_timer.elapsed()
+            
+        if self.countdown_target_ms > 0:
+            return self.countdown_target_ms - ms
+        return ms
+
+if __name__ == '__main__':
+    app = QApplication(sys.argv)
+    stopwatch = StopWatch()
+    stopwatch.resize(300, 300)
+    stopwatch.show()
+    sys.exit(app.exec())