### Install Translation Files

Source: https://github.com/ksnip/kimageannotator/blob/master/translations/CMakeLists.txt

This command installs the generated QM translation files to the specified destination directory during the installation process.

```cmake
install(FILES ${KIMAGEANNOTATOR_LANG_QM} DESTINATION ${KIMAGEANNOTATOR_LANG_INSTALL_DIR})
```

--------------------------------

### Complete kImageAnnotator Application in C++

Source: https://context7.com/ksnip/kimageannotator/llms.txt

This is a full example of a screenshot annotation application using the kImageAnnotator library. It demonstrates loading translations, configuring the annotator widget, setting up menus and toolbars, and handling image opening and saving. Ensure Qt and kImageAnnotator are set up correctly in your CMake project.

```cpp
#include <QApplication>
#include <QMainWindow>
#include <QMenuBar>
#include <QToolBar>
#include <QFileDialog>
#include <QClipboard>
#include <kImageAnnotator/KImageAnnotator>

using kImageAnnotator::KImageAnnotator;

class AnnotatorWindow : public QMainWindow {
public:
    AnnotatorWindow() {
        // Load translations first
        kImageAnnotator::loadTranslations();

        // Create annotator widget
        m_annotator = new KImageAnnotator();
        setCentralWidget(m_annotator);

        // Configure annotator settings
        m_annotator->setTabBarAutoHide(true);
        m_annotator->setSmoothPathEnabled(true);
        m_annotator->setSmoothFactor(5);
        m_annotator->setSaveToolSelection(true);
        m_annotator->setSwitchToSelectToolAfterDrawingItem(false);
        m_annotator->setControlsWidgetVisible(true);
        m_annotator->setCanvasColor(Qt::white);

        setupMenus();
        setupToolbar();
        connectSignals();

        // Load initial blank canvas
        QPixmap blank(800, 600);
        blank.fill(Qt::white);
        m_annotator->addTab(blank, "Untitled", "New image");

        setMinimumSize(m_annotator->sizeHint());
        setWindowTitle("Image Annotator");
    }

private:
    void setupMenus() {
        // File menu
        QMenu* fileMenu = menuBar()->addMenu("&File");
        fileMenu->addAction("&Open...", this, &AnnotatorWindow::openImage);
        fileMenu->addAction("&Save...", this, &AnnotatorWindow::saveImage);
        fileMenu->addSeparator();
        fileMenu->addAction("E&xit", this, &QMainWindow::close);

        // Edit menu with undo/redo and view modes
        QMenu* editMenu = menuBar()->addMenu("&Edit");
        editMenu->addAction(m_annotator->undoAction());
        editMenu->addAction(m_annotator->redoAction());
        editMenu->addSeparator();
        editMenu->addAction("&Annotate", m_annotator, &KImageAnnotator::showAnnotator);
        editMenu->addAction("&Crop", m_annotator, &KImageAnnotator::showCropper);
        editMenu->addAction("&Scale", m_annotator, &KImageAnnotator::showScaler);
        editMenu->addAction("&Rotate", m_annotator, &KImageAnnotator::showRotator);
        editMenu->addAction("&Modify Canvas", m_annotator, &KImageAnnotator::showCanvasModifier);
        editMenu->addAction("Cu&t", m_annotator, &KImageAnnotator::showCutter);
    }

    void setupToolbar() {
        QToolBar* toolbar = addToolBar("Main");
        toolbar->addAction(m_annotator->undoAction());
        toolbar->addAction(m_annotator->redoAction());
    }

    void connectSignals() {
        connect(m_annotator, &KImageAnnotator::imageChanged,
                this, [this]() { setWindowModified(true); });

        connect(m_annotator, &KImageAnnotator::tabCloseRequested,
                this, [this](int index) { m_annotator->removeTab(index); });
    }

    void openImage() {
        QString path = QFileDialog::getOpenFileName(this, "Open Image", "",
                                                    "Images (*.png *.jpg *.bmp)");
        if (!path.isEmpty()) {
            QPixmap pixmap(path);
            m_annotator->addTab(pixmap, QFileInfo(path).fileName(), path);
        }
    }

    void saveImage() {
        QString path = QFileDialog::getSaveFileName(this, "Save Image", "",
                                                    "PNG (*.png);;JPEG (*.jpg)");
        if (!path.isEmpty()) {
            m_annotator->image().save(path);
            setWindowModified(false);
        }
    }

    KImageAnnotator* m_annotator;
};

int main(int argc, char** argv) {
    QApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
    QApplication app(argc, argv);

    AnnotatorWindow window;
    window.show();

    return app.exec();
}

```

