Default material blue-grey transparent style for SuperToasts.
@return A new Style
190233
public static Style blueGrey() {
        final Style style = new Style();
        style.color = PaletteUtils.getSolidColor(PaletteUtils.MATERIAL_BLUE_GREY);
        return style;
    }
1374210
public static Style deepOrange() {
        final Style style = new Style();
        style.color = PaletteUtils.getSolidColor(PaletteUtils.MATERIAL_DEEP_ORANGE);
        return style;
    }
153998
public Paint getTopShadowGradient(Shape s) {
        Rectangle2D bounds = s.getBounds2D();
        float       minY   = (float) bounds.getMinY();
        float       maxY   = (float) bounds.getMaxY();
        float       midX   = (float) bounds.getCenterX();

        return new LinearGradientPaint(midX, minY, midX, maxY, (new float[] { 0f, 1f }), new Color[] { innerShadow.top, transparentColor });
    }
793649
public String getStyle() {
        final Object result = getStateHelper().eval(PropertyKeys.style, null);
        if (result == null) {
            return null;
        }
        return result.toString();
    }
422252
protected function makeFilterBlueprint()
    {
        return new Blueprint(self::FILTER_CLASS, [
            new SimpleValueAsField('name'),
            new CustomMapping('type', function ($type, Scaffold $s) {
                switch($type) {
                    case 'select':
                        $s->class = 'Nayjest\Grids\SelectFilterConfig';
                        break;
                    default:
                        break;
                }
            }, null, Instruction::PHASE_PRE_INST),
            new Rename(0,'name'),
            new Rename(1,'operator'),
        ]);
    }
293712
public Img gray() {
		final ColorConvertOp op = new ColorConvertOp(ColorSpace.getInstance(ColorSpace.CS_GRAY), null);
		this.targetImage = op.filter(getValidSrcImg(), null);
		return this;
	}
109757
function() {
            var self = this;
            if(this.isVertical) {
                this.hcConfig = $.extend(true, {}, Splunk.JSCharting.AbstractAxis.DEFAULT_VERT_CONFIG);
            }
            else {
                this.hcConfig = $.extend(true, {}, Splunk.JSCharting.AbstractAxis.DEFAULT_HORIZ_CONFIG);
            }
            // apply the color scheme
            $.extend(true, this.hcConfig, {
                lineColor: this.foregroundColorSoft,
                gridLineColor: this.foregroundColorSofter,
                tickColor: this.foregroundColorSoft,
                minorTickColor: this.foregroundColorSoft,
                title: {
                    style: {
                        color: this.fontColor
                    }
                },
                labels: {
                    style: {
                        color: this.fontColor
                    }
                }
            });
            this.mapper = new Splunk.JSCharting.PropertyMapper(this.hcConfig);
            this.hcConfig.id = this.id;
            this.hcConfig.labels.formatter = function() {
                return self.formatLabel.call(self, this);
            };
        }
929237
public static Style lightGreen() {
        final Style style = new Style();
        style.color = PaletteUtils.getSolidColor(PaletteUtils.MATERIAL_LIGHT_GREEN);
        return style;
    }
249541
function () {
    var data = this.data;
    var hasChangedShader;
    var material = this.material;
    var NewShader;
    var shaderData = this.shaderData;
    var shaderName;

    // Infer shader if using a stock font (or from `-msdf` filename convention).
    shaderName = data.shader;
    if (MSDF_FONTS.indexOf(data.font) !== -1 || data.font.indexOf('-msdf.') >= 0) {
      shaderName = 'msdf';
    } else if (data.font in FONTS && MSDF_FONTS.indexOf(data.font) === -1) {
      shaderName = 'sdf';
    }

    hasChangedShader = (this.shaderObject && this.shaderObject.name) !== shaderName;

    shaderData.alphaTest = data.alphaTest;
    shaderData.color = data.color;
    shaderData.map = this.texture;
    shaderData.opacity = data.opacity;
    shaderData.side = parseSide(data.side);
    shaderData.transparent = data.transparent;
    shaderData.negate = data.negate;

    // Shader has not changed, do an update.
    if (!hasChangedShader) {
      // Update shader material.
      this.shaderObject.update(shaderData);
      // Apparently, was not set on `init` nor `update`.
      material.transparent = shaderData.transparent;
      material.side = shaderData.side;
      return;
    }

    // Shader has changed. Create a shader material.
    NewShader = createShader(this.el, shaderName, shaderData);
    this.material = NewShader.material;
    this.shaderObject = NewShader.shader;

    // Set new shader material.
    this.material.side = shaderData.side;
    if (this.mesh) { this.mesh.material = this.material; }
  }
