### Monitor Clipboard for Multiple MIME Types

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/configuration.md

This example shows how to monitor the clipboard for various MIME types, prioritizing images, then HTML, and finally plain text. It polls the clipboard every second.

```rust
use wayland_clipboard_listener::{WlClipboardPasteStream, WlListenType};
use std::thread;
use std::time::Duration;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut stream = WlClipboardPasteStream::init(WlListenType::ListenOnCopy)?;
    
    // Prefer images, then HTML, then plain text
    stream.set_priority(vec![
        "image/png".into(),
        "image/jpeg".into(),
        "text/html".into(),
        "text/plain;charset=utf-8".into(),
    ]);
    
    loop {
        match stream.try_get_clipboard()? {
            Some(msg) => {
                println!("MIME type: {}", msg.context.mime_type);
                println!("Size: {} bytes", msg.context.context.len());
                println!("Available types: {:?}", msg.mime_types);
            }
            None => thread::sleep(Duration::from_secs(1)),
        }
    }
}
```

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

### Listen for Clipboard with MIME Type Priority

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/quick-start-examples.md

This example shows how to listen for clipboard changes and set a priority for specific MIME types. Use `WlClipboardPasteStream::init` to create the stream and `set_priority` to define the preferred order of MIME types for retrieval. The `get_clipboard` method retrieves the data.

```rust
use wayland_clipboard_listener::{WlClipboardPasteStream, WlListenType};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut stream = WlClipboardPasteStream::init(WlListenType::ListenOnCopy)?;
    
    // Prefer images, then HTML, then plain text
    stream.set_priority(vec![
        "image/png".into(),
        "image/jpeg".into(),
        "text/html".into(),
        "text/plain;charset=utf-8".into(),
    ]);
    
    let message = stream.get_clipboard()?;
    
    match message.context.mime_type.as_str() {
        "image/png" | "image/jpeg" => {
            println!("Got image ({} bytes)", message.context.context.len());
        }
        "text/html" => {
            println!("Got HTML: {}", String::from_utf8_lossy(&message.context.context));
        }
        "text/plain;charset=utf-8" => {
            println!("Got text: {}", String::from_utf8_lossy(&message.context.context));
        }
        _ => {
            println!("Got unknown format: {}", message.context.mime_type);
        }
    }
    
    Ok(())
}
```

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

### Copy Text to Wayland Clipboard

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/README.md

Initializes a stream to copy data to the Wayland clipboard. This example expects a single command-line argument, which will be the text to copy. The data provider must remain alive for the clipboard content to be available for pasting.

```rust
use wayland_clipboard_listener::{WlClipboardCopyStream, WlClipboardListenerError};
fn main() -> Result<(), WlClipboardListenerError> {
    let args = std::env::args();
    if args.len() != 2 {
        println!("You need to pass a string to it");
        return Ok(())
    }
    let context: &str = &args.last().unwrap();
    let mut stream = WlClipboardCopyStream::init()?;
    stream.copy_to_clipboard(context.as_bytes().to_vec())?;
    Ok(())
}
```

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

### Dependencies for Clipboard Monitoring

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/quick-start-examples.md

TOML dependencies required for the clipboard listener examples, including the main crate and the 'chrono' crate for timestamping.

```toml
[dependencies]
wayland-clipboard-listener = "0.6"
chrono = "0.4"
```

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

### Monitor Clipboard in Background Thread

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/quick-start-examples.md

This example demonstrates running clipboard monitoring in a separate background thread. It uses an MPSC channel to send clipboard content to the main thread for processing.

```rust
use wayland_clipboard_listener::{WlClipboardPasteStream, WlListenType};
use std::thread;
use std::sync::mpsc;
use std::time::Duration;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let (tx, rx) = mpsc::channel();
    
    let monitor = thread::spawn(move || {
        if let Ok(mut stream) = WlClipboardPasteStream::init(WlListenType::ListenOnCopy) {
            loop {
                if let Ok(Some(message)) = stream.try_get_clipboard() {
                    let text = String::from_utf8_lossy(&message.context.context).to_string();
                    let _ = tx.send(text);
                }
                thread::sleep(Duration::from_millis(500));
            }
        }
    });
    
    println!("Clipboard monitor running in background");
    println!("(copy something to see it here)");
    
    // Receive clipboard events from background thread
    for clipboard_text in rx.iter().take(5) {
        println!("Clipboard: {}", clipboard_text);
    }
    
    drop(rx);  // Drop receiver to stop thread
    let _ = monitor.join();
    
    Ok(())
}
```

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

### Error Handling with Detailed Messages

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/quick-start-examples.md

This example demonstrates robust error handling for clipboard operations. It matches against different `WlClipboardListenerError` variants to provide specific, user-friendly messages for common issues like Wayland environment problems or connection errors. The `run` function encapsulates the core logic, returning a `Result` that is then handled in `main`.

```rust
use wayland_clipboard_listener::{WlClipboardPasteStream, WlListenType, WlClipboardListenerError};

fn main() {
    match run() {
        Ok(_) => {},
        Err(e) => {
            eprintln!("Error: {}", e);
            match e {
                WlClipboardListenerError::InitFailed(_) => {
                    eprintln!("\nYou are not running on a Wayland desktop.");
                    eprintln!("This tool requires Wayland and a compositor that supports");
                    eprintln!("the data control protocol (GNOME, KDE, Sway, Hyperland, etc.)");
                }
                WlClipboardListenerError::QueueError(_) => {
                    eprintln!("\nWayland connection error. The server may have crashed.");
                }
                WlClipboardListenerError::PipeError => {
                    eprintln!("\nFailed to read clipboard data.");
                    eprintln!("The clipboard provider may have crashed.");
                }
                WlClipboardListenerError::DispatchError(_) => {
                    eprintln!("\nWayland protocol error. This is a bug.");
                }
            }
            std::process::exit(1);
        }
    }
}

fn run() -> Result<(), WlClipboardListenerError> {
    let mut stream = WlClipboardPasteStream::init(WlListenType::ListenOnCopy)?;
    let message = stream.get_clipboard()?;
    println!("{}", String::from_utf8_lossy(&message.context.context));
    Ok(())
}
```

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

