Struct kas_core::geom::DVec2

#[repr(C)]
pub struct DVec2(pub f64, pub f64);

2D vector (double precision)

Usually used as either a coordinate or a difference of coordinates, but may have some other uses.

Vectors are partially ordered and support component-wise comparison via methods like lhs.lt(rhs). The PartialOrd trait is not implemented since it implements lhs ≤ rhs as lhs < rhs || lhs == rhs which is wrong for vectors (consider for lhs = (0, 1), rhs = (1, 0)).

Tuple Fields

0: f64

1: f64

Implementations

impl DVec2

pub const ZERO: DVec2 = _

Zero

pub const ONE: DVec2 = _

One

pub const NEG_INFINITY: DVec2 = _

Negative infinity

pub const INFINITY: DVec2 = _

Positive infinity

pub const NAN: DVec2 = _

Not a Number (NaN)

pub const fn splat(value: f64) -> Self

Constructs a new instance with each element initialized to value.

pub fn min_comp(self) -> f64

Take the minimum component

pub fn max_comp(self) -> f64

Take the maximum component

pub fn min(self, other: Self) -> Self

Return the minimum, componentwise

pub fn max(self, other: Self) -> Self

Return the maximum, componentwise

pub fn abs(self) -> Self

Take the absolute value of each component

pub fn floor(self) -> Self

Take the floor of each component

pub fn ceil(self) -> Self

Take the ceiling of each component

pub fn round(self) -> Self

Round each component to the nearest integer

pub fn trunc(self) -> Self

Take the trunc of each component

pub fn fract(self) -> Self

Take the fract of each component

pub fn sign(self) -> Self

For each component, return ±1 with the same sign as self.

pub fn lt(self, rhs: Self) -> bool

True when for all components, lhs < rhs

pub fn le(self, rhs: Self) -> bool

True when for all components, lhs ≤ rhs

pub fn ge(self, rhs: Self) -> bool

True when for all components, lhs ≥ rhs

pub fn gt(self, rhs: Self) -> bool

True when for all components, lhs > rhs

pub fn complex_mul(self, rhs: Self) -> Self

Multiply two vectors as if they are complex numbers

Examples found in repository

src/event/manager/mgr_shell.rs (line 190)

    pub fn update(&mut self, shell: &mut dyn ShellWindow, widget: &mut dyn Widget) -> TkAction {
        let old_hover_icon = self.hover_icon;

        let mut mgr = EventMgr {
            state: self,
            shell,
            messages: vec![],
            scroll: Scroll::None,
            action: TkAction::empty(),
        };

        while let Some((parent, wid)) = mgr.popup_removed.pop() {
            mgr.send_event(widget, parent, Event::PopupRemoved(wid));
        }

        if let Some((id, event)) = mgr.mouse_grab().and_then(|g| g.flush_move()) {
            mgr.send_event(widget, id, event);
        }

        for i in 0..mgr.touch_grab.len() {
            if let Some((id, event)) = mgr.touch_grab[i].flush_move() {
                mgr.send_event(widget, id, event);
            }
        }

        for gi in 0..mgr.pan_grab.len() {
            let grab = &mut mgr.pan_grab[gi];
            debug_assert!(grab.mode != GrabMode::Grab);
            assert!(grab.n > 0);

            // Terminology: pi are old coordinates, qi are new coords
            let (p1, q1) = (DVec2::conv(grab.coords[0].0), DVec2::conv(grab.coords[0].1));
            grab.coords[0].0 = grab.coords[0].1;

            let alpha;
            let delta;

            if grab.mode == GrabMode::PanOnly || grab.n == 1 {
                alpha = DVec2(1.0, 0.0);
                delta = q1 - p1;
            } else {
                // We don't use more than two touches: information would be
                // redundant (although it could be averaged).
                let (p2, q2) = (DVec2::conv(grab.coords[1].0), DVec2::conv(grab.coords[1].1));
                grab.coords[1].0 = grab.coords[1].1;
                let (pd, qd) = (p2 - p1, q2 - q1);

                alpha = match grab.mode {
                    GrabMode::PanFull => qd.complex_div(pd),
                    GrabMode::PanScale => DVec2((qd.sum_square() / pd.sum_square()).sqrt(), 0.0),
                    GrabMode::PanRotate => {
                        let a = qd.complex_div(pd);
                        a / a.sum_square().sqrt()
                    }
                    _ => unreachable!(),
                };

                // Average delta from both movements:
                delta = (q1 - alpha.complex_mul(p1) + q2 - alpha.complex_mul(p2)) * 0.5;
            }

            let id = grab.id.clone();
            if alpha != DVec2(1.0, 0.0) || delta != DVec2::ZERO {
                let event = Event::Pan { alpha, delta };
                mgr.send_event(widget, id, event);
            }
        }

        // Warning: infinite loops are possible here if widgets always queue a
        // new pending event when evaluating one of these:
        while let Some(item) = mgr.pending.pop_front() {
            log::trace!(target: "kas_core::event::manager", "update: handling Pending::{item:?}");
            let (id, event) = match item {
                Pending::SetNavFocus(id, key_focus) => (id, Event::NavFocus(key_focus)),
                Pending::MouseHover(id) => (id, Event::MouseHover),
                Pending::LostNavFocus(id) => (id, Event::LostNavFocus),
                Pending::LostMouseHover(id) => {
                    mgr.hover_icon = Default::default();
                    (id, Event::LostMouseHover)
                }
                Pending::LostCharFocus(id) => (id, Event::LostCharFocus),
                Pending::LostSelFocus(id) => (id, Event::LostSelFocus),
            };
            mgr.send_event(widget, id, event);
        }

        let action = mgr.action;
        drop(mgr);

        if self.hover_icon != old_hover_icon && self.mouse_grab.is_none() {
            shell.set_cursor_icon(self.hover_icon);
        }

        let action = action | self.action;
        self.action = TkAction::empty();
        action
    }

