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

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

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