refactor(framwork): flesh out more headers

framework/include/toon_boom/toolbar.hpp

@@ -0,0 +1,945 @@
+/**
+ * @file toolbar.hpp
+ * @brief Reconstructed header for Toon Boom AC_Toolbar class hierarchy
+ *
+ * This header was reverse-engineered from ToonBoomActionManager.dll
+ * IDA Database: RE/ToonBoomActionManager.dll.i64
+ *
+ * AC_Toolbar provides customizable toolbar functionality for Toon Boom
+ * applications. It supports:
+ * - Dynamic item insertion (buttons, multi-buttons, comboboxes, separators)
+ * - Placeholder-based customization
+ * - Configuration save/restore
+ * - Integration with AC_Manager for action handling
+ *
+ * @note All offsets and structures derived from decompilation analysis.
+ *       This is NOT official Toon Boom code.
+ */
+
+#pragma once
+
+#include "./ac_manager.hpp"
+#include <QtCore/QObject>
+#include <QtCore/QString>
+#include <QtCore/QList>
+#include <QtWidgets/QToolBar>
+#include <QtWidgets/QWidget>
+#include <QtWidgets/QMainWindow>
+#include <QtGui/QAction>
+#include <QtXml/QDomElement>
+
+// Forward declarations
+class AC_Object;
+class AC_Item;
+class AC_Separator;
+class AC_Container;
+class AC_ContainerImpl;
+class AC_Toolbar;
+class AC_ToolbarImpl;
+class AC_ToolbarItemGenerator;
+class AC_Help;
+
+/**
+ * @brief Abstract base class for toolbar objects (items, separators, etc.)
+ *
+ * AC_Object is the base interface for all items that can be contained
+ * within an AC_Container (toolbar, menu, etc.).
+ *
+ * vtable at 0x18004ed88 (16 virtual methods, most pure virtual)
+ */
+class AC_Object {
+public:
+    virtual ~AC_Object() = 0;
+
+    /**
+     * @brief Get the identity string for this object
+     * @return Reference to identity QString
+     */
+    virtual const QString& identity() const = 0;
+
+    /**
+     * @brief Check if this object is visible
+     * @return true if visible
+     */
+    virtual bool isVisible() const = 0;
+
+    /**
+     * @brief Set visibility of this object
+     * @param visible New visibility state
+     */
+    virtual void setVisible(bool visible) = 0;
+
+    /**
+     * @brief Check if this object is enabled
+     * @return true if enabled
+     */
+    virtual bool isEnabled() const = 0;
+
+    /**
+     * @brief Set enabled state of this object
+     * @param enabled New enabled state
+     */
+    virtual void setEnabled(bool enabled) = 0;
+
+    /**
+     * @brief Cast to AC_Item if this is an item
+     * @return Pointer to AC_Item or nullptr
+     */
+    virtual const AC_Item* toItem() const = 0;
+
+    /**
+     * @brief Cast to AC_Separator if this is a separator
+     * @return Pointer to AC_Separator or nullptr
+     */
+    virtual const AC_Separator* toSeparator() const = 0;
+
+    /**
+     * @brief Cast to AC_Toolbar if this is a toolbar
+     * @return Pointer to AC_Toolbar or nullptr
+     */
+    virtual const AC_Toolbar* toToolbar() const = 0;
+
+    // Additional virtual methods exist but are mostly pure virtual stubs
+};
+
+/**
+ * @brief Abstract interface for toolbar items (buttons, etc.)
+ *
+ * AC_Item extends AC_Object with item-specific functionality like
+ * checked state and action association.
+ */
+class AC_Item : public AC_Object {
+public:
+    virtual ~AC_Item() = 0;
+
+    /**
+     * @brief Check if this item is checked (for toggle buttons)
+     * @return true if checked
+     */
+    virtual bool isChecked() const = 0;
+
+    /**
+     * @brief Set the checked state
+     * @param checked New checked state
+     */
+    virtual void setChecked(bool checked) = 0;
+
+    /**
+     * @brief Get the associated QAction
+     * @return QAction pointer or nullptr
+     */
+    virtual QAction* action() const = 0;
+};
+
+/**
+ * @brief Abstract interface for toolbar separators
+ */
+class AC_Separator : public AC_Object {
+public:
+    virtual ~AC_Separator() = 0;
+};
+
+/**
+ * @brief Abstract interface for containers that hold AC_Objects
+ *
+ * AC_Container provides methods for managing child objects within
+ * a toolbar or similar container.
+ *
+ * vtable at 0x180054ef8 (AC_ToolbarImpl's AC_Container vtable)
+ */
+class AC_Container {
+public:
+    virtual ~AC_Container() = 0;
+
+    /**
+     * @brief Get the number of objects in this container
+     * @return Object count
+     */
+    virtual int objectCount() const = 0;
+
+    /**
+     * @brief Get object at specified index
+     * @param index Zero-based index
+     * @return AC_Object at index or nullptr
+     */
+    virtual AC_Object* objectAtIndex(int index) const = 0;
+
+    /**
+     * @brief Find object by identity
+     * @param identity Identity string to find
+     * @return Found object or nullptr
+     */
+    virtual AC_Object* findObject(const char* identity) const = 0;
+
+    /**
+     * @brief Find item by identity
+     * @param identity Identity string to find
+     * @return Found item or nullptr
+     */
+    virtual AC_Item* findItem(const char* identity) const = 0;
+
+    /**
+     * @brief Get index of an object
+     * @param object Object to find
+     * @return Zero-based index or -1 if not found
+     */
+    virtual int indexOf(AC_Object* object) const = 0;
+
+    /**
+     * @brief Get index of object by identity
+     * @param identity Identity string to find
+     * @return Zero-based index or -1 if not found
+     */
+    virtual int indexOf(const char* identity) const = 0;
+
+    /**
+     * @brief Check if item is checked
+     * @param identity Item identity
+     * @return true if item exists and is checked
+     */
+    virtual bool isChecked(const char* identity) const = 0;
+
+    /**
+     * @brief Set checked state of item
+     * @param identity Item identity
+     * @param checked New checked state
+     */
+    virtual void setChecked(const char* identity, bool checked) = 0;
+};
+
+/**
+ * @brief Context-sensitive help interface
+ *
+ * AC_Help provides methods for context-sensitive help in toolbars.
+ *
+ * vtable at 0x1800550f8 (AC_ToolbarImpl's AC_Help vtable)
+ */
+class AC_Help {
+public:
+    virtual ~AC_Help();
+
+    /**
+     * @brief Help type enumeration
+     */
+    enum cshHelpType {
+        Type0 = 0,
+        Type1 = 1,
+        Type2 = 2,
+        Type3 = 3,
+        Type4 = 4,
+        ToolbarHelp = 5  // Used by AC_ToolbarImpl::cshHelpId
+    };
+
+    /**
+     * @brief Get context-sensitive help ID
+     * @return Help ID string
+     */
+    virtual QString cshHelpId() = 0;
+
+    /**
+     * @brief Get help prefix for a type
+     * @param type Help type
+     * @return Prefix string
+     */
+    static QString cshHelpPref(cshHelpType type);
+
+    /**
+     * @brief Get help shortcut string
+     * @return Shortcut string
+     */
+    static QString cshHelpShortcut();
+};
+
+/**
+ * @brief Abstract base class for toolbars
+ *
+ * AC_Toolbar is the abstract interface for toolbar functionality.
+ * The concrete implementation is AC_ToolbarImpl.
+ *
+ * Key features:
+ * - Item management (insert, remove, find)
+ * - Configuration save/restore
+ * - Placeholder system for customization
+ * - Integration with AC_Manager
+ *
+ * vtable at 0x180054eb0 (32 entries for main vtable)
+ */
+class AC_Toolbar : public AC_Object, public AC_Container, public AC_Help {
+public:
+    virtual ~AC_Toolbar() = 0;
+
+    // =========================================================================
+    // Identity and Basic Properties
+    // =========================================================================
+
+    /**
+     * @brief Get the toolbar identity
+     * @return Reference to identity QString (at offset -72 from AC_Toolbar*)
+     */
+    virtual const QString& identity() const override = 0;
+
+    /**
+     * @brief Get the toolbar text/title
+     * @return Toolbar title
+     */
+    virtual QString text() const = 0;
+
+    /**
+     * @brief Set the toolbar text/title
+     * @param text New title
+     */
+    virtual void setText(const QString& text) = 0;
+
+    /**
+     * @brief Check if toolbar is visible
+     * @return true if visible
+     */
+    virtual bool isVisible() const override = 0;
+
+    /**
+     * @brief Set toolbar visibility
+     * @param visible New visibility state
+     */
+    virtual void setVisible(bool visible) override = 0;
+
+    /**
+     * @brief Check if toolbar is enabled
+     * @return true if enabled
+     */
+    virtual bool isEnabled() const override = 0;
+
+    /**
+     * @brief Set toolbar enabled state
+     * @param enabled New enabled state
+     */
+    virtual void setEnabled(bool enabled) override = 0;
+
+    /**
+     * @brief Check if toolbar is customizable
+     * @return true if customization is allowed
+     */
+    virtual bool isCustomizable() const = 0;
+
+    // =========================================================================
+    // Manager and Owner
+    // =========================================================================
+
+    /**
+     * @brief Get the associated AC_Manager
+     * @return Manager pointer or nullptr
+     */
+    virtual AC_Manager* manager() const = 0;
+
+    /**
+     * @brief Get the owner object
+     * @return Owner QObject or nullptr
+     */
+    virtual QObject* owner() const = 0;
+
+    /**
+     * @brief Set the owner object
+     * @param owner New owner
+     */
+    virtual void setOwner(QObject* owner) = 0;
+
+    // =========================================================================
+    // Item Generator
+    // =========================================================================
+
+    /**
+     * @brief Get the toolbar item generator
+     * @return Item generator or nullptr
+     */
+    virtual AC_ToolbarItemGenerator* itemGenerator() const = 0;
+
+    /**
+     * @brief Set the toolbar item generator
+     * @param generator New generator
+     */
+    virtual void setItemGenerator(AC_ToolbarItemGenerator* generator) = 0;
+
+    // =========================================================================
+    // Content Management
+    // =========================================================================
+
+    /**
+     * @brief Insert an object from XML element
+     * @param beforeObject Insert before this object (nullptr = end)
+     * @param element XML element defining the item
+     * @return Inserted AC_Object or nullptr
+     */
+    virtual AC_Object* insert(AC_Object* beforeObject, const QDomElement& element) = 0;
+
+    /**
+     * @brief Insert a separator before an object
+     * @param beforeObject Insert before this object
+     * @return Created separator or nullptr
+     */
+    virtual AC_Separator* insertSeparator(AC_Object* beforeObject) = 0;
+
+    /**
+     * @brief Insert at a named placeholder
+     * @param placeholder Placeholder name
+     * @param element XML element defining the item
+     * @return Inserted AC_Object or nullptr
+     */
+    virtual AC_Object* insertAtPlaceholder(const char* placeholder,
+                                            const QDomElement& element) = 0;
+
+    /**
+     * @brief Insert at placeholder with full parameters
+     * @param placeholder Placeholder name
+     * @param responderIdentity Responder identity
+     * @param actionName Action name
+     * @param objectName Object name (may be nullptr)
+     * @param keywords Keywords list (may be nullptr)
+     * @param visible Initial visibility
+     * @return Inserted AC_Object or nullptr
+     */
+    virtual AC_Object* insertAtPlaceholder(const char* placeholder,
+                                            const QString& responderIdentity,
+                                            const QString& actionName,
+                                            const char* objectName,
+                                            const QList<QString>* keywords,
+                                            bool visible) = 0;
+
+    /**
+     * @brief Insert placeholder contents
+     * @param beforeObject Insert before this object
+     * @param responderIdentity Responder identity
+     * @param actionName Action name
+     * @param objectName Object name
+     * @param keywords Keywords list
+     * @param visible Visibility
+     * @param flag Additional flag
+     * @return Inserted AC_Item or nullptr
+     */
+    virtual AC_Item* insertPlaceHolderContents(AC_Object* beforeObject,
+                                                const QString& responderIdentity,
+                                                const QString& actionName,
+                                                const char* objectName,
+                                                const QList<QString>* keywords,
+                                                bool visible,
+                                                bool flag) = 0;
+
+    /**
+     * @brief Remove an object by identity
+     * @param identity Object identity to remove
+     * @return true if removed successfully
+     */
+    virtual bool removeObject(const char* identity) = 0;
+
+    /**
+     * @brief Remove a QAction from the toolbar
+     * @param action Action to remove
+     */
+    virtual void removeAction(QAction* action) = 0;
+
+    /**
+     * @brief Remove a child QObject
+     * @param child Child to remove
+     */
+    virtual void removeChild(QObject* child) = 0;
+
+    /**
+     * @brief Clear all objects from toolbar
+     */
+    virtual void clear() = 0;
+
+    /**
+     * @brief Clear a specific placeholder
+     * @param placeholder Placeholder name to clear
+     */
+    virtual void clearPlaceholder(const char* placeholder) = 0;
+
+    /**
+     * @brief Clear all placeholders
+     */
+    virtual void clearPlaceholders() = 0;
+
+    /**
+     * @brief Hide all objects
+     */
+    virtual void hideAllObjects() = 0;
+
+    /**
+     * @brief Remove the toolbar from its parent
+     */
+    virtual void remove() = 0;
+
+    // =========================================================================
+    // Configuration
+    // =========================================================================
+
+    /**
+     * @brief Get current configuration
+     * @return List of item identities in current order
+     */
+    virtual QList<QString> config() const = 0;
+
+    /**
+     * @brief Set configuration from list
+     * @param config List of item identities
+     */
+    virtual void setConfig(const QList<QString>& config) = 0;
+
+    /**
+     * @brief Get default configuration
+     * @return List of item identities in default order
+     */
+    virtual QList<QString> defaultConfig() const = 0;
+
+    /**
+     * @brief Set default configuration
+     * @param config List of item identities for default
+     */
+    virtual void setDefaultConfig(const QList<QString>& config) = 0;
+
+    /**
+     * @brief Check if current config matches default
+     * @return true if config is default
+     */
+    virtual bool isDefaultConfig() const = 0;
+
+    /**
+     * @brief Check if a button is in default config
+     * @param identity Button identity
+     * @return true if button is default
+     */
+    virtual bool isDefaultButton(const QString& identity) const = 0;
+
+    /**
+     * @brief Change toolbar content from XML
+     * @param element New XML definition
+     * @param addedIds Output list of added IDs
+     * @param removedIds Output list of removed IDs
+     * @return true if changed successfully
+     */
+    virtual bool changeContent(const QDomElement& element,
+                                QList<QString>* addedIds,
+                                QList<QString>* removedIds) = 0;
+
+    /**
+     * @brief Change toolbar content from name
+     * @param name Toolbar definition name
+     * @param addedIds Output list of added IDs
+     * @param removedIds Output list of removed IDs
+     * @return true if changed successfully
+     */
+    virtual bool changeContent(const QString& name,
+                                QList<QString>* addedIds,
+                                QList<QString>* removedIds) = 0;
+
+    // =========================================================================
+    // Validation and Updates
+    // =========================================================================
+
+    /**
+     * @brief Validate all content (enable/disable states)
+     */
+    virtual void validateContent() = 0;
+
+    /**
+     * @brief Validate content if toolbar is visible
+     */
+    virtual void validateContentIfVisible() = 0;
+
+    /**
+     * @brief Validate tooltip text for all items
+     */
+    virtual void validateTooltipText() = 0;
+
+    /**
+     * @brief Validate tooltip text if toolbar is visible
+     */
+    virtual void validateTooltipTextIfVisible() = 0;
+
+    /**
+     * @brief Update separator visibility based on adjacent items
+     */
+    virtual void updateSeparators() = 0;
+
+    /**
+     * @brief Update customized button states
+     * @param identity Button identity
+     * @param oldName Old name
+     * @param newName New name
+     */
+    virtual void updateCustomizedButtons(const QString& identity,
+                                          const QString& oldName,
+                                          const QString& newName) = 0;
+
+    // =========================================================================
+    // Customization
+    // =========================================================================
+
+    /**
+     * @brief Open customization dialog
+     * @param parent Parent widget for dialog
+     */
+    virtual void customize(QWidget* parent) = 0;
+
+    /**
+     * @brief Connect update signals
+     * @param receiver Receiver object
+     * @param slot Slot to connect
+     */
+    virtual void connectUpdate(QObject* receiver, const char* slot) = 0;
+
+    // =========================================================================
+    // Widget Conversion
+    // =========================================================================
+
+    /**
+     * @brief Get as QWidget
+     * @return QWidget pointer (this - 128 for AC_ToolbarImpl)
+     */
+    virtual QWidget* toQWidget() = 0;
+
+    /**
+     * @brief Get as QToolBar
+     * @return QToolBar pointer
+     */
+    virtual QToolBar* toQToolBar() = 0;
+
+    // =========================================================================
+    // Visible Objects
+    // =========================================================================
+
+    /**
+     * @brief Get count of visible objects
+     * @return Number of visible objects
+     */
+    virtual int visibleObjects() = 0;
+
+    // =========================================================================
+    // Translation
+    // =========================================================================
+
+    /**
+     * @brief Translate a string using toolbar's context
+     * @param text Text to translate
+     * @return Translated string
+     */
+    virtual QString translate(const QString& text) = 0;
+};
+
+/**
+ * @brief Concrete implementation of AC_Container
+ *
+ * AC_ContainerImpl provides the base container functionality used by
+ * AC_ToolbarImpl and other container classes.
+ *
+ * sizeof(AC_ContainerImpl) = 0x58 (88 bytes) on x64
+ *
+ * Memory layout:
+ * - +0x00: vptr (AC_ContainerImpl vtable)
+ * - +0x08: AC_ManagerImpl* m_manager
+ * - +0x10: QString m_identity (24 bytes)
+ * - +0x28: bool m_enabled
+ * - +0x29: bool m_isToolbar (flag)
+ * - +0x30: std::vector<AC_Object*> m_objects
+ * - +0x48: Internal tree/map for placeholders
+ */
+class AC_ContainerImpl {
+public:
+    /**
+     * @brief Construct container with manager
+     * @param manager Owning manager
+     * @param isToolbar true if this is a toolbar container
+     */
+    AC_ContainerImpl(AC_ManagerImpl* manager, bool isToolbar);
+    AC_ContainerImpl(const AC_ContainerImpl& other);
+    virtual ~AC_ContainerImpl();
+
+    AC_ContainerImpl& operator=(const AC_ContainerImpl& other);
+
+    // AC_Container interface implementation
+    int objectCount() const;
+    AC_Object* objectAtIndex(int index) const;
+    AC_Object* findObject(const char* identity) const;
+    AC_Item* findItem(const char* identity) const;
+    int indexOf(AC_Object* object) const;
+    int indexOf(const char* identity) const;
+    bool isChecked(const char* identity) const;
+    void setChecked(const char* identity, bool checked);
+
+    /**
+     * @brief Get all objects
+     * @return Reference to objects vector
+     */
+    const std::vector<AC_Object*>& objects() const;
+
+    /**
+     * @brief Update objects from external vector
+     * @param newObjects New objects to set
+     */
+    void updateObjects(const std::vector<AC_Object*>& newObjects);
+
+    /**
+     * @brief Handle child object destruction
+     * @param object Destroyed object
+     */
+    virtual void childDestroyed(AC_Object* object);
+
+    /**
+     * @brief Handle child QObject destruction
+     * @param object Destroyed QObject
+     */
+    virtual void childDestroyed(QObject* object);
+
+    /**
+     * @brief Handle child insertion
+     * @param object Inserted object
+     * @param index Insertion index
+     */
+    virtual void childInsert(AC_Object* object, int index);
+};
+
+/**
+ * @brief Concrete implementation of AC_Toolbar
+ *
+ * AC_ToolbarImpl inherits from QToolBar and implements AC_Toolbar, AC_Container,
+ * and AC_Help interfaces. It provides full toolbar functionality including:
+ * - Dynamic item management
+ * - Customization support
+ * - Configuration persistence
+ * - Context-sensitive help
+ *
+ * sizeof(AC_ToolbarImpl) = 0x118 (280 bytes) on x64
+ *
+ * Memory layout:
+ * - +0x00: QToolBar (vptr for QObject at +0x00, QPaintDevice at +0x10)
+ * - +0x28: AC_ContainerImpl m_container (88 bytes, ends at +0x80)
+ * - +0x80: AC_Toolbar vptr (main toolbar interface)
+ * - +0x88: AC_Container vptr
+ * - +0x90: AC_Help vptr
+ * - +0x98: QString m_responderIdentity (24 bytes)
+ * - +0xB0: std::vector<AC_Object*> m_defaultConfig (24 bytes)
+ * - +0xC8: bool m_isCustomizable
+ * - +0xD0: void* m_customizeButton
+ * - +0xD8: void* m_unknown1
+ * - +0xE0: QObject* m_owner
+ * - +0xE8: QWeakPointer<QWidget> m_mainWindow (16 bytes)
+ * - +0xF8: float m_scaleFactor (default 1.0)
+ * - +0x100: QString m_translationContext (24 bytes)
+ *
+ * Vtable addresses:
+ * - QObject vtable:     0x180054c90
+ * - QPaintDevice vtable: 0x180054e70
+ * - AC_Toolbar vtable:  0x180054eb0
+ * - AC_Container vtable: 0x180054ef8
+ * - AC_Help vtable:     0x1800550f8
+ *
+ * Signals:
+ * - customized(QString) - emitted when toolbar is customized
+ */
+class AC_ToolbarImpl : public QToolBar {
+    Q_OBJECT
+
+public:
+    /**
+     * @brief Construct AC_ToolbarImpl
+     * @param owner Owner QObject
+     * @param title Toolbar title
+     * @param mainWindow Parent main window
+     * @param objectName Object name (C-string)
+     * @param manager Owning AC_ManagerImpl
+     * @param element XML element defining toolbar content
+     * @param defaultConfig Default configuration (may be nullptr)
+     */
+    AC_ToolbarImpl(QObject* owner, const QString& title, QMainWindow* mainWindow,
+                    const char* objectName, AC_ManagerImpl* manager,
+                    const QDomElement& element, const QList<QString>* defaultConfig);
+    virtual ~AC_ToolbarImpl() override;
+
+    // =========================================================================
+    // AC_Object interface
+    // =========================================================================
+    const QString& identity() const;
+    bool isVisible() const;
+    void setVisible(bool visible);
+    bool isEnabled() const;
+    void setEnabled(bool enabled);
+    const AC_Item* toItem() const { return nullptr; }
+    const AC_Separator* toSeparator() const { return nullptr; }
+    const AC_Toolbar* toToolbar() const;
+
+    // =========================================================================
+    // AC_Container interface
+    // =========================================================================
+    int objectCount() const;
+    AC_Object* objectAtIndex(int index) const;
+    AC_Object* findObject(const char* identity) const;
+    AC_Item* findItem(const char* identity) const;
+    int indexOf(AC_Object* object) const;
+    int indexOf(const char* identity) const;
+    bool isChecked(const char* identity) const;
+    void setChecked(const char* identity, bool checked);
+
+    // =========================================================================
+    // AC_Help interface
+    // =========================================================================
+    QString cshHelpId();
+
+    // =========================================================================
+    // AC_Toolbar interface
+    // =========================================================================
+    QString text() const;
+    void setText(const QString& text);
+    bool isCustomizable() const;
+    AC_Manager* manager() const;
+    QObject* owner() const;
+    void setOwner(QObject* owner);
+    AC_ToolbarItemGenerator* itemGenerator() const;
+    void setItemGenerator(AC_ToolbarItemGenerator* generator);
+
+    AC_Object* insert(AC_Object* beforeObject, const QDomElement& element);
+    AC_Separator* insertSeparator(AC_Object* beforeObject);
+    AC_Object* insertAtPlaceholder(const char* placeholder, const QDomElement& element);
+    AC_Object* insertAtPlaceholder(const char* placeholder,
+                                    const QString& responderIdentity,
+                                    const QString& actionName,
+                                    const char* objectName,
+                                    const QList<QString>* keywords,
+                                    bool visible);
+    AC_Item* insertPlaceHolderContents(AC_Object* beforeObject,
+                                        const QString& responderIdentity,
+                                        const QString& actionName,
+                                        const char* objectName,
+                                        const QList<QString>* keywords,
+                                        bool visible,
+                                        bool flag);
+
+    bool removeObject(const char* identity);
+    void removeAction(QAction* action);
+    void removeChild(QObject* child);
+    void clear();
+    void clearPlaceholder(const char* placeholder);
+    void clearPlaceholders();
+    void hideAllObjects();
+    void remove();
+
+    QList<QString> config() const;
+    void setConfig(const QList<QString>& config);
+    QList<QString> defaultConfig() const;
+    void setDefaultConfig(const QList<QString>& config);
+    bool isDefaultConfig() const;
+    bool isDefaultButton(const QString& identity) const;
+    bool changeContent(const QDomElement& element,
+                        QList<QString>* addedIds,
+                        QList<QString>* removedIds);
+    bool changeContent(const QString& name,
+                        QList<QString>* addedIds,
+                        QList<QString>* removedIds);
+
+    void validateContent();
+    void validateContentIfVisible();
+    void validateTooltipText();
+    void validateTooltipTextIfVisible();
+    void updateSeparators();
+    void updateCustomizedButtons(const QString& identity,
+                                  const QString& oldName,
+                                  const QString& newName);
+
+    void customize(QWidget* parent);
+    void connectUpdate(QObject* receiver, const char* slot);
+
+    QWidget* toQWidget();
+    QToolBar* toQToolBar();
+    int visibleObjects();
+    QString translate(const QString& text);
+
+    // =========================================================================
+    // Static helpers
+    // =========================================================================
+
+    /**
+     * @brief Translation helper
+     */
+
+signals:
+    /**
+     * @brief Emitted when toolbar is customized
+     * @param identity Toolbar identity
+     */
+    void customized(QString identity);
+
+protected:
+    /**
+     * @brief Handle show events
+     */
+    virtual void showEvent(QShowEvent* event) override;
+
+    /**
+     * @brief Create toolbar content from XML
+     * @param element XML element defining content
+     */
+    void create(const QDomElement& element);
+
+    /**
+     * @brief Create toolbar content with default config
+     * @param element XML element
+     * @param defaultConfig Default configuration
+     */
+    void create(const QDomElement& element, const QList<QString>& defaultConfig);
+
+    /**
+     * @brief Create the customize button
+     */
+    void createCustomizeButton();
+
+private slots:
+    /**
+     * @brief Handle owner destruction
+     */
+    void ownerDestroyed();
+};
+
+/**
+ * @brief Interface for generating custom toolbar items
+ *
+ * Implement this interface to provide custom item creation logic
+ * for toolbars managed by AC_Manager.
+ */
+class AC_ToolbarItemGenerator {
+public:
+    virtual ~AC_ToolbarItemGenerator() = default;
+
+    /**
+     * @brief Create an item for the given identity
+     * @param identity Item identity
+     * @param parent Parent toolbar
+     * @return Created item or nullptr
+     */
+    virtual AC_Item* createItem(const QString& identity, AC_ToolbarImpl* parent) = 0;
+};
+
+// ============================================================================
+// Offset Constants (for reference/debugging)
+// ============================================================================
+namespace AC_ToolbarImpl_Offsets {
+    // Offsets from QToolBar base
+    constexpr size_t ContainerImpl        = 0x28;   // 40 - AC_ContainerImpl embedded
+    constexpr size_t ToolbarVtable        = 0x80;   // 128 - AC_Toolbar vptr
+    constexpr size_t ContainerVtable      = 0x88;   // 136 - AC_Container vptr
+    constexpr size_t HelpVtable           = 0x90;   // 144 - AC_Help vptr
+    constexpr size_t ResponderIdentity    = 0x98;   // 152 - QString
+    constexpr size_t DefaultConfigVector  = 0xB0;   // 176 - std::vector<AC_Object*>
+    constexpr size_t IsCustomizable       = 0xC8;   // 200 - bool
+    constexpr size_t CustomizeButton      = 0xD0;   // 208 - void*
+    constexpr size_t Owner                = 0xE0;   // 224 - QObject*
+    constexpr size_t MainWindowWeakPtr    = 0xE8;   // 232 - QWeakPointer<QWidget>
+    constexpr size_t ScaleFactor          = 0xF8;   // 248 - float (default 1.0)
+    constexpr size_t TranslationContext   = 0x100;  // 256 - QString
+}
+
+namespace AC_ContainerImpl_Offsets {
+    constexpr size_t Manager              = 0x08;   // 8 - AC_ManagerImpl*
+    constexpr size_t Identity             = 0x10;   // 16 - QString
+    constexpr size_t Enabled              = 0x28;   // 40 - bool
+    constexpr size_t IsToolbar            = 0x29;   // 41 - bool
+    constexpr size_t Objects              = 0x30;   // 48 - std::vector<AC_Object*>
+    constexpr size_t Placeholders         = 0x48;   // 72 - Internal tree/map
+}
+

