Subversion Repositories svn.mios32

Rev

Rev 2618 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
240 tk 1
// $Id: seq_ui_opt.c 2628 2018-12-30 21:14:09Z tk $
2
/*
3
 * Options page
4
 *
5
 * ==========================================================================
6
 *
7
 *  Copyright (C) 2008 Thorsten Klose (tk@midibox.org)
8
 *  Licensed for personal non-commercial use only.
9
 *  All other rights reserved.
10
 *
11
 * ==========================================================================
12
 */
13
 
14
/////////////////////////////////////////////////////////////////////////////
15
// Include files
16
/////////////////////////////////////////////////////////////////////////////
17
 
18
#include <mios32.h>
1810 tk 19
#include <string.h>
352 tk 20
#include "tasks.h"
21
 
240 tk 22
#include "seq_lcd.h"
23
#include "seq_ui.h"
24
 
1123 tk 25
#include "seq_file.h"
352 tk 26
#include "seq_file_c.h"
1052 tk 27
#include "seq_file_gc.h"
352 tk 28
 
240 tk 29
#include "seq_core.h"
254 tk 30
#include "seq_cc.h"
2542 tk 31
#include "seq_midi_in.h"
625 tk 32
#include "seq_midi_port.h"
33
#include "seq_midi_sysex.h"
2027 tk 34
#include "seq_mixer.h"
1864 tk 35
#include "seq_tpd.h"
2020 tk 36
#include "seq_blm.h"
2130 tk 37
#include "seq_lcd_logo.h"
240 tk 38
 
39
 
40
/////////////////////////////////////////////////////////////////////////////
41
// Local definitions
42
/////////////////////////////////////////////////////////////////////////////
43
 
2542 tk 44
#define ITEM_STEPS_MEASURE                 0
45
#define ITEM_STEPS_PATTERN                 1
46
#define ITEM_SYNC_CHANGE                   2
47
#define ITEM_PATTERN_RESEND_PC             3
48
#define ITEM_RATOPC                        4
49
#define ITEM_PATTERN_MIXER_MAP_COUPLING    5
50
#define ITEM_SYNC_MUTE                     6
51
#define ITEM_SYNC_UNMUTE                   7
2587 tk 52
#define ITEM_SELECT_UNMUTED_TRACK          8
53
#define ITEM_PASTE_CLR_ALL                 9
54
#define ITEM_RESTORE_TRACK_SELECTIONS     10
55
#define ITEM_MODIFY_PATTERN_BANKS         11
2628 tk 56
#define ITEM_ALL_FOR_STEP_VIEW_ONLY       12
57
#define ITEM_PRINT_AND_MODIFY_WITHOUT_GATES 13
58
#define ITEM_PRINT_TRANSPOSED_NOTES       14
59
#define ITEM_METRONOME                    15
60
#define ITEM_SHADOW_OUT                   16
61
#define ITEM_MIDI_REMOTE                  17
62
#define ITEM_TRACK_CC                     18
63
#define ITEM_RUNTIME_STATUS_OPTIMIZATION  19
64
#define ITEM_LIVE_LAYER_MUTE              20
65
#define ITEM_INIT_WITH_TRIGGERS           21
66
#define ITEM_INIT_CC                      22
67
#define ITEM_DRUM_CC                      23
68
#define ITEM_TPD_MODE                     24
69
#define ITEM_SWAP_GP_LED_COLOURS          25
70
#define ITEM_INVERT_MUTE_LEDS             26
71
#define ITEM_BLM_ALWAYS_USE_FTS           27
72
#define ITEM_BLM_FADERS                   28
73
#define ITEM_MIXER_CC1234                 29
74
#define ITEM_MENU_SHORTCUTS               30
75
#define ITEM_SCREEN_SAVER                 31
240 tk 76
 
2628 tk 77
#define NUM_OF_ITEMS                      32
1794 tk 78
 
1810 tk 79
 
80
static const char *item_text[NUM_OF_ITEMS][2] = {
81
 
82
  {//<-------------------------------------->
83
    "Track Synchronisation",
84
    "Steps per Measure:" // %3d
85
  },
86
 
87
  {//<-------------------------------------->
88
    "Pattern Change Synchronisation",
89
    "Change considered each " // %3d steps
90
  },
91
 
92
  {//<-------------------------------------->
93
    "Pattern Change Synchronisation",
94
    NULL, // enabled/disabled
95
  },
96
 
97
  {//<-------------------------------------->
2523 tk 98
    "Pattern Change re-sends Program Change",
99
    NULL, // enabled/disabled
100
  },
101
 
102
  {//<-------------------------------------->
1810 tk 103
    "Restart all Tracks on Pattern Change",
104
    NULL, // enabled/disabled
105
  },
106
 
107
  {//<-------------------------------------->
108
    "Dump a predefined Mixer Map on",
109
    "Pattern Changes: ", // enabled/disabled
110
  },
111
 
112
  {//<-------------------------------------->
113
    "Synchronize MUTE to Measure",
114
    NULL, // enabled/disabled
115
  },
116
 
117
  {//<-------------------------------------->
118
    "Synchronize UNMUTE to Measure",
119
    NULL, // enabled/disabled
120
  },
121
 
122
  {//<-------------------------------------->
2587 tk 123
    "Auto-Select unmuted Track",
124
    NULL, // enabled/disabled
125
  },
126
 
127
  {//<-------------------------------------->
1810 tk 128
    "Paste and Clear button will modify",
129
    NULL, // Only Steps/Complete Track
130
  },
131
 
132
  {//<-------------------------------------->
2250 tk 133
    "Selections restored on Track Change",
134
    NULL, // enabled/disabled
135
  },
136
 
137
  {//<-------------------------------------->
2545 tk 138
    "Allow to change pattern banks",
139
    NULL, // enabled/disabled
140
  },
141
 
142
  {//<-------------------------------------->
2628 tk 143
    "ALL Function works on Step View only",
144
    NULL, // enabled/disabled
145
  },
146
 
147
  {//<-------------------------------------->
2564 tk 148
    "Print/Modify Steps w/o changing Gates",
149
    NULL, // enabled/disabled
150
  },
151
 
152
  {//<-------------------------------------->
2567 tk 153
    "Print Notes with transposed value",
154
    NULL, // enabled/disabled
155
  },
156
 
157
  {//<-------------------------------------->
2545 tk 158
    "Metronome Port Chn. Meas.Note  BeatNote",
159
    NULL,
160
  },
161
 
162
  {//<-------------------------------------->
163
    "ShadowOut Port Chn.",
164
    NULL,
165
  },
166
 
167
  {//<-------------------------------------->
2542 tk 168
    "Frontpanel MIDI Remote Control",
169
    "via: ",
170
  },
171
 
172
  {//<-------------------------------------->
173
    "Sending selected Track as CC to a DAW",
174
    NULL,
175
  },
176
 
177
  {//<-------------------------------------->
178
    "MIDI OUT Runtime Status Optimization",
179
    NULL,
180
  },
181
 
182
  {//<-------------------------------------->
2294 tk 183
    "If Live function, matching received",
184
    "MIDI Events will: ",
1810 tk 185
  },
186
 
187
  {//<-------------------------------------->
2294 tk 188
    "Initial Gate Trigger Layer Pattern:",
189
    NULL,
1810 tk 190
  },
1864 tk 191
 
192
  {//<-------------------------------------->
2294 tk 193
    "Initial CC value for Clear and Init",
194
    "is: ",
195
  },
196
 
197
  {//<-------------------------------------->
2552 tk 198
    "Session specific Drum CC Assignments",
199
    "",
200
  },
201
 
202
  {//<-------------------------------------->
1864 tk 203
    "Track Position Display (TPD) Mode",
2542 tk 204
    NULL,
1864 tk 205
  },
2020 tk 206
 
207
  {//<-------------------------------------->
2618 tk 208
    "Swap LED Colours:   GP   Select  XOR Pos",
2609 tk 209
    "",
210
  },
211
 
212
  {//<-------------------------------------->
2610 tk 213
    "Invert Mute LEDs",
214
    NULL,
215
  },
216
 
217
  {//<-------------------------------------->
2020 tk 218
    "The BLM16x16+X should always use",
219
    "Force-To-Scale in Grid Edit Mode: " // yes/no
220
  },
2027 tk 221
 
222
  {//<-------------------------------------->
2227 tk 223
    "BLM16x16+X Fader Assignments",
2542 tk 224
    NULL,
2227 tk 225
  },
226
 
227
  {//<-------------------------------------->
2027 tk 228
    "Mixer CCs which should be sent after PC",
2542 tk 229
    NULL,
2027 tk 230
  },
2130 tk 231
 
232
  {//<-------------------------------------->
2542 tk 233
    "MENU button page assignments",
234
    "GP Button #",
235
  },
236
 
237
  {//<-------------------------------------->
2130 tk 238
    "Screen Saver:",
239
    ""
240
  },
1810 tk 241
};
242
 
