Something like a macro but without a name that supports the options "quantity" and "multiple".
So that you could write something like:

( q=5
    command
    command
        ( m, q=2
            command
            command
        )
        command
)

Something more or less like this:
channel effect:what/function duration options
E.g. for a pitch band change affecting the whole channel:
0 effect:pitchband/sinus /2 amplitude=20, wavecount=2.5
Or for a polyphonic aftertouch graph affecting only one note:
0 effect:polypressure/line /2 from=-5, to=15, note=c+

Rename staccato to legato (or something similar).
Find a good short name. ('l' is not good because it's planned for lyrics later.)
Rewrite the code accordingly, using:
legato(new) = 1.0 - staccato(old)

Reason:
Than we have a value range from 0 to +infinite. That's much more natural.
That's much more intuitive than minus infinite to +1.0
The negative staccato values are not intuitive, and it's hard to calculate what happens.

Add a pre-parsing run to the MidicaPL parser, only for parsing MACRO definitions.
Then a macro can be called before it is defined.

Currently the default is:

c-----
c----
c---
c--
c-
c
c+
c++
...
c+++++

That's not very readable.
Instead of that, implement the following one:

c-5
c-4
c-3
c-2
c-
c
c+
c+2
c+3
...

This should also be the new default.
Additionally:

• adjust all unit tests
• adjust readme file
• adjust example file (or replace it completely by something better)

Check and correct note symbols beginning with *.

Add an option for block and include commands to transpose the content by an arbitrary number of half tone steps.
The option name should be shift (short form s) because for transpose there is no reasonable short form available. (t and tr are already used.)

e.g.:

INCLUDE macro shift=-12 // transposed 1 octave lower
( s=12
    ... // transposed 1 octave higher
    ( s=12
        ... // transposed 2 octaves higher
    )
)

finish this functionality

Problem:

Currently the karaoke player reads lyrics information from no matter which track. But there are songs containing text/lyrics in different tracks.
This can have different reasons, e.g.:

• there are different karaoke formats in one song
• one track contains lyrics, the other one other information

This leads to broken lyrics.

Solution:

• develop a strategy to find out which track to be regarded as the karaoke track
• use text/lyrics for karaoke only from this track

Idea for the strategy:

• check if one of the included formats is soft karaoke, and use the according track, if yes
• otherwise: count text/lyrics events by track and choose the one with the highest number

Moreover:

• For the sake of readability, maybe move karaoke parsing away from the SequenceAnalyzer to a new class.

Example:

( t=4:3
  0 c  /4+/8
)

This results in:
0 c /4+/8t4:3
But correct would be:
0 c /4t4:3+/8t4:3

Add a tremolo option for channel commands
Example:
0 c /1 tremolo=/8
for tremolo-ing a full note with 8ths

The stack trace should be shown on errors MidicaPL parsing.
It should contain:

• function call information (function name, file, line, parameters, options)
• nestable block information (file, line, block options)
• line content, file and number
• maybe file include information (included from file..., line...)

instead of lowlevel tuplet modifiers on channel command level, also enable tuplets as a nestable block parameter.
e.g.

( t=3:2
    command
    command
    ( t=5:4
        commnad
        commnad
    )
)

• for import
• for export

E.g.:
/2+/8 for a note with the length of one half plus one eighth.

The parsing order is wrong so that the data entries are parsed before the (N)RPN messages.
This needs to be fixed.

( and ) are uncommon for blocks in most programming languages.
Most people are more familiar with { and }.

Currently in the standard configuration it's not possible to include a comma in a lyrics inside of MidicaPL.
Reason: The comma is interpreted as an option separator before so it cannot be used inside a syllable.

Solution:
Add \c as escape sequence to encode commas.

Example:

0  c  /4  l=Hey\c_
0  c  /4  l=you!

This sould result in the lyrics Hey, you!.

We need to be able to switch an instrument for a channel without using an INSTRUMENTS block.
Reasons: INSTRUMENTS blocks cannot be nested. But it should be possible to change instruments from inside a nestable block or a macro.

There should be a filter for the note/percussion list in the soundcheck window.
According to the table filters.
Maybe the list could be transformed to a table.
Or we need a JList filter.

Standard MIDI Karaoke is already supported everywhere in Midica.
Soft Karaoke is currently only supported by the Analyzer and Player.
This causes problems if a Soft Karaoke file is decompiled, or if a MidicaPL file is exported as MIDI and used by software that expects soft karaoke.

• Add some META tags for soft karaoke in MidicaPL
• The syllables themselves must still be defined by the user
• In the decompiler: check, if soft karaoke is used, and if yes: export the according META fields

Something like this should be possible:

VAR $channel = 0
$channel  c+  /4
VAR $channel = 1
$channel  c+  /4

Tried out with windows for the first time and found a problem that doesn't occur on linux:
As long as no specific soundfont is loaded, the info button throws exceptions, and the info window doesn't open.
After loading a soundfont everything works.
Try again with windows, look at the stack trace and fix the error.

Support new options:

• if <condition>
• elsif <condition>
• else

All these options should work as a block option for nestable blocks.
For convenience reasons, if should also work as a call option or a channel command option. But for elsif and else that does not make sense.

The condition part should support one boolean expression with 2 values and one operator between them. The following operators should be supported:

• equals (e.g. ==)
• not equals (e.g. !=)

Maybe the following operators could be supported as well:

• lower (e.g. <)
• lower or equal (e.g. <=)
• higher (e.g. >)
• higher or equal (e.g. >=)
• defined (e.g. no operator and only one value)

More complicated boolean expressions could be implemented in the future but for now they are not yet needed. E.g. something like $a==$b||$c<5||$d

Track controller and RPN values.
Use these structures to replace more specialized structures like the instrument history or the pitch bend sensitivity MSB/LSB histories.

Target:
This makes it easier to track more details.
It avoids to create a new data structure for each task.

The main volume slider should change the master volume (using a SysEx message).
The channel volume sliders should change the according channel volume directly (not using a calculated value relative to the main volume any more).

In the Midi Sequence analyzer / details field:

• add a field for further information
• in this field, add note details for the following message types:
  • note on
  • note off
  • key signature

#12 addressed legato overlapping problems.
But the following is still wrong:
0 c /4 d=100%, q=2
In this case, the first note-off is in the same tick as the second note-on.
Move the note-off one tick to the past in this case.

Rename MACRO to FUNCTION.
Rename INCLUDE to CALL.
Support named or unnamed parameters.
Example for named parameters:

FUNCTION test
    ${channel}   c  /4  v=${velocity}
END
CALL test(channel=4, velocity=100)  q=2

Example for unnamed parameters:

FUNCTION test
    $[0]   c  /4  v=$[1]
END
CALL test(4, 100)  q=2

The parameters shall still be optional.
The following calls are equivalent:

CALL func()
CALL func

• provide defaults in Config.java
• main window: add a key binding config button that opens...
• ... a new key binding config window
• add a tab in the info window that shows all configured key bindings
• add tooltips to the elements to be controlled by the key bindings, containing the according key binding

Move all color definitions to the Config class.
Change colors to make the ui less ugly.

Contents can be note names, key or time signatures, pressure values and so on.

Something like this:
* 1-3,6,p,12-14
For synchronizing the following channels:
1,2,3,6,9,12,13,14

Or maybe with an additional keyword. E.g.
* channels 1-3,6,p,12-14

move translations from the source code to external files

In the MidicaPLParser, when a SOUNDFONT command is found, check if this soundfont is already loaded.
In this case, don't load it again.
Don't allow more than one SOUNDFONT command in the source.

Only definition and execution commands should be upper-cased.
Tuplets, triplets and percussion shortcuts should be lower-cased.
Maybe percussion shortcuts could also be made shorter.

Add the possibility to use variables.
Example:

var $forte = 120
var $staccato = duration=50%
...
0  c  /4  v=$forte
0  c  /4  $staccato

events like:

• author
• copyright
• etc.

see headline

There are exceptions with java versions later than 8.
Since java 9 the package com.sun.media.sound doesn't exist any more.

• fix the exceptions
• replace using the classes of this package by something else
• restore the according functionality somehow else

Use JUnit 5. Therefore Java 1.8 or higher is required. But apart from the tests the application could still be available in Java 1.7

Then include unit testing into the precommit hook.

Something like this:

// define pattern
PATTERN my_pattern
    0      /4
    1      /8
    2      /8
    0,1,2  /4
END

// use the pattern instead of a note length
5   c,e,g   my_pattern
7   g,e,c   my_pattern

This should be equivalent to:

5  c      /4
5  e      /8
5  g      /8
5  c,e,g  /4
7  g      /4
7  e      /8
7  c      /8
7  g,e,c  /4

At least for some JTables it woult be useful.
E.g. the drum instruments table.

Example:

( q=3
    command
    command
    command
) m
command
(
    command
    command
) q=2

If the duration option is >1.0 and the same note in the same channel is played twice, the overlapping leads to the following sequence:

• note-on
• note-on
• note-off
• note-off
  For different notes or different channels that's no problem.
  But in the same channel with the same note, it should be avoided.