--------------------------------

### Define Executable and Link Library

Source: https://github.com/ksnip/kimageannotator/blob/master/example/CMakeLists.txt

This CMake code defines the executable for the KImageAnnotator example and links it against the KImageAnnotator library. Ensure KImageAnnotator is installed or available in the build environment.

```cmake
add_executable(kImageAnnotator-example main.cpp)

target_link_libraries(kImageAnnotator-example kImageAnnotator)
```

--------------------------------

### Build kImageAnnotator from source

Source: https://github.com/ksnip/kimageannotator/blob/master/README.md

Commands to clone, configure, and build the project using CMake.

```bash
$ git clone https://github.com/ksnip/kImageAnnotator
```

```bash
$ cd kImageAnnotator
```

```bash
$ mkdir build && cd build
```

```bash
$ cmake .. && make
```

```bash
$ sudo make install
```

```bash
$ ./example/kImageAnnotator-example
```

--------------------------------

### Initialize KImageAnnotator Widget

Source: https://context7.com/ksnip/kimageannotator/llms.txt

Embed the KImageAnnotator widget into a Qt application's main window.

```cpp
#include <QApplication>
#include <QMainWindow>
#include <kImageAnnotator/KImageAnnotator.h>

using kImageAnnotator::KImageAnnotator;

int main(int argc, char **argv) {
    QApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
    QApplication app(argc, argv);

    // Create the annotator widget
    auto annotator = new KImageAnnotator();

    // Create main window and set annotator as central widget
    QMainWindow mainWindow;
    mainWindow.setCentralWidget(annotator);
    mainWindow.setMinimumSize(annotator->sizeHint());
    mainWindow.show();

    return app.exec();
}
```

--------------------------------

### Integrate with CMake

Source: https://context7.com/ksnip/kimageannotator/llms.txt

Configure project dependencies by finding the package and linking the library. Supports both Qt5 and Qt6 variants.

```cmake
cmake_minimum_required(VERSION 3.5)
project(MyAnnotationApp LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_AUTOMOC ON)

# Set minimum version requirement
set(KIMAGEANNOTATOR_MIN_VERSION "0.7.0")

# Find Qt (choose Qt5 or Qt6)
find_package(Qt5 5.15.2 REQUIRED COMPONENTS Widgets)

# Find kImageAnnotator for Qt5
find_package(kImageAnnotator-Qt5 ${KIMAGEANNOTATOR_MIN_VERSION} REQUIRED)

# For Qt6, use instead:
# find_package(Qt6 REQUIRED COMPONENTS Widgets)
# find_package(kImageAnnotator-Qt6 ${KIMAGEANNOTATOR_MIN_VERSION} REQUIRED)

add_executable(MyAnnotationApp main.cpp)

target_link_libraries(MyAnnotationApp
    Qt5::Widgets
    kImageAnnotator
)
```

--------------------------------

### Configure Annotation Behavior

Source: https://context7.com/ksnip/kimageannotator/llms.txt

Adjust settings for path smoothing, tool persistence, canvas appearance, and UI visibility.

```cpp
#include <kImageAnnotator/KImageAnnotator.h>

using kImageAnnotator::KImageAnnotator;

void configureAnnotator(KImageAnnotator* annotator) {
    // Enable smooth path drawing for pen/marker tools
    annotator->setSmoothPathEnabled(true);
    annotator->setSmoothFactor(7); // Higher = smoother, range typically 1-10

    // Remember selected tool between sessions
    annotator->setSaveToolSelection(true);

    // Auto-switch to select tool after drawing an item
    annotator->setSwitchToSelectToolAfterDrawingItem(true);

    // Select item immediately after drawing it
    annotator->setSelectItemAfterDrawing(true);

    // When changing number tool seed, update all existing numbers
    annotator->setNumberToolSeedChangeUpdatesAllItems(true);

    // Set canvas background color
    annotator->setCanvasColor(QColor(255, 255, 255)); // White background

    // Collapse settings panel for more image space
    annotator->setSettingsCollapsed(true);

    // Show/hide the controls widget (undo, redo, crop, scale buttons)
    annotator->setControlsWidgetVisible(true);
}
```