### Check Wayland Compositor Information

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/errors.md

Use compositor-specific tools like 'weston-info' to get details about the running Wayland compositor.

```bash
weston-info  # or similar compositor-specific tool
```

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

### Conditional Protocol Support (WLR and Modern)

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/quick-start-examples.md

This example shows how to support both legacy WLR and modern Wayland clipboard protocols. It attempts to use the WLR protocol first and falls back to the modern protocol if WLR is not available. Ensure the 'wlr-data-control' feature is enabled in Cargo.toml for WLR support.

```rust
use wayland_clipboard_listener::{WlClipboardListenerError, WlListenType};

#[cfg(feature = "wlr-data-control")]
use wayland_clipboard_listener::WlClipboardPasteStreamWlr;

use wayland_clipboard_listener::WlClipboardPasteStream;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Try WLR protocol first (if available)
    #[cfg(feature = "wlr-data-control")]
    {
        match WlClipboardPasteStreamWlr::init(WlListenType::ListenOnCopy) {
            Ok(mut stream) => {
                println!("Using WLR protocol");
                let msg = stream.get_clipboard()?;
                println!("Content: {}", String::from_utf8_lossy(&msg.context.context));
                return Ok(())
            }
            Err(_) => {
                println!("WLR protocol not available, trying modern protocol");
            }
        }
    }
    
    // Fall back to modern protocol
    let mut stream = WlClipboardPasteStream::init(WlListenType::ListenOnCopy)?;
    println!("Using modern protocol");
    let msg = stream.get_clipboard()?;
    println!("Content: {}", String::from_utf8_lossy(&msg.context.context));
    
    Ok(())
}
```

```toml
[dependencies]
wayland-clipboard-listener = { version = "0.6", features = ["wlr-data-control"] }
```

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

### Handling QueueError in Rust

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/errors.md

Demonstrates how to handle QueueError when fetching clipboard content. This example shows how to catch the error, log a specific message indicating a potential Wayland server issue, and attempt to reconnect by breaking the loop.

```rust
use wayland_clipboard_listener::{WlClipboardPasteStream, WlListenType, WlClipboardListenerError};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut stream = WlClipboardPasteStream::init(WlListenType::ListenOnCopy)?;
    
    loop {
        match stream.get_clipboard() {
            Ok(message) => {
                println!("Clipboard content: {} bytes", message.context.context.len());
            }
            Err(WlClipboardListenerError::QueueError(reason)) => {
                eprintln!("Queue error (possibly Wayland server crashed): {}", reason);
                eprintln!("Attempting to reconnect...");
                break;
            }
            Err(e) => {
                eprintln!("Other error: {}", e);
                return Err(e.into());
            }
        }
    }
    
    Ok(())
}
```

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

### Get Clipboard Data (Attempt, Legacy Wlr)

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/REFERENCE-INDEX.txt

Attempts to retrieve clipboard data using the legacy WLR protocol. Returns None if data is unavailable or an error occurs.

```rust
let clipboard_data = paste_stream_wlr.try_get_clipboard().await;

```

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

### Try Get Clipboard (Rust)

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/api-reference-paste-stream.md

Attempt to retrieve clipboard data without blocking. Returns `Ok(None)` if no clipboard event is currently available. This method is useful for polling clipboard updates.

```rust
use wayland_clipboard_listener::WlClipboardPasteStream;
use wayland_clipboard_listener::WlListenType;
use std::thread;
use std::time::Duration;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut stream = WlClipboardPasteStream::init(WlListenType::ListenOnCopy)?;
    
    // Poll for clipboard updates without blocking
    loop {
        match stream.try_get_clipboard()? {
            Some(message) => {
                println!("New clipboard content!");
                println!("Type: {}", message.context.mime_type);
                break;
            }
            None => {
                println!("Waiting for clipboard event...");
                thread::sleep(Duration::from_millis(500));
            }
        }
    }
    
    Ok(())
}
```

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

### Acquire Queue and Get Handle

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/listener-stream-internals.md

Acquires exclusive access to the event queue for clipboard operations.

```rust
let eventqh = self.queue.clone().unwrap();
let mut event_queue = eventqh.lock().unwrap();
let qh = event_queue.handle();
let manager = self.data_manager.as_ref().unwrap();
```

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

### Initialize WlClipboardPasteStream

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/api-reference-paste-stream.md

Initializes a clipboard paste listener stream. Use `ListenOnCopy` to capture copy events with full MIME type information, or `ListenOnSelect` for selection events (text only).

```rust
use wayland_clipboard_listener::WlClipboardPasteStream;
use wayland_clipboard_listener::WlListenType;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize to listen on copy events with full MIME type information
    let mut stream = WlClipboardPasteStream::init(WlListenType::ListenOnCopy)?;
    
    // Retrieve clipboard data once
    let message = stream.get_clipboard()?;
    println!("Mime types: {:?}", message.mime_types);
    println!("Content: {:?}", message.context.mime_type);
    println!("Data size: {} bytes", message.context.context.len());
    
    Ok(())
}
```

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

