```
#[repr(C, u8)]pub enum GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U> {
Blur(Length),
Brightness(NonNegativeFactor),
Contrast(NonNegativeFactor),
Grayscale(ZeroToOneFactor),
HueRotate(Angle),
Invert(ZeroToOneFactor),
Opacity(ZeroToOneFactor),
Saturate(NonNegativeFactor),
Sepia(ZeroToOneFactor),
DropShadow(Shadow),
Url(U),
}
```

## Expand description

A generic value for a single `filter`

.

## Variants§

### Blur(Length)

`blur(<length>)`

### Brightness(NonNegativeFactor)

`brightness(<factor>)`

### Contrast(NonNegativeFactor)

`contrast(<factor>)`

### Grayscale(ZeroToOneFactor)

`grayscale(<factor>)`

### HueRotate(Angle)

`hue-rotate(<angle>)`

### Invert(ZeroToOneFactor)

`invert(<factor>)`

### Opacity(ZeroToOneFactor)

`opacity(<factor>)`

### Saturate(NonNegativeFactor)

`saturate(<factor>)`

### Sepia(ZeroToOneFactor)

`sepia(<factor>)`

### DropShadow(Shadow)

`drop-shadow(...)`

### Url(U)

`<url>`

## Implementations§

source§### impl GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, NonNegative<Length>, GenericSimpleShadow<Option<Color>, Length, Option<NonNegative<Length>>>, Impossible>

### impl GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, NonNegative<Length>, GenericSimpleShadow<Option<Color>, Length, Option<NonNegative<Length>>>, Impossible>

source#### pub fn to_computed_value_without_context(&self) -> Result<ComputedFilter, ()>

#### pub fn to_computed_value_without_context(&self) -> Result<ComputedFilter, ()>

Generate the ComputedFilter without Context.

## Trait Implementations§

source§### impl<Angle: Clone, NonNegativeFactor: Clone, ZeroToOneFactor: Clone, Length: Clone, Shadow: Clone, U: Clone> Clone for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>

### impl<Angle: Clone, NonNegativeFactor: Clone, ZeroToOneFactor: Clone, Length: Clone, Shadow: Clone, U: Clone> Clone for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>

source§#### fn clone(
&self,
) -> GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>

#### fn clone( &self, ) -> GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>

Returns a copy of the value. Read more

1.0.0 · source§#### fn clone_from(&mut self, source: &Self)

#### fn clone_from(&mut self, source: &Self)

Performs copy-assignment from

`source`

. Read moresource§### impl<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U> ComputeSquaredDistance for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>where
Angle: ComputeSquaredDistance,
NonNegativeFactor: ComputeSquaredDistance,
ZeroToOneFactor: ComputeSquaredDistance,
Length: ComputeSquaredDistance,
Shadow: ComputeSquaredDistance,

### impl<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U> ComputeSquaredDistance for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>where
Angle: ComputeSquaredDistance,
NonNegativeFactor: ComputeSquaredDistance,
ZeroToOneFactor: ComputeSquaredDistance,
Length: ComputeSquaredDistance,
Shadow: ComputeSquaredDistance,

source§#### fn compute_squared_distance(&self, other: &Self) -> Result<SquaredDistance, ()>

#### fn compute_squared_distance(&self, other: &Self) -> Result<SquaredDistance, ()>

Computes the squared distance between two animatable values.

source§### impl<Angle: Debug, NonNegativeFactor: Debug, ZeroToOneFactor: Debug, Length: Debug, Shadow: Debug, U: Debug> Debug for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>

### impl<Angle: Debug, NonNegativeFactor: Debug, ZeroToOneFactor: Debug, Length: Debug, Shadow: Debug, U: Debug> Debug for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>

source§### impl<'de, Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U> Deserialize<'de> for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>where
Angle: Deserialize<'de>,
NonNegativeFactor: Deserialize<'de>,
ZeroToOneFactor: Deserialize<'de>,
Length: Deserialize<'de>,
Shadow: Deserialize<'de>,
U: Deserialize<'de>,

### impl<'de, Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U> Deserialize<'de> for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>where
Angle: Deserialize<'de>,
NonNegativeFactor: Deserialize<'de>,
ZeroToOneFactor: Deserialize<'de>,
Length: Deserialize<'de>,
Shadow: Deserialize<'de>,
U: Deserialize<'de>,

source§#### fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
__D: Deserializer<'de>,

#### fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
__D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more

source§### impl<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U> MallocSizeOf for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>where
Angle: MallocSizeOf,
NonNegativeFactor: MallocSizeOf,
ZeroToOneFactor: MallocSizeOf,
Length: MallocSizeOf,
Shadow: MallocSizeOf,
U: MallocSizeOf,

### impl<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U> MallocSizeOf for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>where
Angle: MallocSizeOf,
NonNegativeFactor: MallocSizeOf,
ZeroToOneFactor: MallocSizeOf,
Length: MallocSizeOf,
Shadow: MallocSizeOf,
U: MallocSizeOf,

