Cacao

https://docs.rs/cacao/latest/cacao/
Admin
Cacao is a Rust library that provides safe bindings for Apple's AppKit and UIKit frameworks, aiming...
Tokens:505,265
Snippets:2,799
Trust Score:9.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Basic View Setup with Autolayout in Rust

Source: https://docs.rs/cacao/latest/cacao/listview/index

Demonstrates setting up a basic window with a subview and applying Autolayout constraints using the Cacao library in Rust. This example shows how to set a background color for a view and position it within its parent using constraints.

```rust
use cacao::color::Color;
use cacao::layout::{Layout, LayoutConstraint};
use cacao::view::View;
use cacao::appkit::window::{Window, WindowDelegate};

#[derive(Default)]
struct AppWindow {
    content: View,
    red: View,
    window: Window
}

impl WindowDelegate for AppWindow {
    const NAME: &'static str = "RootView";
    fn did_load(&mut self, window: Window) {
        window.set_minimum_content_size(300., 300.);
        self.window = window;

        self.red.set_background_color(Color::rgb(224, 82, 99));
        self.content.add_subview(&self.red);

        self.window.set_content_view(&self.content);

        LayoutConstraint::activate(&[
            self.red.top.constraint_equal_to(&self.content.top).offset(16.),
            self.red.leading.constraint_equal_to(&self.content.leading).offset(16.),
            self.red.trailing.constraint_equal_to(&self.content.trailing).offset(-16.),
            self.red.bottom.constraint_equal_to(&self.content.bottom).offset(-16.),
        ]);
    }
}
```

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

### Cacao Initialization and Features

Source: https://docs.rs/cacao/latest/cacao/index

This snippet outlines the basic structure for initializing and using the cacao crate, including sections on 'Hello World' and 'Optional Features'. It highlights the core concepts for getting started with the library.

```rust
// Cacao crate usage overview

// Section: Cacao
// Provides core functionalities for interacting with native UI frameworks.

// Section: Hello World
// Demonstrates a basic application setup.

// Subsection: Initialization
// Details on how to initialize the cacao framework.

// Subsection: Optional Features
// Information on enabling and using optional features like 'infer' and 'uuid'.
```

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

### Pasteboard Example

Source: https://docs.rs/cacao/latest/cacao/pasteboard/index

Demonstrates how to get the default system pasteboard and copy text to the clipboard using the Cacao pasteboard module.

```rust
use cacao::pasteboard::Pasteboard;

// Get the default system pasteboard
let pasteboard = Pasteboard::default();

// Copy a piece of text to the clipboard
pasteboard.copy_text("My message here");
```

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

### SafeAreaLayoutGuide Clone Implementation

Source: https://docs.rs/cacao/latest/cacao/layout/struct.SafeAreaLayoutGuide

Provides the ability to clone a SafeAreaLayoutGuide instance. This is useful for creating copies of layout guide configurations.

```APIDOC
impl Clone for SafeAreaLayoutGuide
  clone(&self) -> Self
    Creates a copy of the SafeAreaLayoutGuide.
```

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

### Rust Ecosystem Links

Source: https://docs.rs/cacao/latest/cacao/webview/index

Provides links to essential Rust resources, including the official website, The Book, standard library API reference, Rust by Example, and Cargo Guide.

```Rust
* [Rust website](https://www.rust-lang.org/)
    * [The Book](https://doc.rust-lang.org/book/)
    * [Standard Library API Reference](https://doc.rust-lang.org/std/)
    * [Rust by Example](https://doc.rust-lang.org/rust-by-example/)
    * [The Cargo Guide](https://doc.rust-lang.org/cargo/guide/)
    * [Clippy Documentation](https://doc.rust-lang.org/nightly/clippy)
```

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

### TextField Autolayout Example

Source: https://docs.rs/cacao/latest/cacao/input/index

Demonstrates the usage of TextField with Autolayout constraints for positioning within a window. This example shows how to set up a basic UI with a TextField and apply constraints for its subview.

```rust
use cacao::color::Color;
use cacao::layout::{Layout, LayoutConstraint};
use cacao::input::TextField;
use cacao::view::View;
use cacao::appkit::window::{Window, WindowDelegate};

#[derive(Default)]
struct AppWindow {
    content: TextField,
    label: TextField,
    red: View,
    window: Window
}

impl WindowDelegate for AppWindow {
    const NAME: &'static str = "RootView";
    fn did_load(&mut self, window: Window) {
        window.set_minimum_content_size(300., 300.);
        self.window = window;

        self.label.set_background_color(Color::rgb(224, 82, 99));
        self.label.set_text("LOL");
        self.content.add_subview(&self.red);

        self.window.set_content_view(&self.content);

        LayoutConstraint::activate(&[
            self.red.top.constraint_equal_to(&self.content.top).offset(16.),
            self.red.leading.constraint_equal_to(&self.content.leading).offset(16.),
            self.red.trailing.constraint_equal_to(&self.content.trailing).offset(-16.),
            self.red.bottom.constraint_equal_to(&self.content.bottom).offset(-16.),
        ]);
    }
}
```

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