framework/include/toon_boom/toon_boom_layout.hpp

@@ -14,6 +14,7 @@
 #ifndef TOON_BOOM_LAYOUT_HPP
 #define TOON_BOOM_LAYOUT_HPP
 
+#include "./toolbar.hpp"
 #include <QtCore/QEvent>
 #include <QtCore/QObject>
 #include <QtCore/QString>
@@ -46,9 +47,7 @@ class TULayoutDisplayTools;
 class TULayout;
 class AC_Manager;
 class AC_Menu;
-class AC_Toolbar;
 class AC_ActionInfo;
-class AC_ToolbarItemGenerator;
 class AC_Responder;
 class AC_ResponderTemplate;
 class TUWidgetLayoutView;
@@ -59,64 +58,43 @@ class UI_Splitter;
 class WID_VBoxLayout;
 class WID_HBoxLayout;
 
-/**
- * @brief Result code for action command handling
- */
-enum class AC_Result {
-  NotHandled = 0,
-  Handled = 1,
-  Error = 2
-};
-
 // =============================================================================
-// AC_Responder, AC_ResponderTemplate, AC_ResponderTemplateWidget
+// AC_Responder - Defined in ac_manager.hpp
 // =============================================================================
 //
-// These classes are implemented in Toon Boom DLLs (ToonBoomActionManager.dll
+// The AC_Responder interface and AC_ResponderBase convenience class are
-// or similar). Since we don't have access to those libraries for linking,
+// defined in ac_manager.hpp. Include that header to create custom responders.
-// we provide forward declarations only.
 //
