Struct Primitive

Source
pub struct Primitive(/* private fields */);

Implementations§

Source§

impl Primitive

Source

pub fn new_p2( 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 = cogl_primitive_new_p2 (COGL_VERTICES_MODE_TRIANGLE_FAN,
                              3, triangle);
cogl_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.

Source

pub fn new_p2c4( 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 Attributes 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 = cogl_primitive_new_p2c4 (COGL_VERTICES_MODE_TRIANGLE_FAN,
                                3, triangle);
cogl_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.

Source

pub fn new_p2t2( 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 Attributes 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 = cogl_primitive_new_p2t2 (COGL_VERTICES_MODE_TRIANGLE_FAN,
                                3, triangle);
cogl_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.

Source

pub fn new_p2t2c4( 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 Attributes 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 = cogl_primitive_new_p2t2c4 (COGL_VERTICES_MODE_TRIANGLE_FAN,
                                  3, triangle);
cogl_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.

Source

pub fn new_p3( 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 = cogl_primitive_new_p3 (COGL_VERTICES_MODE_TRIANGLE_FAN,
                              3, triangle);
cogl_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.

Source

pub fn new_p3c4( 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 Attributes 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 = cogl_primitive_new_p3c4 (COGL_VERTICES_MODE_TRIANGLE_FAN,
                                3, triangle);
cogl_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.

Source

pub fn new_p3t2( 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 Attributes 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 = cogl_primitive_new_p3t2 (COGL_VERTICES_MODE_TRIANGLE_FAN,
                                3, triangle);
cogl_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.

Source

pub fn new_p3t2c4( 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 Attributes 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 = cogl_primitive_new_p3t2c4 (COGL_VERTICES_MODE_TRIANGLE_FAN,
                                  3, triangle);
cogl_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.

Source

pub fn copy(&self) -> Option<Primitive>

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

Source

pub fn draw<P: IsA<Framebuffer>>(&self, framebuffer: &P, pipeline: &Pipeline)

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

Source

pub fn foreach_attribute<P: FnMut(&Primitive, &Attribute) -> i32>( &self, callback: P, )

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

Source

pub fn get_first_vertex(&self) -> i32

Source

pub fn get_indices(&self) -> Option<Indices>

§Returns

the indices that were set with Primitive::set_indices or None if no indices were set.

Source

pub fn get_mode(&self) -> VerticesMode

Source

pub fn get_n_vertices(&self) -> i32

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.

Source

pub fn set_first_vertex(&self, first_vertex: i32)

Source

pub fn set_indices(&self, indices: &Indices, n_indices: i32)

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

Source

pub fn set_mode(&self, mode: VerticesMode)

Source

pub fn set_n_vertices(&self, n_vertices: i32)

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§

Source§

impl Clone for Primitive

Source§

fn clone(&self) -> Primitive

Returns a duplicate of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from source. Read more
Source§

impl Debug for Primitive

Source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
Source§

impl Display for Primitive

Source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
Source§

impl Hash for Primitive

Source§

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher. Read more
1.3.0 · Source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
Source§

impl Ord for Primitive

Source§

fn cmp(&self, other: &Primitive) -> Ordering

This method returns an Ordering between self and other. Read more
1.21.0 · Source§

fn max(self, other: Self) -> Self
where Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · Source§

fn min(self, other: Self) -> Self
where Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · Source§

fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized,

Restrict a value to a certain interval. Read more
Source§

impl<T: ObjectType> PartialEq<T> for Primitive

Source§

fn eq(&self, other: &T) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Source§

impl<T: ObjectType> PartialOrd<T> for Primitive

Source§

fn partial_cmp(&self, other: &T) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · Source§

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · Source§

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · Source§

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · Source§

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
Source§

impl StaticType for Primitive

Source§

fn static_type() -> Type

Returns the type identifier of Self.
Source§

impl Eq for Primitive

Source§

impl IsA<Object> for Primitive

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

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

Mutably borrows from an owned value. Read more
Source§

impl<T> Cast for T
where T: ObjectType,

Source§

fn upcast<T>(self) -> T
where T: ObjectType, Self: IsA<T>,

Upcasts an object to a superclass or interface T. Read more
Source§

fn upcast_ref<T>(&self) -> &T
where T: ObjectType, Self: IsA<T>,

Upcasts an object to a reference of its superclass or interface T. Read more
Source§

fn downcast<T>(self) -> Result<T, Self>
where T: ObjectType, Self: CanDowncast<T>,

Tries to downcast to a subclass or interface implementor T. Read more
Source§

fn downcast_ref<T>(&self) -> Option<&T>
where T: ObjectType, Self: CanDowncast<T>,

Tries to downcast to a reference of its subclass or interface implementor T. Read more
Source§

fn dynamic_cast<T>(self) -> Result<T, Self>
where T: ObjectType,

Tries to cast to an object of type T. This handles upcasting, downcasting and casting between interface and interface implementors. All checks are performed at runtime, while downcast and upcast will do many checks at compile-time already. Read more
Source§

fn dynamic_cast_ref<T>(&self) -> Option<&T>
where T: ObjectType,

Tries to cast to reference to an object of type T. This handles upcasting, downcasting and casting between interface and interface implementors. All checks are performed at runtime, while downcast and upcast will do many checks at compile-time already. Read more
Source§

unsafe fn unsafe_cast<T>(self) -> T
where T: ObjectType,

Casts to T unconditionally. Read more
Source§

unsafe fn unsafe_cast_ref<T>(&self) -> &T
where T: ObjectType,

Casts to &T unconditionally. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T> FromGlibContainerAsVec<<T as GlibPtrDefault>::GlibType, *const GList> for T

Source§

impl<T> FromGlibContainerAsVec<<T as GlibPtrDefault>::GlibType, *const GPtrArray> for T

Source§

impl<T> FromGlibContainerAsVec<<T as GlibPtrDefault>::GlibType, *const GSList> for T

Source§

impl<T> FromGlibContainerAsVec<<T as GlibPtrDefault>::GlibType, *mut GList> for T

Source§

impl<T> FromGlibContainerAsVec<<T as GlibPtrDefault>::GlibType, *mut GPtrArray> for T

Source§

impl<T> FromGlibContainerAsVec<<T as GlibPtrDefault>::GlibType, *mut GSList> for T

Source§

impl<T> FromGlibPtrArrayContainerAsVec<<T as GlibPtrDefault>::GlibType, *const GList> for T

Source§

impl<T> FromGlibPtrArrayContainerAsVec<<T as GlibPtrDefault>::GlibType, *const GPtrArray> for T

Source§

impl<T> FromGlibPtrArrayContainerAsVec<<T as GlibPtrDefault>::GlibType, *const GSList> for T

Source§

impl<T> FromGlibPtrArrayContainerAsVec<<T as GlibPtrDefault>::GlibType, *mut GList> for T

Source§

impl<T> FromGlibPtrArrayContainerAsVec<<T as GlibPtrDefault>::GlibType, *mut GPtrArray> for T

Source§

impl<T> FromGlibPtrArrayContainerAsVec<<T as GlibPtrDefault>::GlibType, *mut GSList> for T

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> ObjectExt for T
where T: ObjectType,

Source§

fn is<U>(&self) -> bool
where U: StaticType,

Returns true if the object is an instance of (can be cast to) T.
Source§

fn get_type(&self) -> Type

Source§

fn get_object_class(&self) -> &ObjectClass

Source§

fn set_properties( &self, property_values: &[(&str, &dyn ToValue)], ) -> Result<(), BoolError>

Source§

fn set_property<'a, N>( &self, property_name: N, value: &dyn ToValue, ) -> Result<(), BoolError>
where N: Into<&'a str>,

Source§

fn get_property<'a, N>(&self, property_name: N) -> Result<Value, BoolError>
where N: Into<&'a str>,

Source§

unsafe fn set_qdata<QD>(&self, key: Quark, value: QD)
where QD: 'static,

Safety Read more
Source§

unsafe fn get_qdata<QD>(&self, key: Quark) -> Option<&QD>
where QD: 'static,

Safety Read more
Source§

unsafe fn steal_qdata<QD>(&self, key: Quark) -> Option<QD>
where QD: 'static,

Safety Read more
Source§

unsafe fn set_data<QD>(&self, key: &str, value: QD)
where QD: 'static,

Safety Read more
Source§

unsafe fn get_data<QD>(&self, key: &str) -> Option<&QD>
where QD: 'static,

Safety Read more
Source§

unsafe fn steal_data<QD>(&self, key: &str) -> Option<QD>
where QD: 'static,

Safety Read more
Source§

fn block_signal(&self, handler_id: &SignalHandlerId)

Source§

fn unblock_signal(&self, handler_id: &SignalHandlerId)

Source§

fn stop_signal_emission(&self, signal_name: &str)

Source§

fn disconnect(&self, handler_id: SignalHandlerId)

Source§

fn connect_notify<F>(&self, name: Option<&str>, f: F) -> SignalHandlerId
where F: Fn(&T, &ParamSpec) + Send + Sync + 'static,

Source§

unsafe fn connect_notify_unsafe<F>( &self, name: Option<&str>, f: F, ) -> SignalHandlerId
where F: Fn(&T, &ParamSpec),

Source§

fn notify<'a, N>(&self, property_name: N)
where N: Into<&'a str>,

Source§

fn notify_by_pspec(&self, pspec: &ParamSpec)

Source§

fn has_property<'a, N>(&self, property_name: N, type_: Option<Type>) -> bool
where N: Into<&'a str>,

Source§

fn get_property_type<'a, N>(&self, property_name: N) -> Option<Type>
where N: Into<&'a str>,

Source§

fn find_property<'a, N>(&self, property_name: N) -> Option<ParamSpec>
where N: Into<&'a str>,

Source§

fn list_properties(&self) -> Vec<ParamSpec>

Source§

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,

Source§

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,

Source§

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>,

Source§

fn emit<'a, N>( &self, signal_name: N, args: &[&dyn ToValue], ) -> Result<Option<Value>, BoolError>
where N: Into<&'a str>,

Source§

fn downgrade(&self) -> WeakRef<T>

Source§

fn bind_property<'a, O, N, M>( &'a self, source_property: N, target: &'a O, target_property: M, ) -> BindingBuilder<'a>
where O: ObjectType, N: Into<&'a str>, M: Into<&'a str>,

Source§

fn ref_count(&self) -> u32

Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T> ToString for T
where T: Display + ?Sized,

Source§

fn to_string(&self) -> String

Converts the given value to a String. Read more
Source§

impl<T> ToValue for T
where T: SetValue + ?Sized,

Source§

fn to_value(&self) -> Value

Returns a Value clone of self.
Source§

fn to_value_type(&self) -> Type

Returns the type identifer of self. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<Super, Sub> CanDowncast<Sub> for Super
where Super: IsA<Super>, Sub: IsA<Super>,

Source§

impl<O> ObjectExt for O
where O: IsA<Object>,