From b80877057382af2eec24c8f5a8f72bdcbd310950 Mon Sep 17 00:00:00 2001
From: Mohamed Salem <mohamed.salem@teqanylogix.com>
Date: Thu, 2 Apr 2026 16:40:52 +0200
Subject: [PATCH] Step 1: GUI skeleton for LIN Simulator (Python + C++)

- PyQt6 main window with Tx/Rx tables, connection dock, LDF toolbar,
  control bar with global send rate, and status bar
- C++ Qt6 equivalent with identical layout and feature parity
- About dialog: TeqanyLogix LTD / Developer: Mohamed Salem
- Application logo (SVG + PNG) with LIN bus waveform design
- Full test suites: Python (32 tests), C++ QTest (34 tests)
- Project plan and Step 1 documentation

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .gitignore                       |  29 ++
 PLAN.md                          | 207 ++++++++++++
 cpp/CMakeLists.txt               |  88 +++++
 cpp/src/main.cpp                 |  51 +++
 cpp/src/main_window.cpp          | 372 +++++++++++++++++++++
 cpp/src/main_window.h            | 162 +++++++++
 cpp/tests/test_main_window.cpp   | 278 ++++++++++++++++
 docs/step1_gui_skeleton.md       |  89 +++++
 python/requirements.txt          |   2 +
 python/src/__init__.py           |   0
 python/src/main.py               |  74 +++++
 python/src/main_window.py        | 547 +++++++++++++++++++++++++++++++
 python/tests/__init__.py         |   0
 python/tests/test_main_window.py | 207 ++++++++++++
 resources/logo.png               | Bin 0 -> 77417 bytes
 resources/logo.svg               |  75 +++++
 16 files changed, 2181 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 PLAN.md
 create mode 100644 cpp/CMakeLists.txt
 create mode 100644 cpp/src/main.cpp
 create mode 100644 cpp/src/main_window.cpp
 create mode 100644 cpp/src/main_window.h
 create mode 100644 cpp/tests/test_main_window.cpp
 create mode 100644 docs/step1_gui_skeleton.md
 create mode 100644 python/requirements.txt
 create mode 100644 python/src/__init__.py
 create mode 100644 python/src/main.py
 create mode 100644 python/src/main_window.py
 create mode 100644 python/tests/__init__.py
 create mode 100644 python/tests/test_main_window.py
 create mode 100644 resources/logo.png
 create mode 100644 resources/logo.svg

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..9df17f8
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,29 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+venv/
+.venv/
+
+# C++
+build/
+cmake-build-*/
+*.o
+*.so
+*.dylib
+*.dll
+*.exe
+
+# IDE
+.vscode/
+.idea/
+*.swp
+
+# OS
+.DS_Store
+Thumbs.db
+
+# PyInstaller
+*.spec
diff --git a/PLAN.md b/PLAN.md
new file mode 100644
index 0000000..6d6577f
--- /dev/null
+++ b/PLAN.md
@@ -0,0 +1,207 @@
+# LIN Master Simulator Tool — Implementation Plan
+
+## Context
+Build a cross-platform LIN master simulator GUI using BabyLIN devices. Two parallel implementations: Python (PyQt6) and C++ (Qt6). Each step is built, verified, and tested before moving to the next.
+
+## Project Structure
+```
+LIN_Control_Tool/
+├── python/                # Python implementation
+│   ├── src/
+│   ├── tests/
+│   └── requirements.txt
+├── cpp/                   # C++ implementation
+│   ├── src/
+│   ├── tests/
+│   └── CMakeLists.txt
+└── resources/             # Shared: sample LDF files, icons, etc.
+```
+
+## Tech Stack
+- **Python:** PyQt6, ldfparser, pyserial, pytest
+- **C++:** Qt6 (Widgets, SerialPort), CMake, GoogleTest
+- **LDF parsing (C++):** Custom or port of ldfparser logic
+
+## Step-by-Step Plan
+
+### Step 1 — GUI Skeleton
+- **Status:** DONE — Python (32/32 tests) | C++ (34/34 tests)
+- **Goal:** Main window with all panel placeholders laid out.
+
+**Panels:**
+- Top bar: LDF file loader (path + browse button + auto-reload indicator)
+- Left: Connection status panel (device dropdown, connect/disconnect, status LED)
+- Center-top: Tx panel (table placeholder — frame name, ID, signals, data, send button)
+- Center-bottom: Rx panel (table placeholder — timestamp, frame name, ID, data, signals)
+- Bottom: Control bar (start/stop scheduler, manual send)
+
+**Python:** PyQt6 QMainWindow, QDockWidget or QSplitter layout
+**C++:** Qt6 QMainWindow, same layout with .ui or code-based
+
+**Testing:**
+- Launch app, verify all panels render correctly
+- Resize window — panels resize proportionally
+- Cross-platform: test on macOS, Windows, Linux
+
+---
+
+### Step 2 — LDF Loading & Display
+- **Status:** Not started
+- **Goal:** Load an LDF file, parse it, populate Tx/Rx tables with frame/signal info.
+
+**Features:**
+- File picker dialog
+- Parse LDF using `ldfparser` (Python) / custom parser (C++)
+- Populate Tx table with master frames (name, ID, length, signals)
+- Populate Rx table columns (ready for runtime data)
+- Auto-reload: watch file for changes, re-parse on modification
+- Error handling for invalid LDF files
+
+**Python:** ldfparser library, QFileSystemWatcher for auto-reload
+**C++:** Custom LDF parser, QFileSystemWatcher
+
+**Testing:**
+- Load valid LDF → tables populate correctly
+- Load invalid file → error message shown
+- Modify LDF on disk → auto-reload triggers, tables update
+- Verify parsed frame IDs, signal names, lengths match LDF content
+
+---
+
+### Step 3 — Tx Panel (Signal Editing)
+- **Status:** Not started
+- **Goal:** Editable Tx table where user can modify signal values based on LDF types.
+
+**Features:**
+- Each master frame row expandable to show individual signals
+- Signal value editors based on type (bool → checkbox, int → spinbox, enum → dropdown)
+- Frame data bytes update live as signals are edited
+- Respect signal bit position, length, encoding from LDF
+- Manual "Send" button per frame
+
+**Python:** QTreeWidget or QTableWidget with custom delegates
+**C++:** Same with QStyledItemDelegate subclasses
+
+**Testing:**
+- Edit a signal → frame data bytes reflect the change correctly
+- Bool signal toggles between 0/1
+- Enum signal shows correct value names from LDF
+- Integer signal respects min/max range from LDF
+- Bit packing: verify multi-signal frames encode correctly
+
+---
+
+### Step 4 — Rx Panel (Real-time Display)
+- **Status:** Not started
+- **Goal:** Rx table that shows incoming frames with timestamps.
+
+**Features:**
+- Columns: timestamp, frame name, frame ID, raw data, decoded signals
+- Expandable rows to see individual signal values
+- Auto-scroll with pause option
+- Clear button
+- Signal highlighting on value change
+
+**Python:** QTableWidget with QTimer-based mock data for testing
+**C++:** Same approach
+
+**Testing:**
+- Feed mock Rx data → rows appear with correct timestamps
+- Auto-scroll follows new data
+- Pause stops scrolling, resume catches up
+- Signal decode matches expected values
+- Performance: handle 1000+ rows without lag
+
+---
+
+### Step 5 — Connection Panel & Device Discovery
+- **Status:** Not started
+- **Goal:** Detect BabyLIN devices, show connection status.
+
+**Features:**
+- Scan for available serial ports / BabyLIN devices
+- Device dropdown with refresh button
+- Connect / Disconnect buttons
+- Status indicator (disconnected/connecting/connected/error)
+- Display device info on connect (firmware version, etc.)
+
+**Python:** pyserial for port enumeration, QThread for connection
+**C++:** QSerialPort, QSerialPortInfo
+
+**Testing:**
+- No device → dropdown empty, status shows "No device"
+- Mock serial port → connection succeeds, status turns green
+- Disconnect → status updates, UI re-enables connect
+- Unplug during session → error state shown, graceful handling
+
+---
+
+### Step 6 — BabyLIN Communication Backend
+- **Status:** Not started
+- **Goal:** Implement the protocol layer for BabyLIN communication.
+
+**Features:**
+- Serial protocol commands (init, send frame, receive frame)
+- BabyLIN-DLL/SDK integration if available
+- Abstract interface so serial vs SDK can be swapped
+- Frame send/receive with proper LIN timing
+- Error detection and reporting
+
+**Python:** pyserial + threading, abstract base class
+**C++:** QSerialPort, abstract interface class
+
+**Testing:**
+- Unit test protocol encoding/decoding
+- Loopback test if hardware available
+- Mock device for CI testing
+- Verify frame timing within LIN spec tolerances
+
+---
+
+### Step 7 — Master Scheduler
+- **Status:** Not started
+- **Goal:** Periodic frame transmission using LDF schedule tables.
+
+**Features:**
+- Parse schedule tables from LDF
+- Run selected schedule with correct timing (slot delays)
+- Start/Stop/Pause controls
+- Visual indication of currently transmitting frame
+- Manual send overrides during schedule execution
+- Schedule table selector dropdown
+
+**Python:** QTimer-based scheduler, QThread for timing accuracy
+**C++:** QTimer, dedicated thread
+
+**Testing:**
+- Start schedule → frames sent in correct order and timing
+- Stop → transmission halts
+- Manual send during schedule → frame injected correctly
+- Verify slot timing accuracy (within tolerance)
+- Switch schedule tables mid-run
+
+---
+
+### Step 8 — Integration & End-to-End
+- **Status:** Not started
+- **Goal:** Wire all components together, full workflow testing.
+
+**Features:**
+- Load LDF → connect device → start schedule → see Rx responses
+- Edit Tx signals on-the-fly during active schedule
+- Full error handling chain (device disconnect mid-run, etc.)
+- Package as standalone executable (PyInstaller / CMake install)
+
+**Testing:**
+- Full workflow with real BabyLIN + LIN slave device
+- Stress test: extended run (hours), verify no memory leaks
+- Cross-platform packaging and launch test
+- Verify all UI states transition correctly
+
+---
+
+## Verification Checklist (Every Step)
+- [ ] Code review — clean, no warnings
+- [ ] Unit tests pass (pytest / GoogleTest)
+- [ ] Manual GUI test on at least one platform
+- [ ] Both Python and C++ versions reach feature parity
diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
new file mode 100644
index 0000000..20983c9
--- /dev/null
+++ b/cpp/CMakeLists.txt
@@ -0,0 +1,88 @@
+# CMakeLists.txt — Build configuration for the LIN Simulator (C++)
+#
+# CMAKE BASICS:
+# =============
+# CMake is a build system generator. It doesn't compile code directly.
+# Instead, it generates platform-specific build files:
+#   - macOS/Linux: Makefiles (then you run `make`)
+#   - Windows: Visual Studio project files
+#   - Any platform: Ninja build files (faster than Make)
+#
+# The workflow is:
+#   1. mkdir build && cd build
+#   2. cmake ..              ← generates build files from this CMakeLists.txt
+#   3. cmake --build .       ← compiles and links the project
+#   4. ./lin_simulator       ← run the application
+#
+# Qt6 integration:
+#   CMake has built-in support for Qt via find_package(Qt6).
+#   Qt needs special preprocessing for its features:
+#     - MOC (Meta-Object Compiler): processes Q_OBJECT macros for signals/slots
+#     - UIC: compiles .ui designer files to C++ headers (we don't use these)
+#     - RCC: compiles resource files (icons, etc.) into the binary
+
+cmake_minimum_required(VERSION 3.16)
+
+project(LINSimulator
+    VERSION 0.1.0
+    LANGUAGES CXX
+    DESCRIPTION "LIN Simulator using BabyLIN devices"
+)
+
+# C++17 standard — required for structured bindings, std::optional, etc.
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# ── Qt6 auto-processing ──
+# These three lines enable Qt's special preprocessors:
+#   AUTOMOC: automatically runs MOC on headers containing Q_OBJECT
+#   AUTOUIC: automatically compiles .ui files (if we had any)
+#   AUTORCC: automatically compiles .qrc resource files
+set(CMAKE_AUTOMOC ON)
+set(CMAKE_AUTOUIC ON)
+set(CMAKE_AUTORCC ON)
+
+# ── Find Qt6 ──
+# find_package searches for Qt6 on the system.
+# REQUIRED means CMake will error if Qt6 is not found.
+# COMPONENTS lists which Qt modules we need:
+#   Widgets: GUI widgets (QMainWindow, QPushButton, etc.)
+#   We'll add SerialPort in Step 5 when we need device communication.
+find_package(Qt6 REQUIRED COMPONENTS Widgets)
+
+# ── Main application target ──
+# qt_add_executable is Qt's wrapper around add_executable.
+# It handles platform-specific details (macOS app bundle, Windows subsystem, etc.)
+qt_add_executable(lin_simulator
+    src/main.cpp
+    src/main_window.cpp
+    src/main_window.h
+)
+
+# Link against Qt6 Widgets library
+# PRIVATE means this dependency is only for building this target,
+# not propagated to anything that depends on us.
+target_link_libraries(lin_simulator PRIVATE Qt6::Widgets)
+
+# ── Tests ──
+# We use Qt's built-in test framework (QTest) instead of GoogleTest
+# because it integrates naturally with Qt's event loop and widgets.
+# QTest provides:
+#   - QVERIFY(condition): assert a condition is true
+#   - QCOMPARE(actual, expected): assert two values are equal
+#   - QTest::mouseClick(): simulate mouse events
+#   - QTest::keyClick(): simulate keyboard events
+enable_testing()
+find_package(Qt6 REQUIRED COMPONENTS Test)
+
+qt_add_executable(test_main_window
+    tests/test_main_window.cpp
+    src/main_window.cpp
+    src/main_window.h
+)
+
+target_link_libraries(test_main_window PRIVATE Qt6::Widgets Qt6::Test)
+target_include_directories(test_main_window PRIVATE src)
+
+# Register the test with CTest so `ctest` can discover and run it
+add_test(NAME test_main_window COMMAND test_main_window)
diff --git a/cpp/src/main.cpp b/cpp/src/main.cpp
new file mode 100644
index 0000000..45d1970
--- /dev/null
+++ b/cpp/src/main.cpp
@@ -0,0 +1,51 @@
+/**
+ * main.cpp — Application entry point for the LIN Simulator (C++).
+ *
+ * This is the C++ equivalent of python/src/main.py.
+ *
+ * C++ VS PYTHON STARTUP:
+ * ======================
+ * Python:  app = QApplication(sys.argv)    →  window = MainWindow()  →  app.exec()
+ * C++:     QApplication app(argc, argv)    →  MainWindow window      →  app.exec()
+ *
+ * The key difference: in C++, objects can live on the STACK (local variable)
+ * or the HEAP (new/delete). Here, both `app` and `window` are stack objects.
+ * When main() returns, they're automatically destroyed — no garbage collector needed.
+ *
+ * Stack vs Heap:
+ *   Stack: `MainWindow window;`      — destroyed when function exits (automatic)
+ *   Heap:  `auto* w = new MainWindow;` — lives until explicitly deleted
+ *
+ * For the main window and app, stack allocation is perfect because they
+ * should live for the entire program duration and be cleaned up at exit.
+ */
+
+#include <QApplication>
+#include <QIcon>
+#include <QDir>
+#include "main_window.h"
+
+int main(int argc, char* argv[])
+{
+    // argc/argv are the C++ equivalent of sys.argv
+    // Qt uses them for platform-specific flags like --platform, --style, etc.
+    QApplication app(argc, argv);
+
+    app.setApplicationName("LIN Simulator");
+    app.setOrganizationName("TeqanyLogix LTD");
+
+    // Set application icon — resolves relative to the executable location.
+    // In the build directory, the icon is at ../../resources/logo.png
+    QString iconPath = QDir(QCoreApplication::applicationDirPath())
+        .filePath("../../resources/logo.png");
+    if (QFile::exists(iconPath)) {
+        app.setWindowIcon(QIcon(iconPath));
+    }
+
+    MainWindow window;
+    window.show();
+
+    // app.exec() enters the event loop — blocks until last window closes.
+    // Returns 0 on success, which main() returns to the OS.
+    return app.exec();
+}
diff --git a/cpp/src/main_window.cpp b/cpp/src/main_window.cpp
new file mode 100644
index 0000000..924778e
--- /dev/null
+++ b/cpp/src/main_window.cpp
@@ -0,0 +1,372 @@
+/**
+ * main_window.cpp — Implementation of the LIN Simulator main window.
+ *
+ * This is the C++ equivalent of python/src/main_window.py.
+ * The structure mirrors the Python version exactly:
+ *   createMenuBar()       ↔  _create_menu_bar()
+ *   createLdfToolbar()    ↔  _create_ldf_toolbar()
+ *   createCentralWidget() ↔  _create_central_widget()
+ *   createConnectionDock()↔  _create_connection_dock()
+ *   createControlBar()    ↔  _create_control_bar()
+ *   createStatusBar()     ↔  _create_status_bar()
+ *
+ * KEY C++ / QT PATTERNS:
+ * ======================
+ * 1. `new Widget(parent)` — parent takes ownership, no need to delete
+ * 2. `connect(sender, &Class::signal, receiver, &Class::slot)` — type-safe connections
+ * 3. `tr("text")` — marks strings for translation (internationalization)
+ * 4. `QString` — Qt's string class, supports Unicode, formatting, etc.
+ */
+
+#include "main_window.h"
+
+// Now we include the full headers — needed because we're using these classes
+#include <QMenuBar>
+#include <QMenu>
+#include <QToolBar>
+#include <QStatusBar>
+#include <QDockWidget>
+#include <QSplitter>
+#include <QGroupBox>
+#include <QTableWidget>
+#include <QHeaderView>
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+#include <QLabel>
+#include <QLineEdit>
+#include <QPushButton>
+#include <QComboBox>
+#include <QCheckBox>
+#include <QSpinBox>
+#include <QFileDialog>
+#include <QMessageBox>
+#include <QAction>
+
+// ─── Constructor ──────────────────────────────────────────────────────
+
+MainWindow::MainWindow(QWidget* parent)
+    : QMainWindow(parent)  // Initialize base class with parent
+    // ^^^ This is the "member initializer list" — it calls the base class
+    // constructor before the body runs. Required for QMainWindow.
+{
+    setWindowTitle(tr("LIN Simulator"));
+    // tr() wraps strings for Qt's translation system. Even if you never
+    // translate, it's a good habit — makes internationalization easy later.
+
+    setMinimumSize(1024, 768);
+
+    createMenuBar();
+    createLdfToolbar();
+    createCentralWidget();
+    createConnectionDock();
+    createControlBar();
+    createStatusBar();
+}
+
+// ─── Menu Bar ─────────────────────────────────────────────────────────
+
+void MainWindow::createMenuBar()
+{
+    // menuBar() returns the QMainWindow's built-in menu bar (creates it if needed)
+    auto* fileMenu = menuBar()->addMenu(tr("&File"));
+
+    // QAction in C++ — same concept as Python, but connection syntax differs:
+    //   Python: action.triggered.connect(self._on_load_ldf)
+    //   C++:    connect(action, &QAction::triggered, this, &MainWindow::onLoadLdf)
+    //
+    // The C++ syntax uses pointers-to-member-functions which are type-checked
+    // at compile time — if onLoadLdf doesn't exist, compilation fails.
+    // Python only discovers the error at runtime.
+    m_actionLoadLdf = new QAction(tr("&Load LDF..."), this);
+    m_actionLoadLdf->setShortcut(QKeySequence(tr("Ctrl+O")));
+    m_actionLoadLdf->setStatusTip(tr("Load a LIN Description File"));
+    connect(m_actionLoadLdf, &QAction::triggered, this, &MainWindow::onLoadLdf);
+    fileMenu->addAction(m_actionLoadLdf);
+
+    fileMenu->addSeparator();
+
+    auto* actionExit = new QAction(tr("E&xit"), this);
+    actionExit->setShortcut(QKeySequence(tr("Ctrl+Q")));
+    connect(actionExit, &QAction::triggered, this, &QMainWindow::close);
+    fileMenu->addAction(actionExit);
+
+    m_viewMenu = menuBar()->addMenu(tr("&View"));
+
+    // Help menu
+    auto* helpMenu = menuBar()->addMenu(tr("&Help"));
+    auto* actionAbout = new QAction(tr("&About"), this);
+    connect(actionAbout, &QAction::triggered, this, &MainWindow::onAbout);
+    helpMenu->addAction(actionAbout);
+}
+
+// ─── LDF Toolbar ──────────────────────────────────────────────────────
+
+void MainWindow::createLdfToolbar()
+{
+    auto* toolbar = addToolBar(tr("LDF File"));
+    toolbar->setMovable(false);
+
+    toolbar->addWidget(new QLabel(tr("  LDF File: ")));
+
+    m_ldfPathEdit = new QLineEdit();
+    m_ldfPathEdit->setReadOnly(true);
+    m_ldfPathEdit->setPlaceholderText(tr("No LDF file loaded"));
+    m_ldfPathEdit->setMinimumWidth(300);
+    toolbar->addWidget(m_ldfPathEdit);
+
+    m_btnBrowse = new QPushButton(tr("Browse..."));
+    connect(m_btnBrowse, &QPushButton::clicked, this, &MainWindow::onLoadLdf);
+    toolbar->addWidget(m_btnBrowse);
+
+    m_chkAutoReload = new QCheckBox(tr("Auto-reload"));
+    m_chkAutoReload->setChecked(true);
+    m_chkAutoReload->setToolTip(
+        tr("Automatically reload the LDF file when it changes on disk")
+    );
+    toolbar->addWidget(m_chkAutoReload);
+}
+
+// ─── Central Widget (Tx + Rx Panels) ─────────────────────────────────
+
+void MainWindow::createCentralWidget()
+{
+    // In C++, we must explicitly create a central widget and set it.
+    // `new QWidget(this)` — MainWindow becomes the parent/owner.
+    auto* central = new QWidget(this);
+    auto* layout = new QVBoxLayout(central);
+    layout->setContentsMargins(4, 4, 4, 4);
+
+    // Qt::Vertical means the divider line is horizontal (widgets stack top/bottom)
+    auto* splitter = new QSplitter(Qt::Vertical);
+
+    // Tx panel
+    auto* txGroup = new QGroupBox(tr("Tx Frames (Master → Slave)"));
+    auto* txLayout = new QVBoxLayout(txGroup);
+    m_txTable = createTxTable();
+    txLayout->addWidget(m_txTable);
+    splitter->addWidget(txGroup);
+
+    // Rx panel
+    auto* rxGroup = new QGroupBox(tr("Rx Frames (Slave → Master)"));
+    auto* rxLayout = new QVBoxLayout(rxGroup);
+    m_rxTable = createRxTable();
+    rxLayout->addWidget(m_rxTable);
+    splitter->addWidget(rxGroup);
+
+    splitter->setSizes({400, 400});
+
+    layout->addWidget(splitter);
+    setCentralWidget(central);
+}
+
+QTableWidget* MainWindow::createTxTable()
+{
+    auto* table = new QTableWidget();
+    table->setColumnCount(7);
+    table->setHorizontalHeaderLabels({
+        tr("Frame Name"), tr("Frame ID"), tr("Length"), tr("Interval (ms)"),
+        tr("Data"), tr("Signals"), tr("Action")
+    });
+
+    // In C++, we access the enum values with the full scope path:
+    //   QHeaderView::Stretch  vs  Python's QHeaderView.ResizeMode.Stretch
+    auto* header = table->horizontalHeader();
+    header->setSectionResizeMode(0, QHeaderView::Stretch);           // Frame Name
+    header->setSectionResizeMode(1, QHeaderView::ResizeToContents);  // ID
+    header->setSectionResizeMode(2, QHeaderView::ResizeToContents);  // Length
+    header->setSectionResizeMode(3, QHeaderView::ResizeToContents);  // Interval
+    header->setSectionResizeMode(4, QHeaderView::Stretch);           // Data
+    header->setSectionResizeMode(5, QHeaderView::Stretch);           // Signals
+    header->setSectionResizeMode(6, QHeaderView::ResizeToContents);  // Action
+
+    table->setAlternatingRowColors(true);
+    table->setSelectionBehavior(QAbstractItemView::SelectRows);
+
+    return table;
+}
+
+QTableWidget* MainWindow::createRxTable()
+{
+    auto* table = new QTableWidget();
+    table->setColumnCount(5);
+    table->setHorizontalHeaderLabels({
+        tr("Timestamp"), tr("Frame Name"), tr("Frame ID"),
+        tr("Data"), tr("Signals")
+    });
+
+    auto* header = table->horizontalHeader();
+    header->setSectionResizeMode(0, QHeaderView::ResizeToContents);  // Timestamp
+    header->setSectionResizeMode(1, QHeaderView::Stretch);           // Frame Name
+    header->setSectionResizeMode(2, QHeaderView::ResizeToContents);  // ID
+    header->setSectionResizeMode(3, QHeaderView::Stretch);           // Data
+    header->setSectionResizeMode(4, QHeaderView::Stretch);           // Signals
+
+    table->setAlternatingRowColors(true);
+    table->setSelectionBehavior(QAbstractItemView::SelectRows);
+    table->setEditTriggers(QAbstractItemView::NoEditTriggers);
+
+    return table;
+}
+
+// ─── Connection Dock Widget ───────────────────────────────────────────
+
+void MainWindow::createConnectionDock()
+{
+    auto* dock = new QDockWidget(tr("Connection"), this);
+    dock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
+
+    auto* container = new QWidget();
+    auto* layout = new QVBoxLayout(container);
+
+    // Device selection
+    layout->addWidget(new QLabel(tr("Device:")));
+
+    auto* deviceRow = new QHBoxLayout();
+    m_comboDevice = new QComboBox();
+    m_comboDevice->setPlaceholderText(tr("Select device..."));
+    m_comboDevice->setMinimumWidth(150);
+    deviceRow->addWidget(m_comboDevice);
+
+    m_btnRefresh = new QPushButton(tr("Refresh"));
+    m_btnRefresh->setToolTip(tr("Scan for connected BabyLIN devices"));
+    deviceRow->addWidget(m_btnRefresh);
+    layout->addLayout(deviceRow);
+
+    // Baud rate display (read-only, from LDF)
+    layout->addWidget(new QLabel(tr("Baud Rate:")));
+    m_lblBaudRate = new QLabel(tr("— (load LDF)"));
+    m_lblBaudRate->setStyleSheet("font-weight: bold;");
+    m_lblBaudRate->setToolTip(
+        tr("LIN bus baud rate — automatically detected from the LDF file")
+    );
+    layout->addWidget(m_lblBaudRate);
+
+    // Connect / Disconnect
+    auto* btnRow = new QHBoxLayout();
+    m_btnConnect = new QPushButton(tr("Connect"));
+    m_btnDisconnect = new QPushButton(tr("Disconnect"));
+    m_btnDisconnect->setEnabled(false);
+    btnRow->addWidget(m_btnConnect);
+    btnRow->addWidget(m_btnDisconnect);
+    layout->addLayout(btnRow);
+
+    // Status
+    m_lblConnStatus = new QLabel(tr("Status: Disconnected"));
+    m_lblConnStatus->setStyleSheet("color: red; font-weight: bold;");
+    layout->addWidget(m_lblConnStatus);
+
+    // Device info
+    m_lblDeviceInfo = new QLabel(tr("Device Info: —"));
+    layout->addWidget(m_lblDeviceInfo);
+
+    layout->addStretch();
+
+    dock->setWidget(container);
+    addDockWidget(Qt::LeftDockWidgetArea, dock);
+
+    // toggleViewAction() returns a QAction that shows/hides the dock
+    m_viewMenu->addAction(dock->toggleViewAction());
+}
+
+// ─── Control Bar (Bottom Toolbar) ─────────────────────────────────────
+
+void MainWindow::createControlBar()
+{
+    auto* toolbar = new QToolBar(tr("Controls"));
+    toolbar->setMovable(false);
+    addToolBar(Qt::BottomToolBarArea, toolbar);
+
+    // Schedule selector
+    toolbar->addWidget(new QLabel(tr("  Schedule: ")));
+    m_comboSchedule = new QComboBox();
+    m_comboSchedule->setPlaceholderText(tr("No schedule loaded"));
+    m_comboSchedule->setMinimumWidth(200);
+    toolbar->addWidget(m_comboSchedule);
+
+    toolbar->addSeparator();
+
+    // Global send rate
+    toolbar->addWidget(new QLabel(tr("  Global Rate (ms): ")));
+    m_spinGlobalRate = new QSpinBox();
+    m_spinGlobalRate->setRange(1, 10000);
+    m_spinGlobalRate->setValue(50);
+    m_spinGlobalRate->setSingleStep(10);
+    m_spinGlobalRate->setSuffix(tr(" ms"));
+    m_spinGlobalRate->setToolTip(
+        tr("Default send interval for all frames. "
+           "Per-frame intervals in the Tx table override this.")
+    );
+    toolbar->addWidget(m_spinGlobalRate);
+
+    toolbar->addSeparator();
+
+    // Scheduler controls
+    m_btnStart = new QPushButton(tr("▶ Start"));
+    m_btnStop = new QPushButton(tr("■ Stop"));
+    m_btnPause = new QPushButton(tr("⏸ Pause"));
+    m_btnStart->setEnabled(false);
+    m_btnStop->setEnabled(false);
+    m_btnPause->setEnabled(false);
+    toolbar->addWidget(m_btnStart);
+    toolbar->addWidget(m_btnStop);
+    toolbar->addWidget(m_btnPause);
+
+    toolbar->addSeparator();
+
+    // Manual send
+    m_btnManualSend = new QPushButton(tr("Send Selected Frame"));
+    m_btnManualSend->setEnabled(false);
+    toolbar->addWidget(m_btnManualSend);
+}
+
+// ─── Status Bar ───────────────────────────────────────────────────────
+
+void MainWindow::createStatusBar()
+{
+    // statusBar() creates the status bar if it doesn't exist yet
+    m_lblStatusConnection = new QLabel(tr("● Disconnected"));
+    m_lblStatusConnection->setStyleSheet("color: red;");
+    statusBar()->addPermanentWidget(m_lblStatusConnection);
+
+    statusBar()->showMessage(tr("Ready — Load an LDF file to begin"), 5000);
+}
+
+// ─── Slots ────────────────────────────────────────────────────────────
+
+void MainWindow::onLoadLdf()
+{
+    // QFileDialog::getOpenFileName returns a QString.
+    // In C++, empty string check is .isEmpty() instead of Python's truthiness.
+    QString filePath = QFileDialog::getOpenFileName(
+        this,
+        tr("Open LIN Description File"),
+        QString(),  // Empty = last used directory
+        tr("LDF Files (*.ldf);;All Files (*)")
+    );
+
+    if (!filePath.isEmpty()) {
+        m_ldfPathEdit->setText(filePath);
+        statusBar()->showMessage(
+            tr("LDF file selected: %1").arg(filePath), 3000
+        );
+        // %1 is Qt's string formatting placeholder — .arg() substitutes it.
+        // Similar to Python's f-string: f"LDF file selected: {file_path}"
+    }
+}
+
+void MainWindow::onAbout()
+{
+    QMessageBox::about(
+        this,
+        tr("About LIN Simulator"),
+        tr("<h2>LIN Simulator</h2>"
+           "<p>Version 0.1.0</p>"
+           "<p>A cross-platform tool for simulating LIN master nodes "
+           "using BabyLIN devices.</p>"
+           "<hr>"
+           "<p><b>Owner:</b> TeqanyLogix LTD</p>"
+           "<p><b>Developer:</b> Mohamed Salem</p>"
+           "<hr>"
+           "<p>&copy; 2026 TeqanyLogix LTD. All rights reserved.</p>")
+    );
+}
diff --git a/cpp/src/main_window.h b/cpp/src/main_window.h
new file mode 100644
index 0000000..ae6d9c9
--- /dev/null
+++ b/cpp/src/main_window.h
@@ -0,0 +1,162 @@
+/**
+ * main_window.h — Header file for the LIN Simulator main window.
+ *
+ * HEADER FILES IN C++:
+ * ====================
+ * Unlike Python where everything is in one file, C++ splits code into:
+ *   - Header (.h): DECLARES what exists (class names, function signatures)
+ *   - Source (.cpp): DEFINES how it works (function bodies, logic)
+ *
+ * Why? Because C++ compiles each .cpp file independently. Headers let
+ * different .cpp files know about each other's classes without seeing
+ * the full implementation. Think of it like a table of contents.
+ *
+ * Q_OBJECT MACRO:
+ * ===============
+ * Any class that uses Qt's signals/slots MUST include Q_OBJECT at the top.
+ * This tells Qt's Meta-Object Compiler (MOC) to generate extra code that
+ * enables runtime introspection — Qt needs this for:
+ *   - Signal/slot connections
+ *   - Property system
+ *   - Dynamic casting with qobject_cast
+ *
+ * MOC reads this header, generates a moc_main_window.cpp file with the
+ * glue code, and the build system compiles it automatically (CMAKE_AUTOMOC).
+ */
+
+#ifndef MAIN_WINDOW_H
+#define MAIN_WINDOW_H
+// ^^^ "Include guard" — prevents this header from being included twice
+// in the same compilation unit, which would cause duplicate definition errors.
+
+#include <QMainWindow>
+
+// Forward declarations — tell the compiler these classes exist without
+// including their full headers. This speeds up compilation because we
+// only need the full definition in the .cpp file where we use them.
+// Think of it as saying "trust me, QTableWidget exists, I'll show you later."
+class QTableWidget;
+class QLineEdit;
+class QPushButton;
+class QComboBox;
+class QCheckBox;
+class QSpinBox;
+class QLabel;
+class QAction;
+
+/**
+ * MainWindow — The root window of the LIN Simulator.
+ *
+ * Inherits from QMainWindow which provides:
+ *   - Menu bar, toolbars, dock areas, status bar
+ *   - Central widget area
+ *
+ * PARENT-CHILD OWNERSHIP:
+ * All widgets created with `new Widget(parent)` are owned by their parent.
+ * When MainWindow is destroyed, it automatically destroys all children.
+ * This is why we use raw pointers (Widget*) without delete — Qt manages it.
+ */
+class MainWindow : public QMainWindow
+{
+    Q_OBJECT  // Required for signals/slots — MOC processes this
+
+public:
+    /**
+     * Constructor.
+     * @param parent  Parent widget (nullptr for top-level window).
+     *
+     * In Qt, every widget can have a parent. For the main window,
+     * parent is nullptr because it's the top-level window with no owner.
+     */
+    explicit MainWindow(QWidget* parent = nullptr);
+
+    // No destructor needed — Qt's parent-child system handles cleanup.
+    // All the pointers below are children of MainWindow and will be
+    // automatically deleted when MainWindow is destroyed.
+
+    // ── Public accessors for testing ──
+    // These let tests verify the widget tree without exposing internals.
+    // In Python we accessed attributes directly (window.tx_table).
+    // In C++ we use getter functions — this is idiomatic C++ encapsulation.
+    QTableWidget* txTable() const { return m_txTable; }
+    QTableWidget* rxTable() const { return m_rxTable; }
+    QLineEdit* ldfPathEdit() const { return m_ldfPathEdit; }
+    QPushButton* browseButton() const { return m_btnBrowse; }
+    QCheckBox* autoReloadCheck() const { return m_chkAutoReload; }
+    QComboBox* deviceCombo() const { return m_comboDevice; }
+    QPushButton* connectButton() const { return m_btnConnect; }
+    QPushButton* disconnectButton() const { return m_btnDisconnect; }
+    QLabel* connStatusLabel() const { return m_lblConnStatus; }
+    QLabel* baudRateLabel() const { return m_lblBaudRate; }
+    QLabel* deviceInfoLabel() const { return m_lblDeviceInfo; }
+    QComboBox* scheduleCombo() const { return m_comboSchedule; }
+    QSpinBox* globalRateSpin() const { return m_spinGlobalRate; }
+    QPushButton* startButton() const { return m_btnStart; }
+    QPushButton* stopButton() const { return m_btnStop; }
+    QPushButton* pauseButton() const { return m_btnPause; }
+    QPushButton* manualSendButton() const { return m_btnManualSend; }
+    QLabel* statusConnectionLabel() const { return m_lblStatusConnection; }
+    QAction* loadLdfAction() const { return m_actionLoadLdf; }
+
+private slots:
+    // ── Slots ──
+    // In C++, slots are declared in a special section. The `slots` keyword
+    // is a Qt macro that MOC processes. These are functions that can be
+    // connected to signals.
+    void onLoadLdf();
+    void onAbout();
+
+private:
+    // ── Setup methods ──
+    void createMenuBar();
+    void createLdfToolbar();
+    void createCentralWidget();
+    void createConnectionDock();
+    void createControlBar();
+    void createStatusBar();
+
+    // ── Helper methods ──
+    QTableWidget* createTxTable();
+    QTableWidget* createRxTable();
+
+    // ── Member variables ──
+    // Convention: m_ prefix for member variables (common in Qt/C++ codebases).
+    // All are raw pointers — Qt's parent-child system manages their lifetime.
+
+    // LDF toolbar
+    QLineEdit*   m_ldfPathEdit;
+    QPushButton* m_btnBrowse;
+    QCheckBox*   m_chkAutoReload;
+
+    // Central tables
+    QTableWidget* m_txTable;
+    QTableWidget* m_rxTable;
+
+    // Connection dock
+    QComboBox*   m_comboDevice;
+    QPushButton* m_btnRefresh;
+    QPushButton* m_btnConnect;
+    QPushButton* m_btnDisconnect;
+    QLabel*      m_lblConnStatus;
+    QLabel*      m_lblBaudRate;
+    QLabel*      m_lblDeviceInfo;
+
+    // Control bar
+    QComboBox*   m_comboSchedule;
+    QSpinBox*    m_spinGlobalRate;
+    QPushButton* m_btnStart;
+    QPushButton* m_btnStop;
+    QPushButton* m_btnPause;
+    QPushButton* m_btnManualSend;
+
+    // Status bar
+    QLabel*      m_lblStatusConnection;
+
+    // Actions
+    QAction*     m_actionLoadLdf;
+
+    // View menu (need to store to add dock toggle actions)
+    QMenu*       m_viewMenu;
+};
+
+#endif // MAIN_WINDOW_H
diff --git a/cpp/tests/test_main_window.cpp b/cpp/tests/test_main_window.cpp
new file mode 100644
index 0000000..b6f7eea
--- /dev/null
+++ b/cpp/tests/test_main_window.cpp
@@ -0,0 +1,278 @@
+/**
+ * test_main_window.cpp — Tests for the GUI skeleton (Step 1, C++).
+ *
+ * QTest FRAMEWORK:
+ * ================
+ * Qt provides its own test framework, QTest. It's simpler than GoogleTest
+ * but integrates perfectly with Qt's event loop and widget system.
+ *
+ * Key differences from pytest:
+ *   pytest:  assert window.windowTitle() == "..."
+ *   QTest:   QCOMPARE(window.windowTitle(), QString("..."))
+ *
+ * Test discovery:
+ *   - Each test class inherits QObject and has Q_OBJECT
+ *   - Test methods are private slots named test_*() or *_test()
+ *   - QTEST_MAIN() generates main() that runs all test slots
+ *
+ * QCOMPARE vs QVERIFY:
+ *   QVERIFY(condition)         — like assert condition
+ *   QCOMPARE(actual, expected) — like assert actual == expected, but prints both values on failure
+ */
+
+#include <QtTest/QtTest>
+#include <QDockWidget>
+#include <QTableWidget>
+#include <QSpinBox>
+#include <QLineEdit>
+#include <QPushButton>
+#include <QCheckBox>
+#include <QComboBox>
+#include <QLabel>
+#include "main_window.h"
+
+class TestMainWindow : public QObject
+{
+    Q_OBJECT
+
+private:
+    MainWindow* m_window;
+
+private slots:
+    // ── Setup/Teardown ──
+    // init() runs BEFORE each test, cleanup() runs AFTER each test.
+    // This gives each test a fresh MainWindow (like pytest fixtures).
+    void init()
+    {
+        m_window = new MainWindow();
+    }
+
+    void cleanup()
+    {
+        delete m_window;
+        m_window = nullptr;
+    }
+
+    // ─── Window Basics ────────────────────────────────────────────
+
+    void test_windowTitle()
+    {
+        QCOMPARE(m_window->windowTitle(), QString("LIN Simulator"));
+    }
+
+    void test_minimumSize()
+    {
+        QVERIFY(m_window->minimumWidth() >= 1024);
+        QVERIFY(m_window->minimumHeight() >= 768);
+    }
+
+    void test_centralWidgetExists()
+    {
+        QVERIFY(m_window->centralWidget() != nullptr);
+    }
+
+    // ─── Menu Bar ─────────────────────────────────────────────────
+
+    void test_menuBarExists()
+    {
+        QVERIFY(m_window->menuBar() != nullptr);
+    }
+
+    void test_loadLdfActionExists()
+    {
+        QVERIFY(m_window->loadLdfAction() != nullptr);
+        QCOMPARE(m_window->loadLdfAction()->text(), QString("&Load LDF..."));
+    }
+
+    void test_loadLdfShortcut()
+    {
+        QCOMPARE(m_window->loadLdfAction()->shortcut().toString(), QString("Ctrl+O"));
+    }
+
+    // ─── LDF Toolbar ──────────────────────────────────────────────
+
+    void test_ldfPathFieldExists()
+    {
+        QVERIFY(m_window->ldfPathEdit() != nullptr);
+        QVERIFY(m_window->ldfPathEdit()->isReadOnly());
+    }
+
+    void test_ldfPathPlaceholder()
+    {
+        QCOMPARE(m_window->ldfPathEdit()->placeholderText(),
+                 QString("No LDF file loaded"));
+    }
+
+    void test_browseButtonExists()
+    {
+        QVERIFY(m_window->browseButton() != nullptr);
+    }
+
+    void test_autoReloadDefaultChecked()
+    {
+        QVERIFY(m_window->autoReloadCheck()->isChecked());
+    }
+
+    // ─── Tx Table ─────────────────────────────────────────────────
+
+    void test_txTableExists()
+    {
+        auto* table = m_window->txTable();
+        QVERIFY(table != nullptr);
+        // qobject_cast is Qt's type-safe dynamic cast.
+        // Returns nullptr if the object isn't the expected type.
+        QVERIFY(qobject_cast<QTableWidget*>(table) != nullptr);
+    }
+
+    void test_txTableColumns()
+    {
+        auto* table = m_window->txTable();
+        QCOMPARE(table->columnCount(), 7);
+
+        QStringList expected = {
+            "Frame Name", "Frame ID", "Length", "Interval (ms)",
+            "Data", "Signals", "Action"
+        };
+        for (int i = 0; i < table->columnCount(); ++i) {
+            QCOMPARE(table->horizontalHeaderItem(i)->text(), expected[i]);
+        }
+    }
+
+    void test_txTableAlternatingColors()
+    {
+        QVERIFY(m_window->txTable()->alternatingRowColors());
+    }
+
+    // ─── Rx Table ─────────────────────────────────────────────────
+
+    void test_rxTableExists()
+    {
+        auto* table = m_window->rxTable();
+        QVERIFY(table != nullptr);
+        QVERIFY(qobject_cast<QTableWidget*>(table) != nullptr);
+    }
+
+    void test_rxTableColumns()
+    {
+        auto* table = m_window->rxTable();
+        QCOMPARE(table->columnCount(), 5);
+
+        QStringList expected = {
+            "Timestamp", "Frame Name", "Frame ID", "Data", "Signals"
+        };
+        for (int i = 0; i < table->columnCount(); ++i) {
+            QCOMPARE(table->horizontalHeaderItem(i)->text(), expected[i]);
+        }
+    }
+
+    void test_rxTableNotEditable()
+    {
+        QCOMPARE(m_window->rxTable()->editTriggers(),
+                 QAbstractItemView::NoEditTriggers);
+    }
+
+    // ─── Connection Dock ──────────────────────────────────────────
+
+    void test_dockExists()
+    {
+        // findChildren<T>() searches the widget tree for all children of type T
+        auto docks = m_window->findChildren<QDockWidget*>();
+        QCOMPARE(docks.size(), 1);
+        QCOMPARE(docks[0]->windowTitle(), QString("Connection"));
+    }
+
+    void test_deviceComboExists()
+    {
+        QVERIFY(m_window->deviceCombo() != nullptr);
+    }
+
+    void test_connectButtonExists()
+    {
+        QVERIFY(m_window->connectButton() != nullptr);
+        QVERIFY(m_window->connectButton()->isEnabled());
+    }
+
+    void test_disconnectButtonDisabledInitially()
+    {
+        QVERIFY(!m_window->disconnectButton()->isEnabled());
+    }
+
+    void test_statusLabelShowsDisconnected()
+    {
+        QVERIFY(m_window->connStatusLabel()->text().contains("Disconnected"));
+    }
+
+    void test_baudRateLabelExists()
+    {
+        QVERIFY(m_window->baudRateLabel() != nullptr);
+    }
+
+    void test_baudRateShowsPlaceholderBeforeLdf()
+    {
+        QVERIFY(m_window->baudRateLabel()->text().contains("load LDF"));
+    }
+
+    // ─── Control Bar ──────────────────────────────────────────────
+
+    void test_scheduleComboExists()
+    {
+        QVERIFY(m_window->scheduleCombo() != nullptr);
+    }
+
+    void test_schedulerButtonsDisabledInitially()
+    {
+        QVERIFY(!m_window->startButton()->isEnabled());
+        QVERIFY(!m_window->stopButton()->isEnabled());
+        QVERIFY(!m_window->pauseButton()->isEnabled());
+    }
+
+    void test_manualSendDisabledInitially()
+    {
+        QVERIFY(!m_window->manualSendButton()->isEnabled());
+    }
+
+    void test_globalRateSpinboxExists()
+    {
+        QVERIFY(m_window->globalRateSpin() != nullptr);
+    }
+
+    void test_globalRateDefault50ms()
+    {
+        QCOMPARE(m_window->globalRateSpin()->value(), 50);
+    }
+
+    void test_globalRateRange()
+    {
+        QCOMPARE(m_window->globalRateSpin()->minimum(), 1);
+        QCOMPARE(m_window->globalRateSpin()->maximum(), 10000);
+    }
+
+    void test_globalRateSuffix()
+    {
+        QCOMPARE(m_window->globalRateSpin()->suffix(), QString(" ms"));
+    }
+
+    // ─── Status Bar ───────────────────────────────────────────────
+
+    void test_statusBarExists()
+    {
+        QVERIFY(m_window->statusBar() != nullptr);
+    }
+
+    void test_connectionStatusLabel()
+    {
+        QVERIFY(m_window->statusConnectionLabel()->text().contains("Disconnected"));
+    }
+};
+
+// QTEST_MAIN generates a main() function that:
+//   1. Creates a QApplication
+//   2. Instantiates TestMainWindow
+//   3. Runs all private slots as test cases
+//   4. Reports results
+QTEST_MAIN(TestMainWindow)
+
+// This #include is required when the test class is defined in a .cpp file
+// (not a .h file). It includes the MOC-generated code for our Q_OBJECT class.
+// Without it, the linker would fail with "undefined reference to vtable".
+#include "test_main_window.moc"
diff --git a/docs/step1_gui_skeleton.md b/docs/step1_gui_skeleton.md
new file mode 100644
index 0000000..4624a4d
--- /dev/null
+++ b/docs/step1_gui_skeleton.md
@@ -0,0 +1,89 @@
+# Step 1 — GUI Skeleton
+
+## What Was Built
+
+The main window layout for the LIN Master Simulator using PyQt6 (Python).
+
+## Architecture
+
+```
+MainWindow (QMainWindow)
+├── Menu Bar
+│   ├── File → Load LDF... (Ctrl+O), Exit (Ctrl+Q)
+│   └── View → Toggle Connection panel
+├── LDF Toolbar (top, fixed)
+│   ├── LDF File path (read-only QLineEdit)
+│   ├── Browse button → opens file dialog
+│   └── Auto-reload checkbox (default: on)
+├── Central Widget
+│   └── QSplitter (vertical, resizable)
+│       ├── Tx Panel (QGroupBox)
+│       │   └── QTableWidget: Frame Name | Frame ID | Length | Interval (ms) | Data | Signals | Action
+│       └── Rx Panel (QGroupBox)
+│           └── QTableWidget: Timestamp | Frame Name | Frame ID | Data | Signals
+├── Connection Dock (QDockWidget, left side, detachable)
+│   ├── Device dropdown + Refresh button
+│   ├── Baud Rate label (read-only, auto-detected from LDF's LIN_speed field)
+│   ├── Connect / Disconnect buttons
+│   ├── Status label (red "Disconnected")
+│   └── Device info label
+├── Control Bar (bottom toolbar, fixed)
+│   ├── Schedule table dropdown
+│   ├── Global Rate (ms) spinbox (1-10000ms, default 50ms)
+│   ├── Start / Stop / Pause buttons (disabled)
+│   └── Send Selected Frame button (disabled)
+└── Status Bar
+    ├── Temporary messages (left)
+    └── Connection indicator (right, permanent)
+```
+
+## Send Rate Hierarchy
+When the scheduler runs, each frame's send interval is determined by priority:
+1. **Per-frame interval** (Tx table "Interval (ms)" column) — highest priority, user override
+2. **Global send rate** (Control bar spinbox) — default fallback for frames with no per-frame interval
+3. **LDF schedule table** — auto-fills per-frame intervals when LDF is loaded
+
+## Key Concepts Introduced
+
+### PyQt6 Widget Tree
+Every visible element is a QWidget. Widgets contain other widgets via layouts.
+The root widget is QMainWindow which provides menu, toolbars, dock areas, and status bar for free.
+
+### Layouts
+- **QVBoxLayout**: stacks widgets vertically
+- **QHBoxLayout**: stacks widgets horizontally
+- **QSplitter**: like a layout but with a draggable divider
+
+### Signals & Slots
+Qt's event system. A signal (e.g., `button.clicked`) connects to a slot (any Python function).
+Example: `self.btn_browse_ldf.clicked.connect(self._on_load_ldf)`
+
+### QDockWidget
+A panel that can be dragged to any window edge, floated, or hidden.
+Used for the Connection panel so users can maximize table space during monitoring.
+
+### Initial Widget States
+Controls that require prerequisites (LDF loaded, device connected) start **disabled**.
+This prevents users from triggering actions that would fail. We enable them as preconditions are met.
+
+## Files
+
+| File | Purpose |
+|------|---------|
+| `python/src/main.py` | Application entry point — creates QApplication, shows MainWindow |
+| `python/src/main_window.py` | MainWindow class — all panel creation and layout |
+| `python/tests/test_main_window.py` | 26 tests verifying widget tree structure and initial states |
+
+## Running
+
+```bash
+# Launch the GUI
+cd python/src && python main.py
+
+# Run tests
+cd python && python -m pytest tests/test_main_window.py -v
+```
+
+## Test Results
+- 32 tests, all passing
+- Tests cover: window properties, menu bar, toolbar, Tx/Rx tables (incl. Interval column), connection dock (incl. baud rate label), control bar (incl. global rate), status bar
diff --git a/python/requirements.txt b/python/requirements.txt
new file mode 100644
index 0000000..ff2bfe0
--- /dev/null
+++ b/python/requirements.txt
@@ -0,0 +1,2 @@
+PyQt6>=6.5.0
+pytest>=7.0.0
diff --git a/python/src/__init__.py b/python/src/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/python/src/main.py b/python/src/main.py
new file mode 100644
index 0000000..6fbfabc
--- /dev/null
+++ b/python/src/main.py
@@ -0,0 +1,74 @@
+"""
+main.py — Application entry point for the LIN Simulator.
+
+HOW A PyQt6 APPLICATION STARTS:
+================================
+
+Every Qt application needs exactly ONE QApplication instance. This object:
+  1. Manages the event loop (listens for mouse clicks, key presses, timers, etc.)
+  2. Holds application-wide settings (style, font, etc.)
+  3. Routes events to the correct widget
+
+The event loop is the core of any GUI application:
+
+    ┌─────────────────────────────┐
+    │     app.exec() starts       │
+    │     the EVENT LOOP          │
+    │                             │
+    │  ┌───────────────────────┐  │
+    │  │ Wait for event        │◄─┼── Mouse click, key press,
+    │  │ (blocking)            │  │   timer tick, signal, etc.
+    │  ├───────────────────────┤  │
+    │  │ Dispatch event to     │  │
+    │  │ correct widget        │──┼── Widget processes it
+    │  ├───────────────────────┤  │
+    │  │ Widget emits signals  │  │
+    │  │ → connected slots run │  │
+    │  └───────┬───────────────┘  │
+    │          │ loop back        │
+    │          └──────────────────│
+    │                             │
+    │  Loop exits when last       │
+    │  window is closed           │
+    └─────────────────────────────┘
+
+sys.exit(app.exec()) ensures the process exit code matches
+Qt's exit code (0 = normal, non-zero = error).
+"""
+
+import sys
+from pathlib import Path
+from PyQt6.QtWidgets import QApplication
+from PyQt6.QtGui import QIcon
+from main_window import MainWindow
+
+
+def main():
+    # Step 1: Create the application object.
+    # sys.argv is passed so Qt can process command-line arguments
+    # like --style, --platform, etc.
+    app = QApplication(sys.argv)
+
+    # Optional: set application metadata (used by OS for window grouping, etc.)
+    app.setApplicationName("LIN Simulator")
+    app.setOrganizationName("TeqanyLogix LTD")
+
+    # Set application icon — used in the taskbar, window title bar, and dock.
+    # Path resolves relative to this script's location: src/ → ../../resources/
+    icon_path = Path(__file__).parent.parent.parent / "resources" / "logo.png"
+    if icon_path.exists():
+        app.setWindowIcon(QIcon(str(icon_path)))
+
+    # Step 2: Create and show the main window.
+    # show() makes it visible — without this call, the window exists but is hidden.
+    window = MainWindow()
+    window.show()
+
+    # Step 3: Enter the event loop.
+    # This call BLOCKS until the application exits (all windows closed).
+    # sys.exit() ensures the process returns Qt's exit code to the OS.
+    sys.exit(app.exec())
+
+
+if __name__ == "__main__":
+    main()
diff --git a/python/src/main_window.py b/python/src/main_window.py
new file mode 100644
index 0000000..a64a377
--- /dev/null
+++ b/python/src/main_window.py
@@ -0,0 +1,547 @@
+"""
+main_window.py — The root window of the LIN Simulator.
+
+ARCHITECTURE OVERVIEW:
+======================
+QMainWindow is Qt's specialized top-level window. Unlike a plain QWidget,
+it has built-in support for:
+  - Menu bar (File, Edit, Help menus)
+  - Toolbars (icon buttons at the top)
+  - Dock widgets (panels that can float or snap to edges)
+  - Status bar (info text at the bottom)
+  - Central widget (the main content area)
+
+Our layout strategy:
+┌─────────────────────────────────────────────────┐
+│  Menu Bar (File > Load LDF, Exit)               │
+├─────────────────────────────────────────────────┤
+│  LDF Toolbar: [path field] [Browse] [Auto-reload indicator] │
+├──────────┬──────────────────────────────────────┤
+│          │  Tx Panel (QGroupBox)                │
+│ Connect  │    QTableWidget (frames/signals)     │
+│ Panel    │──────────────────────────────────────│
+│ (Dock)   │  Rx Panel (QGroupBox)                │
+│          │    QTableWidget (timestamp/frames)   │
+├──────────┴──────────────────────────────────────┤
+│  Control Bar: [Start] [Stop] [Send] | Status    │
+└─────────────────────────────────────────────────┘
+
+The Connection Panel is a QDockWidget — meaning the user can:
+  - Drag it to any edge of the window
+  - Undock it to a floating window
+  - Close/reopen it from the View menu
+This is useful because during normal operation you might want more
+space for Tx/Rx tables and hide the connection panel.
+"""
+
+from PyQt6.QtWidgets import (
+    QMainWindow,       # The root window class
+    QWidget,           # Base class for all UI objects
+    QVBoxLayout,       # Arranges widgets vertically (top to bottom)
+    QHBoxLayout,       # Arranges widgets horizontally (left to right)
+    QSplitter,         # Resizable divider between two widgets
+    QGroupBox,         # Labeled border around a group of widgets
+    QTableWidget,      # Table with rows and columns
+    QHeaderView,       # Controls table header behavior (resize modes)
+    QDockWidget,       # Detachable/dockable panel
+    QToolBar,          # Row of tool buttons/widgets
+    QStatusBar,        # Bottom info bar
+    QLabel,            # Static text display
+    QLineEdit,         # Single-line text input
+    QPushButton,       # Clickable button
+    QComboBox,         # Dropdown selector
+    QCheckBox,         # Checkbox toggle
+    QSpinBox,          # Numeric input with up/down arrows
+    QFileDialog,       # OS-native file picker dialog
+    QMessageBox,       # Modal dialog for messages (info, warning, about)
+)
+from PyQt6.QtCore import Qt, QSize
+from PyQt6.QtGui import QAction
+
+
+class MainWindow(QMainWindow):
+    """
+    The main application window.
+
+    QMainWindow provides the framework — we fill in the content by:
+    1. Setting up the menu bar       → _create_menu_bar()
+    2. Setting up the LDF toolbar    → _create_ldf_toolbar()
+    3. Creating the central widget   → _create_central_widget()
+    4. Adding the connection dock     → _create_connection_dock()
+    5. Adding the control bar         → _create_control_bar()
+    6. Setting up the status bar      → _create_status_bar()
+    """
+
+    def __init__(self):
+        # super().__init__() calls QMainWindow's constructor.
+        # This is required — Qt needs to initialize its internal C++ object.
+        super().__init__()
+
+        # Window properties
+        self.setWindowTitle("LIN Simulator")
+        self.setMinimumSize(QSize(1024, 768))  # Minimum usable size
+
+        # Build the UI in logical order
+        self._create_menu_bar()
+        self._create_ldf_toolbar()
+        self._create_central_widget()
+        self._create_connection_dock()
+        self._create_control_bar()
+        self._create_status_bar()
+
+    # ─── Menu Bar ──────────────────────────────────────────────────────
+
+    def _create_menu_bar(self):
+        """
+        Menu bar sits at the very top of the window (or macOS system bar).
+
+        QAction represents a single menu item. It can have:
+          - Text ("Load LDF...")
+          - Shortcut (Ctrl+O)
+          - A connected slot (function to call when triggered)
+
+        We use QAction so the same action can appear in both the menu
+        AND a toolbar button, sharing the same shortcut and behavior.
+        """
+        menu_bar = self.menuBar()  # QMainWindow provides this built-in
+
+        # ── File menu ──
+        file_menu = menu_bar.addMenu("&File")
+        # The '&' before 'F' makes it an Alt+F keyboard accelerator
+
+        # Load LDF action
+        self.action_load_ldf = QAction("&Load LDF...", self)
+        self.action_load_ldf.setShortcut("Ctrl+O")
+        self.action_load_ldf.setStatusTip("Load a LIN Description File")
+        self.action_load_ldf.triggered.connect(self._on_load_ldf)
+        file_menu.addAction(self.action_load_ldf)
+
+        file_menu.addSeparator()  # Visual divider line
+
+        # Exit action
+        action_exit = QAction("E&xit", self)
+        action_exit.setShortcut("Ctrl+Q")
+        action_exit.triggered.connect(self.close)  # close() is built into QMainWindow
+        file_menu.addAction(action_exit)
+
+        # ── View menu ── (will be used to toggle dock widget visibility)
+        self.view_menu = menu_bar.addMenu("&View")
+
+        # ── Help menu ──
+        help_menu = menu_bar.addMenu("&Help")
+
+        action_about = QAction("&About", self)
+        action_about.triggered.connect(self._on_about)
+        help_menu.addAction(action_about)
+
+    # ─── LDF Toolbar ───────────────────────────────────────────────────
+
+    def _create_ldf_toolbar(self):
+        """
+        Toolbar for LDF file management.
+
+        QToolBar is a horizontal bar that can hold widgets (not just buttons).
+        We add a QLineEdit to show the file path and a browse button.
+
+        The auto-reload checkbox uses QFileSystemWatcher (added in Step 2)
+        to detect when the LDF file changes on disk and automatically re-parse it.
+        """
+        toolbar = QToolBar("LDF File")
+        toolbar.setMovable(False)  # Keep it fixed at the top
+        self.addToolBar(toolbar)
+
+        toolbar.addWidget(QLabel("  LDF File: "))
+
+        # Path display — read-only, shows the currently loaded file path
+        self.ldf_path_edit = QLineEdit()
+        self.ldf_path_edit.setReadOnly(True)
+        self.ldf_path_edit.setPlaceholderText("No LDF file loaded")
+        self.ldf_path_edit.setMinimumWidth(300)
+        toolbar.addWidget(self.ldf_path_edit)
+
+        # Browse button — opens a file dialog
+        self.btn_browse_ldf = QPushButton("Browse...")
+        self.btn_browse_ldf.clicked.connect(self._on_load_ldf)
+        toolbar.addWidget(self.btn_browse_ldf)
+
+        # Auto-reload toggle
+        self.chk_auto_reload = QCheckBox("Auto-reload")
+        self.chk_auto_reload.setChecked(True)  # On by default
+        self.chk_auto_reload.setToolTip(
+            "Automatically reload the LDF file when it changes on disk"
+        )
+        toolbar.addWidget(self.chk_auto_reload)
+
+    # ─── Central Widget (Tx + Rx Panels) ──────────────────────────────
+
+    def _create_central_widget(self):
+        """
+        The central widget is the main content area of QMainWindow.
+
+        We use a QSplitter to divide it into Tx (top) and Rx (bottom) panels.
+        QSplitter lets the user drag the divider to resize the panels.
+
+        Layout hierarchy:
+          QWidget (central)
+            └── QVBoxLayout
+                 └── QSplitter (vertical)
+                      ├── QGroupBox "Tx Frames (Master → Slave)"
+                      │    └── QVBoxLayout
+                      │         └── QTableWidget
+                      └── QGroupBox "Rx Frames (Slave → Master)"
+                           └── QVBoxLayout
+                                └── QTableWidget
+        """
+        central = QWidget()
+        layout = QVBoxLayout(central)
+        # setContentsMargins(left, top, right, bottom) — padding around the layout
+        layout.setContentsMargins(4, 4, 4, 4)
+
+        # QSplitter orientation: Vertical means the divider is horizontal
+        # (widgets stack top/bottom). This is a common source of confusion!
+        splitter = QSplitter(Qt.Orientation.Vertical)
+
+        # ── Tx Panel ──
+        tx_group = QGroupBox("Tx Frames (Master → Slave)")
+        tx_layout = QVBoxLayout(tx_group)
+        self.tx_table = self._create_tx_table()
+        tx_layout.addWidget(self.tx_table)
+        splitter.addWidget(tx_group)
+
+        # ── Rx Panel ──
+        rx_group = QGroupBox("Rx Frames (Slave → Master)")
+        rx_layout = QVBoxLayout(rx_group)
+        self.rx_table = self._create_rx_table()
+        rx_layout.addWidget(self.rx_table)
+        splitter.addWidget(rx_group)
+
+        # Set initial size ratio: 50% Tx, 50% Rx
+        # setSizes() takes pixel heights — these are proportional when the window resizes
+        splitter.setSizes([400, 400])
+
+        layout.addWidget(splitter)
+        self.setCentralWidget(central)
+
+    def _create_tx_table(self):
+        """
+        Create the Tx (transmit) frames table.
+
+        QTableWidget is a ready-to-use table. For our Tx panel:
+          - Frame Name:    LIN frame identifier (e.g., "BCM_Command")
+          - Frame ID:      Hex ID (e.g., 0x3C)
+          - Length:        Data bytes count (1-8)
+          - Interval (ms): Per-frame send rate in milliseconds. Overrides the
+                           global rate. Auto-filled from LDF schedule table
+                           slot delays, but user can edit for testing.
+          - Data:          Raw hex bytes (e.g., "FF 00 A3 00 00 00 00 00")
+          - Signals:       Decoded signal summary (filled in Step 3)
+          - Action:        Send button per row (filled in Step 3)
+
+        QHeaderView.ResizeMode controls how columns resize:
+          - Stretch: fills available space (good for Data/Signals)
+          - ResizeToContents: fits the content width (good for ID/Length)
+        """
+        table = QTableWidget()
+        table.setColumnCount(7)
+        table.setHorizontalHeaderLabels(
+            ["Frame Name", "Frame ID", "Length", "Interval (ms)",
+             "Data", "Signals", "Action"]
+        )
+
+        # Configure header resize behavior
+        header = table.horizontalHeader()
+        header.setSectionResizeMode(0, QHeaderView.ResizeMode.Stretch)       # Frame Name
+        header.setSectionResizeMode(1, QHeaderView.ResizeMode.ResizeToContents)  # ID
+        header.setSectionResizeMode(2, QHeaderView.ResizeMode.ResizeToContents)  # Length
+        header.setSectionResizeMode(3, QHeaderView.ResizeMode.ResizeToContents)  # Interval
+        header.setSectionResizeMode(4, QHeaderView.ResizeMode.Stretch)       # Data
+        header.setSectionResizeMode(5, QHeaderView.ResizeMode.Stretch)       # Signals
+        header.setSectionResizeMode(6, QHeaderView.ResizeMode.ResizeToContents)  # Action
+
+        # Alternating row colors improve readability
+        table.setAlternatingRowColors(True)
+
+        # Select entire rows, not individual cells
+        table.setSelectionBehavior(
+            QTableWidget.SelectionBehavior.SelectRows
+        )
+
+        return table
+
+    def _create_rx_table(self):
+        """
+        Create the Rx (receive) frames table.
+
+        Similar to Tx but with a Timestamp column and no Action column.
+        The Timestamp shows when each frame was received — critical for
+        debugging LIN bus timing issues.
+
+        In Step 4, this table will auto-scroll as new frames arrive
+        and support pausing/resuming the scroll.
+        """
+        table = QTableWidget()
+        table.setColumnCount(5)
+        table.setHorizontalHeaderLabels(
+            ["Timestamp", "Frame Name", "Frame ID", "Data", "Signals"]
+        )
+
+        header = table.horizontalHeader()
+        header.setSectionResizeMode(0, QHeaderView.ResizeMode.ResizeToContents)  # Timestamp
+        header.setSectionResizeMode(1, QHeaderView.ResizeMode.Stretch)       # Frame Name
+        header.setSectionResizeMode(2, QHeaderView.ResizeMode.ResizeToContents)  # ID
+        header.setSectionResizeMode(3, QHeaderView.ResizeMode.Stretch)       # Data
+        header.setSectionResizeMode(4, QHeaderView.ResizeMode.Stretch)       # Signals
+
+        table.setAlternatingRowColors(True)
+        table.setSelectionBehavior(
+            QTableWidget.SelectionBehavior.SelectRows
+        )
+
+        # Rx table is read-only — user can't edit received data
+        table.setEditTriggers(QTableWidget.EditTrigger.NoEditTriggers)
+
+        return table
+
+    # ─── Connection Dock Widget ────────────────────────────────────────
+
+    def _create_connection_dock(self):
+        """
+        Connection panel as a QDockWidget.
+
+        QDockWidget is special — it can:
+          1. Dock to any edge (left/right/top/bottom) of the main window
+          2. Float as a separate window
+          3. Be closed and reopened from the View menu
+
+        This makes the UI flexible: during setup, the user needs the
+        connection panel visible. During monitoring, they can hide it
+        to maximize table space.
+
+        Layout inside the dock:
+          QWidget (container)
+            └── QVBoxLayout
+                 ├── QLabel "Device:"
+                 ├── QHBoxLayout
+                 │    ├── QComboBox (device list)
+                 │    └── QPushButton "Refresh"
+                 ├── QLabel "Baud Rate:"
+                 ├── QComboBox (9600, 19200, 20000 + editable for custom)
+                 ├── QHBoxLayout
+                 │    ├── QPushButton "Connect"
+                 │    └── QPushButton "Disconnect"
+                 ├── QLabel "Status: Disconnected"
+                 └── QLabel "Device Info: —"
+        """
+        dock = QDockWidget("Connection", self)
+
+        # Allow docking on left and right edges only
+        dock.setAllowedAreas(
+            Qt.DockWidgetArea.LeftDockWidgetArea
+            | Qt.DockWidgetArea.RightDockWidgetArea
+        )
+
+        # Build the dock's content
+        container = QWidget()
+        layout = QVBoxLayout(container)
+
+        # ── Device selection ──
+        layout.addWidget(QLabel("Device:"))
+
+        device_row = QHBoxLayout()
+        self.combo_device = QComboBox()
+        self.combo_device.setPlaceholderText("Select device...")
+        self.combo_device.setMinimumWidth(150)
+        device_row.addWidget(self.combo_device)
+
+        self.btn_refresh = QPushButton("Refresh")
+        self.btn_refresh.setToolTip("Scan for connected BabyLIN devices")
+        device_row.addWidget(self.btn_refresh)
+        layout.addLayout(device_row)
+
+        # ── Baud rate display (read-only) ──
+        # LIN bus speed is defined in the LDF file's LIN_speed field.
+        # This is NOT user-editable — it's extracted from the LDF when loaded
+        # (Step 2). The BabyLIN device must be configured to match this rate.
+        # Shows "—" until an LDF is loaded.
+        layout.addWidget(QLabel("Baud Rate:"))
+        self.lbl_baud_rate = QLabel("— (load LDF)")
+        self.lbl_baud_rate.setStyleSheet("font-weight: bold;")
+        self.lbl_baud_rate.setToolTip(
+            "LIN bus baud rate — automatically detected from the LDF file"
+        )
+        layout.addWidget(self.lbl_baud_rate)
+
+        # ── Connect / Disconnect buttons ──
+        btn_row = QHBoxLayout()
+        self.btn_connect = QPushButton("Connect")
+        self.btn_disconnect = QPushButton("Disconnect")
+        self.btn_disconnect.setEnabled(False)  # Disabled until connected
+        btn_row.addWidget(self.btn_connect)
+        btn_row.addWidget(self.btn_disconnect)
+        layout.addLayout(btn_row)
+
+        # ── Status display ──
+        self.lbl_conn_status = QLabel("Status: Disconnected")
+        self.lbl_conn_status.setStyleSheet("color: red; font-weight: bold;")
+        layout.addWidget(self.lbl_conn_status)
+
+        # ── Device info ──
+        self.lbl_device_info = QLabel("Device Info: —")
+        layout.addWidget(self.lbl_device_info)
+
+        # Push everything to the top, remaining space below
+        layout.addStretch()
+
+        dock.setWidget(container)
+
+        # Add dock to the LEFT side of the main window
+        self.addDockWidget(Qt.DockWidgetArea.LeftDockWidgetArea, dock)
+
+        # Add a toggle action to the View menu so user can show/hide this panel
+        self.view_menu.addAction(dock.toggleViewAction())
+
+    # ─── Control Bar (Bottom Toolbar) ──────────────────────────────────
+
+    def _create_control_bar(self):
+        """
+        Bottom toolbar with scheduler and manual send controls.
+
+        We use addToolBar with Qt.ToolBarArea.BottomToolBarArea to place
+        this at the bottom of the window. It contains:
+          - Schedule table selector
+          - Global send rate (default interval for all frames)
+          - Start/Stop/Pause buttons for the scheduler
+          - A manual "Send Frame" button
+
+        SEND RATE HIERARCHY:
+          1. Per-frame interval (Tx table "Interval (ms)" column) — highest priority
+          2. Global send rate (this toolbar's spinbox) — default fallback
+          3. LDF schedule table slot delays — auto-fill source for per-frame
+
+        In Step 7, the scheduler will use QTimer to periodically send
+        frames according to the selected schedule table from the LDF.
+        """
+        toolbar = QToolBar("Controls")
+        toolbar.setMovable(False)
+        self.addToolBar(Qt.ToolBarArea.BottomToolBarArea, toolbar)
+
+        # ── Schedule table selector ──
+        toolbar.addWidget(QLabel("  Schedule: "))
+        self.combo_schedule = QComboBox()
+        self.combo_schedule.setPlaceholderText("No schedule loaded")
+        self.combo_schedule.setMinimumWidth(200)
+        toolbar.addWidget(self.combo_schedule)
+
+        toolbar.addSeparator()
+
+        # ── Global send rate ──
+        # QSpinBox provides a numeric input with up/down arrows and
+        # min/max/step constraints. This sets the default interval (in ms)
+        # between frame transmissions. Individual frames can override this
+        # via the "Interval (ms)" column in the Tx table.
+        #
+        # Range: 1ms to 10000ms (10 seconds)
+        #   - 10ms  = 100 frames/sec (aggressive, for stress testing)
+        #   - 50ms  = 20 frames/sec (typical LIN schedule)
+        #   - 100ms = 10 frames/sec (relaxed)
+        toolbar.addWidget(QLabel("  Global Rate (ms): "))
+        self.spin_global_rate = QSpinBox()
+        self.spin_global_rate.setRange(1, 10000)
+        self.spin_global_rate.setValue(50)        # 50ms default = 20 frames/sec
+        self.spin_global_rate.setSingleStep(10)   # Up/down arrows change by 10ms
+        self.spin_global_rate.setSuffix(" ms")    # Display "50 ms" in the box
+        self.spin_global_rate.setToolTip(
+            "Default send interval for all frames. "
+            "Per-frame intervals in the Tx table override this."
+        )
+        toolbar.addWidget(self.spin_global_rate)
+
+        toolbar.addSeparator()
+
+        # ── Scheduler controls ──
+        self.btn_start = QPushButton("▶ Start")
+        self.btn_stop = QPushButton("■ Stop")
+        self.btn_pause = QPushButton("⏸ Pause")
+
+        # Initially disabled — enabled when LDF is loaded and device connected
+        self.btn_start.setEnabled(False)
+        self.btn_stop.setEnabled(False)
+        self.btn_pause.setEnabled(False)
+
+        toolbar.addWidget(self.btn_start)
+        toolbar.addWidget(self.btn_stop)
+        toolbar.addWidget(self.btn_pause)
+
+        toolbar.addSeparator()
+
+        # ── Manual send ──
+        self.btn_manual_send = QPushButton("Send Selected Frame")
+        self.btn_manual_send.setEnabled(False)
+        toolbar.addWidget(self.btn_manual_send)
+
+    # ─── Status Bar ────────────────────────────────────────────────────
+
+    def _create_status_bar(self):
+        """
+        Status bar at the very bottom of the window.
+
+        QStatusBar can show:
+          - Temporary messages (disappear after a timeout)
+          - Permanent widgets (always visible, e.g., connection indicator)
+
+        We add a permanent label on the right side for the connection state,
+        and use showMessage() for transient feedback like "LDF loaded successfully".
+        """
+        status_bar = QStatusBar()
+        self.setStatusBar(status_bar)
+
+        # Permanent connection status on the right side
+        self.lbl_status_connection = QLabel("● Disconnected")
+        self.lbl_status_connection.setStyleSheet("color: red;")
+        status_bar.addPermanentWidget(self.lbl_status_connection)
+
+        # Show initial message
+        status_bar.showMessage("Ready — Load an LDF file to begin", 5000)
+        # 5000 = message disappears after 5 seconds
+
+    # ─── Slot: Load LDF ───────────────────────────────────────────────
+
+    def _on_load_ldf(self):
+        """
+        Slot connected to the Load LDF action and Browse button.
+
+        QFileDialog.getOpenFileName() opens the OS-native file picker.
+        It returns a tuple: (file_path, selected_filter).
+        If the user cancels, file_path is an empty string.
+
+        The actual parsing happens in Step 2 — for now we just show
+        the selected path.
+        """
+        file_path, _ = QFileDialog.getOpenFileName(
+            self,                              # Parent window
+            "Open LIN Description File",       # Dialog title
+            "",                                # Starting directory (empty = last used)
+            "LDF Files (*.ldf);;All Files (*)" # File type filters
+        )
+
+        if file_path:
+            self.ldf_path_edit.setText(file_path)
+            self.statusBar().showMessage(f"LDF file selected: {file_path}", 3000)
+
+    # ─── Slot: About ──────────────────────────────────────────────────
+
+    def _on_about(self):
+        """Show the About dialog with ownership and developer information."""
+        QMessageBox.about(
+            self,
+            "About LIN Simulator",
+            "<h2>LIN Simulator</h2>"
+            "<p>Version 0.1.0</p>"
+            "<p>A cross-platform tool for simulating LIN master nodes "
+            "using BabyLIN devices.</p>"
+            "<hr>"
+            "<p><b>Owner:</b> TeqanyLogix LTD</p>"
+            "<p><b>Developer:</b> Mohamed Salem</p>"
+            "<hr>"
+            "<p>&copy; 2026 TeqanyLogix LTD. All rights reserved.</p>"
+        )
diff --git a/python/tests/__init__.py b/python/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/python/tests/test_main_window.py b/python/tests/test_main_window.py
new file mode 100644
index 0000000..8840c47
--- /dev/null
+++ b/python/tests/test_main_window.py
@@ -0,0 +1,207 @@
+"""
+test_main_window.py — Tests for the GUI skeleton (Step 1).
+
+TESTING PyQt6 APPLICATIONS:
+============================
+GUI testing has a challenge: Qt widgets need a running QApplication.
+We use a pytest fixture to create ONE QApplication for the entire test session.
+
+Key things we verify:
+  1. Window creates without errors
+  2. All panels exist and are the correct widget types
+  3. Tables have the right columns
+  4. Buttons and controls are in the expected initial state
+  5. Window has a reasonable minimum size
+
+We do NOT test visual appearance (that's manual testing).
+We DO test that the widget tree is correctly assembled.
+"""
+
+import sys
+import pytest
+
+# Add src to path so we can import our modules
+sys.path.insert(0, str(__import__("pathlib").Path(__file__).parent.parent / "src"))
+
+from PyQt6.QtWidgets import QApplication, QDockWidget, QTableWidget
+from PyQt6.QtCore import Qt
+
+
+# ─── Fixtures ──────────────────────────────────────────────────────────
+# Fixtures are pytest's way of providing shared setup. The "session" scope
+# means this QApplication is created once and reused across ALL tests.
+
+@pytest.fixture(scope="session")
+def app():
+    """Create a QApplication instance for the test session."""
+    application = QApplication.instance() or QApplication(sys.argv)
+    yield application
+
+
+@pytest.fixture
+def window(app):
+    """Create a fresh MainWindow for each test."""
+    from main_window import MainWindow
+    w = MainWindow()
+    yield w
+    w.close()
+
+
+# ─── Tests ─────────────────────────────────────────────────────────────
+
+class TestWindowBasics:
+    """Test that the window initializes correctly."""
+
+    def test_window_title(self, window):
+        assert window.windowTitle() == "LIN Simulator"
+
+    def test_minimum_size(self, window):
+        assert window.minimumWidth() >= 1024
+        assert window.minimumHeight() >= 768
+
+    def test_central_widget_exists(self, window):
+        assert window.centralWidget() is not None
+
+
+class TestMenuBar:
+    """Test menu bar structure."""
+
+    def test_menu_bar_exists(self, window):
+        assert window.menuBar() is not None
+
+    def test_load_ldf_action_exists(self, window):
+        assert window.action_load_ldf is not None
+        assert window.action_load_ldf.text() == "&Load LDF..."
+
+    def test_load_ldf_shortcut(self, window):
+        assert window.action_load_ldf.shortcut().toString() == "Ctrl+O"
+
+
+class TestLdfToolbar:
+    """Test the LDF file toolbar."""
+
+    def test_ldf_path_field_exists(self, window):
+        assert window.ldf_path_edit is not None
+        assert window.ldf_path_edit.isReadOnly()
+
+    def test_ldf_path_placeholder(self, window):
+        assert window.ldf_path_edit.placeholderText() == "No LDF file loaded"
+
+    def test_browse_button_exists(self, window):
+        assert window.btn_browse_ldf is not None
+
+    def test_auto_reload_default_checked(self, window):
+        assert window.chk_auto_reload.isChecked()
+
+
+class TestTxTable:
+    """Test the Tx (transmit) table structure."""
+
+    def test_tx_table_exists(self, window):
+        assert isinstance(window.tx_table, QTableWidget)
+
+    def test_tx_table_columns(self, window):
+        assert window.tx_table.columnCount() == 7
+        headers = []
+        for i in range(window.tx_table.columnCount()):
+            headers.append(window.tx_table.horizontalHeaderItem(i).text())
+        assert headers == [
+            "Frame Name", "Frame ID", "Length", "Interval (ms)",
+            "Data", "Signals", "Action"
+        ]
+
+    def test_tx_table_alternating_colors(self, window):
+        assert window.tx_table.alternatingRowColors()
+
+
+class TestRxTable:
+    """Test the Rx (receive) table structure."""
+
+    def test_rx_table_exists(self, window):
+        assert isinstance(window.rx_table, QTableWidget)
+
+    def test_rx_table_columns(self, window):
+        assert window.rx_table.columnCount() == 5
+        headers = []
+        for i in range(window.rx_table.columnCount()):
+            headers.append(window.rx_table.horizontalHeaderItem(i).text())
+        assert headers == ["Timestamp", "Frame Name", "Frame ID", "Data", "Signals"]
+
+    def test_rx_table_not_editable(self, window):
+        """Rx table should be read-only — users can't edit received data."""
+        assert (
+            window.rx_table.editTriggers()
+            == QTableWidget.EditTrigger.NoEditTriggers
+        )
+
+
+class TestConnectionDock:
+    """Test the connection panel dock widget."""
+
+    def test_dock_exists(self, window):
+        docks = window.findChildren(QDockWidget)
+        assert len(docks) == 1
+        assert docks[0].windowTitle() == "Connection"
+
+    def test_device_combo_exists(self, window):
+        assert window.combo_device is not None
+
+    def test_connect_button_exists(self, window):
+        assert window.btn_connect is not None
+        assert window.btn_connect.isEnabled()
+
+    def test_disconnect_button_disabled_initially(self, window):
+        """Disconnect should be disabled when no device is connected."""
+        assert not window.btn_disconnect.isEnabled()
+
+    def test_status_label_shows_disconnected(self, window):
+        assert "Disconnected" in window.lbl_conn_status.text()
+
+    def test_baud_rate_label_exists(self, window):
+        assert window.lbl_baud_rate is not None
+
+    def test_baud_rate_shows_placeholder_before_ldf(self, window):
+        """Before loading an LDF, baud rate should show a placeholder."""
+        assert "load LDF" in window.lbl_baud_rate.text()
+
+
+class TestControlBar:
+    """Test the bottom control toolbar."""
+
+    def test_schedule_combo_exists(self, window):
+        assert window.combo_schedule is not None
+
+    def test_scheduler_buttons_disabled_initially(self, window):
+        """Start/Stop/Pause should be disabled until LDF loaded + connected."""
+        assert not window.btn_start.isEnabled()
+        assert not window.btn_stop.isEnabled()
+        assert not window.btn_pause.isEnabled()
+
+    def test_manual_send_disabled_initially(self, window):
+        assert not window.btn_manual_send.isEnabled()
+
+    def test_global_rate_spinbox_exists(self, window):
+        assert window.spin_global_rate is not None
+
+    def test_global_rate_default_50ms(self, window):
+        """50ms default = ~20 frames/sec, typical LIN schedule speed."""
+        assert window.spin_global_rate.value() == 50
+
+    def test_global_rate_range(self, window):
+        """Range should be 1ms (fast stress test) to 10000ms (very slow)."""
+        assert window.spin_global_rate.minimum() == 1
+        assert window.spin_global_rate.maximum() == 10000
+
+    def test_global_rate_suffix(self, window):
+        """Should display the unit 'ms' in the spinbox."""
+        assert window.spin_global_rate.suffix() == " ms"
+
+
+class TestStatusBar:
+    """Test the status bar."""
+
+    def test_status_bar_exists(self, window):
+        assert window.statusBar() is not None
+
+    def test_connection_status_label(self, window):
+        assert "Disconnected" in window.lbl_status_connection.text()
diff --git a/resources/logo.png b/resources/logo.png
new file mode 100644
index 0000000000000000000000000000000000000000..c7de099b2c264d743b8006942aa9345115959673
GIT binary patch
literal 77417
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
SlotZvpSr4!N(ss;<o^KE!oAG^

literal 0
HcmV?d00001

diff --git a/resources/logo.svg b/resources/logo.svg
new file mode 100644
index 0000000..168e5c7
--- /dev/null
+++ b/resources/logo.svg
@@ -0,0 +1,75 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" width="512" height="512">
+  <defs>
+    <!-- Gradient for the main circle background -->
+    <linearGradient id="bgGrad" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" style="stop-color:#1a237e;stop-opacity:1" />
+      <stop offset="100%" style="stop-color:#0d47a1;stop-opacity:1" />
+    </linearGradient>
+    <!-- Gradient for the LIN waveform glow -->
+    <linearGradient id="waveGrad" x1="0%" y1="0%" x2="100%" y2="0%">
+      <stop offset="0%" style="stop-color:#00e676;stop-opacity:1" />
+      <stop offset="50%" style="stop-color:#69f0ae;stop-opacity:1" />
+      <stop offset="100%" style="stop-color:#00e676;stop-opacity:1" />
+    </linearGradient>
+    <!-- Glow filter for the waveform -->
+    <filter id="glow" x="-20%" y="-20%" width="140%" height="140%">
+      <feGaussianBlur stdDeviation="4" result="blur"/>
+      <feMerge>
+        <feMergeNode in="blur"/>
+        <feMergeNode in="SourceGraphic"/>
+      </feMerge>
+    </filter>
+    <!-- Subtle shadow for the circle -->
+    <filter id="shadow" x="-10%" y="-10%" width="120%" height="130%">
+      <feDropShadow dx="0" dy="4" stdDeviation="8" flood-color="#000" flood-opacity="0.3"/>
+    </filter>
+  </defs>
+
+  <!-- Main circle background -->
+  <circle cx="256" cy="256" r="240" fill="url(#bgGrad)" filter="url(#shadow)"/>
+
+  <!-- Outer ring -->
+  <circle cx="256" cy="256" r="240" fill="none" stroke="#42a5f5" stroke-width="4" opacity="0.6"/>
+
+  <!-- Inner subtle ring -->
+  <circle cx="256" cy="256" r="210" fill="none" stroke="#1565c0" stroke-width="1.5" opacity="0.4"/>
+
+  <!-- LIN bus waveform — characteristic digital signal pattern
+       LIN uses UART-style: dominant (low) and recessive (high) states
+       This shows a sync break + sync field + data pattern -->
+  <g filter="url(#glow)">
+    <!-- Main waveform line -->
+    <polyline
+      points="70,300 110,300 110,200 150,200 150,300 170,300 170,200 210,200 210,300 230,300 230,200 290,200 290,300 310,300 310,200 340,200 340,300 380,300 380,200 400,200 400,300 440,300"
+      fill="none"
+      stroke="url(#waveGrad)"
+      stroke-width="6"
+      stroke-linecap="round"
+      stroke-linejoin="round"
+    />
+  </g>
+
+  <!-- Small node dots representing master and slave nodes on the bus -->
+  <!-- Master node (left, larger) -->
+  <circle cx="90" cy="300" r="10" fill="#ffd740" stroke="#ff8f00" stroke-width="2"/>
+  <!-- Slave node indicators along the bus -->
+  <circle cx="190" cy="200" r="6" fill="#80cbc4" stroke="#00897b" stroke-width="1.5"/>
+  <circle cx="310" cy="200" r="6" fill="#80cbc4" stroke="#00897b" stroke-width="1.5"/>
+  <circle cx="440" cy="300" r="6" fill="#80cbc4" stroke="#00897b" stroke-width="1.5"/>
+
+  <!-- "LIN" text -->
+  <text x="256" y="170" text-anchor="middle" font-family="Arial, Helvetica, sans-serif" font-weight="bold" font-size="72" fill="#ffffff" letter-spacing="8">LIN</text>
+
+  <!-- "SIMULATOR" text below waveform -->
+  <text x="256" y="380" text-anchor="middle" font-family="Arial, Helvetica, sans-serif" font-weight="600" font-size="32" fill="#90caf9" letter-spacing="6">SIMULATOR</text>
+
+  <!-- Small connection arrows indicating bidirectional communication -->
+  <!-- Tx arrow (down) -->
+  <polygon points="130,340 140,355 120,355" fill="#ffd740" opacity="0.7"/>
+  <!-- Rx arrow (up) -->
+  <polygon points="370,355 380,340 360,340" fill="#80cbc4" opacity="0.7"/>
+
+  <!-- Tx/Rx labels -->
+  <text x="130" y="372" text-anchor="middle" font-family="Arial, Helvetica, sans-serif" font-size="14" fill="#ffd740" opacity="0.8">Tx</text>
+  <text x="370" y="372" text-anchor="middle" font-family="Arial, Helvetica, sans-serif" font-size="14" fill="#80cbc4" opacity="0.8">Rx</text>
+</svg>