gecko/gfx/layers/ipc/LayersMessages.ipdlh

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 * vim: sw=2 ts=8 et :
 */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

include LayersSurfaces;
include protocol PCompositable;
include protocol PCompositor;
include protocol PGrallocBuffer;
include protocol PLayer;
include protocol PRenderFrame;
include protocol PTexture;

include "gfxipc/ShadowLayerUtils.h";
include "mozilla/GfxMessageUtils.h";
include "ImageLayers.h";

using mozilla::GraphicsFilterType from "mozilla/GfxMessageUtils.h";
using struct gfxRGBA from "gfxColor.h";
using struct gfxPoint3D from "gfxPoint3D.h";
using class mozilla::gfx::Matrix4x4 from "mozilla/gfx/Matrix.h";
using class gfx3DMatrix from "gfx3DMatrix.h";
using nscoord from "nsCoord.h";
using struct nsIntPoint from "nsPoint.h";
using struct nsRect from "nsRect.h";
using struct nsPoint from "nsPoint.h";
using class mozilla::TimeDuration from "mozilla/TimeStamp.h";
using class mozilla::TimeStamp from "mozilla/TimeStamp.h";
using mozilla::ScreenRotation from "mozilla/WidgetUtils.h";
using nsCSSProperty from "nsCSSProperty.h";
using mozilla::dom::ScreenOrientation from "mozilla/dom/ScreenOrientation.h";
using struct mozilla::layers::TextureInfo from "mozilla/layers/CompositorTypes.h";
using mozilla::LayerMargin from "Units.h";
using mozilla::LayerPoint from "Units.h";
using mozilla::LayerRect from "Units.h";
using mozilla::layers::ScaleMode from "mozilla/layers/LayersTypes.h";
using mozilla::layers::EventRegions from "mozilla/layers/LayersTypes.h";
using mozilla::layers::DiagnosticTypes from "mozilla/layers/CompositorTypes.h";
using struct mozilla::layers::FrameMetrics from "FrameMetrics.h";