240 tk 243
/////////////////////////////////////////////////////////////////////////////
513 tk 244
// Local variables
245
/////////////////////////////////////////////////////////////////////////////
246
 
1810 tk 247
static u8 local_selected_item = 0; // stays stable when menu is exit
513 tk 248
 
2227 tk 249
static u8 selected_blm_fader = 0;
2542 tk 250
static u8 selected_menu_assignment_button = 0;
513 tk 251
 
2542 tk 252
 
513 tk 253
/////////////////////////////////////////////////////////////////////////////
240 tk 254
// Local LED handler function
255
/////////////////////////////////////////////////////////////////////////////
256
static s32 LED_Handler(u16 *gp_leds)
257
{
258
  if( ui_cursor_flash ) // if flashing flag active: no LED flag set
259
    return 0;
260
 
1810 tk 261
  *gp_leds = 0xffc0;
240 tk 262
 
263
  return 0; // no error
264
}
265
 
266
 
267
 
268
/////////////////////////////////////////////////////////////////////////////
269
// Local encoder callback function
270
// Should return:
271
//   1 if value has been changed
272
//   0 if value hasn't been changed
273
//  -1 if invalid or unsupported encoder
274
/////////////////////////////////////////////////////////////////////////////
275
static s32 Encoder_Handler(seq_ui_encoder_t encoder, s32 incrementer)
276
{
1810 tk 277
  if( encoder <= SEQ_UI_ENCODER_GP6 )
278
    return -1; // not mapped
758 tk 279
 
1810 tk 280
  // change page
281
  if( encoder == SEQ_UI_ENCODER_GP7 || encoder == SEQ_UI_ENCODER_GP8 ) {
282
    if( SEQ_UI_Var8_Inc(&local_selected_item, 0, NUM_OF_ITEMS-1, incrementer) >= 0 ) {
283
      return 1; // changed
284
    }
285
    return 0; // not changed
240 tk 286
  }
287
 
288
  // for GP encoders and Datawheel
1810 tk 289
  switch( local_selected_item ) {
758 tk 290
    case ITEM_STEPS_MEASURE:
1810 tk 291
      if( encoder == SEQ_UI_ENCODER_GP16 ) {
758 tk 292
    // increment in +/- 16 steps
293
    u8 value = seq_core_steps_per_measure >> 4;
294
    if( SEQ_UI_Var8_Inc(&value, 0, 15, incrementer) >= 0 ) {
295
      seq_core_steps_per_measure = (value << 4) + 15;
2102 tk 296
      ui_store_file_required = 1;
758 tk 297
      return 1;
298
    }
299
      } else {
300
    if( SEQ_UI_Var8_Inc(&seq_core_steps_per_measure, 0, 255, incrementer) >= 0 ) {
2102 tk 301
      ui_store_file_required = 1;
758 tk 302
      return 1;
303
    }
304
      }
305
      return 0;
306
 
307
    case ITEM_STEPS_PATTERN:
1810 tk 308
      if( encoder == SEQ_UI_ENCODER_GP16 ) {
758 tk 309
    // increment in +/- 16 steps
310
    u8 value = seq_core_steps_per_pattern >> 4;
311
    if( SEQ_UI_Var8_Inc(&value, 0, 15, incrementer) >= 0 ) {
312
      seq_core_steps_per_pattern = (value << 4) + 15;
2102 tk 313
      ui_store_file_required = 1;
758 tk 314
      return 1;
315
    }
316
      } else {
317
    if( SEQ_UI_Var8_Inc(&seq_core_steps_per_pattern, 0, 255, incrementer) >= 0 ) {
2102 tk 318
      ui_store_file_required = 1;
758 tk 319
      return 1;
320
    }
321
      }
322
      return 0;
323
 
416 tk 324
    case ITEM_SYNC_CHANGE:
325
      if( incrementer )
2542 tk 326
    seq_core_options.SYNCHED_PATTERN_CHANGE = (incrementer > 0) ? 1 : 0;
416 tk 327
      else
328
    seq_core_options.SYNCHED_PATTERN_CHANGE ^= 1;
2102 tk 329
      ui_store_file_required = 1;
416 tk 330
      return 1;
331
 
2523 tk 332
    case ITEM_PATTERN_RESEND_PC:
333
      if( incrementer )
2542 tk 334
    seq_core_options.PATTERN_CHANGE_DONT_RESET_LATCHED_PC = (incrementer > 0) ? 1 : 0;
2523 tk 335
      else
336
    seq_core_options.PATTERN_CHANGE_DONT_RESET_LATCHED_PC ^= 1;
337
      ui_store_file_required = 1;
338
      return 1;
339
 
1810 tk 340
    case ITEM_PATTERN_MIXER_MAP_COUPLING:
341
      if( incrementer )
2542 tk 342
    seq_core_options.PATTERN_MIXER_MAP_COUPLING = (incrementer > 0) ? 1 : 0;
1810 tk 343
      else
344
    seq_core_options.PATTERN_MIXER_MAP_COUPLING ^= 1;
2102 tk 345
      ui_store_file_required = 1;
1810 tk 346
      return 1;
347
 
416 tk 348
    case ITEM_PASTE_CLR_ALL:
349
      if( incrementer )
2542 tk 350
    seq_core_options.PASTE_CLR_ALL = (incrementer > 0) ? 1 : 0;
416 tk 351
      else
352
    seq_core_options.PASTE_CLR_ALL ^= 1;
2102 tk 353
      ui_store_file_required = 1;
416 tk 354
      return 1;
625 tk 355
 
1205 tk 356
    case ITEM_RATOPC:
357
      if( incrementer )
2542 tk 358
    seq_core_options.RATOPC = (incrementer > 0) ? 1 : 0;
1205 tk 359
      else
360
    seq_core_options.RATOPC ^= 1;
2102 tk 361
      ui_store_file_required = 1;
1205 tk 362
      return 1;
363
 
1261 tk 364
    case ITEM_SYNC_MUTE: {
365
      if( incrementer )
2542 tk 366
    seq_core_options.SYNCHED_MUTE = (incrementer > 0) ? 1 : 0;
1261 tk 367
      else
368
    seq_core_options.SYNCHED_MUTE ^= 1;
2102 tk 369
      ui_store_file_required = 1;
1261 tk 370
      return 1;
371
    } break;
372
 
373
    case ITEM_SYNC_UNMUTE: {
374
      if( incrementer )
2542 tk 375
    seq_core_options.SYNCHED_UNMUTE = (incrementer > 0) ? 1 : 0;
1261 tk 376
      else
377
    seq_core_options.SYNCHED_UNMUTE ^= 1;
2102 tk 378
      ui_store_file_required = 1;
1261 tk 379
      return 1;
380
    } break;
1810 tk 381
 
2587 tk 382
    case ITEM_SELECT_UNMUTED_TRACK: {
383
      if( incrementer )
384
    seq_ui_options.SELECT_UNMUTED_TRACK = (incrementer > 0) ? 1 : 0;
385
      else
386
    seq_ui_options.SELECT_UNMUTED_TRACK ^= 1;
387
      ui_store_file_required = 1;
388
      return 1;
389
    } break;
390
 
2250 tk 391
    case ITEM_RESTORE_TRACK_SELECTIONS: {
392
      if( incrementer )
2542 tk 393
    seq_ui_options.RESTORE_TRACK_SELECTIONS = (incrementer > 0) ? 1 : 0;
2250 tk 394
      else
395
    seq_ui_options.RESTORE_TRACK_SELECTIONS ^= 1;
396
      ui_store_file_required = 1;
397
      return 1;
398
    } break;
399
 
2545 tk 400
    case ITEM_MODIFY_PATTERN_BANKS: {
401
      if( incrementer )
402
    seq_ui_options.MODIFY_PATTERN_BANKS = (incrementer > 0) ? 1 : 0;
403
      else
404
    seq_ui_options.MODIFY_PATTERN_BANKS ^= 1;
405
      ui_store_file_required = 1;
406
      return 1;
407
    } break;
408
 
2628 tk 409
    case ITEM_ALL_FOR_STEP_VIEW_ONLY: {
410
      if( incrementer )
411
    seq_ui_options.ALL_FOR_STEP_VIEW_ONLY = (incrementer > 0) ? 1 : 0;
412
      else
413
    seq_ui_options.ALL_FOR_STEP_VIEW_ONLY ^= 1;
414
      ui_store_file_required = 1;
415
      return 1;
416
    } break;
417
 
2564 tk 418
    case ITEM_PRINT_AND_MODIFY_WITHOUT_GATES: {
419
      if( incrementer )
420
    seq_ui_options.PRINT_AND_MODIFY_WITHOUT_GATES = (incrementer > 0) ? 1 : 0;
421
      else
422
    seq_ui_options.PRINT_AND_MODIFY_WITHOUT_GATES ^= 1;
423
      ui_store_file_required = 1;
424
      return 1;
425
    } break;
426
 
2567 tk 427
    case ITEM_PRINT_TRANSPOSED_NOTES: {
428
      if( incrementer )
429
    seq_ui_options.PRINT_TRANSPOSED_NOTES = (incrementer > 0) ? 1 : 0;
430
      else
431
    seq_ui_options.PRINT_TRANSPOSED_NOTES ^= 1;
432
      ui_store_file_required = 1;
433
      return 1;
434
    } break;
435
 
2294 tk 436
    case ITEM_INIT_WITH_TRIGGERS: {
437
      if( incrementer )
2542 tk 438
    seq_core_options.INIT_WITH_TRIGGERS = (incrementer > 0) ? 1 : 0;
2294 tk 439
      else
440
    seq_core_options.INIT_WITH_TRIGGERS ^= 1;
441
      ui_store_file_required = 1;
442
      return 1;
443
    } break;
444
 
1810 tk 445
    case ITEM_INIT_CC: {
446
      u8 value = seq_core_options.INIT_CC;
2448 tk 447
      if( SEQ_UI_Var8_Inc(&value, 0, 128, incrementer) >= 0 ) {
1810 tk 448
    seq_core_options.INIT_CC = value;
2102 tk 449
    ui_store_file_required = 1;
1810 tk 450
    return 1;
451
      }
452
      return 0;
453
    } break;
454
 
2552 tk 455
    case ITEM_DRUM_CC: {
456
#ifdef MBSEQV4P
457
      switch( encoder ) {
458
      case SEQ_UI_ENCODER_GP9:
459
      case SEQ_UI_ENCODER_GP10:
460
      case SEQ_UI_ENCODER_GP11:
461
      case SEQ_UI_ENCODER_GP12: {
462
    if( SEQ_UI_Var8_Inc(&ui_selected_instrument, 0, 15, incrementer) >= 0 ) {
463
      return 1; // value changed
464
    }
465
    return 0; // no change
466
      } break;
467
 
468
      case SEQ_UI_ENCODER_GP13:
469
      case SEQ_UI_ENCODER_GP14: {
470
    if( ui_selected_par_layer >= 4 ) {
471
      ui_selected_par_layer = 3; // max. 4 layers supported
472
      return 1;
473
    }
474
 
475
    if( SEQ_UI_Var8_Inc(&ui_selected_par_layer, 0, 3, incrementer) >= 0 ) {
476
      return 1; // value changed
477
    }
478
    return 0; // no change
479
      } break;
480
 
481
      case SEQ_UI_ENCODER_GP15:
482
      case SEQ_UI_ENCODER_GP16: {
483
    if( SEQ_UI_Var8_Inc(&seq_layer_drum_cc[ui_selected_instrument][ui_selected_par_layer], 0, 128, incrementer) >= 0 ) {
484
      ui_store_file_required = 1;
485
      return 1; // value changed
486
    }
487
    return 0; // no change
488
      } break;
489
      }
490
#endif
491
 
492
      return -1;
493
    } break;
494
 
2545 tk 495
    case ITEM_METRONOME: {
496
      switch( encoder ) {
497
      case SEQ_UI_ENCODER_GP9:
498
      case SEQ_UI_ENCODER_GP10: {
499
    if( incrementer )
500
      seq_core_state.METRONOME = ((incrementer > 0)) ? 1 : 0;
501
    else
502
      seq_core_state.METRONOME ^= 1;
503
    ui_store_file_required = 1;
504
    return 1;
505
      } break;
506
 
507
      case SEQ_UI_ENCODER_GP11: {
508
    u8 port_ix = SEQ_MIDI_PORT_OutIxGet(seq_core_metronome_port);
509
    if( SEQ_UI_Var8_Inc(&port_ix, 0, SEQ_MIDI_PORT_OutNumGet()-1, incrementer) >= 0 ) {
510
      seq_core_metronome_port = SEQ_MIDI_PORT_OutPortGet(port_ix);
511
      ui_store_file_required = 1;
512
      return 1; // value changed
513
    }
514
    return 0; // no change
515
      } break;
516
 
517
      case SEQ_UI_ENCODER_GP12: {
518
    if( SEQ_UI_Var8_Inc(&seq_core_metronome_chn, 0, 16, incrementer) >= 0 ) {
519
      ui_store_file_required = 1;
520
      return 1; // value changed
521
    }
522
    return 0; // no change
523
      } break;
524
 
525
      case SEQ_UI_ENCODER_GP13:
526
      case SEQ_UI_ENCODER_GP14: {
527
    if( SEQ_UI_Var8_Inc(&seq_core_metronome_note_m, 0, 127, incrementer) >= 0 ) {
528
      ui_store_file_required = 1;
529
      return 1; // value changed
530
    }
531
    return 0; // no change
532
      } break;
533
 
534
      case SEQ_UI_ENCODER_GP15:
535
      case SEQ_UI_ENCODER_GP16: {
536
    if( SEQ_UI_Var8_Inc(&seq_core_metronome_note_b, 0, 127, incrementer) >= 0 ) {
537
      ui_store_file_required = 1;
538
      return 1; // value changed
539
    }
540
    return 0; // no change
541
      } break;
542
      }
543
 
544
      return -1;
545
    } break;
546
 
547
    case ITEM_SHADOW_OUT: {
548
      switch( encoder ) {
549
      case SEQ_UI_ENCODER_GP11: {
550
    u8 port_ix = SEQ_MIDI_PORT_OutIxGet(seq_core_shadow_out_port);
551
    if( SEQ_UI_Var8_Inc(&port_ix, 0, SEQ_MIDI_PORT_OutNumGet()-1, incrementer) >= 0 ) {
552
      seq_core_shadow_out_port = SEQ_MIDI_PORT_OutPortGet(port_ix);
553
      ui_store_file_required = 1;
554
      return 1; // value changed
555
    }
556
    return 0; // no change
557
      } break;
558
 
559
      case SEQ_UI_ENCODER_GP12: {
560
    if( SEQ_UI_Var8_Inc(&seq_core_shadow_out_chn, 0, 16, incrementer) >= 0 ) {
561
      ui_store_file_required = 1;
562
      return 1; // value changed
563
    }
564
    return 0; // no change
565
      } break;
566
      }
567
 
568
      return -1;
569
    } break;
570
 
2542 tk 571
    case ITEM_MIDI_REMOTE: {
572
      if( encoder == SEQ_UI_ENCODER_GP10 ) {
573
    if( incrementer )
574
      seq_midi_in_remote.cc_or_key = ((incrementer > 0)) ? 1 : 0;
575
    else
576
      seq_midi_in_remote.cc_or_key ^= 1;
577
    ui_store_file_required = 1;
578
    return 1;
579
      } else if( encoder == SEQ_UI_ENCODER_GP11 ) {
580
    u8 value = seq_midi_in_remote.value;
581
    if( SEQ_UI_Var8_Inc(&value, 0, 127, incrementer) >= 0 ) {
582
      seq_midi_in_remote.value = value;
583
      ui_store_file_required = 1;
584
      return 1;
585
    }
586
      }
587
 
588
      return 0;
589
    } break;
590
 
591
    case ITEM_TRACK_CC: {
592
      switch( encoder ) {
593
      case SEQ_UI_ENCODER_GP9:
594
      case SEQ_UI_ENCODER_GP10:
595
      case SEQ_UI_ENCODER_GP11:
596
      case SEQ_UI_ENCODER_GP12: {
597
    u8 value = seq_ui_track_cc.mode;
598
    if( SEQ_UI_Var8_Inc(&value, 0, 2, incrementer) >= 0 ) {
599
      seq_ui_track_cc.mode = value;
600
      ui_store_file_required = 1;
601
      return 1;
602
    }
603
    return 0;
604
      } break;
605
      case SEQ_UI_ENCODER_GP13:
606
      case SEQ_UI_ENCODER_GP14: {
607
    u8 port_ix = SEQ_MIDI_PORT_OutIxGet(seq_ui_track_cc.port);
608
    if( SEQ_UI_Var8_Inc(&port_ix, 0, SEQ_MIDI_PORT_OutNumGet()-1, incrementer) >= 0 ) {
609
      seq_ui_track_cc.port = SEQ_MIDI_PORT_OutPortGet(port_ix);
610
      ui_store_file_required = 1;
611
      return 1;
612
    }
613
    return 0;
614
      } break;
615
      case SEQ_UI_ENCODER_GP15: {
616
    u8 value = seq_ui_track_cc.chn;
617
    if( SEQ_UI_Var8_Inc(&value, 0, 15, incrementer) >= 0 ) {
618
      seq_ui_track_cc.chn = value;
619
      ui_store_file_required = 1;
620
      return 1;
621
    }
622
    return 0;
623
      } break;
624
      case SEQ_UI_ENCODER_GP16: {
625
    u8 value = seq_ui_track_cc.cc;
626
    if( SEQ_UI_Var8_Inc(&value, 0, 127, incrementer) >= 0 ) {
627
      seq_ui_track_cc.cc = value;
628
      ui_store_file_required = 1;
629
      return 1;
630
    }
631
    return 0;
632
      } break;
633
      }
634
 
635
      return -1;
636
    } break;
637
 
638
    case ITEM_RUNTIME_STATUS_OPTIMIZATION: {
639
      mios32_midi_port_t port = DEFAULT;
640
 
641
      if( encoder == SEQ_UI_ENCODER_GP10 ) {
642
    port = UART0;
643
      } else if( encoder == SEQ_UI_ENCODER_GP12 ) {
644
    port = UART1;
645
      } else if( encoder == SEQ_UI_ENCODER_GP14 ) {
646
    port = UART2;
647
      } else if( encoder == SEQ_UI_ENCODER_GP16 ) {
648
    port = UART3;
649
      }
650
 
651
      if( port != DEFAULT ) {
652
    if( incrementer )
653
      MIOS32_MIDI_RS_OptimisationSet(port, (incrementer > 0) ? 1 : 0);
654
    else
655
      MIOS32_MIDI_RS_OptimisationSet(port, (MIOS32_MIDI_RS_OptimisationGet(port) > 0) ? 0 : 1);
656
    ui_store_file_required = 1;
657
    return 1;
658
      }
659
 
660
      return 0;
661
    } break;
662
 
1810 tk 663
    case ITEM_LIVE_LAYER_MUTE: {
664
      u8 value = seq_core_options.LIVE_LAYER_MUTE_STEPS;
665
      if( SEQ_UI_Var8_Inc(&value, 0, 7, incrementer) >= 0 ) {
666
    seq_core_options.LIVE_LAYER_MUTE_STEPS = value;
2102 tk 667
    ui_store_file_required = 1;
1810 tk 668
    return 1;
669
      }
670
      return 0;
671
    } break;
672
 
1864 tk 673
    case ITEM_TPD_MODE: {
674
      u8 value = SEQ_TPD_ModeGet();
675
      if( SEQ_UI_Var8_Inc(&value, 0, SEQ_TPD_NUM_MODES-1, incrementer) >= 0 ) {
676
    SEQ_TPD_ModeSet(value);
2102 tk 677
    ui_store_file_required = 1;
1864 tk 678
    return 1;
679
      }
680
      return 0;
681
    } break;
682
 
2609 tk 683
    case ITEM_SWAP_GP_LED_COLOURS: {
684
      if( encoder == SEQ_UI_ENCODER_GP13 ) {
685
    if( incrementer )
686
      seq_ui_options.SWAP_GP_LED_COLOURS = (incrementer > 0) ? 1 : 0;
687
    else
688
      seq_ui_options.SWAP_GP_LED_COLOURS ^= 1;
689
    ui_store_file_required = 1;
690
      } else if( encoder == SEQ_UI_ENCODER_GP14 ) {
691
    if( incrementer )
692
      seq_ui_options.SWAP_SELECT_LED_COLOURS = (incrementer > 0) ? 1 : 0;
693
    else
694
      seq_ui_options.SWAP_SELECT_LED_COLOURS ^= 1;
695
    ui_store_file_required = 1;
2618 tk 696
      } else if(  encoder == SEQ_UI_ENCODER_GP15 || encoder == SEQ_UI_ENCODER_GP16 ) {
697
    if( incrementer )
698
      seq_ui_options.GP_LED_DONT_XOR_POS = (incrementer > 0) ? 1 : 0;
699
    else
700
      seq_ui_options.GP_LED_DONT_XOR_POS ^= 1;
701
    ui_store_file_required = 1;
2609 tk 702
      }
703
      return 1;
704
    } break;
705
 
2610 tk 706
    case ITEM_INVERT_MUTE_LEDS: {
707
      if( incrementer )
708
    seq_ui_options.INVERT_MUTE_LEDS = (incrementer > 0) ? 1 : 0;
709
      else
710
    seq_ui_options.INVERT_MUTE_LEDS ^= 1;
711
      ui_store_file_required = 1;
712
      return 1;
713
    } break;
714
 
2020 tk 715
    case ITEM_BLM_ALWAYS_USE_FTS: {
716
      if( incrementer )
2542 tk 717
    seq_blm_options.ALWAYS_USE_FTS = (incrementer > 0) ? 1 : 0;
2020 tk 718
      else
719
    seq_blm_options.ALWAYS_USE_FTS ^= 1;
2102 tk 720
      ui_store_file_required = 1;
2020 tk 721
      return 1;
722
    } break;
723
 
2227 tk 724
    case ITEM_BLM_FADERS: {
725
      seq_blm_fader_t *fader = &seq_blm_fader[selected_blm_fader];
726
 
727
      switch( encoder ) {
728
      case SEQ_UI_ENCODER_GP9: {
729
    if( SEQ_UI_Var8_Inc(&selected_blm_fader, 0, SEQ_BLM_NUM_FADERS-1, incrementer) >= 0 ) {
730
      return 1;
731
    }
732
    return 0;
733
      } break;
734
 
735
      case SEQ_UI_ENCODER_GP10:
736
      case SEQ_UI_ENCODER_GP11: {
737
    u8 port_ix = SEQ_MIDI_PORT_OutIxGet(fader->port);
738
    if( SEQ_UI_Var8_Inc(&port_ix, 0, SEQ_MIDI_PORT_OutNumGet()-1, incrementer) >= 0 ) {
739
      fader->port = SEQ_MIDI_PORT_OutPortGet(port_ix);
740
      ui_store_file_required = 1;
741
      return 1;
742
    }
743
    return 0;
744
      } break;
745
 
746
      case SEQ_UI_ENCODER_GP12:
747
      case SEQ_UI_ENCODER_GP13: {
748
    u8 value = fader->chn;
749
    if( SEQ_UI_Var8_Inc(&value, 0, 16, incrementer) >= 0 ) {
750
      fader->chn = value;
751
      ui_store_file_required = 1;
752
      return 1;
753
    }
754
    return 0;
755
      } break;
756
 
757
      case SEQ_UI_ENCODER_GP14:
758
      case SEQ_UI_ENCODER_GP16:
759
      case SEQ_UI_ENCODER_GP15: {
2228 tk 760
    u16 value = fader->send_function;
761
    if( SEQ_UI_Var16_Inc(&value, 0, 256, incrementer) >= 0 ) {
2227 tk 762
      fader->send_function = value;
763
      ui_store_file_required = 1;
764
      return 1;
765
    }
766
    return 0;
767
      } break;
768
      }
769
      return 1;
770
    } break;
771
 
2027 tk 772
    case ITEM_MIXER_CC1234: {
773
      u8 pos = (encoder-8) / 2;
774
      u8 value = (seq_mixer_cc1234_before_pc & (1 << pos)) ? 0 : 1; // note: we've to invert yes/no!
775
      if( SEQ_UI_Var8_Inc(&value, 0, 1, incrementer) >= 0 ) {
776
    if( !value ) // note: we've to invert yes/no
777
      seq_mixer_cc1234_before_pc |= (1 << pos);
778
    else
779
      seq_mixer_cc1234_before_pc &= ~(1 << pos);
780
 
2102 tk 781
    ui_store_file_required = 1;
2027 tk 782
    return 1;
783
      }
784
      return 0;
785
    } break;
786
 
2542 tk 787
    case ITEM_MENU_SHORTCUTS: {
788
      switch( encoder ) {
789
      case SEQ_UI_ENCODER_GP9:
790
      case SEQ_UI_ENCODER_GP10:
791
      case SEQ_UI_ENCODER_GP11: {
792
    if( SEQ_UI_Var8_Inc(&selected_menu_assignment_button, 0, 15, incrementer) >= 0 ) {
793
      return 1;
794
    }
795
    return 0;
796
      } break;
797
      case SEQ_UI_ENCODER_GP12:
798
      case SEQ_UI_ENCODER_GP13:
799
      case SEQ_UI_ENCODER_GP14:
800
      case SEQ_UI_ENCODER_GP15:
801
      case SEQ_UI_ENCODER_GP16: {
802
    u8 value = (u8)SEQ_UI_PAGES_MenuShortcutPageGet(selected_menu_assignment_button);
803
    if( SEQ_UI_Var8_Inc(&value, 0, SEQ_UI_PAGES-1, incrementer) >= 0 ) {
804
      SEQ_UI_PAGES_MenuShortcutPageSet(selected_menu_assignment_button, value);
805
      ui_store_file_required = 1;
806
      return 1;
807
    }
808
    return 0;
809
      } break;
810
      }
811
      return -1;
812
    } break;
813
 
2130 tk 814
    case ITEM_SCREEN_SAVER: {
815
      if( incrementer ) {
816
    int delay = (int)seq_lcd_logo_screensaver_delay + incrementer;
817
    if( delay > 255 )
818
      delay = 255;
819
    else if( delay < 0 )
820
      delay = 0;
821
 
822
    seq_lcd_logo_screensaver_delay = delay;
823
    ui_store_file_required = 1;
824
      }
825
      return 1;
826
    } break;
827
 
240 tk 828
  }
829
 
830
  return -1; // invalid or unsupported encoder
831
}
832
 