### Rust Documentation Links

Source: https://docs.rs/cacao/latest/cacao/utils/index

Provides a collection of useful links related to Rust programming, including the official Rust website, The Book, Standard Library API Reference, Rust by Example, and the Cargo Guide.

```rust
* [Rust website](https://www.rust-lang.org/)
    * [The Book](https://doc.rust-lang.org/book/)
    * [Standard Library API Reference](https://doc.rust-lang.org/std/)
    * [Rust by Example](https://doc.rust-lang.org/rust-by-example/)
    * [The Cargo Guide](https://doc.rust-lang.org/cargo/guide/)
    * [Clippy Documentation](https://doc.rust-lang.org/nightly/clippy)
```

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

### Rust Ecosystem Links

Source: https://docs.rs/cacao/latest/cacao/button/index

Lists essential links for the Rust programming language ecosystem, including the official website, The Book, Standard Library API Reference, Rust by Example, and Cargo Guide.

```Rust
* [Rust](https://docs.rs/cacao/latest/cacao/button/index.html)
    * [Rust website](https://www.rust-lang.org/)
    * [The Book](https://doc.rust-lang.org/book/)
    * [Standard Library API Reference](https://doc.rust-lang.org/std/)
    * [Rust by Example](https://doc.rust-lang.org/rust-by-example/)
    * [The Cargo Guide](https://doc.rust-lang.org/cargo/guide/)
    * [Clippy Documentation](https://doc.rust-lang.org/nightly/clippy)
```

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

### Application Launching Lifecycle

Source: https://docs.rs/cacao/latest/cacao/appkit/trait.AppDelegate

Methods related to the application's launch sequence. `will_finish_launching` is called before the application finishes launching, and `did_finish_launching` is called after. The latter is recommended for most setup tasks.

```APIDOC
AppDelegate:
  will_finish_launching(&self)
    - Called right before the application will finish launching.
    - Recommended to use `did_finish_launching` for setup unless specific timing is required.

  did_finish_launching(&self)
    - Fired when the application has finished launching.
    - Use `App::shared()` to access the shared application instance if needed.
```

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

### Basic View Setup and Autolayout in Rust

Source: https://docs.rs/cacao/latest/cacao/view/index

Demonstrates how to set up a basic window with a subview using Cacao's view and layout functionalities in Rust. It shows setting background color, adding subviews, and activating layout constraints for positioning.

```rust
use cacao::color::Color;
use cacao::layout::{Layout, LayoutConstraint};
use cacao::view::View;
use cacao::appkit::window::{Window, WindowDelegate};

#[derive(Default)]
struct AppWindow {
    content: View,
    red: View,
    window: Window
}

impl WindowDelegate for AppWindow {
    const NAME: &'static str = "RootView";
    fn did_load(&mut self, window: Window) {
        window.set_minimum_content_size(300., 300.);
        self.window = window;

        self.red.set_background_color(Color::SystemRed);
        self.content.add_subview(&self.red);

        self.window.set_content_view(&self.content);

        LayoutConstraint::activate(&[
            self.red.top.constraint_equal_to(&self.content.top).offset(16.),
            self.red.leading.constraint_equal_to(&self.content.leading).offset(16.),
            self.red.trailing.constraint_equal_to(&self.content.trailing).offset(-16.),
            self.red.bottom.constraint_equal_to(&self.content.bottom).offset(-16.),
        ]);
    }
}
```

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

### App Initialization and Running

Source: https://docs.rs/cacao/latest/cacao/appkit/struct.App

Provides methods for creating and running the application. `new` initializes the application with a delegate, and `run` starts the NSRunLoop, blocking execution until the application terminates. Requires an AppDelegate implementation.

```rust
pub fn new(_bundle_id: &[str], delegate: T) -> Self
// Creates an NSAutoReleasePool, configures various NSApplication properties (e.g, activation policies), injects an `NSObject` delegate wrapper, and retains everything on the Objective-C side of things.

pub fn run(&self)
// Kicks off the NSRunLoop for the NSApplication instance. This blocks when called. If you’re wondering where to go from here… you need an `AppDelegate` that implements `did_finish_launching`.
```

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

### Basic View Setup with Autolayout in Rust

Source: https://docs.rs/cacao/latest/cacao/scrollview/index

Demonstrates setting up a basic window with a red subview using Cacao's layout system in Rust. It shows how to set background colors, add subviews, and activate layout constraints for positioning.

```rust
use cacao::color::Color;;
use cacao::layout::{Layout, LayoutConstraint};
use cacao::view::View;
use cacao::appkit::window::{Window, WindowDelegate};

#[derive(Default)]
struct AppWindow {
    content: View,
    red: View,
    window: Window
}

impl WindowDelegate for AppWindow {
    const NAME: &'static str = "WindowDelegate";
    fn did_load(&mut self, window: Window) {
        window.set_minimum_content_size(300., 300.);
        self.window = window;

        self.red.set_background_color(Color::rgb(224, 82, 99));
        self.content.add_subview(&self.red);

        self.window.set_content_view(&self.content);

        LayoutConstraint::activate(&[
            self.red.top.constraint_equal_to(&self.content.top).offset(16.),
            self.red.leading.constraint_equal_to(&self.content.leading).offset(16.),
            self.red.trailing.constraint_equal_to(&self.content.trailing).offset(-16.),
            self.red.bottom.constraint_equal_to(&self.content.bottom).offset(-16.),
        ]);
    }
}
```

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