--------------------------------

### Load UI Translations

Source: https://context7.com/ksnip/kimageannotator/llms.txt

Initialize internationalization support by calling the load function before creating the KImageAnnotator widget.

```cpp
#include <QApplication>
#include <QLocale>
#include <kImageAnnotator/KImageAnnotator.h>

int main(int argc, char **argv) {
    QApplication app(argc, argv);

    // Load kImageAnnotator translations based on system locale
    // This must be called before creating the KImageAnnotator widget
    kImageAnnotator::loadTranslations();

    // Create annotator after loading translations
    auto annotator = new kImageAnnotator::KImageAnnotator();

    // UI strings will now appear in the user's language if available
    // Supported: ar, bg, ca, cs, da, de, el, es, et, eu, fr, gl, hr, hu,
    //            id, it, ja, ko, nl, no, pl, pt, pt_BR, ro, ru, si, sq,
    //            sv, ta, tr, uk, zh_CN

    return app.exec();
}
```

--------------------------------

### Integrate kImageAnnotator with CMake

Source: https://github.com/ksnip/kimageannotator/blob/master/README.md

Configuration steps to locate and link the library in a CMake project.

```cmake
set(KIMAGEANNOTATOR_MIN_VERSION "0.x.x")
```

```cmake
find_package(kImageAnnotator-Qt5 ${KIMAGEANNOTATOR_MIN_VERSION} REQUIRED)
```

```cmake
find_package(kImageAnnotator-Qt6 ${KIMAGEANNOTATOR_MIN_VERSION} REQUIRED)
```

```cmake
target_link_libraries(myApp kImageAnnotator)
```

--------------------------------

### Integrate Undo/Redo Actions

Source: https://context7.com/ksnip/kimageannotator/llms.txt

Retrieve QAction objects for undo and redo to add them to application menus or toolbars. These actions automatically track the internal undo stack state.

```cpp
#include <QMainWindow>
#include <QToolBar>
#include <QMenuBar>
#include <kImageAnnotator/KImageAnnotator.h>

using kImageAnnotator::KImageAnnotator;

void setupUndoRedo(QMainWindow* mainWindow, KImageAnnotator* annotator) {
    // Get undo/redo actions from annotator
    QAction* undoAction = annotator->undoAction();
    QAction* redoAction = annotator->redoAction();

    // Add to Edit menu
    QMenu* editMenu = mainWindow->menuBar()->addMenu("Edit");
    editMenu->addAction(undoAction);
    editMenu->addAction(redoAction);
    editMenu->addSeparator();

    // Add to toolbar
    QToolBar* toolbar = mainWindow->addToolBar("Edit");
    toolbar->addAction(undoAction);
    toolbar->addAction(redoAction);

    // Actions automatically enable/disable based on undo stack state
    // Shortcuts are typically Ctrl+Z and Ctrl+Y by default
}
```

--------------------------------

### Configure Annotation View Modes

Source: https://context7.com/ksnip/kimageannotator/llms.txt

Connect menu actions to specific view modes like cropping, scaling, or rotating within the annotator.

```cpp
#include <QMainWindow>
#include <QMenuBar>
#include <QAction>
#include <kImageAnnotator/KImageAnnotator.h>

using kImageAnnotator::KImageAnnotator;

void setupEditMenu(QMainWindow* mainWindow, KImageAnnotator* annotator) {
    QMenu* editMenu = mainWindow->menuBar()->addMenu("Edit");

    // Annotation mode - draw shapes, text, blur, etc.
    QAction* annotateAction = new QAction("Annotate", mainWindow);
    QObject::connect(annotateAction, &QAction::triggered,
                     annotator, &KImageAnnotator::showAnnotator);
    editMenu->addAction(annotateAction);

    // Crop mode - select region to crop
    QAction* cropAction = new QAction("Crop", mainWindow);
    QObject::connect(cropAction, &QAction::triggered,
                     annotator, &KImageAnnotator::showCropper);
    editMenu->addAction(cropAction);

    // Scale mode - resize the image
    QAction* scaleAction = new QAction("Scale", mainWindow);
    QObject::connect(scaleAction, &QAction::triggered,
                     annotator, &KImageAnnotator::showScaler);
    editMenu->addAction(scaleAction);

    // Rotate mode - rotate or flip the image
    QAction* rotateAction = new QAction("Rotate/Flip", mainWindow);
    QObject::connect(rotateAction, &QAction::triggered,
                     annotator, &KImageAnnotator::showRotator);
    editMenu->addAction(rotateAction);

    // Canvas modifier - change canvas size and color
    QAction* canvasAction = new QAction("Modify Canvas", mainWindow);
    QObject::connect(canvasAction, &QAction::triggered,
                     annotator, &KImageAnnotator::showCanvasModifier);
    editMenu->addAction(canvasAction);

    // Cut mode - cut out vertical or horizontal slices
    QAction* cutAction = new QAction("Cut", mainWindow);
    QObject::connect(cutAction, &QAction::triggered,
                     annotator, &KImageAnnotator::showCutter);
    editMenu->addAction(cutAction);
}
```

