text:
class Layout::SketchUpModel < Layout::Entity

  # Constants

  BOTTOM_RELATIVE_VIEW = nil # Stub value.
  BOTTOM_VIEW = nil # Stub value.

  BACK_VIEW = nil # Stub value.

  CUSTOM_VIEW = nil # Stub value.

  FRONT_VIEW = nil # Stub value.

  HYBRID_RENDER = nil # Stub value.

  ISO_VIEW = nil # Stub value.

  LEFT_VIEW = nil # Stub value.

  RASTER_RENDER = nil # Stub value.

  RIGHT_VIEW = nil # Stub value.

  TOP_RELATIVE_VIEW = nil # Stub value.
  TOP_VIEW = nil # Stub value.

  VECTOR_RENDER = nil # Stub value.

  # Instance Methods

  # The {#camera_modified?} method returns whether the camera of the
  # {Layout::SketchUpModel} has been modified.
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   modified = model.camera_modified?
  #
  # @return [Boolean]
  #
  # @version LayOut 2020.1
  def camera_modified?
  end

  # The {#clip_mask} method returns the clip mask entity for the
  # {Layout::SketchUpModel}, or +nil+ if it does not have one. clip_mask can be a
  # {Layout::Rectangle}, {Layout::Ellipse}, or {Layout::Path}.
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   clip_mask = model.clip_mask
  #
  # @return [Layout::Entity]
  #
  # @version LayOut 2018
  def clip_mask
  end

  # The {#clip_mask=} method sets a clip mask for the {Layout::SketchUpModel}.
  # clip_mask can be a {Layout::Rectangle}, {Layout::Ellipse}, or {Layout::Path},
  # or +nil+, and it must not currently exist in a {Layout::Document},
  # or {Layout::Group}.
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   rect = Layout::Rectangle.new([[2, 2], [3, 3]]);
  #   model.clip_mask = rect
  #
  # @note +clip_mask+ may be +nil+ as of LayOut 2020.1.
  #
  # @param [Layout::Entity, nil] clip_mask
  #   The clip mask can be a {Layout::Path},
  #   {Layout::Rectangle}, {Layout::Ellipse}, or +nil+.
  #
  # @raise [ArgumentError] if clip_mask is already in a {Layout::Document} or
  #   {Layout::Group}
  #
  # @raise [ArgumentError] if clip_mask is not a {Layout::Rectangle},
  #   {Layout::Ellipse}, or {Layout::Path}
  #
  # @raise [LockedLayerError] if the {Layout::SketchUpModel} is on a locked
  #   {Layout::Layer}
  #
  # @raise [LockedEntityError] if the {Layout::SketchUpModel} is locked
  #
  # @version LayOut 2018
  def clip_mask=(clip_mask)
  end

  # The {#current_scene} method returns the index of the most recently
  # selected scene of the {Layout::SketchUpModel}.
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   scene_index = model.current_scene
  #
  # @raise [ArgumentError] if the most recently selected scene no longer exists
  #
  # @return [Integer]
  #
  # @version LayOut 2018
  def current_scene
  end

  # The {#current_scene=} method sets the scene of the {Layout::SketchUpModel}.
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   model.current_scene = 1
  #
  # @note LayOut automatically adds the scene "Last Saved SketchUp View" to each
  #   {Layout::SketchUpModel}. This means that the {Sketchup::Model}'s scenes
  #   start with index 1.
  #
  # @param [Integer] index
  #   The index into the list of available scenes.
  #
  # @raise [IndexError] if index is out of range
  #
  # @raise [LockedLayerError] if the {Layout::SketchUpModel} is on a locked
  #   {Layout::Layer}
  #
  # @raise [LockedEntityError] if the {Layout::SketchUpModel} is locked
  #
  # @version LayOut 2018
  def current_scene=(index)
  end

  # The {#current_scene_modified?} method returns whether the most recently
  # selected scene of the {Layout::SketchUpModel} has been modified.
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   modified = model.current_scene_modified?
  #
  # @raise [ArgumentError] if the most recently selected scene no longer exists
  #
  # @return [Boolean]
  #
  # @version LayOut 2018
  def current_scene_modified?
  end

  # The {#dash_scale} method returns the dash scale for the
  # {Layout::SketchUpModel}. A scale value of 0.0 means the dashes are scaled
  # based on the line weight.
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   dash_scale = model.dash_scale
  #
  # @return [Float]
  #
  # @version LayOut 2019
  def dash_scale
  end

  # The {#dash_scale=} method sets the dash scale for the {Layout::SketchUpModel}.
  # A scale value of 0.0 or lower will "auto" scale the dashes based on the line
  # weight.
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   model.dash_scale = 2.5
  #
  # @param [Float] dash_scale
  #
  # @raise [LockedLayerError] if the {Layout::SketchUpModel} is on a locked
  #   {Layout::Layer}
  #
  # @raise [LockedEntityError] if the {Layout::SketchUpModel} is locked
  #
  # @version LayOut 2018
  def dash_scale=(dash_scale)
  end

  # The {#display_background=} method sets whether the background is displayed
  # for the {Layout::SketchUpModel}.
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   model.display_background = false
  #
  # @param [Boolean] display
  #
  # @raise [LockedLayerError] if the {Layout::SketchUpModel} is on a locked
  #   {Layout::Layer}
  #
  # @raise [LockedEntityError] if the {Layout::SketchUpModel} is locked
  #
  # @version LayOut 2018
  def display_background=(display)
  end

  # The {#display_background?} method returns whether the background is displayed
  # for the {Layout::SketchUpModel}.
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   displayed = model.display_background?
  #
  # @return [Boolean]
  #
  # @version LayOut 2018
  def display_background?
  end

  # The {#effects_modified?} method returns whether the shadow or fog settings
  # of the {Layout::SketchUpModel} have been modified.
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   modified = model.effects_modified?
  #
  # @return [Boolean]
  #
  # @version LayOut 2020.1
  def effects_modified?
  end

  # The {#entities} method returns the {Layout::Group} that represents the
  # {Layout::SketchUpModel} in its exploded form. The {Layout::Group} will
  # contain a {Layout::Image} for raster and hybrid-rendered models, and
  # will contain a {Layout::Group} of LayOut entities for
  # vector and hybrid-rendered models.
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   entities = model.entities
  #
  # @return [Layout::Entity]
  #
  # @version LayOut 2018
  def entities
  end

  # The {#initialize} method creates a new {Layout::SketchUpModel}.
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #
  # @param [String] path
  #   The path to a .skp file
  #
  # @param [Geom::Bounds2d] bounds
  #
  # @raise [ArgumentError] if path does not point to a valid SketchUp Model file
  #
  # @raise [ArgumentError] if bounds is zero size
  #
  # @return [Layout::SketchUpModel]
  #
  # @version LayOut 2018
  def initialize(path, bounds)
  end

  # The {#layers_modified?} method returns whether the layers of the
  # {Layout::SketchUpModel} has been modified.
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   modified = model.layers_modified?
  #
  # @note In SketchUp 2020, SketchUp "layers" were renamed to "tags". For
  #   consistency with the SketchUp API, this will continue to refer to
  #   "tags" as "layers".
  #
  # @return [Boolean]
  #
  # @version LayOut 2020.1
  def layers_modified?
  end

  # The {#line_weight} method returns the line weight for the
  # {Layout::SketchUpModel}.
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   line_weight = model.line_weight
  #
  # @return [Float]
  #
  # @version LayOut 2018
  def line_weight
  end

  # The {#line_weight=} method sets the line weight for the
  # {Layout::SketchUpModel}. Line weight must be at least 0.01.
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   model.line_weight = 2.5
  #
  # @param [Float] line_weight
  #
  # @raise [ArgumentError] if line_weight is less than 0.01
  #
  # @raise [LockedLayerError] if the {Layout::SketchUpModel} is on a locked
  #   {Layout::Layer}
  #
  # @raise [LockedEntityError] if the {Layout::SketchUpModel} is locked
  #
  # @version LayOut 2018
  def line_weight=(line_weight)
  end

  # The {#model_to_paper_point} method converts the {Geom::Point3d} in the
  # {Layout::SketchUpModel} to a {Geom::Point2d} in paper space.
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   point_3d = [200, 100, 100]
  #   point_2d = model.model_to_paper_point(point_3d)
  #
  # @param [Geom::Point3d] model_point
  #
  # @return [Geom::Point2d]
  #
  # @version LayOut 2018
  def model_to_paper_point(model_point)
  end

  # The {#perspective=} method sets whether the {Layout::SketchUpModel}'s view
  # is perspective or orthographic.
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   model.perspective = false
  #
  # @param [Boolean] perspective
  #
  # @raise [LockedLayerError] if the {Layout::SketchUpModel} is on a locked
  #   {Layout::Layer}
  #
  # @raise [LockedEntityError] if the {Layout::SketchUpModel} is locked
  #
  # @version LayOut 2018
  def perspective=(perspective)
  end

  # The {#perspective?} method returns whether the {Layout::SketchUpModel}'s view
  # is perspective or orthographic.
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   perspective = model.perspective?
  #
  # @return [Boolean]
  #
  # @version LayOut 2018
  def perspective?
  end

  # The {#preserve_scale_on_resize=} method sets whether the scale is preserved
  # when the {Layout::SketchUpModel} is resized.
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   model.preserve_scale_on_resize = true
  #
  # @param [Boolean] preserve_scale
  #
  # @raise [LockedLayerError] if the {Layout::SketchUpModel} is on a locked
  #   {Layout::Layer}
  #
  # @raise [LockedEntityError] if the {Layout::SketchUpModel} is locked
  #
  # @version LayOut 2018
  def preserve_scale_on_resize=(preserve_scale)
  end

  # The {#preserve_scale_on_resize?} method returns whether the scale is
  # preserved when the {Layout::SketchUpModel} is resized.
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   will_scale = model.preserve_scale_on_resize?
  #
  # @return [Boolean]
  #
  # @version LayOut 2018
  def preserve_scale_on_resize?
  end

  # The {#render} method renders the {Layout::SketchUpModel}. If the model
  # belongs to a {Layout::Document}, then the render will be performed at the
  # quality set in document.page_info (see {Layout::Document} and
  # {Layout::PageInfo}). Otherwise, the render will be performed at Low quality.
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   model.render if model.render_needed?
  #
  # @raise [LockedLayerError] if the {Layout::SketchUpModel} is on a locked
  #   {Layout::Layer}
  #
  # @raise [LockedEntityError] if the {Layout::SketchUpModel} is locked
  #
  # @version LayOut 2018
  def render
  end

  # The {#render_mode} method returns the render mode of the
  # {Layout::SketchUpModel}.
  #
  # The render mode can be one of the following:
  # [+Layout::SketchUpModel::RASTER_RENDER+]
  # [+Layout::SketchUpModel::HYBRID_RENDER+]
  # [+Layout::SketchUpModel::VECTOR_RENDER+]
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   render_mode = model.render_mode
  #
  # @return [Integer]
  #
  # @version LayOut 2018
  def render_mode
  end

  # The {#render_mode=} method sets the render mode of the
  # {Layout::SketchUpModel}.
  #
  # The render mode can be one of the following:
  # [+Layout::SketchUpModel::RASTER_RENDER+]
  # [+Layout::SketchUpModel::HYBRID_RENDER+]
  # [+Layout::SketchUpModel::VECTOR_RENDER+]
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   model.render_mode = Layout::SketchUpModel::RASTER_RENDER
  #
  # @param [Integer] render_mode
  #
  # @raise [ArgumentError] if render_mode is not a valid render mode
  #
  # @raise [LockedLayertError] if the {Layout::SketchUpModel} is on a locked
  #   {Layout::Layer}
  #
  # @raise [LockedEntityError] if the {Layout::SketchUpModel} is locked
  #
  # @version LayOut 2018
  def render_mode=(render_mode)
  end

  # The {#render_needed?} method returns whether the {Layout::SketchUpModel}
  # needs to be rendered.
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   model.render if model.render_needed?
  #
  # @return [Boolean]
  #
  # @version LayOut 2018
  def render_needed?
  end

  # The {#reset_camera} method resets the {Layout::SketchUpModel}'s camera to
  # the scene's setting.
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   model.reset_camera if model.camera_modified?
  #
  # @raise [LockedLayerError] if the {Layout::SketchUpModel} is on a locked
  #   {Layout::Layer}
  #
  # @raise [LockedEntityError] if the {Layout::SketchUpModel} is locked
  #
  # @version LayOut 2020.1
  def reset_camera
  end

  # The {#reset_effects} method resets the {Layout::SketchUpModel}'s shadow and
  # fog settings to the scene's settings.
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   model.reset_effects if model.effects_modified?
  #
  # @raise [LockedLayerError] if the {Layout::SketchUpModel} is on a locked
  #   {Layout::Layer}
  #
  # @raise [LockedEntityError] if the {Layout::SketchUpModel} is locked
  #
  # @version LayOut 2020.1
  def reset_effects
  end

  # The {#reset_layers} method resets the {Layout::SketchUpModel}'s layers to
  # the scene's setting.
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   model.reset_layers if model.layers_modified?
  #
  # @note In SketchUp 2020, SketchUp "layers" were renamed to "tags". For
  #   consistency with the SketchUp API, this will continue to refer to
  #   "tags" as "layers".
  #
  # @raise [LockedLayerError] if the {Layout::SketchUpModel} is on a locked
  #   {Layout::Layer}
  #
  # @raise [LockedEntityError] if the {Layout::SketchUpModel} is locked
  #
  # @version LayOut 2020.1
  def reset_layers
  end

  # The {#reset_style} method resets the {Layout::SketchUpModel}'s style to
  # the scene's setting.
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   model.reset_style if model.style_modified?
  #
  # @raise [LockedLayerError] if the {Layout::SketchUpModel} is on a locked
  #   {Layout::Layer}
  #
  # @raise [LockedEntityError] if the {Layout::SketchUpModel} is locked
  #
  # @version LayOut 2020.1
  def reset_style
  end

  # The {#scale} method returns the scale of the {Layout::SketchUpModel}.
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   scale = model.scale
  #
  # @return [Float]
  #
  # @version LayOut 2018
  def scale
  end

  # The {#scale=} method sets the scale of the {Layout::SketchUpModel}. Scale
  # must be at least 0.0000001, and the view must be orthographic.
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   model.scale = 2.0
  #
  # @param [Float] scale
  #
  # @raise [ArgumentError] if the {Layout::SketchUpModel} view is not orthographic
  #
  # @raise [ArgumentError] if scale is less than 0.0000001
  #
  # @raise [LockedLayerError] if the {Layout::SketchUpModel} is on a locked
  #   {Layout::Layer}
  #
  # @raise [LockedEntityError] if the {Layout::SketchUpModel} is locked
  #
  # @version LayOut 2018
  def scale=(scale)
  end

  # The {#scenes} method returns an array of scene names that are available
  # for the {Layout::SketchUpModel}. The first scene will always be the default
  # scene, called "Last saved SketchUp View".
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   scene_names = model.scenes
  #
  # @return [Array<String>]
  #
  # @version LayOut 2018
  def scenes
  end

  # The {#style_modified?} method returns whether the style of the
  # {Layout::SketchUpModel} has been modified.
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   modified = model.style_modified?
  #
  # @return [Boolean]
  #
  # @version LayOut 2020.1
  def style_modified?
  end

  # The {#view} method returns the standard view of the {Layout::SketchUpModel}.
  #
  # The standard view can be one of the following values:
  # [+Layout::SketchUpModel::CUSTOM_VIEW+]
  # [+Layout::SketchUpModel::TOP_VIEW+]
  # [+Layout::SketchUpModel::TOP_RELATIVE_VIEW+]
  # [+Layout::SketchUpModel::BOTTOM_VIEW+]
  # [+Layout::SketchUpModel::BOTTOM_RELATIVE_VIEW+]
  # [+Layout::SketchUpModel::FRONT_VIEW+]
  # [+Layout::SketchUpModel::BACK_VIEW+]
  # [+Layout::SketchUpModel::LEFT_VIEW+]
  # [+Layout::SketchUpModel::RIGHT_VIEW+]
  # [+Layout::SketchUpModel::ISO_VIEW+]
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   view = model.view
  #
  # @return [Integer]
  #
  # @version LayOut 2018
  def view
  end

  # The {#view=} method sets the standard view of the {Layout::SketchUpModel}.
  #
  # The standard view can be one of the following values:
  # [+Layout::SketchUpModel::TOP_VIEW+]
  # [+Layout::SketchUpModel::TOP_RELATIVE_VIEW+]
  # [+Layout::SketchUpModel::BOTTOM_VIEW+]
  # [+Layout::SketchUpModel::BOTTOM_RELATIVE_VIEW+]
  # [+Layout::SketchUpModel::FRONT_VIEW+]
  # [+Layout::SketchUpModel::BACK_VIEW+]
  # [+Layout::SketchUpModel::LEFT_VIEW+]
  # [+Layout::SketchUpModel::RIGHT_VIEW+]
  # [+Layout::SketchUpModel::ISO_VIEW+]
  #
  # @example
  #   bounds = Geom::Bounds2d.new(1, 1, 3, 3)
  #   model = Layout::SketchUpModel.new("C:/Path/to/model.skp", bounds)
  #   model.view = Layout::SketchUpModel::FRONT_VIEW
  #
  # @param [Integer] view
  #
  # @raise [ArgumentError] if view is not a valid standard view
  #
  # @raise [LockedLayerError] if the {Layout::SketchUpModel} is on a locked
  #   {Layout::Layer}
  #
  # @raise [LockedEntityError] if the {Layout::SketchUpModel} is locked
  #
  # @version LayOut 2018
  def view=(view)
  end