### Button Usage Example

Source: https://docs.rs/cacao/latest/cacao/button/struct.Button

Demonstrates how to create and configure a Button, set a key equivalent for keyboard interaction, define an action callback for click events, and add the button as a subview to another view. It's important to manage the button's lifetime.

```rust
use cacao::button::Button;
use cacao::view::View;
use crate::cacao::layout::Layout;

let mut button = Button::new("My button title");
button.set_key_equivalent("c");

button.set_action(|| {
    println!("My button was clicked.");
});

let my_view : View<()> = todo!();

// Make sure you don't let your Button drop for as long as you need it.
my_view.add_subview(&button);
```

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

### Cacao Pasteboard Module Overview

Source: https://docs.rs/cacao/latest/cacao/pasteboard/index

Provides an overview of the pasteboard module within the cacao Rust crate. It lists available structs and enums, and points to an example for usage.

```rust
/// Module pasteboard
///
/// Sections:
/// * Example
///
/// Module Items:
/// * Structs
/// * Enums
```

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

### cacao Foundation Module Overview

Source: https://docs.rs/cacao/latest/cacao/foundation/constant.nil

Provides an overview of the foundation module in the cacao Rust crate. It lists available structs, enums, constants, and functions, offering a starting point for exploring the library's core components.

```rust
/// Structs in cacao::foundation:
/// AutoReleasePool, NSArray, NSData, NSMutableDictionary, NSNumber, NSString, NSURL
/// 
/// Enums in cacao::foundation:
/// NSURLBookmarkCreationOption, NSURLBookmarkResolutionOption
/// 
/// Constants in cacao::foundation:
/// NO, YES, nil
/// 
/// Functions in cacao::foundation:
/// load_or_register_class, to_bool
```

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

### WebView Initialization and Configuration

Source: https://docs.rs/cacao/latest/cacao/webview/struct.WebView

Details methods for creating and configuring a WebView instance. Includes the `new` method for basic initialization and the `with` method for applying configurations.

```APIDOC
WebView:
  new() -> Self
    Creates a new instance of the WebView.

  with<F>(f: F) -> Self where F: FnOnce(&mut Self)
    Applies a configuration closure to the WebView.
    Parameters:
      f: A closure that takes a mutable reference to the WebView and applies configurations.
```

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

### Hello World App in Rust

Source: https://docs.rs/cacao/latest/cacao/index

A basic 'Hello World' application demonstrating the creation of a window with a title and minimum content size using the Cacao library. It sets up an `AppDelegate` and runs the application.

```rust
use cacao::appkit::{App, AppDelegate};
use cacao::appkit::window::Window;

#[derive(Default)]
struct BasicApp {
    window: Window
}

impl AppDelegate for BasicApp {
    fn did_finish_launching(&self) {
       self.window.set_minimum_content_size(400., 400.);
       self.window.set_title("Hello World!");
       self.window.show();
    }
}

fn main() {
    App::new("com.hello.world", BasicApp::default()).run();
}
```

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

### Window Methods

Source: https://docs.rs/cacao/latest/cacao/appkit/window/struct.Window

Provides documentation for methods available on the `Window` struct, including `toggle_toolbar_shown` and `with`.

```APIDOC
Window Methods:

toggle_toolbar_shown()
  Toggles the visibility of the window's toolbar.

with<F>(closure: F)
  Applies a closure to configure the window.
  Parameters:
    closure: A closure that takes a mutable reference to the window.

```

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

### Dispatching Messages Example

Source: https://docs.rs/cacao/latest/cacao/notification_center/trait.Dispatcher

Example of how to dispatch a message asynchronously to the app delegate.

```rust
App::<YourAppDelegate, YourMessageType>::dispatch_main(your_message);
```

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

### WebView Initialization

Source: https://docs.rs/cacao/latest/cacao/webview/struct.WebView

Provides methods for creating and initializing a WebView. The `new` function creates a default WebView, while `with` allows initialization with a custom delegate for event handling.

```APIDOC
WebView:
  new(config: WebViewConfig) -> Self
    Creates a default WebView instance.

  with<T: WebViewDelegate + 'static>(config: WebViewConfig, delegate: T) -> WebView<T>
    Initializes a new WebView with a given WebViewDelegate.
    This allows for event handling and customization.
```

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

### ViewController Usage Example

Source: https://docs.rs/cacao/latest/cacao/view/struct.ViewController

An example demonstrating how to implement the ViewDelegate trait for a custom struct (ContentViewDelegate) to handle view controller lifecycle events like 'will_appear'.