-// For reference, the full interface is documented in RE/ToonBoomLayout_Classes.md
+// To create a custom responder:
+//   1. Inherit from AC_ResponderBase (provides default implementations)
+//   2. Override perform() to handle actions via Qt slots
+//   3. Register with AC_Manager::registerResponder()
+//
+// Example:
+//   class MyResponder : public QObject, public AC_ResponderBase {
+//       Q_OBJECT
+//   public:
+//       MyResponder(AC_Manager* mgr) : AC_ResponderBase("myResponder", mgr) {
+//           mgr->registerResponder(this, nullptr);
+//       }
+//   public slots:
+//       void onActionDoSomething() { /* handle action */ }
+//   };
+//
+// Toon Boom's internal classes (for reference only - cannot be extended):
+//   - AC_ResponderTemplate: Toon Boom's internal base class
+//   - AC_ResponderTemplateWidget<T>: Template combining QWidget with responder
 //
 // Key vtable addresses (in ToonBoomLayout.dll):
 //   - AC_Responder vtable: 0x18004cd28
 //   - AC_ResponderTemplate vtable: 0x18004cdc8
 //   - AC_ResponderTemplateWidget<QWidget> vtable: 0x18004ce68
-//
-// AC_Responder is a pure abstract interface with the following virtual methods:
-//   - perform(AC_ActionInfo*) -> AC_Result
-//   - performDownToChildren(AC_ActionInfo*) -> AC_Result
-//   - parentResponder() -> AC_Responder*
-//   - proxyResponder() -> AC_Responder*
-//   - acceptsFirstResponder() -> bool
-//   - acceptsSelectionResponder() -> bool
-//   - becomeFirstResponder() -> bool
-//   - becomeSelectionResponder() -> bool
-//   - resignFirstResponder() -> bool
-//   - handleShortcuts() const -> bool
-//   - shouldReceiveMessages() const -> bool
-//   - responderIdentity() const -> const QString&
-//   - responderDescription() const -> const QString&
-//   - setResponderDescription(const QString&) -> void
-//   - actionManager() const -> AC_Manager*
-//
-// AC_ResponderTemplate (sizeof 0x38):
-//   - Inherits AC_Responder
-//   - +0x08: QString m_identity
-//   - +0x20: QString m_description
-//   - +0x30: AC_Manager* m_manager
-//
-// AC_ResponderTemplateWidget<T> (sizeof ~0x68 for T=QWidget):
-//   - Inherits T (QWidget, QFrame, etc.) and AC_ResponderTemplate
-//   - Combines a Qt widget with action responder capabilities
 // =============================================================================
 
