input of certain symbols simultaneous with note input

Most articulations (staccato, tenuto...) now have their own shortcuts.
Therefore, I guess that's fixed.
[r.a3d5580].

I think really what you're asking for is a set of toggle keys for articulations so that you could hit a shortcut then all subsequent note entries would be staccato until you toggled it off?

Is that the sort of thing you're after?

Incidentally if you want to try out the nightly builds of 2.0 they are freely downloadable from the relevant section of the downloads page.

JUst make sure you obey the caveats about unstable builds.

I'd think a toggle option would be useful. Something along the lines of [Shift] - dot for staccato, [Shift] - minus for tenuto, [Shift] - ^ for accent/attack for single notes AFTER entering the note to keep things much as they are but add in [Shift] - dot dot, [Shift] - minus minus, [Shift] - ^^ etc. to turn on the toggle for that function and then have a cancel shortcut such as [Shif] - / (question-mark) or other suitable key.

Without the toggle, it's no more efficient than the current method - it's just a different order of operations (articulation followed by note rather than the reverse). It is only idea of a toggle that saves keystrokes.

Well, I've created a feature request for the toggle button, even though, IMHO, it's quite unnecessary, since you can select all the notes and then double-click the staccato button.

#17415: Toggle button for articulations

---
About changing the input method... I think it's quite irresponsible to change it at this point. For some reason the "by design" status option exists; again IMHO.

I am quite sure you would soon un-learn your SIbelius habits and get into MuseScore's methods, just as I did with FInale (which I can barely remember how to use now, despite being a pretty heavy user for around 15 years before switching to MuseScore).

However, I do like the toggle idea, and I also like the idea of being able to select an accidental before entering the note. My hope is that both could probably be implemented without too much impact on the rest of the program, but to me, that's the key for things like this. No sense rewriting major chunks of the note input system for what would amount to a pretty minor difference in usability. But if it's easy, great.

Yes, please.

I don't mind so much about articulations. But for accidentals, this is really important.
It really bothers me that I have to put in the wrong note first, and then change it to the right note.
Hearing the wrong note interrupts my train of thought when I have a musical line in my head.

Also, this toggle, I think, should not be on sharp or flat.
It should be on raise a half step, and lower a half step.
So, for example, with 3 flats in the key signature,
the toggle that makes F-sharp instead of F,
the same toggle will make A-natural instead of A-flat.

(It could be an option, to allow it both ways - making 5 toggles:
flat, sharp, natural, raise half step, lower half step
But the raise half step, and lower half step are what I would prefer.)

Since everyone seems to agree this is not about "faster", I'll make an edit to the issue title.

FYI, you can use the Piano Keybaord window (press "P" or see View menu), or MIDI input, if you don't want to have to enter the accidental after the note.

Sorry for reviving an old post. Have there been any news in this regard?

If you think about it, the duration is indeed specified before entering the note, so this is illogical. The duration you specify will apply to the next note you enter, but the accidentals to the one you just did. Of course we can all get used to doing it this way no matter how arbitrary it seems, but to me it's also extremely distracting to have to hear the wrong note first, and then correct it. It's no big deal if you are transcribing, but lots of us write our music straight on the computer, using the sounds for reference.

To give you an idea of what a turn-off this is to me, here's the length to which I go in order to work around this shortcoming: disable sound, enter note, enable sound back, alter it properly. To have to do that every time a single accidental occurs, it's unnecessarily cumbersome.

I agree "It's no big deal if you are transcribing, but lots of us write our music straight on the computer, using the sounds for reference." And I agree "In the case of accidentals, though, I think it's better not to hear the "wrong" pitch first". And as Marc says, "Hearing the wrong note interrupts my train of thought when I have a musical line in my head." I feel the same.

But now the question is what should be the UI? I'd like to do this from the keyboard-only. But soo many keystrokes already have meanings defined. So it will be hard to find some key-combination which will do accidentals. What I'm thinking it maybe holding down '=' while pressing a,b,c,d,e,f will produce sharps, and holding down '-' while pressing a,b,c,d,e,f will produce sharps. The reason I say that is because '=' has the same key as '+' (which is produced by holding shift and '=' on most keyboards), and they are right next to eachother. Or maybe don't need to hold down, but just pressing '=' or '-' once would effectively depress the sharp and flat buttons on the GUI and result in the next inputted note receiving that accidental.

