Struct ux::prelude::dx::Primitive [−][src]
pub struct Primitive(_, _);
Implementations
impl Primitive
[src]
impl Primitive
[src]pub fn new_p2(
context: &Context,
mode: VerticesMode,
data: &[&VertexP2]
) -> Primitive
[src]
context: &Context,
mode: VerticesMode,
data: &[&VertexP2]
) -> Primitive
Provides a convenient way to describe a primitive, such as a single
triangle strip or a triangle fan, that will internally allocate the
necessary AttributeBuffer
storage, describe the position
attribute with a Attribute
and upload your data.
For example to draw a convex polygon you can do:
CoglVertexP2 triangle[] =
{
{ 0, 300 },
{ 150, 0, },
{ 300, 300 }
};
prim = primitive_new_p2 (VERTICES_MODE_TRIANGLE_FAN,
3, triangle);
primitive_draw (prim);
The value passed as n_vertices
is initially used to determine how
much can be read from data
but it will also be used to update the
Primitive
<structfield>
n_vertices</structfield>
property as if
Primitive::set_n_vertices
were called. This property defines
the number of vertices to read when drawing.
<note>
The primitive API doesn’t support drawing with sliced
textures (since switching between slices implies changing state and
so that implies multiple primitives need to be submitted). You
should pass the TextureFlags::NoSlicing
flag to all textures that
might be used while drawing with this API. If your hardware doesn’t
support non-power of two textures (For example you are using GLES
1.1) then you will need to make sure your assets are resized to a
power-of-two size (though they don’t have to be square)</note>
context
A Context
mode
A VerticesMode
defining how to draw the vertices
n_vertices
The number of vertices to read from data
and also
the number of vertices to read when later drawing.
data
An array
of VertexP2
vertices
Returns
A newly allocated Primitive
with a reference of 1. This can be freed using Object::unref
.
pub fn new_p2c4(
context: &Context,
mode: VerticesMode,
data: &[&VertexP2C4]
) -> Primitive
[src]
context: &Context,
mode: VerticesMode,
data: &[&VertexP2C4]
) -> Primitive
Provides a convenient way to describe a primitive, such as a single
triangle strip or a triangle fan, that will internally allocate the
necessary AttributeBuffer
storage, describe the position
and color attributes with Attribute
s and upload
your data.
For example to draw a convex polygon with a linear gradient you can do:
CoglVertexP2C4 triangle[] =
{
{ 0, 300, 0xff, 0x00, 0x00, 0xff },
{ 150, 0, 0x00, 0xff, 0x00, 0xff },
{ 300, 300, 0xff, 0x00, 0x00, 0xff }
};
prim = primitive_new_p2c4 (VERTICES_MODE_TRIANGLE_FAN,
3, triangle);
primitive_draw (prim);
The value passed as n_vertices
is initially used to determine how
much can be read from data
but it will also be used to update the
Primitive
<structfield>
n_vertices</structfield>
property as if
Primitive::set_n_vertices
were called. This property defines
the number of vertices to read when drawing.
<note>
The primitive API doesn’t support drawing with sliced
textures (since switching between slices implies changing state and
so that implies multiple primitives need to be submitted). You
should pass the TextureFlags::NoSlicing
flag to all textures that
might be used while drawing with this API. If your hardware doesn’t
support non-power of two textures (For example you are using GLES
1.1) then you will need to make sure your assets are resized to a
power-of-two size (though they don’t have to be square)</note>
context
A Context
mode
A VerticesMode
defining how to draw the vertices
n_vertices
The number of vertices to read from data
and also
the number of vertices to read when later drawing.
data
An array
of VertexP2C4
vertices
Returns
A newly allocated Primitive
with a reference of 1. This can be freed using Object::unref
.
pub fn new_p2t2(
context: &Context,
mode: VerticesMode,
data: &[&VertexP2T2]
) -> Primitive
[src]
context: &Context,
mode: VerticesMode,
data: &[&VertexP2T2]
) -> Primitive
Provides a convenient way to describe a primitive, such as a single
triangle strip or a triangle fan, that will internally allocate the
necessary AttributeBuffer
storage, describe the position and
texture coordinate attributes with Attribute
s and
upload your data.
For example to draw a convex polygon with texture mapping you can do:
CoglVertexP2T2 triangle[] =
{
{ 0, 300, 0.0, 1.0},
{ 150, 0, 0.5, 0.0},
{ 300, 300, 1.0, 1.0}
};
prim = primitive_new_p2t2 (VERTICES_MODE_TRIANGLE_FAN,
3, triangle);
primitive_draw (prim);
The value passed as n_vertices
is initially used to determine how
much can be read from data
but it will also be used to update the
Primitive
<structfield>
n_vertices</structfield>
property as if
Primitive::set_n_vertices
were called. This property defines
the number of vertices to read when drawing.
<note>
The primitive API doesn’t support drawing with sliced
textures (since switching between slices implies changing state and
so that implies multiple primitives need to be submitted). You
should pass the TextureFlags::NoSlicing
flag to all textures that
might be used while drawing with this API. If your hardware doesn’t
support non-power of two textures (For example you are using GLES
1.1) then you will need to make sure your assets are resized to a
power-of-two size (though they don’t have to be square)</note>
context
A Context
mode
A VerticesMode
defining how to draw the vertices
n_vertices
The number of vertices to read from data
and also
the number of vertices to read when later drawing.
data
An array
of VertexP2T2
vertices
Returns
A newly allocated Primitive
with a reference of 1. This can be freed using Object::unref
.
pub fn new_p2t2c4(
context: &Context,
mode: VerticesMode,
data: &[&VertexP2T2C4]
) -> Primitive
[src]
context: &Context,
mode: VerticesMode,
data: &[&VertexP2T2C4]
) -> Primitive
Provides a convenient way to describe a primitive, such as a single
triangle strip or a triangle fan, that will internally allocate the
necessary AttributeBuffer
storage, describe the position, texture
coordinate and color attributes with Attribute
s and
upload your data.
For example to draw a convex polygon with texture mapping and a linear gradient you can do:
CoglVertexP2T2C4 triangle[] =
{
{ 0, 300, 0.0, 1.0, 0xff, 0x00, 0x00, 0xff},
{ 150, 0, 0.5, 0.0, 0x00, 0xff, 0x00, 0xff},
{ 300, 300, 1.0, 1.0, 0xff, 0x00, 0x00, 0xff}
};
prim = primitive_new_p2t2c4 (VERTICES_MODE_TRIANGLE_FAN,
3, triangle);
primitive_draw (prim);
The value passed as n_vertices
is initially used to determine how
much can be read from data
but it will also be used to update the
Primitive
<structfield>
n_vertices</structfield>
property as if
Primitive::set_n_vertices
were called. This property defines
the number of vertices to read when drawing.
<note>
The primitive API doesn’t support drawing with sliced
textures (since switching between slices implies changing state and
so that implies multiple primitives need to be submitted). You
should pass the TextureFlags::NoSlicing
flag to all textures that
might be used while drawing with this API. If your hardware doesn’t
support non-power of two textures (For example you are using GLES
1.1) then you will need to make sure your assets are resized to a
power-of-two size (though they don’t have to be square)</note>
context
A Context
mode
A VerticesMode
defining how to draw the vertices
n_vertices
The number of vertices to read from data
and also
the number of vertices to read when later drawing.
data
An
array of VertexP2T2C4
vertices
Returns
A newly allocated Primitive
with a reference of 1. This can be freed using Object::unref
.
pub fn new_p3(
context: &Context,
mode: VerticesMode,
data: &[&VertexP3]
) -> Primitive
[src]
context: &Context,
mode: VerticesMode,
data: &[&VertexP3]
) -> Primitive
Provides a convenient way to describe a primitive, such as a single
triangle strip or a triangle fan, that will internally allocate the
necessary AttributeBuffer
storage, describe the position
attribute with a Attribute
and upload your data.
For example to draw a convex polygon you can do:
CoglVertexP3 triangle[] =
{
{ 0, 300, 0 },
{ 150, 0, 0 },
{ 300, 300, 0 }
};
prim = primitive_new_p3 (VERTICES_MODE_TRIANGLE_FAN,
3, triangle);
primitive_draw (prim);
The value passed as n_vertices
is initially used to determine how
much can be read from data
but it will also be used to update the
Primitive
<structfield>
n_vertices</structfield>
property as if
Primitive::set_n_vertices
were called. This property defines
the number of vertices to read when drawing.
<note>
The primitive API doesn’t support drawing with sliced
textures (since switching between slices implies changing state and
so that implies multiple primitives need to be submitted). You
should pass the TextureFlags::NoSlicing
flag to all textures that
might be used while drawing with this API. If your hardware doesn’t
support non-power of two textures (For example you are using GLES
1.1) then you will need to make sure your assets are resized to a
power-of-two size (though they don’t have to be square)</note>
context
A Context
mode
A VerticesMode
defining how to draw the vertices
n_vertices
The number of vertices to read from data
and also
the number of vertices to read when later drawing.
data
An array of
VertexP3
vertices
Returns
A newly allocated Primitive
with a reference of 1. This can be freed using Object::unref
.
pub fn new_p3c4(
context: &Context,
mode: VerticesMode,
data: &[&VertexP3C4]
) -> Primitive
[src]
context: &Context,
mode: VerticesMode,
data: &[&VertexP3C4]
) -> Primitive
Provides a convenient way to describe a primitive, such as a single
triangle strip or a triangle fan, that will internally allocate the
necessary AttributeBuffer
storage, describe the position
and color attributes with Attribute
s and upload
your data.
For example to draw a convex polygon with a linear gradient you can do:
CoglVertexP3C4 triangle[] =
{
{ 0, 300, 0, 0xff, 0x00, 0x00, 0xff },
{ 150, 0, 0, 0x00, 0xff, 0x00, 0xff },
{ 300, 300, 0, 0xff, 0x00, 0x00, 0xff }
};
prim = primitive_new_p3c4 (VERTICES_MODE_TRIANGLE_FAN,
3, triangle);
primitive_draw (prim);
The value passed as n_vertices
is initially used to determine how
much can be read from data
but it will also be used to update the
Primitive
<structfield>
n_vertices</structfield>
property as if
Primitive::set_n_vertices
were called. This property defines
the number of vertices to read when drawing.
<note>
The primitive API doesn’t support drawing with sliced
textures (since switching between slices implies changing state and
so that implies multiple primitives need to be submitted). You
should pass the TextureFlags::NoSlicing
flag to all textures that
might be used while drawing with this API. If your hardware doesn’t
support non-power of two textures (For example you are using GLES
1.1) then you will need to make sure your assets are resized to a
power-of-two size (though they don’t have to be square)</note>
context
A Context
mode
A VerticesMode
defining how to draw the vertices
n_vertices
The number of vertices to read from data
and also
the number of vertices to read when later drawing.
data
An array
of VertexP3C4
vertices
Returns
A newly allocated Primitive
with a reference of 1. This can be freed using Object::unref
.
pub fn new_p3t2(
context: &Context,
mode: VerticesMode,
data: &[&VertexP3T2]
) -> Primitive
[src]
context: &Context,
mode: VerticesMode,
data: &[&VertexP3T2]
) -> Primitive
Provides a convenient way to describe a primitive, such as a single
triangle strip or a triangle fan, that will internally allocate the
necessary AttributeBuffer
storage, describe the position and
texture coordinate attributes with Attribute
s and
upload your data.
For example to draw a convex polygon with texture mapping you can do:
CoglVertexP3T2 triangle[] =
{
{ 0, 300, 0, 0.0, 1.0},
{ 150, 0, 0, 0.5, 0.0},
{ 300, 300, 0, 1.0, 1.0}
};
prim = primitive_new_p3t2 (VERTICES_MODE_TRIANGLE_FAN,
3, triangle);
primitive_draw (prim);
The value passed as n_vertices
is initially used to determine how
much can be read from data
but it will also be used to update the
Primitive
<structfield>
n_vertices</structfield>
property as if
Primitive::set_n_vertices
were called. This property defines
the number of vertices to read when drawing.
<note>
The primitive API doesn’t support drawing with sliced
textures (since switching between slices implies changing state and
so that implies multiple primitives need to be submitted). You
should pass the TextureFlags::NoSlicing
flag to all textures that
might be used while drawing with this API. If your hardware doesn’t
support non-power of two textures (For example you are using GLES
1.1) then you will need to make sure your assets are resized to a
power-of-two size (though they don’t have to be square)</note>
context
A Context
mode
A VerticesMode
defining how to draw the vertices
n_vertices
The number of vertices to read from data
and also
the number of vertices to read when later drawing.
data
An array
of VertexP3T2
vertices
Returns
A newly allocated Primitive
with a reference of 1. This can be freed using Object::unref
.
pub fn new_p3t2c4(
context: &Context,
mode: VerticesMode,
data: &[&VertexP3T2C4]
) -> Primitive
[src]
context: &Context,
mode: VerticesMode,
data: &[&VertexP3T2C4]
) -> Primitive
Provides a convenient way to describe a primitive, such as a single
triangle strip or a triangle fan, that will internally allocate the
necessary AttributeBuffer
storage, describe the position, texture
coordinate and color attributes with Attribute
s and
upload your data.
For example to draw a convex polygon with texture mapping and a linear gradient you can do:
CoglVertexP3T2C4 triangle[] =
{
{ 0, 300, 0, 0.0, 1.0, 0xff, 0x00, 0x00, 0xff},
{ 150, 0, 0, 0.5, 0.0, 0x00, 0xff, 0x00, 0xff},
{ 300, 300, 0, 1.0, 1.0, 0xff, 0x00, 0x00, 0xff}
};
prim = primitive_new_p3t2c4 (VERTICES_MODE_TRIANGLE_FAN,
3, triangle);
primitive_draw (prim);
The value passed as n_vertices
is initially used to determine how
much can be read from data
but it will also be used to update the
Primitive
<structfield>
n_vertices</structfield>
property as if
Primitive::set_n_vertices
were called. This property defines
the number of vertices to read when drawing.
<note>
The primitive API doesn’t support drawing with sliced
textures (since switching between slices implies changing state and
so that implies multiple primitives need to be submitted). You
should pass the TextureFlags::NoSlicing
flag to all textures that
might be used while drawing with this API. If your hardware doesn’t
support non-power of two textures (For example you are using GLES
1.1) then you will need to make sure your assets are resized to a
power-of-two size (though they don’t have to be square)</note>
context
A Context
mode
A VerticesMode
defining how to draw the vertices
n_vertices
The number of vertices to read from data
and also
the number of vertices to read when later drawing.
data
An
array of VertexP3T2C4
vertices
Returns
A newly allocated Primitive
with a reference of 1. This can be freed using Object::unref
.
pub fn copy(&self) -> Option<Primitive>
[src]
Makes a copy of an existing Primitive
. Note that the primitive
is a shallow copy which means it will use the same attributes and
attribute buffers as the original primitive.
Returns
the new primitive
pub fn draw<P>(&self, framebuffer: &P, pipeline: &Pipeline) where
P: IsA<Framebuffer>,
[src]
P: IsA<Framebuffer>,
Draws the given self
geometry to the specified destination
framebuffer
using the graphics processing state described by pipeline
.
This drawing api doesn’t support high-level meta texture types such
as Texture2DSliced
so it is the user’s responsibility to
ensure that only low-level textures that can be directly sampled by
a GPU such as Texture2D
, TextureRectangle
or Texture3D
are associated with layers of the given pipeline
.
framebuffer
A destination Framebuffer
pipeline
A Pipeline
state object
pub fn foreach_attribute<P>(&self, callback: P) where
P: FnMut(&Primitive, &Attribute) -> i32,
[src]
P: FnMut(&Primitive, &Attribute) -> i32,
Iterates all the attributes of the given Primitive
.
callback
A CoglPrimitiveAttributeCallback
to be
called for each attribute
user_data
Private data that will be passed to the callback
pub fn get_first_vertex(&self) -> i32
[src]
pub fn get_indices(&self) -> Option<Indices>
[src]
Returns
the indices that were set with
Primitive::set_indices
or None
if no indices were set.
pub fn get_mode(&self) -> VerticesMode
[src]
pub fn get_n_vertices(&self) -> i32
[src]
Queries the number of vertices to read when drawing the given
self
. Usually this value is implicitly set when associating
vertex data or indices with a Primitive
.
If Primitive::set_indices
has been used to associate a
sequence of Indices
with the given self
then the
number of vertices to read can also be phrased as the number
of indices to read.
<note>
To be clear; it doesn’t refer to the number of vertices - in
terms of data - associated with the primitive it’s just the number
of vertices to read and draw.</note>
Returns
The number of vertices to read when drawing.
pub fn set_first_vertex(&self, first_vertex: i32)
[src]
pub fn set_indices(&self, indices: &Indices, n_indices: i32)
[src]
Associates a sequence of Indices
with the given self
.
Indices
provide a way to virtualize your real vertex data by
providing a sequence of indices that index into your real vertex
data. The GPU will walk though the index values to indirectly
lookup the data for each vertex instead of sequentially walking
through the data directly. This lets you save memory by indexing
shared data multiple times instead of duplicating the data.
The value passed as n_indices
will simply update the
Primitive
<structfield>
n_vertices</structfield>
property as if
Primitive::set_n_vertices
were called. This property defines
the number of vertices to draw or, put another way, how many
indices should be read from indices
when drawing.
<note>
The Primitive
<structfield>
first_vertex</structfield>
property
also affects drawing with indices by defining the first entry of the
indices to start drawing from.</note>
indices
A Indices
array
n_indices
The number of indices to reference when drawing
pub fn set_mode(&self, mode: VerticesMode)
[src]
pub fn set_n_vertices(&self, n_vertices: i32)
[src]
Specifies how many vertices should be read when drawing the given
self
.
Usually this value is set implicitly when associating vertex data
or indices with a Primitive
.
<note>
To be clear; it doesn’t refer to the number of vertices - in
terms of data - associated with the primitive it’s just the number
of vertices to read and draw.</note>
n_vertices
The number of vertices to read when drawing.
Trait Implementations
impl<T> PartialEq<T> for Primitive where
T: ObjectType,
[src]
impl<T> PartialEq<T> for Primitive where
T: ObjectType,
[src]impl<T> PartialOrd<T> for Primitive where
T: ObjectType,
[src]
impl<T> PartialOrd<T> for Primitive where
T: ObjectType,
[src]impl StaticType for Primitive
[src]
impl StaticType for Primitive
[src]pub fn static_type() -> Type
[src]
Auto Trait Implementations
impl RefUnwindSafe for Primitive
impl RefUnwindSafe for Primitive
impl UnwindSafe for Primitive
impl UnwindSafe for Primitive
Blanket Implementations
impl<Super, Sub> CanDowncast<Sub> for Super where
Sub: IsA<Super>,
Super: IsA<Super>,
[src]
impl<Super, Sub> CanDowncast<Sub> for Super where
Sub: IsA<Super>,
Super: IsA<Super>,
[src]impl<T> Cast for T where
T: ObjectType,
[src]
impl<T> Cast for T where
T: ObjectType,
[src]pub fn upcast<T>(self) -> T where
Self: IsA<T>,
T: ObjectType,
[src]
Self: IsA<T>,
T: ObjectType,
pub fn upcast_ref<T>(&self) -> &T where
Self: IsA<T>,
T: ObjectType,
[src]
Self: IsA<T>,
T: ObjectType,
pub fn downcast<T>(self) -> Result<T, Self> where
Self: CanDowncast<T>,
T: ObjectType,
[src]
Self: CanDowncast<T>,
T: ObjectType,
pub fn downcast_ref<T>(&self) -> Option<&T> where
Self: CanDowncast<T>,
T: ObjectType,
[src]
Self: CanDowncast<T>,
T: ObjectType,
pub fn dynamic_cast<T>(self) -> Result<T, Self> where
T: ObjectType,
[src]
T: ObjectType,
pub fn dynamic_cast_ref<T>(&self) -> Option<&T> where
T: ObjectType,
[src]
T: ObjectType,
pub unsafe fn unsafe_cast<T>(self) -> T where
T: ObjectType,
[src]
T: ObjectType,
pub unsafe fn unsafe_cast_ref<T>(&self) -> &T where
T: ObjectType,
[src]
T: ObjectType,
impl<Fr, To> IntoColor<To> for Fr where
To: FromColor<Fr>,
[src]
impl<Fr, To> IntoColor<To> for Fr where
To: FromColor<Fr>,
[src]pub fn into_color(self) -> To
[src]
impl<T> ObjectExt for T where
T: ObjectType,
[src]
impl<T> ObjectExt for T where
T: ObjectType,
[src]pub fn is<U>(&self) -> bool where
U: StaticType,
[src]
U: StaticType,
pub fn get_type(&self) -> Type
[src]
pub fn get_object_class(&self) -> &ObjectClass
[src]
pub fn set_properties(
&self,
property_values: &[(&str, &dyn ToValue)]
) -> Result<(), BoolError>
[src]
&self,
property_values: &[(&str, &dyn ToValue)]
) -> Result<(), BoolError>
pub fn set_property<'a, N>(
&self,
property_name: N,
value: &dyn ToValue
) -> Result<(), BoolError> where
N: Into<&'a str>,
[src]
&self,
property_name: N,
value: &dyn ToValue
) -> Result<(), BoolError> where
N: Into<&'a str>,
pub fn get_property<'a, N>(&self, property_name: N) -> Result<Value, BoolError> where
N: Into<&'a str>,
[src]
N: Into<&'a str>,
pub unsafe fn set_qdata<QD>(&self, key: Quark, value: QD) where
QD: 'static,
[src]
QD: 'static,
pub unsafe fn get_qdata<QD>(&self, key: Quark) -> Option<&QD> where
QD: 'static,
[src]
QD: 'static,
pub unsafe fn steal_qdata<QD>(&self, key: Quark) -> Option<QD> where
QD: 'static,
[src]
QD: 'static,
pub unsafe fn set_data<QD>(&self, key: &str, value: QD) where
QD: 'static,
[src]
QD: 'static,
pub unsafe fn get_data<QD>(&self, key: &str) -> Option<&QD> where
QD: 'static,
[src]
QD: 'static,
pub unsafe fn steal_data<QD>(&self, key: &str) -> Option<QD> where
QD: 'static,
[src]
QD: 'static,
pub fn block_signal(&self, handler_id: &SignalHandlerId)
[src]
pub fn unblock_signal(&self, handler_id: &SignalHandlerId)
[src]
pub fn stop_signal_emission(&self, signal_name: &str)
[src]
pub fn disconnect(&self, handler_id: SignalHandlerId)
[src]
pub fn connect_notify<F>(&self, name: Option<&str>, f: F) -> SignalHandlerId where
F: 'static + Fn(&T, &ParamSpec) + Send + Sync,
[src]
F: 'static + Fn(&T, &ParamSpec) + Send + Sync,
pub unsafe fn connect_notify_unsafe<F>(
&self,
name: Option<&str>,
f: F
) -> SignalHandlerId where
F: Fn(&T, &ParamSpec),
[src]
&self,
name: Option<&str>,
f: F
) -> SignalHandlerId where
F: Fn(&T, &ParamSpec),
pub fn notify<'a, N>(&self, property_name: N) where
N: Into<&'a str>,
[src]
N: Into<&'a str>,
pub fn notify_by_pspec(&self, pspec: &ParamSpec)
[src]
pub fn has_property<'a, N>(&self, property_name: N, type_: Option<Type>) -> bool where
N: Into<&'a str>,
[src]
N: Into<&'a str>,
pub fn get_property_type<'a, N>(&self, property_name: N) -> Option<Type> where
N: Into<&'a str>,
[src]
N: Into<&'a str>,
pub fn find_property<'a, N>(&self, property_name: N) -> Option<ParamSpec> where
N: Into<&'a str>,
[src]
N: Into<&'a str>,
pub fn list_properties(&self) -> Vec<ParamSpec, Global>ⓘ
[src]
pub fn connect<'a, N, F>(
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
N: Into<&'a str>,
F: Fn(&[Value]) -> Option<Value> + Send + Sync + 'static,
[src]
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
N: Into<&'a str>,
F: Fn(&[Value]) -> Option<Value> + Send + Sync + 'static,
pub fn connect_local<'a, N, F>(
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
N: Into<&'a str>,
F: Fn(&[Value]) -> Option<Value> + 'static,
[src]
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
N: Into<&'a str>,
F: Fn(&[Value]) -> Option<Value> + 'static,
pub unsafe fn connect_unsafe<'a, N, F>(
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
N: Into<&'a str>,
F: Fn(&[Value]) -> Option<Value>,
[src]
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
N: Into<&'a str>,
F: Fn(&[Value]) -> Option<Value>,
pub fn emit<'a, N>(
&self,
signal_name: N,
args: &[&dyn ToValue]
) -> Result<Option<Value>, BoolError> where
N: Into<&'a str>,
[src]
&self,
signal_name: N,
args: &[&dyn ToValue]
) -> Result<Option<Value>, BoolError> where
N: Into<&'a str>,
pub fn downgrade(&self) -> WeakRef<T>
[src]
pub fn bind_property<'a, O, N, M>(
&'a self,
source_property: N,
target: &'a O,
target_property: M
) -> BindingBuilder<'a> where
N: Into<&'a str>,
O: ObjectType,
M: Into<&'a str>,
[src]
&'a self,
source_property: N,
target: &'a O,
target_property: M
) -> BindingBuilder<'a> where
N: Into<&'a str>,
O: ObjectType,
M: Into<&'a str>,
pub fn ref_count(&self) -> u32
[src]
impl<T> ToSendValue for T where
T: SetValue + Send + ToValue + ?Sized,
[src]
impl<T> ToSendValue for T where
T: SetValue + Send + ToValue + ?Sized,
[src]pub fn to_send_value(&self) -> SendValue
[src]
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,