A History Palette Like Photoshop ...

I was thinking how useful it would be to have a history palette like photoshop. That way I can trace a line of thought back to a moment and possibly undo it or revise it. You could even save these “idea paths” and put notes on them and save them as a card.

Just a thought.

Love the program so much btw - seriously, greatest program for writers ever.

Have you looked at the snapshot function yet?

Yes - very cool - I meant an actual pane like a palette that’s tracking everything as you go and doing it visually for you to see - just like photoshop does. Like this - livedocs.adobe.com/en_US/Photosh … /wa_17.png.

Perhaps it can link to the snapshot function?

Not speaking for KB, but I think that would be a coding nightmare based on how scriv projects are managed. In a graphic file all the data is essentially a single large document where all changes are linear and easily managed. But in scrivener there are many many files that you may access non-linearly (from the file perspective, not the doc perspective). Given that the idea of scriv was to maximize the non-linear capabilities that are inherent in a note card method, I would expect that displaying the actual changes might require some 4d technology from the future.

But then again, KB is a wizard and may already have a solution that escapes my meager thought processes. He is like that.

I suspected this might be tough to code.

But it sure would be useful and cool. :slight_smile:

Not arguing with you there.

It’s a great idea, and I can see how it would work with pictures, but I’m not sure how it would work with text.

If I draw a line, that gets an entry. If I darken a portion of the picture, that gets an entry.

But with text, do I put an entry into the history for each character that is changed?

How is this any different than the undo stack? The reasoning behind Photoshop’s history palette is that one can amass a large number of “micro-edits” depending on their brush style, resulting in forty or fifty individual undo events for a minor change. If you wished to go back to a place prior to using that brush, doing so could take a very long time. The second primary reason is that Photoshop has bunches of different tools. You can identify steps by their tool label and contextual positioning.

So, with Scrivener we already have snapshots, which is the third big thing about Photoshop’s history. With Scrivener we have essentially two tools: text entry and format changes. And accordingly, undo does not track every single keystroke but rather sessions of keystrokes. Whenever you pause it starts a new text undo event, but a single event may hold hundreds of words. You don’t really have the quantity problem so much.

You don’t have the “stacking” problem that Photoshop has where brush strokes are all landing on top of one another and potentially irreversibly obscuring each other. When we write the letters all come out in a row in a linear fashion. Our “history” is right there in the form of a typed paragraph. If you are deleting or over-writing, you should be using snapshots.

I don’t get it. What’s so useful about this idea? The proposal of naming and annotating undo stacks is interesting, but would result in extremely bloated projects. Currently the stack disappears when you exit the session. If every document retained its own stacks forever, and could even have them annotated and visually displayed, that would essentially mean that every document exist at least twice for a linear writer, and potentially dozens of times for scattered revisionists. And yes, this would be a per-document palette. Tracking the whole project in one palette would essentially render the function useless. There is a reason why each control has its own undo stack! Having the wipe out 300 edits to fix one document from five hours ago would not be an improvement to the existing system.

I’ll describe why it came up and maybe there’s already a solution for this. Where i’d find it useful is working with my binder’s draft folder, (i’m using it for a screenplay so it says screenplay instead of draft.) Inside of my screenplay folder, I’ve created a series of subfolders - act one, act two, act three, beats, scenes, characters, locations, dialogue, etc. As I move further along in my progress, I move around beats, characters, locations, dialogue, etc. into scenes. But sometimes I might want to see the path I’ve taken when moving things around and redo them or revise them. For example, I might move a beat into a scene in act 1 - then later move it into act two. I’d love for this history palette to identify this move for me in a window that is linear - so if I later decide to move it back or somewhere else, I can trace my thought process and see why and when I placed it there.

This probably sounds really confusing but for some reason makes sense to me. It’s like a linear timeline of my progress - like a snapshot but with a window palette that shows each move, each new folder creation, etc.

I love how amazing Scrivener is at allowing me to think like a writer and organize thoughts/research so I wouldn’t have even thought of this without the brilliance of this program.

Applying it to the Binder, specifically, does make more sense—especially since we only have partial undo there anyway. There is definitely a need for some kind of Binder-level management like that!

And actually, when you put it like that, Amber suggested something not entirely dissimilar herself not long ago. :slight_smile: Amber suggested some way of having “multiple binders” - that is, being able to save the binder in different configurations, which would do pretty much what you want (sort of a snapshot of the current order). There are numerous technical problems with implementing this, though - even though it is a good idea - particularly when you think that some documents may have been deleted and others may have been created between such times.

Suppose you had, at one stage, some files that looked like this (let’s call it configuration 1):
Folder A
– File 1

And supposing that at some point you rearranged these, like so (configuration 2):

Folder A
File 1

And then say you decided that you didn’t need Folder A at all, so you moved it to the Trash and then emptied the Trash. How would it be possible for Scrivener to allow you to go back to configuration 1, given that Folder A has been deleted, it’s contents wiped from disk?

Or, say you have this configuration (configuration 3):

Folder B
– File 2
---- File 3
-----File 4
Folder C
– File 5
---- File 6

And later have this one (configuration 4):

Folder B
– File 2
---- File 3
---- File 4
------ File 7
---- File 5
– Folder C
---- File 6

But you decide you liked configuration 3 better, so revert to it and continue working from there… What happens to File 7? It didn’t exist in configuration 3, as it was only created later.

Now imagine the scenarios above with potentially dozens of files… It makes the issue rather complicated. Scrivener would have to remember every file ever created in a project, which would render the “Empty Trash” function meaningless and bloat file sizes. It would also have to start guessing what to do with files that exist in a later iteration but not in an earlier iteration to which the project is reverted.

So, although the idea of being able to save different states of the binder is a really good one, it is fraught with conceptual and technical problems. All of which isn’t a “no”, by the way; although this isn’t planned for 2.0, I am interested in hearing proposals for potential solutions to the problems above, or seeing examples of programs that might implement something similar…

All the best,
Keith

I figured on the back end this might be difficult to do. I’m sure you get so many ‘wouldn’t-it-be-great-ifs’ that sound good but are really hard to implement. (How about a feature that writes my story for me and automatically serves me tea at 4 o’clock?)

Either way, don’t worry, I’m still a passionate Scrivener fan. Maybe someone creative out there can suggest a possible solution!

Keep up the fantastic work and can’t wait until 2.0. This version is so great I can’t imagine what’s coming.

–joey

A “text log” dump of all Binder actions would be one stripped down way of making the original idea work. Every time you move, rename, create, delete, label, et cetera a line gets printed into the log. “[Chapter one] moved to [Part two] after [Chapter twenty]” or [Chapter twenty] excluded from the draft." It could even do some automatic clustering for bulk action cases where you option click in the Binder and set 500 documents to be included in the draft. Rather than 500 individual lines, you get a single line stating you just enabled 500 documents between X and Y.

This wouldn’t be a functional thing, but would give someone an idea of what they’ve done. Since it is text they can copy and paste it anywhere and annotated it. Would a simple “plain english” logging function like that be worthwhile to you? The problem always comes back to the emptied trash with these ideas. If the history palette includes references to files that no longer exist, jumping back 100 steps could turn your project into spaghetti.

Simply stating the file got deleted though, and letting the writing go, “Hmmm”. There is nothing risky about that.

Realized I never answered this, but I like that idea of a “text log.”

:slight_smile:

2.0 is AMAZING btw.

Better late than never. :wink: