1use core::ffi::*;
4use core::ptr::NonNull;
5use objc2::__framework_prelude::*;
6#[cfg(feature = "objc2-core-foundation")]
7use objc2_core_foundation::*;
8use objc2_foundation::*;
9
10use crate::*;
11
12#[cfg(all(
13 feature = "UIResponder",
14 feature = "UIView",
15 feature = "objc2-core-foundation"
16))]
17#[inline]
18pub extern "C-unwind" fn UIAccessibilityConvertFrameToScreenCoordinates(
19 rect: CGRect,
20 view: &UIView,
21) -> CGRect {
22 extern "C-unwind" {
23 fn UIAccessibilityConvertFrameToScreenCoordinates(rect: CGRect, view: &UIView) -> CGRect;
24 }
25 unsafe { UIAccessibilityConvertFrameToScreenCoordinates(rect, view) }
26}
27
28#[cfg(all(feature = "UIBezierPath", feature = "UIResponder", feature = "UIView"))]
29#[inline]
30pub extern "C-unwind" fn UIAccessibilityConvertPathToScreenCoordinates(
31 path: &UIBezierPath,
32 view: &UIView,
33) -> Retained<UIBezierPath> {
34 extern "C-unwind" {
35 fn UIAccessibilityConvertPathToScreenCoordinates(
36 path: &UIBezierPath,
37 view: &UIView,
38 ) -> *mut UIBezierPath;
39 }
40 let ret = unsafe { UIAccessibilityConvertPathToScreenCoordinates(path, view) };
41 unsafe { Retained::retain_autoreleased(ret) }
42 .expect("function was marked as returning non-null, but actually returned NULL")
43}
44
45#[cfg(feature = "block2")]
47pub type AXBoolReturnBlock = *mut block2::DynBlock<dyn Fn() -> Bool>;
48
49#[cfg(feature = "block2")]
51pub type AXStringReturnBlock = *mut block2::DynBlock<dyn Fn() -> *mut NSString>;
52
53#[cfg(feature = "block2")]
55pub type AXStringArrayReturnBlock = *mut block2::DynBlock<dyn Fn() -> *mut NSArray<NSString>>;
56
57#[cfg(feature = "block2")]
59pub type AXAttributedStringReturnBlock = *mut block2::DynBlock<dyn Fn() -> *mut NSAttributedString>;
60
61#[cfg(feature = "block2")]
63pub type AXAttributedStringArrayReturnBlock =
64 *mut block2::DynBlock<dyn Fn() -> *mut NSArray<NSAttributedString>>;
65
66#[cfg(all(feature = "block2", feature = "objc2-core-foundation"))]
68pub type AXRectReturnBlock = *mut block2::DynBlock<dyn Fn() -> CGRect>;
69
70#[cfg(all(feature = "UIBezierPath", feature = "block2"))]
72pub type AXPathReturnBlock = *mut block2::DynBlock<dyn Fn() -> *mut UIBezierPath>;
73
74#[cfg(all(feature = "block2", feature = "objc2-core-foundation"))]
76pub type AXPointReturnBlock = *mut block2::DynBlock<dyn Fn() -> CGPoint>;
77
78#[cfg(feature = "block2")]
80pub type AXObjectReturnBlock = *mut block2::DynBlock<dyn Fn() -> *mut AnyObject>;
81
82#[cfg(feature = "block2")]
84pub type AXArrayReturnBlock = *mut block2::DynBlock<dyn Fn() -> *mut NSArray>;
85
86#[cfg(feature = "block2")]
88pub type AXVoidReturnBlock = *mut block2::DynBlock<dyn Fn()>;
89
90#[cfg(all(feature = "UIAccessibilityConstants", feature = "block2"))]
92pub type AXTraitsReturnBlock = *mut block2::DynBlock<dyn Fn() -> UIAccessibilityTraits>;
93
94#[cfg(all(feature = "UIAccessibilityConstants", feature = "block2"))]
96pub type AXNavigationStyleReturnBlock =
97 *mut block2::DynBlock<dyn Fn() -> UIAccessibilityNavigationStyle>;
98
99#[cfg(all(feature = "UIAccessibilityConstants", feature = "block2"))]
101pub type AXContainerTypeReturnBlock =
102 *mut block2::DynBlock<dyn Fn() -> UIAccessibilityContainerType>;
103
104#[cfg(all(feature = "UIAccessibilityConstants", feature = "block2"))]
106pub type AXTextualContextReturnBlock =
107 *mut block2::DynBlock<dyn Fn() -> *mut UIAccessibilityTextualContext>;
108
109#[cfg(all(feature = "UIAccessibilityCustomAction", feature = "block2"))]
111pub type AXCustomActionsReturnBlock =
112 *mut block2::DynBlock<dyn Fn() -> *mut NSArray<UIAccessibilityCustomAction>>;
113
114#[cfg(all(
116 feature = "UITextInput",
117 feature = "UITextInputTraits",
118 feature = "block2"
119))]
120pub type AXUITextInputReturnBlock =
121 *mut block2::DynBlock<dyn Fn() -> *mut ProtocolObject<dyn UITextInput>>;
122
123mod private_NSObjectUIAccessibility {
124 pub trait Sealed {}
125}
126
127#[doc(alias = "UIAccessibility")]
129pub unsafe trait NSObjectUIAccessibility:
130 ClassType + Sized + private_NSObjectUIAccessibility::Sealed
131{
132 extern_methods!(
133 #[unsafe(method(isAccessibilityElement))]
134 #[unsafe(method_family = none)]
135 fn isAccessibilityElement(&self, mtm: MainThreadMarker) -> bool;
136
137 #[unsafe(method(setIsAccessibilityElement:))]
139 #[unsafe(method_family = none)]
140 fn setIsAccessibilityElement(&self, is_accessibility_element: bool, mtm: MainThreadMarker);
141
142 #[unsafe(method(accessibilityLabel))]
143 #[unsafe(method_family = none)]
144 fn accessibilityLabel(&self, mtm: MainThreadMarker) -> Option<Retained<NSString>>;
145
146 #[unsafe(method(setAccessibilityLabel:))]
150 #[unsafe(method_family = none)]
151 fn setAccessibilityLabel(
152 &self,
153 accessibility_label: Option<&NSString>,
154 mtm: MainThreadMarker,
155 );
156
157 #[unsafe(method(accessibilityAttributedLabel))]
158 #[unsafe(method_family = none)]
159 fn accessibilityAttributedLabel(
160 &self,
161 mtm: MainThreadMarker,
162 ) -> Option<Retained<NSAttributedString>>;
163
164 #[unsafe(method(setAccessibilityAttributedLabel:))]
168 #[unsafe(method_family = none)]
169 fn setAccessibilityAttributedLabel(
170 &self,
171 accessibility_attributed_label: Option<&NSAttributedString>,
172 mtm: MainThreadMarker,
173 );
174
175 #[unsafe(method(accessibilityHint))]
176 #[unsafe(method_family = none)]
177 fn accessibilityHint(&self, mtm: MainThreadMarker) -> Option<Retained<NSString>>;
178
179 #[unsafe(method(setAccessibilityHint:))]
183 #[unsafe(method_family = none)]
184 fn setAccessibilityHint(
185 &self,
186 accessibility_hint: Option<&NSString>,
187 mtm: MainThreadMarker,
188 );
189
190 #[unsafe(method(accessibilityAttributedHint))]
191 #[unsafe(method_family = none)]
192 fn accessibilityAttributedHint(
193 &self,
194 mtm: MainThreadMarker,
195 ) -> Option<Retained<NSAttributedString>>;
196
197 #[unsafe(method(setAccessibilityAttributedHint:))]
201 #[unsafe(method_family = none)]
202 fn setAccessibilityAttributedHint(
203 &self,
204 accessibility_attributed_hint: Option<&NSAttributedString>,
205 mtm: MainThreadMarker,
206 );
207
208 #[unsafe(method(accessibilityValue))]
209 #[unsafe(method_family = none)]
210 fn accessibilityValue(&self, mtm: MainThreadMarker) -> Option<Retained<NSString>>;
211
212 #[unsafe(method(setAccessibilityValue:))]
216 #[unsafe(method_family = none)]
217 fn setAccessibilityValue(
218 &self,
219 accessibility_value: Option<&NSString>,
220 mtm: MainThreadMarker,
221 );
222
223 #[unsafe(method(accessibilityAttributedValue))]
224 #[unsafe(method_family = none)]
225 fn accessibilityAttributedValue(
226 &self,
227 mtm: MainThreadMarker,
228 ) -> Option<Retained<NSAttributedString>>;
229
230 #[unsafe(method(setAccessibilityAttributedValue:))]
234 #[unsafe(method_family = none)]
235 fn setAccessibilityAttributedValue(
236 &self,
237 accessibility_attributed_value: Option<&NSAttributedString>,
238 mtm: MainThreadMarker,
239 );
240
241 #[cfg(feature = "UIAccessibilityConstants")]
242 #[unsafe(method(accessibilityTraits))]
243 #[unsafe(method_family = none)]
244 fn accessibilityTraits(&self, mtm: MainThreadMarker) -> UIAccessibilityTraits;
245
246 #[cfg(feature = "UIAccessibilityConstants")]
247 #[unsafe(method(setAccessibilityTraits:))]
249 #[unsafe(method_family = none)]
250 fn setAccessibilityTraits(
251 &self,
252 accessibility_traits: UIAccessibilityTraits,
253 mtm: MainThreadMarker,
254 );
255
256 #[cfg(feature = "objc2-core-foundation")]
257 #[unsafe(method(accessibilityFrame))]
258 #[unsafe(method_family = none)]
259 fn accessibilityFrame(&self, mtm: MainThreadMarker) -> CGRect;
260
261 #[cfg(feature = "objc2-core-foundation")]
262 #[unsafe(method(setAccessibilityFrame:))]
264 #[unsafe(method_family = none)]
265 fn setAccessibilityFrame(&self, accessibility_frame: CGRect, mtm: MainThreadMarker);
266
267 #[cfg(feature = "UIBezierPath")]
268 #[unsafe(method(accessibilityPath))]
269 #[unsafe(method_family = none)]
270 fn accessibilityPath(&self, mtm: MainThreadMarker) -> Option<Retained<UIBezierPath>>;
271
272 #[cfg(feature = "UIBezierPath")]
273 #[unsafe(method(setAccessibilityPath:))]
277 #[unsafe(method_family = none)]
278 fn setAccessibilityPath(
279 &self,
280 accessibility_path: Option<&UIBezierPath>,
281 mtm: MainThreadMarker,
282 );
283
284 #[cfg(feature = "objc2-core-foundation")]
285 #[unsafe(method(accessibilityActivationPoint))]
286 #[unsafe(method_family = none)]
287 fn accessibilityActivationPoint(&self, mtm: MainThreadMarker) -> CGPoint;
288
289 #[cfg(feature = "objc2-core-foundation")]
290 #[unsafe(method(setAccessibilityActivationPoint:))]
292 #[unsafe(method_family = none)]
293 fn setAccessibilityActivationPoint(
294 &self,
295 accessibility_activation_point: CGPoint,
296 mtm: MainThreadMarker,
297 );
298
299 #[unsafe(method(accessibilityLanguage))]
300 #[unsafe(method_family = none)]
301 fn accessibilityLanguage(&self, mtm: MainThreadMarker) -> Option<Retained<NSString>>;
302
303 #[unsafe(method(setAccessibilityLanguage:))]
305 #[unsafe(method_family = none)]
306 fn setAccessibilityLanguage(
307 &self,
308 accessibility_language: Option<&NSString>,
309 mtm: MainThreadMarker,
310 );
311
312 #[unsafe(method(accessibilityElementsHidden))]
313 #[unsafe(method_family = none)]
314 fn accessibilityElementsHidden(&self, mtm: MainThreadMarker) -> bool;
315
316 #[unsafe(method(setAccessibilityElementsHidden:))]
318 #[unsafe(method_family = none)]
319 fn setAccessibilityElementsHidden(
320 &self,
321 accessibility_elements_hidden: bool,
322 mtm: MainThreadMarker,
323 );
324
325 #[unsafe(method(accessibilityViewIsModal))]
326 #[unsafe(method_family = none)]
327 fn accessibilityViewIsModal(&self, mtm: MainThreadMarker) -> bool;
328
329 #[unsafe(method(setAccessibilityViewIsModal:))]
331 #[unsafe(method_family = none)]
332 fn setAccessibilityViewIsModal(
333 &self,
334 accessibility_view_is_modal: bool,
335 mtm: MainThreadMarker,
336 );
337
338 #[unsafe(method(shouldGroupAccessibilityChildren))]
339 #[unsafe(method_family = none)]
340 fn shouldGroupAccessibilityChildren(&self, mtm: MainThreadMarker) -> bool;
341
342 #[unsafe(method(setShouldGroupAccessibilityChildren:))]
344 #[unsafe(method_family = none)]
345 fn setShouldGroupAccessibilityChildren(
346 &self,
347 should_group_accessibility_children: bool,
348 mtm: MainThreadMarker,
349 );
350
351 #[cfg(feature = "UIAccessibilityConstants")]
352 #[unsafe(method(accessibilityNavigationStyle))]
353 #[unsafe(method_family = none)]
354 fn accessibilityNavigationStyle(
355 &self,
356 mtm: MainThreadMarker,
357 ) -> UIAccessibilityNavigationStyle;
358
359 #[cfg(feature = "UIAccessibilityConstants")]
360 #[unsafe(method(setAccessibilityNavigationStyle:))]
362 #[unsafe(method_family = none)]
363 fn setAccessibilityNavigationStyle(
364 &self,
365 accessibility_navigation_style: UIAccessibilityNavigationStyle,
366 mtm: MainThreadMarker,
367 );
368
369 #[unsafe(method(accessibilityRespondsToUserInteraction))]
370 #[unsafe(method_family = none)]
371 fn accessibilityRespondsToUserInteraction(&self, mtm: MainThreadMarker) -> bool;
372
373 #[unsafe(method(setAccessibilityRespondsToUserInteraction:))]
375 #[unsafe(method_family = none)]
376 fn setAccessibilityRespondsToUserInteraction(
377 &self,
378 accessibility_responds_to_user_interaction: bool,
379 mtm: MainThreadMarker,
380 );
381
382 #[unsafe(method(accessibilityUserInputLabels))]
383 #[unsafe(method_family = none)]
384 fn accessibilityUserInputLabels(
385 &self,
386 mtm: MainThreadMarker,
387 ) -> Option<Retained<NSArray<NSString>>>;
388
389 #[unsafe(method(setAccessibilityUserInputLabels:))]
395 #[unsafe(method_family = none)]
396 unsafe fn setAccessibilityUserInputLabels(
397 &self,
398 accessibility_user_input_labels: Option<&NSArray<NSString>>,
399 mtm: MainThreadMarker,
400 );
401
402 #[unsafe(method(accessibilityAttributedUserInputLabels))]
403 #[unsafe(method_family = none)]
404 fn accessibilityAttributedUserInputLabels(
405 &self,
406 mtm: MainThreadMarker,
407 ) -> Retained<NSArray<NSAttributedString>>;
408
409 #[unsafe(method(setAccessibilityAttributedUserInputLabels:))]
413 #[unsafe(method_family = none)]
414 fn setAccessibilityAttributedUserInputLabels(
415 &self,
416 accessibility_attributed_user_input_labels: Option<&NSArray<NSAttributedString>>,
417 mtm: MainThreadMarker,
418 );
419
420 #[unsafe(method(accessibilityHeaderElements))]
421 #[unsafe(method_family = none)]
422 fn accessibilityHeaderElements(&self, mtm: MainThreadMarker) -> Option<Retained<NSArray>>;
423
424 #[unsafe(method(setAccessibilityHeaderElements:))]
432 #[unsafe(method_family = none)]
433 unsafe fn setAccessibilityHeaderElements(
434 &self,
435 accessibility_header_elements: Option<&NSArray>,
436 mtm: MainThreadMarker,
437 );
438
439 #[cfg(feature = "UIAccessibilityConstants")]
440 #[unsafe(method(accessibilityTextualContext))]
441 #[unsafe(method_family = none)]
442 fn accessibilityTextualContext(
443 &self,
444 mtm: MainThreadMarker,
445 ) -> Option<Retained<UIAccessibilityTextualContext>>;
446
447 #[cfg(feature = "UIAccessibilityConstants")]
448 #[unsafe(method(setAccessibilityTextualContext:))]
450 #[unsafe(method_family = none)]
451 fn setAccessibilityTextualContext(
452 &self,
453 accessibility_textual_context: Option<&UIAccessibilityTextualContext>,
454 mtm: MainThreadMarker,
455 );
456
457 #[cfg(feature = "UIAccessibilityConstants")]
458 #[unsafe(method(accessibilityDirectTouchOptions))]
459 #[unsafe(method_family = none)]
460 fn accessibilityDirectTouchOptions(
461 &self,
462 mtm: MainThreadMarker,
463 ) -> UIAccessibilityDirectTouchOptions;
464
465 #[cfg(feature = "UIAccessibilityConstants")]
466 #[unsafe(method(setAccessibilityDirectTouchOptions:))]
468 #[unsafe(method_family = none)]
469 fn setAccessibilityDirectTouchOptions(
470 &self,
471 accessibility_direct_touch_options: UIAccessibilityDirectTouchOptions,
472 mtm: MainThreadMarker,
473 );
474
475 #[cfg(feature = "UIAccessibilityConstants")]
476 #[unsafe(method(accessibilityExpandedStatus))]
477 #[unsafe(method_family = none)]
478 fn accessibilityExpandedStatus(
479 &self,
480 mtm: MainThreadMarker,
481 ) -> UIAccessibilityExpandedStatus;
482
483 #[cfg(feature = "UIAccessibilityConstants")]
484 #[unsafe(method(setAccessibilityExpandedStatus:))]
486 #[unsafe(method_family = none)]
487 fn setAccessibilityExpandedStatus(
488 &self,
489 accessibility_expanded_status: UIAccessibilityExpandedStatus,
490 mtm: MainThreadMarker,
491 );
492
493 #[cfg(feature = "block2")]
494 #[unsafe(method(isAccessibilityElementBlock))]
495 #[unsafe(method_family = none)]
496 fn isAccessibilityElementBlock(&self, mtm: MainThreadMarker) -> AXBoolReturnBlock;
497
498 #[cfg(feature = "block2")]
499 #[unsafe(method(setIsAccessibilityElementBlock:))]
507 #[unsafe(method_family = none)]
508 unsafe fn setIsAccessibilityElementBlock(
509 &self,
510 is_accessibility_element_block: AXBoolReturnBlock,
511 mtm: MainThreadMarker,
512 );
513
514 #[cfg(feature = "block2")]
515 #[unsafe(method(accessibilityLabelBlock))]
516 #[unsafe(method_family = none)]
517 fn accessibilityLabelBlock(&self, mtm: MainThreadMarker) -> AXStringReturnBlock;
518
519 #[cfg(feature = "block2")]
520 #[unsafe(method(setAccessibilityLabelBlock:))]
528 #[unsafe(method_family = none)]
529 unsafe fn setAccessibilityLabelBlock(
530 &self,
531 accessibility_label_block: AXStringReturnBlock,
532 mtm: MainThreadMarker,
533 );
534
535 #[cfg(feature = "block2")]
536 #[unsafe(method(accessibilityValueBlock))]
537 #[unsafe(method_family = none)]
538 fn accessibilityValueBlock(&self, mtm: MainThreadMarker) -> AXStringReturnBlock;
539
540 #[cfg(feature = "block2")]
541 #[unsafe(method(setAccessibilityValueBlock:))]
549 #[unsafe(method_family = none)]
550 unsafe fn setAccessibilityValueBlock(
551 &self,
552 accessibility_value_block: AXStringReturnBlock,
553 mtm: MainThreadMarker,
554 );
555
556 #[cfg(feature = "block2")]
557 #[unsafe(method(accessibilityHintBlock))]
558 #[unsafe(method_family = none)]
559 fn accessibilityHintBlock(&self, mtm: MainThreadMarker) -> AXStringReturnBlock;
560
561 #[cfg(feature = "block2")]
562 #[unsafe(method(setAccessibilityHintBlock:))]
570 #[unsafe(method_family = none)]
571 unsafe fn setAccessibilityHintBlock(
572 &self,
573 accessibility_hint_block: AXStringReturnBlock,
574 mtm: MainThreadMarker,
575 );
576
577 #[cfg(all(feature = "UIAccessibilityConstants", feature = "block2"))]
578 #[unsafe(method(accessibilityTraitsBlock))]
579 #[unsafe(method_family = none)]
580 fn accessibilityTraitsBlock(&self, mtm: MainThreadMarker) -> AXTraitsReturnBlock;
581
582 #[cfg(all(feature = "UIAccessibilityConstants", feature = "block2"))]
583 #[unsafe(method(setAccessibilityTraitsBlock:))]
591 #[unsafe(method_family = none)]
592 unsafe fn setAccessibilityTraitsBlock(
593 &self,
594 accessibility_traits_block: AXTraitsReturnBlock,
595 mtm: MainThreadMarker,
596 );
597
598 #[cfg(feature = "block2")]
599 #[unsafe(method(accessibilityIdentifierBlock))]
600 #[unsafe(method_family = none)]
601 fn accessibilityIdentifierBlock(&self, mtm: MainThreadMarker) -> AXStringReturnBlock;
602
603 #[cfg(feature = "block2")]
604 #[unsafe(method(setAccessibilityIdentifierBlock:))]
612 #[unsafe(method_family = none)]
613 unsafe fn setAccessibilityIdentifierBlock(
614 &self,
615 accessibility_identifier_block: AXStringReturnBlock,
616 mtm: MainThreadMarker,
617 );
618
619 #[cfg(feature = "block2")]
620 #[unsafe(method(accessibilityHeaderElementsBlock))]
621 #[unsafe(method_family = none)]
622 fn accessibilityHeaderElementsBlock(&self, mtm: MainThreadMarker) -> AXArrayReturnBlock;
623
624 #[cfg(feature = "block2")]
625 #[unsafe(method(setAccessibilityHeaderElementsBlock:))]
633 #[unsafe(method_family = none)]
634 unsafe fn setAccessibilityHeaderElementsBlock(
635 &self,
636 accessibility_header_elements_block: AXArrayReturnBlock,
637 mtm: MainThreadMarker,
638 );
639
640 #[cfg(feature = "block2")]
641 #[unsafe(method(accessibilityAttributedLabelBlock))]
642 #[unsafe(method_family = none)]
643 fn accessibilityAttributedLabelBlock(
644 &self,
645 mtm: MainThreadMarker,
646 ) -> AXAttributedStringReturnBlock;
647
648 #[cfg(feature = "block2")]
649 #[unsafe(method(setAccessibilityAttributedLabelBlock:))]
657 #[unsafe(method_family = none)]
658 unsafe fn setAccessibilityAttributedLabelBlock(
659 &self,
660 accessibility_attributed_label_block: AXAttributedStringReturnBlock,
661 mtm: MainThreadMarker,
662 );
663
664 #[cfg(feature = "block2")]
665 #[unsafe(method(accessibilityAttributedHintBlock))]
666 #[unsafe(method_family = none)]
667 fn accessibilityAttributedHintBlock(
668 &self,
669 mtm: MainThreadMarker,
670 ) -> AXAttributedStringReturnBlock;
671
672 #[cfg(feature = "block2")]
673 #[unsafe(method(setAccessibilityAttributedHintBlock:))]
681 #[unsafe(method_family = none)]
682 unsafe fn setAccessibilityAttributedHintBlock(
683 &self,
684 accessibility_attributed_hint_block: AXAttributedStringReturnBlock,
685 mtm: MainThreadMarker,
686 );
687
688 #[cfg(feature = "block2")]
689 #[unsafe(method(accessibilityLanguageBlock))]
690 #[unsafe(method_family = none)]
691 fn accessibilityLanguageBlock(&self, mtm: MainThreadMarker) -> AXStringReturnBlock;
692
693 #[cfg(feature = "block2")]
694 #[unsafe(method(setAccessibilityLanguageBlock:))]
702 #[unsafe(method_family = none)]
703 unsafe fn setAccessibilityLanguageBlock(
704 &self,
705 accessibility_language_block: AXStringReturnBlock,
706 mtm: MainThreadMarker,
707 );
708
709 #[cfg(all(feature = "UIAccessibilityConstants", feature = "block2"))]
710 #[unsafe(method(accessibilityTextualContextBlock))]
711 #[unsafe(method_family = none)]
712 fn accessibilityTextualContextBlock(
713 &self,
714 mtm: MainThreadMarker,
715 ) -> AXTextualContextReturnBlock;
716
717 #[cfg(all(feature = "UIAccessibilityConstants", feature = "block2"))]
718 #[unsafe(method(setAccessibilityTextualContextBlock:))]
726 #[unsafe(method_family = none)]
727 unsafe fn setAccessibilityTextualContextBlock(
728 &self,
729 accessibility_textual_context_block: AXTextualContextReturnBlock,
730 mtm: MainThreadMarker,
731 );
732
733 #[cfg(feature = "block2")]
734 #[unsafe(method(accessibilityUserInputLabelsBlock))]
735 #[unsafe(method_family = none)]
736 fn accessibilityUserInputLabelsBlock(
737 &self,
738 mtm: MainThreadMarker,
739 ) -> AXStringArrayReturnBlock;
740
741 #[cfg(feature = "block2")]
742 #[unsafe(method(setAccessibilityUserInputLabelsBlock:))]
750 #[unsafe(method_family = none)]
751 unsafe fn setAccessibilityUserInputLabelsBlock(
752 &self,
753 accessibility_user_input_labels_block: AXStringArrayReturnBlock,
754 mtm: MainThreadMarker,
755 );
756
757 #[cfg(feature = "block2")]
758 #[unsafe(method(accessibilityAttributedUserInputLabelsBlock))]
759 #[unsafe(method_family = none)]
760 fn accessibilityAttributedUserInputLabelsBlock(
761 &self,
762 mtm: MainThreadMarker,
763 ) -> AXAttributedStringArrayReturnBlock;
764
765 #[cfg(feature = "block2")]
766 #[unsafe(method(setAccessibilityAttributedUserInputLabelsBlock:))]
774 #[unsafe(method_family = none)]
775 unsafe fn setAccessibilityAttributedUserInputLabelsBlock(
776 &self,
777 accessibility_attributed_user_input_labels_block: AXAttributedStringArrayReturnBlock,
778 mtm: MainThreadMarker,
779 );
780
781 #[cfg(feature = "block2")]
782 #[unsafe(method(accessibilityAttributedValueBlock))]
783 #[unsafe(method_family = none)]
784 fn accessibilityAttributedValueBlock(
785 &self,
786 mtm: MainThreadMarker,
787 ) -> AXAttributedStringReturnBlock;
788
789 #[cfg(feature = "block2")]
790 #[unsafe(method(setAccessibilityAttributedValueBlock:))]
798 #[unsafe(method_family = none)]
799 unsafe fn setAccessibilityAttributedValueBlock(
800 &self,
801 accessibility_attributed_value_block: AXAttributedStringReturnBlock,
802 mtm: MainThreadMarker,
803 );
804
805 #[cfg(feature = "block2")]
806 #[unsafe(method(accessibilityElementsHiddenBlock))]
807 #[unsafe(method_family = none)]
808 fn accessibilityElementsHiddenBlock(&self, mtm: MainThreadMarker) -> AXBoolReturnBlock;
809
810 #[cfg(feature = "block2")]
811 #[unsafe(method(setAccessibilityElementsHiddenBlock:))]
819 #[unsafe(method_family = none)]
820 unsafe fn setAccessibilityElementsHiddenBlock(
821 &self,
822 accessibility_elements_hidden_block: AXBoolReturnBlock,
823 mtm: MainThreadMarker,
824 );
825
826 #[cfg(feature = "block2")]
827 #[unsafe(method(accessibilityRespondsToUserInteractionBlock))]
828 #[unsafe(method_family = none)]
829 fn accessibilityRespondsToUserInteractionBlock(
830 &self,
831 mtm: MainThreadMarker,
832 ) -> AXBoolReturnBlock;
833
834 #[cfg(feature = "block2")]
835 #[unsafe(method(setAccessibilityRespondsToUserInteractionBlock:))]
843 #[unsafe(method_family = none)]
844 unsafe fn setAccessibilityRespondsToUserInteractionBlock(
845 &self,
846 accessibility_responds_to_user_interaction_block: AXBoolReturnBlock,
847 mtm: MainThreadMarker,
848 );
849
850 #[cfg(feature = "block2")]
851 #[unsafe(method(accessibilityViewIsModalBlock))]
852 #[unsafe(method_family = none)]
853 fn accessibilityViewIsModalBlock(&self, mtm: MainThreadMarker) -> AXBoolReturnBlock;
854
855 #[cfg(feature = "block2")]
856 #[unsafe(method(setAccessibilityViewIsModalBlock:))]
864 #[unsafe(method_family = none)]
865 unsafe fn setAccessibilityViewIsModalBlock(
866 &self,
867 accessibility_view_is_modal_block: AXBoolReturnBlock,
868 mtm: MainThreadMarker,
869 );
870
871 #[cfg(feature = "block2")]
872 #[unsafe(method(accessibilityShouldGroupAccessibilityChildrenBlock))]
873 #[unsafe(method_family = none)]
874 fn accessibilityShouldGroupAccessibilityChildrenBlock(
875 &self,
876 mtm: MainThreadMarker,
877 ) -> AXBoolReturnBlock;
878
879 #[cfg(feature = "block2")]
880 #[unsafe(method(setAccessibilityShouldGroupAccessibilityChildrenBlock:))]
888 #[unsafe(method_family = none)]
889 unsafe fn setAccessibilityShouldGroupAccessibilityChildrenBlock(
890 &self,
891 accessibility_should_group_accessibility_children_block: AXBoolReturnBlock,
892 mtm: MainThreadMarker,
893 );
894
895 #[cfg(all(feature = "UIAccessibilityConstants", feature = "block2"))]
896 #[unsafe(method(accessibilityExpandedStatusBlock))]
897 #[unsafe(method_family = none)]
898 fn accessibilityExpandedStatusBlock(
899 &self,
900 mtm: MainThreadMarker,
901 ) -> *mut block2::DynBlock<dyn Fn() -> UIAccessibilityExpandedStatus>;
902
903 #[cfg(all(feature = "UIAccessibilityConstants", feature = "block2"))]
904 #[unsafe(method(setAccessibilityExpandedStatusBlock:))]
908 #[unsafe(method_family = none)]
909 fn setAccessibilityExpandedStatusBlock(
910 &self,
911 accessibility_expanded_status_block: Option<
912 &block2::DynBlock<dyn Fn() -> UIAccessibilityExpandedStatus>,
913 >,
914 mtm: MainThreadMarker,
915 );
916
917 #[cfg(feature = "block2")]
918 #[unsafe(method(accessibilityElementsBlock))]
919 #[unsafe(method_family = none)]
920 fn accessibilityElementsBlock(&self, mtm: MainThreadMarker) -> AXArrayReturnBlock;
921
922 #[cfg(feature = "block2")]
923 #[unsafe(method(setAccessibilityElementsBlock:))]
931 #[unsafe(method_family = none)]
932 unsafe fn setAccessibilityElementsBlock(
933 &self,
934 accessibility_elements_block: AXArrayReturnBlock,
935 mtm: MainThreadMarker,
936 );
937
938 #[cfg(feature = "block2")]
939 #[unsafe(method(automationElementsBlock))]
940 #[unsafe(method_family = none)]
941 fn automationElementsBlock(&self, mtm: MainThreadMarker) -> AXArrayReturnBlock;
942
943 #[cfg(feature = "block2")]
944 #[unsafe(method(setAutomationElementsBlock:))]
952 #[unsafe(method_family = none)]
953 unsafe fn setAutomationElementsBlock(
954 &self,
955 automation_elements_block: AXArrayReturnBlock,
956 mtm: MainThreadMarker,
957 );
958
959 #[cfg(all(feature = "UIAccessibilityConstants", feature = "block2"))]
960 #[unsafe(method(accessibilityContainerTypeBlock))]
961 #[unsafe(method_family = none)]
962 fn accessibilityContainerTypeBlock(
963 &self,
964 mtm: MainThreadMarker,
965 ) -> AXContainerTypeReturnBlock;
966
967 #[cfg(all(feature = "UIAccessibilityConstants", feature = "block2"))]
968 #[unsafe(method(setAccessibilityContainerTypeBlock:))]
976 #[unsafe(method_family = none)]
977 unsafe fn setAccessibilityContainerTypeBlock(
978 &self,
979 accessibility_container_type_block: AXContainerTypeReturnBlock,
980 mtm: MainThreadMarker,
981 );
982
983 #[cfg(all(feature = "block2", feature = "objc2-core-foundation"))]
984 #[unsafe(method(accessibilityActivationPointBlock))]
985 #[unsafe(method_family = none)]
986 fn accessibilityActivationPointBlock(&self, mtm: MainThreadMarker) -> AXPointReturnBlock;
987
988 #[cfg(all(feature = "block2", feature = "objc2-core-foundation"))]
989 #[unsafe(method(setAccessibilityActivationPointBlock:))]
997 #[unsafe(method_family = none)]
998 unsafe fn setAccessibilityActivationPointBlock(
999 &self,
1000 accessibility_activation_point_block: AXPointReturnBlock,
1001 mtm: MainThreadMarker,
1002 );
1003
1004 #[cfg(all(feature = "block2", feature = "objc2-core-foundation"))]
1005 #[unsafe(method(accessibilityFrameBlock))]
1006 #[unsafe(method_family = none)]
1007 fn accessibilityFrameBlock(&self, mtm: MainThreadMarker) -> AXRectReturnBlock;
1008
1009 #[cfg(all(feature = "block2", feature = "objc2-core-foundation"))]
1010 #[unsafe(method(setAccessibilityFrameBlock:))]
1018 #[unsafe(method_family = none)]
1019 unsafe fn setAccessibilityFrameBlock(
1020 &self,
1021 accessibility_frame_block: AXRectReturnBlock,
1022 mtm: MainThreadMarker,
1023 );
1024
1025 #[cfg(all(feature = "UIAccessibilityConstants", feature = "block2"))]
1026 #[unsafe(method(accessibilityNavigationStyleBlock))]
1027 #[unsafe(method_family = none)]
1028 fn accessibilityNavigationStyleBlock(
1029 &self,
1030 mtm: MainThreadMarker,
1031 ) -> AXNavigationStyleReturnBlock;
1032
1033 #[cfg(all(feature = "UIAccessibilityConstants", feature = "block2"))]
1034 #[unsafe(method(setAccessibilityNavigationStyleBlock:))]
1042 #[unsafe(method_family = none)]
1043 unsafe fn setAccessibilityNavigationStyleBlock(
1044 &self,
1045 accessibility_navigation_style_block: AXNavigationStyleReturnBlock,
1046 mtm: MainThreadMarker,
1047 );
1048
1049 #[cfg(all(feature = "UIBezierPath", feature = "block2"))]
1050 #[unsafe(method(accessibilityPathBlock))]
1051 #[unsafe(method_family = none)]
1052 fn accessibilityPathBlock(&self, mtm: MainThreadMarker) -> AXPathReturnBlock;
1053
1054 #[cfg(all(feature = "UIBezierPath", feature = "block2"))]
1055 #[unsafe(method(setAccessibilityPathBlock:))]
1063 #[unsafe(method_family = none)]
1064 unsafe fn setAccessibilityPathBlock(
1065 &self,
1066 accessibility_path_block: AXPathReturnBlock,
1067 mtm: MainThreadMarker,
1068 );
1069
1070 #[cfg(feature = "block2")]
1071 #[unsafe(method(accessibilityActivateBlock))]
1072 #[unsafe(method_family = none)]
1073 fn accessibilityActivateBlock(&self, mtm: MainThreadMarker) -> AXBoolReturnBlock;
1074
1075 #[cfg(feature = "block2")]
1076 #[unsafe(method(setAccessibilityActivateBlock:))]
1084 #[unsafe(method_family = none)]
1085 unsafe fn setAccessibilityActivateBlock(
1086 &self,
1087 accessibility_activate_block: AXBoolReturnBlock,
1088 mtm: MainThreadMarker,
1089 );
1090
1091 #[cfg(feature = "block2")]
1092 #[unsafe(method(accessibilityIncrementBlock))]
1093 #[unsafe(method_family = none)]
1094 fn accessibilityIncrementBlock(&self, mtm: MainThreadMarker) -> AXVoidReturnBlock;
1095
1096 #[cfg(feature = "block2")]
1097 #[unsafe(method(setAccessibilityIncrementBlock:))]
1105 #[unsafe(method_family = none)]
1106 unsafe fn setAccessibilityIncrementBlock(
1107 &self,
1108 accessibility_increment_block: AXVoidReturnBlock,
1109 mtm: MainThreadMarker,
1110 );
1111
1112 #[cfg(feature = "block2")]
1113 #[unsafe(method(accessibilityDecrementBlock))]
1114 #[unsafe(method_family = none)]
1115 fn accessibilityDecrementBlock(&self, mtm: MainThreadMarker) -> AXVoidReturnBlock;
1116
1117 #[cfg(feature = "block2")]
1118 #[unsafe(method(setAccessibilityDecrementBlock:))]
1126 #[unsafe(method_family = none)]
1127 unsafe fn setAccessibilityDecrementBlock(
1128 &self,
1129 accessibility_decrement_block: AXVoidReturnBlock,
1130 mtm: MainThreadMarker,
1131 );
1132
1133 #[cfg(feature = "block2")]
1134 #[unsafe(method(accessibilityPerformEscapeBlock))]
1135 #[unsafe(method_family = none)]
1136 fn accessibilityPerformEscapeBlock(&self, mtm: MainThreadMarker) -> AXBoolReturnBlock;
1137
1138 #[cfg(feature = "block2")]
1139 #[unsafe(method(setAccessibilityPerformEscapeBlock:))]
1147 #[unsafe(method_family = none)]
1148 unsafe fn setAccessibilityPerformEscapeBlock(
1149 &self,
1150 accessibility_perform_escape_block: AXBoolReturnBlock,
1151 mtm: MainThreadMarker,
1152 );
1153
1154 #[cfg(feature = "block2")]
1155 #[unsafe(method(accessibilityMagicTapBlock))]
1156 #[unsafe(method_family = none)]
1157 fn accessibilityMagicTapBlock(&self, mtm: MainThreadMarker) -> AXBoolReturnBlock;
1158
1159 #[cfg(feature = "block2")]
1160 #[unsafe(method(setAccessibilityMagicTapBlock:))]
1168 #[unsafe(method_family = none)]
1169 unsafe fn setAccessibilityMagicTapBlock(
1170 &self,
1171 accessibility_magic_tap_block: AXBoolReturnBlock,
1172 mtm: MainThreadMarker,
1173 );
1174
1175 #[cfg(all(feature = "UIAccessibilityCustomAction", feature = "block2"))]
1176 #[unsafe(method(accessibilityCustomActionsBlock))]
1177 #[unsafe(method_family = none)]
1178 fn accessibilityCustomActionsBlock(
1179 &self,
1180 mtm: MainThreadMarker,
1181 ) -> AXCustomActionsReturnBlock;
1182
1183 #[cfg(all(feature = "UIAccessibilityCustomAction", feature = "block2"))]
1184 #[unsafe(method(setAccessibilityCustomActionsBlock:))]
1192 #[unsafe(method_family = none)]
1193 unsafe fn setAccessibilityCustomActionsBlock(
1194 &self,
1195 accessibility_custom_actions_block: AXCustomActionsReturnBlock,
1196 mtm: MainThreadMarker,
1197 );
1198 );
1199}
1200
1201impl private_NSObjectUIAccessibility::Sealed for NSObject {}
1202unsafe impl NSObjectUIAccessibility for NSObject {}
1203
1204#[cfg(feature = "UIAccessibilityConstants")]
1205#[inline]
1206pub extern "C-unwind" fn UIAccessibilityFocusedElement(
1207 assistive_technology_identifier: Option<&UIAccessibilityAssistiveTechnologyIdentifier>,
1208) -> Option<Retained<AnyObject>> {
1209 extern "C-unwind" {
1210 fn UIAccessibilityFocusedElement(
1211 assistive_technology_identifier: Option<&UIAccessibilityAssistiveTechnologyIdentifier>,
1212 ) -> *mut AnyObject;
1213 }
1214 let ret = unsafe { UIAccessibilityFocusedElement(assistive_technology_identifier) };
1215 unsafe { Retained::retain_autoreleased(ret) }
1216}
1217
1218mod private_NSObjectUIAccessibilityFocus {
1219 pub trait Sealed {}
1220}
1221
1222#[doc(alias = "UIAccessibilityFocus")]
1224pub unsafe trait NSObjectUIAccessibilityFocus:
1225 ClassType + Sized + private_NSObjectUIAccessibilityFocus::Sealed
1226{
1227 extern_methods!(
1228 #[unsafe(method(accessibilityElementDidBecomeFocused))]
1229 #[unsafe(method_family = none)]
1230 fn accessibilityElementDidBecomeFocused(&self, mtm: MainThreadMarker);
1231
1232 #[unsafe(method(accessibilityElementDidLoseFocus))]
1233 #[unsafe(method_family = none)]
1234 fn accessibilityElementDidLoseFocus(&self, mtm: MainThreadMarker);
1235
1236 #[unsafe(method(accessibilityElementIsFocused))]
1237 #[unsafe(method_family = none)]
1238 fn accessibilityElementIsFocused(&self, mtm: MainThreadMarker) -> bool;
1239
1240 #[cfg(feature = "UIAccessibilityConstants")]
1241 #[unsafe(method(accessibilityAssistiveTechnologyFocusedIdentifiers))]
1242 #[unsafe(method_family = none)]
1243 fn accessibilityAssistiveTechnologyFocusedIdentifiers(
1244 &self,
1245 mtm: MainThreadMarker,
1246 ) -> Option<Retained<NSSet<UIAccessibilityAssistiveTechnologyIdentifier>>>;
1247 );
1248}
1249
1250impl private_NSObjectUIAccessibilityFocus::Sealed for NSObject {}
1251unsafe impl NSObjectUIAccessibilityFocus for NSObject {}
1252
1253#[repr(transparent)]
1256#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
1257pub struct UIAccessibilityScrollDirection(pub NSInteger);
1258impl UIAccessibilityScrollDirection {
1259 #[doc(alias = "UIAccessibilityScrollDirectionRight")]
1260 pub const Right: Self = Self(1);
1261 #[doc(alias = "UIAccessibilityScrollDirectionLeft")]
1262 pub const Left: Self = Self(2);
1263 #[doc(alias = "UIAccessibilityScrollDirectionUp")]
1264 pub const Up: Self = Self(3);
1265 #[doc(alias = "UIAccessibilityScrollDirectionDown")]
1266 pub const Down: Self = Self(4);
1267 #[doc(alias = "UIAccessibilityScrollDirectionNext")]
1268 pub const Next: Self = Self(5);
1269 #[doc(alias = "UIAccessibilityScrollDirectionPrevious")]
1270 pub const Previous: Self = Self(6);
1271}
1272
1273unsafe impl Encode for UIAccessibilityScrollDirection {
1274 const ENCODING: Encoding = NSInteger::ENCODING;
1275}
1276
1277unsafe impl RefEncode for UIAccessibilityScrollDirection {
1278 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1279}
1280
1281mod private_NSObjectUIAccessibilityAction {
1282 pub trait Sealed {}
1283}
1284
1285#[doc(alias = "UIAccessibilityAction")]
1287pub unsafe trait NSObjectUIAccessibilityAction:
1288 ClassType + Sized + private_NSObjectUIAccessibilityAction::Sealed
1289{
1290 extern_methods!(
1291 #[unsafe(method(accessibilityActivate))]
1292 #[unsafe(method_family = none)]
1293 fn accessibilityActivate(&self, mtm: MainThreadMarker) -> bool;
1294
1295 #[unsafe(method(accessibilityIncrement))]
1296 #[unsafe(method_family = none)]
1297 fn accessibilityIncrement(&self, mtm: MainThreadMarker);
1298
1299 #[unsafe(method(accessibilityDecrement))]
1300 #[unsafe(method_family = none)]
1301 fn accessibilityDecrement(&self, mtm: MainThreadMarker);
1302
1303 #[cfg(feature = "objc2-core-foundation")]
1304 #[unsafe(method(accessibilityZoomInAtPoint:))]
1305 #[unsafe(method_family = none)]
1306 fn accessibilityZoomInAtPoint(&self, point: CGPoint, mtm: MainThreadMarker) -> bool;
1307
1308 #[cfg(feature = "objc2-core-foundation")]
1309 #[unsafe(method(accessibilityZoomOutAtPoint:))]
1310 #[unsafe(method_family = none)]
1311 fn accessibilityZoomOutAtPoint(&self, point: CGPoint, mtm: MainThreadMarker) -> bool;
1312
1313 #[unsafe(method(accessibilityScroll:))]
1314 #[unsafe(method_family = none)]
1315 fn accessibilityScroll(
1316 &self,
1317 direction: UIAccessibilityScrollDirection,
1318 mtm: MainThreadMarker,
1319 ) -> bool;
1320
1321 #[unsafe(method(accessibilityPerformEscape))]
1322 #[unsafe(method_family = none)]
1323 fn accessibilityPerformEscape(&self, mtm: MainThreadMarker) -> bool;
1324
1325 #[unsafe(method(accessibilityPerformMagicTap))]
1326 #[unsafe(method_family = none)]
1327 fn accessibilityPerformMagicTap(&self, mtm: MainThreadMarker) -> bool;
1328
1329 #[cfg(feature = "UIAccessibilityCustomAction")]
1330 #[unsafe(method(accessibilityCustomActions))]
1331 #[unsafe(method_family = none)]
1332 fn accessibilityCustomActions(
1333 &self,
1334 mtm: MainThreadMarker,
1335 ) -> Option<Retained<NSArray<UIAccessibilityCustomAction>>>;
1336
1337 #[cfg(feature = "UIAccessibilityCustomAction")]
1338 #[unsafe(method(setAccessibilityCustomActions:))]
1340 #[unsafe(method_family = none)]
1341 fn setAccessibilityCustomActions(
1342 &self,
1343 accessibility_custom_actions: Option<&NSArray<UIAccessibilityCustomAction>>,
1344 mtm: MainThreadMarker,
1345 );
1346 );
1347}
1348
1349impl private_NSObjectUIAccessibilityAction::Sealed for NSObject {}
1350unsafe impl NSObjectUIAccessibilityAction for NSObject {}
1351
1352extern_protocol!(
1353 pub unsafe trait UIAccessibilityReadingContent: MainThreadOnly {
1355 #[cfg(feature = "objc2-core-foundation")]
1356 #[unsafe(method(accessibilityLineNumberForPoint:))]
1357 #[unsafe(method_family = none)]
1358 fn accessibilityLineNumberForPoint(&self, point: CGPoint) -> NSInteger;
1359
1360 #[unsafe(method(accessibilityContentForLineNumber:))]
1361 #[unsafe(method_family = none)]
1362 fn accessibilityContentForLineNumber(
1363 &self,
1364 line_number: NSInteger,
1365 ) -> Option<Retained<NSString>>;
1366
1367 #[cfg(feature = "objc2-core-foundation")]
1368 #[unsafe(method(accessibilityFrameForLineNumber:))]
1369 #[unsafe(method_family = none)]
1370 fn accessibilityFrameForLineNumber(&self, line_number: NSInteger) -> CGRect;
1371
1372 #[unsafe(method(accessibilityPageContent))]
1373 #[unsafe(method_family = none)]
1374 fn accessibilityPageContent(&self) -> Option<Retained<NSString>>;
1375
1376 #[optional]
1377 #[unsafe(method(accessibilityAttributedContentForLineNumber:))]
1378 #[unsafe(method_family = none)]
1379 fn accessibilityAttributedContentForLineNumber(
1380 &self,
1381 line_number: NSInteger,
1382 ) -> Option<Retained<NSAttributedString>>;
1383
1384 #[optional]
1385 #[unsafe(method(accessibilityAttributedPageContent))]
1386 #[unsafe(method_family = none)]
1387 fn accessibilityAttributedPageContent(&self) -> Option<Retained<NSAttributedString>>;
1388 }
1389);
1390
1391mod private_NSObjectUIAccessibilityDragging {
1392 pub trait Sealed {}
1393}
1394
1395#[doc(alias = "UIAccessibilityDragging")]
1397pub unsafe trait NSObjectUIAccessibilityDragging:
1398 ClassType + Sized + private_NSObjectUIAccessibilityDragging::Sealed
1399{
1400 extern_methods!(
1401 #[cfg(feature = "UIAccessibilityLocationDescriptor")]
1402 #[unsafe(method(accessibilityDragSourceDescriptors))]
1403 #[unsafe(method_family = none)]
1404 fn accessibilityDragSourceDescriptors(
1405 &self,
1406 mtm: MainThreadMarker,
1407 ) -> Option<Retained<NSArray<UIAccessibilityLocationDescriptor>>>;
1408
1409 #[cfg(feature = "UIAccessibilityLocationDescriptor")]
1410 #[unsafe(method(setAccessibilityDragSourceDescriptors:))]
1414 #[unsafe(method_family = none)]
1415 fn setAccessibilityDragSourceDescriptors(
1416 &self,
1417 accessibility_drag_source_descriptors: Option<
1418 &NSArray<UIAccessibilityLocationDescriptor>,
1419 >,
1420 mtm: MainThreadMarker,
1421 );
1422
1423 #[cfg(feature = "UIAccessibilityLocationDescriptor")]
1424 #[unsafe(method(accessibilityDropPointDescriptors))]
1425 #[unsafe(method_family = none)]
1426 fn accessibilityDropPointDescriptors(
1427 &self,
1428 mtm: MainThreadMarker,
1429 ) -> Option<Retained<NSArray<UIAccessibilityLocationDescriptor>>>;
1430
1431 #[cfg(feature = "UIAccessibilityLocationDescriptor")]
1432 #[unsafe(method(setAccessibilityDropPointDescriptors:))]
1436 #[unsafe(method_family = none)]
1437 fn setAccessibilityDropPointDescriptors(
1438 &self,
1439 accessibility_drop_point_descriptors: Option<
1440 &NSArray<UIAccessibilityLocationDescriptor>,
1441 >,
1442 mtm: MainThreadMarker,
1443 );
1444 );
1445}
1446
1447impl private_NSObjectUIAccessibilityDragging::Sealed for NSObject {}
1448unsafe impl NSObjectUIAccessibilityDragging for NSObject {}
1449
1450mod private_NSObjectUIAccessibilityHitTest {
1451 pub trait Sealed {}
1452}
1453
1454#[doc(alias = "UIAccessibilityHitTest")]
1456pub unsafe trait NSObjectUIAccessibilityHitTest:
1457 ClassType + Sized + private_NSObjectUIAccessibilityHitTest::Sealed
1458{
1459 extern_methods!(
1460 #[cfg(all(feature = "UIEvent", feature = "objc2-core-foundation"))]
1461 #[unsafe(method(accessibilityHitTest:withEvent:))]
1462 #[unsafe(method_family = none)]
1463 fn accessibilityHitTest_withEvent(
1464 &self,
1465 point: CGPoint,
1466 event: Option<&UIEvent>,
1467 mtm: MainThreadMarker,
1468 ) -> Option<Retained<AnyObject>>;
1469 );
1470}
1471
1472impl private_NSObjectUIAccessibilityHitTest::Sealed for NSObject {}
1473unsafe impl NSObjectUIAccessibilityHitTest for NSObject {}
1474
1475mod private_NSObjectUIAccessibilityTextNavigation {
1476 pub trait Sealed {}
1477}
1478
1479#[doc(alias = "UIAccessibilityTextNavigation")]
1481pub unsafe trait NSObjectUIAccessibilityTextNavigation:
1482 ClassType + Sized + private_NSObjectUIAccessibilityTextNavigation::Sealed
1483{
1484 extern_methods!(
1485 #[unsafe(method(accessibilityPreviousTextNavigationElement))]
1486 #[unsafe(method_family = none)]
1487 fn accessibilityPreviousTextNavigationElement(
1488 &self,
1489 mtm: MainThreadMarker,
1490 ) -> Option<Retained<AnyObject>>;
1491
1492 #[unsafe(method(setAccessibilityPreviousTextNavigationElement:))]
1498 #[unsafe(method_family = none)]
1499 unsafe fn setAccessibilityPreviousTextNavigationElement(
1500 &self,
1501 accessibility_previous_text_navigation_element: Option<&AnyObject>,
1502 mtm: MainThreadMarker,
1503 );
1504
1505 #[unsafe(method(accessibilityNextTextNavigationElement))]
1506 #[unsafe(method_family = none)]
1507 fn accessibilityNextTextNavigationElement(
1508 &self,
1509 mtm: MainThreadMarker,
1510 ) -> Option<Retained<AnyObject>>;
1511
1512 #[unsafe(method(setAccessibilityNextTextNavigationElement:))]
1518 #[unsafe(method_family = none)]
1519 unsafe fn setAccessibilityNextTextNavigationElement(
1520 &self,
1521 accessibility_next_text_navigation_element: Option<&AnyObject>,
1522 mtm: MainThreadMarker,
1523 );
1524
1525 #[cfg(feature = "block2")]
1526 #[unsafe(method(accessibilityPreviousTextNavigationElementBlock))]
1527 #[unsafe(method_family = none)]
1528 fn accessibilityPreviousTextNavigationElementBlock(
1529 &self,
1530 mtm: MainThreadMarker,
1531 ) -> AXObjectReturnBlock;
1532
1533 #[cfg(feature = "block2")]
1534 #[unsafe(method(setAccessibilityPreviousTextNavigationElementBlock:))]
1542 #[unsafe(method_family = none)]
1543 unsafe fn setAccessibilityPreviousTextNavigationElementBlock(
1544 &self,
1545 accessibility_previous_text_navigation_element_block: AXObjectReturnBlock,
1546 mtm: MainThreadMarker,
1547 );
1548
1549 #[cfg(feature = "block2")]
1550 #[unsafe(method(accessibilityNextTextNavigationElementBlock))]
1551 #[unsafe(method_family = none)]
1552 fn accessibilityNextTextNavigationElementBlock(
1553 &self,
1554 mtm: MainThreadMarker,
1555 ) -> AXObjectReturnBlock;
1556
1557 #[cfg(feature = "block2")]
1558 #[unsafe(method(setAccessibilityNextTextNavigationElementBlock:))]
1566 #[unsafe(method_family = none)]
1567 unsafe fn setAccessibilityNextTextNavigationElementBlock(
1568 &self,
1569 accessibility_next_text_navigation_element_block: AXObjectReturnBlock,
1570 mtm: MainThreadMarker,
1571 );
1572 );
1573}
1574
1575impl private_NSObjectUIAccessibilityTextNavigation::Sealed for NSObject {}
1576unsafe impl NSObjectUIAccessibilityTextNavigation for NSObject {}
1577
1578mod private_NSObjectUIAccessibilityTextOperations {
1579 pub trait Sealed {}
1580}
1581
1582#[doc(alias = "UIAccessibilityTextOperations")]
1584pub unsafe trait NSObjectUIAccessibilityTextOperations:
1585 ClassType + Sized + private_NSObjectUIAccessibilityTextOperations::Sealed
1586{
1587 extern_methods!(
1588 #[cfg(all(feature = "UITextInput", feature = "UITextInputTraits"))]
1589 #[unsafe(method(accessibilityTextInputResponder))]
1590 #[unsafe(method_family = none)]
1591 fn accessibilityTextInputResponder(
1592 &self,
1593 mtm: MainThreadMarker,
1594 ) -> Option<Retained<ProtocolObject<dyn UITextInput>>>;
1595
1596 #[cfg(all(feature = "UITextInput", feature = "UITextInputTraits"))]
1597 #[unsafe(method(setAccessibilityTextInputResponder:))]
1601 #[unsafe(method_family = none)]
1602 fn setAccessibilityTextInputResponder(
1603 &self,
1604 accessibility_text_input_responder: Option<&ProtocolObject<dyn UITextInput>>,
1605 mtm: MainThreadMarker,
1606 );
1607
1608 #[cfg(all(
1609 feature = "UITextInput",
1610 feature = "UITextInputTraits",
1611 feature = "block2"
1612 ))]
1613 #[unsafe(method(accessibilityTextInputResponderBlock))]
1614 #[unsafe(method_family = none)]
1615 fn accessibilityTextInputResponderBlock(
1616 &self,
1617 mtm: MainThreadMarker,
1618 ) -> AXUITextInputReturnBlock;
1619
1620 #[cfg(all(
1621 feature = "UITextInput",
1622 feature = "UITextInputTraits",
1623 feature = "block2"
1624 ))]
1625 #[unsafe(method(setAccessibilityTextInputResponderBlock:))]
1633 #[unsafe(method_family = none)]
1634 unsafe fn setAccessibilityTextInputResponderBlock(
1635 &self,
1636 accessibility_text_input_responder_block: AXUITextInputReturnBlock,
1637 mtm: MainThreadMarker,
1638 );
1639 );
1640}
1641
1642impl private_NSObjectUIAccessibilityTextOperations::Sealed for NSObject {}
1643unsafe impl NSObjectUIAccessibilityTextOperations for NSObject {}
1644
1645extern "C-unwind" {
1646 #[cfg(feature = "UIAccessibilityConstants")]
1650 pub fn UIAccessibilityPostNotification(
1651 notification: UIAccessibilityNotifications,
1652 argument: Option<&AnyObject>,
1653 );
1654}
1655
1656#[inline]
1657pub extern "C-unwind" fn UIAccessibilityIsVoiceOverRunning() -> bool {
1658 extern "C-unwind" {
1659 fn UIAccessibilityIsVoiceOverRunning() -> Bool;
1660 }
1661 unsafe { UIAccessibilityIsVoiceOverRunning() }.as_bool()
1662}
1663
1664extern "C" {
1665 #[deprecated]
1667 pub static UIAccessibilityVoiceOverStatusChanged: &'static NSString;
1668}
1669
1670extern "C" {
1671 pub static UIAccessibilityVoiceOverStatusDidChangeNotification: &'static NSNotificationName;
1673}
1674
1675#[inline]
1676pub extern "C-unwind" fn UIAccessibilityIsMonoAudioEnabled() -> bool {
1677 extern "C-unwind" {
1678 fn UIAccessibilityIsMonoAudioEnabled() -> Bool;
1679 }
1680 unsafe { UIAccessibilityIsMonoAudioEnabled() }.as_bool()
1681}
1682
1683extern "C" {
1684 pub static UIAccessibilityMonoAudioStatusDidChangeNotification: &'static NSNotificationName;
1686}
1687
1688#[inline]
1689pub extern "C-unwind" fn UIAccessibilityIsClosedCaptioningEnabled() -> bool {
1690 extern "C-unwind" {
1691 fn UIAccessibilityIsClosedCaptioningEnabled() -> Bool;
1692 }
1693 unsafe { UIAccessibilityIsClosedCaptioningEnabled() }.as_bool()
1694}
1695
1696extern "C" {
1697 pub static UIAccessibilityClosedCaptioningStatusDidChangeNotification:
1699 &'static NSNotificationName;
1700}
1701
1702#[inline]
1703pub extern "C-unwind" fn UIAccessibilityIsInvertColorsEnabled() -> bool {
1704 extern "C-unwind" {
1705 fn UIAccessibilityIsInvertColorsEnabled() -> Bool;
1706 }
1707 unsafe { UIAccessibilityIsInvertColorsEnabled() }.as_bool()
1708}
1709
1710extern "C" {
1711 pub static UIAccessibilityInvertColorsStatusDidChangeNotification: &'static NSNotificationName;
1713}
1714
1715#[inline]
1716pub extern "C-unwind" fn UIAccessibilityIsGuidedAccessEnabled() -> bool {
1717 extern "C-unwind" {
1718 fn UIAccessibilityIsGuidedAccessEnabled() -> Bool;
1719 }
1720 unsafe { UIAccessibilityIsGuidedAccessEnabled() }.as_bool()
1721}
1722
1723extern "C" {
1724 pub static UIAccessibilityGuidedAccessStatusDidChangeNotification: &'static NSNotificationName;
1726}
1727
1728#[inline]
1729pub extern "C-unwind" fn UIAccessibilityIsBoldTextEnabled() -> bool {
1730 extern "C-unwind" {
1731 fn UIAccessibilityIsBoldTextEnabled() -> Bool;
1732 }
1733 unsafe { UIAccessibilityIsBoldTextEnabled() }.as_bool()
1734}
1735
1736extern "C" {
1737 pub static UIAccessibilityBoldTextStatusDidChangeNotification: &'static NSNotificationName;
1739}
1740
1741#[inline]
1742pub extern "C-unwind" fn UIAccessibilityButtonShapesEnabled() -> bool {
1743 extern "C-unwind" {
1744 fn UIAccessibilityButtonShapesEnabled() -> Bool;
1745 }
1746 unsafe { UIAccessibilityButtonShapesEnabled() }.as_bool()
1747}
1748
1749extern "C" {
1750 pub static UIAccessibilityButtonShapesEnabledStatusDidChangeNotification:
1752 &'static NSNotificationName;
1753}
1754
1755#[inline]
1756pub extern "C-unwind" fn UIAccessibilityIsGrayscaleEnabled() -> bool {
1757 extern "C-unwind" {
1758 fn UIAccessibilityIsGrayscaleEnabled() -> Bool;
1759 }
1760 unsafe { UIAccessibilityIsGrayscaleEnabled() }.as_bool()
1761}
1762
1763extern "C" {
1764 pub static UIAccessibilityGrayscaleStatusDidChangeNotification: &'static NSNotificationName;
1766}
1767
1768#[inline]
1769pub extern "C-unwind" fn UIAccessibilityIsReduceTransparencyEnabled() -> bool {
1770 extern "C-unwind" {
1771 fn UIAccessibilityIsReduceTransparencyEnabled() -> Bool;
1772 }
1773 unsafe { UIAccessibilityIsReduceTransparencyEnabled() }.as_bool()
1774}
1775
1776extern "C" {
1777 pub static UIAccessibilityReduceTransparencyStatusDidChangeNotification:
1779 &'static NSNotificationName;
1780}
1781
1782#[inline]
1783pub extern "C-unwind" fn UIAccessibilityIsReduceMotionEnabled() -> bool {
1784 extern "C-unwind" {
1785 fn UIAccessibilityIsReduceMotionEnabled() -> Bool;
1786 }
1787 unsafe { UIAccessibilityIsReduceMotionEnabled() }.as_bool()
1788}
1789
1790extern "C" {
1791 pub static UIAccessibilityReduceMotionStatusDidChangeNotification: &'static NSNotificationName;
1793}
1794
1795#[inline]
1796pub extern "C-unwind" fn UIAccessibilityPrefersCrossFadeTransitions() -> bool {
1797 extern "C-unwind" {
1798 fn UIAccessibilityPrefersCrossFadeTransitions() -> Bool;
1799 }
1800 unsafe { UIAccessibilityPrefersCrossFadeTransitions() }.as_bool()
1801}
1802
1803extern "C" {
1804 pub static UIAccessibilityPrefersCrossFadeTransitionsStatusDidChangeNotification:
1806 &'static NSNotificationName;
1807}
1808
1809#[inline]
1810pub extern "C-unwind" fn UIAccessibilityIsVideoAutoplayEnabled() -> bool {
1811 extern "C-unwind" {
1812 fn UIAccessibilityIsVideoAutoplayEnabled() -> Bool;
1813 }
1814 unsafe { UIAccessibilityIsVideoAutoplayEnabled() }.as_bool()
1815}
1816
1817extern "C" {
1818 pub static UIAccessibilityVideoAutoplayStatusDidChangeNotification: &'static NSNotificationName;
1820}
1821
1822#[inline]
1823pub extern "C-unwind" fn UIAccessibilityDarkerSystemColorsEnabled() -> bool {
1824 extern "C-unwind" {
1825 fn UIAccessibilityDarkerSystemColorsEnabled() -> Bool;
1826 }
1827 unsafe { UIAccessibilityDarkerSystemColorsEnabled() }.as_bool()
1828}
1829
1830extern "C" {
1831 pub static UIAccessibilityDarkerSystemColorsStatusDidChangeNotification:
1833 &'static NSNotificationName;
1834}
1835
1836#[inline]
1837pub extern "C-unwind" fn UIAccessibilityIsSwitchControlRunning() -> bool {
1838 extern "C-unwind" {
1839 fn UIAccessibilityIsSwitchControlRunning() -> Bool;
1840 }
1841 unsafe { UIAccessibilityIsSwitchControlRunning() }.as_bool()
1842}
1843
1844extern "C" {
1845 pub static UIAccessibilitySwitchControlStatusDidChangeNotification: &'static NSNotificationName;
1847}
1848
1849#[inline]
1850pub extern "C-unwind" fn UIAccessibilityIsSpeakSelectionEnabled() -> bool {
1851 extern "C-unwind" {
1852 fn UIAccessibilityIsSpeakSelectionEnabled() -> Bool;
1853 }
1854 unsafe { UIAccessibilityIsSpeakSelectionEnabled() }.as_bool()
1855}
1856
1857extern "C" {
1858 pub static UIAccessibilitySpeakSelectionStatusDidChangeNotification:
1860 &'static NSNotificationName;
1861}
1862
1863#[inline]
1864pub extern "C-unwind" fn UIAccessibilityIsSpeakScreenEnabled() -> bool {
1865 extern "C-unwind" {
1866 fn UIAccessibilityIsSpeakScreenEnabled() -> Bool;
1867 }
1868 unsafe { UIAccessibilityIsSpeakScreenEnabled() }.as_bool()
1869}
1870
1871extern "C" {
1872 pub static UIAccessibilitySpeakScreenStatusDidChangeNotification: &'static NSNotificationName;
1874}
1875
1876#[inline]
1877pub extern "C-unwind" fn UIAccessibilityIsShakeToUndoEnabled() -> bool {
1878 extern "C-unwind" {
1879 fn UIAccessibilityIsShakeToUndoEnabled() -> Bool;
1880 }
1881 unsafe { UIAccessibilityIsShakeToUndoEnabled() }.as_bool()
1882}
1883
1884extern "C" {
1885 pub static UIAccessibilityShakeToUndoDidChangeNotification: &'static NSNotificationName;
1887}
1888
1889#[inline]
1890pub extern "C-unwind" fn UIAccessibilityIsAssistiveTouchRunning() -> bool {
1891 extern "C-unwind" {
1892 fn UIAccessibilityIsAssistiveTouchRunning() -> Bool;
1893 }
1894 unsafe { UIAccessibilityIsAssistiveTouchRunning() }.as_bool()
1895}
1896
1897extern "C" {
1898 pub static UIAccessibilityAssistiveTouchStatusDidChangeNotification:
1900 &'static NSNotificationName;
1901}
1902
1903#[inline]
1904pub extern "C-unwind" fn UIAccessibilityShouldDifferentiateWithoutColor() -> bool {
1905 extern "C-unwind" {
1906 fn UIAccessibilityShouldDifferentiateWithoutColor() -> Bool;
1907 }
1908 unsafe { UIAccessibilityShouldDifferentiateWithoutColor() }.as_bool()
1909}
1910
1911extern "C" {
1912 pub static UIAccessibilityShouldDifferentiateWithoutColorDidChangeNotification:
1914 &'static NSNotificationName;
1915}
1916
1917#[inline]
1918pub extern "C-unwind" fn UIAccessibilityIsOnOffSwitchLabelsEnabled() -> bool {
1919 extern "C-unwind" {
1920 fn UIAccessibilityIsOnOffSwitchLabelsEnabled() -> Bool;
1921 }
1922 unsafe { UIAccessibilityIsOnOffSwitchLabelsEnabled() }.as_bool()
1923}
1924
1925extern "C" {
1926 pub static UIAccessibilityOnOffSwitchLabelsDidChangeNotification: &'static NSNotificationName;
1928}
1929
1930#[cfg(feature = "block2")]
1931#[inline]
1932pub extern "C-unwind" fn UIAccessibilityRequestGuidedAccessSession(
1933 enable: bool,
1934 completion_handler: &block2::DynBlock<dyn Fn(Bool)>,
1935) {
1936 extern "C-unwind" {
1937 fn UIAccessibilityRequestGuidedAccessSession(
1938 enable: Bool,
1939 completion_handler: &block2::DynBlock<dyn Fn(Bool)>,
1940 );
1941 }
1942 unsafe { UIAccessibilityRequestGuidedAccessSession(Bool::new(enable), completion_handler) }
1943}
1944
1945#[repr(transparent)]
1948#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
1949pub struct UIAccessibilityHearingDeviceEar(pub NSUInteger);
1950bitflags::bitflags! {
1951 impl UIAccessibilityHearingDeviceEar: NSUInteger {
1952 #[doc(alias = "UIAccessibilityHearingDeviceEarNone")]
1953 const None = 0;
1954 #[doc(alias = "UIAccessibilityHearingDeviceEarLeft")]
1955 const Left = 1<<1;
1956 #[doc(alias = "UIAccessibilityHearingDeviceEarRight")]
1957 const Right = 1<<2;
1958 #[doc(alias = "UIAccessibilityHearingDeviceEarBoth")]
1959 const Both = UIAccessibilityHearingDeviceEar::Left.0|UIAccessibilityHearingDeviceEar::Right.0;
1960 }
1961}
1962
1963unsafe impl Encode for UIAccessibilityHearingDeviceEar {
1964 const ENCODING: Encoding = NSUInteger::ENCODING;
1965}
1966
1967unsafe impl RefEncode for UIAccessibilityHearingDeviceEar {
1968 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1969}
1970
1971#[inline]
1972pub extern "C-unwind" fn UIAccessibilityHearingDevicePairedEar() -> UIAccessibilityHearingDeviceEar
1973{
1974 extern "C-unwind" {
1975 fn UIAccessibilityHearingDevicePairedEar() -> UIAccessibilityHearingDeviceEar;
1976 }
1977 unsafe { UIAccessibilityHearingDevicePairedEar() }
1978}
1979
1980extern "C" {
1981 pub static UIAccessibilityHearingDevicePairedEarDidChangeNotification:
1983 &'static NSNotificationName;
1984}