pub fn complex_div(self, rhs: Self) -> Self

Divide by a second vector as if they are complex numbers

Examples found in repository

src/event/manager/mgr_shell.rs (line 180)

    pub fn update(&mut self, shell: &mut dyn ShellWindow, widget: &mut dyn Widget) -> TkAction {
        let old_hover_icon = self.hover_icon;

        let mut mgr = EventMgr {
            state: self,
            shell,
            messages: vec![],
            scroll: Scroll::None,
            action: TkAction::empty(),
        };

        while let Some((parent, wid)) = mgr.popup_removed.pop() {
            mgr.send_event(widget, parent, Event::PopupRemoved(wid));
        }

        if let Some((id, event)) = mgr.mouse_grab().and_then(|g| g.flush_move()) {
            mgr.send_event(widget, id, event);
        }

        for i in 0..mgr.touch_grab.len() {
            if let Some((id, event)) = mgr.touch_grab[i].flush_move() {
                mgr.send_event(widget, id, event);
            }
        }

        for gi in 0..mgr.pan_grab.len() {
            let grab = &mut mgr.pan_grab[gi];
            debug_assert!(grab.mode != GrabMode::Grab);
            assert!(grab.n > 0);

            // Terminology: pi are old coordinates, qi are new coords
            let (p1, q1) = (DVec2::conv(grab.coords[0].0), DVec2::conv(grab.coords[0].1));
            grab.coords[0].0 = grab.coords[0].1;

            let alpha;
            let delta;

            if grab.mode == GrabMode::PanOnly || grab.n == 1 {
                alpha = DVec2(1.0, 0.0);
                delta = q1 - p1;
            } else {
                // We don't use more than two touches: information would be
                // redundant (although it could be averaged).
                let (p2, q2) = (DVec2::conv(grab.coords[1].0), DVec2::conv(grab.coords[1].1));
                grab.coords[1].0 = grab.coords[1].1;
                let (pd, qd) = (p2 - p1, q2 - q1);

                alpha = match grab.mode {
                    GrabMode::PanFull => qd.complex_div(pd),
                    GrabMode::PanScale => DVec2((qd.sum_square() / pd.sum_square()).sqrt(), 0.0),
                    GrabMode::PanRotate => {
                        let a = qd.complex_div(pd);
                        a / a.sum_square().sqrt()
                    }
                    _ => unreachable!(),
                };

                // Average delta from both movements:
                delta = (q1 - alpha.complex_mul(p1) + q2 - alpha.complex_mul(p2)) * 0.5;
            }

            let id = grab.id.clone();
            if alpha != DVec2(1.0, 0.0) || delta != DVec2::ZERO {
                let event = Event::Pan { alpha, delta };
                mgr.send_event(widget, id, event);
            }
        }

        // Warning: infinite loops are possible here if widgets always queue a
        // new pending event when evaluating one of these:
        while let Some(item) = mgr.pending.pop_front() {
            log::trace!(target: "kas_core::event::manager", "update: handling Pending::{item:?}");
            let (id, event) = match item {
                Pending::SetNavFocus(id, key_focus) => (id, Event::NavFocus(key_focus)),
                Pending::MouseHover(id) => (id, Event::MouseHover),
                Pending::LostNavFocus(id) => (id, Event::LostNavFocus),
                Pending::LostMouseHover(id) => {
                    mgr.hover_icon = Default::default();
                    (id, Event::LostMouseHover)
                }
                Pending::LostCharFocus(id) => (id, Event::LostCharFocus),
                Pending::LostSelFocus(id) => (id, Event::LostSelFocus),
            };
            mgr.send_event(widget, id, event);
        }

        let action = mgr.action;
        drop(mgr);

        if self.hover_icon != old_hover_icon && self.mouse_grab.is_none() {
            shell.set_cursor_icon(self.hover_icon);
        }

        let action = action | self.action;
        self.action = TkAction::empty();
        action
    }