end


text:
package org.dotwebstack.framework.core.query.model;

import lombok.Builder;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NonNull;

@Builder
@Getter
@EqualsAndHashCode
public class ContextFieldCriteria {
  @NonNull
  private final String field;

  @NonNull
  private final Object value;
}

redpajama_set_name: RedPajamaGithub


text:
// Copyright (c) 2014 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.

/**
 * @fileoverview Enable developer features screen implementation.
 */

/* #js_imports_placeholder */

/**
 * Possible UI states of the enable debugging screen.
 * These values must be kept in sync with EnableDebuggingScreenHandler::UIState
 * in C++ code and the order of the enum must be the same.
 * @enum {string}
 */
const EnableDebuggingState = {
  ERROR: 'error',
  NONE: 'none',
  REMOVE_PROTECTION: 'remove-protection',
  SETUP: 'setup',
  WAIT: 'wait',
  DONE: 'done',
};

/**
 * @constructor
 * @extends {PolymerElement}
 * @implements {LoginScreenBehaviorInterface}
 * @implements {MultiStepBehaviorInterface}
 */
 const EnableDebuggingBase = Polymer.mixinBehaviors(
  [OobeI18nBehavior, LoginScreenBehavior, MultiStepBehavior],
  Polymer.Element);

/**
 * @typedef {{
 *   removeProtectionProceedButton:  OobeTextButtonElement,
 *   password:  CrInputElement,
 *   okButton:  OobeTextButtonElement,
 *   errorOkButton: OobeTextButtonElement
 * }}
 */
 EnableDebuggingBase.$;