-// Forward declarations only - implemented in Toon Boom DLLs
+// Toon Boom internal classes - forward declarations only
-class AC_Responder;
+// These are implemented in Toon Boom DLLs and cannot be extended by users
 class AC_ResponderTemplate;
 
-// Template class - forward declaration for common instantiations
-// The actual template is implemented in Toon Boom DLLs
 template <typename T>
 class AC_ResponderTemplateWidget;
 
@@ -261,7 +239,31 @@ public:
   virtual void setMenu(AC_Manager *manager, const char *menuName, MenuType type);  // slot 8
   virtual void setMenu(AC_Menu *menu, MenuType type);               // slot 9
   virtual AC_Menu *menu(MenuType type);                             // slot 10
+  
+  /**
+   * @brief Returns the QDomElement defining this view's toolbar
+   * 
+   * Override this method to provide a view-specific toolbar. The default
+   * implementation returns an empty QDomElement (no toolbar).
+   * 
+   * To access the AC_Manager for toolbar lookup, use:
+   * @code
+   * QDomElement MyView::toolbar() {
+   *     AC_Manager* manager = TULayoutView_getActionManager(this);
+   *     if (manager) {
+   *         // manager->getToolbarElement() at vtable[52]
+   *         // Returns QDomElement for a named toolbar
+   *     }
+   *     return QDomElement();
+   * }
+   * @endcode
+   * 
+   * @return QDomElement defining toolbar, or empty element for no toolbar
+   * @see TULayoutView_getActionManager()
+   * @see docs/TULayoutView_Toolbar_Integration.md
+   */
   virtual QDomElement toolbar();                                    // slot 11