--------------------------------

### Extend Tab Context Menu with Custom Actions

Source: https://context7.com/ksnip/kimageannotator/llms.txt

Use this to add application-specific operations like saving or copying to the tab context menu. Requires passing a pointer to the KImageAnnotator instance.

```cpp
#include <QAction>
#include <QMessageBox>
#include <kImageAnnotator/KImageAnnotator.h>

using kImageAnnotator::KImageAnnotator;

void setupTabContextMenu(KImageAnnotator* annotator) {
    QList<QAction*> customActions;

    // Create custom action for saving tab
    QAction* saveAction = new QAction("Save This Tab", annotator);
    QObject::connect(saveAction, &QAction::triggered, [annotator]() {
        QImage image = annotator->image();
        image.save("saved_tab.png");
    });
    customActions.append(saveAction);

    // Create custom action for copying to clipboard
    QAction* copyAction = new QAction("Copy to Clipboard", annotator);
    QObject::connect(copyAction, &QAction::triggered, [annotator]() {
        QImage image = annotator->image();
        QApplication::clipboard()->setImage(image);
    });
    customActions.append(copyAction);

    // Add all custom actions to tab context menu
    annotator->addTabContextMenuActions(customActions);
}
```

--------------------------------

### Configure Qt Translation Files

Source: https://github.com/ksnip/kimageannotator/blob/master/translations/CMakeLists.txt

This snippet configures Qt translation files using CMake. It conditionally uses `qt_create_translation` if `UPDATE_TS_FILES` is defined, otherwise it uses `qt_add_translation`. This allows for updating .ts files or simply compiling .qm files.

```cmake
find_package(Qt${QT_MAJOR_VERSION}LinguistTools)

set(KIMAGEANNOTATOR_LANG_TS
	kImageAnnotator_ar.ts
	kImageAnnotator_bg.ts
	kImageAnnotator_ca.ts
	kImageAnnotator_cs.ts
	kImageAnnotator_da.ts
	kImageAnnotator_de.ts
	kImageAnnotator_el.ts
	kImageAnnotator_es.ts
	kImageAnnotator_eu.ts
	kImageAnnotator_fr.ts
	kImageAnnotator_fr_CA.ts
	kImageAnnotator_gl.ts
	kImageAnnotator_hr.ts
	kImageAnnotator_hu.ts
	kImageAnnotator_id.ts
	kImageAnnotator_it.ts
	kImageAnnotator_ja.ts
	kImageAnnotator_ko.ts
	kImageAnnotator_nl.ts
	kImageAnnotator_no.ts
	kImageAnnotator_pl.ts
	kImageAnnotator_pt.ts
	kImageAnnotator_pt_BR.ts
	kImageAnnotator_ro.ts
	kImageAnnotator_ru.ts
	kImageAnnotator_si.ts
	kImageAnnotator_sq.ts
	kImageAnnotator_sv.ts
	kImageAnnotator_tr.ts
	kImageAnnotator_uk.ts
    kImageAnnotator_zh_CN.ts)

if (DEFINED UPDATE_TS_FILES)
	qt_create_translation(KIMAGEANNOTATOR_LANG_QM ${CMAKE_SOURCE_DIR}/translations ${KIMAGEANNOTATOR_SRCS} ${KIMAGEANNOTATOR_LANG_TS} OPTIONS "-no-obsolete")
else ()
	qt_add_translation(KIMAGEANNOTATOR_LANG_QM ${KIMAGEANNOTATOR_LANG_TS})
endif ()
```

