objc2_quartz_core/generated/
CALayer.rs1use 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-graphics")]
9use objc2_core_graphics::*;
10use objc2_foundation::*;
11
12use crate::*;
13
14pub type CALayerContentsGravity = NSString;
17
18pub type CALayerContentsFormat = NSString;
21
22pub type CALayerContentsFilter = NSString;
25
26pub type CALayerCornerCurve = NSString;
29
30#[repr(transparent)]
33#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
34pub struct CAAutoresizingMask(pub c_uint);
35bitflags::bitflags! {
36 impl CAAutoresizingMask: c_uint {
37 #[doc(alias = "kCALayerNotSizable")]
38 const LayerNotSizable = 0;
39 #[doc(alias = "kCALayerMinXMargin")]
40 const LayerMinXMargin = 1<<0;
41 #[doc(alias = "kCALayerWidthSizable")]
42 const LayerWidthSizable = 1<<1;
43 #[doc(alias = "kCALayerMaxXMargin")]
44 const LayerMaxXMargin = 1<<2;
45 #[doc(alias = "kCALayerMinYMargin")]
46 const LayerMinYMargin = 1<<3;
47 #[doc(alias = "kCALayerHeightSizable")]
48 const LayerHeightSizable = 1<<4;
49 #[doc(alias = "kCALayerMaxYMargin")]
50 const LayerMaxYMargin = 1<<5;
51 }
52}
53
54unsafe impl Encode for CAAutoresizingMask {
55 const ENCODING: Encoding = c_uint::ENCODING;
56}
57
58unsafe impl RefEncode for CAAutoresizingMask {
59 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
60}
61
62pub type CAToneMapMode = NSString;
65
66extern "C" {
67 pub static CAToneMapModeAutomatic: &'static CAToneMapMode;
69}
70
71extern "C" {
72 pub static CAToneMapModeNever: &'static CAToneMapMode;
74}
75
76extern "C" {
77 pub static CAToneMapModeIfSupported: &'static CAToneMapMode;
79}
80
81#[repr(transparent)]
84#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
85pub struct CAEdgeAntialiasingMask(pub c_uint);
86bitflags::bitflags! {
87 impl CAEdgeAntialiasingMask: c_uint {
88 #[doc(alias = "kCALayerLeftEdge")]
89 const LayerLeftEdge = 1<<0;
90 #[doc(alias = "kCALayerRightEdge")]
91 const LayerRightEdge = 1<<1;
92 #[doc(alias = "kCALayerBottomEdge")]
93 const LayerBottomEdge = 1<<2;
94 #[doc(alias = "kCALayerTopEdge")]
95 const LayerTopEdge = 1<<3;
96 }
97}
98
99unsafe impl Encode for CAEdgeAntialiasingMask {
100 const ENCODING: Encoding = c_uint::ENCODING;
101}
102
103unsafe impl RefEncode for CAEdgeAntialiasingMask {
104 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
105}
106
107#[repr(transparent)]
110#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
111pub struct CACornerMask(pub NSUInteger);
112bitflags::bitflags! {
113 impl CACornerMask: NSUInteger {
114 #[doc(alias = "kCALayerMinXMinYCorner")]
115 const LayerMinXMinYCorner = 1<<0;
116 #[doc(alias = "kCALayerMaxXMinYCorner")]
117 const LayerMaxXMinYCorner = 1<<1;
118 #[doc(alias = "kCALayerMinXMaxYCorner")]
119 const LayerMinXMaxYCorner = 1<<2;
120 #[doc(alias = "kCALayerMaxXMaxYCorner")]
121 const LayerMaxXMaxYCorner = 1<<3;
122 }
123}
124
125unsafe impl Encode for CACornerMask {
126 const ENCODING: Encoding = NSUInteger::ENCODING;
127}
128
129unsafe impl RefEncode for CACornerMask {
130 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
131}
132
133extern_class!(
134 #[unsafe(super(NSObject))]
138 #[derive(Debug, PartialEq, Eq, Hash)]
139 pub struct CALayer;
140);
141
142#[cfg(feature = "CAMediaTiming")]
143unsafe impl CAMediaTiming for CALayer {}
144
145unsafe impl NSCoding for CALayer {}
146
147unsafe impl NSObjectProtocol for CALayer {}
148
149unsafe impl NSSecureCoding for CALayer {}
150
151impl CALayer {
152 extern_methods!(
153 #[unsafe(method(layer))]
155 #[unsafe(method_family = none)]
156 pub fn layer() -> Retained<Self>;
157
158 #[unsafe(method(init))]
159 #[unsafe(method_family = init)]
160 pub fn init(this: Allocated<Self>) -> Retained<Self>;
161
162 #[unsafe(method(initWithLayer:))]
163 #[unsafe(method_family = init)]
164 pub unsafe fn initWithLayer(this: Allocated<Self>, layer: &AnyObject) -> Retained<Self>;
165
166 #[unsafe(method(presentationLayer))]
167 #[unsafe(method_family = none)]
168 pub unsafe fn presentationLayer(&self) -> Option<Retained<Self>>;
169
170 #[unsafe(method(modelLayer))]
171 #[unsafe(method_family = none)]
172 pub unsafe fn modelLayer(&self) -> Retained<Self>;
173
174 #[unsafe(method(defaultValueForKey:))]
176 #[unsafe(method_family = none)]
177 pub unsafe fn defaultValueForKey(key: &NSString) -> Option<Retained<AnyObject>>;
178
179 #[unsafe(method(needsDisplayForKey:))]
180 #[unsafe(method_family = none)]
181 pub unsafe fn needsDisplayForKey(key: &NSString) -> bool;
182
183 #[unsafe(method(shouldArchiveValueForKey:))]
184 #[unsafe(method_family = none)]
185 pub unsafe fn shouldArchiveValueForKey(&self, key: &NSString) -> bool;
186
187 #[cfg(feature = "objc2-core-foundation")]
188 #[unsafe(method(bounds))]
190 #[unsafe(method_family = none)]
191 pub fn bounds(&self) -> CGRect;
192
193 #[cfg(feature = "objc2-core-foundation")]
194 #[unsafe(method(setBounds:))]
196 #[unsafe(method_family = none)]
197 pub fn setBounds(&self, bounds: CGRect);
198
199 #[cfg(feature = "objc2-core-foundation")]
200 #[unsafe(method(position))]
201 #[unsafe(method_family = none)]
202 pub fn position(&self) -> CGPoint;
203
204 #[cfg(feature = "objc2-core-foundation")]
205 #[unsafe(method(setPosition:))]
207 #[unsafe(method_family = none)]
208 pub fn setPosition(&self, position: CGPoint);
209
210 #[cfg(feature = "objc2-core-foundation")]
211 #[unsafe(method(zPosition))]
212 #[unsafe(method_family = none)]
213 pub fn zPosition(&self) -> CGFloat;
214
215 #[cfg(feature = "objc2-core-foundation")]
216 #[unsafe(method(setZPosition:))]
218 #[unsafe(method_family = none)]
219 pub fn setZPosition(&self, z_position: CGFloat);
220
221 #[cfg(feature = "objc2-core-foundation")]
222 #[unsafe(method(anchorPoint))]
223 #[unsafe(method_family = none)]
224 pub fn anchorPoint(&self) -> CGPoint;
225
226 #[cfg(feature = "objc2-core-foundation")]
227 #[unsafe(method(setAnchorPoint:))]
229 #[unsafe(method_family = none)]
230 pub fn setAnchorPoint(&self, anchor_point: CGPoint);
231
232 #[cfg(feature = "objc2-core-foundation")]
233 #[unsafe(method(anchorPointZ))]
234 #[unsafe(method_family = none)]
235 pub fn anchorPointZ(&self) -> CGFloat;
236
237 #[cfg(feature = "objc2-core-foundation")]
238 #[unsafe(method(setAnchorPointZ:))]
240 #[unsafe(method_family = none)]
241 pub fn setAnchorPointZ(&self, anchor_point_z: CGFloat);
242
243 #[cfg(all(feature = "CATransform3D", feature = "objc2-core-foundation"))]
244 #[unsafe(method(transform))]
245 #[unsafe(method_family = none)]
246 pub fn transform(&self) -> CATransform3D;
247
248 #[cfg(all(feature = "CATransform3D", feature = "objc2-core-foundation"))]
249 #[unsafe(method(setTransform:))]
251 #[unsafe(method_family = none)]
252 pub fn setTransform(&self, transform: CATransform3D);
253
254 #[cfg(feature = "objc2-core-foundation")]
255 #[unsafe(method(affineTransform))]
256 #[unsafe(method_family = none)]
257 pub fn affineTransform(&self) -> CGAffineTransform;
258
259 #[cfg(feature = "objc2-core-foundation")]
260 #[unsafe(method(setAffineTransform:))]
261 #[unsafe(method_family = none)]
262 pub fn setAffineTransform(&self, m: CGAffineTransform);
263
264 #[cfg(feature = "objc2-core-foundation")]
265 #[unsafe(method(frame))]
266 #[unsafe(method_family = none)]
267 pub fn frame(&self) -> CGRect;
268
269 #[cfg(feature = "objc2-core-foundation")]
270 #[unsafe(method(setFrame:))]
272 #[unsafe(method_family = none)]
273 pub fn setFrame(&self, frame: CGRect);
274
275 #[unsafe(method(isHidden))]
276 #[unsafe(method_family = none)]
277 pub fn isHidden(&self) -> bool;
278
279 #[unsafe(method(setHidden:))]
281 #[unsafe(method_family = none)]
282 pub fn setHidden(&self, hidden: bool);
283
284 #[unsafe(method(isDoubleSided))]
285 #[unsafe(method_family = none)]
286 pub fn isDoubleSided(&self) -> bool;
287
288 #[unsafe(method(setDoubleSided:))]
290 #[unsafe(method_family = none)]
291 pub fn setDoubleSided(&self, double_sided: bool);
292
293 #[unsafe(method(isGeometryFlipped))]
294 #[unsafe(method_family = none)]
295 pub fn isGeometryFlipped(&self) -> bool;
296
297 #[unsafe(method(setGeometryFlipped:))]
299 #[unsafe(method_family = none)]
300 pub fn setGeometryFlipped(&self, geometry_flipped: bool);
301
302 #[unsafe(method(contentsAreFlipped))]
303 #[unsafe(method_family = none)]
304 pub fn contentsAreFlipped(&self) -> bool;
305
306 #[unsafe(method(superlayer))]
307 #[unsafe(method_family = none)]
308 pub fn superlayer(&self) -> Option<Retained<CALayer>>;
309
310 #[unsafe(method(removeFromSuperlayer))]
311 #[unsafe(method_family = none)]
312 pub fn removeFromSuperlayer(&self);
313
314 #[unsafe(method(sublayers))]
315 #[unsafe(method_family = none)]
316 pub unsafe fn sublayers(&self) -> Option<Retained<NSArray<CALayer>>>;
317
318 #[unsafe(method(setSublayers:))]
320 #[unsafe(method_family = none)]
321 pub unsafe fn setSublayers(&self, sublayers: Option<&NSArray<CALayer>>);
322
323 #[unsafe(method(addSublayer:))]
324 #[unsafe(method_family = none)]
325 pub fn addSublayer(&self, layer: &CALayer);
326
327 #[unsafe(method(insertSublayer:atIndex:))]
328 #[unsafe(method_family = none)]
329 pub fn insertSublayer_atIndex(&self, layer: &CALayer, idx: c_uint);
330
331 #[unsafe(method(insertSublayer:below:))]
332 #[unsafe(method_family = none)]
333 pub fn insertSublayer_below(&self, layer: &CALayer, sibling: Option<&CALayer>);
334
335 #[unsafe(method(insertSublayer:above:))]
336 #[unsafe(method_family = none)]
337 pub fn insertSublayer_above(&self, layer: &CALayer, sibling: Option<&CALayer>);
338
339 #[unsafe(method(replaceSublayer:with:))]
340 #[unsafe(method_family = none)]
341 pub unsafe fn replaceSublayer_with(&self, old_layer: &CALayer, new_layer: &CALayer);
342
343 #[cfg(all(feature = "CATransform3D", feature = "objc2-core-foundation"))]
344 #[unsafe(method(sublayerTransform))]
345 #[unsafe(method_family = none)]
346 pub fn sublayerTransform(&self) -> CATransform3D;
347
348 #[cfg(all(feature = "CATransform3D", feature = "objc2-core-foundation"))]
349 #[unsafe(method(setSublayerTransform:))]
351 #[unsafe(method_family = none)]
352 pub fn setSublayerTransform(&self, sublayer_transform: CATransform3D);
353
354 #[unsafe(method(mask))]
355 #[unsafe(method_family = none)]
356 pub fn mask(&self) -> Option<Retained<CALayer>>;
357
358 #[unsafe(method(setMask:))]
360 #[unsafe(method_family = none)]
361 pub unsafe fn setMask(&self, mask: Option<&CALayer>);
362
363 #[unsafe(method(masksToBounds))]
364 #[unsafe(method_family = none)]
365 pub fn masksToBounds(&self) -> bool;
366
367 #[unsafe(method(setMasksToBounds:))]
369 #[unsafe(method_family = none)]
370 pub fn setMasksToBounds(&self, masks_to_bounds: bool);
371
372 #[cfg(feature = "objc2-core-foundation")]
373 #[unsafe(method(convertPoint:fromLayer:))]
375 #[unsafe(method_family = none)]
376 pub fn convertPoint_fromLayer(&self, p: CGPoint, l: Option<&CALayer>) -> CGPoint;
377
378 #[cfg(feature = "objc2-core-foundation")]
379 #[unsafe(method(convertPoint:toLayer:))]
380 #[unsafe(method_family = none)]
381 pub fn convertPoint_toLayer(&self, p: CGPoint, l: Option<&CALayer>) -> CGPoint;
382
383 #[cfg(feature = "objc2-core-foundation")]
384 #[unsafe(method(convertRect:fromLayer:))]
385 #[unsafe(method_family = none)]
386 pub fn convertRect_fromLayer(&self, r: CGRect, l: Option<&CALayer>) -> CGRect;
387
388 #[cfg(feature = "objc2-core-foundation")]
389 #[unsafe(method(convertRect:toLayer:))]
390 #[unsafe(method_family = none)]
391 pub fn convertRect_toLayer(&self, r: CGRect, l: Option<&CALayer>) -> CGRect;
392
393 #[cfg(feature = "objc2-core-foundation")]
394 #[unsafe(method(convertTime:fromLayer:))]
395 #[unsafe(method_family = none)]
396 pub fn convertTime_fromLayer(
397 &self,
398 t: CFTimeInterval,
399 l: Option<&CALayer>,
400 ) -> CFTimeInterval;
401
402 #[cfg(feature = "objc2-core-foundation")]
403 #[unsafe(method(convertTime:toLayer:))]
404 #[unsafe(method_family = none)]
405 pub fn convertTime_toLayer(&self, t: CFTimeInterval, l: Option<&CALayer>)
406 -> CFTimeInterval;
407
408 #[cfg(feature = "objc2-core-foundation")]
409 #[unsafe(method(hitTest:))]
411 #[unsafe(method_family = none)]
412 pub fn hitTest(&self, p: CGPoint) -> Option<Retained<CALayer>>;
413
414 #[cfg(feature = "objc2-core-foundation")]
415 #[unsafe(method(containsPoint:))]
416 #[unsafe(method_family = none)]
417 pub fn containsPoint(&self, p: CGPoint) -> bool;
418
419 #[unsafe(method(contents))]
421 #[unsafe(method_family = none)]
422 pub unsafe fn contents(&self) -> Option<Retained<AnyObject>>;
423
424 #[unsafe(method(setContents:))]
426 #[unsafe(method_family = none)]
427 pub unsafe fn setContents(&self, contents: Option<&AnyObject>);
428
429 #[cfg(feature = "objc2-core-foundation")]
430 #[unsafe(method(contentsRect))]
431 #[unsafe(method_family = none)]
432 pub fn contentsRect(&self) -> CGRect;
433
434 #[cfg(feature = "objc2-core-foundation")]
435 #[unsafe(method(setContentsRect:))]
437 #[unsafe(method_family = none)]
438 pub fn setContentsRect(&self, contents_rect: CGRect);
439
440 #[unsafe(method(contentsGravity))]
441 #[unsafe(method_family = none)]
442 pub fn contentsGravity(&self) -> Retained<CALayerContentsGravity>;
443
444 #[unsafe(method(setContentsGravity:))]
446 #[unsafe(method_family = none)]
447 pub fn setContentsGravity(&self, contents_gravity: &CALayerContentsGravity);
448
449 #[cfg(feature = "objc2-core-foundation")]
450 #[unsafe(method(contentsScale))]
451 #[unsafe(method_family = none)]
452 pub fn contentsScale(&self) -> CGFloat;
453
454 #[cfg(feature = "objc2-core-foundation")]
455 #[unsafe(method(setContentsScale:))]
457 #[unsafe(method_family = none)]
458 pub fn setContentsScale(&self, contents_scale: CGFloat);
459
460 #[cfg(feature = "objc2-core-foundation")]
461 #[unsafe(method(contentsCenter))]
462 #[unsafe(method_family = none)]
463 pub fn contentsCenter(&self) -> CGRect;
464
465 #[cfg(feature = "objc2-core-foundation")]
466 #[unsafe(method(setContentsCenter:))]
468 #[unsafe(method_family = none)]
469 pub fn setContentsCenter(&self, contents_center: CGRect);
470
471 #[unsafe(method(contentsFormat))]
472 #[unsafe(method_family = none)]
473 pub fn contentsFormat(&self) -> Retained<CALayerContentsFormat>;
474
475 #[unsafe(method(setContentsFormat:))]
477 #[unsafe(method_family = none)]
478 pub fn setContentsFormat(&self, contents_format: &CALayerContentsFormat);
479
480 #[unsafe(method(wantsExtendedDynamicRangeContent))]
481 #[unsafe(method_family = none)]
482 pub unsafe fn wantsExtendedDynamicRangeContent(&self) -> bool;
483
484 #[unsafe(method(setWantsExtendedDynamicRangeContent:))]
486 #[unsafe(method_family = none)]
487 pub unsafe fn setWantsExtendedDynamicRangeContent(
488 &self,
489 wants_extended_dynamic_range_content: bool,
490 );
491
492 #[unsafe(method(toneMapMode))]
493 #[unsafe(method_family = none)]
494 pub unsafe fn toneMapMode(&self) -> Retained<CAToneMapMode>;
495
496 #[unsafe(method(setToneMapMode:))]
498 #[unsafe(method_family = none)]
499 pub unsafe fn setToneMapMode(&self, tone_map_mode: &CAToneMapMode);
500
501 #[unsafe(method(wantsDynamicContentScaling))]
502 #[unsafe(method_family = none)]
503 pub unsafe fn wantsDynamicContentScaling(&self) -> bool;
504
505 #[unsafe(method(setWantsDynamicContentScaling:))]
507 #[unsafe(method_family = none)]
508 pub unsafe fn setWantsDynamicContentScaling(&self, wants_dynamic_content_scaling: bool);
509
510 #[unsafe(method(minificationFilter))]
511 #[unsafe(method_family = none)]
512 pub fn minificationFilter(&self) -> Retained<CALayerContentsFilter>;
513
514 #[unsafe(method(setMinificationFilter:))]
516 #[unsafe(method_family = none)]
517 pub fn setMinificationFilter(&self, minification_filter: &CALayerContentsFilter);
518
519 #[unsafe(method(magnificationFilter))]
520 #[unsafe(method_family = none)]
521 pub fn magnificationFilter(&self) -> Retained<CALayerContentsFilter>;
522
523 #[unsafe(method(setMagnificationFilter:))]
525 #[unsafe(method_family = none)]
526 pub fn setMagnificationFilter(&self, magnification_filter: &CALayerContentsFilter);
527
528 #[unsafe(method(minificationFilterBias))]
529 #[unsafe(method_family = none)]
530 pub fn minificationFilterBias(&self) -> c_float;
531
532 #[unsafe(method(setMinificationFilterBias:))]
534 #[unsafe(method_family = none)]
535 pub fn setMinificationFilterBias(&self, minification_filter_bias: c_float);
536
537 #[unsafe(method(isOpaque))]
538 #[unsafe(method_family = none)]
539 pub fn isOpaque(&self) -> bool;
540
541 #[unsafe(method(setOpaque:))]
543 #[unsafe(method_family = none)]
544 pub fn setOpaque(&self, opaque: bool);
545
546 #[unsafe(method(display))]
547 #[unsafe(method_family = none)]
548 pub fn display(&self);
549
550 #[unsafe(method(setNeedsDisplay))]
551 #[unsafe(method_family = none)]
552 pub fn setNeedsDisplay(&self);
553
554 #[cfg(feature = "objc2-core-foundation")]
555 #[unsafe(method(setNeedsDisplayInRect:))]
556 #[unsafe(method_family = none)]
557 pub fn setNeedsDisplayInRect(&self, r: CGRect);
558
559 #[unsafe(method(needsDisplay))]
560 #[unsafe(method_family = none)]
561 pub fn needsDisplay(&self) -> bool;
562
563 #[unsafe(method(displayIfNeeded))]
564 #[unsafe(method_family = none)]
565 pub fn displayIfNeeded(&self);
566
567 #[unsafe(method(needsDisplayOnBoundsChange))]
568 #[unsafe(method_family = none)]
569 pub fn needsDisplayOnBoundsChange(&self) -> bool;
570
571 #[unsafe(method(setNeedsDisplayOnBoundsChange:))]
573 #[unsafe(method_family = none)]
574 pub fn setNeedsDisplayOnBoundsChange(&self, needs_display_on_bounds_change: bool);
575
576 #[unsafe(method(drawsAsynchronously))]
577 #[unsafe(method_family = none)]
578 pub fn drawsAsynchronously(&self) -> bool;
579
580 #[unsafe(method(setDrawsAsynchronously:))]
582 #[unsafe(method_family = none)]
583 pub fn setDrawsAsynchronously(&self, draws_asynchronously: bool);
584
585 #[cfg(feature = "objc2-core-graphics")]
586 #[unsafe(method(drawInContext:))]
587 #[unsafe(method_family = none)]
588 pub unsafe fn drawInContext(&self, ctx: &CGContext);
589
590 #[cfg(feature = "objc2-core-graphics")]
591 #[unsafe(method(renderInContext:))]
593 #[unsafe(method_family = none)]
594 pub unsafe fn renderInContext(&self, ctx: &CGContext);
595
596 #[unsafe(method(edgeAntialiasingMask))]
597 #[unsafe(method_family = none)]
598 pub fn edgeAntialiasingMask(&self) -> CAEdgeAntialiasingMask;
599
600 #[unsafe(method(setEdgeAntialiasingMask:))]
602 #[unsafe(method_family = none)]
603 pub fn setEdgeAntialiasingMask(&self, edge_antialiasing_mask: CAEdgeAntialiasingMask);
604
605 #[unsafe(method(allowsEdgeAntialiasing))]
606 #[unsafe(method_family = none)]
607 pub fn allowsEdgeAntialiasing(&self) -> bool;
608
609 #[unsafe(method(setAllowsEdgeAntialiasing:))]
611 #[unsafe(method_family = none)]
612 pub fn setAllowsEdgeAntialiasing(&self, allows_edge_antialiasing: bool);
613
614 #[cfg(feature = "objc2-core-graphics")]
615 #[unsafe(method(backgroundColor))]
616 #[unsafe(method_family = none)]
617 pub unsafe fn backgroundColor(&self) -> Option<Retained<CGColor>>;
618
619 #[cfg(feature = "objc2-core-graphics")]
620 #[unsafe(method(setBackgroundColor:))]
622 #[unsafe(method_family = none)]
623 pub unsafe fn setBackgroundColor(&self, background_color: Option<&CGColor>);
624
625 #[cfg(feature = "objc2-core-foundation")]
626 #[unsafe(method(cornerRadius))]
627 #[unsafe(method_family = none)]
628 pub fn cornerRadius(&self) -> CGFloat;
629
630 #[cfg(feature = "objc2-core-foundation")]
631 #[unsafe(method(setCornerRadius:))]
633 #[unsafe(method_family = none)]
634 pub fn setCornerRadius(&self, corner_radius: CGFloat);
635
636 #[unsafe(method(maskedCorners))]
637 #[unsafe(method_family = none)]
638 pub fn maskedCorners(&self) -> CACornerMask;
639
640 #[unsafe(method(setMaskedCorners:))]
642 #[unsafe(method_family = none)]
643 pub fn setMaskedCorners(&self, masked_corners: CACornerMask);
644
645 #[unsafe(method(cornerCurve))]
646 #[unsafe(method_family = none)]
647 pub fn cornerCurve(&self) -> Retained<CALayerCornerCurve>;
648
649 #[unsafe(method(setCornerCurve:))]
651 #[unsafe(method_family = none)]
652 pub fn setCornerCurve(&self, corner_curve: &CALayerCornerCurve);
653
654 #[cfg(feature = "objc2-core-foundation")]
655 #[unsafe(method(cornerCurveExpansionFactor:))]
656 #[unsafe(method_family = none)]
657 pub fn cornerCurveExpansionFactor(curve: &CALayerCornerCurve) -> CGFloat;
658
659 #[cfg(feature = "objc2-core-foundation")]
660 #[unsafe(method(borderWidth))]
661 #[unsafe(method_family = none)]
662 pub fn borderWidth(&self) -> CGFloat;
663
664 #[cfg(feature = "objc2-core-foundation")]
665 #[unsafe(method(setBorderWidth:))]
667 #[unsafe(method_family = none)]
668 pub fn setBorderWidth(&self, border_width: CGFloat);
669
670 #[cfg(feature = "objc2-core-graphics")]
671 #[unsafe(method(borderColor))]
672 #[unsafe(method_family = none)]
673 pub unsafe fn borderColor(&self) -> Option<Retained<CGColor>>;
674
675 #[cfg(feature = "objc2-core-graphics")]
676 #[unsafe(method(setBorderColor:))]
678 #[unsafe(method_family = none)]
679 pub unsafe fn setBorderColor(&self, border_color: Option<&CGColor>);
680
681 #[unsafe(method(opacity))]
682 #[unsafe(method_family = none)]
683 pub fn opacity(&self) -> c_float;
684
685 #[unsafe(method(setOpacity:))]
687 #[unsafe(method_family = none)]
688 pub fn setOpacity(&self, opacity: c_float);
689
690 #[unsafe(method(allowsGroupOpacity))]
691 #[unsafe(method_family = none)]
692 pub fn allowsGroupOpacity(&self) -> bool;
693
694 #[unsafe(method(setAllowsGroupOpacity:))]
696 #[unsafe(method_family = none)]
697 pub fn setAllowsGroupOpacity(&self, allows_group_opacity: bool);
698
699 #[unsafe(method(compositingFilter))]
700 #[unsafe(method_family = none)]
701 pub unsafe fn compositingFilter(&self) -> Option<Retained<AnyObject>>;
702
703 #[unsafe(method(setCompositingFilter:))]
705 #[unsafe(method_family = none)]
706 pub unsafe fn setCompositingFilter(&self, compositing_filter: Option<&AnyObject>);
707
708 #[unsafe(method(filters))]
709 #[unsafe(method_family = none)]
710 pub unsafe fn filters(&self) -> Option<Retained<NSArray>>;
711
712 #[unsafe(method(setFilters:))]
714 #[unsafe(method_family = none)]
715 pub unsafe fn setFilters(&self, filters: Option<&NSArray>);
716
717 #[unsafe(method(backgroundFilters))]
718 #[unsafe(method_family = none)]
719 pub unsafe fn backgroundFilters(&self) -> Option<Retained<NSArray>>;
720
721 #[unsafe(method(setBackgroundFilters:))]
723 #[unsafe(method_family = none)]
724 pub unsafe fn setBackgroundFilters(&self, background_filters: Option<&NSArray>);
725
726 #[unsafe(method(shouldRasterize))]
727 #[unsafe(method_family = none)]
728 pub fn shouldRasterize(&self) -> bool;
729
730 #[unsafe(method(setShouldRasterize:))]
732 #[unsafe(method_family = none)]
733 pub fn setShouldRasterize(&self, should_rasterize: bool);
734
735 #[cfg(feature = "objc2-core-foundation")]
736 #[unsafe(method(rasterizationScale))]
737 #[unsafe(method_family = none)]
738 pub fn rasterizationScale(&self) -> CGFloat;
739
740 #[cfg(feature = "objc2-core-foundation")]
741 #[unsafe(method(setRasterizationScale:))]
743 #[unsafe(method_family = none)]
744 pub fn setRasterizationScale(&self, rasterization_scale: CGFloat);
745
746 #[cfg(feature = "objc2-core-graphics")]
747 #[unsafe(method(shadowColor))]
749 #[unsafe(method_family = none)]
750 pub unsafe fn shadowColor(&self) -> Option<Retained<CGColor>>;
751
752 #[cfg(feature = "objc2-core-graphics")]
753 #[unsafe(method(setShadowColor:))]
755 #[unsafe(method_family = none)]
756 pub unsafe fn setShadowColor(&self, shadow_color: Option<&CGColor>);
757
758 #[unsafe(method(shadowOpacity))]
759 #[unsafe(method_family = none)]
760 pub fn shadowOpacity(&self) -> c_float;
761
762 #[unsafe(method(setShadowOpacity:))]
764 #[unsafe(method_family = none)]
765 pub fn setShadowOpacity(&self, shadow_opacity: c_float);
766
767 #[cfg(feature = "objc2-core-foundation")]
768 #[unsafe(method(shadowOffset))]
769 #[unsafe(method_family = none)]
770 pub fn shadowOffset(&self) -> CGSize;
771
772 #[cfg(feature = "objc2-core-foundation")]
773 #[unsafe(method(setShadowOffset:))]
775 #[unsafe(method_family = none)]
776 pub fn setShadowOffset(&self, shadow_offset: CGSize);
777
778 #[cfg(feature = "objc2-core-foundation")]
779 #[unsafe(method(shadowRadius))]
780 #[unsafe(method_family = none)]
781 pub fn shadowRadius(&self) -> CGFloat;
782
783 #[cfg(feature = "objc2-core-foundation")]
784 #[unsafe(method(setShadowRadius:))]
786 #[unsafe(method_family = none)]
787 pub fn setShadowRadius(&self, shadow_radius: CGFloat);
788
789 #[cfg(feature = "objc2-core-graphics")]
790 #[unsafe(method(shadowPath))]
791 #[unsafe(method_family = none)]
792 pub unsafe fn shadowPath(&self) -> Option<Retained<CGPath>>;
793
794 #[cfg(feature = "objc2-core-graphics")]
795 #[unsafe(method(setShadowPath:))]
797 #[unsafe(method_family = none)]
798 pub unsafe fn setShadowPath(&self, shadow_path: Option<&CGPath>);
799
800 #[unsafe(method(autoresizingMask))]
802 #[unsafe(method_family = none)]
803 pub fn autoresizingMask(&self) -> CAAutoresizingMask;
804
805 #[unsafe(method(setAutoresizingMask:))]
807 #[unsafe(method_family = none)]
808 pub fn setAutoresizingMask(&self, autoresizing_mask: CAAutoresizingMask);
809
810 #[unsafe(method(layoutManager))]
811 #[unsafe(method_family = none)]
812 pub fn layoutManager(&self) -> Option<Retained<ProtocolObject<dyn CALayoutManager>>>;
813
814 #[unsafe(method(setLayoutManager:))]
816 #[unsafe(method_family = none)]
817 pub fn setLayoutManager(
818 &self,
819 layout_manager: Option<&ProtocolObject<dyn CALayoutManager>>,
820 );
821
822 #[cfg(feature = "objc2-core-foundation")]
823 #[unsafe(method(preferredFrameSize))]
824 #[unsafe(method_family = none)]
825 pub fn preferredFrameSize(&self) -> CGSize;
826
827 #[unsafe(method(setNeedsLayout))]
828 #[unsafe(method_family = none)]
829 pub fn setNeedsLayout(&self);
830
831 #[unsafe(method(needsLayout))]
832 #[unsafe(method_family = none)]
833 pub fn needsLayout(&self) -> bool;
834
835 #[unsafe(method(layoutIfNeeded))]
836 #[unsafe(method_family = none)]
837 pub fn layoutIfNeeded(&self);
838
839 #[unsafe(method(layoutSublayers))]
840 #[unsafe(method_family = none)]
841 pub fn layoutSublayers(&self);
842
843 #[cfg(feature = "objc2-core-foundation")]
844 #[unsafe(method(resizeSublayersWithOldSize:))]
845 #[unsafe(method_family = none)]
846 pub fn resizeSublayersWithOldSize(&self, size: CGSize);
847
848 #[cfg(feature = "objc2-core-foundation")]
849 #[unsafe(method(resizeWithOldSuperlayerSize:))]
850 #[unsafe(method_family = none)]
851 pub fn resizeWithOldSuperlayerSize(&self, size: CGSize);
852
853 #[unsafe(method(defaultActionForKey:))]
855 #[unsafe(method_family = none)]
856 pub fn defaultActionForKey(
857 event: &NSString,
858 ) -> Option<Retained<ProtocolObject<dyn CAAction>>>;
859
860 #[unsafe(method(actionForKey:))]
861 #[unsafe(method_family = none)]
862 pub fn actionForKey(
863 &self,
864 event: &NSString,
865 ) -> Option<Retained<ProtocolObject<dyn CAAction>>>;
866
867 #[unsafe(method(actions))]
868 #[unsafe(method_family = none)]
869 pub fn actions(
870 &self,
871 ) -> Option<Retained<NSDictionary<NSString, ProtocolObject<dyn CAAction>>>>;
872
873 #[unsafe(method(setActions:))]
875 #[unsafe(method_family = none)]
876 pub fn setActions(
877 &self,
878 actions: Option<&NSDictionary<NSString, ProtocolObject<dyn CAAction>>>,
879 );
880
881 #[cfg(feature = "CAAnimation")]
882 #[unsafe(method(addAnimation:forKey:))]
884 #[unsafe(method_family = none)]
885 pub fn addAnimation_forKey(&self, anim: &CAAnimation, key: Option<&NSString>);
886
887 #[unsafe(method(removeAllAnimations))]
888 #[unsafe(method_family = none)]
889 pub fn removeAllAnimations(&self);
890
891 #[unsafe(method(removeAnimationForKey:))]
892 #[unsafe(method_family = none)]
893 pub fn removeAnimationForKey(&self, key: &NSString);
894
895 #[unsafe(method(animationKeys))]
896 #[unsafe(method_family = none)]
897 pub fn animationKeys(&self) -> Option<Retained<NSArray<NSString>>>;
898
899 #[cfg(feature = "CAAnimation")]
900 #[unsafe(method(animationForKey:))]
901 #[unsafe(method_family = none)]
902 pub unsafe fn animationForKey(&self, key: &NSString) -> Option<Retained<CAAnimation>>;
903
904 #[unsafe(method(name))]
906 #[unsafe(method_family = none)]
907 pub fn name(&self) -> Option<Retained<NSString>>;
908
909 #[unsafe(method(setName:))]
911 #[unsafe(method_family = none)]
912 pub fn setName(&self, name: Option<&NSString>);
913
914 #[unsafe(method(delegate))]
915 #[unsafe(method_family = none)]
916 pub fn delegate(&self) -> Option<Retained<ProtocolObject<dyn CALayerDelegate>>>;
917
918 #[unsafe(method(setDelegate:))]
921 #[unsafe(method_family = none)]
922 pub fn setDelegate(&self, delegate: Option<&ProtocolObject<dyn CALayerDelegate>>);
923
924 #[unsafe(method(style))]
925 #[unsafe(method_family = none)]
926 pub unsafe fn style(&self) -> Option<Retained<NSDictionary>>;
927
928 #[unsafe(method(setStyle:))]
930 #[unsafe(method_family = none)]
931 pub unsafe fn setStyle(&self, style: Option<&NSDictionary>);
932 );
933}
934
935impl CALayer {
937 extern_methods!(
938 #[unsafe(method(new))]
939 #[unsafe(method_family = new)]
940 pub fn new() -> Retained<Self>;
941 );
942}
943
944impl DefaultRetained for CALayer {
945 #[inline]
946 fn default_retained() -> Retained<Self> {
947 Self::new()
948 }
949}
950
951extern_protocol!(
952 pub unsafe trait CALayoutManager: NSObjectProtocol {
956 #[cfg(feature = "objc2-core-foundation")]
957 #[optional]
958 #[unsafe(method(preferredSizeOfLayer:))]
959 #[unsafe(method_family = none)]
960 unsafe fn preferredSizeOfLayer(&self, layer: &CALayer) -> CGSize;
961
962 #[optional]
963 #[unsafe(method(invalidateLayoutOfLayer:))]
964 #[unsafe(method_family = none)]
965 unsafe fn invalidateLayoutOfLayer(&self, layer: &CALayer);
966
967 #[optional]
968 #[unsafe(method(layoutSublayersOfLayer:))]
969 #[unsafe(method_family = none)]
970 unsafe fn layoutSublayersOfLayer(&self, layer: &CALayer);
971 }
972);
973
974extern_protocol!(
975 pub unsafe trait CAAction {
979 #[unsafe(method(runActionForKey:object:arguments:))]
980 #[unsafe(method_family = none)]
981 unsafe fn runActionForKey_object_arguments(
982 &self,
983 event: &NSString,
984 an_object: &AnyObject,
985 dict: Option<&NSDictionary>,
986 );
987 }
988);
989
990unsafe impl CAAction for NSNull {}
991
992extern_protocol!(
993 pub unsafe trait CALayerDelegate: NSObjectProtocol {
997 #[optional]
998 #[unsafe(method(displayLayer:))]
999 #[unsafe(method_family = none)]
1000 unsafe fn displayLayer(&self, layer: &CALayer);
1001
1002 #[cfg(feature = "objc2-core-graphics")]
1003 #[optional]
1004 #[unsafe(method(drawLayer:inContext:))]
1005 #[unsafe(method_family = none)]
1006 unsafe fn drawLayer_inContext(&self, layer: &CALayer, ctx: &CGContext);
1007
1008 #[optional]
1009 #[unsafe(method(layerWillDraw:))]
1010 #[unsafe(method_family = none)]
1011 unsafe fn layerWillDraw(&self, layer: &CALayer);
1012
1013 #[optional]
1014 #[unsafe(method(layoutSublayersOfLayer:))]
1015 #[unsafe(method_family = none)]
1016 unsafe fn layoutSublayersOfLayer(&self, layer: &CALayer);
1017
1018 #[optional]
1019 #[unsafe(method(actionForLayer:forKey:))]
1020 #[unsafe(method_family = none)]
1021 unsafe fn actionForLayer_forKey(
1022 &self,
1023 layer: &CALayer,
1024 event: &NSString,
1025 ) -> Option<Retained<ProtocolObject<dyn CAAction>>>;
1026 }
1027);
1028
1029extern "C" {
1030 pub static kCAGravityCenter: &'static CALayerContentsGravity;
1034}
1035
1036extern "C" {
1037 pub static kCAGravityTop: &'static CALayerContentsGravity;
1039}
1040
1041extern "C" {
1042 pub static kCAGravityBottom: &'static CALayerContentsGravity;
1044}
1045
1046extern "C" {
1047 pub static kCAGravityLeft: &'static CALayerContentsGravity;
1049}
1050
1051extern "C" {
1052 pub static kCAGravityRight: &'static CALayerContentsGravity;
1054}
1055
1056extern "C" {
1057 pub static kCAGravityTopLeft: &'static CALayerContentsGravity;
1059}
1060
1061extern "C" {
1062 pub static kCAGravityTopRight: &'static CALayerContentsGravity;
1064}
1065
1066extern "C" {
1067 pub static kCAGravityBottomLeft: &'static CALayerContentsGravity;
1069}
1070
1071extern "C" {
1072 pub static kCAGravityBottomRight: &'static CALayerContentsGravity;
1074}
1075
1076extern "C" {
1077 pub static kCAGravityResize: &'static CALayerContentsGravity;
1079}
1080
1081extern "C" {
1082 pub static kCAGravityResizeAspect: &'static CALayerContentsGravity;
1084}
1085
1086extern "C" {
1087 pub static kCAGravityResizeAspectFill: &'static CALayerContentsGravity;
1089}
1090
1091extern "C" {
1092 pub static kCAContentsFormatRGBA8Uint: &'static CALayerContentsFormat;
1096}
1097
1098extern "C" {
1099 pub static kCAContentsFormatRGBA16Float: &'static CALayerContentsFormat;
1101}
1102
1103extern "C" {
1104 pub static kCAContentsFormatGray8Uint: &'static CALayerContentsFormat;
1106}
1107
1108extern "C" {
1109 pub static kCAFilterNearest: &'static CALayerContentsFilter;
1113}
1114
1115extern "C" {
1116 pub static kCAFilterLinear: &'static CALayerContentsFilter;
1118}
1119
1120extern "C" {
1121 pub static kCAFilterTrilinear: &'static CALayerContentsFilter;
1123}
1124
1125extern "C" {
1126 pub static kCACornerCurveCircular: &'static CALayerCornerCurve;
1130}
1131
1132extern "C" {
1133 pub static kCACornerCurveContinuous: &'static CALayerCornerCurve;
1135}
1136
1137extern "C" {
1138 pub static kCAOnOrderIn: &'static NSString;
1142}
1143
1144extern "C" {
1145 pub static kCAOnOrderOut: &'static NSString;
1147}
1148
1149extern "C" {
1150 pub static kCATransition: &'static NSString;
1154}