pub fn complex_inv(self) -> Self

Take the complex reciprocal

pub fn sum(self) -> f64

Return the sum of the terms

pub fn sum_square(self) -> f64

Return the sum of the square of the terms

Examples found in repository

src/event/manager/mgr_shell.rs (line 181)

    pub fn update(&mut self, shell: &mut dyn ShellWindow, widget: &mut dyn Widget) -> TkAction {
        let old_hover_icon = self.hover_icon;

        let mut mgr = EventMgr {
            state: self,
            shell,
            messages: vec![],
            scroll: Scroll::None,
            action: TkAction::empty(),
        };

        while let Some((parent, wid)) = mgr.popup_removed.pop() {
            mgr.send_event(widget, parent, Event::PopupRemoved(wid));
        }

        if let Some((id, event)) = mgr.mouse_grab().and_then(|g| g.flush_move()) {
            mgr.send_event(widget, id, event);
        }

        for i in 0..mgr.touch_grab.len() {
            if let Some((id, event)) = mgr.touch_grab[i].flush_move() {
                mgr.send_event(widget, id, event);
            }
        }

        for gi in 0..mgr.pan_grab.len() {
            let grab = &mut mgr.pan_grab[gi];
            debug_assert!(grab.mode != GrabMode::Grab);
            assert!(grab.n > 0);

            // Terminology: pi are old coordinates, qi are new coords
            let (p1, q1) = (DVec2::conv(grab.coords[0].0), DVec2::conv(grab.coords[0].1));
            grab.coords[0].0 = grab.coords[0].1;

            let alpha;
            let delta;

            if grab.mode == GrabMode::PanOnly || grab.n == 1 {
                alpha = DVec2(1.0, 0.0);
                delta = q1 - p1;
            } else {
                // We don't use more than two touches: information would be
                // redundant (although it could be averaged).
                let (p2, q2) = (DVec2::conv(grab.coords[1].0), DVec2::conv(grab.coords[1].1));
                grab.coords[1].0 = grab.coords[1].1;
                let (pd, qd) = (p2 - p1, q2 - q1);

                alpha = match grab.mode {
                    GrabMode::PanFull => qd.complex_div(pd),
                    GrabMode::PanScale => DVec2((qd.sum_square() / pd.sum_square()).sqrt(), 0.0),
                    GrabMode::PanRotate => {
                        let a = qd.complex_div(pd);
                        a / a.sum_square().sqrt()
                    }
                    _ => unreachable!(),
                };

                // Average delta from both movements:
                delta = (q1 - alpha.complex_mul(p1) + q2 - alpha.complex_mul(p2)) * 0.5;
            }

            let id = grab.id.clone();
            if alpha != DVec2(1.0, 0.0) || delta != DVec2::ZERO {
                let event = Event::Pan { alpha, delta };
                mgr.send_event(widget, id, event);
            }
        }

        // Warning: infinite loops are possible here if widgets always queue a
        // new pending event when evaluating one of these:
        while let Some(item) = mgr.pending.pop_front() {
            log::trace!(target: "kas_core::event::manager", "update: handling Pending::{item:?}");
            let (id, event) = match item {
                Pending::SetNavFocus(id, key_focus) => (id, Event::NavFocus(key_focus)),
                Pending::MouseHover(id) => (id, Event::MouseHover),
                Pending::LostNavFocus(id) => (id, Event::LostNavFocus),
                Pending::LostMouseHover(id) => {
                    mgr.hover_icon = Default::default();
                    (id, Event::LostMouseHover)
                }
                Pending::LostCharFocus(id) => (id, Event::LostCharFocus),
                Pending::LostSelFocus(id) => (id, Event::LostSelFocus),
            };
            mgr.send_event(widget, id, event);
        }

        let action = mgr.action;
        drop(mgr);

        if self.hover_icon != old_hover_icon && self.mouse_grab.is_none() {
            shell.set_cursor_icon(self.hover_icon);
        }

        let action = action | self.action;
        self.action = TkAction::empty();
        action
    }