### Get Clipboard Data (Attempt)

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/REFERENCE-INDEX.txt

Attempts to retrieve data from the Wayland clipboard, returning None if no data is available or an error occurs. Useful for non-blocking checks.

```rust
let clipboard_data = paste_stream.try_get_clipboard().await;

```

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

### Initialize WlClipboardCopyStream

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/api-reference-copy-stream.md

Initializes a clipboard copy stream. The stream remains active until another application copies data to the clipboard. Ensure Wayland connection is successful and required protocols are available.

```rust
use wayland_clipboard_listener::WlClipboardCopyStream;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut stream = WlClipboardCopyStream::init()?;
    
    println!("Clipboard copy stream initialized");
    
    Ok(())
}
```

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

### Get Clipboard Synchronously

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/api-reference-paste-stream.md

Retrieve clipboard data synchronously. This method blocks until a clipboard event is available or an error occurs. It's suitable for immediate data retrieval after an event.

```rust
use wayland_clipboard_listener::WlClipboardPasteStream;
use wayland_clipboard_listener::WlListenType;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut stream = WlClipboardPasteStream::init(WlListenType::ListenOnCopy)?;
    
    // Get clipboard data (blocks until next copy event)
    let message = stream.get_clipboard()?;
    
    // Check available MIME types
    println!("Available MIME types:");
    for mime in &message.mime_types {
        println!("  - {}", mime);
    }
    
    // Access the selected content
    let text = String::from_utf8_lossy(&message.context.context);
    println!("Clipboard (as text): {}", text);
    
    Ok(())
}
```

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

### init

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/api-reference-copy-stream-wlr.md

Initializes a clipboard copy stream using the legacy WLR data control protocol. This stream remains active until another copy operation occurs. Requires the 'wlr-data-control' feature to be enabled.

```APIDOC
## init

### Description
Initialize a clipboard copy stream with the WLR data control protocol. The stream persists until another copy operation occurs elsewhere.

### Method
Rust function call

### Parameters
(none)

### Return Type
`Result<WlClipboardCopyStreamWlr, WlClipboardListenerError>`

A new WLR copy stream instance, or an error if initialization fails.

### Throws/Rejects
- `WlClipboardListenerError::InitFailed` — Cannot connect to Wayland or `zwlr-data-control-manager-v1` not available.

### Example
```rust
#[cfg(feature = "wlr-data-control")]
{
    use wayland_clipboard_listener::WlClipboardCopyStreamWlr;

    fn main() -> Result<(), Box<dyn std::error::Error>> {
        let mut stream = WlClipboardCopyStreamWlr::init()?;
        println!("Copy stream ready");
        Ok(())
    }
}
```
```

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

### Initialize Copy Stream

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/REFERENCE-INDEX.txt

Initializes a new WlClipboardCopyStream instance. This is required before copying data to the Wayland clipboard.

```rust
let copy_stream = WlClipboardCopyStream::init().await;

```

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

### Handling PipeError when getting clipboard data

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/errors.md

This snippet demonstrates how to specifically catch and handle the PipeError, which occurs when reading clipboard data fails. It provides user-friendly messages about potential causes.

```rust
use wayland_clipboard_listener::{WlClipboardPasteStream, WlListenType, WlClipboardListenerError};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut stream = WlClipboardPasteStream::init(WlListenType::ListenOnCopy)?;
    
    match stream.get_clipboard() {
        Ok(message) => {
            println!("Success: {} bytes", message.context.context.len());
        }
        Err(WlClipboardListenerError::PipeError) => {
            eprintln!("Failed to read clipboard data");
            eprintln!("Possible causes:");
            eprintln!("  - The clipboard provider (e.g., Firefox) crashed");
            eprintln!("  - Another copy operation occurred before data was fully read");
            eprintln!("  - Insufficient system resources");
        }
        Err(e) => eprintln!("Other error: {}", e),
    }
    
    Ok(())
}
```

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

### Command-Line Copy Tool

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/quick-start-examples.md

Create a tool that copies command-line arguments to the clipboard, similar to wl-copy.

```rust
use wayland_clipboard_listener::WlClipboardCopyStream;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args: Vec<String> = std::env::args().collect();
    
    if args.len() < 2 {
        eprintln!("Usage: {} <text>", args[0]);
        std::process::exit(1);
    }
    
    let text = &args[1];
    let mut stream = WlClipboardCopyStream::init()?;
    
    stream.copy_to_clipboard(
        text.as_bytes().to_vec(),
        vec!["text/plain;charset=utf-8"],
        false,
    )?;
    
    println!("✓ Copied to clipboard");
    
    Ok(())
}
```

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

### Handle InitFailed Error

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/errors.md

Demonstrates how to catch and handle the `InitFailed` error when initializing the clipboard listener. This is useful when the Wayland server is unavailable or required protocols are not supported.

```rust
use wayland_clipboard_listener::{WlClipboardPasteStream, WlListenType, WlClipboardListenerError};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    match WlClipboardPasteStream::init(WlListenType::ListenOnCopy) {
        Ok(stream) => {
            println!("Clipboard listener initialized successfully");
            // use stream
        }
        Err(WlClipboardListenerError::InitFailed(reason)) => {
            eprintln!("Failed to initialize clipboard listener: {}", reason);
            eprintln!("This usually means:");
            eprintln!("  1. Wayland is not running (not on a Wayland desktop)");
            eprintln!("  2. Your compositor doesn't support data control protocol");
            eprintln!("  3. WAYLAND_DISPLAY environment variable is not set");
            std::process::exit(1);
        }
        Err(e) => Err(e.into()),
    }
}
```

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

