Number Field dragging is unpredictable
Closed, ResolvedPublic

Description

Blender has the ability to tweak number fields by dragging the field left/right. This is much more tactile than manually typing in values, and as such this is a great idea. You don't focus on the number value so much as the result.

The problem is that there is no reliable relationship between cursor travel distance and the value being changed.

The Issue:

  • When you start to drag a number field, it moves in small increments (typically 1 integer)
  • But as you continue dragging around, the dragging increments increases. The longer time you drag, the larger the increment
  • In the end it gets out of control and you can’t get back into the range you started at.

Solution
Remove the exponential increase of increments. Make the relationship between cursor screen distance and values linear and predictable.

The Issue is already fixed if you turn on Continuous Grab in preferences, but remains to be fixed with that option turned off

Details

Type
Design

@William Reynish (billrey), good catch and nice solution. I was not actually aware of the exponential increase but always wondered why dragging values always seemed so finicky.

Jonathan Williamson (carter2422) triaged this task as Normal priority.Nov 14 2013, 5:35 PM

How about middle mouse scrollwheel to increment or decrease values?

@Rexford Nkansah (nkansahrexford): Middle mouse scrolling for values would conflict with regular scrolling of the view. You woudln't want values to accidentally change as you scroll the view with MMB.

Midlle mouse+alt already increments or decreases values, but it's rather hidden and obscure.

Finally I understand how blender input fields work. And they don't work well at this moment. Good idea @William Reynish (billrey) !

Note, since this report we now have continuous-grab enabled by default. So this task only applies when this preference is disabled or for tablets.


This feature was added because making large changes was very awkward, and your cursor would hit the side of the screen.

The problem with disabling this is it makes editing buttons with a very large range difficult. (object location or lamp distance for example).

  • Either a pixel maps to large changes (1 pixel movement == 1.0 adjustment for eg), which allows dragging large values but means you have to type in small adjustments or click multiple times.
  • Or you have a fixed small value adjustment, which means you need to type in large values because its impractical to move the cursor.

Update, since looking into the logic here, there was a bug/glitch with int buttons where small motions wouldn't adjust the value. Fixed rBf3ec08d934bee17252fbed59ceb0d01f88072ede

Julian Eisel (Severin) closed this task as Resolved.Feb 27 2016, 1:16 AM
Julian Eisel (Severin) claimed this task.

Closing this since main issue has be addressed by using continuous grab per default. While it's still not an optimal solution, I think the remaining issues can be resolved with value ladders (D760).

@Jonathan Williamson (carter2422), regarding buttons being finicky, the non-linear behavior only kicks in for larger ranges.

Before this, it was very annoying to offset the current frame for eg, to 1000+ frames (you _always_ had to type it in).

I don't think non-linear scaling of cursor input is by definition problematic, however if there is some button in Blender's UI that is currently not very usable - we could look into tweaking the behavior here.


Note, besides value ladders (which I agree are probably the way to go...), some other changes could be made here.

  • Make scaling acceleration based. fast movements can change values at a higher scale.
  • We could detect when the cursor stops moving the mouse and reset the non-linear-scale. (So fast motions can be non-linear as they are now, but slow motion after can still be precise).
  • Non linear scale could be rounded to more even units. (so its always scaling by 1x, 2x, 5x, 10x... so as not to give such *random* looking results).

All that said, I rather only do these if its really clear improvement - and I have the impression they're more like small tweaks which some users like but annoy others.

The first 2 suggestions for eg rely on dynamic scaling, which may sound handy, but means moving cursor to original location won't have the same value.

  • Make scaling acceleration based. fast movements can change values at a higher scale.
  • We could detect when the cursor stops moving the mouse and reset the non-linear-scale. (So fast motions can be non-linear as they are now, but slow motion after can still be precise).
  • Non linear scale could be rounded to more even units. (so its always scaling by 1x, 2x, 5x, 10x... so as not to give such *random* looking results).

    All that said, I rather only do these if its really clear improvement - and I have the impression they're more like small tweaks which some users like but annoy others.

    The first 2 suggestions for eg rely on dynamic scaling, which may sound handy, but means moving cursor to original location won't have the same value.

Of those three suggestions the third seems the most practical to me. It at least would offer consistent results that the user can anticipate.

Acceleration based changes always frustrate me personally as I find them difficult to attune to muscle memory; this is the same reason I find acceleration-based zoom and scrolling to be very bad. It always sounds nice in theory but in practice is frustrating.

The biggest issue I find with these kind of dynamic value changes is they're not consistent (unless a user is exactly accurate in their mouse movement).

With that said, a tentative +1 towards value ladders as well to help resolve this.