+  
   virtual void setToolbarInfo(const LAY_ToolbarInfo &info);         // slot 12
   virtual void connectView() {}                                     // slot 13 (empty impl)
   virtual void disconnectView() {}                                  // slot 14 (empty impl)
@@ -324,42 +326,94 @@ private:
 // TUWidgetLayoutView
 // =============================================================================
 //
-// TUWidgetLayoutView is implemented in ToonBoomLayout.dll. It inherits from
+// TUWidgetLayoutView is a concrete layout view class implemented in 
-// AC_ResponderTemplateWidget<QWidget> and embeds a TULayoutView at offset +0x68.
+// ToonBoomLayout.dll. It combines a QWidget (for UI display) with both
+// AC_Responder capabilities (for action handling) and TULayoutView
+// functionality (for the layout system).
 //
-// Since the base classes are implemented in Toon Boom DLLs, we cannot define
+// INHERITANCE HIERARCHY:
-// a compilable C++ class here. Use this as a reference for the memory layout
+//   QWidget
-// when working with TUWidgetLayoutView pointers obtained from the application.
+//       └── AC_ResponderTemplateWidget<QWidget>  (multiple inheritance)
+//               ├── QWidget base
+//               └── AC_ResponderTemplate (mixin at +0x28)
+//                       └── TUWidgetLayoutView
+//                               └── TULayoutView (embedded at +0x68)
 //
