mirror of
https://github.com/mii443/vrclipboard-ime-gui.git
synced 2025-08-22 16:15:32 +00:00
328 lines
9.8 KiB
JavaScript
328 lines
9.8 KiB
JavaScript
import { SERIALIZE_TO_IPC_FN } from './core.js';
|
|
|
|
// Copyright 2019-2024 Tauri Programme within The Commons Conservancy
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
// SPDX-License-Identifier: MIT
|
|
/**
|
|
* A size represented in logical pixels.
|
|
*
|
|
* @since 2.0.0
|
|
*/
|
|
class LogicalSize {
|
|
constructor(...args) {
|
|
this.type = 'Logical';
|
|
if (args.length === 1) {
|
|
if ('Logical' in args[0]) {
|
|
this.width = args[0].Logical.width;
|
|
this.height = args[0].Logical.height;
|
|
}
|
|
else {
|
|
this.width = args[0].width;
|
|
this.height = args[0].height;
|
|
}
|
|
}
|
|
else {
|
|
this.width = args[0];
|
|
this.height = args[1];
|
|
}
|
|
}
|
|
/**
|
|
* Converts the logical size to a physical one.
|
|
* @example
|
|
* ```typescript
|
|
* import { LogicalSize } from '@tauri-apps/api/dpi';
|
|
* import { getCurrentWindow } from '@tauri-apps/api/window';
|
|
*
|
|
* const appWindow = getCurrentWindow();
|
|
* const factor = await appWindow.scaleFactor();
|
|
* const size = new LogicalSize(400, 500);
|
|
* const physical = size.toPhysical(factor);
|
|
* ```
|
|
*
|
|
* @since 2.0.0
|
|
*/
|
|
toPhysical(scaleFactor) {
|
|
return new PhysicalSize(this.width * scaleFactor, this.height * scaleFactor);
|
|
}
|
|
[SERIALIZE_TO_IPC_FN]() {
|
|
return {
|
|
width: this.width,
|
|
height: this.height
|
|
};
|
|
}
|
|
toJSON() {
|
|
// eslint-disable-next-line security/detect-object-injection
|
|
return this[SERIALIZE_TO_IPC_FN]();
|
|
}
|
|
}
|
|
/**
|
|
* A size represented in physical pixels.
|
|
*
|
|
* @since 2.0.0
|
|
*/
|
|
class PhysicalSize {
|
|
constructor(...args) {
|
|
this.type = 'Physical';
|
|
if (args.length === 1) {
|
|
if ('Physical' in args[0]) {
|
|
this.width = args[0].Physical.width;
|
|
this.height = args[0].Physical.height;
|
|
}
|
|
else {
|
|
this.width = args[0].width;
|
|
this.height = args[0].height;
|
|
}
|
|
}
|
|
else {
|
|
this.width = args[0];
|
|
this.height = args[1];
|
|
}
|
|
}
|
|
/**
|
|
* Converts the physical size to a logical one.
|
|
* @example
|
|
* ```typescript
|
|
* import { getCurrentWindow } from '@tauri-apps/api/window';
|
|
* const appWindow = getCurrentWindow();
|
|
* const factor = await appWindow.scaleFactor();
|
|
* const size = await appWindow.innerSize(); // PhysicalSize
|
|
* const logical = size.toLogical(factor);
|
|
* ```
|
|
*/
|
|
toLogical(scaleFactor) {
|
|
return new LogicalSize(this.width / scaleFactor, this.height / scaleFactor);
|
|
}
|
|
[SERIALIZE_TO_IPC_FN]() {
|
|
return {
|
|
width: this.width,
|
|
height: this.height
|
|
};
|
|
}
|
|
toJSON() {
|
|
// eslint-disable-next-line security/detect-object-injection
|
|
return this[SERIALIZE_TO_IPC_FN]();
|
|
}
|
|
}
|
|
/**
|
|
* A size represented either in physical or in logical pixels.
|
|
*
|
|
* This type is basically a union type of {@linkcode LogicalSize} and {@linkcode PhysicalSize}
|
|
* but comes in handy when using `tauri::Size` in Rust as an argument to a command, as this class
|
|
* automatically serializes into a valid format so it can be deserialized correctly into `tauri::Size`
|
|
*
|
|
* So instead of
|
|
* ```typescript
|
|
* import { invoke } from '@tauri-apps/api/core';
|
|
* import { LogicalSize, PhysicalSize } from '@tauri-apps/api/dpi';
|
|
*
|
|
* const size: LogicalSize | PhysicalSize = someFunction(); // where someFunction returns either LogicalSize or PhysicalSize
|
|
* const validSize = size instanceof LogicalSize
|
|
* ? { Logical: { width: size.width, height: size.height } }
|
|
* : { Physical: { width: size.width, height: size.height } }
|
|
* await invoke("do_something_with_size", { size: validSize });
|
|
* ```
|
|
*
|
|
* You can just use {@linkcode Size}
|
|
* ```typescript
|
|
* import { invoke } from '@tauri-apps/api/core';
|
|
* import { LogicalSize, PhysicalSize, Size } from '@tauri-apps/api/dpi';
|
|
*
|
|
* const size: LogicalSize | PhysicalSize = someFunction(); // where someFunction returns either LogicalSize or PhysicalSize
|
|
* const validSize = new Size(size);
|
|
* await invoke("do_something_with_size", { size: validSize });
|
|
* ```
|
|
*
|
|
* @since 2.1.0
|
|
*/
|
|
class Size {
|
|
constructor(size) {
|
|
this.size = size;
|
|
}
|
|
toLogical(scaleFactor) {
|
|
return this.size instanceof LogicalSize
|
|
? this.size
|
|
: this.size.toLogical(scaleFactor);
|
|
}
|
|
toPhysical(scaleFactor) {
|
|
return this.size instanceof PhysicalSize
|
|
? this.size
|
|
: this.size.toPhysical(scaleFactor);
|
|
}
|
|
[SERIALIZE_TO_IPC_FN]() {
|
|
return {
|
|
[`${this.size.type}`]: {
|
|
width: this.size.width,
|
|
height: this.size.height
|
|
}
|
|
};
|
|
}
|
|
toJSON() {
|
|
// eslint-disable-next-line security/detect-object-injection
|
|
return this[SERIALIZE_TO_IPC_FN]();
|
|
}
|
|
}
|
|
/**
|
|
* A position represented in logical pixels.
|
|
*
|
|
* @since 2.0.0
|
|
*/
|
|
class LogicalPosition {
|
|
constructor(...args) {
|
|
this.type = 'Logical';
|
|
if (args.length === 1) {
|
|
if ('Logical' in args[0]) {
|
|
this.x = args[0].Logical.x;
|
|
this.y = args[0].Logical.y;
|
|
}
|
|
else {
|
|
this.x = args[0].x;
|
|
this.y = args[0].y;
|
|
}
|
|
}
|
|
else {
|
|
this.x = args[0];
|
|
this.y = args[1];
|
|
}
|
|
}
|
|
/**
|
|
* Converts the logical position to a physical one.
|
|
* @example
|
|
* ```typescript
|
|
* import { LogicalPosition } from '@tauri-apps/api/dpi';
|
|
* import { getCurrentWindow } from '@tauri-apps/api/window';
|
|
*
|
|
* const appWindow = getCurrentWindow();
|
|
* const factor = await appWindow.scaleFactor();
|
|
* const position = new LogicalPosition(400, 500);
|
|
* const physical = position.toPhysical(factor);
|
|
* ```
|
|
*
|
|
* @since 2.0.0
|
|
*/
|
|
toPhysical(scaleFactor) {
|
|
return new PhysicalPosition(this.x * scaleFactor, this.y * scaleFactor);
|
|
}
|
|
[SERIALIZE_TO_IPC_FN]() {
|
|
return {
|
|
x: this.x,
|
|
y: this.y
|
|
};
|
|
}
|
|
toJSON() {
|
|
// eslint-disable-next-line security/detect-object-injection
|
|
return this[SERIALIZE_TO_IPC_FN]();
|
|
}
|
|
}
|
|
/**
|
|
* A position represented in physical pixels.
|
|
*
|
|
* @since 2.0.0
|
|
*/
|
|
class PhysicalPosition {
|
|
constructor(...args) {
|
|
this.type = 'Physical';
|
|
if (args.length === 1) {
|
|
if ('Physical' in args[0]) {
|
|
this.x = args[0].Physical.x;
|
|
this.y = args[0].Physical.y;
|
|
}
|
|
else {
|
|
this.x = args[0].x;
|
|
this.y = args[0].y;
|
|
}
|
|
}
|
|
else {
|
|
this.x = args[0];
|
|
this.y = args[1];
|
|
}
|
|
}
|
|
/**
|
|
* Converts the physical position to a logical one.
|
|
* @example
|
|
* ```typescript
|
|
* import { PhysicalPosition } from '@tauri-apps/api/dpi';
|
|
* import { getCurrentWindow } from '@tauri-apps/api/window';
|
|
*
|
|
* const appWindow = getCurrentWindow();
|
|
* const factor = await appWindow.scaleFactor();
|
|
* const position = new PhysicalPosition(400, 500);
|
|
* const physical = position.toLogical(factor);
|
|
* ```
|
|
*
|
|
* @since 2.0.0
|
|
*/
|
|
toLogical(scaleFactor) {
|
|
return new LogicalPosition(this.x / scaleFactor, this.y / scaleFactor);
|
|
}
|
|
[SERIALIZE_TO_IPC_FN]() {
|
|
return {
|
|
x: this.x,
|
|
y: this.y
|
|
};
|
|
}
|
|
toJSON() {
|
|
// eslint-disable-next-line security/detect-object-injection
|
|
return this[SERIALIZE_TO_IPC_FN]();
|
|
}
|
|
}
|
|
/**
|
|
* A position represented either in physical or in logical pixels.
|
|
*
|
|
* This type is basically a union type of {@linkcode LogicalSize} and {@linkcode PhysicalSize}
|
|
* but comes in handy when using `tauri::Position` in Rust as an argument to a command, as this class
|
|
* automatically serializes into a valid format so it can be deserialized correctly into `tauri::Position`
|
|
*
|
|
* So instead of
|
|
* ```typescript
|
|
* import { invoke } from '@tauri-apps/api/core';
|
|
* import { LogicalPosition, PhysicalPosition } from '@tauri-apps/api/dpi';
|
|
*
|
|
* const position: LogicalPosition | PhysicalPosition = someFunction(); // where someFunction returns either LogicalPosition or PhysicalPosition
|
|
* const validPosition = position instanceof LogicalPosition
|
|
* ? { Logical: { x: position.x, y: position.y } }
|
|
* : { Physical: { x: position.x, y: position.y } }
|
|
* await invoke("do_something_with_position", { position: validPosition });
|
|
* ```
|
|
*
|
|
* You can just use {@linkcode Position}
|
|
* ```typescript
|
|
* import { invoke } from '@tauri-apps/api/core';
|
|
* import { LogicalPosition, PhysicalPosition, Position } from '@tauri-apps/api/dpi';
|
|
*
|
|
* const position: LogicalPosition | PhysicalPosition = someFunction(); // where someFunction returns either LogicalPosition or PhysicalPosition
|
|
* const validPosition = new Position(position);
|
|
* await invoke("do_something_with_position", { position: validPosition });
|
|
* ```
|
|
*
|
|
* @since 2.1.0
|
|
*/
|
|
class Position {
|
|
constructor(position) {
|
|
this.position = position;
|
|
}
|
|
toLogical(scaleFactor) {
|
|
return this.position instanceof LogicalPosition
|
|
? this.position
|
|
: this.position.toLogical(scaleFactor);
|
|
}
|
|
toPhysical(scaleFactor) {
|
|
return this.position instanceof PhysicalPosition
|
|
? this.position
|
|
: this.position.toPhysical(scaleFactor);
|
|
}
|
|
[SERIALIZE_TO_IPC_FN]() {
|
|
return {
|
|
[`${this.position.type}`]: {
|
|
x: this.position.x,
|
|
y: this.position.y
|
|
}
|
|
};
|
|
}
|
|
toJSON() {
|
|
// eslint-disable-next-line security/detect-object-injection
|
|
return this[SERIALIZE_TO_IPC_FN]();
|
|
}
|
|
}
|
|
|
|
export { LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize, Position, Size };
|