QMetaObject

https://docs.rs/qmetaobject/0.2.10
Admin
QMetaObject is a Rust crate that provides bindings to the Qt API, enabling developers to use QML...
Tokens:189,204
Snippets:1,488
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### init_qt_to_rust

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/log/index.html

Installs a function into the Qt logging system that forwards messages to the Rust logging facade.

```APIDOC
## init_qt_to_rust

### Description
Installs into the Qt logging system a function which forwards messages to the Rust logging facade.

### Method
Function Call

### Parameters
None
```

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

### Install Message Handler

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/log/fn.install_message_handler.html

Installs a custom message handler for Qt messages. To restore the default handler, call this function with `None`.

```APIDOC
## Function install_message_handler

### Description
Wrapper for `qInstallMessageHandler` function.

### Method
`pub fn install_message_handler(logger: QtMessageHandler) -> QtMessageHandler`

### Endpoint
N/A (Rust function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
// Example of installing a message handler
let old_handler = qmetaobject::log::install_message_handler(|msg_type, context, msg| {
    // Custom logging logic here
    println!("Qt Message: {:?}, {:?}, {}", msg_type, context, msg);
});

// To restore the original handler:
// qmetaobject::log::install_message_handler(old_handler);
```

### Response
#### Success Response (200)
Returns the previous message handler.

#### Response Example
```rust
// The return type is QtMessageHandler, which is a closure or function pointer.
// Example: let previous_handler: QtMessageHandler = ...;
```

### Wrapper-specific behavior
To restore the message handler, call `install_message_handler(None)`.
```

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

### Register resources with qrc!

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/macro.qrc.html

Example showing how to use the qrc! macro to register files with different base directories and aliases.

```rust
use qmetaobject::qrc;
// private fn, base directory shortcut
qrc!(my_resource_1,
    "tests/qml" as "foo1" {
        "main.qml",
        "Bar.qml" as "baz/Foo.qml",
     }
);

// public fn, no shortcuts
qrc!(pub my_resource_2,
    "foo2" {
        // either use file alias or re-organize files
        "tests/qml/main.qml" as "main.qml",
        "tests/qml/Bar.qml" as "baz/Foo.qml",
     }
);

// registers the resource to Qt
my_resource_1();
my_resource_2();
// do something with resources
use_resource("qrc:/foo1/baz/Foo.qml");
use_resource("qrc:/foo2/baz/Foo.qml");
```

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

### String Conversion for QMetaType

Source: https://docs.rs/qmetaobject/0.2.10/src/qmetaobject/qmetatype.rs.html

Implement `CONVERSION_TO_STRING` and `CONVERSION_FROM_STRING` for types that need to be converted to and from `QString`. This example shows the implementation for `String`.

```rust
impl QMetaType for String {
    const CONVERSION_TO_STRING: Option<fn(&Self) -> QString> = Some(|s| QString::from(&*s as &str));
    const CONVERSION_FROM_STRING: Option<fn(&QString) -> Self> = Some(|s| s.to_string());
}
```

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

### QQmlExtensionPlugin Implementation

Source: https://docs.rs/qmetaobject/0.2.10/src/qmetaobject/qtdeclarative.rs.html

Example implementation of a QML extension plugin using the QQmlExtensionPlugin trait.

```rust
use qmetaobject::*;
use std::ffi::CStr;

#[derive(Default, QObject)]
struct QExampleQmlPlugin {
    base: qt_base_class!(trait QQmlExtensionPlugin),
    plugin: qt_plugin!("org.qt-project.Qt.QQmlExtensionInterface/1.0"),
}

impl QQmlExtensionPlugin for QExampleQmlPlugin {
    fn register_types(&mut self, uri: &CStr) {
        // call `qml_register_type` here
    }
}
```

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

### Install Qt Message Handler

Source: https://docs.rs/qmetaobject/0.2.10/src/qmetaobject/log.rs.html

Wraps the qInstallMessageHandler function. Pass None to restore the default handler.

```rust
pub fn install_message_handler(logger: QtMessageHandler) -> QtMessageHandler {
    cpp!(unsafe [logger as "QtMessageHandler"] -> QtMessageHandler as "QtMessageHandler" {
        return qInstallMessageHandler(logger);
    })
}
```

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

### Equivalent .qrc file structure

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/macro.qrc.html

The XML structure that corresponds to the resource registration defined in the Rust example.

```xml
<RCC>
    <qresource prefix="/foo">
        <file>main.qml</file>
        <file alias="baz/Foo.qml">Bar.qml</file>
    </qresource>
</RCC>
```

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

### Declaring Meta Methods with qt_method

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/macro.qt_method.html

Example showing how to use qt_method within a QObject struct for both inline and out-of-line method definitions.

```rust
use qmetaobject::*;

#[derive(QObject)]
struct Foo {
   base: qt_base_class!(trait QObject),
   defined_method: qt_method!(fn defined_method(&self, foo: u32) -> u32 {
      println!("contents goes here.");
      return 42;
   }),
   out_of_line_method: qt_method!(fn(&self, foo: u32)-> u32),
}