### Get Mutable WLR Stream for Paste Events

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/api-reference-paste-stream-wlr.md

Returns a mutable reference to the underlying WLR stream, which can be used as an iterator to process clipboard events. This is useful for continuous monitoring of clipboard changes.

```rust
#[cfg(feature = "wlr-data-control")]
pub fn paste_stream(&mut self) -> &mut WlClipboardListenerStreamWlr
```

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

### Constructor: init

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/api-reference-copy-stream.md

Initializes a clipboard copy stream. The stream remains active in the background until another application modifies the clipboard content. It returns a Result, which is either a new stream instance or an error if the Wayland connection fails or required interfaces are unavailable.

```APIDOC
## Constructor: init

### Description
Initialize a clipboard copy stream. The stream persists in the background until another application copies to the clipboard.

### Signature
```rust
pub fn init() -> Result<Self, WlClipboardListenerError>
```

### Parameters
(none)

### Return Value
`Result<WlClipboardCopyStream, WlClipboardListenerError>` - A new copy stream instance ready to send data to the clipboard, or an initialization error if Wayland connection fails.

### Errors
- `WlClipboardListenerError::InitFailed` - Cannot connect to Wayland server or required protocol interfaces not available.

### Example
```rust
use wayland_clipboard_listener::WlClipboardCopyStream;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut stream = WlClipboardCopyStream::init()?;
    
    println!("Clipboard copy stream initialized");
    
    Ok(())
}
```
```

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

### Copy to Clipboard with Multiple MIME Types

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/quick-start-examples.md

Use this to copy data to the clipboard, offering it in several MIME types to ensure compatibility with different applications. The `WlClipboardCopyStream::init` function initializes the stream, and `copy_to_clipboard` handles the data transfer.

```rust
use wayland_clipboard_listener::WlClipboardCopyStream;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut stream = WlClipboardCopyStream::init()?;
    
    let text = "Rich text example";
    stream.copy_to_clipboard(
        text.as_bytes().to_vec(),
        vec![
            "text/plain;charset=utf-8",
            "TEXT",
            "text/plain",
        ],
        false,
    )?;
    
    println!("Copied with multiple formats");
    
    Ok(())
}
```

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

### Distinguishing Initialization vs Runtime Errors

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/errors.md

This pattern shows how to separate initialization errors from runtime errors. It maps specific initialization errors to a formatted string, ensuring clear error reporting during setup.

```rust
use wayland_clipboard_listener::{WlClipboardPasteStream, WlListenType, WlClipboardListenerError};

fn setup_listener() -> Result<WlClipboardPasteStream, String> {
    WlClipboardPasteStream::init(WlListenType::ListenOnCopy)
        .map_err(|e| match e {
            WlClipboardListenerError::InitFailed(msg) => {
                format!("Init failed: {}", msg)
            }
            _ => format!("Unexpected error during init: {}", e),
        })
}

fn main() -> Result<(), String> {
    let mut stream = setup_listener()?;
    // Process clipboard...
    Ok(())
}
```

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

### Add Default Dependency

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/configuration.md

Include the `wayland-clipboard-listener` crate in your `Cargo.toml` to use the modern `ext-data-control-v1` protocol.

```toml
[dependencies]
wayland-clipboard-listener = "0.6"
```

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

### Copy Data with Multiple MIME Types

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/configuration.md

When copying, declare all MIME types the data supports to allow receiving applications to choose the best format. This example shows declaring primary, fallback, and variant text formats.

```rust
use wayland_clipboard_listener::WlClipboardCopyStream;

let mut stream = WlClipboardCopyStream::init()?;

let text = "Multi-format data";
stream.copy_to_clipboard(
    text.as_bytes().to_vec(),
    vec![
        "text/plain;charset=utf-8",  // Primary format
        "TEXT",                        // Fallback format
        "text/plain",                  // Another variant
    ],
    false,
)?
```

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

### Initialize Paste Stream

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/REFERENCE-INDEX.txt

Initializes a new WlClipboardPasteStream instance. This is the first step before interacting with the Wayland clipboard for pasting operations.

```rust
let paste_stream = WlClipboardPasteStream::init().await;

```

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

### Wayland Event Loop Steps

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/protocol-overview.md

Illustrates the sequence of operations for connecting to a Wayland server and processing events using the library's event queue mechanism.

```text
1. Connection::connect_to_env() — Connect to Wayland server
2. conn.new_event_queue() — Create event queue
3. event_queue.handle() — Get queue handle for binding objects
4. Dispatch implementation — Handle Wayland events
5. event_queue.blocking_dispatch(&mut state) — Process events (blocks)
6. event_queue.roundtrip(&mut state) — Process events and wait for replies
7. event_queue.flush() — Send pending requests without waiting
```

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

### Listen for Clipboard Changes (Basic)

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/README.md

Initializes a stream to listen for clipboard copy events and retrieves the latest clipboard content.

```rust
let mut stream = WlClipboardPasteStream::init(WlListenType::ListenOnCopy)?;
let message = stream.get_clipboard()?;
println!("{}", String::from_utf8_lossy(&message.context.context));
```

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

### Copy Text and Binary Data to Clipboard

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/configuration.md

Initialize a copy stream and provide data as `Vec<u8>`. Declare supported MIME types, including text and custom binary formats.

```rust
use wayland_clipboard_listener::WlClipboardCopyStream;

let mut stream = WlClipboardCopyStream::init()?;

// Text data (UTF-8 encoded)
let text = "Hello, Wayland!";
let data = text.as_bytes().to_vec();

// Binary data (raw bytes)
let binary = vec![0x89, 0x50, 0x4E, 0x47];  // PNG header

stream.copy_to_clipboard(
    data,
    vec!["text/plain;charset=utf-8"],
    false,
)?;
```

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

