/* 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/. */

#ifndef mozilla_ServoStyleConsts_h

#define mozilla_ServoStyleConsts_h

/* Generated with cbindgen:0.6.2 */

/* DO NOT MODIFY THIS MANUALLY! This file was generated using cbindgen.

 * To generate this file:

 *   1. Get the latest cbindgen using `cargo install --force cbindgen`

 *      a. Alternatively, you can clone `https://github.com/eqrion/cbindgen` and use a tagged release

 *   2. Run `rustup run nightly cbindgen toolkit/library/rust/ --lockfile Cargo.lock --crate style -o layout/style/ServoStyleConsts.h`

 */

#include <cstdint>

#include <cstdlib>

namespace mozilla {

// The value for the `appearance` property.

//

// https://developer.mozilla.org/en-US/docs/Web/CSS/-moz-appearance

//

// NOTE(emilio): When changing this you may want to regenerate the C++ bindings

// (see components/style/cbindgen.toml)

enum class StyleAppearance : uint8_t {

  // No appearance at all.

  None,

  // A typical dialog button.

  Button,

  // Various arrows that go in buttons

  ButtonArrowDown,

  ButtonArrowNext,

  ButtonArrowPrevious,

  ButtonArrowUp,

  // A rectangular button that contains complex content

  // like images (e.g. HTML <button> elements)

  ButtonBevel,

  // The focus outline box inside of a button.

  ButtonFocus,

  // The caret of a text area

  Caret,

  // A dual toolbar button (e.g., a Back button with a dropdown)

  Dualbutton,

  // A groupbox.

  Groupbox,

  // A inner-spin button.

  InnerSpinButton,

  // List boxes.

  Listbox,

  // A listbox item.

  Listitem,

  // Menu Bar background

  Menubar,

  // <menu> and <menuitem> appearances

  Menuitem,

  Checkmenuitem,

  Radiomenuitem,

  // For text on non-iconic menuitems only

  Menuitemtext,

  // A dropdown list.

  Menulist,

  // The dropdown button(s) that open up a dropdown list.

  MenulistButton,

  // The text part of a dropdown list, to left of button.

  MenulistText,

  // An editable textfield with a dropdown list (a combobox).

  MenulistTextfield,

  // Menu Popup background.

  Menupopup,

  // menu checkbox/radio appearances

  Menucheckbox,

  Menuradio,

  Menuseparator,

  Menuarrow,

  // An image in the menu gutter, like in bookmarks or history.

  Menuimage,

  // A horizontal meter bar.

  Meterbar,

  // The meter bar's meter indicator.

  Meterchunk,

  // The "arrowed" part of the dropdown button that open up a dropdown list.

  MozMenulistButton,

  // For HTML's <input type=number>

  NumberInput,

  // A horizontal progress bar.

  Progressbar,

  // The progress bar's progress indicator

  Progresschunk,

  // A vertical progress bar.

  ProgressbarVertical,

  // A vertical progress chunk.

  ProgresschunkVertical,

  // A checkbox element.

  Checkbox,

  // A radio element within a radio group.

  Radio,

  // A generic container that always repaints on state changes. This is a

  // hack to make XUL checkboxes and radio buttons work.

  CheckboxContainer,

  RadioContainer,

  // The label part of a checkbox or radio button, used for painting a focus

  // outline.

  CheckboxLabel,

  RadioLabel,

  // nsRangeFrame and its subparts

  Range,

  RangeThumb,

  // The resizer background area in a status bar for the resizer widget in

  // the corner of a window.

  Resizerpanel,

  // The resizer itself.

  Resizer,

  // A slider.

  ScaleHorizontal,

  ScaleVertical,

  // A slider's thumb.

  ScalethumbHorizontal,

  ScalethumbVertical,

  // If the platform supports it, the left/right chunks of the slider thumb.

  Scalethumbstart,

  Scalethumbend,

  // The ticks for a slider.

  Scalethumbtick,

  // A scrollbar.

  Scrollbar,

  // A small scrollbar.

  ScrollbarSmall,

  // The scrollbar slider

  ScrollbarHorizontal,

  ScrollbarVertical,

  // A scrollbar button (up/down/left/right).

  // Keep these in order (some code casts these values to `int` in order to

  // compare them against each other).

  ScrollbarbuttonUp,

