Outline view in individual documents?

Scrivener Wish List
1

I am writing with a suggestion for a new feature for Scrivener.

I think your program is really wonderful. But I thought you might find it useful to have a bit of feedback about the workflow that I have developed. And if you think it’s something that others would find useful, you might implement a new feature to make it more natural to do in Scrivener.

I am a university professor, and my field is ancient philosophy. So normally I write long pieces (40pp to 300pp) with complex, detailed arguments. I break up a paper or a book that I am writing into parts, and often those parts have subordinate parts.

Previously I had kept track of all this by using the Outline view in iWork Pages. But when I found Scrivener, it allowed me to make these complex documents in a much better way, with the document structure present clearly in the Binder. So when I write, I first block out my overall argument, and then make documenst that reflect that structure in Scrivener, and fill in the individual documents in whatever order makes most sense. So much is already possible in Scrivener.

However, the individual documents that make up my overall argument also have to be organised and logically coherent. I sometimes use Omnioutliner to write these individual parts. This allows me to compose my paragraphs with a very clear logical structure. The aim is for the outline to be my finished text, only requiring me to change its formatting from outline to a series of finished paragraphs.

I then import this into Scrivener. But Omnioutliner doesn’t make it easy to do this. The easiest way is to export a file as a Word document, change the indentation, get rid of carriage returns, and then copy and paste into Scrivener. This laborious process means that when doing revisions, I don’t go back to the original outline, but do it in the prose in Scrivener. But then I am losing the benefit of seeing the structure clearly.

What I would suggest is for you to make it possible to do all this within Scrivener, by adding an outline view for individual documents. That way, I could compose my ground-level argument as a structured outline within a single Scrivener document, and then hit a toggle button and it would be formatted as a series of paragraphs. Hit the toggle again, and I would see the outline again, allowing me to make structural changes to my argument with ease. There would have to be some sort of ‘new paragraph’ marker. Perhaps each highest level heading begins a new paragraph, or perhaps a code at the beginning of a line could tell Scrivener to begin a new paragraph. It would also be nice if the heading levels were clearly indicated, perhaps with Harvard numbering, or something that.

Anyway, there are probably lots of reasons why this wouldn’t be easy or desireable to implement. But I thought I would share it with you anyway.

2

You can already do this.

You do know that documents in Scrivener can have subdocuments, which can also have sub-documents, etc, don’t you? Calling things folders and documents is just for convenience, they are in reality the same thing. Both can contain both text and subdocuments/-folders. So you can have as many levels as you need.

Simply break up the text so that every subordinate part is a single document and write down the main message as synopsis in the Inspector. Then i Outline view you can expand or collapse to the level you need for the moment, and you can choose to se the synopsis or not. Maybe it would sometimes be enough with the sub-document title? Then when it is time to write you simply use Scrivenings mode to show as much text as you like.

3

I think one of the lightbulb moments in Scrivener is the realisation that it is an outliner—it’s just easy to lose sight of that because its “notes” field is so elaborate and more like what you’d expect in a word processor. It doesn’t have quite as many outlining features as a dedicated program like OmniOutliner or NeO, sure, but as a basic concept, that is what you’re working with—and when you consider that Scrivenings mode sews together a bunch of what we can now think of as outliner nodes rather than “documents”, you’ve already got everything you’re asking for right under your fingertips.

As with an outline in a more traditional outlining program, Scrivener only gets more powerful the smaller you break things down within it. You’ll even find people around here that outline to a paragraph level in the binder; they maybe merge them at some point back into larger pieces, and that is easy to do, but with the program’s text-first approach to editing the trick is to think about an outline slightly differently, maybe halfway in between the Word outline and the MORE style outline.

The thing that sets Scrivener apart from other tools that take a piecemeal approach is its dynamic scoping ability, or the aforementioned “Scrivenings” feature, which is a way of selecting an arbitrary slice of the entire book and viewing/editing it as though it were a single file in a word processor. With a tool like that, it is inconsequential whether you’ve got 80 pieces of outline to a chapter or one.