### Select Wayland Clipboard Protocol at Runtime

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/quick-start-examples.md

Demonstrates how to select between 'modern' and 'wlr' Wayland clipboard protocols based on an environment variable. It attempts to use the 'modern' protocol by default if 'auto' is specified and the 'modern' protocol fails.

```rust
use wayland_clipboard_listener::WlListenType;

#[cfg(feature = "wlr-data-control")]
use wayland_clipboard_listener::WlClipboardPasteStreamWlr;

use wayland_clipboard_listener::WlClipboardPasteStream;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let protocol = std::env::var("CLIPBOARD_PROTOCOL")
        .unwrap_or_else(|_| "auto".to_string());
    
    match protocol.as_str() {
        "modern" => {
            let mut stream = WlClipboardPasteStream::init(WlListenType::ListenOnCopy)?;
            let msg = stream.get_clipboard()?;
            println!("Modern: {}", String::from_utf8_lossy(&msg.context.context));
        }
        #[cfg(feature = "wlr-data-control")]
        "wlr" => {
            let mut stream = WlClipboardPasteStreamWlr::init(WlListenType::ListenOnCopy)?;
            let msg = stream.get_clipboard()?;
            println!("WLR: {}", String::from_utf8_lossy(&msg.context.context));
        }
        _ => {
            // Auto: try modern first
            match WlClipboardPasteStream::init(WlListenType::ListenOnCopy) {
                Ok(mut stream) => {
                    let msg = stream.get_clipboard()?;
                    println!("Auto (modern): {}", String::from_utf8_lossy(&msg.context.context));
                }
                Err(_) => {
                    #[cfg(feature = "wlr-data-control")]
                    {
                        let mut stream = WlClipboardPasteStreamWlr::init(WlListenType::ListenOnCopy)?;
                        let msg = stream.get_clipboard()?;
                        println!("Auto (WLR): {}", String::from_utf8_lossy(&msg.context.context));
                    }
                    #[cfg(not(feature = "wlr-data-control"))]
                    {
                        return Err("Modern protocol not available".into());
                    }
                }
            }
        }
    }
    
    Ok(())
}

```

```bash
CLIPBOARD_PROTOCOL=modern cargo run
CLIPBOARD_PROTOCOL=wlr cargo run
CLIPBOARD_PROTOCOL=auto cargo run
```

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

### Run with Custom Wayland Display

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/configuration.md

Override the default Wayland display socket by setting the `WAYLAND_DISPLAY` environment variable before running the application.

```bash
WAYLAND_DISPLAY=wayland-1 cargo run
```

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

### Initialize Wayland Clipboard Paste Stream

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/api-reference-paste-stream.md

Initializes a Wayland clipboard paste stream. Use `WlListenType::ListenOnCopy` to set MIME type preferences. This setting is ignored for `WlListenType::ListenOnSelect`.

```rust
use wayland_clipboard_listener::WlClipboardPasteStream;
use wayland_clipboard_listener::WlListenType;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut stream = WlClipboardPasteStream::init(WlListenType::ListenOnCopy)?;
    
    // Prefer JPEG images, then UTF-8 text, then anything else
    stream.set_priority(vec![
        "image/jpeg".into(),
        "text/plain;charset=utf-8".into(),
    ]);
    
    let message = stream.get_clipboard()?;
    println!("Selected MIME type: {}", message.context.mime_type);
    println!("Data: {} bytes", message.context.context.len());
    
    Ok(())
}
```

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

### WlClipboardPasteStream::init

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/api-reference-paste-stream.md

Initializes a clipboard paste listener stream with the specified listening mode. It returns a new paste stream instance or an initialization error.

```APIDOC
## Constructor: init

### Description
Initializes a clipboard paste listener stream with the specified listening mode.

### Signature
```rust
pub fn init(listentype: WlListenType) -> Result<Self, WlClipboardListenerError>
```

### Parameters
#### Path Parameters
- **listentype** (WlListenType) - Required - Determines when clipboard events are captured: `ListenOnSelect` for selection events (text only, MIME types unknown) or `ListenOnCopy` for copy events (full MIME type information available).

### Return Type
`Result<WlClipboardPasteStream, WlClipboardListenerError>`
A new paste stream instance ready to listen for clipboard events, or an initialization error if Wayland connection fails or protocol objects cannot be created.

### Throws/Rejects
- `WlClipboardListenerError::InitFailed` — Cannot connect to Wayland server or required protocol interfaces not available.

### Example
```rust
use wayland_clipboard_listener::WlClipboardPasteStream;
use wayland_clipboard_listener::WlListenType;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize to listen on copy events with full MIME type information
    let mut stream = WlClipboardPasteStream::init(WlListenType::ListenOnCopy)?;
    
    // Retrieve clipboard data once
    let message = stream.get_clipboard()?;
    println!("Mime types: {:?}", message.mime_types);
    println!("Content: {:?}", message.context.mime_type);
    println!("Data size: {} bytes", message.context.context.len());
    
    Ok(())
}
```
```

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

### Run with Custom Runtime Directory

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/configuration.md

Specify a custom directory for Wayland sockets by setting the `XDG_RUNTIME_DIR` environment variable.

```bash
XDG_RUNTIME_DIR=/tmp/wayland cargo run
```

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

### Listen for Copy Events with Wayland Clipboard

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/README.md

