gdk/
rectangle.rs

1// Copyright 2013-2015, The Gtk-rs Project Developers.
2// See the COPYRIGHT file at the top-level directory of this distribution.
3// Licensed under the MIT license, see the LICENSE file or <http://opensource.org/licenses/MIT>
4
5use cairo::RectangleInt;
6use gdk_sys;
7use glib;
8use glib::translate::*;
9use glib_sys;
10use glib_sys::gconstpointer;
11use gobject_sys;
12use std::convert::{AsRef, From};
13use std::mem;
14
15#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
16#[repr(C)]
17pub struct Rectangle {
18    pub x: i32,
19    pub y: i32,
20    pub width: i32,
21    pub height: i32,
22}
23
24impl Rectangle {
25    pub fn intersect(&self, other: &Rectangle) -> Option<Rectangle> {
26        unsafe {
27            let mut ret = Rectangle::uninitialized();
28            if from_glib(gdk_sys::gdk_rectangle_intersect(
29                self.to_glib_none().0,
30                other.to_glib_none().0,
31                ret.to_glib_none_mut().0,
32            )) {
33                Some(ret)
34            } else {
35                None
36            }
37        }
38    }
39
40    pub fn union(&self, other: &Rectangle) -> Rectangle {
41        unsafe {
42            let mut ret = Rectangle::uninitialized();
43            gdk_sys::gdk_rectangle_union(
44                self.to_glib_none().0,
45                other.to_glib_none().0,
46                ret.to_glib_none_mut().0,
47            );
48            ret
49        }
50    }
51}
52
53#[doc(hidden)]
54impl Uninitialized for Rectangle {
55    #[inline]
56    unsafe fn uninitialized() -> Self {
57        mem::uninitialized()
58    }
59}
60
61#[doc(hidden)]
62impl<'a> ToGlibPtr<'a, *const gdk_sys::GdkRectangle> for Rectangle {
63    type Storage = &'a Self;
64
65    #[inline]
66    fn to_glib_none(&'a self) -> Stash<'a, *const gdk_sys::GdkRectangle, Self> {
67        let ptr: *const Rectangle = &*self;
68        Stash(ptr as *const gdk_sys::GdkRectangle, self)
69    }
70}
71
72#[doc(hidden)]
73impl<'a> ToGlibPtrMut<'a, *mut gdk_sys::GdkRectangle> for Rectangle {
74    type Storage = &'a mut Self;
75
76    #[inline]
77    fn to_glib_none_mut(&'a mut self) -> StashMut<'a, *mut gdk_sys::GdkRectangle, Self> {
78        let ptr: *mut Rectangle = &mut *self;
79        StashMut(ptr as *mut gdk_sys::GdkRectangle, self)
80    }
81}
82
83#[doc(hidden)]
84impl FromGlibPtrNone<*const gdk_sys::GdkRectangle> for Rectangle {
85    unsafe fn from_glib_none(ptr: *const gdk_sys::GdkRectangle) -> Self {
86        *(ptr as *const Rectangle)
87    }
88}
89
90#[doc(hidden)]
91impl FromGlibPtrNone<*mut gdk_sys::GdkRectangle> for Rectangle {
92    unsafe fn from_glib_none(ptr: *mut gdk_sys::GdkRectangle) -> Self {
93        *(ptr as *mut Rectangle)
94    }
95}
96
97#[doc(hidden)]
98impl FromGlibPtrBorrow<*const gdk_sys::GdkRectangle> for Rectangle {
99    unsafe fn from_glib_borrow(ptr: *const gdk_sys::GdkRectangle) -> Self {
100        *(ptr as *const Rectangle)
101    }
102}
103
104#[doc(hidden)]
105impl FromGlibPtrBorrow<*mut gdk_sys::GdkRectangle> for Rectangle {
106    unsafe fn from_glib_borrow(ptr: *mut gdk_sys::GdkRectangle) -> Self {
107        *(ptr as *mut Rectangle)
108    }
109}
110
111#[doc(hidden)]
112impl FromGlibPtrFull<*mut gdk_sys::GdkRectangle> for Rectangle {
113    unsafe fn from_glib_full(ptr: *mut gdk_sys::GdkRectangle) -> Self {
114        let rect = *(ptr as *mut Rectangle);
115        glib_sys::g_free(ptr as *mut _);
116        rect
117    }
118}
119
120#[doc(hidden)]
121impl FromGlibPtrFull<*const gdk_sys::GdkRectangle> for Rectangle {
122    unsafe fn from_glib_full(ptr: *const gdk_sys::GdkRectangle) -> Self {
123        let rect = *(ptr as *const Rectangle);
124        glib_sys::g_free(ptr as *mut _);
125        rect
126    }
127}
128
129impl AsRef<RectangleInt> for Rectangle {
130    fn as_ref(&self) -> &RectangleInt {
131        unsafe { mem::transmute(self) }
132    }
133}
134
135impl From<RectangleInt> for Rectangle {
136    fn from(r: RectangleInt) -> Rectangle {
137        skip_assert_initialized!();
138        unsafe { mem::transmute(r) }
139    }
140}
141
142impl glib::StaticType for Rectangle {
143    fn static_type() -> glib::types::Type {
144        skip_assert_initialized!();
145        unsafe { from_glib(gdk_sys::gdk_rectangle_get_type()) }
146    }
147}
148
149impl<'a> glib::value::FromValueOptional<'a> for Rectangle {
150    unsafe fn from_value_optional(value: &'a glib::Value) -> Option<Self> {
151        from_glib_full(
152            gobject_sys::g_value_dup_boxed(value.to_glib_none().0) as *mut gdk_sys::GdkRectangle
153        )
154    }
155}
156
157impl glib::value::SetValue for Rectangle {
158    unsafe fn set_value(value: &mut glib::Value, this: &Self) {
159        gobject_sys::g_value_set_boxed(
160            value.to_glib_none_mut().0,
161            this.to_glib_none().0 as gconstpointer,
162        )
163    }
164}
165
166impl glib::value::SetValueOptional for Rectangle {
167    unsafe fn set_value_optional(value: &mut glib::Value, this: Option<&Self>) {
168        gobject_sys::g_value_set_boxed(
169            value.to_glib_none_mut().0,
170            this.to_glib_none().0 as gconstpointer,
171        )
172    }
173}