/**
 * @polymer
 */
class EnableDebugging extends EnableDebuggingBase {

  static get is() { return 'enable-debugging-element'; }

  /* #html_template_placeholder */

  get EXTERNAL_API() {
    return ['updateState'];
  }

  static get properties() {
    return {
      /**
       * Current value of password input field.
       */
      password_: {type: String, value: ''},

      /**
       * Current value of repeat password input field.
       */
      passwordRepeat_: {type: String, value: ''},

      /**
       * Whether password input fields are matching.
       */
      passwordsMatch_: {
        type: Boolean,
        computed: 'computePasswordsMatch_(password_, passwordRepeat_)',
      },
    };
  }

  ready() {
    super.ready();
    this.initializeLoginScreen('EnableDebuggingScreen', {
      resetAllowed: false,
    });
  }

  defaultUIStep() {
    return EnableDebuggingState.NONE;
  }

  get UI_STEPS() {
    return EnableDebuggingState;
  }

  /**
   * Returns a control which should receive an initial focus.
   */
  get defaultControl() {
    if (this.uiStep == EnableDebuggingState.REMOVE_PROTECTION)
      return this.$.removeProtectionProceedButton;
    else if (this.uiStep == EnableDebuggingState.SETUP)
      return this.$.password;
    else if (this.uiStep == EnableDebuggingState.DONE)
      return this.$.okButton;
    else if (this.uiStep == EnableDebuggingState.ERROR)
      return this.$.errorOkButton;
    else
      return null;
  }