--------------------------------

### Load Images into Annotator

Source: https://context7.com/ksnip/kimageannotator/llms.txt

Use loadImage for single images or addTab for multi-tab editing. Each tab maintains independent annotation states.

```cpp
#include <kImageAnnotator/KImageAnnotator.h>

using kImageAnnotator::KImageAnnotator;

void setupAnnotator(KImageAnnotator* annotator) {
    // Create a pixmap to annotate
    QPixmap screenshot = QPixmap::grabWindow(QApplication::desktop()->winId());

    // Load single image (replaces current content)
    annotator->loadImage(screenshot);

    // Or add multiple images as tabs
    QPixmap image1(QSize(800, 600));
    image1.fill(Qt::white);

    QPixmap image2(QSize(1024, 768));
    image2.fill(Qt::lightGray);

    // addTab returns the index of the new tab
    int tabIndex1 = annotator->addTab(image1, "Screenshot 1", "First screenshot");
    int tabIndex2 = annotator->addTab(image2, "Screenshot 2", "Second screenshot");

    // Update tab information later
    annotator->updateTabInfo(tabIndex1, "Modified Screenshot", "Edited on 2024-01-15");

    // Auto-hide tab bar when only one tab exists
    annotator->setTabBarAutoHide(true);
}
```

--------------------------------

### Retrieve Annotated Images

Source: https://context7.com/ksnip/kimageannotator/llms.txt

Use image() to access the current tab's annotated QImage or imageAt() for specific tabs. The returned image includes all rendered annotations.

```cpp
#include <QFileDialog>
#include <kImageAnnotator/KImageAnnotator.h>

using kImageAnnotator::KImageAnnotator;

void saveAnnotatedImage(KImageAnnotator* annotator) {
    // Get the annotated image from current tab
    QImage annotatedImage = annotator->image();

    // Save to file
    QString filePath = QFileDialog::getSaveFileName(
        nullptr,
        "Save Image",
        "annotated.png",
        "Images (*.png *.jpg *.bmp)"
    );

    if (!filePath.isEmpty()) {
        annotatedImage.save(filePath);
    }

    // Get image from a specific tab by index
    int tabIndex = 2;
    QImage specificImage = annotator->imageAt(tabIndex);
    specificImage.save("tab2_annotated.png");
}
```

--------------------------------

### Manage Custom Stickers

Source: https://context7.com/ksnip/kimageannotator/llms.txt

Define custom sticker sets using file paths. The keepDefault parameter determines whether to include built-in OpenMoji stickers.

```cpp
#include <kImageAnnotator/KImageAnnotator.h>

using kImageAnnotator::KImageAnnotator;

void configureStickers(KImageAnnotator* annotator) {
    // Define paths to custom sticker images
    QStringList customStickers;
    customStickers << "/path/to/stickers/checkmark.svg"
                   << "/path/to/stickers/cross.svg"
                   << "/path/to/stickers/star.svg"
                   << "/path/to/stickers/arrow_left.svg"
                   << "/path/to/stickers/arrow_right.svg";

    // Set stickers - keepDefault=true keeps built-in OpenMoji stickers
    annotator->setStickers(customStickers, true);

    // Or replace all stickers with custom ones only
    annotator->setStickers(customStickers, false);
}
```

--------------------------------

### Connect to Annotator Signals

Source: https://context7.com/ksnip/kimageannotator/llms.txt

Respond to user interactions and state changes such as image modifications, tab switching, or tab closing. Ensure the parent widget is available for UI-related updates.