namespace mozilla {
namespace layers {

struct TargetConfig {
  nsIntRect naturalBounds;
  ScreenRotation rotation;
  nsIntRect clientBounds;
  ScreenOrientation orientation;
};

// Create a shadow layer for |layer|
struct OpCreateThebesLayer     { PLayer layer; };
struct OpCreateContainerLayer  { PLayer layer; };
struct OpCreateImageLayer      { PLayer layer; };
struct OpCreateColorLayer      { PLayer layer; };
struct OpCreateCanvasLayer     { PLayer layer; };
struct OpCreateRefLayer        { PLayer layer; };

struct OpAttachCompositable {
  PLayer layer;
  PCompositable compositable;
};

struct OpAttachAsyncCompositable {
  PLayer layer;
  uint64_t containerID;
};

struct ThebesBufferData {
  nsIntRect rect;
  nsIntPoint rotation;
};

struct CubicBezierFunction {
  float x1;
  float y1;
  float x2;
  float y2;
};

struct StepFunction {
  int steps;
  // 1 = nsTimingFunction::StepStart, 2 = nsTimingFunction::StepEnd
  int type;
};

union TimingFunction {
  CubicBezierFunction;
  StepFunction;
};

struct LayerColor { gfxRGBA value; };
struct Perspective { float value; };
struct RotationX { float radians; };
struct RotationY { float radians; };
struct RotationZ { float radians; };
struct Rotation { float radians; };
struct Rotation3D {
  float x;
  float y;
  float z;
  float radians;
};
struct Scale {
  float x;
  float y;
  float z;
};
struct Skew { float x; float y; };
struct SkewX { float x; };
struct SkewY { float y; };
struct TransformMatrix { Matrix4x4 value; };
struct Translation {
  float x;
  float y;
  float z;
};

union TransformFunction {
  Perspective;
  RotationX;
  RotationY;
  RotationZ;
  Rotation;
  Rotation3D;
  Scale;
  Skew;
  SkewX;
  SkewY;
  Translation;
  TransformMatrix;
};

union Animatable {
  float;
  TransformFunction[];
};

struct AnimationSegment {
  Animatable startState;
  Animatable endState;
  float startPortion;
  float endPortion;
  TimingFunction sampleFn;
};

// Transforms need extra information to correctly convert the list of transform
// functions to a gfx3DMatrix that can be applied directly to the layer.
struct TransformData {
  // the origin of the frame being transformed in app units
  nsPoint origin;
  // the transform-origin property for the transform in css pixels
  gfxPoint3D transformOrigin;
  // the perspective-origin property for the transform in css pixels
  gfxPoint3D perspectiveOrigin;
  nsRect bounds;
  nscoord perspective;
  int32_t appUnitsPerDevPixel;
};

union AnimationData {
  null_t;
  TransformData;
};

struct Animation {
  // Unlike in nsAnimationManager, this start time is at the end of the
  // delay.  If the delay is changed dynamically, the layer's data will
  // be updated.
  TimeStamp startTime;
  TimeDuration duration;
  // For each frame, the interpolation point is computed based on the
  // startTime, the direction, the duration, and the current time.
  // The segments must uniquely cover the portion from 0.0 to 1.0
  AnimationSegment[] segments;
  // How many times to repeat the animation.  -1 means "forever".
  float numIterations;
  // This uses the NS_STYLE_ANIMATION_DIRECTION_* constants.
  int32_t direction;
  nsCSSProperty property;
  AnimationData data;
};

// Change a layer's attributes
struct CommonLayerAttributes {
  nsIntRegion visibleRegion;
  EventRegions eventRegions;
  TransformMatrix transform;
  float postXScale;
  float postYScale;
  uint32_t contentFlags;
  float opacity;
  bool useClipRect;
  nsIntRect clipRect;
  bool isFixedPosition;
  LayerPoint fixedPositionAnchor;
  LayerMargin fixedPositionMargin;
  bool isStickyPosition;
  uint64_t stickyScrollContainerId;
  LayerRect stickyScrollRangeOuter;
  LayerRect stickyScrollRangeInner;
  uint64_t scrollbarTargetContainerId;
  uint32_t scrollbarDirection;
  nullable PLayer maskLayer;
  // Animated colors will only honored for ColorLayers.
  Animation[] animations;
  nsIntRegion invalidRegion;
};

struct ThebesLayerAttributes {
  nsIntRegion validRegion;
};
struct ContainerLayerAttributes {
  FrameMetrics metrics;
  float preXScale;
  float preYScale;
  float inheritedXScale;
  float inheritedYScale;
};
struct ColorLayerAttributes     { LayerColor color; nsIntRect bounds; };
struct CanvasLayerAttributes    { GraphicsFilterType filter; nsIntRect bounds; };
struct RefLayerAttributes       { int64_t id; };
struct ImageLayerAttributes     { GraphicsFilterType filter; IntSize scaleToSize; ScaleMode scaleMode; };

union SpecificLayerAttributes {
  null_t;
  ThebesLayerAttributes;
  ContainerLayerAttributes;
  ColorLayerAttributes;
  CanvasLayerAttributes;
  RefLayerAttributes;
  ImageLayerAttributes;
};

struct LayerAttributes {
  CommonLayerAttributes common;
  SpecificLayerAttributes specific;
};

struct OpSetLayerAttributes {
  PLayer layer;
  LayerAttributes attrs;
};

// Monkey with the tree structure
struct OpSetRoot          { PLayer root; };
struct OpInsertAfter      { PLayer container; PLayer childLayer; PLayer after; };
struct OpAppendChild      { PLayer container; PLayer childLayer; };
struct OpRemoveChild      { PLayer container; PLayer childLayer; };
struct OpRepositionChild  { PLayer container; PLayer childLayer; PLayer after; };
struct OpRaiseToTopChild  { PLayer container; PLayer childLayer; };

struct OpSetDiagnosticTypes { DiagnosticTypes diagnostics; };

// Paint (buffer update)
struct OpPaintTiledLayerBuffer {
  PCompositable compositable;
  SurfaceDescriptorTiles tileLayerDescriptor;
};

struct OpCreatedTexture {
  PCompositable compositable;
  uint32_t textureId;
  SurfaceDescriptor descriptor;
  TextureInfo textureInfo;
};

struct OpCreatedIncrementalTexture {
  PCompositable compositable;
  TextureInfo textureInfo;
  nsIntRect bufferRect;
};

struct OpDestroyThebesBuffer {
  PCompositable compositable;
};

struct OpPaintTexture {
  PCompositable compositable;
  uint32_t textureId;
  SurfaceDescriptor image;
};

struct OpPaintTextureRegion {
  PCompositable compositable;
  ThebesBufferData bufferData;
  nsIntRegion updatedRegion;
};

struct OpPaintTextureIncremental {
  PCompositable compositable;
  uint32_t textureId;
  SurfaceDescriptor image;
  nsIntRegion updatedRegion;
  nsIntRect bufferRect;
  nsIntPoint bufferRotation;
};

struct OpUpdatePictureRect {
  PCompositable compositable;
  nsIntRect picture;
};

/**
 * Tells the compositor-side which texture to use (for example, as front buffer
 * if there is several textures for double buffering)
 */
struct OpUseTexture {
  PCompositable compositable;
  PTexture texture;
};

union MaybeRegion {
  nsIntRegion;
  null_t;
};

struct OpUpdateTexture {
  PCompositable compositable;
  PTexture texture;
  MaybeRegion region;
};

union CompositableOperation {
  OpUpdatePictureRect;

  OpCreatedTexture;
  OpCreatedIncrementalTexture;
  OpDestroyThebesBuffer;

  OpPaintTexture;
  OpPaintTextureRegion;
  OpPaintTextureIncremental;

  OpPaintTiledLayerBuffer;

  OpUpdateTexture;
  OpUseTexture;
};

// A unit of a changeset; a set of these comprise a changeset
union Edit {
  OpCreateThebesLayer;
  OpCreateContainerLayer;
  OpCreateImageLayer;
  OpCreateColorLayer;
  OpCreateCanvasLayer;
  OpCreateRefLayer;

  OpSetLayerAttributes;
  OpSetDiagnosticTypes;

  OpSetRoot;
  OpInsertAfter;
  OpAppendChild;
  OpRemoveChild;
  OpRepositionChild;
  OpRaiseToTopChild;

  OpAttachCompositable;
  OpAttachAsyncCompositable;

  CompositableOperation;
};


// Replies to operations

struct OpContentBufferSwap {
  PCompositable compositable;
  nsIntRegion frontUpdatedRegion;
};

struct OpTextureSwap {
  PCompositable compositable;
  uint32_t textureId;
  SurfaceDescriptor image;
};

// Unit of a "changeset reply".  This is a weird abstraction, probably
// only to be used for buffer swapping.
union EditReply {
  OpContentBufferSwap;
  OpTextureSwap;
};

} // namespace
} // namespace