Initializes a stream to listen for copy events on the Wayland clipboard. The loop processes received clipboard contexts, which can include various MIME types. Ensure the Wayland environment is correctly set up.

```rust
use wayland_clipboard_listener::WlClipboardPasteStream;
use wayland_clipboard_listener::WlListenType;

fn main() {
    let mut stream = WlClipboardPasteStream::init(WlListenType::ListenOnCopy).unwrap();
    for context in stream.paste_stream().flatten().flatten() {
    //  Note: MIME type priority is ignored when WlListenType is ListenOnSelect
    //  stream.set_priority(vec![
    //      "image/jpeg".into(),
    //      "text/plain;charset=utf-8".into(),
    //  ]);
        println!("{context:?}");
    }
}
```

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

### Initialize WlClipboardPasteStreamWlr

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/api-reference-paste-stream-wlr.md

Initializes a clipboard paste listener stream using the WLR data control protocol. This function requires the `wlr-data-control` feature to be enabled. It can fail if connection to the Wayland server is not possible or the necessary interface is unavailable.

```rust
#[cfg(feature = "wlr-data-control")]
pub fn init(listentype: WlListenType) -> Result<Self, WlClipboardListenerError>
```

```rust
#[cfg(feature = "wlr-data-control")]
{
    use wayland_clipboard_listener::WlClipboardPasteStreamWlr;
    use wayland_clipboard_listener::WlListenType;

    fn main() -> Result<(), Box<dyn std::error::Error>> {
        let mut stream = WlClipboardPasteStreamWlr::init(WlListenType::ListenOnCopy)?;
        
        let message = stream.get_clipboard()?;
        println!("Clipboard: {}", String::from_utf8_lossy(&message.context.context));
        
        Ok(())
    }
}
```

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

### Copy Text to Clipboard (wl-copy Equivalent)

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/configuration.md

This snippet provides functionality similar to `wl-copy`, allowing you to copy provided text to the Wayland clipboard. It expects the text to copy as a command-line argument.

```rust
use wayland_clipboard_listener::WlClipboardCopyStream;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args: Vec<String> = std::env::args().collect();
    
    if args.len() < 2 {
        eprintln!("Usage: {} <text to copy>", args[0]);
        std::process::exit(1);
    }
    
    let text = &args[1];
    let mut stream = WlClipboardCopyStream::init()?;
    
    stream.copy_to_clipboard(
        text.as_bytes().to_vec(),
        vec!["text/plain;charset=utf-8"],
        false,
    )?;
    
    println!("Copied to clipboard");
    
    Ok(())
}
```

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

### Check Device Readiness

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/listener-stream-internals.md

Verifies that essential Wayland devices, specifically the seat and data manager, have been successfully bound during initialization. Returns an error if they are not ready.

```rust
if !state.device_ready() {
    return Err(WlClipboardListenerError::InitFailed(...));
}
```

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

### Feature-Gated Protocol Initialization

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/configuration.md

Conditionally initialize the clipboard listener based on the presence of the `wlr-data-control` feature. This allows your application to support both modern and legacy Wayland protocols.

```rust
#[cfg(feature = "wlr-data-control")]
use wayland_clipboard_listener::WlClipboardPasteStreamWlr;

use wayland_clipboard_listener::{WlClipboardPasteStream, WlListenType};

fn init_listener() -> Result<(), Box<dyn std::error::Error>> {
    #[cfg(feature = "wlr-data-control")]
    {
        if let Ok(stream) = WlClipboardPasteStreamWlr::init(WlListenType::ListenOnCopy) {
            println!("Using WLR protocol");
            return Ok(())
        }
    }
    
    let _stream = WlClipboardPasteStream::init(WlListenType::ListenOnCopy)?;
    println!("Using modern protocol");
    Ok(())
}
```

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

### Initialize Listener State

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/listener-stream-internals.md

Sets up the initial state for the Wayland clipboard listener, ensuring all Wayland object fields are initially unbound.

```rust
let mut state = WlClipboardListenerStream {
    listentype,
    seat: None,
    seat_name: None,
    // ... all fields set to None or default
};
```

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

### WlClipboardCopyStream

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/README.md

Provides methods to initialize and copy data to the clipboard.

```APIDOC
## WlClipboardCopyStream

### Description
Represents a stream for copying data to the Wayland clipboard.

### Methods

#### init() -> Self
Initializes a new WlClipboardCopyStream.

#### copy_to_clipboard(data: Vec<u8>, mime_types: Vec<&str>, append: bool) -> ()
Copies data to the clipboard.

- **data** (Vec<u8>) - The byte data to copy.
- **mime_types** (Vec<&str>) - A list of MIME types for the data.
- **append** (bool) - Whether to append to existing clipboard content.
```

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

### Prepare and Return Clipboard Message

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/listener-stream-internals.md

Resets the `pipereader` state for subsequent clipboard events and clears the `mime_types`. It then prepares and returns the `ClipBoardListenMessage` containing the mime types and the clipboard context.

```rust
self.pipereader = None;
let mime_types = self.mime_types.clone();
self.mime_types.clear();
let mime_type = self.current_type.clone().unwrap();
Ok(ClipBoardListenMessage {
    mime_types,
    context: ClipBoardListenContext { mime_type, context },
})
```

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

### WlClipboardPasteStreamWlr::init

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/api-reference-paste-stream-wlr.md

Initializes a clipboard paste listener stream using the legacy WLR data control protocol. This is suitable for older Wayland compositors.