source§#### fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize

#### fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize

Measure the heap usage of all descendant heap-allocated structures, but
not the space taken up by the value itself.

source§### impl<Angle: PartialEq, NonNegativeFactor: PartialEq, ZeroToOneFactor: PartialEq, Length: PartialEq, Shadow: PartialEq, U: PartialEq> PartialEq for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>

### impl<Angle: PartialEq, NonNegativeFactor: PartialEq, ZeroToOneFactor: PartialEq, Length: PartialEq, Shadow: PartialEq, U: PartialEq> PartialEq for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>

source§#### fn eq(
&self,
other: &GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>,
) -> bool

#### fn eq( &self, other: &GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>, ) -> bool

This method tests for

`self`

and `other`

values to be equal, and is used
by `==`

.source§### impl<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U> Serialize for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>

### impl<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U> Serialize for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>

source§### impl<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U> SpecifiedValueInfo for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>where
Angle: SpecifiedValueInfo,
NonNegativeFactor: SpecifiedValueInfo,
ZeroToOneFactor: SpecifiedValueInfo,
Length: SpecifiedValueInfo,
Shadow: SpecifiedValueInfo,
U: SpecifiedValueInfo,

### impl<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U> SpecifiedValueInfo for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>where
Angle: SpecifiedValueInfo,
NonNegativeFactor: SpecifiedValueInfo,
ZeroToOneFactor: SpecifiedValueInfo,
Length: SpecifiedValueInfo,
Shadow: SpecifiedValueInfo,
U: SpecifiedValueInfo,

source§#### const SUPPORTED_TYPES: u8 = _

#### const SUPPORTED_TYPES: u8 = _

Supported CssTypes by the given value type. Read more

source§### impl<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U> ToAnimatedValue for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>where
Angle: ToAnimatedValue,
NonNegativeFactor: ToAnimatedValue,
ZeroToOneFactor: ToAnimatedValue,
Length: ToAnimatedValue,
Shadow: ToAnimatedValue,
U: ToAnimatedValue,

### impl<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U> ToAnimatedValue for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>where
Angle: ToAnimatedValue,
NonNegativeFactor: ToAnimatedValue,
ZeroToOneFactor: ToAnimatedValue,
Length: ToAnimatedValue,
Shadow: ToAnimatedValue,
U: ToAnimatedValue,

§#### type AnimatedValue = GenericFilter<<Angle as ToAnimatedValue>::AnimatedValue, <NonNegativeFactor as ToAnimatedValue>::AnimatedValue, <ZeroToOneFactor as ToAnimatedValue>::AnimatedValue, <Length as ToAnimatedValue>::AnimatedValue, <Shadow as ToAnimatedValue>::AnimatedValue, <U as ToAnimatedValue>::AnimatedValue>

#### type AnimatedValue = GenericFilter<<Angle as ToAnimatedValue>::AnimatedValue, <NonNegativeFactor as ToAnimatedValue>::AnimatedValue, <ZeroToOneFactor as ToAnimatedValue>::AnimatedValue, <Length as ToAnimatedValue>::AnimatedValue, <Shadow as ToAnimatedValue>::AnimatedValue, <U as ToAnimatedValue>::AnimatedValue>

The type of the animated value.

source§#### fn from_animated_value(from: Self::AnimatedValue) -> Self

#### fn from_animated_value(from: Self::AnimatedValue) -> Self

Converts back an animated value into a computed value.

source§#### fn to_animated_value(self, context: &Context<'_>) -> Self::AnimatedValue

#### fn to_animated_value(self, context: &Context<'_>) -> Self::AnimatedValue

Converts this value to an animated value.

source§### impl<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U> ToComputedValue for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>where
Angle: ToComputedValue,
NonNegativeFactor: ToComputedValue,
ZeroToOneFactor: ToComputedValue,
Length: ToComputedValue,
Shadow: ToComputedValue,
U: ToComputedValue,

### impl<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U> ToComputedValue for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>where
Angle: ToComputedValue,
NonNegativeFactor: ToComputedValue,
ZeroToOneFactor: ToComputedValue,
Length: ToComputedValue,
Shadow: ToComputedValue,
U: ToComputedValue,

§#### type ComputedValue = GenericFilter<<Angle as ToComputedValue>::ComputedValue, <NonNegativeFactor as ToComputedValue>::ComputedValue, <ZeroToOneFactor as ToComputedValue>::ComputedValue, <Length as ToComputedValue>::ComputedValue, <Shadow as ToComputedValue>::ComputedValue, <U as ToComputedValue>::ComputedValue>