  /**
   * Cancels the enable debugging screen and drops the user back to the
   * network settings.
   */
  cancel() {
    this.userActed('cancel');
  }

  /**
   * Update UI for corresponding state of the screen.
   * @param {number} state
   */
  updateState(state) {
    // Use `state + 1` as index to locate the corresponding EnableDebuggingState
    this.setUIStep(Object.values(EnableDebuggingState)[state + 1]);

    if (this.defaultControl)
      this.defaultControl.focus();
  }

  computePasswordsMatch_(password, password2) {
    return (password.length == 0 && password2.length == 0) ||
        (password == password2 && password.length >= 4);
  }

  onHelpLinkClicked_() {
    this.userActed('learnMore');
  }

  onRemoveButtonClicked_() {
    this.userActed('removeRootFSProtection');
  }

  onEnableButtonClicked_() {
    chrome.send('enableDebuggingOnSetup', [this.password_]);
    this.password_ = '';
    this.passwordRepeat_ = '';
  }

  onOKButtonClicked_() {
    this.userActed('done');
  }
}

customElements.define(EnableDebugging.is, EnableDebugging);


text:
using UnityEngine;
using System.Collections;
using RAIN.Action;
using RAIN.Core;

public class ForgetAboutSpottedAspects : MonoBehaviour
{
	AIRig ai;