```cpp
#include <QObject>
#include <kImageAnnotator/KImageAnnotator.h>

using kImageAnnotator::KImageAnnotator;

void connectSignals(KImageAnnotator* annotator, QWidget* parent) {
    // Image content changed (annotation added, modified, etc.)
    QObject::connect(annotator, &KImageAnnotator::imageChanged, [parent]() {
        parent->setWindowModified(true);
        qDebug() << "Image was modified";
    });

    // Tab selection changed
    QObject::connect(annotator, &KImageAnnotator::currentTabChanged,
                     [](int index) {
        qDebug() << "Switched to tab:" << index;
    });

    // User requested to close a tab (via middle-click or context menu)
    QObject::connect(annotator, &KImageAnnotator::tabCloseRequested,
                     [annotator](int index) {
        // Optionally prompt to save before closing
        annotator->removeTab(index);
    });

    // Tabs reordered by drag and drop
    QObject::connect(annotator, &KImageAnnotator::tabMoved,
                     [](int fromIndex, int toIndex) {
        qDebug() << "Tab moved from" << fromIndex << "to" << toIndex;
    });

    // Context menu opened on a tab
    QObject::connect(annotator, &KImageAnnotator::tabContextMenuOpened,
                     [](int index) {
        qDebug() << "Context menu opened for tab:" << index;
    });
}
```

--------------------------------

### kImageAnnotator Annotation Tools Enum

Source: https://context7.com/ksnip/kimageannotator/llms.txt

Use the Tools enum to access and specify different annotation functionalities provided by the library. Each tool has configurable properties.

```cpp
// Tools enum from kImageAnnotator namespace
enum class Tools {
    Select,         // Select and modify existing items
    Pen,            // Freehand drawing
    MarkerPen,      // Highlighter-style freehand drawing
    MarkerRect,     // Rectangular highlighter
    MarkerEllipse,  // Elliptical highlighter
    Line,           // Straight line
    Arrow,          // Single-headed arrow
    DoubleArrow,    // Double-headed arrow
    Rect,           // Rectangle shape
    Ellipse,        // Ellipse/circle shape
    Number,         // Numbered badge/circle
    NumberPointer,  // Number with pointer line
    NumberArrow,    // Number with arrow
    Text,           // Text box
    TextPointer,    // Text with pointer line
    TextArrow,      // Text with arrow
    Blur,           // Blur/obfuscate region
    Image,          // Insert image
    Sticker,        // Insert sticker/emoji
    Pixelate,       // Pixelate/mosaic region
    Duplicate       // Duplicate region of image
};
```

--------------------------------

### Insert External Images as Annotations

Source: https://context7.com/ksnip/kimageannotator/llms.txt

Use insertImageItem() to place external images onto the canvas as movable and resizable annotation items.

```cpp
#include <kImageAnnotator/KImageAnnotator.h>

using kImageAnnotator::KImageAnnotator;

void insertOverlayImages(KImageAnnotator* annotator) {
    // Load an overlay image (logo, watermark, etc.)
    QPixmap logo(":/images/logo.png");

    // Insert at specific position (100, 100) on the canvas
    QPointF position(100.0, 100.0);
    annotator->insertImageItem(position, logo);

    // Insert another image at different position
    QPixmap arrow(":/images/arrow.png");
    annotator->insertImageItem(QPointF(300.0, 200.0), arrow);

    // The inserted images can be moved, resized, and deleted
    // just like any other annotation item
}
```

--------------------------------

### Create Translation Target

Source: https://github.com/ksnip/kimageannotator/blob/master/translations/CMakeLists.txt

This command creates a custom CMake target named 'translations' that depends on the generated QM files. This ensures that translation files are processed when the 'translations' target is built.

```cmake
add_custom_target(translations ALL DEPENDS ${KIMAGEANNOTATOR_LANG_QM})
```

--------------------------------

### kImageAnnotator Image Effects Enum

Source: https://context7.com/ksnip/kimageannotator/llms.txt

The ImageEffects enum lists various visual effects that can be applied to images within the annotator. Choose an effect to modify the image's appearance.

```cpp
// Image effects that can be applied
enum class ImageEffects {
    NoEffect,       // No effect
    DropShadow,     // Add drop shadow
    Grayscale,      // Convert to grayscale
    Border,         // Add border
    InvertColor     // Invert colors
};
```

--------------------------------

### kImageAnnotator Fill Modes Enum

Source: https://context7.com/ksnip/kimageannotator/llms.txt

The FillModes enum defines how shapes are rendered, specifying whether to include a border, fill the shape, or both. Use this to control the visual appearance of shapes.

```cpp
// Fill modes for shapes
enum class FillModes {
    BorderAndNoFill,    // Outline only
    BorderAndFill,      // Filled with border
    NoBorderAndNoFill,  // Transparent (text only)
    NoBorderAndFill     // Filled without border
};
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.