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

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

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