-// Memory layout (x64 MSVC):
+// VTABLE STRUCTURE (4 vtables due to multiple inheritance):
-// - +0x00: vptr (QObject) - from AC_ResponderTemplateWidget<QWidget>
+//   +0x00: vptr[0] - QObject vtable (includes QWidget virtuals)
-// - +0x10: vptr (QPaintDevice)
+//   +0x10: vptr[1] - QPaintDevice vtable  
-// - +0x18-0x27: QWidget members
+//   +0x28: vptr[2] - AC_ResponderTemplateWidget<QWidget> / AC_Responder vtable
-// - +0x28: vptr (AC_ResponderTemplateWidget)
+//   +0x68: vptr[3] - TULayoutView vtable
-// - +0x30: AC_Manager* m_actionManager
-// - +0x38: QString m_responderIdentity
-// - +0x50: QString m_responderDescription
-// - +0x68: vptr (TULayoutView) - TULayoutView base starts here
-// - +0x70: QString m_internalName (from TULayoutView)
-// - +0x88: LAY_ToolbarInfo m_toolbarInfo (from TULayoutView)
-// - +0xF0: AC_Menu* m_menuByType[2] (from TULayoutView)
-// - +0x100: bool m_initializedFromCopy (from TULayoutView)
-// - +0x108: QString m_caption (from TULayoutView)
 //
