// Copyright © SixtyFPS GmbH <[email protected]>

// SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-Royalty-free-2.0 OR LicenseRef-Slint-Software-3.0

// cSpell: ignore backtab

#![warn(missing_docs)]

//! Exposed Window API

use crate::api::{

CloseRequestResponse, LogicalPosition, PhysicalPosition, PhysicalSize, PlatformError, Window,

WindowPosition, WindowSize,

};

use crate::graphics::Point;

use crate::input::{

key_codes, ClickState, InternalKeyboardModifierState, KeyEvent, KeyEventType, MouseEvent,

MouseInputState, TextCursorBlinker,

};

use crate::item_tree::ItemRc;

use crate::item_tree::{ItemTreeRc, ItemTreeRef, ItemTreeVTable, ItemTreeWeak};

use crate::items::{ColorScheme, InputType, ItemRef, MouseCursor};

use crate::lengths::{LogicalLength, LogicalPoint, LogicalRect, SizeLengths};

use crate::properties::{Property, PropertyTracker};

use crate::renderer::Renderer;

use crate::{Callback, Coord, SharedString};

#[cfg(not(feature = "std"))]

use alloc::boxed::Box;

use alloc::rc::{Rc, Weak};

use core::cell::{Cell, RefCell};

use core::pin::Pin;

use euclid::num::Zero;

use vtable::VRcMapped;

fn next_focus_item(item: ItemRc) -> ItemRc {

item.next_focus_item()

}

fn previous_focus_item(item: ItemRc) -> ItemRc {

item.previous_focus_item()

}

/// This trait represents the adaptation layer between the [`Window`] API and then

/// windowing specific window representation, such as a Win32 `HWND` handle or a `wayland_surface_t`.

///

/// Implement this trait to establish the link between the two, and pass messages in both

/// directions:

///

/// - When receiving messages from the windowing system about state changes, such as the window being resized,

/// the user requested the window to be closed, input being received, etc. you need to create a

/// [`crate::platform::WindowEvent`](enum.WindowEvent.html) and send it to Slint via [`create::Window::dispatch_event()`](../struct.Window.html#method.dispatch_event).

///

/// - Slint sends requests to change visibility, position, size, etc. via functions such as [`Self::set_visible`],

/// [`Self::set_size`], [`Self::set_position`], or [`Self::update_window_properties()`]. Re-implement these functions

/// and delegate the requests to the windowing system.

///

/// If the implementation of this bi-directional message passing protocol is incomplete, the user may

/// experience unexpected behavior, or the intention of the developer calling functions on the [`crate::Window`](struct.Window.html)

/// API may not be fulfilled.

///

/// Your implementation must hold a renderer, such as [`crate::software_renderer::SoftwareRenderer`].

/// In the [`Self::renderer()`] function, you must return a reference to it.

///

/// It is also required to hold a [`crate::Window`](struct.Window.html) and return a reference to it in your

/// implementation of [`Self::window()`].

///

/// See also [`MinimalSoftwareWindow`](crate::software_renderer::MinimalSoftwareWindow)

/// for a minimal implementation of this trait using the software renderer

pub trait WindowAdapter {

}

/// Implementation details behind [`WindowAdapter`], but since this

/// trait is not exported in the public API, it is not possible for the

/// users to call or re-implement these functions.

// TODO: add events for window receiving and loosing focus

#[doc(hidden)]

pub trait WindowAdapterInternal {

}

/// This is the parameter from [`WindowAdapterInternal::input_method_request()`] which lets the editable text input field

/// communicate with the platform about input methods.

#[non_exhaustive]

#[derive(Debug, Clone)]

pub enum InputMethodRequest {

}

/// This struct holds properties related to an input method.

#[non_exhaustive]

#[derive(Clone, Default, Debug)]

pub struct InputMethodProperties {

}

/// This struct describes layout constraints of a resizable element, such as a window.

#[non_exhaustive]

#[derive(Copy, Clone, Debug, PartialEq, Default)]

pub struct LayoutConstraints {

}

/// This struct contains getters that provide access to properties of the `Window`

/// element, and is used with [`WindowAdapter::update_window_properties`].

pub struct WindowProperties<'a>(&'a WindowInner);

impl<'a> WindowProperties<'a> {

}

struct WindowPropertiesTracker {

window_adapter_weak: Weak<dyn WindowAdapter>,

}

impl crate::properties::PropertyDirtyHandler for WindowPropertiesTracker {

}

struct WindowRedrawTracker {

window_adapter_weak: Weak<dyn WindowAdapter>,

}

impl crate::properties::PropertyDirtyHandler for WindowRedrawTracker {

}

/// This enum describes the different ways a popup can be rendered by the back-end.

enum PopupWindowLocation {

}

/// This structure defines a graphical element that is designed to pop up from the surrounding

/// UI content, for example to show a context menu.

struct PopupWindow {

}

#[pin_project::pin_project]

struct WindowPinnedFields {

}

/// Inner datastructure for the [`crate::api::Window`]

pub struct WindowInner {

}

impl Drop for WindowInner {

}

impl WindowInner {