use std::cell::{Ref, RefCell};
use std::rc::Rc;
use dom_struct::dom_struct;
use js::rust::{HandleObject, MutableHandleValue};
use crate::dom::bindings::cell::DomRefCell;
use crate::dom::bindings::codegen::Bindings::DataTransferBinding::DataTransferMethods;
use crate::dom::bindings::inheritance::Castable;
use crate::dom::bindings::reflector::{DomGlobal, Reflector, reflect_dom_object_with_proto};
use crate::dom::bindings::root::{Dom, DomRoot};
use crate::dom::bindings::str::DOMString;
use crate::dom::datatransferitemlist::DataTransferItemList;
use crate::dom::element::Element;
use crate::dom::filelist::FileList;
use crate::dom::htmlimageelement::HTMLImageElement;
use crate::dom::window::Window;
use crate::drag_data_store::{DragDataStore, Mode};
use crate::script_runtime::{CanGc, JSContext};
const VALID_DROP_EFFECTS: [&str; 4] = ["none", "copy", "link", "move"];
const VALID_EFFECTS_ALLOWED: [&str; 9] = [
"none",
"copy",
"copyLink",
"copyMove",
"link",
"linkMove",
"move",
"all",
"uninitialized",
];
#[dom_struct]
pub(crate) struct DataTransfer {
reflector_: Reflector,
drop_effect: DomRefCell<DOMString>,
effect_allowed: DomRefCell<DOMString>,
items: Dom<DataTransferItemList>,
#[ignore_malloc_size_of = "Rc"]
#[no_trace]
data_store: Rc<RefCell<Option<DragDataStore>>>,
}
impl DataTransfer {
fn new_inherited(
data_store: Rc<RefCell<Option<DragDataStore>>>,
item_list: &DataTransferItemList,
) -> DataTransfer {
DataTransfer {
reflector_: Reflector::new(),
drop_effect: DomRefCell::new(DOMString::from("none")),
effect_allowed: DomRefCell::new(DOMString::from("none")),
items: Dom::from_ref(item_list),
data_store,
}
}
pub(crate) fn new_with_proto(
window: &Window,
proto: Option<HandleObject>,
can_gc: CanGc,
data_store: Rc<RefCell<Option<DragDataStore>>>,
) -> DomRoot<DataTransfer> {
let item_list = DataTransferItemList::new(window, Rc::clone(&data_store), can_gc);
reflect_dom_object_with_proto(
Box::new(DataTransfer::new_inherited(data_store, &item_list)),
window,
proto,
can_gc,
)
}
pub(crate) fn new(
window: &Window,
data_store: Rc<RefCell<Option<DragDataStore>>>,
can_gc: CanGc,
) -> DomRoot<DataTransfer> {
Self::new_with_proto(window, None, can_gc, data_store)
}
pub(crate) fn data_store(&self) -> Option<Ref<DragDataStore>> {
Ref::filter_map(self.data_store.borrow(), |data_store| data_store.as_ref()).ok()
}
}
impl DataTransferMethods<crate::DomTypeHolder> for DataTransfer {
fn Constructor(
window: &Window,
proto: Option<HandleObject>,
can_gc: CanGc,
) -> DomRoot<DataTransfer> {
let mut drag_data_store = DragDataStore::new();
drag_data_store.set_mode(Mode::ReadWrite);
let data_store = Rc::new(RefCell::new(Some(drag_data_store)));
DataTransfer::new_with_proto(window, proto, can_gc, data_store)
}
fn DropEffect(&self) -> DOMString {
self.drop_effect.borrow().clone()
}
fn SetDropEffect(&self, value: DOMString) {
if VALID_DROP_EFFECTS.contains(&value.as_ref()) {
*self.drop_effect.borrow_mut() = value;
}
}
fn EffectAllowed(&self) -> DOMString {
self.effect_allowed.borrow().clone()
}
fn SetEffectAllowed(&self, value: DOMString) {
if self
.data_store
.borrow()
.as_ref()
.is_some_and(|data_store| data_store.mode() == Mode::ReadWrite) &&
VALID_EFFECTS_ALLOWED.contains(&value.as_ref())
{
*self.drop_effect.borrow_mut() = value;
}
}
fn Items(&self) -> DomRoot<DataTransferItemList> {
DomRoot::from_ref(&self.items)
}
fn SetDragImage(&self, image: &Element, x: i32, y: i32) {
let mut option = self.data_store.borrow_mut();
let data_store = match option.as_mut() {
Some(value) => value,
None => return,
};
if data_store.mode() != Mode::ReadWrite {
return;
}
if let Some(image) = image.downcast::<HTMLImageElement>() {
data_store.set_bitmap(image.image_data(), x, y);
}
}
fn Types(&self, cx: JSContext, can_gc: CanGc, retval: MutableHandleValue) {
self.items.frozen_types(cx, retval, can_gc);
}
fn GetData(&self, mut format: DOMString) -> DOMString {
let option = self.data_store.borrow();
let data_store = match option.as_ref() {
Some(value) => value,
None => return DOMString::new(),
};
if data_store.mode() == Mode::Protected {
return DOMString::new();
}
format.make_ascii_lowercase();
let mut convert_to_url = false;
let type_ = match format.as_ref() {
"text" => DOMString::from("text/plain"),
"url" => {
convert_to_url = true;
DOMString::from("text/uri-list")
},
_ => format,
};
let data = data_store.find_matching_text(&type_);
if let Some(result) = data {
if convert_to_url {
}
result
} else {
DOMString::new()
}
}
fn SetData(&self, format: DOMString, data: DOMString) {
let mut option = self.data_store.borrow_mut();
let data_store = match option.as_mut() {
Some(value) => value,
None => return,
};
if data_store.mode() != Mode::ReadWrite {
return;
}
data_store.set_data(format, data);
self.items.invalidate_frozen_types();
}
fn ClearData(&self, format: Option<DOMString>) {
let mut option = self.data_store.borrow_mut();
let data_store = match option.as_mut() {
Some(value) => value,
None => return,
};
if data_store.mode() != Mode::ReadWrite {
return;
}
if data_store.clear_data(format) {
self.items.invalidate_frozen_types();
}
}
fn Files(&self, can_gc: CanGc) -> DomRoot<FileList> {
let mut files = Vec::new();
if let Some(data_store) = self.data_store.borrow().as_ref() {
data_store.files(&self.global(), can_gc, &mut files);
}
FileList::new(self.global().as_window(), files, can_gc)
}
}