	// Use this for initialization
	void Start ()
	{
		ai = GetComponent<AIRig> ();
	}

	// Update is called once per frame
	void Update ()
	{

	}
}


text:
FROM jenserat/samba-publicshare
MAINTAINER Frank Pommerening "frank@pommerening-online.de"
ENV REFRESHED_AT 2016-02-09
COPY smb.conf /etc/samba/smb.conf
ADD setup.sh /setup.sh
RUN /setup.sh


text:
package availability

import (
	"net/http"

	"github.com/ghmeier/go-mixmax/client"
	"github.com/ghmeier/go-mixmax/models"
	"github.com/ghmeier/go-service"
)

type Client struct {
	*client.Client
}

func New(c *client.Client) *Client {
	return &Client{
		Client: &client.Client{
			Key: c.Key,
			S:   c.S.Copy("availability"),
		},
	}
}

func (c *Client) List() (*models.Availabilities, error) {
	var res models.Availabilities
	err := c.S.Send(&service.Request{Method: http.MethodGet}, &res)

	if err != nil {
		return nil, err
	}

	return &res, nil
}

func (c *Client) Get(id string) (*models.Availability, error) {
	var res models.Availability
	err := c.S.Copy(id).Send(&service.Request{
		Method: http.MethodGet,
	}, &res)

	if err != nil {
		return nil, err
	}

	return &res, nil
}


