1use core::ffi::*;
4use core::ptr::NonNull;
5use objc2::__framework_prelude::*;
6#[cfg(feature = "objc2-core-foundation")]
7use objc2_core_foundation::*;
8#[cfg(feature = "objc2-core-location")]
9use objc2_core_location::*;
10use objc2_foundation::*;
11
12use crate::*;
13
14#[cfg(feature = "objc2-core-location")]
16#[repr(C)]
17#[derive(Clone, Copy, Debug, PartialEq)]
18pub struct MKCoordinateSpan {
19 pub latitudeDelta: CLLocationDegrees,
20 pub longitudeDelta: CLLocationDegrees,
21}
22
23#[cfg(feature = "objc2-core-location")]
24unsafe impl Encode for MKCoordinateSpan {
25 const ENCODING: Encoding = Encoding::Struct(
26 "?",
27 &[<CLLocationDegrees>::ENCODING, <CLLocationDegrees>::ENCODING],
28 );
29}
30
31#[cfg(feature = "objc2-core-location")]
32unsafe impl RefEncode for MKCoordinateSpan {
33 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
34}
35
36#[cfg(feature = "objc2-core-location")]
38#[repr(C)]
39#[derive(Clone, Copy, Debug, PartialEq)]
40pub struct MKCoordinateRegion {
41 pub center: CLLocationCoordinate2D,
42 pub span: MKCoordinateSpan,
43}
44
45#[cfg(feature = "objc2-core-location")]
46unsafe impl Encode for MKCoordinateRegion {
47 const ENCODING: Encoding = Encoding::Struct(
48 "?",
49 &[
50 <CLLocationCoordinate2D>::ENCODING,
51 <MKCoordinateSpan>::ENCODING,
52 ],
53 );
54}
55
56#[cfg(feature = "objc2-core-location")]
57unsafe impl RefEncode for MKCoordinateRegion {
58 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
59}
60
61#[cfg(feature = "objc2-core-location")]
62impl MKCoordinateSpan {
63 }
65
66#[cfg(feature = "objc2-core-location")]
67impl MKCoordinateRegion {
68 #[doc(alias = "MKCoordinateRegionMakeWithDistance")]
71 #[cfg(feature = "objc2-core-location")]
72 #[inline]
73 pub unsafe fn with_distance(
74 center_coordinate: CLLocationCoordinate2D,
75 latitudinal_meters: CLLocationDistance,
76 longitudinal_meters: CLLocationDistance,
77 ) -> MKCoordinateRegion {
78 extern "C-unwind" {
79 fn MKCoordinateRegionMakeWithDistance(
80 center_coordinate: CLLocationCoordinate2D,
81 latitudinal_meters: CLLocationDistance,
82 longitudinal_meters: CLLocationDistance,
83 ) -> MKCoordinateRegion;
84 }
85 unsafe {
86 MKCoordinateRegionMakeWithDistance(
87 center_coordinate,
88 latitudinal_meters,
89 longitudinal_meters,
90 )
91 }
92 }
93}
94
95#[repr(C)]
97#[derive(Clone, Copy, Debug, PartialEq)]
98pub struct MKMapPoint {
99 pub x: c_double,
100 pub y: c_double,
101}
102
103unsafe impl Encode for MKMapPoint {
104 const ENCODING: Encoding = Encoding::Struct("?", &[<c_double>::ENCODING, <c_double>::ENCODING]);
105}
106
107unsafe impl RefEncode for MKMapPoint {
108 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
109}
110
111#[repr(C)]
113#[derive(Clone, Copy, Debug, PartialEq)]
114pub struct MKMapSize {
115 pub width: c_double,
116 pub height: c_double,
117}
118
119unsafe impl Encode for MKMapSize {
120 const ENCODING: Encoding = Encoding::Struct("?", &[<c_double>::ENCODING, <c_double>::ENCODING]);
121}
122
123unsafe impl RefEncode for MKMapSize {
124 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
125}
126
127#[repr(C)]
129#[derive(Clone, Copy, Debug, PartialEq)]
130pub struct MKMapRect {
131 pub origin: MKMapPoint,
132 pub size: MKMapSize,
133}
134
135unsafe impl Encode for MKMapRect {
136 const ENCODING: Encoding =
137 Encoding::Struct("?", &[<MKMapPoint>::ENCODING, <MKMapSize>::ENCODING]);
138}
139
140unsafe impl RefEncode for MKMapRect {
141 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
142}
143
144#[cfg(feature = "objc2-core-foundation")]
146pub type MKZoomScale = CGFloat;
147
148extern "C" {
149 pub static MKMapSizeWorld: MKMapSize;
151}
152
153extern "C" {
154 pub static MKMapRectWorld: MKMapRect;
156}
157
158impl MKMapPoint {
159 #[doc(alias = "MKMapPointForCoordinate")]
160 #[cfg(feature = "objc2-core-location")]
161 #[inline]
162 pub unsafe fn for_coordinate(coordinate: CLLocationCoordinate2D) -> MKMapPoint {
163 extern "C-unwind" {
164 fn MKMapPointForCoordinate(coordinate: CLLocationCoordinate2D) -> MKMapPoint;
165 }
166 unsafe { MKMapPointForCoordinate(coordinate) }
167 }
168}
169
170extern "C-unwind" {
171 #[cfg(feature = "objc2-core-location")]
172 pub fn MKCoordinateForMapPoint(map_point: MKMapPoint) -> CLLocationCoordinate2D;
173}
174
175extern "C-unwind" {
176 #[cfg(feature = "objc2-core-location")]
177 pub fn MKMetersPerMapPointAtLatitude(latitude: CLLocationDegrees) -> CLLocationDistance;
178}
179
180extern "C-unwind" {
181 #[cfg(feature = "objc2-core-location")]
182 pub fn MKMapPointsPerMeterAtLatitude(latitude: CLLocationDegrees) -> c_double;
183}
184
185extern "C-unwind" {
186 #[cfg(feature = "objc2-core-location")]
187 pub fn MKMetersBetweenMapPoints(a: MKMapPoint, b: MKMapPoint) -> CLLocationDistance;
188}
189
190extern "C" {
191 pub static MKMapRectNull: MKMapRect;
193}
194
195impl MKMapPoint {
196 }
198
199impl MKMapSize {
200 }
202
203impl MKMapRect {
204 }
222
223impl MKMapPoint {
224 }
226
227impl MKMapSize {
228 }
230
231impl MKMapRect {
232 }
238
239impl MKMapRect {
246 #[doc(alias = "MKMapRectUnion")]
247 #[inline]
248 pub unsafe fn union(self, rect2: MKMapRect) -> MKMapRect {
249 extern "C-unwind" {
250 fn MKMapRectUnion(rect1: MKMapRect, rect2: MKMapRect) -> MKMapRect;
251 }
252 unsafe { MKMapRectUnion(self, rect2) }
253 }
254
255 #[doc(alias = "MKMapRectIntersection")]
256 #[inline]
257 pub unsafe fn intersection(self, rect2: MKMapRect) -> MKMapRect {
258 extern "C-unwind" {
259 fn MKMapRectIntersection(rect1: MKMapRect, rect2: MKMapRect) -> MKMapRect;
260 }
261 unsafe { MKMapRectIntersection(self, rect2) }
262 }
263
264 #[doc(alias = "MKMapRectInset")]
265 #[inline]
266 pub unsafe fn inset(self, dx: c_double, dy: c_double) -> MKMapRect {
267 extern "C-unwind" {
268 fn MKMapRectInset(rect: MKMapRect, dx: c_double, dy: c_double) -> MKMapRect;
269 }
270 unsafe { MKMapRectInset(self, dx, dy) }
271 }
272
273 #[doc(alias = "MKMapRectOffset")]
274 #[inline]
275 pub unsafe fn offset(self, dx: c_double, dy: c_double) -> MKMapRect {
276 extern "C-unwind" {
277 fn MKMapRectOffset(rect: MKMapRect, dx: c_double, dy: c_double) -> MKMapRect;
278 }
279 unsafe { MKMapRectOffset(self, dx, dy) }
280 }
281
282 #[doc(alias = "MKMapRectDivide")]
287 #[cfg(feature = "objc2-core-foundation")]
288 #[inline]
289 pub unsafe fn divide(
290 self,
291 slice: NonNull<MKMapRect>,
292 remainder: NonNull<MKMapRect>,
293 amount: c_double,
294 edge: CGRectEdge,
295 ) {
296 extern "C-unwind" {
297 fn MKMapRectDivide(
298 rect: MKMapRect,
299 slice: NonNull<MKMapRect>,
300 remainder: NonNull<MKMapRect>,
301 amount: c_double,
302 edge: CGRectEdge,
303 );
304 }
305 unsafe { MKMapRectDivide(self, slice, remainder, amount, edge) }
306 }
307
308 #[doc(alias = "MKMapRectContainsPoint")]
309 #[inline]
310 pub unsafe fn contains_point(self, point: MKMapPoint) -> bool {
311 extern "C-unwind" {
312 fn MKMapRectContainsPoint(rect: MKMapRect, point: MKMapPoint) -> Bool;
313 }
314 unsafe { MKMapRectContainsPoint(self, point) }.as_bool()
315 }
316
317 #[doc(alias = "MKMapRectContainsRect")]
318 #[inline]
319 pub unsafe fn contains_rect(self, rect2: MKMapRect) -> bool {
320 extern "C-unwind" {
321 fn MKMapRectContainsRect(rect1: MKMapRect, rect2: MKMapRect) -> Bool;
322 }
323 unsafe { MKMapRectContainsRect(self, rect2) }.as_bool()
324 }
325
326 #[doc(alias = "MKMapRectIntersectsRect")]
327 #[inline]
328 pub unsafe fn intersects_rect(self, rect2: MKMapRect) -> bool {
329 extern "C-unwind" {
330 fn MKMapRectIntersectsRect(rect1: MKMapRect, rect2: MKMapRect) -> Bool;
331 }
332 unsafe { MKMapRectIntersectsRect(self, rect2) }.as_bool()
333 }
334}
335
336#[cfg(feature = "objc2-core-location")]
337impl MKCoordinateRegion {
338 #[doc(alias = "MKCoordinateRegionForMapRect")]
339 #[cfg(feature = "objc2-core-location")]
340 #[inline]
341 pub unsafe fn for_map_rect(rect: MKMapRect) -> MKCoordinateRegion {
342 extern "C-unwind" {
343 fn MKCoordinateRegionForMapRect(rect: MKMapRect) -> MKCoordinateRegion;
344 }
345 unsafe { MKCoordinateRegionForMapRect(rect) }
346 }
347}
348
349impl MKMapRect {
350 #[doc(alias = "MKMapRectSpans180thMeridian")]
351 #[inline]
352 pub unsafe fn spans180th_meridian(self) -> bool {
353 extern "C-unwind" {
354 fn MKMapRectSpans180thMeridian(rect: MKMapRect) -> Bool;
355 }
356 unsafe { MKMapRectSpans180thMeridian(self) }.as_bool()
357 }
358
359 #[doc(alias = "MKMapRectRemainder")]
360 #[inline]
361 pub unsafe fn remainder(self) -> MKMapRect {
362 extern "C-unwind" {
363 fn MKMapRectRemainder(rect: MKMapRect) -> MKMapRect;
364 }
365 unsafe { MKMapRectRemainder(self) }
366 }
367}
368
369mod private_NSValueMapKitGeometryExtensions {
370 pub trait Sealed {}
371}
372
373pub unsafe trait NSValueMapKitGeometryExtensions:
375 ClassType + Sized + private_NSValueMapKitGeometryExtensions::Sealed
376{
377 extern_methods!(
378 #[cfg(feature = "objc2-core-location")]
379 #[unsafe(method(valueWithMKCoordinate:))]
380 #[unsafe(method_family = none)]
381 unsafe fn valueWithMKCoordinate(coordinate: CLLocationCoordinate2D) -> Retained<NSValue>;
382
383 #[cfg(feature = "objc2-core-location")]
384 #[unsafe(method(valueWithMKCoordinateSpan:))]
385 #[unsafe(method_family = none)]
386 unsafe fn valueWithMKCoordinateSpan(span: MKCoordinateSpan) -> Retained<NSValue>;
387
388 #[cfg(feature = "objc2-core-location")]
389 #[unsafe(method(MKCoordinateValue))]
390 #[unsafe(method_family = none)]
391 unsafe fn MKCoordinateValue(&self) -> CLLocationCoordinate2D;
392
393 #[cfg(feature = "objc2-core-location")]
394 #[unsafe(method(MKCoordinateSpanValue))]
395 #[unsafe(method_family = none)]
396 unsafe fn MKCoordinateSpanValue(&self) -> MKCoordinateSpan;
397 );
398}
399
400impl private_NSValueMapKitGeometryExtensions::Sealed for NSValue {}
401unsafe impl NSValueMapKitGeometryExtensions for NSValue {}
402
403extern "C-unwind" {
404 #[cfg(feature = "objc2-core-location")]
405 #[deprecated = "renamed to `MKCoordinateRegion::with_distance`"]
406 pub fn MKCoordinateRegionMakeWithDistance(
407 center_coordinate: CLLocationCoordinate2D,
408 latitudinal_meters: CLLocationDistance,
409 longitudinal_meters: CLLocationDistance,
410 ) -> MKCoordinateRegion;
411}
412
413extern "C-unwind" {
414 #[cfg(feature = "objc2-core-location")]
415 #[deprecated = "renamed to `MKMapPoint::for_coordinate`"]
416 pub fn MKMapPointForCoordinate(coordinate: CLLocationCoordinate2D) -> MKMapPoint;
417}
418
419extern "C-unwind" {
420 #[deprecated = "renamed to `MKMapRect::union`"]
421 pub fn MKMapRectUnion(rect1: MKMapRect, rect2: MKMapRect) -> MKMapRect;
422}
423
424extern "C-unwind" {
425 #[deprecated = "renamed to `MKMapRect::intersection`"]
426 pub fn MKMapRectIntersection(rect1: MKMapRect, rect2: MKMapRect) -> MKMapRect;
427}
428
429extern "C-unwind" {
430 #[deprecated = "renamed to `MKMapRect::inset`"]
431 pub fn MKMapRectInset(rect: MKMapRect, dx: c_double, dy: c_double) -> MKMapRect;
432}
433
434extern "C-unwind" {
435 #[deprecated = "renamed to `MKMapRect::offset`"]
436 pub fn MKMapRectOffset(rect: MKMapRect, dx: c_double, dy: c_double) -> MKMapRect;
437}
438
439extern "C-unwind" {
440 #[cfg(feature = "objc2-core-foundation")]
441 #[deprecated = "renamed to `MKMapRect::divide`"]
442 pub fn MKMapRectDivide(
443 rect: MKMapRect,
444 slice: NonNull<MKMapRect>,
445 remainder: NonNull<MKMapRect>,
446 amount: c_double,
447 edge: CGRectEdge,
448 );
449}
450
451#[deprecated = "renamed to `MKMapRect::contains_point`"]
452#[inline]
453pub unsafe extern "C-unwind" fn MKMapRectContainsPoint(rect: MKMapRect, point: MKMapPoint) -> bool {
454 extern "C-unwind" {
455 fn MKMapRectContainsPoint(rect: MKMapRect, point: MKMapPoint) -> Bool;
456 }
457 unsafe { MKMapRectContainsPoint(rect, point) }.as_bool()
458}
459
460#[deprecated = "renamed to `MKMapRect::contains_rect`"]
461#[inline]
462pub unsafe extern "C-unwind" fn MKMapRectContainsRect(rect1: MKMapRect, rect2: MKMapRect) -> bool {
463 extern "C-unwind" {
464 fn MKMapRectContainsRect(rect1: MKMapRect, rect2: MKMapRect) -> Bool;
465 }
466 unsafe { MKMapRectContainsRect(rect1, rect2) }.as_bool()
467}
468
469#[deprecated = "renamed to `MKMapRect::intersects_rect`"]
470#[inline]
471pub unsafe extern "C-unwind" fn MKMapRectIntersectsRect(
472 rect1: MKMapRect,
473 rect2: MKMapRect,
474) -> bool {
475 extern "C-unwind" {
476 fn MKMapRectIntersectsRect(rect1: MKMapRect, rect2: MKMapRect) -> Bool;
477 }
478 unsafe { MKMapRectIntersectsRect(rect1, rect2) }.as_bool()
479}
480
481extern "C-unwind" {
482 #[cfg(feature = "objc2-core-location")]
483 #[deprecated = "renamed to `MKCoordinateRegion::for_map_rect`"]
484 pub fn MKCoordinateRegionForMapRect(rect: MKMapRect) -> MKCoordinateRegion;
485}
486
487#[deprecated = "renamed to `MKMapRect::spans180th_meridian`"]
488#[inline]
489pub unsafe extern "C-unwind" fn MKMapRectSpans180thMeridian(rect: MKMapRect) -> bool {
490 extern "C-unwind" {
491 fn MKMapRectSpans180thMeridian(rect: MKMapRect) -> Bool;
492 }
493 unsafe { MKMapRectSpans180thMeridian(rect) }.as_bool()
494}
495
496extern "C-unwind" {
497 #[deprecated = "renamed to `MKMapRect::remainder`"]
498 pub fn MKMapRectRemainder(rect: MKMapRect) -> MKMapRect;
499}