impl Foo {
   fn out_of_line_method(&mut self, foo: u32) -> u32 {
      println!("Or here.");
      return 69;
   }
}
```

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

### Install Qt Message Handler

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/log/fn.install_message_handler.html

Registers a custom Qt message handler. Call with None to restore the default handler.

```rust
pub fn install_message_handler(logger: QtMessageHandler) -> QtMessageHandler
```

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

### Declaring and Emitting a Signal

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/macro.qt_signal.html

Example of defining a signal within a QObject struct and emitting it from a function.

```rust
use qmetaobject::*;

#[derive(QObject)]
struct Foo {
   base: qt_base_class!(trait QObject),
   my_signal: qt_signal!(xx: u32, yy: String),
}

fn some_code(foo: &mut Foo) {
   foo.my_signal(42, "42".into()); // emits the signal
}
```

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

### QQuickItem Helper Methods

Source: https://docs.rs/qmetaobject/0.2.10/src/qmetaobject/qtdeclarative.rs.html

Provides helper methods for QQuickItem, such as getting the bounding rectangle and triggering an update.

```APIDOC
## QQuickItem Helper Methods

### Description
Provides helper methods for QQuickItem, such as getting the bounding rectangle and triggering an update.

### Methods

#### `bounding_rect`
Returns the bounding rectangle of the item.

- **Returns**:
  - `QRectF` - The bounding rectangle.

#### `update`
Triggers a repaint of the item.
```

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

### Create QSettings from File Path

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/struct.QSettings.html

Initializes QSettings using a specific file path and format.

```rust
pub fn from_path(file_name: &str) -> QSettings
```

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

### Get Reference from QPointer

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/struct.QPointer.html

Safely gets a reference to the managed QObject. Returns None if the C++ object has been deleted.

```rust
pub fn as_ref(&self) -> Option<&T>
```

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

### Usage of queued_callback

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/fn.queued_callback.html

Example of creating a callback that executes a closure on the main Qt thread from a spawned thread.

```rust
use qmetaobject::queued_callback;

let callback = queued_callback(|()| println!("hello from main thread"));
std::thread::spawn(move || {callback(());}).join();
```

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

### Get QVariant User Type

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QVariant.html

Wrapper around the `userType()` method to get the integer identifier for the QVariant's type.

```rust
pub fn user_type(&self) -> i32
```

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

### Create QSettings with Organization and Application

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/struct.QSettings.html

Initializes QSettings using organization and application names. It defaults to IniFormat and UserScope.

```rust
pub fn new(organization: &str, application: &str) -> QSettings
```

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

### Install Message Handler

Source: https://docs.rs/qmetaobject/0.2.10/src/qmetaobject/log.rs.html

Wrapper for `qInstallMessageHandler` function. Call `install_message_handler(None)` to restore the original message handler.

```APIDOC
## POST /install_message_handler

### Description
Installs a custom message handler for Qt.

### Method
POST

### Endpoint
/install_message_handler

### Parameters
#### Request Body
- **logger** (QtMessageHandler) - Required - The message handler function to install.

### Request Example
```json
{
  "logger": "your_rust_handler_function"
}
```

### Response
#### Success Response (200)
- **previous_handler** (QtMessageHandler) - The previously installed message handler.

#### Response Example
```json
{
  "previous_handler": "previous_handler_reference"
}
```
```

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

### Get QVariant Type Name

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QVariant.html

Wrapper around the `typeName()` method to get the name of the QVariant's type as a QString.

```rust
pub fn type_name(&self) -> QString
```

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

### Initialize Qt to Rust Logging

Source: https://docs.rs/qmetaobject/0.2.10/src/qmetaobject/log.rs.html

Installs a handler that forwards Qt messages to the Rust logging facade. This function is safe to call multiple times.

```rust
#[cfg(feature = "log")]
pub fn init_qt_to_rust() {
    // The reason it is named so complex instead of simple `init` is that
    // such descriptive name is future-proof. Consider if someone someday
    // would want to implement the opposite forwarding logger?
    install_message_handler(Some(log_capture));
}
```

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

### Get Color Name

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Retrieves the name of the color.

```rust
pub fn name(&self) -> QString
```

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

### Get RGBA Value

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Retrieves the RGBA value of the color.

```rust
pub fn rgba(&self) -> QRgb
```

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

### Initialize Qt to Rust Logging

Source: https://docs.rs/qmetaobject/0.2.10/src/qmetaobject/log.rs.html

Installs a function into the Qt logging system that forwards messages to the Rust logging facade. Most metadata from Qt logging context is retained and passed to `log::Record`. Logging levels are mapped using the default `From` implementation. This function can be called multiple times.

```APIDOC
## POST /init_qt_to_rust

### Description
Initializes the integration to forward Qt messages to the Rust logging facade.