  ScrollbarbuttonDown,

  ScrollbarbuttonLeft,

  ScrollbarbuttonRight,

  // The scrollbar thumb.

  ScrollbarthumbHorizontal,

  ScrollbarthumbVertical,

  // The scrollbar track.

  ScrollbartrackHorizontal,

  ScrollbartrackVertical,

  // The scroll corner

  Scrollcorner,

  // A searchfield.

  Searchfield,

  // A separator.  Can be horizontal or vertical.

  Separator,

  // A spin control (up/down control for time/date pickers).

  Spinner,

  // The up button of a spin control.

  SpinnerUpbutton,

  // The down button of a spin control.

  SpinnerDownbutton,

  // The textfield of a spin control

  SpinnerTextfield,

  // A splitter.  Can be horizontal or vertical.

  Splitter,

  // A status bar in a main application window.

  Statusbar,

  // A single pane of a status bar.

  Statusbarpanel,

  // A single tab in a tab widget.

  Tab,

  // A single pane (inside the tabpanels container).

  Tabpanel,

  // The tab panels container.

  Tabpanels,

  // The tabs scroll arrows (left/right).

  TabScrollArrowBack,

  TabScrollArrowForward,

  // A textfield or text area.

  Textfield,

  // A multiline text field.

  TextfieldMultiline,

  // A toolbar in an application window.

  Toolbar,

  // A single toolbar button (with no associated dropdown).

  Toolbarbutton,

  // The dropdown portion of a toolbar button

  ToolbarbuttonDropdown,

  // The gripper for a toolbar.

  Toolbargripper,

  // The toolbox that contains the toolbars.

  Toolbox,

  // A tooltip.

  Tooltip,

  // A listbox or tree widget header

  Treeheader,

  // An individual header cell

  Treeheadercell,

  // The sort arrow for a header.

  Treeheadersortarrow,

  // A tree item.

  Treeitem,

  // A tree widget branch line

  Treeline,

  // A tree widget twisty.

  Treetwisty,

  // Open tree widget twisty.

  Treetwistyopen,

  // A tree widget.

  Treeview,

  // Window and dialog backgrounds.

  Window,

  Dialog,

  // Vista Rebars.

  MozWinCommunicationsToolbox,

  MozWinMediaToolbox,

  MozWinBrowsertabbarToolbox,

  // Vista glass.

  MozWinGlass,

  MozWinBorderlessGlass,

  // -moz-apperance style used in setting proper glass margins.

  MozWinExcludeGlass,

  // Titlebar elements on the Mac.

  MozMacFullscreenButton,

  // Mac help button.

  MozMacHelpButton,

  // Windows themed window frame elements.

  MozWindowButtonBox,

  MozWindowButtonBoxMaximized,

  MozWindowButtonClose,

  MozWindowButtonMaximize,

  MozWindowButtonMinimize,

  MozWindowButtonRestore,

  MozWindowFrameBottom,

  MozWindowFrameLeft,

  MozWindowFrameRight,

  MozWindowTitlebar,

  MozWindowTitlebarMaximized,

  MozGtkInfoBar,

  MozMacActiveSourceListSelection,

  MozMacDisclosureButtonClosed,

  MozMacDisclosureButtonOpen,

  MozMacSourceList,

  MozMacSourceListSelection,

  MozMacVibrancyDark,

  MozMacVibrancyLight,

  MozMacVibrantTitlebarDark,

  MozMacVibrantTitlebarLight,

  // A non-disappearing scrollbar.

  ScrollbarNonDisappearing,

  // A themed focus outline (for outline:auto).

  //

  // This isn't exposed to CSS at all, just here for convenience.

  FocusOutline,

  // A dummy variant that should be last to let the GTK widget do hackery.

  Count,

};

// Defines an element’s display type, which consists of

// the two basic qualities of how an element generates boxes

// <https://drafts.csswg.org/css-display/#propdef-display>

//

//

// NOTE(emilio): Order is important in Gecko!

//

// If you change it, make sure to take a look at the

// FrameConstructionDataByDisplay stuff (both the XUL and non-XUL version), and

// ensure it's still correct!

//

// Also, when you change this from Gecko you may need to regenerate the

// C++-side bindings (see components/style/cbindgen.toml).

enum class StyleDisplay : uint8_t {