Would that produce any conflicts?

But what about for natural? I'm thinking '[' is right below '-' and '=', so maybe it would make for a good candidate for natural?

"But what about for natural? I'm thinking '[' is right below '-' and '=', so maybe it would make for a good candidate for natural?"
This makes no sense for me (and maybe others). I'm on a german computer keyboard, those keys are spread apart.

B, H and N are very close to one another, on any or at least many keyboards? Need some additional modifier though

one slight problem, jojo: 'B' is already reserved for the note 'B'. :)

What to call the shortcut isn't the limiting factor, we don't even need to define one by default at all. User could simply choose their own. We also support the ability to have different shortcuts for different keyboard layouts, not that I recommend going there for this.

BTW, instead of coming up with a new entry mode, we could consider just having "pre-altered" notes. Eg, use the "key sequence" facility to define a two-character sequence "# F" or whatever that just enters an F# directly.

I wonder, though, why not simply use the piano keyboard to enter notes instead of going to such elaborate handstands to avoid hearing the "wrong" pitch?

Anyhow, the way things are done now is not "arbitrary" - defining duration before make makes a ton of logical sense because it is extremely common for one duration to continue over the course of many notes (eg, a string of eight or more eighth notes all in a row) whereas it is much less common to want to have the same accidental carry through for multiple notes (after entering an F#, you probably don't really want to enter G#, E#, etc, at least nowhere near as often). So the interface would need to be quite inconsistent - durations lasting until changed, accidentals switching themselves off. Not impossible, but the point is, it's quite logical and consistent as is. Which is one reason I like the idea of separate shortcuts for "# F" etc.

one slight problem, jojo: 'B' is already reserved for the note 'B' you mean the one called H in German? ;-)

Why not use / for natural since it's near - and + on the numeric keypad. I keep may hands on the numeric keypad and letters a-g most of the time while entering scores.

Let's agree on two things:

1) The "toggling" idea as it was discussed earlier should only apply to certain symbols (say staccato), as was proposed, but NOT to accidentals, for the very reason you say. That's what's reasonable either if accidentals are entered before or after the notes they apply to. It would make no sense to have to "un-check sharps" just because you have employed a sharp, the reasonable thing to assume is that it was an isolated one, and if you happen to require another, you should have to order a new one.

2) The current input scheme should not be modified, ESPECIALLY the role of the up and down arrows in regards to the last note entered. I think it's amazingly clever the way they solved the problem of letting you introduce notes AND correct mistakes on the go without hindering your workflow in the slightest: you enter the notes one by one and hear them while they are being written, thus making sure they are all as you intended; if you've made a "typo" the sound will make it evident and without having to exit input mode you just correct it with the up and down arrows, still having the sound for guidance, and when you are done MS is already awaiting your input of the following notes. That's brilliant, with Sibelius 4 every correction was such a hassle!