```rust
use cacao::view::ViewDelegate;

struct ContentViewDelegate;

impl ViewDelegate for ContentViewDelegate {
    const NAME: &'static str = "ContentViewDelegate";

    fn will_appear(&self, animated: bool) {
        println!("This controller is about to appear!");
    }
}
```

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

### cacao AppKit Module Overview

Source: https://docs.rs/cacao/latest/cacao/appkit/menu/index

Provides an overview of the cacao::appkit module, listing its sub-modules and structs. It links to detailed documentation for each component.

```rust
/// [In cacao::appkit](https://docs.rs/cacao/latest/cacao/appkit/index.html)
/// ### [Modules](https://docs.rs/cacao/latest/cacao/appkit/index.html#modules)
///   * [menu](https://docs.rs/cacao/latest/cacao/appkit/menu/index.html)
///   * [printing](https://docs.rs/cacao/latest/cacao/appkit/printing/index.html)
///   * [toolbar](https://docs.rs/cacao/latest/cacao/appkit/toolbar/index.html)
///   * [window](https://docs.rs/cacao/latest/cacao/appkit/window/index.html)
///
/// ### [Structs](https://docs.rs/cacao/latest/cacao/appkit/index.html#structs)
///   * [Alert](https://docs.rs/cacao/latest/cacao/appkit/struct.Alert.html)
///   * [AnimationContext](https://docs.rs/cacao/latest/cacao/appkit/struct.AnimationContext.html)
///   * [App](https://docs.rs/cacao/latest/cacao/appkit/struct.App.html)
///   * [Cursor](https://docs.rs/cacao/latest/cacao/appkit/struct.Cursor.html)
///   * [Event](https://docs.rs/cacao/latest/cacao/appkit/struct.Event.html)
///   * [EventMonitor](https://docs.rs/cacao/latest/cacao/appkit/struct.EventMonitor.html)
```

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

### Get URL from FileSavePanel

Source: https://docs.rs/cacao/latest/cacao/filesystem/save/fn.get_url

Retrieves the selected URLs from a FileSavePanel. This function is part of the cacao crate's filesystem module and is used to get file paths from a save panel. It takes a reference to an Objective-C Object representing the panel and returns an Option containing a String with the URL, or None if no URL is selected.

```rust
pub fn get_url(panel: &Object) -> Option<String>
```
```

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

### WindowController Initialization and Management

Source: https://docs.rs/cacao/latest/cacao/appkit/window/struct.WindowController

Provides methods for creating, configuring, and managing window controllers within the AppKit framework using Cacao.

```APIDOC
WindowController<T>:
  with(config: WindowConfig, delegate: T) -> Self
    Allocates and configures an NSWindowController in the Objective-C/Cocoa runtime that maps over to your supplied delegate.
    Parameters:
      config: WindowConfig - Configuration for the window.
      delegate: T - The WindowDelegate for the controller.

  set_content_view_controller<C: Controller + 'static>( &self, controller: [&C])
    Given a view, sets it as the content view controller for this window.
    Parameters:
      controller: [&C] - A reference to the controller to set as the content view.

  show(&self)
    Shows the window, running a configuration pass if necessary.

  close(&self)
    Closes the window.
```

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

### Get Length of NSData

Source: https://docs.rs/cacao/latest/cacao/foundation/struct.NSData

Returns the number of bytes contained within the NSData object.

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

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

### Any Trait - type_id

Source: https://docs.rs/cacao/latest/cacao/appkit/printing/settings/struct.PrintSettings

The `Any` trait provides a way to get the `TypeId` of a type. This is useful for runtime type identification.

```rust
impl<T> Any for T where T: 'static + ?Sized {
    fn type_id(&self) -> TypeId
}
```

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

### SafeAreaLayoutGuide Constructor

Source: https://docs.rs/cacao/latest/cacao/layout/struct.SafeAreaLayoutGuide

Creates a new SafeAreaLayoutGuide by extracting safe area layout properties from a given view pointer. This is essential for setting up layout constraints relative to the safe area.

```APIDOC
SafeAreaLayoutGuide::new(view: id) -> Self
  Given a view pointer, will extract the safe area layout guide properties and return a `SafeAreaLayoutGuide` composed of them.
```

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

### Create and Configure a Button

Source: https://docs.rs/cacao/latest/cacao/button/index

Demonstrates how to create a new button with a title, set a key equivalent for keyboard activation, and define a callback action to be executed when the button is clicked. It also shows how to add the button as a subview to another view.

```rust
use cacao::button::Button;
use cacao::view::View;
use crate::cacao::layout::Layout;
let mut button = Button::new("My button title");
button.set_key_equivalent("c");

button.set_action(|| {
    println!("My button was clicked.");
});
let my_view : View<()> = todo!();

