objc2_core_midi/generated/
MIDIMessages.rs1use core::ffi::*;
4#[cfg(feature = "objc2")]
5use objc2::__framework_prelude::*;
6
7use crate::*;
8
9#[repr(transparent)]
12#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
13pub struct MIDIMessageType(pub c_uint);
14impl MIDIMessageType {
15 #[doc(alias = "kMIDIMessageTypeUtility")]
16 pub const Utility: Self = Self(0x0);
17 #[doc(alias = "kMIDIMessageTypeSystem")]
18 pub const System: Self = Self(0x1);
19 #[doc(alias = "kMIDIMessageTypeChannelVoice1")]
20 pub const ChannelVoice1: Self = Self(0x2);
21 #[doc(alias = "kMIDIMessageTypeSysEx")]
22 pub const SysEx: Self = Self(0x3);
23 #[doc(alias = "kMIDIMessageTypeChannelVoice2")]
24 pub const ChannelVoice2: Self = Self(0x4);
25 #[doc(alias = "kMIDIMessageTypeData128")]
26 pub const Data128: Self = Self(0x5);
27 #[doc(alias = "kMIDIMessageTypeFlexData")]
28 pub const FlexData: Self = Self(0xD);
29 #[doc(alias = "kMIDIMessageTypeUnknownF")]
30 pub const UnknownF: Self = Self(0xF);
31 #[doc(alias = "kMIDIMessageTypeStream")]
32 pub const Stream: Self = Self(0xF);
33 #[doc(alias = "kMIDIMessageTypeInvalid")]
34 pub const Invalid: Self = Self(0xFF);
35}
36
37#[cfg(feature = "objc2")]
38unsafe impl Encode for MIDIMessageType {
39 const ENCODING: Encoding = c_uint::ENCODING;
40}
41
42#[cfg(feature = "objc2")]
43unsafe impl RefEncode for MIDIMessageType {
44 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
45}
46
47#[repr(transparent)]
50#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
51pub struct MIDICVStatus(pub c_uint);
52impl MIDICVStatus {
53 #[doc(alias = "kMIDICVStatusNoteOff")]
54 pub const NoteOff: Self = Self(0x8);
55 #[doc(alias = "kMIDICVStatusNoteOn")]
56 pub const NoteOn: Self = Self(0x9);
57 #[doc(alias = "kMIDICVStatusPolyPressure")]
58 pub const PolyPressure: Self = Self(0xA);
59 #[doc(alias = "kMIDICVStatusControlChange")]
60 pub const ControlChange: Self = Self(0xB);
61 #[doc(alias = "kMIDICVStatusProgramChange")]
62 pub const ProgramChange: Self = Self(0xC);
63 #[doc(alias = "kMIDICVStatusChannelPressure")]
64 pub const ChannelPressure: Self = Self(0xD);
65 #[doc(alias = "kMIDICVStatusPitchBend")]
66 pub const PitchBend: Self = Self(0xE);
67 #[doc(alias = "kMIDICVStatusRegisteredPNC")]
68 pub const RegisteredPNC: Self = Self(0x0);
69 #[doc(alias = "kMIDICVStatusAssignablePNC")]
70 pub const AssignablePNC: Self = Self(0x1);
71 #[doc(alias = "kMIDICVStatusRegisteredControl")]
72 pub const RegisteredControl: Self = Self(0x2);
73 #[doc(alias = "kMIDICVStatusAssignableControl")]
74 pub const AssignableControl: Self = Self(0x3);
75 #[doc(alias = "kMIDICVStatusRelRegisteredControl")]
76 pub const RelRegisteredControl: Self = Self(0x4);
77 #[doc(alias = "kMIDICVStatusRelAssignableControl")]
78 pub const RelAssignableControl: Self = Self(0x5);
79 #[doc(alias = "kMIDICVStatusPerNotePitchBend")]
80 pub const PerNotePitchBend: Self = Self(0x6);
81 #[doc(alias = "kMIDICVStatusPerNoteMgmt")]
82 pub const PerNoteMgmt: Self = Self(0xF);
83}
84
85#[cfg(feature = "objc2")]
86unsafe impl Encode for MIDICVStatus {
87 const ENCODING: Encoding = c_uint::ENCODING;
88}
89
90#[cfg(feature = "objc2")]
91unsafe impl RefEncode for MIDICVStatus {
92 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
93}
94
95#[repr(transparent)]
98#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
99pub struct MIDISystemStatus(pub c_uint);
100impl MIDISystemStatus {
101 #[doc(alias = "kMIDIStatusStartOfExclusive")]
102 pub const StatusStartOfExclusive: Self = Self(0xF0);
103 #[doc(alias = "kMIDIStatusEndOfExclusive")]
104 pub const StatusEndOfExclusive: Self = Self(0xF7);
105 #[doc(alias = "kMIDIStatusMTC")]
106 pub const StatusMTC: Self = Self(0xF1);
107 #[doc(alias = "kMIDIStatusSongPosPointer")]
108 pub const StatusSongPosPointer: Self = Self(0xF2);
109 #[doc(alias = "kMIDIStatusSongSelect")]
110 pub const StatusSongSelect: Self = Self(0xF3);
111 #[doc(alias = "kMIDIStatusTuneRequest")]
112 pub const StatusTuneRequest: Self = Self(0xF6);
113 #[doc(alias = "kMIDIStatusTimingClock")]
114 pub const StatusTimingClock: Self = Self(0xF8);
115 #[doc(alias = "kMIDIStatusStart")]
116 pub const StatusStart: Self = Self(0xFA);
117 #[doc(alias = "kMIDIStatusContinue")]
118 pub const StatusContinue: Self = Self(0xFB);
119 #[doc(alias = "kMIDIStatusStop")]
120 pub const StatusStop: Self = Self(0xFC);
121 #[doc(alias = "kMIDIStatusActiveSending")]
122 pub const StatusActiveSending: Self = Self(0xFE);
123 #[doc(alias = "kMIDIStatusActiveSensing")]
124 pub const StatusActiveSensing: Self = Self(MIDISystemStatus::StatusActiveSending.0);
125 #[doc(alias = "kMIDIStatusSystemReset")]
126 pub const StatusSystemReset: Self = Self(0xFF);
127}
128
129#[cfg(feature = "objc2")]
130unsafe impl Encode for MIDISystemStatus {
131 const ENCODING: Encoding = c_uint::ENCODING;
132}
133
134#[cfg(feature = "objc2")]
135unsafe impl RefEncode for MIDISystemStatus {
136 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
137}
138
139#[repr(transparent)]
142#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
143pub struct MIDISysExStatus(pub c_uint);
144impl MIDISysExStatus {
145 #[doc(alias = "kMIDISysExStatusComplete")]
146 pub const Complete: Self = Self(0x0);
147 #[doc(alias = "kMIDISysExStatusStart")]
148 pub const Start: Self = Self(0x1);
149 #[doc(alias = "kMIDISysExStatusContinue")]
150 pub const Continue: Self = Self(0x2);
151 #[doc(alias = "kMIDISysExStatusEnd")]
152 pub const End: Self = Self(0x3);
153 #[doc(alias = "kMIDISysExStatusMixedDataSetHeader")]
154 pub const MixedDataSetHeader: Self = Self(0x8);
155 #[doc(alias = "kMIDISysExStatusMixedDataSetPayload")]
156 pub const MixedDataSetPayload: Self = Self(0x9);
157}
158
159#[cfg(feature = "objc2")]
160unsafe impl Encode for MIDISysExStatus {
161 const ENCODING: Encoding = c_uint::ENCODING;
162}
163
164#[cfg(feature = "objc2")]
165unsafe impl RefEncode for MIDISysExStatus {
166 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
167}
168
169#[repr(transparent)]
172#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
173pub struct MIDIUtilityStatus(pub c_uint);
174impl MIDIUtilityStatus {
175 #[doc(alias = "kMIDIUtilityStatusNOOP")]
176 pub const NOOP: Self = Self(0x0);
177 #[doc(alias = "kMIDIUtilityStatusJitterReductionClock")]
178 pub const JitterReductionClock: Self = Self(0x1);
179 #[doc(alias = "kMIDIUtilityStatusJitterReductionTimestamp")]
180 pub const JitterReductionTimestamp: Self = Self(0x2);
181 #[doc(alias = "kMIDIUtilityStatusDeltaClockstampTicksPerQuarterNote")]
182 pub const DeltaClockstampTicksPerQuarterNote: Self = Self(0x3);
183 #[doc(alias = "kMIDIUtilityStatusTicksSinceLastEvent")]
184 pub const TicksSinceLastEvent: Self = Self(0x4);
185}
186
187#[cfg(feature = "objc2")]
188unsafe impl Encode for MIDIUtilityStatus {
189 const ENCODING: Encoding = c_uint::ENCODING;
190}
191
192#[cfg(feature = "objc2")]
193unsafe impl RefEncode for MIDIUtilityStatus {
194 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
195}
196
197#[repr(transparent)]
200#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
201pub struct UMPStreamMessageStatus(pub c_uint);
202impl UMPStreamMessageStatus {
203 #[doc(alias = "kUMPStreamMessageStatusEndpointDiscovery")]
204 pub const EndpointDiscovery: Self = Self(0x00);
205 #[doc(alias = "kUMPStreamMessageStatusEndpointInfoNotification")]
206 pub const EndpointInfoNotification: Self = Self(0x01);
207 #[doc(alias = "kUMPStreamMessageStatusDeviceIdentityNotification")]
208 pub const DeviceIdentityNotification: Self = Self(0x02);
209 #[doc(alias = "kUMPStreamMessageStatusEndpointNameNotification")]
210 pub const EndpointNameNotification: Self = Self(0x03);
211 #[doc(alias = "kUMPStreamMessageStatusProductInstanceIDNotification")]
212 pub const ProductInstanceIDNotification: Self = Self(0x04);
213 #[doc(alias = "kUMPStreamMessageStatusStreamConfigurationRequest")]
214 pub const StreamConfigurationRequest: Self = Self(0x05);
215 #[doc(alias = "kUMPStreamMessageStatusStreamConfigurationNotification")]
216 pub const StreamConfigurationNotification: Self = Self(0x06);
217 #[doc(alias = "kUMPStreamMessageStatusFunctionBlockDiscovery")]
218 pub const FunctionBlockDiscovery: Self = Self(0x10);
219 #[doc(alias = "kUMPStreamMessageStatusFunctionBlockInfoNotification")]
220 pub const FunctionBlockInfoNotification: Self = Self(0x11);
221 #[doc(alias = "kUMPStreamMessageStatusFunctionBlockNameNotification")]
222 pub const FunctionBlockNameNotification: Self = Self(0x12);
223 #[doc(alias = "kUMPStreamMessageStatusStartOfClip")]
224 pub const StartOfClip: Self = Self(0x20);
225 #[doc(alias = "kUMPStreamMessageStatusEndOfClip")]
226 pub const EndOfClip: Self = Self(0x21);
227}
228
229#[cfg(feature = "objc2")]
230unsafe impl Encode for UMPStreamMessageStatus {
231 const ENCODING: Encoding = c_uint::ENCODING;
232}
233
234#[cfg(feature = "objc2")]
235unsafe impl RefEncode for UMPStreamMessageStatus {
236 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
237}
238
239#[repr(transparent)]
242#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
243pub struct MIDINoteAttribute(pub u8);
244impl MIDINoteAttribute {
245 #[doc(alias = "kMIDINoteAttributeNone")]
246 pub const None: Self = Self(0x0);
247 #[doc(alias = "kMIDINoteAttributeManufacturerSpecific")]
248 pub const ManufacturerSpecific: Self = Self(0x1);
249 #[doc(alias = "kMIDINoteAttributeProfileSpecific")]
250 pub const ProfileSpecific: Self = Self(0x2);
251 #[doc(alias = "kMIDINoteAttributePitch")]
252 pub const Pitch: Self = Self(0x3);
253}
254
255#[cfg(feature = "objc2")]
256unsafe impl Encode for MIDINoteAttribute {
257 const ENCODING: Encoding = u8::ENCODING;
258}
259
260#[cfg(feature = "objc2")]
261unsafe impl RefEncode for MIDINoteAttribute {
262 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
263}
264
265#[repr(transparent)]
268#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
269pub struct MIDIProgramChangeOptions(pub u8);
270bitflags::bitflags! {
271 impl MIDIProgramChangeOptions: u8 {
272 #[doc(alias = "kMIDIProgramChangeBankValid")]
273 const BankValid = 0x1;
274 }
275}
276
277#[cfg(feature = "objc2")]
278unsafe impl Encode for MIDIProgramChangeOptions {
279 const ENCODING: Encoding = u8::ENCODING;
280}
281
282#[cfg(feature = "objc2")]
283unsafe impl RefEncode for MIDIProgramChangeOptions {
284 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
285}
286
287#[repr(transparent)]
290#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
291pub struct MIDIPerNoteManagementOptions(pub u8);
292bitflags::bitflags! {
293 impl MIDIPerNoteManagementOptions: u8 {
294 #[doc(alias = "kMIDIPerNoteManagementReset")]
295 const Reset = 0x1;
296 #[doc(alias = "kMIDIPerNoteManagementDetach")]
297 const Detach = 0x2;
298 }
299}
300
301#[cfg(feature = "objc2")]
302unsafe impl Encode for MIDIPerNoteManagementOptions {
303 const ENCODING: Encoding = u8::ENCODING;
304}
305
306#[cfg(feature = "objc2")]
307unsafe impl RefEncode for MIDIPerNoteManagementOptions {
308 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
309}
310
311#[repr(transparent)]
316#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
317pub struct MIDIUMPFunctionBlockMIDI1Info(pub i32);
318impl MIDIUMPFunctionBlockMIDI1Info {
319 #[doc(alias = "kMIDIUMPFunctionBlockMIDI1InfoNotMIDI1")]
320 pub const NotMIDI1: Self = Self(0);
321 #[doc(alias = "kMIDIUMPFunctionBlockMIDI1InfoUnrestrictedBandwidth")]
322 pub const UnrestrictedBandwidth: Self = Self(1);
323 #[doc(alias = "kMIDIUMPFunctionBlockMIDI1InfoRestrictedBandwidth")]
324 pub const RestrictedBandwidth: Self = Self(2);
325}
326
327#[cfg(feature = "objc2")]
328unsafe impl Encode for MIDIUMPFunctionBlockMIDI1Info {
329 const ENCODING: Encoding = i32::ENCODING;
330}
331
332#[cfg(feature = "objc2")]
333unsafe impl RefEncode for MIDIUMPFunctionBlockMIDI1Info {
334 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
335}
336
337#[repr(transparent)]
342#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
343pub struct MIDIUMPFunctionBlockUIHint(pub i32);
344impl MIDIUMPFunctionBlockUIHint {
345 #[doc(alias = "kMIDIUMPFunctionBlockUIHintUnknown")]
346 pub const Unknown: Self = Self(0);
347 #[doc(alias = "kMIDIUMPFunctionBlockUIHintReceiver")]
348 pub const Receiver: Self = Self(1);
349 #[doc(alias = "kMIDIUMPFunctionBlockUIHintSender")]
350 pub const Sender: Self = Self(2);
351 #[doc(alias = "kMIDIUMPFunctionBlockUIHintSenderReceiver")]
352 pub const SenderReceiver: Self = Self(3);
353}
354
355#[cfg(feature = "objc2")]
356unsafe impl Encode for MIDIUMPFunctionBlockUIHint {
357 const ENCODING: Encoding = i32::ENCODING;
358}
359
360#[cfg(feature = "objc2")]
361unsafe impl RefEncode for MIDIUMPFunctionBlockUIHint {
362 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
363}
364
365#[repr(transparent)]
370#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
371pub struct MIDIUMPFunctionBlockDirection(pub i32);
372impl MIDIUMPFunctionBlockDirection {
373 #[doc(alias = "kMIDIUMPFunctionBlockDirectionUnknown")]
374 pub const Unknown: Self = Self(0);
375 #[doc(alias = "kMIDIUMPFunctionBlockDirectionInput")]
376 pub const Input: Self = Self(1);
377 #[doc(alias = "kMIDIUMPFunctionBlockDirectionOutput")]
378 pub const Output: Self = Self(2);
379 #[doc(alias = "kMIDIUMPFunctionBlockDirectionBidirectional")]
380 pub const Bidirectional: Self = Self(3);
381}
382
383#[cfg(feature = "objc2")]
384unsafe impl Encode for MIDIUMPFunctionBlockDirection {
385 const ENCODING: Encoding = i32::ENCODING;
386}
387
388#[cfg(feature = "objc2")]
389unsafe impl RefEncode for MIDIUMPFunctionBlockDirection {
390 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
391}
392
393#[repr(transparent)]
398#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
399pub struct UMPStreamMessageFormat(pub u8);
400impl UMPStreamMessageFormat {
401 #[doc(alias = "kUMPStreamMessageFormatComplete")]
402 pub const Complete: Self = Self(0x00);
403 #[doc(alias = "kUMPStreamMessageFormatStart")]
404 pub const Start: Self = Self(0x01);
405 #[doc(alias = "kUMPStreamMessageFormatContinuing")]
406 pub const Continuing: Self = Self(0x02);
407 #[doc(alias = "kUMPStreamMessageFormatEnd")]
408 pub const End: Self = Self(0x03);
409}
410
411#[cfg(feature = "objc2")]
412unsafe impl Encode for UMPStreamMessageFormat {
413 const ENCODING: Encoding = u8::ENCODING;
414}
415
416#[cfg(feature = "objc2")]
417unsafe impl RefEncode for UMPStreamMessageFormat {
418 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
419}
420
421pub type MIDIUInteger2 = u8;
425
426pub type MIDIUInteger4 = u8;
430
431pub type MIDIUInteger7 = u8;
435
436pub type MIDIUInteger14 = u16;
440
441pub type MIDIUInteger28 = u32;
445
446pub static kMIDIUInteger2Max: MIDIUInteger2 = 0x3;
450
451pub static kMIDIUInteger4Max: MIDIUInteger4 = 0xF;
453
454pub static kMIDIUInteger7Max: MIDIUInteger7 = 0x7F;
456
457pub static kMIDIUInteger14Max: MIDIUInteger14 = 0x3FFF;
459
460pub static kMIDIUInteger28Max: MIDIUInteger28 = 0xFFFFFFF;
462
463pub type MIDIUMPGroupNumber = MIDIUInteger4;
467
468pub type MIDIChannelNumber = MIDIUInteger4;
473
474pub type MIDICIDeviceID = MIDIUInteger7;
478
479pub static kMIDIDeviceIDUMPGroup: MIDICIDeviceID = 0x7e;
483
484pub static kMIDIDeviceIDFunctionBlock: MIDICIDeviceID = 0x7f;
488
489pub type MIDICIMUID = MIDIUInteger28;
494
495pub type MIDIMessage_32 = u32;
497
498#[repr(C)]
500#[derive(Clone, Copy, Debug, PartialEq)]
501pub struct MIDIMessage_64 {
502 pub word0: u32,
503 pub word1: u32,
504}
505
506#[cfg(feature = "objc2")]
507unsafe impl Encode for MIDIMessage_64 {
508 const ENCODING: Encoding =
509 Encoding::Struct("MIDIMessage_64", &[<u32>::ENCODING, <u32>::ENCODING]);
510}
511
512#[cfg(feature = "objc2")]
513unsafe impl RefEncode for MIDIMessage_64 {
514 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
515}
516
517#[repr(C)]
519#[derive(Clone, Copy, Debug, PartialEq)]
520pub struct MIDIMessage_96 {
521 pub word0: u32,
522 pub word1: u32,
523 pub word2: u32,
524}
525
526#[cfg(feature = "objc2")]
527unsafe impl Encode for MIDIMessage_96 {
528 const ENCODING: Encoding = Encoding::Struct(
529 "MIDIMessage_96",
530 &[<u32>::ENCODING, <u32>::ENCODING, <u32>::ENCODING],
531 );
532}
533
534#[cfg(feature = "objc2")]
535unsafe impl RefEncode for MIDIMessage_96 {
536 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
537}
538
539#[repr(C)]
541#[derive(Clone, Copy, Debug, PartialEq)]
542pub struct MIDIMessage_128 {
543 pub word0: u32,
544 pub word1: u32,
545 pub word2: u32,
546 pub word3: u32,
547}
548
549#[cfg(feature = "objc2")]
550unsafe impl Encode for MIDIMessage_128 {
551 const ENCODING: Encoding = Encoding::Struct(
552 "MIDIMessage_128",
553 &[
554 <u32>::ENCODING,
555 <u32>::ENCODING,
556 <u32>::ENCODING,
557 <u32>::ENCODING,
558 ],
559 );
560}
561
562#[cfg(feature = "objc2")]
563unsafe impl RefEncode for MIDIMessage_128 {
564 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
565}
566
567impl MIDIMessageType {
568 }
570
571pub static kMIDI1UPMaxSysexSize: u8 = 6;
593
594#[repr(C)]
672#[derive(Clone, Copy, Debug, PartialEq)]
673pub struct MIDIUniversalMessage {
674 pub r#type: MIDIMessageType,
676 pub group: u8,
678 pub reserved: [u8; 3],
679}
680
681#[cfg(feature = "objc2")]
682unsafe impl Encode for MIDIUniversalMessage {
683 const ENCODING: Encoding = Encoding::Struct(
684 "MIDIUniversalMessage",
685 &[
686 <MIDIMessageType>::ENCODING,
687 <u8>::ENCODING,
688 <[u8; 3]>::ENCODING,
689 ],
690 );
691}
692
693#[cfg(feature = "objc2")]
694unsafe impl RefEncode for MIDIUniversalMessage {
695 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
696}
697
698#[cfg(feature = "MIDIServices")]
711pub type MIDIEventVisitor =
712 Option<unsafe extern "C-unwind" fn(*mut c_void, MIDITimeStamp, MIDIUniversalMessage)>;
713
714#[cfg(feature = "MIDIServices")]
715impl MIDIEventList {
716 #[doc(alias = "MIDIEventListForEachEvent")]
737 #[cfg(feature = "MIDIServices")]
738 #[inline]
739 pub unsafe fn for_each_event(
740 evtlist: *const MIDIEventList,
741 visitor: MIDIEventVisitor,
742 visitor_context: *mut c_void,
743 ) {
744 extern "C-unwind" {
745 fn MIDIEventListForEachEvent(
746 evtlist: *const MIDIEventList,
747 visitor: MIDIEventVisitor,
748 visitor_context: *mut c_void,
749 );
750 }
751 unsafe { MIDIEventListForEachEvent(evtlist, visitor, visitor_context) }
752 }
753}
754
755extern "C-unwind" {
756 #[cfg(feature = "MIDIServices")]
757 #[deprecated = "renamed to `MIDIEventList::for_each_event`"]
758 pub fn MIDIEventListForEachEvent(
759 evtlist: *const MIDIEventList,
760 visitor: MIDIEventVisitor,
761 visitor_context: *mut c_void,
762 );
763}