-// sizeof(TUWidgetLayoutView) ≈ 0x120 (288 bytes) on x64
+// MEMORY LAYOUT (x64 MSVC, sizeof = 0x120 / 288 bytes):
+//   +0x00: vptr (QObject)
+//   +0x08: QObjectData* d_ptr (QObject)
+//   +0x10: vptr (QPaintDevice)
+//   +0x18: [QWidget internal data ~16 bytes]
+//   +0x28: vptr (AC_ResponderTemplateWidget<QWidget>)
+//   +0x30: AC_Manager* m_actionManager
+//   +0x38: QString m_responderIdentity (24 bytes)
+//   +0x50: QString m_responderDescription (24 bytes)
+//   +0x68: vptr (TULayoutView) ─┐
+//   +0x70: QString m_internalName     │ TULayoutView
+//   +0x88: LAY_ToolbarInfo m_toolbarInfo   │ embedded
+//   +0xF0: AC_Menu* m_menuByType[2]   │ (184 bytes)
+//   +0x100: bool m_initializedFromCopy │
+//   +0x108: QString m_caption        ─┘
 //
-// Key methods (in ToonBoomLayout.dll):
+// KEY VIRTUAL METHOD OVERRIDES IN TUWIDGETLAYOUTVIEW:
-//   - Constructor at 0x1800300A0
+//   From TULayoutView:
-//   - Destructor at 0x180030480
+//     - widget() - pure virtual, not implemented (returns _purecall)
-//   - getWidget() at 0x180030E90 - returns (this - 104) from TULayoutView*
+//     - getWidget() const/non-const - returns (this - 104), i.e., the QWidget*
+//     - triggerMenuChanged() - emits menuChanged() signal on QWidget
+//     - isTULayoutView() - empty implementation (RTTI marker)
+//   From QWidget:
+//     - mousePressEvent() - accepts event and sets focus (Qt::MouseFocusReason)
+//     - metaObject(), qt_metacast(), qt_metacall() - Qt meta-object support
 //
