On 29/07/19 10:39 AM, Junio C Hamano wrote:
"brian m. carlson" <sandals@xxxxxxxxxxxxxxxxxxxx> writes:
These are probably pretty cheap on all but the largest repositories. I
was worried we were enumerating all refs or all history or something
like that.
ui_do_rescan changes the focus to the first diff. It is executed when you
press F5 or choose Rescan from the menu. do_rescan does not do that.
Resetting to first diff on focus change will get annoying when you are in
the middle of looking at some other file. do_rescan just updates the
software state without changing what file you are looking at or where in
that file you are looking at.
Yeah, this definitely seems like the right move.
"Right move" in the sense that it would try not to change what is
being shown too much. Rescan will still not be without cost, so it
will be annoying if it happens when the user did not make any
change.
And it is annoying even more, if the user did make change in another
window. You may make a change perhaps from the command line, write
a short e-mail about it to let others know in your MUA, and then
switch the focus back to git-gui to continue working. Refreshing
upon git-gui getting focus is no better than manually pressing F5 or
whatever at that point. It is too late at that point for spending
extra cycles without being asked without getting annoying to the user.
On my system with a not-so-fast hard disk, it takes under 10ms to do a
rescan (4 to 7ms usually). Using it for some time, I never felt any
latency or lag. Maybe it will cause problems on other systems, but I'd
like to hear from more people about it.
Also, why is it no better than manually refreshing? Manually refreshing
gets annoying real quick (and that's why I sent this change in the first
place). Not having to hit refresh every time you make any change is
pretty sweet.
Yes it maybe doesn't matter as much when you open git-gui _after_ you're
done making changes, and now only have to write the commit message. But
if you keep it open while you are editing code, and then when you are
done, you switch to it to commit, auto refresh is a great quality of
life improvement.
Again, on my system at least, there is no noticeable latency when
switching focus. How about making rescan on focus optional? The user can
disable it if they feel like it is getting in their way.
The right time to spend cycles (in the background) in the above
sample sequence is immediately after you made a change and switch to
your MUA---while you are typing a few paragraphs, you would not mind
git-gui spending seconds to repaint.
FYI, we are not just repainting, we are also syncing the repo state with
the in-memory state when doing a rescan.
So probably a more productive use of our time, if we were to futz
with git-gui, would be to figure out how git-gui can have an
background idle process that notices a change in the repository and
refreshes but only when you are *not* interacting with it (if it
does things while you are interacting with it, it would become
annoying and distracting), I would guess. Just when you come back
is the worst, and the most annoying, time to auto-refresh.
So maybe something like inotify? tcl-inotify [0] (a tcl extension) can
be used for it I suppose, though I haven't looked into it much yet.
My idea with this change was to keep it as minimal as possible. Doing a
rescan on focus seems like a good compromise to me. I can look into
inotify, but I'm not too aware of the performance impact it can have.
Also, do you know how editors like Atom or VSCode refresh when there is
a change to the tree? I've seen them auto-update the GUI when you make
any changes from outside of them.
I will look into tcl-inotify if there is a consensus that it is the
better way to go about this. It seems like a significant time
investment, and I'd rather not spend a lot of time doing something that
would get rejected instantly.
[0] http://tcl-inotify.sourceforge.net/
--
Regards,
Pratyush Yadav