### Method
POST

### Endpoint
/init_qt_to_rust

### Parameters
This endpoint does not require any parameters.

### Request Example
```json
{}
```

### Response
#### Success Response (200)
This endpoint does not return any specific data upon success.

#### Response Example
```json
null
```
```

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

### Get RGBA64 Value

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Retrieves the RGBA64 value of the color.

```rust
pub fn rgba64(&self) -> QRgba64
```

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

### Initialize QmlEngine Instance

Source: https://docs.rs/qmetaobject/0.2.10/src/qmetaobject/qtdeclarative.rs.html

Creates a new QmlEngine instance by passing command-line arguments to the underlying C++ implementation.

```rust
impl QmlEngine {
    /// Create a new QmlEngine
    pub fn new() -> QmlEngine {
        let mut arguments: Vec<*mut c_char> = std::env::args()
            .map(|arg| CString::new(arg.into_bytes()).expect("argument contains invalid c-string!"))
            .map(|arg| arg.into_raw())
            .collect();
        let argc: i32 = arguments.len() as i32;
        let argv: *mut *mut c_char = arguments.as_mut_ptr();

        let result = cpp!(unsafe [
            argc as "int",
            argv as "char **"
        ] -> QmlEngine as "QmlEngineHolder" {
            // Static variables when used inside function are initialized only once
            static int _argc  = argc;
            static char **_argv = nullptr;
            // this is *real* initialization, and it would also happen only once
            if (_argv == nullptr) {
                // copy the arguments
                _argv = new char *[argc + 1];
                // argv should be null terminated
                _argv[argc] = nullptr;
                for (int i = 0; i < argc; ++i) {
                    _argv[i] = new char[strlen(argv[i]) + 1];
                    strcpy(_argv[i], argv[i]);
                }
            }
            return QmlEngineHolder(_argc, _argv);
        });
```

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

### Get RGB Value

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Retrieves the RGB value of the color.

```rust
pub fn rgb(&self) -> QRgb
```

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

### Type ID Implementation

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/connections/struct.RustSignal.html

Gets the `TypeId` of the `RustSignal` type.

```rust
fn type_id(&self) -> TypeId
```

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

### QStringList::new() - Create a new QStringList

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/struct.QStringList.html

Creates and returns a new, empty QStringList. This is the default way to initialize a QStringList.

```rust
pub fn new() -> QStringList
```

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

### Get QSettings Filename

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/struct.QSettings.html

Retrieves the filename associated with the QSettings instance.

```rust
pub fn filename(&self) -> String
```

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

### qmetaobject::log::init_qt_to_rust

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/log/fn.init_qt_to_rust.html

Installs a function into the Qt logging system that forwards messages to the Rust logging facade. It retains most metadata from the Qt logging context and maps logging levels using the default `From` implementation. This function can be called multiple times.

```APIDOC
## Function init_qt_to_rust

### Description
Installs into Qt logging system a function which forwards messages to the Rust logging facade. Most metadata from Qt logging context is retained and passed to `log::Record`. Logging levels are mapped with the default `From` implementation. This function may be called more than once.

### Signature
```rust
pub fn init_qt_to_rust()
```
```

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

### Get Lightness (i32)

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Retrieves the lightness component of the color as an integer.

```rust
pub fn lightness(&self) -> i32
```

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

### Create QPen from Style

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/struct.QPen.html

Creates a new QPen instance initialized with the specified PenStyle.

```rust
pub fn from_style(style: PenStyle) -> QPen
```

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

### Trait QSingletonInit

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/qtdeclarative/trait.QSingletonInit.html

Documentation for the QSingletonInit trait used for initializing singleton QML objects.

```APIDOC
## Trait QSingletonInit

### Description
Initialization for singleton QML objects. This trait defines the interface for objects that require initialization after the C++ object has been created.

### Required Methods
#### fn init(&mut self)
Initialize the singleton QML object. This method is called on a default-constructed object after the C++ object has been created.

### Panics
The process will be aborted if the init method panics.
```

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

### Get Red Component (i32)

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Retrieves the red component of the color as an integer.

```rust
pub fn red(&self) -> i32
```

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

### Get Color Name with Format

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Retrieves the name of the color with a specified format.

```rust
pub fn name_with_format(&self, format: QColorNameFormat) -> QString
```

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

### QmlEngine::new()

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/qtdeclarative/struct.QmlEngine.html

Creates a new instance of QmlEngine.

```APIDOC
## pub fn new() -> QmlEngine

### Description
Create a new QmlEngine.

### Method
POST

### Endpoint
/api/qmlengine

### Returns
A new QmlEngine instance.
```

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

### Get Lightness (f64)

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Retrieves the lightness component of the color as a floating-point number.

```rust
pub fn lightness_f(&self) -> f64
```

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

### Get Green Component (i32)

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Retrieves the green component of the color as an integer.

```rust
pub fn green(&self) -> i32
```

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

### Initialize Qt to Rust logging

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/log/fn.init_qt_to_rust.html

Call this function to forward Qt log messages to the Rust logging facade. It can be invoked multiple times safely.

```rust
pub fn init_qt_to_rust()
```

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

### Get Blue Component (i32)

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Retrieves the blue component of the color as an integer.

```rust
pub fn blue(&self) -> i32
```

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

### QCoreApplication Static Methods

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/qtcore/core_application/struct.QCoreApplication.html

Methods for managing application identity, versioning, and lifecycle control.

```APIDOC
## QCoreApplication Static Methods

### Description
Provides access to static Qt core application properties and control functions.

### Methods
- **application_name() -> QString**: Returns the application name.
- **set_application_name(application: QString)**: Sets the application name.
- **application_version() -> QString**: Returns the application version.
- **set_application_version(version: QString)**: Sets the application version.
- **organization_domain() -> QString**: Returns the organization domain.
- **set_organization_domain(org_domain: QString)**: Sets the organization domain.
- **organization_name() -> QString**: Returns the organization name.
- **set_organization_name(org_name: QString)**: Sets the organization name.
- **quit()**: Stops event processing.
```

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

### Get Alpha Component (i32)

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Retrieves the alpha component of the color as an integer.

```rust
pub fn alpha(&self) -> i32
```

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

### Create a new QQuickView

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/qtdeclarative/struct.QQuickView.html

Instantiates a new QQuickView, initializing its associated QML engine and application.

```rust
pub fn new() -> QQuickView
```

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

### QStringList::len() - Get the number of items

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/struct.QStringList.html

Returns the number of elements currently in the QStringList.

```rust
pub fn len(&self) -> usize
```

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

### QPointer<T> Implementations (Pinned Reference)

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/struct.QPointer.html

Provides a method to get a pinned reference to the QObject.

```APIDOC
## impl<T: QObject> QPointer<T>

### Methods

#### `as_pinned(&self) -> Option<QObjectPinned<'_, T>>`
Returns a pinned reference to the QObject, or None if it was deleted.
```

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

### QmlEngine::exec()

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/qtdeclarative/struct.QmlEngine.html

Launches the Qt application event loop.

```APIDOC
## pub fn exec(&self)

### Description
Launches the application.

### Method
GET

### Endpoint
/api/qmlengine/exec
```

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

### Get String Value from QSettings

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/struct.QSettings.html

Retrieves a string value for a given key from QSettings.

```rust
pub fn value_string(&self, key: &str) -> String
```

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

### Register Public Resource with Qt

Source: https://docs.rs/qmetaobject/0.2.10/src/qmetaobject/lib.rs.html

Call the generated public function to register the resource. This is typically done in the main function or initialization logic.

```rust
private::
my_resource_2();
```

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

### Get Boolean Value from QSettings

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/struct.QSettings.html

Retrieves a boolean value for a given key from QSettings.

```rust
pub fn value_bool(&self, key: &str) -> bool
```

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

### Create New QQuickView

Source: https://docs.rs/qmetaobject/0.2.10/src/qmetaobject/qtdeclarative.rs.html

Initializes a new QQuickView instance with its own QmlEngine. The view is configured to resize the root object to fit the view.

```rust
pub fn new() -> QQuickView {
        let mut engine = QmlEngine::new();
        cpp!(unsafe [mut engine as "QmlEngineHolder"] {
            engine.view = std::unique_ptr<QQuickView>(new QQuickView(engine.engine.get(), nullptr));
            engine.view->setResizeMode(QQuickView::SizeRootObjectToView);
        });
        QQuickView { engine }
    }
```

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

### Get Red Component (f64)

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Retrieves the red component of the color as a floating-point number.

```rust
pub fn red_f(&self) -> f64
```

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

### Include QCoreApplication Header

Source: https://docs.rs/qmetaobject/0.2.10/src/qmetaobject/qtcore/core_application.rs.html

Includes the necessary Qt header for QCoreApplication within the Rust module.

```rust
cpp! {{
    #include <QtCore/QCoreApplication>
}}
```

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

### Get Green Component (f64)

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Retrieves the green component of the color as a floating-point number.

```rust
pub fn green_f(&self) -> f64
```

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

### Get HSVA Components (i32)

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Retrieves the HSVA components of the color as a tuple of integers.

```rust
pub fn get_hsva(&self) -> (i32, i32, i32, i32)
```

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

### Create QPen from Color

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/struct.QPen.html

Creates a new QPen instance initialized with the specified QColor.

```rust
pub fn from_color(color: QColor) -> QPen
```

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

### Get HSLA Components (i32)

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Retrieves the HSLA components of the color as a tuple of integers.

```rust
pub fn get_hsla(&self) -> (i32, i32, i32, i32)
```

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

### Get Blue Component (f64)

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Retrieves the blue component of the color as a floating-point number.

```rust
pub fn blue_f(&self) -> f64
```

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

### Show QQuickView

Source: https://docs.rs/qmetaobject/0.2.10/src/qmetaobject/qtdeclarative.rs.html

Displays the QQuickView window. This function directly calls the `show()` method of the underlying C++ QQuickView object.

```rust
pub fn show(&mut self) {
        let engine = self.engine();
        cpp!(unsafe [engine as "QmlEngineHolder *"] {
            engine->view->show();
        });
    }
```

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

### Show QQuickView

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/qtdeclarative/struct.QQuickView.html

Displays the QQuickView. Refer to the Qt documentation for QQuickView::show for detailed behavior.

```rust
pub fn show(&mut self)
```

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

### Get Alpha Component (f64)

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Retrieves the alpha component of the color as a floating-point number.

```rust
pub fn alpha_f(&self) -> f64
```

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

### Create QPointer from Reference

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/struct.QPointer.html

Constructs a QPointer from a reference to a QObject. The C++ object must already exist.

```rust
fn from(obj: &'a T) -> Self
```

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

### Implement Any for T

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/scenegraph/enum.RectangleNode.html

Blanket implementation of the Any trait for any type T. This allows getting the TypeId of a type.

```rust
impl<T> Any for T
where T: 'static + ?Sized,
```

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

### Get category from QMessageLogContext

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/log/struct.QMessageLogContext.html

Wrapper for QMessageLogContext::category, returning the category as a string slice.

```rust
pub fn category(&self) -> &str
```

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

### QmlEngine::load_file()

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/qtdeclarative/struct.QmlEngine.html

Loads a QML file from the specified path.

```APIDOC
## pub fn load_file(&mut self, path: QString)

### Description
Loads a file as a qml file (See QQmlApplicationEngine::load(const QString & filePath)).

### Method
POST

### Endpoint
/api/qmlengine/load_file

### Parameters
#### Path Parameters
- **path** (QString) - Required - The path to the QML file to load.
```

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

### Create QmlComponent

Source: https://docs.rs/qmetaobject/0.2.10/src/qmetaobject/qtdeclarative.rs.html

Constructs a new QmlComponent wrapper using a provided QmlEngine. This is the initial step before loading QML data or URLs.

```rust
pub fn new(engine: &QmlEngine) -> QmlComponent {
        cpp!(unsafe [engine as "QmlEngineHolder *"] -> QmlComponent as "QQmlComponentHolder" {
            return QQmlComponentHolder(engine->engine.get());
        })
    }
```

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

### Access Application Metadata

Source: https://docs.rs/qmetaobject/0.2.10/src/qmetaobject/qtcore/core_application.rs.html

Methods to get and set application name, version, and organization details.

```rust
pub fn application_name() -> QString {
        cpp!(unsafe [] -> QString as "QString" {
            return QCoreApplication::applicationName();
        })
    }
```

```rust
pub fn set_application_name(application: QString) {
        cpp!(unsafe [application as "QString"] {
            QCoreApplication::setApplicationName(application);
        });
    }
```

```rust
pub fn application_version() -> QString {
        cpp!(unsafe [] -> QString as "QString" {
            return QCoreApplication::applicationVersion();
        })
    }
```

```rust
pub fn set_application_version(version: QString) {
        cpp!(unsafe [version as "QString"] {
            QCoreApplication::setApplicationVersion(version);
        });
    }
```

```rust
pub fn organization_domain() -> QString {
        cpp!(unsafe [] -> QString as "QString" {
            return QCoreApplication::organizationDomain();
        })
    }
```

```rust
pub fn set_organization_domain(org_domain: QString) {
        cpp!(unsafe [org_domain as "QString"] {
            QCoreApplication::setOrganizationDomain(org_domain);
        });
    }
```

```rust
pub fn organization_name() -> QString {
        cpp!(unsafe [] -> QString as "QString" {
            return QCoreApplication::organizationName();
        })
    }
```

```rust
pub fn set_organization_name(org_name: QString) {
        cpp!(unsafe [org_name as "QString"] {
            QCoreApplication::setOrganizationName(org_name);
        });
    }
```

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

### Define QObject with a Signal

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/macro.qt_signal.html

This example shows how to define a struct `Foo` that derives from `QObject` and includes a custom signal `my_signal` declared using `qt_signal!`. The signal takes a `u32` and a `String`.

```rust
use qmetaobject::*

#[derive(QObject)]
struct Foo {
   base: qt_base_class!(trait QObject),
   my_signal: qt_signal!(xx: u32, yy: String),
}
```

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

### Implement Clone for QSizeF

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/struct.QSizeF.html

Provides methods for cloning QSizeF instances. `clone` creates a new QSizeF with the same values, while `clone_from` performs copy-assignment.

```rust
fn clone(&self) -> QSizeF
```

```rust
fn clone_from(&mut self, source: &Self)
```

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

### Get RGBA Components (f64)

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Retrieves the RGBA components of the color as a tuple of floating-point numbers.

```rust
pub fn get_rgba_f(&self) -> (f64, f64, f64, f64)
```

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

### Get HSVA Components (f64)

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Retrieves the HSVA components of the color as a tuple of floating-point numbers.

```rust
pub fn get_hsva_f(&self) -> (f64, f64, f64, f64)
```

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

### QDateTime Methods

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/struct.QDateTime.html

Methods for creating and interacting with QDateTime instances.

```APIDOC
## QDateTime Methods

### Description
Methods to construct QDateTime objects and retrieve date/time components.

### Methods
- **from_date(date: QDate) -> QDateTime**: Creates a QDateTime from a QDate.
- **from_date_time_local_timezone(date: QDate, time: QTime) -> QDateTime**: Creates a QDateTime using local timezone.
- **get_date(&self) -> QDate**: Returns the date component.
- **get_time(&self) -> QTime**: Returns the time component.
- **get_date_time(&self) -> (QDate, QTime)**: Returns both date and time components.
- **is_valid(&self) -> bool**: Checks if the QDateTime instance is valid.
```

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

### QDateTime Constructors

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QDateTime.html

Methods for creating new QDateTime instances.

```APIDOC
## impl QDateTime

### pub fn from_date(date: QDate) -> QDateTime

Wrapper around `QDateTime(const QDateTime &other)` constructor.

### pub fn from_date_time_local_timezone(date: QDate, time: QTime) -> QDateTime

Wrapper around `QDateTime(const QDate &date, const QTime &time, Qt::TimeSpec spec = Qt::LocalTime)` constructor.

##### §Wrapper-specific
`spec` is left as it is, thus it is always `Qt::LocalTime`.
```

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

### Get Type ID of SGNode

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/scenegraph/struct.SGNode.html

Returns the TypeId of the SGNode, useful for runtime type identification.

```rust
fn type_id(&self) -> TypeId
Gets the `TypeId` of `self`. Read more

```

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

### Get HSLA Components (f64)

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Retrieves the HSLA components of the color as a tuple of floating-point numbers.

```rust
pub fn get_hsla_f(&self) -> (f64, f64, f64, f64)
```

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

### QQuickView Struct and Methods

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/qtdeclarative/struct.QQuickView.html

Provides details on creating and managing a QQuickView instance.

```APIDOC
## Struct QQuickView

### Description
Bindings to a QQuickView.

### Methods

#### pub fn new() -> QQuickView
Creates a new QQuickView, its engine and an application.

#### pub fn engine(&mut self) -> &mut QmlEngine
Returns the wrapper to the engine.

#### pub fn show(&mut self)
Refer to the Qt documentation of QQuickView::show.

#### pub fn set_source(&mut self, url: QString)
Refer to the Qt documentation of QQuickView::setSource.
```

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

### Create QColor from HSV (f64)

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Constructs a QColor from HSV floating-point components.

```rust
pub fn from_hsv_f(h: f64, s: f64, v: f64) -> QColor
```

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

### Get QMouseEvent Event Type

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/qtdeclarative/struct.QMouseEvent.html

Returns the type of the QMouseEvent. This method is part of the QMouseEvent implementation.

```rust
pub fn event_type(self) -> QMouseEventType

```

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

### Get line number from QMessageLogContext

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/log/struct.QMessageLogContext.html

Wrapper for QMessageLogContext::line, returning the line number as an i32.

```rust
pub fn line(&self) -> i32
```

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

### Execute Application Event Loop

Source: https://docs.rs/qmetaobject/0.2.10/src/qmetaobject/qtdeclarative.rs.html

Starts the Qt application's event loop, allowing it to process events and respond to user interactions. This should typically be called after setting up the QML engine and UI.

```rust
pub fn exec(&self) {
        cpp!(unsafe [self as "QmlEngineHolder *"] {
            self->app->exec();
        })
    }
```

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

### Create QColor from RGB (f64)

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Constructs a QColor from RGB floating-point components. Alpha defaults to 1.0.

```rust
pub fn from_rgb_f(r: f64, g: f64, b: f64) -> QColor
```

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

### Struct QCoreApplication

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/qtcore/core_application/index.html

Documentation for the QCoreApplication struct which acts as a wrapper around the C++ QCoreApplication class.

```APIDOC
## Struct QCoreApplication

### Description
Wrapper around the `QCoreApplication` class from the Qt framework.

### Module
`qmetaobject::qtcore`
```

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

### Using qt_base_class in a QObject

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/macro.qt_base_class.html

Example of applying the qt_base_class macro within a struct that derives QObject.

```rust
use qmetaobject::*;

#[derive(QObject)]
struct Foo {
   base : qt_base_class!(trait QObject),
}
```

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

### QObjectBox Implementations

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/struct.QObjectBox.html

Provides methods for creating and accessing QObjectBox instances.

```APIDOC
### impl<T: QObject> QObjectBox<T>

#### pub fn new(obj: T) -> Self
Creates a new QObjectBox instance with the given object.
```

```APIDOC
### impl<T: QObject + ?Sized> QObjectBox<T>

#### pub fn pinned(&self) -> QObjectPinned<'_, T>
Returns a pinned reference to the object within the QObjectBox.
```

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

### Get Date and Time from QDateTime

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/struct.QDateTime.html

A convenience function to obtain both the date and time components from a QDateTime object.

```rust
pub fn get_date_time(&self) -> (QDate, QTime)
```

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

### Create QBrush from Color

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/struct.QBrush.html

Creates a new QBrush instance from a given QColor. Ensure QColor is properly initialized before use.

```rust
pub fn from_color(color: QColor) -> QBrush
```

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

### QMetaType Implementation for String

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/qmetatype/trait.QMetaType.html

Demonstrates the implementation of QMetaType for the String type, including definitions for string conversion constants.

```rust
const CONVERSION_TO_STRING: Option<fn(&Self) -> QString>
```

```rust
const CONVERSION_FROM_STRING: Option<fn(&QString) -> Self>
```

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

### Get Magenta Component (i32)

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Retrieves the magenta component of the color in a CMYK color space as an integer.

```rust
pub fn magenta(&self) -> i32
```

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

### Get HSV Saturation (i32)

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Retrieves the saturation component of the color in the HSV color space as an integer.

```rust
pub fn hsv_saturation(&self) -> i32
```

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

### Create QmlComponent with QmlEngine

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/qtdeclarative/struct.QmlComponent.html

Initializes a new QmlComponent instance using an existing QmlEngine. This is the primary way to create a QmlComponent.

```rust
pub fn new(engine: &QmlEngine) -> QmlComponent
```

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

### Implement Rust_QQuickPaintedItem C++ Wrapper

Source: https://docs.rs/qmetaobject/0.2.10/src/qmetaobject/qtdeclarative.rs.html

Provides the C++ implementation for a QQuickPaintedItem that delegates events and painting to Rust.

```cpp
cpp! {{
    #include <qmetaobject_rust.hpp>
    #include <QtQuick/QQuickItem>
    #include <QtQuick/QQuickPaintedItem>
    #include <QtGui/QPainter>

    struct Rust_QQuickPaintedItem : RustObject<QQuickPaintedItem> {
        void classBegin() override {
            QQuickPaintedItem::classBegin();
            rust!(Rust_QQuickPaintedItem_classBegin[
                rust_object: QObjectPinned<dyn QQuickPaintedItem> as "TraitObject"
            ] {
                rust_object.borrow_mut().class_begin();
            });
        }

        void componentComplete() override {
            QQuickPaintedItem::componentComplete();
            rust!(Rust_QQuickPaintedItem_componentComplete[
                rust_object: QObjectPinned<dyn QQuickPaintedItem> as "TraitObject"
            ] {
                rust_object.borrow_mut().component_complete();
            });
        }

        void mousePressEvent(QMouseEvent *event) override { handleMouseEvent(event); }
        void mouseMoveEvent(QMouseEvent *event) override { handleMouseEvent(event); }
        void mouseReleaseEvent(QMouseEvent *event) override { handleMouseEvent(event); }

        void handleMouseEvent(QMouseEvent *event) {
           if (!rust!(Rust_QQuickPaintedItem_mousePressEvent[
                rust_object: QObjectPinned<dyn QQuickPaintedItem> as "TraitObject",
                event: QMouseEvent as "QMouseEvent *"
            ] -> bool as "bool" {
                rust_object.borrow_mut().mouse_event(event)
            })) { event->ignore(); }
        }

        void QT_QQUICKITEM_GEOMETRYCHANGE (const QRectF &new_geometry, const QRectF &old_geometry) override{
            rust!(Rust_QQuickPaintedItem_geometryChanged[
                rust_object: QObjectPinned<dyn QQuickPaintedItem> as "TraitObject",
                new_geometry: QRectF as "QRectF",
                old_geometry: QRectF as "QRectF"
            ] {
                rust_object.borrow_mut().geometry_changed(new_geometry, old_geometry);
            });
            QQuickPaintedItem::QT_QQUICKITEM_GEOMETRYCHANGE(new_geometry, old_geometry);
        }

        void releaseResources() override {
            QQuickPaintedItem::releaseResources();
            rust!(Rust_QQuickPaintedItem_releaseResources[
                rust_object: QObjectPinned<dyn QQuickPaintedItem> as "TraitObject"
            ] {
                rust_object.borrow_mut().release_resources();
            });
        }

        void paint(QPainter *p) override {
            rust!(Rust_QQuickPaintedItem_paint[
                rust_object: QObjectPinned<dyn QQuickPaintedItem> as "TraitObject",
                p: *mut QPainter as "QPainter*"
            ] {
                rust_object.borrow_mut().paint(&mut *p);
            });
        }
    };
}}
```

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

### Get HSV Hue (i32)

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Retrieves the hue component of the color in the HSV color space as an integer.

```rust
pub fn hsv_hue(&self) -> i32
```

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

### Get HSL Saturation (i32)

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Retrieves the saturation component of the color in the HSL color space as an integer.

```rust
pub fn hsl_saturation(&self) -> i32
```

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

### Set Qt Quick Controls Style

Source: https://docs.rs/qmetaobject/0.2.10/src/qmetaobject/qtquickcontrols2.rs.html

Configures the style for Qt Quick Controls by setting the QT_QUICK_CONTROLS_STYLE environment variable.

```rust
1/// Refer to the Qt documentation for QQuickStyle
2pub struct QQuickStyle {}
3
4impl QQuickStyle {
5    /// Refer to the Qt documentation for QQuickStyle::setStyle
6    pub fn set_style(style: &str) {
7        std::env::set_var("QT_QUICK_CONTROLS_STYLE", style);
8    }
9}
```

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

### Get HSL Hue (i32)

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Retrieves the hue component of the color in the HSL color space as an integer.

```rust
pub fn hsl_hue(&self) -> i32
```

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

### QMetaType Implementation

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Methods for registering QColor with the Qt meta-object system and converting to/from QVariant.

```APIDOC
## QMetaType Implementation

### Description
Provides integration with Qt's meta-object system for type registration and variant conversion.

### Methods
- **register(name: Option<&CStr>) -> i32**
- **id() -> i32**
- **to_qvariant() -> QVariant**
- **from_qvariant(variant: QVariant) -> Option<Self>**
```

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

### Create QColor from RGB (i32)

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Constructs a QColor from RGB integer components.

```rust
pub fn from_rgb(r: i32, g: i32, b: i32) -> QColor
```

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

### Get Cyan Component (i32)

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Retrieves the cyan component of the color in a CMYK color space as an integer.

```rust
pub fn cyan(&self) -> i32
```

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

### Get Black Component (i32)

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Retrieves the black component of the color in a CMYK color space as an integer.

```rust
pub fn black(&self) -> i32
```

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

### Load QML File with QString

Source: https://docs.rs/qmetaobject/0.2.10/src/qmetaobject/qtdeclarative.rs.html

Loads a QML file specified by a QString path into the QML engine. Ensure the path is valid.

```rust
pub fn load_file(&mut self, path: QString) {
        cpp!(unsafe [self as "QmlEngineHolder *", path as "QString"] {
            self->engine->load(path);
        })
    }
```

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

### Get QMouseEvent Position

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/qtdeclarative/struct.QMouseEvent.html

Returns the position of the QMouseEvent. This is a wrapper around Qt’s QMouseEvent::localPos().

```rust
pub fn position(self) -> QPointF

```

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

### Create QTime from Hour, Minute, Second, Millisecond

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QTime.html

Constructs a QTime object using hour, minute, and optional second and millisecond values. Default arguments from the Qt constructor are converted to Options.

```rust
pub fn from_h_m_s_ms(h: i32, m: i32, s: Option<i32>, ms: Option<i32>) -> QTime
```

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

### Get function name from QMessageLogContext

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/log/struct.QMessageLogContext.html

Wrapper for QMessageLogContext::function, returning the function name as a string slice.

```rust
pub fn function(&self) -> &str
```

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

### Create QColor from HSL (f64)

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Constructs a QColor from HSL floating-point components.

```rust
pub fn from_hsl_f(h: f64, s: f64, l: f64) -> QColor
```

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

### Create QColor from Name

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/prelude/struct.QColor.html

Constructs a QColor from a string name. This is a wrapper around the QColor(QLatin1String) constructor.

```rust
pub fn from_name(name: &str) -> QColor
```

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

### Get file name from QMessageLogContext

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/log/struct.QMessageLogContext.html

Wrapper for QMessageLogContext::file, returning the file name as a string slice.

```rust
pub fn file(&self) -> &str
```

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

### QMessageLogContext Methods

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/log/struct.QMessageLogContext.html

Implementation details for methods available on the QMessageLogContext structure.

```APIDOC
## impl QMessageLogContext

### pub fn line(&self) -> i32

Wrapper for `QMessageLogContext::line`.

### pub fn file(&self) -> &str

Wrapper for `QMessageLogContext::file`.

### pub fn function(&self) -> &str

Wrapper for `QMessageLogContext::function`.

### pub fn category(&self) -> &str

Wrapper for `QMessageLogContext::category`.
```

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

### QmlEngine::load_url()

Source: https://docs.rs/qmetaobject/0.2.10/qmetaobject/qtdeclarative/struct.QmlEngine.html

Loads the root QML file located at the specified URL.

```APIDOC
## pub fn load_url(&mut self, url: QUrl)

### Description
Loads the root QML file located at url (See QQmlApplicationEngine::load(const QUrl &url)).

### Method
POST

### Endpoint
/api/qmlengine/load_url

### Parameters
#### Path Parameters
- **url** (QUrl) - Required - The URL of the QML file to load.
```
Tokens:
Raw