My only objection is that when they thought this through they believed this already covers for the input of accidentals, since it couldn't possibly take any less keystrokes to specify that the next note you enter will be, say, sharp, and then entering it, than to just enter the note first and then "sharpen" it as a "correction". Like I've said, that may be the case for transcribing, but not so much for composing straight on the computer. And it's clear I'm far from alone on this (here in this thread, and also in many others that show up on Google; there was even a guy saying this is the one reason why he doesn't use MS).

What I suggest is a modification much simpler than you are thinking, all it would take is changing the function of the "sharp" shortcut and button, from "sharpen last note entered" to "sharpen next note to be entered" and so on with double sharp, natural, etc. The change in code should be minimal, and it would make A WORLD of difference.

The only slight complication is that this should contemplate the scenario in which the user first presses the shortcut for sharp (say, by mistake) and before entering a note, presses the shortcut for flat. For that matter, the buttons for all accidentals should have a "pressed" and "unpressed" state (which is not how they work currently), and pressing any one of them should un-press all the others.

Of course if you are not in input mode the shortcuts and buttons for accidentals should keep working the way they do now, as in "sharpen/flatten the note currently selected".

Ohhh wait! Wait wait wait! I've got it! It should take next to zero work!

All that needs to be done is copy - paste the code currently employed on the shortcuts and buttons for augmentation dots and use it as a template, and just change the augmentation dots for accidentals. But the work has already been done with those, think of how they work now:

In input mode:

• You type the shortcut or press the button for the desired number of augmentation dots, and the corresponding button stays pressed until you enter a note, which will have the appropriate augmentation dot and this will result in the button switching back to un-pressed.
• Pressing any of those buttons un-presses both of the others, and typing any of those shortcuts presses the corresponding button and un-presses both of the others.
• Also, typing the shortcut once presses the button, and typing it again without entering a note un-presses it.

When not in input mode:

• Selecting any note will press the right button matching the number of augmentation dots the note has (un-pressing them all of them if the note has no augmentation dots) and de-selecting un-presses them all.
• Selecting a note and pressing any of those buttons (or typing the shortcut) will modify the selected note accordingly.

This is how accidentals should work! And the code has already been written!

> "You type the shortcut or press the button for the desired number of augmentation dots, and the corresponding button stays pressed until you enter a note"

That is what I what I meant earlier when I wrote "Or maybe don't need to hold down, but just pressing '=' or '-' once would effectively depress the sharp and flat buttons on the GUI and result in the next inputted note receiving that accidental." although I realize now I wasn't clear.

just FYI - ALL (not just most) of the work for what you're talking about here was already done years ago.
https://github.com/musescore/MuseScore/pull/2651

That PR needs a rebase though

Yeah. I don't have any more the computer that I used to work on that, so i don't have the build system and dependencies set up. It might be easier for someone else to try cherry picking it - someone who is more familiar with how the code has changed in the last few years.

@beauxq

I only read the first message in the thread you link, but that's not what we are talking about here because:

a) We've all agreed a literal toggle (one that will stay activated until manually deactivated) is not the proper way to handle accidentals; we are talking about a "sort of toggle" that you switch on and it stays that way only until you enter a note, and this action automatically turns it back off, which is how the augmentation dots currently work.

b) This is not about raising or lowering notes by a half step, but rather entering accidentals, which is not the same. For example if you are in G# minor (five sharps) and want to enter an F double sharp (the leading tone), the F itself is sharp already because of the key signature, but we are not looking to enter it as "F, which is already sharp, raised one more semitone" (and have the computer guess if you meant F double sharp or natural G), nor equivalently, " G, which is sharp here because of the key signature, lowered one semitone", but rather as "the next note I'll enter, I want it double sharpened; that note is F". This is not only about getting the correct sound, the aim is to get the desired sound introduced from the start as the right note that it is, all at once. Like I said, it can be easily accomplished because all the code has already been written for augmentation dots.

EDIT: Now that I think about it, in the majority of cases you could accomplish the same with what you link; you only couldn't get double sharps on notes that aren't sharpened by the key signature or double flats on notes that aren't flattened by the key signature (which should be quite rare scenarios to begin with). I believe my proposal is a more "straightforward" way of thinking about it though, but maybe that's a matter of taste.

So you're talking about making 5 commands (double flat, flat, natural, sharp, double sharp), when you could cover 99% of use cases with just 2 commands (raise and lower)?

I think having just the 2 commands is also more musical. A melody exists independent of its key, so we shouldn't have to pay that much attention to the key when thinking about a melody. Raise and lower works the same for a melody no matter what key it's in. With those 5 accidentals, you have to change which one you use depending on the key.

Turning the toggle off when a note is entered is ok, and that would be easy with the code in that pull request. (easier than copy and pasting code from augmentation dots)

Yeah, I edited my comment, your proposal could accomplish pretty much the same, and it would require only 2 commands, which is a significant advantage. Why was it never implemented though? I see even more people sharing this view in that thread.