pub fn extract<D: Directional>(self, dir: D) -> f64

Extract one component, based on a direction

This merely extracts the horizontal or vertical component. It never negates it, even if the axis is reversed.

Trait Implementations

impl Add<DVec2> for DVec2

type Output = DVec2

The resulting type after applying the + operator.

fn add(self, rhs: DVec2) -> Self::Output

Performs the + operation.

impl Add<f64> for DVec2

type Output = DVec2

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> Self::Output

Performs the + operation.

impl AddAssign<DVec2> for DVec2

fn add_assign(&mut self, rhs: DVec2)

Performs the += operation.

impl AddAssign<f64> for DVec2

fn add_assign(&mut self, rhs: f64)

Performs the += operation.

impl Clone for DVec2

fn clone(&self) -> DVec2

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Conv<(f64, f64)> for DVec2

fn conv(arg: (f64, f64)) -> Self

Convert from T to Self

fn try_conv(v: (f64, f64)) -> Result<Self>

Try converting from T to Self

impl Conv<Coord> for DVec2

fn try_conv(arg: Coord) -> Result<Self>

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl Conv<DVec2> for (f64, f64)

fn conv(v: DVec2) -> Self

Convert from T to Self

fn try_conv(v: DVec2) -> Result<Self>

Try converting from T to Self

impl Conv<Offset> for DVec2

fn try_conv(arg: Offset) -> Result<Self>

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl Conv<Size> for DVec2

fn try_conv(arg: Size) -> Result<Self>

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl ConvApprox<DVec2> for Coord

fn try_conv_approx(arg: DVec2) -> Result<Self>

Try converting from T to Self, allowing approximation of value

fn conv_approx(x: T) -> Self

Converting from T to Self, allowing approximation of value

impl ConvApprox<DVec2> for Offset

fn try_conv_approx(arg: DVec2) -> Result<Self>

Try converting from T to Self, allowing approximation of value

fn conv_approx(x: T) -> Self

Converting from T to Self, allowing approximation of value

impl ConvApprox<DVec2> for Size

fn try_conv_approx(arg: DVec2) -> Result<Self>

Try converting from T to Self, allowing approximation of value

fn conv_approx(x: T) -> Self

Converting from T to Self, allowing approximation of value

impl ConvApprox<DVec2> for Vec2

fn try_conv_approx(size: DVec2) -> Result<Vec2>

Try converting from T to Self, allowing approximation of value

fn conv_approx(x: T) -> Self

Converting from T to Self, allowing approximation of value