So give this a try: you’re starting a new document—and here is where you’d ordinarily be heading over to OmniOutliner—you’ve got the text editor in front of you, press Cmd-3. Now you’re looking at the outliner for this document. Try hitting the Return key, just like in OmniOutliner, you’ve got a new entry to type into, so input your first structural note. You can press Return twice to start a new one, or just hit Cmd-N at any time, whatever works best for you. User Ctrl-Cmd-RightArrow to indent subsidiary structures, LeftArrow to promote. You can enable synopses in the view and achieve a working style similar to Omni’s in that you can add inline notes about the heading as you proceed. When you’ve got some idea for the text that would be written into any section, select it and hit Cmd-1 and start typing. When you’re done, press Cmd-3 to switch back to outlining view.

Prefer to see a little of the text content as you outline? Split the view and then click the auto-load button in the footer bar (arrow coming out of a box). Now as you work in the outline the text of that section automatically appears—Ctrl-Tab to switch back and forth (and hide the Binder to make the process more efficient and increase focus).

As you start building up the text, Scrivenings view (Cmd-1) will become bulkier and less easy to move around in on its own, but that’s no problem overall. You have a built-in table of contents with Cmd-3, and built-in navigation by cursoring over, and pressing Cmd-1 to open Scrivenings back up with the selected chunk of outline focussed.

You can work in the other direction as well by the way! I discussed things from the viewpoint of plotting downward and filling in the structure with written text, but all of this works upward too. Try pressing Cmd-N while you’re writing in a Scrivenings session, there’s your structural break point (new paragraph marker if you will). Press Cmd-3 to view it, move it around, maybe give it a name if the paragraph text it used to automatically name it isn’t enough, etc. We’ll be making these aspects even better in the future, in terms of being able to blend in a concept of using the outliner more like a “manage my text” view instead of “manage my outline nodes” view.

You might also prefer a less visually invasive mechanism in Scrivenings mode, try Separate scrivenings with single line breaks at the bottom of the Formatting preference pane.

It make all take a little getting used to, as I said it’s a bit in between a pure outliner and a word processor—but in case it wasn’t obvious from the above, I work using these specific techniques all day long. The ability to seamlessly outline and write in the same view is to me one of Scrivener’s best assets.

4

Friends,

I am with Gregory on this. The use case he describes, which I understand very well, is geniunely not conducive to the sort of suggestions being made. I could say more about why this is, but I have gone into it before on these forums.* I say this as a long time tech-savvy user and one with the same sort of usage needs Gregory describes. In short, I think I know whereof I speak!

Gregory,

Here are two suggestions for you from my own usage.

A) For making outlines in Scrivener: Set up a series of paragraph presets in Scrivener which have increasing left inset. Assign handy key commands to these using Appl system prefs. Also make a preset and key command for whatever is your normal paragraph style. Once you have done this, you can work in an outline way in Scrivener much as you would in MS Word. In fact, I set my paragraph presets to exactly match my preferred stylings of Word’s Headings (aka outline) paragraph styles, so that I can copy outlined text from Word to Scrivener with perfect fidelity. What you don’t get functionally is an easy way to just move paragraphs around as you might in Word or oo outlining.

B) For bringing outlines into Scrivener. 1) There is the copy and paste method from Word mentioned above, of course. 2) I do not use Omnioutliner, because I discovered mindmap software to be far superior for the sort of work we are talking about. But the import challenge is similar. I have basically two approaches. Both involve copying the tree structure from the mindmap software and pasting into Word --which produces tab-indented or space-indented structured text. (You may need to do a tab-delimited export from OO.) I then apply one or the other of two specialized Word macros, depending on the outline I am working with. i) One macro converts the indented text to Word outline style – this can then be copy and pasted into a Scrivener doc and will perfectly match my outlining styles there. ii) The second macro is designed for more all inclusive outlines – ones whose root nodes represent the stucture and substructure of the work, and where the branch nodes represent structured content. The second macro converts the indent-delimd text into Multimarkdown code. The resulting multimarkdown text file is to be imported into Scriv with its import function for that purpose. The result is that the root nodes are converted into a hierarchy of Binder structured folders/docs and the branch nodes become structured body text inside their respective parent docs. The limitation in this case is that the body text is not structured in your preferred inset paragraph styles, but remains merely tab-indented. This makes the structure recoverable, but requires touching up and so is not entirely optimal.