text:
class PrisonerStep
  include MemoryModel
  include Person

  attribute :processor, :steps_processor

  attribute :first_name, :string
  attribute :last_name, :string
  attribute :date_of_birth, :uncoerced_date
  attribute :number, :string
  attribute :prison_id, :string

  validates :number, prisoner_number: true
  validates :prison_id, presence: true

  validate :validate_prisoner

  delegate :name, to: :prison, prefix: true

  I18N_SCOPE = %i[ activemodel errors models prisoner_step api ]

  def prison
    # Memoize to avoid multiple API lookups
    @prison ||= prison_id.present? ? Prison.find_by_id(prison_id) : nil
  end

  def options_available?
    false
  end

  def prisoner_attributes
    {
      first_name: first_name,
      last_name: last_name,
      date_of_birth: date_of_birth.to_date,
      number: number
    }
  end

private

  def validate_prisoner
    return if prevent_api_call?
    return if prisoner_valid?

    describe_errors
  rescue PrisonVisits::APIError => e
    Rails.logger.error e.message
  end

  def prisoner_valid?
    prisoner_validation_results.fetch('valid')
  end

  def describe_errors
    error_nomatch = 'prisoner_does_not_exist'
    if prisoner_validation_results.fetch('errors').include?(error_nomatch)
      errors.add :number, I18n.t(error_nomatch, scope: I18N_SCOPE)
      errors.add :date_of_birth, I18n.t(error_nomatch, scope: I18N_SCOPE)
    end
  end

  def prisoner_validation_results
    options = { number: number, date_of_birth: date_of_birth.to_date }
    @prisoner_validation_results ||= PrisonVisits::Api.instance.validate_prisoner(options)
  end

  def prevent_api_call?
    # If date_of_birth of number are invalid, there's no need to call the API
    errors[:date_of_birth].any? || errors[:number].any?
  end
end


text:
/*
 * Copyright (C) 1995-96   Silicon Graphics, Inc.
 *
 _______________________________________________________________________
 ______________  S I L I C O N   G R A P H I C S   I N C .  ____________
 |
 |   Classes:
 |	SoLODV2
 |
 |   Authors: David Mott
 |
 ______________  S I L I C O N   G R A P H I C S   I N C .  ____________
 _______________________________________________________________________
 */