135830
private Style getStyle() {
        SharedPreferences sharedPreferences =
                PreferenceManager.getDefaultSharedPreferences(getActivity());
        String key = getString(R.string.bottom_sheet_style_preference_key);
        String defaultValue = getString(R.string.bottom_sheet_style_preference_default_value);
        String style = sharedPreferences.getString(key, defaultValue);

        switch (style) {
            case "list":
                return Style.LIST;
            case "list_columns":
                return Style.LIST_COLUMNS;
            default:
                return Style.GRID;
        }
    }
62355
@NonNull
    public IconicsDrawable backgroundColor(@NonNull ColorStateList colors) {
        if (colors != null) {
            boolean isInvalidate = false;

            if (mRoundedCornerRx == -1) {
                mRoundedCornerRx = 0;
                isInvalidate = true;
            }
            if (mRoundedCornerRy == -1) {
                mRoundedCornerRy = 0;
                isInvalidate = true;
            }

            mBackgroundBrush.setColors(colors);
            if (mBackgroundBrush.applyState(getState())) {
                isInvalidate = true;
            }

            if (isInvalidate) {
                invalidateSelf();
            }
        }
        return this;
    }
773368
protected String textureFragmentShader() {
    StringBuilder str = new StringBuilder(FRAGMENT_PREAMBLE);

    str.append(textureUniforms());
    str.append(textureVaryings());

    str.append("void main(void) {\n");

    str.append(textureColor());
    str.append(textureTint());
    str.append(textureAlpha());

    str.append(
      "  gl_FragColor = textureColor;\n" +
      "}");

    return str.toString();
  }
78960
public CellStyleGenerator getDefaultCellStyleGenerator() {

        return new CellStyleGenerator() {

            private static final long serialVersionUID = 1L;

            @SuppressWarnings("synthetic-access")
            public String getStyle(Table source, Object itemId, Object propertyId) {

                for (ColumnBean colBean : m_columns) {
                    if (colBean.getProperty().getName().equals(propertyId)) {
                        return colBean.getInfo().styleName();
                    }
                }
                return "";
            }
        };
    }
1064432
StageStyle getDefaultStyle() {
        final String style = annotation.stageStyle();
        return StageStyle.valueOf(style.toUpperCase());
    }
614144
public CMYKColor getComplementaryColor() {
        double[] rgb = CMYKColor.getRGB(cyan, magenta, yellow, black);
        double[] cmyk = CMYKColor.getCMYK(1.0 - rgb[0], 1.0 - rgb[1], 1.0 - rgb[2]);
        return new CMYKColor(cmyk[0], cmyk[1], cmyk[2], cmyk[3]);
    }
842845
public static String colorHeader() {
        return  Color.BOLD +
                HEADER_L1 + "\n" +
                new Color(Color.YELLOW, Color.UNDERLINE) +
                HEADER_L2 + "    " +
                Color.CLEAR;
    }
411473
private Paint getSliderTrackBorderColors() {
        switch (state) {

        case BACKGROUND_DISABLED:
            return getTextBorderPaint(CommonControlState.DISABLED,false);

        case BACKGROUND_ENABLED:
            return getTextBorderPaint(CommonControlState.ENABLED,false);
        }

        return null;
    }