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

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

Use void pointers for mem*() functions.
  • 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 void *memset(void *vp, 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 stddkey(short k);
34extern void nokey(void);
35extern void stdmkey(void);
36
37extern short et_strn(short n);
38extern short ef_strn(short n);
39extern short rd_strn(short n);
40extern short nd_strn(short n, short k);
41extern short et_snbt(short n);
42extern short ef_snbt(short n);
43extern short rd_snbt(short n);
44extern short nd_snbt(short n, short k);
45
46extern short et_ioas(short n);
47extern short ef_ioas(short n);
48extern short rd_ioas(short n);
49extern short nd_ioas(short n, short k);
50extern short et_tune(short n);
51extern short ef_tune(short n);
52extern short rd_tune(short n);
53extern short nd_tune(short n, short k);
54extern short et_tmpo(short n);
55extern short ef_tmpo(short n);
56extern short rd_tmpo(short n);
57extern short nd_tmpo(short n, short k);
58extern short et_intp(short n);
59extern short ef_intp(short n);
60extern short rd_intp(short n);
61extern short nd_intp(short n, short k);
62
63extern short et_inst(short n);
64extern short ef_inst(short n);
65extern short rd_inst(short n);
66extern short nd_inst(short n, short k);
67extern short et_trns(short n);
68extern short ef_trns(short n);
69extern short rd_trns(short n);
70extern short nd_trns(short n, short k);
71extern short et_dyn(short n);
72extern short ef_dyn(short n);
73extern short rd_dyn(short n);
74extern short nd_dyn(short n, short k);
75extern short et_loc(short n);
76extern short ef_loc(short n);
77extern short rd_loc(short n);
78extern short nd_loc(short n, short k);
79extern short et_vel(short n);
80extern short ef_vel(short n);
81extern short rd_vel(short n);
82extern short nd_vel(short n, short k);
83
84extern short et_res1(short n);
85extern short ef_res1(short n);
86extern short rd_res1(short n);
87extern short nd_res1(short n, short k);
88extern short et_aval(short n);
89extern short ef_aval(short n);
90extern short rd_aval(short n);
91extern short nd_aval(short n, short k);
92extern short et_agrp(short n);
93extern short ef_agrp(short n);
94extern short rd_agrp(short n);
95extern short nd_agrp(short n, short k);
96
97extern short et_scor(short n);
98extern short ef_scor(short n);
99extern short rd_scor(short n);
100extern short nd_scor(short n, short k);
101
102/* forward references */
103
104short et_null(short n);
105short ef_null(short n);
106short rd_null(short n);
107short nd_null(short n, short k);
108void sdcxu(void);
109void sdcyu(void);
110void sdxkey(void);
111void sdmkey(void);
112short scntfld(short k);
113
114/*
115
116*/
117
118/* variables defined elsewhere */
119
120extern short ancmsw;
121extern short angroup;
122extern short astat;
123extern short clkrun;
124extern short cmfirst;
125extern short cmtype;
126extern short curhold;
127extern short curscor;
128extern short cxrate;
129extern short cxval;
130extern short cyrate;
131extern short cyval;
132extern short ebflag;
133extern short hcwval;
134extern short insmode;
135extern short oldpk;
136extern short oldsl;
137extern short pkctrl;
138extern short recsw;
139extern short scmctl;
140extern short sdmctl;
141extern short sliders;
142extern short stccol;
143extern short stcrow;
144extern short thcwval;
145extern short tvcwval;
146extern short vcwval;
147extern short vtccol;
148extern short vtcrow;
149extern short vtxval;
150extern short vtyval;
151
152extern long ctime;
153extern long t_ins;
154
155extern char ebuf[MAXEBUF+1];
156
157extern short crate1[];
158extern short ehdlist[];
159extern short grpmode[];
160extern short grpstat[];
161extern short grptmap[];
162extern short sdmlim[][4];
163extern short 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
342short et_null(short n)
343{
344 return(SUCCESS);
345}
346
347short ef_null(short n)
348{
349 return(SUCCESS);
350}
351
352short rd_null(short n)
353{
354 return(SUCCESS);
355}
356
357short nd_null(short n, short 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 long 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
545short scntfld(short k)
546{
547 register short 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
646short cp2time(short cx)
647{
648 register long ct;
649
650 ct = t_cur + ((long)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
669short delevts(short etp, long thetime)
670{
671 register struct s_entry *ep, *np;
672 register short et;
673 register short rc;
674 register short 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
733short deladat(void)
734{
735 register struct s_entry *ep, *rp;
736 register short 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 short 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.