  None = 0,

  Block,

  FlowRoot,

  Inline,

  InlineBlock,

  ListItem,

  Table,

  InlineTable,

  TableRowGroup,

  TableColumn,

  TableColumnGroup,

  TableHeaderGroup,

  TableFooterGroup,

  TableRow,

  TableCell,

  TableCaption,

  Flex,

  InlineFlex,

  Grid,

  InlineGrid,

  Ruby,

  RubyBase,

  RubyBaseContainer,

  RubyText,

  RubyTextContainer,

  Contents,

  WebkitBox,

  WebkitInlineBox,

  MozBox,

  MozInlineBox,

  MozGrid,

  MozInlineGrid,

  MozGridGroup,

  MozGridLine,

  MozStack,

  MozInlineStack,

  MozDeck,

  MozGroupbox,

  MozPopup,

};

// Values for the display-mode media feature.

enum class StyleDisplayMode : uint8_t {

  Browser = 0,

  MinimalUi,

  Standalone,

  Fullscreen,

};

enum class StyleFillRule : uint8_t {

  Nonzero,

  Evenodd,

};

// The path command absolute type.

enum class StyleIsAbsolute : uint8_t {

  Yes,

  No,

};

// A CSS float value.

using StyleCSSFloat = float;

// The path coord type.

struct StyleCoordPair {

  StyleCSSFloat _0;

  StyleCSSFloat _1;

  bool operator==(const StyleCoordPair& other) const {

    return _0 == other._0 &&

           _1 == other._1;

  }

};

// The EllipticalArc flag type.

struct StyleArcFlag {

  bool _0;

  bool operator==(const StyleArcFlag& other) const {

    return _0 == other._0;

  }

};

// The SVG path command.

// The fields of these commands are self-explanatory, so we skip the documents.

// Note: the index of the control points, e.g. control1, control2, are mapping to the control

// points of the Bézier curve in the spec.

//

// https://www.w3.org/TR/SVG11/paths.html#PathData

struct StylePathCommand {

  enum class Tag : uint8_t {

    // The unknown type.

    // https://www.w3.org/TR/SVG/paths.html#__svg__SVGPathSeg__PATHSEG_UNKNOWN

    Unknown,

    // The "moveto" command.

    MoveTo,

    // The "lineto" command.

    LineTo,

    // The horizontal "lineto" command.

    HorizontalLineTo,

    // The vertical "lineto" command.

    VerticalLineTo,

    // The cubic Bézier curve command.

    CurveTo,

    // The smooth curve command.

    SmoothCurveTo,

    // The quadratic Bézier curve command.

    QuadBezierCurveTo,

    // The smooth quadratic Bézier curve command.

    SmoothQuadBezierCurveTo,

    // The elliptical arc curve command.

    EllipticalArc,

    // The "closepath" command.

    ClosePath,

  };

  struct StyleMoveTo_Body {

    StyleCoordPair point;

    StyleIsAbsolute absolute;

    bool operator==(const StyleMoveTo_Body& other) const {

      return point == other.point &&

             absolute == other.absolute;

    }

  };

  struct StyleLineTo_Body {

    StyleCoordPair point;

    StyleIsAbsolute absolute;

    bool operator==(const StyleLineTo_Body& other) const {

      return point == other.point &&

             absolute == other.absolute;

    }

  };

  struct StyleHorizontalLineTo_Body {

    StyleCSSFloat x;

    StyleIsAbsolute absolute;

    bool operator==(const StyleHorizontalLineTo_Body& other) const {

      return x == other.x &&

             absolute == other.absolute;

    }

  };

  struct StyleVerticalLineTo_Body {

    StyleCSSFloat y;

    StyleIsAbsolute absolute;

    bool operator==(const StyleVerticalLineTo_Body& other) const {

      return y == other.y &&

             absolute == other.absolute;

    }

  };

  struct StyleCurveTo_Body {

    StyleCoordPair control1;

    StyleCoordPair control2;

    StyleCoordPair point;

    StyleIsAbsolute absolute;

    bool operator==(const StyleCurveTo_Body& other) const {

      return control1 == other.control1 &&

             control2 == other.control2 &&

             point == other.point &&

             absolute == other.absolute;

    }

  };

  struct StyleSmoothCurveTo_Body {

    StyleCoordPair control2;