// Make sure you don't let your Button drop for as long as you need it.
my_view.add_subview(&button);
```

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

### InjectAt Enum Variants

Source: https://docs.rs/cacao/latest/cacao/webview/enum.InjectAt

Defines the possible injection points for webview content. The variants are 'End' and 'Start'.

```rust
enum InjectAt {
    End,
    Start,
}
```

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

### FileSelectPanel API Documentation

Source: https://docs.rs/cacao/latest/cacao/filesystem/select/struct.FileSelectPanel

Provides API documentation for the FileSelectPanel struct, including its constructor and methods for configuring selection behavior. This covers initialization, setting delegates, and specifying whether files or directories can be chosen.

```APIDOC
FileSelectPanel:
  new() -> Self
    Creates and returns a `FileSelectPanel`, which holds pointers to the Objective C runtime for instrumenting the dialog.

  set_delegate(&mut self)
    Sets the delegate for the FileSelectPanel.

  set_can_choose_files(&mut self, can_choose: bool)
    Sets whether files can be chosen by the user. Defaults to `true`.
```

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

### AVDisplayManager Notifications

Source: https://docs.rs/cacao/latest/cacao/notification_center/enum.NotificationName

Notifications related to AVDisplayManager mode switching, including start, end, and settings changes.

```APIDOC
AVDisplayManagerModeSwitchEnd
AVDisplayManagerModeSwitchSettingsChanged
AVDisplayManagerModeSwitchStart
```

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

### TextField Methods

Source: https://docs.rs/cacao/latest/cacao/input/struct.TextField

Provides methods to interact with and configure a TextField, including getting its value and setting various visual properties.

```APIDOC
TextField:
  with<T>(delegate: T) -> TextField<T>
    Initializes a new TextField with a given TextFieldDelegate.

  get_value(&self) -> String
    Grabs the value from the textfield and returns it as an owned String.

  set_background_color<C: AsRef<Color>>(&self, color: C)
    Call this to set the background color for the backing layer.

  set_text(&self, text: &str)
    Call this to set the text for the label.

  set_placeholder_text(&self, text: &str)
    Call this to set the text for the label.

  set_text_alignment(&self, alignment: TextAlign)
    The the text alignment style for this control.

  set_uses_single_line(&self, uses_single_line: bool)
    Set whether this field operates in single-line mode.

  set_wraps(&self, uses_single_line: bool)
    Set whether this field operates in single-line mode.

  set_max_number_of_lines(&self, num: NSInteger)
    Sets the maximum number of lines.

  set_font<F: AsRef<Font>>(&self, font: F)
    Sets the font for this input.
```

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

### InjectAt Enum Variants

Source: https://docs.rs/cacao/latest/cacao/webview/enum.InjectAt

Details the variants of the `InjectAt` enum: `Start` for injecting at the beginning of the document and `End` for injecting at the end.

```rust
/// Start = 0
/// Inject at the start of the document.

/// End = 1
/// Inject at the end of the document.
```

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

### SafeAreaLayoutGuide Clone Methods

Source: https://docs.rs/cacao/latest/cacao/layout/struct.SafeAreaLayoutGuide

Provides methods for cloning SafeAreaLayoutGuide instances. The `clone` method creates a duplicate, while `clone_from` performs copy-assignment.

```rust
fn clone(&self) -> SafeAreaLayoutGuide
// Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)
// Performs copy-assignment from `source`.
```

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

### Get OS Codename

Source: https://docs.rs/cacao/latest/cacao/utils/os/struct.OS_VERSION

Retrieves the optional codename of the operating system. This function returns an Option<&str> which will be None if the codename is not available.

```rust
use os_info::Info;

let info = Info::unknown();
assert_eq!(None, info.codename());
```

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

### Cacao Button Implementations

Source: https://docs.rs/cacao/latest/cacao/button/struct.Button

Provides documentation for the methods available on the Button struct, including creation and image setting.

```APIDOC
Button Methods:
  new(text: &str) -> Self
    Creates a new NSButton instance, configures it appropriately, and retains the necessary Objective-C runtime pointer.
  set_image(&mut self, image: Image)
    Sets an image on the underlying button.
```

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

### Rust Core Trait: Any

Source: https://docs.rs/cacao/latest/cacao/layout/enum.LayoutAnchorY

Provides the `type_id` method to get the unique identifier of a type. This is useful for runtime type checking and downcasting.

```APIDOC
Any:
  type_id() -> TypeId
    Gets the TypeId of self.
    Parameters:
      - self: A reference to the object.
    Returns:
      - TypeId: The unique identifier for the type of self.
```

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

### Rust Into Trait

Source: https://docs.rs/cacao/latest/cacao/utils/struct.CGSize

The `Into` trait is used for cheap, điển hình-by-value conversions. It is the reciprocal of the `From` trait. This means that if you implement `From<T>` for `U`, you will get `Into<U>` for `T` for free.

```rust
fn into(self) -> U
Calls `U::from(self)`.
```

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

### FileSelectPanel Implementation

Source: https://docs.rs/cacao/latest/cacao/filesystem/select/index

Implements `FileSelectPanel`, which allows the user to select files for processing and hands you urls to work with. It currently doesn’t implement _everything_ necessary, but it’s functional enough for general use.

```rust
/// Module select
///
/// In cacao::filesystem
///
/// # Module Items
/// ## Structs
/// * [FileSelectPanel](https://docs.rs/cacao/latest/cacao/filesystem/select/struct.FileSelectPanel.html "struct cacao::filesystem::select::FileSelectPanel")
///
/// Implements `FileSelectPanel`, which allows the user to select files for processing and hands you urls to work with. It currently doesn’t implement _everything_ necessary, but it’s functional enough for general use.
```

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

### Any Trait - type_id

Source: https://docs.rs/cacao/latest/cacao/foundation/struct.NSData

The `Any` trait provides a way to get the `TypeId` of a type. This is useful for runtime type identification. It requires the type to be `'static` and `Sized`.