833
 
834
/////////////////////////////////////////////////////////////////////////////
835
// Local button callback function
836
// Should return:
837
//   1 if value has been changed
838
//   0 if value hasn't been changed
839
//  -1 if invalid or unsupported button
840
/////////////////////////////////////////////////////////////////////////////
841
static s32 Button_Handler(seq_ui_button_t button, s32 depressed)
842
{
843
  if( depressed ) return 0; // ignore when button depressed
844
 
416 tk 845
#if 0
846
  // leads to: comparison is always true due to limited range of data type
847
  if( button >= SEQ_UI_BUTTON_GP1 && button <= SEQ_UI_BUTTON_GP16 ) {
848
#else
849
  if( button <= SEQ_UI_BUTTON_GP16 ) {
850
#endif
851
    // re-use encoder handler - only select UI item, don't increment, flags will be toggled
852
    return Encoder_Handler((int)button, 0);
853
  }
854
 
855
  // remaining buttons:
240 tk 856
  switch( button ) {
857
    case SEQ_UI_BUTTON_Select:
858
    case SEQ_UI_BUTTON_Right:
859
      if( depressed ) return -1;
1810 tk 860
      if( ++local_selected_item >= NUM_OF_ITEMS )
861
    local_selected_item = 0;
240 tk 862
      return 1; // value always changed
863
 
864
    case SEQ_UI_BUTTON_Left:
865
      if( depressed ) return -1;
1810 tk 866
      if( local_selected_item == 0 )
867
    local_selected_item = NUM_OF_ITEMS-1;
1142 tk 868
      else
1810 tk 869
    --local_selected_item;
240 tk 870
      return 1; // value always changed
871
 
872
    case SEQ_UI_BUTTON_Up:
873
      if( depressed ) return -1;
874
      return Encoder_Handler(SEQ_UI_ENCODER_Datawheel, 1);
875
 
876
    case SEQ_UI_BUTTON_Down:
877
      if( depressed ) return -1;
878
      return Encoder_Handler(SEQ_UI_ENCODER_Datawheel, -1);
879
  }
880
 
881
  return -1; // invalid or unsupported button
882
}
883
 
884
 
885
/////////////////////////////////////////////////////////////////////////////
886
// Local Display Handler function
887
// IN: <high_prio>: if set, a high-priority LCD update is requested
888
/////////////////////////////////////////////////////////////////////////////
889
static s32 LCD_Handler(u8 high_prio)
890
{
891
  if( high_prio )
892
    return 0; // there are no high-priority updates
893
 
894
  // layout:
895
  // 00000000001111111111222222222233333333330000000000111111111122222222223333333333
896
  // 01234567890123456789012345678901234567890123456789012345678901234567890123456789
897
  // <--------------------------------------><-------------------------------------->
1810 tk 898
  //                                 Option  Track Synchronisation
899
  //                                   1/10  Steps per Measure:  16
240 tk 900
 
901
  ///////////////////////////////////////////////////////////////////////////
278 tk 902
  SEQ_LCD_CursorSet(0, 0);
1810 tk 903
  SEQ_LCD_PrintSpaces(32);
904
  SEQ_LCD_PrintString("Option  ");
905
  SEQ_LCD_PrintStringPadded((char *)item_text[local_selected_item][0], 40);
240 tk 906
 
907
  ///////////////////////////////////////////////////////////////////////////
278 tk 908
  SEQ_LCD_CursorSet(0, 1);
1810 tk 909
  SEQ_LCD_PrintSpaces(33);
910
  SEQ_LCD_PrintFormattedString("%2d/%-2d  ", local_selected_item+1, NUM_OF_ITEMS);
240 tk 911
 
758 tk 912
  ///////////////////////////////////////////////////////////////////////////
1810 tk 913
  char *str = (char *)item_text[local_selected_item][1];
914
  u32 len = strlen(str);
915
  int enabled_value = -1; // cheap: will print enabled/disabled in second line if >= 0
240 tk 916
 
1810 tk 917
  switch( local_selected_item ) {
918
 
240 tk 919
  ///////////////////////////////////////////////////////////////////////////
1810 tk 920
  case ITEM_STEPS_MEASURE: {
921
    SEQ_LCD_PrintString(str);
922
    if( ui_cursor_flash ) {
923
      SEQ_LCD_PrintSpaces(3);
924
    } else {
925
      SEQ_LCD_PrintFormattedString("%3d", (int)seq_core_steps_per_measure + 1);
926
    }
927
    SEQ_LCD_PrintSpaces(40-3-len);
928
  } break;
240 tk 929
 
930
  ///////////////////////////////////////////////////////////////////////////
1810 tk 931
  case ITEM_STEPS_PATTERN: {
932
    SEQ_LCD_PrintString(str);
933
    if( ui_cursor_flash ) {
934
      SEQ_LCD_PrintSpaces(9);
935
    } else {
936
      SEQ_LCD_PrintFormattedString("%3d steps", (int)seq_core_steps_per_pattern + 1);
937
    }
938
    SEQ_LCD_PrintSpaces(40-9-len);
939
  } break;
240 tk 940
 
941
  ///////////////////////////////////////////////////////////////////////////
1810 tk 942
  case ITEM_SYNC_CHANGE: {
943
    enabled_value = seq_core_options.SYNCHED_PATTERN_CHANGE;
944
  } break;
240 tk 945
 
1810 tk 946
  ///////////////////////////////////////////////////////////////////////////
2523 tk 947
  case ITEM_PATTERN_RESEND_PC: {
948
    enabled_value = seq_core_options.PATTERN_CHANGE_DONT_RESET_LATCHED_PC ? 0 : 1;
949
  } break;
950
 
951
  ///////////////////////////////////////////////////////////////////////////
1810 tk 952
  case ITEM_RATOPC: {
953
    enabled_value = seq_core_options.RATOPC;
954
  } break;
1261 tk 955
 
240 tk 956
  ///////////////////////////////////////////////////////////////////////////
1810 tk 957
  case ITEM_PATTERN_MIXER_MAP_COUPLING: {
958
    SEQ_LCD_PrintString(str);
625 tk 959
 
1810 tk 960
    if( ui_cursor_flash ) {
961
      SEQ_LCD_PrintSpaces(40-len);
962
    } else {
963
      SEQ_LCD_PrintStringPadded(seq_core_options.PATTERN_MIXER_MAP_COUPLING ? "enabled" : "disabled", 40-len);
964
    }
965
  } break;
966
 
1205 tk 967
  ///////////////////////////////////////////////////////////////////////////
1810 tk 968
  case ITEM_SYNC_MUTE: {
969
    enabled_value = seq_core_options.SYNCHED_MUTE;
970
  } break;
1261 tk 971
 
972
  ///////////////////////////////////////////////////////////////////////////
1810 tk 973
  case ITEM_SYNC_UNMUTE: {
974
    enabled_value = seq_core_options.SYNCHED_UNMUTE;
975
  } break;
1205 tk 976
 
1794 tk 977
  ///////////////////////////////////////////////////////////////////////////
2587 tk 978
  case ITEM_SELECT_UNMUTED_TRACK: {
979
    enabled_value = seq_ui_options.SELECT_UNMUTED_TRACK;
980
  } break;
981
 
982
  ///////////////////////////////////////////////////////////////////////////
1810 tk 983
  case ITEM_PASTE_CLR_ALL: {
984
    if( ui_cursor_flash ) {
985
      SEQ_LCD_PrintSpaces(14);
986
    } else {
2294 tk 987
      SEQ_LCD_PrintString(seq_core_options.PASTE_CLR_ALL ? "Complete Track" : "Only Steps    ");
1810 tk 988
    }
989
    SEQ_LCD_PrintSpaces(40-14);
990
  } break;
991
 
2542 tk 992
 
1810 tk 993
  ///////////////////////////////////////////////////////////////////////////
2545 tk 994
  case ITEM_METRONOME: {
995
    if( ui_cursor_flash ) {
996
      SEQ_LCD_PrintSpaces(40);
997
    } else {
998
      SEQ_LCD_PrintSpaces(3);
999
      SEQ_LCD_PrintString(seq_core_state.METRONOME ? "on " : "off");
1000
      SEQ_LCD_PrintSpaces(4);
1001
 
1002
      SEQ_LCD_PrintString(SEQ_MIDI_PORT_OutNameGet(SEQ_MIDI_PORT_OutIxGet(seq_core_metronome_port)));
1003
      SEQ_LCD_PrintSpaces(1);
1004
 
1005
      if( !seq_core_metronome_chn )
1006
    SEQ_LCD_PrintString("---");
1007
      else
1008
    SEQ_LCD_PrintFormattedString("#%2d", seq_core_metronome_chn);
1009
      SEQ_LCD_PrintSpaces(5);
1010
 
1011
      SEQ_LCD_PrintNote(seq_core_metronome_note_m);
1012
      SEQ_LCD_PrintSpaces(7);
1013
 
1014
      SEQ_LCD_PrintNote(seq_core_metronome_note_b);
1015
      SEQ_LCD_PrintSpaces(4);
1016
    }
1017
  } break;
1018
 
1019
  ///////////////////////////////////////////////////////////////////////////
1020
  case ITEM_SHADOW_OUT: {
1021
    if( ui_cursor_flash ) {
1022
      SEQ_LCD_PrintSpaces(40);
1023
    } else {
1024
      SEQ_LCD_PrintSpaces(10);
1025
 
1026
      SEQ_LCD_PrintString(SEQ_MIDI_PORT_OutNameGet(SEQ_MIDI_PORT_OutIxGet(seq_core_shadow_out_port)));
1027
      SEQ_LCD_PrintSpaces(1);
1028
 
1029
      if( !seq_core_shadow_out_chn )
1030
    SEQ_LCD_PrintString("---");
1031
      else
1032
    SEQ_LCD_PrintFormattedString("#%2d", seq_core_shadow_out_chn);
1033
      SEQ_LCD_PrintSpaces(25);
1034
    }
1035
  } break;
1036
 
1037
  ///////////////////////////////////////////////////////////////////////////
2542 tk 1038
  case ITEM_MIDI_REMOTE: {
1039
    SEQ_LCD_PrintString(str);
1040
 
1041
    if( ui_cursor_flash ) {
1042
      SEQ_LCD_PrintSpaces(8);
1043
    } else {
1044
      if( seq_midi_in_remote.cc_or_key ) {
1045
    SEQ_LCD_PrintFormattedString("CC   #%3d", seq_midi_in_remote.value);
1046
      } else {
1047
    SEQ_LCD_PrintString("Key   ");
1048
    SEQ_LCD_PrintNote(seq_midi_in_remote.value);
1049
      }
1050
 
1051
    }
1052
    SEQ_LCD_PrintSpaces(40-8-5);
1053
  } break;
1054
 
1055
  ///////////////////////////////////////////////////////////////////////////
1056
  case ITEM_TRACK_CC: {
1057
    u8 valid = 0;
1058
    if( ui_cursor_flash ) {
1059
      SEQ_LCD_PrintSpaces(40);
1060
    } else {
1061
      if( seq_ui_track_cc.mode == 1 ) {
1062
    SEQ_LCD_PrintString("Single CC with Track: ");
1063
    valid = 1;
1064
      } else if( seq_ui_track_cc.mode == 2 ) {
1065
    SEQ_LCD_PrintString("CC..CC+15 per Track:  ");
1066
    valid = 1;
1067
      } else {
1068
    SEQ_LCD_PrintString("Function disabled     ");
1069
      }
1070
 
1071
      if( !valid ) {
1072
    SEQ_LCD_PrintSpaces(40-22);
1073
      } else {
1074
    SEQ_LCD_PrintString(SEQ_MIDI_PORT_OutNameGet(SEQ_MIDI_PORT_OutIxGet(seq_ui_track_cc.port)));
1075
    SEQ_LCD_PrintFormattedString(" Chn#%2d CC#%3d", seq_ui_track_cc.chn+1, seq_ui_track_cc.cc);
1076
      }
1077
    }
1078
  } break;
1079
 
1080
  ///////////////////////////////////////////////////////////////////////////
1081
  case ITEM_RUNTIME_STATUS_OPTIMIZATION: {
1082
    int i;
1083
 
1084
    for(i=0; i<4; ++i) {
1085
      SEQ_LCD_PrintFormattedString("OUT%d: ", i+1);
1086
      if( ui_cursor_flash ) {
1087
    SEQ_LCD_PrintSpaces(4);
1088
      } else {
1089
    s32 enabled = MIOS32_MIDI_RS_OptimisationGet(UART0 + i);
1090
    if( enabled < 0 ) {
1091
      SEQ_LCD_PrintString("--- ");
1092
    } else {
1093
      SEQ_LCD_PrintString(enabled >= 1 ? "on  " : "off ");
1094
    }
1095
      }
1096
    }
1097
  } break;
1098
 
1099
  ///////////////////////////////////////////////////////////////////////////
2250 tk 1100
  case ITEM_RESTORE_TRACK_SELECTIONS: {
1101
    enabled_value = seq_ui_options.RESTORE_TRACK_SELECTIONS;
1102
  } break;
1103
 
1104
  ///////////////////////////////////////////////////////////////////////////
2545 tk 1105
  case ITEM_MODIFY_PATTERN_BANKS: {
1106
    enabled_value = seq_ui_options.MODIFY_PATTERN_BANKS;
1107
  } break;
1108
 
1109
  ///////////////////////////////////////////////////////////////////////////
2628 tk 1110
  case ITEM_ALL_FOR_STEP_VIEW_ONLY: {
1111
    enabled_value = seq_ui_options.ALL_FOR_STEP_VIEW_ONLY;
1112
  } break;
1113
 
1114
  ///////////////////////////////////////////////////////////////////////////
2564 tk 1115
  case ITEM_PRINT_AND_MODIFY_WITHOUT_GATES: {
1116
    enabled_value = seq_ui_options.PRINT_AND_MODIFY_WITHOUT_GATES;
1117
  } break;
1118
 
1119
  ///////////////////////////////////////////////////////////////////////////
2567 tk 1120
  case ITEM_PRINT_TRANSPOSED_NOTES: {
1121
    enabled_value = seq_ui_options.PRINT_TRANSPOSED_NOTES;
1122
  } break;
1123
 
1124
  ///////////////////////////////////////////////////////////////////////////
2294 tk 1125
  case ITEM_INIT_WITH_TRIGGERS: {
1126
    if( ui_cursor_flash ) {
1127
      SEQ_LCD_PrintSpaces(25);
1128
    } else {
1129
      SEQ_LCD_PrintString(seq_core_options.INIT_WITH_TRIGGERS ? "Set gate on each 4th step" : "Empty                    ");
1130
    }
1131
    SEQ_LCD_PrintSpaces(40-25);
1132
  } break;
1133
 
1134
  ///////////////////////////////////////////////////////////////////////////
1810 tk 1135
  case ITEM_INIT_CC: {
1136
    SEQ_LCD_PrintString(str);
1137
    if( ui_cursor_flash ) {
1138
      SEQ_LCD_PrintSpaces(3);
1139
    } else {
2448 tk 1140
      if( seq_core_options.INIT_CC >= 0x80 ) {
1141
    SEQ_LCD_PrintString("---");
1142
      } else {
1143
    SEQ_LCD_PrintFormattedString("%3d", seq_core_options.INIT_CC);
1144
      }
1810 tk 1145
    }
1146
    SEQ_LCD_PrintSpaces(40-3-len);
1147
  } break;
1148
 
1149
  ///////////////////////////////////////////////////////////////////////////
2552 tk 1150
  case ITEM_DRUM_CC: {
1151
#ifndef MBSEQV4P
1152
    SEQ_LCD_PrintStringPadded("Only supported by V4+ Firmware!", 40);
1153
#else
1154
    SEQ_LCD_PrintString("Drum #");
1155
    if( ui_cursor_flash ) {
1156
      SEQ_LCD_PrintSpaces(2);
1157
    } else {
1158
      SEQ_LCD_PrintFormattedString("%2d", ui_selected_instrument+1);
1159
    }
1160
 
1161
    u8 visible_track = SEQ_UI_VisibleTrackGet();
1162
    seq_cc_trk_t *tcc = &seq_cc_trk[visible_track];
1163
    if( tcc->event_mode == SEQ_EVENT_MODE_Drum ) {
1164
      SEQ_LCD_PrintString(" (");
1165
      if( ui_cursor_flash ) {
1166
    SEQ_LCD_PrintSpaces(5);
1167
      } else {
1168
    SEQ_LCD_PrintTrackDrum(visible_track, ui_selected_instrument, (char *)seq_core_trk[visible_track].name);
1169
      }
1170
      SEQ_LCD_PrintString(")");
1171
    } else {
1172
      SEQ_LCD_PrintSpaces(8);
1173
    }
1174
 
1175
    SEQ_LCD_PrintString("    PLayer:");
1176
    if( ui_cursor_flash ) {
1177
      SEQ_LCD_PrintChar(' ');
1178
    } else {
1179
      SEQ_LCD_PrintChar('A' + ui_selected_par_layer);
1180
    }
1181
 
1182
    SEQ_LCD_PrintString("  CC:#");
1183
    if( ui_cursor_flash ) {
1184
      SEQ_LCD_PrintSpaces(3);
1185
    } else {
1186
      u8 cc = seq_layer_drum_cc[ui_selected_instrument][ui_selected_par_layer];
1187
      if( cc >= 128 ) {
1188
    SEQ_LCD_PrintString("---");
1189
      } else {
1190
    SEQ_LCD_PrintFormattedString("%3d", cc);
1191
      }
1192
    }
1193
 
1194
    SEQ_LCD_PrintSpaces(3);
1195
#endif
1196
  } break;
1197
 
1198
  ///////////////////////////////////////////////////////////////////////////
1810 tk 1199
  case ITEM_LIVE_LAYER_MUTE: {
1200
    SEQ_LCD_PrintString(str);
1201
 
1202
    if( ui_cursor_flash ) {
1203
      SEQ_LCD_PrintSpaces(22);
1204
    } else {
1205
      if( seq_core_options.LIVE_LAYER_MUTE_STEPS == 0 ) {
1206
    SEQ_LCD_PrintStringPadded("do nothing", 22);
1207
      } else if( seq_core_options.LIVE_LAYER_MUTE_STEPS == 1 ) {
1208
    SEQ_LCD_PrintStringPadded("mute the appr. layer", 22);
1209
      } else if( seq_core_options.LIVE_LAYER_MUTE_STEPS == 2 ) {
1210
    SEQ_LCD_PrintStringPadded("mute layer for 1 step ", 22);
1211
      } else {
1212
    SEQ_LCD_PrintFormattedString("mute layer for %d steps", seq_core_options.LIVE_LAYER_MUTE_STEPS-1);
1213
      }
1214
    }
1215
  } break;
1216
 
1217
  ///////////////////////////////////////////////////////////////////////////
1864 tk 1218
  case ITEM_TPD_MODE: {
1219
    if( ui_cursor_flash ) {
2027 tk 1220
      SEQ_LCD_PrintSpaces(40);
1864 tk 1221
    } else {
1222
      const char *tpd_mode_str[SEQ_TPD_NUM_MODES] = {
1223
       //<-------------------------------------->
1224
    "Green LED: Pos      Red LED: Track",
1225
    "Green LED: Pos      Red LED: Track (Rot)",
1226
    "Green LED: Meter    Red LED: Pos",
1227
    "Green LED: Meter    Red LED: Pos   (Rot)",
1228
    "Green LED: DotMeter Red LED: Pos",
1229
    "Green LED: DotMeter Red LED: Pos   (Rot)",
2611 tk 1230
    "Green LED: Logo     Red LED: Logo",
1231
    "Green LED: Logo     Red LED: Beat",
1232
    "Green LED: BPM      Red LED: BPM",
1233
    "Green LED: BPM      Red LED: Beat",
1864 tk 1234
      };
1235
 
1236
      u8 mode = SEQ_TPD_ModeGet();
1237
      if( mode >= SEQ_TPD_NUM_MODES )
1238
    mode = 0;
1239
 
1240
      SEQ_LCD_PrintStringPadded((char *)tpd_mode_str[mode], 40);
1241
    }
1242
  } break;
1243
 
1244
  ///////////////////////////////////////////////////////////////////////////
2609 tk 1245
  case ITEM_SWAP_GP_LED_COLOURS: {
1246
    SEQ_LCD_PrintSpaces(20);
1247
    if( ui_cursor_flash ) {
1248
      SEQ_LCD_PrintSpaces(20);
1249
    } else {
2618 tk 1250
      SEQ_LCD_PrintString(seq_ui_options.SWAP_GP_LED_COLOURS ? "Swap" : "Norm");
1251
      SEQ_LCD_PrintSpaces(1);
1252
      SEQ_LCD_PrintString(seq_ui_options.SWAP_SELECT_LED_COLOURS ? "Swap" : "Norm");
1253
      SEQ_LCD_PrintSpaces(1 + 3);
1254
      SEQ_LCD_PrintString(seq_ui_options.GP_LED_DONT_XOR_POS ? "Off" : "On ");
1255
      SEQ_LCD_PrintSpaces(5);
2609 tk 1256
    }
1257
  } break;
1258
 
1259
  ///////////////////////////////////////////////////////////////////////////
2610 tk 1260
  case ITEM_INVERT_MUTE_LEDS: {
1261
    enabled_value = seq_ui_options.INVERT_MUTE_LEDS;
1262
  } break;
1263
 
1264
  ///////////////////////////////////////////////////////////////////////////
2020 tk 1265
  case ITEM_BLM_ALWAYS_USE_FTS: {
1266
    SEQ_LCD_PrintString(str);
1267
 
1268
    if( ui_cursor_flash ) {
1269
      SEQ_LCD_PrintSpaces(40-len);
1270
    } else {
1271
      SEQ_LCD_PrintStringPadded(seq_blm_options.ALWAYS_USE_FTS ? "yes" : "no", 40-len);
1272
    }
1273
  } break;
1274
 
1275
  ///////////////////////////////////////////////////////////////////////////
2227 tk 1276
  case ITEM_BLM_FADERS: {
1277
    if( ui_cursor_flash ) {
1278
      SEQ_LCD_PrintSpaces(40);
1279
    } else {
1280
      seq_blm_fader_t *fader = &seq_blm_fader[selected_blm_fader];
1281
 
1282
      SEQ_LCD_PrintFormattedString("Fader:%d ", selected_blm_fader+1);
1283
 
1284
      SEQ_LCD_PrintString("Port:");
1285
      if( fader->port == DEFAULT ) {
1286
    SEQ_LCD_PrintString("Trk ");
1287
      } else {
1288
    SEQ_LCD_PrintString(SEQ_MIDI_PORT_OutNameGet(SEQ_MIDI_PORT_OutIxGet(fader->port)));
1289
      }
1290
 
1291
      SEQ_LCD_PrintString(" Chn:");
1292
      if( fader->chn == 0 ) {
1293
    SEQ_LCD_PrintString("Trk");
1294
      } else {
1295
    SEQ_LCD_PrintFormattedString("%2d ", fader->chn);
1296
      }
1297
      SEQ_LCD_PrintString(" Send:");
1298
 
1299
      if( fader->send_function < 128 ) {
2228 tk 1300
    SEQ_LCD_PrintFormattedString("CC#%3d   ", fader->send_function);
1301
      } else if( fader->send_function < 256 ) {
1302
    SEQ_LCD_PrintFormattedString("CC#%3dInv", fader->send_function - 128);
2227 tk 1303
      } else {
2228 tk 1304
    SEQ_LCD_PrintFormattedString("TODO#%3d ", fader->send_function & 0x7f);
2227 tk 1305
      }
1306
    }
1307
  } break;
1308
 
1309
  ///////////////////////////////////////////////////////////////////////////
2027 tk 1310
  case ITEM_MIXER_CC1234: {
1311
    if( ui_cursor_flash ) {
1312
      SEQ_LCD_PrintSpaces(40);
1313
    } else {
1314
      SEQ_LCD_PrintFormattedString(" CC1:%s   CC2:%s   CC3:%s   CC4:%s  ",
1315
                   (seq_mixer_cc1234_before_pc & 0x1) ? " no" : "yes",
1316
                   (seq_mixer_cc1234_before_pc & 0x2) ? " no" : "yes",
1317
                   (seq_mixer_cc1234_before_pc & 0x4) ? " no" : "yes",
1318
                   (seq_mixer_cc1234_before_pc & 0x8) ? " no" : "yes");
1319
    }
1320
  } break;
1321
 
1322
  ///////////////////////////////////////////////////////////////////////////
2542 tk 1323
  case ITEM_MENU_SHORTCUTS: {
1324
    SEQ_LCD_PrintString(str);
1325
 
1326
    if( ui_cursor_flash ) {
1327
      SEQ_LCD_PrintSpaces(4);
1328
    } else {
1329
      SEQ_LCD_PrintFormattedString("%2d  ", selected_menu_assignment_button+1);
1330
    }
1331
 
1332
    if( ui_cursor_flash ) {
1333
      SEQ_LCD_PrintSpaces(25);
1334
    } else {
1335
      seq_ui_page_t page = SEQ_UI_PAGES_MenuShortcutPageGet(selected_menu_assignment_button);
1336
      SEQ_LCD_PrintString(SEQ_UI_PAGES_MenuShortcutNameGet(selected_menu_assignment_button));
1337
      SEQ_LCD_PrintString(": ");
1338
      SEQ_LCD_PrintStringPadded((char *)SEQ_UI_PAGES_PageNameGet(page), 18);
1339
    }
1340
 
1341
  } break;
1342
 
1343
  ///////////////////////////////////////////////////////////////////////////
2130 tk 1344
  case ITEM_SCREEN_SAVER: {
1345
    if( !seq_lcd_logo_screensaver_delay ) {
1346
      if( ui_cursor_flash ) {
1347
    SEQ_LCD_PrintSpaces(3);
1348
      } else {
1349
    SEQ_LCD_PrintString("off");
1350
      }
1351
      SEQ_LCD_PrintSpaces(40-3);
1352
    } else {
1353
      int delay_len;
1354
      if( seq_lcd_logo_screensaver_delay < 10 )
1355
    delay_len = 1;
1356
      else if( seq_lcd_logo_screensaver_delay < 100 )
1357
    delay_len = 2;
1358
      else
1359
    delay_len = 3;
1360
 
1361
      SEQ_LCD_PrintString("after ");
1362
      if( ui_cursor_flash ) {
1363
    SEQ_LCD_PrintSpaces(delay_len);
1364
      } else {
1365
    SEQ_LCD_PrintFormattedString("%d", seq_lcd_logo_screensaver_delay);
1366
      }
1367
      SEQ_LCD_PrintString(" minutes");
1368
      SEQ_LCD_PrintSpaces(40-6-delay_len-8);
1369
    }
1370
  } break;
1371
 
1372
  ///////////////////////////////////////////////////////////////////////////
1810 tk 1373
  default:
1374
    SEQ_LCD_PrintSpaces(40);
1794 tk 1375
  }
1810 tk 1376
  ///////////////////////////////////////////////////////////////////////////
1377
  ///////////////////////////////////////////////////////////////////////////
1205 tk 1378
 
1794 tk 1379
 
1810 tk 1380
  // for cheap enabled/disabled
1381
  if( enabled_value >= 0 ) {
1382
    if( ui_cursor_flash ) {
1383
      SEQ_LCD_PrintSpaces(40);
1384
    } else {
1385
      SEQ_LCD_PrintStringPadded(enabled_value ? "enabled" : "disabled", 40);
1386
    }
1387
  }
1388
 
240 tk 1389
  return 0; // no error
1390
}
1391
 
1392
 
1393
/////////////////////////////////////////////////////////////////////////////
352 tk 1394
// Local exit function
1395
/////////////////////////////////////////////////////////////////////////////
1396
static s32 EXIT_Handler(void)
1397
{
513 tk 1398
  s32 status = 0;
352 tk 1399
 
2102 tk 1400
  if( ui_store_file_required ) {
1052 tk 1401
    // write config files
513 tk 1402
    MUTEX_SDCARD_TAKE;
1123 tk 1403
    if( (status=SEQ_FILE_C_Write(seq_file_session_name)) < 0 )
513 tk 1404
      SEQ_UI_SDCardErrMsg(2000, status);
1405
    MUTEX_SDCARD_GIVE;
352 tk 1406
 
1052 tk 1407
    MUTEX_SDCARD_TAKE;
1408
    if( (status=SEQ_FILE_GC_Write()) < 0 )
1409
      SEQ_UI_SDCardErrMsg(2000, status);
1410
    MUTEX_SDCARD_GIVE;
1411
 
2102 tk 1412
    ui_store_file_required = 0;
513 tk 1413
  }
1414
 
352 tk 1415
  return status;
1416
}
1417
 
1418
 
1419
/////////////////////////////////////////////////////////////////////////////
240 tk 1420
// Initialisation
1421
/////////////////////////////////////////////////////////////////////////////
1422
s32 SEQ_UI_OPT_Init(u32 mode)
1423
{
1424
  // install callback routines
1425
  SEQ_UI_InstallButtonCallback(Button_Handler);
1426
  SEQ_UI_InstallEncoderCallback(Encoder_Handler);
1427
  SEQ_UI_InstallLEDCallback(LED_Handler);
1428
  SEQ_UI_InstallLCDCallback(LCD_Handler);
352 tk 1429
  SEQ_UI_InstallExitCallback(EXIT_Handler);
240 tk 1430
 
1431
  return 0; // no error
1432
}