impl ConvFloat<DVec2> for Coord

fn try_conv_trunc(x: DVec2) -> Result<Self>

Try converting to integer with truncation

fn try_conv_nearest(x: DVec2) -> Result<Self>

Try converting to the nearest integer

fn try_conv_floor(x: DVec2) -> Result<Self>

Try converting the floor to an integer

fn try_conv_ceil(x: DVec2) -> Result<Self>

Try convert the ceiling to an integer

fn conv_trunc(x: T) -> Self

Convert to integer with truncatation

fn conv_nearest(x: T) -> Self

Convert to the nearest integer

fn conv_floor(x: T) -> Self

Convert the floor to an integer

fn conv_ceil(x: T) -> Self

Convert the ceiling to an integer

impl ConvFloat<DVec2> for Offset

fn try_conv_trunc(x: DVec2) -> Result<Self>

Try converting to integer with truncation

fn try_conv_nearest(x: DVec2) -> Result<Self>

Try converting to the nearest integer

fn try_conv_floor(x: DVec2) -> Result<Self>

Try converting the floor to an integer

fn try_conv_ceil(x: DVec2) -> Result<Self>

Try convert the ceiling to an integer

fn conv_trunc(x: T) -> Self

Convert to integer with truncatation

fn conv_nearest(x: T) -> Self

Convert to the nearest integer

fn conv_floor(x: T) -> Self

Convert the floor to an integer

fn conv_ceil(x: T) -> Self

Convert the ceiling to an integer

impl ConvFloat<DVec2> for Size

fn try_conv_trunc(x: DVec2) -> Result<Self>

Try converting to integer with truncation

fn try_conv_nearest(x: DVec2) -> Result<Self>

Try converting to the nearest integer

fn try_conv_floor(x: DVec2) -> Result<Self>

Try converting the floor to an integer

fn try_conv_ceil(x: DVec2) -> Result<Self>

Try convert the ceiling to an integer

fn conv_trunc(x: T) -> Self

Convert to integer with truncatation

fn conv_nearest(x: T) -> Self

Convert to the nearest integer

fn conv_floor(x: T) -> Self

Convert the floor to an integer

fn conv_ceil(x: T) -> Self

Convert the ceiling to an integer

impl Debug for DVec2

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

Formats the value using the given formatter.

impl Default for DVec2

fn default() -> DVec2

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for DVec2

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

Deserialize this value from the given Serde deserializer.

impl Div<DVec2> for DVec2

type Output = DVec2

The resulting type after applying the / operator.

fn div(self, rhs: DVec2) -> Self::Output

Performs the / operation.

impl Div<DVec2> for f64

type Output = DVec2

The resulting type after applying the / operator.

fn div(self, rhs: DVec2) -> Self::Output

Performs the / operation.

impl Div<f64> for DVec2

type Output = DVec2

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Self::Output

Performs the / operation.

impl From<(f64, f64)> for DVec2

fn from(arg: (f64, f64)) -> Self

Converts to this type from the input type.

impl From<DVec2> for (f64, f64)

fn from(v: DVec2) -> Self

Converts to this type from the input type.

impl Mul<DVec2> for DVec2

type Output = DVec2

The resulting type after applying the * operator.

fn mul(self, rhs: DVec2) -> Self::Output

Performs the * operation.

impl Mul<f64> for DVec2

type Output = DVec2

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Self::Output

Performs the * operation.

impl Neg for DVec2

type Output = DVec2

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl PartialEq<DVec2> for DVec2

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for DVec2

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub<DVec2> for DVec2

type Output = DVec2

The resulting type after applying the - operator.

fn sub(self, rhs: DVec2) -> Self::Output

Performs the - operation.

impl Sub<f64> for DVec2

type Output = DVec2

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Self::Output

Performs the - operation.

impl SubAssign<DVec2> for DVec2

fn sub_assign(&mut self, rhs: DVec2)

Performs the -= operation.

impl SubAssign<f64> for DVec2

fn sub_assign(&mut self, rhs: f64)

Performs the -= operation.

impl Copy for DVec2

impl StructuralPartialEq for DVec2