```rust
impl<T> Any for T
where T: 'static + ?Sized,
{
    fn type_id(&self) -> TypeId
}
```

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

### cacao Crate Overview

Source: https://docs.rs/cacao/latest/cacao/progress/index

Provides an overview of the cacao crate, including its version, license, source code links, and dependencies. It also indicates the documentation coverage percentage.

```rust
Crate: cacao 0.3.2
License: MIT OR MPL-2.0+
Source: https://github.com/ryanmcgrath/cacao
Dependencies:
  - block ^0.1.6
  - core-foundation ^0.9
  - core-graphics ^0.22
  - dispatch ^0.2.0
  - infer ^0.4 (optional)
  - lazy_static ^1.4.0
  - libc ^0.2
  - objc ^0.2.7
  - objc_id ^0.1.1
  - os_info ^3.0.1
  - url ^2.1.1
  - uuid ^0.8 (optional)
Documentation Coverage: 95.15%
```

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

### Any Trait: type_id

Source: https://docs.rs/cacao/latest/cacao/color/enum.Color

The `Any` trait provides a way to get the `TypeId` of a type. This is useful for runtime type identification. It requires the type to be `'static` and `Sized`.

```rust
impl<T> Any for T where T: 'static + ?Sized {
    fn type_id(&self) -> TypeId
}
```

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

### Any Trait Implementation for CursorType

Source: https://docs.rs/cacao/latest/cacao/appkit/enum.CursorType

Implementation of the Any trait for CursorType, providing a way to get the TypeId of an instance. This is part of the blanket implementations for generic types.

```rust
impl<T> Any for T where T: 'static + ?Sized {
    fn type_id(&self) -> TypeId {
        // Implementation details for getting TypeId
        unimplemented!()
    }
}
```

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

### cacao Crate Overview

Source: https://docs.rs/cacao/latest/cacao/cloudkit/index

Provides an overview of the cacao crate, including its version, license, source code links, and dependencies. It also indicates the documentation coverage percentage.

```rust
Crate: cacao 0.3.2
License: MIT OR MPL-2.0+
Dependencies:
- block ^0.1.6
- core-foundation ^0.9
- core-graphics ^0.22
- dispatch ^0.2.0
- infer ^0.4 (optional)
- lazy_static ^1.4.0
- libc ^0.2
- objc ^0.2.7
- objc_id ^0.1.1
- os_info ^3.0.1
- url ^2.1.1
- uuid ^0.8 (optional)
- eval ^0.4 (dev)
Documentation Coverage: 95.15%
```

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

### cacao Crate Overview

Source: https://docs.rs/cacao/latest/cacao/appkit/toolbar/index

Provides an overview of the cacao crate, including its version, license, source code links, and dependencies. It also indicates the documentation coverage percentage.

```Rust
Project: /context7/rs-cacao-cacao
Content:
[ Docs.rs ](https://docs.rs/)
  * [ cacao-0.3.2 ](https://docs.rs/cacao/latest/cacao/appkit/toolbar/index.html "Rust bindings for AppKit (macOS/Airyx/GNUStep, beta) and UIKit (iOS/tvOS, alpha).")
    * cacao 0.3.2 
    * [](https://docs.rs/cacao/0.3.2/cacao/appkit/toolbar/index.html "Get a link to this specific version")
    * [ ](https://docs.rs/crate/cacao/latest "See cacao in docs.rs")
    * [MIT](https://spdx.org/licenses/MIT) OR [MPL-2.0](https://spdx.org/licenses/MPL-2.0)+
    * Links
    * [ ](https://github.com/ryanmcgrath/cacao)
    * [ ](https://crates.io/crates/cacao "See cacao in crates.io")
    * [ ](https://docs.rs/crate/cacao/latest/source/ "Browse source of cacao-0.3.2")
    * Owners
    * [ ](https://crates.io/users/ryanmcgrath)
    * Dependencies
    *       * [ block ^0.1.6 _normal_ ](https://docs.rs/block/^0.1.6)
      * [ core-foundation ^0.9 _normal_ ](https://docs.rs/core-foundation/^0.9)
      * [ core-graphics ^0.22 _normal_ ](https://docs.rs/core-graphics/^0.22)
      * [ dispatch ^0.2.0 _normal_ ](https://docs.rs/dispatch/^0.2.0)
      * [ infer ^0.4 _normal_ _optional_ ](https://docs.rs/infer/^0.4)
      * [ lazy_static ^1.4.0 _normal_ ](https://docs.rs/lazy_static/^1.4.0)
      * [ libc ^0.2 _normal_ ](https://docs.rs/libc/^0.2)
      * [ objc ^0.2.7 _normal_ ](https://docs.rs/objc/^0.2.7)
      * [ objc_id ^0.1.1 _normal_ ](https://docs.rs/objc_id/^0.1.1)
      * [ os_info ^3.0.1 _normal_ ](https://docs.rs/os_info/^3.0.1)
      * [ url ^2.1.1 _normal_ ](https://docs.rs/url/^2.1.1)
      * [ uuid ^0.8 _normal_ _optional_ ](https://docs.rs/uuid/^0.8)
      * [ eval ^0.4 _dev_ ](https://docs.rs/eval/^0.4)
    * Versions
    * [ **95.15%** of the crate is documented ](https://docs.rs/crate/cacao/latest)
  * [ Platform ](https://docs.rs/cacao/latest/cacao/appkit/toolbar/index.html)
    * [x86_64-apple-darwin](https://docs.rs/crate/cacao/latest/target-redirect/x86_64-apple-darwin/cacao/appkit/toolbar/index.html)
  * [ Feature flags ](https://docs.rs/crate/cacao/latest/features "Browse available feature flags of cacao-0.3.2")
```

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

