1#[repr(C)]
2#[derive(Copy, Clone)]
3pub struct wl_display {
4 _private: [u8; 0],
5}
6unsafe impl Send for wl_display {}
7unsafe impl Sync for wl_display {}
8#[repr(C)]
9#[derive(Copy, Clone)]
10pub struct wl_surface {
11 _private: [u8; 0],
12}
13unsafe impl Send for wl_surface {}
14unsafe impl Sync for wl_surface {}
15#[repr(C)]
16#[derive(Copy, Clone)]
17pub struct xdg_surface {
18 _private: [u8; 0],
19}
20unsafe impl Send for xdg_surface {}
21unsafe impl Sync for xdg_surface {}
22#[repr(C)]
23#[derive(Copy, Clone)]
24pub struct xdg_toplevel {
25 _private: [u8; 0],
26}
27unsafe impl Send for xdg_toplevel {}
28unsafe impl Sync for xdg_toplevel {}
29pub mod Steinberg {
30 #[allow(unused_imports)]
31 use super::*;
32 pub type CString = *const tchar;
33 pub type CStringA = *const char8;
34 pub type CStringW = *const char16;
35 pub type ColorComponent = uint8;
36 pub type ColorSpec = uint32;
37 pub type Direction = crate::support::DefaultEnumType;
38 pub mod Direction_ {
39 #[allow(unused_imports)]
40 use super::*;
41 pub const kEast: Direction = 2;
42 pub const kNoDirection: Direction = 8;
43 pub const kNorth: Direction = 0;
44 pub const kNorthEast: Direction = 1;
45 pub const kNorthWest: Direction = 7;
46 pub const kNumberOfDirections: Direction = 9;
47 pub const kSouth: Direction = 4;
48 pub const kSouthEast: Direction = 3;
49 pub const kSouthWest: Direction = 5;
50 pub const kWest: Direction = 6;
51 }
52 pub type FIDString = *const char8;
53 pub type IAttrID = FIDString;
54 pub type KeyModifier = crate::support::DefaultEnumType;
55 pub mod KeyModifier_ {
56 #[allow(unused_imports)]
57 use super::*;
58 pub const kAlternateKey: KeyModifier = 2;
59 pub const kCommandKey: KeyModifier = 4;
60 pub const kControlKey: KeyModifier = 8;
61 pub const kShiftKey: KeyModifier = 1;
62 }
63 pub type Orientation = crate::support::DefaultEnumType;
64 pub mod Orientation_ {
65 #[allow(unused_imports)]
66 use super::*;
67 pub const kHorizontal: Orientation = 0;
68 pub const kNumberOfOrientations: Orientation = 2;
69 pub const kVertical: Orientation = 1;
70 }
71 pub type StandardColor = crate::support::DefaultEnumType;
72 pub mod StandardColor_ {
73 #[allow(unused_imports)]
74 use super::*;
75 pub const kBlack: StandardColor = 0;
76 pub const kBlack50: StandardColor = 31;
77 pub const kBlack70: StandardColor = 32;
78 pub const kBlue: StandardColor = 18;
79 pub const kDkBlue: StandardColor = 20;
80 pub const kDkGray: StandardColor = 9;
81 pub const kDkGreen: StandardColor = 17;
82 pub const kDkMagenta: StandardColor = 23;
83 pub const kDkOrange: StandardColor = 29;
84 pub const kDkRed: StandardColor = 14;
85 pub const kDkYellow: StandardColor = 26;
86 pub const kGold: StandardColor = 30;
87 pub const kGray: StandardColor = 7;
88 pub const kGray10: StandardColor = 3;
89 pub const kGray20: StandardColor = 4;
90 pub const kGray30: StandardColor = 5;
91 pub const kGray40: StandardColor = 6;
92 pub const kGray5: StandardColor = 2;
93 pub const kGray50: StandardColor = 7;
94 pub const kGray60: StandardColor = 8;
95 pub const kGray70: StandardColor = 9;
96 pub const kGray80: StandardColor = 10;
97 pub const kGray90: StandardColor = 11;
98 pub const kGreen: StandardColor = 15;
99 pub const kLtBlue: StandardColor = 19;
100 pub const kLtGray: StandardColor = 4;
101 pub const kLtGreen: StandardColor = 16;
102 pub const kLtMagenta: StandardColor = 22;
103 pub const kLtOrange: StandardColor = 28;
104 pub const kLtRed: StandardColor = 13;
105 pub const kLtYellow: StandardColor = 25;
106 pub const kMagenta: StandardColor = 21;
107 pub const kNumStandardColors: StandardColor = 33;
108 pub const kOrange: StandardColor = 27;
109 pub const kRed: StandardColor = 12;
110 pub const kWhite: StandardColor = 1;
111 pub const kYellow: StandardColor = 24;
112 }
113 pub type TBool = uint8;
114 pub type TPtrInt = uint64;
115 pub type TSize = int64;
116 pub type TUID = [::std::ffi::c_char; 16];
117 pub type UColorComponent = ColorComponent;
118 pub type UColorSpec = ColorSpec;
119 pub type UCoord = int32;
120 pub type VirtualKeyCodes = crate::support::DefaultEnumType;
121 pub mod VirtualKeyCodes_ {
122 #[allow(unused_imports)]
123 use super::*;
124 pub const KEY_ADD: VirtualKeyCodes = 35;
125 pub const KEY_ALT: VirtualKeyCodes = 56;
126 pub const KEY_BACK: VirtualKeyCodes = 1;
127 pub const KEY_CLEAR: VirtualKeyCodes = 3;
128 pub const KEY_CONTEXTMENU: VirtualKeyCodes = 58;
129 pub const KEY_CONTROL: VirtualKeyCodes = 55;
130 pub const KEY_DECIMAL: VirtualKeyCodes = 38;
131 pub const KEY_DELETE: VirtualKeyCodes = 22;
132 pub const KEY_DIVIDE: VirtualKeyCodes = 39;
133 pub const KEY_DOWN: VirtualKeyCodes = 14;
134 pub const KEY_END: VirtualKeyCodes = 9;
135 pub const KEY_ENTER: VirtualKeyCodes = 19;
136 pub const KEY_EQUALS: VirtualKeyCodes = 57;
137 pub const KEY_ESCAPE: VirtualKeyCodes = 6;
138 pub const KEY_F1: VirtualKeyCodes = 40;
139 pub const KEY_F10: VirtualKeyCodes = 49;
140 pub const KEY_F11: VirtualKeyCodes = 50;
141 pub const KEY_F12: VirtualKeyCodes = 51;
142 pub const KEY_F13: VirtualKeyCodes = 65;
143 pub const KEY_F14: VirtualKeyCodes = 66;
144 pub const KEY_F15: VirtualKeyCodes = 67;
145 pub const KEY_F16: VirtualKeyCodes = 68;
146 pub const KEY_F17: VirtualKeyCodes = 69;
147 pub const KEY_F18: VirtualKeyCodes = 70;
148 pub const KEY_F19: VirtualKeyCodes = 71;
149 pub const KEY_F2: VirtualKeyCodes = 41;
150 pub const KEY_F20: VirtualKeyCodes = 72;
151 pub const KEY_F21: VirtualKeyCodes = 73;
152 pub const KEY_F22: VirtualKeyCodes = 74;
153 pub const KEY_F23: VirtualKeyCodes = 75;
154 pub const KEY_F24: VirtualKeyCodes = 76;
155 pub const KEY_F3: VirtualKeyCodes = 42;
156 pub const KEY_F4: VirtualKeyCodes = 43;
157 pub const KEY_F5: VirtualKeyCodes = 44;
158 pub const KEY_F6: VirtualKeyCodes = 45;
159 pub const KEY_F7: VirtualKeyCodes = 46;
160 pub const KEY_F8: VirtualKeyCodes = 47;
161 pub const KEY_F9: VirtualKeyCodes = 48;
162 pub const KEY_HELP: VirtualKeyCodes = 23;
163 pub const KEY_HOME: VirtualKeyCodes = 10;
164 pub const KEY_INSERT: VirtualKeyCodes = 21;
165 pub const KEY_LEFT: VirtualKeyCodes = 11;
166 pub const KEY_MEDIA_NEXT: VirtualKeyCodes = 62;
167 pub const KEY_MEDIA_PLAY: VirtualKeyCodes = 59;
168 pub const KEY_MEDIA_PREV: VirtualKeyCodes = 61;
169 pub const KEY_MEDIA_STOP: VirtualKeyCodes = 60;
170 pub const KEY_MULTIPLY: VirtualKeyCodes = 34;
171 pub const KEY_NEXT: VirtualKeyCodes = 8;
172 pub const KEY_NUMLOCK: VirtualKeyCodes = 52;
173 pub const KEY_NUMPAD0: VirtualKeyCodes = 24;
174 pub const KEY_NUMPAD1: VirtualKeyCodes = 25;
175 pub const KEY_NUMPAD2: VirtualKeyCodes = 26;
176 pub const KEY_NUMPAD3: VirtualKeyCodes = 27;
177 pub const KEY_NUMPAD4: VirtualKeyCodes = 28;
178 pub const KEY_NUMPAD5: VirtualKeyCodes = 29;
179 pub const KEY_NUMPAD6: VirtualKeyCodes = 30;
180 pub const KEY_NUMPAD7: VirtualKeyCodes = 31;
181 pub const KEY_NUMPAD8: VirtualKeyCodes = 32;
182 pub const KEY_NUMPAD9: VirtualKeyCodes = 33;
183 pub const KEY_PAGEDOWN: VirtualKeyCodes = 16;
184 pub const KEY_PAGEUP: VirtualKeyCodes = 15;
185 pub const KEY_PAUSE: VirtualKeyCodes = 5;
186 pub const KEY_PRINT: VirtualKeyCodes = 18;
187 pub const KEY_RETURN: VirtualKeyCodes = 4;
188 pub const KEY_RIGHT: VirtualKeyCodes = 13;
189 pub const KEY_SCROLL: VirtualKeyCodes = 53;
190 pub const KEY_SELECT: VirtualKeyCodes = 17;
191 pub const KEY_SEPARATOR: VirtualKeyCodes = 36;
192 pub const KEY_SHIFT: VirtualKeyCodes = 54;
193 pub const KEY_SNAPSHOT: VirtualKeyCodes = 20;
194 pub const KEY_SPACE: VirtualKeyCodes = 7;
195 pub const KEY_SUBTRACT: VirtualKeyCodes = 37;
196 pub const KEY_SUPER: VirtualKeyCodes = 77;
197 pub const KEY_TAB: VirtualKeyCodes = 2;
198 pub const KEY_UP: VirtualKeyCodes = 12;
199 pub const KEY_VOLUME_DOWN: VirtualKeyCodes = 64;
200 pub const KEY_VOLUME_UP: VirtualKeyCodes = 63;
201 pub const VKEY_FIRST_ASCII: VirtualKeyCodes = 128;
202 pub const VKEY_FIRST_CODE: VirtualKeyCodes = 1;
203 pub const VKEY_LAST_CODE: VirtualKeyCodes = 77;
204 }
205 pub type char16 = u16;
206 pub type char8 = ::std::ffi::c_char;
207 pub type int16 = i16;
208 pub type int32 = i32;
209 pub type int64 = i64;
210 pub type int8 = ::std::ffi::c_char;
211 pub type tchar = char16;
212 pub type tresult = int32;
213 pub type uchar = ::std::ffi::c_uchar;
214 pub type uint16 = u16;
215 pub type uint32 = u32;
216 pub type uint64 = u64;
217 pub type uint8 = u8;
218 #[repr(C)]
219 #[derive(Copy, Clone)]
220 pub struct FUnknown {
221 pub vtbl: *const FUnknownVtbl,
222 }
223 unsafe impl Send for FUnknown {}
224 unsafe impl Sync for FUnknown {}
225 impl ::com_scrape_types::Unknown for FUnknown {
226 #[inline]
227 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
228 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
229 }
230 #[inline]
231 unsafe fn add_ref(this: *mut Self) -> usize {
232 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
233 }
234 #[inline]
235 unsafe fn release(this: *mut Self) -> usize {
236 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
237 }
238 }
239 unsafe impl ::com_scrape_types::Interface for FUnknown {
240 type Vtbl = FUnknownVtbl;
241 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(FUnknown_iid);
242 #[inline]
243 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
244 iid == &Self::IID
245 }
246 }
247 #[repr(C)]
248 #[derive(Copy, Clone)]
249 pub struct FUnknownVtbl {
250 pub queryInterface: unsafe extern "system" fn(
251 this: *mut FUnknown,
252 _iid: *const TUID,
253 obj: *mut *mut ::std::ffi::c_void,
254 ) -> tresult,
255 pub addRef: unsafe extern "system" fn(
256 this: *mut FUnknown,
257 ) -> uint32,
258 pub release: unsafe extern "system" fn(
259 this: *mut FUnknown,
260 ) -> uint32,
261 }
262 mod __FVariant_wrapper {
263 #[allow(unused_imports)]
264 use super::*;
265 #[allow(unused_imports)]
266 use super::FVariant_::*;
267 #[repr(C)]
268 #[derive(Copy, Clone)]
269 pub struct FVariant {
270 pub r#type: uint16,
271 pub __field0: FVariant__type0,
272 }
273 unsafe impl Send for FVariant {}
274 unsafe impl Sync for FVariant {}
275 }
276 pub use __FVariant_wrapper::*;
277 pub mod FVariant_ {
278 #[allow(unused_imports)]
279 use super::*;
280 pub const kEmpty: crate::support::DefaultEnumType = 0;
281 pub const kFloat: crate::support::DefaultEnumType = 2;
282 pub const kInteger: crate::support::DefaultEnumType = 1;
283 pub const kObject: crate::support::DefaultEnumType = 8;
284 pub const kOwner: crate::support::DefaultEnumType = 16;
285 pub const kString16: crate::support::DefaultEnumType = 32;
286 pub const kString8: crate::support::DefaultEnumType = 4;
287 }
288 #[repr(C)]
289 #[derive(Copy, Clone)]
290 pub union FVariant__type0 {
291 pub intValue: int64,
292 pub floatValue: f64,
293 pub string8: *const char8,
294 pub string16: *const char16,
295 pub object: *mut FUnknown,
296 }
297 unsafe impl Send for FVariant__type0 {}
298 unsafe impl Sync for FVariant__type0 {}
299 #[repr(C)]
300 #[derive(Copy, Clone)]
301 pub struct IAttributes {
302 pub vtbl: *const IAttributesVtbl,
303 }
304 unsafe impl Send for IAttributes {}
305 unsafe impl Sync for IAttributes {}
306 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IAttributes {}
307 impl ::com_scrape_types::Unknown for IAttributes {
308 #[inline]
309 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
310 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
311 }
312 #[inline]
313 unsafe fn add_ref(this: *mut Self) -> usize {
314 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
315 }
316 #[inline]
317 unsafe fn release(this: *mut Self) -> usize {
318 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
319 }
320 }
321 unsafe impl ::com_scrape_types::Interface for IAttributes {
322 type Vtbl = IAttributesVtbl;
323 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IAttributes_iid);
324 #[inline]
325 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
326 iid == &Self::IID || FUnknown::inherits(iid)
327 }
328 }
329 #[repr(C)]
330 #[derive(Copy, Clone)]
331 pub struct IAttributesVtbl {
332 pub base: FUnknownVtbl,
333 pub set: unsafe extern "system" fn(
334 this: *mut IAttributes,
335 attrID: IAttrID,
336 data: *const FVariant,
337 ) -> tresult,
338 pub queue: unsafe extern "system" fn(
339 this: *mut IAttributes,
340 listID: IAttrID,
341 data: *const FVariant,
342 ) -> tresult,
343 pub setBinaryData: unsafe extern "system" fn(
344 this: *mut IAttributes,
345 attrID: IAttrID,
346 data: *mut ::std::ffi::c_void,
347 bytes: uint32,
348 copyBytes: bool,
349 ) -> tresult,
350 pub get: unsafe extern "system" fn(
351 this: *mut IAttributes,
352 attrID: IAttrID,
353 data: *mut FVariant,
354 ) -> tresult,
355 pub unqueue: unsafe extern "system" fn(
356 this: *mut IAttributes,
357 listID: IAttrID,
358 data: *mut FVariant,
359 ) -> tresult,
360 pub getQueueItemCount: unsafe extern "system" fn(
361 this: *mut IAttributes,
362 attrId: IAttrID,
363 ) -> int32,
364 pub resetQueue: unsafe extern "system" fn(
365 this: *mut IAttributes,
366 attrID: IAttrID,
367 ) -> tresult,
368 pub resetAllQueues: unsafe extern "system" fn(
369 this: *mut IAttributes,
370 ) -> tresult,
371 pub getBinaryData: unsafe extern "system" fn(
372 this: *mut IAttributes,
373 attrID: IAttrID,
374 data: *mut ::std::ffi::c_void,
375 bytes: uint32,
376 ) -> tresult,
377 pub getBinaryDataSize: unsafe extern "system" fn(
378 this: *mut IAttributes,
379 attrID: IAttrID,
380 ) -> uint32,
381 }
382 pub trait IAttributesTrait {
383 unsafe fn set(
384 &self,
385 attrID: IAttrID,
386 data: *const FVariant,
387 ) -> tresult;
388 unsafe fn queue(
389 &self,
390 listID: IAttrID,
391 data: *const FVariant,
392 ) -> tresult;
393 unsafe fn setBinaryData(
394 &self,
395 attrID: IAttrID,
396 data: *mut ::std::ffi::c_void,
397 bytes: uint32,
398 copyBytes: bool,
399 ) -> tresult;
400 unsafe fn get(
401 &self,
402 attrID: IAttrID,
403 data: *mut FVariant,
404 ) -> tresult;
405 unsafe fn unqueue(
406 &self,
407 listID: IAttrID,
408 data: *mut FVariant,
409 ) -> tresult;
410 unsafe fn getQueueItemCount(
411 &self,
412 attrId: IAttrID,
413 ) -> int32;
414 unsafe fn resetQueue(
415 &self,
416 attrID: IAttrID,
417 ) -> tresult;
418 unsafe fn resetAllQueues(
419 &self,
420 ) -> tresult;
421 unsafe fn getBinaryData(
422 &self,
423 attrID: IAttrID,
424 data: *mut ::std::ffi::c_void,
425 bytes: uint32,
426 ) -> tresult;
427 unsafe fn getBinaryDataSize(
428 &self,
429 attrID: IAttrID,
430 ) -> uint32;
431 }
432 impl<P> IAttributesTrait for P
433 where
434 P: ::com_scrape_types::SmartPtr,
435 P::Target: ::com_scrape_types::Inherits<IAttributes>,
436 {
437 #[inline]
438 unsafe fn set(
439 &self,
440 attrID: IAttrID,
441 data: *const FVariant,
442 ) -> tresult {
443 let ptr = self.ptr() as *mut IAttributes;
444 ((*(*ptr).vtbl).set)(
445 ptr,
446 attrID,
447 data,
448 )
449 }
450 #[inline]
451 unsafe fn queue(
452 &self,
453 listID: IAttrID,
454 data: *const FVariant,
455 ) -> tresult {
456 let ptr = self.ptr() as *mut IAttributes;
457 ((*(*ptr).vtbl).queue)(
458 ptr,
459 listID,
460 data,
461 )
462 }
463 #[inline]
464 unsafe fn setBinaryData(
465 &self,
466 attrID: IAttrID,
467 data: *mut ::std::ffi::c_void,
468 bytes: uint32,
469 copyBytes: bool,
470 ) -> tresult {
471 let ptr = self.ptr() as *mut IAttributes;
472 ((*(*ptr).vtbl).setBinaryData)(
473 ptr,
474 attrID,
475 data,
476 bytes,
477 copyBytes,
478 )
479 }
480 #[inline]
481 unsafe fn get(
482 &self,
483 attrID: IAttrID,
484 data: *mut FVariant,
485 ) -> tresult {
486 let ptr = self.ptr() as *mut IAttributes;
487 ((*(*ptr).vtbl).get)(
488 ptr,
489 attrID,
490 data,
491 )
492 }
493 #[inline]
494 unsafe fn unqueue(
495 &self,
496 listID: IAttrID,
497 data: *mut FVariant,
498 ) -> tresult {
499 let ptr = self.ptr() as *mut IAttributes;
500 ((*(*ptr).vtbl).unqueue)(
501 ptr,
502 listID,
503 data,
504 )
505 }
506 #[inline]
507 unsafe fn getQueueItemCount(
508 &self,
509 attrId: IAttrID,
510 ) -> int32 {
511 let ptr = self.ptr() as *mut IAttributes;
512 ((*(*ptr).vtbl).getQueueItemCount)(
513 ptr,
514 attrId,
515 )
516 }
517 #[inline]
518 unsafe fn resetQueue(
519 &self,
520 attrID: IAttrID,
521 ) -> tresult {
522 let ptr = self.ptr() as *mut IAttributes;
523 ((*(*ptr).vtbl).resetQueue)(
524 ptr,
525 attrID,
526 )
527 }
528 #[inline]
529 unsafe fn resetAllQueues(
530 &self,
531 ) -> tresult {
532 let ptr = self.ptr() as *mut IAttributes;
533 ((*(*ptr).vtbl).resetAllQueues)(
534 ptr,
535 )
536 }
537 #[inline]
538 unsafe fn getBinaryData(
539 &self,
540 attrID: IAttrID,
541 data: *mut ::std::ffi::c_void,
542 bytes: uint32,
543 ) -> tresult {
544 let ptr = self.ptr() as *mut IAttributes;
545 ((*(*ptr).vtbl).getBinaryData)(
546 ptr,
547 attrID,
548 data,
549 bytes,
550 )
551 }
552 #[inline]
553 unsafe fn getBinaryDataSize(
554 &self,
555 attrID: IAttrID,
556 ) -> uint32 {
557 let ptr = self.ptr() as *mut IAttributes;
558 ((*(*ptr).vtbl).getBinaryDataSize)(
559 ptr,
560 attrID,
561 )
562 }
563 }
564 impl IAttributes {
565 const fn make_vtbl<C, W, const OFFSET: isize>() -> IAttributesVtbl
566 where
567 C: IAttributesTrait + ::com_scrape_types::Class,
568 W: ::com_scrape_types::Wrapper<C>,
569 {
570 unsafe extern "system" fn set<C, W, const OFFSET: isize>(
571 this: *mut IAttributes,
572 attrID: IAttrID,
573 data: *const FVariant,
574 ) -> tresult
575 where
576 C: IAttributesTrait + ::com_scrape_types::Class,
577 W: ::com_scrape_types::Wrapper<C>,
578 {
579 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
580 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
581 (*ptr).set(
582 attrID,
583 data,
584 )
585 }
586 unsafe extern "system" fn queue<C, W, const OFFSET: isize>(
587 this: *mut IAttributes,
588 listID: IAttrID,
589 data: *const FVariant,
590 ) -> tresult
591 where
592 C: IAttributesTrait + ::com_scrape_types::Class,
593 W: ::com_scrape_types::Wrapper<C>,
594 {
595 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
596 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
597 (*ptr).queue(
598 listID,
599 data,
600 )
601 }
602 unsafe extern "system" fn setBinaryData<C, W, const OFFSET: isize>(
603 this: *mut IAttributes,
604 attrID: IAttrID,
605 data: *mut ::std::ffi::c_void,
606 bytes: uint32,
607 copyBytes: bool,
608 ) -> tresult
609 where
610 C: IAttributesTrait + ::com_scrape_types::Class,
611 W: ::com_scrape_types::Wrapper<C>,
612 {
613 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
614 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
615 (*ptr).setBinaryData(
616 attrID,
617 data,
618 bytes,
619 copyBytes,
620 )
621 }
622 unsafe extern "system" fn get<C, W, const OFFSET: isize>(
623 this: *mut IAttributes,
624 attrID: IAttrID,
625 data: *mut FVariant,
626 ) -> tresult
627 where
628 C: IAttributesTrait + ::com_scrape_types::Class,
629 W: ::com_scrape_types::Wrapper<C>,
630 {
631 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
632 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
633 (*ptr).get(
634 attrID,
635 data,
636 )
637 }
638 unsafe extern "system" fn unqueue<C, W, const OFFSET: isize>(
639 this: *mut IAttributes,
640 listID: IAttrID,
641 data: *mut FVariant,
642 ) -> tresult
643 where
644 C: IAttributesTrait + ::com_scrape_types::Class,
645 W: ::com_scrape_types::Wrapper<C>,
646 {
647 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
648 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
649 (*ptr).unqueue(
650 listID,
651 data,
652 )
653 }
654 unsafe extern "system" fn getQueueItemCount<C, W, const OFFSET: isize>(
655 this: *mut IAttributes,
656 attrId: IAttrID,
657 ) -> int32
658 where
659 C: IAttributesTrait + ::com_scrape_types::Class,
660 W: ::com_scrape_types::Wrapper<C>,
661 {
662 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
663 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
664 (*ptr).getQueueItemCount(
665 attrId,
666 )
667 }
668 unsafe extern "system" fn resetQueue<C, W, const OFFSET: isize>(
669 this: *mut IAttributes,
670 attrID: IAttrID,
671 ) -> tresult
672 where
673 C: IAttributesTrait + ::com_scrape_types::Class,
674 W: ::com_scrape_types::Wrapper<C>,
675 {
676 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
677 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
678 (*ptr).resetQueue(
679 attrID,
680 )
681 }
682 unsafe extern "system" fn resetAllQueues<C, W, const OFFSET: isize>(
683 this: *mut IAttributes,
684 ) -> tresult
685 where
686 C: IAttributesTrait + ::com_scrape_types::Class,
687 W: ::com_scrape_types::Wrapper<C>,
688 {
689 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
690 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
691 (*ptr).resetAllQueues(
692 )
693 }
694 unsafe extern "system" fn getBinaryData<C, W, const OFFSET: isize>(
695 this: *mut IAttributes,
696 attrID: IAttrID,
697 data: *mut ::std::ffi::c_void,
698 bytes: uint32,
699 ) -> tresult
700 where
701 C: IAttributesTrait + ::com_scrape_types::Class,
702 W: ::com_scrape_types::Wrapper<C>,
703 {
704 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
705 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
706 (*ptr).getBinaryData(
707 attrID,
708 data,
709 bytes,
710 )
711 }
712 unsafe extern "system" fn getBinaryDataSize<C, W, const OFFSET: isize>(
713 this: *mut IAttributes,
714 attrID: IAttrID,
715 ) -> uint32
716 where
717 C: IAttributesTrait + ::com_scrape_types::Class,
718 W: ::com_scrape_types::Wrapper<C>,
719 {
720 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
721 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
722 (*ptr).getBinaryDataSize(
723 attrID,
724 )
725 }
726 IAttributesVtbl {
727 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
728 set: set::<C, W, OFFSET>,
729 queue: queue::<C, W, OFFSET>,
730 setBinaryData: setBinaryData::<C, W, OFFSET>,
731 get: get::<C, W, OFFSET>,
732 unqueue: unqueue::<C, W, OFFSET>,
733 getQueueItemCount: getQueueItemCount::<C, W, OFFSET>,
734 resetQueue: resetQueue::<C, W, OFFSET>,
735 resetAllQueues: resetAllQueues::<C, W, OFFSET>,
736 getBinaryData: getBinaryData::<C, W, OFFSET>,
737 getBinaryDataSize: getBinaryDataSize::<C, W, OFFSET>,
738 }
739 }
740 }
741 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IAttributes
742 where
743 C: IAttributesTrait + ::com_scrape_types::Class,
744 W: ::com_scrape_types::Wrapper<C>,
745 {
746 const OBJ: Self = IAttributes {
747 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
748 };
749 }
750 #[repr(C)]
751 #[derive(Copy, Clone)]
752 pub struct IAttributes2 {
753 pub vtbl: *const IAttributes2Vtbl,
754 }
755 unsafe impl Send for IAttributes2 {}
756 unsafe impl Sync for IAttributes2 {}
757 unsafe impl ::com_scrape_types::Inherits<IAttributes> for IAttributes2 {}
758 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IAttributes2 {}
759 impl ::com_scrape_types::Unknown for IAttributes2 {
760 #[inline]
761 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
762 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
763 }
764 #[inline]
765 unsafe fn add_ref(this: *mut Self) -> usize {
766 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
767 }
768 #[inline]
769 unsafe fn release(this: *mut Self) -> usize {
770 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
771 }
772 }
773 unsafe impl ::com_scrape_types::Interface for IAttributes2 {
774 type Vtbl = IAttributes2Vtbl;
775 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IAttributes2_iid);
776 #[inline]
777 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
778 iid == &Self::IID || IAttributes::inherits(iid)
779 }
780 }
781 #[repr(C)]
782 #[derive(Copy, Clone)]
783 pub struct IAttributes2Vtbl {
784 pub base: IAttributesVtbl,
785 pub countAttributes: unsafe extern "system" fn(
786 this: *mut IAttributes2,
787 ) -> int32,
788 pub getAttributeID: unsafe extern "system" fn(
789 this: *mut IAttributes2,
790 index: int32,
791 ) -> IAttrID,
792 }
793 pub trait IAttributes2Trait: IAttributesTrait {
794 unsafe fn countAttributes(
795 &self,
796 ) -> int32;
797 unsafe fn getAttributeID(
798 &self,
799 index: int32,
800 ) -> IAttrID;
801 }
802 impl<P> IAttributes2Trait for P
803 where
804 P: ::com_scrape_types::SmartPtr,
805 P::Target: ::com_scrape_types::Inherits<IAttributes2>,
806 P::Target: ::com_scrape_types::Inherits<IAttributes>,
807 {
808 #[inline]
809 unsafe fn countAttributes(
810 &self,
811 ) -> int32 {
812 let ptr = self.ptr() as *mut IAttributes2;
813 ((*(*ptr).vtbl).countAttributes)(
814 ptr,
815 )
816 }
817 #[inline]
818 unsafe fn getAttributeID(
819 &self,
820 index: int32,
821 ) -> IAttrID {
822 let ptr = self.ptr() as *mut IAttributes2;
823 ((*(*ptr).vtbl).getAttributeID)(
824 ptr,
825 index,
826 )
827 }
828 }
829 impl IAttributes2 {
830 const fn make_vtbl<C, W, const OFFSET: isize>() -> IAttributes2Vtbl
831 where
832 C: IAttributes2Trait + ::com_scrape_types::Class,
833 W: ::com_scrape_types::Wrapper<C>,
834 {
835 unsafe extern "system" fn countAttributes<C, W, const OFFSET: isize>(
836 this: *mut IAttributes2,
837 ) -> int32
838 where
839 C: IAttributes2Trait + ::com_scrape_types::Class,
840 W: ::com_scrape_types::Wrapper<C>,
841 {
842 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
843 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
844 (*ptr).countAttributes(
845 )
846 }
847 unsafe extern "system" fn getAttributeID<C, W, const OFFSET: isize>(
848 this: *mut IAttributes2,
849 index: int32,
850 ) -> IAttrID
851 where
852 C: IAttributes2Trait + ::com_scrape_types::Class,
853 W: ::com_scrape_types::Wrapper<C>,
854 {
855 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
856 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
857 (*ptr).getAttributeID(
858 index,
859 )
860 }
861 IAttributes2Vtbl {
862 base: IAttributes::make_vtbl::<C, W, OFFSET>(),
863 countAttributes: countAttributes::<C, W, OFFSET>,
864 getAttributeID: getAttributeID::<C, W, OFFSET>,
865 }
866 }
867 }
868 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IAttributes2
869 where
870 C: IAttributes2Trait + ::com_scrape_types::Class,
871 W: ::com_scrape_types::Wrapper<C>,
872 {
873 const OBJ: Self = IAttributes2 {
874 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
875 };
876 }
877 mod __IBStream_wrapper {
878 #[allow(unused_imports)]
879 use super::*;
880 #[allow(unused_imports)]
881 use super::IBStream_::*;
882 #[repr(C)]
883 #[derive(Copy, Clone)]
884 pub struct IBStream {
885 pub vtbl: *const IBStreamVtbl,
886 }
887 unsafe impl Send for IBStream {}
888 unsafe impl Sync for IBStream {}
889 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IBStream {}
890 impl ::com_scrape_types::Unknown for IBStream {
891 #[inline]
892 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
893 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
894 }
895 #[inline]
896 unsafe fn add_ref(this: *mut Self) -> usize {
897 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
898 }
899 #[inline]
900 unsafe fn release(this: *mut Self) -> usize {
901 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
902 }
903 }
904 unsafe impl ::com_scrape_types::Interface for IBStream {
905 type Vtbl = IBStreamVtbl;
906 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IBStream_iid);
907 #[inline]
908 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
909 iid == &Self::IID || FUnknown::inherits(iid)
910 }
911 }
912 #[repr(C)]
913 #[derive(Copy, Clone)]
914 pub struct IBStreamVtbl {
915 pub base: FUnknownVtbl,
916 pub read: unsafe extern "system" fn(
917 this: *mut IBStream,
918 buffer: *mut ::std::ffi::c_void,
919 numBytes: int32,
920 numBytesRead: *mut int32,
921 ) -> tresult,
922 pub write: unsafe extern "system" fn(
923 this: *mut IBStream,
924 buffer: *mut ::std::ffi::c_void,
925 numBytes: int32,
926 numBytesWritten: *mut int32,
927 ) -> tresult,
928 pub seek: unsafe extern "system" fn(
929 this: *mut IBStream,
930 pos: int64,
931 mode: int32,
932 result: *mut int64,
933 ) -> tresult,
934 pub tell: unsafe extern "system" fn(
935 this: *mut IBStream,
936 pos: *mut int64,
937 ) -> tresult,
938 }
939 pub trait IBStreamTrait {
940 unsafe fn read(
941 &self,
942 buffer: *mut ::std::ffi::c_void,
943 numBytes: int32,
944 numBytesRead: *mut int32,
945 ) -> tresult;
946 unsafe fn write(
947 &self,
948 buffer: *mut ::std::ffi::c_void,
949 numBytes: int32,
950 numBytesWritten: *mut int32,
951 ) -> tresult;
952 unsafe fn seek(
953 &self,
954 pos: int64,
955 mode: int32,
956 result: *mut int64,
957 ) -> tresult;
958 unsafe fn tell(
959 &self,
960 pos: *mut int64,
961 ) -> tresult;
962 }
963 impl<P> IBStreamTrait for P
964 where
965 P: ::com_scrape_types::SmartPtr,
966 P::Target: ::com_scrape_types::Inherits<IBStream>,
967 {
968 #[inline]
969 unsafe fn read(
970 &self,
971 buffer: *mut ::std::ffi::c_void,
972 numBytes: int32,
973 numBytesRead: *mut int32,
974 ) -> tresult {
975 let ptr = self.ptr() as *mut IBStream;
976 ((*(*ptr).vtbl).read)(
977 ptr,
978 buffer,
979 numBytes,
980 numBytesRead,
981 )
982 }
983 #[inline]
984 unsafe fn write(
985 &self,
986 buffer: *mut ::std::ffi::c_void,
987 numBytes: int32,
988 numBytesWritten: *mut int32,
989 ) -> tresult {
990 let ptr = self.ptr() as *mut IBStream;
991 ((*(*ptr).vtbl).write)(
992 ptr,
993 buffer,
994 numBytes,
995 numBytesWritten,
996 )
997 }
998 #[inline]
999 unsafe fn seek(
1000 &self,
1001 pos: int64,
1002 mode: int32,
1003 result: *mut int64,
1004 ) -> tresult {
1005 let ptr = self.ptr() as *mut IBStream;
1006 ((*(*ptr).vtbl).seek)(
1007 ptr,
1008 pos,
1009 mode,
1010 result,
1011 )
1012 }
1013 #[inline]
1014 unsafe fn tell(
1015 &self,
1016 pos: *mut int64,
1017 ) -> tresult {
1018 let ptr = self.ptr() as *mut IBStream;
1019 ((*(*ptr).vtbl).tell)(
1020 ptr,
1021 pos,
1022 )
1023 }
1024 }
1025 impl IBStream {
1026 const fn make_vtbl<C, W, const OFFSET: isize>() -> IBStreamVtbl
1027 where
1028 C: IBStreamTrait + ::com_scrape_types::Class,
1029 W: ::com_scrape_types::Wrapper<C>,
1030 {
1031 unsafe extern "system" fn read<C, W, const OFFSET: isize>(
1032 this: *mut IBStream,
1033 buffer: *mut ::std::ffi::c_void,
1034 numBytes: int32,
1035 numBytesRead: *mut int32,
1036 ) -> tresult
1037 where
1038 C: IBStreamTrait + ::com_scrape_types::Class,
1039 W: ::com_scrape_types::Wrapper<C>,
1040 {
1041 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
1042 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
1043 (*ptr).read(
1044 buffer,
1045 numBytes,
1046 numBytesRead,
1047 )
1048 }
1049 unsafe extern "system" fn write<C, W, const OFFSET: isize>(
1050 this: *mut IBStream,
1051 buffer: *mut ::std::ffi::c_void,
1052 numBytes: int32,
1053 numBytesWritten: *mut int32,
1054 ) -> tresult
1055 where
1056 C: IBStreamTrait + ::com_scrape_types::Class,
1057 W: ::com_scrape_types::Wrapper<C>,
1058 {
1059 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
1060 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
1061 (*ptr).write(
1062 buffer,
1063 numBytes,
1064 numBytesWritten,
1065 )
1066 }
1067 unsafe extern "system" fn seek<C, W, const OFFSET: isize>(
1068 this: *mut IBStream,
1069 pos: int64,
1070 mode: int32,
1071 result: *mut int64,
1072 ) -> tresult
1073 where
1074 C: IBStreamTrait + ::com_scrape_types::Class,
1075 W: ::com_scrape_types::Wrapper<C>,
1076 {
1077 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
1078 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
1079 (*ptr).seek(
1080 pos,
1081 mode,
1082 result,
1083 )
1084 }
1085 unsafe extern "system" fn tell<C, W, const OFFSET: isize>(
1086 this: *mut IBStream,
1087 pos: *mut int64,
1088 ) -> tresult
1089 where
1090 C: IBStreamTrait + ::com_scrape_types::Class,
1091 W: ::com_scrape_types::Wrapper<C>,
1092 {
1093 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
1094 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
1095 (*ptr).tell(
1096 pos,
1097 )
1098 }
1099 IBStreamVtbl {
1100 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
1101 read: read::<C, W, OFFSET>,
1102 write: write::<C, W, OFFSET>,
1103 seek: seek::<C, W, OFFSET>,
1104 tell: tell::<C, W, OFFSET>,
1105 }
1106 }
1107 }
1108 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IBStream
1109 where
1110 C: IBStreamTrait + ::com_scrape_types::Class,
1111 W: ::com_scrape_types::Wrapper<C>,
1112 {
1113 const OBJ: Self = IBStream {
1114 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
1115 };
1116 }
1117 }
1118 pub use __IBStream_wrapper::*;
1119 pub mod IBStream_ {
1120 #[allow(unused_imports)]
1121 use super::*;
1122 pub type IStreamSeekMode = crate::support::DefaultEnumType;
1123 pub mod IStreamSeekMode_ {
1124 #[allow(unused_imports)]
1125 use super::*;
1126 pub const kIBSeekCur: IStreamSeekMode = 1;
1127 pub const kIBSeekEnd: IStreamSeekMode = 2;
1128 pub const kIBSeekSet: IStreamSeekMode = 0;
1129 }
1130 }
1131 #[repr(C)]
1132 #[derive(Copy, Clone)]
1133 pub struct ICloneable {
1134 pub vtbl: *const ICloneableVtbl,
1135 }
1136 unsafe impl Send for ICloneable {}
1137 unsafe impl Sync for ICloneable {}
1138 unsafe impl ::com_scrape_types::Inherits<FUnknown> for ICloneable {}
1139 impl ::com_scrape_types::Unknown for ICloneable {
1140 #[inline]
1141 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
1142 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
1143 }
1144 #[inline]
1145 unsafe fn add_ref(this: *mut Self) -> usize {
1146 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
1147 }
1148 #[inline]
1149 unsafe fn release(this: *mut Self) -> usize {
1150 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
1151 }
1152 }
1153 unsafe impl ::com_scrape_types::Interface for ICloneable {
1154 type Vtbl = ICloneableVtbl;
1155 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(ICloneable_iid);
1156 #[inline]
1157 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
1158 iid == &Self::IID || FUnknown::inherits(iid)
1159 }
1160 }
1161 #[repr(C)]
1162 #[derive(Copy, Clone)]
1163 pub struct ICloneableVtbl {
1164 pub base: FUnknownVtbl,
1165 pub clone: unsafe extern "system" fn(
1166 this: *mut ICloneable,
1167 ) -> *mut FUnknown,
1168 }
1169 pub trait ICloneableTrait {
1170 unsafe fn clone(
1171 &self,
1172 ) -> *mut FUnknown;
1173 }
1174 impl<P> ICloneableTrait for P
1175 where
1176 P: ::com_scrape_types::SmartPtr,
1177 P::Target: ::com_scrape_types::Inherits<ICloneable>,
1178 {
1179 #[inline]
1180 unsafe fn clone(
1181 &self,
1182 ) -> *mut FUnknown {
1183 let ptr = self.ptr() as *mut ICloneable;
1184 ((*(*ptr).vtbl).clone)(
1185 ptr,
1186 )
1187 }
1188 }
1189 impl ICloneable {
1190 const fn make_vtbl<C, W, const OFFSET: isize>() -> ICloneableVtbl
1191 where
1192 C: ICloneableTrait + ::com_scrape_types::Class,
1193 W: ::com_scrape_types::Wrapper<C>,
1194 {
1195 unsafe extern "system" fn clone<C, W, const OFFSET: isize>(
1196 this: *mut ICloneable,
1197 ) -> *mut FUnknown
1198 where
1199 C: ICloneableTrait + ::com_scrape_types::Class,
1200 W: ::com_scrape_types::Wrapper<C>,
1201 {
1202 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
1203 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
1204 (*ptr).clone(
1205 )
1206 }
1207 ICloneableVtbl {
1208 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
1209 clone: clone::<C, W, OFFSET>,
1210 }
1211 }
1212 }
1213 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for ICloneable
1214 where
1215 C: ICloneableTrait + ::com_scrape_types::Class,
1216 W: ::com_scrape_types::Wrapper<C>,
1217 {
1218 const OBJ: Self = ICloneable {
1219 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
1220 };
1221 }
1222 mod __IDependent_wrapper {
1223 #[allow(unused_imports)]
1224 use super::*;
1225 #[allow(unused_imports)]
1226 use super::IDependent_::*;
1227 #[repr(C)]
1228 #[derive(Copy, Clone)]
1229 pub struct IDependent {
1230 pub vtbl: *const IDependentVtbl,
1231 }
1232 unsafe impl Send for IDependent {}
1233 unsafe impl Sync for IDependent {}
1234 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IDependent {}
1235 impl ::com_scrape_types::Unknown for IDependent {
1236 #[inline]
1237 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
1238 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
1239 }
1240 #[inline]
1241 unsafe fn add_ref(this: *mut Self) -> usize {
1242 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
1243 }
1244 #[inline]
1245 unsafe fn release(this: *mut Self) -> usize {
1246 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
1247 }
1248 }
1249 unsafe impl ::com_scrape_types::Interface for IDependent {
1250 type Vtbl = IDependentVtbl;
1251 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IDependent_iid);
1252 #[inline]
1253 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
1254 iid == &Self::IID || FUnknown::inherits(iid)
1255 }
1256 }
1257 #[repr(C)]
1258 #[derive(Copy, Clone)]
1259 pub struct IDependentVtbl {
1260 pub base: FUnknownVtbl,
1261 pub update: unsafe extern "system" fn(
1262 this: *mut IDependent,
1263 changedUnknown: *mut FUnknown,
1264 message: int32,
1265 ),
1266 }
1267 pub trait IDependentTrait {
1268 unsafe fn update(
1269 &self,
1270 changedUnknown: *mut FUnknown,
1271 message: int32,
1272 );
1273 }
1274 impl<P> IDependentTrait for P
1275 where
1276 P: ::com_scrape_types::SmartPtr,
1277 P::Target: ::com_scrape_types::Inherits<IDependent>,
1278 {
1279 #[inline]
1280 unsafe fn update(
1281 &self,
1282 changedUnknown: *mut FUnknown,
1283 message: int32,
1284 ) {
1285 let ptr = self.ptr() as *mut IDependent;
1286 ((*(*ptr).vtbl).update)(
1287 ptr,
1288 changedUnknown,
1289 message,
1290 )
1291 }
1292 }
1293 impl IDependent {
1294 const fn make_vtbl<C, W, const OFFSET: isize>() -> IDependentVtbl
1295 where
1296 C: IDependentTrait + ::com_scrape_types::Class,
1297 W: ::com_scrape_types::Wrapper<C>,
1298 {
1299 unsafe extern "system" fn update<C, W, const OFFSET: isize>(
1300 this: *mut IDependent,
1301 changedUnknown: *mut FUnknown,
1302 message: int32,
1303 )
1304 where
1305 C: IDependentTrait + ::com_scrape_types::Class,
1306 W: ::com_scrape_types::Wrapper<C>,
1307 {
1308 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
1309 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
1310 (*ptr).update(
1311 changedUnknown,
1312 message,
1313 )
1314 }
1315 IDependentVtbl {
1316 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
1317 update: update::<C, W, OFFSET>,
1318 }
1319 }
1320 }
1321 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IDependent
1322 where
1323 C: IDependentTrait + ::com_scrape_types::Class,
1324 W: ::com_scrape_types::Wrapper<C>,
1325 {
1326 const OBJ: Self = IDependent {
1327 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
1328 };
1329 }
1330 }
1331 pub use __IDependent_wrapper::*;
1332 pub mod IDependent_ {
1333 #[allow(unused_imports)]
1334 use super::*;
1335 pub type ChangeMessage = crate::support::DefaultEnumType;
1336 pub mod ChangeMessage_ {
1337 #[allow(unused_imports)]
1338 use super::*;
1339 pub const kChanged: ChangeMessage = 1;
1340 pub const kDestroyed: ChangeMessage = 2;
1341 pub const kStdChangeMessageLast: ChangeMessage = 3;
1342 pub const kWillChange: ChangeMessage = 0;
1343 pub const kWillDestroy: ChangeMessage = 3;
1344 }
1345 }
1346 #[repr(C)]
1347 #[derive(Copy, Clone)]
1348 pub struct IErrorContext {
1349 pub vtbl: *const IErrorContextVtbl,
1350 }
1351 unsafe impl Send for IErrorContext {}
1352 unsafe impl Sync for IErrorContext {}
1353 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IErrorContext {}
1354 impl ::com_scrape_types::Unknown for IErrorContext {
1355 #[inline]
1356 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
1357 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
1358 }
1359 #[inline]
1360 unsafe fn add_ref(this: *mut Self) -> usize {
1361 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
1362 }
1363 #[inline]
1364 unsafe fn release(this: *mut Self) -> usize {
1365 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
1366 }
1367 }
1368 unsafe impl ::com_scrape_types::Interface for IErrorContext {
1369 type Vtbl = IErrorContextVtbl;
1370 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IErrorContext_iid);
1371 #[inline]
1372 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
1373 iid == &Self::IID || FUnknown::inherits(iid)
1374 }
1375 }
1376 #[repr(C)]
1377 #[derive(Copy, Clone)]
1378 pub struct IErrorContextVtbl {
1379 pub base: FUnknownVtbl,
1380 pub disableErrorUI: unsafe extern "system" fn(
1381 this: *mut IErrorContext,
1382 state: bool,
1383 ),
1384 pub errorMessageShown: unsafe extern "system" fn(
1385 this: *mut IErrorContext,
1386 ) -> tresult,
1387 pub getErrorMessage: unsafe extern "system" fn(
1388 this: *mut IErrorContext,
1389 message: *mut IString,
1390 ) -> tresult,
1391 }
1392 pub trait IErrorContextTrait {
1393 unsafe fn disableErrorUI(
1394 &self,
1395 state: bool,
1396 );
1397 unsafe fn errorMessageShown(
1398 &self,
1399 ) -> tresult;
1400 unsafe fn getErrorMessage(
1401 &self,
1402 message: *mut IString,
1403 ) -> tresult;
1404 }
1405 impl<P> IErrorContextTrait for P
1406 where
1407 P: ::com_scrape_types::SmartPtr,
1408 P::Target: ::com_scrape_types::Inherits<IErrorContext>,
1409 {
1410 #[inline]
1411 unsafe fn disableErrorUI(
1412 &self,
1413 state: bool,
1414 ) {
1415 let ptr = self.ptr() as *mut IErrorContext;
1416 ((*(*ptr).vtbl).disableErrorUI)(
1417 ptr,
1418 state,
1419 )
1420 }
1421 #[inline]
1422 unsafe fn errorMessageShown(
1423 &self,
1424 ) -> tresult {
1425 let ptr = self.ptr() as *mut IErrorContext;
1426 ((*(*ptr).vtbl).errorMessageShown)(
1427 ptr,
1428 )
1429 }
1430 #[inline]
1431 unsafe fn getErrorMessage(
1432 &self,
1433 message: *mut IString,
1434 ) -> tresult {
1435 let ptr = self.ptr() as *mut IErrorContext;
1436 ((*(*ptr).vtbl).getErrorMessage)(
1437 ptr,
1438 message,
1439 )
1440 }
1441 }
1442 impl IErrorContext {
1443 const fn make_vtbl<C, W, const OFFSET: isize>() -> IErrorContextVtbl
1444 where
1445 C: IErrorContextTrait + ::com_scrape_types::Class,
1446 W: ::com_scrape_types::Wrapper<C>,
1447 {
1448 unsafe extern "system" fn disableErrorUI<C, W, const OFFSET: isize>(
1449 this: *mut IErrorContext,
1450 state: bool,
1451 )
1452 where
1453 C: IErrorContextTrait + ::com_scrape_types::Class,
1454 W: ::com_scrape_types::Wrapper<C>,
1455 {
1456 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
1457 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
1458 (*ptr).disableErrorUI(
1459 state,
1460 )
1461 }
1462 unsafe extern "system" fn errorMessageShown<C, W, const OFFSET: isize>(
1463 this: *mut IErrorContext,
1464 ) -> tresult
1465 where
1466 C: IErrorContextTrait + ::com_scrape_types::Class,
1467 W: ::com_scrape_types::Wrapper<C>,
1468 {
1469 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
1470 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
1471 (*ptr).errorMessageShown(
1472 )
1473 }
1474 unsafe extern "system" fn getErrorMessage<C, W, const OFFSET: isize>(
1475 this: *mut IErrorContext,
1476 message: *mut IString,
1477 ) -> tresult
1478 where
1479 C: IErrorContextTrait + ::com_scrape_types::Class,
1480 W: ::com_scrape_types::Wrapper<C>,
1481 {
1482 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
1483 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
1484 (*ptr).getErrorMessage(
1485 message,
1486 )
1487 }
1488 IErrorContextVtbl {
1489 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
1490 disableErrorUI: disableErrorUI::<C, W, OFFSET>,
1491 errorMessageShown: errorMessageShown::<C, W, OFFSET>,
1492 getErrorMessage: getErrorMessage::<C, W, OFFSET>,
1493 }
1494 }
1495 }
1496 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IErrorContext
1497 where
1498 C: IErrorContextTrait + ::com_scrape_types::Class,
1499 W: ::com_scrape_types::Wrapper<C>,
1500 {
1501 const OBJ: Self = IErrorContext {
1502 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
1503 };
1504 }
1505 #[repr(C)]
1506 #[derive(Copy, Clone)]
1507 pub struct IPersistent {
1508 pub vtbl: *const IPersistentVtbl,
1509 }
1510 unsafe impl Send for IPersistent {}
1511 unsafe impl Sync for IPersistent {}
1512 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IPersistent {}
1513 impl ::com_scrape_types::Unknown for IPersistent {
1514 #[inline]
1515 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
1516 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
1517 }
1518 #[inline]
1519 unsafe fn add_ref(this: *mut Self) -> usize {
1520 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
1521 }
1522 #[inline]
1523 unsafe fn release(this: *mut Self) -> usize {
1524 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
1525 }
1526 }
1527 unsafe impl ::com_scrape_types::Interface for IPersistent {
1528 type Vtbl = IPersistentVtbl;
1529 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IPersistent_iid);
1530 #[inline]
1531 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
1532 iid == &Self::IID || FUnknown::inherits(iid)
1533 }
1534 }
1535 #[repr(C)]
1536 #[derive(Copy, Clone)]
1537 pub struct IPersistentVtbl {
1538 pub base: FUnknownVtbl,
1539 pub getClassID: unsafe extern "system" fn(
1540 this: *mut IPersistent,
1541 uid: *mut char8,
1542 ) -> tresult,
1543 pub saveAttributes: unsafe extern "system" fn(
1544 this: *mut IPersistent,
1545 _0: *mut IAttributes,
1546 ) -> tresult,
1547 pub loadAttributes: unsafe extern "system" fn(
1548 this: *mut IPersistent,
1549 _0: *mut IAttributes,
1550 ) -> tresult,
1551 }
1552 pub trait IPersistentTrait {
1553 unsafe fn getClassID(
1554 &self,
1555 uid: *mut char8,
1556 ) -> tresult;
1557 unsafe fn saveAttributes(
1558 &self,
1559 _0: *mut IAttributes,
1560 ) -> tresult;
1561 unsafe fn loadAttributes(
1562 &self,
1563 _0: *mut IAttributes,
1564 ) -> tresult;
1565 }
1566 impl<P> IPersistentTrait for P
1567 where
1568 P: ::com_scrape_types::SmartPtr,
1569 P::Target: ::com_scrape_types::Inherits<IPersistent>,
1570 {
1571 #[inline]
1572 unsafe fn getClassID(
1573 &self,
1574 uid: *mut char8,
1575 ) -> tresult {
1576 let ptr = self.ptr() as *mut IPersistent;
1577 ((*(*ptr).vtbl).getClassID)(
1578 ptr,
1579 uid,
1580 )
1581 }
1582 #[inline]
1583 unsafe fn saveAttributes(
1584 &self,
1585 _0: *mut IAttributes,
1586 ) -> tresult {
1587 let ptr = self.ptr() as *mut IPersistent;
1588 ((*(*ptr).vtbl).saveAttributes)(
1589 ptr,
1590 _0,
1591 )
1592 }
1593 #[inline]
1594 unsafe fn loadAttributes(
1595 &self,
1596 _0: *mut IAttributes,
1597 ) -> tresult {
1598 let ptr = self.ptr() as *mut IPersistent;
1599 ((*(*ptr).vtbl).loadAttributes)(
1600 ptr,
1601 _0,
1602 )
1603 }
1604 }
1605 impl IPersistent {
1606 const fn make_vtbl<C, W, const OFFSET: isize>() -> IPersistentVtbl
1607 where
1608 C: IPersistentTrait + ::com_scrape_types::Class,
1609 W: ::com_scrape_types::Wrapper<C>,
1610 {
1611 unsafe extern "system" fn getClassID<C, W, const OFFSET: isize>(
1612 this: *mut IPersistent,
1613 uid: *mut char8,
1614 ) -> tresult
1615 where
1616 C: IPersistentTrait + ::com_scrape_types::Class,
1617 W: ::com_scrape_types::Wrapper<C>,
1618 {
1619 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
1620 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
1621 (*ptr).getClassID(
1622 uid,
1623 )
1624 }
1625 unsafe extern "system" fn saveAttributes<C, W, const OFFSET: isize>(
1626 this: *mut IPersistent,
1627 _0: *mut IAttributes,
1628 ) -> tresult
1629 where
1630 C: IPersistentTrait + ::com_scrape_types::Class,
1631 W: ::com_scrape_types::Wrapper<C>,
1632 {
1633 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
1634 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
1635 (*ptr).saveAttributes(
1636 _0,
1637 )
1638 }
1639 unsafe extern "system" fn loadAttributes<C, W, const OFFSET: isize>(
1640 this: *mut IPersistent,
1641 _0: *mut IAttributes,
1642 ) -> tresult
1643 where
1644 C: IPersistentTrait + ::com_scrape_types::Class,
1645 W: ::com_scrape_types::Wrapper<C>,
1646 {
1647 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
1648 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
1649 (*ptr).loadAttributes(
1650 _0,
1651 )
1652 }
1653 IPersistentVtbl {
1654 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
1655 getClassID: getClassID::<C, W, OFFSET>,
1656 saveAttributes: saveAttributes::<C, W, OFFSET>,
1657 loadAttributes: loadAttributes::<C, W, OFFSET>,
1658 }
1659 }
1660 }
1661 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IPersistent
1662 where
1663 C: IPersistentTrait + ::com_scrape_types::Class,
1664 W: ::com_scrape_types::Wrapper<C>,
1665 {
1666 const OBJ: Self = IPersistent {
1667 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
1668 };
1669 }
1670 #[repr(C)]
1671 #[derive(Copy, Clone)]
1672 pub struct IPlugFrame {
1673 pub vtbl: *const IPlugFrameVtbl,
1674 }
1675 unsafe impl Send for IPlugFrame {}
1676 unsafe impl Sync for IPlugFrame {}
1677 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IPlugFrame {}
1678 impl ::com_scrape_types::Unknown for IPlugFrame {
1679 #[inline]
1680 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
1681 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
1682 }
1683 #[inline]
1684 unsafe fn add_ref(this: *mut Self) -> usize {
1685 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
1686 }
1687 #[inline]
1688 unsafe fn release(this: *mut Self) -> usize {
1689 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
1690 }
1691 }
1692 unsafe impl ::com_scrape_types::Interface for IPlugFrame {
1693 type Vtbl = IPlugFrameVtbl;
1694 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IPlugFrame_iid);
1695 #[inline]
1696 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
1697 iid == &Self::IID || FUnknown::inherits(iid)
1698 }
1699 }
1700 #[repr(C)]
1701 #[derive(Copy, Clone)]
1702 pub struct IPlugFrameVtbl {
1703 pub base: FUnknownVtbl,
1704 pub resizeView: unsafe extern "system" fn(
1705 this: *mut IPlugFrame,
1706 view: *mut IPlugView,
1707 newSize: *mut ViewRect,
1708 ) -> tresult,
1709 }
1710 pub trait IPlugFrameTrait {
1711 unsafe fn resizeView(
1712 &self,
1713 view: *mut IPlugView,
1714 newSize: *mut ViewRect,
1715 ) -> tresult;
1716 }
1717 impl<P> IPlugFrameTrait for P
1718 where
1719 P: ::com_scrape_types::SmartPtr,
1720 P::Target: ::com_scrape_types::Inherits<IPlugFrame>,
1721 {
1722 #[inline]
1723 unsafe fn resizeView(
1724 &self,
1725 view: *mut IPlugView,
1726 newSize: *mut ViewRect,
1727 ) -> tresult {
1728 let ptr = self.ptr() as *mut IPlugFrame;
1729 ((*(*ptr).vtbl).resizeView)(
1730 ptr,
1731 view,
1732 newSize,
1733 )
1734 }
1735 }
1736 impl IPlugFrame {
1737 const fn make_vtbl<C, W, const OFFSET: isize>() -> IPlugFrameVtbl
1738 where
1739 C: IPlugFrameTrait + ::com_scrape_types::Class,
1740 W: ::com_scrape_types::Wrapper<C>,
1741 {
1742 unsafe extern "system" fn resizeView<C, W, const OFFSET: isize>(
1743 this: *mut IPlugFrame,
1744 view: *mut IPlugView,
1745 newSize: *mut ViewRect,
1746 ) -> tresult
1747 where
1748 C: IPlugFrameTrait + ::com_scrape_types::Class,
1749 W: ::com_scrape_types::Wrapper<C>,
1750 {
1751 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
1752 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
1753 (*ptr).resizeView(
1754 view,
1755 newSize,
1756 )
1757 }
1758 IPlugFrameVtbl {
1759 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
1760 resizeView: resizeView::<C, W, OFFSET>,
1761 }
1762 }
1763 }
1764 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IPlugFrame
1765 where
1766 C: IPlugFrameTrait + ::com_scrape_types::Class,
1767 W: ::com_scrape_types::Wrapper<C>,
1768 {
1769 const OBJ: Self = IPlugFrame {
1770 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
1771 };
1772 }
1773 #[repr(C)]
1774 #[derive(Copy, Clone)]
1775 pub struct IPlugView {
1776 pub vtbl: *const IPlugViewVtbl,
1777 }
1778 unsafe impl Send for IPlugView {}
1779 unsafe impl Sync for IPlugView {}
1780 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IPlugView {}
1781 impl ::com_scrape_types::Unknown for IPlugView {
1782 #[inline]
1783 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
1784 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
1785 }
1786 #[inline]
1787 unsafe fn add_ref(this: *mut Self) -> usize {
1788 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
1789 }
1790 #[inline]
1791 unsafe fn release(this: *mut Self) -> usize {
1792 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
1793 }
1794 }
1795 unsafe impl ::com_scrape_types::Interface for IPlugView {
1796 type Vtbl = IPlugViewVtbl;
1797 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IPlugView_iid);
1798 #[inline]
1799 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
1800 iid == &Self::IID || FUnknown::inherits(iid)
1801 }
1802 }
1803 #[repr(C)]
1804 #[derive(Copy, Clone)]
1805 pub struct IPlugViewVtbl {
1806 pub base: FUnknownVtbl,
1807 pub isPlatformTypeSupported: unsafe extern "system" fn(
1808 this: *mut IPlugView,
1809 r#type: FIDString,
1810 ) -> tresult,
1811 pub attached: unsafe extern "system" fn(
1812 this: *mut IPlugView,
1813 parent: *mut ::std::ffi::c_void,
1814 r#type: FIDString,
1815 ) -> tresult,
1816 pub removed: unsafe extern "system" fn(
1817 this: *mut IPlugView,
1818 ) -> tresult,
1819 pub onWheel: unsafe extern "system" fn(
1820 this: *mut IPlugView,
1821 distance: f32,
1822 ) -> tresult,
1823 pub onKeyDown: unsafe extern "system" fn(
1824 this: *mut IPlugView,
1825 key: char16,
1826 keyCode: int16,
1827 modifiers: int16,
1828 ) -> tresult,
1829 pub onKeyUp: unsafe extern "system" fn(
1830 this: *mut IPlugView,
1831 key: char16,
1832 keyCode: int16,
1833 modifiers: int16,
1834 ) -> tresult,
1835 pub getSize: unsafe extern "system" fn(
1836 this: *mut IPlugView,
1837 size: *mut ViewRect,
1838 ) -> tresult,
1839 pub onSize: unsafe extern "system" fn(
1840 this: *mut IPlugView,
1841 newSize: *mut ViewRect,
1842 ) -> tresult,
1843 pub onFocus: unsafe extern "system" fn(
1844 this: *mut IPlugView,
1845 state: TBool,
1846 ) -> tresult,
1847 pub setFrame: unsafe extern "system" fn(
1848 this: *mut IPlugView,
1849 frame: *mut IPlugFrame,
1850 ) -> tresult,
1851 pub canResize: unsafe extern "system" fn(
1852 this: *mut IPlugView,
1853 ) -> tresult,
1854 pub checkSizeConstraint: unsafe extern "system" fn(
1855 this: *mut IPlugView,
1856 rect: *mut ViewRect,
1857 ) -> tresult,
1858 }
1859 pub trait IPlugViewTrait {
1860 unsafe fn isPlatformTypeSupported(
1861 &self,
1862 r#type: FIDString,
1863 ) -> tresult;
1864 unsafe fn attached(
1865 &self,
1866 parent: *mut ::std::ffi::c_void,
1867 r#type: FIDString,
1868 ) -> tresult;
1869 unsafe fn removed(
1870 &self,
1871 ) -> tresult;
1872 unsafe fn onWheel(
1873 &self,
1874 distance: f32,
1875 ) -> tresult;
1876 unsafe fn onKeyDown(
1877 &self,
1878 key: char16,
1879 keyCode: int16,
1880 modifiers: int16,
1881 ) -> tresult;
1882 unsafe fn onKeyUp(
1883 &self,
1884 key: char16,
1885 keyCode: int16,
1886 modifiers: int16,
1887 ) -> tresult;
1888 unsafe fn getSize(
1889 &self,
1890 size: *mut ViewRect,
1891 ) -> tresult;
1892 unsafe fn onSize(
1893 &self,
1894 newSize: *mut ViewRect,
1895 ) -> tresult;
1896 unsafe fn onFocus(
1897 &self,
1898 state: TBool,
1899 ) -> tresult;
1900 unsafe fn setFrame(
1901 &self,
1902 frame: *mut IPlugFrame,
1903 ) -> tresult;
1904 unsafe fn canResize(
1905 &self,
1906 ) -> tresult;
1907 unsafe fn checkSizeConstraint(
1908 &self,
1909 rect: *mut ViewRect,
1910 ) -> tresult;
1911 }
1912 impl<P> IPlugViewTrait for P
1913 where
1914 P: ::com_scrape_types::SmartPtr,
1915 P::Target: ::com_scrape_types::Inherits<IPlugView>,
1916 {
1917 #[inline]
1918 unsafe fn isPlatformTypeSupported(
1919 &self,
1920 r#type: FIDString,
1921 ) -> tresult {
1922 let ptr = self.ptr() as *mut IPlugView;
1923 ((*(*ptr).vtbl).isPlatformTypeSupported)(
1924 ptr,
1925 r#type,
1926 )
1927 }
1928 #[inline]
1929 unsafe fn attached(
1930 &self,
1931 parent: *mut ::std::ffi::c_void,
1932 r#type: FIDString,
1933 ) -> tresult {
1934 let ptr = self.ptr() as *mut IPlugView;
1935 ((*(*ptr).vtbl).attached)(
1936 ptr,
1937 parent,
1938 r#type,
1939 )
1940 }
1941 #[inline]
1942 unsafe fn removed(
1943 &self,
1944 ) -> tresult {
1945 let ptr = self.ptr() as *mut IPlugView;
1946 ((*(*ptr).vtbl).removed)(
1947 ptr,
1948 )
1949 }
1950 #[inline]
1951 unsafe fn onWheel(
1952 &self,
1953 distance: f32,
1954 ) -> tresult {
1955 let ptr = self.ptr() as *mut IPlugView;
1956 ((*(*ptr).vtbl).onWheel)(
1957 ptr,
1958 distance,
1959 )
1960 }
1961 #[inline]
1962 unsafe fn onKeyDown(
1963 &self,
1964 key: char16,
1965 keyCode: int16,
1966 modifiers: int16,
1967 ) -> tresult {
1968 let ptr = self.ptr() as *mut IPlugView;
1969 ((*(*ptr).vtbl).onKeyDown)(
1970 ptr,
1971 key,
1972 keyCode,
1973 modifiers,
1974 )
1975 }
1976 #[inline]
1977 unsafe fn onKeyUp(
1978 &self,
1979 key: char16,
1980 keyCode: int16,
1981 modifiers: int16,
1982 ) -> tresult {
1983 let ptr = self.ptr() as *mut IPlugView;
1984 ((*(*ptr).vtbl).onKeyUp)(
1985 ptr,
1986 key,
1987 keyCode,
1988 modifiers,
1989 )
1990 }
1991 #[inline]
1992 unsafe fn getSize(
1993 &self,
1994 size: *mut ViewRect,
1995 ) -> tresult {
1996 let ptr = self.ptr() as *mut IPlugView;
1997 ((*(*ptr).vtbl).getSize)(
1998 ptr,
1999 size,
2000 )
2001 }
2002 #[inline]
2003 unsafe fn onSize(
2004 &self,
2005 newSize: *mut ViewRect,
2006 ) -> tresult {
2007 let ptr = self.ptr() as *mut IPlugView;
2008 ((*(*ptr).vtbl).onSize)(
2009 ptr,
2010 newSize,
2011 )
2012 }
2013 #[inline]
2014 unsafe fn onFocus(
2015 &self,
2016 state: TBool,
2017 ) -> tresult {
2018 let ptr = self.ptr() as *mut IPlugView;
2019 ((*(*ptr).vtbl).onFocus)(
2020 ptr,
2021 state,
2022 )
2023 }
2024 #[inline]
2025 unsafe fn setFrame(
2026 &self,
2027 frame: *mut IPlugFrame,
2028 ) -> tresult {
2029 let ptr = self.ptr() as *mut IPlugView;
2030 ((*(*ptr).vtbl).setFrame)(
2031 ptr,
2032 frame,
2033 )
2034 }
2035 #[inline]
2036 unsafe fn canResize(
2037 &self,
2038 ) -> tresult {
2039 let ptr = self.ptr() as *mut IPlugView;
2040 ((*(*ptr).vtbl).canResize)(
2041 ptr,
2042 )
2043 }
2044 #[inline]
2045 unsafe fn checkSizeConstraint(
2046 &self,
2047 rect: *mut ViewRect,
2048 ) -> tresult {
2049 let ptr = self.ptr() as *mut IPlugView;
2050 ((*(*ptr).vtbl).checkSizeConstraint)(
2051 ptr,
2052 rect,
2053 )
2054 }
2055 }
2056 impl IPlugView {
2057 const fn make_vtbl<C, W, const OFFSET: isize>() -> IPlugViewVtbl
2058 where
2059 C: IPlugViewTrait + ::com_scrape_types::Class,
2060 W: ::com_scrape_types::Wrapper<C>,
2061 {
2062 unsafe extern "system" fn isPlatformTypeSupported<C, W, const OFFSET: isize>(
2063 this: *mut IPlugView,
2064 r#type: FIDString,
2065 ) -> tresult
2066 where
2067 C: IPlugViewTrait + ::com_scrape_types::Class,
2068 W: ::com_scrape_types::Wrapper<C>,
2069 {
2070 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
2071 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
2072 (*ptr).isPlatformTypeSupported(
2073 r#type,
2074 )
2075 }
2076 unsafe extern "system" fn attached<C, W, const OFFSET: isize>(
2077 this: *mut IPlugView,
2078 parent: *mut ::std::ffi::c_void,
2079 r#type: FIDString,
2080 ) -> tresult
2081 where
2082 C: IPlugViewTrait + ::com_scrape_types::Class,
2083 W: ::com_scrape_types::Wrapper<C>,
2084 {
2085 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
2086 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
2087 (*ptr).attached(
2088 parent,
2089 r#type,
2090 )
2091 }
2092 unsafe extern "system" fn removed<C, W, const OFFSET: isize>(
2093 this: *mut IPlugView,
2094 ) -> tresult
2095 where
2096 C: IPlugViewTrait + ::com_scrape_types::Class,
2097 W: ::com_scrape_types::Wrapper<C>,
2098 {
2099 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
2100 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
2101 (*ptr).removed(
2102 )
2103 }
2104 unsafe extern "system" fn onWheel<C, W, const OFFSET: isize>(
2105 this: *mut IPlugView,
2106 distance: f32,
2107 ) -> tresult
2108 where
2109 C: IPlugViewTrait + ::com_scrape_types::Class,
2110 W: ::com_scrape_types::Wrapper<C>,
2111 {
2112 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
2113 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
2114 (*ptr).onWheel(
2115 distance,
2116 )
2117 }
2118 unsafe extern "system" fn onKeyDown<C, W, const OFFSET: isize>(
2119 this: *mut IPlugView,
2120 key: char16,
2121 keyCode: int16,
2122 modifiers: int16,
2123 ) -> tresult
2124 where
2125 C: IPlugViewTrait + ::com_scrape_types::Class,
2126 W: ::com_scrape_types::Wrapper<C>,
2127 {
2128 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
2129 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
2130 (*ptr).onKeyDown(
2131 key,
2132 keyCode,
2133 modifiers,
2134 )
2135 }
2136 unsafe extern "system" fn onKeyUp<C, W, const OFFSET: isize>(
2137 this: *mut IPlugView,
2138 key: char16,
2139 keyCode: int16,
2140 modifiers: int16,
2141 ) -> tresult
2142 where
2143 C: IPlugViewTrait + ::com_scrape_types::Class,
2144 W: ::com_scrape_types::Wrapper<C>,
2145 {
2146 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
2147 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
2148 (*ptr).onKeyUp(
2149 key,
2150 keyCode,
2151 modifiers,
2152 )
2153 }
2154 unsafe extern "system" fn getSize<C, W, const OFFSET: isize>(
2155 this: *mut IPlugView,
2156 size: *mut ViewRect,
2157 ) -> tresult
2158 where
2159 C: IPlugViewTrait + ::com_scrape_types::Class,
2160 W: ::com_scrape_types::Wrapper<C>,
2161 {
2162 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
2163 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
2164 (*ptr).getSize(
2165 size,
2166 )
2167 }
2168 unsafe extern "system" fn onSize<C, W, const OFFSET: isize>(
2169 this: *mut IPlugView,
2170 newSize: *mut ViewRect,
2171 ) -> tresult
2172 where
2173 C: IPlugViewTrait + ::com_scrape_types::Class,
2174 W: ::com_scrape_types::Wrapper<C>,
2175 {
2176 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
2177 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
2178 (*ptr).onSize(
2179 newSize,
2180 )
2181 }
2182 unsafe extern "system" fn onFocus<C, W, const OFFSET: isize>(
2183 this: *mut IPlugView,
2184 state: TBool,
2185 ) -> tresult
2186 where
2187 C: IPlugViewTrait + ::com_scrape_types::Class,
2188 W: ::com_scrape_types::Wrapper<C>,
2189 {
2190 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
2191 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
2192 (*ptr).onFocus(
2193 state,
2194 )
2195 }
2196 unsafe extern "system" fn setFrame<C, W, const OFFSET: isize>(
2197 this: *mut IPlugView,
2198 frame: *mut IPlugFrame,
2199 ) -> tresult
2200 where
2201 C: IPlugViewTrait + ::com_scrape_types::Class,
2202 W: ::com_scrape_types::Wrapper<C>,
2203 {
2204 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
2205 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
2206 (*ptr).setFrame(
2207 frame,
2208 )
2209 }
2210 unsafe extern "system" fn canResize<C, W, const OFFSET: isize>(
2211 this: *mut IPlugView,
2212 ) -> tresult
2213 where
2214 C: IPlugViewTrait + ::com_scrape_types::Class,
2215 W: ::com_scrape_types::Wrapper<C>,
2216 {
2217 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
2218 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
2219 (*ptr).canResize(
2220 )
2221 }
2222 unsafe extern "system" fn checkSizeConstraint<C, W, const OFFSET: isize>(
2223 this: *mut IPlugView,
2224 rect: *mut ViewRect,
2225 ) -> tresult
2226 where
2227 C: IPlugViewTrait + ::com_scrape_types::Class,
2228 W: ::com_scrape_types::Wrapper<C>,
2229 {
2230 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
2231 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
2232 (*ptr).checkSizeConstraint(
2233 rect,
2234 )
2235 }
2236 IPlugViewVtbl {
2237 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
2238 isPlatformTypeSupported: isPlatformTypeSupported::<C, W, OFFSET>,
2239 attached: attached::<C, W, OFFSET>,
2240 removed: removed::<C, W, OFFSET>,
2241 onWheel: onWheel::<C, W, OFFSET>,
2242 onKeyDown: onKeyDown::<C, W, OFFSET>,
2243 onKeyUp: onKeyUp::<C, W, OFFSET>,
2244 getSize: getSize::<C, W, OFFSET>,
2245 onSize: onSize::<C, W, OFFSET>,
2246 onFocus: onFocus::<C, W, OFFSET>,
2247 setFrame: setFrame::<C, W, OFFSET>,
2248 canResize: canResize::<C, W, OFFSET>,
2249 checkSizeConstraint: checkSizeConstraint::<C, W, OFFSET>,
2250 }
2251 }
2252 }
2253 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IPlugView
2254 where
2255 C: IPlugViewTrait + ::com_scrape_types::Class,
2256 W: ::com_scrape_types::Wrapper<C>,
2257 {
2258 const OBJ: Self = IPlugView {
2259 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
2260 };
2261 }
2262 mod __IPlugViewContentScaleSupport_wrapper {
2263 #[allow(unused_imports)]
2264 use super::*;
2265 #[allow(unused_imports)]
2266 use super::IPlugViewContentScaleSupport_::*;
2267 #[repr(C)]
2268 #[derive(Copy, Clone)]
2269 pub struct IPlugViewContentScaleSupport {
2270 pub vtbl: *const IPlugViewContentScaleSupportVtbl,
2271 }
2272 unsafe impl Send for IPlugViewContentScaleSupport {}
2273 unsafe impl Sync for IPlugViewContentScaleSupport {}
2274 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IPlugViewContentScaleSupport {}
2275 impl ::com_scrape_types::Unknown for IPlugViewContentScaleSupport {
2276 #[inline]
2277 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
2278 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
2279 }
2280 #[inline]
2281 unsafe fn add_ref(this: *mut Self) -> usize {
2282 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
2283 }
2284 #[inline]
2285 unsafe fn release(this: *mut Self) -> usize {
2286 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
2287 }
2288 }
2289 unsafe impl ::com_scrape_types::Interface for IPlugViewContentScaleSupport {
2290 type Vtbl = IPlugViewContentScaleSupportVtbl;
2291 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IPlugViewContentScaleSupport_iid);
2292 #[inline]
2293 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
2294 iid == &Self::IID || FUnknown::inherits(iid)
2295 }
2296 }
2297 #[repr(C)]
2298 #[derive(Copy, Clone)]
2299 pub struct IPlugViewContentScaleSupportVtbl {
2300 pub base: FUnknownVtbl,
2301 pub setContentScaleFactor: unsafe extern "system" fn(
2302 this: *mut IPlugViewContentScaleSupport,
2303 factor: ScaleFactor,
2304 ) -> tresult,
2305 }
2306 pub trait IPlugViewContentScaleSupportTrait {
2307 unsafe fn setContentScaleFactor(
2308 &self,
2309 factor: ScaleFactor,
2310 ) -> tresult;
2311 }
2312 impl<P> IPlugViewContentScaleSupportTrait for P
2313 where
2314 P: ::com_scrape_types::SmartPtr,
2315 P::Target: ::com_scrape_types::Inherits<IPlugViewContentScaleSupport>,
2316 {
2317 #[inline]
2318 unsafe fn setContentScaleFactor(
2319 &self,
2320 factor: ScaleFactor,
2321 ) -> tresult {
2322 let ptr = self.ptr() as *mut IPlugViewContentScaleSupport;
2323 ((*(*ptr).vtbl).setContentScaleFactor)(
2324 ptr,
2325 factor,
2326 )
2327 }
2328 }
2329 impl IPlugViewContentScaleSupport {
2330 const fn make_vtbl<C, W, const OFFSET: isize>() -> IPlugViewContentScaleSupportVtbl
2331 where
2332 C: IPlugViewContentScaleSupportTrait + ::com_scrape_types::Class,
2333 W: ::com_scrape_types::Wrapper<C>,
2334 {
2335 unsafe extern "system" fn setContentScaleFactor<C, W, const OFFSET: isize>(
2336 this: *mut IPlugViewContentScaleSupport,
2337 factor: ScaleFactor,
2338 ) -> tresult
2339 where
2340 C: IPlugViewContentScaleSupportTrait + ::com_scrape_types::Class,
2341 W: ::com_scrape_types::Wrapper<C>,
2342 {
2343 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
2344 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
2345 (*ptr).setContentScaleFactor(
2346 factor,
2347 )
2348 }
2349 IPlugViewContentScaleSupportVtbl {
2350 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
2351 setContentScaleFactor: setContentScaleFactor::<C, W, OFFSET>,
2352 }
2353 }
2354 }
2355 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IPlugViewContentScaleSupport
2356 where
2357 C: IPlugViewContentScaleSupportTrait + ::com_scrape_types::Class,
2358 W: ::com_scrape_types::Wrapper<C>,
2359 {
2360 const OBJ: Self = IPlugViewContentScaleSupport {
2361 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
2362 };
2363 }
2364 }
2365 pub use __IPlugViewContentScaleSupport_wrapper::*;
2366 pub mod IPlugViewContentScaleSupport_ {
2367 #[allow(unused_imports)]
2368 use super::*;
2369 pub type ScaleFactor = f32;
2370 }
2371 #[repr(C)]
2372 #[derive(Copy, Clone)]
2373 pub struct IPluginBase {
2374 pub vtbl: *const IPluginBaseVtbl,
2375 }
2376 unsafe impl Send for IPluginBase {}
2377 unsafe impl Sync for IPluginBase {}
2378 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IPluginBase {}
2379 impl ::com_scrape_types::Unknown for IPluginBase {
2380 #[inline]
2381 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
2382 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
2383 }
2384 #[inline]
2385 unsafe fn add_ref(this: *mut Self) -> usize {
2386 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
2387 }
2388 #[inline]
2389 unsafe fn release(this: *mut Self) -> usize {
2390 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
2391 }
2392 }
2393 unsafe impl ::com_scrape_types::Interface for IPluginBase {
2394 type Vtbl = IPluginBaseVtbl;
2395 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IPluginBase_iid);
2396 #[inline]
2397 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
2398 iid == &Self::IID || FUnknown::inherits(iid)
2399 }
2400 }
2401 #[repr(C)]
2402 #[derive(Copy, Clone)]
2403 pub struct IPluginBaseVtbl {
2404 pub base: FUnknownVtbl,
2405 pub initialize: unsafe extern "system" fn(
2406 this: *mut IPluginBase,
2407 context: *mut FUnknown,
2408 ) -> tresult,
2409 pub terminate: unsafe extern "system" fn(
2410 this: *mut IPluginBase,
2411 ) -> tresult,
2412 }
2413 pub trait IPluginBaseTrait {
2414 unsafe fn initialize(
2415 &self,
2416 context: *mut FUnknown,
2417 ) -> tresult;
2418 unsafe fn terminate(
2419 &self,
2420 ) -> tresult;
2421 }
2422 impl<P> IPluginBaseTrait for P
2423 where
2424 P: ::com_scrape_types::SmartPtr,
2425 P::Target: ::com_scrape_types::Inherits<IPluginBase>,
2426 {
2427 #[inline]
2428 unsafe fn initialize(
2429 &self,
2430 context: *mut FUnknown,
2431 ) -> tresult {
2432 let ptr = self.ptr() as *mut IPluginBase;
2433 ((*(*ptr).vtbl).initialize)(
2434 ptr,
2435 context,
2436 )
2437 }
2438 #[inline]
2439 unsafe fn terminate(
2440 &self,
2441 ) -> tresult {
2442 let ptr = self.ptr() as *mut IPluginBase;
2443 ((*(*ptr).vtbl).terminate)(
2444 ptr,
2445 )
2446 }
2447 }
2448 impl IPluginBase {
2449 const fn make_vtbl<C, W, const OFFSET: isize>() -> IPluginBaseVtbl
2450 where
2451 C: IPluginBaseTrait + ::com_scrape_types::Class,
2452 W: ::com_scrape_types::Wrapper<C>,
2453 {
2454 unsafe extern "system" fn initialize<C, W, const OFFSET: isize>(
2455 this: *mut IPluginBase,
2456 context: *mut FUnknown,
2457 ) -> tresult
2458 where
2459 C: IPluginBaseTrait + ::com_scrape_types::Class,
2460 W: ::com_scrape_types::Wrapper<C>,
2461 {
2462 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
2463 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
2464 (*ptr).initialize(
2465 context,
2466 )
2467 }
2468 unsafe extern "system" fn terminate<C, W, const OFFSET: isize>(
2469 this: *mut IPluginBase,
2470 ) -> tresult
2471 where
2472 C: IPluginBaseTrait + ::com_scrape_types::Class,
2473 W: ::com_scrape_types::Wrapper<C>,
2474 {
2475 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
2476 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
2477 (*ptr).terminate(
2478 )
2479 }
2480 IPluginBaseVtbl {
2481 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
2482 initialize: initialize::<C, W, OFFSET>,
2483 terminate: terminate::<C, W, OFFSET>,
2484 }
2485 }
2486 }
2487 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IPluginBase
2488 where
2489 C: IPluginBaseTrait + ::com_scrape_types::Class,
2490 W: ::com_scrape_types::Wrapper<C>,
2491 {
2492 const OBJ: Self = IPluginBase {
2493 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
2494 };
2495 }
2496 #[repr(C)]
2497 #[derive(Copy, Clone)]
2498 pub struct IPluginCompatibility {
2499 pub vtbl: *const IPluginCompatibilityVtbl,
2500 }
2501 unsafe impl Send for IPluginCompatibility {}
2502 unsafe impl Sync for IPluginCompatibility {}
2503 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IPluginCompatibility {}
2504 impl ::com_scrape_types::Unknown for IPluginCompatibility {
2505 #[inline]
2506 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
2507 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
2508 }
2509 #[inline]
2510 unsafe fn add_ref(this: *mut Self) -> usize {
2511 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
2512 }
2513 #[inline]
2514 unsafe fn release(this: *mut Self) -> usize {
2515 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
2516 }
2517 }
2518 unsafe impl ::com_scrape_types::Interface for IPluginCompatibility {
2519 type Vtbl = IPluginCompatibilityVtbl;
2520 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IPluginCompatibility_iid);
2521 #[inline]
2522 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
2523 iid == &Self::IID || FUnknown::inherits(iid)
2524 }
2525 }
2526 #[repr(C)]
2527 #[derive(Copy, Clone)]
2528 pub struct IPluginCompatibilityVtbl {
2529 pub base: FUnknownVtbl,
2530 pub getCompatibilityJSON: unsafe extern "system" fn(
2531 this: *mut IPluginCompatibility,
2532 stream: *mut IBStream,
2533 ) -> tresult,
2534 }
2535 pub trait IPluginCompatibilityTrait {
2536 unsafe fn getCompatibilityJSON(
2537 &self,
2538 stream: *mut IBStream,
2539 ) -> tresult;
2540 }
2541 impl<P> IPluginCompatibilityTrait for P
2542 where
2543 P: ::com_scrape_types::SmartPtr,
2544 P::Target: ::com_scrape_types::Inherits<IPluginCompatibility>,
2545 {
2546 #[inline]
2547 unsafe fn getCompatibilityJSON(
2548 &self,
2549 stream: *mut IBStream,
2550 ) -> tresult {
2551 let ptr = self.ptr() as *mut IPluginCompatibility;
2552 ((*(*ptr).vtbl).getCompatibilityJSON)(
2553 ptr,
2554 stream,
2555 )
2556 }
2557 }
2558 impl IPluginCompatibility {
2559 const fn make_vtbl<C, W, const OFFSET: isize>() -> IPluginCompatibilityVtbl
2560 where
2561 C: IPluginCompatibilityTrait + ::com_scrape_types::Class,
2562 W: ::com_scrape_types::Wrapper<C>,
2563 {
2564 unsafe extern "system" fn getCompatibilityJSON<C, W, const OFFSET: isize>(
2565 this: *mut IPluginCompatibility,
2566 stream: *mut IBStream,
2567 ) -> tresult
2568 where
2569 C: IPluginCompatibilityTrait + ::com_scrape_types::Class,
2570 W: ::com_scrape_types::Wrapper<C>,
2571 {
2572 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
2573 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
2574 (*ptr).getCompatibilityJSON(
2575 stream,
2576 )
2577 }
2578 IPluginCompatibilityVtbl {
2579 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
2580 getCompatibilityJSON: getCompatibilityJSON::<C, W, OFFSET>,
2581 }
2582 }
2583 }
2584 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IPluginCompatibility
2585 where
2586 C: IPluginCompatibilityTrait + ::com_scrape_types::Class,
2587 W: ::com_scrape_types::Wrapper<C>,
2588 {
2589 const OBJ: Self = IPluginCompatibility {
2590 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
2591 };
2592 }
2593 #[repr(C)]
2594 #[derive(Copy, Clone)]
2595 pub struct IPluginFactory {
2596 pub vtbl: *const IPluginFactoryVtbl,
2597 }
2598 unsafe impl Send for IPluginFactory {}
2599 unsafe impl Sync for IPluginFactory {}
2600 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IPluginFactory {}
2601 impl ::com_scrape_types::Unknown for IPluginFactory {
2602 #[inline]
2603 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
2604 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
2605 }
2606 #[inline]
2607 unsafe fn add_ref(this: *mut Self) -> usize {
2608 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
2609 }
2610 #[inline]
2611 unsafe fn release(this: *mut Self) -> usize {
2612 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
2613 }
2614 }
2615 unsafe impl ::com_scrape_types::Interface for IPluginFactory {
2616 type Vtbl = IPluginFactoryVtbl;
2617 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IPluginFactory_iid);
2618 #[inline]
2619 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
2620 iid == &Self::IID || FUnknown::inherits(iid)
2621 }
2622 }
2623 #[repr(C)]
2624 #[derive(Copy, Clone)]
2625 pub struct IPluginFactoryVtbl {
2626 pub base: FUnknownVtbl,
2627 pub getFactoryInfo: unsafe extern "system" fn(
2628 this: *mut IPluginFactory,
2629 info: *mut PFactoryInfo,
2630 ) -> tresult,
2631 pub countClasses: unsafe extern "system" fn(
2632 this: *mut IPluginFactory,
2633 ) -> int32,
2634 pub getClassInfo: unsafe extern "system" fn(
2635 this: *mut IPluginFactory,
2636 index: int32,
2637 info: *mut PClassInfo,
2638 ) -> tresult,
2639 pub createInstance: unsafe extern "system" fn(
2640 this: *mut IPluginFactory,
2641 cid: FIDString,
2642 _iid: FIDString,
2643 obj: *mut *mut ::std::ffi::c_void,
2644 ) -> tresult,
2645 }
2646 pub trait IPluginFactoryTrait {
2647 unsafe fn getFactoryInfo(
2648 &self,
2649 info: *mut PFactoryInfo,
2650 ) -> tresult;
2651 unsafe fn countClasses(
2652 &self,
2653 ) -> int32;
2654 unsafe fn getClassInfo(
2655 &self,
2656 index: int32,
2657 info: *mut PClassInfo,
2658 ) -> tresult;
2659 unsafe fn createInstance(
2660 &self,
2661 cid: FIDString,
2662 _iid: FIDString,
2663 obj: *mut *mut ::std::ffi::c_void,
2664 ) -> tresult;
2665 }
2666 impl<P> IPluginFactoryTrait for P
2667 where
2668 P: ::com_scrape_types::SmartPtr,
2669 P::Target: ::com_scrape_types::Inherits<IPluginFactory>,
2670 {
2671 #[inline]
2672 unsafe fn getFactoryInfo(
2673 &self,
2674 info: *mut PFactoryInfo,
2675 ) -> tresult {
2676 let ptr = self.ptr() as *mut IPluginFactory;
2677 ((*(*ptr).vtbl).getFactoryInfo)(
2678 ptr,
2679 info,
2680 )
2681 }
2682 #[inline]
2683 unsafe fn countClasses(
2684 &self,
2685 ) -> int32 {
2686 let ptr = self.ptr() as *mut IPluginFactory;
2687 ((*(*ptr).vtbl).countClasses)(
2688 ptr,
2689 )
2690 }
2691 #[inline]
2692 unsafe fn getClassInfo(
2693 &self,
2694 index: int32,
2695 info: *mut PClassInfo,
2696 ) -> tresult {
2697 let ptr = self.ptr() as *mut IPluginFactory;
2698 ((*(*ptr).vtbl).getClassInfo)(
2699 ptr,
2700 index,
2701 info,
2702 )
2703 }
2704 #[inline]
2705 unsafe fn createInstance(
2706 &self,
2707 cid: FIDString,
2708 _iid: FIDString,
2709 obj: *mut *mut ::std::ffi::c_void,
2710 ) -> tresult {
2711 let ptr = self.ptr() as *mut IPluginFactory;
2712 ((*(*ptr).vtbl).createInstance)(
2713 ptr,
2714 cid,
2715 _iid,
2716 obj,
2717 )
2718 }
2719 }
2720 impl IPluginFactory {
2721 const fn make_vtbl<C, W, const OFFSET: isize>() -> IPluginFactoryVtbl
2722 where
2723 C: IPluginFactoryTrait + ::com_scrape_types::Class,
2724 W: ::com_scrape_types::Wrapper<C>,
2725 {
2726 unsafe extern "system" fn getFactoryInfo<C, W, const OFFSET: isize>(
2727 this: *mut IPluginFactory,
2728 info: *mut PFactoryInfo,
2729 ) -> tresult
2730 where
2731 C: IPluginFactoryTrait + ::com_scrape_types::Class,
2732 W: ::com_scrape_types::Wrapper<C>,
2733 {
2734 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
2735 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
2736 (*ptr).getFactoryInfo(
2737 info,
2738 )
2739 }
2740 unsafe extern "system" fn countClasses<C, W, const OFFSET: isize>(
2741 this: *mut IPluginFactory,
2742 ) -> int32
2743 where
2744 C: IPluginFactoryTrait + ::com_scrape_types::Class,
2745 W: ::com_scrape_types::Wrapper<C>,
2746 {
2747 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
2748 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
2749 (*ptr).countClasses(
2750 )
2751 }
2752 unsafe extern "system" fn getClassInfo<C, W, const OFFSET: isize>(
2753 this: *mut IPluginFactory,
2754 index: int32,
2755 info: *mut PClassInfo,
2756 ) -> tresult
2757 where
2758 C: IPluginFactoryTrait + ::com_scrape_types::Class,
2759 W: ::com_scrape_types::Wrapper<C>,
2760 {
2761 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
2762 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
2763 (*ptr).getClassInfo(
2764 index,
2765 info,
2766 )
2767 }
2768 unsafe extern "system" fn createInstance<C, W, const OFFSET: isize>(
2769 this: *mut IPluginFactory,
2770 cid: FIDString,
2771 _iid: FIDString,
2772 obj: *mut *mut ::std::ffi::c_void,
2773 ) -> tresult
2774 where
2775 C: IPluginFactoryTrait + ::com_scrape_types::Class,
2776 W: ::com_scrape_types::Wrapper<C>,
2777 {
2778 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
2779 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
2780 (*ptr).createInstance(
2781 cid,
2782 _iid,
2783 obj,
2784 )
2785 }
2786 IPluginFactoryVtbl {
2787 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
2788 getFactoryInfo: getFactoryInfo::<C, W, OFFSET>,
2789 countClasses: countClasses::<C, W, OFFSET>,
2790 getClassInfo: getClassInfo::<C, W, OFFSET>,
2791 createInstance: createInstance::<C, W, OFFSET>,
2792 }
2793 }
2794 }
2795 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IPluginFactory
2796 where
2797 C: IPluginFactoryTrait + ::com_scrape_types::Class,
2798 W: ::com_scrape_types::Wrapper<C>,
2799 {
2800 const OBJ: Self = IPluginFactory {
2801 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
2802 };
2803 }
2804 #[repr(C)]
2805 #[derive(Copy, Clone)]
2806 pub struct IPluginFactory2 {
2807 pub vtbl: *const IPluginFactory2Vtbl,
2808 }
2809 unsafe impl Send for IPluginFactory2 {}
2810 unsafe impl Sync for IPluginFactory2 {}
2811 unsafe impl ::com_scrape_types::Inherits<IPluginFactory> for IPluginFactory2 {}
2812 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IPluginFactory2 {}
2813 impl ::com_scrape_types::Unknown for IPluginFactory2 {
2814 #[inline]
2815 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
2816 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
2817 }
2818 #[inline]
2819 unsafe fn add_ref(this: *mut Self) -> usize {
2820 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
2821 }
2822 #[inline]
2823 unsafe fn release(this: *mut Self) -> usize {
2824 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
2825 }
2826 }
2827 unsafe impl ::com_scrape_types::Interface for IPluginFactory2 {
2828 type Vtbl = IPluginFactory2Vtbl;
2829 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IPluginFactory2_iid);
2830 #[inline]
2831 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
2832 iid == &Self::IID || IPluginFactory::inherits(iid)
2833 }
2834 }
2835 #[repr(C)]
2836 #[derive(Copy, Clone)]
2837 pub struct IPluginFactory2Vtbl {
2838 pub base: IPluginFactoryVtbl,
2839 pub getClassInfo2: unsafe extern "system" fn(
2840 this: *mut IPluginFactory2,
2841 index: int32,
2842 info: *mut PClassInfo2,
2843 ) -> tresult,
2844 }
2845 pub trait IPluginFactory2Trait: IPluginFactoryTrait {
2846 unsafe fn getClassInfo2(
2847 &self,
2848 index: int32,
2849 info: *mut PClassInfo2,
2850 ) -> tresult;
2851 }
2852 impl<P> IPluginFactory2Trait for P
2853 where
2854 P: ::com_scrape_types::SmartPtr,
2855 P::Target: ::com_scrape_types::Inherits<IPluginFactory2>,
2856 P::Target: ::com_scrape_types::Inherits<IPluginFactory>,
2857 {
2858 #[inline]
2859 unsafe fn getClassInfo2(
2860 &self,
2861 index: int32,
2862 info: *mut PClassInfo2,
2863 ) -> tresult {
2864 let ptr = self.ptr() as *mut IPluginFactory2;
2865 ((*(*ptr).vtbl).getClassInfo2)(
2866 ptr,
2867 index,
2868 info,
2869 )
2870 }
2871 }
2872 impl IPluginFactory2 {
2873 const fn make_vtbl<C, W, const OFFSET: isize>() -> IPluginFactory2Vtbl
2874 where
2875 C: IPluginFactory2Trait + ::com_scrape_types::Class,
2876 W: ::com_scrape_types::Wrapper<C>,
2877 {
2878 unsafe extern "system" fn getClassInfo2<C, W, const OFFSET: isize>(
2879 this: *mut IPluginFactory2,
2880 index: int32,
2881 info: *mut PClassInfo2,
2882 ) -> tresult
2883 where
2884 C: IPluginFactory2Trait + ::com_scrape_types::Class,
2885 W: ::com_scrape_types::Wrapper<C>,
2886 {
2887 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
2888 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
2889 (*ptr).getClassInfo2(
2890 index,
2891 info,
2892 )
2893 }
2894 IPluginFactory2Vtbl {
2895 base: IPluginFactory::make_vtbl::<C, W, OFFSET>(),
2896 getClassInfo2: getClassInfo2::<C, W, OFFSET>,
2897 }
2898 }
2899 }
2900 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IPluginFactory2
2901 where
2902 C: IPluginFactory2Trait + ::com_scrape_types::Class,
2903 W: ::com_scrape_types::Wrapper<C>,
2904 {
2905 const OBJ: Self = IPluginFactory2 {
2906 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
2907 };
2908 }
2909 #[repr(C)]
2910 #[derive(Copy, Clone)]
2911 pub struct IPluginFactory3 {
2912 pub vtbl: *const IPluginFactory3Vtbl,
2913 }
2914 unsafe impl Send for IPluginFactory3 {}
2915 unsafe impl Sync for IPluginFactory3 {}
2916 unsafe impl ::com_scrape_types::Inherits<IPluginFactory2> for IPluginFactory3 {}
2917 unsafe impl ::com_scrape_types::Inherits<IPluginFactory> for IPluginFactory3 {}
2918 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IPluginFactory3 {}
2919 impl ::com_scrape_types::Unknown for IPluginFactory3 {
2920 #[inline]
2921 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
2922 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
2923 }
2924 #[inline]
2925 unsafe fn add_ref(this: *mut Self) -> usize {
2926 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
2927 }
2928 #[inline]
2929 unsafe fn release(this: *mut Self) -> usize {
2930 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
2931 }
2932 }
2933 unsafe impl ::com_scrape_types::Interface for IPluginFactory3 {
2934 type Vtbl = IPluginFactory3Vtbl;
2935 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IPluginFactory3_iid);
2936 #[inline]
2937 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
2938 iid == &Self::IID || IPluginFactory2::inherits(iid)
2939 }
2940 }
2941 #[repr(C)]
2942 #[derive(Copy, Clone)]
2943 pub struct IPluginFactory3Vtbl {
2944 pub base: IPluginFactory2Vtbl,
2945 pub getClassInfoUnicode: unsafe extern "system" fn(
2946 this: *mut IPluginFactory3,
2947 index: int32,
2948 info: *mut PClassInfoW,
2949 ) -> tresult,
2950 pub setHostContext: unsafe extern "system" fn(
2951 this: *mut IPluginFactory3,
2952 context: *mut FUnknown,
2953 ) -> tresult,
2954 }
2955 pub trait IPluginFactory3Trait: IPluginFactory2Trait {
2956 unsafe fn getClassInfoUnicode(
2957 &self,
2958 index: int32,
2959 info: *mut PClassInfoW,
2960 ) -> tresult;
2961 unsafe fn setHostContext(
2962 &self,
2963 context: *mut FUnknown,
2964 ) -> tresult;
2965 }
2966 impl<P> IPluginFactory3Trait for P
2967 where
2968 P: ::com_scrape_types::SmartPtr,
2969 P::Target: ::com_scrape_types::Inherits<IPluginFactory3>,
2970 P::Target: ::com_scrape_types::Inherits<IPluginFactory2>,
2971 P::Target: ::com_scrape_types::Inherits<IPluginFactory>,
2972 {
2973 #[inline]
2974 unsafe fn getClassInfoUnicode(
2975 &self,
2976 index: int32,
2977 info: *mut PClassInfoW,
2978 ) -> tresult {
2979 let ptr = self.ptr() as *mut IPluginFactory3;
2980 ((*(*ptr).vtbl).getClassInfoUnicode)(
2981 ptr,
2982 index,
2983 info,
2984 )
2985 }
2986 #[inline]
2987 unsafe fn setHostContext(
2988 &self,
2989 context: *mut FUnknown,
2990 ) -> tresult {
2991 let ptr = self.ptr() as *mut IPluginFactory3;
2992 ((*(*ptr).vtbl).setHostContext)(
2993 ptr,
2994 context,
2995 )
2996 }
2997 }
2998 impl IPluginFactory3 {
2999 const fn make_vtbl<C, W, const OFFSET: isize>() -> IPluginFactory3Vtbl
3000 where
3001 C: IPluginFactory3Trait + ::com_scrape_types::Class,
3002 W: ::com_scrape_types::Wrapper<C>,
3003 {
3004 unsafe extern "system" fn getClassInfoUnicode<C, W, const OFFSET: isize>(
3005 this: *mut IPluginFactory3,
3006 index: int32,
3007 info: *mut PClassInfoW,
3008 ) -> tresult
3009 where
3010 C: IPluginFactory3Trait + ::com_scrape_types::Class,
3011 W: ::com_scrape_types::Wrapper<C>,
3012 {
3013 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
3014 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
3015 (*ptr).getClassInfoUnicode(
3016 index,
3017 info,
3018 )
3019 }
3020 unsafe extern "system" fn setHostContext<C, W, const OFFSET: isize>(
3021 this: *mut IPluginFactory3,
3022 context: *mut FUnknown,
3023 ) -> tresult
3024 where
3025 C: IPluginFactory3Trait + ::com_scrape_types::Class,
3026 W: ::com_scrape_types::Wrapper<C>,
3027 {
3028 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
3029 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
3030 (*ptr).setHostContext(
3031 context,
3032 )
3033 }
3034 IPluginFactory3Vtbl {
3035 base: IPluginFactory2::make_vtbl::<C, W, OFFSET>(),
3036 getClassInfoUnicode: getClassInfoUnicode::<C, W, OFFSET>,
3037 setHostContext: setHostContext::<C, W, OFFSET>,
3038 }
3039 }
3040 }
3041 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IPluginFactory3
3042 where
3043 C: IPluginFactory3Trait + ::com_scrape_types::Class,
3044 W: ::com_scrape_types::Wrapper<C>,
3045 {
3046 const OBJ: Self = IPluginFactory3 {
3047 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
3048 };
3049 }
3050 #[repr(C)]
3051 #[derive(Copy, Clone)]
3052 pub struct ISizeableStream {
3053 pub vtbl: *const ISizeableStreamVtbl,
3054 }
3055 unsafe impl Send for ISizeableStream {}
3056 unsafe impl Sync for ISizeableStream {}
3057 unsafe impl ::com_scrape_types::Inherits<FUnknown> for ISizeableStream {}
3058 impl ::com_scrape_types::Unknown for ISizeableStream {
3059 #[inline]
3060 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
3061 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
3062 }
3063 #[inline]
3064 unsafe fn add_ref(this: *mut Self) -> usize {
3065 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
3066 }
3067 #[inline]
3068 unsafe fn release(this: *mut Self) -> usize {
3069 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
3070 }
3071 }
3072 unsafe impl ::com_scrape_types::Interface for ISizeableStream {
3073 type Vtbl = ISizeableStreamVtbl;
3074 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(ISizeableStream_iid);
3075 #[inline]
3076 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
3077 iid == &Self::IID || FUnknown::inherits(iid)
3078 }
3079 }
3080 #[repr(C)]
3081 #[derive(Copy, Clone)]
3082 pub struct ISizeableStreamVtbl {
3083 pub base: FUnknownVtbl,
3084 pub getStreamSize: unsafe extern "system" fn(
3085 this: *mut ISizeableStream,
3086 size: *mut int64,
3087 ) -> tresult,
3088 pub setStreamSize: unsafe extern "system" fn(
3089 this: *mut ISizeableStream,
3090 size: int64,
3091 ) -> tresult,
3092 }
3093 pub trait ISizeableStreamTrait {
3094 unsafe fn getStreamSize(
3095 &self,
3096 size: *mut int64,
3097 ) -> tresult;
3098 unsafe fn setStreamSize(
3099 &self,
3100 size: int64,
3101 ) -> tresult;
3102 }
3103 impl<P> ISizeableStreamTrait for P
3104 where
3105 P: ::com_scrape_types::SmartPtr,
3106 P::Target: ::com_scrape_types::Inherits<ISizeableStream>,
3107 {
3108 #[inline]
3109 unsafe fn getStreamSize(
3110 &self,
3111 size: *mut int64,
3112 ) -> tresult {
3113 let ptr = self.ptr() as *mut ISizeableStream;
3114 ((*(*ptr).vtbl).getStreamSize)(
3115 ptr,
3116 size,
3117 )
3118 }
3119 #[inline]
3120 unsafe fn setStreamSize(
3121 &self,
3122 size: int64,
3123 ) -> tresult {
3124 let ptr = self.ptr() as *mut ISizeableStream;
3125 ((*(*ptr).vtbl).setStreamSize)(
3126 ptr,
3127 size,
3128 )
3129 }
3130 }
3131 impl ISizeableStream {
3132 const fn make_vtbl<C, W, const OFFSET: isize>() -> ISizeableStreamVtbl
3133 where
3134 C: ISizeableStreamTrait + ::com_scrape_types::Class,
3135 W: ::com_scrape_types::Wrapper<C>,
3136 {
3137 unsafe extern "system" fn getStreamSize<C, W, const OFFSET: isize>(
3138 this: *mut ISizeableStream,
3139 size: *mut int64,
3140 ) -> tresult
3141 where
3142 C: ISizeableStreamTrait + ::com_scrape_types::Class,
3143 W: ::com_scrape_types::Wrapper<C>,
3144 {
3145 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
3146 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
3147 (*ptr).getStreamSize(
3148 size,
3149 )
3150 }
3151 unsafe extern "system" fn setStreamSize<C, W, const OFFSET: isize>(
3152 this: *mut ISizeableStream,
3153 size: int64,
3154 ) -> tresult
3155 where
3156 C: ISizeableStreamTrait + ::com_scrape_types::Class,
3157 W: ::com_scrape_types::Wrapper<C>,
3158 {
3159 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
3160 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
3161 (*ptr).setStreamSize(
3162 size,
3163 )
3164 }
3165 ISizeableStreamVtbl {
3166 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
3167 getStreamSize: getStreamSize::<C, W, OFFSET>,
3168 setStreamSize: setStreamSize::<C, W, OFFSET>,
3169 }
3170 }
3171 }
3172 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for ISizeableStream
3173 where
3174 C: ISizeableStreamTrait + ::com_scrape_types::Class,
3175 W: ::com_scrape_types::Wrapper<C>,
3176 {
3177 const OBJ: Self = ISizeableStream {
3178 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
3179 };
3180 }
3181 #[repr(C)]
3182 #[derive(Copy, Clone)]
3183 pub struct IString {
3184 pub vtbl: *const IStringVtbl,
3185 }
3186 unsafe impl Send for IString {}
3187 unsafe impl Sync for IString {}
3188 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IString {}
3189 impl ::com_scrape_types::Unknown for IString {
3190 #[inline]
3191 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
3192 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
3193 }
3194 #[inline]
3195 unsafe fn add_ref(this: *mut Self) -> usize {
3196 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
3197 }
3198 #[inline]
3199 unsafe fn release(this: *mut Self) -> usize {
3200 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
3201 }
3202 }
3203 unsafe impl ::com_scrape_types::Interface for IString {
3204 type Vtbl = IStringVtbl;
3205 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IString_iid);
3206 #[inline]
3207 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
3208 iid == &Self::IID || FUnknown::inherits(iid)
3209 }
3210 }
3211 #[repr(C)]
3212 #[derive(Copy, Clone)]
3213 pub struct IStringVtbl {
3214 pub base: FUnknownVtbl,
3215 pub setText8: unsafe extern "system" fn(
3216 this: *mut IString,
3217 text: *const char8,
3218 ),
3219 pub setText16: unsafe extern "system" fn(
3220 this: *mut IString,
3221 text: *const char16,
3222 ),
3223 pub getText8: unsafe extern "system" fn(
3224 this: *mut IString,
3225 ) -> *const char8,
3226 pub getText16: unsafe extern "system" fn(
3227 this: *mut IString,
3228 ) -> *const char16,
3229 pub take: unsafe extern "system" fn(
3230 this: *mut IString,
3231 s: *mut ::std::ffi::c_void,
3232 isWide: bool,
3233 ),
3234 pub isWideString: unsafe extern "system" fn(
3235 this: *mut IString,
3236 ) -> bool,
3237 }
3238 pub trait IStringTrait {
3239 unsafe fn setText8(
3240 &self,
3241 text: *const char8,
3242 );
3243 unsafe fn setText16(
3244 &self,
3245 text: *const char16,
3246 );
3247 unsafe fn getText8(
3248 &self,
3249 ) -> *const char8;
3250 unsafe fn getText16(
3251 &self,
3252 ) -> *const char16;
3253 unsafe fn take(
3254 &self,
3255 s: *mut ::std::ffi::c_void,
3256 isWide: bool,
3257 );
3258 unsafe fn isWideString(
3259 &self,
3260 ) -> bool;
3261 }
3262 impl<P> IStringTrait for P
3263 where
3264 P: ::com_scrape_types::SmartPtr,
3265 P::Target: ::com_scrape_types::Inherits<IString>,
3266 {
3267 #[inline]
3268 unsafe fn setText8(
3269 &self,
3270 text: *const char8,
3271 ) {
3272 let ptr = self.ptr() as *mut IString;
3273 ((*(*ptr).vtbl).setText8)(
3274 ptr,
3275 text,
3276 )
3277 }
3278 #[inline]
3279 unsafe fn setText16(
3280 &self,
3281 text: *const char16,
3282 ) {
3283 let ptr = self.ptr() as *mut IString;
3284 ((*(*ptr).vtbl).setText16)(
3285 ptr,
3286 text,
3287 )
3288 }
3289 #[inline]
3290 unsafe fn getText8(
3291 &self,
3292 ) -> *const char8 {
3293 let ptr = self.ptr() as *mut IString;
3294 ((*(*ptr).vtbl).getText8)(
3295 ptr,
3296 )
3297 }
3298 #[inline]
3299 unsafe fn getText16(
3300 &self,
3301 ) -> *const char16 {
3302 let ptr = self.ptr() as *mut IString;
3303 ((*(*ptr).vtbl).getText16)(
3304 ptr,
3305 )
3306 }
3307 #[inline]
3308 unsafe fn take(
3309 &self,
3310 s: *mut ::std::ffi::c_void,
3311 isWide: bool,
3312 ) {
3313 let ptr = self.ptr() as *mut IString;
3314 ((*(*ptr).vtbl).take)(
3315 ptr,
3316 s,
3317 isWide,
3318 )
3319 }
3320 #[inline]
3321 unsafe fn isWideString(
3322 &self,
3323 ) -> bool {
3324 let ptr = self.ptr() as *mut IString;
3325 ((*(*ptr).vtbl).isWideString)(
3326 ptr,
3327 )
3328 }
3329 }
3330 impl IString {
3331 const fn make_vtbl<C, W, const OFFSET: isize>() -> IStringVtbl
3332 where
3333 C: IStringTrait + ::com_scrape_types::Class,
3334 W: ::com_scrape_types::Wrapper<C>,
3335 {
3336 unsafe extern "system" fn setText8<C, W, const OFFSET: isize>(
3337 this: *mut IString,
3338 text: *const char8,
3339 )
3340 where
3341 C: IStringTrait + ::com_scrape_types::Class,
3342 W: ::com_scrape_types::Wrapper<C>,
3343 {
3344 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
3345 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
3346 (*ptr).setText8(
3347 text,
3348 )
3349 }
3350 unsafe extern "system" fn setText16<C, W, const OFFSET: isize>(
3351 this: *mut IString,
3352 text: *const char16,
3353 )
3354 where
3355 C: IStringTrait + ::com_scrape_types::Class,
3356 W: ::com_scrape_types::Wrapper<C>,
3357 {
3358 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
3359 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
3360 (*ptr).setText16(
3361 text,
3362 )
3363 }
3364 unsafe extern "system" fn getText8<C, W, const OFFSET: isize>(
3365 this: *mut IString,
3366 ) -> *const char8
3367 where
3368 C: IStringTrait + ::com_scrape_types::Class,
3369 W: ::com_scrape_types::Wrapper<C>,
3370 {
3371 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
3372 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
3373 (*ptr).getText8(
3374 )
3375 }
3376 unsafe extern "system" fn getText16<C, W, const OFFSET: isize>(
3377 this: *mut IString,
3378 ) -> *const char16
3379 where
3380 C: IStringTrait + ::com_scrape_types::Class,
3381 W: ::com_scrape_types::Wrapper<C>,
3382 {
3383 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
3384 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
3385 (*ptr).getText16(
3386 )
3387 }
3388 unsafe extern "system" fn take<C, W, const OFFSET: isize>(
3389 this: *mut IString,
3390 s: *mut ::std::ffi::c_void,
3391 isWide: bool,
3392 )
3393 where
3394 C: IStringTrait + ::com_scrape_types::Class,
3395 W: ::com_scrape_types::Wrapper<C>,
3396 {
3397 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
3398 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
3399 (*ptr).take(
3400 s,
3401 isWide,
3402 )
3403 }
3404 unsafe extern "system" fn isWideString<C, W, const OFFSET: isize>(
3405 this: *mut IString,
3406 ) -> bool
3407 where
3408 C: IStringTrait + ::com_scrape_types::Class,
3409 W: ::com_scrape_types::Wrapper<C>,
3410 {
3411 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
3412 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
3413 (*ptr).isWideString(
3414 )
3415 }
3416 IStringVtbl {
3417 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
3418 setText8: setText8::<C, W, OFFSET>,
3419 setText16: setText16::<C, W, OFFSET>,
3420 getText8: getText8::<C, W, OFFSET>,
3421 getText16: getText16::<C, W, OFFSET>,
3422 take: take::<C, W, OFFSET>,
3423 isWideString: isWideString::<C, W, OFFSET>,
3424 }
3425 }
3426 }
3427 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IString
3428 where
3429 C: IStringTrait + ::com_scrape_types::Class,
3430 W: ::com_scrape_types::Wrapper<C>,
3431 {
3432 const OBJ: Self = IString {
3433 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
3434 };
3435 }
3436 #[repr(C)]
3437 #[derive(Copy, Clone)]
3438 pub struct IStringResult {
3439 pub vtbl: *const IStringResultVtbl,
3440 }
3441 unsafe impl Send for IStringResult {}
3442 unsafe impl Sync for IStringResult {}
3443 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IStringResult {}
3444 impl ::com_scrape_types::Unknown for IStringResult {
3445 #[inline]
3446 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
3447 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
3448 }
3449 #[inline]
3450 unsafe fn add_ref(this: *mut Self) -> usize {
3451 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
3452 }
3453 #[inline]
3454 unsafe fn release(this: *mut Self) -> usize {
3455 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
3456 }
3457 }
3458 unsafe impl ::com_scrape_types::Interface for IStringResult {
3459 type Vtbl = IStringResultVtbl;
3460 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IStringResult_iid);
3461 #[inline]
3462 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
3463 iid == &Self::IID || FUnknown::inherits(iid)
3464 }
3465 }
3466 #[repr(C)]
3467 #[derive(Copy, Clone)]
3468 pub struct IStringResultVtbl {
3469 pub base: FUnknownVtbl,
3470 pub setText: unsafe extern "system" fn(
3471 this: *mut IStringResult,
3472 text: *const char8,
3473 ),
3474 }
3475 pub trait IStringResultTrait {
3476 unsafe fn setText(
3477 &self,
3478 text: *const char8,
3479 );
3480 }
3481 impl<P> IStringResultTrait for P
3482 where
3483 P: ::com_scrape_types::SmartPtr,
3484 P::Target: ::com_scrape_types::Inherits<IStringResult>,
3485 {
3486 #[inline]
3487 unsafe fn setText(
3488 &self,
3489 text: *const char8,
3490 ) {
3491 let ptr = self.ptr() as *mut IStringResult;
3492 ((*(*ptr).vtbl).setText)(
3493 ptr,
3494 text,
3495 )
3496 }
3497 }
3498 impl IStringResult {
3499 const fn make_vtbl<C, W, const OFFSET: isize>() -> IStringResultVtbl
3500 where
3501 C: IStringResultTrait + ::com_scrape_types::Class,
3502 W: ::com_scrape_types::Wrapper<C>,
3503 {
3504 unsafe extern "system" fn setText<C, W, const OFFSET: isize>(
3505 this: *mut IStringResult,
3506 text: *const char8,
3507 )
3508 where
3509 C: IStringResultTrait + ::com_scrape_types::Class,
3510 W: ::com_scrape_types::Wrapper<C>,
3511 {
3512 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
3513 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
3514 (*ptr).setText(
3515 text,
3516 )
3517 }
3518 IStringResultVtbl {
3519 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
3520 setText: setText::<C, W, OFFSET>,
3521 }
3522 }
3523 }
3524 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IStringResult
3525 where
3526 C: IStringResultTrait + ::com_scrape_types::Class,
3527 W: ::com_scrape_types::Wrapper<C>,
3528 {
3529 const OBJ: Self = IStringResult {
3530 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
3531 };
3532 }
3533 #[repr(C)]
3534 #[derive(Copy, Clone)]
3535 pub struct IUpdateHandler {
3536 pub vtbl: *const IUpdateHandlerVtbl,
3537 }
3538 unsafe impl Send for IUpdateHandler {}
3539 unsafe impl Sync for IUpdateHandler {}
3540 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IUpdateHandler {}
3541 impl ::com_scrape_types::Unknown for IUpdateHandler {
3542 #[inline]
3543 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
3544 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
3545 }
3546 #[inline]
3547 unsafe fn add_ref(this: *mut Self) -> usize {
3548 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
3549 }
3550 #[inline]
3551 unsafe fn release(this: *mut Self) -> usize {
3552 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
3553 }
3554 }
3555 unsafe impl ::com_scrape_types::Interface for IUpdateHandler {
3556 type Vtbl = IUpdateHandlerVtbl;
3557 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IUpdateHandler_iid);
3558 #[inline]
3559 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
3560 iid == &Self::IID || FUnknown::inherits(iid)
3561 }
3562 }
3563 #[repr(C)]
3564 #[derive(Copy, Clone)]
3565 pub struct IUpdateHandlerVtbl {
3566 pub base: FUnknownVtbl,
3567 pub addDependent: unsafe extern "system" fn(
3568 this: *mut IUpdateHandler,
3569 object: *mut FUnknown,
3570 dependent: *mut IDependent,
3571 ) -> tresult,
3572 pub removeDependent: unsafe extern "system" fn(
3573 this: *mut IUpdateHandler,
3574 object: *mut FUnknown,
3575 dependent: *mut IDependent,
3576 ) -> tresult,
3577 pub triggerUpdates: unsafe extern "system" fn(
3578 this: *mut IUpdateHandler,
3579 object: *mut FUnknown,
3580 message: int32,
3581 ) -> tresult,
3582 pub deferUpdates: unsafe extern "system" fn(
3583 this: *mut IUpdateHandler,
3584 object: *mut FUnknown,
3585 message: int32,
3586 ) -> tresult,
3587 }
3588 pub trait IUpdateHandlerTrait {
3589 unsafe fn addDependent(
3590 &self,
3591 object: *mut FUnknown,
3592 dependent: *mut IDependent,
3593 ) -> tresult;
3594 unsafe fn removeDependent(
3595 &self,
3596 object: *mut FUnknown,
3597 dependent: *mut IDependent,
3598 ) -> tresult;
3599 unsafe fn triggerUpdates(
3600 &self,
3601 object: *mut FUnknown,
3602 message: int32,
3603 ) -> tresult;
3604 unsafe fn deferUpdates(
3605 &self,
3606 object: *mut FUnknown,
3607 message: int32,
3608 ) -> tresult;
3609 }
3610 impl<P> IUpdateHandlerTrait for P
3611 where
3612 P: ::com_scrape_types::SmartPtr,
3613 P::Target: ::com_scrape_types::Inherits<IUpdateHandler>,
3614 {
3615 #[inline]
3616 unsafe fn addDependent(
3617 &self,
3618 object: *mut FUnknown,
3619 dependent: *mut IDependent,
3620 ) -> tresult {
3621 let ptr = self.ptr() as *mut IUpdateHandler;
3622 ((*(*ptr).vtbl).addDependent)(
3623 ptr,
3624 object,
3625 dependent,
3626 )
3627 }
3628 #[inline]
3629 unsafe fn removeDependent(
3630 &self,
3631 object: *mut FUnknown,
3632 dependent: *mut IDependent,
3633 ) -> tresult {
3634 let ptr = self.ptr() as *mut IUpdateHandler;
3635 ((*(*ptr).vtbl).removeDependent)(
3636 ptr,
3637 object,
3638 dependent,
3639 )
3640 }
3641 #[inline]
3642 unsafe fn triggerUpdates(
3643 &self,
3644 object: *mut FUnknown,
3645 message: int32,
3646 ) -> tresult {
3647 let ptr = self.ptr() as *mut IUpdateHandler;
3648 ((*(*ptr).vtbl).triggerUpdates)(
3649 ptr,
3650 object,
3651 message,
3652 )
3653 }
3654 #[inline]
3655 unsafe fn deferUpdates(
3656 &self,
3657 object: *mut FUnknown,
3658 message: int32,
3659 ) -> tresult {
3660 let ptr = self.ptr() as *mut IUpdateHandler;
3661 ((*(*ptr).vtbl).deferUpdates)(
3662 ptr,
3663 object,
3664 message,
3665 )
3666 }
3667 }
3668 impl IUpdateHandler {
3669 const fn make_vtbl<C, W, const OFFSET: isize>() -> IUpdateHandlerVtbl
3670 where
3671 C: IUpdateHandlerTrait + ::com_scrape_types::Class,
3672 W: ::com_scrape_types::Wrapper<C>,
3673 {
3674 unsafe extern "system" fn addDependent<C, W, const OFFSET: isize>(
3675 this: *mut IUpdateHandler,
3676 object: *mut FUnknown,
3677 dependent: *mut IDependent,
3678 ) -> tresult
3679 where
3680 C: IUpdateHandlerTrait + ::com_scrape_types::Class,
3681 W: ::com_scrape_types::Wrapper<C>,
3682 {
3683 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
3684 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
3685 (*ptr).addDependent(
3686 object,
3687 dependent,
3688 )
3689 }
3690 unsafe extern "system" fn removeDependent<C, W, const OFFSET: isize>(
3691 this: *mut IUpdateHandler,
3692 object: *mut FUnknown,
3693 dependent: *mut IDependent,
3694 ) -> tresult
3695 where
3696 C: IUpdateHandlerTrait + ::com_scrape_types::Class,
3697 W: ::com_scrape_types::Wrapper<C>,
3698 {
3699 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
3700 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
3701 (*ptr).removeDependent(
3702 object,
3703 dependent,
3704 )
3705 }
3706 unsafe extern "system" fn triggerUpdates<C, W, const OFFSET: isize>(
3707 this: *mut IUpdateHandler,
3708 object: *mut FUnknown,
3709 message: int32,
3710 ) -> tresult
3711 where
3712 C: IUpdateHandlerTrait + ::com_scrape_types::Class,
3713 W: ::com_scrape_types::Wrapper<C>,
3714 {
3715 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
3716 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
3717 (*ptr).triggerUpdates(
3718 object,
3719 message,
3720 )
3721 }
3722 unsafe extern "system" fn deferUpdates<C, W, const OFFSET: isize>(
3723 this: *mut IUpdateHandler,
3724 object: *mut FUnknown,
3725 message: int32,
3726 ) -> tresult
3727 where
3728 C: IUpdateHandlerTrait + ::com_scrape_types::Class,
3729 W: ::com_scrape_types::Wrapper<C>,
3730 {
3731 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
3732 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
3733 (*ptr).deferUpdates(
3734 object,
3735 message,
3736 )
3737 }
3738 IUpdateHandlerVtbl {
3739 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
3740 addDependent: addDependent::<C, W, OFFSET>,
3741 removeDependent: removeDependent::<C, W, OFFSET>,
3742 triggerUpdates: triggerUpdates::<C, W, OFFSET>,
3743 deferUpdates: deferUpdates::<C, W, OFFSET>,
3744 }
3745 }
3746 }
3747 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IUpdateHandler
3748 where
3749 C: IUpdateHandlerTrait + ::com_scrape_types::Class,
3750 W: ::com_scrape_types::Wrapper<C>,
3751 {
3752 const OBJ: Self = IUpdateHandler {
3753 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
3754 };
3755 }
3756 #[repr(C)]
3757 #[derive(Copy, Clone)]
3758 pub struct IWaylandFrame {
3759 pub vtbl: *const IWaylandFrameVtbl,
3760 }
3761 unsafe impl Send for IWaylandFrame {}
3762 unsafe impl Sync for IWaylandFrame {}
3763 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IWaylandFrame {}
3764 impl ::com_scrape_types::Unknown for IWaylandFrame {
3765 #[inline]
3766 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
3767 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
3768 }
3769 #[inline]
3770 unsafe fn add_ref(this: *mut Self) -> usize {
3771 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
3772 }
3773 #[inline]
3774 unsafe fn release(this: *mut Self) -> usize {
3775 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
3776 }
3777 }
3778 unsafe impl ::com_scrape_types::Interface for IWaylandFrame {
3779 type Vtbl = IWaylandFrameVtbl;
3780 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IWaylandFrame_iid);
3781 #[inline]
3782 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
3783 iid == &Self::IID || FUnknown::inherits(iid)
3784 }
3785 }
3786 #[repr(C)]
3787 #[derive(Copy, Clone)]
3788 pub struct IWaylandFrameVtbl {
3789 pub base: FUnknownVtbl,
3790 pub getWaylandSurface: unsafe extern "system" fn(
3791 this: *mut IWaylandFrame,
3792 display: *mut wl_display,
3793 ) -> *mut wl_surface,
3794 pub getParentSurface: unsafe extern "system" fn(
3795 this: *mut IWaylandFrame,
3796 parentSize: *mut ViewRect,
3797 display: *mut wl_display,
3798 ) -> *mut xdg_surface,
3799 pub getParentToplevel: unsafe extern "system" fn(
3800 this: *mut IWaylandFrame,
3801 display: *mut wl_display,
3802 ) -> *mut xdg_toplevel,
3803 }
3804 pub trait IWaylandFrameTrait {
3805 unsafe fn getWaylandSurface(
3806 &self,
3807 display: *mut wl_display,
3808 ) -> *mut wl_surface;
3809 unsafe fn getParentSurface(
3810 &self,
3811 parentSize: *mut ViewRect,
3812 display: *mut wl_display,
3813 ) -> *mut xdg_surface;
3814 unsafe fn getParentToplevel(
3815 &self,
3816 display: *mut wl_display,
3817 ) -> *mut xdg_toplevel;
3818 }
3819 impl<P> IWaylandFrameTrait for P
3820 where
3821 P: ::com_scrape_types::SmartPtr,
3822 P::Target: ::com_scrape_types::Inherits<IWaylandFrame>,
3823 {
3824 #[inline]
3825 unsafe fn getWaylandSurface(
3826 &self,
3827 display: *mut wl_display,
3828 ) -> *mut wl_surface {
3829 let ptr = self.ptr() as *mut IWaylandFrame;
3830 ((*(*ptr).vtbl).getWaylandSurface)(
3831 ptr,
3832 display,
3833 )
3834 }
3835 #[inline]
3836 unsafe fn getParentSurface(
3837 &self,
3838 parentSize: *mut ViewRect,
3839 display: *mut wl_display,
3840 ) -> *mut xdg_surface {
3841 let ptr = self.ptr() as *mut IWaylandFrame;
3842 ((*(*ptr).vtbl).getParentSurface)(
3843 ptr,
3844 parentSize,
3845 display,
3846 )
3847 }
3848 #[inline]
3849 unsafe fn getParentToplevel(
3850 &self,
3851 display: *mut wl_display,
3852 ) -> *mut xdg_toplevel {
3853 let ptr = self.ptr() as *mut IWaylandFrame;
3854 ((*(*ptr).vtbl).getParentToplevel)(
3855 ptr,
3856 display,
3857 )
3858 }
3859 }
3860 impl IWaylandFrame {
3861 const fn make_vtbl<C, W, const OFFSET: isize>() -> IWaylandFrameVtbl
3862 where
3863 C: IWaylandFrameTrait + ::com_scrape_types::Class,
3864 W: ::com_scrape_types::Wrapper<C>,
3865 {
3866 unsafe extern "system" fn getWaylandSurface<C, W, const OFFSET: isize>(
3867 this: *mut IWaylandFrame,
3868 display: *mut wl_display,
3869 ) -> *mut wl_surface
3870 where
3871 C: IWaylandFrameTrait + ::com_scrape_types::Class,
3872 W: ::com_scrape_types::Wrapper<C>,
3873 {
3874 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
3875 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
3876 (*ptr).getWaylandSurface(
3877 display,
3878 )
3879 }
3880 unsafe extern "system" fn getParentSurface<C, W, const OFFSET: isize>(
3881 this: *mut IWaylandFrame,
3882 parentSize: *mut ViewRect,
3883 display: *mut wl_display,
3884 ) -> *mut xdg_surface
3885 where
3886 C: IWaylandFrameTrait + ::com_scrape_types::Class,
3887 W: ::com_scrape_types::Wrapper<C>,
3888 {
3889 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
3890 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
3891 (*ptr).getParentSurface(
3892 parentSize,
3893 display,
3894 )
3895 }
3896 unsafe extern "system" fn getParentToplevel<C, W, const OFFSET: isize>(
3897 this: *mut IWaylandFrame,
3898 display: *mut wl_display,
3899 ) -> *mut xdg_toplevel
3900 where
3901 C: IWaylandFrameTrait + ::com_scrape_types::Class,
3902 W: ::com_scrape_types::Wrapper<C>,
3903 {
3904 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
3905 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
3906 (*ptr).getParentToplevel(
3907 display,
3908 )
3909 }
3910 IWaylandFrameVtbl {
3911 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
3912 getWaylandSurface: getWaylandSurface::<C, W, OFFSET>,
3913 getParentSurface: getParentSurface::<C, W, OFFSET>,
3914 getParentToplevel: getParentToplevel::<C, W, OFFSET>,
3915 }
3916 }
3917 }
3918 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IWaylandFrame
3919 where
3920 C: IWaylandFrameTrait + ::com_scrape_types::Class,
3921 W: ::com_scrape_types::Wrapper<C>,
3922 {
3923 const OBJ: Self = IWaylandFrame {
3924 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
3925 };
3926 }
3927 #[repr(C)]
3928 #[derive(Copy, Clone)]
3929 pub struct IWaylandHost {
3930 pub vtbl: *const IWaylandHostVtbl,
3931 }
3932 unsafe impl Send for IWaylandHost {}
3933 unsafe impl Sync for IWaylandHost {}
3934 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IWaylandHost {}
3935 impl ::com_scrape_types::Unknown for IWaylandHost {
3936 #[inline]
3937 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
3938 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
3939 }
3940 #[inline]
3941 unsafe fn add_ref(this: *mut Self) -> usize {
3942 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
3943 }
3944 #[inline]
3945 unsafe fn release(this: *mut Self) -> usize {
3946 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
3947 }
3948 }
3949 unsafe impl ::com_scrape_types::Interface for IWaylandHost {
3950 type Vtbl = IWaylandHostVtbl;
3951 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IWaylandHost_iid);
3952 #[inline]
3953 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
3954 iid == &Self::IID || FUnknown::inherits(iid)
3955 }
3956 }
3957 #[repr(C)]
3958 #[derive(Copy, Clone)]
3959 pub struct IWaylandHostVtbl {
3960 pub base: FUnknownVtbl,
3961 pub openWaylandConnection: unsafe extern "system" fn(
3962 this: *mut IWaylandHost,
3963 ) -> *mut wl_display,
3964 pub closeWaylandConnection: unsafe extern "system" fn(
3965 this: *mut IWaylandHost,
3966 display: *mut wl_display,
3967 ) -> tresult,
3968 }
3969 pub trait IWaylandHostTrait {
3970 unsafe fn openWaylandConnection(
3971 &self,
3972 ) -> *mut wl_display;
3973 unsafe fn closeWaylandConnection(
3974 &self,
3975 display: *mut wl_display,
3976 ) -> tresult;
3977 }
3978 impl<P> IWaylandHostTrait for P
3979 where
3980 P: ::com_scrape_types::SmartPtr,
3981 P::Target: ::com_scrape_types::Inherits<IWaylandHost>,
3982 {
3983 #[inline]
3984 unsafe fn openWaylandConnection(
3985 &self,
3986 ) -> *mut wl_display {
3987 let ptr = self.ptr() as *mut IWaylandHost;
3988 ((*(*ptr).vtbl).openWaylandConnection)(
3989 ptr,
3990 )
3991 }
3992 #[inline]
3993 unsafe fn closeWaylandConnection(
3994 &self,
3995 display: *mut wl_display,
3996 ) -> tresult {
3997 let ptr = self.ptr() as *mut IWaylandHost;
3998 ((*(*ptr).vtbl).closeWaylandConnection)(
3999 ptr,
4000 display,
4001 )
4002 }
4003 }
4004 impl IWaylandHost {
4005 const fn make_vtbl<C, W, const OFFSET: isize>() -> IWaylandHostVtbl
4006 where
4007 C: IWaylandHostTrait + ::com_scrape_types::Class,
4008 W: ::com_scrape_types::Wrapper<C>,
4009 {
4010 unsafe extern "system" fn openWaylandConnection<C, W, const OFFSET: isize>(
4011 this: *mut IWaylandHost,
4012 ) -> *mut wl_display
4013 where
4014 C: IWaylandHostTrait + ::com_scrape_types::Class,
4015 W: ::com_scrape_types::Wrapper<C>,
4016 {
4017 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
4018 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
4019 (*ptr).openWaylandConnection(
4020 )
4021 }
4022 unsafe extern "system" fn closeWaylandConnection<C, W, const OFFSET: isize>(
4023 this: *mut IWaylandHost,
4024 display: *mut wl_display,
4025 ) -> tresult
4026 where
4027 C: IWaylandHostTrait + ::com_scrape_types::Class,
4028 W: ::com_scrape_types::Wrapper<C>,
4029 {
4030 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
4031 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
4032 (*ptr).closeWaylandConnection(
4033 display,
4034 )
4035 }
4036 IWaylandHostVtbl {
4037 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
4038 openWaylandConnection: openWaylandConnection::<C, W, OFFSET>,
4039 closeWaylandConnection: closeWaylandConnection::<C, W, OFFSET>,
4040 }
4041 }
4042 }
4043 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IWaylandHost
4044 where
4045 C: IWaylandHostTrait + ::com_scrape_types::Class,
4046 W: ::com_scrape_types::Wrapper<C>,
4047 {
4048 const OBJ: Self = IWaylandHost {
4049 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
4050 };
4051 }
4052 #[repr(C)]
4053 #[derive(Copy, Clone)]
4054 pub struct KeyCode {
4055 pub character: tchar,
4056 pub virt: uint8,
4057 pub modifier: uint8,
4058 }
4059 unsafe impl Send for KeyCode {}
4060 unsafe impl Sync for KeyCode {}
4061 mod __PClassInfo_wrapper {
4062 #[allow(unused_imports)]
4063 use super::*;
4064 #[allow(unused_imports)]
4065 use super::PClassInfo_::*;
4066 #[repr(C)]
4067 #[derive(Copy, Clone)]
4068 pub struct PClassInfo {
4069 pub cid: TUID,
4070 pub cardinality: int32,
4071 pub category: [char8; 32],
4072 pub name: [char8; 64],
4073 }
4074 unsafe impl Send for PClassInfo {}
4075 unsafe impl Sync for PClassInfo {}
4076 }
4077 pub use __PClassInfo_wrapper::*;
4078 pub mod PClassInfo_ {
4079 #[allow(unused_imports)]
4080 use super::*;
4081 pub type ClassCardinality = crate::support::DefaultEnumType;
4082 pub mod ClassCardinality_ {
4083 #[allow(unused_imports)]
4084 use super::*;
4085 pub const kManyInstances: ClassCardinality = 2147483647;
4086 }
4087 pub const kCategorySize: crate::support::DefaultEnumType = 32;
4088 pub const kNameSize: crate::support::DefaultEnumType = 64;
4089 }
4090 mod __PClassInfo2_wrapper {
4091 #[allow(unused_imports)]
4092 use super::*;
4093 #[allow(unused_imports)]
4094 use super::PClassInfo2_::*;
4095 #[repr(C)]
4096 #[derive(Copy, Clone)]
4097 pub struct PClassInfo2 {
4098 pub cid: TUID,
4099 pub cardinality: int32,
4100 pub category: [char8; 32],
4101 pub name: [char8; 64],
4102 pub classFlags: uint32,
4103 pub subCategories: [char8; 128],
4104 pub vendor: [char8; 64],
4105 pub version: [char8; 64],
4106 pub sdkVersion: [char8; 64],
4107 }
4108 unsafe impl Send for PClassInfo2 {}
4109 unsafe impl Sync for PClassInfo2 {}
4110 }
4111 pub use __PClassInfo2_wrapper::*;
4112 pub mod PClassInfo2_ {
4113 #[allow(unused_imports)]
4114 use super::*;
4115 pub const kSubCategoriesSize: crate::support::DefaultEnumType = 128;
4116 pub const kVendorSize: crate::support::DefaultEnumType = 64;
4117 pub const kVersionSize: crate::support::DefaultEnumType = 64;
4118 }
4119 mod __PClassInfoW_wrapper {
4120 #[allow(unused_imports)]
4121 use super::*;
4122 #[allow(unused_imports)]
4123 use super::PClassInfoW_::*;
4124 #[repr(C)]
4125 #[derive(Copy, Clone)]
4126 pub struct PClassInfoW {
4127 pub cid: TUID,
4128 pub cardinality: int32,
4129 pub category: [char8; 32],
4130 pub name: [char16; 64],
4131 pub classFlags: uint32,
4132 pub subCategories: [char8; 128],
4133 pub vendor: [char16; 64],
4134 pub version: [char16; 64],
4135 pub sdkVersion: [char16; 64],
4136 }
4137 unsafe impl Send for PClassInfoW {}
4138 unsafe impl Sync for PClassInfoW {}
4139 }
4140 pub use __PClassInfoW_wrapper::*;
4141 pub mod PClassInfoW_ {
4142 #[allow(unused_imports)]
4143 use super::*;
4144 pub const kSubCategoriesSize: crate::support::DefaultEnumType = 128;
4145 pub const kVendorSize: crate::support::DefaultEnumType = 64;
4146 pub const kVersionSize: crate::support::DefaultEnumType = 64;
4147 }
4148 mod __PFactoryInfo_wrapper {
4149 #[allow(unused_imports)]
4150 use super::*;
4151 #[allow(unused_imports)]
4152 use super::PFactoryInfo_::*;
4153 #[repr(C)]
4154 #[derive(Copy, Clone)]
4155 pub struct PFactoryInfo {
4156 pub vendor: [char8; 64],
4157 pub url: [char8; 256],
4158 pub email: [char8; 128],
4159 pub flags: int32,
4160 }
4161 unsafe impl Send for PFactoryInfo {}
4162 unsafe impl Sync for PFactoryInfo {}
4163 }
4164 pub use __PFactoryInfo_wrapper::*;
4165 pub mod PFactoryInfo_ {
4166 #[allow(unused_imports)]
4167 use super::*;
4168 pub type FactoryFlags = crate::support::DefaultEnumType;
4169 pub mod FactoryFlags_ {
4170 #[allow(unused_imports)]
4171 use super::*;
4172 pub const kClassesDiscardable: FactoryFlags = 1;
4173 pub const kComponentNonDiscardable: FactoryFlags = 8;
4174 pub const kLicenseCheck: FactoryFlags = 2;
4175 pub const kNoFlags: FactoryFlags = 0;
4176 pub const kUnicode: FactoryFlags = 16;
4177 }
4178 pub const kEmailSize: crate::support::DefaultEnumType = 128;
4179 pub const kNameSize: crate::support::DefaultEnumType = 64;
4180 pub const kURLSize: crate::support::DefaultEnumType = 256;
4181 }
4182 #[repr(C)]
4183 #[derive(Copy, Clone)]
4184 pub struct ViewRect {
4185 pub left: int32,
4186 pub top: int32,
4187 pub right: int32,
4188 pub bottom: int32,
4189 }
4190 unsafe impl Send for ViewRect {}
4191 unsafe impl Sync for ViewRect {}
4192 pub const FUnknown_iid: TUID = crate::support::uid(0x00000000, 0x00000000, 0xC0000000, 0x00000046);
4193 pub const IAttributes2_iid: TUID = crate::support::uid(0x1382126A, 0xFECA4871, 0x97D52A45, 0xB042AE99);
4194 pub const IAttributes_iid: TUID = crate::support::uid(0xFA1E32F9, 0xCA6D46F5, 0xA982F956, 0xB1191B58);
4195 pub const IBStream_iid: TUID = crate::support::uid(0xC3BF6EA2, 0x30994752, 0x9B6BF990, 0x1EE33E9B);
4196 pub const ICloneable_iid: TUID = crate::support::uid(0xD45406B9, 0x3A2D4443, 0x9DAD9BA9, 0x85A1454B);
4197 pub const IDependent_iid: TUID = crate::support::uid(0xF52B7AAE, 0xDE72416d, 0x8AF18ACE, 0x9DD7BD5E);
4198 pub const IErrorContext_iid: TUID = crate::support::uid(0x12BCD07B, 0x7C694336, 0xB7DA77C3, 0x444A0CD0);
4199 pub const IPersistent_iid: TUID = crate::support::uid(0xBA1A4637, 0x3C9F46D0, 0xA65DBA0E, 0xB85DA829);
4200 pub const IPlugFrame_iid: TUID = crate::support::uid(0x367FAF01, 0xAFA94693, 0x8D4DA2A0, 0xED0882A3);
4201 pub const IPlugViewContentScaleSupport_iid: TUID = crate::support::uid(0x65ED9690, 0x8AC44525, 0x8AADEF7A, 0x72EA703F);
4202 pub const IPlugView_iid: TUID = crate::support::uid(0x5BC32507, 0xD06049EA, 0xA6151B52, 0x2B755B29);
4203 pub const IPluginBase_iid: TUID = crate::support::uid(0x22888DDB, 0x156E45AE, 0x8358B348, 0x08190625);
4204 pub const IPluginCompatibility_iid: TUID = crate::support::uid(0x4AFD4B6A, 0x35D7C240, 0xA5C31414, 0xFB7D15E6);
4205 pub const IPluginFactory2_iid: TUID = crate::support::uid(0x0007B650, 0xF24B4C0B, 0xA464EDB9, 0xF00B2ABB);
4206 pub const IPluginFactory3_iid: TUID = crate::support::uid(0x4555A2AB, 0xC1234E57, 0x9B122910, 0x36878931);
4207 pub const IPluginFactory_iid: TUID = crate::support::uid(0x7A4D811C, 0x52114A1F, 0xAED9D2EE, 0x0B43BF9F);
4208 pub const ISizeableStream_iid: TUID = crate::support::uid(0x04F9549E, 0xE02F4E6E, 0x87E86A87, 0x47F4E17F);
4209 pub const IStringResult_iid: TUID = crate::support::uid(0x550798BC, 0x872049DB, 0x84920A15, 0x3B50B7A8);
4210 pub const IString_iid: TUID = crate::support::uid(0xF99DB7A3, 0x0FC14821, 0x800B0CF9, 0x8E348EDF);
4211 pub const IUpdateHandler_iid: TUID = crate::support::uid(0xF5246D56, 0x86544d60, 0xB026AFB5, 0x7B697B37);
4212 pub const IWaylandFrame_iid: TUID = crate::support::uid(0x809FAEC6, 0x231C4FFA, 0x98ED046C, 0x6E9E2003);
4213 pub const IWaylandHost_iid: TUID = crate::support::uid(0x5E9582EE, 0x86594652, 0xB213678E, 0x7F1A705E);
4214 pub const kInternalError: ::std::ffi::c_int = crate::support::kInternalError;
4215 pub const kInvalidArgument: ::std::ffi::c_int = crate::support::kInvalidArgument;
4216 pub const kMaxCoord: UCoord = 2147483647;
4217 pub const kMaxDouble: f64 = 1.7976931348623157e308;
4218 pub const kMaxFloat: f32 = 3.4028234663852886e38;
4219 pub const kMaxInt32: int32 = 2147483647;
4220 pub const kMaxInt32u: uint32 = 4294967295;
4221 pub const kMaxInt64: int64 = 9223372036854775807;
4222 pub const kMaxInt64u: uint64 = 18446744073709551615;
4223 pub const kMaxLong: int32 = 2147483647;
4224 pub const kMinCoord: UCoord = -2147483647;
4225 pub const kMinInt32: int32 = -2147483648;
4226 pub const kMinInt64: int64 = -9223372036854775808;
4227 pub const kMinLong: int32 = -2147483648;
4228 pub const kNoInterface: ::std::ffi::c_int = crate::support::kNoInterface;
4229 pub const kNotImplemented: ::std::ffi::c_int = crate::support::kNotImplemented;
4230 pub const kNotInitialized: ::std::ffi::c_int = crate::support::kNotInitialized;
4231 pub const kOutOfMemory: ::std::ffi::c_int = crate::support::kOutOfMemory;
4232 pub const kPlatformStringIOS: FIDString = b"IOS\0".as_ptr() as *const ::std::ffi::c_char;
4233 pub const kPlatformStringLinux: FIDString = b"Linux\0".as_ptr() as *const ::std::ffi::c_char;
4234 pub const kPlatformStringMac: FIDString = b"MAC\0".as_ptr() as *const ::std::ffi::c_char;
4235 pub const kPlatformStringWin: FIDString = b"WIN\0".as_ptr() as *const ::std::ffi::c_char;
4236 pub const kPlatformTypeHIView: FIDString = b"HIView\0".as_ptr() as *const ::std::ffi::c_char;
4237 pub const kPlatformTypeHWND: FIDString = b"HWND\0".as_ptr() as *const ::std::ffi::c_char;
4238 pub const kPlatformTypeNSView: FIDString = b"NSView\0".as_ptr() as *const ::std::ffi::c_char;
4239 pub const kPlatformTypeUIView: FIDString = b"UIView\0".as_ptr() as *const ::std::ffi::c_char;
4240 pub const kPlatformTypeWaylandSurfaceID: FIDString = b"WaylandSurfaceID\0".as_ptr() as *const ::std::ffi::c_char;
4241 pub const kPlatformTypeX11EmbedWindowID: FIDString = b"X11EmbedWindowID\0".as_ptr() as *const ::std::ffi::c_char;
4242 pub const kPrintfBufferSize: uint32 = 4096;
4243 pub const kResultFalse: ::std::ffi::c_int = crate::support::kResultFalse;
4244 pub const kResultOk: ::std::ffi::c_int = crate::support::kResultOk;
4245 pub const kResultTrue: ::std::ffi::c_int = crate::support::kResultTrue;
4246 pub mod Linux {
4247 #[allow(unused_imports)]
4248 use super::*;
4249 pub type FileDescriptor = ::std::ffi::c_int;
4250 pub type TimerInterval = uint64;
4251 #[repr(C)]
4252 #[derive(Copy, Clone)]
4253 pub struct IEventHandler {
4254 pub vtbl: *const IEventHandlerVtbl,
4255 }
4256 unsafe impl Send for IEventHandler {}
4257 unsafe impl Sync for IEventHandler {}
4258 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IEventHandler {}
4259 impl ::com_scrape_types::Unknown for IEventHandler {
4260 #[inline]
4261 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
4262 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
4263 }
4264 #[inline]
4265 unsafe fn add_ref(this: *mut Self) -> usize {
4266 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
4267 }
4268 #[inline]
4269 unsafe fn release(this: *mut Self) -> usize {
4270 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
4271 }
4272 }
4273 unsafe impl ::com_scrape_types::Interface for IEventHandler {
4274 type Vtbl = IEventHandlerVtbl;
4275 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IEventHandler_iid);
4276 #[inline]
4277 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
4278 iid == &Self::IID || FUnknown::inherits(iid)
4279 }
4280 }
4281 #[repr(C)]
4282 #[derive(Copy, Clone)]
4283 pub struct IEventHandlerVtbl {
4284 pub base: FUnknownVtbl,
4285 pub onFDIsSet: unsafe extern "system" fn(
4286 this: *mut IEventHandler,
4287 fd: FileDescriptor,
4288 ),
4289 }
4290 pub trait IEventHandlerTrait {
4291 unsafe fn onFDIsSet(
4292 &self,
4293 fd: FileDescriptor,
4294 );
4295 }
4296 impl<P> IEventHandlerTrait for P
4297 where
4298 P: ::com_scrape_types::SmartPtr,
4299 P::Target: ::com_scrape_types::Inherits<IEventHandler>,
4300 {
4301 #[inline]
4302 unsafe fn onFDIsSet(
4303 &self,
4304 fd: FileDescriptor,
4305 ) {
4306 let ptr = self.ptr() as *mut IEventHandler;
4307 ((*(*ptr).vtbl).onFDIsSet)(
4308 ptr,
4309 fd,
4310 )
4311 }
4312 }
4313 impl IEventHandler {
4314 const fn make_vtbl<C, W, const OFFSET: isize>() -> IEventHandlerVtbl
4315 where
4316 C: IEventHandlerTrait + ::com_scrape_types::Class,
4317 W: ::com_scrape_types::Wrapper<C>,
4318 {
4319 unsafe extern "system" fn onFDIsSet<C, W, const OFFSET: isize>(
4320 this: *mut IEventHandler,
4321 fd: FileDescriptor,
4322 )
4323 where
4324 C: IEventHandlerTrait + ::com_scrape_types::Class,
4325 W: ::com_scrape_types::Wrapper<C>,
4326 {
4327 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
4328 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
4329 (*ptr).onFDIsSet(
4330 fd,
4331 )
4332 }
4333 IEventHandlerVtbl {
4334 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
4335 onFDIsSet: onFDIsSet::<C, W, OFFSET>,
4336 }
4337 }
4338 }
4339 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IEventHandler
4340 where
4341 C: IEventHandlerTrait + ::com_scrape_types::Class,
4342 W: ::com_scrape_types::Wrapper<C>,
4343 {
4344 const OBJ: Self = IEventHandler {
4345 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
4346 };
4347 }
4348 #[repr(C)]
4349 #[derive(Copy, Clone)]
4350 pub struct IRunLoop {
4351 pub vtbl: *const IRunLoopVtbl,
4352 }
4353 unsafe impl Send for IRunLoop {}
4354 unsafe impl Sync for IRunLoop {}
4355 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IRunLoop {}
4356 impl ::com_scrape_types::Unknown for IRunLoop {
4357 #[inline]
4358 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
4359 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
4360 }
4361 #[inline]
4362 unsafe fn add_ref(this: *mut Self) -> usize {
4363 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
4364 }
4365 #[inline]
4366 unsafe fn release(this: *mut Self) -> usize {
4367 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
4368 }
4369 }
4370 unsafe impl ::com_scrape_types::Interface for IRunLoop {
4371 type Vtbl = IRunLoopVtbl;
4372 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IRunLoop_iid);
4373 #[inline]
4374 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
4375 iid == &Self::IID || FUnknown::inherits(iid)
4376 }
4377 }
4378 #[repr(C)]
4379 #[derive(Copy, Clone)]
4380 pub struct IRunLoopVtbl {
4381 pub base: FUnknownVtbl,
4382 pub registerEventHandler: unsafe extern "system" fn(
4383 this: *mut IRunLoop,
4384 handler: *mut IEventHandler,
4385 fd: FileDescriptor,
4386 ) -> tresult,
4387 pub unregisterEventHandler: unsafe extern "system" fn(
4388 this: *mut IRunLoop,
4389 handler: *mut IEventHandler,
4390 ) -> tresult,
4391 pub registerTimer: unsafe extern "system" fn(
4392 this: *mut IRunLoop,
4393 handler: *mut ITimerHandler,
4394 milliseconds: TimerInterval,
4395 ) -> tresult,
4396 pub unregisterTimer: unsafe extern "system" fn(
4397 this: *mut IRunLoop,
4398 handler: *mut ITimerHandler,
4399 ) -> tresult,
4400 }
4401 pub trait IRunLoopTrait {
4402 unsafe fn registerEventHandler(
4403 &self,
4404 handler: *mut IEventHandler,
4405 fd: FileDescriptor,
4406 ) -> tresult;
4407 unsafe fn unregisterEventHandler(
4408 &self,
4409 handler: *mut IEventHandler,
4410 ) -> tresult;
4411 unsafe fn registerTimer(
4412 &self,
4413 handler: *mut ITimerHandler,
4414 milliseconds: TimerInterval,
4415 ) -> tresult;
4416 unsafe fn unregisterTimer(
4417 &self,
4418 handler: *mut ITimerHandler,
4419 ) -> tresult;
4420 }
4421 impl<P> IRunLoopTrait for P
4422 where
4423 P: ::com_scrape_types::SmartPtr,
4424 P::Target: ::com_scrape_types::Inherits<IRunLoop>,
4425 {
4426 #[inline]
4427 unsafe fn registerEventHandler(
4428 &self,
4429 handler: *mut IEventHandler,
4430 fd: FileDescriptor,
4431 ) -> tresult {
4432 let ptr = self.ptr() as *mut IRunLoop;
4433 ((*(*ptr).vtbl).registerEventHandler)(
4434 ptr,
4435 handler,
4436 fd,
4437 )
4438 }
4439 #[inline]
4440 unsafe fn unregisterEventHandler(
4441 &self,
4442 handler: *mut IEventHandler,
4443 ) -> tresult {
4444 let ptr = self.ptr() as *mut IRunLoop;
4445 ((*(*ptr).vtbl).unregisterEventHandler)(
4446 ptr,
4447 handler,
4448 )
4449 }
4450 #[inline]
4451 unsafe fn registerTimer(
4452 &self,
4453 handler: *mut ITimerHandler,
4454 milliseconds: TimerInterval,
4455 ) -> tresult {
4456 let ptr = self.ptr() as *mut IRunLoop;
4457 ((*(*ptr).vtbl).registerTimer)(
4458 ptr,
4459 handler,
4460 milliseconds,
4461 )
4462 }
4463 #[inline]
4464 unsafe fn unregisterTimer(
4465 &self,
4466 handler: *mut ITimerHandler,
4467 ) -> tresult {
4468 let ptr = self.ptr() as *mut IRunLoop;
4469 ((*(*ptr).vtbl).unregisterTimer)(
4470 ptr,
4471 handler,
4472 )
4473 }
4474 }
4475 impl IRunLoop {
4476 const fn make_vtbl<C, W, const OFFSET: isize>() -> IRunLoopVtbl
4477 where
4478 C: IRunLoopTrait + ::com_scrape_types::Class,
4479 W: ::com_scrape_types::Wrapper<C>,
4480 {
4481 unsafe extern "system" fn registerEventHandler<C, W, const OFFSET: isize>(
4482 this: *mut IRunLoop,
4483 handler: *mut IEventHandler,
4484 fd: FileDescriptor,
4485 ) -> tresult
4486 where
4487 C: IRunLoopTrait + ::com_scrape_types::Class,
4488 W: ::com_scrape_types::Wrapper<C>,
4489 {
4490 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
4491 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
4492 (*ptr).registerEventHandler(
4493 handler,
4494 fd,
4495 )
4496 }
4497 unsafe extern "system" fn unregisterEventHandler<C, W, const OFFSET: isize>(
4498 this: *mut IRunLoop,
4499 handler: *mut IEventHandler,
4500 ) -> tresult
4501 where
4502 C: IRunLoopTrait + ::com_scrape_types::Class,
4503 W: ::com_scrape_types::Wrapper<C>,
4504 {
4505 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
4506 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
4507 (*ptr).unregisterEventHandler(
4508 handler,
4509 )
4510 }
4511 unsafe extern "system" fn registerTimer<C, W, const OFFSET: isize>(
4512 this: *mut IRunLoop,
4513 handler: *mut ITimerHandler,
4514 milliseconds: TimerInterval,
4515 ) -> tresult
4516 where
4517 C: IRunLoopTrait + ::com_scrape_types::Class,
4518 W: ::com_scrape_types::Wrapper<C>,
4519 {
4520 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
4521 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
4522 (*ptr).registerTimer(
4523 handler,
4524 milliseconds,
4525 )
4526 }
4527 unsafe extern "system" fn unregisterTimer<C, W, const OFFSET: isize>(
4528 this: *mut IRunLoop,
4529 handler: *mut ITimerHandler,
4530 ) -> tresult
4531 where
4532 C: IRunLoopTrait + ::com_scrape_types::Class,
4533 W: ::com_scrape_types::Wrapper<C>,
4534 {
4535 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
4536 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
4537 (*ptr).unregisterTimer(
4538 handler,
4539 )
4540 }
4541 IRunLoopVtbl {
4542 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
4543 registerEventHandler: registerEventHandler::<C, W, OFFSET>,
4544 unregisterEventHandler: unregisterEventHandler::<C, W, OFFSET>,
4545 registerTimer: registerTimer::<C, W, OFFSET>,
4546 unregisterTimer: unregisterTimer::<C, W, OFFSET>,
4547 }
4548 }
4549 }
4550 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IRunLoop
4551 where
4552 C: IRunLoopTrait + ::com_scrape_types::Class,
4553 W: ::com_scrape_types::Wrapper<C>,
4554 {
4555 const OBJ: Self = IRunLoop {
4556 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
4557 };
4558 }
4559 #[repr(C)]
4560 #[derive(Copy, Clone)]
4561 pub struct ITimerHandler {
4562 pub vtbl: *const ITimerHandlerVtbl,
4563 }
4564 unsafe impl Send for ITimerHandler {}
4565 unsafe impl Sync for ITimerHandler {}
4566 unsafe impl ::com_scrape_types::Inherits<FUnknown> for ITimerHandler {}
4567 impl ::com_scrape_types::Unknown for ITimerHandler {
4568 #[inline]
4569 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
4570 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
4571 }
4572 #[inline]
4573 unsafe fn add_ref(this: *mut Self) -> usize {
4574 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
4575 }
4576 #[inline]
4577 unsafe fn release(this: *mut Self) -> usize {
4578 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
4579 }
4580 }
4581 unsafe impl ::com_scrape_types::Interface for ITimerHandler {
4582 type Vtbl = ITimerHandlerVtbl;
4583 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(ITimerHandler_iid);
4584 #[inline]
4585 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
4586 iid == &Self::IID || FUnknown::inherits(iid)
4587 }
4588 }
4589 #[repr(C)]
4590 #[derive(Copy, Clone)]
4591 pub struct ITimerHandlerVtbl {
4592 pub base: FUnknownVtbl,
4593 pub onTimer: unsafe extern "system" fn(
4594 this: *mut ITimerHandler,
4595 ),
4596 }
4597 pub trait ITimerHandlerTrait {
4598 unsafe fn onTimer(
4599 &self,
4600 );
4601 }
4602 impl<P> ITimerHandlerTrait for P
4603 where
4604 P: ::com_scrape_types::SmartPtr,
4605 P::Target: ::com_scrape_types::Inherits<ITimerHandler>,
4606 {
4607 #[inline]
4608 unsafe fn onTimer(
4609 &self,
4610 ) {
4611 let ptr = self.ptr() as *mut ITimerHandler;
4612 ((*(*ptr).vtbl).onTimer)(
4613 ptr,
4614 )
4615 }
4616 }
4617 impl ITimerHandler {
4618 const fn make_vtbl<C, W, const OFFSET: isize>() -> ITimerHandlerVtbl
4619 where
4620 C: ITimerHandlerTrait + ::com_scrape_types::Class,
4621 W: ::com_scrape_types::Wrapper<C>,
4622 {
4623 unsafe extern "system" fn onTimer<C, W, const OFFSET: isize>(
4624 this: *mut ITimerHandler,
4625 )
4626 where
4627 C: ITimerHandlerTrait + ::com_scrape_types::Class,
4628 W: ::com_scrape_types::Wrapper<C>,
4629 {
4630 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
4631 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
4632 (*ptr).onTimer(
4633 )
4634 }
4635 ITimerHandlerVtbl {
4636 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
4637 onTimer: onTimer::<C, W, OFFSET>,
4638 }
4639 }
4640 }
4641 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for ITimerHandler
4642 where
4643 C: ITimerHandlerTrait + ::com_scrape_types::Class,
4644 W: ::com_scrape_types::Wrapper<C>,
4645 {
4646 const OBJ: Self = ITimerHandler {
4647 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
4648 };
4649 }
4650 pub const IEventHandler_iid: TUID = crate::support::uid(0x561E65C9, 0x13A0496F, 0x813A2C35, 0x654D7983);
4651 pub const IRunLoop_iid: TUID = crate::support::uid(0x18C35366, 0x97764F1A, 0x9C5B8385, 0x7A871389);
4652 pub const ITimerHandler_iid: TUID = crate::support::uid(0x10BDD94F, 0x41424774, 0x821FAD8F, 0xECA72CA9);
4653 }
4654 pub mod Vst {
4655 #[allow(unused_imports)]
4656 use super::*;
4657 pub type BusDirection = int32;
4658 pub type BusDirections = crate::support::DefaultEnumType;
4659 pub mod BusDirections_ {
4660 #[allow(unused_imports)]
4661 use super::*;
4662 pub const kInput: BusDirections = 0;
4663 pub const kOutput: BusDirections = 1;
4664 }
4665 pub type BusIndex = int32;
4666 pub type BusType = int32;
4667 pub type BusTypes = crate::support::DefaultEnumType;
4668 pub mod BusTypes_ {
4669 #[allow(unused_imports)]
4670 use super::*;
4671 pub const kAux: BusTypes = 1;
4672 pub const kMain: BusTypes = 0;
4673 }
4674 pub type CString = *const char8;
4675 pub type ColorSpec = uint32;
4676 pub type ComponentFlags = crate::support::DefaultEnumType;
4677 pub mod ComponentFlags_ {
4678 #[allow(unused_imports)]
4679 use super::*;
4680 pub const kDistributable: ComponentFlags = 1;
4681 pub const kSimpleModeSupported: ComponentFlags = 2;
4682 }
4683 pub type ControllerNumbers = crate::support::DefaultEnumType;
4684 pub mod ControllerNumbers_ {
4685 #[allow(unused_imports)]
4686 use super::*;
4687 pub const kAfterTouch: ControllerNumbers = 128;
4688 pub const kCountCtrlNumber: ControllerNumbers = 130;
4689 pub const kCtrlAllNotesOff: ControllerNumbers = 123;
4690 pub const kCtrlAllSoundsOff: ControllerNumbers = 120;
4691 pub const kCtrlAttackTime: ControllerNumbers = 73;
4692 pub const kCtrlBalance: ControllerNumbers = 8;
4693 pub const kCtrlBankSelectLSB: ControllerNumbers = 32;
4694 pub const kCtrlBankSelectMSB: ControllerNumbers = 0;
4695 pub const kCtrlBreath: ControllerNumbers = 2;
4696 pub const kCtrlDataDecrement: ControllerNumbers = 97;
4697 pub const kCtrlDataEntryLSB: ControllerNumbers = 38;
4698 pub const kCtrlDataEntryMSB: ControllerNumbers = 6;
4699 pub const kCtrlDataIncrement: ControllerNumbers = 96;
4700 pub const kCtrlDecayTime: ControllerNumbers = 75;
4701 pub const kCtrlEff1Depth: ControllerNumbers = 91;
4702 pub const kCtrlEff2Depth: ControllerNumbers = 92;
4703 pub const kCtrlEff3Depth: ControllerNumbers = 93;
4704 pub const kCtrlEff4Depth: ControllerNumbers = 94;
4705 pub const kCtrlEff5Depth: ControllerNumbers = 95;
4706 pub const kCtrlEffect1: ControllerNumbers = 12;
4707 pub const kCtrlEffect2: ControllerNumbers = 13;
4708 pub const kCtrlExpression: ControllerNumbers = 11;
4709 pub const kCtrlFilterCutoff: ControllerNumbers = 71;
4710 pub const kCtrlFilterResonance: ControllerNumbers = 74;
4711 pub const kCtrlFoot: ControllerNumbers = 4;
4712 pub const kCtrlGPC1: ControllerNumbers = 16;
4713 pub const kCtrlGPC2: ControllerNumbers = 17;
4714 pub const kCtrlGPC3: ControllerNumbers = 18;
4715 pub const kCtrlGPC4: ControllerNumbers = 19;
4716 pub const kCtrlGPC5: ControllerNumbers = 80;
4717 pub const kCtrlGPC6: ControllerNumbers = 81;
4718 pub const kCtrlGPC7: ControllerNumbers = 82;
4719 pub const kCtrlGPC8: ControllerNumbers = 83;
4720 pub const kCtrlHold2OnOff: ControllerNumbers = 69;
4721 pub const kCtrlLegatoFootSwOnOff: ControllerNumbers = 68;
4722 pub const kCtrlLocalCtrlOnOff: ControllerNumbers = 122;
4723 pub const kCtrlModWheel: ControllerNumbers = 1;
4724 pub const kCtrlNRPNSelectLSB: ControllerNumbers = 98;
4725 pub const kCtrlNRPNSelectMSB: ControllerNumbers = 99;
4726 pub const kCtrlOmniModeOff: ControllerNumbers = 124;
4727 pub const kCtrlOmniModeOn: ControllerNumbers = 125;
4728 pub const kCtrlPan: ControllerNumbers = 10;
4729 pub const kCtrlPolyModeOn: ControllerNumbers = 127;
4730 pub const kCtrlPolyModeOnOff: ControllerNumbers = 126;
4731 pub const kCtrlPolyPressure: ControllerNumbers = 131;
4732 pub const kCtrlPortaControl: ControllerNumbers = 84;
4733 pub const kCtrlPortaOnOff: ControllerNumbers = 65;
4734 pub const kCtrlPortaTime: ControllerNumbers = 5;
4735 pub const kCtrlProgramChange: ControllerNumbers = 130;
4736 pub const kCtrlQuarterFrame: ControllerNumbers = 132;
4737 pub const kCtrlRPNSelectLSB: ControllerNumbers = 100;
4738 pub const kCtrlRPNSelectMSB: ControllerNumbers = 101;
4739 pub const kCtrlReleaseTime: ControllerNumbers = 72;
4740 pub const kCtrlResetAllCtrlers: ControllerNumbers = 121;
4741 pub const kCtrlSoftPedalOnOff: ControllerNumbers = 67;
4742 pub const kCtrlSoundCtrler10: ControllerNumbers = 79;
4743 pub const kCtrlSoundVariation: ControllerNumbers = 70;
4744 pub const kCtrlSustainOnOff: ControllerNumbers = 64;
4745 pub const kCtrlSustenutoOnOff: ControllerNumbers = 66;
4746 pub const kCtrlVibratoDelay: ControllerNumbers = 78;
4747 pub const kCtrlVibratoDepth: ControllerNumbers = 77;
4748 pub const kCtrlVibratoRate: ControllerNumbers = 76;
4749 pub const kCtrlVolume: ControllerNumbers = 7;
4750 pub const kPitchBend: ControllerNumbers = 129;
4751 pub const kSystemActiveSensing: ControllerNumbers = 140;
4752 pub const kSystemCableSelect: ControllerNumbers = 135;
4753 pub const kSystemMidiClockContinue: ControllerNumbers = 138;
4754 pub const kSystemMidiClockStart: ControllerNumbers = 137;
4755 pub const kSystemMidiClockStop: ControllerNumbers = 139;
4756 pub const kSystemSongPointer: ControllerNumbers = 134;
4757 pub const kSystemSongSelect: ControllerNumbers = 133;
4758 pub const kSystemTuneRequest: ControllerNumbers = 136;
4759 }
4760 pub type CtrlNumber = int16;
4761 pub type DataExchangeBlockID = uint32;
4762 pub type DataExchangeQueueID = uint32;
4763 pub type DataExchangeUserContextID = uint32;
4764 pub type IoMode = int32;
4765 pub type IoModes = crate::support::DefaultEnumType;
4766 pub mod IoModes_ {
4767 #[allow(unused_imports)]
4768 use super::*;
4769 pub const kAdvanced: IoModes = 1;
4770 pub const kOfflineProcessing: IoModes = 2;
4771 pub const kSimple: IoModes = 0;
4772 }
4773 pub type KeyswitchTypeID = uint32;
4774 pub type KeyswitchTypeIDs = uint32;
4775 pub mod KeyswitchTypeIDs_ {
4776 #[allow(unused_imports)]
4777 use super::*;
4778 pub const kKeyRangeTypeID: KeyswitchTypeIDs = 3;
4779 pub const kNoteOnKeyswitchTypeID: KeyswitchTypeIDs = 0;
4780 pub const kOnReleaseKeyswitchTypeID: KeyswitchTypeIDs = 2;
4781 pub const kOnTheFlyKeyswitchTypeID: KeyswitchTypeIDs = 1;
4782 }
4783 pub type KnobMode = int32;
4784 pub type KnobModes = KnobMode;
4785 pub mod KnobModes_ {
4786 #[allow(unused_imports)]
4787 use super::*;
4788 pub const kCircularMode: KnobModes = 0;
4789 pub const kLinearMode: KnobModes = 2;
4790 pub const kRelativCircularMode: KnobModes = 1;
4791 }
4792 pub type MediaType = int32;
4793 pub type MediaTypes = crate::support::DefaultEnumType;
4794 pub mod MediaTypes_ {
4795 #[allow(unused_imports)]
4796 use super::*;
4797 pub const kAudio: MediaTypes = 0;
4798 pub const kEvent: MediaTypes = 1;
4799 pub const kNumMediaTypes: MediaTypes = 2;
4800 }
4801 pub type MidiChannel = uint8;
4802 pub type MidiGroup = uint8;
4803 pub type NoteExpressionTypeID = uint32;
4804 pub type NoteExpressionTypeIDs = uint32;
4805 pub mod NoteExpressionTypeIDs_ {
4806 #[allow(unused_imports)]
4807 use super::*;
4808 pub const kBrightnessTypeID: NoteExpressionTypeIDs = 5;
4809 pub const kCustomEnd: NoteExpressionTypeIDs = 200000;
4810 pub const kCustomStart: NoteExpressionTypeIDs = 100000;
4811 pub const kExpressionTypeID: NoteExpressionTypeIDs = 4;
4812 pub const kInvalidTypeID: NoteExpressionTypeIDs = 4294967295;
4813 pub const kPanTypeID: NoteExpressionTypeIDs = 1;
4814 pub const kPhonemeTypeID: NoteExpressionTypeIDs = 7;
4815 pub const kTextTypeID: NoteExpressionTypeIDs = 6;
4816 pub const kTuningTypeID: NoteExpressionTypeIDs = 2;
4817 pub const kVibratoTypeID: NoteExpressionTypeIDs = 3;
4818 pub const kVolumeTypeID: NoteExpressionTypeIDs = 0;
4819 }
4820 pub type NoteExpressionValue = f64;
4821 pub type NoteIDUserRange = ::std::ffi::c_int;
4822 pub mod NoteIDUserRange_ {
4823 #[allow(unused_imports)]
4824 use super::*;
4825 pub const kNoteIDUserRangeLowerBound: NoteIDUserRange = -10000;
4826 pub const kNoteIDUserRangeUpperBound: NoteIDUserRange = -1000;
4827 }
4828 pub type ParamID = uint32;
4829 pub type ParamValue = f64;
4830 pub type PhysicalUITypeID = uint32;
4831 pub type PhysicalUITypeIDs = crate::support::DefaultEnumType;
4832 pub mod PhysicalUITypeIDs_ {
4833 #[allow(unused_imports)]
4834 use super::*;
4835 pub const kInvalidPUITypeID: PhysicalUITypeIDs = 0xFFFFFFFFu32 as crate::support::DefaultEnumType;
4836 pub const kPUIPressure: PhysicalUITypeIDs = 2;
4837 pub const kPUITypeCount: PhysicalUITypeIDs = 3;
4838 pub const kPUIXMovement: PhysicalUITypeIDs = 0;
4839 pub const kPUIYMovement: PhysicalUITypeIDs = 1;
4840 }
4841 pub type PrefetchableSupport = uint32;
4842 pub type ProcessModes = crate::support::DefaultEnumType;
4843 pub mod ProcessModes_ {
4844 #[allow(unused_imports)]
4845 use super::*;
4846 pub const kOffline: ProcessModes = 2;
4847 pub const kPrefetch: ProcessModes = 1;
4848 pub const kRealtime: ProcessModes = 0;
4849 }
4850 pub type ProgramListID = int32;
4851 pub type RestartFlags = int32;
4852 pub mod RestartFlags_ {
4853 #[allow(unused_imports)]
4854 use super::*;
4855 pub const kIoChanged: RestartFlags = 2;
4856 pub const kIoTitlesChanged: RestartFlags = 128;
4857 pub const kKeyswitchChanged: RestartFlags = 1024;
4858 pub const kLatencyChanged: RestartFlags = 8;
4859 pub const kMidiCCAssignmentChanged: RestartFlags = 32;
4860 pub const kNoteExpressionChanged: RestartFlags = 64;
4861 pub const kParamIDMappingChanged: RestartFlags = 2048;
4862 pub const kParamTitlesChanged: RestartFlags = 16;
4863 pub const kParamValuesChanged: RestartFlags = 4;
4864 pub const kPrefetchableSupportChanged: RestartFlags = 256;
4865 pub const kReloadComponent: RestartFlags = 1;
4866 pub const kRoutingInfoChanged: RestartFlags = 512;
4867 }
4868 pub type Sample32 = f32;
4869 pub type Sample64 = f64;
4870 pub type SampleRate = f64;
4871 pub type Speaker = uint64;
4872 pub type SpeakerArrangement = uint64;
4873 pub type String128 = [TChar; 128];
4874 pub type SymbolicSampleSizes = crate::support::DefaultEnumType;
4875 pub mod SymbolicSampleSizes_ {
4876 #[allow(unused_imports)]
4877 use super::*;
4878 pub const kSample32: SymbolicSampleSizes = 0;
4879 pub const kSample64: SymbolicSampleSizes = 1;
4880 }
4881 pub type TChar = char16;
4882 pub type TQuarterNotes = f64;
4883 pub type TSamples = int64;
4884 pub type UnitID = int32;
4885 pub type ePrefetchableSupport = crate::support::DefaultEnumType;
4886 pub mod ePrefetchableSupport_ {
4887 #[allow(unused_imports)]
4888 use super::*;
4889 pub const kIsNeverPrefetchable: ePrefetchableSupport = 0;
4890 pub const kIsNotYetPrefetchable: ePrefetchableSupport = 2;
4891 pub const kIsYetPrefetchable: ePrefetchableSupport = 1;
4892 pub const kNumPrefetchableSupport: ePrefetchableSupport = 3;
4893 }
4894 #[repr(C)]
4895 #[derive(Copy, Clone)]
4896 pub struct AudioBusBuffers {
4897 pub numChannels: int32,
4898 pub silenceFlags: uint64,
4899 pub __field0: AudioBusBuffers__type0,
4900 }
4901 unsafe impl Send for AudioBusBuffers {}
4902 unsafe impl Sync for AudioBusBuffers {}
4903 #[repr(C)]
4904 #[derive(Copy, Clone)]
4905 pub union AudioBusBuffers__type0 {
4906 pub channelBuffers32: *mut *mut Sample32,
4907 pub channelBuffers64: *mut *mut Sample64,
4908 }
4909 unsafe impl Send for AudioBusBuffers__type0 {}
4910 unsafe impl Sync for AudioBusBuffers__type0 {}
4911 mod __BusInfo_wrapper {
4912 #[allow(unused_imports)]
4913 use super::*;
4914 #[allow(unused_imports)]
4915 use super::BusInfo_::*;
4916 #[repr(C)]
4917 #[derive(Copy, Clone)]
4918 pub struct BusInfo {
4919 pub mediaType: MediaType,
4920 pub direction: BusDirection,
4921 pub channelCount: int32,
4922 pub name: String128,
4923 pub busType: BusType,
4924 pub flags: uint32,
4925 }
4926 unsafe impl Send for BusInfo {}
4927 unsafe impl Sync for BusInfo {}
4928 }
4929 pub use __BusInfo_wrapper::*;
4930 pub mod BusInfo_ {
4931 #[allow(unused_imports)]
4932 use super::*;
4933 pub type BusFlags = crate::support::DefaultEnumType;
4934 pub mod BusFlags_ {
4935 #[allow(unused_imports)]
4936 use super::*;
4937 pub const kDefaultActive: BusFlags = 1;
4938 pub const kIsControlVoltage: BusFlags = 2;
4939 }
4940 }
4941 mod __Chord_wrapper {
4942 #[allow(unused_imports)]
4943 use super::*;
4944 #[allow(unused_imports)]
4945 use super::Chord_::*;
4946 #[repr(C)]
4947 #[derive(Copy, Clone)]
4948 pub struct Chord {
4949 pub keyNote: uint8,
4950 pub rootNote: uint8,
4951 pub chordMask: int16,
4952 }
4953 unsafe impl Send for Chord {}
4954 unsafe impl Sync for Chord {}
4955 }
4956 pub use __Chord_wrapper::*;
4957 pub mod Chord_ {
4958 #[allow(unused_imports)]
4959 use super::*;
4960 pub type Masks = crate::support::DefaultEnumType;
4961 pub mod Masks_ {
4962 #[allow(unused_imports)]
4963 use super::*;
4964 pub const kChordMask: Masks = 4095;
4965 pub const kReservedMask: Masks = 61440;
4966 }
4967 }
4968 #[repr(C)]
4969 #[derive(Copy, Clone)]
4970 pub struct ChordEvent {
4971 pub root: int16,
4972 pub bassNote: int16,
4973 pub mask: int16,
4974 pub textLen: uint16,
4975 pub text: *const TChar,
4976 }
4977 unsafe impl Send for ChordEvent {}
4978 unsafe impl Sync for ChordEvent {}
4979 mod __DataEvent_wrapper {
4980 #[allow(unused_imports)]
4981 use super::*;
4982 #[allow(unused_imports)]
4983 use super::DataEvent_::*;
4984 #[repr(C)]
4985 #[derive(Copy, Clone)]
4986 pub struct DataEvent {
4987 pub size: uint32,
4988 pub r#type: uint32,
4989 pub bytes: *const uint8,
4990 }
4991 unsafe impl Send for DataEvent {}
4992 unsafe impl Sync for DataEvent {}
4993 }
4994 pub use __DataEvent_wrapper::*;
4995 pub mod DataEvent_ {
4996 #[allow(unused_imports)]
4997 use super::*;
4998 pub type DataTypes = crate::support::DefaultEnumType;
4999 pub mod DataTypes_ {
5000 #[allow(unused_imports)]
5001 use super::*;
5002 pub const kMidiSysEx: DataTypes = 0;
5003 }
5004 }
5005 #[repr(C)]
5006 #[derive(Copy, Clone)]
5007 pub struct DataExchangeBlock {
5008 pub data: *mut ::std::ffi::c_void,
5009 pub size: uint32,
5010 pub blockID: DataExchangeBlockID,
5011 }
5012 unsafe impl Send for DataExchangeBlock {}
5013 unsafe impl Sync for DataExchangeBlock {}
5014 mod __Event_wrapper {
5015 #[allow(unused_imports)]
5016 use super::*;
5017 #[allow(unused_imports)]
5018 use super::Event_::*;
5019 #[repr(C)]
5020 #[derive(Copy, Clone)]
5021 pub struct Event {
5022 pub busIndex: int32,
5023 pub sampleOffset: int32,
5024 pub ppqPosition: TQuarterNotes,
5025 pub flags: uint16,
5026 pub r#type: uint16,
5027 pub __field0: Event__type0,
5028 }
5029 unsafe impl Send for Event {}
5030 unsafe impl Sync for Event {}
5031 }
5032 pub use __Event_wrapper::*;
5033 pub mod Event_ {
5034 #[allow(unused_imports)]
5035 use super::*;
5036 pub type EventFlags = crate::support::DefaultEnumType;
5037 pub mod EventFlags_ {
5038 #[allow(unused_imports)]
5039 use super::*;
5040 pub const kIsLive: EventFlags = 1;
5041 pub const kUserReserved1: EventFlags = 16384;
5042 pub const kUserReserved2: EventFlags = 32768;
5043 }
5044 pub type EventTypes = crate::support::DefaultEnumType;
5045 pub mod EventTypes_ {
5046 #[allow(unused_imports)]
5047 use super::*;
5048 pub const kChordEvent: EventTypes = 6;
5049 pub const kDataEvent: EventTypes = 2;
5050 pub const kLegacyMIDICCOutEvent: EventTypes = 65535;
5051 pub const kNoteExpressionIntValueEvent: EventTypes = 8;
5052 pub const kNoteExpressionTextEvent: EventTypes = 5;
5053 pub const kNoteExpressionValueEvent: EventTypes = 4;
5054 pub const kNoteOffEvent: EventTypes = 1;
5055 pub const kNoteOnEvent: EventTypes = 0;
5056 pub const kPolyPressureEvent: EventTypes = 3;
5057 pub const kScaleEvent: EventTypes = 7;
5058 }
5059 }
5060 #[repr(C)]
5061 #[derive(Copy, Clone)]
5062 pub union Event__type0 {
5063 pub noteOn: NoteOnEvent,
5064 pub noteOff: NoteOffEvent,
5065 pub data: DataEvent,
5066 pub polyPressure: PolyPressureEvent,
5067 pub noteExpressionValue: NoteExpressionValueEvent,
5068 pub noteExpressionText: NoteExpressionTextEvent,
5069 pub noteExpressionIntValue: NoteExpressionIntValueEvent,
5070 pub chord: ChordEvent,
5071 pub scale: ScaleEvent,
5072 pub midiCCOut: LegacyMIDICCOutEvent,
5073 }
5074 unsafe impl Send for Event__type0 {}
5075 unsafe impl Sync for Event__type0 {}
5076 mod __FrameRate_wrapper {
5077 #[allow(unused_imports)]
5078 use super::*;
5079 #[allow(unused_imports)]
5080 use super::FrameRate_::*;
5081 #[repr(C)]
5082 #[derive(Copy, Clone)]
5083 pub struct FrameRate {
5084 pub framesPerSecond: uint32,
5085 pub flags: uint32,
5086 }
5087 unsafe impl Send for FrameRate {}
5088 unsafe impl Sync for FrameRate {}
5089 }
5090 pub use __FrameRate_wrapper::*;
5091 pub mod FrameRate_ {
5092 #[allow(unused_imports)]
5093 use super::*;
5094 pub type FrameRateFlags = crate::support::DefaultEnumType;
5095 pub mod FrameRateFlags_ {
5096 #[allow(unused_imports)]
5097 use super::*;
5098 pub const kDropRate: FrameRateFlags = 2;
5099 pub const kPullDownRate: FrameRateFlags = 1;
5100 }
5101 }
5102 mod __IAttributeList_wrapper {
5103 #[allow(unused_imports)]
5104 use super::*;
5105 #[allow(unused_imports)]
5106 use super::IAttributeList_::*;
5107 #[repr(C)]
5108 #[derive(Copy, Clone)]
5109 pub struct IAttributeList {
5110 pub vtbl: *const IAttributeListVtbl,
5111 }
5112 unsafe impl Send for IAttributeList {}
5113 unsafe impl Sync for IAttributeList {}
5114 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IAttributeList {}
5115 impl ::com_scrape_types::Unknown for IAttributeList {
5116 #[inline]
5117 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
5118 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
5119 }
5120 #[inline]
5121 unsafe fn add_ref(this: *mut Self) -> usize {
5122 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
5123 }
5124 #[inline]
5125 unsafe fn release(this: *mut Self) -> usize {
5126 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
5127 }
5128 }
5129 unsafe impl ::com_scrape_types::Interface for IAttributeList {
5130 type Vtbl = IAttributeListVtbl;
5131 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IAttributeList_iid);
5132 #[inline]
5133 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
5134 iid == &Self::IID || FUnknown::inherits(iid)
5135 }
5136 }
5137 #[repr(C)]
5138 #[derive(Copy, Clone)]
5139 pub struct IAttributeListVtbl {
5140 pub base: FUnknownVtbl,
5141 pub setInt: unsafe extern "system" fn(
5142 this: *mut IAttributeList,
5143 id: AttrID,
5144 value: int64,
5145 ) -> tresult,
5146 pub getInt: unsafe extern "system" fn(
5147 this: *mut IAttributeList,
5148 id: AttrID,
5149 value: *mut int64,
5150 ) -> tresult,
5151 pub setFloat: unsafe extern "system" fn(
5152 this: *mut IAttributeList,
5153 id: AttrID,
5154 value: f64,
5155 ) -> tresult,
5156 pub getFloat: unsafe extern "system" fn(
5157 this: *mut IAttributeList,
5158 id: AttrID,
5159 value: *mut f64,
5160 ) -> tresult,
5161 pub setString: unsafe extern "system" fn(
5162 this: *mut IAttributeList,
5163 id: AttrID,
5164 string: *const TChar,
5165 ) -> tresult,
5166 pub getString: unsafe extern "system" fn(
5167 this: *mut IAttributeList,
5168 id: AttrID,
5169 string: *mut TChar,
5170 sizeInBytes: uint32,
5171 ) -> tresult,
5172 pub setBinary: unsafe extern "system" fn(
5173 this: *mut IAttributeList,
5174 id: AttrID,
5175 data: *const ::std::ffi::c_void,
5176 sizeInBytes: uint32,
5177 ) -> tresult,
5178 pub getBinary: unsafe extern "system" fn(
5179 this: *mut IAttributeList,
5180 id: AttrID,
5181 data: *mut *const ::std::ffi::c_void,
5182 sizeInBytes: *mut uint32,
5183 ) -> tresult,
5184 }
5185 pub trait IAttributeListTrait {
5186 unsafe fn setInt(
5187 &self,
5188 id: AttrID,
5189 value: int64,
5190 ) -> tresult;
5191 unsafe fn getInt(
5192 &self,
5193 id: AttrID,
5194 value: *mut int64,
5195 ) -> tresult;
5196 unsafe fn setFloat(
5197 &self,
5198 id: AttrID,
5199 value: f64,
5200 ) -> tresult;
5201 unsafe fn getFloat(
5202 &self,
5203 id: AttrID,
5204 value: *mut f64,
5205 ) -> tresult;
5206 unsafe fn setString(
5207 &self,
5208 id: AttrID,
5209 string: *const TChar,
5210 ) -> tresult;
5211 unsafe fn getString(
5212 &self,
5213 id: AttrID,
5214 string: *mut TChar,
5215 sizeInBytes: uint32,
5216 ) -> tresult;
5217 unsafe fn setBinary(
5218 &self,
5219 id: AttrID,
5220 data: *const ::std::ffi::c_void,
5221 sizeInBytes: uint32,
5222 ) -> tresult;
5223 unsafe fn getBinary(
5224 &self,
5225 id: AttrID,
5226 data: *mut *const ::std::ffi::c_void,
5227 sizeInBytes: *mut uint32,
5228 ) -> tresult;
5229 }
5230 impl<P> IAttributeListTrait for P
5231 where
5232 P: ::com_scrape_types::SmartPtr,
5233 P::Target: ::com_scrape_types::Inherits<IAttributeList>,
5234 {
5235 #[inline]
5236 unsafe fn setInt(
5237 &self,
5238 id: AttrID,
5239 value: int64,
5240 ) -> tresult {
5241 let ptr = self.ptr() as *mut IAttributeList;
5242 ((*(*ptr).vtbl).setInt)(
5243 ptr,
5244 id,
5245 value,
5246 )
5247 }
5248 #[inline]
5249 unsafe fn getInt(
5250 &self,
5251 id: AttrID,
5252 value: *mut int64,
5253 ) -> tresult {
5254 let ptr = self.ptr() as *mut IAttributeList;
5255 ((*(*ptr).vtbl).getInt)(
5256 ptr,
5257 id,
5258 value,
5259 )
5260 }
5261 #[inline]
5262 unsafe fn setFloat(
5263 &self,
5264 id: AttrID,
5265 value: f64,
5266 ) -> tresult {
5267 let ptr = self.ptr() as *mut IAttributeList;
5268 ((*(*ptr).vtbl).setFloat)(
5269 ptr,
5270 id,
5271 value,
5272 )
5273 }
5274 #[inline]
5275 unsafe fn getFloat(
5276 &self,
5277 id: AttrID,
5278 value: *mut f64,
5279 ) -> tresult {
5280 let ptr = self.ptr() as *mut IAttributeList;
5281 ((*(*ptr).vtbl).getFloat)(
5282 ptr,
5283 id,
5284 value,
5285 )
5286 }
5287 #[inline]
5288 unsafe fn setString(
5289 &self,
5290 id: AttrID,
5291 string: *const TChar,
5292 ) -> tresult {
5293 let ptr = self.ptr() as *mut IAttributeList;
5294 ((*(*ptr).vtbl).setString)(
5295 ptr,
5296 id,
5297 string,
5298 )
5299 }
5300 #[inline]
5301 unsafe fn getString(
5302 &self,
5303 id: AttrID,
5304 string: *mut TChar,
5305 sizeInBytes: uint32,
5306 ) -> tresult {
5307 let ptr = self.ptr() as *mut IAttributeList;
5308 ((*(*ptr).vtbl).getString)(
5309 ptr,
5310 id,
5311 string,
5312 sizeInBytes,
5313 )
5314 }
5315 #[inline]
5316 unsafe fn setBinary(
5317 &self,
5318 id: AttrID,
5319 data: *const ::std::ffi::c_void,
5320 sizeInBytes: uint32,
5321 ) -> tresult {
5322 let ptr = self.ptr() as *mut IAttributeList;
5323 ((*(*ptr).vtbl).setBinary)(
5324 ptr,
5325 id,
5326 data,
5327 sizeInBytes,
5328 )
5329 }
5330 #[inline]
5331 unsafe fn getBinary(
5332 &self,
5333 id: AttrID,
5334 data: *mut *const ::std::ffi::c_void,
5335 sizeInBytes: *mut uint32,
5336 ) -> tresult {
5337 let ptr = self.ptr() as *mut IAttributeList;
5338 ((*(*ptr).vtbl).getBinary)(
5339 ptr,
5340 id,
5341 data,
5342 sizeInBytes,
5343 )
5344 }
5345 }
5346 impl IAttributeList {
5347 const fn make_vtbl<C, W, const OFFSET: isize>() -> IAttributeListVtbl
5348 where
5349 C: IAttributeListTrait + ::com_scrape_types::Class,
5350 W: ::com_scrape_types::Wrapper<C>,
5351 {
5352 unsafe extern "system" fn setInt<C, W, const OFFSET: isize>(
5353 this: *mut IAttributeList,
5354 id: AttrID,
5355 value: int64,
5356 ) -> tresult
5357 where
5358 C: IAttributeListTrait + ::com_scrape_types::Class,
5359 W: ::com_scrape_types::Wrapper<C>,
5360 {
5361 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
5362 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
5363 (*ptr).setInt(
5364 id,
5365 value,
5366 )
5367 }
5368 unsafe extern "system" fn getInt<C, W, const OFFSET: isize>(
5369 this: *mut IAttributeList,
5370 id: AttrID,
5371 value: *mut int64,
5372 ) -> tresult
5373 where
5374 C: IAttributeListTrait + ::com_scrape_types::Class,
5375 W: ::com_scrape_types::Wrapper<C>,
5376 {
5377 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
5378 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
5379 (*ptr).getInt(
5380 id,
5381 value,
5382 )
5383 }
5384 unsafe extern "system" fn setFloat<C, W, const OFFSET: isize>(
5385 this: *mut IAttributeList,
5386 id: AttrID,
5387 value: f64,
5388 ) -> tresult
5389 where
5390 C: IAttributeListTrait + ::com_scrape_types::Class,
5391 W: ::com_scrape_types::Wrapper<C>,
5392 {
5393 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
5394 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
5395 (*ptr).setFloat(
5396 id,
5397 value,
5398 )
5399 }
5400 unsafe extern "system" fn getFloat<C, W, const OFFSET: isize>(
5401 this: *mut IAttributeList,
5402 id: AttrID,
5403 value: *mut f64,
5404 ) -> tresult
5405 where
5406 C: IAttributeListTrait + ::com_scrape_types::Class,
5407 W: ::com_scrape_types::Wrapper<C>,
5408 {
5409 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
5410 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
5411 (*ptr).getFloat(
5412 id,
5413 value,
5414 )
5415 }
5416 unsafe extern "system" fn setString<C, W, const OFFSET: isize>(
5417 this: *mut IAttributeList,
5418 id: AttrID,
5419 string: *const TChar,
5420 ) -> tresult
5421 where
5422 C: IAttributeListTrait + ::com_scrape_types::Class,
5423 W: ::com_scrape_types::Wrapper<C>,
5424 {
5425 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
5426 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
5427 (*ptr).setString(
5428 id,
5429 string,
5430 )
5431 }
5432 unsafe extern "system" fn getString<C, W, const OFFSET: isize>(
5433 this: *mut IAttributeList,
5434 id: AttrID,
5435 string: *mut TChar,
5436 sizeInBytes: uint32,
5437 ) -> tresult
5438 where
5439 C: IAttributeListTrait + ::com_scrape_types::Class,
5440 W: ::com_scrape_types::Wrapper<C>,
5441 {
5442 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
5443 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
5444 (*ptr).getString(
5445 id,
5446 string,
5447 sizeInBytes,
5448 )
5449 }
5450 unsafe extern "system" fn setBinary<C, W, const OFFSET: isize>(
5451 this: *mut IAttributeList,
5452 id: AttrID,
5453 data: *const ::std::ffi::c_void,
5454 sizeInBytes: uint32,
5455 ) -> tresult
5456 where
5457 C: IAttributeListTrait + ::com_scrape_types::Class,
5458 W: ::com_scrape_types::Wrapper<C>,
5459 {
5460 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
5461 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
5462 (*ptr).setBinary(
5463 id,
5464 data,
5465 sizeInBytes,
5466 )
5467 }
5468 unsafe extern "system" fn getBinary<C, W, const OFFSET: isize>(
5469 this: *mut IAttributeList,
5470 id: AttrID,
5471 data: *mut *const ::std::ffi::c_void,
5472 sizeInBytes: *mut uint32,
5473 ) -> tresult
5474 where
5475 C: IAttributeListTrait + ::com_scrape_types::Class,
5476 W: ::com_scrape_types::Wrapper<C>,
5477 {
5478 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
5479 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
5480 (*ptr).getBinary(
5481 id,
5482 data,
5483 sizeInBytes,
5484 )
5485 }
5486 IAttributeListVtbl {
5487 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
5488 setInt: setInt::<C, W, OFFSET>,
5489 getInt: getInt::<C, W, OFFSET>,
5490 setFloat: setFloat::<C, W, OFFSET>,
5491 getFloat: getFloat::<C, W, OFFSET>,
5492 setString: setString::<C, W, OFFSET>,
5493 getString: getString::<C, W, OFFSET>,
5494 setBinary: setBinary::<C, W, OFFSET>,
5495 getBinary: getBinary::<C, W, OFFSET>,
5496 }
5497 }
5498 }
5499 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IAttributeList
5500 where
5501 C: IAttributeListTrait + ::com_scrape_types::Class,
5502 W: ::com_scrape_types::Wrapper<C>,
5503 {
5504 const OBJ: Self = IAttributeList {
5505 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
5506 };
5507 }
5508 }
5509 pub use __IAttributeList_wrapper::*;
5510 pub mod IAttributeList_ {
5511 #[allow(unused_imports)]
5512 use super::*;
5513 pub type AttrID = *const ::std::ffi::c_char;
5514 }
5515 #[repr(C)]
5516 #[derive(Copy, Clone)]
5517 pub struct IAudioPresentationLatency {
5518 pub vtbl: *const IAudioPresentationLatencyVtbl,
5519 }
5520 unsafe impl Send for IAudioPresentationLatency {}
5521 unsafe impl Sync for IAudioPresentationLatency {}
5522 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IAudioPresentationLatency {}
5523 impl ::com_scrape_types::Unknown for IAudioPresentationLatency {
5524 #[inline]
5525 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
5526 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
5527 }
5528 #[inline]
5529 unsafe fn add_ref(this: *mut Self) -> usize {
5530 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
5531 }
5532 #[inline]
5533 unsafe fn release(this: *mut Self) -> usize {
5534 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
5535 }
5536 }
5537 unsafe impl ::com_scrape_types::Interface for IAudioPresentationLatency {
5538 type Vtbl = IAudioPresentationLatencyVtbl;
5539 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IAudioPresentationLatency_iid);
5540 #[inline]
5541 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
5542 iid == &Self::IID || FUnknown::inherits(iid)
5543 }
5544 }
5545 #[repr(C)]
5546 #[derive(Copy, Clone)]
5547 pub struct IAudioPresentationLatencyVtbl {
5548 pub base: FUnknownVtbl,
5549 pub setAudioPresentationLatencySamples: unsafe extern "system" fn(
5550 this: *mut IAudioPresentationLatency,
5551 dir: BusDirection,
5552 busIndex: int32,
5553 latencyInSamples: uint32,
5554 ) -> tresult,
5555 }
5556 pub trait IAudioPresentationLatencyTrait {
5557 unsafe fn setAudioPresentationLatencySamples(
5558 &self,
5559 dir: BusDirection,
5560 busIndex: int32,
5561 latencyInSamples: uint32,
5562 ) -> tresult;
5563 }
5564 impl<P> IAudioPresentationLatencyTrait for P
5565 where
5566 P: ::com_scrape_types::SmartPtr,
5567 P::Target: ::com_scrape_types::Inherits<IAudioPresentationLatency>,
5568 {
5569 #[inline]
5570 unsafe fn setAudioPresentationLatencySamples(
5571 &self,
5572 dir: BusDirection,
5573 busIndex: int32,
5574 latencyInSamples: uint32,
5575 ) -> tresult {
5576 let ptr = self.ptr() as *mut IAudioPresentationLatency;
5577 ((*(*ptr).vtbl).setAudioPresentationLatencySamples)(
5578 ptr,
5579 dir,
5580 busIndex,
5581 latencyInSamples,
5582 )
5583 }
5584 }
5585 impl IAudioPresentationLatency {
5586 const fn make_vtbl<C, W, const OFFSET: isize>() -> IAudioPresentationLatencyVtbl
5587 where
5588 C: IAudioPresentationLatencyTrait + ::com_scrape_types::Class,
5589 W: ::com_scrape_types::Wrapper<C>,
5590 {
5591 unsafe extern "system" fn setAudioPresentationLatencySamples<C, W, const OFFSET: isize>(
5592 this: *mut IAudioPresentationLatency,
5593 dir: BusDirection,
5594 busIndex: int32,
5595 latencyInSamples: uint32,
5596 ) -> tresult
5597 where
5598 C: IAudioPresentationLatencyTrait + ::com_scrape_types::Class,
5599 W: ::com_scrape_types::Wrapper<C>,
5600 {
5601 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
5602 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
5603 (*ptr).setAudioPresentationLatencySamples(
5604 dir,
5605 busIndex,
5606 latencyInSamples,
5607 )
5608 }
5609 IAudioPresentationLatencyVtbl {
5610 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
5611 setAudioPresentationLatencySamples: setAudioPresentationLatencySamples::<C, W, OFFSET>,
5612 }
5613 }
5614 }
5615 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IAudioPresentationLatency
5616 where
5617 C: IAudioPresentationLatencyTrait + ::com_scrape_types::Class,
5618 W: ::com_scrape_types::Wrapper<C>,
5619 {
5620 const OBJ: Self = IAudioPresentationLatency {
5621 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
5622 };
5623 }
5624 #[repr(C)]
5625 #[derive(Copy, Clone)]
5626 pub struct IAudioProcessor {
5627 pub vtbl: *const IAudioProcessorVtbl,
5628 }
5629 unsafe impl Send for IAudioProcessor {}
5630 unsafe impl Sync for IAudioProcessor {}
5631 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IAudioProcessor {}
5632 impl ::com_scrape_types::Unknown for IAudioProcessor {
5633 #[inline]
5634 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
5635 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
5636 }
5637 #[inline]
5638 unsafe fn add_ref(this: *mut Self) -> usize {
5639 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
5640 }
5641 #[inline]
5642 unsafe fn release(this: *mut Self) -> usize {
5643 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
5644 }
5645 }
5646 unsafe impl ::com_scrape_types::Interface for IAudioProcessor {
5647 type Vtbl = IAudioProcessorVtbl;
5648 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IAudioProcessor_iid);
5649 #[inline]
5650 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
5651 iid == &Self::IID || FUnknown::inherits(iid)
5652 }
5653 }
5654 #[repr(C)]
5655 #[derive(Copy, Clone)]
5656 pub struct IAudioProcessorVtbl {
5657 pub base: FUnknownVtbl,
5658 pub setBusArrangements: unsafe extern "system" fn(
5659 this: *mut IAudioProcessor,
5660 inputs: *mut SpeakerArrangement,
5661 numIns: int32,
5662 outputs: *mut SpeakerArrangement,
5663 numOuts: int32,
5664 ) -> tresult,
5665 pub getBusArrangement: unsafe extern "system" fn(
5666 this: *mut IAudioProcessor,
5667 dir: BusDirection,
5668 index: int32,
5669 arr: *mut SpeakerArrangement,
5670 ) -> tresult,
5671 pub canProcessSampleSize: unsafe extern "system" fn(
5672 this: *mut IAudioProcessor,
5673 symbolicSampleSize: int32,
5674 ) -> tresult,
5675 pub getLatencySamples: unsafe extern "system" fn(
5676 this: *mut IAudioProcessor,
5677 ) -> uint32,
5678 pub setupProcessing: unsafe extern "system" fn(
5679 this: *mut IAudioProcessor,
5680 setup: *mut ProcessSetup,
5681 ) -> tresult,
5682 pub setProcessing: unsafe extern "system" fn(
5683 this: *mut IAudioProcessor,
5684 state: TBool,
5685 ) -> tresult,
5686 pub process: unsafe extern "system" fn(
5687 this: *mut IAudioProcessor,
5688 data: *mut ProcessData,
5689 ) -> tresult,
5690 pub getTailSamples: unsafe extern "system" fn(
5691 this: *mut IAudioProcessor,
5692 ) -> uint32,
5693 }
5694 pub trait IAudioProcessorTrait {
5695 unsafe fn setBusArrangements(
5696 &self,
5697 inputs: *mut SpeakerArrangement,
5698 numIns: int32,
5699 outputs: *mut SpeakerArrangement,
5700 numOuts: int32,
5701 ) -> tresult;
5702 unsafe fn getBusArrangement(
5703 &self,
5704 dir: BusDirection,
5705 index: int32,
5706 arr: *mut SpeakerArrangement,
5707 ) -> tresult;
5708 unsafe fn canProcessSampleSize(
5709 &self,
5710 symbolicSampleSize: int32,
5711 ) -> tresult;
5712 unsafe fn getLatencySamples(
5713 &self,
5714 ) -> uint32;
5715 unsafe fn setupProcessing(
5716 &self,
5717 setup: *mut ProcessSetup,
5718 ) -> tresult;
5719 unsafe fn setProcessing(
5720 &self,
5721 state: TBool,
5722 ) -> tresult;
5723 unsafe fn process(
5724 &self,
5725 data: *mut ProcessData,
5726 ) -> tresult;
5727 unsafe fn getTailSamples(
5728 &self,
5729 ) -> uint32;
5730 }
5731 impl<P> IAudioProcessorTrait for P
5732 where
5733 P: ::com_scrape_types::SmartPtr,
5734 P::Target: ::com_scrape_types::Inherits<IAudioProcessor>,
5735 {
5736 #[inline]
5737 unsafe fn setBusArrangements(
5738 &self,
5739 inputs: *mut SpeakerArrangement,
5740 numIns: int32,
5741 outputs: *mut SpeakerArrangement,
5742 numOuts: int32,
5743 ) -> tresult {
5744 let ptr = self.ptr() as *mut IAudioProcessor;
5745 ((*(*ptr).vtbl).setBusArrangements)(
5746 ptr,
5747 inputs,
5748 numIns,
5749 outputs,
5750 numOuts,
5751 )
5752 }
5753 #[inline]
5754 unsafe fn getBusArrangement(
5755 &self,
5756 dir: BusDirection,
5757 index: int32,
5758 arr: *mut SpeakerArrangement,
5759 ) -> tresult {
5760 let ptr = self.ptr() as *mut IAudioProcessor;
5761 ((*(*ptr).vtbl).getBusArrangement)(
5762 ptr,
5763 dir,
5764 index,
5765 arr,
5766 )
5767 }
5768 #[inline]
5769 unsafe fn canProcessSampleSize(
5770 &self,
5771 symbolicSampleSize: int32,
5772 ) -> tresult {
5773 let ptr = self.ptr() as *mut IAudioProcessor;
5774 ((*(*ptr).vtbl).canProcessSampleSize)(
5775 ptr,
5776 symbolicSampleSize,
5777 )
5778 }
5779 #[inline]
5780 unsafe fn getLatencySamples(
5781 &self,
5782 ) -> uint32 {
5783 let ptr = self.ptr() as *mut IAudioProcessor;
5784 ((*(*ptr).vtbl).getLatencySamples)(
5785 ptr,
5786 )
5787 }
5788 #[inline]
5789 unsafe fn setupProcessing(
5790 &self,
5791 setup: *mut ProcessSetup,
5792 ) -> tresult {
5793 let ptr = self.ptr() as *mut IAudioProcessor;
5794 ((*(*ptr).vtbl).setupProcessing)(
5795 ptr,
5796 setup,
5797 )
5798 }
5799 #[inline]
5800 unsafe fn setProcessing(
5801 &self,
5802 state: TBool,
5803 ) -> tresult {
5804 let ptr = self.ptr() as *mut IAudioProcessor;
5805 ((*(*ptr).vtbl).setProcessing)(
5806 ptr,
5807 state,
5808 )
5809 }
5810 #[inline]
5811 unsafe fn process(
5812 &self,
5813 data: *mut ProcessData,
5814 ) -> tresult {
5815 let ptr = self.ptr() as *mut IAudioProcessor;
5816 ((*(*ptr).vtbl).process)(
5817 ptr,
5818 data,
5819 )
5820 }
5821 #[inline]
5822 unsafe fn getTailSamples(
5823 &self,
5824 ) -> uint32 {
5825 let ptr = self.ptr() as *mut IAudioProcessor;
5826 ((*(*ptr).vtbl).getTailSamples)(
5827 ptr,
5828 )
5829 }
5830 }
5831 impl IAudioProcessor {
5832 const fn make_vtbl<C, W, const OFFSET: isize>() -> IAudioProcessorVtbl
5833 where
5834 C: IAudioProcessorTrait + ::com_scrape_types::Class,
5835 W: ::com_scrape_types::Wrapper<C>,
5836 {
5837 unsafe extern "system" fn setBusArrangements<C, W, const OFFSET: isize>(
5838 this: *mut IAudioProcessor,
5839 inputs: *mut SpeakerArrangement,
5840 numIns: int32,
5841 outputs: *mut SpeakerArrangement,
5842 numOuts: int32,
5843 ) -> tresult
5844 where
5845 C: IAudioProcessorTrait + ::com_scrape_types::Class,
5846 W: ::com_scrape_types::Wrapper<C>,
5847 {
5848 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
5849 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
5850 (*ptr).setBusArrangements(
5851 inputs,
5852 numIns,
5853 outputs,
5854 numOuts,
5855 )
5856 }
5857 unsafe extern "system" fn getBusArrangement<C, W, const OFFSET: isize>(
5858 this: *mut IAudioProcessor,
5859 dir: BusDirection,
5860 index: int32,
5861 arr: *mut SpeakerArrangement,
5862 ) -> tresult
5863 where
5864 C: IAudioProcessorTrait + ::com_scrape_types::Class,
5865 W: ::com_scrape_types::Wrapper<C>,
5866 {
5867 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
5868 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
5869 (*ptr).getBusArrangement(
5870 dir,
5871 index,
5872 arr,
5873 )
5874 }
5875 unsafe extern "system" fn canProcessSampleSize<C, W, const OFFSET: isize>(
5876 this: *mut IAudioProcessor,
5877 symbolicSampleSize: int32,
5878 ) -> tresult
5879 where
5880 C: IAudioProcessorTrait + ::com_scrape_types::Class,
5881 W: ::com_scrape_types::Wrapper<C>,
5882 {
5883 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
5884 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
5885 (*ptr).canProcessSampleSize(
5886 symbolicSampleSize,
5887 )
5888 }
5889 unsafe extern "system" fn getLatencySamples<C, W, const OFFSET: isize>(
5890 this: *mut IAudioProcessor,
5891 ) -> uint32
5892 where
5893 C: IAudioProcessorTrait + ::com_scrape_types::Class,
5894 W: ::com_scrape_types::Wrapper<C>,
5895 {
5896 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
5897 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
5898 (*ptr).getLatencySamples(
5899 )
5900 }
5901 unsafe extern "system" fn setupProcessing<C, W, const OFFSET: isize>(
5902 this: *mut IAudioProcessor,
5903 setup: *mut ProcessSetup,
5904 ) -> tresult
5905 where
5906 C: IAudioProcessorTrait + ::com_scrape_types::Class,
5907 W: ::com_scrape_types::Wrapper<C>,
5908 {
5909 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
5910 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
5911 (*ptr).setupProcessing(
5912 setup,
5913 )
5914 }
5915 unsafe extern "system" fn setProcessing<C, W, const OFFSET: isize>(
5916 this: *mut IAudioProcessor,
5917 state: TBool,
5918 ) -> tresult
5919 where
5920 C: IAudioProcessorTrait + ::com_scrape_types::Class,
5921 W: ::com_scrape_types::Wrapper<C>,
5922 {
5923 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
5924 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
5925 (*ptr).setProcessing(
5926 state,
5927 )
5928 }
5929 unsafe extern "system" fn process<C, W, const OFFSET: isize>(
5930 this: *mut IAudioProcessor,
5931 data: *mut ProcessData,
5932 ) -> tresult
5933 where
5934 C: IAudioProcessorTrait + ::com_scrape_types::Class,
5935 W: ::com_scrape_types::Wrapper<C>,
5936 {
5937 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
5938 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
5939 (*ptr).process(
5940 data,
5941 )
5942 }
5943 unsafe extern "system" fn getTailSamples<C, W, const OFFSET: isize>(
5944 this: *mut IAudioProcessor,
5945 ) -> uint32
5946 where
5947 C: IAudioProcessorTrait + ::com_scrape_types::Class,
5948 W: ::com_scrape_types::Wrapper<C>,
5949 {
5950 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
5951 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
5952 (*ptr).getTailSamples(
5953 )
5954 }
5955 IAudioProcessorVtbl {
5956 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
5957 setBusArrangements: setBusArrangements::<C, W, OFFSET>,
5958 getBusArrangement: getBusArrangement::<C, W, OFFSET>,
5959 canProcessSampleSize: canProcessSampleSize::<C, W, OFFSET>,
5960 getLatencySamples: getLatencySamples::<C, W, OFFSET>,
5961 setupProcessing: setupProcessing::<C, W, OFFSET>,
5962 setProcessing: setProcessing::<C, W, OFFSET>,
5963 process: process::<C, W, OFFSET>,
5964 getTailSamples: getTailSamples::<C, W, OFFSET>,
5965 }
5966 }
5967 }
5968 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IAudioProcessor
5969 where
5970 C: IAudioProcessorTrait + ::com_scrape_types::Class,
5971 W: ::com_scrape_types::Wrapper<C>,
5972 {
5973 const OBJ: Self = IAudioProcessor {
5974 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
5975 };
5976 }
5977 mod __IAutomationState_wrapper {
5978 #[allow(unused_imports)]
5979 use super::*;
5980 #[allow(unused_imports)]
5981 use super::IAutomationState_::*;
5982 #[repr(C)]
5983 #[derive(Copy, Clone)]
5984 pub struct IAutomationState {
5985 pub vtbl: *const IAutomationStateVtbl,
5986 }
5987 unsafe impl Send for IAutomationState {}
5988 unsafe impl Sync for IAutomationState {}
5989 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IAutomationState {}
5990 impl ::com_scrape_types::Unknown for IAutomationState {
5991 #[inline]
5992 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
5993 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
5994 }
5995 #[inline]
5996 unsafe fn add_ref(this: *mut Self) -> usize {
5997 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
5998 }
5999 #[inline]
6000 unsafe fn release(this: *mut Self) -> usize {
6001 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
6002 }
6003 }
6004 unsafe impl ::com_scrape_types::Interface for IAutomationState {
6005 type Vtbl = IAutomationStateVtbl;
6006 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IAutomationState_iid);
6007 #[inline]
6008 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
6009 iid == &Self::IID || FUnknown::inherits(iid)
6010 }
6011 }
6012 #[repr(C)]
6013 #[derive(Copy, Clone)]
6014 pub struct IAutomationStateVtbl {
6015 pub base: FUnknownVtbl,
6016 pub setAutomationState: unsafe extern "system" fn(
6017 this: *mut IAutomationState,
6018 state: int32,
6019 ) -> tresult,
6020 }
6021 pub trait IAutomationStateTrait {
6022 unsafe fn setAutomationState(
6023 &self,
6024 state: int32,
6025 ) -> tresult;
6026 }
6027 impl<P> IAutomationStateTrait for P
6028 where
6029 P: ::com_scrape_types::SmartPtr,
6030 P::Target: ::com_scrape_types::Inherits<IAutomationState>,
6031 {
6032 #[inline]
6033 unsafe fn setAutomationState(
6034 &self,
6035 state: int32,
6036 ) -> tresult {
6037 let ptr = self.ptr() as *mut IAutomationState;
6038 ((*(*ptr).vtbl).setAutomationState)(
6039 ptr,
6040 state,
6041 )
6042 }
6043 }
6044 impl IAutomationState {
6045 const fn make_vtbl<C, W, const OFFSET: isize>() -> IAutomationStateVtbl
6046 where
6047 C: IAutomationStateTrait + ::com_scrape_types::Class,
6048 W: ::com_scrape_types::Wrapper<C>,
6049 {
6050 unsafe extern "system" fn setAutomationState<C, W, const OFFSET: isize>(
6051 this: *mut IAutomationState,
6052 state: int32,
6053 ) -> tresult
6054 where
6055 C: IAutomationStateTrait + ::com_scrape_types::Class,
6056 W: ::com_scrape_types::Wrapper<C>,
6057 {
6058 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
6059 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
6060 (*ptr).setAutomationState(
6061 state,
6062 )
6063 }
6064 IAutomationStateVtbl {
6065 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
6066 setAutomationState: setAutomationState::<C, W, OFFSET>,
6067 }
6068 }
6069 }
6070 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IAutomationState
6071 where
6072 C: IAutomationStateTrait + ::com_scrape_types::Class,
6073 W: ::com_scrape_types::Wrapper<C>,
6074 {
6075 const OBJ: Self = IAutomationState {
6076 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
6077 };
6078 }
6079 }
6080 pub use __IAutomationState_wrapper::*;
6081 pub mod IAutomationState_ {
6082 #[allow(unused_imports)]
6083 use super::*;
6084 pub type AutomationStates = int32;
6085 pub mod AutomationStates_ {
6086 #[allow(unused_imports)]
6087 use super::*;
6088 pub const kNoAutomation: AutomationStates = 0;
6089 pub const kReadState: AutomationStates = 1;
6090 pub const kReadWriteState: AutomationStates = 3;
6091 pub const kWriteState: AutomationStates = 2;
6092 }
6093 }
6094 #[repr(C)]
6095 #[derive(Copy, Clone)]
6096 pub struct IComponent {
6097 pub vtbl: *const IComponentVtbl,
6098 }
6099 unsafe impl Send for IComponent {}
6100 unsafe impl Sync for IComponent {}
6101 unsafe impl ::com_scrape_types::Inherits<IPluginBase> for IComponent {}
6102 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IComponent {}
6103 impl ::com_scrape_types::Unknown for IComponent {
6104 #[inline]
6105 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
6106 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
6107 }
6108 #[inline]
6109 unsafe fn add_ref(this: *mut Self) -> usize {
6110 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
6111 }
6112 #[inline]
6113 unsafe fn release(this: *mut Self) -> usize {
6114 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
6115 }
6116 }
6117 unsafe impl ::com_scrape_types::Interface for IComponent {
6118 type Vtbl = IComponentVtbl;
6119 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IComponent_iid);
6120 #[inline]
6121 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
6122 iid == &Self::IID || IPluginBase::inherits(iid)
6123 }
6124 }
6125 #[repr(C)]
6126 #[derive(Copy, Clone)]
6127 pub struct IComponentVtbl {
6128 pub base: IPluginBaseVtbl,
6129 pub getControllerClassId: unsafe extern "system" fn(
6130 this: *mut IComponent,
6131 classId: *mut TUID,
6132 ) -> tresult,
6133 pub setIoMode: unsafe extern "system" fn(
6134 this: *mut IComponent,
6135 mode: IoMode,
6136 ) -> tresult,
6137 pub getBusCount: unsafe extern "system" fn(
6138 this: *mut IComponent,
6139 r#type: MediaType,
6140 dir: BusDirection,
6141 ) -> int32,
6142 pub getBusInfo: unsafe extern "system" fn(
6143 this: *mut IComponent,
6144 r#type: MediaType,
6145 dir: BusDirection,
6146 index: int32,
6147 bus: *mut BusInfo,
6148 ) -> tresult,
6149 pub getRoutingInfo: unsafe extern "system" fn(
6150 this: *mut IComponent,
6151 inInfo: *mut RoutingInfo,
6152 outInfo: *mut RoutingInfo,
6153 ) -> tresult,
6154 pub activateBus: unsafe extern "system" fn(
6155 this: *mut IComponent,
6156 r#type: MediaType,
6157 dir: BusDirection,
6158 index: int32,
6159 state: TBool,
6160 ) -> tresult,
6161 pub setActive: unsafe extern "system" fn(
6162 this: *mut IComponent,
6163 state: TBool,
6164 ) -> tresult,
6165 pub setState: unsafe extern "system" fn(
6166 this: *mut IComponent,
6167 state: *mut IBStream,
6168 ) -> tresult,
6169 pub getState: unsafe extern "system" fn(
6170 this: *mut IComponent,
6171 state: *mut IBStream,
6172 ) -> tresult,
6173 }
6174 pub trait IComponentTrait: IPluginBaseTrait {
6175 unsafe fn getControllerClassId(
6176 &self,
6177 classId: *mut TUID,
6178 ) -> tresult;
6179 unsafe fn setIoMode(
6180 &self,
6181 mode: IoMode,
6182 ) -> tresult;
6183 unsafe fn getBusCount(
6184 &self,
6185 r#type: MediaType,
6186 dir: BusDirection,
6187 ) -> int32;
6188 unsafe fn getBusInfo(
6189 &self,
6190 r#type: MediaType,
6191 dir: BusDirection,
6192 index: int32,
6193 bus: *mut BusInfo,
6194 ) -> tresult;
6195 unsafe fn getRoutingInfo(
6196 &self,
6197 inInfo: *mut RoutingInfo,
6198 outInfo: *mut RoutingInfo,
6199 ) -> tresult;
6200 unsafe fn activateBus(
6201 &self,
6202 r#type: MediaType,
6203 dir: BusDirection,
6204 index: int32,
6205 state: TBool,
6206 ) -> tresult;
6207 unsafe fn setActive(
6208 &self,
6209 state: TBool,
6210 ) -> tresult;
6211 unsafe fn setState(
6212 &self,
6213 state: *mut IBStream,
6214 ) -> tresult;
6215 unsafe fn getState(
6216 &self,
6217 state: *mut IBStream,
6218 ) -> tresult;
6219 }
6220 impl<P> IComponentTrait for P
6221 where
6222 P: ::com_scrape_types::SmartPtr,
6223 P::Target: ::com_scrape_types::Inherits<IComponent>,
6224 P::Target: ::com_scrape_types::Inherits<IPluginBase>,
6225 {
6226 #[inline]
6227 unsafe fn getControllerClassId(
6228 &self,
6229 classId: *mut TUID,
6230 ) -> tresult {
6231 let ptr = self.ptr() as *mut IComponent;
6232 ((*(*ptr).vtbl).getControllerClassId)(
6233 ptr,
6234 classId,
6235 )
6236 }
6237 #[inline]
6238 unsafe fn setIoMode(
6239 &self,
6240 mode: IoMode,
6241 ) -> tresult {
6242 let ptr = self.ptr() as *mut IComponent;
6243 ((*(*ptr).vtbl).setIoMode)(
6244 ptr,
6245 mode,
6246 )
6247 }
6248 #[inline]
6249 unsafe fn getBusCount(
6250 &self,
6251 r#type: MediaType,
6252 dir: BusDirection,
6253 ) -> int32 {
6254 let ptr = self.ptr() as *mut IComponent;
6255 ((*(*ptr).vtbl).getBusCount)(
6256 ptr,
6257 r#type,
6258 dir,
6259 )
6260 }
6261 #[inline]
6262 unsafe fn getBusInfo(
6263 &self,
6264 r#type: MediaType,
6265 dir: BusDirection,
6266 index: int32,
6267 bus: *mut BusInfo,
6268 ) -> tresult {
6269 let ptr = self.ptr() as *mut IComponent;
6270 ((*(*ptr).vtbl).getBusInfo)(
6271 ptr,
6272 r#type,
6273 dir,
6274 index,
6275 bus,
6276 )
6277 }
6278 #[inline]
6279 unsafe fn getRoutingInfo(
6280 &self,
6281 inInfo: *mut RoutingInfo,
6282 outInfo: *mut RoutingInfo,
6283 ) -> tresult {
6284 let ptr = self.ptr() as *mut IComponent;
6285 ((*(*ptr).vtbl).getRoutingInfo)(
6286 ptr,
6287 inInfo,
6288 outInfo,
6289 )
6290 }
6291 #[inline]
6292 unsafe fn activateBus(
6293 &self,
6294 r#type: MediaType,
6295 dir: BusDirection,
6296 index: int32,
6297 state: TBool,
6298 ) -> tresult {
6299 let ptr = self.ptr() as *mut IComponent;
6300 ((*(*ptr).vtbl).activateBus)(
6301 ptr,
6302 r#type,
6303 dir,
6304 index,
6305 state,
6306 )
6307 }
6308 #[inline]
6309 unsafe fn setActive(
6310 &self,
6311 state: TBool,
6312 ) -> tresult {
6313 let ptr = self.ptr() as *mut IComponent;
6314 ((*(*ptr).vtbl).setActive)(
6315 ptr,
6316 state,
6317 )
6318 }
6319 #[inline]
6320 unsafe fn setState(
6321 &self,
6322 state: *mut IBStream,
6323 ) -> tresult {
6324 let ptr = self.ptr() as *mut IComponent;
6325 ((*(*ptr).vtbl).setState)(
6326 ptr,
6327 state,
6328 )
6329 }
6330 #[inline]
6331 unsafe fn getState(
6332 &self,
6333 state: *mut IBStream,
6334 ) -> tresult {
6335 let ptr = self.ptr() as *mut IComponent;
6336 ((*(*ptr).vtbl).getState)(
6337 ptr,
6338 state,
6339 )
6340 }
6341 }
6342 impl IComponent {
6343 const fn make_vtbl<C, W, const OFFSET: isize>() -> IComponentVtbl
6344 where
6345 C: IComponentTrait + ::com_scrape_types::Class,
6346 W: ::com_scrape_types::Wrapper<C>,
6347 {
6348 unsafe extern "system" fn getControllerClassId<C, W, const OFFSET: isize>(
6349 this: *mut IComponent,
6350 classId: *mut TUID,
6351 ) -> tresult
6352 where
6353 C: IComponentTrait + ::com_scrape_types::Class,
6354 W: ::com_scrape_types::Wrapper<C>,
6355 {
6356 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
6357 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
6358 (*ptr).getControllerClassId(
6359 classId,
6360 )
6361 }
6362 unsafe extern "system" fn setIoMode<C, W, const OFFSET: isize>(
6363 this: *mut IComponent,
6364 mode: IoMode,
6365 ) -> tresult
6366 where
6367 C: IComponentTrait + ::com_scrape_types::Class,
6368 W: ::com_scrape_types::Wrapper<C>,
6369 {
6370 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
6371 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
6372 (*ptr).setIoMode(
6373 mode,
6374 )
6375 }
6376 unsafe extern "system" fn getBusCount<C, W, const OFFSET: isize>(
6377 this: *mut IComponent,
6378 r#type: MediaType,
6379 dir: BusDirection,
6380 ) -> int32
6381 where
6382 C: IComponentTrait + ::com_scrape_types::Class,
6383 W: ::com_scrape_types::Wrapper<C>,
6384 {
6385 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
6386 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
6387 (*ptr).getBusCount(
6388 r#type,
6389 dir,
6390 )
6391 }
6392 unsafe extern "system" fn getBusInfo<C, W, const OFFSET: isize>(
6393 this: *mut IComponent,
6394 r#type: MediaType,
6395 dir: BusDirection,
6396 index: int32,
6397 bus: *mut BusInfo,
6398 ) -> tresult
6399 where
6400 C: IComponentTrait + ::com_scrape_types::Class,
6401 W: ::com_scrape_types::Wrapper<C>,
6402 {
6403 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
6404 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
6405 (*ptr).getBusInfo(
6406 r#type,
6407 dir,
6408 index,
6409 bus,
6410 )
6411 }
6412 unsafe extern "system" fn getRoutingInfo<C, W, const OFFSET: isize>(
6413 this: *mut IComponent,
6414 inInfo: *mut RoutingInfo,
6415 outInfo: *mut RoutingInfo,
6416 ) -> tresult
6417 where
6418 C: IComponentTrait + ::com_scrape_types::Class,
6419 W: ::com_scrape_types::Wrapper<C>,
6420 {
6421 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
6422 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
6423 (*ptr).getRoutingInfo(
6424 inInfo,
6425 outInfo,
6426 )
6427 }
6428 unsafe extern "system" fn activateBus<C, W, const OFFSET: isize>(
6429 this: *mut IComponent,
6430 r#type: MediaType,
6431 dir: BusDirection,
6432 index: int32,
6433 state: TBool,
6434 ) -> tresult
6435 where
6436 C: IComponentTrait + ::com_scrape_types::Class,
6437 W: ::com_scrape_types::Wrapper<C>,
6438 {
6439 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
6440 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
6441 (*ptr).activateBus(
6442 r#type,
6443 dir,
6444 index,
6445 state,
6446 )
6447 }
6448 unsafe extern "system" fn setActive<C, W, const OFFSET: isize>(
6449 this: *mut IComponent,
6450 state: TBool,
6451 ) -> tresult
6452 where
6453 C: IComponentTrait + ::com_scrape_types::Class,
6454 W: ::com_scrape_types::Wrapper<C>,
6455 {
6456 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
6457 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
6458 (*ptr).setActive(
6459 state,
6460 )
6461 }
6462 unsafe extern "system" fn setState<C, W, const OFFSET: isize>(
6463 this: *mut IComponent,
6464 state: *mut IBStream,
6465 ) -> tresult
6466 where
6467 C: IComponentTrait + ::com_scrape_types::Class,
6468 W: ::com_scrape_types::Wrapper<C>,
6469 {
6470 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
6471 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
6472 (*ptr).setState(
6473 state,
6474 )
6475 }
6476 unsafe extern "system" fn getState<C, W, const OFFSET: isize>(
6477 this: *mut IComponent,
6478 state: *mut IBStream,
6479 ) -> tresult
6480 where
6481 C: IComponentTrait + ::com_scrape_types::Class,
6482 W: ::com_scrape_types::Wrapper<C>,
6483 {
6484 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
6485 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
6486 (*ptr).getState(
6487 state,
6488 )
6489 }
6490 IComponentVtbl {
6491 base: IPluginBase::make_vtbl::<C, W, OFFSET>(),
6492 getControllerClassId: getControllerClassId::<C, W, OFFSET>,
6493 setIoMode: setIoMode::<C, W, OFFSET>,
6494 getBusCount: getBusCount::<C, W, OFFSET>,
6495 getBusInfo: getBusInfo::<C, W, OFFSET>,
6496 getRoutingInfo: getRoutingInfo::<C, W, OFFSET>,
6497 activateBus: activateBus::<C, W, OFFSET>,
6498 setActive: setActive::<C, W, OFFSET>,
6499 setState: setState::<C, W, OFFSET>,
6500 getState: getState::<C, W, OFFSET>,
6501 }
6502 }
6503 }
6504 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IComponent
6505 where
6506 C: IComponentTrait + ::com_scrape_types::Class,
6507 W: ::com_scrape_types::Wrapper<C>,
6508 {
6509 const OBJ: Self = IComponent {
6510 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
6511 };
6512 }
6513 #[repr(C)]
6514 #[derive(Copy, Clone)]
6515 pub struct IComponentHandler {
6516 pub vtbl: *const IComponentHandlerVtbl,
6517 }
6518 unsafe impl Send for IComponentHandler {}
6519 unsafe impl Sync for IComponentHandler {}
6520 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IComponentHandler {}
6521 impl ::com_scrape_types::Unknown for IComponentHandler {
6522 #[inline]
6523 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
6524 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
6525 }
6526 #[inline]
6527 unsafe fn add_ref(this: *mut Self) -> usize {
6528 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
6529 }
6530 #[inline]
6531 unsafe fn release(this: *mut Self) -> usize {
6532 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
6533 }
6534 }
6535 unsafe impl ::com_scrape_types::Interface for IComponentHandler {
6536 type Vtbl = IComponentHandlerVtbl;
6537 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IComponentHandler_iid);
6538 #[inline]
6539 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
6540 iid == &Self::IID || FUnknown::inherits(iid)
6541 }
6542 }
6543 #[repr(C)]
6544 #[derive(Copy, Clone)]
6545 pub struct IComponentHandlerVtbl {
6546 pub base: FUnknownVtbl,
6547 pub beginEdit: unsafe extern "system" fn(
6548 this: *mut IComponentHandler,
6549 id: ParamID,
6550 ) -> tresult,
6551 pub performEdit: unsafe extern "system" fn(
6552 this: *mut IComponentHandler,
6553 id: ParamID,
6554 valueNormalized: ParamValue,
6555 ) -> tresult,
6556 pub endEdit: unsafe extern "system" fn(
6557 this: *mut IComponentHandler,
6558 id: ParamID,
6559 ) -> tresult,
6560 pub restartComponent: unsafe extern "system" fn(
6561 this: *mut IComponentHandler,
6562 flags: int32,
6563 ) -> tresult,
6564 }
6565 pub trait IComponentHandlerTrait {
6566 unsafe fn beginEdit(
6567 &self,
6568 id: ParamID,
6569 ) -> tresult;
6570 unsafe fn performEdit(
6571 &self,
6572 id: ParamID,
6573 valueNormalized: ParamValue,
6574 ) -> tresult;
6575 unsafe fn endEdit(
6576 &self,
6577 id: ParamID,
6578 ) -> tresult;
6579 unsafe fn restartComponent(
6580 &self,
6581 flags: int32,
6582 ) -> tresult;
6583 }
6584 impl<P> IComponentHandlerTrait for P
6585 where
6586 P: ::com_scrape_types::SmartPtr,
6587 P::Target: ::com_scrape_types::Inherits<IComponentHandler>,
6588 {
6589 #[inline]
6590 unsafe fn beginEdit(
6591 &self,
6592 id: ParamID,
6593 ) -> tresult {
6594 let ptr = self.ptr() as *mut IComponentHandler;
6595 ((*(*ptr).vtbl).beginEdit)(
6596 ptr,
6597 id,
6598 )
6599 }
6600 #[inline]
6601 unsafe fn performEdit(
6602 &self,
6603 id: ParamID,
6604 valueNormalized: ParamValue,
6605 ) -> tresult {
6606 let ptr = self.ptr() as *mut IComponentHandler;
6607 ((*(*ptr).vtbl).performEdit)(
6608 ptr,
6609 id,
6610 valueNormalized,
6611 )
6612 }
6613 #[inline]
6614 unsafe fn endEdit(
6615 &self,
6616 id: ParamID,
6617 ) -> tresult {
6618 let ptr = self.ptr() as *mut IComponentHandler;
6619 ((*(*ptr).vtbl).endEdit)(
6620 ptr,
6621 id,
6622 )
6623 }
6624 #[inline]
6625 unsafe fn restartComponent(
6626 &self,
6627 flags: int32,
6628 ) -> tresult {
6629 let ptr = self.ptr() as *mut IComponentHandler;
6630 ((*(*ptr).vtbl).restartComponent)(
6631 ptr,
6632 flags,
6633 )
6634 }
6635 }
6636 impl IComponentHandler {
6637 const fn make_vtbl<C, W, const OFFSET: isize>() -> IComponentHandlerVtbl
6638 where
6639 C: IComponentHandlerTrait + ::com_scrape_types::Class,
6640 W: ::com_scrape_types::Wrapper<C>,
6641 {
6642 unsafe extern "system" fn beginEdit<C, W, const OFFSET: isize>(
6643 this: *mut IComponentHandler,
6644 id: ParamID,
6645 ) -> tresult
6646 where
6647 C: IComponentHandlerTrait + ::com_scrape_types::Class,
6648 W: ::com_scrape_types::Wrapper<C>,
6649 {
6650 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
6651 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
6652 (*ptr).beginEdit(
6653 id,
6654 )
6655 }
6656 unsafe extern "system" fn performEdit<C, W, const OFFSET: isize>(
6657 this: *mut IComponentHandler,
6658 id: ParamID,
6659 valueNormalized: ParamValue,
6660 ) -> tresult
6661 where
6662 C: IComponentHandlerTrait + ::com_scrape_types::Class,
6663 W: ::com_scrape_types::Wrapper<C>,
6664 {
6665 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
6666 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
6667 (*ptr).performEdit(
6668 id,
6669 valueNormalized,
6670 )
6671 }
6672 unsafe extern "system" fn endEdit<C, W, const OFFSET: isize>(
6673 this: *mut IComponentHandler,
6674 id: ParamID,
6675 ) -> tresult
6676 where
6677 C: IComponentHandlerTrait + ::com_scrape_types::Class,
6678 W: ::com_scrape_types::Wrapper<C>,
6679 {
6680 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
6681 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
6682 (*ptr).endEdit(
6683 id,
6684 )
6685 }
6686 unsafe extern "system" fn restartComponent<C, W, const OFFSET: isize>(
6687 this: *mut IComponentHandler,
6688 flags: int32,
6689 ) -> tresult
6690 where
6691 C: IComponentHandlerTrait + ::com_scrape_types::Class,
6692 W: ::com_scrape_types::Wrapper<C>,
6693 {
6694 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
6695 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
6696 (*ptr).restartComponent(
6697 flags,
6698 )
6699 }
6700 IComponentHandlerVtbl {
6701 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
6702 beginEdit: beginEdit::<C, W, OFFSET>,
6703 performEdit: performEdit::<C, W, OFFSET>,
6704 endEdit: endEdit::<C, W, OFFSET>,
6705 restartComponent: restartComponent::<C, W, OFFSET>,
6706 }
6707 }
6708 }
6709 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IComponentHandler
6710 where
6711 C: IComponentHandlerTrait + ::com_scrape_types::Class,
6712 W: ::com_scrape_types::Wrapper<C>,
6713 {
6714 const OBJ: Self = IComponentHandler {
6715 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
6716 };
6717 }
6718 #[repr(C)]
6719 #[derive(Copy, Clone)]
6720 pub struct IComponentHandler2 {
6721 pub vtbl: *const IComponentHandler2Vtbl,
6722 }
6723 unsafe impl Send for IComponentHandler2 {}
6724 unsafe impl Sync for IComponentHandler2 {}
6725 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IComponentHandler2 {}
6726 impl ::com_scrape_types::Unknown for IComponentHandler2 {
6727 #[inline]
6728 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
6729 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
6730 }
6731 #[inline]
6732 unsafe fn add_ref(this: *mut Self) -> usize {
6733 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
6734 }
6735 #[inline]
6736 unsafe fn release(this: *mut Self) -> usize {
6737 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
6738 }
6739 }
6740 unsafe impl ::com_scrape_types::Interface for IComponentHandler2 {
6741 type Vtbl = IComponentHandler2Vtbl;
6742 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IComponentHandler2_iid);
6743 #[inline]
6744 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
6745 iid == &Self::IID || FUnknown::inherits(iid)
6746 }
6747 }
6748 #[repr(C)]
6749 #[derive(Copy, Clone)]
6750 pub struct IComponentHandler2Vtbl {
6751 pub base: FUnknownVtbl,
6752 pub setDirty: unsafe extern "system" fn(
6753 this: *mut IComponentHandler2,
6754 state: TBool,
6755 ) -> tresult,
6756 pub requestOpenEditor: unsafe extern "system" fn(
6757 this: *mut IComponentHandler2,
6758 name: FIDString,
6759 ) -> tresult,
6760 pub startGroupEdit: unsafe extern "system" fn(
6761 this: *mut IComponentHandler2,
6762 ) -> tresult,
6763 pub finishGroupEdit: unsafe extern "system" fn(
6764 this: *mut IComponentHandler2,
6765 ) -> tresult,
6766 }
6767 pub trait IComponentHandler2Trait {
6768 unsafe fn setDirty(
6769 &self,
6770 state: TBool,
6771 ) -> tresult;
6772 unsafe fn requestOpenEditor(
6773 &self,
6774 name: FIDString,
6775 ) -> tresult;
6776 unsafe fn startGroupEdit(
6777 &self,
6778 ) -> tresult;
6779 unsafe fn finishGroupEdit(
6780 &self,
6781 ) -> tresult;
6782 }
6783 impl<P> IComponentHandler2Trait for P
6784 where
6785 P: ::com_scrape_types::SmartPtr,
6786 P::Target: ::com_scrape_types::Inherits<IComponentHandler2>,
6787 {
6788 #[inline]
6789 unsafe fn setDirty(
6790 &self,
6791 state: TBool,
6792 ) -> tresult {
6793 let ptr = self.ptr() as *mut IComponentHandler2;
6794 ((*(*ptr).vtbl).setDirty)(
6795 ptr,
6796 state,
6797 )
6798 }
6799 #[inline]
6800 unsafe fn requestOpenEditor(
6801 &self,
6802 name: FIDString,
6803 ) -> tresult {
6804 let ptr = self.ptr() as *mut IComponentHandler2;
6805 ((*(*ptr).vtbl).requestOpenEditor)(
6806 ptr,
6807 name,
6808 )
6809 }
6810 #[inline]
6811 unsafe fn startGroupEdit(
6812 &self,
6813 ) -> tresult {
6814 let ptr = self.ptr() as *mut IComponentHandler2;
6815 ((*(*ptr).vtbl).startGroupEdit)(
6816 ptr,
6817 )
6818 }
6819 #[inline]
6820 unsafe fn finishGroupEdit(
6821 &self,
6822 ) -> tresult {
6823 let ptr = self.ptr() as *mut IComponentHandler2;
6824 ((*(*ptr).vtbl).finishGroupEdit)(
6825 ptr,
6826 )
6827 }
6828 }
6829 impl IComponentHandler2 {
6830 const fn make_vtbl<C, W, const OFFSET: isize>() -> IComponentHandler2Vtbl
6831 where
6832 C: IComponentHandler2Trait + ::com_scrape_types::Class,
6833 W: ::com_scrape_types::Wrapper<C>,
6834 {
6835 unsafe extern "system" fn setDirty<C, W, const OFFSET: isize>(
6836 this: *mut IComponentHandler2,
6837 state: TBool,
6838 ) -> tresult
6839 where
6840 C: IComponentHandler2Trait + ::com_scrape_types::Class,
6841 W: ::com_scrape_types::Wrapper<C>,
6842 {
6843 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
6844 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
6845 (*ptr).setDirty(
6846 state,
6847 )
6848 }
6849 unsafe extern "system" fn requestOpenEditor<C, W, const OFFSET: isize>(
6850 this: *mut IComponentHandler2,
6851 name: FIDString,
6852 ) -> tresult
6853 where
6854 C: IComponentHandler2Trait + ::com_scrape_types::Class,
6855 W: ::com_scrape_types::Wrapper<C>,
6856 {
6857 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
6858 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
6859 (*ptr).requestOpenEditor(
6860 name,
6861 )
6862 }
6863 unsafe extern "system" fn startGroupEdit<C, W, const OFFSET: isize>(
6864 this: *mut IComponentHandler2,
6865 ) -> tresult
6866 where
6867 C: IComponentHandler2Trait + ::com_scrape_types::Class,
6868 W: ::com_scrape_types::Wrapper<C>,
6869 {
6870 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
6871 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
6872 (*ptr).startGroupEdit(
6873 )
6874 }
6875 unsafe extern "system" fn finishGroupEdit<C, W, const OFFSET: isize>(
6876 this: *mut IComponentHandler2,
6877 ) -> tresult
6878 where
6879 C: IComponentHandler2Trait + ::com_scrape_types::Class,
6880 W: ::com_scrape_types::Wrapper<C>,
6881 {
6882 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
6883 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
6884 (*ptr).finishGroupEdit(
6885 )
6886 }
6887 IComponentHandler2Vtbl {
6888 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
6889 setDirty: setDirty::<C, W, OFFSET>,
6890 requestOpenEditor: requestOpenEditor::<C, W, OFFSET>,
6891 startGroupEdit: startGroupEdit::<C, W, OFFSET>,
6892 finishGroupEdit: finishGroupEdit::<C, W, OFFSET>,
6893 }
6894 }
6895 }
6896 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IComponentHandler2
6897 where
6898 C: IComponentHandler2Trait + ::com_scrape_types::Class,
6899 W: ::com_scrape_types::Wrapper<C>,
6900 {
6901 const OBJ: Self = IComponentHandler2 {
6902 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
6903 };
6904 }
6905 #[repr(C)]
6906 #[derive(Copy, Clone)]
6907 pub struct IComponentHandler3 {
6908 pub vtbl: *const IComponentHandler3Vtbl,
6909 }
6910 unsafe impl Send for IComponentHandler3 {}
6911 unsafe impl Sync for IComponentHandler3 {}
6912 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IComponentHandler3 {}
6913 impl ::com_scrape_types::Unknown for IComponentHandler3 {
6914 #[inline]
6915 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
6916 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
6917 }
6918 #[inline]
6919 unsafe fn add_ref(this: *mut Self) -> usize {
6920 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
6921 }
6922 #[inline]
6923 unsafe fn release(this: *mut Self) -> usize {
6924 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
6925 }
6926 }
6927 unsafe impl ::com_scrape_types::Interface for IComponentHandler3 {
6928 type Vtbl = IComponentHandler3Vtbl;
6929 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IComponentHandler3_iid);
6930 #[inline]
6931 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
6932 iid == &Self::IID || FUnknown::inherits(iid)
6933 }
6934 }
6935 #[repr(C)]
6936 #[derive(Copy, Clone)]
6937 pub struct IComponentHandler3Vtbl {
6938 pub base: FUnknownVtbl,
6939 pub createContextMenu: unsafe extern "system" fn(
6940 this: *mut IComponentHandler3,
6941 plugView: *mut IPlugView,
6942 paramID: *const ParamID,
6943 ) -> *mut IContextMenu,
6944 }
6945 pub trait IComponentHandler3Trait {
6946 unsafe fn createContextMenu(
6947 &self,
6948 plugView: *mut IPlugView,
6949 paramID: *const ParamID,
6950 ) -> *mut IContextMenu;
6951 }
6952 impl<P> IComponentHandler3Trait for P
6953 where
6954 P: ::com_scrape_types::SmartPtr,
6955 P::Target: ::com_scrape_types::Inherits<IComponentHandler3>,
6956 {
6957 #[inline]
6958 unsafe fn createContextMenu(
6959 &self,
6960 plugView: *mut IPlugView,
6961 paramID: *const ParamID,
6962 ) -> *mut IContextMenu {
6963 let ptr = self.ptr() as *mut IComponentHandler3;
6964 ((*(*ptr).vtbl).createContextMenu)(
6965 ptr,
6966 plugView,
6967 paramID,
6968 )
6969 }
6970 }
6971 impl IComponentHandler3 {
6972 const fn make_vtbl<C, W, const OFFSET: isize>() -> IComponentHandler3Vtbl
6973 where
6974 C: IComponentHandler3Trait + ::com_scrape_types::Class,
6975 W: ::com_scrape_types::Wrapper<C>,
6976 {
6977 unsafe extern "system" fn createContextMenu<C, W, const OFFSET: isize>(
6978 this: *mut IComponentHandler3,
6979 plugView: *mut IPlugView,
6980 paramID: *const ParamID,
6981 ) -> *mut IContextMenu
6982 where
6983 C: IComponentHandler3Trait + ::com_scrape_types::Class,
6984 W: ::com_scrape_types::Wrapper<C>,
6985 {
6986 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
6987 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
6988 (*ptr).createContextMenu(
6989 plugView,
6990 paramID,
6991 )
6992 }
6993 IComponentHandler3Vtbl {
6994 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
6995 createContextMenu: createContextMenu::<C, W, OFFSET>,
6996 }
6997 }
6998 }
6999 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IComponentHandler3
7000 where
7001 C: IComponentHandler3Trait + ::com_scrape_types::Class,
7002 W: ::com_scrape_types::Wrapper<C>,
7003 {
7004 const OBJ: Self = IComponentHandler3 {
7005 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
7006 };
7007 }
7008 #[repr(C)]
7009 #[derive(Copy, Clone)]
7010 pub struct IComponentHandlerBusActivation {
7011 pub vtbl: *const IComponentHandlerBusActivationVtbl,
7012 }
7013 unsafe impl Send for IComponentHandlerBusActivation {}
7014 unsafe impl Sync for IComponentHandlerBusActivation {}
7015 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IComponentHandlerBusActivation {}
7016 impl ::com_scrape_types::Unknown for IComponentHandlerBusActivation {
7017 #[inline]
7018 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
7019 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
7020 }
7021 #[inline]
7022 unsafe fn add_ref(this: *mut Self) -> usize {
7023 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
7024 }
7025 #[inline]
7026 unsafe fn release(this: *mut Self) -> usize {
7027 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
7028 }
7029 }
7030 unsafe impl ::com_scrape_types::Interface for IComponentHandlerBusActivation {
7031 type Vtbl = IComponentHandlerBusActivationVtbl;
7032 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IComponentHandlerBusActivation_iid);
7033 #[inline]
7034 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
7035 iid == &Self::IID || FUnknown::inherits(iid)
7036 }
7037 }
7038 #[repr(C)]
7039 #[derive(Copy, Clone)]
7040 pub struct IComponentHandlerBusActivationVtbl {
7041 pub base: FUnknownVtbl,
7042 pub requestBusActivation: unsafe extern "system" fn(
7043 this: *mut IComponentHandlerBusActivation,
7044 r#type: MediaType,
7045 dir: BusDirection,
7046 index: int32,
7047 state: TBool,
7048 ) -> tresult,
7049 }
7050 pub trait IComponentHandlerBusActivationTrait {
7051 unsafe fn requestBusActivation(
7052 &self,
7053 r#type: MediaType,
7054 dir: BusDirection,
7055 index: int32,
7056 state: TBool,
7057 ) -> tresult;
7058 }
7059 impl<P> IComponentHandlerBusActivationTrait for P
7060 where
7061 P: ::com_scrape_types::SmartPtr,
7062 P::Target: ::com_scrape_types::Inherits<IComponentHandlerBusActivation>,
7063 {
7064 #[inline]
7065 unsafe fn requestBusActivation(
7066 &self,
7067 r#type: MediaType,
7068 dir: BusDirection,
7069 index: int32,
7070 state: TBool,
7071 ) -> tresult {
7072 let ptr = self.ptr() as *mut IComponentHandlerBusActivation;
7073 ((*(*ptr).vtbl).requestBusActivation)(
7074 ptr,
7075 r#type,
7076 dir,
7077 index,
7078 state,
7079 )
7080 }
7081 }
7082 impl IComponentHandlerBusActivation {
7083 const fn make_vtbl<C, W, const OFFSET: isize>() -> IComponentHandlerBusActivationVtbl
7084 where
7085 C: IComponentHandlerBusActivationTrait + ::com_scrape_types::Class,
7086 W: ::com_scrape_types::Wrapper<C>,
7087 {
7088 unsafe extern "system" fn requestBusActivation<C, W, const OFFSET: isize>(
7089 this: *mut IComponentHandlerBusActivation,
7090 r#type: MediaType,
7091 dir: BusDirection,
7092 index: int32,
7093 state: TBool,
7094 ) -> tresult
7095 where
7096 C: IComponentHandlerBusActivationTrait + ::com_scrape_types::Class,
7097 W: ::com_scrape_types::Wrapper<C>,
7098 {
7099 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
7100 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
7101 (*ptr).requestBusActivation(
7102 r#type,
7103 dir,
7104 index,
7105 state,
7106 )
7107 }
7108 IComponentHandlerBusActivationVtbl {
7109 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
7110 requestBusActivation: requestBusActivation::<C, W, OFFSET>,
7111 }
7112 }
7113 }
7114 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IComponentHandlerBusActivation
7115 where
7116 C: IComponentHandlerBusActivationTrait + ::com_scrape_types::Class,
7117 W: ::com_scrape_types::Wrapper<C>,
7118 {
7119 const OBJ: Self = IComponentHandlerBusActivation {
7120 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
7121 };
7122 }
7123 #[repr(C)]
7124 #[derive(Copy, Clone)]
7125 pub struct IComponentHandlerSystemTime {
7126 pub vtbl: *const IComponentHandlerSystemTimeVtbl,
7127 }
7128 unsafe impl Send for IComponentHandlerSystemTime {}
7129 unsafe impl Sync for IComponentHandlerSystemTime {}
7130 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IComponentHandlerSystemTime {}
7131 impl ::com_scrape_types::Unknown for IComponentHandlerSystemTime {
7132 #[inline]
7133 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
7134 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
7135 }
7136 #[inline]
7137 unsafe fn add_ref(this: *mut Self) -> usize {
7138 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
7139 }
7140 #[inline]
7141 unsafe fn release(this: *mut Self) -> usize {
7142 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
7143 }
7144 }
7145 unsafe impl ::com_scrape_types::Interface for IComponentHandlerSystemTime {
7146 type Vtbl = IComponentHandlerSystemTimeVtbl;
7147 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IComponentHandlerSystemTime_iid);
7148 #[inline]
7149 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
7150 iid == &Self::IID || FUnknown::inherits(iid)
7151 }
7152 }
7153 #[repr(C)]
7154 #[derive(Copy, Clone)]
7155 pub struct IComponentHandlerSystemTimeVtbl {
7156 pub base: FUnknownVtbl,
7157 pub getSystemTime: unsafe extern "system" fn(
7158 this: *mut IComponentHandlerSystemTime,
7159 systemTime: *mut int64,
7160 ) -> tresult,
7161 }
7162 pub trait IComponentHandlerSystemTimeTrait {
7163 unsafe fn getSystemTime(
7164 &self,
7165 systemTime: *mut int64,
7166 ) -> tresult;
7167 }
7168 impl<P> IComponentHandlerSystemTimeTrait for P
7169 where
7170 P: ::com_scrape_types::SmartPtr,
7171 P::Target: ::com_scrape_types::Inherits<IComponentHandlerSystemTime>,
7172 {
7173 #[inline]
7174 unsafe fn getSystemTime(
7175 &self,
7176 systemTime: *mut int64,
7177 ) -> tresult {
7178 let ptr = self.ptr() as *mut IComponentHandlerSystemTime;
7179 ((*(*ptr).vtbl).getSystemTime)(
7180 ptr,
7181 systemTime,
7182 )
7183 }
7184 }
7185 impl IComponentHandlerSystemTime {
7186 const fn make_vtbl<C, W, const OFFSET: isize>() -> IComponentHandlerSystemTimeVtbl
7187 where
7188 C: IComponentHandlerSystemTimeTrait + ::com_scrape_types::Class,
7189 W: ::com_scrape_types::Wrapper<C>,
7190 {
7191 unsafe extern "system" fn getSystemTime<C, W, const OFFSET: isize>(
7192 this: *mut IComponentHandlerSystemTime,
7193 systemTime: *mut int64,
7194 ) -> tresult
7195 where
7196 C: IComponentHandlerSystemTimeTrait + ::com_scrape_types::Class,
7197 W: ::com_scrape_types::Wrapper<C>,
7198 {
7199 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
7200 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
7201 (*ptr).getSystemTime(
7202 systemTime,
7203 )
7204 }
7205 IComponentHandlerSystemTimeVtbl {
7206 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
7207 getSystemTime: getSystemTime::<C, W, OFFSET>,
7208 }
7209 }
7210 }
7211 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IComponentHandlerSystemTime
7212 where
7213 C: IComponentHandlerSystemTimeTrait + ::com_scrape_types::Class,
7214 W: ::com_scrape_types::Wrapper<C>,
7215 {
7216 const OBJ: Self = IComponentHandlerSystemTime {
7217 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
7218 };
7219 }
7220 #[repr(C)]
7221 #[derive(Copy, Clone)]
7222 pub struct IConnectionPoint {
7223 pub vtbl: *const IConnectionPointVtbl,
7224 }
7225 unsafe impl Send for IConnectionPoint {}
7226 unsafe impl Sync for IConnectionPoint {}
7227 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IConnectionPoint {}
7228 impl ::com_scrape_types::Unknown for IConnectionPoint {
7229 #[inline]
7230 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
7231 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
7232 }
7233 #[inline]
7234 unsafe fn add_ref(this: *mut Self) -> usize {
7235 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
7236 }
7237 #[inline]
7238 unsafe fn release(this: *mut Self) -> usize {
7239 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
7240 }
7241 }
7242 unsafe impl ::com_scrape_types::Interface for IConnectionPoint {
7243 type Vtbl = IConnectionPointVtbl;
7244 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IConnectionPoint_iid);
7245 #[inline]
7246 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
7247 iid == &Self::IID || FUnknown::inherits(iid)
7248 }
7249 }
7250 #[repr(C)]
7251 #[derive(Copy, Clone)]
7252 pub struct IConnectionPointVtbl {
7253 pub base: FUnknownVtbl,
7254 pub connect: unsafe extern "system" fn(
7255 this: *mut IConnectionPoint,
7256 other: *mut IConnectionPoint,
7257 ) -> tresult,
7258 pub disconnect: unsafe extern "system" fn(
7259 this: *mut IConnectionPoint,
7260 other: *mut IConnectionPoint,
7261 ) -> tresult,
7262 pub notify: unsafe extern "system" fn(
7263 this: *mut IConnectionPoint,
7264 message: *mut IMessage,
7265 ) -> tresult,
7266 }
7267 pub trait IConnectionPointTrait {
7268 unsafe fn connect(
7269 &self,
7270 other: *mut IConnectionPoint,
7271 ) -> tresult;
7272 unsafe fn disconnect(
7273 &self,
7274 other: *mut IConnectionPoint,
7275 ) -> tresult;
7276 unsafe fn notify(
7277 &self,
7278 message: *mut IMessage,
7279 ) -> tresult;
7280 }
7281 impl<P> IConnectionPointTrait for P
7282 where
7283 P: ::com_scrape_types::SmartPtr,
7284 P::Target: ::com_scrape_types::Inherits<IConnectionPoint>,
7285 {
7286 #[inline]
7287 unsafe fn connect(
7288 &self,
7289 other: *mut IConnectionPoint,
7290 ) -> tresult {
7291 let ptr = self.ptr() as *mut IConnectionPoint;
7292 ((*(*ptr).vtbl).connect)(
7293 ptr,
7294 other,
7295 )
7296 }
7297 #[inline]
7298 unsafe fn disconnect(
7299 &self,
7300 other: *mut IConnectionPoint,
7301 ) -> tresult {
7302 let ptr = self.ptr() as *mut IConnectionPoint;
7303 ((*(*ptr).vtbl).disconnect)(
7304 ptr,
7305 other,
7306 )
7307 }
7308 #[inline]
7309 unsafe fn notify(
7310 &self,
7311 message: *mut IMessage,
7312 ) -> tresult {
7313 let ptr = self.ptr() as *mut IConnectionPoint;
7314 ((*(*ptr).vtbl).notify)(
7315 ptr,
7316 message,
7317 )
7318 }
7319 }
7320 impl IConnectionPoint {
7321 const fn make_vtbl<C, W, const OFFSET: isize>() -> IConnectionPointVtbl
7322 where
7323 C: IConnectionPointTrait + ::com_scrape_types::Class,
7324 W: ::com_scrape_types::Wrapper<C>,
7325 {
7326 unsafe extern "system" fn connect<C, W, const OFFSET: isize>(
7327 this: *mut IConnectionPoint,
7328 other: *mut IConnectionPoint,
7329 ) -> tresult
7330 where
7331 C: IConnectionPointTrait + ::com_scrape_types::Class,
7332 W: ::com_scrape_types::Wrapper<C>,
7333 {
7334 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
7335 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
7336 (*ptr).connect(
7337 other,
7338 )
7339 }
7340 unsafe extern "system" fn disconnect<C, W, const OFFSET: isize>(
7341 this: *mut IConnectionPoint,
7342 other: *mut IConnectionPoint,
7343 ) -> tresult
7344 where
7345 C: IConnectionPointTrait + ::com_scrape_types::Class,
7346 W: ::com_scrape_types::Wrapper<C>,
7347 {
7348 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
7349 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
7350 (*ptr).disconnect(
7351 other,
7352 )
7353 }
7354 unsafe extern "system" fn notify<C, W, const OFFSET: isize>(
7355 this: *mut IConnectionPoint,
7356 message: *mut IMessage,
7357 ) -> tresult
7358 where
7359 C: IConnectionPointTrait + ::com_scrape_types::Class,
7360 W: ::com_scrape_types::Wrapper<C>,
7361 {
7362 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
7363 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
7364 (*ptr).notify(
7365 message,
7366 )
7367 }
7368 IConnectionPointVtbl {
7369 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
7370 connect: connect::<C, W, OFFSET>,
7371 disconnect: disconnect::<C, W, OFFSET>,
7372 notify: notify::<C, W, OFFSET>,
7373 }
7374 }
7375 }
7376 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IConnectionPoint
7377 where
7378 C: IConnectionPointTrait + ::com_scrape_types::Class,
7379 W: ::com_scrape_types::Wrapper<C>,
7380 {
7381 const OBJ: Self = IConnectionPoint {
7382 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
7383 };
7384 }
7385 mod __IContextMenu_wrapper {
7386 #[allow(unused_imports)]
7387 use super::*;
7388 #[allow(unused_imports)]
7389 use super::IContextMenu_::*;
7390 #[repr(C)]
7391 #[derive(Copy, Clone)]
7392 pub struct IContextMenu {
7393 pub vtbl: *const IContextMenuVtbl,
7394 }
7395 unsafe impl Send for IContextMenu {}
7396 unsafe impl Sync for IContextMenu {}
7397 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IContextMenu {}
7398 impl ::com_scrape_types::Unknown for IContextMenu {
7399 #[inline]
7400 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
7401 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
7402 }
7403 #[inline]
7404 unsafe fn add_ref(this: *mut Self) -> usize {
7405 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
7406 }
7407 #[inline]
7408 unsafe fn release(this: *mut Self) -> usize {
7409 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
7410 }
7411 }
7412 unsafe impl ::com_scrape_types::Interface for IContextMenu {
7413 type Vtbl = IContextMenuVtbl;
7414 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IContextMenu_iid);
7415 #[inline]
7416 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
7417 iid == &Self::IID || FUnknown::inherits(iid)
7418 }
7419 }
7420 #[repr(C)]
7421 #[derive(Copy, Clone)]
7422 pub struct IContextMenuVtbl {
7423 pub base: FUnknownVtbl,
7424 pub getItemCount: unsafe extern "system" fn(
7425 this: *mut IContextMenu,
7426 ) -> int32,
7427 pub getItem: unsafe extern "system" fn(
7428 this: *mut IContextMenu,
7429 index: int32,
7430 item: *mut Item,
7431 target: *mut *mut IContextMenuTarget,
7432 ) -> tresult,
7433 pub addItem: unsafe extern "system" fn(
7434 this: *mut IContextMenu,
7435 item: *const Item,
7436 target: *mut IContextMenuTarget,
7437 ) -> tresult,
7438 pub removeItem: unsafe extern "system" fn(
7439 this: *mut IContextMenu,
7440 item: *const Item,
7441 target: *mut IContextMenuTarget,
7442 ) -> tresult,
7443 pub popup: unsafe extern "system" fn(
7444 this: *mut IContextMenu,
7445 x: UCoord,
7446 y: UCoord,
7447 ) -> tresult,
7448 }
7449 pub trait IContextMenuTrait {
7450 unsafe fn getItemCount(
7451 &self,
7452 ) -> int32;
7453 unsafe fn getItem(
7454 &self,
7455 index: int32,
7456 item: *mut Item,
7457 target: *mut *mut IContextMenuTarget,
7458 ) -> tresult;
7459 unsafe fn addItem(
7460 &self,
7461 item: *const Item,
7462 target: *mut IContextMenuTarget,
7463 ) -> tresult;
7464 unsafe fn removeItem(
7465 &self,
7466 item: *const Item,
7467 target: *mut IContextMenuTarget,
7468 ) -> tresult;
7469 unsafe fn popup(
7470 &self,
7471 x: UCoord,
7472 y: UCoord,
7473 ) -> tresult;
7474 }
7475 impl<P> IContextMenuTrait for P
7476 where
7477 P: ::com_scrape_types::SmartPtr,
7478 P::Target: ::com_scrape_types::Inherits<IContextMenu>,
7479 {
7480 #[inline]
7481 unsafe fn getItemCount(
7482 &self,
7483 ) -> int32 {
7484 let ptr = self.ptr() as *mut IContextMenu;
7485 ((*(*ptr).vtbl).getItemCount)(
7486 ptr,
7487 )
7488 }
7489 #[inline]
7490 unsafe fn getItem(
7491 &self,
7492 index: int32,
7493 item: *mut Item,
7494 target: *mut *mut IContextMenuTarget,
7495 ) -> tresult {
7496 let ptr = self.ptr() as *mut IContextMenu;
7497 ((*(*ptr).vtbl).getItem)(
7498 ptr,
7499 index,
7500 item,
7501 target,
7502 )
7503 }
7504 #[inline]
7505 unsafe fn addItem(
7506 &self,
7507 item: *const Item,
7508 target: *mut IContextMenuTarget,
7509 ) -> tresult {
7510 let ptr = self.ptr() as *mut IContextMenu;
7511 ((*(*ptr).vtbl).addItem)(
7512 ptr,
7513 item,
7514 target,
7515 )
7516 }
7517 #[inline]
7518 unsafe fn removeItem(
7519 &self,
7520 item: *const Item,
7521 target: *mut IContextMenuTarget,
7522 ) -> tresult {
7523 let ptr = self.ptr() as *mut IContextMenu;
7524 ((*(*ptr).vtbl).removeItem)(
7525 ptr,
7526 item,
7527 target,
7528 )
7529 }
7530 #[inline]
7531 unsafe fn popup(
7532 &self,
7533 x: UCoord,
7534 y: UCoord,
7535 ) -> tresult {
7536 let ptr = self.ptr() as *mut IContextMenu;
7537 ((*(*ptr).vtbl).popup)(
7538 ptr,
7539 x,
7540 y,
7541 )
7542 }
7543 }
7544 impl IContextMenu {
7545 const fn make_vtbl<C, W, const OFFSET: isize>() -> IContextMenuVtbl
7546 where
7547 C: IContextMenuTrait + ::com_scrape_types::Class,
7548 W: ::com_scrape_types::Wrapper<C>,
7549 {
7550 unsafe extern "system" fn getItemCount<C, W, const OFFSET: isize>(
7551 this: *mut IContextMenu,
7552 ) -> int32
7553 where
7554 C: IContextMenuTrait + ::com_scrape_types::Class,
7555 W: ::com_scrape_types::Wrapper<C>,
7556 {
7557 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
7558 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
7559 (*ptr).getItemCount(
7560 )
7561 }
7562 unsafe extern "system" fn getItem<C, W, const OFFSET: isize>(
7563 this: *mut IContextMenu,
7564 index: int32,
7565 item: *mut Item,
7566 target: *mut *mut IContextMenuTarget,
7567 ) -> tresult
7568 where
7569 C: IContextMenuTrait + ::com_scrape_types::Class,
7570 W: ::com_scrape_types::Wrapper<C>,
7571 {
7572 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
7573 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
7574 (*ptr).getItem(
7575 index,
7576 item,
7577 target,
7578 )
7579 }
7580 unsafe extern "system" fn addItem<C, W, const OFFSET: isize>(
7581 this: *mut IContextMenu,
7582 item: *const Item,
7583 target: *mut IContextMenuTarget,
7584 ) -> tresult
7585 where
7586 C: IContextMenuTrait + ::com_scrape_types::Class,
7587 W: ::com_scrape_types::Wrapper<C>,
7588 {
7589 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
7590 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
7591 (*ptr).addItem(
7592 item,
7593 target,
7594 )
7595 }
7596 unsafe extern "system" fn removeItem<C, W, const OFFSET: isize>(
7597 this: *mut IContextMenu,
7598 item: *const Item,
7599 target: *mut IContextMenuTarget,
7600 ) -> tresult
7601 where
7602 C: IContextMenuTrait + ::com_scrape_types::Class,
7603 W: ::com_scrape_types::Wrapper<C>,
7604 {
7605 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
7606 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
7607 (*ptr).removeItem(
7608 item,
7609 target,
7610 )
7611 }
7612 unsafe extern "system" fn popup<C, W, const OFFSET: isize>(
7613 this: *mut IContextMenu,
7614 x: UCoord,
7615 y: UCoord,
7616 ) -> tresult
7617 where
7618 C: IContextMenuTrait + ::com_scrape_types::Class,
7619 W: ::com_scrape_types::Wrapper<C>,
7620 {
7621 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
7622 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
7623 (*ptr).popup(
7624 x,
7625 y,
7626 )
7627 }
7628 IContextMenuVtbl {
7629 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
7630 getItemCount: getItemCount::<C, W, OFFSET>,
7631 getItem: getItem::<C, W, OFFSET>,
7632 addItem: addItem::<C, W, OFFSET>,
7633 removeItem: removeItem::<C, W, OFFSET>,
7634 popup: popup::<C, W, OFFSET>,
7635 }
7636 }
7637 }
7638 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IContextMenu
7639 where
7640 C: IContextMenuTrait + ::com_scrape_types::Class,
7641 W: ::com_scrape_types::Wrapper<C>,
7642 {
7643 const OBJ: Self = IContextMenu {
7644 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
7645 };
7646 }
7647 }
7648 pub use __IContextMenu_wrapper::*;
7649 pub mod IContextMenu_ {
7650 #[allow(unused_imports)]
7651 use super::*;
7652 pub type Item = IContextMenuItem;
7653 }
7654 mod __IContextMenuItem_wrapper {
7655 #[allow(unused_imports)]
7656 use super::*;
7657 #[allow(unused_imports)]
7658 use super::IContextMenuItem_::*;
7659 #[repr(C)]
7660 #[derive(Copy, Clone)]
7661 pub struct IContextMenuItem {
7662 pub name: String128,
7663 pub tag: int32,
7664 pub flags: int32,
7665 }
7666 unsafe impl Send for IContextMenuItem {}
7667 unsafe impl Sync for IContextMenuItem {}
7668 }
7669 pub use __IContextMenuItem_wrapper::*;
7670 pub mod IContextMenuItem_ {
7671 #[allow(unused_imports)]
7672 use super::*;
7673 pub type Flags = crate::support::DefaultEnumType;
7674 pub mod Flags_ {
7675 #[allow(unused_imports)]
7676 use super::*;
7677 pub const kIsChecked: Flags = 4;
7678 pub const kIsDisabled: Flags = 2;
7679 pub const kIsGroupEnd: Flags = 17;
7680 pub const kIsGroupStart: Flags = 10;
7681 pub const kIsSeparator: Flags = 1;
7682 }
7683 }
7684 #[repr(C)]
7685 #[derive(Copy, Clone)]
7686 pub struct IContextMenuTarget {
7687 pub vtbl: *const IContextMenuTargetVtbl,
7688 }
7689 unsafe impl Send for IContextMenuTarget {}
7690 unsafe impl Sync for IContextMenuTarget {}
7691 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IContextMenuTarget {}
7692 impl ::com_scrape_types::Unknown for IContextMenuTarget {
7693 #[inline]
7694 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
7695 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
7696 }
7697 #[inline]
7698 unsafe fn add_ref(this: *mut Self) -> usize {
7699 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
7700 }
7701 #[inline]
7702 unsafe fn release(this: *mut Self) -> usize {
7703 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
7704 }
7705 }
7706 unsafe impl ::com_scrape_types::Interface for IContextMenuTarget {
7707 type Vtbl = IContextMenuTargetVtbl;
7708 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IContextMenuTarget_iid);
7709 #[inline]
7710 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
7711 iid == &Self::IID || FUnknown::inherits(iid)
7712 }
7713 }
7714 #[repr(C)]
7715 #[derive(Copy, Clone)]
7716 pub struct IContextMenuTargetVtbl {
7717 pub base: FUnknownVtbl,
7718 pub executeMenuItem: unsafe extern "system" fn(
7719 this: *mut IContextMenuTarget,
7720 tag: int32,
7721 ) -> tresult,
7722 }
7723 pub trait IContextMenuTargetTrait {
7724 unsafe fn executeMenuItem(
7725 &self,
7726 tag: int32,
7727 ) -> tresult;
7728 }
7729 impl<P> IContextMenuTargetTrait for P
7730 where
7731 P: ::com_scrape_types::SmartPtr,
7732 P::Target: ::com_scrape_types::Inherits<IContextMenuTarget>,
7733 {
7734 #[inline]
7735 unsafe fn executeMenuItem(
7736 &self,
7737 tag: int32,
7738 ) -> tresult {
7739 let ptr = self.ptr() as *mut IContextMenuTarget;
7740 ((*(*ptr).vtbl).executeMenuItem)(
7741 ptr,
7742 tag,
7743 )
7744 }
7745 }
7746 impl IContextMenuTarget {
7747 const fn make_vtbl<C, W, const OFFSET: isize>() -> IContextMenuTargetVtbl
7748 where
7749 C: IContextMenuTargetTrait + ::com_scrape_types::Class,
7750 W: ::com_scrape_types::Wrapper<C>,
7751 {
7752 unsafe extern "system" fn executeMenuItem<C, W, const OFFSET: isize>(
7753 this: *mut IContextMenuTarget,
7754 tag: int32,
7755 ) -> tresult
7756 where
7757 C: IContextMenuTargetTrait + ::com_scrape_types::Class,
7758 W: ::com_scrape_types::Wrapper<C>,
7759 {
7760 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
7761 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
7762 (*ptr).executeMenuItem(
7763 tag,
7764 )
7765 }
7766 IContextMenuTargetVtbl {
7767 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
7768 executeMenuItem: executeMenuItem::<C, W, OFFSET>,
7769 }
7770 }
7771 }
7772 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IContextMenuTarget
7773 where
7774 C: IContextMenuTargetTrait + ::com_scrape_types::Class,
7775 W: ::com_scrape_types::Wrapper<C>,
7776 {
7777 const OBJ: Self = IContextMenuTarget {
7778 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
7779 };
7780 }
7781 #[repr(C)]
7782 #[derive(Copy, Clone)]
7783 pub struct IDataExchangeHandler {
7784 pub vtbl: *const IDataExchangeHandlerVtbl,
7785 }
7786 unsafe impl Send for IDataExchangeHandler {}
7787 unsafe impl Sync for IDataExchangeHandler {}
7788 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IDataExchangeHandler {}
7789 impl ::com_scrape_types::Unknown for IDataExchangeHandler {
7790 #[inline]
7791 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
7792 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
7793 }
7794 #[inline]
7795 unsafe fn add_ref(this: *mut Self) -> usize {
7796 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
7797 }
7798 #[inline]
7799 unsafe fn release(this: *mut Self) -> usize {
7800 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
7801 }
7802 }
7803 unsafe impl ::com_scrape_types::Interface for IDataExchangeHandler {
7804 type Vtbl = IDataExchangeHandlerVtbl;
7805 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IDataExchangeHandler_iid);
7806 #[inline]
7807 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
7808 iid == &Self::IID || FUnknown::inherits(iid)
7809 }
7810 }
7811 #[repr(C)]
7812 #[derive(Copy, Clone)]
7813 pub struct IDataExchangeHandlerVtbl {
7814 pub base: FUnknownVtbl,
7815 pub openQueue: unsafe extern "system" fn(
7816 this: *mut IDataExchangeHandler,
7817 processor: *mut IAudioProcessor,
7818 blockSize: uint32,
7819 numBlocks: uint32,
7820 alignment: uint32,
7821 userContextID: DataExchangeUserContextID,
7822 outID: *mut DataExchangeQueueID,
7823 ) -> tresult,
7824 pub closeQueue: unsafe extern "system" fn(
7825 this: *mut IDataExchangeHandler,
7826 queueID: DataExchangeQueueID,
7827 ) -> tresult,
7828 pub lockBlock: unsafe extern "system" fn(
7829 this: *mut IDataExchangeHandler,
7830 queueId: DataExchangeQueueID,
7831 block: *mut DataExchangeBlock,
7832 ) -> tresult,
7833 pub freeBlock: unsafe extern "system" fn(
7834 this: *mut IDataExchangeHandler,
7835 queueId: DataExchangeQueueID,
7836 blockID: DataExchangeBlockID,
7837 sendToController: TBool,
7838 ) -> tresult,
7839 }
7840 pub trait IDataExchangeHandlerTrait {
7841 unsafe fn openQueue(
7842 &self,
7843 processor: *mut IAudioProcessor,
7844 blockSize: uint32,
7845 numBlocks: uint32,
7846 alignment: uint32,
7847 userContextID: DataExchangeUserContextID,
7848 outID: *mut DataExchangeQueueID,
7849 ) -> tresult;
7850 unsafe fn closeQueue(
7851 &self,
7852 queueID: DataExchangeQueueID,
7853 ) -> tresult;
7854 unsafe fn lockBlock(
7855 &self,
7856 queueId: DataExchangeQueueID,
7857 block: *mut DataExchangeBlock,
7858 ) -> tresult;
7859 unsafe fn freeBlock(
7860 &self,
7861 queueId: DataExchangeQueueID,
7862 blockID: DataExchangeBlockID,
7863 sendToController: TBool,
7864 ) -> tresult;
7865 }
7866 impl<P> IDataExchangeHandlerTrait for P
7867 where
7868 P: ::com_scrape_types::SmartPtr,
7869 P::Target: ::com_scrape_types::Inherits<IDataExchangeHandler>,
7870 {
7871 #[inline]
7872 unsafe fn openQueue(
7873 &self,
7874 processor: *mut IAudioProcessor,
7875 blockSize: uint32,
7876 numBlocks: uint32,
7877 alignment: uint32,
7878 userContextID: DataExchangeUserContextID,
7879 outID: *mut DataExchangeQueueID,
7880 ) -> tresult {
7881 let ptr = self.ptr() as *mut IDataExchangeHandler;
7882 ((*(*ptr).vtbl).openQueue)(
7883 ptr,
7884 processor,
7885 blockSize,
7886 numBlocks,
7887 alignment,
7888 userContextID,
7889 outID,
7890 )
7891 }
7892 #[inline]
7893 unsafe fn closeQueue(
7894 &self,
7895 queueID: DataExchangeQueueID,
7896 ) -> tresult {
7897 let ptr = self.ptr() as *mut IDataExchangeHandler;
7898 ((*(*ptr).vtbl).closeQueue)(
7899 ptr,
7900 queueID,
7901 )
7902 }
7903 #[inline]
7904 unsafe fn lockBlock(
7905 &self,
7906 queueId: DataExchangeQueueID,
7907 block: *mut DataExchangeBlock,
7908 ) -> tresult {
7909 let ptr = self.ptr() as *mut IDataExchangeHandler;
7910 ((*(*ptr).vtbl).lockBlock)(
7911 ptr,
7912 queueId,
7913 block,
7914 )
7915 }
7916 #[inline]
7917 unsafe fn freeBlock(
7918 &self,
7919 queueId: DataExchangeQueueID,
7920 blockID: DataExchangeBlockID,
7921 sendToController: TBool,
7922 ) -> tresult {
7923 let ptr = self.ptr() as *mut IDataExchangeHandler;
7924 ((*(*ptr).vtbl).freeBlock)(
7925 ptr,
7926 queueId,
7927 blockID,
7928 sendToController,
7929 )
7930 }
7931 }
7932 impl IDataExchangeHandler {
7933 const fn make_vtbl<C, W, const OFFSET: isize>() -> IDataExchangeHandlerVtbl
7934 where
7935 C: IDataExchangeHandlerTrait + ::com_scrape_types::Class,
7936 W: ::com_scrape_types::Wrapper<C>,
7937 {
7938 unsafe extern "system" fn openQueue<C, W, const OFFSET: isize>(
7939 this: *mut IDataExchangeHandler,
7940 processor: *mut IAudioProcessor,
7941 blockSize: uint32,
7942 numBlocks: uint32,
7943 alignment: uint32,
7944 userContextID: DataExchangeUserContextID,
7945 outID: *mut DataExchangeQueueID,
7946 ) -> tresult
7947 where
7948 C: IDataExchangeHandlerTrait + ::com_scrape_types::Class,
7949 W: ::com_scrape_types::Wrapper<C>,
7950 {
7951 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
7952 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
7953 (*ptr).openQueue(
7954 processor,
7955 blockSize,
7956 numBlocks,
7957 alignment,
7958 userContextID,
7959 outID,
7960 )
7961 }
7962 unsafe extern "system" fn closeQueue<C, W, const OFFSET: isize>(
7963 this: *mut IDataExchangeHandler,
7964 queueID: DataExchangeQueueID,
7965 ) -> tresult
7966 where
7967 C: IDataExchangeHandlerTrait + ::com_scrape_types::Class,
7968 W: ::com_scrape_types::Wrapper<C>,
7969 {
7970 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
7971 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
7972 (*ptr).closeQueue(
7973 queueID,
7974 )
7975 }
7976 unsafe extern "system" fn lockBlock<C, W, const OFFSET: isize>(
7977 this: *mut IDataExchangeHandler,
7978 queueId: DataExchangeQueueID,
7979 block: *mut DataExchangeBlock,
7980 ) -> tresult
7981 where
7982 C: IDataExchangeHandlerTrait + ::com_scrape_types::Class,
7983 W: ::com_scrape_types::Wrapper<C>,
7984 {
7985 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
7986 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
7987 (*ptr).lockBlock(
7988 queueId,
7989 block,
7990 )
7991 }
7992 unsafe extern "system" fn freeBlock<C, W, const OFFSET: isize>(
7993 this: *mut IDataExchangeHandler,
7994 queueId: DataExchangeQueueID,
7995 blockID: DataExchangeBlockID,
7996 sendToController: TBool,
7997 ) -> tresult
7998 where
7999 C: IDataExchangeHandlerTrait + ::com_scrape_types::Class,
8000 W: ::com_scrape_types::Wrapper<C>,
8001 {
8002 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
8003 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
8004 (*ptr).freeBlock(
8005 queueId,
8006 blockID,
8007 sendToController,
8008 )
8009 }
8010 IDataExchangeHandlerVtbl {
8011 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
8012 openQueue: openQueue::<C, W, OFFSET>,
8013 closeQueue: closeQueue::<C, W, OFFSET>,
8014 lockBlock: lockBlock::<C, W, OFFSET>,
8015 freeBlock: freeBlock::<C, W, OFFSET>,
8016 }
8017 }
8018 }
8019 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IDataExchangeHandler
8020 where
8021 C: IDataExchangeHandlerTrait + ::com_scrape_types::Class,
8022 W: ::com_scrape_types::Wrapper<C>,
8023 {
8024 const OBJ: Self = IDataExchangeHandler {
8025 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
8026 };
8027 }
8028 #[repr(C)]
8029 #[derive(Copy, Clone)]
8030 pub struct IDataExchangeReceiver {
8031 pub vtbl: *const IDataExchangeReceiverVtbl,
8032 }
8033 unsafe impl Send for IDataExchangeReceiver {}
8034 unsafe impl Sync for IDataExchangeReceiver {}
8035 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IDataExchangeReceiver {}
8036 impl ::com_scrape_types::Unknown for IDataExchangeReceiver {
8037 #[inline]
8038 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
8039 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
8040 }
8041 #[inline]
8042 unsafe fn add_ref(this: *mut Self) -> usize {
8043 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
8044 }
8045 #[inline]
8046 unsafe fn release(this: *mut Self) -> usize {
8047 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
8048 }
8049 }
8050 unsafe impl ::com_scrape_types::Interface for IDataExchangeReceiver {
8051 type Vtbl = IDataExchangeReceiverVtbl;
8052 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IDataExchangeReceiver_iid);
8053 #[inline]
8054 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
8055 iid == &Self::IID || FUnknown::inherits(iid)
8056 }
8057 }
8058 #[repr(C)]
8059 #[derive(Copy, Clone)]
8060 pub struct IDataExchangeReceiverVtbl {
8061 pub base: FUnknownVtbl,
8062 pub queueOpened: unsafe extern "system" fn(
8063 this: *mut IDataExchangeReceiver,
8064 userContextID: DataExchangeUserContextID,
8065 blockSize: uint32,
8066 dispatchOnBackgroundThread: *mut TBool,
8067 ),
8068 pub queueClosed: unsafe extern "system" fn(
8069 this: *mut IDataExchangeReceiver,
8070 userContextID: DataExchangeUserContextID,
8071 ),
8072 pub onDataExchangeBlocksReceived: unsafe extern "system" fn(
8073 this: *mut IDataExchangeReceiver,
8074 userContextID: DataExchangeUserContextID,
8075 numBlocks: uint32,
8076 blocks: *mut DataExchangeBlock,
8077 onBackgroundThread: TBool,
8078 ),
8079 }
8080 pub trait IDataExchangeReceiverTrait {
8081 unsafe fn queueOpened(
8082 &self,
8083 userContextID: DataExchangeUserContextID,
8084 blockSize: uint32,
8085 dispatchOnBackgroundThread: *mut TBool,
8086 );
8087 unsafe fn queueClosed(
8088 &self,
8089 userContextID: DataExchangeUserContextID,
8090 );
8091 unsafe fn onDataExchangeBlocksReceived(
8092 &self,
8093 userContextID: DataExchangeUserContextID,
8094 numBlocks: uint32,
8095 blocks: *mut DataExchangeBlock,
8096 onBackgroundThread: TBool,
8097 );
8098 }
8099 impl<P> IDataExchangeReceiverTrait for P
8100 where
8101 P: ::com_scrape_types::SmartPtr,
8102 P::Target: ::com_scrape_types::Inherits<IDataExchangeReceiver>,
8103 {
8104 #[inline]
8105 unsafe fn queueOpened(
8106 &self,
8107 userContextID: DataExchangeUserContextID,
8108 blockSize: uint32,
8109 dispatchOnBackgroundThread: *mut TBool,
8110 ) {
8111 let ptr = self.ptr() as *mut IDataExchangeReceiver;
8112 ((*(*ptr).vtbl).queueOpened)(
8113 ptr,
8114 userContextID,
8115 blockSize,
8116 dispatchOnBackgroundThread,
8117 )
8118 }
8119 #[inline]
8120 unsafe fn queueClosed(
8121 &self,
8122 userContextID: DataExchangeUserContextID,
8123 ) {
8124 let ptr = self.ptr() as *mut IDataExchangeReceiver;
8125 ((*(*ptr).vtbl).queueClosed)(
8126 ptr,
8127 userContextID,
8128 )
8129 }
8130 #[inline]
8131 unsafe fn onDataExchangeBlocksReceived(
8132 &self,
8133 userContextID: DataExchangeUserContextID,
8134 numBlocks: uint32,
8135 blocks: *mut DataExchangeBlock,
8136 onBackgroundThread: TBool,
8137 ) {
8138 let ptr = self.ptr() as *mut IDataExchangeReceiver;
8139 ((*(*ptr).vtbl).onDataExchangeBlocksReceived)(
8140 ptr,
8141 userContextID,
8142 numBlocks,
8143 blocks,
8144 onBackgroundThread,
8145 )
8146 }
8147 }
8148 impl IDataExchangeReceiver {
8149 const fn make_vtbl<C, W, const OFFSET: isize>() -> IDataExchangeReceiverVtbl
8150 where
8151 C: IDataExchangeReceiverTrait + ::com_scrape_types::Class,
8152 W: ::com_scrape_types::Wrapper<C>,
8153 {
8154 unsafe extern "system" fn queueOpened<C, W, const OFFSET: isize>(
8155 this: *mut IDataExchangeReceiver,
8156 userContextID: DataExchangeUserContextID,
8157 blockSize: uint32,
8158 dispatchOnBackgroundThread: *mut TBool,
8159 )
8160 where
8161 C: IDataExchangeReceiverTrait + ::com_scrape_types::Class,
8162 W: ::com_scrape_types::Wrapper<C>,
8163 {
8164 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
8165 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
8166 (*ptr).queueOpened(
8167 userContextID,
8168 blockSize,
8169 dispatchOnBackgroundThread,
8170 )
8171 }
8172 unsafe extern "system" fn queueClosed<C, W, const OFFSET: isize>(
8173 this: *mut IDataExchangeReceiver,
8174 userContextID: DataExchangeUserContextID,
8175 )
8176 where
8177 C: IDataExchangeReceiverTrait + ::com_scrape_types::Class,
8178 W: ::com_scrape_types::Wrapper<C>,
8179 {
8180 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
8181 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
8182 (*ptr).queueClosed(
8183 userContextID,
8184 )
8185 }
8186 unsafe extern "system" fn onDataExchangeBlocksReceived<C, W, const OFFSET: isize>(
8187 this: *mut IDataExchangeReceiver,
8188 userContextID: DataExchangeUserContextID,
8189 numBlocks: uint32,
8190 blocks: *mut DataExchangeBlock,
8191 onBackgroundThread: TBool,
8192 )
8193 where
8194 C: IDataExchangeReceiverTrait + ::com_scrape_types::Class,
8195 W: ::com_scrape_types::Wrapper<C>,
8196 {
8197 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
8198 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
8199 (*ptr).onDataExchangeBlocksReceived(
8200 userContextID,
8201 numBlocks,
8202 blocks,
8203 onBackgroundThread,
8204 )
8205 }
8206 IDataExchangeReceiverVtbl {
8207 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
8208 queueOpened: queueOpened::<C, W, OFFSET>,
8209 queueClosed: queueClosed::<C, W, OFFSET>,
8210 onDataExchangeBlocksReceived: onDataExchangeBlocksReceived::<C, W, OFFSET>,
8211 }
8212 }
8213 }
8214 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IDataExchangeReceiver
8215 where
8216 C: IDataExchangeReceiverTrait + ::com_scrape_types::Class,
8217 W: ::com_scrape_types::Wrapper<C>,
8218 {
8219 const OBJ: Self = IDataExchangeReceiver {
8220 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
8221 };
8222 }
8223 #[repr(C)]
8224 #[derive(Copy, Clone)]
8225 pub struct IEditController {
8226 pub vtbl: *const IEditControllerVtbl,
8227 }
8228 unsafe impl Send for IEditController {}
8229 unsafe impl Sync for IEditController {}
8230 unsafe impl ::com_scrape_types::Inherits<IPluginBase> for IEditController {}
8231 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IEditController {}
8232 impl ::com_scrape_types::Unknown for IEditController {
8233 #[inline]
8234 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
8235 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
8236 }
8237 #[inline]
8238 unsafe fn add_ref(this: *mut Self) -> usize {
8239 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
8240 }
8241 #[inline]
8242 unsafe fn release(this: *mut Self) -> usize {
8243 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
8244 }
8245 }
8246 unsafe impl ::com_scrape_types::Interface for IEditController {
8247 type Vtbl = IEditControllerVtbl;
8248 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IEditController_iid);
8249 #[inline]
8250 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
8251 iid == &Self::IID || IPluginBase::inherits(iid)
8252 }
8253 }
8254 #[repr(C)]
8255 #[derive(Copy, Clone)]
8256 pub struct IEditControllerVtbl {
8257 pub base: IPluginBaseVtbl,
8258 pub setComponentState: unsafe extern "system" fn(
8259 this: *mut IEditController,
8260 state: *mut IBStream,
8261 ) -> tresult,
8262 pub setState: unsafe extern "system" fn(
8263 this: *mut IEditController,
8264 state: *mut IBStream,
8265 ) -> tresult,
8266 pub getState: unsafe extern "system" fn(
8267 this: *mut IEditController,
8268 state: *mut IBStream,
8269 ) -> tresult,
8270 pub getParameterCount: unsafe extern "system" fn(
8271 this: *mut IEditController,
8272 ) -> int32,
8273 pub getParameterInfo: unsafe extern "system" fn(
8274 this: *mut IEditController,
8275 paramIndex: int32,
8276 info: *mut ParameterInfo,
8277 ) -> tresult,
8278 pub getParamStringByValue: unsafe extern "system" fn(
8279 this: *mut IEditController,
8280 id: ParamID,
8281 valueNormalized: ParamValue,
8282 string: *mut String128,
8283 ) -> tresult,
8284 pub getParamValueByString: unsafe extern "system" fn(
8285 this: *mut IEditController,
8286 id: ParamID,
8287 string: *mut TChar,
8288 valueNormalized: *mut ParamValue,
8289 ) -> tresult,
8290 pub normalizedParamToPlain: unsafe extern "system" fn(
8291 this: *mut IEditController,
8292 id: ParamID,
8293 valueNormalized: ParamValue,
8294 ) -> ParamValue,
8295 pub plainParamToNormalized: unsafe extern "system" fn(
8296 this: *mut IEditController,
8297 id: ParamID,
8298 plainValue: ParamValue,
8299 ) -> ParamValue,
8300 pub getParamNormalized: unsafe extern "system" fn(
8301 this: *mut IEditController,
8302 id: ParamID,
8303 ) -> ParamValue,
8304 pub setParamNormalized: unsafe extern "system" fn(
8305 this: *mut IEditController,
8306 id: ParamID,
8307 value: ParamValue,
8308 ) -> tresult,
8309 pub setComponentHandler: unsafe extern "system" fn(
8310 this: *mut IEditController,
8311 handler: *mut IComponentHandler,
8312 ) -> tresult,
8313 pub createView: unsafe extern "system" fn(
8314 this: *mut IEditController,
8315 name: FIDString,
8316 ) -> *mut IPlugView,
8317 }
8318 pub trait IEditControllerTrait: IPluginBaseTrait {
8319 unsafe fn setComponentState(
8320 &self,
8321 state: *mut IBStream,
8322 ) -> tresult;
8323 unsafe fn setState(
8324 &self,
8325 state: *mut IBStream,
8326 ) -> tresult;
8327 unsafe fn getState(
8328 &self,
8329 state: *mut IBStream,
8330 ) -> tresult;
8331 unsafe fn getParameterCount(
8332 &self,
8333 ) -> int32;
8334 unsafe fn getParameterInfo(
8335 &self,
8336 paramIndex: int32,
8337 info: *mut ParameterInfo,
8338 ) -> tresult;
8339 unsafe fn getParamStringByValue(
8340 &self,
8341 id: ParamID,
8342 valueNormalized: ParamValue,
8343 string: *mut String128,
8344 ) -> tresult;
8345 unsafe fn getParamValueByString(
8346 &self,
8347 id: ParamID,
8348 string: *mut TChar,
8349 valueNormalized: *mut ParamValue,
8350 ) -> tresult;
8351 unsafe fn normalizedParamToPlain(
8352 &self,
8353 id: ParamID,
8354 valueNormalized: ParamValue,
8355 ) -> ParamValue;
8356 unsafe fn plainParamToNormalized(
8357 &self,
8358 id: ParamID,
8359 plainValue: ParamValue,
8360 ) -> ParamValue;
8361 unsafe fn getParamNormalized(
8362 &self,
8363 id: ParamID,
8364 ) -> ParamValue;
8365 unsafe fn setParamNormalized(
8366 &self,
8367 id: ParamID,
8368 value: ParamValue,
8369 ) -> tresult;
8370 unsafe fn setComponentHandler(
8371 &self,
8372 handler: *mut IComponentHandler,
8373 ) -> tresult;
8374 unsafe fn createView(
8375 &self,
8376 name: FIDString,
8377 ) -> *mut IPlugView;
8378 }
8379 impl<P> IEditControllerTrait for P
8380 where
8381 P: ::com_scrape_types::SmartPtr,
8382 P::Target: ::com_scrape_types::Inherits<IEditController>,
8383 P::Target: ::com_scrape_types::Inherits<IPluginBase>,
8384 {
8385 #[inline]
8386 unsafe fn setComponentState(
8387 &self,
8388 state: *mut IBStream,
8389 ) -> tresult {
8390 let ptr = self.ptr() as *mut IEditController;
8391 ((*(*ptr).vtbl).setComponentState)(
8392 ptr,
8393 state,
8394 )
8395 }
8396 #[inline]
8397 unsafe fn setState(
8398 &self,
8399 state: *mut IBStream,
8400 ) -> tresult {
8401 let ptr = self.ptr() as *mut IEditController;
8402 ((*(*ptr).vtbl).setState)(
8403 ptr,
8404 state,
8405 )
8406 }
8407 #[inline]
8408 unsafe fn getState(
8409 &self,
8410 state: *mut IBStream,
8411 ) -> tresult {
8412 let ptr = self.ptr() as *mut IEditController;
8413 ((*(*ptr).vtbl).getState)(
8414 ptr,
8415 state,
8416 )
8417 }
8418 #[inline]
8419 unsafe fn getParameterCount(
8420 &self,
8421 ) -> int32 {
8422 let ptr = self.ptr() as *mut IEditController;
8423 ((*(*ptr).vtbl).getParameterCount)(
8424 ptr,
8425 )
8426 }
8427 #[inline]
8428 unsafe fn getParameterInfo(
8429 &self,
8430 paramIndex: int32,
8431 info: *mut ParameterInfo,
8432 ) -> tresult {
8433 let ptr = self.ptr() as *mut IEditController;
8434 ((*(*ptr).vtbl).getParameterInfo)(
8435 ptr,
8436 paramIndex,
8437 info,
8438 )
8439 }
8440 #[inline]
8441 unsafe fn getParamStringByValue(
8442 &self,
8443 id: ParamID,
8444 valueNormalized: ParamValue,
8445 string: *mut String128,
8446 ) -> tresult {
8447 let ptr = self.ptr() as *mut IEditController;
8448 ((*(*ptr).vtbl).getParamStringByValue)(
8449 ptr,
8450 id,
8451 valueNormalized,
8452 string,
8453 )
8454 }
8455 #[inline]
8456 unsafe fn getParamValueByString(
8457 &self,
8458 id: ParamID,
8459 string: *mut TChar,
8460 valueNormalized: *mut ParamValue,
8461 ) -> tresult {
8462 let ptr = self.ptr() as *mut IEditController;
8463 ((*(*ptr).vtbl).getParamValueByString)(
8464 ptr,
8465 id,
8466 string,
8467 valueNormalized,
8468 )
8469 }
8470 #[inline]
8471 unsafe fn normalizedParamToPlain(
8472 &self,
8473 id: ParamID,
8474 valueNormalized: ParamValue,
8475 ) -> ParamValue {
8476 let ptr = self.ptr() as *mut IEditController;
8477 ((*(*ptr).vtbl).normalizedParamToPlain)(
8478 ptr,
8479 id,
8480 valueNormalized,
8481 )
8482 }
8483 #[inline]
8484 unsafe fn plainParamToNormalized(
8485 &self,
8486 id: ParamID,
8487 plainValue: ParamValue,
8488 ) -> ParamValue {
8489 let ptr = self.ptr() as *mut IEditController;
8490 ((*(*ptr).vtbl).plainParamToNormalized)(
8491 ptr,
8492 id,
8493 plainValue,
8494 )
8495 }
8496 #[inline]
8497 unsafe fn getParamNormalized(
8498 &self,
8499 id: ParamID,
8500 ) -> ParamValue {
8501 let ptr = self.ptr() as *mut IEditController;
8502 ((*(*ptr).vtbl).getParamNormalized)(
8503 ptr,
8504 id,
8505 )
8506 }
8507 #[inline]
8508 unsafe fn setParamNormalized(
8509 &self,
8510 id: ParamID,
8511 value: ParamValue,
8512 ) -> tresult {
8513 let ptr = self.ptr() as *mut IEditController;
8514 ((*(*ptr).vtbl).setParamNormalized)(
8515 ptr,
8516 id,
8517 value,
8518 )
8519 }
8520 #[inline]
8521 unsafe fn setComponentHandler(
8522 &self,
8523 handler: *mut IComponentHandler,
8524 ) -> tresult {
8525 let ptr = self.ptr() as *mut IEditController;
8526 ((*(*ptr).vtbl).setComponentHandler)(
8527 ptr,
8528 handler,
8529 )
8530 }
8531 #[inline]
8532 unsafe fn createView(
8533 &self,
8534 name: FIDString,
8535 ) -> *mut IPlugView {
8536 let ptr = self.ptr() as *mut IEditController;
8537 ((*(*ptr).vtbl).createView)(
8538 ptr,
8539 name,
8540 )
8541 }
8542 }
8543 impl IEditController {
8544 const fn make_vtbl<C, W, const OFFSET: isize>() -> IEditControllerVtbl
8545 where
8546 C: IEditControllerTrait + ::com_scrape_types::Class,
8547 W: ::com_scrape_types::Wrapper<C>,
8548 {
8549 unsafe extern "system" fn setComponentState<C, W, const OFFSET: isize>(
8550 this: *mut IEditController,
8551 state: *mut IBStream,
8552 ) -> tresult
8553 where
8554 C: IEditControllerTrait + ::com_scrape_types::Class,
8555 W: ::com_scrape_types::Wrapper<C>,
8556 {
8557 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
8558 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
8559 (*ptr).setComponentState(
8560 state,
8561 )
8562 }
8563 unsafe extern "system" fn setState<C, W, const OFFSET: isize>(
8564 this: *mut IEditController,
8565 state: *mut IBStream,
8566 ) -> tresult
8567 where
8568 C: IEditControllerTrait + ::com_scrape_types::Class,
8569 W: ::com_scrape_types::Wrapper<C>,
8570 {
8571 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
8572 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
8573 (*ptr).setState(
8574 state,
8575 )
8576 }
8577 unsafe extern "system" fn getState<C, W, const OFFSET: isize>(
8578 this: *mut IEditController,
8579 state: *mut IBStream,
8580 ) -> tresult
8581 where
8582 C: IEditControllerTrait + ::com_scrape_types::Class,
8583 W: ::com_scrape_types::Wrapper<C>,
8584 {
8585 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
8586 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
8587 (*ptr).getState(
8588 state,
8589 )
8590 }
8591 unsafe extern "system" fn getParameterCount<C, W, const OFFSET: isize>(
8592 this: *mut IEditController,
8593 ) -> int32
8594 where
8595 C: IEditControllerTrait + ::com_scrape_types::Class,
8596 W: ::com_scrape_types::Wrapper<C>,
8597 {
8598 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
8599 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
8600 (*ptr).getParameterCount(
8601 )
8602 }
8603 unsafe extern "system" fn getParameterInfo<C, W, const OFFSET: isize>(
8604 this: *mut IEditController,
8605 paramIndex: int32,
8606 info: *mut ParameterInfo,
8607 ) -> tresult
8608 where
8609 C: IEditControllerTrait + ::com_scrape_types::Class,
8610 W: ::com_scrape_types::Wrapper<C>,
8611 {
8612 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
8613 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
8614 (*ptr).getParameterInfo(
8615 paramIndex,
8616 info,
8617 )
8618 }
8619 unsafe extern "system" fn getParamStringByValue<C, W, const OFFSET: isize>(
8620 this: *mut IEditController,
8621 id: ParamID,
8622 valueNormalized: ParamValue,
8623 string: *mut String128,
8624 ) -> tresult
8625 where
8626 C: IEditControllerTrait + ::com_scrape_types::Class,
8627 W: ::com_scrape_types::Wrapper<C>,
8628 {
8629 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
8630 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
8631 (*ptr).getParamStringByValue(
8632 id,
8633 valueNormalized,
8634 string,
8635 )
8636 }
8637 unsafe extern "system" fn getParamValueByString<C, W, const OFFSET: isize>(
8638 this: *mut IEditController,
8639 id: ParamID,
8640 string: *mut TChar,
8641 valueNormalized: *mut ParamValue,
8642 ) -> tresult
8643 where
8644 C: IEditControllerTrait + ::com_scrape_types::Class,
8645 W: ::com_scrape_types::Wrapper<C>,
8646 {
8647 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
8648 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
8649 (*ptr).getParamValueByString(
8650 id,
8651 string,
8652 valueNormalized,
8653 )
8654 }
8655 unsafe extern "system" fn normalizedParamToPlain<C, W, const OFFSET: isize>(
8656 this: *mut IEditController,
8657 id: ParamID,
8658 valueNormalized: ParamValue,
8659 ) -> ParamValue
8660 where
8661 C: IEditControllerTrait + ::com_scrape_types::Class,
8662 W: ::com_scrape_types::Wrapper<C>,
8663 {
8664 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
8665 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
8666 (*ptr).normalizedParamToPlain(
8667 id,
8668 valueNormalized,
8669 )
8670 }
8671 unsafe extern "system" fn plainParamToNormalized<C, W, const OFFSET: isize>(
8672 this: *mut IEditController,
8673 id: ParamID,
8674 plainValue: ParamValue,
8675 ) -> ParamValue
8676 where
8677 C: IEditControllerTrait + ::com_scrape_types::Class,
8678 W: ::com_scrape_types::Wrapper<C>,
8679 {
8680 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
8681 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
8682 (*ptr).plainParamToNormalized(
8683 id,
8684 plainValue,
8685 )
8686 }
8687 unsafe extern "system" fn getParamNormalized<C, W, const OFFSET: isize>(
8688 this: *mut IEditController,
8689 id: ParamID,
8690 ) -> ParamValue
8691 where
8692 C: IEditControllerTrait + ::com_scrape_types::Class,
8693 W: ::com_scrape_types::Wrapper<C>,
8694 {
8695 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
8696 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
8697 (*ptr).getParamNormalized(
8698 id,
8699 )
8700 }
8701 unsafe extern "system" fn setParamNormalized<C, W, const OFFSET: isize>(
8702 this: *mut IEditController,
8703 id: ParamID,
8704 value: ParamValue,
8705 ) -> tresult
8706 where
8707 C: IEditControllerTrait + ::com_scrape_types::Class,
8708 W: ::com_scrape_types::Wrapper<C>,
8709 {
8710 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
8711 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
8712 (*ptr).setParamNormalized(
8713 id,
8714 value,
8715 )
8716 }
8717 unsafe extern "system" fn setComponentHandler<C, W, const OFFSET: isize>(
8718 this: *mut IEditController,
8719 handler: *mut IComponentHandler,
8720 ) -> tresult
8721 where
8722 C: IEditControllerTrait + ::com_scrape_types::Class,
8723 W: ::com_scrape_types::Wrapper<C>,
8724 {
8725 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
8726 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
8727 (*ptr).setComponentHandler(
8728 handler,
8729 )
8730 }
8731 unsafe extern "system" fn createView<C, W, const OFFSET: isize>(
8732 this: *mut IEditController,
8733 name: FIDString,
8734 ) -> *mut IPlugView
8735 where
8736 C: IEditControllerTrait + ::com_scrape_types::Class,
8737 W: ::com_scrape_types::Wrapper<C>,
8738 {
8739 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
8740 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
8741 (*ptr).createView(
8742 name,
8743 )
8744 }
8745 IEditControllerVtbl {
8746 base: IPluginBase::make_vtbl::<C, W, OFFSET>(),
8747 setComponentState: setComponentState::<C, W, OFFSET>,
8748 setState: setState::<C, W, OFFSET>,
8749 getState: getState::<C, W, OFFSET>,
8750 getParameterCount: getParameterCount::<C, W, OFFSET>,
8751 getParameterInfo: getParameterInfo::<C, W, OFFSET>,
8752 getParamStringByValue: getParamStringByValue::<C, W, OFFSET>,
8753 getParamValueByString: getParamValueByString::<C, W, OFFSET>,
8754 normalizedParamToPlain: normalizedParamToPlain::<C, W, OFFSET>,
8755 plainParamToNormalized: plainParamToNormalized::<C, W, OFFSET>,
8756 getParamNormalized: getParamNormalized::<C, W, OFFSET>,
8757 setParamNormalized: setParamNormalized::<C, W, OFFSET>,
8758 setComponentHandler: setComponentHandler::<C, W, OFFSET>,
8759 createView: createView::<C, W, OFFSET>,
8760 }
8761 }
8762 }
8763 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IEditController
8764 where
8765 C: IEditControllerTrait + ::com_scrape_types::Class,
8766 W: ::com_scrape_types::Wrapper<C>,
8767 {
8768 const OBJ: Self = IEditController {
8769 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
8770 };
8771 }
8772 #[repr(C)]
8773 #[derive(Copy, Clone)]
8774 pub struct IEditController2 {
8775 pub vtbl: *const IEditController2Vtbl,
8776 }
8777 unsafe impl Send for IEditController2 {}
8778 unsafe impl Sync for IEditController2 {}
8779 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IEditController2 {}
8780 impl ::com_scrape_types::Unknown for IEditController2 {
8781 #[inline]
8782 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
8783 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
8784 }
8785 #[inline]
8786 unsafe fn add_ref(this: *mut Self) -> usize {
8787 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
8788 }
8789 #[inline]
8790 unsafe fn release(this: *mut Self) -> usize {
8791 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
8792 }
8793 }
8794 unsafe impl ::com_scrape_types::Interface for IEditController2 {
8795 type Vtbl = IEditController2Vtbl;
8796 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IEditController2_iid);
8797 #[inline]
8798 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
8799 iid == &Self::IID || FUnknown::inherits(iid)
8800 }
8801 }
8802 #[repr(C)]
8803 #[derive(Copy, Clone)]
8804 pub struct IEditController2Vtbl {
8805 pub base: FUnknownVtbl,
8806 pub setKnobMode: unsafe extern "system" fn(
8807 this: *mut IEditController2,
8808 mode: KnobMode,
8809 ) -> tresult,
8810 pub openHelp: unsafe extern "system" fn(
8811 this: *mut IEditController2,
8812 onlyCheck: TBool,
8813 ) -> tresult,
8814 pub openAboutBox: unsafe extern "system" fn(
8815 this: *mut IEditController2,
8816 onlyCheck: TBool,
8817 ) -> tresult,
8818 }
8819 pub trait IEditController2Trait {
8820 unsafe fn setKnobMode(
8821 &self,
8822 mode: KnobMode,
8823 ) -> tresult;
8824 unsafe fn openHelp(
8825 &self,
8826 onlyCheck: TBool,
8827 ) -> tresult;
8828 unsafe fn openAboutBox(
8829 &self,
8830 onlyCheck: TBool,
8831 ) -> tresult;
8832 }
8833 impl<P> IEditController2Trait for P
8834 where
8835 P: ::com_scrape_types::SmartPtr,
8836 P::Target: ::com_scrape_types::Inherits<IEditController2>,
8837 {
8838 #[inline]
8839 unsafe fn setKnobMode(
8840 &self,
8841 mode: KnobMode,
8842 ) -> tresult {
8843 let ptr = self.ptr() as *mut IEditController2;
8844 ((*(*ptr).vtbl).setKnobMode)(
8845 ptr,
8846 mode,
8847 )
8848 }
8849 #[inline]
8850 unsafe fn openHelp(
8851 &self,
8852 onlyCheck: TBool,
8853 ) -> tresult {
8854 let ptr = self.ptr() as *mut IEditController2;
8855 ((*(*ptr).vtbl).openHelp)(
8856 ptr,
8857 onlyCheck,
8858 )
8859 }
8860 #[inline]
8861 unsafe fn openAboutBox(
8862 &self,
8863 onlyCheck: TBool,
8864 ) -> tresult {
8865 let ptr = self.ptr() as *mut IEditController2;
8866 ((*(*ptr).vtbl).openAboutBox)(
8867 ptr,
8868 onlyCheck,
8869 )
8870 }
8871 }
8872 impl IEditController2 {
8873 const fn make_vtbl<C, W, const OFFSET: isize>() -> IEditController2Vtbl
8874 where
8875 C: IEditController2Trait + ::com_scrape_types::Class,
8876 W: ::com_scrape_types::Wrapper<C>,
8877 {
8878 unsafe extern "system" fn setKnobMode<C, W, const OFFSET: isize>(
8879 this: *mut IEditController2,
8880 mode: KnobMode,
8881 ) -> tresult
8882 where
8883 C: IEditController2Trait + ::com_scrape_types::Class,
8884 W: ::com_scrape_types::Wrapper<C>,
8885 {
8886 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
8887 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
8888 (*ptr).setKnobMode(
8889 mode,
8890 )
8891 }
8892 unsafe extern "system" fn openHelp<C, W, const OFFSET: isize>(
8893 this: *mut IEditController2,
8894 onlyCheck: TBool,
8895 ) -> tresult
8896 where
8897 C: IEditController2Trait + ::com_scrape_types::Class,
8898 W: ::com_scrape_types::Wrapper<C>,
8899 {
8900 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
8901 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
8902 (*ptr).openHelp(
8903 onlyCheck,
8904 )
8905 }
8906 unsafe extern "system" fn openAboutBox<C, W, const OFFSET: isize>(
8907 this: *mut IEditController2,
8908 onlyCheck: TBool,
8909 ) -> tresult
8910 where
8911 C: IEditController2Trait + ::com_scrape_types::Class,
8912 W: ::com_scrape_types::Wrapper<C>,
8913 {
8914 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
8915 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
8916 (*ptr).openAboutBox(
8917 onlyCheck,
8918 )
8919 }
8920 IEditController2Vtbl {
8921 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
8922 setKnobMode: setKnobMode::<C, W, OFFSET>,
8923 openHelp: openHelp::<C, W, OFFSET>,
8924 openAboutBox: openAboutBox::<C, W, OFFSET>,
8925 }
8926 }
8927 }
8928 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IEditController2
8929 where
8930 C: IEditController2Trait + ::com_scrape_types::Class,
8931 W: ::com_scrape_types::Wrapper<C>,
8932 {
8933 const OBJ: Self = IEditController2 {
8934 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
8935 };
8936 }
8937 #[repr(C)]
8938 #[derive(Copy, Clone)]
8939 pub struct IEditControllerHostEditing {
8940 pub vtbl: *const IEditControllerHostEditingVtbl,
8941 }
8942 unsafe impl Send for IEditControllerHostEditing {}
8943 unsafe impl Sync for IEditControllerHostEditing {}
8944 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IEditControllerHostEditing {}
8945 impl ::com_scrape_types::Unknown for IEditControllerHostEditing {
8946 #[inline]
8947 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
8948 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
8949 }
8950 #[inline]
8951 unsafe fn add_ref(this: *mut Self) -> usize {
8952 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
8953 }
8954 #[inline]
8955 unsafe fn release(this: *mut Self) -> usize {
8956 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
8957 }
8958 }
8959 unsafe impl ::com_scrape_types::Interface for IEditControllerHostEditing {
8960 type Vtbl = IEditControllerHostEditingVtbl;
8961 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IEditControllerHostEditing_iid);
8962 #[inline]
8963 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
8964 iid == &Self::IID || FUnknown::inherits(iid)
8965 }
8966 }
8967 #[repr(C)]
8968 #[derive(Copy, Clone)]
8969 pub struct IEditControllerHostEditingVtbl {
8970 pub base: FUnknownVtbl,
8971 pub beginEditFromHost: unsafe extern "system" fn(
8972 this: *mut IEditControllerHostEditing,
8973 paramID: ParamID,
8974 ) -> tresult,
8975 pub endEditFromHost: unsafe extern "system" fn(
8976 this: *mut IEditControllerHostEditing,
8977 paramID: ParamID,
8978 ) -> tresult,
8979 }
8980 pub trait IEditControllerHostEditingTrait {
8981 unsafe fn beginEditFromHost(
8982 &self,
8983 paramID: ParamID,
8984 ) -> tresult;
8985 unsafe fn endEditFromHost(
8986 &self,
8987 paramID: ParamID,
8988 ) -> tresult;
8989 }
8990 impl<P> IEditControllerHostEditingTrait for P
8991 where
8992 P: ::com_scrape_types::SmartPtr,
8993 P::Target: ::com_scrape_types::Inherits<IEditControllerHostEditing>,
8994 {
8995 #[inline]
8996 unsafe fn beginEditFromHost(
8997 &self,
8998 paramID: ParamID,
8999 ) -> tresult {
9000 let ptr = self.ptr() as *mut IEditControllerHostEditing;
9001 ((*(*ptr).vtbl).beginEditFromHost)(
9002 ptr,
9003 paramID,
9004 )
9005 }
9006 #[inline]
9007 unsafe fn endEditFromHost(
9008 &self,
9009 paramID: ParamID,
9010 ) -> tresult {
9011 let ptr = self.ptr() as *mut IEditControllerHostEditing;
9012 ((*(*ptr).vtbl).endEditFromHost)(
9013 ptr,
9014 paramID,
9015 )
9016 }
9017 }
9018 impl IEditControllerHostEditing {
9019 const fn make_vtbl<C, W, const OFFSET: isize>() -> IEditControllerHostEditingVtbl
9020 where
9021 C: IEditControllerHostEditingTrait + ::com_scrape_types::Class,
9022 W: ::com_scrape_types::Wrapper<C>,
9023 {
9024 unsafe extern "system" fn beginEditFromHost<C, W, const OFFSET: isize>(
9025 this: *mut IEditControllerHostEditing,
9026 paramID: ParamID,
9027 ) -> tresult
9028 where
9029 C: IEditControllerHostEditingTrait + ::com_scrape_types::Class,
9030 W: ::com_scrape_types::Wrapper<C>,
9031 {
9032 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
9033 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
9034 (*ptr).beginEditFromHost(
9035 paramID,
9036 )
9037 }
9038 unsafe extern "system" fn endEditFromHost<C, W, const OFFSET: isize>(
9039 this: *mut IEditControllerHostEditing,
9040 paramID: ParamID,
9041 ) -> tresult
9042 where
9043 C: IEditControllerHostEditingTrait + ::com_scrape_types::Class,
9044 W: ::com_scrape_types::Wrapper<C>,
9045 {
9046 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
9047 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
9048 (*ptr).endEditFromHost(
9049 paramID,
9050 )
9051 }
9052 IEditControllerHostEditingVtbl {
9053 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
9054 beginEditFromHost: beginEditFromHost::<C, W, OFFSET>,
9055 endEditFromHost: endEditFromHost::<C, W, OFFSET>,
9056 }
9057 }
9058 }
9059 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IEditControllerHostEditing
9060 where
9061 C: IEditControllerHostEditingTrait + ::com_scrape_types::Class,
9062 W: ::com_scrape_types::Wrapper<C>,
9063 {
9064 const OBJ: Self = IEditControllerHostEditing {
9065 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
9066 };
9067 }
9068 #[repr(C)]
9069 #[derive(Copy, Clone)]
9070 pub struct IEventList {
9071 pub vtbl: *const IEventListVtbl,
9072 }
9073 unsafe impl Send for IEventList {}
9074 unsafe impl Sync for IEventList {}
9075 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IEventList {}
9076 impl ::com_scrape_types::Unknown for IEventList {
9077 #[inline]
9078 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
9079 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
9080 }
9081 #[inline]
9082 unsafe fn add_ref(this: *mut Self) -> usize {
9083 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
9084 }
9085 #[inline]
9086 unsafe fn release(this: *mut Self) -> usize {
9087 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
9088 }
9089 }
9090 unsafe impl ::com_scrape_types::Interface for IEventList {
9091 type Vtbl = IEventListVtbl;
9092 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IEventList_iid);
9093 #[inline]
9094 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
9095 iid == &Self::IID || FUnknown::inherits(iid)
9096 }
9097 }
9098 #[repr(C)]
9099 #[derive(Copy, Clone)]
9100 pub struct IEventListVtbl {
9101 pub base: FUnknownVtbl,
9102 pub getEventCount: unsafe extern "system" fn(
9103 this: *mut IEventList,
9104 ) -> int32,
9105 pub getEvent: unsafe extern "system" fn(
9106 this: *mut IEventList,
9107 index: int32,
9108 e: *mut Event,
9109 ) -> tresult,
9110 pub addEvent: unsafe extern "system" fn(
9111 this: *mut IEventList,
9112 e: *mut Event,
9113 ) -> tresult,
9114 }
9115 pub trait IEventListTrait {
9116 unsafe fn getEventCount(
9117 &self,
9118 ) -> int32;
9119 unsafe fn getEvent(
9120 &self,
9121 index: int32,
9122 e: *mut Event,
9123 ) -> tresult;
9124 unsafe fn addEvent(
9125 &self,
9126 e: *mut Event,
9127 ) -> tresult;
9128 }
9129 impl<P> IEventListTrait for P
9130 where
9131 P: ::com_scrape_types::SmartPtr,
9132 P::Target: ::com_scrape_types::Inherits<IEventList>,
9133 {
9134 #[inline]
9135 unsafe fn getEventCount(
9136 &self,
9137 ) -> int32 {
9138 let ptr = self.ptr() as *mut IEventList;
9139 ((*(*ptr).vtbl).getEventCount)(
9140 ptr,
9141 )
9142 }
9143 #[inline]
9144 unsafe fn getEvent(
9145 &self,
9146 index: int32,
9147 e: *mut Event,
9148 ) -> tresult {
9149 let ptr = self.ptr() as *mut IEventList;
9150 ((*(*ptr).vtbl).getEvent)(
9151 ptr,
9152 index,
9153 e,
9154 )
9155 }
9156 #[inline]
9157 unsafe fn addEvent(
9158 &self,
9159 e: *mut Event,
9160 ) -> tresult {
9161 let ptr = self.ptr() as *mut IEventList;
9162 ((*(*ptr).vtbl).addEvent)(
9163 ptr,
9164 e,
9165 )
9166 }
9167 }
9168 impl IEventList {
9169 const fn make_vtbl<C, W, const OFFSET: isize>() -> IEventListVtbl
9170 where
9171 C: IEventListTrait + ::com_scrape_types::Class,
9172 W: ::com_scrape_types::Wrapper<C>,
9173 {
9174 unsafe extern "system" fn getEventCount<C, W, const OFFSET: isize>(
9175 this: *mut IEventList,
9176 ) -> int32
9177 where
9178 C: IEventListTrait + ::com_scrape_types::Class,
9179 W: ::com_scrape_types::Wrapper<C>,
9180 {
9181 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
9182 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
9183 (*ptr).getEventCount(
9184 )
9185 }
9186 unsafe extern "system" fn getEvent<C, W, const OFFSET: isize>(
9187 this: *mut IEventList,
9188 index: int32,
9189 e: *mut Event,
9190 ) -> tresult
9191 where
9192 C: IEventListTrait + ::com_scrape_types::Class,
9193 W: ::com_scrape_types::Wrapper<C>,
9194 {
9195 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
9196 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
9197 (*ptr).getEvent(
9198 index,
9199 e,
9200 )
9201 }
9202 unsafe extern "system" fn addEvent<C, W, const OFFSET: isize>(
9203 this: *mut IEventList,
9204 e: *mut Event,
9205 ) -> tresult
9206 where
9207 C: IEventListTrait + ::com_scrape_types::Class,
9208 W: ::com_scrape_types::Wrapper<C>,
9209 {
9210 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
9211 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
9212 (*ptr).addEvent(
9213 e,
9214 )
9215 }
9216 IEventListVtbl {
9217 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
9218 getEventCount: getEventCount::<C, W, OFFSET>,
9219 getEvent: getEvent::<C, W, OFFSET>,
9220 addEvent: addEvent::<C, W, OFFSET>,
9221 }
9222 }
9223 }
9224 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IEventList
9225 where
9226 C: IEventListTrait + ::com_scrape_types::Class,
9227 W: ::com_scrape_types::Wrapper<C>,
9228 {
9229 const OBJ: Self = IEventList {
9230 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
9231 };
9232 }
9233 #[repr(C)]
9234 #[derive(Copy, Clone)]
9235 pub struct IHostApplication {
9236 pub vtbl: *const IHostApplicationVtbl,
9237 }
9238 unsafe impl Send for IHostApplication {}
9239 unsafe impl Sync for IHostApplication {}
9240 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IHostApplication {}
9241 impl ::com_scrape_types::Unknown for IHostApplication {
9242 #[inline]
9243 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
9244 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
9245 }
9246 #[inline]
9247 unsafe fn add_ref(this: *mut Self) -> usize {
9248 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
9249 }
9250 #[inline]
9251 unsafe fn release(this: *mut Self) -> usize {
9252 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
9253 }
9254 }
9255 unsafe impl ::com_scrape_types::Interface for IHostApplication {
9256 type Vtbl = IHostApplicationVtbl;
9257 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IHostApplication_iid);
9258 #[inline]
9259 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
9260 iid == &Self::IID || FUnknown::inherits(iid)
9261 }
9262 }
9263 #[repr(C)]
9264 #[derive(Copy, Clone)]
9265 pub struct IHostApplicationVtbl {
9266 pub base: FUnknownVtbl,
9267 pub getName: unsafe extern "system" fn(
9268 this: *mut IHostApplication,
9269 name: *mut String128,
9270 ) -> tresult,
9271 pub createInstance: unsafe extern "system" fn(
9272 this: *mut IHostApplication,
9273 cid: *mut TUID,
9274 _iid: *mut TUID,
9275 obj: *mut *mut ::std::ffi::c_void,
9276 ) -> tresult,
9277 }
9278 pub trait IHostApplicationTrait {
9279 unsafe fn getName(
9280 &self,
9281 name: *mut String128,
9282 ) -> tresult;
9283 unsafe fn createInstance(
9284 &self,
9285 cid: *mut TUID,
9286 _iid: *mut TUID,
9287 obj: *mut *mut ::std::ffi::c_void,
9288 ) -> tresult;
9289 }
9290 impl<P> IHostApplicationTrait for P
9291 where
9292 P: ::com_scrape_types::SmartPtr,
9293 P::Target: ::com_scrape_types::Inherits<IHostApplication>,
9294 {
9295 #[inline]
9296 unsafe fn getName(
9297 &self,
9298 name: *mut String128,
9299 ) -> tresult {
9300 let ptr = self.ptr() as *mut IHostApplication;
9301 ((*(*ptr).vtbl).getName)(
9302 ptr,
9303 name,
9304 )
9305 }
9306 #[inline]
9307 unsafe fn createInstance(
9308 &self,
9309 cid: *mut TUID,
9310 _iid: *mut TUID,
9311 obj: *mut *mut ::std::ffi::c_void,
9312 ) -> tresult {
9313 let ptr = self.ptr() as *mut IHostApplication;
9314 ((*(*ptr).vtbl).createInstance)(
9315 ptr,
9316 cid,
9317 _iid,
9318 obj,
9319 )
9320 }
9321 }
9322 impl IHostApplication {
9323 const fn make_vtbl<C, W, const OFFSET: isize>() -> IHostApplicationVtbl
9324 where
9325 C: IHostApplicationTrait + ::com_scrape_types::Class,
9326 W: ::com_scrape_types::Wrapper<C>,
9327 {
9328 unsafe extern "system" fn getName<C, W, const OFFSET: isize>(
9329 this: *mut IHostApplication,
9330 name: *mut String128,
9331 ) -> tresult
9332 where
9333 C: IHostApplicationTrait + ::com_scrape_types::Class,
9334 W: ::com_scrape_types::Wrapper<C>,
9335 {
9336 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
9337 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
9338 (*ptr).getName(
9339 name,
9340 )
9341 }
9342 unsafe extern "system" fn createInstance<C, W, const OFFSET: isize>(
9343 this: *mut IHostApplication,
9344 cid: *mut TUID,
9345 _iid: *mut TUID,
9346 obj: *mut *mut ::std::ffi::c_void,
9347 ) -> tresult
9348 where
9349 C: IHostApplicationTrait + ::com_scrape_types::Class,
9350 W: ::com_scrape_types::Wrapper<C>,
9351 {
9352 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
9353 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
9354 (*ptr).createInstance(
9355 cid,
9356 _iid,
9357 obj,
9358 )
9359 }
9360 IHostApplicationVtbl {
9361 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
9362 getName: getName::<C, W, OFFSET>,
9363 createInstance: createInstance::<C, W, OFFSET>,
9364 }
9365 }
9366 }
9367 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IHostApplication
9368 where
9369 C: IHostApplicationTrait + ::com_scrape_types::Class,
9370 W: ::com_scrape_types::Wrapper<C>,
9371 {
9372 const OBJ: Self = IHostApplication {
9373 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
9374 };
9375 }
9376 #[repr(C)]
9377 #[derive(Copy, Clone)]
9378 pub struct IInterAppAudioConnectionNotification {
9379 pub vtbl: *const IInterAppAudioConnectionNotificationVtbl,
9380 }
9381 unsafe impl Send for IInterAppAudioConnectionNotification {}
9382 unsafe impl Sync for IInterAppAudioConnectionNotification {}
9383 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IInterAppAudioConnectionNotification {}
9384 impl ::com_scrape_types::Unknown for IInterAppAudioConnectionNotification {
9385 #[inline]
9386 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
9387 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
9388 }
9389 #[inline]
9390 unsafe fn add_ref(this: *mut Self) -> usize {
9391 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
9392 }
9393 #[inline]
9394 unsafe fn release(this: *mut Self) -> usize {
9395 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
9396 }
9397 }
9398 unsafe impl ::com_scrape_types::Interface for IInterAppAudioConnectionNotification {
9399 type Vtbl = IInterAppAudioConnectionNotificationVtbl;
9400 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IInterAppAudioConnectionNotification_iid);
9401 #[inline]
9402 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
9403 iid == &Self::IID || FUnknown::inherits(iid)
9404 }
9405 }
9406 #[repr(C)]
9407 #[derive(Copy, Clone)]
9408 pub struct IInterAppAudioConnectionNotificationVtbl {
9409 pub base: FUnknownVtbl,
9410 pub onInterAppAudioConnectionStateChange: unsafe extern "system" fn(
9411 this: *mut IInterAppAudioConnectionNotification,
9412 newState: TBool,
9413 ),
9414 }
9415 pub trait IInterAppAudioConnectionNotificationTrait {
9416 unsafe fn onInterAppAudioConnectionStateChange(
9417 &self,
9418 newState: TBool,
9419 );
9420 }
9421 impl<P> IInterAppAudioConnectionNotificationTrait for P
9422 where
9423 P: ::com_scrape_types::SmartPtr,
9424 P::Target: ::com_scrape_types::Inherits<IInterAppAudioConnectionNotification>,
9425 {
9426 #[inline]
9427 unsafe fn onInterAppAudioConnectionStateChange(
9428 &self,
9429 newState: TBool,
9430 ) {
9431 let ptr = self.ptr() as *mut IInterAppAudioConnectionNotification;
9432 ((*(*ptr).vtbl).onInterAppAudioConnectionStateChange)(
9433 ptr,
9434 newState,
9435 )
9436 }
9437 }
9438 impl IInterAppAudioConnectionNotification {
9439 const fn make_vtbl<C, W, const OFFSET: isize>() -> IInterAppAudioConnectionNotificationVtbl
9440 where
9441 C: IInterAppAudioConnectionNotificationTrait + ::com_scrape_types::Class,
9442 W: ::com_scrape_types::Wrapper<C>,
9443 {
9444 unsafe extern "system" fn onInterAppAudioConnectionStateChange<C, W, const OFFSET: isize>(
9445 this: *mut IInterAppAudioConnectionNotification,
9446 newState: TBool,
9447 )
9448 where
9449 C: IInterAppAudioConnectionNotificationTrait + ::com_scrape_types::Class,
9450 W: ::com_scrape_types::Wrapper<C>,
9451 {
9452 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
9453 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
9454 (*ptr).onInterAppAudioConnectionStateChange(
9455 newState,
9456 )
9457 }
9458 IInterAppAudioConnectionNotificationVtbl {
9459 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
9460 onInterAppAudioConnectionStateChange: onInterAppAudioConnectionStateChange::<C, W, OFFSET>,
9461 }
9462 }
9463 }
9464 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IInterAppAudioConnectionNotification
9465 where
9466 C: IInterAppAudioConnectionNotificationTrait + ::com_scrape_types::Class,
9467 W: ::com_scrape_types::Wrapper<C>,
9468 {
9469 const OBJ: Self = IInterAppAudioConnectionNotification {
9470 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
9471 };
9472 }
9473 #[repr(C)]
9474 #[derive(Copy, Clone)]
9475 pub struct IInterAppAudioHost {
9476 pub vtbl: *const IInterAppAudioHostVtbl,
9477 }
9478 unsafe impl Send for IInterAppAudioHost {}
9479 unsafe impl Sync for IInterAppAudioHost {}
9480 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IInterAppAudioHost {}
9481 impl ::com_scrape_types::Unknown for IInterAppAudioHost {
9482 #[inline]
9483 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
9484 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
9485 }
9486 #[inline]
9487 unsafe fn add_ref(this: *mut Self) -> usize {
9488 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
9489 }
9490 #[inline]
9491 unsafe fn release(this: *mut Self) -> usize {
9492 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
9493 }
9494 }
9495 unsafe impl ::com_scrape_types::Interface for IInterAppAudioHost {
9496 type Vtbl = IInterAppAudioHostVtbl;
9497 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IInterAppAudioHost_iid);
9498 #[inline]
9499 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
9500 iid == &Self::IID || FUnknown::inherits(iid)
9501 }
9502 }
9503 #[repr(C)]
9504 #[derive(Copy, Clone)]
9505 pub struct IInterAppAudioHostVtbl {
9506 pub base: FUnknownVtbl,
9507 pub getScreenSize: unsafe extern "system" fn(
9508 this: *mut IInterAppAudioHost,
9509 size: *mut ViewRect,
9510 scale: *mut f32,
9511 ) -> tresult,
9512 pub connectedToHost: unsafe extern "system" fn(
9513 this: *mut IInterAppAudioHost,
9514 ) -> tresult,
9515 pub switchToHost: unsafe extern "system" fn(
9516 this: *mut IInterAppAudioHost,
9517 ) -> tresult,
9518 pub sendRemoteControlEvent: unsafe extern "system" fn(
9519 this: *mut IInterAppAudioHost,
9520 event: uint32,
9521 ) -> tresult,
9522 pub getHostIcon: unsafe extern "system" fn(
9523 this: *mut IInterAppAudioHost,
9524 icon: *mut *mut ::std::ffi::c_void,
9525 ) -> tresult,
9526 pub scheduleEventFromUI: unsafe extern "system" fn(
9527 this: *mut IInterAppAudioHost,
9528 event: *mut Event,
9529 ) -> tresult,
9530 pub createPresetManager: unsafe extern "system" fn(
9531 this: *mut IInterAppAudioHost,
9532 cid: *const TUID,
9533 ) -> *mut IInterAppAudioPresetManager,
9534 pub showSettingsView: unsafe extern "system" fn(
9535 this: *mut IInterAppAudioHost,
9536 ) -> tresult,
9537 }
9538 pub trait IInterAppAudioHostTrait {
9539 unsafe fn getScreenSize(
9540 &self,
9541 size: *mut ViewRect,
9542 scale: *mut f32,
9543 ) -> tresult;
9544 unsafe fn connectedToHost(
9545 &self,
9546 ) -> tresult;
9547 unsafe fn switchToHost(
9548 &self,
9549 ) -> tresult;
9550 unsafe fn sendRemoteControlEvent(
9551 &self,
9552 event: uint32,
9553 ) -> tresult;
9554 unsafe fn getHostIcon(
9555 &self,
9556 icon: *mut *mut ::std::ffi::c_void,
9557 ) -> tresult;
9558 unsafe fn scheduleEventFromUI(
9559 &self,
9560 event: *mut Event,
9561 ) -> tresult;
9562 unsafe fn createPresetManager(
9563 &self,
9564 cid: *const TUID,
9565 ) -> *mut IInterAppAudioPresetManager;
9566 unsafe fn showSettingsView(
9567 &self,
9568 ) -> tresult;
9569 }
9570 impl<P> IInterAppAudioHostTrait for P
9571 where
9572 P: ::com_scrape_types::SmartPtr,
9573 P::Target: ::com_scrape_types::Inherits<IInterAppAudioHost>,
9574 {
9575 #[inline]
9576 unsafe fn getScreenSize(
9577 &self,
9578 size: *mut ViewRect,
9579 scale: *mut f32,
9580 ) -> tresult {
9581 let ptr = self.ptr() as *mut IInterAppAudioHost;
9582 ((*(*ptr).vtbl).getScreenSize)(
9583 ptr,
9584 size,
9585 scale,
9586 )
9587 }
9588 #[inline]
9589 unsafe fn connectedToHost(
9590 &self,
9591 ) -> tresult {
9592 let ptr = self.ptr() as *mut IInterAppAudioHost;
9593 ((*(*ptr).vtbl).connectedToHost)(
9594 ptr,
9595 )
9596 }
9597 #[inline]
9598 unsafe fn switchToHost(
9599 &self,
9600 ) -> tresult {
9601 let ptr = self.ptr() as *mut IInterAppAudioHost;
9602 ((*(*ptr).vtbl).switchToHost)(
9603 ptr,
9604 )
9605 }
9606 #[inline]
9607 unsafe fn sendRemoteControlEvent(
9608 &self,
9609 event: uint32,
9610 ) -> tresult {
9611 let ptr = self.ptr() as *mut IInterAppAudioHost;
9612 ((*(*ptr).vtbl).sendRemoteControlEvent)(
9613 ptr,
9614 event,
9615 )
9616 }
9617 #[inline]
9618 unsafe fn getHostIcon(
9619 &self,
9620 icon: *mut *mut ::std::ffi::c_void,
9621 ) -> tresult {
9622 let ptr = self.ptr() as *mut IInterAppAudioHost;
9623 ((*(*ptr).vtbl).getHostIcon)(
9624 ptr,
9625 icon,
9626 )
9627 }
9628 #[inline]
9629 unsafe fn scheduleEventFromUI(
9630 &self,
9631 event: *mut Event,
9632 ) -> tresult {
9633 let ptr = self.ptr() as *mut IInterAppAudioHost;
9634 ((*(*ptr).vtbl).scheduleEventFromUI)(
9635 ptr,
9636 event,
9637 )
9638 }
9639 #[inline]
9640 unsafe fn createPresetManager(
9641 &self,
9642 cid: *const TUID,
9643 ) -> *mut IInterAppAudioPresetManager {
9644 let ptr = self.ptr() as *mut IInterAppAudioHost;
9645 ((*(*ptr).vtbl).createPresetManager)(
9646 ptr,
9647 cid,
9648 )
9649 }
9650 #[inline]
9651 unsafe fn showSettingsView(
9652 &self,
9653 ) -> tresult {
9654 let ptr = self.ptr() as *mut IInterAppAudioHost;
9655 ((*(*ptr).vtbl).showSettingsView)(
9656 ptr,
9657 )
9658 }
9659 }
9660 impl IInterAppAudioHost {
9661 const fn make_vtbl<C, W, const OFFSET: isize>() -> IInterAppAudioHostVtbl
9662 where
9663 C: IInterAppAudioHostTrait + ::com_scrape_types::Class,
9664 W: ::com_scrape_types::Wrapper<C>,
9665 {
9666 unsafe extern "system" fn getScreenSize<C, W, const OFFSET: isize>(
9667 this: *mut IInterAppAudioHost,
9668 size: *mut ViewRect,
9669 scale: *mut f32,
9670 ) -> tresult
9671 where
9672 C: IInterAppAudioHostTrait + ::com_scrape_types::Class,
9673 W: ::com_scrape_types::Wrapper<C>,
9674 {
9675 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
9676 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
9677 (*ptr).getScreenSize(
9678 size,
9679 scale,
9680 )
9681 }
9682 unsafe extern "system" fn connectedToHost<C, W, const OFFSET: isize>(
9683 this: *mut IInterAppAudioHost,
9684 ) -> tresult
9685 where
9686 C: IInterAppAudioHostTrait + ::com_scrape_types::Class,
9687 W: ::com_scrape_types::Wrapper<C>,
9688 {
9689 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
9690 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
9691 (*ptr).connectedToHost(
9692 )
9693 }
9694 unsafe extern "system" fn switchToHost<C, W, const OFFSET: isize>(
9695 this: *mut IInterAppAudioHost,
9696 ) -> tresult
9697 where
9698 C: IInterAppAudioHostTrait + ::com_scrape_types::Class,
9699 W: ::com_scrape_types::Wrapper<C>,
9700 {
9701 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
9702 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
9703 (*ptr).switchToHost(
9704 )
9705 }
9706 unsafe extern "system" fn sendRemoteControlEvent<C, W, const OFFSET: isize>(
9707 this: *mut IInterAppAudioHost,
9708 event: uint32,
9709 ) -> tresult
9710 where
9711 C: IInterAppAudioHostTrait + ::com_scrape_types::Class,
9712 W: ::com_scrape_types::Wrapper<C>,
9713 {
9714 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
9715 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
9716 (*ptr).sendRemoteControlEvent(
9717 event,
9718 )
9719 }
9720 unsafe extern "system" fn getHostIcon<C, W, const OFFSET: isize>(
9721 this: *mut IInterAppAudioHost,
9722 icon: *mut *mut ::std::ffi::c_void,
9723 ) -> tresult
9724 where
9725 C: IInterAppAudioHostTrait + ::com_scrape_types::Class,
9726 W: ::com_scrape_types::Wrapper<C>,
9727 {
9728 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
9729 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
9730 (*ptr).getHostIcon(
9731 icon,
9732 )
9733 }
9734 unsafe extern "system" fn scheduleEventFromUI<C, W, const OFFSET: isize>(
9735 this: *mut IInterAppAudioHost,
9736 event: *mut Event,
9737 ) -> tresult
9738 where
9739 C: IInterAppAudioHostTrait + ::com_scrape_types::Class,
9740 W: ::com_scrape_types::Wrapper<C>,
9741 {
9742 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
9743 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
9744 (*ptr).scheduleEventFromUI(
9745 event,
9746 )
9747 }
9748 unsafe extern "system" fn createPresetManager<C, W, const OFFSET: isize>(
9749 this: *mut IInterAppAudioHost,
9750 cid: *const TUID,
9751 ) -> *mut IInterAppAudioPresetManager
9752 where
9753 C: IInterAppAudioHostTrait + ::com_scrape_types::Class,
9754 W: ::com_scrape_types::Wrapper<C>,
9755 {
9756 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
9757 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
9758 (*ptr).createPresetManager(
9759 cid,
9760 )
9761 }
9762 unsafe extern "system" fn showSettingsView<C, W, const OFFSET: isize>(
9763 this: *mut IInterAppAudioHost,
9764 ) -> tresult
9765 where
9766 C: IInterAppAudioHostTrait + ::com_scrape_types::Class,
9767 W: ::com_scrape_types::Wrapper<C>,
9768 {
9769 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
9770 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
9771 (*ptr).showSettingsView(
9772 )
9773 }
9774 IInterAppAudioHostVtbl {
9775 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
9776 getScreenSize: getScreenSize::<C, W, OFFSET>,
9777 connectedToHost: connectedToHost::<C, W, OFFSET>,
9778 switchToHost: switchToHost::<C, W, OFFSET>,
9779 sendRemoteControlEvent: sendRemoteControlEvent::<C, W, OFFSET>,
9780 getHostIcon: getHostIcon::<C, W, OFFSET>,
9781 scheduleEventFromUI: scheduleEventFromUI::<C, W, OFFSET>,
9782 createPresetManager: createPresetManager::<C, W, OFFSET>,
9783 showSettingsView: showSettingsView::<C, W, OFFSET>,
9784 }
9785 }
9786 }
9787 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IInterAppAudioHost
9788 where
9789 C: IInterAppAudioHostTrait + ::com_scrape_types::Class,
9790 W: ::com_scrape_types::Wrapper<C>,
9791 {
9792 const OBJ: Self = IInterAppAudioHost {
9793 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
9794 };
9795 }
9796 #[repr(C)]
9797 #[derive(Copy, Clone)]
9798 pub struct IInterAppAudioPresetManager {
9799 pub vtbl: *const IInterAppAudioPresetManagerVtbl,
9800 }
9801 unsafe impl Send for IInterAppAudioPresetManager {}
9802 unsafe impl Sync for IInterAppAudioPresetManager {}
9803 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IInterAppAudioPresetManager {}
9804 impl ::com_scrape_types::Unknown for IInterAppAudioPresetManager {
9805 #[inline]
9806 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
9807 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
9808 }
9809 #[inline]
9810 unsafe fn add_ref(this: *mut Self) -> usize {
9811 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
9812 }
9813 #[inline]
9814 unsafe fn release(this: *mut Self) -> usize {
9815 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
9816 }
9817 }
9818 unsafe impl ::com_scrape_types::Interface for IInterAppAudioPresetManager {
9819 type Vtbl = IInterAppAudioPresetManagerVtbl;
9820 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IInterAppAudioPresetManager_iid);
9821 #[inline]
9822 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
9823 iid == &Self::IID || FUnknown::inherits(iid)
9824 }
9825 }
9826 #[repr(C)]
9827 #[derive(Copy, Clone)]
9828 pub struct IInterAppAudioPresetManagerVtbl {
9829 pub base: FUnknownVtbl,
9830 pub runLoadPresetBrowser: unsafe extern "system" fn(
9831 this: *mut IInterAppAudioPresetManager,
9832 ) -> tresult,
9833 pub runSavePresetBrowser: unsafe extern "system" fn(
9834 this: *mut IInterAppAudioPresetManager,
9835 ) -> tresult,
9836 pub loadNextPreset: unsafe extern "system" fn(
9837 this: *mut IInterAppAudioPresetManager,
9838 ) -> tresult,
9839 pub loadPreviousPreset: unsafe extern "system" fn(
9840 this: *mut IInterAppAudioPresetManager,
9841 ) -> tresult,
9842 }
9843 pub trait IInterAppAudioPresetManagerTrait {
9844 unsafe fn runLoadPresetBrowser(
9845 &self,
9846 ) -> tresult;
9847 unsafe fn runSavePresetBrowser(
9848 &self,
9849 ) -> tresult;
9850 unsafe fn loadNextPreset(
9851 &self,
9852 ) -> tresult;
9853 unsafe fn loadPreviousPreset(
9854 &self,
9855 ) -> tresult;
9856 }
9857 impl<P> IInterAppAudioPresetManagerTrait for P
9858 where
9859 P: ::com_scrape_types::SmartPtr,
9860 P::Target: ::com_scrape_types::Inherits<IInterAppAudioPresetManager>,
9861 {
9862 #[inline]
9863 unsafe fn runLoadPresetBrowser(
9864 &self,
9865 ) -> tresult {
9866 let ptr = self.ptr() as *mut IInterAppAudioPresetManager;
9867 ((*(*ptr).vtbl).runLoadPresetBrowser)(
9868 ptr,
9869 )
9870 }
9871 #[inline]
9872 unsafe fn runSavePresetBrowser(
9873 &self,
9874 ) -> tresult {
9875 let ptr = self.ptr() as *mut IInterAppAudioPresetManager;
9876 ((*(*ptr).vtbl).runSavePresetBrowser)(
9877 ptr,
9878 )
9879 }
9880 #[inline]
9881 unsafe fn loadNextPreset(
9882 &self,
9883 ) -> tresult {
9884 let ptr = self.ptr() as *mut IInterAppAudioPresetManager;
9885 ((*(*ptr).vtbl).loadNextPreset)(
9886 ptr,
9887 )
9888 }
9889 #[inline]
9890 unsafe fn loadPreviousPreset(
9891 &self,
9892 ) -> tresult {
9893 let ptr = self.ptr() as *mut IInterAppAudioPresetManager;
9894 ((*(*ptr).vtbl).loadPreviousPreset)(
9895 ptr,
9896 )
9897 }
9898 }
9899 impl IInterAppAudioPresetManager {
9900 const fn make_vtbl<C, W, const OFFSET: isize>() -> IInterAppAudioPresetManagerVtbl
9901 where
9902 C: IInterAppAudioPresetManagerTrait + ::com_scrape_types::Class,
9903 W: ::com_scrape_types::Wrapper<C>,
9904 {
9905 unsafe extern "system" fn runLoadPresetBrowser<C, W, const OFFSET: isize>(
9906 this: *mut IInterAppAudioPresetManager,
9907 ) -> tresult
9908 where
9909 C: IInterAppAudioPresetManagerTrait + ::com_scrape_types::Class,
9910 W: ::com_scrape_types::Wrapper<C>,
9911 {
9912 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
9913 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
9914 (*ptr).runLoadPresetBrowser(
9915 )
9916 }
9917 unsafe extern "system" fn runSavePresetBrowser<C, W, const OFFSET: isize>(
9918 this: *mut IInterAppAudioPresetManager,
9919 ) -> tresult
9920 where
9921 C: IInterAppAudioPresetManagerTrait + ::com_scrape_types::Class,
9922 W: ::com_scrape_types::Wrapper<C>,
9923 {
9924 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
9925 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
9926 (*ptr).runSavePresetBrowser(
9927 )
9928 }
9929 unsafe extern "system" fn loadNextPreset<C, W, const OFFSET: isize>(
9930 this: *mut IInterAppAudioPresetManager,
9931 ) -> tresult
9932 where
9933 C: IInterAppAudioPresetManagerTrait + ::com_scrape_types::Class,
9934 W: ::com_scrape_types::Wrapper<C>,
9935 {
9936 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
9937 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
9938 (*ptr).loadNextPreset(
9939 )
9940 }
9941 unsafe extern "system" fn loadPreviousPreset<C, W, const OFFSET: isize>(
9942 this: *mut IInterAppAudioPresetManager,
9943 ) -> tresult
9944 where
9945 C: IInterAppAudioPresetManagerTrait + ::com_scrape_types::Class,
9946 W: ::com_scrape_types::Wrapper<C>,
9947 {
9948 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
9949 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
9950 (*ptr).loadPreviousPreset(
9951 )
9952 }
9953 IInterAppAudioPresetManagerVtbl {
9954 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
9955 runLoadPresetBrowser: runLoadPresetBrowser::<C, W, OFFSET>,
9956 runSavePresetBrowser: runSavePresetBrowser::<C, W, OFFSET>,
9957 loadNextPreset: loadNextPreset::<C, W, OFFSET>,
9958 loadPreviousPreset: loadPreviousPreset::<C, W, OFFSET>,
9959 }
9960 }
9961 }
9962 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IInterAppAudioPresetManager
9963 where
9964 C: IInterAppAudioPresetManagerTrait + ::com_scrape_types::Class,
9965 W: ::com_scrape_types::Wrapper<C>,
9966 {
9967 const OBJ: Self = IInterAppAudioPresetManager {
9968 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
9969 };
9970 }
9971 #[repr(C)]
9972 #[derive(Copy, Clone)]
9973 pub struct IKeyswitchController {
9974 pub vtbl: *const IKeyswitchControllerVtbl,
9975 }
9976 unsafe impl Send for IKeyswitchController {}
9977 unsafe impl Sync for IKeyswitchController {}
9978 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IKeyswitchController {}
9979 impl ::com_scrape_types::Unknown for IKeyswitchController {
9980 #[inline]
9981 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
9982 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
9983 }
9984 #[inline]
9985 unsafe fn add_ref(this: *mut Self) -> usize {
9986 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
9987 }
9988 #[inline]
9989 unsafe fn release(this: *mut Self) -> usize {
9990 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
9991 }
9992 }
9993 unsafe impl ::com_scrape_types::Interface for IKeyswitchController {
9994 type Vtbl = IKeyswitchControllerVtbl;
9995 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IKeyswitchController_iid);
9996 #[inline]
9997 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
9998 iid == &Self::IID || FUnknown::inherits(iid)
9999 }
10000 }
10001 #[repr(C)]
10002 #[derive(Copy, Clone)]
10003 pub struct IKeyswitchControllerVtbl {
10004 pub base: FUnknownVtbl,
10005 pub getKeyswitchCount: unsafe extern "system" fn(
10006 this: *mut IKeyswitchController,
10007 busIndex: int32,
10008 channel: int16,
10009 ) -> int32,
10010 pub getKeyswitchInfo: unsafe extern "system" fn(
10011 this: *mut IKeyswitchController,
10012 busIndex: int32,
10013 channel: int16,
10014 keySwitchIndex: int32,
10015 info: *mut KeyswitchInfo,
10016 ) -> tresult,
10017 }
10018 pub trait IKeyswitchControllerTrait {
10019 unsafe fn getKeyswitchCount(
10020 &self,
10021 busIndex: int32,
10022 channel: int16,
10023 ) -> int32;
10024 unsafe fn getKeyswitchInfo(
10025 &self,
10026 busIndex: int32,
10027 channel: int16,
10028 keySwitchIndex: int32,
10029 info: *mut KeyswitchInfo,
10030 ) -> tresult;
10031 }
10032 impl<P> IKeyswitchControllerTrait for P
10033 where
10034 P: ::com_scrape_types::SmartPtr,
10035 P::Target: ::com_scrape_types::Inherits<IKeyswitchController>,
10036 {
10037 #[inline]
10038 unsafe fn getKeyswitchCount(
10039 &self,
10040 busIndex: int32,
10041 channel: int16,
10042 ) -> int32 {
10043 let ptr = self.ptr() as *mut IKeyswitchController;
10044 ((*(*ptr).vtbl).getKeyswitchCount)(
10045 ptr,
10046 busIndex,
10047 channel,
10048 )
10049 }
10050 #[inline]
10051 unsafe fn getKeyswitchInfo(
10052 &self,
10053 busIndex: int32,
10054 channel: int16,
10055 keySwitchIndex: int32,
10056 info: *mut KeyswitchInfo,
10057 ) -> tresult {
10058 let ptr = self.ptr() as *mut IKeyswitchController;
10059 ((*(*ptr).vtbl).getKeyswitchInfo)(
10060 ptr,
10061 busIndex,
10062 channel,
10063 keySwitchIndex,
10064 info,
10065 )
10066 }
10067 }
10068 impl IKeyswitchController {
10069 const fn make_vtbl<C, W, const OFFSET: isize>() -> IKeyswitchControllerVtbl
10070 where
10071 C: IKeyswitchControllerTrait + ::com_scrape_types::Class,
10072 W: ::com_scrape_types::Wrapper<C>,
10073 {
10074 unsafe extern "system" fn getKeyswitchCount<C, W, const OFFSET: isize>(
10075 this: *mut IKeyswitchController,
10076 busIndex: int32,
10077 channel: int16,
10078 ) -> int32
10079 where
10080 C: IKeyswitchControllerTrait + ::com_scrape_types::Class,
10081 W: ::com_scrape_types::Wrapper<C>,
10082 {
10083 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
10084 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
10085 (*ptr).getKeyswitchCount(
10086 busIndex,
10087 channel,
10088 )
10089 }
10090 unsafe extern "system" fn getKeyswitchInfo<C, W, const OFFSET: isize>(
10091 this: *mut IKeyswitchController,
10092 busIndex: int32,
10093 channel: int16,
10094 keySwitchIndex: int32,
10095 info: *mut KeyswitchInfo,
10096 ) -> tresult
10097 where
10098 C: IKeyswitchControllerTrait + ::com_scrape_types::Class,
10099 W: ::com_scrape_types::Wrapper<C>,
10100 {
10101 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
10102 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
10103 (*ptr).getKeyswitchInfo(
10104 busIndex,
10105 channel,
10106 keySwitchIndex,
10107 info,
10108 )
10109 }
10110 IKeyswitchControllerVtbl {
10111 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
10112 getKeyswitchCount: getKeyswitchCount::<C, W, OFFSET>,
10113 getKeyswitchInfo: getKeyswitchInfo::<C, W, OFFSET>,
10114 }
10115 }
10116 }
10117 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IKeyswitchController
10118 where
10119 C: IKeyswitchControllerTrait + ::com_scrape_types::Class,
10120 W: ::com_scrape_types::Wrapper<C>,
10121 {
10122 const OBJ: Self = IKeyswitchController {
10123 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
10124 };
10125 }
10126 #[repr(C)]
10127 #[derive(Copy, Clone)]
10128 pub struct IMessage {
10129 pub vtbl: *const IMessageVtbl,
10130 }
10131 unsafe impl Send for IMessage {}
10132 unsafe impl Sync for IMessage {}
10133 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IMessage {}
10134 impl ::com_scrape_types::Unknown for IMessage {
10135 #[inline]
10136 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
10137 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
10138 }
10139 #[inline]
10140 unsafe fn add_ref(this: *mut Self) -> usize {
10141 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
10142 }
10143 #[inline]
10144 unsafe fn release(this: *mut Self) -> usize {
10145 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
10146 }
10147 }
10148 unsafe impl ::com_scrape_types::Interface for IMessage {
10149 type Vtbl = IMessageVtbl;
10150 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IMessage_iid);
10151 #[inline]
10152 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
10153 iid == &Self::IID || FUnknown::inherits(iid)
10154 }
10155 }
10156 #[repr(C)]
10157 #[derive(Copy, Clone)]
10158 pub struct IMessageVtbl {
10159 pub base: FUnknownVtbl,
10160 pub getMessageID: unsafe extern "system" fn(
10161 this: *mut IMessage,
10162 ) -> FIDString,
10163 pub setMessageID: unsafe extern "system" fn(
10164 this: *mut IMessage,
10165 id: FIDString,
10166 ),
10167 pub getAttributes: unsafe extern "system" fn(
10168 this: *mut IMessage,
10169 ) -> *mut IAttributeList,
10170 }
10171 pub trait IMessageTrait {
10172 unsafe fn getMessageID(
10173 &self,
10174 ) -> FIDString;
10175 unsafe fn setMessageID(
10176 &self,
10177 id: FIDString,
10178 );
10179 unsafe fn getAttributes(
10180 &self,
10181 ) -> *mut IAttributeList;
10182 }
10183 impl<P> IMessageTrait for P
10184 where
10185 P: ::com_scrape_types::SmartPtr,
10186 P::Target: ::com_scrape_types::Inherits<IMessage>,
10187 {
10188 #[inline]
10189 unsafe fn getMessageID(
10190 &self,
10191 ) -> FIDString {
10192 let ptr = self.ptr() as *mut IMessage;
10193 ((*(*ptr).vtbl).getMessageID)(
10194 ptr,
10195 )
10196 }
10197 #[inline]
10198 unsafe fn setMessageID(
10199 &self,
10200 id: FIDString,
10201 ) {
10202 let ptr = self.ptr() as *mut IMessage;
10203 ((*(*ptr).vtbl).setMessageID)(
10204 ptr,
10205 id,
10206 )
10207 }
10208 #[inline]
10209 unsafe fn getAttributes(
10210 &self,
10211 ) -> *mut IAttributeList {
10212 let ptr = self.ptr() as *mut IMessage;
10213 ((*(*ptr).vtbl).getAttributes)(
10214 ptr,
10215 )
10216 }
10217 }
10218 impl IMessage {
10219 const fn make_vtbl<C, W, const OFFSET: isize>() -> IMessageVtbl
10220 where
10221 C: IMessageTrait + ::com_scrape_types::Class,
10222 W: ::com_scrape_types::Wrapper<C>,
10223 {
10224 unsafe extern "system" fn getMessageID<C, W, const OFFSET: isize>(
10225 this: *mut IMessage,
10226 ) -> FIDString
10227 where
10228 C: IMessageTrait + ::com_scrape_types::Class,
10229 W: ::com_scrape_types::Wrapper<C>,
10230 {
10231 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
10232 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
10233 (*ptr).getMessageID(
10234 )
10235 }
10236 unsafe extern "system" fn setMessageID<C, W, const OFFSET: isize>(
10237 this: *mut IMessage,
10238 id: FIDString,
10239 )
10240 where
10241 C: IMessageTrait + ::com_scrape_types::Class,
10242 W: ::com_scrape_types::Wrapper<C>,
10243 {
10244 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
10245 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
10246 (*ptr).setMessageID(
10247 id,
10248 )
10249 }
10250 unsafe extern "system" fn getAttributes<C, W, const OFFSET: isize>(
10251 this: *mut IMessage,
10252 ) -> *mut IAttributeList
10253 where
10254 C: IMessageTrait + ::com_scrape_types::Class,
10255 W: ::com_scrape_types::Wrapper<C>,
10256 {
10257 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
10258 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
10259 (*ptr).getAttributes(
10260 )
10261 }
10262 IMessageVtbl {
10263 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
10264 getMessageID: getMessageID::<C, W, OFFSET>,
10265 setMessageID: setMessageID::<C, W, OFFSET>,
10266 getAttributes: getAttributes::<C, W, OFFSET>,
10267 }
10268 }
10269 }
10270 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IMessage
10271 where
10272 C: IMessageTrait + ::com_scrape_types::Class,
10273 W: ::com_scrape_types::Wrapper<C>,
10274 {
10275 const OBJ: Self = IMessage {
10276 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
10277 };
10278 }
10279 #[repr(C)]
10280 #[derive(Copy, Clone)]
10281 pub struct IMidiLearn {
10282 pub vtbl: *const IMidiLearnVtbl,
10283 }
10284 unsafe impl Send for IMidiLearn {}
10285 unsafe impl Sync for IMidiLearn {}
10286 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IMidiLearn {}
10287 impl ::com_scrape_types::Unknown for IMidiLearn {
10288 #[inline]
10289 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
10290 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
10291 }
10292 #[inline]
10293 unsafe fn add_ref(this: *mut Self) -> usize {
10294 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
10295 }
10296 #[inline]
10297 unsafe fn release(this: *mut Self) -> usize {
10298 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
10299 }
10300 }
10301 unsafe impl ::com_scrape_types::Interface for IMidiLearn {
10302 type Vtbl = IMidiLearnVtbl;
10303 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IMidiLearn_iid);
10304 #[inline]
10305 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
10306 iid == &Self::IID || FUnknown::inherits(iid)
10307 }
10308 }
10309 #[repr(C)]
10310 #[derive(Copy, Clone)]
10311 pub struct IMidiLearnVtbl {
10312 pub base: FUnknownVtbl,
10313 pub onLiveMIDIControllerInput: unsafe extern "system" fn(
10314 this: *mut IMidiLearn,
10315 busIndex: int32,
10316 channel: int16,
10317 midiCC: CtrlNumber,
10318 ) -> tresult,
10319 }
10320 pub trait IMidiLearnTrait {
10321 unsafe fn onLiveMIDIControllerInput(
10322 &self,
10323 busIndex: int32,
10324 channel: int16,
10325 midiCC: CtrlNumber,
10326 ) -> tresult;
10327 }
10328 impl<P> IMidiLearnTrait for P
10329 where
10330 P: ::com_scrape_types::SmartPtr,
10331 P::Target: ::com_scrape_types::Inherits<IMidiLearn>,
10332 {
10333 #[inline]
10334 unsafe fn onLiveMIDIControllerInput(
10335 &self,
10336 busIndex: int32,
10337 channel: int16,
10338 midiCC: CtrlNumber,
10339 ) -> tresult {
10340 let ptr = self.ptr() as *mut IMidiLearn;
10341 ((*(*ptr).vtbl).onLiveMIDIControllerInput)(
10342 ptr,
10343 busIndex,
10344 channel,
10345 midiCC,
10346 )
10347 }
10348 }
10349 impl IMidiLearn {
10350 const fn make_vtbl<C, W, const OFFSET: isize>() -> IMidiLearnVtbl
10351 where
10352 C: IMidiLearnTrait + ::com_scrape_types::Class,
10353 W: ::com_scrape_types::Wrapper<C>,
10354 {
10355 unsafe extern "system" fn onLiveMIDIControllerInput<C, W, const OFFSET: isize>(
10356 this: *mut IMidiLearn,
10357 busIndex: int32,
10358 channel: int16,
10359 midiCC: CtrlNumber,
10360 ) -> tresult
10361 where
10362 C: IMidiLearnTrait + ::com_scrape_types::Class,
10363 W: ::com_scrape_types::Wrapper<C>,
10364 {
10365 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
10366 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
10367 (*ptr).onLiveMIDIControllerInput(
10368 busIndex,
10369 channel,
10370 midiCC,
10371 )
10372 }
10373 IMidiLearnVtbl {
10374 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
10375 onLiveMIDIControllerInput: onLiveMIDIControllerInput::<C, W, OFFSET>,
10376 }
10377 }
10378 }
10379 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IMidiLearn
10380 where
10381 C: IMidiLearnTrait + ::com_scrape_types::Class,
10382 W: ::com_scrape_types::Wrapper<C>,
10383 {
10384 const OBJ: Self = IMidiLearn {
10385 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
10386 };
10387 }
10388 #[repr(C)]
10389 #[derive(Copy, Clone)]
10390 pub struct IMidiLearn2 {
10391 pub vtbl: *const IMidiLearn2Vtbl,
10392 }
10393 unsafe impl Send for IMidiLearn2 {}
10394 unsafe impl Sync for IMidiLearn2 {}
10395 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IMidiLearn2 {}
10396 impl ::com_scrape_types::Unknown for IMidiLearn2 {
10397 #[inline]
10398 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
10399 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
10400 }
10401 #[inline]
10402 unsafe fn add_ref(this: *mut Self) -> usize {
10403 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
10404 }
10405 #[inline]
10406 unsafe fn release(this: *mut Self) -> usize {
10407 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
10408 }
10409 }
10410 unsafe impl ::com_scrape_types::Interface for IMidiLearn2 {
10411 type Vtbl = IMidiLearn2Vtbl;
10412 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IMidiLearn2_iid);
10413 #[inline]
10414 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
10415 iid == &Self::IID || FUnknown::inherits(iid)
10416 }
10417 }
10418 #[repr(C)]
10419 #[derive(Copy, Clone)]
10420 pub struct IMidiLearn2Vtbl {
10421 pub base: FUnknownVtbl,
10422 pub onLiveMidi2ControllerInput: unsafe extern "system" fn(
10423 this: *mut IMidiLearn2,
10424 index: BusIndex,
10425 channel: MidiChannel,
10426 midiCC: Midi2Controller,
10427 ) -> tresult,
10428 pub onLiveMidi1ControllerInput: unsafe extern "system" fn(
10429 this: *mut IMidiLearn2,
10430 index: BusIndex,
10431 channel: MidiChannel,
10432 midiCC: CtrlNumber,
10433 ) -> tresult,
10434 }
10435 pub trait IMidiLearn2Trait {
10436 unsafe fn onLiveMidi2ControllerInput(
10437 &self,
10438 index: BusIndex,
10439 channel: MidiChannel,
10440 midiCC: Midi2Controller,
10441 ) -> tresult;
10442 unsafe fn onLiveMidi1ControllerInput(
10443 &self,
10444 index: BusIndex,
10445 channel: MidiChannel,
10446 midiCC: CtrlNumber,
10447 ) -> tresult;
10448 }
10449 impl<P> IMidiLearn2Trait for P
10450 where
10451 P: ::com_scrape_types::SmartPtr,
10452 P::Target: ::com_scrape_types::Inherits<IMidiLearn2>,
10453 {
10454 #[inline]
10455 unsafe fn onLiveMidi2ControllerInput(
10456 &self,
10457 index: BusIndex,
10458 channel: MidiChannel,
10459 midiCC: Midi2Controller,
10460 ) -> tresult {
10461 let ptr = self.ptr() as *mut IMidiLearn2;
10462 ((*(*ptr).vtbl).onLiveMidi2ControllerInput)(
10463 ptr,
10464 index,
10465 channel,
10466 midiCC,
10467 )
10468 }
10469 #[inline]
10470 unsafe fn onLiveMidi1ControllerInput(
10471 &self,
10472 index: BusIndex,
10473 channel: MidiChannel,
10474 midiCC: CtrlNumber,
10475 ) -> tresult {
10476 let ptr = self.ptr() as *mut IMidiLearn2;
10477 ((*(*ptr).vtbl).onLiveMidi1ControllerInput)(
10478 ptr,
10479 index,
10480 channel,
10481 midiCC,
10482 )
10483 }
10484 }
10485 impl IMidiLearn2 {
10486 const fn make_vtbl<C, W, const OFFSET: isize>() -> IMidiLearn2Vtbl
10487 where
10488 C: IMidiLearn2Trait + ::com_scrape_types::Class,
10489 W: ::com_scrape_types::Wrapper<C>,
10490 {
10491 unsafe extern "system" fn onLiveMidi2ControllerInput<C, W, const OFFSET: isize>(
10492 this: *mut IMidiLearn2,
10493 index: BusIndex,
10494 channel: MidiChannel,
10495 midiCC: Midi2Controller,
10496 ) -> tresult
10497 where
10498 C: IMidiLearn2Trait + ::com_scrape_types::Class,
10499 W: ::com_scrape_types::Wrapper<C>,
10500 {
10501 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
10502 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
10503 (*ptr).onLiveMidi2ControllerInput(
10504 index,
10505 channel,
10506 midiCC,
10507 )
10508 }
10509 unsafe extern "system" fn onLiveMidi1ControllerInput<C, W, const OFFSET: isize>(
10510 this: *mut IMidiLearn2,
10511 index: BusIndex,
10512 channel: MidiChannel,
10513 midiCC: CtrlNumber,
10514 ) -> tresult
10515 where
10516 C: IMidiLearn2Trait + ::com_scrape_types::Class,
10517 W: ::com_scrape_types::Wrapper<C>,
10518 {
10519 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
10520 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
10521 (*ptr).onLiveMidi1ControllerInput(
10522 index,
10523 channel,
10524 midiCC,
10525 )
10526 }
10527 IMidiLearn2Vtbl {
10528 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
10529 onLiveMidi2ControllerInput: onLiveMidi2ControllerInput::<C, W, OFFSET>,
10530 onLiveMidi1ControllerInput: onLiveMidi1ControllerInput::<C, W, OFFSET>,
10531 }
10532 }
10533 }
10534 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IMidiLearn2
10535 where
10536 C: IMidiLearn2Trait + ::com_scrape_types::Class,
10537 W: ::com_scrape_types::Wrapper<C>,
10538 {
10539 const OBJ: Self = IMidiLearn2 {
10540 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
10541 };
10542 }
10543 #[repr(C)]
10544 #[derive(Copy, Clone)]
10545 pub struct IMidiMapping {
10546 pub vtbl: *const IMidiMappingVtbl,
10547 }
10548 unsafe impl Send for IMidiMapping {}
10549 unsafe impl Sync for IMidiMapping {}
10550 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IMidiMapping {}
10551 impl ::com_scrape_types::Unknown for IMidiMapping {
10552 #[inline]
10553 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
10554 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
10555 }
10556 #[inline]
10557 unsafe fn add_ref(this: *mut Self) -> usize {
10558 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
10559 }
10560 #[inline]
10561 unsafe fn release(this: *mut Self) -> usize {
10562 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
10563 }
10564 }
10565 unsafe impl ::com_scrape_types::Interface for IMidiMapping {
10566 type Vtbl = IMidiMappingVtbl;
10567 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IMidiMapping_iid);
10568 #[inline]
10569 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
10570 iid == &Self::IID || FUnknown::inherits(iid)
10571 }
10572 }
10573 #[repr(C)]
10574 #[derive(Copy, Clone)]
10575 pub struct IMidiMappingVtbl {
10576 pub base: FUnknownVtbl,
10577 pub getMidiControllerAssignment: unsafe extern "system" fn(
10578 this: *mut IMidiMapping,
10579 busIndex: int32,
10580 channel: int16,
10581 midiControllerNumber: CtrlNumber,
10582 id: *mut ParamID,
10583 ) -> tresult,
10584 }
10585 pub trait IMidiMappingTrait {
10586 unsafe fn getMidiControllerAssignment(
10587 &self,
10588 busIndex: int32,
10589 channel: int16,
10590 midiControllerNumber: CtrlNumber,
10591 id: *mut ParamID,
10592 ) -> tresult;
10593 }
10594 impl<P> IMidiMappingTrait for P
10595 where
10596 P: ::com_scrape_types::SmartPtr,
10597 P::Target: ::com_scrape_types::Inherits<IMidiMapping>,
10598 {
10599 #[inline]
10600 unsafe fn getMidiControllerAssignment(
10601 &self,
10602 busIndex: int32,
10603 channel: int16,
10604 midiControllerNumber: CtrlNumber,
10605 id: *mut ParamID,
10606 ) -> tresult {
10607 let ptr = self.ptr() as *mut IMidiMapping;
10608 ((*(*ptr).vtbl).getMidiControllerAssignment)(
10609 ptr,
10610 busIndex,
10611 channel,
10612 midiControllerNumber,
10613 id,
10614 )
10615 }
10616 }
10617 impl IMidiMapping {
10618 const fn make_vtbl<C, W, const OFFSET: isize>() -> IMidiMappingVtbl
10619 where
10620 C: IMidiMappingTrait + ::com_scrape_types::Class,
10621 W: ::com_scrape_types::Wrapper<C>,
10622 {
10623 unsafe extern "system" fn getMidiControllerAssignment<C, W, const OFFSET: isize>(
10624 this: *mut IMidiMapping,
10625 busIndex: int32,
10626 channel: int16,
10627 midiControllerNumber: CtrlNumber,
10628 id: *mut ParamID,
10629 ) -> tresult
10630 where
10631 C: IMidiMappingTrait + ::com_scrape_types::Class,
10632 W: ::com_scrape_types::Wrapper<C>,
10633 {
10634 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
10635 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
10636 (*ptr).getMidiControllerAssignment(
10637 busIndex,
10638 channel,
10639 midiControllerNumber,
10640 id,
10641 )
10642 }
10643 IMidiMappingVtbl {
10644 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
10645 getMidiControllerAssignment: getMidiControllerAssignment::<C, W, OFFSET>,
10646 }
10647 }
10648 }
10649 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IMidiMapping
10650 where
10651 C: IMidiMappingTrait + ::com_scrape_types::Class,
10652 W: ::com_scrape_types::Wrapper<C>,
10653 {
10654 const OBJ: Self = IMidiMapping {
10655 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
10656 };
10657 }
10658 #[repr(C)]
10659 #[derive(Copy, Clone)]
10660 pub struct IMidiMapping2 {
10661 pub vtbl: *const IMidiMapping2Vtbl,
10662 }
10663 unsafe impl Send for IMidiMapping2 {}
10664 unsafe impl Sync for IMidiMapping2 {}
10665 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IMidiMapping2 {}
10666 impl ::com_scrape_types::Unknown for IMidiMapping2 {
10667 #[inline]
10668 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
10669 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
10670 }
10671 #[inline]
10672 unsafe fn add_ref(this: *mut Self) -> usize {
10673 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
10674 }
10675 #[inline]
10676 unsafe fn release(this: *mut Self) -> usize {
10677 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
10678 }
10679 }
10680 unsafe impl ::com_scrape_types::Interface for IMidiMapping2 {
10681 type Vtbl = IMidiMapping2Vtbl;
10682 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IMidiMapping2_iid);
10683 #[inline]
10684 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
10685 iid == &Self::IID || FUnknown::inherits(iid)
10686 }
10687 }
10688 #[repr(C)]
10689 #[derive(Copy, Clone)]
10690 pub struct IMidiMapping2Vtbl {
10691 pub base: FUnknownVtbl,
10692 pub getNumMidi2ControllerAssignments: unsafe extern "system" fn(
10693 this: *mut IMidiMapping2,
10694 direction: BusDirections,
10695 ) -> uint32,
10696 pub getMidi2ControllerAssignments: unsafe extern "system" fn(
10697 this: *mut IMidiMapping2,
10698 direction: BusDirections,
10699 list: *const Midi2ControllerParamIDAssignmentList,
10700 ) -> tresult,
10701 pub getNumMidi1ControllerAssignments: unsafe extern "system" fn(
10702 this: *mut IMidiMapping2,
10703 direction: BusDirections,
10704 ) -> uint32,
10705 pub getMidi1ControllerAssignments: unsafe extern "system" fn(
10706 this: *mut IMidiMapping2,
10707 direction: BusDirections,
10708 list: *const Midi1ControllerParamIDAssignmentList,
10709 ) -> tresult,
10710 }
10711 pub trait IMidiMapping2Trait {
10712 unsafe fn getNumMidi2ControllerAssignments(
10713 &self,
10714 direction: BusDirections,
10715 ) -> uint32;
10716 unsafe fn getMidi2ControllerAssignments(
10717 &self,
10718 direction: BusDirections,
10719 list: *const Midi2ControllerParamIDAssignmentList,
10720 ) -> tresult;
10721 unsafe fn getNumMidi1ControllerAssignments(
10722 &self,
10723 direction: BusDirections,
10724 ) -> uint32;
10725 unsafe fn getMidi1ControllerAssignments(
10726 &self,
10727 direction: BusDirections,
10728 list: *const Midi1ControllerParamIDAssignmentList,
10729 ) -> tresult;
10730 }
10731 impl<P> IMidiMapping2Trait for P
10732 where
10733 P: ::com_scrape_types::SmartPtr,
10734 P::Target: ::com_scrape_types::Inherits<IMidiMapping2>,
10735 {
10736 #[inline]
10737 unsafe fn getNumMidi2ControllerAssignments(
10738 &self,
10739 direction: BusDirections,
10740 ) -> uint32 {
10741 let ptr = self.ptr() as *mut IMidiMapping2;
10742 ((*(*ptr).vtbl).getNumMidi2ControllerAssignments)(
10743 ptr,
10744 direction,
10745 )
10746 }
10747 #[inline]
10748 unsafe fn getMidi2ControllerAssignments(
10749 &self,
10750 direction: BusDirections,
10751 list: *const Midi2ControllerParamIDAssignmentList,
10752 ) -> tresult {
10753 let ptr = self.ptr() as *mut IMidiMapping2;
10754 ((*(*ptr).vtbl).getMidi2ControllerAssignments)(
10755 ptr,
10756 direction,
10757 list,
10758 )
10759 }
10760 #[inline]
10761 unsafe fn getNumMidi1ControllerAssignments(
10762 &self,
10763 direction: BusDirections,
10764 ) -> uint32 {
10765 let ptr = self.ptr() as *mut IMidiMapping2;
10766 ((*(*ptr).vtbl).getNumMidi1ControllerAssignments)(
10767 ptr,
10768 direction,
10769 )
10770 }
10771 #[inline]
10772 unsafe fn getMidi1ControllerAssignments(
10773 &self,
10774 direction: BusDirections,
10775 list: *const Midi1ControllerParamIDAssignmentList,
10776 ) -> tresult {
10777 let ptr = self.ptr() as *mut IMidiMapping2;
10778 ((*(*ptr).vtbl).getMidi1ControllerAssignments)(
10779 ptr,
10780 direction,
10781 list,
10782 )
10783 }
10784 }
10785 impl IMidiMapping2 {
10786 const fn make_vtbl<C, W, const OFFSET: isize>() -> IMidiMapping2Vtbl
10787 where
10788 C: IMidiMapping2Trait + ::com_scrape_types::Class,
10789 W: ::com_scrape_types::Wrapper<C>,
10790 {
10791 unsafe extern "system" fn getNumMidi2ControllerAssignments<C, W, const OFFSET: isize>(
10792 this: *mut IMidiMapping2,
10793 direction: BusDirections,
10794 ) -> uint32
10795 where
10796 C: IMidiMapping2Trait + ::com_scrape_types::Class,
10797 W: ::com_scrape_types::Wrapper<C>,
10798 {
10799 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
10800 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
10801 (*ptr).getNumMidi2ControllerAssignments(
10802 direction,
10803 )
10804 }
10805 unsafe extern "system" fn getMidi2ControllerAssignments<C, W, const OFFSET: isize>(
10806 this: *mut IMidiMapping2,
10807 direction: BusDirections,
10808 list: *const Midi2ControllerParamIDAssignmentList,
10809 ) -> tresult
10810 where
10811 C: IMidiMapping2Trait + ::com_scrape_types::Class,
10812 W: ::com_scrape_types::Wrapper<C>,
10813 {
10814 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
10815 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
10816 (*ptr).getMidi2ControllerAssignments(
10817 direction,
10818 list,
10819 )
10820 }
10821 unsafe extern "system" fn getNumMidi1ControllerAssignments<C, W, const OFFSET: isize>(
10822 this: *mut IMidiMapping2,
10823 direction: BusDirections,
10824 ) -> uint32
10825 where
10826 C: IMidiMapping2Trait + ::com_scrape_types::Class,
10827 W: ::com_scrape_types::Wrapper<C>,
10828 {
10829 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
10830 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
10831 (*ptr).getNumMidi1ControllerAssignments(
10832 direction,
10833 )
10834 }
10835 unsafe extern "system" fn getMidi1ControllerAssignments<C, W, const OFFSET: isize>(
10836 this: *mut IMidiMapping2,
10837 direction: BusDirections,
10838 list: *const Midi1ControllerParamIDAssignmentList,
10839 ) -> tresult
10840 where
10841 C: IMidiMapping2Trait + ::com_scrape_types::Class,
10842 W: ::com_scrape_types::Wrapper<C>,
10843 {
10844 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
10845 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
10846 (*ptr).getMidi1ControllerAssignments(
10847 direction,
10848 list,
10849 )
10850 }
10851 IMidiMapping2Vtbl {
10852 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
10853 getNumMidi2ControllerAssignments: getNumMidi2ControllerAssignments::<C, W, OFFSET>,
10854 getMidi2ControllerAssignments: getMidi2ControllerAssignments::<C, W, OFFSET>,
10855 getNumMidi1ControllerAssignments: getNumMidi1ControllerAssignments::<C, W, OFFSET>,
10856 getMidi1ControllerAssignments: getMidi1ControllerAssignments::<C, W, OFFSET>,
10857 }
10858 }
10859 }
10860 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IMidiMapping2
10861 where
10862 C: IMidiMapping2Trait + ::com_scrape_types::Class,
10863 W: ::com_scrape_types::Wrapper<C>,
10864 {
10865 const OBJ: Self = IMidiMapping2 {
10866 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
10867 };
10868 }
10869 #[repr(C)]
10870 #[derive(Copy, Clone)]
10871 pub struct INoteExpressionController {
10872 pub vtbl: *const INoteExpressionControllerVtbl,
10873 }
10874 unsafe impl Send for INoteExpressionController {}
10875 unsafe impl Sync for INoteExpressionController {}
10876 unsafe impl ::com_scrape_types::Inherits<FUnknown> for INoteExpressionController {}
10877 impl ::com_scrape_types::Unknown for INoteExpressionController {
10878 #[inline]
10879 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
10880 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
10881 }
10882 #[inline]
10883 unsafe fn add_ref(this: *mut Self) -> usize {
10884 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
10885 }
10886 #[inline]
10887 unsafe fn release(this: *mut Self) -> usize {
10888 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
10889 }
10890 }
10891 unsafe impl ::com_scrape_types::Interface for INoteExpressionController {
10892 type Vtbl = INoteExpressionControllerVtbl;
10893 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(INoteExpressionController_iid);
10894 #[inline]
10895 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
10896 iid == &Self::IID || FUnknown::inherits(iid)
10897 }
10898 }
10899 #[repr(C)]
10900 #[derive(Copy, Clone)]
10901 pub struct INoteExpressionControllerVtbl {
10902 pub base: FUnknownVtbl,
10903 pub getNoteExpressionCount: unsafe extern "system" fn(
10904 this: *mut INoteExpressionController,
10905 busIndex: int32,
10906 channel: int16,
10907 ) -> int32,
10908 pub getNoteExpressionInfo: unsafe extern "system" fn(
10909 this: *mut INoteExpressionController,
10910 busIndex: int32,
10911 channel: int16,
10912 noteExpressionIndex: int32,
10913 info: *mut NoteExpressionTypeInfo,
10914 ) -> tresult,
10915 pub getNoteExpressionStringByValue: unsafe extern "system" fn(
10916 this: *mut INoteExpressionController,
10917 busIndex: int32,
10918 channel: int16,
10919 id: NoteExpressionTypeID,
10920 valueNormalized: NoteExpressionValue,
10921 string: *mut String128,
10922 ) -> tresult,
10923 pub getNoteExpressionValueByString: unsafe extern "system" fn(
10924 this: *mut INoteExpressionController,
10925 busIndex: int32,
10926 channel: int16,
10927 id: NoteExpressionTypeID,
10928 string: *const TChar,
10929 valueNormalized: *mut NoteExpressionValue,
10930 ) -> tresult,
10931 }
10932 pub trait INoteExpressionControllerTrait {
10933 unsafe fn getNoteExpressionCount(
10934 &self,
10935 busIndex: int32,
10936 channel: int16,
10937 ) -> int32;
10938 unsafe fn getNoteExpressionInfo(
10939 &self,
10940 busIndex: int32,
10941 channel: int16,
10942 noteExpressionIndex: int32,
10943 info: *mut NoteExpressionTypeInfo,
10944 ) -> tresult;
10945 unsafe fn getNoteExpressionStringByValue(
10946 &self,
10947 busIndex: int32,
10948 channel: int16,
10949 id: NoteExpressionTypeID,
10950 valueNormalized: NoteExpressionValue,
10951 string: *mut String128,
10952 ) -> tresult;
10953 unsafe fn getNoteExpressionValueByString(
10954 &self,
10955 busIndex: int32,
10956 channel: int16,
10957 id: NoteExpressionTypeID,
10958 string: *const TChar,
10959 valueNormalized: *mut NoteExpressionValue,
10960 ) -> tresult;
10961 }
10962 impl<P> INoteExpressionControllerTrait for P
10963 where
10964 P: ::com_scrape_types::SmartPtr,
10965 P::Target: ::com_scrape_types::Inherits<INoteExpressionController>,
10966 {
10967 #[inline]
10968 unsafe fn getNoteExpressionCount(
10969 &self,
10970 busIndex: int32,
10971 channel: int16,
10972 ) -> int32 {
10973 let ptr = self.ptr() as *mut INoteExpressionController;
10974 ((*(*ptr).vtbl).getNoteExpressionCount)(
10975 ptr,
10976 busIndex,
10977 channel,
10978 )
10979 }
10980 #[inline]
10981 unsafe fn getNoteExpressionInfo(
10982 &self,
10983 busIndex: int32,
10984 channel: int16,
10985 noteExpressionIndex: int32,
10986 info: *mut NoteExpressionTypeInfo,
10987 ) -> tresult {
10988 let ptr = self.ptr() as *mut INoteExpressionController;
10989 ((*(*ptr).vtbl).getNoteExpressionInfo)(
10990 ptr,
10991 busIndex,
10992 channel,
10993 noteExpressionIndex,
10994 info,
10995 )
10996 }
10997 #[inline]
10998 unsafe fn getNoteExpressionStringByValue(
10999 &self,
11000 busIndex: int32,
11001 channel: int16,
11002 id: NoteExpressionTypeID,
11003 valueNormalized: NoteExpressionValue,
11004 string: *mut String128,
11005 ) -> tresult {
11006 let ptr = self.ptr() as *mut INoteExpressionController;
11007 ((*(*ptr).vtbl).getNoteExpressionStringByValue)(
11008 ptr,
11009 busIndex,
11010 channel,
11011 id,
11012 valueNormalized,
11013 string,
11014 )
11015 }
11016 #[inline]
11017 unsafe fn getNoteExpressionValueByString(
11018 &self,
11019 busIndex: int32,
11020 channel: int16,
11021 id: NoteExpressionTypeID,
11022 string: *const TChar,
11023 valueNormalized: *mut NoteExpressionValue,
11024 ) -> tresult {
11025 let ptr = self.ptr() as *mut INoteExpressionController;
11026 ((*(*ptr).vtbl).getNoteExpressionValueByString)(
11027 ptr,
11028 busIndex,
11029 channel,
11030 id,
11031 string,
11032 valueNormalized,
11033 )
11034 }
11035 }
11036 impl INoteExpressionController {
11037 const fn make_vtbl<C, W, const OFFSET: isize>() -> INoteExpressionControllerVtbl
11038 where
11039 C: INoteExpressionControllerTrait + ::com_scrape_types::Class,
11040 W: ::com_scrape_types::Wrapper<C>,
11041 {
11042 unsafe extern "system" fn getNoteExpressionCount<C, W, const OFFSET: isize>(
11043 this: *mut INoteExpressionController,
11044 busIndex: int32,
11045 channel: int16,
11046 ) -> int32
11047 where
11048 C: INoteExpressionControllerTrait + ::com_scrape_types::Class,
11049 W: ::com_scrape_types::Wrapper<C>,
11050 {
11051 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
11052 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
11053 (*ptr).getNoteExpressionCount(
11054 busIndex,
11055 channel,
11056 )
11057 }
11058 unsafe extern "system" fn getNoteExpressionInfo<C, W, const OFFSET: isize>(
11059 this: *mut INoteExpressionController,
11060 busIndex: int32,
11061 channel: int16,
11062 noteExpressionIndex: int32,
11063 info: *mut NoteExpressionTypeInfo,
11064 ) -> tresult
11065 where
11066 C: INoteExpressionControllerTrait + ::com_scrape_types::Class,
11067 W: ::com_scrape_types::Wrapper<C>,
11068 {
11069 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
11070 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
11071 (*ptr).getNoteExpressionInfo(
11072 busIndex,
11073 channel,
11074 noteExpressionIndex,
11075 info,
11076 )
11077 }
11078 unsafe extern "system" fn getNoteExpressionStringByValue<C, W, const OFFSET: isize>(
11079 this: *mut INoteExpressionController,
11080 busIndex: int32,
11081 channel: int16,
11082 id: NoteExpressionTypeID,
11083 valueNormalized: NoteExpressionValue,
11084 string: *mut String128,
11085 ) -> tresult
11086 where
11087 C: INoteExpressionControllerTrait + ::com_scrape_types::Class,
11088 W: ::com_scrape_types::Wrapper<C>,
11089 {
11090 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
11091 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
11092 (*ptr).getNoteExpressionStringByValue(
11093 busIndex,
11094 channel,
11095 id,
11096 valueNormalized,
11097 string,
11098 )
11099 }
11100 unsafe extern "system" fn getNoteExpressionValueByString<C, W, const OFFSET: isize>(
11101 this: *mut INoteExpressionController,
11102 busIndex: int32,
11103 channel: int16,
11104 id: NoteExpressionTypeID,
11105 string: *const TChar,
11106 valueNormalized: *mut NoteExpressionValue,
11107 ) -> tresult
11108 where
11109 C: INoteExpressionControllerTrait + ::com_scrape_types::Class,
11110 W: ::com_scrape_types::Wrapper<C>,
11111 {
11112 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
11113 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
11114 (*ptr).getNoteExpressionValueByString(
11115 busIndex,
11116 channel,
11117 id,
11118 string,
11119 valueNormalized,
11120 )
11121 }
11122 INoteExpressionControllerVtbl {
11123 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
11124 getNoteExpressionCount: getNoteExpressionCount::<C, W, OFFSET>,
11125 getNoteExpressionInfo: getNoteExpressionInfo::<C, W, OFFSET>,
11126 getNoteExpressionStringByValue: getNoteExpressionStringByValue::<C, W, OFFSET>,
11127 getNoteExpressionValueByString: getNoteExpressionValueByString::<C, W, OFFSET>,
11128 }
11129 }
11130 }
11131 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for INoteExpressionController
11132 where
11133 C: INoteExpressionControllerTrait + ::com_scrape_types::Class,
11134 W: ::com_scrape_types::Wrapper<C>,
11135 {
11136 const OBJ: Self = INoteExpressionController {
11137 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
11138 };
11139 }
11140 #[repr(C)]
11141 #[derive(Copy, Clone)]
11142 pub struct INoteExpressionPhysicalUIMapping {
11143 pub vtbl: *const INoteExpressionPhysicalUIMappingVtbl,
11144 }
11145 unsafe impl Send for INoteExpressionPhysicalUIMapping {}
11146 unsafe impl Sync for INoteExpressionPhysicalUIMapping {}
11147 unsafe impl ::com_scrape_types::Inherits<FUnknown> for INoteExpressionPhysicalUIMapping {}
11148 impl ::com_scrape_types::Unknown for INoteExpressionPhysicalUIMapping {
11149 #[inline]
11150 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
11151 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
11152 }
11153 #[inline]
11154 unsafe fn add_ref(this: *mut Self) -> usize {
11155 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
11156 }
11157 #[inline]
11158 unsafe fn release(this: *mut Self) -> usize {
11159 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
11160 }
11161 }
11162 unsafe impl ::com_scrape_types::Interface for INoteExpressionPhysicalUIMapping {
11163 type Vtbl = INoteExpressionPhysicalUIMappingVtbl;
11164 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(INoteExpressionPhysicalUIMapping_iid);
11165 #[inline]
11166 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
11167 iid == &Self::IID || FUnknown::inherits(iid)
11168 }
11169 }
11170 #[repr(C)]
11171 #[derive(Copy, Clone)]
11172 pub struct INoteExpressionPhysicalUIMappingVtbl {
11173 pub base: FUnknownVtbl,
11174 pub getPhysicalUIMapping: unsafe extern "system" fn(
11175 this: *mut INoteExpressionPhysicalUIMapping,
11176 busIndex: int32,
11177 channel: int16,
11178 list: *mut PhysicalUIMapList,
11179 ) -> tresult,
11180 }
11181 pub trait INoteExpressionPhysicalUIMappingTrait {
11182 unsafe fn getPhysicalUIMapping(
11183 &self,
11184 busIndex: int32,
11185 channel: int16,
11186 list: *mut PhysicalUIMapList,
11187 ) -> tresult;
11188 }
11189 impl<P> INoteExpressionPhysicalUIMappingTrait for P
11190 where
11191 P: ::com_scrape_types::SmartPtr,
11192 P::Target: ::com_scrape_types::Inherits<INoteExpressionPhysicalUIMapping>,
11193 {
11194 #[inline]
11195 unsafe fn getPhysicalUIMapping(
11196 &self,
11197 busIndex: int32,
11198 channel: int16,
11199 list: *mut PhysicalUIMapList,
11200 ) -> tresult {
11201 let ptr = self.ptr() as *mut INoteExpressionPhysicalUIMapping;
11202 ((*(*ptr).vtbl).getPhysicalUIMapping)(
11203 ptr,
11204 busIndex,
11205 channel,
11206 list,
11207 )
11208 }
11209 }
11210 impl INoteExpressionPhysicalUIMapping {
11211 const fn make_vtbl<C, W, const OFFSET: isize>() -> INoteExpressionPhysicalUIMappingVtbl
11212 where
11213 C: INoteExpressionPhysicalUIMappingTrait + ::com_scrape_types::Class,
11214 W: ::com_scrape_types::Wrapper<C>,
11215 {
11216 unsafe extern "system" fn getPhysicalUIMapping<C, W, const OFFSET: isize>(
11217 this: *mut INoteExpressionPhysicalUIMapping,
11218 busIndex: int32,
11219 channel: int16,
11220 list: *mut PhysicalUIMapList,
11221 ) -> tresult
11222 where
11223 C: INoteExpressionPhysicalUIMappingTrait + ::com_scrape_types::Class,
11224 W: ::com_scrape_types::Wrapper<C>,
11225 {
11226 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
11227 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
11228 (*ptr).getPhysicalUIMapping(
11229 busIndex,
11230 channel,
11231 list,
11232 )
11233 }
11234 INoteExpressionPhysicalUIMappingVtbl {
11235 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
11236 getPhysicalUIMapping: getPhysicalUIMapping::<C, W, OFFSET>,
11237 }
11238 }
11239 }
11240 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for INoteExpressionPhysicalUIMapping
11241 where
11242 C: INoteExpressionPhysicalUIMappingTrait + ::com_scrape_types::Class,
11243 W: ::com_scrape_types::Wrapper<C>,
11244 {
11245 const OBJ: Self = INoteExpressionPhysicalUIMapping {
11246 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
11247 };
11248 }
11249 #[repr(C)]
11250 #[derive(Copy, Clone)]
11251 pub struct IParamValueQueue {
11252 pub vtbl: *const IParamValueQueueVtbl,
11253 }
11254 unsafe impl Send for IParamValueQueue {}
11255 unsafe impl Sync for IParamValueQueue {}
11256 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IParamValueQueue {}
11257 impl ::com_scrape_types::Unknown for IParamValueQueue {
11258 #[inline]
11259 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
11260 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
11261 }
11262 #[inline]
11263 unsafe fn add_ref(this: *mut Self) -> usize {
11264 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
11265 }
11266 #[inline]
11267 unsafe fn release(this: *mut Self) -> usize {
11268 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
11269 }
11270 }
11271 unsafe impl ::com_scrape_types::Interface for IParamValueQueue {
11272 type Vtbl = IParamValueQueueVtbl;
11273 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IParamValueQueue_iid);
11274 #[inline]
11275 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
11276 iid == &Self::IID || FUnknown::inherits(iid)
11277 }
11278 }
11279 #[repr(C)]
11280 #[derive(Copy, Clone)]
11281 pub struct IParamValueQueueVtbl {
11282 pub base: FUnknownVtbl,
11283 pub getParameterId: unsafe extern "system" fn(
11284 this: *mut IParamValueQueue,
11285 ) -> ParamID,
11286 pub getPointCount: unsafe extern "system" fn(
11287 this: *mut IParamValueQueue,
11288 ) -> int32,
11289 pub getPoint: unsafe extern "system" fn(
11290 this: *mut IParamValueQueue,
11291 index: int32,
11292 sampleOffset: *mut int32,
11293 value: *mut ParamValue,
11294 ) -> tresult,
11295 pub addPoint: unsafe extern "system" fn(
11296 this: *mut IParamValueQueue,
11297 sampleOffset: int32,
11298 value: ParamValue,
11299 index: *mut int32,
11300 ) -> tresult,
11301 }
11302 pub trait IParamValueQueueTrait {
11303 unsafe fn getParameterId(
11304 &self,
11305 ) -> ParamID;
11306 unsafe fn getPointCount(
11307 &self,
11308 ) -> int32;
11309 unsafe fn getPoint(
11310 &self,
11311 index: int32,
11312 sampleOffset: *mut int32,
11313 value: *mut ParamValue,
11314 ) -> tresult;
11315 unsafe fn addPoint(
11316 &self,
11317 sampleOffset: int32,
11318 value: ParamValue,
11319 index: *mut int32,
11320 ) -> tresult;
11321 }
11322 impl<P> IParamValueQueueTrait for P
11323 where
11324 P: ::com_scrape_types::SmartPtr,
11325 P::Target: ::com_scrape_types::Inherits<IParamValueQueue>,
11326 {
11327 #[inline]
11328 unsafe fn getParameterId(
11329 &self,
11330 ) -> ParamID {
11331 let ptr = self.ptr() as *mut IParamValueQueue;
11332 ((*(*ptr).vtbl).getParameterId)(
11333 ptr,
11334 )
11335 }
11336 #[inline]
11337 unsafe fn getPointCount(
11338 &self,
11339 ) -> int32 {
11340 let ptr = self.ptr() as *mut IParamValueQueue;
11341 ((*(*ptr).vtbl).getPointCount)(
11342 ptr,
11343 )
11344 }
11345 #[inline]
11346 unsafe fn getPoint(
11347 &self,
11348 index: int32,
11349 sampleOffset: *mut int32,
11350 value: *mut ParamValue,
11351 ) -> tresult {
11352 let ptr = self.ptr() as *mut IParamValueQueue;
11353 ((*(*ptr).vtbl).getPoint)(
11354 ptr,
11355 index,
11356 sampleOffset,
11357 value,
11358 )
11359 }
11360 #[inline]
11361 unsafe fn addPoint(
11362 &self,
11363 sampleOffset: int32,
11364 value: ParamValue,
11365 index: *mut int32,
11366 ) -> tresult {
11367 let ptr = self.ptr() as *mut IParamValueQueue;
11368 ((*(*ptr).vtbl).addPoint)(
11369 ptr,
11370 sampleOffset,
11371 value,
11372 index,
11373 )
11374 }
11375 }
11376 impl IParamValueQueue {
11377 const fn make_vtbl<C, W, const OFFSET: isize>() -> IParamValueQueueVtbl
11378 where
11379 C: IParamValueQueueTrait + ::com_scrape_types::Class,
11380 W: ::com_scrape_types::Wrapper<C>,
11381 {
11382 unsafe extern "system" fn getParameterId<C, W, const OFFSET: isize>(
11383 this: *mut IParamValueQueue,
11384 ) -> ParamID
11385 where
11386 C: IParamValueQueueTrait + ::com_scrape_types::Class,
11387 W: ::com_scrape_types::Wrapper<C>,
11388 {
11389 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
11390 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
11391 (*ptr).getParameterId(
11392 )
11393 }
11394 unsafe extern "system" fn getPointCount<C, W, const OFFSET: isize>(
11395 this: *mut IParamValueQueue,
11396 ) -> int32
11397 where
11398 C: IParamValueQueueTrait + ::com_scrape_types::Class,
11399 W: ::com_scrape_types::Wrapper<C>,
11400 {
11401 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
11402 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
11403 (*ptr).getPointCount(
11404 )
11405 }
11406 unsafe extern "system" fn getPoint<C, W, const OFFSET: isize>(
11407 this: *mut IParamValueQueue,
11408 index: int32,
11409 sampleOffset: *mut int32,
11410 value: *mut ParamValue,
11411 ) -> tresult
11412 where
11413 C: IParamValueQueueTrait + ::com_scrape_types::Class,
11414 W: ::com_scrape_types::Wrapper<C>,
11415 {
11416 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
11417 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
11418 (*ptr).getPoint(
11419 index,
11420 sampleOffset,
11421 value,
11422 )
11423 }
11424 unsafe extern "system" fn addPoint<C, W, const OFFSET: isize>(
11425 this: *mut IParamValueQueue,
11426 sampleOffset: int32,
11427 value: ParamValue,
11428 index: *mut int32,
11429 ) -> tresult
11430 where
11431 C: IParamValueQueueTrait + ::com_scrape_types::Class,
11432 W: ::com_scrape_types::Wrapper<C>,
11433 {
11434 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
11435 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
11436 (*ptr).addPoint(
11437 sampleOffset,
11438 value,
11439 index,
11440 )
11441 }
11442 IParamValueQueueVtbl {
11443 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
11444 getParameterId: getParameterId::<C, W, OFFSET>,
11445 getPointCount: getPointCount::<C, W, OFFSET>,
11446 getPoint: getPoint::<C, W, OFFSET>,
11447 addPoint: addPoint::<C, W, OFFSET>,
11448 }
11449 }
11450 }
11451 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IParamValueQueue
11452 where
11453 C: IParamValueQueueTrait + ::com_scrape_types::Class,
11454 W: ::com_scrape_types::Wrapper<C>,
11455 {
11456 const OBJ: Self = IParamValueQueue {
11457 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
11458 };
11459 }
11460 #[repr(C)]
11461 #[derive(Copy, Clone)]
11462 pub struct IParameterChanges {
11463 pub vtbl: *const IParameterChangesVtbl,
11464 }
11465 unsafe impl Send for IParameterChanges {}
11466 unsafe impl Sync for IParameterChanges {}
11467 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IParameterChanges {}
11468 impl ::com_scrape_types::Unknown for IParameterChanges {
11469 #[inline]
11470 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
11471 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
11472 }
11473 #[inline]
11474 unsafe fn add_ref(this: *mut Self) -> usize {
11475 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
11476 }
11477 #[inline]
11478 unsafe fn release(this: *mut Self) -> usize {
11479 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
11480 }
11481 }
11482 unsafe impl ::com_scrape_types::Interface for IParameterChanges {
11483 type Vtbl = IParameterChangesVtbl;
11484 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IParameterChanges_iid);
11485 #[inline]
11486 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
11487 iid == &Self::IID || FUnknown::inherits(iid)
11488 }
11489 }
11490 #[repr(C)]
11491 #[derive(Copy, Clone)]
11492 pub struct IParameterChangesVtbl {
11493 pub base: FUnknownVtbl,
11494 pub getParameterCount: unsafe extern "system" fn(
11495 this: *mut IParameterChanges,
11496 ) -> int32,
11497 pub getParameterData: unsafe extern "system" fn(
11498 this: *mut IParameterChanges,
11499 index: int32,
11500 ) -> *mut IParamValueQueue,
11501 pub addParameterData: unsafe extern "system" fn(
11502 this: *mut IParameterChanges,
11503 id: *const ParamID,
11504 index: *mut int32,
11505 ) -> *mut IParamValueQueue,
11506 }
11507 pub trait IParameterChangesTrait {
11508 unsafe fn getParameterCount(
11509 &self,
11510 ) -> int32;
11511 unsafe fn getParameterData(
11512 &self,
11513 index: int32,
11514 ) -> *mut IParamValueQueue;
11515 unsafe fn addParameterData(
11516 &self,
11517 id: *const ParamID,
11518 index: *mut int32,
11519 ) -> *mut IParamValueQueue;
11520 }
11521 impl<P> IParameterChangesTrait for P
11522 where
11523 P: ::com_scrape_types::SmartPtr,
11524 P::Target: ::com_scrape_types::Inherits<IParameterChanges>,
11525 {
11526 #[inline]
11527 unsafe fn getParameterCount(
11528 &self,
11529 ) -> int32 {
11530 let ptr = self.ptr() as *mut IParameterChanges;
11531 ((*(*ptr).vtbl).getParameterCount)(
11532 ptr,
11533 )
11534 }
11535 #[inline]
11536 unsafe fn getParameterData(
11537 &self,
11538 index: int32,
11539 ) -> *mut IParamValueQueue {
11540 let ptr = self.ptr() as *mut IParameterChanges;
11541 ((*(*ptr).vtbl).getParameterData)(
11542 ptr,
11543 index,
11544 )
11545 }
11546 #[inline]
11547 unsafe fn addParameterData(
11548 &self,
11549 id: *const ParamID,
11550 index: *mut int32,
11551 ) -> *mut IParamValueQueue {
11552 let ptr = self.ptr() as *mut IParameterChanges;
11553 ((*(*ptr).vtbl).addParameterData)(
11554 ptr,
11555 id,
11556 index,
11557 )
11558 }
11559 }
11560 impl IParameterChanges {
11561 const fn make_vtbl<C, W, const OFFSET: isize>() -> IParameterChangesVtbl
11562 where
11563 C: IParameterChangesTrait + ::com_scrape_types::Class,
11564 W: ::com_scrape_types::Wrapper<C>,
11565 {
11566 unsafe extern "system" fn getParameterCount<C, W, const OFFSET: isize>(
11567 this: *mut IParameterChanges,
11568 ) -> int32
11569 where
11570 C: IParameterChangesTrait + ::com_scrape_types::Class,
11571 W: ::com_scrape_types::Wrapper<C>,
11572 {
11573 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
11574 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
11575 (*ptr).getParameterCount(
11576 )
11577 }
11578 unsafe extern "system" fn getParameterData<C, W, const OFFSET: isize>(
11579 this: *mut IParameterChanges,
11580 index: int32,
11581 ) -> *mut IParamValueQueue
11582 where
11583 C: IParameterChangesTrait + ::com_scrape_types::Class,
11584 W: ::com_scrape_types::Wrapper<C>,
11585 {
11586 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
11587 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
11588 (*ptr).getParameterData(
11589 index,
11590 )
11591 }
11592 unsafe extern "system" fn addParameterData<C, W, const OFFSET: isize>(
11593 this: *mut IParameterChanges,
11594 id: *const ParamID,
11595 index: *mut int32,
11596 ) -> *mut IParamValueQueue
11597 where
11598 C: IParameterChangesTrait + ::com_scrape_types::Class,
11599 W: ::com_scrape_types::Wrapper<C>,
11600 {
11601 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
11602 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
11603 (*ptr).addParameterData(
11604 id,
11605 index,
11606 )
11607 }
11608 IParameterChangesVtbl {
11609 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
11610 getParameterCount: getParameterCount::<C, W, OFFSET>,
11611 getParameterData: getParameterData::<C, W, OFFSET>,
11612 addParameterData: addParameterData::<C, W, OFFSET>,
11613 }
11614 }
11615 }
11616 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IParameterChanges
11617 where
11618 C: IParameterChangesTrait + ::com_scrape_types::Class,
11619 W: ::com_scrape_types::Wrapper<C>,
11620 {
11621 const OBJ: Self = IParameterChanges {
11622 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
11623 };
11624 }
11625 #[repr(C)]
11626 #[derive(Copy, Clone)]
11627 pub struct IParameterFinder {
11628 pub vtbl: *const IParameterFinderVtbl,
11629 }
11630 unsafe impl Send for IParameterFinder {}
11631 unsafe impl Sync for IParameterFinder {}
11632 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IParameterFinder {}
11633 impl ::com_scrape_types::Unknown for IParameterFinder {
11634 #[inline]
11635 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
11636 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
11637 }
11638 #[inline]
11639 unsafe fn add_ref(this: *mut Self) -> usize {
11640 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
11641 }
11642 #[inline]
11643 unsafe fn release(this: *mut Self) -> usize {
11644 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
11645 }
11646 }
11647 unsafe impl ::com_scrape_types::Interface for IParameterFinder {
11648 type Vtbl = IParameterFinderVtbl;
11649 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IParameterFinder_iid);
11650 #[inline]
11651 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
11652 iid == &Self::IID || FUnknown::inherits(iid)
11653 }
11654 }
11655 #[repr(C)]
11656 #[derive(Copy, Clone)]
11657 pub struct IParameterFinderVtbl {
11658 pub base: FUnknownVtbl,
11659 pub findParameter: unsafe extern "system" fn(
11660 this: *mut IParameterFinder,
11661 xPos: int32,
11662 yPos: int32,
11663 resultTag: *mut ParamID,
11664 ) -> tresult,
11665 }
11666 pub trait IParameterFinderTrait {
11667 unsafe fn findParameter(
11668 &self,
11669 xPos: int32,
11670 yPos: int32,
11671 resultTag: *mut ParamID,
11672 ) -> tresult;
11673 }
11674 impl<P> IParameterFinderTrait for P
11675 where
11676 P: ::com_scrape_types::SmartPtr,
11677 P::Target: ::com_scrape_types::Inherits<IParameterFinder>,
11678 {
11679 #[inline]
11680 unsafe fn findParameter(
11681 &self,
11682 xPos: int32,
11683 yPos: int32,
11684 resultTag: *mut ParamID,
11685 ) -> tresult {
11686 let ptr = self.ptr() as *mut IParameterFinder;
11687 ((*(*ptr).vtbl).findParameter)(
11688 ptr,
11689 xPos,
11690 yPos,
11691 resultTag,
11692 )
11693 }
11694 }
11695 impl IParameterFinder {
11696 const fn make_vtbl<C, W, const OFFSET: isize>() -> IParameterFinderVtbl
11697 where
11698 C: IParameterFinderTrait + ::com_scrape_types::Class,
11699 W: ::com_scrape_types::Wrapper<C>,
11700 {
11701 unsafe extern "system" fn findParameter<C, W, const OFFSET: isize>(
11702 this: *mut IParameterFinder,
11703 xPos: int32,
11704 yPos: int32,
11705 resultTag: *mut ParamID,
11706 ) -> tresult
11707 where
11708 C: IParameterFinderTrait + ::com_scrape_types::Class,
11709 W: ::com_scrape_types::Wrapper<C>,
11710 {
11711 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
11712 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
11713 (*ptr).findParameter(
11714 xPos,
11715 yPos,
11716 resultTag,
11717 )
11718 }
11719 IParameterFinderVtbl {
11720 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
11721 findParameter: findParameter::<C, W, OFFSET>,
11722 }
11723 }
11724 }
11725 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IParameterFinder
11726 where
11727 C: IParameterFinderTrait + ::com_scrape_types::Class,
11728 W: ::com_scrape_types::Wrapper<C>,
11729 {
11730 const OBJ: Self = IParameterFinder {
11731 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
11732 };
11733 }
11734 #[repr(C)]
11735 #[derive(Copy, Clone)]
11736 pub struct IParameterFunctionName {
11737 pub vtbl: *const IParameterFunctionNameVtbl,
11738 }
11739 unsafe impl Send for IParameterFunctionName {}
11740 unsafe impl Sync for IParameterFunctionName {}
11741 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IParameterFunctionName {}
11742 impl ::com_scrape_types::Unknown for IParameterFunctionName {
11743 #[inline]
11744 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
11745 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
11746 }
11747 #[inline]
11748 unsafe fn add_ref(this: *mut Self) -> usize {
11749 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
11750 }
11751 #[inline]
11752 unsafe fn release(this: *mut Self) -> usize {
11753 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
11754 }
11755 }
11756 unsafe impl ::com_scrape_types::Interface for IParameterFunctionName {
11757 type Vtbl = IParameterFunctionNameVtbl;
11758 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IParameterFunctionName_iid);
11759 #[inline]
11760 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
11761 iid == &Self::IID || FUnknown::inherits(iid)
11762 }
11763 }
11764 #[repr(C)]
11765 #[derive(Copy, Clone)]
11766 pub struct IParameterFunctionNameVtbl {
11767 pub base: FUnknownVtbl,
11768 pub getParameterIDFromFunctionName: unsafe extern "system" fn(
11769 this: *mut IParameterFunctionName,
11770 unitID: UnitID,
11771 functionName: FIDString,
11772 paramID: *mut ParamID,
11773 ) -> tresult,
11774 }
11775 pub trait IParameterFunctionNameTrait {
11776 unsafe fn getParameterIDFromFunctionName(
11777 &self,
11778 unitID: UnitID,
11779 functionName: FIDString,
11780 paramID: *mut ParamID,
11781 ) -> tresult;
11782 }
11783 impl<P> IParameterFunctionNameTrait for P
11784 where
11785 P: ::com_scrape_types::SmartPtr,
11786 P::Target: ::com_scrape_types::Inherits<IParameterFunctionName>,
11787 {
11788 #[inline]
11789 unsafe fn getParameterIDFromFunctionName(
11790 &self,
11791 unitID: UnitID,
11792 functionName: FIDString,
11793 paramID: *mut ParamID,
11794 ) -> tresult {
11795 let ptr = self.ptr() as *mut IParameterFunctionName;
11796 ((*(*ptr).vtbl).getParameterIDFromFunctionName)(
11797 ptr,
11798 unitID,
11799 functionName,
11800 paramID,
11801 )
11802 }
11803 }
11804 impl IParameterFunctionName {
11805 const fn make_vtbl<C, W, const OFFSET: isize>() -> IParameterFunctionNameVtbl
11806 where
11807 C: IParameterFunctionNameTrait + ::com_scrape_types::Class,
11808 W: ::com_scrape_types::Wrapper<C>,
11809 {
11810 unsafe extern "system" fn getParameterIDFromFunctionName<C, W, const OFFSET: isize>(
11811 this: *mut IParameterFunctionName,
11812 unitID: UnitID,
11813 functionName: FIDString,
11814 paramID: *mut ParamID,
11815 ) -> tresult
11816 where
11817 C: IParameterFunctionNameTrait + ::com_scrape_types::Class,
11818 W: ::com_scrape_types::Wrapper<C>,
11819 {
11820 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
11821 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
11822 (*ptr).getParameterIDFromFunctionName(
11823 unitID,
11824 functionName,
11825 paramID,
11826 )
11827 }
11828 IParameterFunctionNameVtbl {
11829 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
11830 getParameterIDFromFunctionName: getParameterIDFromFunctionName::<C, W, OFFSET>,
11831 }
11832 }
11833 }
11834 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IParameterFunctionName
11835 where
11836 C: IParameterFunctionNameTrait + ::com_scrape_types::Class,
11837 W: ::com_scrape_types::Wrapper<C>,
11838 {
11839 const OBJ: Self = IParameterFunctionName {
11840 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
11841 };
11842 }
11843 #[repr(C)]
11844 #[derive(Copy, Clone)]
11845 pub struct IPlugInterfaceSupport {
11846 pub vtbl: *const IPlugInterfaceSupportVtbl,
11847 }
11848 unsafe impl Send for IPlugInterfaceSupport {}
11849 unsafe impl Sync for IPlugInterfaceSupport {}
11850 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IPlugInterfaceSupport {}
11851 impl ::com_scrape_types::Unknown for IPlugInterfaceSupport {
11852 #[inline]
11853 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
11854 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
11855 }
11856 #[inline]
11857 unsafe fn add_ref(this: *mut Self) -> usize {
11858 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
11859 }
11860 #[inline]
11861 unsafe fn release(this: *mut Self) -> usize {
11862 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
11863 }
11864 }
11865 unsafe impl ::com_scrape_types::Interface for IPlugInterfaceSupport {
11866 type Vtbl = IPlugInterfaceSupportVtbl;
11867 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IPlugInterfaceSupport_iid);
11868 #[inline]
11869 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
11870 iid == &Self::IID || FUnknown::inherits(iid)
11871 }
11872 }
11873 #[repr(C)]
11874 #[derive(Copy, Clone)]
11875 pub struct IPlugInterfaceSupportVtbl {
11876 pub base: FUnknownVtbl,
11877 pub isPlugInterfaceSupported: unsafe extern "system" fn(
11878 this: *mut IPlugInterfaceSupport,
11879 _iid: *const TUID,
11880 ) -> tresult,
11881 }
11882 pub trait IPlugInterfaceSupportTrait {
11883 unsafe fn isPlugInterfaceSupported(
11884 &self,
11885 _iid: *const TUID,
11886 ) -> tresult;
11887 }
11888 impl<P> IPlugInterfaceSupportTrait for P
11889 where
11890 P: ::com_scrape_types::SmartPtr,
11891 P::Target: ::com_scrape_types::Inherits<IPlugInterfaceSupport>,
11892 {
11893 #[inline]
11894 unsafe fn isPlugInterfaceSupported(
11895 &self,
11896 _iid: *const TUID,
11897 ) -> tresult {
11898 let ptr = self.ptr() as *mut IPlugInterfaceSupport;
11899 ((*(*ptr).vtbl).isPlugInterfaceSupported)(
11900 ptr,
11901 _iid,
11902 )
11903 }
11904 }
11905 impl IPlugInterfaceSupport {
11906 const fn make_vtbl<C, W, const OFFSET: isize>() -> IPlugInterfaceSupportVtbl
11907 where
11908 C: IPlugInterfaceSupportTrait + ::com_scrape_types::Class,
11909 W: ::com_scrape_types::Wrapper<C>,
11910 {
11911 unsafe extern "system" fn isPlugInterfaceSupported<C, W, const OFFSET: isize>(
11912 this: *mut IPlugInterfaceSupport,
11913 _iid: *const TUID,
11914 ) -> tresult
11915 where
11916 C: IPlugInterfaceSupportTrait + ::com_scrape_types::Class,
11917 W: ::com_scrape_types::Wrapper<C>,
11918 {
11919 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
11920 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
11921 (*ptr).isPlugInterfaceSupported(
11922 _iid,
11923 )
11924 }
11925 IPlugInterfaceSupportVtbl {
11926 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
11927 isPlugInterfaceSupported: isPlugInterfaceSupported::<C, W, OFFSET>,
11928 }
11929 }
11930 }
11931 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IPlugInterfaceSupport
11932 where
11933 C: IPlugInterfaceSupportTrait + ::com_scrape_types::Class,
11934 W: ::com_scrape_types::Wrapper<C>,
11935 {
11936 const OBJ: Self = IPlugInterfaceSupport {
11937 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
11938 };
11939 }
11940 #[repr(C)]
11941 #[derive(Copy, Clone)]
11942 pub struct IPrefetchableSupport {
11943 pub vtbl: *const IPrefetchableSupportVtbl,
11944 }
11945 unsafe impl Send for IPrefetchableSupport {}
11946 unsafe impl Sync for IPrefetchableSupport {}
11947 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IPrefetchableSupport {}
11948 impl ::com_scrape_types::Unknown for IPrefetchableSupport {
11949 #[inline]
11950 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
11951 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
11952 }
11953 #[inline]
11954 unsafe fn add_ref(this: *mut Self) -> usize {
11955 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
11956 }
11957 #[inline]
11958 unsafe fn release(this: *mut Self) -> usize {
11959 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
11960 }
11961 }
11962 unsafe impl ::com_scrape_types::Interface for IPrefetchableSupport {
11963 type Vtbl = IPrefetchableSupportVtbl;
11964 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IPrefetchableSupport_iid);
11965 #[inline]
11966 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
11967 iid == &Self::IID || FUnknown::inherits(iid)
11968 }
11969 }
11970 #[repr(C)]
11971 #[derive(Copy, Clone)]
11972 pub struct IPrefetchableSupportVtbl {
11973 pub base: FUnknownVtbl,
11974 pub getPrefetchableSupport: unsafe extern "system" fn(
11975 this: *mut IPrefetchableSupport,
11976 prefetchable: *mut PrefetchableSupport,
11977 ) -> tresult,
11978 }
11979 pub trait IPrefetchableSupportTrait {
11980 unsafe fn getPrefetchableSupport(
11981 &self,
11982 prefetchable: *mut PrefetchableSupport,
11983 ) -> tresult;
11984 }
11985 impl<P> IPrefetchableSupportTrait for P
11986 where
11987 P: ::com_scrape_types::SmartPtr,
11988 P::Target: ::com_scrape_types::Inherits<IPrefetchableSupport>,
11989 {
11990 #[inline]
11991 unsafe fn getPrefetchableSupport(
11992 &self,
11993 prefetchable: *mut PrefetchableSupport,
11994 ) -> tresult {
11995 let ptr = self.ptr() as *mut IPrefetchableSupport;
11996 ((*(*ptr).vtbl).getPrefetchableSupport)(
11997 ptr,
11998 prefetchable,
11999 )
12000 }
12001 }
12002 impl IPrefetchableSupport {
12003 const fn make_vtbl<C, W, const OFFSET: isize>() -> IPrefetchableSupportVtbl
12004 where
12005 C: IPrefetchableSupportTrait + ::com_scrape_types::Class,
12006 W: ::com_scrape_types::Wrapper<C>,
12007 {
12008 unsafe extern "system" fn getPrefetchableSupport<C, W, const OFFSET: isize>(
12009 this: *mut IPrefetchableSupport,
12010 prefetchable: *mut PrefetchableSupport,
12011 ) -> tresult
12012 where
12013 C: IPrefetchableSupportTrait + ::com_scrape_types::Class,
12014 W: ::com_scrape_types::Wrapper<C>,
12015 {
12016 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
12017 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
12018 (*ptr).getPrefetchableSupport(
12019 prefetchable,
12020 )
12021 }
12022 IPrefetchableSupportVtbl {
12023 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
12024 getPrefetchableSupport: getPrefetchableSupport::<C, W, OFFSET>,
12025 }
12026 }
12027 }
12028 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IPrefetchableSupport
12029 where
12030 C: IPrefetchableSupportTrait + ::com_scrape_types::Class,
12031 W: ::com_scrape_types::Wrapper<C>,
12032 {
12033 const OBJ: Self = IPrefetchableSupport {
12034 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
12035 };
12036 }
12037 mod __IProcessContextRequirements_wrapper {
12038 #[allow(unused_imports)]
12039 use super::*;
12040 #[allow(unused_imports)]
12041 use super::IProcessContextRequirements_::*;
12042 #[repr(C)]
12043 #[derive(Copy, Clone)]
12044 pub struct IProcessContextRequirements {
12045 pub vtbl: *const IProcessContextRequirementsVtbl,
12046 }
12047 unsafe impl Send for IProcessContextRequirements {}
12048 unsafe impl Sync for IProcessContextRequirements {}
12049 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IProcessContextRequirements {}
12050 impl ::com_scrape_types::Unknown for IProcessContextRequirements {
12051 #[inline]
12052 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
12053 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
12054 }
12055 #[inline]
12056 unsafe fn add_ref(this: *mut Self) -> usize {
12057 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
12058 }
12059 #[inline]
12060 unsafe fn release(this: *mut Self) -> usize {
12061 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
12062 }
12063 }
12064 unsafe impl ::com_scrape_types::Interface for IProcessContextRequirements {
12065 type Vtbl = IProcessContextRequirementsVtbl;
12066 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IProcessContextRequirements_iid);
12067 #[inline]
12068 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
12069 iid == &Self::IID || FUnknown::inherits(iid)
12070 }
12071 }
12072 #[repr(C)]
12073 #[derive(Copy, Clone)]
12074 pub struct IProcessContextRequirementsVtbl {
12075 pub base: FUnknownVtbl,
12076 pub getProcessContextRequirements: unsafe extern "system" fn(
12077 this: *mut IProcessContextRequirements,
12078 ) -> uint32,
12079 }
12080 pub trait IProcessContextRequirementsTrait {
12081 unsafe fn getProcessContextRequirements(
12082 &self,
12083 ) -> uint32;
12084 }
12085 impl<P> IProcessContextRequirementsTrait for P
12086 where
12087 P: ::com_scrape_types::SmartPtr,
12088 P::Target: ::com_scrape_types::Inherits<IProcessContextRequirements>,
12089 {
12090 #[inline]
12091 unsafe fn getProcessContextRequirements(
12092 &self,
12093 ) -> uint32 {
12094 let ptr = self.ptr() as *mut IProcessContextRequirements;
12095 ((*(*ptr).vtbl).getProcessContextRequirements)(
12096 ptr,
12097 )
12098 }
12099 }
12100 impl IProcessContextRequirements {
12101 const fn make_vtbl<C, W, const OFFSET: isize>() -> IProcessContextRequirementsVtbl
12102 where
12103 C: IProcessContextRequirementsTrait + ::com_scrape_types::Class,
12104 W: ::com_scrape_types::Wrapper<C>,
12105 {
12106 unsafe extern "system" fn getProcessContextRequirements<C, W, const OFFSET: isize>(
12107 this: *mut IProcessContextRequirements,
12108 ) -> uint32
12109 where
12110 C: IProcessContextRequirementsTrait + ::com_scrape_types::Class,
12111 W: ::com_scrape_types::Wrapper<C>,
12112 {
12113 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
12114 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
12115 (*ptr).getProcessContextRequirements(
12116 )
12117 }
12118 IProcessContextRequirementsVtbl {
12119 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
12120 getProcessContextRequirements: getProcessContextRequirements::<C, W, OFFSET>,
12121 }
12122 }
12123 }
12124 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IProcessContextRequirements
12125 where
12126 C: IProcessContextRequirementsTrait + ::com_scrape_types::Class,
12127 W: ::com_scrape_types::Wrapper<C>,
12128 {
12129 const OBJ: Self = IProcessContextRequirements {
12130 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
12131 };
12132 }
12133 }
12134 pub use __IProcessContextRequirements_wrapper::*;
12135 pub mod IProcessContextRequirements_ {
12136 #[allow(unused_imports)]
12137 use super::*;
12138 pub type Flags = crate::support::DefaultEnumType;
12139 pub mod Flags_ {
12140 #[allow(unused_imports)]
12141 use super::*;
12142 pub const kNeedBarPositionMusic: Flags = 8;
12143 pub const kNeedChord: Flags = 256;
12144 pub const kNeedContinousTimeSamples: Flags = 2;
12145 pub const kNeedCycleMusic: Flags = 16;
12146 pub const kNeedFrameRate: Flags = 512;
12147 pub const kNeedProjectTimeMusic: Flags = 4;
12148 pub const kNeedSamplesToNextClock: Flags = 32;
12149 pub const kNeedSystemTime: Flags = 1;
12150 pub const kNeedTempo: Flags = 64;
12151 pub const kNeedTimeSignature: Flags = 128;
12152 pub const kNeedTransportState: Flags = 1024;
12153 }
12154 }
12155 #[repr(C)]
12156 #[derive(Copy, Clone)]
12157 pub struct IProgramListData {
12158 pub vtbl: *const IProgramListDataVtbl,
12159 }
12160 unsafe impl Send for IProgramListData {}
12161 unsafe impl Sync for IProgramListData {}
12162 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IProgramListData {}
12163 impl ::com_scrape_types::Unknown for IProgramListData {
12164 #[inline]
12165 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
12166 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
12167 }
12168 #[inline]
12169 unsafe fn add_ref(this: *mut Self) -> usize {
12170 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
12171 }
12172 #[inline]
12173 unsafe fn release(this: *mut Self) -> usize {
12174 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
12175 }
12176 }
12177 unsafe impl ::com_scrape_types::Interface for IProgramListData {
12178 type Vtbl = IProgramListDataVtbl;
12179 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IProgramListData_iid);
12180 #[inline]
12181 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
12182 iid == &Self::IID || FUnknown::inherits(iid)
12183 }
12184 }
12185 #[repr(C)]
12186 #[derive(Copy, Clone)]
12187 pub struct IProgramListDataVtbl {
12188 pub base: FUnknownVtbl,
12189 pub programDataSupported: unsafe extern "system" fn(
12190 this: *mut IProgramListData,
12191 listId: ProgramListID,
12192 ) -> tresult,
12193 pub getProgramData: unsafe extern "system" fn(
12194 this: *mut IProgramListData,
12195 listId: ProgramListID,
12196 programIndex: int32,
12197 data: *mut IBStream,
12198 ) -> tresult,
12199 pub setProgramData: unsafe extern "system" fn(
12200 this: *mut IProgramListData,
12201 listId: ProgramListID,
12202 programIndex: int32,
12203 data: *mut IBStream,
12204 ) -> tresult,
12205 }
12206 pub trait IProgramListDataTrait {
12207 unsafe fn programDataSupported(
12208 &self,
12209 listId: ProgramListID,
12210 ) -> tresult;
12211 unsafe fn getProgramData(
12212 &self,
12213 listId: ProgramListID,
12214 programIndex: int32,
12215 data: *mut IBStream,
12216 ) -> tresult;
12217 unsafe fn setProgramData(
12218 &self,
12219 listId: ProgramListID,
12220 programIndex: int32,
12221 data: *mut IBStream,
12222 ) -> tresult;
12223 }
12224 impl<P> IProgramListDataTrait for P
12225 where
12226 P: ::com_scrape_types::SmartPtr,
12227 P::Target: ::com_scrape_types::Inherits<IProgramListData>,
12228 {
12229 #[inline]
12230 unsafe fn programDataSupported(
12231 &self,
12232 listId: ProgramListID,
12233 ) -> tresult {
12234 let ptr = self.ptr() as *mut IProgramListData;
12235 ((*(*ptr).vtbl).programDataSupported)(
12236 ptr,
12237 listId,
12238 )
12239 }
12240 #[inline]
12241 unsafe fn getProgramData(
12242 &self,
12243 listId: ProgramListID,
12244 programIndex: int32,
12245 data: *mut IBStream,
12246 ) -> tresult {
12247 let ptr = self.ptr() as *mut IProgramListData;
12248 ((*(*ptr).vtbl).getProgramData)(
12249 ptr,
12250 listId,
12251 programIndex,
12252 data,
12253 )
12254 }
12255 #[inline]
12256 unsafe fn setProgramData(
12257 &self,
12258 listId: ProgramListID,
12259 programIndex: int32,
12260 data: *mut IBStream,
12261 ) -> tresult {
12262 let ptr = self.ptr() as *mut IProgramListData;
12263 ((*(*ptr).vtbl).setProgramData)(
12264 ptr,
12265 listId,
12266 programIndex,
12267 data,
12268 )
12269 }
12270 }
12271 impl IProgramListData {
12272 const fn make_vtbl<C, W, const OFFSET: isize>() -> IProgramListDataVtbl
12273 where
12274 C: IProgramListDataTrait + ::com_scrape_types::Class,
12275 W: ::com_scrape_types::Wrapper<C>,
12276 {
12277 unsafe extern "system" fn programDataSupported<C, W, const OFFSET: isize>(
12278 this: *mut IProgramListData,
12279 listId: ProgramListID,
12280 ) -> tresult
12281 where
12282 C: IProgramListDataTrait + ::com_scrape_types::Class,
12283 W: ::com_scrape_types::Wrapper<C>,
12284 {
12285 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
12286 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
12287 (*ptr).programDataSupported(
12288 listId,
12289 )
12290 }
12291 unsafe extern "system" fn getProgramData<C, W, const OFFSET: isize>(
12292 this: *mut IProgramListData,
12293 listId: ProgramListID,
12294 programIndex: int32,
12295 data: *mut IBStream,
12296 ) -> tresult
12297 where
12298 C: IProgramListDataTrait + ::com_scrape_types::Class,
12299 W: ::com_scrape_types::Wrapper<C>,
12300 {
12301 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
12302 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
12303 (*ptr).getProgramData(
12304 listId,
12305 programIndex,
12306 data,
12307 )
12308 }
12309 unsafe extern "system" fn setProgramData<C, W, const OFFSET: isize>(
12310 this: *mut IProgramListData,
12311 listId: ProgramListID,
12312 programIndex: int32,
12313 data: *mut IBStream,
12314 ) -> tresult
12315 where
12316 C: IProgramListDataTrait + ::com_scrape_types::Class,
12317 W: ::com_scrape_types::Wrapper<C>,
12318 {
12319 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
12320 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
12321 (*ptr).setProgramData(
12322 listId,
12323 programIndex,
12324 data,
12325 )
12326 }
12327 IProgramListDataVtbl {
12328 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
12329 programDataSupported: programDataSupported::<C, W, OFFSET>,
12330 getProgramData: getProgramData::<C, W, OFFSET>,
12331 setProgramData: setProgramData::<C, W, OFFSET>,
12332 }
12333 }
12334 }
12335 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IProgramListData
12336 where
12337 C: IProgramListDataTrait + ::com_scrape_types::Class,
12338 W: ::com_scrape_types::Wrapper<C>,
12339 {
12340 const OBJ: Self = IProgramListData {
12341 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
12342 };
12343 }
12344 mod __IProgress_wrapper {
12345 #[allow(unused_imports)]
12346 use super::*;
12347 #[allow(unused_imports)]
12348 use super::IProgress_::*;
12349 #[repr(C)]
12350 #[derive(Copy, Clone)]
12351 pub struct IProgress {
12352 pub vtbl: *const IProgressVtbl,
12353 }
12354 unsafe impl Send for IProgress {}
12355 unsafe impl Sync for IProgress {}
12356 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IProgress {}
12357 impl ::com_scrape_types::Unknown for IProgress {
12358 #[inline]
12359 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
12360 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
12361 }
12362 #[inline]
12363 unsafe fn add_ref(this: *mut Self) -> usize {
12364 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
12365 }
12366 #[inline]
12367 unsafe fn release(this: *mut Self) -> usize {
12368 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
12369 }
12370 }
12371 unsafe impl ::com_scrape_types::Interface for IProgress {
12372 type Vtbl = IProgressVtbl;
12373 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IProgress_iid);
12374 #[inline]
12375 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
12376 iid == &Self::IID || FUnknown::inherits(iid)
12377 }
12378 }
12379 #[repr(C)]
12380 #[derive(Copy, Clone)]
12381 pub struct IProgressVtbl {
12382 pub base: FUnknownVtbl,
12383 pub start: unsafe extern "system" fn(
12384 this: *mut IProgress,
12385 r#type: ProgressType,
12386 optionalDescription: *const tchar,
12387 outID: *mut ID,
12388 ) -> tresult,
12389 pub update: unsafe extern "system" fn(
12390 this: *mut IProgress,
12391 id: ID,
12392 normValue: ParamValue,
12393 ) -> tresult,
12394 pub finish: unsafe extern "system" fn(
12395 this: *mut IProgress,
12396 id: ID,
12397 ) -> tresult,
12398 }
12399 pub trait IProgressTrait {
12400 unsafe fn start(
12401 &self,
12402 r#type: ProgressType,
12403 optionalDescription: *const tchar,
12404 outID: *mut ID,
12405 ) -> tresult;
12406 unsafe fn update(
12407 &self,
12408 id: ID,
12409 normValue: ParamValue,
12410 ) -> tresult;
12411 unsafe fn finish(
12412 &self,
12413 id: ID,
12414 ) -> tresult;
12415 }
12416 impl<P> IProgressTrait for P
12417 where
12418 P: ::com_scrape_types::SmartPtr,
12419 P::Target: ::com_scrape_types::Inherits<IProgress>,
12420 {
12421 #[inline]
12422 unsafe fn start(
12423 &self,
12424 r#type: ProgressType,
12425 optionalDescription: *const tchar,
12426 outID: *mut ID,
12427 ) -> tresult {
12428 let ptr = self.ptr() as *mut IProgress;
12429 ((*(*ptr).vtbl).start)(
12430 ptr,
12431 r#type,
12432 optionalDescription,
12433 outID,
12434 )
12435 }
12436 #[inline]
12437 unsafe fn update(
12438 &self,
12439 id: ID,
12440 normValue: ParamValue,
12441 ) -> tresult {
12442 let ptr = self.ptr() as *mut IProgress;
12443 ((*(*ptr).vtbl).update)(
12444 ptr,
12445 id,
12446 normValue,
12447 )
12448 }
12449 #[inline]
12450 unsafe fn finish(
12451 &self,
12452 id: ID,
12453 ) -> tresult {
12454 let ptr = self.ptr() as *mut IProgress;
12455 ((*(*ptr).vtbl).finish)(
12456 ptr,
12457 id,
12458 )
12459 }
12460 }
12461 impl IProgress {
12462 const fn make_vtbl<C, W, const OFFSET: isize>() -> IProgressVtbl
12463 where
12464 C: IProgressTrait + ::com_scrape_types::Class,
12465 W: ::com_scrape_types::Wrapper<C>,
12466 {
12467 unsafe extern "system" fn start<C, W, const OFFSET: isize>(
12468 this: *mut IProgress,
12469 r#type: ProgressType,
12470 optionalDescription: *const tchar,
12471 outID: *mut ID,
12472 ) -> tresult
12473 where
12474 C: IProgressTrait + ::com_scrape_types::Class,
12475 W: ::com_scrape_types::Wrapper<C>,
12476 {
12477 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
12478 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
12479 (*ptr).start(
12480 r#type,
12481 optionalDescription,
12482 outID,
12483 )
12484 }
12485 unsafe extern "system" fn update<C, W, const OFFSET: isize>(
12486 this: *mut IProgress,
12487 id: ID,
12488 normValue: ParamValue,
12489 ) -> tresult
12490 where
12491 C: IProgressTrait + ::com_scrape_types::Class,
12492 W: ::com_scrape_types::Wrapper<C>,
12493 {
12494 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
12495 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
12496 (*ptr).update(
12497 id,
12498 normValue,
12499 )
12500 }
12501 unsafe extern "system" fn finish<C, W, const OFFSET: isize>(
12502 this: *mut IProgress,
12503 id: ID,
12504 ) -> tresult
12505 where
12506 C: IProgressTrait + ::com_scrape_types::Class,
12507 W: ::com_scrape_types::Wrapper<C>,
12508 {
12509 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
12510 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
12511 (*ptr).finish(
12512 id,
12513 )
12514 }
12515 IProgressVtbl {
12516 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
12517 start: start::<C, W, OFFSET>,
12518 update: update::<C, W, OFFSET>,
12519 finish: finish::<C, W, OFFSET>,
12520 }
12521 }
12522 }
12523 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IProgress
12524 where
12525 C: IProgressTrait + ::com_scrape_types::Class,
12526 W: ::com_scrape_types::Wrapper<C>,
12527 {
12528 const OBJ: Self = IProgress {
12529 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
12530 };
12531 }
12532 }
12533 pub use __IProgress_wrapper::*;
12534 pub mod IProgress_ {
12535 #[allow(unused_imports)]
12536 use super::*;
12537 pub type ID = uint64;
12538 pub type ProgressType = uint32;
12539 pub mod ProgressType_ {
12540 #[allow(unused_imports)]
12541 use super::*;
12542 pub const AsyncStateRestoration: ProgressType = 0;
12543 pub const UIBackgroundTask: ProgressType = 1;
12544 }
12545 }
12546 #[repr(C)]
12547 #[derive(Copy, Clone)]
12548 pub struct IRemapParamID {
12549 pub vtbl: *const IRemapParamIDVtbl,
12550 }
12551 unsafe impl Send for IRemapParamID {}
12552 unsafe impl Sync for IRemapParamID {}
12553 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IRemapParamID {}
12554 impl ::com_scrape_types::Unknown for IRemapParamID {
12555 #[inline]
12556 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
12557 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
12558 }
12559 #[inline]
12560 unsafe fn add_ref(this: *mut Self) -> usize {
12561 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
12562 }
12563 #[inline]
12564 unsafe fn release(this: *mut Self) -> usize {
12565 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
12566 }
12567 }
12568 unsafe impl ::com_scrape_types::Interface for IRemapParamID {
12569 type Vtbl = IRemapParamIDVtbl;
12570 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IRemapParamID_iid);
12571 #[inline]
12572 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
12573 iid == &Self::IID || FUnknown::inherits(iid)
12574 }
12575 }
12576 #[repr(C)]
12577 #[derive(Copy, Clone)]
12578 pub struct IRemapParamIDVtbl {
12579 pub base: FUnknownVtbl,
12580 pub getCompatibleParamID: unsafe extern "system" fn(
12581 this: *mut IRemapParamID,
12582 pluginToReplaceUID: *const TUID,
12583 oldParamID: ParamID,
12584 newParamID: *mut ParamID,
12585 ) -> tresult,
12586 }
12587 pub trait IRemapParamIDTrait {
12588 unsafe fn getCompatibleParamID(
12589 &self,
12590 pluginToReplaceUID: *const TUID,
12591 oldParamID: ParamID,
12592 newParamID: *mut ParamID,
12593 ) -> tresult;
12594 }
12595 impl<P> IRemapParamIDTrait for P
12596 where
12597 P: ::com_scrape_types::SmartPtr,
12598 P::Target: ::com_scrape_types::Inherits<IRemapParamID>,
12599 {
12600 #[inline]
12601 unsafe fn getCompatibleParamID(
12602 &self,
12603 pluginToReplaceUID: *const TUID,
12604 oldParamID: ParamID,
12605 newParamID: *mut ParamID,
12606 ) -> tresult {
12607 let ptr = self.ptr() as *mut IRemapParamID;
12608 ((*(*ptr).vtbl).getCompatibleParamID)(
12609 ptr,
12610 pluginToReplaceUID,
12611 oldParamID,
12612 newParamID,
12613 )
12614 }
12615 }
12616 impl IRemapParamID {
12617 const fn make_vtbl<C, W, const OFFSET: isize>() -> IRemapParamIDVtbl
12618 where
12619 C: IRemapParamIDTrait + ::com_scrape_types::Class,
12620 W: ::com_scrape_types::Wrapper<C>,
12621 {
12622 unsafe extern "system" fn getCompatibleParamID<C, W, const OFFSET: isize>(
12623 this: *mut IRemapParamID,
12624 pluginToReplaceUID: *const TUID,
12625 oldParamID: ParamID,
12626 newParamID: *mut ParamID,
12627 ) -> tresult
12628 where
12629 C: IRemapParamIDTrait + ::com_scrape_types::Class,
12630 W: ::com_scrape_types::Wrapper<C>,
12631 {
12632 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
12633 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
12634 (*ptr).getCompatibleParamID(
12635 pluginToReplaceUID,
12636 oldParamID,
12637 newParamID,
12638 )
12639 }
12640 IRemapParamIDVtbl {
12641 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
12642 getCompatibleParamID: getCompatibleParamID::<C, W, OFFSET>,
12643 }
12644 }
12645 }
12646 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IRemapParamID
12647 where
12648 C: IRemapParamIDTrait + ::com_scrape_types::Class,
12649 W: ::com_scrape_types::Wrapper<C>,
12650 {
12651 const OBJ: Self = IRemapParamID {
12652 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
12653 };
12654 }
12655 #[repr(C)]
12656 #[derive(Copy, Clone)]
12657 pub struct IStreamAttributes {
12658 pub vtbl: *const IStreamAttributesVtbl,
12659 }
12660 unsafe impl Send for IStreamAttributes {}
12661 unsafe impl Sync for IStreamAttributes {}
12662 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IStreamAttributes {}
12663 impl ::com_scrape_types::Unknown for IStreamAttributes {
12664 #[inline]
12665 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
12666 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
12667 }
12668 #[inline]
12669 unsafe fn add_ref(this: *mut Self) -> usize {
12670 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
12671 }
12672 #[inline]
12673 unsafe fn release(this: *mut Self) -> usize {
12674 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
12675 }
12676 }
12677 unsafe impl ::com_scrape_types::Interface for IStreamAttributes {
12678 type Vtbl = IStreamAttributesVtbl;
12679 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IStreamAttributes_iid);
12680 #[inline]
12681 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
12682 iid == &Self::IID || FUnknown::inherits(iid)
12683 }
12684 }
12685 #[repr(C)]
12686 #[derive(Copy, Clone)]
12687 pub struct IStreamAttributesVtbl {
12688 pub base: FUnknownVtbl,
12689 pub getFileName: unsafe extern "system" fn(
12690 this: *mut IStreamAttributes,
12691 name: *mut String128,
12692 ) -> tresult,
12693 pub getAttributes: unsafe extern "system" fn(
12694 this: *mut IStreamAttributes,
12695 ) -> *mut IAttributeList,
12696 }
12697 pub trait IStreamAttributesTrait {
12698 unsafe fn getFileName(
12699 &self,
12700 name: *mut String128,
12701 ) -> tresult;
12702 unsafe fn getAttributes(
12703 &self,
12704 ) -> *mut IAttributeList;
12705 }
12706 impl<P> IStreamAttributesTrait for P
12707 where
12708 P: ::com_scrape_types::SmartPtr,
12709 P::Target: ::com_scrape_types::Inherits<IStreamAttributes>,
12710 {
12711 #[inline]
12712 unsafe fn getFileName(
12713 &self,
12714 name: *mut String128,
12715 ) -> tresult {
12716 let ptr = self.ptr() as *mut IStreamAttributes;
12717 ((*(*ptr).vtbl).getFileName)(
12718 ptr,
12719 name,
12720 )
12721 }
12722 #[inline]
12723 unsafe fn getAttributes(
12724 &self,
12725 ) -> *mut IAttributeList {
12726 let ptr = self.ptr() as *mut IStreamAttributes;
12727 ((*(*ptr).vtbl).getAttributes)(
12728 ptr,
12729 )
12730 }
12731 }
12732 impl IStreamAttributes {
12733 const fn make_vtbl<C, W, const OFFSET: isize>() -> IStreamAttributesVtbl
12734 where
12735 C: IStreamAttributesTrait + ::com_scrape_types::Class,
12736 W: ::com_scrape_types::Wrapper<C>,
12737 {
12738 unsafe extern "system" fn getFileName<C, W, const OFFSET: isize>(
12739 this: *mut IStreamAttributes,
12740 name: *mut String128,
12741 ) -> tresult
12742 where
12743 C: IStreamAttributesTrait + ::com_scrape_types::Class,
12744 W: ::com_scrape_types::Wrapper<C>,
12745 {
12746 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
12747 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
12748 (*ptr).getFileName(
12749 name,
12750 )
12751 }
12752 unsafe extern "system" fn getAttributes<C, W, const OFFSET: isize>(
12753 this: *mut IStreamAttributes,
12754 ) -> *mut IAttributeList
12755 where
12756 C: IStreamAttributesTrait + ::com_scrape_types::Class,
12757 W: ::com_scrape_types::Wrapper<C>,
12758 {
12759 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
12760 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
12761 (*ptr).getAttributes(
12762 )
12763 }
12764 IStreamAttributesVtbl {
12765 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
12766 getFileName: getFileName::<C, W, OFFSET>,
12767 getAttributes: getAttributes::<C, W, OFFSET>,
12768 }
12769 }
12770 }
12771 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IStreamAttributes
12772 where
12773 C: IStreamAttributesTrait + ::com_scrape_types::Class,
12774 W: ::com_scrape_types::Wrapper<C>,
12775 {
12776 const OBJ: Self = IStreamAttributes {
12777 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
12778 };
12779 }
12780 #[repr(C)]
12781 #[derive(Copy, Clone)]
12782 pub struct IUnitData {
12783 pub vtbl: *const IUnitDataVtbl,
12784 }
12785 unsafe impl Send for IUnitData {}
12786 unsafe impl Sync for IUnitData {}
12787 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IUnitData {}
12788 impl ::com_scrape_types::Unknown for IUnitData {
12789 #[inline]
12790 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
12791 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
12792 }
12793 #[inline]
12794 unsafe fn add_ref(this: *mut Self) -> usize {
12795 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
12796 }
12797 #[inline]
12798 unsafe fn release(this: *mut Self) -> usize {
12799 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
12800 }
12801 }
12802 unsafe impl ::com_scrape_types::Interface for IUnitData {
12803 type Vtbl = IUnitDataVtbl;
12804 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IUnitData_iid);
12805 #[inline]
12806 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
12807 iid == &Self::IID || FUnknown::inherits(iid)
12808 }
12809 }
12810 #[repr(C)]
12811 #[derive(Copy, Clone)]
12812 pub struct IUnitDataVtbl {
12813 pub base: FUnknownVtbl,
12814 pub unitDataSupported: unsafe extern "system" fn(
12815 this: *mut IUnitData,
12816 unitID: UnitID,
12817 ) -> tresult,
12818 pub getUnitData: unsafe extern "system" fn(
12819 this: *mut IUnitData,
12820 unitId: UnitID,
12821 data: *mut IBStream,
12822 ) -> tresult,
12823 pub setUnitData: unsafe extern "system" fn(
12824 this: *mut IUnitData,
12825 unitId: UnitID,
12826 data: *mut IBStream,
12827 ) -> tresult,
12828 }
12829 pub trait IUnitDataTrait {
12830 unsafe fn unitDataSupported(
12831 &self,
12832 unitID: UnitID,
12833 ) -> tresult;
12834 unsafe fn getUnitData(
12835 &self,
12836 unitId: UnitID,
12837 data: *mut IBStream,
12838 ) -> tresult;
12839 unsafe fn setUnitData(
12840 &self,
12841 unitId: UnitID,
12842 data: *mut IBStream,
12843 ) -> tresult;
12844 }
12845 impl<P> IUnitDataTrait for P
12846 where
12847 P: ::com_scrape_types::SmartPtr,
12848 P::Target: ::com_scrape_types::Inherits<IUnitData>,
12849 {
12850 #[inline]
12851 unsafe fn unitDataSupported(
12852 &self,
12853 unitID: UnitID,
12854 ) -> tresult {
12855 let ptr = self.ptr() as *mut IUnitData;
12856 ((*(*ptr).vtbl).unitDataSupported)(
12857 ptr,
12858 unitID,
12859 )
12860 }
12861 #[inline]
12862 unsafe fn getUnitData(
12863 &self,
12864 unitId: UnitID,
12865 data: *mut IBStream,
12866 ) -> tresult {
12867 let ptr = self.ptr() as *mut IUnitData;
12868 ((*(*ptr).vtbl).getUnitData)(
12869 ptr,
12870 unitId,
12871 data,
12872 )
12873 }
12874 #[inline]
12875 unsafe fn setUnitData(
12876 &self,
12877 unitId: UnitID,
12878 data: *mut IBStream,
12879 ) -> tresult {
12880 let ptr = self.ptr() as *mut IUnitData;
12881 ((*(*ptr).vtbl).setUnitData)(
12882 ptr,
12883 unitId,
12884 data,
12885 )
12886 }
12887 }
12888 impl IUnitData {
12889 const fn make_vtbl<C, W, const OFFSET: isize>() -> IUnitDataVtbl
12890 where
12891 C: IUnitDataTrait + ::com_scrape_types::Class,
12892 W: ::com_scrape_types::Wrapper<C>,
12893 {
12894 unsafe extern "system" fn unitDataSupported<C, W, const OFFSET: isize>(
12895 this: *mut IUnitData,
12896 unitID: UnitID,
12897 ) -> tresult
12898 where
12899 C: IUnitDataTrait + ::com_scrape_types::Class,
12900 W: ::com_scrape_types::Wrapper<C>,
12901 {
12902 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
12903 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
12904 (*ptr).unitDataSupported(
12905 unitID,
12906 )
12907 }
12908 unsafe extern "system" fn getUnitData<C, W, const OFFSET: isize>(
12909 this: *mut IUnitData,
12910 unitId: UnitID,
12911 data: *mut IBStream,
12912 ) -> tresult
12913 where
12914 C: IUnitDataTrait + ::com_scrape_types::Class,
12915 W: ::com_scrape_types::Wrapper<C>,
12916 {
12917 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
12918 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
12919 (*ptr).getUnitData(
12920 unitId,
12921 data,
12922 )
12923 }
12924 unsafe extern "system" fn setUnitData<C, W, const OFFSET: isize>(
12925 this: *mut IUnitData,
12926 unitId: UnitID,
12927 data: *mut IBStream,
12928 ) -> tresult
12929 where
12930 C: IUnitDataTrait + ::com_scrape_types::Class,
12931 W: ::com_scrape_types::Wrapper<C>,
12932 {
12933 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
12934 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
12935 (*ptr).setUnitData(
12936 unitId,
12937 data,
12938 )
12939 }
12940 IUnitDataVtbl {
12941 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
12942 unitDataSupported: unitDataSupported::<C, W, OFFSET>,
12943 getUnitData: getUnitData::<C, W, OFFSET>,
12944 setUnitData: setUnitData::<C, W, OFFSET>,
12945 }
12946 }
12947 }
12948 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IUnitData
12949 where
12950 C: IUnitDataTrait + ::com_scrape_types::Class,
12951 W: ::com_scrape_types::Wrapper<C>,
12952 {
12953 const OBJ: Self = IUnitData {
12954 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
12955 };
12956 }
12957 #[repr(C)]
12958 #[derive(Copy, Clone)]
12959 pub struct IUnitHandler {
12960 pub vtbl: *const IUnitHandlerVtbl,
12961 }
12962 unsafe impl Send for IUnitHandler {}
12963 unsafe impl Sync for IUnitHandler {}
12964 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IUnitHandler {}
12965 impl ::com_scrape_types::Unknown for IUnitHandler {
12966 #[inline]
12967 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
12968 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
12969 }
12970 #[inline]
12971 unsafe fn add_ref(this: *mut Self) -> usize {
12972 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
12973 }
12974 #[inline]
12975 unsafe fn release(this: *mut Self) -> usize {
12976 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
12977 }
12978 }
12979 unsafe impl ::com_scrape_types::Interface for IUnitHandler {
12980 type Vtbl = IUnitHandlerVtbl;
12981 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IUnitHandler_iid);
12982 #[inline]
12983 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
12984 iid == &Self::IID || FUnknown::inherits(iid)
12985 }
12986 }
12987 #[repr(C)]
12988 #[derive(Copy, Clone)]
12989 pub struct IUnitHandlerVtbl {
12990 pub base: FUnknownVtbl,
12991 pub notifyUnitSelection: unsafe extern "system" fn(
12992 this: *mut IUnitHandler,
12993 unitId: UnitID,
12994 ) -> tresult,
12995 pub notifyProgramListChange: unsafe extern "system" fn(
12996 this: *mut IUnitHandler,
12997 listId: ProgramListID,
12998 programIndex: int32,
12999 ) -> tresult,
13000 }
13001 pub trait IUnitHandlerTrait {
13002 unsafe fn notifyUnitSelection(
13003 &self,
13004 unitId: UnitID,
13005 ) -> tresult;
13006 unsafe fn notifyProgramListChange(
13007 &self,
13008 listId: ProgramListID,
13009 programIndex: int32,
13010 ) -> tresult;
13011 }
13012 impl<P> IUnitHandlerTrait for P
13013 where
13014 P: ::com_scrape_types::SmartPtr,
13015 P::Target: ::com_scrape_types::Inherits<IUnitHandler>,
13016 {
13017 #[inline]
13018 unsafe fn notifyUnitSelection(
13019 &self,
13020 unitId: UnitID,
13021 ) -> tresult {
13022 let ptr = self.ptr() as *mut IUnitHandler;
13023 ((*(*ptr).vtbl).notifyUnitSelection)(
13024 ptr,
13025 unitId,
13026 )
13027 }
13028 #[inline]
13029 unsafe fn notifyProgramListChange(
13030 &self,
13031 listId: ProgramListID,
13032 programIndex: int32,
13033 ) -> tresult {
13034 let ptr = self.ptr() as *mut IUnitHandler;
13035 ((*(*ptr).vtbl).notifyProgramListChange)(
13036 ptr,
13037 listId,
13038 programIndex,
13039 )
13040 }
13041 }
13042 impl IUnitHandler {
13043 const fn make_vtbl<C, W, const OFFSET: isize>() -> IUnitHandlerVtbl
13044 where
13045 C: IUnitHandlerTrait + ::com_scrape_types::Class,
13046 W: ::com_scrape_types::Wrapper<C>,
13047 {
13048 unsafe extern "system" fn notifyUnitSelection<C, W, const OFFSET: isize>(
13049 this: *mut IUnitHandler,
13050 unitId: UnitID,
13051 ) -> tresult
13052 where
13053 C: IUnitHandlerTrait + ::com_scrape_types::Class,
13054 W: ::com_scrape_types::Wrapper<C>,
13055 {
13056 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
13057 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
13058 (*ptr).notifyUnitSelection(
13059 unitId,
13060 )
13061 }
13062 unsafe extern "system" fn notifyProgramListChange<C, W, const OFFSET: isize>(
13063 this: *mut IUnitHandler,
13064 listId: ProgramListID,
13065 programIndex: int32,
13066 ) -> tresult
13067 where
13068 C: IUnitHandlerTrait + ::com_scrape_types::Class,
13069 W: ::com_scrape_types::Wrapper<C>,
13070 {
13071 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
13072 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
13073 (*ptr).notifyProgramListChange(
13074 listId,
13075 programIndex,
13076 )
13077 }
13078 IUnitHandlerVtbl {
13079 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
13080 notifyUnitSelection: notifyUnitSelection::<C, W, OFFSET>,
13081 notifyProgramListChange: notifyProgramListChange::<C, W, OFFSET>,
13082 }
13083 }
13084 }
13085 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IUnitHandler
13086 where
13087 C: IUnitHandlerTrait + ::com_scrape_types::Class,
13088 W: ::com_scrape_types::Wrapper<C>,
13089 {
13090 const OBJ: Self = IUnitHandler {
13091 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
13092 };
13093 }
13094 #[repr(C)]
13095 #[derive(Copy, Clone)]
13096 pub struct IUnitHandler2 {
13097 pub vtbl: *const IUnitHandler2Vtbl,
13098 }
13099 unsafe impl Send for IUnitHandler2 {}
13100 unsafe impl Sync for IUnitHandler2 {}
13101 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IUnitHandler2 {}
13102 impl ::com_scrape_types::Unknown for IUnitHandler2 {
13103 #[inline]
13104 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
13105 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
13106 }
13107 #[inline]
13108 unsafe fn add_ref(this: *mut Self) -> usize {
13109 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
13110 }
13111 #[inline]
13112 unsafe fn release(this: *mut Self) -> usize {
13113 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
13114 }
13115 }
13116 unsafe impl ::com_scrape_types::Interface for IUnitHandler2 {
13117 type Vtbl = IUnitHandler2Vtbl;
13118 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IUnitHandler2_iid);
13119 #[inline]
13120 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
13121 iid == &Self::IID || FUnknown::inherits(iid)
13122 }
13123 }
13124 #[repr(C)]
13125 #[derive(Copy, Clone)]
13126 pub struct IUnitHandler2Vtbl {
13127 pub base: FUnknownVtbl,
13128 pub notifyUnitByBusChange: unsafe extern "system" fn(
13129 this: *mut IUnitHandler2,
13130 ) -> tresult,
13131 }
13132 pub trait IUnitHandler2Trait {
13133 unsafe fn notifyUnitByBusChange(
13134 &self,
13135 ) -> tresult;
13136 }
13137 impl<P> IUnitHandler2Trait for P
13138 where
13139 P: ::com_scrape_types::SmartPtr,
13140 P::Target: ::com_scrape_types::Inherits<IUnitHandler2>,
13141 {
13142 #[inline]
13143 unsafe fn notifyUnitByBusChange(
13144 &self,
13145 ) -> tresult {
13146 let ptr = self.ptr() as *mut IUnitHandler2;
13147 ((*(*ptr).vtbl).notifyUnitByBusChange)(
13148 ptr,
13149 )
13150 }
13151 }
13152 impl IUnitHandler2 {
13153 const fn make_vtbl<C, W, const OFFSET: isize>() -> IUnitHandler2Vtbl
13154 where
13155 C: IUnitHandler2Trait + ::com_scrape_types::Class,
13156 W: ::com_scrape_types::Wrapper<C>,
13157 {
13158 unsafe extern "system" fn notifyUnitByBusChange<C, W, const OFFSET: isize>(
13159 this: *mut IUnitHandler2,
13160 ) -> tresult
13161 where
13162 C: IUnitHandler2Trait + ::com_scrape_types::Class,
13163 W: ::com_scrape_types::Wrapper<C>,
13164 {
13165 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
13166 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
13167 (*ptr).notifyUnitByBusChange(
13168 )
13169 }
13170 IUnitHandler2Vtbl {
13171 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
13172 notifyUnitByBusChange: notifyUnitByBusChange::<C, W, OFFSET>,
13173 }
13174 }
13175 }
13176 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IUnitHandler2
13177 where
13178 C: IUnitHandler2Trait + ::com_scrape_types::Class,
13179 W: ::com_scrape_types::Wrapper<C>,
13180 {
13181 const OBJ: Self = IUnitHandler2 {
13182 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
13183 };
13184 }
13185 #[repr(C)]
13186 #[derive(Copy, Clone)]
13187 pub struct IUnitInfo {
13188 pub vtbl: *const IUnitInfoVtbl,
13189 }
13190 unsafe impl Send for IUnitInfo {}
13191 unsafe impl Sync for IUnitInfo {}
13192 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IUnitInfo {}
13193 impl ::com_scrape_types::Unknown for IUnitInfo {
13194 #[inline]
13195 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
13196 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
13197 }
13198 #[inline]
13199 unsafe fn add_ref(this: *mut Self) -> usize {
13200 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
13201 }
13202 #[inline]
13203 unsafe fn release(this: *mut Self) -> usize {
13204 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
13205 }
13206 }
13207 unsafe impl ::com_scrape_types::Interface for IUnitInfo {
13208 type Vtbl = IUnitInfoVtbl;
13209 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IUnitInfo_iid);
13210 #[inline]
13211 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
13212 iid == &Self::IID || FUnknown::inherits(iid)
13213 }
13214 }
13215 #[repr(C)]
13216 #[derive(Copy, Clone)]
13217 pub struct IUnitInfoVtbl {
13218 pub base: FUnknownVtbl,
13219 pub getUnitCount: unsafe extern "system" fn(
13220 this: *mut IUnitInfo,
13221 ) -> int32,
13222 pub getUnitInfo: unsafe extern "system" fn(
13223 this: *mut IUnitInfo,
13224 unitIndex: int32,
13225 info: *mut UnitInfo,
13226 ) -> tresult,
13227 pub getProgramListCount: unsafe extern "system" fn(
13228 this: *mut IUnitInfo,
13229 ) -> int32,
13230 pub getProgramListInfo: unsafe extern "system" fn(
13231 this: *mut IUnitInfo,
13232 listIndex: int32,
13233 info: *mut ProgramListInfo,
13234 ) -> tresult,
13235 pub getProgramName: unsafe extern "system" fn(
13236 this: *mut IUnitInfo,
13237 listId: ProgramListID,
13238 programIndex: int32,
13239 name: *mut String128,
13240 ) -> tresult,
13241 pub getProgramInfo: unsafe extern "system" fn(
13242 this: *mut IUnitInfo,
13243 listId: ProgramListID,
13244 programIndex: int32,
13245 attributeId: CString,
13246 attributeValue: *mut String128,
13247 ) -> tresult,
13248 pub hasProgramPitchNames: unsafe extern "system" fn(
13249 this: *mut IUnitInfo,
13250 listId: ProgramListID,
13251 programIndex: int32,
13252 ) -> tresult,
13253 pub getProgramPitchName: unsafe extern "system" fn(
13254 this: *mut IUnitInfo,
13255 listId: ProgramListID,
13256 programIndex: int32,
13257 midiPitch: int16,
13258 name: *mut String128,
13259 ) -> tresult,
13260 pub getSelectedUnit: unsafe extern "system" fn(
13261 this: *mut IUnitInfo,
13262 ) -> UnitID,
13263 pub selectUnit: unsafe extern "system" fn(
13264 this: *mut IUnitInfo,
13265 unitId: UnitID,
13266 ) -> tresult,
13267 pub getUnitByBus: unsafe extern "system" fn(
13268 this: *mut IUnitInfo,
13269 r#type: MediaType,
13270 dir: BusDirection,
13271 busIndex: int32,
13272 channel: int32,
13273 unitId: *mut UnitID,
13274 ) -> tresult,
13275 pub setUnitProgramData: unsafe extern "system" fn(
13276 this: *mut IUnitInfo,
13277 listOrUnitId: int32,
13278 programIndex: int32,
13279 data: *mut IBStream,
13280 ) -> tresult,
13281 }
13282 pub trait IUnitInfoTrait {
13283 unsafe fn getUnitCount(
13284 &self,
13285 ) -> int32;
13286 unsafe fn getUnitInfo(
13287 &self,
13288 unitIndex: int32,
13289 info: *mut UnitInfo,
13290 ) -> tresult;
13291 unsafe fn getProgramListCount(
13292 &self,
13293 ) -> int32;
13294 unsafe fn getProgramListInfo(
13295 &self,
13296 listIndex: int32,
13297 info: *mut ProgramListInfo,
13298 ) -> tresult;
13299 unsafe fn getProgramName(
13300 &self,
13301 listId: ProgramListID,
13302 programIndex: int32,
13303 name: *mut String128,
13304 ) -> tresult;
13305 unsafe fn getProgramInfo(
13306 &self,
13307 listId: ProgramListID,
13308 programIndex: int32,
13309 attributeId: CString,
13310 attributeValue: *mut String128,
13311 ) -> tresult;
13312 unsafe fn hasProgramPitchNames(
13313 &self,
13314 listId: ProgramListID,
13315 programIndex: int32,
13316 ) -> tresult;
13317 unsafe fn getProgramPitchName(
13318 &self,
13319 listId: ProgramListID,
13320 programIndex: int32,
13321 midiPitch: int16,
13322 name: *mut String128,
13323 ) -> tresult;
13324 unsafe fn getSelectedUnit(
13325 &self,
13326 ) -> UnitID;
13327 unsafe fn selectUnit(
13328 &self,
13329 unitId: UnitID,
13330 ) -> tresult;
13331 unsafe fn getUnitByBus(
13332 &self,
13333 r#type: MediaType,
13334 dir: BusDirection,
13335 busIndex: int32,
13336 channel: int32,
13337 unitId: *mut UnitID,
13338 ) -> tresult;
13339 unsafe fn setUnitProgramData(
13340 &self,
13341 listOrUnitId: int32,
13342 programIndex: int32,
13343 data: *mut IBStream,
13344 ) -> tresult;
13345 }
13346 impl<P> IUnitInfoTrait for P
13347 where
13348 P: ::com_scrape_types::SmartPtr,
13349 P::Target: ::com_scrape_types::Inherits<IUnitInfo>,
13350 {
13351 #[inline]
13352 unsafe fn getUnitCount(
13353 &self,
13354 ) -> int32 {
13355 let ptr = self.ptr() as *mut IUnitInfo;
13356 ((*(*ptr).vtbl).getUnitCount)(
13357 ptr,
13358 )
13359 }
13360 #[inline]
13361 unsafe fn getUnitInfo(
13362 &self,
13363 unitIndex: int32,
13364 info: *mut UnitInfo,
13365 ) -> tresult {
13366 let ptr = self.ptr() as *mut IUnitInfo;
13367 ((*(*ptr).vtbl).getUnitInfo)(
13368 ptr,
13369 unitIndex,
13370 info,
13371 )
13372 }
13373 #[inline]
13374 unsafe fn getProgramListCount(
13375 &self,
13376 ) -> int32 {
13377 let ptr = self.ptr() as *mut IUnitInfo;
13378 ((*(*ptr).vtbl).getProgramListCount)(
13379 ptr,
13380 )
13381 }
13382 #[inline]
13383 unsafe fn getProgramListInfo(
13384 &self,
13385 listIndex: int32,
13386 info: *mut ProgramListInfo,
13387 ) -> tresult {
13388 let ptr = self.ptr() as *mut IUnitInfo;
13389 ((*(*ptr).vtbl).getProgramListInfo)(
13390 ptr,
13391 listIndex,
13392 info,
13393 )
13394 }
13395 #[inline]
13396 unsafe fn getProgramName(
13397 &self,
13398 listId: ProgramListID,
13399 programIndex: int32,
13400 name: *mut String128,
13401 ) -> tresult {
13402 let ptr = self.ptr() as *mut IUnitInfo;
13403 ((*(*ptr).vtbl).getProgramName)(
13404 ptr,
13405 listId,
13406 programIndex,
13407 name,
13408 )
13409 }
13410 #[inline]
13411 unsafe fn getProgramInfo(
13412 &self,
13413 listId: ProgramListID,
13414 programIndex: int32,
13415 attributeId: CString,
13416 attributeValue: *mut String128,
13417 ) -> tresult {
13418 let ptr = self.ptr() as *mut IUnitInfo;
13419 ((*(*ptr).vtbl).getProgramInfo)(
13420 ptr,
13421 listId,
13422 programIndex,
13423 attributeId,
13424 attributeValue,
13425 )
13426 }
13427 #[inline]
13428 unsafe fn hasProgramPitchNames(
13429 &self,
13430 listId: ProgramListID,
13431 programIndex: int32,
13432 ) -> tresult {
13433 let ptr = self.ptr() as *mut IUnitInfo;
13434 ((*(*ptr).vtbl).hasProgramPitchNames)(
13435 ptr,
13436 listId,
13437 programIndex,
13438 )
13439 }
13440 #[inline]
13441 unsafe fn getProgramPitchName(
13442 &self,
13443 listId: ProgramListID,
13444 programIndex: int32,
13445 midiPitch: int16,
13446 name: *mut String128,
13447 ) -> tresult {
13448 let ptr = self.ptr() as *mut IUnitInfo;
13449 ((*(*ptr).vtbl).getProgramPitchName)(
13450 ptr,
13451 listId,
13452 programIndex,
13453 midiPitch,
13454 name,
13455 )
13456 }
13457 #[inline]
13458 unsafe fn getSelectedUnit(
13459 &self,
13460 ) -> UnitID {
13461 let ptr = self.ptr() as *mut IUnitInfo;
13462 ((*(*ptr).vtbl).getSelectedUnit)(
13463 ptr,
13464 )
13465 }
13466 #[inline]
13467 unsafe fn selectUnit(
13468 &self,
13469 unitId: UnitID,
13470 ) -> tresult {
13471 let ptr = self.ptr() as *mut IUnitInfo;
13472 ((*(*ptr).vtbl).selectUnit)(
13473 ptr,
13474 unitId,
13475 )
13476 }
13477 #[inline]
13478 unsafe fn getUnitByBus(
13479 &self,
13480 r#type: MediaType,
13481 dir: BusDirection,
13482 busIndex: int32,
13483 channel: int32,
13484 unitId: *mut UnitID,
13485 ) -> tresult {
13486 let ptr = self.ptr() as *mut IUnitInfo;
13487 ((*(*ptr).vtbl).getUnitByBus)(
13488 ptr,
13489 r#type,
13490 dir,
13491 busIndex,
13492 channel,
13493 unitId,
13494 )
13495 }
13496 #[inline]
13497 unsafe fn setUnitProgramData(
13498 &self,
13499 listOrUnitId: int32,
13500 programIndex: int32,
13501 data: *mut IBStream,
13502 ) -> tresult {
13503 let ptr = self.ptr() as *mut IUnitInfo;
13504 ((*(*ptr).vtbl).setUnitProgramData)(
13505 ptr,
13506 listOrUnitId,
13507 programIndex,
13508 data,
13509 )
13510 }
13511 }
13512 impl IUnitInfo {
13513 const fn make_vtbl<C, W, const OFFSET: isize>() -> IUnitInfoVtbl
13514 where
13515 C: IUnitInfoTrait + ::com_scrape_types::Class,
13516 W: ::com_scrape_types::Wrapper<C>,
13517 {
13518 unsafe extern "system" fn getUnitCount<C, W, const OFFSET: isize>(
13519 this: *mut IUnitInfo,
13520 ) -> int32
13521 where
13522 C: IUnitInfoTrait + ::com_scrape_types::Class,
13523 W: ::com_scrape_types::Wrapper<C>,
13524 {
13525 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
13526 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
13527 (*ptr).getUnitCount(
13528 )
13529 }
13530 unsafe extern "system" fn getUnitInfo<C, W, const OFFSET: isize>(
13531 this: *mut IUnitInfo,
13532 unitIndex: int32,
13533 info: *mut UnitInfo,
13534 ) -> tresult
13535 where
13536 C: IUnitInfoTrait + ::com_scrape_types::Class,
13537 W: ::com_scrape_types::Wrapper<C>,
13538 {
13539 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
13540 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
13541 (*ptr).getUnitInfo(
13542 unitIndex,
13543 info,
13544 )
13545 }
13546 unsafe extern "system" fn getProgramListCount<C, W, const OFFSET: isize>(
13547 this: *mut IUnitInfo,
13548 ) -> int32
13549 where
13550 C: IUnitInfoTrait + ::com_scrape_types::Class,
13551 W: ::com_scrape_types::Wrapper<C>,
13552 {
13553 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
13554 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
13555 (*ptr).getProgramListCount(
13556 )
13557 }
13558 unsafe extern "system" fn getProgramListInfo<C, W, const OFFSET: isize>(
13559 this: *mut IUnitInfo,
13560 listIndex: int32,
13561 info: *mut ProgramListInfo,
13562 ) -> tresult
13563 where
13564 C: IUnitInfoTrait + ::com_scrape_types::Class,
13565 W: ::com_scrape_types::Wrapper<C>,
13566 {
13567 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
13568 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
13569 (*ptr).getProgramListInfo(
13570 listIndex,
13571 info,
13572 )
13573 }
13574 unsafe extern "system" fn getProgramName<C, W, const OFFSET: isize>(
13575 this: *mut IUnitInfo,
13576 listId: ProgramListID,
13577 programIndex: int32,
13578 name: *mut String128,
13579 ) -> tresult
13580 where
13581 C: IUnitInfoTrait + ::com_scrape_types::Class,
13582 W: ::com_scrape_types::Wrapper<C>,
13583 {
13584 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
13585 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
13586 (*ptr).getProgramName(
13587 listId,
13588 programIndex,
13589 name,
13590 )
13591 }
13592 unsafe extern "system" fn getProgramInfo<C, W, const OFFSET: isize>(
13593 this: *mut IUnitInfo,
13594 listId: ProgramListID,
13595 programIndex: int32,
13596 attributeId: CString,
13597 attributeValue: *mut String128,
13598 ) -> tresult
13599 where
13600 C: IUnitInfoTrait + ::com_scrape_types::Class,
13601 W: ::com_scrape_types::Wrapper<C>,
13602 {
13603 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
13604 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
13605 (*ptr).getProgramInfo(
13606 listId,
13607 programIndex,
13608 attributeId,
13609 attributeValue,
13610 )
13611 }
13612 unsafe extern "system" fn hasProgramPitchNames<C, W, const OFFSET: isize>(
13613 this: *mut IUnitInfo,
13614 listId: ProgramListID,
13615 programIndex: int32,
13616 ) -> tresult
13617 where
13618 C: IUnitInfoTrait + ::com_scrape_types::Class,
13619 W: ::com_scrape_types::Wrapper<C>,
13620 {
13621 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
13622 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
13623 (*ptr).hasProgramPitchNames(
13624 listId,
13625 programIndex,
13626 )
13627 }
13628 unsafe extern "system" fn getProgramPitchName<C, W, const OFFSET: isize>(
13629 this: *mut IUnitInfo,
13630 listId: ProgramListID,
13631 programIndex: int32,
13632 midiPitch: int16,
13633 name: *mut String128,
13634 ) -> tresult
13635 where
13636 C: IUnitInfoTrait + ::com_scrape_types::Class,
13637 W: ::com_scrape_types::Wrapper<C>,
13638 {
13639 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
13640 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
13641 (*ptr).getProgramPitchName(
13642 listId,
13643 programIndex,
13644 midiPitch,
13645 name,
13646 )
13647 }
13648 unsafe extern "system" fn getSelectedUnit<C, W, const OFFSET: isize>(
13649 this: *mut IUnitInfo,
13650 ) -> UnitID
13651 where
13652 C: IUnitInfoTrait + ::com_scrape_types::Class,
13653 W: ::com_scrape_types::Wrapper<C>,
13654 {
13655 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
13656 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
13657 (*ptr).getSelectedUnit(
13658 )
13659 }
13660 unsafe extern "system" fn selectUnit<C, W, const OFFSET: isize>(
13661 this: *mut IUnitInfo,
13662 unitId: UnitID,
13663 ) -> tresult
13664 where
13665 C: IUnitInfoTrait + ::com_scrape_types::Class,
13666 W: ::com_scrape_types::Wrapper<C>,
13667 {
13668 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
13669 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
13670 (*ptr).selectUnit(
13671 unitId,
13672 )
13673 }
13674 unsafe extern "system" fn getUnitByBus<C, W, const OFFSET: isize>(
13675 this: *mut IUnitInfo,
13676 r#type: MediaType,
13677 dir: BusDirection,
13678 busIndex: int32,
13679 channel: int32,
13680 unitId: *mut UnitID,
13681 ) -> tresult
13682 where
13683 C: IUnitInfoTrait + ::com_scrape_types::Class,
13684 W: ::com_scrape_types::Wrapper<C>,
13685 {
13686 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
13687 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
13688 (*ptr).getUnitByBus(
13689 r#type,
13690 dir,
13691 busIndex,
13692 channel,
13693 unitId,
13694 )
13695 }
13696 unsafe extern "system" fn setUnitProgramData<C, W, const OFFSET: isize>(
13697 this: *mut IUnitInfo,
13698 listOrUnitId: int32,
13699 programIndex: int32,
13700 data: *mut IBStream,
13701 ) -> tresult
13702 where
13703 C: IUnitInfoTrait + ::com_scrape_types::Class,
13704 W: ::com_scrape_types::Wrapper<C>,
13705 {
13706 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
13707 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
13708 (*ptr).setUnitProgramData(
13709 listOrUnitId,
13710 programIndex,
13711 data,
13712 )
13713 }
13714 IUnitInfoVtbl {
13715 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
13716 getUnitCount: getUnitCount::<C, W, OFFSET>,
13717 getUnitInfo: getUnitInfo::<C, W, OFFSET>,
13718 getProgramListCount: getProgramListCount::<C, W, OFFSET>,
13719 getProgramListInfo: getProgramListInfo::<C, W, OFFSET>,
13720 getProgramName: getProgramName::<C, W, OFFSET>,
13721 getProgramInfo: getProgramInfo::<C, W, OFFSET>,
13722 hasProgramPitchNames: hasProgramPitchNames::<C, W, OFFSET>,
13723 getProgramPitchName: getProgramPitchName::<C, W, OFFSET>,
13724 getSelectedUnit: getSelectedUnit::<C, W, OFFSET>,
13725 selectUnit: selectUnit::<C, W, OFFSET>,
13726 getUnitByBus: getUnitByBus::<C, W, OFFSET>,
13727 setUnitProgramData: setUnitProgramData::<C, W, OFFSET>,
13728 }
13729 }
13730 }
13731 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IUnitInfo
13732 where
13733 C: IUnitInfoTrait + ::com_scrape_types::Class,
13734 W: ::com_scrape_types::Wrapper<C>,
13735 {
13736 const OBJ: Self = IUnitInfo {
13737 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
13738 };
13739 }
13740 #[repr(C)]
13741 #[derive(Copy, Clone)]
13742 pub struct IVst3ToAAXWrapper {
13743 }
13744 unsafe impl Send for IVst3ToAAXWrapper {}
13745 unsafe impl Sync for IVst3ToAAXWrapper {}
13746 #[repr(C)]
13747 #[derive(Copy, Clone)]
13748 pub struct IVst3ToAUWrapper {
13749 }
13750 unsafe impl Send for IVst3ToAUWrapper {}
13751 unsafe impl Sync for IVst3ToAUWrapper {}
13752 #[repr(C)]
13753 #[derive(Copy, Clone)]
13754 pub struct IVst3ToVst2Wrapper {
13755 }
13756 unsafe impl Send for IVst3ToVst2Wrapper {}
13757 unsafe impl Sync for IVst3ToVst2Wrapper {}
13758 #[repr(C)]
13759 #[derive(Copy, Clone)]
13760 pub struct IVst3WrapperMPESupport {
13761 pub vtbl: *const IVst3WrapperMPESupportVtbl,
13762 }
13763 unsafe impl Send for IVst3WrapperMPESupport {}
13764 unsafe impl Sync for IVst3WrapperMPESupport {}
13765 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IVst3WrapperMPESupport {}
13766 impl ::com_scrape_types::Unknown for IVst3WrapperMPESupport {
13767 #[inline]
13768 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
13769 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
13770 }
13771 #[inline]
13772 unsafe fn add_ref(this: *mut Self) -> usize {
13773 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
13774 }
13775 #[inline]
13776 unsafe fn release(this: *mut Self) -> usize {
13777 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
13778 }
13779 }
13780 unsafe impl ::com_scrape_types::Interface for IVst3WrapperMPESupport {
13781 type Vtbl = IVst3WrapperMPESupportVtbl;
13782 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IVst3WrapperMPESupport_iid);
13783 #[inline]
13784 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
13785 iid == &Self::IID || FUnknown::inherits(iid)
13786 }
13787 }
13788 #[repr(C)]
13789 #[derive(Copy, Clone)]
13790 pub struct IVst3WrapperMPESupportVtbl {
13791 pub base: FUnknownVtbl,
13792 pub enableMPEInputProcessing: unsafe extern "system" fn(
13793 this: *mut IVst3WrapperMPESupport,
13794 state: TBool,
13795 ) -> tresult,
13796 pub setMPEInputDeviceSettings: unsafe extern "system" fn(
13797 this: *mut IVst3WrapperMPESupport,
13798 masterChannel: int32,
13799 memberBeginChannel: int32,
13800 memberEndChannel: int32,
13801 ) -> tresult,
13802 }
13803 pub trait IVst3WrapperMPESupportTrait {
13804 unsafe fn enableMPEInputProcessing(
13805 &self,
13806 state: TBool,
13807 ) -> tresult;
13808 unsafe fn setMPEInputDeviceSettings(
13809 &self,
13810 masterChannel: int32,
13811 memberBeginChannel: int32,
13812 memberEndChannel: int32,
13813 ) -> tresult;
13814 }
13815 impl<P> IVst3WrapperMPESupportTrait for P
13816 where
13817 P: ::com_scrape_types::SmartPtr,
13818 P::Target: ::com_scrape_types::Inherits<IVst3WrapperMPESupport>,
13819 {
13820 #[inline]
13821 unsafe fn enableMPEInputProcessing(
13822 &self,
13823 state: TBool,
13824 ) -> tresult {
13825 let ptr = self.ptr() as *mut IVst3WrapperMPESupport;
13826 ((*(*ptr).vtbl).enableMPEInputProcessing)(
13827 ptr,
13828 state,
13829 )
13830 }
13831 #[inline]
13832 unsafe fn setMPEInputDeviceSettings(
13833 &self,
13834 masterChannel: int32,
13835 memberBeginChannel: int32,
13836 memberEndChannel: int32,
13837 ) -> tresult {
13838 let ptr = self.ptr() as *mut IVst3WrapperMPESupport;
13839 ((*(*ptr).vtbl).setMPEInputDeviceSettings)(
13840 ptr,
13841 masterChannel,
13842 memberBeginChannel,
13843 memberEndChannel,
13844 )
13845 }
13846 }
13847 impl IVst3WrapperMPESupport {
13848 const fn make_vtbl<C, W, const OFFSET: isize>() -> IVst3WrapperMPESupportVtbl
13849 where
13850 C: IVst3WrapperMPESupportTrait + ::com_scrape_types::Class,
13851 W: ::com_scrape_types::Wrapper<C>,
13852 {
13853 unsafe extern "system" fn enableMPEInputProcessing<C, W, const OFFSET: isize>(
13854 this: *mut IVst3WrapperMPESupport,
13855 state: TBool,
13856 ) -> tresult
13857 where
13858 C: IVst3WrapperMPESupportTrait + ::com_scrape_types::Class,
13859 W: ::com_scrape_types::Wrapper<C>,
13860 {
13861 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
13862 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
13863 (*ptr).enableMPEInputProcessing(
13864 state,
13865 )
13866 }
13867 unsafe extern "system" fn setMPEInputDeviceSettings<C, W, const OFFSET: isize>(
13868 this: *mut IVst3WrapperMPESupport,
13869 masterChannel: int32,
13870 memberBeginChannel: int32,
13871 memberEndChannel: int32,
13872 ) -> tresult
13873 where
13874 C: IVst3WrapperMPESupportTrait + ::com_scrape_types::Class,
13875 W: ::com_scrape_types::Wrapper<C>,
13876 {
13877 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
13878 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
13879 (*ptr).setMPEInputDeviceSettings(
13880 masterChannel,
13881 memberBeginChannel,
13882 memberEndChannel,
13883 )
13884 }
13885 IVst3WrapperMPESupportVtbl {
13886 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
13887 enableMPEInputProcessing: enableMPEInputProcessing::<C, W, OFFSET>,
13888 setMPEInputDeviceSettings: setMPEInputDeviceSettings::<C, W, OFFSET>,
13889 }
13890 }
13891 }
13892 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IVst3WrapperMPESupport
13893 where
13894 C: IVst3WrapperMPESupportTrait + ::com_scrape_types::Class,
13895 W: ::com_scrape_types::Wrapper<C>,
13896 {
13897 const OBJ: Self = IVst3WrapperMPESupport {
13898 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
13899 };
13900 }
13901 #[repr(C)]
13902 #[derive(Copy, Clone)]
13903 pub struct IXmlRepresentationController {
13904 pub vtbl: *const IXmlRepresentationControllerVtbl,
13905 }
13906 unsafe impl Send for IXmlRepresentationController {}
13907 unsafe impl Sync for IXmlRepresentationController {}
13908 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IXmlRepresentationController {}
13909 impl ::com_scrape_types::Unknown for IXmlRepresentationController {
13910 #[inline]
13911 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
13912 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
13913 }
13914 #[inline]
13915 unsafe fn add_ref(this: *mut Self) -> usize {
13916 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
13917 }
13918 #[inline]
13919 unsafe fn release(this: *mut Self) -> usize {
13920 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
13921 }
13922 }
13923 unsafe impl ::com_scrape_types::Interface for IXmlRepresentationController {
13924 type Vtbl = IXmlRepresentationControllerVtbl;
13925 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IXmlRepresentationController_iid);
13926 #[inline]
13927 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
13928 iid == &Self::IID || FUnknown::inherits(iid)
13929 }
13930 }
13931 #[repr(C)]
13932 #[derive(Copy, Clone)]
13933 pub struct IXmlRepresentationControllerVtbl {
13934 pub base: FUnknownVtbl,
13935 pub getXmlRepresentationStream: unsafe extern "system" fn(
13936 this: *mut IXmlRepresentationController,
13937 info: *mut RepresentationInfo,
13938 stream: *mut IBStream,
13939 ) -> tresult,
13940 }
13941 pub trait IXmlRepresentationControllerTrait {
13942 unsafe fn getXmlRepresentationStream(
13943 &self,
13944 info: *mut RepresentationInfo,
13945 stream: *mut IBStream,
13946 ) -> tresult;
13947 }
13948 impl<P> IXmlRepresentationControllerTrait for P
13949 where
13950 P: ::com_scrape_types::SmartPtr,
13951 P::Target: ::com_scrape_types::Inherits<IXmlRepresentationController>,
13952 {
13953 #[inline]
13954 unsafe fn getXmlRepresentationStream(
13955 &self,
13956 info: *mut RepresentationInfo,
13957 stream: *mut IBStream,
13958 ) -> tresult {
13959 let ptr = self.ptr() as *mut IXmlRepresentationController;
13960 ((*(*ptr).vtbl).getXmlRepresentationStream)(
13961 ptr,
13962 info,
13963 stream,
13964 )
13965 }
13966 }
13967 impl IXmlRepresentationController {
13968 const fn make_vtbl<C, W, const OFFSET: isize>() -> IXmlRepresentationControllerVtbl
13969 where
13970 C: IXmlRepresentationControllerTrait + ::com_scrape_types::Class,
13971 W: ::com_scrape_types::Wrapper<C>,
13972 {
13973 unsafe extern "system" fn getXmlRepresentationStream<C, W, const OFFSET: isize>(
13974 this: *mut IXmlRepresentationController,
13975 info: *mut RepresentationInfo,
13976 stream: *mut IBStream,
13977 ) -> tresult
13978 where
13979 C: IXmlRepresentationControllerTrait + ::com_scrape_types::Class,
13980 W: ::com_scrape_types::Wrapper<C>,
13981 {
13982 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
13983 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
13984 (*ptr).getXmlRepresentationStream(
13985 info,
13986 stream,
13987 )
13988 }
13989 IXmlRepresentationControllerVtbl {
13990 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
13991 getXmlRepresentationStream: getXmlRepresentationStream::<C, W, OFFSET>,
13992 }
13993 }
13994 }
13995 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IXmlRepresentationController
13996 where
13997 C: IXmlRepresentationControllerTrait + ::com_scrape_types::Class,
13998 W: ::com_scrape_types::Wrapper<C>,
13999 {
14000 const OBJ: Self = IXmlRepresentationController {
14001 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
14002 };
14003 }
14004 #[repr(C)]
14005 #[derive(Copy, Clone)]
14006 pub struct KeyswitchInfo {
14007 pub typeId: KeyswitchTypeID,
14008 pub title: String128,
14009 pub shortTitle: String128,
14010 pub keyswitchMin: int32,
14011 pub keyswitchMax: int32,
14012 pub keyRemapped: int32,
14013 pub unitId: int32,
14014 pub flags: int32,
14015 }
14016 unsafe impl Send for KeyswitchInfo {}
14017 unsafe impl Sync for KeyswitchInfo {}
14018 #[repr(C)]
14019 #[derive(Copy, Clone)]
14020 pub struct LegacyMIDICCOutEvent {
14021 pub controlNumber: uint8,
14022 pub channel: int8,
14023 pub value: int8,
14024 pub value2: int8,
14025 }
14026 unsafe impl Send for LegacyMIDICCOutEvent {}
14027 unsafe impl Sync for LegacyMIDICCOutEvent {}
14028 #[repr(C)]
14029 #[derive(Copy, Clone)]
14030 pub struct Midi1ControllerParamIDAssignment {
14031 pub pId: ParamID,
14032 pub busIndex: BusIndex,
14033 pub channel: MidiChannel,
14034 pub controller: CtrlNumber,
14035 }
14036 unsafe impl Send for Midi1ControllerParamIDAssignment {}
14037 unsafe impl Sync for Midi1ControllerParamIDAssignment {}
14038 #[repr(C)]
14039 #[derive(Copy, Clone)]
14040 pub struct Midi1ControllerParamIDAssignmentList {
14041 pub count: uint32,
14042 pub map: *mut Midi1ControllerParamIDAssignment,
14043 }
14044 unsafe impl Send for Midi1ControllerParamIDAssignmentList {}
14045 unsafe impl Sync for Midi1ControllerParamIDAssignmentList {}
14046 #[repr(C)]
14047 #[derive(Copy, Clone)]
14048 pub struct Midi2Controller {
14049 pub bank: uint8,
14050 pub registered: TBool,
14051 pub index: uint8,
14052 pub reserved: TBool,
14053 }
14054 unsafe impl Send for Midi2Controller {}
14055 unsafe impl Sync for Midi2Controller {}
14056 #[repr(C)]
14057 #[derive(Copy, Clone)]
14058 pub struct Midi2ControllerParamIDAssignment {
14059 pub pId: ParamID,
14060 pub busIndex: BusIndex,
14061 pub channel: MidiChannel,
14062 pub controller: Midi2Controller,
14063 }
14064 unsafe impl Send for Midi2ControllerParamIDAssignment {}
14065 unsafe impl Sync for Midi2ControllerParamIDAssignment {}
14066 #[repr(C)]
14067 #[derive(Copy, Clone)]
14068 pub struct Midi2ControllerParamIDAssignmentList {
14069 pub count: uint32,
14070 pub map: *mut Midi2ControllerParamIDAssignment,
14071 }
14072 unsafe impl Send for Midi2ControllerParamIDAssignmentList {}
14073 unsafe impl Sync for Midi2ControllerParamIDAssignmentList {}
14074 #[repr(C)]
14075 #[derive(Copy, Clone)]
14076 pub struct NoteExpressionIntValueEvent {
14077 pub typeId: NoteExpressionTypeID,
14078 pub noteId: int32,
14079 pub value: uint64,
14080 }
14081 unsafe impl Send for NoteExpressionIntValueEvent {}
14082 unsafe impl Sync for NoteExpressionIntValueEvent {}
14083 #[repr(C)]
14084 #[derive(Copy, Clone)]
14085 pub struct NoteExpressionTextEvent {
14086 pub typeId: NoteExpressionTypeID,
14087 pub noteId: int32,
14088 pub textLen: uint32,
14089 pub text: *const TChar,
14090 }
14091 unsafe impl Send for NoteExpressionTextEvent {}
14092 unsafe impl Sync for NoteExpressionTextEvent {}
14093 mod __NoteExpressionTypeInfo_wrapper {
14094 #[allow(unused_imports)]
14095 use super::*;
14096 #[allow(unused_imports)]
14097 use super::NoteExpressionTypeInfo_::*;
14098 #[repr(C)]
14099 #[derive(Copy, Clone)]
14100 pub struct NoteExpressionTypeInfo {
14101 pub typeId: NoteExpressionTypeID,
14102 pub title: String128,
14103 pub shortTitle: String128,
14104 pub units: String128,
14105 pub unitId: int32,
14106 pub valueDesc: NoteExpressionValueDescription,
14107 pub associatedParameterId: ParamID,
14108 pub flags: int32,
14109 }
14110 unsafe impl Send for NoteExpressionTypeInfo {}
14111 unsafe impl Sync for NoteExpressionTypeInfo {}
14112 }
14113 pub use __NoteExpressionTypeInfo_wrapper::*;
14114 pub mod NoteExpressionTypeInfo_ {
14115 #[allow(unused_imports)]
14116 use super::*;
14117 pub type NoteExpressionTypeFlags = crate::support::DefaultEnumType;
14118 pub mod NoteExpressionTypeFlags_ {
14119 #[allow(unused_imports)]
14120 use super::*;
14121 pub const kAssociatedParameterIDValid: NoteExpressionTypeFlags = 8;
14122 pub const kIsAbsolute: NoteExpressionTypeFlags = 4;
14123 pub const kIsBipolar: NoteExpressionTypeFlags = 1;
14124 pub const kIsOneShot: NoteExpressionTypeFlags = 2;
14125 }
14126 }
14127 #[repr(C)]
14128 #[derive(Copy, Clone)]
14129 pub struct NoteExpressionValueDescription {
14130 pub defaultValue: NoteExpressionValue,
14131 pub minimum: NoteExpressionValue,
14132 pub maximum: NoteExpressionValue,
14133 pub stepCount: int32,
14134 }
14135 unsafe impl Send for NoteExpressionValueDescription {}
14136 unsafe impl Sync for NoteExpressionValueDescription {}
14137 #[repr(C)]
14138 #[derive(Copy, Clone)]
14139 pub struct NoteExpressionValueEvent {
14140 pub typeId: NoteExpressionTypeID,
14141 pub noteId: int32,
14142 pub value: NoteExpressionValue,
14143 }
14144 unsafe impl Send for NoteExpressionValueEvent {}
14145 unsafe impl Sync for NoteExpressionValueEvent {}
14146 #[repr(C)]
14147 #[derive(Copy, Clone)]
14148 pub struct NoteOffEvent {
14149 pub channel: int16,
14150 pub pitch: int16,
14151 pub velocity: f32,
14152 pub noteId: int32,
14153 pub tuning: f32,
14154 }
14155 unsafe impl Send for NoteOffEvent {}
14156 unsafe impl Sync for NoteOffEvent {}
14157 #[repr(C)]
14158 #[derive(Copy, Clone)]
14159 pub struct NoteOnEvent {
14160 pub channel: int16,
14161 pub pitch: int16,
14162 pub tuning: f32,
14163 pub velocity: f32,
14164 pub length: int32,
14165 pub noteId: int32,
14166 }
14167 unsafe impl Send for NoteOnEvent {}
14168 unsafe impl Sync for NoteOnEvent {}
14169 mod __ParameterInfo_wrapper {
14170 #[allow(unused_imports)]
14171 use super::*;
14172 #[allow(unused_imports)]
14173 use super::ParameterInfo_::*;
14174 #[repr(C)]
14175 #[derive(Copy, Clone)]
14176 pub struct ParameterInfo {
14177 pub id: ParamID,
14178 pub title: String128,
14179 pub shortTitle: String128,
14180 pub units: String128,
14181 pub stepCount: int32,
14182 pub defaultNormalizedValue: ParamValue,
14183 pub unitId: UnitID,
14184 pub flags: int32,
14185 }
14186 unsafe impl Send for ParameterInfo {}
14187 unsafe impl Sync for ParameterInfo {}
14188 }
14189 pub use __ParameterInfo_wrapper::*;
14190 pub mod ParameterInfo_ {
14191 #[allow(unused_imports)]
14192 use super::*;
14193 pub type ParameterFlags = int32;
14194 pub mod ParameterFlags_ {
14195 #[allow(unused_imports)]
14196 use super::*;
14197 pub const kCanAutomate: ParameterFlags = 1;
14198 pub const kIsBypass: ParameterFlags = 65536;
14199 pub const kIsHidden: ParameterFlags = 16;
14200 pub const kIsList: ParameterFlags = 8;
14201 pub const kIsProgramChange: ParameterFlags = 32768;
14202 pub const kIsReadOnly: ParameterFlags = 2;
14203 pub const kIsWrapAround: ParameterFlags = 4;
14204 pub const kNoFlags: ParameterFlags = 0;
14205 }
14206 }
14207 #[repr(C)]
14208 #[derive(Copy, Clone)]
14209 pub struct PhysicalUIMap {
14210 pub physicalUITypeID: PhysicalUITypeID,
14211 pub noteExpressionTypeID: NoteExpressionTypeID,
14212 }
14213 unsafe impl Send for PhysicalUIMap {}
14214 unsafe impl Sync for PhysicalUIMap {}
14215 #[repr(C)]
14216 #[derive(Copy, Clone)]
14217 pub struct PhysicalUIMapList {
14218 pub count: uint32,
14219 pub map: *mut PhysicalUIMap,
14220 }
14221 unsafe impl Send for PhysicalUIMapList {}
14222 unsafe impl Sync for PhysicalUIMapList {}
14223 #[repr(C)]
14224 #[derive(Copy, Clone)]
14225 pub struct PolyPressureEvent {
14226 pub channel: int16,
14227 pub pitch: int16,
14228 pub pressure: f32,
14229 pub noteId: int32,
14230 }
14231 unsafe impl Send for PolyPressureEvent {}
14232 unsafe impl Sync for PolyPressureEvent {}
14233 mod __ProcessContext_wrapper {
14234 #[allow(unused_imports)]
14235 use super::*;
14236 #[allow(unused_imports)]
14237 use super::ProcessContext_::*;
14238 #[repr(C)]
14239 #[derive(Copy, Clone)]
14240 pub struct ProcessContext {
14241 pub state: uint32,
14242 pub sampleRate: f64,
14243 pub projectTimeSamples: TSamples,
14244 pub systemTime: int64,
14245 pub continousTimeSamples: TSamples,
14246 pub projectTimeMusic: TQuarterNotes,
14247 pub barPositionMusic: TQuarterNotes,
14248 pub cycleStartMusic: TQuarterNotes,
14249 pub cycleEndMusic: TQuarterNotes,
14250 pub tempo: f64,
14251 pub timeSigNumerator: int32,
14252 pub timeSigDenominator: int32,
14253 pub chord: Chord,
14254 pub smpteOffsetSubframes: int32,
14255 pub frameRate: FrameRate,
14256 pub samplesToNextClock: int32,
14257 }
14258 unsafe impl Send for ProcessContext {}
14259 unsafe impl Sync for ProcessContext {}
14260 }
14261 pub use __ProcessContext_wrapper::*;
14262 pub mod ProcessContext_ {
14263 #[allow(unused_imports)]
14264 use super::*;
14265 pub type StatesAndFlags = crate::support::DefaultEnumType;
14266 pub mod StatesAndFlags_ {
14267 #[allow(unused_imports)]
14268 use super::*;
14269 pub const kBarPositionValid: StatesAndFlags = 2048;
14270 pub const kChordValid: StatesAndFlags = 262144;
14271 pub const kClockValid: StatesAndFlags = 32768;
14272 pub const kContTimeValid: StatesAndFlags = 131072;
14273 pub const kCycleActive: StatesAndFlags = 4;
14274 pub const kCycleValid: StatesAndFlags = 4096;
14275 pub const kPlaying: StatesAndFlags = 2;
14276 pub const kProjectTimeMusicValid: StatesAndFlags = 512;
14277 pub const kRecording: StatesAndFlags = 8;
14278 pub const kSmpteValid: StatesAndFlags = 16384;
14279 pub const kSystemTimeValid: StatesAndFlags = 256;
14280 pub const kTempoValid: StatesAndFlags = 1024;
14281 pub const kTimeSigValid: StatesAndFlags = 8192;
14282 }
14283 }
14284 #[repr(C)]
14285 #[derive(Copy, Clone)]
14286 pub struct ProcessData {
14287 pub processMode: int32,
14288 pub symbolicSampleSize: int32,
14289 pub numSamples: int32,
14290 pub numInputs: int32,
14291 pub numOutputs: int32,
14292 pub inputs: *mut AudioBusBuffers,
14293 pub outputs: *mut AudioBusBuffers,
14294 pub inputParameterChanges: *mut IParameterChanges,
14295 pub outputParameterChanges: *mut IParameterChanges,
14296 pub inputEvents: *mut IEventList,
14297 pub outputEvents: *mut IEventList,
14298 pub processContext: *mut ProcessContext,
14299 }
14300 unsafe impl Send for ProcessData {}
14301 unsafe impl Sync for ProcessData {}
14302 #[repr(C)]
14303 #[derive(Copy, Clone)]
14304 pub struct ProcessSetup {
14305 pub processMode: int32,
14306 pub symbolicSampleSize: int32,
14307 pub maxSamplesPerBlock: int32,
14308 pub sampleRate: SampleRate,
14309 }
14310 unsafe impl Send for ProcessSetup {}
14311 unsafe impl Sync for ProcessSetup {}
14312 #[repr(C)]
14313 #[derive(Copy, Clone)]
14314 pub struct ProgramListInfo {
14315 pub id: ProgramListID,
14316 pub name: String128,
14317 pub programCount: int32,
14318 }
14319 unsafe impl Send for ProgramListInfo {}
14320 unsafe impl Sync for ProgramListInfo {}
14321 mod __RepresentationInfo_wrapper {
14322 #[allow(unused_imports)]
14323 use super::*;
14324 #[allow(unused_imports)]
14325 use super::RepresentationInfo_::*;
14326 #[repr(C)]
14327 #[derive(Copy, Clone)]
14328 pub struct RepresentationInfo {
14329 pub vendor: [char8; 64],
14330 pub name: [char8; 64],
14331 pub version: [char8; 64],
14332 pub host: [char8; 64],
14333 }
14334 unsafe impl Send for RepresentationInfo {}
14335 unsafe impl Sync for RepresentationInfo {}
14336 }
14337 pub use __RepresentationInfo_wrapper::*;
14338 pub mod RepresentationInfo_ {
14339 #[allow(unused_imports)]
14340 use super::*;
14341 pub const kNameSize: crate::support::DefaultEnumType = 64;
14342 }
14343 #[repr(C)]
14344 #[derive(Copy, Clone)]
14345 pub struct RoutingInfo {
14346 pub mediaType: MediaType,
14347 pub busIndex: int32,
14348 pub channel: int32,
14349 }
14350 unsafe impl Send for RoutingInfo {}
14351 unsafe impl Sync for RoutingInfo {}
14352 #[repr(C)]
14353 #[derive(Copy, Clone)]
14354 pub struct ScaleEvent {
14355 pub root: int16,
14356 pub mask: int16,
14357 pub textLen: uint16,
14358 pub text: *const TChar,
14359 }
14360 unsafe impl Send for ScaleEvent {}
14361 unsafe impl Sync for ScaleEvent {}
14362 #[repr(C)]
14363 #[derive(Copy, Clone)]
14364 pub struct UnitInfo {
14365 pub id: UnitID,
14366 pub parentUnitId: UnitID,
14367 pub name: String128,
14368 pub programListId: ProgramListID,
14369 }
14370 unsafe impl Send for UnitInfo {}
14371 unsafe impl Sync for UnitInfo {}
14372 pub const IAttributeList_iid: TUID = crate::support::uid(0x1E5F0AEB, 0xCC7F4533, 0xA2544011, 0x38AD5EE4);
14373 pub const IAudioPresentationLatency_iid: TUID = crate::support::uid(0x309ECE78, 0xEB7D4fae, 0x8B2225D9, 0x09FD08B6);
14374 pub const IAudioProcessor_iid: TUID = crate::support::uid(0x42043F99, 0xB7DA453C, 0xA569E79D, 0x9AAEC33D);
14375 pub const IAutomationState_iid: TUID = crate::support::uid(0xB4E8287F, 0x1BB346AA, 0x83A46667, 0x68937BAB);
14376 pub const IComponentHandler2_iid: TUID = crate::support::uid(0xF040B4B3, 0xA36045EC, 0xABCDC045, 0xB4D5A2CC);
14377 pub const IComponentHandler3_iid: TUID = crate::support::uid(0x69F11617, 0xD26B400D, 0xA4B6B964, 0x7B6EBBAB);
14378 pub const IComponentHandlerBusActivation_iid: TUID = crate::support::uid(0x067D02C1, 0x5B4E274D, 0xA92D90FD, 0x6EAF7240);
14379 pub const IComponentHandlerSystemTime_iid: TUID = crate::support::uid(0xF9E53056, 0xD1554CD5, 0xB7695E1B, 0x7B0F7745);
14380 pub const IComponentHandler_iid: TUID = crate::support::uid(0x93A0BEA3, 0x0BD045DB, 0x8E890B0C, 0xC1E46AC6);
14381 pub const IComponent_iid: TUID = crate::support::uid(0xE831FF31, 0xF2D54301, 0x928EBBEE, 0x25697802);
14382 pub const IConnectionPoint_iid: TUID = crate::support::uid(0x70A4156F, 0x6E6E4026, 0x989148BF, 0xAA60D8D1);
14383 pub const IContextMenuTarget_iid: TUID = crate::support::uid(0x3CDF2E75, 0x85D34144, 0xBF86D36B, 0xD7C4894D);
14384 pub const IContextMenu_iid: TUID = crate::support::uid(0x2E93C863, 0x0C9C4588, 0x97DBECF5, 0xAD17817D);
14385 pub const IDataExchangeHandler_iid: TUID = crate::support::uid(0x36D551BD, 0x6FF54F08, 0xB48E830D, 0x8BD5A03B);
14386 pub const IDataExchangeReceiver_iid: TUID = crate::support::uid(0x45A759DC, 0x84FA4907, 0xABCB6175, 0x2FC786B6);
14387 pub const IEditController2_iid: TUID = crate::support::uid(0x7F4EFE59, 0xF3204967, 0xAC27A3AE, 0xAFB63038);
14388 pub const IEditControllerHostEditing_iid: TUID = crate::support::uid(0xC1271208, 0x70594098, 0xB9DD34B3, 0x6BB0195E);
14389 pub const IEditController_iid: TUID = crate::support::uid(0xDCD7BBE3, 0x7742448D, 0xA874AACC, 0x979C759E);
14390 pub const IEventList_iid: TUID = crate::support::uid(0x3A2C4214, 0x346349FE, 0xB2C4F397, 0xB9695A44);
14391 pub const IHostApplication_iid: TUID = crate::support::uid(0x58E595CC, 0xDB2D4969, 0x8B6AAF8C, 0x36A664E5);
14392 pub const IInterAppAudioConnectionNotification_iid: TUID = crate::support::uid(0x6020C72D, 0x5FC24AA1, 0xB0950DB5, 0xD7D6D5CF);
14393 pub const IInterAppAudioHost_iid: TUID = crate::support::uid(0x0CE5743D, 0x68DF415E, 0xAE285BD4, 0xE2CDC8FD);
14394 pub const IInterAppAudioPresetManager_iid: TUID = crate::support::uid(0xADE6FCC4, 0x46C94E1D, 0xB3B49A80, 0xC93FEFDD);
14395 pub const IKeyswitchController_iid: TUID = crate::support::uid(0x1F2F76D3, 0xBFFB4B96, 0xB99527A5, 0x5EBCCEF4);
14396 pub const IMessage_iid: TUID = crate::support::uid(0x936F033B, 0xC6C047DB, 0xBB0882F8, 0x13C1E613);
14397 pub const IMidiLearn2_iid: TUID = crate::support::uid(0xF07E498A, 0x78864327, 0x8B431CED, 0xA3C553FC);
14398 pub const IMidiLearn_iid: TUID = crate::support::uid(0x6B2449CC, 0x419740B5, 0xAB3C79DA, 0xC5FE5C86);
14399 pub const IMidiMapping2_iid: TUID = crate::support::uid(0x6DE14B88, 0x03F94F09, 0xA2552F0F, 0x9326593E);
14400 pub const IMidiMapping_iid: TUID = crate::support::uid(0xDF0FF9F7, 0x49B74669, 0xB63AB732, 0x7ADBF5E5);
14401 pub const INoteExpressionController_iid: TUID = crate::support::uid(0xB7F8F859, 0x41234872, 0x91169581, 0x4F3721A3);
14402 pub const INoteExpressionPhysicalUIMapping_iid: TUID = crate::support::uid(0xB03078FF, 0x94D24AC8, 0x90CCD303, 0xD4133324);
14403 pub const IParamValueQueue_iid: TUID = crate::support::uid(0x01263A18, 0xED074F6F, 0x98C9D356, 0x4686F9BA);
14404 pub const IParameterChanges_iid: TUID = crate::support::uid(0xA4779663, 0x0BB64A56, 0xB44384A8, 0x466FEB9D);
14405 pub const IParameterFinder_iid: TUID = crate::support::uid(0x0F618302, 0x215D4587, 0xA512073C, 0x77B9D383);
14406 pub const IParameterFunctionName_iid: TUID = crate::support::uid(0x6D21E1DC, 0x91199D4B, 0xA2A02FEF, 0x6C1AE55C);
14407 pub const IPlugInterfaceSupport_iid: TUID = crate::support::uid(0x4FB58B9E, 0x9EAA4E0F, 0xAB361C1C, 0xCCB56FEA);
14408 pub const IPrefetchableSupport_iid: TUID = crate::support::uid(0x8AE54FDA, 0xE93046B9, 0xA28555BC, 0xDC98E21E);
14409 pub const IProcessContextRequirements_iid: TUID = crate::support::uid(0x2A654303, 0xEF764E3D, 0x95B5FE83, 0x730EF6D0);
14410 pub const IProgramListData_iid: TUID = crate::support::uid(0x8683B01F, 0x7B354F70, 0xA2651DEC, 0x353AF4FF);
14411 pub const IProgress_iid: TUID = crate::support::uid(0x00C9DC5B, 0x9D904254, 0x91A388C8, 0xB4E91B69);
14412 pub const IRemapParamID_iid: TUID = crate::support::uid(0x2B88021E, 0x6286B646, 0xB49DF76A, 0x5663061C);
14413 pub const IStreamAttributes_iid: TUID = crate::support::uid(0xD6CE2FFC, 0xEFAF4B8C, 0x9E74F1BB, 0x12DA44B4);
14414 pub const IUnitData_iid: TUID = crate::support::uid(0x6C389611, 0xD391455D, 0xB870B833, 0x94A0EFDD);
14415 pub const IUnitHandler2_iid: TUID = crate::support::uid(0xF89F8CDF, 0x699E4BA5, 0x96AAC9A4, 0x81452B01);
14416 pub const IUnitHandler_iid: TUID = crate::support::uid(0x4B5147F8, 0x4654486B, 0x8DAB30BA, 0x163A3C56);
14417 pub const IUnitInfo_iid: TUID = crate::support::uid(0x3D4BD6B5, 0x913A4FD2, 0xA886E768, 0xA5EB92C1);
14418 pub const IVst3ToAAXWrapper_iid: TUID = crate::support::uid(0x6D319DC6, 0x60C56242, 0xB32C951B, 0x93BEF4C6);
14419 pub const IVst3ToAUWrapper_iid: TUID = crate::support::uid(0xA3B8C6C5, 0xC0954688, 0xB0916F0B, 0xB697AA44);
14420 pub const IVst3ToVst2Wrapper_iid: TUID = crate::support::uid(0x29633AEC, 0x1D1C47E2, 0xBB85B97B, 0xD36EAC61);
14421 pub const IVst3WrapperMPESupport_iid: TUID = crate::support::uid(0x44149067, 0x42CF4BF9, 0x8800B750, 0xF7359FE3);
14422 pub const IXmlRepresentationController_iid: TUID = crate::support::uid(0xA81A0471, 0x48C34DC4, 0xAC30C9E1, 0x3C8393D5);
14423 pub const InvalidDataExchangeBlockID: DataExchangeBlockID = 2147483647;
14424 pub const InvalidDataExchangeQueueID: DataExchangeQueueID = 2147483647;
14425 pub const SDKVersion: uint32 = 198656;
14426 pub const SDKVersionMajor: uint32 = 3;
14427 pub const SDKVersionMinor: uint32 = 8;
14428 pub const SDKVersionString: FIDString = b"VST 3.8.0\0".as_ptr() as *const ::std::ffi::c_char;
14429 pub const SDKVersionSub: uint32 = 0;
14430 pub const SDKVersion_3_0_0: uint32 = 196608;
14431 pub const SDKVersion_3_1_0: uint32 = 196864;
14432 pub const SDKVersion_3_5_0: uint32 = 197888;
14433 pub const SDKVersion_3_6_0: uint32 = 198144;
14434 pub const SDKVersion_3_6_10: uint32 = 198154;
14435 pub const SDKVersion_3_6_11: uint32 = 198155;
14436 pub const SDKVersion_3_6_12: uint32 = 198156;
14437 pub const SDKVersion_3_6_13: uint32 = 198157;
14438 pub const SDKVersion_3_6_14: uint32 = 198158;
14439 pub const SDKVersion_3_6_5: uint32 = 198149;
14440 pub const SDKVersion_3_6_6: uint32 = 198150;
14441 pub const SDKVersion_3_6_7: uint32 = 198151;
14442 pub const SDKVersion_3_6_8: uint32 = 198152;
14443 pub const SDKVersion_3_6_9: uint32 = 198153;
14444 pub const SDKVersion_3_7_0: uint32 = 198400;
14445 pub const SDKVersion_3_7_1: uint32 = 198401;
14446 pub const SDKVersion_3_7_10: uint32 = 198410;
14447 pub const SDKVersion_3_7_11: uint32 = 198411;
14448 pub const SDKVersion_3_7_12: uint32 = 198412;
14449 pub const SDKVersion_3_7_13: uint32 = 198413;
14450 pub const SDKVersion_3_7_14: uint32 = 198414;
14451 pub const SDKVersion_3_7_2: uint32 = 198402;
14452 pub const SDKVersion_3_7_3: uint32 = 198403;
14453 pub const SDKVersion_3_7_4: uint32 = 198404;
14454 pub const SDKVersion_3_7_5: uint32 = 198405;
14455 pub const SDKVersion_3_7_6: uint32 = 198406;
14456 pub const SDKVersion_3_7_7: uint32 = 198407;
14457 pub const SDKVersion_3_7_8: uint32 = 198408;
14458 pub const SDKVersion_3_7_9: uint32 = 198409;
14459 pub const SDKVersion_3_8_0: uint32 = 198656;
14460 pub const kAllProgramInvalid: int32 = -1;
14461 pub const kDefaultFactoryFlags: int32 = 16;
14462 pub const kInfiniteTail: uint32 = 4294967295;
14463 pub const kMaxParamId: ParamID = 2147483647;
14464 pub const kMinParamId: ParamID = 0;
14465 pub const kNoParamId: ParamID = 4294967295;
14466 pub const kNoParentUnitId: UnitID = -1;
14467 pub const kNoProgramListId: ProgramListID = -1;
14468 pub const kNoTail: uint32 = 0;
14469 pub const kRootUnitId: UnitID = 0;
14470 pub const kSpeakerACN0: Speaker = 1048576;
14471 pub const kSpeakerACN1: Speaker = 2097152;
14472 pub const kSpeakerACN10: Speaker = 17592186044416;
14473 pub const kSpeakerACN11: Speaker = 35184372088832;
14474 pub const kSpeakerACN12: Speaker = 70368744177664;
14475 pub const kSpeakerACN13: Speaker = 140737488355328;
14476 pub const kSpeakerACN14: Speaker = 281474976710656;
14477 pub const kSpeakerACN15: Speaker = 562949953421312;
14478 pub const kSpeakerACN16: Speaker = 1125899906842624;
14479 pub const kSpeakerACN17: Speaker = 2251799813685248;
14480 pub const kSpeakerACN18: Speaker = 4503599627370496;
14481 pub const kSpeakerACN19: Speaker = 9007199254740992;
14482 pub const kSpeakerACN2: Speaker = 4194304;
14483 pub const kSpeakerACN20: Speaker = 18014398509481984;
14484 pub const kSpeakerACN21: Speaker = 36028797018963968;
14485 pub const kSpeakerACN22: Speaker = 72057594037927936;
14486 pub const kSpeakerACN23: Speaker = 144115188075855872;
14487 pub const kSpeakerACN24: Speaker = 288230376151711744;
14488 pub const kSpeakerACN3: Speaker = 8388608;
14489 pub const kSpeakerACN4: Speaker = 274877906944;
14490 pub const kSpeakerACN5: Speaker = 549755813888;
14491 pub const kSpeakerACN6: Speaker = 1099511627776;
14492 pub const kSpeakerACN7: Speaker = 2199023255552;
14493 pub const kSpeakerACN8: Speaker = 4398046511104;
14494 pub const kSpeakerACN9: Speaker = 8796093022208;
14495 pub const kSpeakerBfc: Speaker = 536870912;
14496 pub const kSpeakerBfl: Speaker = 268435456;
14497 pub const kSpeakerBfr: Speaker = 1073741824;
14498 pub const kSpeakerBrc: Speaker = 68719476736;
14499 pub const kSpeakerBrl: Speaker = 34359738368;
14500 pub const kSpeakerBrr: Speaker = 137438953472;
14501 pub const kSpeakerBsl: Speaker = 8589934592;
14502 pub const kSpeakerBsr: Speaker = 17179869184;
14503 pub const kSpeakerC: Speaker = 4;
14504 pub const kSpeakerCs: Speaker = 256;
14505 pub const kSpeakerL: Speaker = 1;
14506 pub const kSpeakerLc: Speaker = 64;
14507 pub const kSpeakerLcs: Speaker = 67108864;
14508 pub const kSpeakerLfe: Speaker = 8;
14509 pub const kSpeakerLfe2: Speaker = 262144;
14510 pub const kSpeakerLs: Speaker = 16;
14511 pub const kSpeakerLw: Speaker = 576460752303423488;
14512 pub const kSpeakerM: Speaker = 524288;
14513 pub const kSpeakerPl: Speaker = 2147483648;
14514 pub const kSpeakerPr: Speaker = 4294967296;
14515 pub const kSpeakerR: Speaker = 2;
14516 pub const kSpeakerRc: Speaker = 128;
14517 pub const kSpeakerRcs: Speaker = 134217728;
14518 pub const kSpeakerRs: Speaker = 32;
14519 pub const kSpeakerRw: Speaker = 1152921504606846976;
14520 pub const kSpeakerS: Speaker = 256;
14521 pub const kSpeakerSl: Speaker = 512;
14522 pub const kSpeakerSr: Speaker = 1024;
14523 pub const kSpeakerTc: Speaker = 2048;
14524 pub const kSpeakerTfc: Speaker = 8192;
14525 pub const kSpeakerTfl: Speaker = 4096;
14526 pub const kSpeakerTfr: Speaker = 16384;
14527 pub const kSpeakerTrc: Speaker = 65536;
14528 pub const kSpeakerTrl: Speaker = 32768;
14529 pub const kSpeakerTrr: Speaker = 131072;
14530 pub const kSpeakerTsl: Speaker = 16777216;
14531 pub const kSpeakerTsr: Speaker = 33554432;
14532 pub mod Attributes {
14533 #[allow(unused_imports)]
14534 use super::*;
14535 pub const kFlags: CString = b"flags\0".as_ptr() as *const ::std::ffi::c_char;
14536 pub const kFunction: CString = b"function\0".as_ptr() as *const ::std::ffi::c_char;
14537 pub const kKnobTurnsPerFullRange: CString = b"turnsPerFullRange\0".as_ptr() as *const ::std::ffi::c_char;
14538 pub const kLEDStyle: CString = b"ledStyle\0".as_ptr() as *const ::std::ffi::c_char;
14539 pub const kStyle: CString = b"style\0".as_ptr() as *const ::std::ffi::c_char;
14540 pub const kSwitchStyle: CString = b"switchStyle\0".as_ptr() as *const ::std::ffi::c_char;
14541 }
14542 pub mod AttributesFlags {
14543 #[allow(unused_imports)]
14544 use super::*;
14545 pub const kHideableFlag: CString = b"hideable\0".as_ptr() as *const ::std::ffi::c_char;
14546 }
14547 pub mod AttributesFunction {
14548 #[allow(unused_imports)]
14549 use super::*;
14550 pub const kGainReductionFunc: CString = b"GainReduction\0".as_ptr() as *const ::std::ffi::c_char;
14551 pub const kMuteFunc: CString = b"Mute\0".as_ptr() as *const ::std::ffi::c_char;
14552 pub const kPanLawFunc: CString = b"PanLaw\0".as_ptr() as *const ::std::ffi::c_char;
14553 pub const kPanLfeGainFunc: CString = b"PanLfeGain\0".as_ptr() as *const ::std::ffi::c_char;
14554 pub const kPanMirrorModeFunc: CString = b"PanMirrorMode\0".as_ptr() as *const ::std::ffi::c_char;
14555 pub const kPanPosCenterXFunc: CString = b"PanPosCenterX\0".as_ptr() as *const ::std::ffi::c_char;
14556 pub const kPanPosCenterYFunc: CString = b"PanPosCenterY\0".as_ptr() as *const ::std::ffi::c_char;
14557 pub const kPanPosFrontLeftXFunc: CString = b"PanPosFrontLeftX\0".as_ptr() as *const ::std::ffi::c_char;
14558 pub const kPanPosFrontLeftYFunc: CString = b"PanPosFrontLeftY\0".as_ptr() as *const ::std::ffi::c_char;
14559 pub const kPanPosFrontRightXFunc: CString = b"PanPosFrontRightX\0".as_ptr() as *const ::std::ffi::c_char;
14560 pub const kPanPosFrontRightYFunc: CString = b"PanPosFrontRightY\0".as_ptr() as *const ::std::ffi::c_char;
14561 pub const kPanRotationFunc: CString = b"PanRotation\0".as_ptr() as *const ::std::ffi::c_char;
14562 pub const kSoloFunc: CString = b"Solo\0".as_ptr() as *const ::std::ffi::c_char;
14563 pub const kVolumeFunc: CString = b"Volume\0".as_ptr() as *const ::std::ffi::c_char;
14564 }
14565 pub mod AttributesStyle {
14566 #[allow(unused_imports)]
14567 use super::*;
14568 pub const kInverseStyle: CString = b"inverse\0".as_ptr() as *const ::std::ffi::c_char;
14569 pub const kLEDBoostCutStyle: CString = b"boostCut\0".as_ptr() as *const ::std::ffi::c_char;
14570 pub const kLEDSingleDotStyle: CString = b"singleDot\0".as_ptr() as *const ::std::ffi::c_char;
14571 pub const kLEDSpreadStyle: CString = b"spread\0".as_ptr() as *const ::std::ffi::c_char;
14572 pub const kLEDWrapLeftStyle: CString = b"wrapLeft\0".as_ptr() as *const ::std::ffi::c_char;
14573 pub const kLEDWrapRightStyle: CString = b"wrapRight\0".as_ptr() as *const ::std::ffi::c_char;
14574 pub const kSwitchLatchStyle: CString = b"latch\0".as_ptr() as *const ::std::ffi::c_char;
14575 pub const kSwitchPushDecLoopedStyle: CString = b"pushDecLooped\0".as_ptr() as *const ::std::ffi::c_char;
14576 pub const kSwitchPushDecStyle: CString = b"pushDec\0".as_ptr() as *const ::std::ffi::c_char;
14577 pub const kSwitchPushIncLoopedStyle: CString = b"pushIncLooped\0".as_ptr() as *const ::std::ffi::c_char;
14578 pub const kSwitchPushIncStyle: CString = b"pushInc\0".as_ptr() as *const ::std::ffi::c_char;
14579 pub const kSwitchPushStyle: CString = b"push\0".as_ptr() as *const ::std::ffi::c_char;
14580 }
14581 pub mod ChannelContext {
14582 #[allow(unused_imports)]
14583 use super::*;
14584 pub type ChannelPluginLocation = crate::support::DefaultEnumType;
14585 pub mod ChannelPluginLocation_ {
14586 #[allow(unused_imports)]
14587 use super::*;
14588 pub const kPostVolumeFader: ChannelPluginLocation = 1;
14589 pub const kPreVolumeFader: ChannelPluginLocation = 0;
14590 pub const kUsedAsPanner: ChannelPluginLocation = 2;
14591 }
14592 pub type ColorComponent = uint8;
14593 pub type ColorSpec = uint32;
14594 #[repr(C)]
14595 #[derive(Copy, Clone)]
14596 pub struct IInfoListener {
14597 pub vtbl: *const IInfoListenerVtbl,
14598 }
14599 unsafe impl Send for IInfoListener {}
14600 unsafe impl Sync for IInfoListener {}
14601 unsafe impl ::com_scrape_types::Inherits<FUnknown> for IInfoListener {}
14602 impl ::com_scrape_types::Unknown for IInfoListener {
14603 #[inline]
14604 unsafe fn query_interface(this: *mut Self, iid: &::com_scrape_types::Guid) -> Option<*mut ::std::ffi::c_void> {
14605 crate::support::FUnknown_query_interface(this as *mut ::std::ffi::c_void, iid)
14606 }
14607 #[inline]
14608 unsafe fn add_ref(this: *mut Self) -> usize {
14609 crate::support::FUnknown_add_ref(this as *mut ::std::ffi::c_void)
14610 }
14611 #[inline]
14612 unsafe fn release(this: *mut Self) -> usize {
14613 crate::support::FUnknown_release(this as *mut ::std::ffi::c_void)
14614 }
14615 }
14616 unsafe impl ::com_scrape_types::Interface for IInfoListener {
14617 type Vtbl = IInfoListenerVtbl;
14618 const IID: ::com_scrape_types::Guid = crate::support::tuid_as_guid(IInfoListener_iid);
14619 #[inline]
14620 fn inherits(iid: &::com_scrape_types::Guid) -> bool {
14621 iid == &Self::IID || FUnknown::inherits(iid)
14622 }
14623 }
14624 #[repr(C)]
14625 #[derive(Copy, Clone)]
14626 pub struct IInfoListenerVtbl {
14627 pub base: FUnknownVtbl,
14628 pub setChannelContextInfos: unsafe extern "system" fn(
14629 this: *mut IInfoListener,
14630 list: *mut IAttributeList,
14631 ) -> tresult,
14632 }
14633 pub trait IInfoListenerTrait {
14634 unsafe fn setChannelContextInfos(
14635 &self,
14636 list: *mut IAttributeList,
14637 ) -> tresult;
14638 }
14639 impl<P> IInfoListenerTrait for P
14640 where
14641 P: ::com_scrape_types::SmartPtr,
14642 P::Target: ::com_scrape_types::Inherits<IInfoListener>,
14643 {
14644 #[inline]
14645 unsafe fn setChannelContextInfos(
14646 &self,
14647 list: *mut IAttributeList,
14648 ) -> tresult {
14649 let ptr = self.ptr() as *mut IInfoListener;
14650 ((*(*ptr).vtbl).setChannelContextInfos)(
14651 ptr,
14652 list,
14653 )
14654 }
14655 }
14656 impl IInfoListener {
14657 const fn make_vtbl<C, W, const OFFSET: isize>() -> IInfoListenerVtbl
14658 where
14659 C: IInfoListenerTrait + ::com_scrape_types::Class,
14660 W: ::com_scrape_types::Wrapper<C>,
14661 {
14662 unsafe extern "system" fn setChannelContextInfos<C, W, const OFFSET: isize>(
14663 this: *mut IInfoListener,
14664 list: *mut IAttributeList,
14665 ) -> tresult
14666 where
14667 C: IInfoListenerTrait + ::com_scrape_types::Class,
14668 W: ::com_scrape_types::Wrapper<C>,
14669 {
14670 let header_ptr = (this as *mut u8).offset(-OFFSET) as *mut ::com_scrape_types::Header<C>;
14671 let ptr = <W as ::com_scrape_types::Wrapper<C>>::data_from_header(header_ptr);
14672 (*ptr).setChannelContextInfos(
14673 list,
14674 )
14675 }
14676 IInfoListenerVtbl {
14677 base: FUnknown::make_vtbl::<C, W, OFFSET>(),
14678 setChannelContextInfos: setChannelContextInfos::<C, W, OFFSET>,
14679 }
14680 }
14681 }
14682 unsafe impl<C, W, const OFFSET: isize> ::com_scrape_types::Construct<C, W, OFFSET> for IInfoListener
14683 where
14684 C: IInfoListenerTrait + ::com_scrape_types::Class,
14685 W: ::com_scrape_types::Wrapper<C>,
14686 {
14687 const OBJ: Self = IInfoListener {
14688 vtbl: &Self::make_vtbl::<C, W, OFFSET>(),
14689 };
14690 }
14691 pub const IInfoListener_iid: TUID = crate::support::uid(0x0F194781, 0x8D984ADA, 0xBBA0C1EF, 0xC011D8D0);
14692 pub const kChannelColorKey: CString = b"channel color\0".as_ptr() as *const ::std::ffi::c_char;
14693 pub const kChannelImageKey: CString = b"channel image\0".as_ptr() as *const ::std::ffi::c_char;
14694 pub const kChannelIndexKey: CString = b"channel index\0".as_ptr() as *const ::std::ffi::c_char;
14695 pub const kChannelIndexNamespaceKey: CString = b"channel index namespace\0".as_ptr() as *const ::std::ffi::c_char;
14696 pub const kChannelIndexNamespaceLengthKey: CString = b"channel index namespace length\0".as_ptr() as *const ::std::ffi::c_char;
14697 pub const kChannelIndexNamespaceOrderKey: CString = b"channel index namespace order\0".as_ptr() as *const ::std::ffi::c_char;
14698 pub const kChannelNameKey: CString = b"channel name\0".as_ptr() as *const ::std::ffi::c_char;
14699 pub const kChannelNameLengthKey: CString = b"channel name length\0".as_ptr() as *const ::std::ffi::c_char;
14700 pub const kChannelPluginLocationKey: CString = b"channel plugin location\0".as_ptr() as *const ::std::ffi::c_char;
14701 pub const kChannelRuntimeIDKey: CString = b"channel runtime id\0".as_ptr() as *const ::std::ffi::c_char;
14702 pub const kChannelUIDKey: CString = b"channel uid\0".as_ptr() as *const ::std::ffi::c_char;
14703 pub const kChannelUIDLengthKey: CString = b"channel uid length\0".as_ptr() as *const ::std::ffi::c_char;
14704 }
14705 pub mod CurveType {
14706 #[allow(unused_imports)]
14707 use super::*;
14708 pub const kSegment: CString = b"segment\0".as_ptr() as *const ::std::ffi::c_char;
14709 pub const kValueList: CString = b"valueList\0".as_ptr() as *const ::std::ffi::c_char;
14710 }
14711 pub mod FunctionNameType {
14712 #[allow(unused_imports)]
14713 use super::*;
14714 pub const kCompGainReduction: CString = b"Comp:GainReduction\0".as_ptr() as *const ::std::ffi::c_char;
14715 pub const kCompGainReductionMax: CString = b"Comp:GainReductionMax\0".as_ptr() as *const ::std::ffi::c_char;
14716 pub const kCompGainReductionPeakHold: CString = b"Comp:GainReductionPeakHold\0".as_ptr() as *const ::std::ffi::c_char;
14717 pub const kCompResetGainReductionMax: CString = b"Comp:ResetGainReductionMax\0".as_ptr() as *const ::std::ffi::c_char;
14718 pub const kDryWetMix: CString = b"DryWetMix\0".as_ptr() as *const ::std::ffi::c_char;
14719 pub const kLowLatencyMode: CString = b"LowLatencyMode\0".as_ptr() as *const ::std::ffi::c_char;
14720 pub const kPanPosCenterX: CString = b"PanPosCenterX\0".as_ptr() as *const ::std::ffi::c_char;
14721 pub const kPanPosCenterY: CString = b"PanPosCenterY\0".as_ptr() as *const ::std::ffi::c_char;
14722 pub const kPanPosCenterZ: CString = b"PanPosCenterZ\0".as_ptr() as *const ::std::ffi::c_char;
14723 pub const kRandomize: CString = b"Randomize\0".as_ptr() as *const ::std::ffi::c_char;
14724 }
14725 pub mod LayerType {
14726 #[allow(unused_imports)]
14727 use super::*;
14728 pub const kDisplay: crate::support::DefaultEnumType = 6;
14729 pub const kEndOfLayerType: crate::support::DefaultEnumType = 8;
14730 pub const kFader: crate::support::DefaultEnumType = 7;
14731 pub const kKnob: crate::support::DefaultEnumType = 0;
14732 pub const kLED: crate::support::DefaultEnumType = 4;
14733 pub const kLink: crate::support::DefaultEnumType = 5;
14734 pub const kPressedKnob: crate::support::DefaultEnumType = 1;
14735 pub const kSwitch: crate::support::DefaultEnumType = 3;
14736 pub const kSwitchKnob: crate::support::DefaultEnumType = 2;
14737 }
14738 pub mod MusicalCharacter {
14739 #[allow(unused_imports)]
14740 use super::*;
14741 pub const kAcoustic: CString = b"Acoustic\0".as_ptr() as *const ::std::ffi::c_char;
14742 pub const kAnalog: CString = b"Analog\0".as_ptr() as *const ::std::ffi::c_char;
14743 pub const kAttack: CString = b"Attack\0".as_ptr() as *const ::std::ffi::c_char;
14744 pub const kBright: CString = b"Bright\0".as_ptr() as *const ::std::ffi::c_char;
14745 pub const kClean: CString = b"Clean\0".as_ptr() as *const ::std::ffi::c_char;
14746 pub const kClear: CString = b"Clear\0".as_ptr() as *const ::std::ffi::c_char;
14747 pub const kCold: CString = b"Cold\0".as_ptr() as *const ::std::ffi::c_char;
14748 pub const kDark: CString = b"Dark\0".as_ptr() as *const ::std::ffi::c_char;
14749 pub const kDecay: CString = b"Decay\0".as_ptr() as *const ::std::ffi::c_char;
14750 pub const kDigital: CString = b"Digital\0".as_ptr() as *const ::std::ffi::c_char;
14751 pub const kDissonant: CString = b"Dissonant\0".as_ptr() as *const ::std::ffi::c_char;
14752 pub const kDistorted: CString = b"Distorted\0".as_ptr() as *const ::std::ffi::c_char;
14753 pub const kDry: CString = b"Dry\0".as_ptr() as *const ::std::ffi::c_char;
14754 pub const kElectric: CString = b"Electric\0".as_ptr() as *const ::std::ffi::c_char;
14755 pub const kEnsemble: CString = b"Ensemble\0".as_ptr() as *const ::std::ffi::c_char;
14756 pub const kFast: CString = b"Fast\0".as_ptr() as *const ::std::ffi::c_char;
14757 pub const kFastAttack: CString = b"Fast Attack\0".as_ptr() as *const ::std::ffi::c_char;
14758 pub const kGlass: CString = b"Glass\0".as_ptr() as *const ::std::ffi::c_char;
14759 pub const kGlide: CString = b"Glide\0".as_ptr() as *const ::std::ffi::c_char;
14760 pub const kGlissando: CString = b"Glissando\0".as_ptr() as *const ::std::ffi::c_char;
14761 pub const kHarmonic: CString = b"Harmonic\0".as_ptr() as *const ::std::ffi::c_char;
14762 pub const kLayer: CString = b"Layer\0".as_ptr() as *const ::std::ffi::c_char;
14763 pub const kLong: CString = b"Long\0".as_ptr() as *const ::std::ffi::c_char;
14764 pub const kLongRelease: CString = b"Long Release\0".as_ptr() as *const ::std::ffi::c_char;
14765 pub const kLoop: CString = b"Loop\0".as_ptr() as *const ::std::ffi::c_char;
14766 pub const kMajor: CString = b"Major\0".as_ptr() as *const ::std::ffi::c_char;
14767 pub const kMetallic: CString = b"Metallic\0".as_ptr() as *const ::std::ffi::c_char;
14768 pub const kMinor: CString = b"Minor\0".as_ptr() as *const ::std::ffi::c_char;
14769 pub const kModern: CString = b"Modern\0".as_ptr() as *const ::std::ffi::c_char;
14770 pub const kMono: CString = b"Mono\0".as_ptr() as *const ::std::ffi::c_char;
14771 pub const kMoving: CString = b"Moving\0".as_ptr() as *const ::std::ffi::c_char;
14772 pub const kNew: CString = b"New\0".as_ptr() as *const ::std::ffi::c_char;
14773 pub const kNoisy: CString = b"Noisy\0".as_ptr() as *const ::std::ffi::c_char;
14774 pub const kOld: CString = b"Old\0".as_ptr() as *const ::std::ffi::c_char;
14775 pub const kOneShot: CString = b"One Shot\0".as_ptr() as *const ::std::ffi::c_char;
14776 pub const kPercussive: CString = b"Percussive\0".as_ptr() as *const ::std::ffi::c_char;
14777 pub const kPlastic: CString = b"Plastic\0".as_ptr() as *const ::std::ffi::c_char;
14778 pub const kPoly: CString = b"Poly\0".as_ptr() as *const ::std::ffi::c_char;
14779 pub const kProcessed: CString = b"Processed\0".as_ptr() as *const ::std::ffi::c_char;
14780 pub const kRelease: CString = b"Release\0".as_ptr() as *const ::std::ffi::c_char;
14781 pub const kRich: CString = b"Rich\0".as_ptr() as *const ::std::ffi::c_char;
14782 pub const kShort: CString = b"Short\0".as_ptr() as *const ::std::ffi::c_char;
14783 pub const kShortRelease: CString = b"Short Release\0".as_ptr() as *const ::std::ffi::c_char;
14784 pub const kSingle: CString = b"Single\0".as_ptr() as *const ::std::ffi::c_char;
14785 pub const kSlow: CString = b"Slow\0".as_ptr() as *const ::std::ffi::c_char;
14786 pub const kSlowAttack: CString = b"Slow Attack\0".as_ptr() as *const ::std::ffi::c_char;
14787 pub const kSoft: CString = b"Soft\0".as_ptr() as *const ::std::ffi::c_char;
14788 pub const kSplit: CString = b"Split\0".as_ptr() as *const ::std::ffi::c_char;
14789 pub const kStatic: CString = b"Static\0".as_ptr() as *const ::std::ffi::c_char;
14790 pub const kSustain: CString = b"Sustain\0".as_ptr() as *const ::std::ffi::c_char;
14791 pub const kThin: CString = b"Thin\0".as_ptr() as *const ::std::ffi::c_char;
14792 pub const kVintage: CString = b"Vintage\0".as_ptr() as *const ::std::ffi::c_char;
14793 pub const kWarm: CString = b"Warm\0".as_ptr() as *const ::std::ffi::c_char;
14794 pub const kWooden: CString = b"Wooden\0".as_ptr() as *const ::std::ffi::c_char;
14795 }
14796 pub mod MusicalInstrument {
14797 #[allow(unused_imports)]
14798 use super::*;
14799 pub const kAccordion: CString = b"Accordion\0".as_ptr() as *const ::std::ffi::c_char;
14800 pub const kAccordionAccordion: CString = b"Accordion|Accordion\0".as_ptr() as *const ::std::ffi::c_char;
14801 pub const kAccordionHarmonica: CString = b"Accordion|Harmonica\0".as_ptr() as *const ::std::ffi::c_char;
14802 pub const kAccordionOther: CString = b"Accordion|Other\0".as_ptr() as *const ::std::ffi::c_char;
14803 pub const kBass: CString = b"Bass\0".as_ptr() as *const ::std::ffi::c_char;
14804 pub const kBassABass: CString = b"Bass|A. Bass\0".as_ptr() as *const ::std::ffi::c_char;
14805 pub const kBassEBass: CString = b"Bass|E. Bass\0".as_ptr() as *const ::std::ffi::c_char;
14806 pub const kBassOther: CString = b"Bass|Other\0".as_ptr() as *const ::std::ffi::c_char;
14807 pub const kBassSynthBass: CString = b"Bass|Synth Bass\0".as_ptr() as *const ::std::ffi::c_char;
14808 pub const kBrass: CString = b"Brass\0".as_ptr() as *const ::std::ffi::c_char;
14809 pub const kBrassFrenchHorn: CString = b"Brass|French Horn\0".as_ptr() as *const ::std::ffi::c_char;
14810 pub const kBrassOther: CString = b"Brass|Other\0".as_ptr() as *const ::std::ffi::c_char;
14811 pub const kBrassSection: CString = b"Brass|Section\0".as_ptr() as *const ::std::ffi::c_char;
14812 pub const kBrassSynth: CString = b"Brass|Synth\0".as_ptr() as *const ::std::ffi::c_char;
14813 pub const kBrassTrombone: CString = b"Brass|Trombone\0".as_ptr() as *const ::std::ffi::c_char;
14814 pub const kBrassTrumpet: CString = b"Brass|Trumpet\0".as_ptr() as *const ::std::ffi::c_char;
14815 pub const kBrassTuba: CString = b"Brass|Tuba\0".as_ptr() as *const ::std::ffi::c_char;
14816 pub const kChromaticPerc: CString = b"Chromatic Perc\0".as_ptr() as *const ::std::ffi::c_char;
14817 pub const kChromaticPercBell: CString = b"Chromatic Perc|Bell\0".as_ptr() as *const ::std::ffi::c_char;
14818 pub const kChromaticPercMallett: CString = b"Chromatic Perc|Mallett\0".as_ptr() as *const ::std::ffi::c_char;
14819 pub const kChromaticPercOther: CString = b"Chromatic Perc|Other\0".as_ptr() as *const ::std::ffi::c_char;
14820 pub const kChromaticPercPercussion: CString = b"Chromatic Perc|Percussion\0".as_ptr() as *const ::std::ffi::c_char;
14821 pub const kChromaticPercTimpani: CString = b"Chromatic Perc|Timpani\0".as_ptr() as *const ::std::ffi::c_char;
14822 pub const kChromaticPercWood: CString = b"Chromatic Perc|Wood\0".as_ptr() as *const ::std::ffi::c_char;
14823 pub const kDrumPerc: CString = b"Drum&Perc\0".as_ptr() as *const ::std::ffi::c_char;
14824 pub const kDrumPercBeats: CString = b"Drum&Perc|Beats\0".as_ptr() as *const ::std::ffi::c_char;
14825 pub const kDrumPercCymbals: CString = b"Drum&Perc|Cymbals\0".as_ptr() as *const ::std::ffi::c_char;
14826 pub const kDrumPercDrumMenues: CString = b"Drum&Perc|Drum Menues\0".as_ptr() as *const ::std::ffi::c_char;
14827 pub const kDrumPercDrumset: CString = b"Drum&Perc|Drumset\0".as_ptr() as *const ::std::ffi::c_char;
14828 pub const kDrumPercDrumsetGM: CString = b"Drum&Perc|Drumset GM\0".as_ptr() as *const ::std::ffi::c_char;
14829 pub const kDrumPercHiHats: CString = b"Drum&Perc|HiHats\0".as_ptr() as *const ::std::ffi::c_char;
14830 pub const kDrumPercKickDrum: CString = b"Drum&Perc|Kick Drum\0".as_ptr() as *const ::std::ffi::c_char;
14831 pub const kDrumPercOther: CString = b"Drum&Perc|Other\0".as_ptr() as *const ::std::ffi::c_char;
14832 pub const kDrumPercPercussion: CString = b"Drum&Perc|Percussion\0".as_ptr() as *const ::std::ffi::c_char;
14833 pub const kDrumPercSnareDrum: CString = b"Drum&Perc|Snare Drum\0".as_ptr() as *const ::std::ffi::c_char;
14834 pub const kDrumPercToms: CString = b"Drum&Perc|Toms\0".as_ptr() as *const ::std::ffi::c_char;
14835 pub const kEthnic: CString = b"Ethnic\0".as_ptr() as *const ::std::ffi::c_char;
14836 pub const kEthnicAfrican: CString = b"Ethnic|African\0".as_ptr() as *const ::std::ffi::c_char;
14837 pub const kEthnicAlien: CString = b"Ethnic|Alien\0".as_ptr() as *const ::std::ffi::c_char;
14838 pub const kEthnicAmerican: CString = b"Ethnic|American\0".as_ptr() as *const ::std::ffi::c_char;
14839 pub const kEthnicAsian: CString = b"Ethnic|Asian\0".as_ptr() as *const ::std::ffi::c_char;
14840 pub const kEthnicEuropean: CString = b"Ethnic|European\0".as_ptr() as *const ::std::ffi::c_char;
14841 pub const kEthnicLatin: CString = b"Ethnic|Latin\0".as_ptr() as *const ::std::ffi::c_char;
14842 pub const kEthnicOther: CString = b"Ethnic|Other\0".as_ptr() as *const ::std::ffi::c_char;
14843 pub const kGuitar: CString = b"Guitar/Plucked\0".as_ptr() as *const ::std::ffi::c_char;
14844 pub const kGuitarAGuitar: CString = b"Guitar/Plucked|A. Guitar\0".as_ptr() as *const ::std::ffi::c_char;
14845 pub const kGuitarEGuitar: CString = b"Guitar/Plucked|E. Guitar\0".as_ptr() as *const ::std::ffi::c_char;
14846 pub const kGuitarEthnic: CString = b"Guitar/Plucked|Ethnic\0".as_ptr() as *const ::std::ffi::c_char;
14847 pub const kGuitarHarp: CString = b"Guitar/Plucked|Harp\0".as_ptr() as *const ::std::ffi::c_char;
14848 pub const kGuitarOther: CString = b"Guitar/Plucked|Other\0".as_ptr() as *const ::std::ffi::c_char;
14849 pub const kKeyboard: CString = b"Keyboard\0".as_ptr() as *const ::std::ffi::c_char;
14850 pub const kKeyboardClavi: CString = b"Keyboard|Clavi\0".as_ptr() as *const ::std::ffi::c_char;
14851 pub const kKeyboardEPiano: CString = b"Keyboard|E. Piano\0".as_ptr() as *const ::std::ffi::c_char;
14852 pub const kKeyboardHarpsichord: CString = b"Keyboard|Harpsichord\0".as_ptr() as *const ::std::ffi::c_char;
14853 pub const kKeyboardOther: CString = b"Keyboard|Other\0".as_ptr() as *const ::std::ffi::c_char;
14854 pub const kMusicalFX: CString = b"Musical FX\0".as_ptr() as *const ::std::ffi::c_char;
14855 pub const kMusicalFXBeepsBlips: CString = b"Musical FX|Beeps&Blips\0".as_ptr() as *const ::std::ffi::c_char;
14856 pub const kMusicalFXHitsStabs: CString = b"Musical FX|Hits&Stabs\0".as_ptr() as *const ::std::ffi::c_char;
14857 pub const kMusicalFXMotion: CString = b"Musical FX|Motion\0".as_ptr() as *const ::std::ffi::c_char;
14858 pub const kMusicalFXOther: CString = b"Musical FX|Other\0".as_ptr() as *const ::std::ffi::c_char;
14859 pub const kMusicalFXScratches: CString = b"Musical FX|Scratches\0".as_ptr() as *const ::std::ffi::c_char;
14860 pub const kMusicalFXSweeps: CString = b"Musical FX|Sweeps\0".as_ptr() as *const ::std::ffi::c_char;
14861 pub const kOrgan: CString = b"Organ\0".as_ptr() as *const ::std::ffi::c_char;
14862 pub const kOrganElectric: CString = b"Organ|Electric\0".as_ptr() as *const ::std::ffi::c_char;
14863 pub const kOrganOther: CString = b"Organ|Other\0".as_ptr() as *const ::std::ffi::c_char;
14864 pub const kOrganPipe: CString = b"Organ|Pipe\0".as_ptr() as *const ::std::ffi::c_char;
14865 pub const kPiano: CString = b"Piano\0".as_ptr() as *const ::std::ffi::c_char;
14866 pub const kPianoAPiano: CString = b"Piano|A. Piano\0".as_ptr() as *const ::std::ffi::c_char;
14867 pub const kPianoEGrand: CString = b"Piano|E. Grand\0".as_ptr() as *const ::std::ffi::c_char;
14868 pub const kPianoOther: CString = b"Piano|Other\0".as_ptr() as *const ::std::ffi::c_char;
14869 pub const kSoundFX: CString = b"Sound FX\0".as_ptr() as *const ::std::ffi::c_char;
14870 pub const kSoundFXMechanical: CString = b"Sound FX|Mechanical\0".as_ptr() as *const ::std::ffi::c_char;
14871 pub const kSoundFXNature: CString = b"Sound FX|Nature\0".as_ptr() as *const ::std::ffi::c_char;
14872 pub const kSoundFXOther: CString = b"Sound FX|Other\0".as_ptr() as *const ::std::ffi::c_char;
14873 pub const kSoundFXSynthetic: CString = b"Sound FX|Synthetic\0".as_ptr() as *const ::std::ffi::c_char;
14874 pub const kStrings: CString = b"Strings\0".as_ptr() as *const ::std::ffi::c_char;
14875 pub const kStringsBass: CString = b"Strings|Bass\0".as_ptr() as *const ::std::ffi::c_char;
14876 pub const kStringsCello: CString = b"Strings|Cello\0".as_ptr() as *const ::std::ffi::c_char;
14877 pub const kStringsOther: CString = b"Strings|Other\0".as_ptr() as *const ::std::ffi::c_char;
14878 pub const kStringsSection: CString = b"Strings|Section\0".as_ptr() as *const ::std::ffi::c_char;
14879 pub const kStringsSynth: CString = b"Strings|Synth\0".as_ptr() as *const ::std::ffi::c_char;
14880 pub const kStringsViola: CString = b"Strings|Viola\0".as_ptr() as *const ::std::ffi::c_char;
14881 pub const kStringsViolin: CString = b"Strings|Violin\0".as_ptr() as *const ::std::ffi::c_char;
14882 pub const kSynthComp: CString = b"Synth Comp\0".as_ptr() as *const ::std::ffi::c_char;
14883 pub const kSynthCompAnalog: CString = b"Synth Comp|Analog\0".as_ptr() as *const ::std::ffi::c_char;
14884 pub const kSynthCompDigital: CString = b"Synth Comp|Digital\0".as_ptr() as *const ::std::ffi::c_char;
14885 pub const kSynthCompOther: CString = b"Synth Comp|Other\0".as_ptr() as *const ::std::ffi::c_char;
14886 pub const kSynthLead: CString = b"Synth Lead\0".as_ptr() as *const ::std::ffi::c_char;
14887 pub const kSynthLeadAnalog: CString = b"Synth Lead|Analog\0".as_ptr() as *const ::std::ffi::c_char;
14888 pub const kSynthLeadArpeggio: CString = b"Synth Lead|Arpeggio\0".as_ptr() as *const ::std::ffi::c_char;
14889 pub const kSynthLeadDigital: CString = b"Synth Lead|Digital\0".as_ptr() as *const ::std::ffi::c_char;
14890 pub const kSynthLeadOther: CString = b"Synth Lead|Other\0".as_ptr() as *const ::std::ffi::c_char;
14891 pub const kSynthPad: CString = b"Synth Pad\0".as_ptr() as *const ::std::ffi::c_char;
14892 pub const kSynthPadAnalog: CString = b"Synth Pad|Analog\0".as_ptr() as *const ::std::ffi::c_char;
14893 pub const kSynthPadDigital: CString = b"Synth Pad|Digital\0".as_ptr() as *const ::std::ffi::c_char;
14894 pub const kSynthPadMotion: CString = b"Synth Pad|Motion\0".as_ptr() as *const ::std::ffi::c_char;
14895 pub const kSynthPadOther: CString = b"Synth Pad|Other\0".as_ptr() as *const ::std::ffi::c_char;
14896 pub const kSynthPadSynthChoir: CString = b"Synth Pad|Synth Choir\0".as_ptr() as *const ::std::ffi::c_char;
14897 pub const kVocal: CString = b"Vocal\0".as_ptr() as *const ::std::ffi::c_char;
14898 pub const kVocalAdlibs: CString = b"Vocal|Adlibs\0".as_ptr() as *const ::std::ffi::c_char;
14899 pub const kVocalChoir: CString = b"Vocal|Choir\0".as_ptr() as *const ::std::ffi::c_char;
14900 pub const kVocalFX: CString = b"Vocal|FX\0".as_ptr() as *const ::std::ffi::c_char;
14901 pub const kVocalLeadVocal: CString = b"Vocal|Lead Vocal\0".as_ptr() as *const ::std::ffi::c_char;
14902 pub const kVocalOther: CString = b"Vocal|Other\0".as_ptr() as *const ::std::ffi::c_char;
14903 pub const kVocalSolo: CString = b"Vocal|Solo\0".as_ptr() as *const ::std::ffi::c_char;
14904 pub const kVocalSpoken: CString = b"Vocal|Spoken\0".as_ptr() as *const ::std::ffi::c_char;
14905 pub const kWoodwinds: CString = b"Woodwinds\0".as_ptr() as *const ::std::ffi::c_char;
14906 pub const kWoodwindsBassoon: CString = b"Woodwinds|Bassoon\0".as_ptr() as *const ::std::ffi::c_char;
14907 pub const kWoodwindsClarinet: CString = b"Woodwinds|Clarinet\0".as_ptr() as *const ::std::ffi::c_char;
14908 pub const kWoodwindsEnglHorn: CString = b"Woodwinds|Engl. Horn\0".as_ptr() as *const ::std::ffi::c_char;
14909 pub const kWoodwindsEthnic: CString = b"Woodwinds|Ethnic\0".as_ptr() as *const ::std::ffi::c_char;
14910 pub const kWoodwindsFlute: CString = b"Woodwinds|Flute\0".as_ptr() as *const ::std::ffi::c_char;
14911 pub const kWoodwindsOboe: CString = b"Woodwinds|Oboe\0".as_ptr() as *const ::std::ffi::c_char;
14912 pub const kWoodwindsOther: CString = b"Woodwinds|Other\0".as_ptr() as *const ::std::ffi::c_char;
14913 pub const kWoodwindsSaxophone: CString = b"Woodwinds|Saxophone\0".as_ptr() as *const ::std::ffi::c_char;
14914 }
14915 pub mod MusicalStyle {
14916 #[allow(unused_imports)]
14917 use super::*;
14918 pub const kAlternativeIndie: CString = b"Alternative/Indie\0".as_ptr() as *const ::std::ffi::c_char;
14919 pub const kAlternativeIndieCollegeRock: CString = b"Alternative/Indie|College Rock\0".as_ptr() as *const ::std::ffi::c_char;
14920 pub const kAlternativeIndieDarkWave: CString = b"Alternative/Indie|Dark Wave\0".as_ptr() as *const ::std::ffi::c_char;
14921 pub const kAlternativeIndieGothRock: CString = b"Alternative/Indie|Goth Rock\0".as_ptr() as *const ::std::ffi::c_char;
14922 pub const kAlternativeIndieGrunge: CString = b"Alternative/Indie|Grunge\0".as_ptr() as *const ::std::ffi::c_char;
14923 pub const kAlternativeIndieHardcore: CString = b"Alternative/Indie|Hardcore\0".as_ptr() as *const ::std::ffi::c_char;
14924 pub const kAlternativeIndieNewWave: CString = b"Alternative/Indie|New Wave\0".as_ptr() as *const ::std::ffi::c_char;
14925 pub const kAlternativeIndiePunk: CString = b"Alternative/Indie|Punk\0".as_ptr() as *const ::std::ffi::c_char;
14926 pub const kAmbientChillOut: CString = b"Ambient/ChillOut\0".as_ptr() as *const ::std::ffi::c_char;
14927 pub const kAmbientChillOutDarkAmbient: CString = b"Ambient/ChillOut|Dark Ambient\0".as_ptr() as *const ::std::ffi::c_char;
14928 pub const kAmbientChillOutDowntempo: CString = b"Ambient/ChillOut|Downtempo\0".as_ptr() as *const ::std::ffi::c_char;
14929 pub const kAmbientChillOutLounge: CString = b"Ambient/ChillOut|Lounge\0".as_ptr() as *const ::std::ffi::c_char;
14930 pub const kAmbientChillOutNewAgeMeditation: CString = b"Ambient/ChillOut|New Age/Meditation\0".as_ptr() as *const ::std::ffi::c_char;
14931 pub const kBlues: CString = b"Blues\0".as_ptr() as *const ::std::ffi::c_char;
14932 pub const kBluesAcousticBlues: CString = b"Blues|Acoustic Blues\0".as_ptr() as *const ::std::ffi::c_char;
14933 pub const kBluesChicagoBlues: CString = b"Blues|Chicago Blues\0".as_ptr() as *const ::std::ffi::c_char;
14934 pub const kBluesCountryBlues: CString = b"Blues|Country Blues\0".as_ptr() as *const ::std::ffi::c_char;
14935 pub const kBluesElectricBlues: CString = b"Blues|Electric Blues\0".as_ptr() as *const ::std::ffi::c_char;
14936 pub const kClassical: CString = b"Classical\0".as_ptr() as *const ::std::ffi::c_char;
14937 pub const kClassicalBaroque: CString = b"Classical|Baroque\0".as_ptr() as *const ::std::ffi::c_char;
14938 pub const kClassicalChamberMusic: CString = b"Classical|Chamber Music\0".as_ptr() as *const ::std::ffi::c_char;
14939 pub const kClassicalClassic: CString = b"Classical|Classic\0".as_ptr() as *const ::std::ffi::c_char;
14940 pub const kClassicalGregorian: CString = b"Classical|Gregorian\0".as_ptr() as *const ::std::ffi::c_char;
14941 pub const kClassicalMedieval: CString = b"Classical|Medieval\0".as_ptr() as *const ::std::ffi::c_char;
14942 pub const kClassicalModernComposition: CString = b"Classical|Modern Composition\0".as_ptr() as *const ::std::ffi::c_char;
14943 pub const kClassicalOpera: CString = b"Classical|Opera\0".as_ptr() as *const ::std::ffi::c_char;
14944 pub const kClassicalRenaissance: CString = b"Classical|Renaissance\0".as_ptr() as *const ::std::ffi::c_char;
14945 pub const kClassicalRomantic: CString = b"Classical|Romantic\0".as_ptr() as *const ::std::ffi::c_char;
14946 pub const kClassicalSoundtrack: CString = b"Classical|Soundtrack\0".as_ptr() as *const ::std::ffi::c_char;
14947 pub const kCountry: CString = b"Country\0".as_ptr() as *const ::std::ffi::c_char;
14948 pub const kCountryAmericana: CString = b"Country|Americana\0".as_ptr() as *const ::std::ffi::c_char;
14949 pub const kCountryBluegrass: CString = b"Country|Bluegrass\0".as_ptr() as *const ::std::ffi::c_char;
14950 pub const kCountryCountryWestern: CString = b"Country|Country/Western\0".as_ptr() as *const ::std::ffi::c_char;
14951 pub const kCountryHonkyTonk: CString = b"Country|Honky Tonk\0".as_ptr() as *const ::std::ffi::c_char;
14952 pub const kCountryNorthAmericanFolk: CString = b"Country|North American Folk\0".as_ptr() as *const ::std::ffi::c_char;
14953 pub const kCountrySquaredance: CString = b"Country|Squaredance\0".as_ptr() as *const ::std::ffi::c_char;
14954 pub const kCountryUrbanCowboy: CString = b"Country|Urban Cowboy\0".as_ptr() as *const ::std::ffi::c_char;
14955 pub const kElectronicaDance: CString = b"Electronica/Dance\0".as_ptr() as *const ::std::ffi::c_char;
14956 pub const kElectronicaDanceBigBeats: CString = b"Electronica/Dance|Big Beats\0".as_ptr() as *const ::std::ffi::c_char;
14957 pub const kElectronicaDanceClassicHouse: CString = b"Electronica/Dance|Classic House\0".as_ptr() as *const ::std::ffi::c_char;
14958 pub const kElectronicaDanceDrumNBassJungle: CString = b"Electronica/Dance|Drum'n'Bass/Jungle\0".as_ptr() as *const ::std::ffi::c_char;
14959 pub const kElectronicaDanceDub: CString = b"Electronica/Dance|Dub\0".as_ptr() as *const ::std::ffi::c_char;
14960 pub const kElectronicaDanceElectronicBodyMusic: CString = b"Electronica/Dance|Electronic Body Music\0".as_ptr() as *const ::std::ffi::c_char;
14961 pub const kElectronicaDanceElektro: CString = b"Electronica/Dance|Elektro\0".as_ptr() as *const ::std::ffi::c_char;
14962 pub const kElectronicaDanceElektroHouse: CString = b"Electronica/Dance|Elektro House\0".as_ptr() as *const ::std::ffi::c_char;
14963 pub const kElectronicaDanceFunkyHouse: CString = b"Electronica/Dance|Funky House\0".as_ptr() as *const ::std::ffi::c_char;
14964 pub const kElectronicaDanceIndustrial: CString = b"Electronica/Dance|Industrial\0".as_ptr() as *const ::std::ffi::c_char;
14965 pub const kElectronicaDanceMinimal: CString = b"Electronica/Dance|Minimal\0".as_ptr() as *const ::std::ffi::c_char;
14966 pub const kElectronicaDanceTechno: CString = b"Electronica/Dance|Techno\0".as_ptr() as *const ::std::ffi::c_char;
14967 pub const kElectronicaDanceTrance: CString = b"Electronica/Dance|Trance\0".as_ptr() as *const ::std::ffi::c_char;
14968 pub const kElectronicaDanceTripHop: CString = b"Electronica/Dance|Trip Hop\0".as_ptr() as *const ::std::ffi::c_char;
14969 pub const kExperimental: CString = b"Experimental\0".as_ptr() as *const ::std::ffi::c_char;
14970 pub const kExperimentalElectronicArtMusic: CString = b"Experimental|Electronic Art Music\0".as_ptr() as *const ::std::ffi::c_char;
14971 pub const kExperimentalFreeImprovisation: CString = b"Experimental|Free Improvisation\0".as_ptr() as *const ::std::ffi::c_char;
14972 pub const kExperimentalNewMusic: CString = b"Experimental|New Music\0".as_ptr() as *const ::std::ffi::c_char;
14973 pub const kExperimentalNoise: CString = b"Experimental|Noise\0".as_ptr() as *const ::std::ffi::c_char;
14974 pub const kJazz: CString = b"Jazz\0".as_ptr() as *const ::std::ffi::c_char;
14975 pub const kJazzAvantgarde: CString = b"Jazz|Avantgarde\0".as_ptr() as *const ::std::ffi::c_char;
14976 pub const kJazzFreeJazz: CString = b"Jazz|Free Jazz\0".as_ptr() as *const ::std::ffi::c_char;
14977 pub const kJazzFusion: CString = b"Jazz|Fusion\0".as_ptr() as *const ::std::ffi::c_char;
14978 pub const kJazzLatinJazz: CString = b"Jazz|Latin Jazz\0".as_ptr() as *const ::std::ffi::c_char;
14979 pub const kJazzNewOrleansJazz: CString = b"Jazz|New Orleans Jazz\0".as_ptr() as *const ::std::ffi::c_char;
14980 pub const kJazzOldtimeJazzDixiland: CString = b"Jazz|Oldtime Jazz/Dixiland\0".as_ptr() as *const ::std::ffi::c_char;
14981 pub const kJazzRagtime: CString = b"Jazz|Ragtime\0".as_ptr() as *const ::std::ffi::c_char;
14982 pub const kJazzTraditionalJazz: CString = b"Jazz|Traditional Jazz\0".as_ptr() as *const ::std::ffi::c_char;
14983 pub const kPop: CString = b"Pop\0".as_ptr() as *const ::std::ffi::c_char;
14984 pub const kPop80sPop: CString = b"Pop|80's Pop\0".as_ptr() as *const ::std::ffi::c_char;
14985 pub const kPopBritpop: CString = b"Pop|Britpop\0".as_ptr() as *const ::std::ffi::c_char;
14986 pub const kPopChartDance: CString = b"Pop|Chart Dance\0".as_ptr() as *const ::std::ffi::c_char;
14987 pub const kPopDancehall: CString = b"Pop|Dancehall\0".as_ptr() as *const ::std::ffi::c_char;
14988 pub const kPopDisco: CString = b"Pop|Disco\0".as_ptr() as *const ::std::ffi::c_char;
14989 pub const kPopRock: CString = b"Pop|Pop/Rock\0".as_ptr() as *const ::std::ffi::c_char;
14990 pub const kPopTeenPop: CString = b"Pop|Teen Pop\0".as_ptr() as *const ::std::ffi::c_char;
14991 pub const kRockMetal: CString = b"Rock/Metal\0".as_ptr() as *const ::std::ffi::c_char;
14992 pub const kRockMetalAlternativeRock: CString = b"Rock/Metal|Alternative Rock\0".as_ptr() as *const ::std::ffi::c_char;
14993 pub const kRockMetalBallad: CString = b"Rock/Metal|Ballad\0".as_ptr() as *const ::std::ffi::c_char;
14994 pub const kRockMetalBluesRock: CString = b"Rock/Metal|Blues Rock\0".as_ptr() as *const ::std::ffi::c_char;
14995 pub const kRockMetalClassicRock: CString = b"Rock/Metal|Classic Rock\0".as_ptr() as *const ::std::ffi::c_char;
14996 pub const kRockMetalDeathBlackMetal: CString = b"Rock/Metal|Death/Black Metal\0".as_ptr() as *const ::std::ffi::c_char;
14997 pub const kRockMetalHardRock: CString = b"Rock/Metal|Hard Rock\0".as_ptr() as *const ::std::ffi::c_char;
14998 pub const kRockMetalHeavyMetal: CString = b"Rock/Metal|Heavy Metal\0".as_ptr() as *const ::std::ffi::c_char;
14999 pub const kRockMetalNuMetal: CString = b"Rock/Metal|NuMetal\0".as_ptr() as *const ::std::ffi::c_char;
15000 pub const kRockMetalProgressiveRock: CString = b"Rock/Metal|Progressive Rock\0".as_ptr() as *const ::std::ffi::c_char;
15001 pub const kRockMetalReggae: CString = b"Rock/Metal|Reggae\0".as_ptr() as *const ::std::ffi::c_char;
15002 pub const kRockMetalRockRoll: CString = b"Rock/Metal|Rock & Roll\0".as_ptr() as *const ::std::ffi::c_char;
15003 pub const kRockMetalRockabilly: CString = b"Rock/Metal|Rockabilly\0".as_ptr() as *const ::std::ffi::c_char;
15004 pub const kRockMetalSingerSongwriter: CString = b"Rock/Metal|Singer/Songwriter\0".as_ptr() as *const ::std::ffi::c_char;
15005 pub const kRockMetalThrashMetal: CString = b"Rock/Metal|Thrash Metal\0".as_ptr() as *const ::std::ffi::c_char;
15006 pub const kUrbanHipHopRB: CString = b"Urban (Hip-Hop / R&B)\0".as_ptr() as *const ::std::ffi::c_char;
15007 pub const kUrbanHipHopRBClassic: CString = b"Urban (Hip-Hop / R&B)|Classic R&B\0".as_ptr() as *const ::std::ffi::c_char;
15008 pub const kUrbanHipHopRBEastCoastHipHop: CString = b"Urban (Hip-Hop / R&B)|EastCoast Hip-Hop\0".as_ptr() as *const ::std::ffi::c_char;
15009 pub const kUrbanHipHopRBFunk: CString = b"Urban (Hip-Hop / R&B)|Funk\0".as_ptr() as *const ::std::ffi::c_char;
15010 pub const kUrbanHipHopRBModern: CString = b"Urban (Hip-Hop / R&B)|Modern R&B\0".as_ptr() as *const ::std::ffi::c_char;
15011 pub const kUrbanHipHopRBPop: CString = b"Urban (Hip-Hop / R&B)|R&B Pop\0".as_ptr() as *const ::std::ffi::c_char;
15012 pub const kUrbanHipHopRBRapHipHop: CString = b"Urban (Hip-Hop / R&B)|Rap/Hip Hop\0".as_ptr() as *const ::std::ffi::c_char;
15013 pub const kUrbanHipHopRBSoul: CString = b"Urban (Hip-Hop / R&B)|Soul\0".as_ptr() as *const ::std::ffi::c_char;
15014 pub const kUrbanHipHopRBWestCoastHipHop: CString = b"Urban (Hip-Hop / R&B)|WestCoast Hip-Hop\0".as_ptr() as *const ::std::ffi::c_char;
15015 pub const kWorldEthnic: CString = b"World/Ethnic\0".as_ptr() as *const ::std::ffi::c_char;
15016 pub const kWorldEthnicAfrica: CString = b"World/Ethnic|Africa\0".as_ptr() as *const ::std::ffi::c_char;
15017 pub const kWorldEthnicAsia: CString = b"World/Ethnic|Asia\0".as_ptr() as *const ::std::ffi::c_char;
15018 pub const kWorldEthnicAustralia: CString = b"World/Ethnic|Australia\0".as_ptr() as *const ::std::ffi::c_char;
15019 pub const kWorldEthnicCeltic: CString = b"World/Ethnic|Celtic\0".as_ptr() as *const ::std::ffi::c_char;
15020 pub const kWorldEthnicEasternEurope: CString = b"World/Ethnic|Eastern Europe\0".as_ptr() as *const ::std::ffi::c_char;
15021 pub const kWorldEthnicEurope: CString = b"World/Ethnic|Europe\0".as_ptr() as *const ::std::ffi::c_char;
15022 pub const kWorldEthnicIndiaOriental: CString = b"World/Ethnic|India/Oriental\0".as_ptr() as *const ::std::ffi::c_char;
15023 pub const kWorldEthnicKlezmer: CString = b"World/Ethnic|Klezmer\0".as_ptr() as *const ::std::ffi::c_char;
15024 pub const kWorldEthnicNorthAmerica: CString = b"World/Ethnic|North America\0".as_ptr() as *const ::std::ffi::c_char;
15025 pub const kWorldEthnicScandinavia: CString = b"World/Ethnic|Scandinavia\0".as_ptr() as *const ::std::ffi::c_char;
15026 pub const kWorldEthnicSouthAmerica: CString = b"World/Ethnic|South America\0".as_ptr() as *const ::std::ffi::c_char;
15027 }
15028 pub mod PlugType {
15029 #[allow(unused_imports)]
15030 use super::*;
15031 pub const kAmbisonics: CString = b"Ambisonics\0".as_ptr() as *const ::std::ffi::c_char;
15032 pub const kAnalyzer: CString = b"Analyzer\0".as_ptr() as *const ::std::ffi::c_char;
15033 pub const kFx: CString = b"Fx\0".as_ptr() as *const ::std::ffi::c_char;
15034 pub const kFxAnalyzer: CString = b"Fx|Analyzer\0".as_ptr() as *const ::std::ffi::c_char;
15035 pub const kFxBass: CString = b"Fx|Bass\0".as_ptr() as *const ::std::ffi::c_char;
15036 pub const kFxChannelStrip: CString = b"Fx|Channel Strip\0".as_ptr() as *const ::std::ffi::c_char;
15037 pub const kFxDelay: CString = b"Fx|Delay\0".as_ptr() as *const ::std::ffi::c_char;
15038 pub const kFxDistortion: CString = b"Fx|Distortion\0".as_ptr() as *const ::std::ffi::c_char;
15039 pub const kFxDrums: CString = b"Fx|Drums\0".as_ptr() as *const ::std::ffi::c_char;
15040 pub const kFxDynamics: CString = b"Fx|Dynamics\0".as_ptr() as *const ::std::ffi::c_char;
15041 pub const kFxEQ: CString = b"Fx|EQ\0".as_ptr() as *const ::std::ffi::c_char;
15042 pub const kFxFilter: CString = b"Fx|Filter\0".as_ptr() as *const ::std::ffi::c_char;
15043 pub const kFxGenerator: CString = b"Fx|Generator\0".as_ptr() as *const ::std::ffi::c_char;
15044 pub const kFxGuitar: CString = b"Fx|Guitar\0".as_ptr() as *const ::std::ffi::c_char;
15045 pub const kFxInstrument: CString = b"Fx|Instrument\0".as_ptr() as *const ::std::ffi::c_char;
15046 pub const kFxInstrumentExternal: CString = b"Fx|Instrument|External\0".as_ptr() as *const ::std::ffi::c_char;
15047 pub const kFxMastering: CString = b"Fx|Mastering\0".as_ptr() as *const ::std::ffi::c_char;
15048 pub const kFxMicrophone: CString = b"Fx|Microphone\0".as_ptr() as *const ::std::ffi::c_char;
15049 pub const kFxModulation: CString = b"Fx|Modulation\0".as_ptr() as *const ::std::ffi::c_char;
15050 pub const kFxNetwork: CString = b"Fx|Network\0".as_ptr() as *const ::std::ffi::c_char;
15051 pub const kFxPitchShift: CString = b"Fx|Pitch Shift\0".as_ptr() as *const ::std::ffi::c_char;
15052 pub const kFxRestoration: CString = b"Fx|Restoration\0".as_ptr() as *const ::std::ffi::c_char;
15053 pub const kFxReverb: CString = b"Fx|Reverb\0".as_ptr() as *const ::std::ffi::c_char;
15054 pub const kFxSpatial: CString = b"Fx|Spatial\0".as_ptr() as *const ::std::ffi::c_char;
15055 pub const kFxSurround: CString = b"Fx|Surround\0".as_ptr() as *const ::std::ffi::c_char;
15056 pub const kFxTools: CString = b"Fx|Tools\0".as_ptr() as *const ::std::ffi::c_char;
15057 pub const kFxVocals: CString = b"Fx|Vocals\0".as_ptr() as *const ::std::ffi::c_char;
15058 pub const kInstrument: CString = b"Instrument\0".as_ptr() as *const ::std::ffi::c_char;
15059 pub const kInstrumentDrum: CString = b"Instrument|Drum\0".as_ptr() as *const ::std::ffi::c_char;
15060 pub const kInstrumentExternal: CString = b"Instrument|External\0".as_ptr() as *const ::std::ffi::c_char;
15061 pub const kInstrumentPiano: CString = b"Instrument|Piano\0".as_ptr() as *const ::std::ffi::c_char;
15062 pub const kInstrumentSampler: CString = b"Instrument|Sampler\0".as_ptr() as *const ::std::ffi::c_char;
15063 pub const kInstrumentSynth: CString = b"Instrument|Synth\0".as_ptr() as *const ::std::ffi::c_char;
15064 pub const kInstrumentSynthSampler: CString = b"Instrument|Synth|Sampler\0".as_ptr() as *const ::std::ffi::c_char;
15065 pub const kMono: CString = b"Mono\0".as_ptr() as *const ::std::ffi::c_char;
15066 pub const kNoOfflineProcess: CString = b"NoOfflineProcess\0".as_ptr() as *const ::std::ffi::c_char;
15067 pub const kOnlyARA: CString = b"OnlyARA\0".as_ptr() as *const ::std::ffi::c_char;
15068 pub const kOnlyOfflineProcess: CString = b"OnlyOfflineProcess\0".as_ptr() as *const ::std::ffi::c_char;
15069 pub const kOnlyRealTime: CString = b"OnlyRT\0".as_ptr() as *const ::std::ffi::c_char;
15070 pub const kSpatial: CString = b"Spatial\0".as_ptr() as *const ::std::ffi::c_char;
15071 pub const kSpatialFx: CString = b"Spatial|Fx\0".as_ptr() as *const ::std::ffi::c_char;
15072 pub const kStereo: CString = b"Stereo\0".as_ptr() as *const ::std::ffi::c_char;
15073 pub const kSurround: CString = b"Surround\0".as_ptr() as *const ::std::ffi::c_char;
15074 pub const kUpDownMix: CString = b"Up-Downmix\0".as_ptr() as *const ::std::ffi::c_char;
15075 }
15076 pub mod PresetAttributes {
15077 #[allow(unused_imports)]
15078 use super::*;
15079 pub const kCharacter: CString = b"MusicalCharacter\0".as_ptr() as *const ::std::ffi::c_char;
15080 pub const kFileName: CString = b"FileName\0".as_ptr() as *const ::std::ffi::c_char;
15081 pub const kFilePathStringType: CString = b"FilePathString\0".as_ptr() as *const ::std::ffi::c_char;
15082 pub const kInstrument: CString = b"MusicalInstrument\0".as_ptr() as *const ::std::ffi::c_char;
15083 pub const kName: CString = b"Name\0".as_ptr() as *const ::std::ffi::c_char;
15084 pub const kPlugInCategory: CString = b"PlugInCategory\0".as_ptr() as *const ::std::ffi::c_char;
15085 pub const kPlugInName: CString = b"PlugInName\0".as_ptr() as *const ::std::ffi::c_char;
15086 pub const kStateType: CString = b"StateType\0".as_ptr() as *const ::std::ffi::c_char;
15087 pub const kStyle: CString = b"MusicalStyle\0".as_ptr() as *const ::std::ffi::c_char;
15088 }
15089 pub mod SpeakerArr {
15090 #[allow(unused_imports)]
15091 use super::*;
15092 pub const k100: SpeakerArrangement = 186423;
15093 pub const k100Cine: SpeakerArrangement = 2039;
15094 pub const k100_9_3: SpeakerArrangement = 1929641975;
15095 pub const k101: SpeakerArrangement = 186431;
15096 pub const k101Cine: SpeakerArrangement = 2047;
15097 pub const k101MPEG3D: SpeakerArrangement = 186431;
15098 pub const k102: SpeakerArrangement = 454719;
15099 pub const k102_9_3: SpeakerArrangement = 1929904127;
15100 pub const k110: SpeakerArrangement = 194615;
15101 pub const k111: SpeakerArrangement = 194623;
15102 pub const k111MPEG3D: SpeakerArrangement = 185919;
15103 pub const k122: SpeakerArrangement = 454911;
15104 pub const k130: SpeakerArrangement = 196151;
15105 pub const k131: SpeakerArrangement = 196159;
15106 pub const k140: SpeakerArrangement = 173141055027;
15107 pub const k220: SpeakerArrangement = 1929641975;
15108 pub const k222: SpeakerArrangement = 1929904127;
15109 pub const k30Cine: SpeakerArrangement = 7;
15110 pub const k30Music: SpeakerArrangement = 259;
15111 pub const k30_5_2: SpeakerArrangement = 1342369799;
15112 pub const k31Cine: SpeakerArrangement = 15;
15113 pub const k31Music: SpeakerArrangement = 267;
15114 pub const k40Cine: SpeakerArrangement = 263;
15115 pub const k40Music: SpeakerArrangement = 51;
15116 pub const k40_2_2: SpeakerArrangement = 25820137220;
15117 pub const k40_4: SpeakerArrangement = 184371;
15118 pub const k40_4_2: SpeakerArrangement = 1342361651;
15119 pub const k40_4_4: SpeakerArrangement = 173141053491;
15120 pub const k41Cine: SpeakerArrangement = 271;
15121 pub const k41Music: SpeakerArrangement = 59;
15122 pub const k41_4_1: SpeakerArrangement = 536899643;
15123 pub const k50: SpeakerArrangement = 55;
15124 pub const k50_2: SpeakerArrangement = 20535;
15125 pub const k50_2_2: SpeakerArrangement = 1392508983;
15126 pub const k50_2_TS: SpeakerArrangement = 50331703;
15127 pub const k50_3_2: SpeakerArrangement = 1342206007;
15128 pub const k50_4: SpeakerArrangement = 184375;
15129 pub const k50_4_1: SpeakerArrangement = 537055287;
15130 pub const k50_4_2: SpeakerArrangement = 1342361655;
15131 pub const k50_4_4: SpeakerArrangement = 173141053495;
15132 pub const k50_5: SpeakerArrangement = 186423;
15133 pub const k50_5_3: SpeakerArrangement = 1879240759;
15134 pub const k50_5_Sony: SpeakerArrangement = 192567;
15135 pub const k50_6: SpeakerArrangement = 194615;
15136 pub const k51: SpeakerArrangement = 63;
15137 pub const k51_2: SpeakerArrangement = 20543;
15138 pub const k51_2_TS: SpeakerArrangement = 50331711;
15139 pub const k51_4: SpeakerArrangement = 184383;
15140 pub const k51_4_1: SpeakerArrangement = 537055295;
15141 pub const k51_5: SpeakerArrangement = 186431;
15142 pub const k51_5_3: SpeakerArrangement = 1879240767;
15143 pub const k51_6: SpeakerArrangement = 194623;
15144 pub const k52_5: SpeakerArrangement = 454719;
15145 pub const k60Cine: SpeakerArrangement = 311;
15146 pub const k60Music: SpeakerArrangement = 1587;
15147 pub const k60_4_4: SpeakerArrangement = 173141055027;
15148 pub const k61Cine: SpeakerArrangement = 319;
15149 pub const k61Music: SpeakerArrangement = 1595;
15150 pub const k70Cine: SpeakerArrangement = 247;
15151 pub const k70CineFrontHigh: SpeakerArrangement = 20535;
15152 pub const k70CineSideHigh: SpeakerArrangement = 50331703;
15153 pub const k70MPEG3D: SpeakerArrangement = 20535;
15154 pub const k70Music: SpeakerArrangement = 1591;
15155 pub const k70_2: SpeakerArrangement = 50333239;
15156 pub const k70_2_TF: SpeakerArrangement = 22071;
15157 pub const k70_3: SpeakerArrangement = 87607;
15158 pub const k70_4: SpeakerArrangement = 185911;
15159 pub const k70_4_2: SpeakerArrangement = 1342363191;
15160 pub const k70_6: SpeakerArrangement = 50517559;
15161 pub const k71Cine: SpeakerArrangement = 255;
15162 pub const k71CineCenterHigh: SpeakerArrangement = 8511;
15163 pub const k71CineFrontHigh: SpeakerArrangement = 20543;
15164 pub const k71CineFullFront: SpeakerArrangement = 255;
15165 pub const k71CineFullRear: SpeakerArrangement = 201326655;
15166 pub const k71CineSideFill: SpeakerArrangement = 1599;
15167 pub const k71CineSideHigh: SpeakerArrangement = 50331711;
15168 pub const k71CineTopCenter: SpeakerArrangement = 2367;
15169 pub const k71MPEG3D: SpeakerArrangement = 20543;
15170 pub const k71Music: SpeakerArrangement = 1599;
15171 pub const k71Proximity: SpeakerArrangement = 6442451007;
15172 pub const k71_2: SpeakerArrangement = 50333247;
15173 pub const k71_2_TF: SpeakerArrangement = 22079;
15174 pub const k71_4: SpeakerArrangement = 185919;
15175 pub const k71_6: SpeakerArrangement = 50517567;
15176 pub const k72_3: SpeakerArrangement = 349759;
15177 pub const k72_5: SpeakerArrangement = 454911;
15178 pub const k80Cine: SpeakerArrangement = 503;
15179 pub const k80Cube: SpeakerArrangement = 184371;
15180 pub const k80Music: SpeakerArrangement = 1847;
15181 pub const k81Cine: SpeakerArrangement = 511;
15182 pub const k81MPEG3D: SpeakerArrangement = 536899643;
15183 pub const k81Music: SpeakerArrangement = 1855;
15184 pub const k90: SpeakerArrangement = 184375;
15185 pub const k90Cine: SpeakerArrangement = 1783;
15186 pub const k90_4: SpeakerArrangement = 186103;
15187 pub const k90_4_W: SpeakerArrangement = 1729382256910456375;
15188 pub const k90_6: SpeakerArrangement = 50517751;
15189 pub const k90_6_W: SpeakerArrangement = 1729382256960788023;
15190 pub const k91: SpeakerArrangement = 184383;
15191 pub const k91Atmos: SpeakerArrangement = 50333247;
15192 pub const k91Cine: SpeakerArrangement = 1791;
15193 pub const k91_4: SpeakerArrangement = 186111;
15194 pub const k91_4_W: SpeakerArrangement = 1729382256910456383;
15195 pub const k91_6: SpeakerArrangement = 50517759;
15196 pub const k91_6_W: SpeakerArrangement = 1729382256960788031;
15197 pub const kAmbi1stOrderACN: SpeakerArrangement = 15728640;
15198 pub const kAmbi2cdOrderACN: SpeakerArrangement = 8521230843904;
15199 pub const kAmbi3rdOrderACN: SpeakerArrangement = 1125625044664320;
15200 pub const kAmbi4thOrderACN: SpeakerArrangement = 576460477441245184;
15201 pub const kAmbi5thOrderACN: SpeakerArrangement = 68719476735;
15202 pub const kAmbi6thOrderACN: SpeakerArrangement = 562949953421311;
15203 pub const kAmbi7thOrderACN: SpeakerArrangement = 18446744073709551615;
15204 pub const kCineFront: SpeakerArrangement = 199;
15205 pub const kEmpty: SpeakerArrangement = 0;
15206 pub const kMono: SpeakerArrangement = 524288;
15207 pub const kStereo: SpeakerArrangement = 3;
15208 pub const kStereoBF: SpeakerArrangement = 1342177280;
15209 pub const kStereoCLfe: SpeakerArrangement = 12;
15210 pub const kStereoCenter: SpeakerArrangement = 192;
15211 pub const kStereoSide: SpeakerArrangement = 1536;
15212 pub const kStereoSurround: SpeakerArrangement = 48;
15213 pub const kStereoTF: SpeakerArrangement = 20480;
15214 pub const kStereoTR: SpeakerArrangement = 163840;
15215 pub const kStereoTS: SpeakerArrangement = 50331648;
15216 pub const kStereoWide: SpeakerArrangement = 1729382256910270464;
15217 pub const kString100Cine: CString = b"10.0 Cine\0".as_ptr() as *const ::std::ffi::c_char;
15218 pub const kString100CineS: CString = b"L R C Ls Rs Lc Rc Cs Sl Sr\0".as_ptr() as *const ::std::ffi::c_char;
15219 pub const kString101Cine: CString = b"10.1 Cine\0".as_ptr() as *const ::std::ffi::c_char;
15220 pub const kString101CineS: CString = b"L R C LFE Ls Rs Lc Rc Cs Sl Sr\0".as_ptr() as *const ::std::ffi::c_char;
15221 pub const kString130: CString = b"13.0 Auro-3D\0".as_ptr() as *const ::std::ffi::c_char;
15222 pub const kString130S: CString = b"L R C Ls Rs Sl Sr Tc Tfl Tfc Tfr Trl Trr\0".as_ptr() as *const ::std::ffi::c_char;
15223 pub const kString131: CString = b"13.1 Auro-3D\0".as_ptr() as *const ::std::ffi::c_char;
15224 pub const kString131S: CString = b"L R C LFE Ls Rs Sl Sr Tc Tfl Tfc Tfr Trl Trr\0".as_ptr() as *const ::std::ffi::c_char;
15225 pub const kString220: CString = b"22.0\0".as_ptr() as *const ::std::ffi::c_char;
15226 pub const kString220S: CString = b"L R C Ls Rs Lc Rc Cs Sl Sr Tc Tfl Tfc Tfr Trl Trc Trr Tsl Tsr Bfl Bfc Bfr\0".as_ptr() as *const ::std::ffi::c_char;
15227 pub const kString222: CString = b"22.2\0".as_ptr() as *const ::std::ffi::c_char;
15228 pub const kString222S: CString = b"L R C LFE Ls Rs Lc Rc Cs Sl Sr Tc Tfl Tfc Tfr Trl Trc Trr LFE2 Tsl Tsr Bfl Bfc Bfr\0".as_ptr() as *const ::std::ffi::c_char;
15229 pub const kString30Cine: CString = b"LRC\0".as_ptr() as *const ::std::ffi::c_char;
15230 pub const kString30CineS: CString = b"L R C\0".as_ptr() as *const ::std::ffi::c_char;
15231 pub const kString30Music: CString = b"LRS\0".as_ptr() as *const ::std::ffi::c_char;
15232 pub const kString30MusicS: CString = b"L R S\0".as_ptr() as *const ::std::ffi::c_char;
15233 pub const kString30_5_2: CString = b"3.0.5.2\0".as_ptr() as *const ::std::ffi::c_char;
15234 pub const kString30_5_2S: CString = b"L R C Tfl Tfc Tfr Trl Trr Bfl Bfr\0".as_ptr() as *const ::std::ffi::c_char;
15235 pub const kString31Cine: CString = b"LRC+LFE\0".as_ptr() as *const ::std::ffi::c_char;
15236 pub const kString31CineS: CString = b"L R C LFE\0".as_ptr() as *const ::std::ffi::c_char;
15237 pub const kString31Music: CString = b"LRS+LFE\0".as_ptr() as *const ::std::ffi::c_char;
15238 pub const kString31MusicS: CString = b"L R LFE S\0".as_ptr() as *const ::std::ffi::c_char;
15239 pub const kString40Cine: CString = b"LRCS\0".as_ptr() as *const ::std::ffi::c_char;
15240 pub const kString40CineS: CString = b"L R C S\0".as_ptr() as *const ::std::ffi::c_char;
15241 pub const kString40Music: CString = b"Quadro\0".as_ptr() as *const ::std::ffi::c_char;
15242 pub const kString40MusicS: CString = b"L R Ls Rs\0".as_ptr() as *const ::std::ffi::c_char;
15243 pub const kString40_2_2: CString = b"4.0.3.2\0".as_ptr() as *const ::std::ffi::c_char;
15244 pub const kString40_2_2S: CString = b"C Sl Sr Cs Tfc Tsl Tsr Trc\0".as_ptr() as *const ::std::ffi::c_char;
15245 pub const kString40_4: CString = b"8.0 Cube\0".as_ptr() as *const ::std::ffi::c_char;
15246 pub const kString40_4S: CString = b"L R Ls Rs Tfl Tfr Trl Trr\0".as_ptr() as *const ::std::ffi::c_char;
15247 pub const kString40_4_2: CString = b"4.0.4.2\0".as_ptr() as *const ::std::ffi::c_char;
15248 pub const kString40_4_2S: CString = b"L R Ls Rs Tfl Tfr Trl Trr Bfl Bfr\0".as_ptr() as *const ::std::ffi::c_char;
15249 pub const kString40_4_4: CString = b"4.0.4.4\0".as_ptr() as *const ::std::ffi::c_char;
15250 pub const kString40_4_4S: CString = b"L R Ls Rs Tfl Tfr Trl Trr Bfl Bfr Brl Brr\0".as_ptr() as *const ::std::ffi::c_char;
15251 pub const kString41Cine: CString = b"LRCS+LFE\0".as_ptr() as *const ::std::ffi::c_char;
15252 pub const kString41CineS: CString = b"L R C LFE S\0".as_ptr() as *const ::std::ffi::c_char;
15253 pub const kString41Music: CString = b"Quadro+LFE\0".as_ptr() as *const ::std::ffi::c_char;
15254 pub const kString41MusicS: CString = b"L R LFE Ls Rs\0".as_ptr() as *const ::std::ffi::c_char;
15255 pub const kString41_4_1: CString = b"8.1 MPEG\0".as_ptr() as *const ::std::ffi::c_char;
15256 pub const kString41_4_1S: CString = b"L R LFE Ls Rs Tfl Tfc Tfr Bfc\0".as_ptr() as *const ::std::ffi::c_char;
15257 pub const kString50: CString = b"5.0\0".as_ptr() as *const ::std::ffi::c_char;
15258 pub const kString50S: CString = b"L R C Ls Rs\0".as_ptr() as *const ::std::ffi::c_char;
15259 pub const kString50_2: CString = b"5.0.2\0".as_ptr() as *const ::std::ffi::c_char;
15260 pub const kString50_2S: CString = b"L R C Ls Rs Tfl Tfr\0".as_ptr() as *const ::std::ffi::c_char;
15261 pub const kString50_2TopSide: CString = b"5.0.2 Top Side\0".as_ptr() as *const ::std::ffi::c_char;
15262 pub const kString50_2TopSideS: CString = b"L R C Ls Rs Tsl Tsr\0".as_ptr() as *const ::std::ffi::c_char;
15263 pub const kString50_2_2: CString = b"5.0.2.2\0".as_ptr() as *const ::std::ffi::c_char;
15264 pub const kString50_2_2S: CString = b"L R C Ls Rs Tsl Tsr Bfl Bfr\0".as_ptr() as *const ::std::ffi::c_char;
15265 pub const kString50_3_2: CString = b"5.0.3.2\0".as_ptr() as *const ::std::ffi::c_char;
15266 pub const kString50_3_2S: CString = b"L R C Ls Rs Tfl Tfc Tfr Bfl Bfr\0".as_ptr() as *const ::std::ffi::c_char;
15267 pub const kString50_4: CString = b"5.0.4\0".as_ptr() as *const ::std::ffi::c_char;
15268 pub const kString50_4S: CString = b"L R C Ls Rs Tfl Tfr Trl Trr\0".as_ptr() as *const ::std::ffi::c_char;
15269 pub const kString50_4_1: CString = b"5.0.4.1\0".as_ptr() as *const ::std::ffi::c_char;
15270 pub const kString50_4_1S: CString = b"L R C Ls Rs Tfl Tfr Trl Trr Bfc\0".as_ptr() as *const ::std::ffi::c_char;
15271 pub const kString50_4_2: CString = b"5.0.4.2\0".as_ptr() as *const ::std::ffi::c_char;
15272 pub const kString50_4_2S: CString = b"L R C Ls Rs Tfl Tfr Trl Trr Bfl Bfr\0".as_ptr() as *const ::std::ffi::c_char;
15273 pub const kString50_4_4: CString = b"5.0.4.4\0".as_ptr() as *const ::std::ffi::c_char;
15274 pub const kString50_4_4S: CString = b"L R C Ls Rs Tfl Tfr Trl Trr Bfl Bfr Brl Brr\0".as_ptr() as *const ::std::ffi::c_char;
15275 pub const kString50_5: CString = b"10.0 Auro-3D\0".as_ptr() as *const ::std::ffi::c_char;
15276 pub const kString50_5S: CString = b"L R C Ls Rs Tc Tfl Tfr Trl Trr\0".as_ptr() as *const ::std::ffi::c_char;
15277 pub const kString50_5_3: CString = b"5.0.5.3\0".as_ptr() as *const ::std::ffi::c_char;
15278 pub const kString50_5_3S: CString = b"L R C Ls Rs Tfl Tfc Tfr Trl Trr Bfl Bfc Bfr\0".as_ptr() as *const ::std::ffi::c_char;
15279 pub const kString50_5_Sony: CString = b"5.0.5 Sony\0".as_ptr() as *const ::std::ffi::c_char;
15280 pub const kString50_5_SonyS: CString = b"L R C Ls Rs Tfl Tfc Tfr Trl Trr\0".as_ptr() as *const ::std::ffi::c_char;
15281 pub const kString50_6: CString = b"11.0 Auro-3D\0".as_ptr() as *const ::std::ffi::c_char;
15282 pub const kString50_6S: CString = b"L R C Ls Rs Tc Tfl Tfc Tfr Trl Trr\0".as_ptr() as *const ::std::ffi::c_char;
15283 pub const kString51: CString = b"5.1\0".as_ptr() as *const ::std::ffi::c_char;
15284 pub const kString51S: CString = b"L R C LFE Ls Rs\0".as_ptr() as *const ::std::ffi::c_char;
15285 pub const kString51_2: CString = b"5.1.2\0".as_ptr() as *const ::std::ffi::c_char;
15286 pub const kString51_2S: CString = b"L R C LFE Ls Rs Tfl Tfr\0".as_ptr() as *const ::std::ffi::c_char;
15287 pub const kString51_2TopSide: CString = b"5.1.2 Top Side\0".as_ptr() as *const ::std::ffi::c_char;
15288 pub const kString51_2TopSideS: CString = b"L R C LFE Ls Rs Tsl Tsr\0".as_ptr() as *const ::std::ffi::c_char;
15289 pub const kString51_4: CString = b"5.1.4\0".as_ptr() as *const ::std::ffi::c_char;
15290 pub const kString51_4S: CString = b"L R C LFE Ls Rs Tfl Tfr Trl Trr\0".as_ptr() as *const ::std::ffi::c_char;
15291 pub const kString51_4_1: CString = b"5.1.4.1\0".as_ptr() as *const ::std::ffi::c_char;
15292 pub const kString51_4_1S: CString = b"L R C LFE Ls Rs Tfl Tfr Trl Trr Bfc\0".as_ptr() as *const ::std::ffi::c_char;
15293 pub const kString51_5: CString = b"10.1 Auro-3D\0".as_ptr() as *const ::std::ffi::c_char;
15294 pub const kString51_5S: CString = b"L R C LFE Ls Rs Tc Tfl Tfr Trl Trr\0".as_ptr() as *const ::std::ffi::c_char;
15295 pub const kString51_5_3: CString = b"5.1.5.3\0".as_ptr() as *const ::std::ffi::c_char;
15296 pub const kString51_5_3S: CString = b"L R C LFE Ls Rs Tfl Tfc Tfr Trl Trr Bfl Bfc Bfr\0".as_ptr() as *const ::std::ffi::c_char;
15297 pub const kString51_6: CString = b"11.1 Auro-3D\0".as_ptr() as *const ::std::ffi::c_char;
15298 pub const kString51_6S: CString = b"L R C LFE Ls Rs Tc Tfl Tfc Tfr Trl Trr\0".as_ptr() as *const ::std::ffi::c_char;
15299 pub const kString52_5: CString = b"5.2.5\0".as_ptr() as *const ::std::ffi::c_char;
15300 pub const kString52_5S: CString = b"L R C LFE Ls Rs Tfl Tfc Tfr Trl Trr LFE2\0".as_ptr() as *const ::std::ffi::c_char;
15301 pub const kString60Cine: CString = b"6.0 Cine\0".as_ptr() as *const ::std::ffi::c_char;
15302 pub const kString60CineS: CString = b"L R C Ls Rs Cs\0".as_ptr() as *const ::std::ffi::c_char;
15303 pub const kString60Music: CString = b"6.0 Music\0".as_ptr() as *const ::std::ffi::c_char;
15304 pub const kString60MusicS: CString = b"L R Ls Rs Sl Sr\0".as_ptr() as *const ::std::ffi::c_char;
15305 pub const kString60_4_4: CString = b"14.0\0".as_ptr() as *const ::std::ffi::c_char;
15306 pub const kString60_4_4S: CString = b"L R Ls Rs Sl Sr Tfl Tfr Trl Trr Bfl Bfr Brl Brr\0".as_ptr() as *const ::std::ffi::c_char;
15307 pub const kString61Cine: CString = b"6.1 Cine\0".as_ptr() as *const ::std::ffi::c_char;
15308 pub const kString61CineS: CString = b"L R C LFE Ls Rs Cs\0".as_ptr() as *const ::std::ffi::c_char;
15309 pub const kString61Music: CString = b"6.1 Music\0".as_ptr() as *const ::std::ffi::c_char;
15310 pub const kString61MusicS: CString = b"L R LFE Ls Rs Sl Sr\0".as_ptr() as *const ::std::ffi::c_char;
15311 pub const kString70Cine: CString = b"7.0 SDDS\0".as_ptr() as *const ::std::ffi::c_char;
15312 pub const kString70CineOld: CString = b"7.0 Cine (SDDS)\0".as_ptr() as *const ::std::ffi::c_char;
15313 pub const kString70CineS: CString = b"L R C Ls Rs Lc Rc\0".as_ptr() as *const ::std::ffi::c_char;
15314 pub const kString70Music: CString = b"7.0\0".as_ptr() as *const ::std::ffi::c_char;
15315 pub const kString70MusicOld: CString = b"7.0 Music (Dolby)\0".as_ptr() as *const ::std::ffi::c_char;
15316 pub const kString70MusicS: CString = b"L R C Ls Rs Sl Sr\0".as_ptr() as *const ::std::ffi::c_char;
15317 pub const kString70_2: CString = b"7.0.2\0".as_ptr() as *const ::std::ffi::c_char;
15318 pub const kString70_2S: CString = b"L R C Ls Rs Sl Sr Tsl Tsr\0".as_ptr() as *const ::std::ffi::c_char;
15319 pub const kString70_2_TF: CString = b"7.0.2 Top Front\0".as_ptr() as *const ::std::ffi::c_char;
15320 pub const kString70_2_TFS: CString = b"L R C Ls Rs Sl Sr Tfl Tfr\0".as_ptr() as *const ::std::ffi::c_char;
15321 pub const kString70_3: CString = b"7.0.3\0".as_ptr() as *const ::std::ffi::c_char;
15322 pub const kString70_3S: CString = b"L R C Ls Rs Sl Sr Tfl Tfr Trc\0".as_ptr() as *const ::std::ffi::c_char;
15323 pub const kString70_4: CString = b"7.0.4\0".as_ptr() as *const ::std::ffi::c_char;
15324 pub const kString70_4S: CString = b"L R C Ls Rs Sl Sr Tfl Tfr Trl Trr\0".as_ptr() as *const ::std::ffi::c_char;
15325 pub const kString70_4_2: CString = b"7.0.4.2\0".as_ptr() as *const ::std::ffi::c_char;
15326 pub const kString70_4_2S: CString = b"L R C Ls Rs Sl Sr Tfl Tfr Trl Trr Bfl Bfr\0".as_ptr() as *const ::std::ffi::c_char;
15327 pub const kString70_6: CString = b"7.0.6\0".as_ptr() as *const ::std::ffi::c_char;
15328 pub const kString70_6S: CString = b"L R C Ls Rs Sl Sr Tfl Tfr Trl Trr Tsl Tsr\0".as_ptr() as *const ::std::ffi::c_char;
15329 pub const kString71Cine: CString = b"7.1 SDDS\0".as_ptr() as *const ::std::ffi::c_char;
15330 pub const kString71CineCenterHigh: CString = b"7.1 Cine Center High\0".as_ptr() as *const ::std::ffi::c_char;
15331 pub const kString71CineCenterHighS: CString = b"L R C LFE Ls Rs Cs Tfc\0".as_ptr() as *const ::std::ffi::c_char;
15332 pub const kString71CineFullRear: CString = b"7.1 Cine Full Rear\0".as_ptr() as *const ::std::ffi::c_char;
15333 pub const kString71CineFullRearS: CString = b"L R C LFE Ls Rs Lcs Rcs\0".as_ptr() as *const ::std::ffi::c_char;
15334 pub const kString71CineOld: CString = b"7.1 Cine (SDDS)\0".as_ptr() as *const ::std::ffi::c_char;
15335 pub const kString71CineS: CString = b"L R C LFE Ls Rs Lc Rc\0".as_ptr() as *const ::std::ffi::c_char;
15336 pub const kString71CineTopCenter: CString = b"7.1 Cine Top Center\0".as_ptr() as *const ::std::ffi::c_char;
15337 pub const kString71CineTopCenterS: CString = b"L R C LFE Ls Rs Cs Tc\0".as_ptr() as *const ::std::ffi::c_char;
15338 pub const kString71Music: CString = b"7.1\0".as_ptr() as *const ::std::ffi::c_char;
15339 pub const kString71MusicOld: CString = b"7.1 Music (Dolby)\0".as_ptr() as *const ::std::ffi::c_char;
15340 pub const kString71MusicS: CString = b"L R C LFE Ls Rs Sl Sr\0".as_ptr() as *const ::std::ffi::c_char;
15341 pub const kString71Proximity: CString = b"7.1 Proximity\0".as_ptr() as *const ::std::ffi::c_char;
15342 pub const kString71ProximityS: CString = b"L R C LFE Ls Rs Pl Pr\0".as_ptr() as *const ::std::ffi::c_char;
15343 pub const kString71_2: CString = b"7.1.2\0".as_ptr() as *const ::std::ffi::c_char;
15344 pub const kString71_2S: CString = b"L R C LFE Ls Rs Sl Sr Tsl Tsr\0".as_ptr() as *const ::std::ffi::c_char;
15345 pub const kString71_2_TF: CString = b"7.1.2 Top Front\0".as_ptr() as *const ::std::ffi::c_char;
15346 pub const kString71_2_TFS: CString = b"L R C LFE Ls Rs Sl Sr Tfl Tfr\0".as_ptr() as *const ::std::ffi::c_char;
15347 pub const kString71_4: CString = b"7.1.4\0".as_ptr() as *const ::std::ffi::c_char;
15348 pub const kString71_4S: CString = b"L R C LFE Ls Rs Sl Sr Tfl Tfr Trl Trr\0".as_ptr() as *const ::std::ffi::c_char;
15349 pub const kString71_6: CString = b"7.1.6\0".as_ptr() as *const ::std::ffi::c_char;
15350 pub const kString71_6S: CString = b"L R C LFE Ls Rs Sl Sr Tfl Tfr Trl Trr Tsl Tsr\0".as_ptr() as *const ::std::ffi::c_char;
15351 pub const kString72_3: CString = b"7.2.3\0".as_ptr() as *const ::std::ffi::c_char;
15352 pub const kString72_3S: CString = b"L R C LFE Ls Rs Sl Sr Tfl Tfr Trc LFE2\0".as_ptr() as *const ::std::ffi::c_char;
15353 pub const kString72_5: CString = b"12.2\0".as_ptr() as *const ::std::ffi::c_char;
15354 pub const kString72_5S: CString = b"L R C LFE Ls Rs Lc Rc Tfl Tfc Tfr Trl Trr LFE2\0".as_ptr() as *const ::std::ffi::c_char;
15355 pub const kString80Cine: CString = b"8.0 Cine\0".as_ptr() as *const ::std::ffi::c_char;
15356 pub const kString80CineS: CString = b"L R C Ls Rs Lc Rc Cs\0".as_ptr() as *const ::std::ffi::c_char;
15357 pub const kString80Music: CString = b"8.0 Music\0".as_ptr() as *const ::std::ffi::c_char;
15358 pub const kString80MusicS: CString = b"L R C Ls Rs Cs Sl Sr\0".as_ptr() as *const ::std::ffi::c_char;
15359 pub const kString81Cine: CString = b"8.1 Cine\0".as_ptr() as *const ::std::ffi::c_char;
15360 pub const kString81CineS: CString = b"L R C LFE Ls Rs Lc Rc Cs\0".as_ptr() as *const ::std::ffi::c_char;
15361 pub const kString81Music: CString = b"8.1 Music\0".as_ptr() as *const ::std::ffi::c_char;
15362 pub const kString81MusicS: CString = b"L R C LFE Ls Rs Cs Sl Sr\0".as_ptr() as *const ::std::ffi::c_char;
15363 pub const kString90Cine: CString = b"9.0 Cine\0".as_ptr() as *const ::std::ffi::c_char;
15364 pub const kString90CineS: CString = b"L R C Ls Rs Lc Rc Sl Sr\0".as_ptr() as *const ::std::ffi::c_char;
15365 pub const kString90_4: CString = b"9.0.4 ITU\0".as_ptr() as *const ::std::ffi::c_char;
15366 pub const kString90_4S: CString = b"L R C Ls Rs Lc Rc Sl Sr Tfl Tfr Trl Trr\0".as_ptr() as *const ::std::ffi::c_char;
15367 pub const kString90_4_W: CString = b"9.0.4\0".as_ptr() as *const ::std::ffi::c_char;
15368 pub const kString90_4_WS: CString = b"L R C Ls Rs Sl Sr Tfl Tfr Trl Trr Lw Rw\0".as_ptr() as *const ::std::ffi::c_char;
15369 pub const kString90_6: CString = b"9.0.6 ITU\0".as_ptr() as *const ::std::ffi::c_char;
15370 pub const kString90_6S: CString = b"L R C Ls Rs Lc Rc Sl Sr Tfl Tfr Trl Trr Tsl Tsr\0".as_ptr() as *const ::std::ffi::c_char;
15371 pub const kString90_6_W: CString = b"9.0.6\0".as_ptr() as *const ::std::ffi::c_char;
15372 pub const kString90_6_WS: CString = b"L R C Ls Rs Sl Sr Tfl Tfr Trl Trr Tsl Tsr Lw Rw\0".as_ptr() as *const ::std::ffi::c_char;
15373 pub const kString91Cine: CString = b"9.1 Cine\0".as_ptr() as *const ::std::ffi::c_char;
15374 pub const kString91CineS: CString = b"L R C LFE Ls Rs Lc Rc Sl Sr\0".as_ptr() as *const ::std::ffi::c_char;
15375 pub const kString91_4: CString = b"9.1.4 ITU\0".as_ptr() as *const ::std::ffi::c_char;
15376 pub const kString91_4S: CString = b"L R C LFE Ls Rs Lc Rc Sl Sr Tfl Tfr Trl Trr\0".as_ptr() as *const ::std::ffi::c_char;
15377 pub const kString91_4_W: CString = b"9.1.4\0".as_ptr() as *const ::std::ffi::c_char;
15378 pub const kString91_4_WS: CString = b"L R C LFE Ls Rs Sl Sr Tfl Tfr Trl Trr Lw Rw\0".as_ptr() as *const ::std::ffi::c_char;
15379 pub const kString91_6: CString = b"9.1.6 ITU\0".as_ptr() as *const ::std::ffi::c_char;
15380 pub const kString91_6S: CString = b"L R C LFE Ls Rs Lc Rc Sl Sr Tfl Tfr Trl Trr Tsl Tsr\0".as_ptr() as *const ::std::ffi::c_char;
15381 pub const kString91_6_W: CString = b"9.1.6\0".as_ptr() as *const ::std::ffi::c_char;
15382 pub const kString91_6_WS: CString = b"L R C LFE Ls Rs Sl Sr Tfl Tfr Trl Trr Tsl Tsr Lw Rw\0".as_ptr() as *const ::std::ffi::c_char;
15383 pub const kStringAmbi1stOrder: CString = b"1OA\0".as_ptr() as *const ::std::ffi::c_char;
15384 pub const kStringAmbi1stOrderS: CString = b"0 1 2 3\0".as_ptr() as *const ::std::ffi::c_char;
15385 pub const kStringAmbi2cdOrder: CString = b"2OA\0".as_ptr() as *const ::std::ffi::c_char;
15386 pub const kStringAmbi2cdOrderS: CString = b"0 1 2 3 4 5 6 7 8\0".as_ptr() as *const ::std::ffi::c_char;
15387 pub const kStringAmbi3rdOrder: CString = b"3OA\0".as_ptr() as *const ::std::ffi::c_char;
15388 pub const kStringAmbi3rdOrderS: CString = b"0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15\0".as_ptr() as *const ::std::ffi::c_char;
15389 pub const kStringAmbi4thOrder: CString = b"4OA\0".as_ptr() as *const ::std::ffi::c_char;
15390 pub const kStringAmbi4thOrderS: CString = b"0..24\0".as_ptr() as *const ::std::ffi::c_char;
15391 pub const kStringAmbi5thOrder: CString = b"5OA\0".as_ptr() as *const ::std::ffi::c_char;
15392 pub const kStringAmbi5thOrderS: CString = b"0..35\0".as_ptr() as *const ::std::ffi::c_char;
15393 pub const kStringAmbi6thOrder: CString = b"6OA\0".as_ptr() as *const ::std::ffi::c_char;
15394 pub const kStringAmbi6thOrderS: CString = b"0..48\0".as_ptr() as *const ::std::ffi::c_char;
15395 pub const kStringAmbi7thOrder: CString = b"7OA\0".as_ptr() as *const ::std::ffi::c_char;
15396 pub const kStringAmbi7thOrderS: CString = b"0..63\0".as_ptr() as *const ::std::ffi::c_char;
15397 pub const kStringCineFront: CString = b"Cine Front\0".as_ptr() as *const ::std::ffi::c_char;
15398 pub const kStringCineFrontS: CString = b"L R C Lc Rc\0".as_ptr() as *const ::std::ffi::c_char;
15399 pub const kStringEmpty: CString = b"\0".as_ptr() as *const ::std::ffi::c_char;
15400 pub const kStringMono: CString = b"Mono\0".as_ptr() as *const ::std::ffi::c_char;
15401 pub const kStringMonoS: CString = b"M\0".as_ptr() as *const ::std::ffi::c_char;
15402 pub const kStringStereo: CString = b"Stereo\0".as_ptr() as *const ::std::ffi::c_char;
15403 pub const kStringStereoBF: CString = b"Stereo (Bfl Bfr)\0".as_ptr() as *const ::std::ffi::c_char;
15404 pub const kStringStereoBFS: CString = b"Bfl Bfr\0".as_ptr() as *const ::std::ffi::c_char;
15405 pub const kStringStereoC: CString = b"Stereo (Lc Rc)\0".as_ptr() as *const ::std::ffi::c_char;
15406 pub const kStringStereoCLfe: CString = b"Stereo (C LFE)\0".as_ptr() as *const ::std::ffi::c_char;
15407 pub const kStringStereoCLfeS: CString = b"C LFE\0".as_ptr() as *const ::std::ffi::c_char;
15408 pub const kStringStereoCS: CString = b"Lc Rc\0".as_ptr() as *const ::std::ffi::c_char;
15409 pub const kStringStereoR: CString = b"Stereo (Ls Rs)\0".as_ptr() as *const ::std::ffi::c_char;
15410 pub const kStringStereoRS: CString = b"Ls Rs\0".as_ptr() as *const ::std::ffi::c_char;
15411 pub const kStringStereoS: CString = b"L R\0".as_ptr() as *const ::std::ffi::c_char;
15412 pub const kStringStereoSS: CString = b"Sl Sr\0".as_ptr() as *const ::std::ffi::c_char;
15413 pub const kStringStereoSide: CString = b"Stereo (Sl Sr)\0".as_ptr() as *const ::std::ffi::c_char;
15414 pub const kStringStereoTF: CString = b"Stereo (Tfl Tfr)\0".as_ptr() as *const ::std::ffi::c_char;
15415 pub const kStringStereoTFS: CString = b"Tfl Tfr\0".as_ptr() as *const ::std::ffi::c_char;
15416 pub const kStringStereoTR: CString = b"Stereo (Trl Trr)\0".as_ptr() as *const ::std::ffi::c_char;
15417 pub const kStringStereoTRS: CString = b"Trl Trr\0".as_ptr() as *const ::std::ffi::c_char;
15418 pub const kStringStereoTS: CString = b"Stereo (Tsl Tsr)\0".as_ptr() as *const ::std::ffi::c_char;
15419 pub const kStringStereoTSS: CString = b"Tsl Tsr\0".as_ptr() as *const ::std::ffi::c_char;
15420 pub const kStringStereoWide: CString = b"Stereo (Lw Rw)\0".as_ptr() as *const ::std::ffi::c_char;
15421 pub const kStringStereoWideS: CString = b"Lw Rw\0".as_ptr() as *const ::std::ffi::c_char;
15422 }
15423 pub mod StateType {
15424 #[allow(unused_imports)]
15425 use super::*;
15426 pub const kDefault: CString = b"Default\0".as_ptr() as *const ::std::ffi::c_char;
15427 pub const kProject: CString = b"Project\0".as_ptr() as *const ::std::ffi::c_char;
15428 pub const kTrackPreset: CString = b"TrackPreset\0".as_ptr() as *const ::std::ffi::c_char;
15429 }
15430 pub mod ViewType {
15431 #[allow(unused_imports)]
15432 use super::*;
15433 pub const kEditor: CString = b"editor\0".as_ptr() as *const ::std::ffi::c_char;
15434 }
15435 }
15436}