BEAST - Free Software Audio Synthesizer and Tracker  0.9.2
bsebasics.genidl.hh
Go to the documentation of this file.
1 
2 /*-------- begin ../sfi/sfidl generated code --------*/
3 
4 
5 
6 #include <bse/bse-internals.hh>
7 
8 
9 /* enum prototypes */
10 namespace Bse {
11 #define BSE_TYPE_MUSICAL_TUNING_TYPE BSE_CXX_DECLARED_ENUM_TYPE (Bse, MusicalTuningType)
12 #define BSE_TYPE_MIDI_CONTROL_TYPE BSE_CXX_DECLARED_ENUM_TYPE (Bse, MidiControlType)
13 #define BSE_TYPE_MIDI_CHANNEL_EVENT_TYPE BSE_CXX_DECLARED_ENUM_TYPE (Bse, MidiChannelEventType)
14 
15 
16 /* choice prototypes */
17 static SfiChoiceValues MusicalTuningType_choice_values();
18 static SfiChoiceValues MidiControlType_choice_values();
19 static SfiChoiceValues MidiChannelEventType_choice_values();
20 
21 
22 /* record prototypes */
23 class MidiChannelEvent;
24 typedef Sfi::RecordHandle<MidiChannelEvent> MidiChannelEventHandle;
25 #define BSE_TYPE_MIDI_CHANNEL_EVENT BSE_CXX_DECLARED_RECORD_TYPE (Bse, MidiChannelEvent)
26 class PropertyCandidates;
27 typedef Sfi::RecordHandle<PropertyCandidates> PropertyCandidatesHandle;
28 #define BSE_TYPE_PROPERTY_CANDIDATES BSE_CXX_DECLARED_RECORD_TYPE (Bse, PropertyCandidates)
29 class NoteDescription;
30 typedef Sfi::RecordHandle<NoteDescription> NoteDescriptionHandle;
31 #define BSE_TYPE_NOTE_DESCRIPTION BSE_CXX_DECLARED_RECORD_TYPE (Bse, NoteDescription)
32 class NoteSequence;
33 typedef Sfi::RecordHandle<NoteSequence> NoteSequenceHandle;
34 #define BSE_TYPE_NOTE_SEQUENCE BSE_CXX_DECLARED_RECORD_TYPE (Bse, NoteSequence)
35 class Icon;
36 typedef Sfi::RecordHandle<Icon> IconHandle;
37 #define BSE_TYPE_ICON BSE_CXX_DECLARED_RECORD_TYPE (Bse, Icon)
38 class Category;
39 typedef Sfi::RecordHandle<Category> CategoryHandle;
40 #define BSE_TYPE_CATEGORY BSE_CXX_DECLARED_RECORD_TYPE (Bse, Category)
41 class Dot;
42 typedef Sfi::RecordHandle<Dot> DotHandle;
43 #define BSE_TYPE_DOT BSE_CXX_DECLARED_RECORD_TYPE (Bse, Dot)
44 class TrackPart;
45 typedef Sfi::RecordHandle<TrackPart> TrackPartHandle;
46 #define BSE_TYPE_TRACK_PART BSE_CXX_DECLARED_RECORD_TYPE (Bse, TrackPart)
47 class SampleFileInfo;
48 typedef Sfi::RecordHandle<SampleFileInfo> SampleFileInfoHandle;
49 #define BSE_TYPE_SAMPLE_FILE_INFO BSE_CXX_DECLARED_RECORD_TYPE (Bse, SampleFileInfo)
50 class GConfig;
51 typedef Sfi::RecordHandle<GConfig> GConfigHandle;
52 #define BSE_TYPE_GCONFIG BSE_CXX_DECLARED_RECORD_TYPE (Bse, GConfig)
53 
54 
55 /* sequence prototypes */
56 class IntSeq;
57 #define BSE_TYPE_INT_SEQ BSE_CXX_DECLARED_SEQUENCE_TYPE (Bse, IntSeq)
58 class TypeSeq;
59 #define BSE_TYPE_TYPE_SEQ BSE_CXX_DECLARED_SEQUENCE_TYPE (Bse, TypeSeq)
60 class StringSeq;
61 #define BSE_TYPE_STRING_SEQ BSE_CXX_DECLARED_SEQUENCE_TYPE (Bse, StringSeq)
62 class FloatSeq;
63 #define BSE_TYPE_FLOAT_SEQ BSE_CXX_DECLARED_SEQUENCE_TYPE (Bse, FloatSeq)
64 class NoteSeq;
65 #define BSE_TYPE_NOTE_SEQ BSE_CXX_DECLARED_SEQUENCE_TYPE (Bse, NoteSeq)
66 class ItemSeq;
67 #define BSE_TYPE_ITEM_SEQ BSE_CXX_DECLARED_SEQUENCE_TYPE (Bse, ItemSeq)
68 class PixelSeq;
69 #define BSE_TYPE_PIXEL_SEQ BSE_CXX_DECLARED_SEQUENCE_TYPE (Bse, PixelSeq)
70 class CategorySeq;
71 #define BSE_TYPE_CATEGORY_SEQ BSE_CXX_DECLARED_SEQUENCE_TYPE (Bse, CategorySeq)
72 class DotSeq;
73 #define BSE_TYPE_DOT_SEQ BSE_CXX_DECLARED_SEQUENCE_TYPE (Bse, DotSeq)
74 class TrackPartSeq;
75 #define BSE_TYPE_TRACK_PART_SEQ BSE_CXX_DECLARED_SEQUENCE_TYPE (Bse, TrackPartSeq)
76 
77 
78 /* class prototypes */
79 
80 
81 /* enum definitions */
82 #ifndef SFIDL_SKIPDEF__MusicalTuningType
83 enum MusicalTuningType {
84  MUSICAL_TUNING_12_TET = 1,
85  MUSICAL_TUNING_7_TET = 2,
86  MUSICAL_TUNING_5_TET = 3,
87  MUSICAL_TUNING_DIATONIC_SCALE = 4,
88  MUSICAL_TUNING_INDIAN_SCALE = 5,
89  MUSICAL_TUNING_PYTHAGOREAN_TUNING = 6,
90  MUSICAL_TUNING_PENTATONIC_5_LIMIT = 7,
91  MUSICAL_TUNING_PENTATONIC_BLUES = 8,
92  MUSICAL_TUNING_PENTATONIC_GOGO = 9,
93  MUSICAL_TUNING_QUARTER_COMMA_MEANTONE = 10,
94  MUSICAL_TUNING_SILBERMANN_SORGE = 11,
95  MUSICAL_TUNING_WERCKMEISTER_3 = 12,
96  MUSICAL_TUNING_WERCKMEISTER_4 = 13,
97  MUSICAL_TUNING_WERCKMEISTER_5 = 14,
98  MUSICAL_TUNING_WERCKMEISTER_6 = 15,
99  MUSICAL_TUNING_KIRNBERGER_3 = 16,
100  MUSICAL_TUNING_YOUNG = 17,
101 };
102 #endif // SFIDL_SKIPDEF__MusicalTuningType
103 #ifndef SFIDL_SKIPDEF__MidiControlType
104 enum MidiControlType {
105  MIDI_CONTROL_NONE = 0,
106  MIDI_CONTROL_CONTINUOUS_0 = 64,
107  MIDI_CONTROL_CONTINUOUS_1 = 65,
108  MIDI_CONTROL_CONTINUOUS_2 = 66,
109  MIDI_CONTROL_CONTINUOUS_3 = 67,
110  MIDI_CONTROL_CONTINUOUS_4 = 68,
111  MIDI_CONTROL_CONTINUOUS_5 = 69,
112  MIDI_CONTROL_CONTINUOUS_6 = 70,
113  MIDI_CONTROL_CONTINUOUS_7 = 71,
114  MIDI_CONTROL_CONTINUOUS_8 = 72,
115  MIDI_CONTROL_CONTINUOUS_9 = 73,
116  MIDI_CONTROL_CONTINUOUS_10 = 74,
117  MIDI_CONTROL_CONTINUOUS_11 = 75,
118  MIDI_CONTROL_CONTINUOUS_12 = 76,
119  MIDI_CONTROL_CONTINUOUS_13 = 77,
120  MIDI_CONTROL_CONTINUOUS_14 = 78,
121  MIDI_CONTROL_CONTINUOUS_15 = 79,
122  MIDI_CONTROL_CONTINUOUS_16 = 80,
123  MIDI_CONTROL_CONTINUOUS_17 = 81,
124  MIDI_CONTROL_CONTINUOUS_18 = 82,
125  MIDI_CONTROL_CONTINUOUS_19 = 83,
126  MIDI_CONTROL_CONTINUOUS_20 = 84,
127  MIDI_CONTROL_CONTINUOUS_21 = 85,
128  MIDI_CONTROL_CONTINUOUS_22 = 86,
129  MIDI_CONTROL_CONTINUOUS_23 = 87,
130  MIDI_CONTROL_CONTINUOUS_24 = 88,
131  MIDI_CONTROL_CONTINUOUS_25 = 89,
132  MIDI_CONTROL_CONTINUOUS_26 = 90,
133  MIDI_CONTROL_CONTINUOUS_27 = 91,
134  MIDI_CONTROL_CONTINUOUS_28 = 92,
135  MIDI_CONTROL_CONTINUOUS_29 = 93,
136  MIDI_CONTROL_CONTINUOUS_30 = 94,
137  MIDI_CONTROL_CONTINUOUS_31 = 95,
138  MIDI_CONTROL_0 = 128,
139  MIDI_CONTROL_1 = 129,
140  MIDI_CONTROL_2 = 130,
141  MIDI_CONTROL_3 = 131,
142  MIDI_CONTROL_4 = 132,
143  MIDI_CONTROL_5 = 133,
144  MIDI_CONTROL_6 = 134,
145  MIDI_CONTROL_7 = 135,
146  MIDI_CONTROL_8 = 136,
147  MIDI_CONTROL_9 = 137,
148  MIDI_CONTROL_10 = 138,
149  MIDI_CONTROL_11 = 139,
150  MIDI_CONTROL_12 = 140,
151  MIDI_CONTROL_13 = 141,
152  MIDI_CONTROL_14 = 142,
153  MIDI_CONTROL_15 = 143,
154  MIDI_CONTROL_16 = 144,
155  MIDI_CONTROL_17 = 145,
156  MIDI_CONTROL_18 = 146,
157  MIDI_CONTROL_19 = 147,
158  MIDI_CONTROL_20 = 148,
159  MIDI_CONTROL_21 = 149,
160  MIDI_CONTROL_22 = 150,
161  MIDI_CONTROL_23 = 151,
162  MIDI_CONTROL_24 = 152,
163  MIDI_CONTROL_25 = 153,
164  MIDI_CONTROL_26 = 154,
165  MIDI_CONTROL_27 = 155,
166  MIDI_CONTROL_28 = 156,
167  MIDI_CONTROL_29 = 157,
168  MIDI_CONTROL_30 = 158,
169  MIDI_CONTROL_31 = 159,
170  MIDI_CONTROL_32 = 160,
171  MIDI_CONTROL_33 = 161,
172  MIDI_CONTROL_34 = 162,
173  MIDI_CONTROL_35 = 163,
174  MIDI_CONTROL_36 = 164,
175  MIDI_CONTROL_37 = 165,
176  MIDI_CONTROL_38 = 166,
177  MIDI_CONTROL_39 = 167,
178  MIDI_CONTROL_40 = 168,
179  MIDI_CONTROL_41 = 169,
180  MIDI_CONTROL_42 = 170,
181  MIDI_CONTROL_43 = 171,
182  MIDI_CONTROL_44 = 172,
183  MIDI_CONTROL_45 = 173,
184  MIDI_CONTROL_46 = 174,
185  MIDI_CONTROL_47 = 175,
186  MIDI_CONTROL_48 = 176,
187  MIDI_CONTROL_49 = 177,
188  MIDI_CONTROL_50 = 178,
189  MIDI_CONTROL_51 = 179,
190  MIDI_CONTROL_52 = 180,
191  MIDI_CONTROL_53 = 181,
192  MIDI_CONTROL_54 = 182,
193  MIDI_CONTROL_55 = 183,
194  MIDI_CONTROL_56 = 184,
195  MIDI_CONTROL_57 = 185,
196  MIDI_CONTROL_58 = 186,
197  MIDI_CONTROL_59 = 187,
198  MIDI_CONTROL_60 = 188,
199  MIDI_CONTROL_61 = 189,
200  MIDI_CONTROL_62 = 190,
201  MIDI_CONTROL_63 = 191,
202  MIDI_CONTROL_64 = 192,
203  MIDI_CONTROL_65 = 193,
204  MIDI_CONTROL_66 = 194,
205  MIDI_CONTROL_67 = 195,
206  MIDI_CONTROL_68 = 196,
207  MIDI_CONTROL_69 = 197,
208  MIDI_CONTROL_70 = 198,
209  MIDI_CONTROL_71 = 199,
210  MIDI_CONTROL_72 = 200,
211  MIDI_CONTROL_73 = 201,
212  MIDI_CONTROL_74 = 202,
213  MIDI_CONTROL_75 = 203,
214  MIDI_CONTROL_76 = 204,
215  MIDI_CONTROL_77 = 205,
216  MIDI_CONTROL_78 = 206,
217  MIDI_CONTROL_79 = 207,
218  MIDI_CONTROL_80 = 208,
219  MIDI_CONTROL_81 = 209,
220  MIDI_CONTROL_82 = 210,
221  MIDI_CONTROL_83 = 211,
222  MIDI_CONTROL_84 = 212,
223  MIDI_CONTROL_85 = 213,
224  MIDI_CONTROL_86 = 214,
225  MIDI_CONTROL_87 = 215,
226  MIDI_CONTROL_88 = 216,
227  MIDI_CONTROL_89 = 217,
228  MIDI_CONTROL_90 = 218,
229  MIDI_CONTROL_91 = 219,
230  MIDI_CONTROL_92 = 220,
231  MIDI_CONTROL_93 = 221,
232  MIDI_CONTROL_94 = 222,
233  MIDI_CONTROL_95 = 223,
234  MIDI_CONTROL_96 = 224,
235  MIDI_CONTROL_97 = 225,
236  MIDI_CONTROL_98 = 226,
237  MIDI_CONTROL_99 = 227,
238  MIDI_CONTROL_100 = 228,
239  MIDI_CONTROL_101 = 229,
240  MIDI_CONTROL_102 = 230,
241  MIDI_CONTROL_103 = 231,
242  MIDI_CONTROL_104 = 232,
243  MIDI_CONTROL_105 = 233,
244  MIDI_CONTROL_106 = 234,
245  MIDI_CONTROL_107 = 235,
246  MIDI_CONTROL_108 = 236,
247  MIDI_CONTROL_109 = 237,
248  MIDI_CONTROL_110 = 238,
249  MIDI_CONTROL_111 = 239,
250  MIDI_CONTROL_112 = 240,
251  MIDI_CONTROL_113 = 241,
252  MIDI_CONTROL_114 = 242,
253  MIDI_CONTROL_115 = 243,
254  MIDI_CONTROL_116 = 244,
255  MIDI_CONTROL_117 = 245,
256  MIDI_CONTROL_118 = 246,
257  MIDI_CONTROL_119 = 247,
258  MIDI_CONTROL_120 = 248,
259  MIDI_CONTROL_121 = 249,
260  MIDI_CONTROL_122 = 250,
261  MIDI_CONTROL_123 = 251,
262  MIDI_CONTROL_124 = 252,
263  MIDI_CONTROL_125 = 253,
264  MIDI_CONTROL_126 = 254,
265  MIDI_CONTROL_127 = 255,
266 };
267 #endif // SFIDL_SKIPDEF__MidiControlType
268 #ifndef SFIDL_SKIPDEF__MidiChannelEventType
269 enum MidiChannelEventType {
270  MIDI_EVENT_NONE = 0,
271  MIDI_EVENT_NOTE_OFF = 1,
272  MIDI_EVENT_NOTE_ON = 2,
273  MIDI_EVENT_KEY_PRESSURE = 3,
274  MIDI_EVENT_CONTROL_CHANGE = 4,
275  MIDI_EVENT_PROGRAM_CHANGE = 5,
276  MIDI_EVENT_CHANNEL_PRESSURE = 6,
277  MIDI_EVENT_PITCH_BEND = 7,
278  MIDI_EVENT_SYS_EX = 8,
279  MIDI_EVENT_SONG_POINTER = 9,
280  MIDI_EVENT_SONG_SELECT = 10,
281  MIDI_EVENT_TUNE = 11,
282  MIDI_EVENT_TIMING_CLOCK = 12,
283  MIDI_EVENT_SONG_START = 13,
284  MIDI_EVENT_SONG_CONTINUE = 14,
285  MIDI_EVENT_SONG_STOP = 15,
286  MIDI_EVENT_ACTIVE_SENSING = 16,
287  MIDI_EVENT_SYSTEM_RESET = 17,
288 };
289 #endif // SFIDL_SKIPDEF__MidiChannelEventType
290 
291 
292 /* sequence definitions */
293 class IntSeq : public Sfi::Sequence< Sfi::Int > {
294 public:
295  IntSeq (unsigned int n = 0) : Sfi::Sequence< Sfi::Int > (n) {}
296  static inline ::Bse::IntSeq from_seq (SfiSeq *seq);
297  static inline SfiSeq *to_seq (const ::Bse::IntSeq & seq);
298  static inline ::Bse::IntSeq value_get_boxed (const GValue *value);
299  static inline void value_set_boxed (GValue *value, const ::Bse::IntSeq & self);
300  static inline const char* options () { return ""; }
301  static inline const char* blurb () { return ""; }
302  static inline const char* authors () { return ""; }
303  static inline const char* license () { return ""; }
304  static inline const char* type_name () { return "BseIntSeq"; }
305  static inline GParamSpec* get_element ();
306 };
307 
308 class TypeSeq : public Sfi::Sequence< Sfi::SfiString > {
309 public:
310  TypeSeq (unsigned int n = 0) : Sfi::Sequence< Sfi::SfiString > (n) {}
311  static inline ::Bse::TypeSeq from_seq (SfiSeq *seq);
312  static inline SfiSeq *to_seq (const ::Bse::TypeSeq & seq);
313  static inline ::Bse::TypeSeq value_get_boxed (const GValue *value);
314  static inline void value_set_boxed (GValue *value, const ::Bse::TypeSeq & self);
315  static inline const char* options () { return ""; }
316  static inline const char* blurb () { return ""; }
317  static inline const char* authors () { return ""; }
318  static inline const char* license () { return ""; }
319  static inline const char* type_name () { return "BseTypeSeq"; }
320  static inline GParamSpec* get_element ();
321 };
322 
323 class StringSeq : public Sfi::Sequence< Sfi::SfiString > {
324 public:
325  StringSeq (unsigned int n = 0) : Sfi::Sequence< Sfi::SfiString > (n) {}
326  static inline ::Bse::StringSeq from_seq (SfiSeq *seq);
327  static inline SfiSeq *to_seq (const ::Bse::StringSeq & seq);
328  static inline ::Bse::StringSeq value_get_boxed (const GValue *value);
329  static inline void value_set_boxed (GValue *value, const ::Bse::StringSeq & self);
330  static inline const char* options () { return ""; }
331  static inline const char* blurb () { return ""; }
332  static inline const char* authors () { return ""; }
333  static inline const char* license () { return ""; }
334  static inline const char* type_name () { return "BseStringSeq"; }
335  static inline GParamSpec* get_element ();
336 };
337 
338 class FloatSeq : public Sfi::Sequence< Sfi::Real > {
339 public:
340  FloatSeq (unsigned int n = 0) : Sfi::Sequence< Sfi::Real > (n) {}
341  static inline ::Bse::FloatSeq from_seq (SfiSeq *seq);
342  static inline SfiSeq *to_seq (const ::Bse::FloatSeq & seq);
343  static inline ::Bse::FloatSeq value_get_boxed (const GValue *value);
344  static inline void value_set_boxed (GValue *value, const ::Bse::FloatSeq & self);
345  static inline const char* options () { return ""; }
346  static inline const char* blurb () { return ""; }
347  static inline const char* authors () { return ""; }
348  static inline const char* license () { return ""; }
349  static inline const char* type_name () { return "BseFloatSeq"; }
350  static inline GParamSpec* get_element ();
351 };
352 
353 class NoteSeq : public Sfi::Sequence< Sfi::Int > {
354 public:
355  NoteSeq (unsigned int n = 0) : Sfi::Sequence< Sfi::Int > (n) {}
356  static inline ::Bse::NoteSeq from_seq (SfiSeq *seq);
357  static inline SfiSeq *to_seq (const ::Bse::NoteSeq & seq);
358  static inline ::Bse::NoteSeq value_get_boxed (const GValue *value);
359  static inline void value_set_boxed (GValue *value, const ::Bse::NoteSeq & self);
360  static inline const char* options () { return ""; }
361  static inline const char* blurb () { return ""; }
362  static inline const char* authors () { return ""; }
363  static inline const char* license () { return ""; }
364  static inline const char* type_name () { return "BseNoteSeq"; }
365  static inline GParamSpec* get_element ();
366 };
367 
368 class ItemSeq : public Sfi::Sequence< BseItem* > {
369 public:
370  ItemSeq (unsigned int n = 0) : Sfi::Sequence< BseItem* > (n) {}
371  static inline ::Bse::ItemSeq from_seq (SfiSeq *seq);
372  static inline SfiSeq *to_seq (const ::Bse::ItemSeq & seq);
373  static inline ::Bse::ItemSeq value_get_boxed (const GValue *value);
374  static inline void value_set_boxed (GValue *value, const ::Bse::ItemSeq & self);
375  static inline const char* options () { return ""; }
376  static inline const char* blurb () { return "A list of BSE items or derived types."; }
377  static inline const char* authors () { return ""; }
378  static inline const char* license () { return ""; }
379  static inline const char* type_name () { return "BseItemSeq"; }
380  static inline GParamSpec* get_element ();
381 };
382 
383 class PixelSeq : public Sfi::Sequence< Sfi::Int > {
384 public:
385  PixelSeq (unsigned int n = 0) : Sfi::Sequence< Sfi::Int > (n) {}
386  static inline ::Bse::PixelSeq from_seq (SfiSeq *seq);
387  static inline SfiSeq *to_seq (const ::Bse::PixelSeq & seq);
388  static inline ::Bse::PixelSeq value_get_boxed (const GValue *value);
389  static inline void value_set_boxed (GValue *value, const ::Bse::PixelSeq & self);
390  static inline const char* options () { return ""; }
391  static inline const char* blurb () { return ""; }
392  static inline const char* authors () { return ""; }
393  static inline const char* license () { return ""; }
394  static inline const char* type_name () { return "BsePixelSeq"; }
395  static inline GParamSpec* get_element ();
396 };
397 
398 class CategorySeq : public Sfi::Sequence< ::Bse::CategoryHandle > {
399 public:
400  CategorySeq (unsigned int n = 0) : Sfi::Sequence< ::Bse::CategoryHandle > (n) {}
401  static inline ::Bse::CategorySeq from_seq (SfiSeq *seq);
402  static inline SfiSeq *to_seq (const ::Bse::CategorySeq & seq);
403  static inline ::Bse::CategorySeq value_get_boxed (const GValue *value);
404  static inline void value_set_boxed (GValue *value, const ::Bse::CategorySeq & self);
405  static inline const char* options () { return ""; }
406  static inline const char* blurb () { return ""; }
407  static inline const char* authors () { return ""; }
408  static inline const char* license () { return ""; }
409  static inline const char* type_name () { return "BseCategorySeq"; }
410  static inline GParamSpec* get_element ();
411 };
412 
413 class DotSeq : public Sfi::Sequence< ::Bse::DotHandle > {
414 public:
415  DotSeq (unsigned int n = 0) : Sfi::Sequence< ::Bse::DotHandle > (n) {}
416  static inline ::Bse::DotSeq from_seq (SfiSeq *seq);
417  static inline SfiSeq *to_seq (const ::Bse::DotSeq & seq);
418  static inline ::Bse::DotSeq value_get_boxed (const GValue *value);
419  static inline void value_set_boxed (GValue *value, const ::Bse::DotSeq & self);
420  static inline const char* options () { return ""; }
421  static inline const char* blurb () { return ""; }
422  static inline const char* authors () { return ""; }
423  static inline const char* license () { return ""; }
424  static inline const char* type_name () { return "BseDotSeq"; }
425  static inline GParamSpec* get_element ();
426 };
427 
428 class TrackPartSeq : public Sfi::Sequence< ::Bse::TrackPartHandle > {
429 public:
430  TrackPartSeq (unsigned int n = 0) : Sfi::Sequence< ::Bse::TrackPartHandle > (n) {}
431  static inline ::Bse::TrackPartSeq from_seq (SfiSeq *seq);
432  static inline SfiSeq *to_seq (const ::Bse::TrackPartSeq & seq);
433  static inline ::Bse::TrackPartSeq value_get_boxed (const GValue *value);
434  static inline void value_set_boxed (GValue *value, const ::Bse::TrackPartSeq & self);
435  static inline const char* options () { return ""; }
436  static inline const char* blurb () { return ""; }
437  static inline const char* authors () { return ""; }
438  static inline const char* license () { return ""; }
439  static inline const char* type_name () { return "BseTrackPartSeq"; }
440  static inline GParamSpec* get_element ();
441 };
442 
443 
444 
445 /* record definitions */
447 public:
448  ::Bse::MidiChannelEventType event_type;
449  Sfi::Int channel;
450  Sfi::Num tick_stamp;
451  Sfi::Real frequency;
452  Sfi::Real velocity;
453  Sfi::Int control;
454  Sfi::Real value;
455  Sfi::Int program;
456  Sfi::Real intensity;
457  Sfi::Real pitch_bend;
458  Sfi::Int song_pointer;
459  Sfi::Int song_number;
460  static inline ::Bse::MidiChannelEventHandle from_rec (SfiRec *rec);
461  static inline SfiRec *to_rec (const ::Bse::MidiChannelEventHandle & ptr);
462  static inline ::Bse::MidiChannelEventHandle value_get_boxed (const GValue *value);
463  static inline void value_set_boxed (GValue *value, const ::Bse::MidiChannelEventHandle & self);
464  static inline const char* options () { return ""; }
465  static inline const char* blurb () { return ""; }
466  static inline const char* authors () { return ""; }
467  static inline const char* license () { return ""; }
468  static inline const char* type_name () { return "BseMidiChannelEvent"; }
469  static inline SfiRecFields get_fields ();
470 };
471 
473 public:
474  Sfi::SfiString label;
475  Sfi::SfiString tooltip;
476  ::Bse::ItemSeq items;
477  ::Bse::TypeSeq partitions;
478  static inline ::Bse::PropertyCandidatesHandle from_rec (SfiRec *rec);
479  static inline SfiRec *to_rec (const ::Bse::PropertyCandidatesHandle & ptr);
480  static inline ::Bse::PropertyCandidatesHandle value_get_boxed (const GValue *value);
481  static inline void value_set_boxed (GValue *value, const ::Bse::PropertyCandidatesHandle & self);
482  static inline const char* options () { return ""; }
483  static inline const char* blurb () { return "A structure describing tentative property values."; }
484  static inline const char* authors () { return ""; }
485  static inline const char* license () { return ""; }
486  static inline const char* type_name () { return "BsePropertyCandidates"; }
487  static inline SfiRecFields get_fields ();
488 };
489 
491 public:
492  ::Bse::MusicalTuningType musical_tuning;
493  Sfi::Int note;
494  Sfi::Int octave;
495  Sfi::Real freq;
496  Sfi::Int fine_tune;
497  Sfi::Int semitone;
498  bool upshift;
499  Sfi::Int letter;
500  Sfi::SfiString name;
501  Sfi::Int max_fine_tune;
502  Sfi::Int kammer_note;
503  static inline ::Bse::NoteDescriptionHandle from_rec (SfiRec *rec);
504  static inline SfiRec *to_rec (const ::Bse::NoteDescriptionHandle & ptr);
505  static inline ::Bse::NoteDescriptionHandle value_get_boxed (const GValue *value);
506  static inline void value_set_boxed (GValue *value, const ::Bse::NoteDescriptionHandle & self);
507  static inline const char* options () { return ""; }
508  static inline const char* blurb () { return "A note description provides all necessary details about a specific note. Various procedures exist to retrieve a note description; given different key values. The max_fine_tune and kammer_note fields are constants, which are provided for compatibility reasons and will vanish in future APIs."; }
509  static inline const char* authors () { return ""; }
510  static inline const char* license () { return ""; }
511  static inline const char* type_name () { return "BseNoteDescription"; }
512  static inline SfiRecFields get_fields ();
513 };
514 
516 public:
517  Sfi::Int offset;
518  ::Bse::NoteSeq notes;
519  static inline ::Bse::NoteSequenceHandle from_rec (SfiRec *rec);
520  static inline SfiRec *to_rec (const ::Bse::NoteSequenceHandle & ptr);
521  static inline ::Bse::NoteSequenceHandle value_get_boxed (const GValue *value);
522  static inline void value_set_boxed (GValue *value, const ::Bse::NoteSequenceHandle & self);
523  static inline const char* options () { return ""; }
524  static inline const char* blurb () { return ""; }
525  static inline const char* authors () { return ""; }
526  static inline const char* license () { return ""; }
527  static inline const char* type_name () { return "BseNoteSequence"; }
528  static inline SfiRecFields get_fields ();
529 };
530 
531 class Icon : public ::Sfi::GNewable {
532 public:
533  Sfi::Int width;
534  Sfi::Int height;
535  ::Bse::PixelSeq pixel_seq;
536  static inline ::Bse::IconHandle from_rec (SfiRec *rec);
537  static inline SfiRec *to_rec (const ::Bse::IconHandle & ptr);
538  static inline ::Bse::IconHandle value_get_boxed (const GValue *value);
539  static inline void value_set_boxed (GValue *value, const ::Bse::IconHandle & self);
540  static inline const char* options () { return ""; }
541  static inline const char* blurb () { return "BSE icon representation."; }
542  static inline const char* authors () { return ""; }
543  static inline const char* license () { return ""; }
544  static inline const char* type_name () { return "BseIcon"; }
545  static inline SfiRecFields get_fields ();
546 };
547 
548 class Category : public ::Sfi::GNewable {
549 public:
550  Sfi::Int category_id;
551  Sfi::SfiString category;
552  Sfi::Int mindex;
553  Sfi::Int lindex;
554  Sfi::SfiString type;
555  ::Bse::IconHandle icon;
556  static inline ::Bse::CategoryHandle from_rec (SfiRec *rec);
557  static inline SfiRec *to_rec (const ::Bse::CategoryHandle & ptr);
558  static inline ::Bse::CategoryHandle value_get_boxed (const GValue *value);
559  static inline void value_set_boxed (GValue *value, const ::Bse::CategoryHandle & self);
560  static inline const char* options () { return ""; }
561  static inline const char* blurb () { return ""; }
562  static inline const char* authors () { return ""; }
563  static inline const char* license () { return ""; }
564  static inline const char* type_name () { return "BseCategory"; }
565  static inline SfiRecFields get_fields ();
566 };
567 
568 class Dot : public ::Sfi::GNewable {
569 public:
570  Sfi::Real x;
571  Sfi::Real y;
572  static inline ::Bse::DotHandle from_rec (SfiRec *rec);
573  static inline SfiRec *to_rec (const ::Bse::DotHandle & ptr);
574  static inline ::Bse::DotHandle value_get_boxed (const GValue *value);
575  static inline void value_set_boxed (GValue *value, const ::Bse::DotHandle & self);
576  static inline const char* options () { return ""; }
577  static inline const char* blurb () { return ""; }
578  static inline const char* authors () { return ""; }
579  static inline const char* license () { return ""; }
580  static inline const char* type_name () { return "BseDot"; }
581  static inline SfiRecFields get_fields ();
582 };
583 
584 class TrackPart : public ::Sfi::GNewable {
585 public:
586  Sfi::Int tick;
587  BsePart* part;
588  Sfi::Int duration;
589  static inline ::Bse::TrackPartHandle from_rec (SfiRec *rec);
590  static inline SfiRec *to_rec (const ::Bse::TrackPartHandle & ptr);
591  static inline ::Bse::TrackPartHandle value_get_boxed (const GValue *value);
592  static inline void value_set_boxed (GValue *value, const ::Bse::TrackPartHandle & self);
593  static inline const char* options () { return ""; }
594  static inline const char* blurb () { return ""; }
595  static inline const char* authors () { return ""; }
596  static inline const char* license () { return ""; }
597  static inline const char* type_name () { return "BseTrackPart"; }
598  static inline SfiRecFields get_fields ();
599 };
600 
602 public:
603  Sfi::SfiString file;
604  Sfi::Int size;
605  Sfi::Num mtime;
606  Sfi::SfiString loader;
607  ::Bse::StringSeq waves;
608  Sfi::Int error;
609  static inline ::Bse::SampleFileInfoHandle from_rec (SfiRec *rec);
610  static inline SfiRec *to_rec (const ::Bse::SampleFileInfoHandle & ptr);
611  static inline ::Bse::SampleFileInfoHandle value_get_boxed (const GValue *value);
612  static inline void value_set_boxed (GValue *value, const ::Bse::SampleFileInfoHandle & self);
613  static inline const char* options () { return ""; }
614  static inline const char* blurb () { return ""; }
615  static inline const char* authors () { return ""; }
616  static inline const char* license () { return ""; }
617  static inline const char* type_name () { return "BseSampleFileInfo"; }
618  static inline SfiRecFields get_fields ();
619 };
620 
621 class GConfig : public ::Sfi::GNewable {
622 public:
623  Sfi::Int synth_latency;
624  Sfi::Int synth_mixing_freq;
625  Sfi::Int synth_control_freq;
626  bool invert_sustain;
627  Sfi::SfiString author_default;
628  Sfi::SfiString license_default;
629  Sfi::SfiString sample_path;
630  Sfi::SfiString effect_path;
631  Sfi::SfiString instrument_path;
632  Sfi::SfiString script_path;
633  Sfi::SfiString plugin_path;
634  Sfi::SfiString ladspa_path;
635  static inline ::Bse::GConfigHandle from_rec (SfiRec *rec);
636  static inline SfiRec *to_rec (const ::Bse::GConfigHandle & ptr);
637  static inline ::Bse::GConfigHandle value_get_boxed (const GValue *value);
638  static inline void value_set_boxed (GValue *value, const ::Bse::GConfigHandle & self);
639  static inline const char* options () { return ""; }
640  static inline const char* blurb () { return ""; }
641  static inline const char* authors () { return ""; }
642  static inline const char* license () { return ""; }
643  static inline const char* type_name () { return "BseGConfig"; }
644  static inline SfiRecFields get_fields ();
645 };
646 
647 
648 
649 /* enum declarations */
650 BSE_CXX_DECLARE_ENUM (MusicalTuningType, "BseMusicalTuningType", 17,
651  *v++ = ::Bse::EnumValue (MUSICAL_TUNING_12_TET, "BSE_MUSICAL_TUNING_12_TET", _("12 Tone Equal Temperament") );
652  *v++ = ::Bse::EnumValue (MUSICAL_TUNING_7_TET, "BSE_MUSICAL_TUNING_7_TET", _("7 Tone Equal Temperament") );
653  *v++ = ::Bse::EnumValue (MUSICAL_TUNING_5_TET, "BSE_MUSICAL_TUNING_5_TET", _("5 Tone Equal Temperament") );
654  *v++ = ::Bse::EnumValue (MUSICAL_TUNING_DIATONIC_SCALE, "BSE_MUSICAL_TUNING_DIATONIC_SCALE", _("Diatonic Scale") );
655  *v++ = ::Bse::EnumValue (MUSICAL_TUNING_INDIAN_SCALE, "BSE_MUSICAL_TUNING_INDIAN_SCALE", _("Indian Scale") );
656  *v++ = ::Bse::EnumValue (MUSICAL_TUNING_PYTHAGOREAN_TUNING, "BSE_MUSICAL_TUNING_PYTHAGOREAN_TUNING", _("Pythagorean Tuning") );
657  *v++ = ::Bse::EnumValue (MUSICAL_TUNING_PENTATONIC_5_LIMIT, "BSE_MUSICAL_TUNING_PENTATONIC_5_LIMIT", _("Pentatonic 5-limit") );
658  *v++ = ::Bse::EnumValue (MUSICAL_TUNING_PENTATONIC_BLUES, "BSE_MUSICAL_TUNING_PENTATONIC_BLUES", _("Pentatonic Blues") );
659  *v++ = ::Bse::EnumValue (MUSICAL_TUNING_PENTATONIC_GOGO, "BSE_MUSICAL_TUNING_PENTATONIC_GOGO", _("Pentatonic Gogo") );
660  *v++ = ::Bse::EnumValue (MUSICAL_TUNING_QUARTER_COMMA_MEANTONE, "BSE_MUSICAL_TUNING_QUARTER_COMMA_MEANTONE", _("Quarter-Comma Meantone") );
661  *v++ = ::Bse::EnumValue (MUSICAL_TUNING_SILBERMANN_SORGE, "BSE_MUSICAL_TUNING_SILBERMANN_SORGE", _("Silbermann-Sorge Temperament") );
662  *v++ = ::Bse::EnumValue (MUSICAL_TUNING_WERCKMEISTER_3, "BSE_MUSICAL_TUNING_WERCKMEISTER_3", _("Werckmeister III") );
663  *v++ = ::Bse::EnumValue (MUSICAL_TUNING_WERCKMEISTER_4, "BSE_MUSICAL_TUNING_WERCKMEISTER_4", _("Werckmeister IV") );
664  *v++ = ::Bse::EnumValue (MUSICAL_TUNING_WERCKMEISTER_5, "BSE_MUSICAL_TUNING_WERCKMEISTER_5", _("Werckmeister V") );
665  *v++ = ::Bse::EnumValue (MUSICAL_TUNING_WERCKMEISTER_6, "BSE_MUSICAL_TUNING_WERCKMEISTER_6", _("Werckmeister VI") );
666  *v++ = ::Bse::EnumValue (MUSICAL_TUNING_KIRNBERGER_3, "BSE_MUSICAL_TUNING_KIRNBERGER_3", _("Kirnberger III") );
667  *v++ = ::Bse::EnumValue (MUSICAL_TUNING_YOUNG, "BSE_MUSICAL_TUNING_YOUNG", _("Young Temperament") );
668 );
669 BSE_CXX_DECLARE_ENUM (MidiControlType, "BseMidiControlType", 161,
670  *v++ = ::Bse::EnumValue (MIDI_CONTROL_NONE, "BSE_MIDI_CONTROL_NONE", _("None") );
671  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_0, "BSE_MIDI_CONTROL_CONTINUOUS_0", _("Bank Select") );
672  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_1, "BSE_MIDI_CONTROL_CONTINUOUS_1", _("Modulation Depth") );
673  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_2, "BSE_MIDI_CONTROL_CONTINUOUS_2", _("Breath Control") );
674  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_3, "BSE_MIDI_CONTROL_CONTINUOUS_3", _("Continuous 3") );
675  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_4, "BSE_MIDI_CONTROL_CONTINUOUS_4", _("Foot Controller") );
676  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_5, "BSE_MIDI_CONTROL_CONTINUOUS_5", _("Portamento Time") );
677  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_6, "BSE_MIDI_CONTROL_CONTINUOUS_6", _("Data Entry") );
678  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_7, "BSE_MIDI_CONTROL_CONTINUOUS_7", _("Volume") );
679  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_8, "BSE_MIDI_CONTROL_CONTINUOUS_8", _("Balance") );
680  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_9, "BSE_MIDI_CONTROL_CONTINUOUS_9", _("Continuous 9") );
681  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_10, "BSE_MIDI_CONTROL_CONTINUOUS_10", _("Panorama") );
682  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_11, "BSE_MIDI_CONTROL_CONTINUOUS_11", _("Expression") );
683  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_12, "BSE_MIDI_CONTROL_CONTINUOUS_12", _("Effect Control 1") );
684  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_13, "BSE_MIDI_CONTROL_CONTINUOUS_13", _("Effect Control 2") );
685  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_14, "BSE_MIDI_CONTROL_CONTINUOUS_14", _("Continuous 14") );
686  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_15, "BSE_MIDI_CONTROL_CONTINUOUS_15", _("Continuous 15") );
687  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_16, "BSE_MIDI_CONTROL_CONTINUOUS_16", _("General Purpose Controller 1") );
688  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_17, "BSE_MIDI_CONTROL_CONTINUOUS_17", _("General Purpose Controller 2") );
689  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_18, "BSE_MIDI_CONTROL_CONTINUOUS_18", _("General Purpose Controller 3") );
690  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_19, "BSE_MIDI_CONTROL_CONTINUOUS_19", _("General Purpose Controller 4") );
691  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_20, "BSE_MIDI_CONTROL_CONTINUOUS_20", _("Continuous 20") );
692  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_21, "BSE_MIDI_CONTROL_CONTINUOUS_21", _("Continuous 21") );
693  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_22, "BSE_MIDI_CONTROL_CONTINUOUS_22", _("Continuous 22") );
694  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_23, "BSE_MIDI_CONTROL_CONTINUOUS_23", _("Continuous 23") );
695  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_24, "BSE_MIDI_CONTROL_CONTINUOUS_24", _("Continuous 24") );
696  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_25, "BSE_MIDI_CONTROL_CONTINUOUS_25", _("Continuous 25") );
697  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_26, "BSE_MIDI_CONTROL_CONTINUOUS_26", _("Continuous 26") );
698  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_27, "BSE_MIDI_CONTROL_CONTINUOUS_27", _("Continuous 27") );
699  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_28, "BSE_MIDI_CONTROL_CONTINUOUS_28", _("Continuous 28") );
700  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_29, "BSE_MIDI_CONTROL_CONTINUOUS_29", _("Continuous 29") );
701  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_30, "BSE_MIDI_CONTROL_CONTINUOUS_30", _("Continuous 30") );
702  *v++ = ::Bse::EnumValue (MIDI_CONTROL_CONTINUOUS_31, "BSE_MIDI_CONTROL_CONTINUOUS_31", _("Continuous 31") );
703  *v++ = ::Bse::EnumValue (MIDI_CONTROL_0, "BSE_MIDI_CONTROL_0", _("Control 0 Bank Select MSB") );
704  *v++ = ::Bse::EnumValue (MIDI_CONTROL_1, "BSE_MIDI_CONTROL_1", _("Control 1 Modulation Depth MSB") );
705  *v++ = ::Bse::EnumValue (MIDI_CONTROL_2, "BSE_MIDI_CONTROL_2", _("Control 2 Breath Control MSB") );
706  *v++ = ::Bse::EnumValue (MIDI_CONTROL_3, "BSE_MIDI_CONTROL_3", _("control-3") );
707  *v++ = ::Bse::EnumValue (MIDI_CONTROL_4, "BSE_MIDI_CONTROL_4", _("Control 4 Foot Controller MSB") );
708  *v++ = ::Bse::EnumValue (MIDI_CONTROL_5, "BSE_MIDI_CONTROL_5", _("Control 5 Portamento Time MSB") );
709  *v++ = ::Bse::EnumValue (MIDI_CONTROL_6, "BSE_MIDI_CONTROL_6", _("Control 6 Data Entry MSB") );
710  *v++ = ::Bse::EnumValue (MIDI_CONTROL_7, "BSE_MIDI_CONTROL_7", _("Control 7 Volume MSB") );
711  *v++ = ::Bse::EnumValue (MIDI_CONTROL_8, "BSE_MIDI_CONTROL_8", _("Control 8 Balance MSB") );
712  *v++ = ::Bse::EnumValue (MIDI_CONTROL_9, "BSE_MIDI_CONTROL_9", _("control-9") );
713  *v++ = ::Bse::EnumValue (MIDI_CONTROL_10, "BSE_MIDI_CONTROL_10", _("Control 10 Panorama MSB") );
714  *v++ = ::Bse::EnumValue (MIDI_CONTROL_11, "BSE_MIDI_CONTROL_11", _("Control 11 Expression MSB") );
715  *v++ = ::Bse::EnumValue (MIDI_CONTROL_12, "BSE_MIDI_CONTROL_12", _("Control 12 Effect Control 1 MSB") );
716  *v++ = ::Bse::EnumValue (MIDI_CONTROL_13, "BSE_MIDI_CONTROL_13", _("Control 13 Effect Control 2 MSB") );
717  *v++ = ::Bse::EnumValue (MIDI_CONTROL_14, "BSE_MIDI_CONTROL_14", _("control-14") );
718  *v++ = ::Bse::EnumValue (MIDI_CONTROL_15, "BSE_MIDI_CONTROL_15", _("control-15") );
719  *v++ = ::Bse::EnumValue (MIDI_CONTROL_16, "BSE_MIDI_CONTROL_16", _("Control 16 General Purpose Controller 1 MSB") );
720  *v++ = ::Bse::EnumValue (MIDI_CONTROL_17, "BSE_MIDI_CONTROL_17", _("Control 17 General Purpose Controller 2 MSB") );
721  *v++ = ::Bse::EnumValue (MIDI_CONTROL_18, "BSE_MIDI_CONTROL_18", _("Control 18 General Purpose Controller 3 MSB") );
722  *v++ = ::Bse::EnumValue (MIDI_CONTROL_19, "BSE_MIDI_CONTROL_19", _("Control 19 General Purpose Controller 4 MSB") );
723  *v++ = ::Bse::EnumValue (MIDI_CONTROL_20, "BSE_MIDI_CONTROL_20", _("control-20") );
724  *v++ = ::Bse::EnumValue (MIDI_CONTROL_21, "BSE_MIDI_CONTROL_21", _("control-21") );
725  *v++ = ::Bse::EnumValue (MIDI_CONTROL_22, "BSE_MIDI_CONTROL_22", _("control-22") );
726  *v++ = ::Bse::EnumValue (MIDI_CONTROL_23, "BSE_MIDI_CONTROL_23", _("control-23") );
727  *v++ = ::Bse::EnumValue (MIDI_CONTROL_24, "BSE_MIDI_CONTROL_24", _("control-24") );
728  *v++ = ::Bse::EnumValue (MIDI_CONTROL_25, "BSE_MIDI_CONTROL_25", _("control-25") );
729  *v++ = ::Bse::EnumValue (MIDI_CONTROL_26, "BSE_MIDI_CONTROL_26", _("control-26") );
730  *v++ = ::Bse::EnumValue (MIDI_CONTROL_27, "BSE_MIDI_CONTROL_27", _("control-27") );
731  *v++ = ::Bse::EnumValue (MIDI_CONTROL_28, "BSE_MIDI_CONTROL_28", _("control-28") );
732  *v++ = ::Bse::EnumValue (MIDI_CONTROL_29, "BSE_MIDI_CONTROL_29", _("control-29") );
733  *v++ = ::Bse::EnumValue (MIDI_CONTROL_30, "BSE_MIDI_CONTROL_30", _("control-30") );
734  *v++ = ::Bse::EnumValue (MIDI_CONTROL_31, "BSE_MIDI_CONTROL_31", _("control-31") );
735  *v++ = ::Bse::EnumValue (MIDI_CONTROL_32, "BSE_MIDI_CONTROL_32", _("Control 32 Bank Select LSB") );
736  *v++ = ::Bse::EnumValue (MIDI_CONTROL_33, "BSE_MIDI_CONTROL_33", _("Control 33 Modulation Depth LSB") );
737  *v++ = ::Bse::EnumValue (MIDI_CONTROL_34, "BSE_MIDI_CONTROL_34", _("Control 34 Breath Control LSB") );
738  *v++ = ::Bse::EnumValue (MIDI_CONTROL_35, "BSE_MIDI_CONTROL_35", _("control-35") );
739  *v++ = ::Bse::EnumValue (MIDI_CONTROL_36, "BSE_MIDI_CONTROL_36", _("Control 36 Foot Controller LSB") );
740  *v++ = ::Bse::EnumValue (MIDI_CONTROL_37, "BSE_MIDI_CONTROL_37", _("Control 37 Portamento Time LSB") );
741  *v++ = ::Bse::EnumValue (MIDI_CONTROL_38, "BSE_MIDI_CONTROL_38", _("Control 38 Data Entry LSB") );
742  *v++ = ::Bse::EnumValue (MIDI_CONTROL_39, "BSE_MIDI_CONTROL_39", _("Control 39 Volume LSB") );
743  *v++ = ::Bse::EnumValue (MIDI_CONTROL_40, "BSE_MIDI_CONTROL_40", _("Control 40 Balance LSB") );
744  *v++ = ::Bse::EnumValue (MIDI_CONTROL_41, "BSE_MIDI_CONTROL_41", _("control-41") );
745  *v++ = ::Bse::EnumValue (MIDI_CONTROL_42, "BSE_MIDI_CONTROL_42", _("Control 42 Panorama LSB") );
746  *v++ = ::Bse::EnumValue (MIDI_CONTROL_43, "BSE_MIDI_CONTROL_43", _("Control 43 Expression LSB") );
747  *v++ = ::Bse::EnumValue (MIDI_CONTROL_44, "BSE_MIDI_CONTROL_44", _("Control 44 Effect Control 1 LSB") );
748  *v++ = ::Bse::EnumValue (MIDI_CONTROL_45, "BSE_MIDI_CONTROL_45", _("Control 45 Effect Control 2 LSB") );
749  *v++ = ::Bse::EnumValue (MIDI_CONTROL_46, "BSE_MIDI_CONTROL_46", _("control-46") );
750  *v++ = ::Bse::EnumValue (MIDI_CONTROL_47, "BSE_MIDI_CONTROL_47", _("control-47") );
751  *v++ = ::Bse::EnumValue (MIDI_CONTROL_48, "BSE_MIDI_CONTROL_48", _("Control 48 General Purpose Controller 1 LSB") );
752  *v++ = ::Bse::EnumValue (MIDI_CONTROL_49, "BSE_MIDI_CONTROL_49", _("Control 49 General Purpose Controller 2 LSB") );
753  *v++ = ::Bse::EnumValue (MIDI_CONTROL_50, "BSE_MIDI_CONTROL_50", _("Control 50 General Purpose Controller 3 LSB") );
754  *v++ = ::Bse::EnumValue (MIDI_CONTROL_51, "BSE_MIDI_CONTROL_51", _("Control 51 General Purpose Controller 4 LSB") );
755  *v++ = ::Bse::EnumValue (MIDI_CONTROL_52, "BSE_MIDI_CONTROL_52", _("control-52") );
756  *v++ = ::Bse::EnumValue (MIDI_CONTROL_53, "BSE_MIDI_CONTROL_53", _("control-53") );
757  *v++ = ::Bse::EnumValue (MIDI_CONTROL_54, "BSE_MIDI_CONTROL_54", _("control-54") );
758  *v++ = ::Bse::EnumValue (MIDI_CONTROL_55, "BSE_MIDI_CONTROL_55", _("control-55") );
759  *v++ = ::Bse::EnumValue (MIDI_CONTROL_56, "BSE_MIDI_CONTROL_56", _("control-56") );
760  *v++ = ::Bse::EnumValue (MIDI_CONTROL_57, "BSE_MIDI_CONTROL_57", _("control-57") );
761  *v++ = ::Bse::EnumValue (MIDI_CONTROL_58, "BSE_MIDI_CONTROL_58", _("control-58") );
762  *v++ = ::Bse::EnumValue (MIDI_CONTROL_59, "BSE_MIDI_CONTROL_59", _("control-59") );
763  *v++ = ::Bse::EnumValue (MIDI_CONTROL_60, "BSE_MIDI_CONTROL_60", _("control-60") );
764  *v++ = ::Bse::EnumValue (MIDI_CONTROL_61, "BSE_MIDI_CONTROL_61", _("control-61") );
765  *v++ = ::Bse::EnumValue (MIDI_CONTROL_62, "BSE_MIDI_CONTROL_62", _("control-62") );
766  *v++ = ::Bse::EnumValue (MIDI_CONTROL_63, "BSE_MIDI_CONTROL_63", _("control-63") );
767  *v++ = ::Bse::EnumValue (MIDI_CONTROL_64, "BSE_MIDI_CONTROL_64", _("Control 64 Damper Pedal Switch (Sustain)") );
768  *v++ = ::Bse::EnumValue (MIDI_CONTROL_65, "BSE_MIDI_CONTROL_65", _("Control 65 Portamento Switch") );
769  *v++ = ::Bse::EnumValue (MIDI_CONTROL_66, "BSE_MIDI_CONTROL_66", _("Control 66 Sustenuto Switch") );
770  *v++ = ::Bse::EnumValue (MIDI_CONTROL_67, "BSE_MIDI_CONTROL_67", _("Control 67 Soft Switch") );
771  *v++ = ::Bse::EnumValue (MIDI_CONTROL_68, "BSE_MIDI_CONTROL_68", _("Control 68 Legato Pedal Switch") );
772  *v++ = ::Bse::EnumValue (MIDI_CONTROL_69, "BSE_MIDI_CONTROL_69", _("Control 69 Hold Pedal Switch") );
773  *v++ = ::Bse::EnumValue (MIDI_CONTROL_70, "BSE_MIDI_CONTROL_70", _("Control 70 Sound Variation") );
774  *v++ = ::Bse::EnumValue (MIDI_CONTROL_71, "BSE_MIDI_CONTROL_71", _("Control 71 Filter Resonance (Timbre)") );
775  *v++ = ::Bse::EnumValue (MIDI_CONTROL_72, "BSE_MIDI_CONTROL_72", _("Control 72 Sound Release Time") );
776  *v++ = ::Bse::EnumValue (MIDI_CONTROL_73, "BSE_MIDI_CONTROL_73", _("Control 73 Sound Attack Time") );
777  *v++ = ::Bse::EnumValue (MIDI_CONTROL_74, "BSE_MIDI_CONTROL_74", _("Control 74 Sound Brightness") );
778  *v++ = ::Bse::EnumValue (MIDI_CONTROL_75, "BSE_MIDI_CONTROL_75", _("Control 75 Sound Decay Time") );
779  *v++ = ::Bse::EnumValue (MIDI_CONTROL_76, "BSE_MIDI_CONTROL_76", _("Control 76 Vibrato Rate") );
780  *v++ = ::Bse::EnumValue (MIDI_CONTROL_77, "BSE_MIDI_CONTROL_77", _("Control 77 Vibrato Depth") );
781  *v++ = ::Bse::EnumValue (MIDI_CONTROL_78, "BSE_MIDI_CONTROL_78", _("Control 78 Vibrato Delay") );
782  *v++ = ::Bse::EnumValue (MIDI_CONTROL_79, "BSE_MIDI_CONTROL_79", _("Control 79 Sound Control 10") );
783  *v++ = ::Bse::EnumValue (MIDI_CONTROL_80, "BSE_MIDI_CONTROL_80", _("Control 80 General Purpose Switch 5") );
784  *v++ = ::Bse::EnumValue (MIDI_CONTROL_81, "BSE_MIDI_CONTROL_81", _("Control 81 General Purpose Switch 6") );
785  *v++ = ::Bse::EnumValue (MIDI_CONTROL_82, "BSE_MIDI_CONTROL_82", _("Control 82 General Purpose Switch 7") );
786  *v++ = ::Bse::EnumValue (MIDI_CONTROL_83, "BSE_MIDI_CONTROL_83", _("Control 83 General Purpose Switch 8") );
787  *v++ = ::Bse::EnumValue (MIDI_CONTROL_84, "BSE_MIDI_CONTROL_84", _("Control 84 Portamento Control (Note)") );
788  *v++ = ::Bse::EnumValue (MIDI_CONTROL_85, "BSE_MIDI_CONTROL_85", _("control-85") );
789  *v++ = ::Bse::EnumValue (MIDI_CONTROL_86, "BSE_MIDI_CONTROL_86", _("control-86") );
790  *v++ = ::Bse::EnumValue (MIDI_CONTROL_87, "BSE_MIDI_CONTROL_87", _("control-87") );
791  *v++ = ::Bse::EnumValue (MIDI_CONTROL_88, "BSE_MIDI_CONTROL_88", _("control-88") );
792  *v++ = ::Bse::EnumValue (MIDI_CONTROL_89, "BSE_MIDI_CONTROL_89", _("control-89") );
793  *v++ = ::Bse::EnumValue (MIDI_CONTROL_90, "BSE_MIDI_CONTROL_90", _("control-90") );
794  *v++ = ::Bse::EnumValue (MIDI_CONTROL_91, "BSE_MIDI_CONTROL_91", _("Control 91 Reverb Depth") );
795  *v++ = ::Bse::EnumValue (MIDI_CONTROL_92, "BSE_MIDI_CONTROL_92", _("Control 92 Tremolo Depth") );
796  *v++ = ::Bse::EnumValue (MIDI_CONTROL_93, "BSE_MIDI_CONTROL_93", _("Control 93 Chorus Depth") );
797  *v++ = ::Bse::EnumValue (MIDI_CONTROL_94, "BSE_MIDI_CONTROL_94", _("Control 93 Detune Depth") );
798  *v++ = ::Bse::EnumValue (MIDI_CONTROL_95, "BSE_MIDI_CONTROL_95", _("Control 95 Phase Depth") );
799  *v++ = ::Bse::EnumValue (MIDI_CONTROL_96, "BSE_MIDI_CONTROL_96", _("Control 96 Data Increment Trigger") );
800  *v++ = ::Bse::EnumValue (MIDI_CONTROL_97, "BSE_MIDI_CONTROL_97", _("Control 97 Data Decrement Trigger") );
801  *v++ = ::Bse::EnumValue (MIDI_CONTROL_98, "BSE_MIDI_CONTROL_98", _("Control 98 Non-Registered Parameter MSB") );
802  *v++ = ::Bse::EnumValue (MIDI_CONTROL_99, "BSE_MIDI_CONTROL_99", _("Control 99 Non-Registered Parameter LSB") );
803  *v++ = ::Bse::EnumValue (MIDI_CONTROL_100, "BSE_MIDI_CONTROL_100", _("Control 100 Registered Parameter MSB") );
804  *v++ = ::Bse::EnumValue (MIDI_CONTROL_101, "BSE_MIDI_CONTROL_101", _("Control 101 Registered Parameter LSB") );
805  *v++ = ::Bse::EnumValue (MIDI_CONTROL_102, "BSE_MIDI_CONTROL_102", _("control-102") );
806  *v++ = ::Bse::EnumValue (MIDI_CONTROL_103, "BSE_MIDI_CONTROL_103", _("control-103") );
807  *v++ = ::Bse::EnumValue (MIDI_CONTROL_104, "BSE_MIDI_CONTROL_104", _("control-104") );
808  *v++ = ::Bse::EnumValue (MIDI_CONTROL_105, "BSE_MIDI_CONTROL_105", _("control-105") );
809  *v++ = ::Bse::EnumValue (MIDI_CONTROL_106, "BSE_MIDI_CONTROL_106", _("control-106") );
810  *v++ = ::Bse::EnumValue (MIDI_CONTROL_107, "BSE_MIDI_CONTROL_107", _("control-107") );
811  *v++ = ::Bse::EnumValue (MIDI_CONTROL_108, "BSE_MIDI_CONTROL_108", _("control-108") );
812  *v++ = ::Bse::EnumValue (MIDI_CONTROL_109, "BSE_MIDI_CONTROL_109", _("control-109") );
813  *v++ = ::Bse::EnumValue (MIDI_CONTROL_110, "BSE_MIDI_CONTROL_110", _("control-110") );
814  *v++ = ::Bse::EnumValue (MIDI_CONTROL_111, "BSE_MIDI_CONTROL_111", _("control-111") );
815  *v++ = ::Bse::EnumValue (MIDI_CONTROL_112, "BSE_MIDI_CONTROL_112", _("control-112") );
816  *v++ = ::Bse::EnumValue (MIDI_CONTROL_113, "BSE_MIDI_CONTROL_113", _("control-113") );
817  *v++ = ::Bse::EnumValue (MIDI_CONTROL_114, "BSE_MIDI_CONTROL_114", _("control-114") );
818  *v++ = ::Bse::EnumValue (MIDI_CONTROL_115, "BSE_MIDI_CONTROL_115", _("control-115") );
819  *v++ = ::Bse::EnumValue (MIDI_CONTROL_116, "BSE_MIDI_CONTROL_116", _("control-116") );
820  *v++ = ::Bse::EnumValue (MIDI_CONTROL_117, "BSE_MIDI_CONTROL_117", _("control-117") );
821  *v++ = ::Bse::EnumValue (MIDI_CONTROL_118, "BSE_MIDI_CONTROL_118", _("control-118") );
822  *v++ = ::Bse::EnumValue (MIDI_CONTROL_119, "BSE_MIDI_CONTROL_119", _("control-119") );
823  *v++ = ::Bse::EnumValue (MIDI_CONTROL_120, "BSE_MIDI_CONTROL_120", _("Control 120 All Sound Off ITrigger") );
824  *v++ = ::Bse::EnumValue (MIDI_CONTROL_121, "BSE_MIDI_CONTROL_121", _("Control 121 All Controllers Off ITrigger") );
825  *v++ = ::Bse::EnumValue (MIDI_CONTROL_122, "BSE_MIDI_CONTROL_122", _("Control 122 Local Control Switch") );
826  *v++ = ::Bse::EnumValue (MIDI_CONTROL_123, "BSE_MIDI_CONTROL_123", _("Control 123 All Notes Off ITrigger") );
827  *v++ = ::Bse::EnumValue (MIDI_CONTROL_124, "BSE_MIDI_CONTROL_124", _("Control 124 Omni Mode Off ITrigger") );
828  *v++ = ::Bse::EnumValue (MIDI_CONTROL_125, "BSE_MIDI_CONTROL_125", _("Control 125 Omni Mode On ITrigger") );
829  *v++ = ::Bse::EnumValue (MIDI_CONTROL_126, "BSE_MIDI_CONTROL_126", _("Control 126 Monophonic Voices Mode") );
830  *v++ = ::Bse::EnumValue (MIDI_CONTROL_127, "BSE_MIDI_CONTROL_127", _("Control 127 Polyphonic Mode On ITrigger") );
831 );
832 BSE_CXX_DECLARE_ENUM (MidiChannelEventType, "BseMidiChannelEventType", 18,
833  *v++ = ::Bse::EnumValue (MIDI_EVENT_NONE, "BSE_MIDI_EVENT_NONE", "bse-midi-event-none" );
834  *v++ = ::Bse::EnumValue (MIDI_EVENT_NOTE_OFF, "BSE_MIDI_EVENT_NOTE_OFF", "bse-midi-event-note-off" );
835  *v++ = ::Bse::EnumValue (MIDI_EVENT_NOTE_ON, "BSE_MIDI_EVENT_NOTE_ON", "bse-midi-event-note-on" );
836  *v++ = ::Bse::EnumValue (MIDI_EVENT_KEY_PRESSURE, "BSE_MIDI_EVENT_KEY_PRESSURE", "bse-midi-event-key-pressure" );
837  *v++ = ::Bse::EnumValue (MIDI_EVENT_CONTROL_CHANGE, "BSE_MIDI_EVENT_CONTROL_CHANGE", "bse-midi-event-control-change" );
838  *v++ = ::Bse::EnumValue (MIDI_EVENT_PROGRAM_CHANGE, "BSE_MIDI_EVENT_PROGRAM_CHANGE", "bse-midi-event-program-change" );
839  *v++ = ::Bse::EnumValue (MIDI_EVENT_CHANNEL_PRESSURE, "BSE_MIDI_EVENT_CHANNEL_PRESSURE", "bse-midi-event-channel-pressure" );
840  *v++ = ::Bse::EnumValue (MIDI_EVENT_PITCH_BEND, "BSE_MIDI_EVENT_PITCH_BEND", "bse-midi-event-pitch-bend" );
841  *v++ = ::Bse::EnumValue (MIDI_EVENT_SYS_EX, "BSE_MIDI_EVENT_SYS_EX", "bse-midi-event-sys-ex" );
842  *v++ = ::Bse::EnumValue (MIDI_EVENT_SONG_POINTER, "BSE_MIDI_EVENT_SONG_POINTER", "bse-midi-event-song-pointer" );
843  *v++ = ::Bse::EnumValue (MIDI_EVENT_SONG_SELECT, "BSE_MIDI_EVENT_SONG_SELECT", "bse-midi-event-song-select" );
844  *v++ = ::Bse::EnumValue (MIDI_EVENT_TUNE, "BSE_MIDI_EVENT_TUNE", "bse-midi-event-tune" );
845  *v++ = ::Bse::EnumValue (MIDI_EVENT_TIMING_CLOCK, "BSE_MIDI_EVENT_TIMING_CLOCK", "bse-midi-event-timing-clock" );
846  *v++ = ::Bse::EnumValue (MIDI_EVENT_SONG_START, "BSE_MIDI_EVENT_SONG_START", "bse-midi-event-song-start" );
847  *v++ = ::Bse::EnumValue (MIDI_EVENT_SONG_CONTINUE, "BSE_MIDI_EVENT_SONG_CONTINUE", "bse-midi-event-song-continue" );
848  *v++ = ::Bse::EnumValue (MIDI_EVENT_SONG_STOP, "BSE_MIDI_EVENT_SONG_STOP", "bse-midi-event-song-stop" );
849  *v++ = ::Bse::EnumValue (MIDI_EVENT_ACTIVE_SENSING, "BSE_MIDI_EVENT_ACTIVE_SENSING", "bse-midi-event-active-sensing" );
850  *v++ = ::Bse::EnumValue (MIDI_EVENT_SYSTEM_RESET, "BSE_MIDI_EVENT_SYSTEM_RESET", "bse-midi-event-system-reset" );
851 );
852 
853 
854 /* sequence type declarations */
855 BSE_CXX_DECLARE_SEQUENCE (IntSeq);
856 
857 BSE_CXX_DECLARE_SEQUENCE (TypeSeq);
858 
859 BSE_CXX_DECLARE_SEQUENCE (StringSeq);
860 
861 BSE_CXX_DECLARE_SEQUENCE (FloatSeq);
862 
863 BSE_CXX_DECLARE_SEQUENCE (NoteSeq);
864 
865 BSE_CXX_DECLARE_SEQUENCE (ItemSeq);
866 
867 BSE_CXX_DECLARE_SEQUENCE (PixelSeq);
868 
869 BSE_CXX_DECLARE_SEQUENCE (CategorySeq);
870 
871 BSE_CXX_DECLARE_SEQUENCE (DotSeq);
872 
873 BSE_CXX_DECLARE_SEQUENCE (TrackPartSeq);
874 
875 
876 
877 /* record type declarations */
878 BSE_CXX_DECLARE_RECORD (MidiChannelEvent);
879 
880 BSE_CXX_DECLARE_RECORD (PropertyCandidates);
881 
882 BSE_CXX_DECLARE_RECORD (NoteDescription);
883 
884 BSE_CXX_DECLARE_RECORD (NoteSequence);
885 
886 BSE_CXX_DECLARE_RECORD (Icon);
887 
888 BSE_CXX_DECLARE_RECORD (Category);
889 
890 BSE_CXX_DECLARE_RECORD (Dot);
891 
892 BSE_CXX_DECLARE_RECORD (TrackPart);
893 
894 BSE_CXX_DECLARE_RECORD (SampleFileInfo);
895 
896 BSE_CXX_DECLARE_RECORD (GConfig);
897 
898 
899 
900 /* procedure prototypes */
901 
902 
903 /* class definitions */
904 
905 
906 /* choice implementations */
907 static SfiChoiceValues
908 MusicalTuningType_choice_values()
909 {
910  static SfiChoiceValue values[17];
911  static const SfiChoiceValues choice_values = {
912  G_N_ELEMENTS (values), values,
913  };
914  if (!values[0].choice_ident)
915  {
916  values[0].choice_ident = "BSE_MUSICAL_TUNING_12_TET";
917  values[0].choice_label = _("12 Tone Equal Temperament");
918  values[0].choice_blurb = _("The most common tuning system for modern Western music, is the twelve-tone equal temperament, abbreviated as 12-TET, which divides the octave into 12 equal parts.");
919  values[1].choice_ident = "BSE_MUSICAL_TUNING_7_TET";
920  values[1].choice_label = _("7 Tone Equal Temperament");
921  values[1].choice_blurb = _("A fairly common tuning system is the seven-tone equal temperament tuning system, abbreviated as 7-TET. It divides the octave into 7 equal parts using 171 cent steps.");
922  values[2].choice_ident = "BSE_MUSICAL_TUNING_5_TET";
923  values[2].choice_label = _("5 Tone Equal Temperament");
924  values[2].choice_blurb = _("A fairly common tuning system is the five-tone equal temperament tuning system, abbreviated as 5-TET. It divides the octave into 5 equal parts using 240 cent steps.");
925  values[3].choice_ident = "BSE_MUSICAL_TUNING_DIATONIC_SCALE";
926  values[3].choice_label = _("Diatonic Scale");
927  values[3].choice_blurb = _("In music theory, a diatonic scale (also: heptatonia prima) is a seven-note musical scale comprising five whole-tone and two half-tone steps. The half tones are maximally separated, so between two half-tone steps there are either two or three whole tones, repeating per octave.");
928  values[4].choice_ident = "BSE_MUSICAL_TUNING_INDIAN_SCALE";
929  values[4].choice_label = _("Indian Scale");
930  values[4].choice_blurb = _("Diatonic scale used in Indian music with wolf interval at Dha, close to 3/2");
931  values[5].choice_ident = "BSE_MUSICAL_TUNING_PYTHAGOREAN_TUNING";
932  values[5].choice_label = _("Pythagorean Tuning");
933  values[5].choice_blurb = _("Pythagorean tuning is the oldest way of tuning the 12-note chromatic scale, in which the frequency relationships of all intervals are based on the ratio 3:2. Its discovery is generally credited to Pythagoras.");
934  values[6].choice_ident = "BSE_MUSICAL_TUNING_PENTATONIC_5_LIMIT";
935  values[6].choice_label = _("Pentatonic 5-limit");
936  values[6].choice_blurb = _("Pentatonic scales are used in modern jazz and pop/rock contexts because they work exceedingly well over several chords diatonic to the same key, often better than the parent scale.");
937  values[7].choice_ident = "BSE_MUSICAL_TUNING_PENTATONIC_BLUES";
938  values[7].choice_label = _("Pentatonic Blues");
939  values[7].choice_blurb = _("The blues scale is the minor pentatonic with an additional augmented fourth, which is referred to as the \"blues note\".");
940  values[8].choice_ident = "BSE_MUSICAL_TUNING_PENTATONIC_GOGO";
941  values[8].choice_label = _("Pentatonic Gogo");
942  values[8].choice_blurb = _("The Pentatonic Gogo scale is an anhemitonic pentatonic scale used to tune the instruments of the Gogo people of Tanzania.");
943  values[9].choice_ident = "BSE_MUSICAL_TUNING_QUARTER_COMMA_MEANTONE";
944  values[9].choice_label = _("Quarter-Comma Meantone");
945  values[9].choice_blurb = _("Quarter-comma meantone was the most common meantone temperament in the sixteenth and seventeenth centuries and sometimes used later.");
946  values[10].choice_ident = "BSE_MUSICAL_TUNING_SILBERMANN_SORGE";
947  values[10].choice_label = _("Silbermann-Sorge Temperament");
948  values[10].choice_blurb = _("The Silbermann-Sorge temperament is a meantone temperament used for Baroque era organs by Gottfried Silbermann.");
949  values[11].choice_ident = "BSE_MUSICAL_TUNING_WERCKMEISTER_3";
950  values[11].choice_label = _("Werckmeister III");
951  values[11].choice_blurb = _("This tuning uses mostly pure (perfect) fifths, as in Pythagorean tuning, but each of the fifths C-G, G-D, D-A and B-F# is made smaller, i.e. tempered by 1/4 comma. Werckmeister designated this tuning as particularly suited for playing chromatic music.");
952  values[12].choice_ident = "BSE_MUSICAL_TUNING_WERCKMEISTER_4";
953  values[12].choice_label = _("Werckmeister IV");
954  values[12].choice_blurb = _("In this tuning the fifths C-G, D-A, E-B, F#-C#, and Bb-F are tempered narrow by 1/3 comma, and the fifths G#-D# and Eb-Bb are widened by 1/3 comma. The other fifths are pure. Most of its intervals are close to sixth-comma meantone. Werckmeister designed this tuning for playing mainly diatonic music.");
955  values[13].choice_ident = "BSE_MUSICAL_TUNING_WERCKMEISTER_5";
956  values[13].choice_label = _("Werckmeister V");
957  values[13].choice_blurb = _("In this tuning the fifths D-A, A-E, F#-C#, C#-G#, and F-C are narrowed by 1/4 comma, and the fifth G#-D# is widened by 1/4 comma. The other fifths are pure. This temperament is closer to equal temperament than Werckmeister III or IV.");
958  values[14].choice_ident = "BSE_MUSICAL_TUNING_WERCKMEISTER_6";
959  values[14].choice_label = _("Werckmeister VI");
960  values[14].choice_blurb = _("This tuning is also known as Septenarius tuning is based on a division of the monochord length into 196 = 7 * 7 * 4 parts. The resulting scale has rational frequency relationships, but in practice involves pure and impure sounding fifths. Werckmeister described the Septenarius as a \"temperament which has nothing at all to do with the divisions of the comma, nevertheless in practice so correct that one can be really satisfied with it\".");
961  values[15].choice_ident = "BSE_MUSICAL_TUNING_KIRNBERGER_3";
962  values[15].choice_label = _("Kirnberger III");
963  values[15].choice_blurb = _("Kirnberger's method of compensating for and closing the circle of fifths is to split the \"wolf\" interval known to those who have used meantone temperaments between four fifths instead, allowing for four 1/4-comma wolves to take their place. 1/4-comma wolves are used extensively in meantone and are much easier to tune and to listen to. Therefore, only one third remains pure (between C and E).");
964  values[16].choice_ident = "BSE_MUSICAL_TUNING_YOUNG";
965  values[16].choice_label = _("Young Temperament");
966  values[16].choice_blurb = _("Thomas Young devised a form of musical tuning to make the harmony most perfect in those keys which are the most frequently used (give better major thirds in those keys), but to not have any unplayable keys. This is attempted by tuning upwards from C a sequence of six pure fourths, as well as six equally imperfect fifths.");
967  }
968  return choice_values;
969 }
970 
971 static SfiChoiceValues
972 MidiControlType_choice_values()
973 {
974  static SfiChoiceValue values[161];
975  static const SfiChoiceValues choice_values = {
976  G_N_ELEMENTS (values), values,
977  };
978  if (!values[0].choice_ident)
979  {
980  values[0].choice_ident = "BSE_MIDI_CONTROL_NONE";
981  values[0].choice_label = _("None");
982  values[0].choice_blurb = "";
983  values[1].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_0";
984  values[1].choice_label = _("Bank Select");
985  values[1].choice_blurb = _("Continuous MIDI Control #1 - Bank Select");
986  values[2].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_1";
987  values[2].choice_label = _("Modulation Depth");
988  values[2].choice_blurb = "";
989  values[3].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_2";
990  values[3].choice_label = _("Breath Control");
991  values[3].choice_blurb = "";
992  values[4].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_3";
993  values[4].choice_label = _("Continuous 3");
994  values[4].choice_blurb = "";
995  values[5].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_4";
996  values[5].choice_label = _("Foot Controller");
997  values[5].choice_blurb = "";
998  values[6].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_5";
999  values[6].choice_label = _("Portamento Time");
1000  values[6].choice_blurb = "";
1001  values[7].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_6";
1002  values[7].choice_label = _("Data Entry");
1003  values[7].choice_blurb = "";
1004  values[8].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_7";
1005  values[8].choice_label = _("Volume");
1006  values[8].choice_blurb = "";
1007  values[9].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_8";
1008  values[9].choice_label = _("Balance");
1009  values[9].choice_blurb = "";
1010  values[10].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_9";
1011  values[10].choice_label = _("Continuous 9");
1012  values[10].choice_blurb = "";
1013  values[11].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_10";
1014  values[11].choice_label = _("Panorama");
1015  values[11].choice_blurb = "";
1016  values[12].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_11";
1017  values[12].choice_label = _("Expression");
1018  values[12].choice_blurb = "";
1019  values[13].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_12";
1020  values[13].choice_label = _("Effect Control 1");
1021  values[13].choice_blurb = "";
1022  values[14].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_13";
1023  values[14].choice_label = _("Effect Control 2");
1024  values[14].choice_blurb = "";
1025  values[15].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_14";
1026  values[15].choice_label = _("Continuous 14");
1027  values[15].choice_blurb = "";
1028  values[16].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_15";
1029  values[16].choice_label = _("Continuous 15");
1030  values[16].choice_blurb = "";
1031  values[17].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_16";
1032  values[17].choice_label = _("General Purpose Controller 1");
1033  values[17].choice_blurb = "";
1034  values[18].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_17";
1035  values[18].choice_label = _("General Purpose Controller 2");
1036  values[18].choice_blurb = "";
1037  values[19].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_18";
1038  values[19].choice_label = _("General Purpose Controller 3");
1039  values[19].choice_blurb = "";
1040  values[20].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_19";
1041  values[20].choice_label = _("General Purpose Controller 4");
1042  values[20].choice_blurb = "";
1043  values[21].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_20";
1044  values[21].choice_label = _("Continuous 20");
1045  values[21].choice_blurb = "";
1046  values[22].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_21";
1047  values[22].choice_label = _("Continuous 21");
1048  values[22].choice_blurb = "";
1049  values[23].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_22";
1050  values[23].choice_label = _("Continuous 22");
1051  values[23].choice_blurb = "";
1052  values[24].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_23";
1053  values[24].choice_label = _("Continuous 23");
1054  values[24].choice_blurb = "";
1055  values[25].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_24";
1056  values[25].choice_label = _("Continuous 24");
1057  values[25].choice_blurb = "";
1058  values[26].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_25";
1059  values[26].choice_label = _("Continuous 25");
1060  values[26].choice_blurb = "";
1061  values[27].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_26";
1062  values[27].choice_label = _("Continuous 26");
1063  values[27].choice_blurb = "";
1064  values[28].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_27";
1065  values[28].choice_label = _("Continuous 27");
1066  values[28].choice_blurb = "";
1067  values[29].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_28";
1068  values[29].choice_label = _("Continuous 28");
1069  values[29].choice_blurb = "";
1070  values[30].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_29";
1071  values[30].choice_label = _("Continuous 29");
1072  values[30].choice_blurb = "";
1073  values[31].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_30";
1074  values[31].choice_label = _("Continuous 30");
1075  values[31].choice_blurb = "";
1076  values[32].choice_ident = "BSE_MIDI_CONTROL_CONTINUOUS_31";
1077  values[32].choice_label = _("Continuous 31");
1078  values[32].choice_blurb = "";
1079  values[33].choice_ident = "BSE_MIDI_CONTROL_0";
1080  values[33].choice_label = _("Control 0 Bank Select MSB");
1081  values[33].choice_blurb = "";
1082  values[34].choice_ident = "BSE_MIDI_CONTROL_1";
1083  values[34].choice_label = _("Control 1 Modulation Depth MSB");
1084  values[34].choice_blurb = "";
1085  values[35].choice_ident = "BSE_MIDI_CONTROL_2";
1086  values[35].choice_label = _("Control 2 Breath Control MSB");
1087  values[35].choice_blurb = "";
1088  values[36].choice_ident = "BSE_MIDI_CONTROL_3";
1089  values[36].choice_label = _("control-3");
1090  values[36].choice_blurb = "";
1091  values[37].choice_ident = "BSE_MIDI_CONTROL_4";
1092  values[37].choice_label = _("Control 4 Foot Controller MSB");
1093  values[37].choice_blurb = "";
1094  values[38].choice_ident = "BSE_MIDI_CONTROL_5";
1095  values[38].choice_label = _("Control 5 Portamento Time MSB");
1096  values[38].choice_blurb = "";
1097  values[39].choice_ident = "BSE_MIDI_CONTROL_6";
1098  values[39].choice_label = _("Control 6 Data Entry MSB");
1099  values[39].choice_blurb = "";
1100  values[40].choice_ident = "BSE_MIDI_CONTROL_7";
1101  values[40].choice_label = _("Control 7 Volume MSB");
1102  values[40].choice_blurb = "";
1103  values[41].choice_ident = "BSE_MIDI_CONTROL_8";
1104  values[41].choice_label = _("Control 8 Balance MSB");
1105  values[41].choice_blurb = "";
1106  values[42].choice_ident = "BSE_MIDI_CONTROL_9";
1107  values[42].choice_label = _("control-9");
1108  values[42].choice_blurb = "";
1109  values[43].choice_ident = "BSE_MIDI_CONTROL_10";
1110  values[43].choice_label = _("Control 10 Panorama MSB");
1111  values[43].choice_blurb = "";
1112  values[44].choice_ident = "BSE_MIDI_CONTROL_11";
1113  values[44].choice_label = _("Control 11 Expression MSB");
1114  values[44].choice_blurb = "";
1115  values[45].choice_ident = "BSE_MIDI_CONTROL_12";
1116  values[45].choice_label = _("Control 12 Effect Control 1 MSB");
1117  values[45].choice_blurb = "";
1118  values[46].choice_ident = "BSE_MIDI_CONTROL_13";
1119  values[46].choice_label = _("Control 13 Effect Control 2 MSB");
1120  values[46].choice_blurb = "";
1121  values[47].choice_ident = "BSE_MIDI_CONTROL_14";
1122  values[47].choice_label = _("control-14");
1123  values[47].choice_blurb = "";
1124  values[48].choice_ident = "BSE_MIDI_CONTROL_15";
1125  values[48].choice_label = _("control-15");
1126  values[48].choice_blurb = "";
1127  values[49].choice_ident = "BSE_MIDI_CONTROL_16";
1128  values[49].choice_label = _("Control 16 General Purpose Controller 1 MSB");
1129  values[49].choice_blurb = "";
1130  values[50].choice_ident = "BSE_MIDI_CONTROL_17";
1131  values[50].choice_label = _("Control 17 General Purpose Controller 2 MSB");
1132  values[50].choice_blurb = "";
1133  values[51].choice_ident = "BSE_MIDI_CONTROL_18";
1134  values[51].choice_label = _("Control 18 General Purpose Controller 3 MSB");
1135  values[51].choice_blurb = "";
1136  values[52].choice_ident = "BSE_MIDI_CONTROL_19";
1137  values[52].choice_label = _("Control 19 General Purpose Controller 4 MSB");
1138  values[52].choice_blurb = "";
1139  values[53].choice_ident = "BSE_MIDI_CONTROL_20";
1140  values[53].choice_label = _("control-20");
1141  values[53].choice_blurb = "";
1142  values[54].choice_ident = "BSE_MIDI_CONTROL_21";
1143  values[54].choice_label = _("control-21");
1144  values[54].choice_blurb = "";
1145  values[55].choice_ident = "BSE_MIDI_CONTROL_22";
1146  values[55].choice_label = _("control-22");
1147  values[55].choice_blurb = "";
1148  values[56].choice_ident = "BSE_MIDI_CONTROL_23";
1149  values[56].choice_label = _("control-23");
1150  values[56].choice_blurb = "";
1151  values[57].choice_ident = "BSE_MIDI_CONTROL_24";
1152  values[57].choice_label = _("control-24");
1153  values[57].choice_blurb = "";
1154  values[58].choice_ident = "BSE_MIDI_CONTROL_25";
1155  values[58].choice_label = _("control-25");
1156  values[58].choice_blurb = "";
1157  values[59].choice_ident = "BSE_MIDI_CONTROL_26";
1158  values[59].choice_label = _("control-26");
1159  values[59].choice_blurb = "";
1160  values[60].choice_ident = "BSE_MIDI_CONTROL_27";
1161  values[60].choice_label = _("control-27");
1162  values[60].choice_blurb = "";
1163  values[61].choice_ident = "BSE_MIDI_CONTROL_28";
1164  values[61].choice_label = _("control-28");
1165  values[61].choice_blurb = "";
1166  values[62].choice_ident = "BSE_MIDI_CONTROL_29";
1167  values[62].choice_label = _("control-29");
1168  values[62].choice_blurb = "";
1169  values[63].choice_ident = "BSE_MIDI_CONTROL_30";
1170  values[63].choice_label = _("control-30");
1171  values[63].choice_blurb = "";
1172  values[64].choice_ident = "BSE_MIDI_CONTROL_31";
1173  values[64].choice_label = _("control-31");
1174  values[64].choice_blurb = "";
1175  values[65].choice_ident = "BSE_MIDI_CONTROL_32";
1176  values[65].choice_label = _("Control 32 Bank Select LSB");
1177  values[65].choice_blurb = "";
1178  values[66].choice_ident = "BSE_MIDI_CONTROL_33";
1179  values[66].choice_label = _("Control 33 Modulation Depth LSB");
1180  values[66].choice_blurb = "";
1181  values[67].choice_ident = "BSE_MIDI_CONTROL_34";
1182  values[67].choice_label = _("Control 34 Breath Control LSB");
1183  values[67].choice_blurb = "";
1184  values[68].choice_ident = "BSE_MIDI_CONTROL_35";
1185  values[68].choice_label = _("control-35");
1186  values[68].choice_blurb = "";
1187  values[69].choice_ident = "BSE_MIDI_CONTROL_36";
1188  values[69].choice_label = _("Control 36 Foot Controller LSB");
1189  values[69].choice_blurb = "";
1190  values[70].choice_ident = "BSE_MIDI_CONTROL_37";
1191  values[70].choice_label = _("Control 37 Portamento Time LSB");
1192  values[70].choice_blurb = "";
1193  values[71].choice_ident = "BSE_MIDI_CONTROL_38";
1194  values[71].choice_label = _("Control 38 Data Entry LSB");
1195  values[71].choice_blurb = "";
1196  values[72].choice_ident = "BSE_MIDI_CONTROL_39";
1197  values[72].choice_label = _("Control 39 Volume LSB");
1198  values[72].choice_blurb = "";
1199  values[73].choice_ident = "BSE_MIDI_CONTROL_40";
1200  values[73].choice_label = _("Control 40 Balance LSB");
1201  values[73].choice_blurb = "";
1202  values[74].choice_ident = "BSE_MIDI_CONTROL_41";
1203  values[74].choice_label = _("control-41");
1204  values[74].choice_blurb = "";
1205  values[75].choice_ident = "BSE_MIDI_CONTROL_42";
1206  values[75].choice_label = _("Control 42 Panorama LSB");
1207  values[75].choice_blurb = "";
1208  values[76].choice_ident = "BSE_MIDI_CONTROL_43";
1209  values[76].choice_label = _("Control 43 Expression LSB");
1210  values[76].choice_blurb = "";
1211  values[77].choice_ident = "BSE_MIDI_CONTROL_44";
1212  values[77].choice_label = _("Control 44 Effect Control 1 LSB");
1213  values[77].choice_blurb = "";
1214  values[78].choice_ident = "BSE_MIDI_CONTROL_45";
1215  values[78].choice_label = _("Control 45 Effect Control 2 LSB");
1216  values[78].choice_blurb = "";
1217  values[79].choice_ident = "BSE_MIDI_CONTROL_46";
1218  values[79].choice_label = _("control-46");
1219  values[79].choice_blurb = "";
1220  values[80].choice_ident = "BSE_MIDI_CONTROL_47";
1221  values[80].choice_label = _("control-47");
1222  values[80].choice_blurb = "";
1223  values[81].choice_ident = "BSE_MIDI_CONTROL_48";
1224  values[81].choice_label = _("Control 48 General Purpose Controller 1 LSB");
1225  values[81].choice_blurb = "";
1226  values[82].choice_ident = "BSE_MIDI_CONTROL_49";
1227  values[82].choice_label = _("Control 49 General Purpose Controller 2 LSB");
1228  values[82].choice_blurb = "";
1229  values[83].choice_ident = "BSE_MIDI_CONTROL_50";
1230  values[83].choice_label = _("Control 50 General Purpose Controller 3 LSB");
1231  values[83].choice_blurb = "";
1232  values[84].choice_ident = "BSE_MIDI_CONTROL_51";
1233  values[84].choice_label = _("Control 51 General Purpose Controller 4 LSB");
1234  values[84].choice_blurb = "";
1235  values[85].choice_ident = "BSE_MIDI_CONTROL_52";
1236  values[85].choice_label = _("control-52");
1237  values[85].choice_blurb = "";
1238  values[86].choice_ident = "BSE_MIDI_CONTROL_53";
1239  values[86].choice_label = _("control-53");
1240  values[86].choice_blurb = "";
1241  values[87].choice_ident = "BSE_MIDI_CONTROL_54";
1242  values[87].choice_label = _("control-54");
1243  values[87].choice_blurb = "";
1244  values[88].choice_ident = "BSE_MIDI_CONTROL_55";
1245  values[88].choice_label = _("control-55");
1246  values[88].choice_blurb = "";
1247  values[89].choice_ident = "BSE_MIDI_CONTROL_56";
1248  values[89].choice_label = _("control-56");
1249  values[89].choice_blurb = "";
1250  values[90].choice_ident = "BSE_MIDI_CONTROL_57";
1251  values[90].choice_label = _("control-57");
1252  values[90].choice_blurb = "";
1253  values[91].choice_ident = "BSE_MIDI_CONTROL_58";
1254  values[91].choice_label = _("control-58");
1255  values[91].choice_blurb = "";
1256  values[92].choice_ident = "BSE_MIDI_CONTROL_59";
1257  values[92].choice_label = _("control-59");
1258  values[92].choice_blurb = "";
1259  values[93].choice_ident = "BSE_MIDI_CONTROL_60";
1260  values[93].choice_label = _("control-60");
1261  values[93].choice_blurb = "";
1262  values[94].choice_ident = "BSE_MIDI_CONTROL_61";
1263  values[94].choice_label = _("control-61");
1264  values[94].choice_blurb = "";
1265  values[95].choice_ident = "BSE_MIDI_CONTROL_62";
1266  values[95].choice_label = _("control-62");
1267  values[95].choice_blurb = "";
1268  values[96].choice_ident = "BSE_MIDI_CONTROL_63";
1269  values[96].choice_label = _("control-63");
1270  values[96].choice_blurb = "";
1271  values[97].choice_ident = "BSE_MIDI_CONTROL_64";
1272  values[97].choice_label = _("Control 64 Damper Pedal Switch (Sustain)");
1273  values[97].choice_blurb = "";
1274  values[98].choice_ident = "BSE_MIDI_CONTROL_65";
1275  values[98].choice_label = _("Control 65 Portamento Switch");
1276  values[98].choice_blurb = "";
1277  values[99].choice_ident = "BSE_MIDI_CONTROL_66";
1278  values[99].choice_label = _("Control 66 Sustenuto Switch");
1279  values[99].choice_blurb = "";
1280  values[100].choice_ident = "BSE_MIDI_CONTROL_67";
1281  values[100].choice_label = _("Control 67 Soft Switch");
1282  values[100].choice_blurb = "";
1283  values[101].choice_ident = "BSE_MIDI_CONTROL_68";
1284  values[101].choice_label = _("Control 68 Legato Pedal Switch");
1285  values[101].choice_blurb = "";
1286  values[102].choice_ident = "BSE_MIDI_CONTROL_69";
1287  values[102].choice_label = _("Control 69 Hold Pedal Switch");
1288  values[102].choice_blurb = "";
1289  values[103].choice_ident = "BSE_MIDI_CONTROL_70";
1290  values[103].choice_label = _("Control 70 Sound Variation");
1291  values[103].choice_blurb = "";
1292  values[104].choice_ident = "BSE_MIDI_CONTROL_71";
1293  values[104].choice_label = _("Control 71 Filter Resonance (Timbre)");
1294  values[104].choice_blurb = "";
1295  values[105].choice_ident = "BSE_MIDI_CONTROL_72";
1296  values[105].choice_label = _("Control 72 Sound Release Time");
1297  values[105].choice_blurb = "";
1298  values[106].choice_ident = "BSE_MIDI_CONTROL_73";
1299  values[106].choice_label = _("Control 73 Sound Attack Time");
1300  values[106].choice_blurb = "";
1301  values[107].choice_ident = "BSE_MIDI_CONTROL_74";
1302  values[107].choice_label = _("Control 74 Sound Brightness");
1303  values[107].choice_blurb = "";
1304  values[108].choice_ident = "BSE_MIDI_CONTROL_75";
1305  values[108].choice_label = _("Control 75 Sound Decay Time");
1306  values[108].choice_blurb = "";
1307  values[109].choice_ident = "BSE_MIDI_CONTROL_76";
1308  values[109].choice_label = _("Control 76 Vibrato Rate");
1309  values[109].choice_blurb = "";
1310  values[110].choice_ident = "BSE_MIDI_CONTROL_77";
1311  values[110].choice_label = _("Control 77 Vibrato Depth");
1312  values[110].choice_blurb = "";
1313  values[111].choice_ident = "BSE_MIDI_CONTROL_78";
1314  values[111].choice_label = _("Control 78 Vibrato Delay");
1315  values[111].choice_blurb = "";
1316  values[112].choice_ident = "BSE_MIDI_CONTROL_79";
1317  values[112].choice_label = _("Control 79 Sound Control 10");
1318  values[112].choice_blurb = "";
1319  values[113].choice_ident = "BSE_MIDI_CONTROL_80";
1320  values[113].choice_label = _("Control 80 General Purpose Switch 5");
1321  values[113].choice_blurb = "";
1322  values[114].choice_ident = "BSE_MIDI_CONTROL_81";
1323  values[114].choice_label = _("Control 81 General Purpose Switch 6");
1324  values[114].choice_blurb = "";
1325  values[115].choice_ident = "BSE_MIDI_CONTROL_82";
1326  values[115].choice_label = _("Control 82 General Purpose Switch 7");
1327  values[115].choice_blurb = "";
1328  values[116].choice_ident = "BSE_MIDI_CONTROL_83";
1329  values[116].choice_label = _("Control 83 General Purpose Switch 8");
1330  values[116].choice_blurb = "";
1331  values[117].choice_ident = "BSE_MIDI_CONTROL_84";
1332  values[117].choice_label = _("Control 84 Portamento Control (Note)");
1333  values[117].choice_blurb = "";
1334  values[118].choice_ident = "BSE_MIDI_CONTROL_85";
1335  values[118].choice_label = _("control-85");
1336  values[118].choice_blurb = "";
1337  values[119].choice_ident = "BSE_MIDI_CONTROL_86";
1338  values[119].choice_label = _("control-86");
1339  values[119].choice_blurb = "";
1340  values[120].choice_ident = "BSE_MIDI_CONTROL_87";
1341  values[120].choice_label = _("control-87");
1342  values[120].choice_blurb = "";
1343  values[121].choice_ident = "BSE_MIDI_CONTROL_88";
1344  values[121].choice_label = _("control-88");
1345  values[121].choice_blurb = "";
1346  values[122].choice_ident = "BSE_MIDI_CONTROL_89";
1347  values[122].choice_label = _("control-89");
1348  values[122].choice_blurb = "";
1349  values[123].choice_ident = "BSE_MIDI_CONTROL_90";
1350  values[123].choice_label = _("control-90");
1351  values[123].choice_blurb = "";
1352  values[124].choice_ident = "BSE_MIDI_CONTROL_91";
1353  values[124].choice_label = _("Control 91 Reverb Depth");
1354  values[124].choice_blurb = "";
1355  values[125].choice_ident = "BSE_MIDI_CONTROL_92";
1356  values[125].choice_label = _("Control 92 Tremolo Depth");
1357  values[125].choice_blurb = "";
1358  values[126].choice_ident = "BSE_MIDI_CONTROL_93";
1359  values[126].choice_label = _("Control 93 Chorus Depth");
1360  values[126].choice_blurb = "";
1361  values[127].choice_ident = "BSE_MIDI_CONTROL_94";
1362  values[127].choice_label = _("Control 93 Detune Depth");
1363  values[127].choice_blurb = "";
1364  values[128].choice_ident = "BSE_MIDI_CONTROL_95";
1365  values[128].choice_label = _("Control 95 Phase Depth");
1366  values[128].choice_blurb = "";
1367  values[129].choice_ident = "BSE_MIDI_CONTROL_96";
1368  values[129].choice_label = _("Control 96 Data Increment Trigger");
1369  values[129].choice_blurb = "";
1370  values[130].choice_ident = "BSE_MIDI_CONTROL_97";
1371  values[130].choice_label = _("Control 97 Data Decrement Trigger");
1372  values[130].choice_blurb = "";
1373  values[131].choice_ident = "BSE_MIDI_CONTROL_98";
1374  values[131].choice_label = _("Control 98 Non-Registered Parameter MSB");
1375  values[131].choice_blurb = "";
1376  values[132].choice_ident = "BSE_MIDI_CONTROL_99";
1377  values[132].choice_label = _("Control 99 Non-Registered Parameter LSB");
1378  values[132].choice_blurb = "";
1379  values[133].choice_ident = "BSE_MIDI_CONTROL_100";
1380  values[133].choice_label = _("Control 100 Registered Parameter MSB");
1381  values[133].choice_blurb = "";
1382  values[134].choice_ident = "BSE_MIDI_CONTROL_101";
1383  values[134].choice_label = _("Control 101 Registered Parameter LSB");
1384  values[134].choice_blurb = "";
1385  values[135].choice_ident = "BSE_MIDI_CONTROL_102";
1386  values[135].choice_label = _("control-102");
1387  values[135].choice_blurb = "";
1388  values[136].choice_ident = "BSE_MIDI_CONTROL_103";
1389  values[136].choice_label = _("control-103");
1390  values[136].choice_blurb = "";
1391  values[137].choice_ident = "BSE_MIDI_CONTROL_104";
1392  values[137].choice_label = _("control-104");
1393  values[137].choice_blurb = "";
1394  values[138].choice_ident = "BSE_MIDI_CONTROL_105";
1395  values[138].choice_label = _("control-105");
1396  values[138].choice_blurb = "";
1397  values[139].choice_ident = "BSE_MIDI_CONTROL_106";
1398  values[139].choice_label = _("control-106");
1399  values[139].choice_blurb = "";
1400  values[140].choice_ident = "BSE_MIDI_CONTROL_107";
1401  values[140].choice_label = _("control-107");
1402  values[140].choice_blurb = "";
1403  values[141].choice_ident = "BSE_MIDI_CONTROL_108";
1404  values[141].choice_label = _("control-108");
1405  values[141].choice_blurb = "";
1406  values[142].choice_ident = "BSE_MIDI_CONTROL_109";
1407  values[142].choice_label = _("control-109");
1408  values[142].choice_blurb = "";
1409  values[143].choice_ident = "BSE_MIDI_CONTROL_110";
1410  values[143].choice_label = _("control-110");
1411  values[143].choice_blurb = "";
1412  values[144].choice_ident = "BSE_MIDI_CONTROL_111";
1413  values[144].choice_label = _("control-111");
1414  values[144].choice_blurb = "";
1415  values[145].choice_ident = "BSE_MIDI_CONTROL_112";
1416  values[145].choice_label = _("control-112");
1417  values[145].choice_blurb = "";
1418  values[146].choice_ident = "BSE_MIDI_CONTROL_113";
1419  values[146].choice_label = _("control-113");
1420  values[146].choice_blurb = "";
1421  values[147].choice_ident = "BSE_MIDI_CONTROL_114";
1422  values[147].choice_label = _("control-114");
1423  values[147].choice_blurb = "";
1424  values[148].choice_ident = "BSE_MIDI_CONTROL_115";
1425  values[148].choice_label = _("control-115");
1426  values[148].choice_blurb = "";
1427  values[149].choice_ident = "BSE_MIDI_CONTROL_116";
1428  values[149].choice_label = _("control-116");
1429  values[149].choice_blurb = "";
1430  values[150].choice_ident = "BSE_MIDI_CONTROL_117";
1431  values[150].choice_label = _("control-117");
1432  values[150].choice_blurb = "";
1433  values[151].choice_ident = "BSE_MIDI_CONTROL_118";
1434  values[151].choice_label = _("control-118");
1435  values[151].choice_blurb = "";
1436  values[152].choice_ident = "BSE_MIDI_CONTROL_119";
1437  values[152].choice_label = _("control-119");
1438  values[152].choice_blurb = "";
1439  values[153].choice_ident = "BSE_MIDI_CONTROL_120";
1440  values[153].choice_label = _("Control 120 All Sound Off ITrigger");
1441  values[153].choice_blurb = "";
1442  values[154].choice_ident = "BSE_MIDI_CONTROL_121";
1443  values[154].choice_label = _("Control 121 All Controllers Off ITrigger");
1444  values[154].choice_blurb = "";
1445  values[155].choice_ident = "BSE_MIDI_CONTROL_122";
1446  values[155].choice_label = _("Control 122 Local Control Switch");
1447  values[155].choice_blurb = "";
1448  values[156].choice_ident = "BSE_MIDI_CONTROL_123";
1449  values[156].choice_label = _("Control 123 All Notes Off ITrigger");
1450  values[156].choice_blurb = "";
1451  values[157].choice_ident = "BSE_MIDI_CONTROL_124";
1452  values[157].choice_label = _("Control 124 Omni Mode Off ITrigger");
1453  values[157].choice_blurb = "";
1454  values[158].choice_ident = "BSE_MIDI_CONTROL_125";
1455  values[158].choice_label = _("Control 125 Omni Mode On ITrigger");
1456  values[158].choice_blurb = "";
1457  values[159].choice_ident = "BSE_MIDI_CONTROL_126";
1458  values[159].choice_label = _("Control 126 Monophonic Voices Mode");
1459  values[159].choice_blurb = "";
1460  values[160].choice_ident = "BSE_MIDI_CONTROL_127";
1461  values[160].choice_label = _("Control 127 Polyphonic Mode On ITrigger");
1462  values[160].choice_blurb = "";
1463  }
1464  return choice_values;
1465 }
1466 
1467 static SfiChoiceValues
1468 MidiChannelEventType_choice_values()
1469 {
1470  static SfiChoiceValue values[18];
1471  static const SfiChoiceValues choice_values = {
1472  G_N_ELEMENTS (values), values,
1473  };
1474  if (!values[0].choice_ident)
1475  {
1476  values[0].choice_ident = "BSE_MIDI_EVENT_NONE";
1477  values[0].choice_label = "bse-midi-event-none";
1478  values[0].choice_blurb = "";
1479  values[1].choice_ident = "BSE_MIDI_EVENT_NOTE_OFF";
1480  values[1].choice_label = "bse-midi-event-note-off";
1481  values[1].choice_blurb = "";
1482  values[2].choice_ident = "BSE_MIDI_EVENT_NOTE_ON";
1483  values[2].choice_label = "bse-midi-event-note-on";
1484  values[2].choice_blurb = "";
1485  values[3].choice_ident = "BSE_MIDI_EVENT_KEY_PRESSURE";
1486  values[3].choice_label = "bse-midi-event-key-pressure";
1487  values[3].choice_blurb = "";
1488  values[4].choice_ident = "BSE_MIDI_EVENT_CONTROL_CHANGE";
1489  values[4].choice_label = "bse-midi-event-control-change";
1490  values[4].choice_blurb = "";
1491  values[5].choice_ident = "BSE_MIDI_EVENT_PROGRAM_CHANGE";
1492  values[5].choice_label = "bse-midi-event-program-change";
1493  values[5].choice_blurb = "";
1494  values[6].choice_ident = "BSE_MIDI_EVENT_CHANNEL_PRESSURE";
1495  values[6].choice_label = "bse-midi-event-channel-pressure";
1496  values[6].choice_blurb = "";
1497  values[7].choice_ident = "BSE_MIDI_EVENT_PITCH_BEND";
1498  values[7].choice_label = "bse-midi-event-pitch-bend";
1499  values[7].choice_blurb = "";
1500  values[8].choice_ident = "BSE_MIDI_EVENT_SYS_EX";
1501  values[8].choice_label = "bse-midi-event-sys-ex";
1502  values[8].choice_blurb = "";
1503  values[9].choice_ident = "BSE_MIDI_EVENT_SONG_POINTER";
1504  values[9].choice_label = "bse-midi-event-song-pointer";
1505  values[9].choice_blurb = "";
1506  values[10].choice_ident = "BSE_MIDI_EVENT_SONG_SELECT";
1507  values[10].choice_label = "bse-midi-event-song-select";
1508  values[10].choice_blurb = "";
1509  values[11].choice_ident = "BSE_MIDI_EVENT_TUNE";
1510  values[11].choice_label = "bse-midi-event-tune";
1511  values[11].choice_blurb = "";
1512  values[12].choice_ident = "BSE_MIDI_EVENT_TIMING_CLOCK";
1513  values[12].choice_label = "bse-midi-event-timing-clock";
1514  values[12].choice_blurb = "";
1515  values[13].choice_ident = "BSE_MIDI_EVENT_SONG_START";
1516  values[13].choice_label = "bse-midi-event-song-start";
1517  values[13].choice_blurb = "";
1518  values[14].choice_ident = "BSE_MIDI_EVENT_SONG_CONTINUE";
1519  values[14].choice_label = "bse-midi-event-song-continue";
1520  values[14].choice_blurb = "";
1521  values[15].choice_ident = "BSE_MIDI_EVENT_SONG_STOP";
1522  values[15].choice_label = "bse-midi-event-song-stop";
1523  values[15].choice_blurb = "";
1524  values[16].choice_ident = "BSE_MIDI_EVENT_ACTIVE_SENSING";
1525  values[16].choice_label = "bse-midi-event-active-sensing";
1526  values[16].choice_blurb = "";
1527  values[17].choice_ident = "BSE_MIDI_EVENT_SYSTEM_RESET";
1528  values[17].choice_label = "bse-midi-event-system-reset";
1529  values[17].choice_blurb = "";
1530  }
1531  return choice_values;
1532 }
1533 
1534 
1535 
1536 /* record implementations */
1538 MidiChannelEvent::from_rec (SfiRec *sfi_rec)
1539 {
1540  GValue *element;
1541 
1542  if (!sfi_rec)
1543  return Sfi::INIT_NULL;
1544 
1545  ::Bse::MidiChannelEventHandle rec = Sfi::INIT_DEFAULT;
1546  element = sfi_rec_get (sfi_rec, "event_type");
1547  if (element)
1548  rec->event_type = (::Bse::MidiChannelEventType) sfi_value_get_enum_auto SFI_START_ARGS() BSE_TYPE_MIDI_CHANNEL_EVENT_TYPE, SFI_END_ARGS1 (element);
1549  element = sfi_rec_get (sfi_rec, "channel");
1550  if (element)
1551  rec->channel = sfi_value_get_int (element);
1552  element = sfi_rec_get (sfi_rec, "tick_stamp");
1553  if (element)
1554  rec->tick_stamp = sfi_value_get_num (element);
1555  element = sfi_rec_get (sfi_rec, "frequency");
1556  if (element)
1557  rec->frequency = sfi_value_get_real (element);
1558  element = sfi_rec_get (sfi_rec, "velocity");
1559  if (element)
1560  rec->velocity = sfi_value_get_real (element);
1561  element = sfi_rec_get (sfi_rec, "control");
1562  if (element)
1563  rec->control = sfi_value_get_int (element);
1564  element = sfi_rec_get (sfi_rec, "value");
1565  if (element)
1566  rec->value = sfi_value_get_real (element);
1567  element = sfi_rec_get (sfi_rec, "program");
1568  if (element)
1569  rec->program = sfi_value_get_int (element);
1570  element = sfi_rec_get (sfi_rec, "intensity");
1571  if (element)
1572  rec->intensity = sfi_value_get_real (element);
1573  element = sfi_rec_get (sfi_rec, "pitch_bend");
1574  if (element)
1575  rec->pitch_bend = sfi_value_get_real (element);
1576  element = sfi_rec_get (sfi_rec, "song_pointer");
1577  if (element)
1578  rec->song_pointer = sfi_value_get_int (element);
1579  element = sfi_rec_get (sfi_rec, "song_number");
1580  if (element)
1581  rec->song_number = sfi_value_get_int (element);
1582  return rec;
1583 }
1584 
1585 SfiRec *
1586 MidiChannelEvent::to_rec (const ::Bse::MidiChannelEventHandle & rec)
1587 {
1588  SfiRec *sfi_rec;
1589  GValue *element;
1590 
1591  if (!rec)
1592  return NULL;
1593 
1594  sfi_rec = sfi_rec_new ();
1595  element = sfi_rec_forced_get (sfi_rec, "event_type", SFI_TYPE_CHOICE);
1596  sfi_value_set_enum_auto SFI_START_ARGS() BSE_TYPE_MIDI_CHANNEL_EVENT_TYPE, SFI_END_ARGS2 (element, rec->event_type);
1597  element = sfi_rec_forced_get (sfi_rec, "channel", SFI_TYPE_INT);
1598  sfi_value_set_int (element, rec->channel);
1599  element = sfi_rec_forced_get (sfi_rec, "tick_stamp", SFI_TYPE_NUM);
1600  sfi_value_set_num (element, rec->tick_stamp);
1601  element = sfi_rec_forced_get (sfi_rec, "frequency", SFI_TYPE_REAL);
1602  sfi_value_set_real (element, rec->frequency);
1603  element = sfi_rec_forced_get (sfi_rec, "velocity", SFI_TYPE_REAL);
1604  sfi_value_set_real (element, rec->velocity);
1605  element = sfi_rec_forced_get (sfi_rec, "control", SFI_TYPE_INT);
1606  sfi_value_set_int (element, rec->control);
1607  element = sfi_rec_forced_get (sfi_rec, "value", SFI_TYPE_REAL);
1608  sfi_value_set_real (element, rec->value);
1609  element = sfi_rec_forced_get (sfi_rec, "program", SFI_TYPE_INT);
1610  sfi_value_set_int (element, rec->program);
1611  element = sfi_rec_forced_get (sfi_rec, "intensity", SFI_TYPE_REAL);
1612  sfi_value_set_real (element, rec->intensity);
1613  element = sfi_rec_forced_get (sfi_rec, "pitch_bend", SFI_TYPE_REAL);
1614  sfi_value_set_real (element, rec->pitch_bend);
1615  element = sfi_rec_forced_get (sfi_rec, "song_pointer", SFI_TYPE_INT);
1616  sfi_value_set_int (element, rec->song_pointer);
1617  element = sfi_rec_forced_get (sfi_rec, "song_number", SFI_TYPE_INT);
1618  sfi_value_set_int (element, rec->song_number);
1619  return sfi_rec;
1620 }
1621 
1622 ::Bse::MidiChannelEventHandle
1623 MidiChannelEvent::value_get_boxed (const GValue *value)
1624 {
1625  return ::Bse::MidiChannelEventHandle::value_get_boxed (value);
1626 }
1627 
1628 void
1629 MidiChannelEvent::value_set_boxed (GValue *value, const ::Bse::MidiChannelEventHandle & self)
1630 {
1631  ::Bse::MidiChannelEventHandle::value_set_boxed (value, self);
1632 }
1633 
1635 MidiChannelEvent::get_fields()
1636 {
1637  static SfiRecFields rfields = { 0, NULL };
1638  if (!rfields.n_fields)
1639  {
1640  static GParamSpec *fields[12 + 1];
1641  rfields.n_fields = 12;
1642  fields[0] = sfidl_pspec_Choice_default (NULL,"/opt/src/beast/bse/bsebasics.idl",304, "event_type", Bse::MidiChannelEventType_choice_values());
1643  fields[1] = sfidl_pspec_SfiInt (NULL,"/opt/src/beast/bse/bsebasics.idl",305,"channel","Channel" , "" , 0LL , 0LL , 99LL , 1LL , ":readwrite");
1644  fields[2] = sfidl_pspec_SfiNum (NULL,"/opt/src/beast/bse/bsebasics.idl",306,"tick_stamp","Time Stamp" , "" , 0LL , 0LL , SFI_MAXNUM , 0LL , ":r:w:S:G:");
1645  fields[3] = sfidl_pspec_Freq (NULL,"/opt/src/beast/bse/bsebasics.idl",308,"frequency","Frequency" , "" , KAMMER_FREQ , ":readwrite");
1646  fields[4] = sfidl_pspec_SfiReal (NULL,"/opt/src/beast/bse/bsebasics.idl",309,"velocity","Velocity" , "" , 1LL , 0LL , 1.00000000000000000e+00 , 1.00000000000000006e-01 , ":readwrite");
1647  fields[5] = sfidl_pspec_SfiInt (NULL,"/opt/src/beast/bse/bsebasics.idl",311,"control","Control Number" , "" , 0LL , 0LL , 1024LL , 8LL , ":readwrite");
1648  fields[6] = sfidl_pspec_SfiReal (NULL,"/opt/src/beast/bse/bsebasics.idl",312,"value","Value" , "" , 0LL , - 1LL , + 1LL , 1.00000000000000006e-01 , ":readwrite");
1649  fields[7] = sfidl_pspec_SfiInt (NULL,"/opt/src/beast/bse/bsebasics.idl",314,"program","Program" , "" , 0LL , 0LL , 127LL , 16LL , ":readwrite");
1650  fields[8] = sfidl_pspec_SfiReal (NULL,"/opt/src/beast/bse/bsebasics.idl",316,"intensity","Intensity" , "" , 0LL , 0LL , 1.00000000000000000e+00 , 1.00000000000000006e-01 , ":readwrite");
1651  fields[9] = sfidl_pspec_SfiReal (NULL,"/opt/src/beast/bse/bsebasics.idl",318,"pitch_bend","Pitch Bend" , "" , 0LL , - 1LL , + 1LL , 1.00000000000000006e-01 , ":readwrite");
1652  fields[10] = sfidl_pspec_SfiInt (NULL,"/opt/src/beast/bse/bsebasics.idl",320,"song_pointer","Song Pointer" , "" , 0LL , 0LL , 16383LL , 128LL , ":readwrite");
1653  fields[11] = sfidl_pspec_SfiInt (NULL,"/opt/src/beast/bse/bsebasics.idl",322,"song_number","Song Number" , "" , 0LL , 0LL , 127LL , 16LL , ":readwrite");
1654  rfields.fields = fields;
1655  }
1656  return rfields;
1657 }
1659 PropertyCandidates::from_rec (SfiRec *sfi_rec)
1660 {
1661  GValue *element;
1662 
1663  if (!sfi_rec)
1664  return Sfi::INIT_NULL;
1665 
1666  ::Bse::PropertyCandidatesHandle rec = Sfi::INIT_DEFAULT;
1667  element = sfi_rec_get (sfi_rec, "label");
1668  if (element)
1669  rec->label = ::Sfi::SfiString::value_get_string (element);
1670  element = sfi_rec_get (sfi_rec, "tooltip");
1671  if (element)
1672  rec->tooltip = ::Sfi::SfiString::value_get_string (element);
1673  element = sfi_rec_get (sfi_rec, "items");
1674  if (element)
1675  rec->items = ::Bse::ItemSeq::value_get_boxed (element);
1676  element = sfi_rec_get (sfi_rec, "partitions");
1677  if (element)
1678  rec->partitions = ::Bse::TypeSeq::value_get_boxed (element);
1679  return rec;
1680 }
1681 
1682 SfiRec *
1683 PropertyCandidates::to_rec (const ::Bse::PropertyCandidatesHandle & rec)
1684 {
1685  SfiRec *sfi_rec;
1686  GValue *element;
1687 
1688  if (!rec)
1689  return NULL;
1690 
1691  sfi_rec = sfi_rec_new ();
1692  element = sfi_rec_forced_get (sfi_rec, "label", SFI_TYPE_SFI_STRING);
1693  ::Sfi::SfiString::value_set_string (element, rec->label);
1694  element = sfi_rec_forced_get (sfi_rec, "tooltip", SFI_TYPE_SFI_STRING);
1695  ::Sfi::SfiString::value_set_string (element, rec->tooltip);
1696  element = sfi_rec_forced_get (sfi_rec, "items", SFI_TYPE_SEQ);
1697  ::Bse::ItemSeq::value_set_boxed (element, rec->items);
1698  element = sfi_rec_forced_get (sfi_rec, "partitions", SFI_TYPE_SEQ);
1699  ::Bse::TypeSeq::value_set_boxed (element, rec->partitions);
1700  return sfi_rec;
1701 }
1702 
1704 PropertyCandidates::value_get_boxed (const GValue *value)
1705 {
1706  return ::Bse::PropertyCandidatesHandle::value_get_boxed (value);
1707 }
1708 
1709 void
1710 PropertyCandidates::value_set_boxed (GValue *value, const ::Bse::PropertyCandidatesHandle & self)
1711 {
1712  ::Bse::PropertyCandidatesHandle::value_set_boxed (value, self);
1713 }
1714 
1716 PropertyCandidates::get_fields()
1717 {
1718  static SfiRecFields rfields = { 0, NULL };
1719  if (!rfields.n_fields)
1720  {
1721  static GParamSpec *fields[4 + 1];
1722  rfields.n_fields = 4;
1723  fields[0] = sfidl_pspec_SfiString_default (NULL,"/opt/src/beast/bse/bsebasics.idl",334,"label");
1724  fields[1] = sfidl_pspec_SfiString_default (NULL,"/opt/src/beast/bse/bsebasics.idl",335,"tooltip");
1725  fields[2] = sfidl_pspec_Sequence_default (NULL,"/opt/src/beast/bse/bsebasics.idl",336, "items", Bse::ItemSeq::get_element());
1726  fields[3] = sfidl_pspec_Sequence (NULL,"/opt/src/beast/bse/bsebasics.idl",337, "partitions", "Type Partitions" , "List of types which may logically partition the list of items by type discrimination" , ":r:w:S:G:", Bse::TypeSeq::get_element());
1727  rfields.fields = fields;
1728  }
1729  return rfields;
1730 }
1732 NoteDescription::from_rec (SfiRec *sfi_rec)
1733 {
1734  GValue *element;
1735 
1736  if (!sfi_rec)
1737  return Sfi::INIT_NULL;
1738 
1739  ::Bse::NoteDescriptionHandle rec = Sfi::INIT_DEFAULT;
1740  element = sfi_rec_get (sfi_rec, "musical_tuning");
1741  if (element)
1742  rec->musical_tuning = (::Bse::MusicalTuningType) sfi_value_get_enum_auto SFI_START_ARGS() BSE_TYPE_MUSICAL_TUNING_TYPE, SFI_END_ARGS1 (element);
1743  element = sfi_rec_get (sfi_rec, "note");
1744  if (element)
1745  rec->note = sfi_value_get_int (element);
1746  element = sfi_rec_get (sfi_rec, "octave");
1747  if (element)
1748  rec->octave = sfi_value_get_int (element);
1749  element = sfi_rec_get (sfi_rec, "freq");
1750  if (element)
1751  rec->freq = sfi_value_get_real (element);
1752  element = sfi_rec_get (sfi_rec, "fine_tune");
1753  if (element)
1754  rec->fine_tune = sfi_value_get_int (element);
1755  element = sfi_rec_get (sfi_rec, "semitone");
1756  if (element)
1757  rec->semitone = sfi_value_get_int (element);
1758  element = sfi_rec_get (sfi_rec, "upshift");
1759  if (element)
1760  rec->upshift = sfi_value_get_bool (element);
1761  element = sfi_rec_get (sfi_rec, "letter");
1762  if (element)
1763  rec->letter = sfi_value_get_int (element);
1764  element = sfi_rec_get (sfi_rec, "name");
1765  if (element)
1766  rec->name = ::Sfi::SfiString::value_get_string (element);
1767  element = sfi_rec_get (sfi_rec, "max_fine_tune");
1768  if (element)
1769  rec->max_fine_tune = sfi_value_get_int (element);
1770  element = sfi_rec_get (sfi_rec, "kammer_note");
1771  if (element)
1772  rec->kammer_note = sfi_value_get_int (element);
1773  return rec;
1774 }
1775 
1776 SfiRec *
1777 NoteDescription::to_rec (const ::Bse::NoteDescriptionHandle & rec)
1778 {
1779  SfiRec *sfi_rec;
1780  GValue *element;
1781 
1782  if (!rec)
1783  return NULL;
1784 
1785  sfi_rec = sfi_rec_new ();
1786  element = sfi_rec_forced_get (sfi_rec, "musical_tuning", SFI_TYPE_CHOICE);
1787  sfi_value_set_enum_auto SFI_START_ARGS() BSE_TYPE_MUSICAL_TUNING_TYPE, SFI_END_ARGS2 (element, rec->musical_tuning);
1788  element = sfi_rec_forced_get (sfi_rec, "note", SFI_TYPE_INT);
1789  sfi_value_set_int (element, rec->note);
1790  element = sfi_rec_forced_get (sfi_rec, "octave", SFI_TYPE_INT);
1791  sfi_value_set_int (element, rec->octave);
1792  element = sfi_rec_forced_get (sfi_rec, "freq", SFI_TYPE_REAL);
1793  sfi_value_set_real (element, rec->freq);
1794  element = sfi_rec_forced_get (sfi_rec, "fine_tune", SFI_TYPE_INT);
1795  sfi_value_set_int (element, rec->fine_tune);
1796  element = sfi_rec_forced_get (sfi_rec, "semitone", SFI_TYPE_INT);
1797  sfi_value_set_int (element, rec->semitone);
1798  element = sfi_rec_forced_get (sfi_rec, "upshift", SFI_TYPE_BOOL);
1799  sfi_value_set_bool (element, rec->upshift);
1800  element = sfi_rec_forced_get (sfi_rec, "letter", SFI_TYPE_INT);
1801  sfi_value_set_int (element, rec->letter);
1802  element = sfi_rec_forced_get (sfi_rec, "name", SFI_TYPE_SFI_STRING);
1803  ::Sfi::SfiString::value_set_string (element, rec->name);
1804  element = sfi_rec_forced_get (sfi_rec, "max_fine_tune", SFI_TYPE_INT);
1805  sfi_value_set_int (element, rec->max_fine_tune);
1806  element = sfi_rec_forced_get (sfi_rec, "kammer_note", SFI_TYPE_INT);
1807  sfi_value_set_int (element, rec->kammer_note);
1808  return sfi_rec;
1809 }
1810 
1811 ::Bse::NoteDescriptionHandle
1812 NoteDescription::value_get_boxed (const GValue *value)
1813 {
1814  return ::Bse::NoteDescriptionHandle::value_get_boxed (value);
1815 }
1816 
1817 void
1818 NoteDescription::value_set_boxed (GValue *value, const ::Bse::NoteDescriptionHandle & self)
1819 {
1820  ::Bse::NoteDescriptionHandle::value_set_boxed (value, self);
1821 }
1822 
1824 NoteDescription::get_fields()
1825 {
1826  static SfiRecFields rfields = { 0, NULL };
1827  if (!rfields.n_fields)
1828  {
1829  static GParamSpec *fields[11 + 1];
1830  rfields.n_fields = 11;
1831  fields[0] = sfidl_pspec_Choice_default (NULL,"/opt/src/beast/bse/bsebasics.idl",341, "musical_tuning", Bse::MusicalTuningType_choice_values());
1832  fields[1] = sfidl_pspec_Note (NULL,"/opt/src/beast/bse/bsebasics.idl",342,"note","Note" , "" , KAMMER_NOTE , ":readwrite");
1833  fields[2] = sfidl_pspec_Octave (NULL,"/opt/src/beast/bse/bsebasics.idl",343,"octave","Octave" , "" , KAMMER_OCTAVE , ":readwrite");
1834  fields[3] = sfidl_pspec_Freq (NULL,"/opt/src/beast/bse/bsebasics.idl",344,"freq","Frequency" , "" , KAMMER_FREQ , ":readwrite");
1835  fields[4] = sfidl_pspec_FineTune (NULL,"/opt/src/beast/bse/bsebasics.idl",345,"fine_tune","Fine Tune" , "" , ":readwrite");
1836  fields[5] = sfidl_pspec_SfiInt (NULL,"/opt/src/beast/bse/bsebasics.idl",346,"semitone","Semitone" , "" , 0LL , 0LL , 11LL , 1LL , ":readwrite");
1837  fields[6] = sfidl_pspec_Bool_default (NULL,"/opt/src/beast/bse/bsebasics.idl",347,"upshift");
1838  fields[7] = sfidl_pspec_SfiInt (NULL,"/opt/src/beast/bse/bsebasics.idl",348,"letter","Letter" , "International abbreviation letter for this note" , 64LL , 32LL , 126LL , 1LL , ":readwrite");
1839  fields[8] = sfidl_pspec_SfiString (NULL,"/opt/src/beast/bse/bsebasics.idl",349,"name","Name" , "" , "" , ":readwrite");
1840  fields[9] = sfidl_pspec_SfiInt (NULL,"/opt/src/beast/bse/bsebasics.idl",351,"max_fine_tune","Max Fine Tune" , "" , MAX_FINE_TUNE , MAX_FINE_TUNE , MAX_FINE_TUNE , 0LL , ":readable");
1841  fields[10] = sfidl_pspec_SfiInt (NULL,"/opt/src/beast/bse/bsebasics.idl",352,"kammer_note","Kammer Note" , "" , KAMMER_NOTE , KAMMER_NOTE , KAMMER_NOTE , 0LL , ":readable");
1842  rfields.fields = fields;
1843  }
1844  return rfields;
1845 }
1847 NoteSequence::from_rec (SfiRec *sfi_rec)
1848 {
1849  GValue *element;
1850 
1851  if (!sfi_rec)
1852  return Sfi::INIT_NULL;
1853 
1854  ::Bse::NoteSequenceHandle rec = Sfi::INIT_DEFAULT;
1855  element = sfi_rec_get (sfi_rec, "offset");
1856  if (element)
1857  rec->offset = sfi_value_get_int (element);
1858  element = sfi_rec_get (sfi_rec, "notes");
1859  if (element)
1860  rec->notes = ::Bse::NoteSeq::value_get_boxed (element);
1861  return rec;
1862 }
1863 
1864 SfiRec *
1865 NoteSequence::to_rec (const ::Bse::NoteSequenceHandle & rec)
1866 {
1867  SfiRec *sfi_rec;
1868  GValue *element;
1869 
1870  if (!rec)
1871  return NULL;
1872 
1873  sfi_rec = sfi_rec_new ();
1874  element = sfi_rec_forced_get (sfi_rec, "offset", SFI_TYPE_INT);
1875  sfi_value_set_int (element, rec->offset);
1876  element = sfi_rec_forced_get (sfi_rec, "notes", SFI_TYPE_SEQ);
1877  ::Bse::NoteSeq::value_set_boxed (element, rec->notes);
1878  return sfi_rec;
1879 }
1880 
1882 NoteSequence::value_get_boxed (const GValue *value)
1883 {
1884  return ::Bse::NoteSequenceHandle::value_get_boxed (value);
1885 }
1886 
1887 void
1888 NoteSequence::value_set_boxed (GValue *value, const ::Bse::NoteSequenceHandle & self)
1889 {
1890  ::Bse::NoteSequenceHandle::value_set_boxed (value, self);
1891 }
1892 
1894 NoteSequence::get_fields()
1895 {
1896  static SfiRecFields rfields = { 0, NULL };
1897  if (!rfields.n_fields)
1898  {
1899  static GParamSpec *fields[2 + 1];
1900  rfields.n_fields = 2;
1901  fields[0] = sfidl_pspec_Note (NULL,"/opt/src/beast/bse/bsebasics.idl",360,"offset","Note Offset" , "Center/base note" , KAMMER_NOTE , ":readwrite");
1902  fields[1] = sfidl_pspec_Sequence (NULL,"/opt/src/beast/bse/bsebasics.idl",361, "notes", "Notes" , "Sequence of notes" , ":readwrite", Bse::NoteSeq::get_element());
1903  rfields.fields = fields;
1904  }
1905  return rfields;
1906 }
1908 Icon::from_rec (SfiRec *sfi_rec)
1909 {
1910  GValue *element;
1911 
1912  if (!sfi_rec)
1913  return Sfi::INIT_NULL;
1914 
1915  ::Bse::IconHandle rec = Sfi::INIT_DEFAULT;
1916  element = sfi_rec_get (sfi_rec, "width");
1917  if (element)
1918  rec->width = sfi_value_get_int (element);
1919  element = sfi_rec_get (sfi_rec, "height");
1920  if (element)
1921  rec->height = sfi_value_get_int (element);
1922  element = sfi_rec_get (sfi_rec, "pixel_seq");
1923  if (element)
1924  rec->pixel_seq = ::Bse::PixelSeq::value_get_boxed (element);
1925  return rec;
1926 }
1927 
1928 SfiRec *
1929 Icon::to_rec (const ::Bse::IconHandle & rec)
1930 {
1931  SfiRec *sfi_rec;
1932  GValue *element;
1933 
1934  if (!rec)
1935  return NULL;
1936 
1937  sfi_rec = sfi_rec_new ();
1938  element = sfi_rec_forced_get (sfi_rec, "width", SFI_TYPE_INT);
1939  sfi_value_set_int (element, rec->width);
1940  element = sfi_rec_forced_get (sfi_rec, "height", SFI_TYPE_INT);
1941  sfi_value_set_int (element, rec->height);
1942  element = sfi_rec_forced_get (sfi_rec, "pixel_seq", SFI_TYPE_SEQ);
1943  ::Bse::PixelSeq::value_set_boxed (element, rec->pixel_seq);
1944  return sfi_rec;
1945 }
1946 
1948 Icon::value_get_boxed (const GValue *value)
1949 {
1950  return ::Bse::IconHandle::value_get_boxed (value);
1951 }
1952 
1953 void
1954 Icon::value_set_boxed (GValue *value, const ::Bse::IconHandle & self)
1955 {
1956  ::Bse::IconHandle::value_set_boxed (value, self);
1957 }
1958 
1960 Icon::get_fields()
1961 {
1962  static SfiRecFields rfields = { 0, NULL };
1963  if (!rfields.n_fields)
1964  {
1965  static GParamSpec *fields[3 + 1];
1966  rfields.n_fields = 3;
1967  fields[0] = sfidl_pspec_SfiInt (NULL,"/opt/src/beast/bse/bsebasics.idl",369,"width","Width" , "Width in pixels or 0 for no icon" , 0LL , 0LL , 2147483647LL , 1LL , ":readwrite");
1968  fields[1] = sfidl_pspec_SfiInt (NULL,"/opt/src/beast/bse/bsebasics.idl",370,"height","Height" , "Height in pixels or 0 for no icon" , 0LL , 0LL , 2147483647LL , 1LL , ":readwrite");
1969  fields[2] = sfidl_pspec_Sequence (NULL,"/opt/src/beast/bse/bsebasics.idl",371, "pixel_seq", "Pixels" , "Pixel array of width*height ARGB pixels" , ":readwrite", Bse::PixelSeq::get_element());
1970  rfields.fields = fields;
1971  }
1972  return rfields;
1973 }
1975 Category::from_rec (SfiRec *sfi_rec)
1976 {
1977  GValue *element;
1978 
1979  if (!sfi_rec)
1980  return Sfi::INIT_NULL;
1981 
1982  ::Bse::CategoryHandle rec = Sfi::INIT_DEFAULT;
1983  element = sfi_rec_get (sfi_rec, "category_id");
1984  if (element)
1985  rec->category_id = sfi_value_get_int (element);
1986  element = sfi_rec_get (sfi_rec, "category");
1987  if (element)
1988  rec->category = ::Sfi::SfiString::value_get_string (element);
1989  element = sfi_rec_get (sfi_rec, "mindex");
1990  if (element)
1991  rec->mindex = sfi_value_get_int (element);
1992  element = sfi_rec_get (sfi_rec, "lindex");
1993  if (element)
1994  rec->lindex = sfi_value_get_int (element);
1995  element = sfi_rec_get (sfi_rec, "type");
1996  if (element)
1997  rec->type = ::Sfi::SfiString::value_get_string (element);
1998  element = sfi_rec_get (sfi_rec, "icon");
1999  if (element)
2000  rec->icon = ::Bse::Icon::value_get_boxed (element);
2001  return rec;
2002 }
2003 
2004 SfiRec *
2005 Category::to_rec (const ::Bse::CategoryHandle & rec)
2006 {
2007  SfiRec *sfi_rec;
2008  GValue *element;
2009 
2010  if (!rec)
2011  return NULL;
2012 
2013  sfi_rec = sfi_rec_new ();
2014  element = sfi_rec_forced_get (sfi_rec, "category_id", SFI_TYPE_INT);
2015  sfi_value_set_int (element, rec->category_id);
2016  element = sfi_rec_forced_get (sfi_rec, "category", SFI_TYPE_SFI_STRING);
2017  ::Sfi::SfiString::value_set_string (element, rec->category);
2018  element = sfi_rec_forced_get (sfi_rec, "mindex", SFI_TYPE_INT);
2019  sfi_value_set_int (element, rec->mindex);
2020  element = sfi_rec_forced_get (sfi_rec, "lindex", SFI_TYPE_INT);
2021  sfi_value_set_int (element, rec->lindex);
2022  element = sfi_rec_forced_get (sfi_rec, "type", SFI_TYPE_SFI_STRING);
2023  ::Sfi::SfiString::value_set_string (element, rec->type);
2024  element = sfi_rec_forced_get (sfi_rec, "icon", SFI_TYPE_REC);
2025  ::Bse::Icon::value_set_boxed (element, rec->icon);
2026  return sfi_rec;
2027 }
2028 
2030 Category::value_get_boxed (const GValue *value)
2031 {
2032  return ::Bse::CategoryHandle::value_get_boxed (value);
2033 }
2034 
2035 void
2036 Category::value_set_boxed (GValue *value, const ::Bse::CategoryHandle & self)
2037 {
2038  ::Bse::CategoryHandle::value_set_boxed (value, self);
2039 }
2040 
2042 Category::get_fields()
2043 {
2044  static SfiRecFields rfields = { 0, NULL };
2045  if (!rfields.n_fields)
2046  {
2047  static GParamSpec *fields[6 + 1];
2048  rfields.n_fields = 6;
2049  fields[0] = sfidl_pspec_SfiInt (NULL,"/opt/src/beast/bse/bsebasics.idl",375,"category_id","Category ID" , "" , 1LL , 1LL , G_MAXINT , 1LL , ":readwrite");
2050  fields[1] = sfidl_pspec_SfiString_default (NULL,"/opt/src/beast/bse/bsebasics.idl",376,"category");
2051  fields[2] = sfidl_pspec_Int_default (NULL,"/opt/src/beast/bse/bsebasics.idl",377,"mindex");
2052  fields[3] = sfidl_pspec_Int_default (NULL,"/opt/src/beast/bse/bsebasics.idl",378,"lindex");
2053  fields[4] = sfidl_pspec_SfiString_default (NULL,"/opt/src/beast/bse/bsebasics.idl",379,"type");
2054  fields[5] = sfidl_pspec_Record_default (NULL,"/opt/src/beast/bse/bsebasics.idl",380, "icon", Bse::Icon::get_fields());
2055  rfields.fields = fields;
2056  }
2057  return rfields;
2058 }
2060 Dot::from_rec (SfiRec *sfi_rec)
2061 {
2062  GValue *element;
2063 
2064  if (!sfi_rec)
2065  return Sfi::INIT_NULL;
2066 
2067  ::Bse::DotHandle rec = Sfi::INIT_DEFAULT;
2068  element = sfi_rec_get (sfi_rec, "x");
2069  if (element)
2070  rec->x = sfi_value_get_real (element);
2071  element = sfi_rec_get (sfi_rec, "y");
2072  if (element)
2073  rec->y = sfi_value_get_real (element);
2074  return rec;
2075 }
2076 
2077 SfiRec *
2078 Dot::to_rec (const ::Bse::DotHandle & rec)
2079 {
2080  SfiRec *sfi_rec;
2081  GValue *element;
2082 
2083  if (!rec)
2084  return NULL;
2085 
2086  sfi_rec = sfi_rec_new ();
2087  element = sfi_rec_forced_get (sfi_rec, "x", SFI_TYPE_REAL);
2088  sfi_value_set_real (element, rec->x);
2089  element = sfi_rec_forced_get (sfi_rec, "y", SFI_TYPE_REAL);
2090  sfi_value_set_real (element, rec->y);
2091  return sfi_rec;
2092 }
2093 
2095 Dot::value_get_boxed (const GValue *value)
2096 {
2097  return ::Bse::DotHandle::value_get_boxed (value);
2098 }
2099 
2100 void
2101 Dot::value_set_boxed (GValue *value, const ::Bse::DotHandle & self)
2102 {
2103  ::Bse::DotHandle::value_set_boxed (value, self);
2104 }
2105 
2107 Dot::get_fields()
2108 {
2109  static SfiRecFields rfields = { 0, NULL };
2110  if (!rfields.n_fields)
2111  {
2112  static GParamSpec *fields[2 + 1];
2113  rfields.n_fields = 2;
2114  fields[0] = sfidl_pspec_Real_default (NULL,"/opt/src/beast/bse/bsebasics.idl",387,"x");
2115  fields[1] = sfidl_pspec_Real_default (NULL,"/opt/src/beast/bse/bsebasics.idl",388,"y");
2116  rfields.fields = fields;
2117  }
2118  return rfields;
2119 }
2121 TrackPart::from_rec (SfiRec *sfi_rec)
2122 {
2123  GValue *element;
2124 
2125  if (!sfi_rec)
2126  return Sfi::INIT_NULL;
2127 
2128  ::Bse::TrackPartHandle rec = Sfi::INIT_DEFAULT;
2129  element = sfi_rec_get (sfi_rec, "tick");
2130  if (element)
2131  rec->tick = sfi_value_get_int (element);
2132  element = sfi_rec_get (sfi_rec, "part");
2133  if (element)
2134  rec->part = ::Bse::CxxBase::value_get_gobject< BsePart> (element);
2135  element = sfi_rec_get (sfi_rec, "duration");
2136  if (element)
2137  rec->duration = sfi_value_get_int (element);
2138  return rec;
2139 }
2140 
2141 SfiRec *
2142 TrackPart::to_rec (const ::Bse::TrackPartHandle & rec)
2143 {
2144  SfiRec *sfi_rec;
2145  GValue *element;
2146 
2147  if (!rec)
2148  return NULL;
2149 
2150  sfi_rec = sfi_rec_new ();
2151  element = sfi_rec_forced_get (sfi_rec, "tick", SFI_TYPE_INT);
2152  sfi_value_set_int (element, rec->tick);
2153  element = sfi_rec_forced_get (sfi_rec, "part", SFI_TYPE_PROXY);
2154  ::Bse::CxxBase::value_set_gobject (element, rec->part);
2155  element = sfi_rec_forced_get (sfi_rec, "duration", SFI_TYPE_INT);
2156  sfi_value_set_int (element, rec->duration);
2157  return sfi_rec;
2158 }
2159 
2161 TrackPart::value_get_boxed (const GValue *value)
2162 {
2163  return ::Bse::TrackPartHandle::value_get_boxed (value);
2164 }
2165 
2166 void
2167 TrackPart::value_set_boxed (GValue *value, const ::Bse::TrackPartHandle & self)
2168 {
2169  ::Bse::TrackPartHandle::value_set_boxed (value, self);
2170 }
2171 
2173 TrackPart::get_fields()
2174 {
2175  static SfiRecFields rfields = { 0, NULL };
2176  if (!rfields.n_fields)
2177  {
2178  static GParamSpec *fields[3 + 1];
2179  rfields.n_fields = 3;
2180  fields[0] = sfidl_pspec_SfiInt (NULL,"/opt/src/beast/bse/bsebasics.idl",398,"tick","Tick" , "" , 0LL , 0LL , G_MAXINT , 384LL , ":r:w:S:G:");
2181  fields[1] = sfidl_pspec_Object_default (NULL,"/opt/src/beast/bse/bsebasics.idl",399,"part");
2182  fields[2] = sfidl_pspec_SfiInt (NULL,"/opt/src/beast/bse/bsebasics.idl",400,"duration","Duration" , "" , 0LL , 0LL , G_MAXINT , 384LL , ":r:w:S:G:");
2183  rfields.fields = fields;
2184  }
2185  return rfields;
2186 }
2188 SampleFileInfo::from_rec (SfiRec *sfi_rec)
2189 {
2190  GValue *element;
2191 
2192  if (!sfi_rec)
2193  return Sfi::INIT_NULL;
2194 
2195  ::Bse::SampleFileInfoHandle rec = Sfi::INIT_DEFAULT;
2196  element = sfi_rec_get (sfi_rec, "file");
2197  if (element)
2198  rec->file = ::Sfi::SfiString::value_get_string (element);
2199  element = sfi_rec_get (sfi_rec, "size");
2200  if (element)
2201  rec->size = sfi_value_get_int (element);
2202  element = sfi_rec_get (sfi_rec, "mtime");
2203  if (element)
2204  rec->mtime = sfi_value_get_num (element);
2205  element = sfi_rec_get (sfi_rec, "loader");
2206  if (element)
2207  rec->loader = ::Sfi::SfiString::value_get_string (element);
2208  element = sfi_rec_get (sfi_rec, "waves");
2209  if (element)
2210  rec->waves = ::Bse::StringSeq::value_get_boxed (element);
2211  element = sfi_rec_get (sfi_rec, "error");
2212  if (element)
2213  rec->error = sfi_value_get_int (element);
2214  return rec;
2215 }
2216 
2217 SfiRec *
2218 SampleFileInfo::to_rec (const ::Bse::SampleFileInfoHandle & rec)
2219 {
2220  SfiRec *sfi_rec;
2221  GValue *element;
2222 
2223  if (!rec)
2224  return NULL;
2225 
2226  sfi_rec = sfi_rec_new ();
2227  element = sfi_rec_forced_get (sfi_rec, "file", SFI_TYPE_SFI_STRING);
2228  ::Sfi::SfiString::value_set_string (element, rec->file);
2229  element = sfi_rec_forced_get (sfi_rec, "size", SFI_TYPE_INT);
2230  sfi_value_set_int (element, rec->size);
2231  element = sfi_rec_forced_get (sfi_rec, "mtime", SFI_TYPE_NUM);
2232  sfi_value_set_num (element, rec->mtime);
2233  element = sfi_rec_forced_get (sfi_rec, "loader", SFI_TYPE_SFI_STRING);
2234  ::Sfi::SfiString::value_set_string (element, rec->loader);
2235  element = sfi_rec_forced_get (sfi_rec, "waves", SFI_TYPE_SEQ);
2236  ::Bse::StringSeq::value_set_boxed (element, rec->waves);
2237  element = sfi_rec_forced_get (sfi_rec, "error", SFI_TYPE_INT);
2238  sfi_value_set_int (element, rec->error);
2239  return sfi_rec;
2240 }
2241 
2243 SampleFileInfo::value_get_boxed (const GValue *value)
2244 {
2245  return ::Bse::SampleFileInfoHandle::value_get_boxed (value);
2246 }
2247 
2248 void
2249 SampleFileInfo::value_set_boxed (GValue *value, const ::Bse::SampleFileInfoHandle & self)
2250 {
2251  ::Bse::SampleFileInfoHandle::value_set_boxed (value, self);
2252 }
2253 
2255 SampleFileInfo::get_fields()
2256 {
2257  static SfiRecFields rfields = { 0, NULL };
2258  if (!rfields.n_fields)
2259  {
2260  static GParamSpec *fields[6 + 1];
2261  rfields.n_fields = 6;
2262  fields[0] = sfidl_pspec_SfiString (NULL,"/opt/src/beast/bse/bsebasics.idl",406,"file","Filename" , "" , "" , ":r:w:S:G:");
2263  fields[1] = sfidl_pspec_SfiInt (NULL,"/opt/src/beast/bse/bsebasics.idl",407,"size","File Size" , "" , 0LL , 0LL , G_MAXINT , 0LL , ":r:w:S:G:");
2264  fields[2] = sfidl_pspec_SfiNum (NULL,"/opt/src/beast/bse/bsebasics.idl",408,"mtime","Modification Time" , "" , 0LL , 0LL , SFI_MAXNUM , 0LL , ":r:w:S:G:");
2265  fields[3] = sfidl_pspec_SfiString (NULL,"/opt/src/beast/bse/bsebasics.idl",409,"loader","Loader" , "" , "" , ":r:w:S:G:");
2266  fields[4] = sfidl_pspec_Sequence (NULL,"/opt/src/beast/bse/bsebasics.idl",410, "waves", "" , "" , ":r:w:S:G:", Bse::StringSeq::get_element());
2267  fields[5] = sfidl_pspec_SfiInt (NULL,"/opt/src/beast/bse/bsebasics.idl",411,"error","BseErrorType" , "" , 0LL , 0LL , G_MAXINT , 0LL , ":r:w:S:G:");
2268  rfields.fields = fields;
2269  }
2270  return rfields;
2271 }
2273 GConfig::from_rec (SfiRec *sfi_rec)
2274 {
2275  GValue *element;
2276 
2277  if (!sfi_rec)
2278  return Sfi::INIT_NULL;
2279 
2280  ::Bse::GConfigHandle rec = Sfi::INIT_DEFAULT;
2281  element = sfi_rec_get (sfi_rec, "synth_latency");
2282  if (element)
2283  rec->synth_latency = sfi_value_get_int (element);
2284  element = sfi_rec_get (sfi_rec, "synth_mixing_freq");
2285  if (element)
2286  rec->synth_mixing_freq = sfi_value_get_int (element);
2287  element = sfi_rec_get (sfi_rec, "synth_control_freq");
2288  if (element)
2289  rec->synth_control_freq = sfi_value_get_int (element);
2290  element = sfi_rec_get (sfi_rec, "invert_sustain");
2291  if (element)
2292  rec->invert_sustain = sfi_value_get_bool (element);
2293  element = sfi_rec_get (sfi_rec, "author_default");
2294  if (element)
2295  rec->author_default = ::Sfi::SfiString::value_get_string (element);
2296  element = sfi_rec_get (sfi_rec, "license_default");
2297  if (element)
2298  rec->license_default = ::Sfi::SfiString::value_get_string (element);
2299  element = sfi_rec_get (sfi_rec, "sample_path");
2300  if (element)
2301  rec->sample_path = ::Sfi::SfiString::value_get_string (element);
2302  element = sfi_rec_get (sfi_rec, "effect_path");
2303  if (element)
2304  rec->effect_path = ::Sfi::SfiString::value_get_string (element);
2305  element = sfi_rec_get (sfi_rec, "instrument_path");
2306  if (element)
2307  rec->instrument_path = ::Sfi::SfiString::value_get_string (element);
2308  element = sfi_rec_get (sfi_rec, "script_path");
2309  if (element)
2310  rec->script_path = ::Sfi::SfiString::value_get_string (element);
2311  element = sfi_rec_get (sfi_rec, "plugin_path");
2312  if (element)
2313  rec->plugin_path = ::Sfi::SfiString::value_get_string (element);
2314  element = sfi_rec_get (sfi_rec, "ladspa_path");
2315  if (element)
2316  rec->ladspa_path = ::Sfi::SfiString::value_get_string (element);
2317  return rec;
2318 }
2319 
2320 SfiRec *
2321 GConfig::to_rec (const ::Bse::GConfigHandle & rec)
2322 {
2323  SfiRec *sfi_rec;
2324  GValue *element;
2325 
2326  if (!rec)
2327  return NULL;
2328 
2329  sfi_rec = sfi_rec_new ();
2330  element = sfi_rec_forced_get (sfi_rec, "synth_latency", SFI_TYPE_INT);
2331  sfi_value_set_int (element, rec->synth_latency);
2332  element = sfi_rec_forced_get (sfi_rec, "synth_mixing_freq", SFI_TYPE_INT);
2333  sfi_value_set_int (element, rec->synth_mixing_freq);
2334  element = sfi_rec_forced_get (sfi_rec, "synth_control_freq", SFI_TYPE_INT);
2335  sfi_value_set_int (element, rec->synth_control_freq);
2336  element = sfi_rec_forced_get (sfi_rec, "invert_sustain", SFI_TYPE_BOOL);
2337  sfi_value_set_bool (element, rec->invert_sustain);
2338  element = sfi_rec_forced_get (sfi_rec, "author_default", SFI_TYPE_SFI_STRING);
2339  ::Sfi::SfiString::value_set_string (element, rec->author_default);
2340  element = sfi_rec_forced_get (sfi_rec, "license_default", SFI_TYPE_SFI_STRING);
2341  ::Sfi::SfiString::value_set_string (element, rec->license_default);
2342  element = sfi_rec_forced_get (sfi_rec, "sample_path", SFI_TYPE_SFI_STRING);
2343  ::Sfi::SfiString::value_set_string (element, rec->sample_path);
2344  element = sfi_rec_forced_get (sfi_rec, "effect_path", SFI_TYPE_SFI_STRING);
2345  ::Sfi::SfiString::value_set_string (element, rec->effect_path);
2346  element = sfi_rec_forced_get (sfi_rec, "instrument_path", SFI_TYPE_SFI_STRING);
2347  ::Sfi::SfiString::value_set_string (element, rec->instrument_path);
2348  element = sfi_rec_forced_get (sfi_rec, "script_path", SFI_TYPE_SFI_STRING);
2349  ::Sfi::SfiString::value_set_string (element, rec->script_path);
2350  element = sfi_rec_forced_get (sfi_rec, "plugin_path", SFI_TYPE_SFI_STRING);
2351  ::Sfi::SfiString::value_set_string (element, rec->plugin_path);
2352  element = sfi_rec_forced_get (sfi_rec, "ladspa_path", SFI_TYPE_SFI_STRING);
2353  ::Sfi::SfiString::value_set_string (element, rec->ladspa_path);
2354  return sfi_rec;
2355 }
2356 
2358 GConfig::value_get_boxed (const GValue *value)
2359 {
2360  return ::Bse::GConfigHandle::value_get_boxed (value);
2361 }
2362 
2363 void
2364 GConfig::value_set_boxed (GValue *value, const ::Bse::GConfigHandle & self)
2365 {
2366  ::Bse::GConfigHandle::value_set_boxed (value, self);
2367 }
2368 
2370 GConfig::get_fields()
2371 {
2372  static SfiRecFields rfields = { 0, NULL };
2373  if (!rfields.n_fields)
2374  {
2375  static GParamSpec *fields[12 + 1];
2376  rfields.n_fields = 12;
2377  fields[0] = sfidl_pspec_SfiInt (_("Synthesis Settings"),"/opt/src/beast/bse/bsebasics.idl",427,"synth_latency",_ ( "Latency [ms]" ) , _ ( "Processing duration between input and output of a single sample, smaller values increase CPU load" ) , 50LL , 1LL , 2000LL , 5LL , ":r:w:S:G:");
2378  fields[1] = sfidl_pspec_SfiInt (_("Synthesis Settings"),"/opt/src/beast/bse/bsebasics.idl",431,"synth_mixing_freq",_ ( "Synth Mixing Frequency" ) , _ ( "Synthesis mixing frequency, common values are: 22050, 44100, 48000" ) , 44100LL , 8000LL , 192000LL , 0LL , ":r:w:S:G:");
2379  fields[2] = sfidl_pspec_SfiInt (_("Synthesis Settings"),"/opt/src/beast/bse/bsebasics.idl",435,"synth_control_freq",_ ( "Synth Control Frequency" ) , _ ( "Frequency at which control values are evaluated, " "should be much smaller than Synth Mixing Frequency to reduce CPU load" ) , 1000LL , 1LL , 192000LL , 0LL , ":r:w:S:G:");
2380  fields[3] = sfidl_pspec_SfiBool (_("MIDI"),"/opt/src/beast/bse/bsebasics.idl",442,"invert_sustain",_ ( "Invert Sustain Pedal" ) , _ ( "Invert the state of sustain (damper) pedal so on/off meanings are reversed" ) , FALSE , ":r:w:S:G:");
2381  fields[4] = sfidl_pspec_SfiString (_("Default Values"),"/opt/src/beast/bse/bsebasics.idl",447,"author_default",_ ( "Default Author" ) , _ ( "Default value for 'Author' fields" ) , "\357\277\271\357\277\272{{bse.idl/default-author}}\357\277\273" , ":r:w:S:G:");
2382  fields[5] = sfidl_pspec_SfiString (_("Default Values"),"/opt/src/beast/bse/bsebasics.idl",449,"license_default",_ ( "Default License" ) , _ ( "Default value for 'License' fields" ) , "\357\277\271\357\277\272{{bse.idl/default-license}}\357\277\273" , ":r:w:S:G:");
2383  fields[6] = sfidl_pspec_SfiString (_("Search Paths"),"/opt/src/beast/bse/bsebasics.idl",453,"sample_path",_ ( "Sample Path" ) , _ ( "Search path of directories, seperated by \";\", used to find audio samples." ) , "\357\277\271\357\277\272{{bse.idl/user-data-path}}\357\277\273samples" , ":r:w:S:G:" ":searchpath");
2384  fields[7] = sfidl_pspec_SfiString (_("Search Paths"),"/opt/src/beast/bse/bsebasics.idl",456,"effect_path",_ ( "Effect Path" ) , _ ( "Search path of directories, seperated by \";\", used to find BSE effect files." ) , "\357\277\271\357\277\272{{bse.idl/user-data-path}}\357\277\273effects" , ":r:w:S:G:" ":searchpath");
2385  fields[8] = sfidl_pspec_SfiString (_("Search Paths"),"/opt/src/beast/bse/bsebasics.idl",459,"instrument_path",_ ( "Instrument Path" ) , _ ( "Search path of directories, seperated by \";\", used to find BSE instrument files." ) , "\357\277\271\357\277\272{{bse.idl/user-data-path}}\357\277\273instruments" , ":r:w:S:G:" ":searchpath");
2386  fields[9] = sfidl_pspec_SfiString (_("Search Paths"),"/opt/src/beast/bse/bsebasics.idl",462,"script_path",_ ( "Script Path" ) , _ ( "Search path of directories, seperated by \";\", used to find BSE scheme scripts." ) , "\357\277\271\357\277\272{{bse.idl/user-data-path}}\357\277\273scripts" , ":r:w:S:G:" ":searchpath");
2387  fields[10] = sfidl_pspec_SfiString (_("Search Paths"),"/opt/src/beast/bse/bsebasics.idl",465,"plugin_path",_ ( "Plugin Path" ) , _ ( "Search path of directories, seperated by \";\", used to find BSE plugins. This path " "is searched for in addition to the standard BSE plugin location on this system." ) , "\357\277\271\357\277\272{{bse.idl/user-data-path}}\357\277\273plugins" , ":r:w:S:G:" ":searchpath");
2388  fields[11] = sfidl_pspec_SfiString (_("Search Paths"),"/opt/src/beast/bse/bsebasics.idl",469,"ladspa_path",_ ( "LADSPA Path" ) , _ ( "Search path of directories, seperated by \";\", used to find LADSPA plugins. This " "path is searched for in addition to the standard LADSPA location on this system. " "LADSPA is the Linux Audio Developer's Simple Plugin API, more informations about " "LADSPA plugins can be found at http://www.ladspa.org/." ) , "" , ":r:w:S:G:" ":searchpath");
2389  rfields.fields = fields;
2390  }
2391  return rfields;
2392 }
2393 
2394 
2395 /* sequence implementations */
2397 IntSeq::from_seq (SfiSeq *sfi_seq)
2398 {
2399  ::Bse::IntSeq cseq;
2400  guint i, length;
2401 
2402  if (!sfi_seq)
2403  return cseq;
2404 
2405  length = sfi_seq_length (sfi_seq);
2406  cseq.resize (length);
2407  for (i = 0; i < length; i++)
2408  {
2409  GValue *element = sfi_seq_get (sfi_seq, i);
2410  cseq[i] = sfi_value_get_int (element);
2411  }
2412  return cseq;
2413 }
2414 
2415 SfiSeq *
2416 IntSeq::to_seq (const ::Bse::IntSeq & cseq)
2417 {
2418  SfiSeq *sfi_seq = sfi_seq_new ();
2419  for (guint i = 0; i < cseq.length(); i++)
2420  {
2421  GValue *element = sfi_seq_append_empty (sfi_seq, SFI_TYPE_INT);
2422  sfi_value_set_int (element, cseq[i]);
2423  }
2424  return sfi_seq;
2425 }
2426 
2428 IntSeq::value_get_boxed (const GValue *value)
2429 {
2430  return ::Sfi::cxx_value_get_boxed_sequence< IntSeq> (value);
2431 }
2432 
2433 void
2434 IntSeq::value_set_boxed (GValue *value, const ::Bse::IntSeq & self)
2435 {
2436  ::Sfi::cxx_value_set_boxed_sequence< IntSeq> (value, self);
2437 }
2438 
2439 GParamSpec*
2440 IntSeq::get_element()
2441 {
2442  static GParamSpec *element = NULL;
2443  if (!element) {
2444  element = g_param_spec_ref (sfidl_pspec_Int_default (NULL,"/opt/src/beast/bse/bsebasics.idl",24,"ints"));
2445  g_param_spec_sink (element);
2446  }
2447  return element;
2448 }
2449 
2451 TypeSeq::from_seq (SfiSeq *sfi_seq)
2452 {
2453  ::Bse::TypeSeq cseq;
2454  guint i, length;
2455 
2456  if (!sfi_seq)
2457  return cseq;
2458 
2459  length = sfi_seq_length (sfi_seq);
2460  cseq.resize (length);
2461  for (i = 0; i < length; i++)
2462  {
2463  GValue *element = sfi_seq_get (sfi_seq, i);
2464  cseq[i] = ::Sfi::SfiString::value_get_string (element);
2465  }
2466  return cseq;
2467 }
2468 
2469 SfiSeq *
2470 TypeSeq::to_seq (const ::Bse::TypeSeq & cseq)
2471 {
2472  SfiSeq *sfi_seq = sfi_seq_new ();
2473  for (guint i = 0; i < cseq.length(); i++)
2474  {
2475  GValue *element = sfi_seq_append_empty (sfi_seq, SFI_TYPE_SFI_STRING);
2476  ::Sfi::SfiString::value_set_string (element, cseq[i]);
2477  }
2478  return sfi_seq;
2479 }
2480 
2482 TypeSeq::value_get_boxed (const GValue *value)
2483 {
2484  return ::Sfi::cxx_value_get_boxed_sequence< TypeSeq> (value);
2485 }
2486 
2487 void
2488 TypeSeq::value_set_boxed (GValue *value, const ::Bse::TypeSeq & self)
2489 {
2490  ::Sfi::cxx_value_set_boxed_sequence< TypeSeq> (value, self);
2491 }
2492 
2493 GParamSpec*
2494 TypeSeq::get_element()
2495 {
2496  static GParamSpec *element = NULL;
2497  if (!element) {
2498  element = g_param_spec_ref (sfidl_pspec_SfiString_default (NULL,"/opt/src/beast/bse/bsebasics.idl",27,"types"));
2499  g_param_spec_sink (element);
2500  }
2501  return element;
2502 }
2503 
2505 StringSeq::from_seq (SfiSeq *sfi_seq)
2506 {
2507  ::Bse::StringSeq cseq;
2508  guint i, length;
2509 
2510  if (!sfi_seq)
2511  return cseq;
2512 
2513  length = sfi_seq_length (sfi_seq);
2514  cseq.resize (length);
2515  for (i = 0; i < length; i++)
2516  {
2517  GValue *element = sfi_seq_get (sfi_seq, i);
2518  cseq[i] = ::Sfi::SfiString::value_get_string (element);
2519  }
2520  return cseq;
2521 }
2522 
2523 SfiSeq *
2524 StringSeq::to_seq (const ::Bse::StringSeq & cseq)
2525 {
2526  SfiSeq *sfi_seq = sfi_seq_new ();
2527  for (guint i = 0; i < cseq.length(); i++)
2528  {
2529  GValue *element = sfi_seq_append_empty (sfi_seq, SFI_TYPE_SFI_STRING);
2530  ::Sfi::SfiString::value_set_string (element, cseq[i]);
2531  }
2532  return sfi_seq;
2533 }
2534 
2536 StringSeq::value_get_boxed (const GValue *value)
2537 {
2538  return ::Sfi::cxx_value_get_boxed_sequence< StringSeq> (value);
2539 }
2540 
2541 void
2542 StringSeq::value_set_boxed (GValue *value, const ::Bse::StringSeq & self)
2543 {
2544  ::Sfi::cxx_value_set_boxed_sequence< StringSeq> (value, self);
2545 }
2546 
2547 GParamSpec*
2548 StringSeq::get_element()
2549 {
2550  static GParamSpec *element = NULL;
2551  if (!element) {
2552  element = g_param_spec_ref (sfidl_pspec_SfiString_default (NULL,"/opt/src/beast/bse/bsebasics.idl",30,"strings"));
2553  g_param_spec_sink (element);
2554  }
2555  return element;
2556 }
2557 
2559 FloatSeq::from_seq (SfiSeq *sfi_seq)
2560 {
2561  ::Bse::FloatSeq cseq;
2562  guint i, length;
2563 
2564  if (!sfi_seq)
2565  return cseq;
2566 
2567  length = sfi_seq_length (sfi_seq);
2568  cseq.resize (length);
2569  for (i = 0; i < length; i++)
2570  {
2571  GValue *element = sfi_seq_get (sfi_seq, i);
2572  cseq[i] = sfi_value_get_real (element);
2573  }
2574  return cseq;
2575 }
2576 
2577 SfiSeq *
2578 FloatSeq::to_seq (const ::Bse::FloatSeq & cseq)
2579 {
2580  SfiSeq *sfi_seq = sfi_seq_new ();
2581  for (guint i = 0; i < cseq.length(); i++)
2582  {
2583  GValue *element = sfi_seq_append_empty (sfi_seq, SFI_TYPE_REAL);
2584  sfi_value_set_real (element, cseq[i]);
2585  }
2586  return sfi_seq;
2587 }
2588 
2590 FloatSeq::value_get_boxed (const GValue *value)
2591 {
2592  return ::Sfi::cxx_value_get_boxed_sequence< FloatSeq> (value);
2593 }
2594 
2595 void
2596 FloatSeq::value_set_boxed (GValue *value, const ::Bse::FloatSeq & self)
2597 {
2598  ::Sfi::cxx_value_set_boxed_sequence< FloatSeq> (value, self);
2599 }
2600 
2601 GParamSpec*
2602 FloatSeq::get_element()
2603 {
2604  static GParamSpec *element = NULL;
2605  if (!element) {
2606  element = g_param_spec_ref (sfidl_pspec_Real_default (NULL,"/opt/src/beast/bse/bsebasics.idl",33,"values"));
2607  g_param_spec_sink (element);
2608  }
2609  return element;
2610 }
2611 
2613 NoteSeq::from_seq (SfiSeq *sfi_seq)
2614 {
2615  ::Bse::NoteSeq cseq;
2616  guint i, length;
2617 
2618  if (!sfi_seq)
2619  return cseq;
2620 
2621  length = sfi_seq_length (sfi_seq);
2622  cseq.resize (length);
2623  for (i = 0; i < length; i++)
2624  {
2625  GValue *element = sfi_seq_get (sfi_seq, i);
2626  cseq[i] = sfi_value_get_int (element);
2627  }
2628  return cseq;
2629 }
2630 
2631 SfiSeq *
2632 NoteSeq::to_seq (const ::Bse::NoteSeq & cseq)
2633 {
2634  SfiSeq *sfi_seq = sfi_seq_new ();
2635  for (guint i = 0; i < cseq.length(); i++)
2636  {
2637  GValue *element = sfi_seq_append_empty (sfi_seq, SFI_TYPE_INT);
2638  sfi_value_set_int (element, cseq[i]);
2639  }
2640  return sfi_seq;
2641 }
2642 
2644 NoteSeq::value_get_boxed (const GValue *value)
2645 {
2646  return ::Sfi::cxx_value_get_boxed_sequence< NoteSeq> (value);
2647 }
2648 
2649 void
2650 NoteSeq::value_set_boxed (GValue *value, const ::Bse::NoteSeq & self)
2651 {
2652  ::Sfi::cxx_value_set_boxed_sequence< NoteSeq> (value, self);
2653 }
2654 
2655 GParamSpec*
2656 NoteSeq::get_element()
2657 {
2658  static GParamSpec *element = NULL;
2659  if (!element) {
2660  element = g_param_spec_ref (sfidl_pspec_Note (NULL,"/opt/src/beast/bse/bsebasics.idl",325,"notes","Note" , "" , KAMMER_NOTE , ":readwrite"));
2661  g_param_spec_sink (element);
2662  }
2663  return element;
2664 }
2665 
2667 ItemSeq::from_seq (SfiSeq *sfi_seq)
2668 {
2669  ::Bse::ItemSeq cseq;
2670  guint i, length;
2671 
2672  if (!sfi_seq)
2673  return cseq;
2674 
2675  length = sfi_seq_length (sfi_seq);
2676  cseq.resize (length);
2677  for (i = 0; i < length; i++)
2678  {
2679  GValue *element = sfi_seq_get (sfi_seq, i);
2680  cseq[i] = ::Bse::CxxBase::value_get_gobject< BseItem> (element);
2681  }
2682  return cseq;
2683 }
2684 
2685 SfiSeq *
2686 ItemSeq::to_seq (const ::Bse::ItemSeq & cseq)
2687 {
2688  SfiSeq *sfi_seq = sfi_seq_new ();
2689  for (guint i = 0; i < cseq.length(); i++)
2690  {
2691  GValue *element = sfi_seq_append_empty (sfi_seq, SFI_TYPE_PROXY);
2692  ::Bse::CxxBase::value_set_gobject (element, cseq[i]);
2693  }
2694  return sfi_seq;
2695 }
2696 
2698 ItemSeq::value_get_boxed (const GValue *value)
2699 {
2700  return ::Sfi::cxx_value_get_boxed_sequence< ItemSeq> (value);
2701 }
2702 
2703 void
2704 ItemSeq::value_set_boxed (GValue *value, const ::Bse::ItemSeq & self)
2705 {
2706  ::Sfi::cxx_value_set_boxed_sequence< ItemSeq> (value, self);
2707 }
2708 
2709 GParamSpec*
2710 ItemSeq::get_element()
2711 {
2712  static GParamSpec *element = NULL;
2713  if (!element) {
2714  element = g_param_spec_ref (sfidl_pspec_Object_default (NULL,"/opt/src/beast/bse/bsebasics.idl",330,"items"));
2715  g_param_spec_sink (element);
2716  }
2717  return element;
2718 }
2719 
2721 PixelSeq::from_seq (SfiSeq *sfi_seq)
2722 {
2723  ::Bse::PixelSeq cseq;
2724  guint i, length;
2725 
2726  if (!sfi_seq)
2727  return cseq;
2728 
2729  length = sfi_seq_length (sfi_seq);
2730  cseq.resize (length);
2731  for (i = 0; i < length; i++)
2732  {
2733  GValue *element = sfi_seq_get (sfi_seq, i);
2734  cseq[i] = sfi_value_get_int (element);
2735  }
2736  return cseq;
2737 }
2738 
2739 SfiSeq *
2740 PixelSeq::to_seq (const ::Bse::PixelSeq & cseq)
2741 {
2742  SfiSeq *sfi_seq = sfi_seq_new ();
2743  for (guint i = 0; i < cseq.length(); i++)
2744  {
2745  GValue *element = sfi_seq_append_empty (sfi_seq, SFI_TYPE_INT);
2746  sfi_value_set_int (element, cseq[i]);
2747  }
2748  return sfi_seq;
2749 }
2750 
2752 PixelSeq::value_get_boxed (const GValue *value)
2753 {
2754  return ::Sfi::cxx_value_get_boxed_sequence< PixelSeq> (value);
2755 }
2756 
2757 void
2758 PixelSeq::value_set_boxed (GValue *value, const ::Bse::PixelSeq & self)
2759 {
2760  ::Sfi::cxx_value_set_boxed_sequence< PixelSeq> (value, self);
2761 }
2762 
2763 GParamSpec*
2764 PixelSeq::get_element()
2765 {
2766  static GParamSpec *element = NULL;
2767  if (!element) {
2768  element = g_param_spec_ref (sfidl_pspec_Int_default (NULL,"/opt/src/beast/bse/bsebasics.idl",364,"pixels"));
2769  g_param_spec_sink (element);
2770  }
2771  return element;
2772 }
2773 
2775 CategorySeq::from_seq (SfiSeq *sfi_seq)
2776 {
2777  ::Bse::CategorySeq cseq;
2778  guint i, length;
2779 
2780  if (!sfi_seq)
2781  return cseq;
2782 
2783  length = sfi_seq_length (sfi_seq);
2784  cseq.resize (length);
2785  for (i = 0; i < length; i++)
2786  {
2787  GValue *element = sfi_seq_get (sfi_seq, i);
2788  cseq[i] = ::Bse::Category::value_get_boxed (element);
2789  }
2790  return cseq;
2791 }
2792 
2793 SfiSeq *
2794 CategorySeq::to_seq (const ::Bse::CategorySeq & cseq)
2795 {
2796  SfiSeq *sfi_seq = sfi_seq_new ();
2797  for (guint i = 0; i < cseq.length(); i++)
2798  {
2799  GValue *element = sfi_seq_append_empty (sfi_seq, SFI_TYPE_REC);
2800  ::Bse::Category::value_set_boxed (element, cseq[i]);
2801  }
2802  return sfi_seq;
2803 }
2804 
2806 CategorySeq::value_get_boxed (const GValue *value)
2807 {
2808  return ::Sfi::cxx_value_get_boxed_sequence< CategorySeq> (value);
2809 }
2810 
2811 void
2812 CategorySeq::value_set_boxed (GValue *value, const ::Bse::CategorySeq & self)
2813 {
2814  ::Sfi::cxx_value_set_boxed_sequence< CategorySeq> (value, self);
2815 }
2816 
2817 GParamSpec*
2818 CategorySeq::get_element()
2819 {
2820  static GParamSpec *element = NULL;
2821  if (!element) {
2822  element = g_param_spec_ref (sfidl_pspec_Record_default (NULL,"/opt/src/beast/bse/bsebasics.idl",383, "cats", Bse::Category::get_fields()));
2823  g_param_spec_sink (element);
2824  }
2825  return element;
2826 }
2827 
2829 DotSeq::from_seq (SfiSeq *sfi_seq)
2830 {
2831  ::Bse::DotSeq cseq;
2832  guint i, length;
2833 
2834  if (!sfi_seq)
2835  return cseq;
2836 
2837  length = sfi_seq_length (sfi_seq);
2838  cseq.resize (length);
2839  for (i = 0; i < length; i++)
2840  {
2841  GValue *element = sfi_seq_get (sfi_seq, i);
2842  cseq[i] = ::Bse::Dot::value_get_boxed (element);
2843  }
2844  return cseq;
2845 }
2846 
2847 SfiSeq *
2848 DotSeq::to_seq (const ::Bse::DotSeq & cseq)
2849 {
2850  SfiSeq *sfi_seq = sfi_seq_new ();
2851  for (guint i = 0; i < cseq.length(); i++)
2852  {
2853  GValue *element = sfi_seq_append_empty (sfi_seq, SFI_TYPE_REC);
2854  ::Bse::Dot::value_set_boxed (element, cseq[i]);
2855  }
2856  return sfi_seq;
2857 }
2858 
2860 DotSeq::value_get_boxed (const GValue *value)
2861 {
2862  return ::Sfi::cxx_value_get_boxed_sequence< DotSeq> (value);
2863 }
2864 
2865 void
2866 DotSeq::value_set_boxed (GValue *value, const ::Bse::DotSeq & self)
2867 {
2868  ::Sfi::cxx_value_set_boxed_sequence< DotSeq> (value, self);
2869 }
2870 
2871 GParamSpec*
2872 DotSeq::get_element()
2873 {
2874  static GParamSpec *element = NULL;
2875  if (!element) {
2876  element = g_param_spec_ref (sfidl_pspec_Record_default (NULL,"/opt/src/beast/bse/bsebasics.idl",391, "dots", Bse::Dot::get_fields()));
2877  g_param_spec_sink (element);
2878  }
2879  return element;
2880 }
2881 
2883 TrackPartSeq::from_seq (SfiSeq *sfi_seq)
2884 {
2885  ::Bse::TrackPartSeq cseq;
2886  guint i, length;
2887 
2888  if (!sfi_seq)
2889  return cseq;
2890 
2891  length = sfi_seq_length (sfi_seq);
2892  cseq.resize (length);
2893  for (i = 0; i < length; i++)
2894  {
2895  GValue *element = sfi_seq_get (sfi_seq, i);
2896  cseq[i] = ::Bse::TrackPart::value_get_boxed (element);
2897  }
2898  return cseq;
2899 }
2900 
2901 SfiSeq *
2902 TrackPartSeq::to_seq (const ::Bse::TrackPartSeq & cseq)
2903 {
2904  SfiSeq *sfi_seq = sfi_seq_new ();
2905  for (guint i = 0; i < cseq.length(); i++)
2906  {
2907  GValue *element = sfi_seq_append_empty (sfi_seq, SFI_TYPE_REC);
2908  ::Bse::TrackPart::value_set_boxed (element, cseq[i]);
2909  }
2910  return sfi_seq;
2911 }
2912 
2914 TrackPartSeq::value_get_boxed (const GValue *value)
2915 {
2916  return ::Sfi::cxx_value_get_boxed_sequence< TrackPartSeq> (value);
2917 }
2918 
2919 void
2920 TrackPartSeq::value_set_boxed (GValue *value, const ::Bse::TrackPartSeq & self)
2921 {
2922  ::Sfi::cxx_value_set_boxed_sequence< TrackPartSeq> (value, self);
2923 }
2924 
2925 GParamSpec*
2926 TrackPartSeq::get_element()
2927 {
2928  static GParamSpec *element = NULL;
2929  if (!element) {
2930  element = g_param_spec_ref (sfidl_pspec_Record_default (NULL,"/opt/src/beast/bse/bsebasics.idl",403, "tparts", Bse::TrackPart::get_fields()));
2931  g_param_spec_sink (element);
2932  }
2933  return element;
2934 }
2935 
2936 
2937 
2938 /* class implementations */
2939 
2940 
2941 /* procedure implementations */
2942 
2943 
2944 /* bsebasics.idl type registrations */
2945 #define BSE_CXX_REGISTER_ALL_TYPES_FROM_BSEBASICS_IDL() \
2946  BSE_CXX_REGISTER_ENUM (MusicalTuningType); \
2947  BSE_CXX_REGISTER_ENUM (MidiControlType); \
2948  BSE_CXX_REGISTER_ENUM (MidiChannelEventType); \
2949  BSE_CXX_REGISTER_RECORD (MidiChannelEvent); \
2950  BSE_CXX_REGISTER_RECORD (PropertyCandidates); \
2951  BSE_CXX_REGISTER_RECORD (NoteDescription); \
2952  BSE_CXX_REGISTER_RECORD (NoteSequence); \
2953  BSE_CXX_REGISTER_RECORD (Icon); \
2954  BSE_CXX_REGISTER_RECORD (Category); \
2955  BSE_CXX_REGISTER_RECORD (Dot); \
2956  BSE_CXX_REGISTER_RECORD (TrackPart); \
2957  BSE_CXX_REGISTER_RECORD (SampleFileInfo); \
2958  BSE_CXX_REGISTER_RECORD (GConfig); \
2959  BSE_CXX_REGISTER_SEQUENCE (IntSeq); \
2960  BSE_CXX_REGISTER_SEQUENCE (TypeSeq); \
2961  BSE_CXX_REGISTER_SEQUENCE (StringSeq); \
2962  BSE_CXX_REGISTER_SEQUENCE (FloatSeq); \
2963  BSE_CXX_REGISTER_SEQUENCE (NoteSeq); \
2964  BSE_CXX_REGISTER_SEQUENCE (ItemSeq); \
2965  BSE_CXX_REGISTER_SEQUENCE (PixelSeq); \
2966  BSE_CXX_REGISTER_SEQUENCE (CategorySeq); \
2967  BSE_CXX_REGISTER_SEQUENCE (DotSeq); \
2968  BSE_CXX_REGISTER_SEQUENCE (TrackPartSeq); \
2969  /* bsebasics.idl type registrations done */
2970 } // Bse
2971 
2972 /*-------- end ../sfi/sfidl generated code --------*/
2973 
2974 
Definition: bsebasics.genidl.hh:293
Definition: bsebasics.genidl.hh:323
Definition: bsebasics.genidl.hh:446
Definition: bsebasics.genidl.hh:398
The Bse namespace contains all functions of the synthesis engine.
Definition: bstbseutils.cc:67
Definition: bsebasics.genidl.hh:515
Const KAMMER_FREQ
Kammer note, representing the kammer frequency's MIDI note value for A' or A4.
Definition: bseapi.idl:281
Definition: bsebasics.genidl.hh:383
Definition: bsebasics.genidl.hh:368
Const KAMMER_OCTAVE
Pitch Standard, see also: https://en.wikipedia.org/wiki/A440_(pitch_standard)
Definition: bseapi.idl:282
Definition: sficxx.hh:326
Definition: sfiparams.hh:63
Definition: bsebasics.genidl.hh:308
Definition: bsebasics.genidl.hh:584
Definition: sfitypes.hh:31
Definition: bsebasics.genidl.hh:353
Definition: sfiparams.hh:71
Definition: bsebasics.genidl.hh:413
Definition: bsebasics.genidl.hh:548
Definition: sficxx.hh:169
Definition: bsebasics.genidl.hh:621
Definition: bsebasics.genidl.hh:428
Definition: bsebasics.genidl.hh:490
Definition: bsepart.hh:26
Definition: bsebasics.genidl.hh:601
Definition: bsebasics.genidl.hh:568
Const KAMMER_NOTE
Value represents unparsable/unknown notes.
Definition: bseapi.idl:280
Definition: sficxx.hh:143
Definition: sficxx.hh:16
Definition: bsebasics.genidl.hh:472
Definition: bsebasics.genidl.hh:338
The Sfi namespace contains utilities for synthesis.
Definition: oldidl.idl:4
Definition: bsebasics.genidl.hh:531