    StyleCoordPair point;

    StyleIsAbsolute absolute;

    bool operator==(const StyleSmoothCurveTo_Body& other) const {

      return control2 == other.control2 &&

             point == other.point &&

             absolute == other.absolute;

    }

  };

  struct StyleQuadBezierCurveTo_Body {

    StyleCoordPair control1;

    StyleCoordPair point;

    StyleIsAbsolute absolute;

    bool operator==(const StyleQuadBezierCurveTo_Body& other) const {

      return control1 == other.control1 &&

             point == other.point &&

             absolute == other.absolute;

    }

  };

  struct StyleSmoothQuadBezierCurveTo_Body {

    StyleCoordPair point;

    StyleIsAbsolute absolute;

    bool operator==(const StyleSmoothQuadBezierCurveTo_Body& other) const {

      return point == other.point &&

             absolute == other.absolute;

    }

  };

  struct StyleEllipticalArc_Body {

    StyleCSSFloat rx;

    StyleCSSFloat ry;

    StyleCSSFloat angle;

    StyleArcFlag large_arc_flag;

    StyleArcFlag sweep_flag;

    StyleCoordPair point;

    StyleIsAbsolute absolute;

    bool operator==(const StyleEllipticalArc_Body& other) const {

      return rx == other.rx &&

             ry == other.ry &&

             angle == other.angle &&

             large_arc_flag == other.large_arc_flag &&

             sweep_flag == other.sweep_flag &&

             point == other.point &&

             absolute == other.absolute;

    }

  };

  Tag tag;

  union {

    StyleMoveTo_Body move_to;

    StyleLineTo_Body line_to;

    StyleHorizontalLineTo_Body horizontal_line_to;

    StyleVerticalLineTo_Body vertical_line_to;

    StyleCurveTo_Body curve_to;

    StyleSmoothCurveTo_Body smooth_curve_to;

    StyleQuadBezierCurveTo_Body quad_bezier_curve_to;

    StyleSmoothQuadBezierCurveTo_Body smooth_quad_bezier_curve_to;

    StyleEllipticalArc_Body elliptical_arc;

  };

  static StylePathCommand Unknown() {

    StylePathCommand result;

    result.tag = Tag::Unknown;

    return result;

  }

  static StylePathCommand MoveTo(StyleCoordPair const& aPoint,

                                 StyleIsAbsolute const& aAbsolute) {

    StylePathCommand result;

    result.move_to.point = aPoint;

    result.move_to.absolute = aAbsolute;

    result.tag = Tag::MoveTo;

    return result;

  }

  static StylePathCommand LineTo(StyleCoordPair const& aPoint,

                                 StyleIsAbsolute const& aAbsolute) {

    StylePathCommand result;

    result.line_to.point = aPoint;

    result.line_to.absolute = aAbsolute;

    result.tag = Tag::LineTo;

    return result;

  }

  static StylePathCommand HorizontalLineTo(StyleCSSFloat const& aX,

                                           StyleIsAbsolute const& aAbsolute) {

    StylePathCommand result;

    result.horizontal_line_to.x = aX;

    result.horizontal_line_to.absolute = aAbsolute;

    result.tag = Tag::HorizontalLineTo;

    return result;

  }

  static StylePathCommand VerticalLineTo(StyleCSSFloat const& aY,

                                         StyleIsAbsolute const& aAbsolute) {

    StylePathCommand result;

    result.vertical_line_to.y = aY;

    result.vertical_line_to.absolute = aAbsolute;

    result.tag = Tag::VerticalLineTo;

    return result;

  }

  static StylePathCommand CurveTo(StyleCoordPair const& aControl1,

                                  StyleCoordPair const& aControl2,

                                  StyleCoordPair const& aPoint,

                                  StyleIsAbsolute const& aAbsolute) {

    StylePathCommand result;

    result.curve_to.control1 = aControl1;

    result.curve_to.control2 = aControl2;

    result.curve_to.point = aPoint;

    result.curve_to.absolute = aAbsolute;

    result.tag = Tag::CurveTo;

    return result;

  }