```APIDOC
## init

### Description
Initializes a clipboard paste listener stream with the WLR data control protocol.

### Method
Rust function call

### Signature
```rust
pub fn init(listentype: WlListenType) -> Result<Self, WlClipboardListenerError>
```

### Parameters
#### Path Parameters
- **listentype** (WlListenType) - Required - Determines listening mode: `ListenOnSelect` for selection events or `ListenOnCopy` for copy events with full MIME type information.

### Response
#### Success Response
- **Self** (WlClipboardPasteStreamWlr) - A new WLR paste stream instance.
#### Error Response
- **WlClipboardListenerError** - An error if initialization fails, such as `InitFailed` if connection to the Wayland server fails or the `zwlr-data-control-manager-v1` interface is unavailable.

### Example
```rust
#[cfg(feature = "wlr-data-control")]
{
    use wayland_clipboard_listener::WlClipboardPasteStreamWlr;
    use wayland_clipboard_listener::WlListenType;

    fn main() -> Result<(), Box<dyn std::error::Error>> {
        let mut stream = WlClipboardPasteStreamWlr::init(WlListenType::ListenOnCopy)?;
        
        let message = stream.get_clipboard()?;
        println!("Clipboard: {}", String::from_utf8_lossy(&message.context.context));
        
        Ok(())
    }
}
```
```

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

### Initialize Listener for Copy Events

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/configuration.md

Use WlListenType::ListenOnCopy to capture explicit copy actions. This mode provides full MIME type information and supports multiple data formats.

```rust
use wayland_clipboard_listener::{WlClipboardPasteStream, WlListenType};

let mut stream = WlClipboardPasteStream::init(WlListenType::ListenOnCopy)?;
```

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

### Initialize WlClipboardCopyStreamWlr

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/api-reference-copy-stream-wlr.md

Initializes a clipboard copy stream using the WLR data control protocol. This stream remains active until another copy operation occurs. Ensure the `wlr-data-control` feature is enabled.

```rust
#[cfg(feature = "wlr-data-control")]
pub fn init() -> Result<Self, WlClipboardListenerError>
```

```rust
#[cfg(feature = "wlr-data-control")]
{
    use wayland_clipboard_listener::WlClipboardCopyStreamWlr;

    fn main() -> Result<(), Box<dyn std::error::Error>> {
        let mut stream = WlClipboardCopyStreamWlr::init()?;
        println!("Copy stream ready");
        Ok(())
    }
}
```

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

### Connect to Wayland via Environment Variables

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/configuration.md

The library automatically determines the Wayland connection string from environment variables. Ensure `WAYLAND_DISPLAY` and `XDG_RUNTIME_DIR` are set appropriately.

```rust
let conn = Connection::connect_to_env()?;
```

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

### Initialize Legacy Paste Stream (Wlr)

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/REFERENCE-INDEX.txt

Initializes a WlClipboardPasteStreamWlr instance for environments using the legacy WLR data control protocol. This is a feature-gated constructor.

```rust
let paste_stream_wlr = WlClipboardPasteStreamWlr::init().await;

```

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

### WlClipboardPasteStream

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/README.md

Provides methods to initialize and interact with a stream for listening to clipboard paste events.

```APIDOC
## WlClipboardPasteStream

### Description
Represents a stream for listening to clipboard paste events.

### Methods

#### init(listen_type: WlListenType) -> Self
Initializes a new WlClipboardPasteStream.

- **listen_type** (WlListenType) - Specifies the type of listening: `ListenOnSelect` for text selection or `ListenOnCopy` for explicit copy with MIME types.

#### paste_stream() -> &mut WlClipboardListenerStream
Returns a mutable reference to the underlying clipboard listener stream.

#### get_clipboard() -> ClipBoardListenMessage
Retrieves the current clipboard content. This method will block if the clipboard is not ready.

#### try_get_clipboard() -> Option<ClipBoardListenMessage>
Attempts to retrieve the current clipboard content without blocking. Returns `None` if the clipboard is not ready.

#### set_priority(mime_types: Vec<String>)
Sets the priority for MIME types to be listened for.
```

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

### Set Data Device

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/listener-stream-internals.md

Creates the data device responsible for listening to clipboard changes. This is called during initialization and after the device is destroyed.

```rust
fn set_data_device(&mut self, qh: &wayland_client::QueueHandle<Self>) {
    let seat = self.seat.as_ref().unwrap();
    let manager = self.data_manager.as_ref().unwrap();
    let device = manager.get_data_device(seat, qh, ());
    self.data_device = Some(device);
}
```

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

### Iterate Clipboard Events with WLR Stream

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/api-reference-paste-stream-wlr.md

Demonstrates how to initialize a WLR clipboard listener and iterate over the first three clipboard events using the `paste_stream` method. It prints the clipboard content or any errors encountered. Ensure the `wlr-data-control` feature is enabled.

```rust
#[cfg(feature = "wlr-data-control")]
{
    use wayland_clipboard_listener::WlClipboardPasteStreamWlr;
    use wayland_clipboard_listener::WlListenType;
    use std::thread;
    use std::time::Duration;

    fn main() -> Result<(), Box<dyn std::error::Error>> {
        let mut stream = WlClipboardPasteStreamWlr::init(WlListenType::ListenOnCopy)?;
        
        for event in stream.paste_stream().take(3) {
            match event {
                Ok(msg) => println!("Clipboard: {}", String::from_utf8_lossy(&msg.context.context)),
                Err(e) => eprintln!("Error: {}", e),
            }
            thread::sleep(Duration::from_millis(200));
        }
        
        Ok(())
    }
}
```

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

### Listen for Plain Text Clipboard Changes

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/configuration.md

This snippet demonstrates how to initialize a stream to listen for clipboard changes and extract plain text content. It polls the clipboard every 500 milliseconds.