If these Word macros might be of use to you, I can get them to you.

Also, I highly recommend a good piece of mindmap software for your workflow. The structural metaphor of a diagrammatic tree is so much more conducive to highly structured composition than the still-too-linear layout of oo or Word outlines.

By the way, we are told that the upcoming vers 3 of desktop Scriv has a full styles system ( as opposed to the preset system it has now), so some of these moves might get better and simpler.

Best,
gr

  • What the OP is speaking of is hierachically structured body text. He is not talking about an “outline” in the sense many if us were (rather uselessly taught) in high school – where a node in the outline might be a single word or phrase. Making the latter into document titles so as to “outline” structure them in Scriv makes sense, but doing the same with the former makes no sense at all – and it also would leave you with basically all of your body text in the title field of the docs, not in their bodies. Really does not make good working sense.
5

I understand what you (both) are describing, but I still don’t see why this can’t be done using multiple levels of sub-documents.
Using different indents would show the “outline” very clearly, as gr suggests. If the titles are of no significance, just use the first words of the document. And in Compile the different levels could easily have different indents.

The analogy with mindmap software doesn’t make it clearer. I use mindmaps a lot, but that’s just because the bigger area (compared to the binder) makes it more visible. It is essentially the same thing (with the central node being replaced by Scrivener itself, the whole Binder). Importing mindmaps, I simply use the opml format. It gives me the structure and the content.

I hope you don’t take my comments and suggestions as criticism. I am curious and interested to understand what I am missing in your point, and eager to learn new ways to work with structured text. :slight_smile:

6

Sorry, lunk, that I haven’t been able to get back to this (except for a little bit right now).

I guess it is not that you couldn’t do what you are suggesting, but it would not be a good way to work for the sort of work in question. In that sense it is at best a kind of workaround. There are just better ways to do this kind of content-level outlining.

I am thinking the new styles system we have heard about in the upcoming Scriv 3.0, may also make a tangible and good difference to what sort of workflows make sense.

Greg

7

The lacking element I see in Scrivener 3 is that outline sentences cannot be joined automatically or toggled into paragraphs in any way. Conversely this would be a godsend. This element would be the glue between outliner and binder docs. So just to make it clear about the feature that we are suggesting, I say that Scrivener 3 does not allow the breakdown of sentences or cells to be joined into a single paragraph unless by manual intervention of the user.Thank you for your consideration.

8

Nhaps,

If I have understand correctly what you are looking for, Scriv 3 already has this capability.

The Documents > Merge command can be used on (even non-contiguous) selected rows in the Outliner view.

gr

9

That’s true, but there is no way to automate the Merge operation, and it will still leave some break between the merged documents.

Similarly, there is no way to eliminate a paragraph break between sub-documents in the Compiled output.

Katherine

10

]Going back to the original post, AFAIU, the desire is for some sort of visual structure for paragraphs within a Scrivener documents, which can then be collapsed easily to leave compile-ready text.

Forgive me if I’m missing something obvious, but this looks to be simple in Scrivener 3, with a combination of inbuilt shortcuts, once you realise that the old shortcuts for moving in the Binder now also work for paragraphs in the Editor.

ie you write the first paragraph. Move on to the second one cmd-ctl-right and it’s indented. This indent continues for subsequent paragraphs until you change it by cmd-ctl-left to unindent, or cmd-ctl-right to indent further. So you create your outline. You’re not happy with the order of the paragraphs, so cmd-ctl-up / down moves them accordingly.

When you’re happy the structure and the words are perfect, cmd-a to select everything and cmd-opt-0 to reset them all to the default style (and of course the default indent).

I’m missing something, and I’m going to look daft, aren’t I?

11

That’s a good idea to start with, but if you implement this on a large document you gotta be careful, because an unindent will throw your doc way at the bottom you won’t even see i right away!