hyprtoolkit

To initialize or configure a Combobox element, use the SComboboxData struct. This struct defines the items available in the list, the currently selected item index, a callback function for when the selection changes, and the element's size.

Key fields:

• items: A std::vector<std::string> containing the list of options.
• currentItem: A size_t representing the index of the currently selected item.
• onChanged: A callback function std::function<void(CSharedPointer<CComboboxElement>, size_t)> that triggers when a user selects a new item. It provides a pointer to the combobox instance and the new index.
• size: A CDynamicSize object defining the element's dimensions.

SComboboxData data;
data.items = {"Option 1", "Option 2", "Option 3"};
data.currentItem = 0;
data.onChanged = [](Hyprutils::Memory::CSharedPointer<CComboboxElement> self, size_t newIndex) {
    // Handle selection change
};
data.size = CDynamicSize{CDynamicSize::HT_SIZE_AUTO, CDynamicSize::HT_SIZE_AUTO, {}};

To create or configure a CTextboxElement, you provide an STextboxData structure. This structure defines the visual and behavioral properties of the textbox, including its text content, placeholder, and event handlers.

Key fields in STextboxData:

• text: The current string content of the textbox.
• placeholder: The text displayed when the textbox is empty.
• onTextEdited: A callback function triggered when the text is modified. It receives a shared pointer to the CTextboxElement and the new std::string content.
• multiline: Boolean determining if the textbox supports multiple lines (defaults to true).
• password: Boolean determining if the text should be masked (defaults to false).
• eyeIcon: Boolean to show/hide an eye icon for toggling password visibility (defaults to false).
• size: A CDynamicSize object defining the element's dimensions (defaults to HT_SIZE_PERCENT with {1, 1}).

STextboxData data;
data.text = "Hello World";
data.placeholder = "Enter text...";
data.multiline = false;
data.password = true;
data.eyeIcon = true;
data.onTextEdited = [](auto self, const std::string& newText) {
    // Handle text change
};

To create a custom application window using hyprtoolkit, you must implement the IToolkitWindow interface. This interface extends IWindow and provides the necessary hooks for rendering, input handling, and window management.

Key responsibilities for an implementation include:

• Rendering: Implement the render() method to draw the window content. You can also use onPreRender() for setup before the main render pass.
• Input Handling: Implement methods for mouse events (mouseEnter, mouseMove, mouseButton, mouseAxis, mouseLeave), keyboard events (keyboardKey), and focus management (setKeyboardFocus, unfocusKeyboard).
• Window Management: Implement openPopup to handle the creation of popups/menus and setCursor to manage the pointer shape.
• Damage & Updates: Use damage(Hyprutils::Math::CRegion&& rg) to mark specific regions for redrawing, damageEntire() to invalidate the whole window, and scheduleFrame() to request a new frame.

class MyToolkitWindow : public Hyprtoolkit::IToolkitWindow {
public:
    void render() override {
        // Implementation of drawing logic
    }

    Hyprtoolkit::SP<Hyprtoolkit::IWindow> openPopup(const Hyprtoolkit::SWindowCreationData& data) override {
        // Implementation of popup creation
        return nullptr;
    }

    void setCursor(Hyprtoolkit::ePointerShape shape) override {
        // Implementation of cursor shape changes
    }
};

The CBackend class is the central entry point for hyprtoolkit. It implements both IBackend and IEventLoop, providing a unified interface for managing system resources, event loops, and hardware outputs.

Key capabilities include:

• Event Loop Management: Control the application lifecycle via enterLoop(), cancelPending(), and destroy().
• File Descriptor Monitoring: Monitor custom file descriptors using addFd(int fd, ...) and removeFd(int fd).
• Timers: Schedule asynchronous tasks using addTimer.
• System Integration: Access system icons via systemIcons(), retrieve color palettes via getPalette(), and manage session locks via aquireSessionLock().
• Display Management: Retrieve available hardware outputs using getOutputs().
• Window Creation: Open new windows using openWindow(const SWindowCreationData& data).

// Conceptual usage of CBackend
Hyprtoolkit::CBackend backend;

// Add a timer
backend.addTimer(std::chrono::seconds(5), [](auto self, void* data) {
    // Timer callback
}, nullptr);

// Monitor a file descriptor
backend.addFd(fd, []() {
    // Callback when fd is readable
});

// Start the event loop
backend.enterLoop();