```rust
use wayland_clipboard_listener::{WlClipboardPasteStream, WlListenType};
use std::thread;
use std::time::Duration;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut stream = WlClipboardPasteStream::init(WlListenType::ListenOnCopy)?;
    
    loop {
        match stream.try_get_clipboard()? {
            Some(msg) => {
                let text = String::from_utf8_lossy(&msg.context.context);
                println!("Clipboard: {}", text);
            }
            None => thread::sleep(Duration::from_millis(500)),
        }
    }
}
```

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

### WlClipboardListenerStream

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/types.md

Low-level clipboard listener stream for the modern `ext-data-control-v1` protocol.

```APIDOC
## WlClipboardListenerStream

### Description
Low-level clipboard listener stream for the modern `ext-data-control-v1` protocol. Implements `Iterator<Item = Result<ClipBoardListenMessage, WlClipboardListenerError>>`.

### Implements
- `Iterator`
- `Dispatch` (for multiple Wayland protocol types)
```

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

### Basic Paste: Listen for Copy Events

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/quick-start-examples.md

Listen for a single clipboard change event and print the new content. Initializes a stream to listen specifically on copy events.

```rust
use wayland_clipboard_listener::{WlClipboardPasteStream, WlListenType};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut stream = WlClipboardPasteStream::init(WlListenType::ListenOnCopy)?;
    
    println!("Waiting for clipboard changes...");
    let message = stream.get_clipboard()?;
    
    let text = String::from_utf8_lossy(&message.context.context);
    println!("Clipboard content: {}", text);
    
    Ok(())
}
```

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

### Initialize Legacy Copy Stream (Wlr)

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/REFERENCE-INDEX.txt

Initializes a WlClipboardCopyStreamWlr instance for copying data using the legacy WLR data control protocol. This is a feature-gated constructor.

```rust
let copy_stream_wlr = WlClipboardCopyStreamWlr::init().await;

```

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

### Initialize Listener for Selection Events

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/configuration.md

Use WlListenType::ListenOnSelect to capture text selection events. MIME types are not available with this mode, and only plain text can be received. This is suitable for applications like translation or autocorrect.

```rust
use wayland_clipboard_listener::{WlClipboardPasteStream, WlListenType};

let mut stream = WlClipboardPasteStream::init(WlListenType::ListenOnSelect)?;
```

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

### WlClipboardPasteStream Structure

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/types.md

Wrapper for listening to clipboard paste events using the modern `ext-data-control-v1` protocol. Provides methods for initializing the listener, accessing the paste stream, and retrieving clipboard content.

```rust
pub struct WlClipboardPasteStream {
    inner: WlClipboardListenerStream,
}
```

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

### WlClipboardCopyStreamWlr

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/README.md

Provides methods to initialize and copy data to the clipboard, supporting legacy compositors via the 'wlr-data-control' feature.

```APIDOC
## WlClipboardCopyStreamWlr

### Description
Represents a stream for copying data to the Wayland clipboard, compatible with legacy compositors using the 'wlr-data-control' feature.

### Methods

#### init() -> Self
Initializes a new WlClipboardCopyStreamWlr.

#### copy_to_clipboard(data: Vec<u8>, mime_types: Vec<&str>, append: bool) -> ()
Copies data to the clipboard.

- **data** (Vec<u8>) - The byte data to copy.
- **mime_types** (Vec<&str>) - A list of MIME types for the data.
- **append** (bool) - Whether to append to existing clipboard content.
```

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

### Create Data Source for Copying

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/listener-stream-internals.md

Creates a new data source object to represent the data being copied to the clipboard.

```rust
let source = manager.create_data_source(&qh, ());
```

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

### WlClipboardCopyStream Structure

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/types.md

A wrapper for copying data to the clipboard using the ext-data-control-v1 protocol. It facilitates sending data and specifying MIME types for clipboard operations.

```rust
pub struct WlClipboardCopyStream {
    inner: WlClipboardListenerStream,
}
```

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

### WlClipboardCopyStreamWlr API (Legacy)

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/REFERENCE-INDEX.txt

Documentation for the WlClipboardCopyStreamWlr class, a legacy version for copying data to the Wayland clipboard using WLR protocol.

```APIDOC
## WlClipboardCopyStreamWlr::init()

### Description
Initializes the WlClipboardCopyStreamWlr object.

### Method
init()

### Parameters
None

### Request Example
```
stream = WlClipboardCopyStreamWlr()
stream.init()
```

### Response
None
```

```APIDOC
## WlClipboardCopyStreamWlr::copy_to_clipboard()

### Description
Copies the provided data to the Wayland clipboard using the WLR protocol.

### Method
copy_to_clipboard(data: str)

### Parameters
- **data** (str) - Required - The data to be copied to the clipboard.

### Request Example
```
copy_stream_wlr_instance.copy_to_clipboard("Text to copy")
```

### Response
None
```

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

### WlClipboardCopyStream

Source: https://github.com/decodetalkers/wayland-clipboard-listener/blob/master/_autodocs/types.md

Wrapper for copying data to the clipboard using the modern `ext-data-control-v1` protocol.

```APIDOC
## WlClipboardCopyStream

### Description
Wrapper for copying data to the clipboard using the modern `ext-data-control-v1` protocol.

### Methods
- `init() -> Result<Self, WlClipboardListenerError>`: Initializes a new instance of WlClipboardCopyStream.
- `copy_to_clipboard(&mut self, data: Vec<u8>, mimetypes: Vec<&str>, useprimary: bool) -> Result<(), WlClipboardListenerError>`: Copies the provided data to the clipboard with specified MIME types and primary selection option.
```