  static StylePathCommand SmoothCurveTo(StyleCoordPair const& aControl2,

                                        StyleCoordPair const& aPoint,

                                        StyleIsAbsolute const& aAbsolute) {

    StylePathCommand result;

    result.smooth_curve_to.control2 = aControl2;

    result.smooth_curve_to.point = aPoint;

    result.smooth_curve_to.absolute = aAbsolute;

    result.tag = Tag::SmoothCurveTo;

    return result;

  }

  static StylePathCommand QuadBezierCurveTo(StyleCoordPair const& aControl1,

                                            StyleCoordPair const& aPoint,

                                            StyleIsAbsolute const& aAbsolute) {

    StylePathCommand result;

    result.quad_bezier_curve_to.control1 = aControl1;

    result.quad_bezier_curve_to.point = aPoint;

    result.quad_bezier_curve_to.absolute = aAbsolute;

    result.tag = Tag::QuadBezierCurveTo;

    return result;

  }

  static StylePathCommand SmoothQuadBezierCurveTo(StyleCoordPair const& aPoint,

                                                  StyleIsAbsolute const& aAbsolute) {

    StylePathCommand result;

    result.smooth_quad_bezier_curve_to.point = aPoint;

    result.smooth_quad_bezier_curve_to.absolute = aAbsolute;

    result.tag = Tag::SmoothQuadBezierCurveTo;

    return result;

  }

  static StylePathCommand EllipticalArc(StyleCSSFloat const& aRx,

                                        StyleCSSFloat const& aRy,

                                        StyleCSSFloat const& aAngle,

                                        StyleArcFlag const& aLargeArcFlag,

                                        StyleArcFlag const& aSweepFlag,

                                        StyleCoordPair const& aPoint,

                                        StyleIsAbsolute const& aAbsolute) {

    StylePathCommand result;

    result.elliptical_arc.rx = aRx;

    result.elliptical_arc.ry = aRy;

    result.elliptical_arc.angle = aAngle;

    result.elliptical_arc.large_arc_flag = aLargeArcFlag;

    result.elliptical_arc.sweep_flag = aSweepFlag;

    result.elliptical_arc.point = aPoint;

    result.elliptical_arc.absolute = aAbsolute;

    result.tag = Tag::EllipticalArc;

    return result;

  }

  static StylePathCommand ClosePath() {

    StylePathCommand result;

    result.tag = Tag::ClosePath;

    return result;

  }

  bool IsUnknown() const {

    return tag == Tag::Unknown;

  }

  bool IsMoveTo() const {

    return tag == Tag::MoveTo;

  }

  bool IsLineTo() const {

    return tag == Tag::LineTo;

  }

  bool IsHorizontalLineTo() const {

    return tag == Tag::HorizontalLineTo;

  }

  bool IsVerticalLineTo() const {

    return tag == Tag::VerticalLineTo;

  }

  bool IsCurveTo() const {

    return tag == Tag::CurveTo;

  }

  bool IsSmoothCurveTo() const {

    return tag == Tag::SmoothCurveTo;

  }

  bool IsQuadBezierCurveTo() const {

    return tag == Tag::QuadBezierCurveTo;

  }

  bool IsSmoothQuadBezierCurveTo() const {

    return tag == Tag::SmoothQuadBezierCurveTo;

  }

  bool IsEllipticalArc() const {

    return tag == Tag::EllipticalArc;

  }

  bool IsClosePath() const {

    return tag == Tag::ClosePath;

  }

  bool operator==(const StylePathCommand& other) const {

    if (tag != other.tag) {

      return false;

    }

    switch (tag) {

      case Tag::MoveTo: return move_to == other.move_to;

      case Tag::LineTo: return line_to == other.line_to;

      case Tag::HorizontalLineTo: return horizontal_line_to == other.horizontal_line_to;

      case Tag::VerticalLineTo: return vertical_line_to == other.vertical_line_to;

      case Tag::CurveTo: return curve_to == other.curve_to;

      case Tag::SmoothCurveTo: return smooth_curve_to == other.smooth_curve_to;

      case Tag::QuadBezierCurveTo: return quad_bezier_curve_to == other.quad_bezier_curve_to;

      case Tag::SmoothQuadBezierCurveTo: return smooth_quad_bezier_curve_to == other.smooth_quad_bezier_curve_to;

      case Tag::EllipticalArc: return elliptical_arc == other.elliptical_arc;

      default: return true;

    }

  }

};

} // namespace mozilla

#endif // mozilla_ServoStyleConsts_h