-// To get TULayoutView* from TUWidgetLayoutView*:
+// SIGNALS (Qt):
-//   TULayoutView* layoutView = reinterpret_cast<TULayoutView*>(
+//   - menuChanged() - emitted by triggerMenuChanged()
-//       reinterpret_cast<char*>(widgetLayoutView) + 104);
 //
-// To get TUWidgetLayoutView* from TULayoutView*:
+// CONSTRUCTOR PARAMETERS:
-//   TUWidgetLayoutView* widget = reinterpret_cast<TUWidgetLayoutView*>(
+//   TUWidgetLayoutView(AC_Manager* manager, const QString& objectName,
-//       reinterpret_cast<char*>(layoutView) - 104);
+//                      QWidget* parent, const char* className,
+//                      Qt::WindowFlags flags)
+//
+// CONSTRUCTION SEQUENCE:
+//   1. AC_ResponderTemplateWidget<QWidget> ctor (parent, flags, objectName)
+//   2. TULayoutView default ctor (at this+104)
+//   3. Set all 4 vtables to TUWidgetLayoutView vtables
+//   4. QWidget::setMinimumWidth(150)
+//   5. If parent and manager: call initActionManager(manager)
+//      Else: store manager at +0x30
+//
+// DESTRUCTION SEQUENCE:
+//   1. Reset vtables
+//   2. Destroy TULayoutView::m_caption at +0x108
+//   3. Destroy TULayoutView::m_toolbarInfo at +0x88
+//   4. Destroy TULayoutView::m_internalName at +0x70
+//   5. Call AC_ResponderTemplateWidget<QWidget> dtor
+//
+// EXPORTED METHODS (ToonBoomLayout.dll):
+//   - ??0TUWidgetLayoutView@@QEAA@... - Constructor
+//   - ??1TUWidgetLayoutView@@UEAA@XZ - Destructor
+//   - ?getWidget@TUWidgetLayoutView@@UEAA/UEBAPEAVQWidget@@XZ - Get QWidget*
+//   - ?mousePressEvent@TUWidgetLayoutView@@MEAAXPEAVQMouseEvent@@@Z
+//   - ?triggerMenuChanged@TUWidgetLayoutView@@MEAAXXZ
+//   - ?menuChanged@TUWidgetLayoutView@@QEAAXXZ - Qt signal
+//   - ?metaObject/qt_metacast/qt_metacall - Qt meta-object methods
+//   - ?tr@TUWidgetLayoutView@@SA?AVQString@@PEBD0H@Z - Translation
+//
+// USAGE NOTES:
+//   Since TUWidgetLayoutView has external base classes, you cannot directly
+//   subclass it in user code. Instead:
+//   1. Obtain TUWidgetLayoutView* from the layout system
+//   2. Use helper functions to convert between pointer types
+//   3. Access TULayoutView virtuals through TULayoutView_getLayoutView()
+//   4. Access QWidget through TUWidgetLayoutView_getWidget()
+//
+// @see TULayoutView_getActionManager() for accessing AC_Manager*
+// @see docs/TUWidgetLayoutView_Analysis.md for detailed analysis
 // =============================================================================
 
 // Forward declaration - implemented in ToonBoomLayout.dll
@@ -393,6 +447,39 @@ inline QWidget *TUWidgetLayoutView_getWidget(TUWidgetLayoutView *widget) {
   return reinterpret_cast<QWidget *>(widget);
 }
 
+/**
+ * @brief Get AC_Manager* from a TULayoutView* embedded in TUWidgetLayoutView
+ * 
+ * This function provides access to the AC_Manager instance for views that
+ * inherit from TUWidgetLayoutView. The AC_Manager is stored in the 
+ * AC_ResponderTemplateWidget<QWidget> base class at offset +48, which is
+ * offset -56 from the embedded TULayoutView*.
+ * 
+ * @note This only works for TULayoutView instances that are embedded in
+ *       TUWidgetLayoutView. Direct TULayoutView subclasses do NOT have
+ *       an AC_Manager member.
+ * 
+ * @param view Pointer to TULayoutView (must be embedded in TUWidgetLayoutView)
+ * @return AC_Manager* or nullptr if invalid
+ * 
+ * @code
+ * // Example usage in a toolbar() override:
+ * QDomElement MyView::toolbar() {
+ *     AC_Manager* manager = TULayoutView_getActionManager(this);
+ *     if (manager) {
+ *         // Use manager->getToolbarElement(...) to get toolbar definition
+ *     }
+ *     return QDomElement();
+ * }
+ * @endcode
+ */
+inline AC_Manager *TULayoutView_getActionManager(TULayoutView *view) {
+  // AC_Manager is at offset +48 in TUWidgetLayoutView
+  // TULayoutView is embedded at offset +104 in TUWidgetLayoutView
+  // So from TULayoutView*, AC_Manager** is at offset -56 (= 48 - 104)
+  return *reinterpret_cast<AC_Manager **>(reinterpret_cast<char *>(view) - 56);
+}
+
 /**
  * @brief Container widget that holds 1-2 TULayoutView instances
  *