### Notification Center Module

Source: https://docs.rs/cacao/latest/cacao/notification_center/index

Details the 'notification_center' module within the cacao crate, listing its available sections such as 'Example', 'Enums', and 'Traits'.

```Rust
Module: notification_center
Sections:
  - Example
Module Items:
  - Enums
  - Traits
```

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

### Scene Methods

Source: https://docs.rs/cacao/latest/cacao/uikit/struct.Scene

Provides methods for interacting with the Scene object. Includes creating a Scene from an id, getting its bounds, and converting it back to an id.

```APIDOC
Scene:
  with(scene: id) -> Scene
    Creates a Scene instance from an Objective-C id.

  get_bounds(&self) -> Rect
    Retrieves the bounds of the Scene as a Rect object.

  into_inner(self) -> id
    Consumes the Scene instance and returns the underlying Objective-C id.
```

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

### cacao Crate Overview

Source: https://docs.rs/cacao/latest/cacao/listview/index

Provides an overview of the cacao crate, including its version, license, source code links, and dependencies. It also indicates the documentation coverage percentage.

```rust
crate: cacao
version: 0.3.2
license: MIT OR MPL-2.0+

Dependencies:
- block ^0.1.6
- core-foundation ^0.9
- core-graphics ^0.22
- dispatch ^0.2.0
- infer ^0.4 (optional)
- lazy_static ^1.4.0
- libc ^0.2
- objc ^0.2.7
- objc_id ^0.1.1
- os_info ^3.0.1
- url ^2.1.1
- uuid ^0.8 (optional)

Documentation coverage: 95.15%
```

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

### Rust Any Trait: type_id

Source: https://docs.rs/cacao/latest/cacao/image/enum.MacSystemIcon

The `Any` trait provides a way to get the `TypeId` of a type. This is useful for dynamic type checking and downcasting. It requires the type to be `'static` and `Sized`.

```rust
impl<T> Any for T where T: 'static + ?Sized {
    fn type_id(&self) -> TypeId
}
```

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

### Generic Any Trait Implementation

Source: https://docs.rs/cacao/latest/cacao/cloudkit/share/struct.CKShareMetaData

This snippet demonstrates the blanket implementation of the Any trait for any type T that is 'static and not Sized. It provides a way to get the TypeId of a value.

```rust
impl<T> Any for T where T: 'static + ?Sized {
    fn type_id(&self) -> TypeId {
        // Implementation details for getting TypeId
        // ...
        TypeId::of::<T>()
    }
}
```

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

### cacao Crate Overview

Source: https://docs.rs/cacao/latest/cacao/text/index

Provides an overview of the cacao crate, including its version, license, source code links, and dependencies. It also indicates the documentation coverage percentage.

```rust
Crate: cacao
Version: 0.3.2
License: MIT OR MPL-2.0+
Documentation Coverage: 95.15%

Dependencies:
- block ^0.1.6
- core-foundation ^0.9
- core-graphics ^0.22
- dispatch ^0.2.0
- infer ^0.4 (optional)
- lazy_static ^1.4.0
- libc ^0.2
- objc ^0.2.7
- objc_id ^0.1.1
- os_info ^3.0.1
- url ^2.1.1
- uuid ^0.8 (optional)
- eval ^0.4 (dev)

Links:
- Source: https://github.com/ryanmcgrath/cacao
- Crates.io: https://crates.io/crates/cacao
- Docs.rs: https://docs.rs/crate/cacao/latest
```

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

### Default Implementation for Window

Source: https://docs.rs/cacao/latest/cacao/appkit/window/struct.Window

Provides a default instance of the Window struct. This implementation creates a new Window with a default WindowConfig, suitable for initial setup.

```rust
impl Default for Window {
    fn default() -> Self {
        // Implementation details...
    }
}
```

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

### Cacao App Initialization and Execution

