source: buchla-68k/ram/scfield.c@ 9519422

Last change on this file since 9519422 was 9519422, checked in by Thomas Lopatic <thomas@…>, 7 years ago

Strip trailing tabs and spaces.
  • Property mode set to 100644
File size: 23.8 KB
Line 
1/*
2 =============================================================================
3 scfield.c -- score editor field setup
4 Version 62 -- 1989-11-15 -- D.N. Lynx Crowe
5 =============================================================================
6*/
7
8#include "stddefs.h"
9#include "fields.h"
10#include "vsdd.h"
11#include "graphdef.h"
12#include "hwdefs.h"
13#include "panel.h"
14#include "macros.h"
15#include "score.h"
16#include "scfns.h"
17#include "curpak.h"
18
19#include "midas.h"
20#include "scdsp.h"
21
22#define PCENTER 256L
23
24/* functions defined elsewhere */
25
26extern void *memset(void *vp, int8_t c, int16_t n);
27
28extern void cxkstd(void);
29extern void cykstd(void);
30extern void select(void);
31extern int16_t oktode(struct s_entry *ep);
32extern int16_t stdctp3(void);
33extern void stddkey(int16_t k);
34extern void nokey(void);
35extern void stdmkey(void);
36
37extern int16_t et_strn(int16_t n);
38extern int16_t ef_strn(int16_t n);
39extern int16_t rd_strn(int16_t n);
40extern int16_t nd_strn(int16_t n, int16_t k);
41extern int16_t et_snbt(int16_t n);
42extern int16_t ef_snbt(int16_t n);
43extern int16_t rd_snbt(int16_t n);
44extern int16_t nd_snbt(int16_t n, int16_t k);
45
46extern int16_t et_ioas(int16_t n);
47extern int16_t ef_ioas(int16_t n);
48extern int16_t rd_ioas(int16_t n);
49extern int16_t nd_ioas(int16_t n, int16_t k);
50extern int16_t et_tune(int16_t n);
51extern int16_t ef_tune(int16_t n);
52extern int16_t rd_tune(int16_t n);
53extern int16_t nd_tune(int16_t n, int16_t k);
54extern int16_t et_tmpo(int16_t n);
55extern int16_t ef_tmpo(int16_t n);
56extern int16_t rd_tmpo(int16_t n);
57extern int16_t nd_tmpo(int16_t n, int16_t k);
58extern int16_t et_intp(int16_t n);
59extern int16_t ef_intp(int16_t n);
60extern int16_t rd_intp(int16_t n);
61extern int16_t nd_intp(int16_t n, int16_t k);
62
63extern int16_t et_inst(int16_t n);
64extern int16_t ef_inst(int16_t n);
65extern int16_t rd_inst(int16_t n);
66extern int16_t nd_inst(int16_t n, int16_t k);
67extern int16_t et_trns(int16_t n);
68extern int16_t ef_trns(int16_t n);
69extern int16_t rd_trns(int16_t n);
70extern int16_t nd_trns(int16_t n, int16_t k);
71extern int16_t et_dyn(int16_t n);
72extern int16_t ef_dyn(int16_t n);
73extern int16_t rd_dyn(int16_t n);
74extern int16_t nd_dyn(int16_t n, int16_t k);
75extern int16_t et_loc(int16_t n);
76extern int16_t ef_loc(int16_t n);
77extern int16_t rd_loc(int16_t n);
78extern int16_t nd_loc(int16_t n, int16_t k);
79extern int16_t et_vel(int16_t n);
80extern int16_t ef_vel(int16_t n);
81extern int16_t rd_vel(int16_t n);
82extern int16_t nd_vel(int16_t n, int16_t k);
83
84extern int16_t et_res1(int16_t n);
85extern int16_t ef_res1(int16_t n);
86extern int16_t rd_res1(int16_t n);
87extern int16_t nd_res1(int16_t n, int16_t k);
88extern int16_t et_aval(int16_t n);
89extern int16_t ef_aval(int16_t n);
90extern int16_t rd_aval(int16_t n);
91extern int16_t nd_aval(int16_t n, int16_t k);
92extern int16_t et_agrp(int16_t n);
93extern int16_t ef_agrp(int16_t n);
94extern int16_t rd_agrp(int16_t n);
95extern int16_t nd_agrp(int16_t n, int16_t k);
96
97extern int16_t et_scor(int16_t n);
98extern int16_t ef_scor(int16_t n);
99extern int16_t rd_scor(int16_t n);
100extern int16_t nd_scor(int16_t n, int16_t k);
101
102/* forward references */
103
104int16_t et_null(int16_t n);
105int16_t ef_null(int16_t n);
106int16_t rd_null(int16_t n);
107int16_t nd_null(int16_t n, int16_t k);
108void sdcxu(void);
109void sdcyu(void);
110void sdxkey(void);
111void sdmkey(void);
112int16_t scntfld(int16_t k);
113
114/*
115
116*/
117
118/* variables defined elsewhere */
119
120extern int16_t ancmsw;
121extern int16_t angroup;
122extern int16_t astat;
123extern int16_t clkrun;
124extern int16_t cmfirst;
125extern int16_t cmtype;
126extern int16_t curhold;
127extern int16_t curscor;
128extern int16_t cxrate;
129extern int16_t cxval;
130extern int16_t cyrate;
131extern int16_t cyval;
132extern int16_t ebflag;
133extern int16_t hcwval;
134extern int16_t insmode;
135extern int16_t oldpk;
136extern int16_t oldsl;
137extern int16_t pkctrl;
138extern int16_t recsw;
139extern int16_t scmctl;
140extern int16_t sdmctl;
141extern int16_t sliders;
142extern int16_t stccol;
143extern int16_t stcrow;
144extern int16_t thcwval;
145extern int16_t tvcwval;
146extern int16_t vcwval;
147extern int16_t vtccol;
148extern int16_t vtcrow;
149extern int16_t vtxval;
150extern int16_t vtyval;
151
152extern int32_t ctime;
153extern int32_t t_ins;
154
155extern int8_t ebuf[MAXEBUF+1];
156
157extern int16_t crate1[];
158extern int16_t ehdlist[];
159extern int16_t grpmode[];
160extern int16_t grpstat[];
161extern int16_t grptmap[];
162extern int16_t sdmlim[][4];
163extern int16_t varmode[8][16];
164
165extern LPF (*swpt)[];
166extern LPF (*oldsw)[];
167
168extern struct fet *cfetp;
169extern struct fet *curfet;
170extern struct fet *infetp;
171
172extern struct selbox *csbp;
173
174extern struct selbox sdboxes[];
175
176extern struct s_entry *peg;
177
178/*
179
180*/
181
182struct fet sc_fet1[] = {
183
184 { 0, 2, 4, 0x0000, et_strn, ef_strn, rd_strn, nd_strn},
185 { 0, 11, 15, 0x0000, et_snbt, ef_snbt, rd_snbt, nd_snbt},
186
187 {17, 11, 12, 0x0000, et_ioas, ef_ioas, rd_ioas, nd_ioas},
188 {17, 19, 19, 0x0000, et_tune, ef_tune, rd_tune, nd_tune},
189 {17, 27, 29, 0x0000, et_tmpo, ef_tmpo, rd_tmpo, nd_tmpo},
190 {17, 35, 38, 0x0000, et_intp, ef_intp, rd_intp, nd_intp},
191
192 {18, 7, 8, 0, et_inst, ef_inst, rd_inst, nd_inst},
193 {18, 12, 13, 1, et_inst, ef_inst, rd_inst, nd_inst},
194 {18, 17, 18, 2, et_inst, ef_inst, rd_inst, nd_inst},
195 {18, 22, 23, 3, et_inst, ef_inst, rd_inst, nd_inst},
196 {18, 27, 28, 4, et_inst, ef_inst, rd_inst, nd_inst},
197 {18, 32, 33, 5, et_inst, ef_inst, rd_inst, nd_inst},
198 {18, 37, 38, 6, et_inst, ef_inst, rd_inst, nd_inst},
199 {18, 42, 43, 7, et_inst, ef_inst, rd_inst, nd_inst},
200 {18, 47, 48, 8, et_inst, ef_inst, rd_inst, nd_inst},
201 {18, 52, 53, 9, et_inst, ef_inst, rd_inst, nd_inst},
202 {18, 57, 58, 10, et_inst, ef_inst, rd_inst, nd_inst},
203 {18, 62, 63, 11, et_inst, ef_inst, rd_inst, nd_inst},
204
205 {19, 5, 8, 0, et_trns, ef_trns, rd_trns, nd_trns},
206 {19, 10, 13, 1, et_trns, ef_trns, rd_trns, nd_trns},
207 {19, 15, 18, 2, et_trns, ef_trns, rd_trns, nd_trns},
208 {19, 20, 23, 3, et_trns, ef_trns, rd_trns, nd_trns},
209 {19, 25, 28, 4, et_trns, ef_trns, rd_trns, nd_trns},
210 {19, 30, 33, 5, et_trns, ef_trns, rd_trns, nd_trns},
211 {19, 35, 38, 6, et_trns, ef_trns, rd_trns, nd_trns},
212 {19, 40, 43, 7, et_trns, ef_trns, rd_trns, nd_trns},
213 {19, 45, 48, 8, et_trns, ef_trns, rd_trns, nd_trns},
214 {19, 50, 53, 9, et_trns, ef_trns, rd_trns, nd_trns},
215 {19, 55, 58, 10, et_trns, ef_trns, rd_trns, nd_trns},
216 {19, 60, 63, 11, et_trns, ef_trns, rd_trns, nd_trns},
217
218/*
219
220*/
221
222 {20, 6, 6, 0, et_dyn, ef_dyn, rd_dyn, nd_dyn},
223 {20, 8, 8, 0, et_loc, ef_loc, rd_loc, nd_loc},
224
225 {20, 11, 11, 1, et_dyn, ef_dyn, rd_dyn, nd_dyn},
226 {20, 13, 13, 1, et_loc, ef_loc, rd_loc, nd_loc},
227
228 {20, 16, 16, 2, et_dyn, ef_dyn, rd_dyn, nd_dyn},
229 {20, 18, 18, 2, et_loc, ef_loc, rd_loc, nd_loc},
230
231 {20, 21, 21, 3, et_dyn, ef_dyn, rd_dyn, nd_dyn},
232 {20, 23, 23, 3, et_loc, ef_loc, rd_loc, nd_loc},
233
234 {20, 26, 26, 4, et_dyn, ef_dyn, rd_dyn, nd_dyn},
235 {20, 28, 28, 4, et_loc, ef_loc, rd_loc, nd_loc},
236
237 {20, 31, 31, 5, et_dyn, ef_dyn, rd_dyn, nd_dyn},
238 {20, 33, 33, 5, et_loc, ef_loc, rd_loc, nd_loc},
239
240 {20, 36, 36, 6, et_dyn, ef_dyn, rd_dyn, nd_dyn},
241 {20, 38, 38, 6, et_loc, ef_loc, rd_loc, nd_loc},
242
243 {20, 41, 41, 7, et_dyn, ef_dyn, rd_dyn, nd_dyn},
244 {20, 43, 43, 7, et_loc, ef_loc, rd_loc, nd_loc},
245
246 {20, 46, 46, 8, et_dyn, ef_dyn, rd_dyn, nd_dyn},
247 {20, 48, 48, 8, et_loc, ef_loc, rd_loc, nd_loc},
248
249 {20, 51, 51, 9, et_dyn, ef_dyn, rd_dyn, nd_dyn},
250 {20, 53, 53, 9, et_loc, ef_loc, rd_loc, nd_loc},
251
252 {20, 56, 56, 10, et_dyn, ef_dyn, rd_dyn, nd_dyn},
253 {20, 58, 58, 10, et_loc, ef_loc, rd_loc, nd_loc},
254
255 {20, 61, 61, 11, et_dyn, ef_dyn, rd_dyn, nd_dyn},
256 {20, 63, 63, 11, et_loc, ef_loc, rd_loc, nd_loc},
257
258/*
259
260*/
261
262 {21, 6, 8, 0, et_vel, ef_vel, rd_vel, nd_vel},
263 {21, 11, 13, 1, et_vel, ef_vel, rd_vel, nd_vel},
264 {21, 16, 18, 2, et_vel, ef_vel, rd_vel, nd_vel},
265 {21, 21, 23, 3, et_vel, ef_vel, rd_vel, nd_vel},
266 {21, 26, 28, 4, et_vel, ef_vel, rd_vel, nd_vel},
267 {21, 31, 33, 5, et_vel, ef_vel, rd_vel, nd_vel},
268 {21, 36, 38, 6, et_vel, ef_vel, rd_vel, nd_vel},
269 {21, 41, 43, 7, et_vel, ef_vel, rd_vel, nd_vel},
270 {21, 46, 48, 8, et_vel, ef_vel, rd_vel, nd_vel},
271 {21, 51, 53, 9, et_vel, ef_vel, rd_vel, nd_vel},
272 {21, 56, 58, 10, et_vel, ef_vel, rd_vel, nd_vel},
273 {21, 61, 63, 11, et_vel, ef_vel, rd_vel, nd_vel},
274
275
276 {23, 6, 6, 0, et_res1, ef_res1, rd_res1, nd_res1},
277 {23, 8, 12, 0, et_aval, ef_aval, rd_aval, nd_aval},
278
279 {23, 15, 15, 1, et_res1, ef_res1, rd_res1, nd_res1},
280 {23, 17, 21, 1, et_aval, ef_aval, rd_aval, nd_aval},
281
282 {23, 24, 24, 2, et_res1, ef_res1, rd_res1, nd_res1},
283 {23, 26, 30, 2, et_aval, ef_aval, rd_aval, nd_aval},
284
285 {23, 33, 33, 3, et_res1, ef_res1, rd_res1, nd_res1},
286 {23, 35, 39, 3, et_aval, ef_aval, rd_aval, nd_aval},
287
288 {23, 42, 42, 4, et_res1, ef_res1, rd_res1, nd_res1},
289 {23, 44, 48, 4, et_aval, ef_aval, rd_aval, nd_aval},
290
291 {23, 51, 51, 5, et_res1, ef_res1, rd_res1, nd_res1},
292 {23, 53, 57, 5, et_aval, ef_aval, rd_aval, nd_aval},
293
294 {23, 61, 62, 0, et_agrp, ef_agrp, rd_agrp, nd_agrp},
295
296 {24, 7, 8, 0x0000, et_scor, ef_scor, rd_scor, nd_scor},
297 {24, 10, 25, 0x0000, et_null, ef_null, rd_null, nd_null},
298
299
300 { 0, 0, 0, 0x0000, FN_NULL, FN_NULL, FN_NULL, FN_NULL}
301};
302
303/*
304
305*/
306
307struct curpak sc_flds = {
308
309 stdctp3, /* curtype */
310 nokey, /* premove */
311 nokey, /* pstmove */
312 cxkstd, /* cx_key */
313 cykstd, /* cy_key */
314 sdcxu, /* cx_upd */
315 sdcyu, /* cy_upd */
316 nokey, /* xy_up */
317 nokey, /* xy_dn */
318 sdxkey, /* x_key */
319 select, /* e_key */
320 sdmkey, /* m_key */
321 stddkey, /* d_key */
322 scntfld, /* not_fld */
323 sc_fet1, /* curfet */
324 sdboxes, /* csbp */
325 crate1, /* cratex */
326 crate1, /* cratey */
327 CT_GRAF, /* cmtype */
328 C1X, /* cxval */
329 C1Y /* cyval */
330};
331
332/*
333
334*/
335
336/*
337 =============================================================================
338 et_null() .. nd_null() -- null data entry key processors
339 =============================================================================
340*/
341
342int16_t et_null(int16_t n)
343{
344 return(SUCCESS);
345}
346
347int16_t ef_null(int16_t n)
348{
349 return(SUCCESS);
350}
351
352int16_t rd_null(int16_t n)
353{
354 return(SUCCESS);
355}
356
357int16_t nd_null(int16_t n, int16_t k)
358{
359 return(SUCCESS);
360}
361
362/*
363
364*/
365
366/*
367 =============================================================================
368 istart() -- start insert mode
369 =============================================================================
370*/
371
372void istart(void)
373{
374 register struct s_entry *ep, *pp, *tp;
375
376 if (insmode) /* can't already be inserting */
377 return;
378
379 ep = ep_adj(p_cur, 1, t_cur); /* locate tail */
380
381 if (EV_SCORE EQ (0x007F & ep->e_type)) /* skip begin score event */
382 ep = ep->e_fwd;
383
384 if (EV_FINI EQ (0x007F & ep->e_type)) /* null if at end of score */
385 return;
386
387 tp = scores[curscor]->e_bak; /* locate end of score */
388 pp = ep->e_bak; /* locate end of head */
389
390 ep->e_bak = E_NULL; /* unhook tail from head */
391 pp->e_fwd = tp; /* unhook head from tail */
392 (tp->e_bak)->e_fwd = E_NULL; /* unhook tail from end */
393
394 tp->e_bak = pp; /* connect end to head */
395
396 t_ins = t_cur; /* record tail time */
397 peg = ep; /* hang tail on peg */
398
399 p_cur = ep_adj(pp, 0, t_cur); /* adjust p_cur */
400 p_ctr = p_cur; /* adjust p_ctr */
401 p_bak = ep_adj(p_cur, 0, t_bak); /* adjust p_bak */
402 p_fwd = ep_adj(p_cur, 0, t_fwd); /* adjust p_fwd */
403
404 insmode = TRUE;
405}
406
407/*
408
409*/
410
411/*
412 =============================================================================
413 icancel() -- cancel insert mode
414 =============================================================================
415*/
416
417void icancel(void)
418{
419 register struct s_entry *ep, *tp, *rp;
420 struct s_entry *pp;
421 int32_t endtime;
422
423 if (NOT insmode)
424 return;
425
426 tp = scores[curscor]->e_bak; /* locate end of score */
427 pp = tp->e_bak; /* locate end of head */
428
429 endtime = pp->e_time; /* find last time in score */
430
431 if (t_cur > endtime) /* use max of t_cur, endtime */
432 endtime = t_cur;
433
434 rp = peg; /* point at start of tail */
435
436 while (E_NULL NE rp) { /* scan each event in the tail */
437
438 ep = rp; /* update pointers */
439 rp = ep->e_fwd;
440
441 ep->e_time = (ep->e_time - t_ins) + endtime; /* adjust time */
442 }
443
444 ep->e_fwd = tp; /* connect tail to end */
445 tp->e_bak = ep; /* connect end to tail */
446
447 pp->e_fwd = peg; /* connect head to tail */
448 peg->e_bak = pp; /* connect tail to head */
449
450 p_cur = ep_adj(pp, 0, t_cur); /* adjust p_cur */
451 p_ctr = p_cur; /* adjust p_ctr */
452 p_bak = ep_adj(p_cur, 0, t_bak); /* adjust p_bak */
453 p_fwd = ep_adj(p_cur, 0, t_fwd); /* adjust p_fwd */
454
455 insmode = FALSE;
456}
457
458/*
459
460*/
461
462/*
463 =============================================================================
464 sdcxu() -- score cursor x update processing
465 =============================================================================
466*/
467
468void sdcxu(void)
469{
470 if (sdmctl EQ 0) { /* typewriter up */
471
472 vtcxupd();
473
474 } else if (sdmctl > 0) { /* menu up */
475
476 vtccol = XTOC(vtxval += cxrate);
477
478 if (vtccol > sdmlim[sdmctl][3])
479 vtxval = CTOX(vtccol = sdmlim[sdmctl][3]);
480 else if (vtccol < sdmlim[sdmctl][1])
481 vtxval = CTOX(vtccol = sdmlim[sdmctl][1]);
482
483 } else { /* no menu showing */
484
485 cxval += cxrate;
486
487 if (cxval > CXMAX)
488 cxval = CXMAX;
489 else if (cxval < 0)
490 cxval = 0;
491 }
492
493 return;
494}
495
496/*
497
498*/
499
500/*
501 =============================================================================
502 sdcyu() -- score cursor y update processing
503 =============================================================================
504*/
505
506void sdcyu(void)
507{
508 if (sdmctl EQ 0) {
509
510 vtcyupd();
511
512 } else if (sdmctl > 0) { /* menu up */
513
514 vtcrow = YTOR(vtyval += cyrate);
515
516 if (vtcrow < sdmlim[sdmctl][0])
517 vtyval = RTOY(vtcrow = sdmlim[sdmctl][0]);
518 else if (vtcrow > sdmlim[sdmctl][2])
519 vtyval = RTOY(vtcrow = sdmlim[sdmctl][2]);
520
521 } else { /* no menu showing */
522
523 cyval += cyrate;
524
525 if (cyval > CYMAX)
526 cyval = CYMAX;
527 else if (cyval < 0)
528 cyval = 0;
529
530 }
531
532 return;
533}
534
535/*
536
537*/
538
539/*
540 =============================================================================
541 scntfld() -- not-in-field data entry key processing
542 =============================================================================
543*/
544
545int16_t scntfld(int16_t k)
546{
547 register int16_t grp, fnc, var;
548
549 if (NOT astat)
550 return(FAILURE);
551
552 if (stcrow EQ 18) { /* group status or mode */
553
554 if (stccol LT 5)
555 return(FAILURE);
556
557 grp = (stccol - 5) / 5; /* group */
558 fnc = (stccol - 5) % 5; /* status or mode */
559
560 if (fnc EQ 0) { /* status */
561
562 if (k EQ 8) { /* '-' */
563
564 grpstat[grp] = FALSE;
565 dsgstat(grp);
566 return(SUCCESS);
567
568 } else if (k EQ 9) { /* '+' */
569
570 grpstat[grp] = TRUE;
571 dsgstat(grp);
572 return(SUCCESS);
573
574 } else
575 return(FAILURE);
576/*
577
578*/
579 } else if (fnc EQ 1) { /* mode */
580
581 if (k EQ 8) { /* '-' */
582
583 grpmode[grp] = 0;
584 dsgmode(grp);
585 return(SUCCESS);
586
587 } else if (k EQ 9) { /* '+' */
588
589 if (++grpmode[grp] GT 1)
590 grpmode[grp] = 2;
591
592 dsgmode(grp);
593 return(SUCCESS);
594
595 } else
596 return(FAILURE);
597
598 } else
599 return(FAILURE);
600/*
601
602*/
603 } else if (stcrow EQ 22) { /* analog variables */
604
605 if (stccol < 5)
606 return(FAILURE);
607
608 var = (stccol - 5) / 9; /* variable */
609 fnc = (stccol - 5) % 9; /* field column */
610 grp = abs(angroup) - 1; /* group */
611
612 if (fnc EQ 0) { /* mode column */
613
614 if (k EQ 8) { /* '-' */
615
616 varmode[var][grp] = 0;
617 dsvmode(var);
618 return(SUCCESS);
619
620 } else if (k EQ 9) { /* '+' */
621
622 if (++varmode[var][grp] GT 1)
623 varmode[var][grp] = 2;
624
625 dsvmode(var);
626 return(SUCCESS);
627 }
628 }
629 }
630
631 return(FAILURE);
632}
633
634/*
635
636*/
637
638/*
639 =============================================================================
640 cp2time() -- check cursor position and convert it to time
641
642 Sets 'ctime' if the cursor x argument, 'cx', is within the score.
643 =============================================================================
644*/
645
646int16_t cp2time(int16_t cx)
647{
648 register int32_t ct;
649
650 ct = t_cur + ((int32_t)cx - PCENTER);
651
652 if (ct < 0L) /* if out of score time range */
653 return(FALSE); /* ... return FALSE */
654
655 ctime = ct; /* set ctime */
656 return(TRUE); /* ... and return TRUE */
657}
658
659/*
660
661*/
662
663/*
664 =============================================================================
665 delevts() -- delete record enabled non-note events at current time
666 =============================================================================
667*/
668
669int16_t delevts(int16_t etp, int32_t thetime)
670{
671 register struct s_entry *ep, *np;
672 register int16_t et;
673 register int16_t rc;
674 register int16_t dsw;
675
676 rc = FALSE; /* intialize return code */
677
678 ep = ep_adj(p_cur, 1, thetime); /* start at left end of chain */
679
680/*
681
682*/
683 while (ep->e_time EQ thetime) { /* for each event at ctime ... */
684
685 np = ep->e_fwd; /* get next event pointer */
686 et = 0x007F & ep->e_type; /* get type */
687 dsw = oktode(ep); /* get deletion status */
688
689 if (dsw AND /* delete event if it's deletable ... */
690 ((etp EQ -1) OR (et EQ etp))) { /* ... and the right kind */
691
692 rc = TRUE;
693
694 if (-1 NE ehdlist[et]) /* if this is a header event ... */
695 eh_rmv(ep, ehdlist[et]); /* remove from hdr list */
696
697 /* fix up any effected pointers */
698
699 if (p_bak EQ ep)
700 p_bak = np;
701
702 if (p_cur EQ ep)
703 p_cur = np;
704
705 if (p_ctr EQ ep)
706 p_ctr = np;
707
708 if (p_fwd EQ ep)
709 p_fwd = np;
710
711 e_del(e_rmv(ep)); /* delete the event */
712 }
713
714 ep = np;
715 }
716
717 if (rc) /* if anything was deleted ... */
718 sc_refr(t_cur); /* ... update the display */
719
720 return(rc);
721}
722
723/*
724
725*/
726
727/*
728 =============================================================================
729 deladat() -- delete analog varaible data
730 =============================================================================
731*/
732
733int16_t deladat(void)
734{
735 register struct s_entry *ep, *rp;
736 register int16_t grp, rc, var, vc, vn;
737
738 rc = FALSE;
739
740 if (stccol < 6) /* pointing at var ? */
741 return(rc);
742
743 vn = (stccol - 6) / 9; /* variable number */
744 vc = (stccol - 6) % 9; /* variable column */
745
746 ep = ep_adj(p_cur, 1, t_cur); /* start at left end of chain */
747
748 if (vc EQ 0) { /* resolution */
749
750 while (t_cur EQ ep->e_time) {
751
752 rp = ep->e_fwd;
753
754 if (EV_ANRS EQ (0x007F & ep->e_type)) {
755
756 grp = 0x000F & ep->e_data1;
757 var = 0x000F & (ep->e_data1 >> 4);
758
759 if ((var EQ vn) AND grpstat[grp] AND
760 (2 EQ (ancmsw ? varmode[var][grp] :
761 grpmode[grp]))) {
762
763 /* fix pointers */
764
765 if (p_bak EQ ep)
766 p_bak = rp;
767
768 if (p_cur EQ ep)
769 p_cur = rp;
770
771 if (p_ctr EQ ep)
772 p_ctr = rp;
773
774 if (p_fwd EQ ep)
775 p_fwd = rp;
776
777 /* delete event */
778
779 eh_rmv(ep, EH_ANRS);
780 e_del(e_rmv(ep));
781 rc = TRUE;
782 }
783 }
784
785 ep = rp; /* next event */
786 }
787/*
788
789*/
790 } else if ((vc GE 2) AND (vc LE 6)) { /* value */
791
792 while (t_cur EQ ep->e_time) {
793
794 rp = ep->e_fwd;
795
796 if (EV_ANVL EQ (0x007F & ep->e_type)) {
797
798 grp = 0x000F & ep->e_data1;
799 var = 0x000F & (ep->e_data1 >> 4);
800
801 if ((var EQ vn) AND grpstat[grp] AND
802 (2 EQ (ancmsw ? varmode[var][grp] :
803 grpmode[grp]))) {
804
805 /* fix pointers */
806
807 if (p_bak EQ ep)
808 p_bak = rp;
809
810 if (p_cur EQ ep)
811 p_cur = rp;
812
813 if (p_ctr EQ ep)
814 p_ctr = rp;
815
816 if (p_fwd EQ ep)
817 p_fwd = rp;
818
819 e_del(e_rmv(ep)); /* delete */
820 rc = TRUE;
821 }
822 }
823
824 ep = rp; /* next event */
825 }
826 }
827
828 if (rc) { /* refresh the screen if it changed */
829
830 sc_refr(fc_val);
831 ds_anrs();
832 ds_anvl();
833 }
834
835 return(rc);
836}
837
838/*
839
840*/
841
842/*
843 =============================================================================
844 sdxkey() -- score delete key processing
845 =============================================================================
846*/
847
848void sdxkey(void)
849{
850 register int16_t col, grp, sect;
851 register struct s_entry *ep, *rp;
852
853 if (NOT astat) /* only do when key goes down */
854 return;
855
856 if (clkrun) /* ... and not while clock is running */
857 return;
858
859 if (scmctl NE -1) /* ... and area 1 menu is down */
860 return;
861/*
862
863*/
864 if (sdmctl EQ 4) { /* section menu is up */
865
866 if (((vtcrow EQ 19) OR (vtcrow EQ 20)) AND
867 (vtccol GE 24)) {
868
869 if (NOT recsw)
870 return;
871
872 /* set up to delete a section marker */
873
874 sect = ((vtccol - 24) >> 2) + ((vtcrow EQ 20) ? 10 : 0);
875 col = (vtccol - 24) & 3;
876
877 switch (col) {
878
879 case 0: /* delete begin section */
880
881
882 if (E_NULL NE (ep = seclist[curscor][sect])) {
883
884 /* fix pointers */
885
886 rp = ep->e_fwd;
887
888 if (p_bak EQ ep)
889 p_bak = rp;
890
891 if (p_cur EQ ep)
892 p_cur = rp;
893
894 if (p_ctr EQ ep)
895 p_ctr = rp;
896
897 if (p_fwd EQ ep)
898 p_fwd = rp;
899
900 eh_rmv(ep, EH_SBGN); /* delete */
901 e_del(e_rmv(ep));
902 seclist[curscor][sect] = E_NULL;
903 sdmenu(-1); /* take down menu */
904 sc_refr(fc_val); /* refresh screen */
905 }
906
907 break;
908/*
909
910*/
911 case 1: /* section number */
912 case 2:
913 break;
914
915 case 3: /* delete end section */
916
917 if (E_NULL NE
918 (ep = ehfind(EV_SEND, -1L, sect, -1))) {
919
920 /* fix pointers */
921
922 rp = ep->e_fwd;
923
924 if (p_bak EQ ep)
925 p_bak = rp;
926
927 if (p_cur EQ ep)
928 p_cur = rp;
929
930 if (p_ctr EQ ep)
931 p_ctr = rp;
932
933 if (p_fwd EQ ep)
934 p_fwd = rp;
935
936 eh_rmv(ep, EH_SEND); /* delete */
937 e_del(e_rmv(ep));
938 sdmenu(-1); /* take down menu */
939 sc_refr(fc_val); /* refresh screen */
940 }
941
942 break;
943 }
944
945 return;
946
947/*
948
949*/
950 } else if ((vtcrow EQ 23) AND
951 (vtccol GE 28) AND (vtccol LE 62)) {
952
953 /* group map entry */
954
955 col = vtccol - 28;
956
957 if (2 EQ (col % 3))
958 return;
959
960 grp = col / 3;
961 grptmap[grp] = -1;
962 dsgtme(grp);
963 return;
964 }
965 }
966
967 if (NOT recsw) /* do only if recording */
968 return;
969
970 if ((cyval GE 14) AND (cyval LE 223)) { /* notes */
971
972 delnote(); /* delete a note */
973
974 } else if ((cyval GE 224) AND (cyval LE 237)) { /* new data */
975
976 if (cp2time(cxval))
977 delevts(-1, ctime); /* delete all events at cursor */
978
979/*
980
981*/
982
983 } else if (stcrow EQ 17) {
984
985 if ((stccol GE 11) AND (stccol LE 12))
986 delevts(EV_ASGN, t_cur); /* assignment */
987 else if (stccol EQ 19)
988 delevts(EV_TUNE, t_cur); /* tuning */
989 else if ((stccol GE 27) AND (stccol LE 29))
990 delevts(EV_TMPO, t_cur); /* tempo */
991 else if ((stccol GE 36) AND (stccol LE 38))
992 delevts(EV_INTP, t_cur); /* interpolation */
993 else if ((stccol GE 40) AND (stccol LE 43))
994 delevts(EV_STOP, t_cur); /* stop */
995 else if ((stccol GE 45) AND (stccol LE 48))
996 delevts(EV_NEXT, t_cur); /* next */
997 else if ((stccol GE 50) AND (stccol LE 55))
998 delevts(EV_PNCH, t_cur); /* punch in/out */
999
1000 } else if ((stcrow EQ 18) AND
1001 (0 EQ ((stccol - 5) % 5))) { /* group status */
1002
1003 delevts(EV_GRP, t_cur);
1004
1005 } else if ((stcrow EQ 18) AND
1006 ((2 EQ ((stccol - 5) % 5)) OR
1007 (3 EQ ((stccol - 5) % 5)))) { /* instrument */
1008
1009 delevts(EV_INST, t_cur);
1010
1011 } else if (stcrow EQ 19) { /* transposition */
1012
1013 delevts(EV_TRNS, t_cur);
1014
1015 } else if ((stcrow EQ 20) AND (stccol GE 6) AND
1016 (0 EQ ((stccol - 6) % 5))) { /* dynamics */
1017
1018 delevts(EV_DYN, t_cur);
1019
1020 } else if ((stcrow EQ 20) AND (stccol GE 6) AND
1021 (2 EQ ((stccol - 6) % 5))) { /* location */
1022
1023 delevts(EV_LOCN, t_cur);
1024
1025 } else if (stcrow EQ 23) { /* analog */
1026
1027 deladat();
1028/*
1029
1030*/
1031 } else if (stcrow EQ 24) { /* score */
1032
1033 if (stccol LE 4) {
1034
1035 /* clear score */
1036
1037 if (insmode) /* cancel insert mode */
1038 icancel();
1039
1040 sc_clr(curscor); /* clear score itself */
1041 selscor(curscor); /* refresh the display */
1042
1043 } else if ((stccol GE 10) AND (stccol LE 25)) {
1044
1045 /* clear score name */
1046
1047 memset(scname[curscor], ' ', 16);
1048 dswin(13);
1049 }
1050 }
1051}
1052
1053/*
1054
1055*/
1056
1057/*
1058 =============================================================================
1059 sdmkey() -- score display menu key processor
1060 =============================================================================
1061*/
1062
1063void sdmkey(void)
1064{
1065 if (astat) {
1066
1067 if (insmode)
1068 icancel();
1069 }
1070
1071 stdmkey();
1072}
1073
1074/*
1075
1076*/
1077
1078/*
1079 =============================================================================
1080 scfield() -- setup field routines for the score display
1081 =============================================================================
1082*/
1083
1084void scfield(void)
1085{
1086 curset(&sc_flds);
1087}
Note: See TracBrowser for help on using the repository browser.