mirror of
https://github.com/klzgrad/naiveproxy.git
synced 2024-12-01 01:36:09 +03:00
276 lines
10 KiB
Plaintext
276 lines
10 KiB
Plaintext
// Copyright 2018 The Chromium Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
module ash.mojom;
|
|
|
|
import "ui/gfx/geometry/mojo/geometry.mojom";
|
|
import "ui/display/mojo/display.mojom";
|
|
|
|
// All points, bounds, and insets are in display pixels unless otherwise
|
|
// sepcified.
|
|
|
|
// SetDisplayLayoutInfo or SetDisplayProperties result.
|
|
enum DisplayConfigResult {
|
|
kSuccess = 0,
|
|
kInvalidOperationError,
|
|
kInvalidDisplayIdError,
|
|
kUnifiedNotEnabledError,
|
|
kPropertyValueOutOfRangeError,
|
|
kNotSupportedOnInternalDisplayError,
|
|
kNegativeValueError,
|
|
kSetDisplayModeError,
|
|
kInvalidDisplayLayoutError,
|
|
kMirrorModeSingleDisplayError,
|
|
kMirrorModeSourceIdError,
|
|
kMirrorModeDestIdError,
|
|
kCalibrationNotAvailableError,
|
|
kCalibrationNotStartedError,
|
|
kCalibrationInProgressError,
|
|
kCalibrationInvalidDataError,
|
|
kCalibrationFailedError,
|
|
};
|
|
|
|
// Describes how the displays are laid out.
|
|
enum DisplayLayoutMode {
|
|
// In normal mode displays are laid out as described by
|
|
// DisplayLayoutInfo.layouts.
|
|
kNormal = 0,
|
|
// In unified desktop mode, a single desktop will be stretched across all
|
|
// available displays.
|
|
kUnified,
|
|
// In mirrored mode, the display defined by DisplayLayoutInfo.mirrorSourceId
|
|
// will be mirrored in the displays defined by
|
|
// DisplayLayoutInfo.mirrorDestinationIds, or in all other displays if
|
|
// mirrorDestinationIds is empty.
|
|
kMirrored
|
|
};
|
|
|
|
// Describes a display edge.
|
|
enum DisplayLayoutPosition {
|
|
kTop = 0,
|
|
kRight,
|
|
kBottom,
|
|
kLeft
|
|
};
|
|
|
|
// Describes an overscan or touch calibration operation.
|
|
enum DisplayConfigOperation {
|
|
kStart = 0,
|
|
kAdjust,
|
|
kReset,
|
|
kComplete,
|
|
kShowNative,
|
|
};
|
|
|
|
// Defines a pair of display + touch points used for touch calibration.
|
|
struct TouchCalibrationPair {
|
|
// The coordinates of the display point.
|
|
gfx.mojom.Point display_point;
|
|
// The coordinates of the touch point corresponding to the display point.
|
|
gfx.mojom.Point touch_point;
|
|
};
|
|
|
|
// Defines the data required for touch calibration.
|
|
struct TouchCalibration {
|
|
// Must contain exactly four pairs of touch calibration points.
|
|
array<TouchCalibrationPair> pairs;
|
|
// Width and height of the display area when the touch calibration was
|
|
// performed.
|
|
gfx.mojom.Size bounds;
|
|
};
|
|
|
|
// Defines the layout of a single display.
|
|
struct DisplayLayout {
|
|
// The unique identifier of the display.
|
|
string id;
|
|
// The unique identifier of the parent display. Empty for the root display.
|
|
string parent_id;
|
|
// The edge of the display that is shared with the parent display. Ignored for
|
|
// the root display.
|
|
DisplayLayoutPosition position;
|
|
// The offset of the display along the connected edge. 0 indicates that
|
|
// the topmost or leftmost corner is aligned.
|
|
int32 offset;
|
|
};
|
|
|
|
// Defines the layout mode and details.
|
|
struct DisplayLayoutInfo {
|
|
// The layout mode to use, see DisplayLayoutMode for details.
|
|
DisplayLayoutMode layout_mode;
|
|
// Ignored if If layout_mode is not kMirrored. Otherwise, if provided,
|
|
// specifies the unique identifier of the source display for mirroring. If
|
|
// not provided, mirror_destination_ids will be ignored and default ('normal')
|
|
// mirrored mode will be enabled.
|
|
string? mirror_source_id;
|
|
// Ignored if layout_mode is not kMirrored. Otherwise, if provided, specifies
|
|
// the unique identifiers of the displays to mirror the source display. If not
|
|
// provided or empty, all displays will mirror the source display.
|
|
array<string>? mirror_destination_ids;
|
|
// An array of layouts describing a directed graph of displays. Required if
|
|
// layout_mode is kNormal or kMirrored and not all displays are mirrored
|
|
// ('mixed' mode). Ignored if layout_mode is kUnified.
|
|
array<DisplayLayout>? layouts;
|
|
};
|
|
|
|
// EDID extracted parameters. Field description refers to "VESA ENHANCED
|
|
// EXTENDED DISPLAY IDENTIFICATION DATA STANDARD (Defines EDID Structure
|
|
// Version 1, Revision 4)" Release A, Revision 2 September 25, 2006.
|
|
// https://www.vesa.org/vesa-standards
|
|
struct Edid {
|
|
// Three character manufacturer code, Sec. 3.4.1 page 21.
|
|
string manufacturer_id;
|
|
// Two byte manufacturer-assigned code, Sec. 3.4.2 page 21.
|
|
string product_id;
|
|
// Year of manufacture. Sec. 3.4.4 page 22.
|
|
int32 year_of_manufacture;
|
|
};
|
|
|
|
// Struct wrapper so that the property can be optional.
|
|
struct DisplayRotation {
|
|
display.mojom.Rotation rotation;
|
|
};
|
|
|
|
// Defines the properties for a display mode, i.e. a valid size and scale.
|
|
struct DisplayMode {
|
|
// The display mode size in device independent (user visible) pixels.
|
|
gfx.mojom.Size size;
|
|
// The display mode size in native pixels.
|
|
gfx.mojom.Size size_in_native_pixels;
|
|
// The display mode UI scale factor.
|
|
double ui_scale;
|
|
// The display mode device scale factor.
|
|
double device_scale_factor;
|
|
// The display mode refresh rate in hertz.
|
|
double refresh_rate;
|
|
// True if the mode is the display's native mode.
|
|
bool is_native;
|
|
};
|
|
|
|
// Defines the properties of an individual display, returned by
|
|
// GetDisplayLayoutInfo.
|
|
struct DisplayUnitInfo {
|
|
// The unique identifier of the display.
|
|
string id;
|
|
// The user-friendly name (e.g. "Acme LCD monitor").
|
|
string name;
|
|
// EDID properties when available.
|
|
Edid? edid;
|
|
// True if this is the primary display.
|
|
bool is_primary;
|
|
// True if this is an internal display.
|
|
bool is_internal;
|
|
// True if this display is enabled.
|
|
bool is_enabled;
|
|
// True when the display is in tablet mode.
|
|
bool is_tablet_mode;
|
|
// True if this display has a touch input device associated with it.
|
|
bool has_touch_support;
|
|
// True if this display has an accelerometer associated with it.
|
|
bool has_accelerometer_support;
|
|
// The number of pixels per inch along the x-axis.
|
|
double dpi_x;
|
|
// The number of pixels per inch along the y-axis.
|
|
double dpi_y;
|
|
// The display's clockwise rotation.
|
|
display.mojom.Rotation rotation;
|
|
// The display's logical bounds.
|
|
gfx.mojom.Rect bounds;
|
|
// The display's ovserscan insets within its screen's bounds.
|
|
gfx.mojom.Insets overscan;
|
|
// The usable work area of the display within the display bounds. Excludes
|
|
// areas of the display reserved for the OS, e.g. the taskbar and launcher.
|
|
gfx.mojom.Rect work_area;
|
|
// The index of the selected display mode.
|
|
int32 selected_display_mode_index;
|
|
// The list of available display modes.
|
|
array<DisplayMode> available_display_modes;
|
|
// The ratio between the display's current and default zoom. i.e. 1.0 is
|
|
// is equivalent to 100% zoom, and value 1.5 is equivalent to 150% zoom.
|
|
double display_zoom_factor;
|
|
// The list of allowed zoom factor values for the display.
|
|
array<double> available_display_zoom_factors;
|
|
};
|
|
|
|
// Properties for configuring an individual display, used in
|
|
// SetDisplayProperties.
|
|
struct DisplayConfigProperties {
|
|
// If true, makes the display primary. No-op if set to false.
|
|
bool set_primary;
|
|
// If provided, sets the display's overscan insets to the provided value.
|
|
// Note: overscan values may not be negative or larger than a half of the
|
|
// screen's size. Overscan cannot be changed on the internal monitor.
|
|
gfx.mojom.Insets? overscan;
|
|
// If provided updates the display's rotation.
|
|
DisplayRotation? rotation;
|
|
// If provided, updates the display's logical bounds origin. Note: when
|
|
// updating the display origin, some constraints will be applied. so the final
|
|
// bounds origin may be different than the one set. The actual bounds will be
|
|
// reflected in DisplayUnitInfo. Cannot be changed on the primary display (or
|
|
// if set_primary is true).
|
|
gfx.mojom.Point? bounds_origin;
|
|
// If non zero, updates the zoom associated with the display. This zoom
|
|
// performs relayout and repaint thus resulting in a better quality zoom than
|
|
// just performing a pixel by pixel stretch enlargement.
|
|
double display_zoom_factor;
|
|
// Optional DisplayMode properties to set. This should match one of the
|
|
// modes listed in DisplayUnitInfo.available_display_modes. Other custom
|
|
// modes may or may not be valid.
|
|
DisplayMode? display_mode;
|
|
};
|
|
|
|
// Interface for configuring displays in Chrome OS. Currently this is
|
|
// implemented in Ash through classes owned by ash::Shell, but the interface
|
|
// should not have any Ash specific dependencies.
|
|
interface CrosDisplayConfigController {
|
|
// Observers are notified when the display layout or any display properties
|
|
// change.
|
|
AddObserver(associated CrosDisplayConfigObserver observer);
|
|
|
|
// Returns the display layout info, including the list of layouts.
|
|
GetDisplayLayoutInfo() => (DisplayLayoutInfo info);
|
|
|
|
// Sets the layout mode, mirroring, and layouts. Returns kSuccess if the
|
|
// layout is valid or an error value otherwise.
|
|
SetDisplayLayoutInfo(DisplayLayoutInfo info) => (DisplayConfigResult result);
|
|
|
|
// Returns the properties for all displays. If |single_unified| is true, a
|
|
// single display will be returned if the display layout is in unifed mode.
|
|
GetDisplayUnitInfoList(bool single_unified) =>
|
|
(array<DisplayUnitInfo> info_list);
|
|
|
|
// Sets |properties| for individual display with identifier |id|. Returns
|
|
// Success if the properties are valid or an error value otherwise.
|
|
SetDisplayProperties(string id, DisplayConfigProperties properties) =>
|
|
(DisplayConfigResult result);
|
|
|
|
// Enables or disables unified desktop mode. If the current display mode is
|
|
// kMirrored the mode will not be changed, if it is kNormal then the mode will
|
|
// be set to kUnified.
|
|
SetUnifiedDesktopEnabled(bool enabled);
|
|
|
|
// Starts, updates, completes, or resets overscan calibration for the display
|
|
// with identifier |display_id|. If |op| is kAdjust, |delta| describes the
|
|
// amount to change the overscan value. Runs the callback after performing the
|
|
// operation or on error.
|
|
OverscanCalibration(string display_id,
|
|
DisplayConfigOperation op,
|
|
gfx.mojom.Insets? delta) => (DisplayConfigResult result);
|
|
|
|
// Starts, completes, or resets touch calibration for the display with
|
|
// identifier |display_id|. If |op| is kShowNative shows the native
|
|
// calibration UI. Runs the callback after performing the operation or on
|
|
// error.
|
|
TouchCalibration(string display_id,
|
|
DisplayConfigOperation op,
|
|
TouchCalibration? calibration) =>
|
|
(DisplayConfigResult result);
|
|
};
|
|
|
|
// Interface for clients needing to be informed when the display configuration
|
|
// changes.
|
|
interface CrosDisplayConfigObserver {
|
|
// Called any time the display configuration changes.
|
|
OnDisplayConfigChanged();
|
|
};
|