Source: https://docs.rs/cacao/latest/cacao/uikit/struct.App

This section covers the core methods for creating and running an iOS application using the Cacao library. The `new` function handles the initialization of the `UIApplication` and `AppDelegate`, while `run` executes the application's main loop.

```APIDOC
App:
  new<T, W, F>(delegate: T, scene_delegate_vendor: F) -> Self
    Description: Initializes a new `App` instance for iOS. This method is crucial for setting up the application's delegate and ensuring Objective-C runtime compatibility before `UIApplicationMain` is called.
    Parameters:
      - delegate: The application's delegate, responsible for handling application lifecycle events.
      - scene_delegate_vendor: A vendor for scene delegates.
    Notes:
      - This pattern is safe because only one AppDelegate can exist at a time.
      - Ensures subclasses are registered in the Objective-C runtime before `UIApplicationMain`.

  run(&self)
    Description: Executes the application's main event loop by calling `UIApplicationMain()`. It ensures that custom `UIApplication` and `UIApplicationDelegate` classes are used.
    Usage: Call this method after initializing the `App` instance.

  fmt(&self, f: &mut Formatter<'_>) -> Result
    Description: Implements the `Debug` trait for the `App` struct, allowing it to be formatted for debugging purposes.
    Parameters:
      - f: A mutable reference to a `Formatter`.
    Returns: A `Result` indicating success or failure of the formatting operation.

Trait Implementations:
  Debug for App<W, T, F>
  Freeze for App<T, W, F>
  RefUnwindSafe for App<T, W, F> where W: RefUnwindSafe, T: RefUnwindSafe, F: RefUnwindSafe
  Send for App<T, W, F> where W: Send, T: Send, F: Send
  Sync for App<T, W, F>
```

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

### ProgressIndicator Usage

Source: https://docs.rs/cacao/latest/cacao/progress/index

Demonstrates how to create and configure a ProgressIndicator in Rust using the Cacao library. This example shows setting the indicator to indeterminate mode and adding it as a subview.

```rust
use cacao::progress::ProgressIndicator;
use cacao::view::View;
use crate::cacao::layout::Layout;

let indicator = ProgressIndicator::new();
indicator.set_indeterminate(true);

let my_view : View<()> = todo!();
my_view.add_subview(&indicator);
```

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

### Cacao Crate Overview

Source: https://docs.rs/cacao/latest/cacao/error/index

Provides an overview of the cacao crate, including its version, license, source code links, and dependencies. It also indicates the percentage of the crate that is documented.

```rust
// Crate: cacao
// Version: 0.3.2
// License: MIT OR MPL-2.0+
// Documentation: 95.15% documented
// Dependencies:
// - block ^0.1.6
// - core-foundation ^0.9
// - core-graphics ^0.22
// - dispatch ^0.2.0
// - infer ^0.4 (optional)
// - lazy_static ^1.4.0
// - libc ^0.2
// - objc ^0.2.7
// - objc_id ^0.1.1
// - os_info ^3.0.1
// - url ^2.1.1
// - uuid ^0.8 (optional)
// - eval ^0.4 (dev)
```

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

### Example Usage of AutoReleasePool

Source: https://docs.rs/cacao/latest/cacao/foundation/type.BOOL

Demonstrates the basic usage of `AutoReleasePool` in Rust with the cacao crate. This is essential for managing Objective-C object lifetimes within Rust code.

```rust
use cacao::foundation::AutoReleasePool;

fn main() {
    let pool = AutoReleasePool::new();
    // Objective-C objects created within this scope will be managed by the pool.
    // ... create and use Objective-C objects here ...
    // The pool is automatically dropped at the end of the scope, releasing objects.
}

```

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

### Image Loading and Wrapping Methods

Source: https://docs.rs/cacao/latest/cacao/image/struct.Image

Provides methods for creating an Image instance. `with` wraps a system-returned image, while `with_contents_of_file` loads an image from a specified file path.

```APIDOC
Image:
  with(image: id) -> Self
    Wraps a system-returned image, e.g. from QuickLook previews.

  with_contents_of_file(path: &str) -> Self
    Loads an image from the specified path.
```

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

### CellFactory Methods

Source: https://docs.rs/cacao/latest/cacao/utils/struct.CellFactory

Provides methods for interacting with the CellFactory struct in the cacao crate. These methods include 'get', 'insert', and 'new', likely for managing or creating cells.

```rust
struct CellFactory;

impl CellFactory {
    fn get(&self) -> ...;
    fn insert(&mut self, ...) -> ...;
    fn new() -> Self;
}
```

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

### Get URL from Filesystem

Source: https://docs.rs/cacao/latest/cacao/filesystem/save/index

Retrieves the selected URLs from the provided panel. This function is intended for use in scenarios where it's not called repeatedly in performance-critical sections.

```APIDOC
fn get_url(panel: Panel) -> Vec<Url>
  Retrieves the selected URLs from the provided panel.
  Parameters:
    panel: The panel from which to retrieve URLs.
  Returns:
    A vector of selected URLs.
```
Tokens:
Raw