#### type ComputedValue = GenericFilter<<Angle as ToComputedValue>::ComputedValue, <NonNegativeFactor as ToComputedValue>::ComputedValue, <ZeroToOneFactor as ToComputedValue>::ComputedValue, <Length as ToComputedValue>::ComputedValue, <Shadow as ToComputedValue>::ComputedValue, <U as ToComputedValue>::ComputedValue>

The computed value type we’re going to be converted to.

source§#### fn from_computed_value(from: &Self::ComputedValue) -> Self

#### fn from_computed_value(from: &Self::ComputedValue) -> Self

Convert a computed value to specified value form. Read more

source§#### fn to_computed_value(&self, context: &Context<'_>) -> Self::ComputedValue

#### fn to_computed_value(&self, context: &Context<'_>) -> Self::ComputedValue

Convert a specified value to a computed value, using itself and the data
inside the

`Context`

.source§### impl<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U> ToCss for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>

### impl<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U> ToCss for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>

source§### impl<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U> ToResolvedValue for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>where
Angle: ToResolvedValue,
NonNegativeFactor: ToResolvedValue,
ZeroToOneFactor: ToResolvedValue,
Length: ToResolvedValue,
Shadow: ToResolvedValue,
U: ToResolvedValue,

### impl<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U> ToResolvedValue for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>where
Angle: ToResolvedValue,
NonNegativeFactor: ToResolvedValue,
ZeroToOneFactor: ToResolvedValue,
Length: ToResolvedValue,
Shadow: ToResolvedValue,
U: ToResolvedValue,

§#### type ResolvedValue = GenericFilter<<Angle as ToResolvedValue>::ResolvedValue, <NonNegativeFactor as ToResolvedValue>::ResolvedValue, <ZeroToOneFactor as ToResolvedValue>::ResolvedValue, <Length as ToResolvedValue>::ResolvedValue, <Shadow as ToResolvedValue>::ResolvedValue, <U as ToResolvedValue>::ResolvedValue>

#### type ResolvedValue = GenericFilter<<Angle as ToResolvedValue>::ResolvedValue, <NonNegativeFactor as ToResolvedValue>::ResolvedValue, <ZeroToOneFactor as ToResolvedValue>::ResolvedValue, <Length as ToResolvedValue>::ResolvedValue, <Shadow as ToResolvedValue>::ResolvedValue, <U as ToResolvedValue>::ResolvedValue>

The resolved value type we’re going to be converted to.

source§#### fn from_resolved_value(from: Self::ResolvedValue) -> Self

#### fn from_resolved_value(from: Self::ResolvedValue) -> Self

Convert a resolved value to resolved value form.

source§#### fn to_resolved_value(self, context: &Context<'_>) -> Self::ResolvedValue

#### fn to_resolved_value(self, context: &Context<'_>) -> Self::ResolvedValue

Convert a resolved value to a resolved value.

source§### impl<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U> ToShmem for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>

### impl<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U> ToShmem for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>

### impl<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U> StructuralPartialEq for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>

## Auto Trait Implementations§

### impl<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U> Freeze for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>

### impl<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U> RefUnwindSafe for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>where
Length: RefUnwindSafe,
NonNegativeFactor: RefUnwindSafe,
ZeroToOneFactor: RefUnwindSafe,
Angle: RefUnwindSafe,
Shadow: RefUnwindSafe,
U: RefUnwindSafe,

### impl<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U> Send for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>

### impl<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U> Sync for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>

### impl<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U> Unpin for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>

### impl<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U> UnwindSafe for GenericFilter<Angle, NonNegativeFactor, ZeroToOneFactor, Length, Shadow, U>where
Length: UnwindSafe,
NonNegativeFactor: UnwindSafe,
ZeroToOneFactor: UnwindSafe,
Angle: UnwindSafe,
Shadow: UnwindSafe,
U: UnwindSafe,

## Blanket Implementations§

source§### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

source§#### fn borrow_mut(&mut self) -> &mut T

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

source§### impl<T> IntoEither for T

### impl<T> IntoEither for T

source§#### fn into_either(self, into_left: bool) -> Either<Self, Self>

#### fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts

`self`

into a `Left`

variant of `Either<Self, Self>`

if `into_left`

is `true`

.
Converts `self`

into a `Right`

variant of `Either<Self, Self>`

otherwise. Read moresource§#### fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>

#### fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>

Converts

`self`

into a `Left`

variant of `Either<Self, Self>`

if `into_left(&self)`

returns `true`

.
Converts `self`

into a `Right`

variant of `Either<Self, Self>`

otherwise. Read moresource§### impl<T> MaybeBoxed<Box<T>> for T

### impl<T> MaybeBoxed<Box<T>> for T

source§#### fn maybe_boxed(self) -> Box<T>

#### fn maybe_boxed(self) -> Box<T>

Convert

source§### impl<T> MaybeBoxed<T> for T

### impl<T> MaybeBoxed<T> for T

source§#### fn maybe_boxed(self) -> T

#### fn maybe_boxed(self) -> T

Convert