#include <math.h>
#include <float.h>
#include <Inventor/nodes/SoLevelOfDetail.h>
#include <Inventor/actions/SoGetMatrixAction.h>
#include <Inventor/actions/SoGetBoundingBoxAction.h>
#include <Inventor/actions/SoWriteAction.h>
#include "SoLODV2.h"

SO_NODE_SOURCE(SoLODV2);

////////////////////////////////////////////////////////////////////////
//
// Description:
//    init that class!
//
void
SoLODV2::initClass()
//
////////////////////////////////////////////////////////////////////////
{
    SO__NODE_INIT_CLASS(SoLODV2, "LOD", SoLOD);

    // Tell the type system whenever it wants to create something
    // of type SoLOD to create a SoLODV2
    SoType::overrideType(
		 SoLOD::getClassTypeId(), &SoLODV2::createInstance);
}

////////////////////////////////////////////////////////////////////////
//
// Description:
//    Constructor
//
SoLODV2::SoLODV2()
//
////////////////////////////////////////////////////////////////////////
{
    SO_NODE_CONSTRUCTOR(SoLODV2);
    SO_NODE_ADD_FIELD(alternateRep, (NULL));
}

////////////////////////////////////////////////////////////////////////
//
// Description:
//    Destructor
//
SoLODV2::~SoLODV2()
//
////////////////////////////////////////////////////////////////////////
{

}

////////////////////////////////////////////////////////////////////////
//
// Description:
//    write the alternate rep for this node
//
void
SoLODV2::write(SoWriteAction *action)
//
////////////////////////////////////////////////////////////////////////
{
    SoOutput	*out = action->getOutput();

    // In write-reference counting phase
    if (out->getStage() == SoOutput::COUNT_REFS) {
	// Only do this once!
	if (alternateRep.isDefault()) {
	    SoLevelOfDetail *levelOfDetail = new SoLevelOfDetail;
	    alternateRep = levelOfDetail;

	    // All LOD children become LevelOfDetail children
	    int j;
	    for (j=0; j < getNumChildren(); j++)
		levelOfDetail->addChild(getChild(j));

	    // We don't need children here any more - they are in the alternateRep
	    removeAllChildren();

	    // Convert the LOD ranges to LevelOfDetail screen areas
	    // We reverse the process of ivToVRML's convertLevelOfDetailToLOD():

	    // Assuming a screen height and width of 1024 and a 45 degree field
	    // of view, the formula for converting a screenArea to a distance
	    // is:
	    //
	    //                       (1024 / 2) * worldBboxRadius
	    //     distance = ______________________________________
	    //
	    //                 tan( 45 / 2) * sqrt(screenArea / PI)
	    //

	    // So, converting distance to screenArea is:
	    //
	    //		(1024/2) * worldBboxRadius
	    //	f = --------------------------------
	    //		tan( 45 / 2 ) * distance
	    //
	    //
	    //	screenArea = f^2 * PI
	    //

	    const SoPath *path = action->getCurPath();

	    // get the matrix
	    SoGetMatrixAction matAction(SbViewportRegion(1024, 1024));

	    matAction.apply((SoPath *) path); // const cast away!

	    SbMatrix toWorld = matAction.getMatrix();

	    // transform the bbox to world space
	    SoGetBoundingBoxAction bba(SbViewportRegion(100, 100));
	    bba.apply(levelOfDetail);
	    SbBox3f bbox = bba.getBoundingBox();

	    bbox.transform(toWorld);

	    float w,h,d;
	    bbox.getSize(w,h,d);

	    w *= 0.5;
	    h *= 0.5;
	    d *= 0.5;

	    float radius = sqrt(w*w + h*h + d*d);

	    // empirically, half the radius seems to work better
	    radius *= 0.5;

	    float distance, newScreenArea;
	    float tanHalf45 = tan((0.5 * 45.0 / 180.0) * M_PI);

	    for (j=0; j < range.getNum(); j++) {
		distance = range[j];
		if (distance != 0.0) {
		    newScreenArea = 512.0 * radius / (tanHalf45 * distance);
		    newScreenArea = newScreenArea * newScreenArea * M_PI;
		} else {
		    newScreenArea = FLT_MAX;
		}
		levelOfDetail->screenArea.set1Value(j, newScreenArea);
	    }
	}
    }

    SoLOD::write(action);
}