Styles as Scrivening Attributes

Scanned this message board for a bit, and did not see this. Likely already submitted, but this is my main desire, so will submit my own.

Moved to Scrivener from Word. Use InDesign a lot whenever good layout is needed. Very happy with Srivener – much better suited to my needs for business creative work (good patent cases, biz plans, etc.)

My one desire for the product is enhanced styles for compiling output. I would like a styles pallet like the paragraph styles pallet in InDesign (well not explicitly a pallet, but some GUI element that provides the easy creation and assignment of paragraph styles). This “pallet” would be used to create and assign styles to individual scrivenings. These, like the labels, etc. would show as attributes in the outline view.

Compilation would grab these styles when compiling obviating the need to work through the compiling styles dialog box. There would also be a lot more flexibility for a variety of styles vs. current setup.

I know Scrivener is not about page layout. Frankly anytime I need good layout I will continue to take text into InDesign.

The point of finer style granularity for scrivenings, easy assignment via a “pallet”, and viewing as an attribute in outline view is because many elements in patent workups and biz plans need special “breakout styles” for easy review.

For example, when citing another application in patent work, it would be great to just assign it a style when creating the scrivening object. Makes this important element stand out when reviewing to total compiled output.

That’s it from me. Hope this is well received, and not something that is already a feature – I’ve been focuses on getting my work done with Scrivener not exploring all the features (first video is nice, but where are the others?).


At the moment, from what I understand, anything to do with styles is limited to the fairly useless Apple text engine (a search will confirm all its limitations). Most regulars on the board will confirm that Scrivener is not a word processor and will not handle styles in the way you are asking for, and suggest that this is the job of a word processor, after the writing phase.

I haven’t seen anything from Keith that would suggest that he is interested in the structural markup you’re looking for, but he may be able to clarify. My own view is that your request is about writing rather than formatting, and is something I’ve wanted from Scrivener, but it seems like it is either too hard to implement or not really a priority for Keith. There are various workarounds (Multimarkdown, etc) that you can use to get what I think you’re looking for.


To answer the last first: more videos should be up soon. David’s in charge of the video tutorials, and we hope to start getting them up every couple of weeks. He is in the process of moving house, though, so once that’s out of the way, you should start start seeing them more regularly. We’re very keen to get more up there too.

As for styles… Hmm, interesting idea. I have been pondering on a better way of applying styles for 2.0. One thing that 2.0 does allow, which is moving towards what you are suggesting, is the application of styles per level at the compile stage (so a text document inside a folder could have a different style to a text item on the same level as the folder, for instance). Your suggestion has given me some ideas for refining this, though. What I’m now thinking would be rather cool, and which could be used instead of a full auto-updating styles system (which is difficult in Scrivener because of the number of documents in one project, and the problems that could arise by changing the style of text documents in the project that are not currently visible to the user), is the following:

• There could be a palette window with a list of styles on the left, and a text view on the right allowing you to set up the paragraph formatting for that style. You could use this palette for creating new styles and for applying styles to existing text if you wanted to.
• In the Inspector, I could get rid of the “Preserve Formatting” button and replace it with a “Compile Style” pop-up button, which would have the following items in it:
– Use Compile Style (the default - would use the settings chosen in Compile Draft).
– Use Document Style (the same as “Preserve formatting” - doesn’t override the formatting when compiled).
– List of styles (a list of the paragraph styles set up in the palette for this project).

This pop-up would also be available in the outliner and in the content tab of Compile Draft. I think this would be a pretty cool solution, allowing users to do no more than in the current version for simple formats, or to take control of the formatting by level for hierarchical documents, or take control of styles on a document-by-document basis. It would be a styles system that suits Scrivener, too, being applied at the Compile stage rather than “live”.

Thanks for the suggestion. Hopefully the above is more or less what you had in mind (the styles list could also appear in the Documents > Convert > Formatting menu…). I have two weeks already allocated for working on styles for 2.0 sometime in December, I think, and I now have a really good idea of where to go with it, as I really like this idea.

Thanks again and all the best,

P.S. dtak - looks like you wrote your reply as I was writing this. My problem with styles has always been how to apply them to all the text in the project when the user can’t see much of the text at any one time; it’s not like in a word processor where all of your text is open in the one document - that’s much easier to implement, causes less problems with undo, and the user can easily glance through the text to make sure that it looks like he or she wanted. In Scrivener, hundreds of documents could be affected without the user realising, and it could be days before he or she realises that they accidentally messed everything up and now has to fix it by hand. But applying styles and formatting at the compile stage, such as Steve is suggesting; that’s something different, and something that really fits with the idea of worrying about formatting only when compiling, and could really fit in well with 2.0 and give users that extra flexibility.

Keith, sorry to butt in, but I’m not sure I see the problem with not being able to see the style changes in documents that are not loaded. This would be much the same as for the project replace - you can do it, but you’d better check to make sure. How long it would take to replace all the styles in a large project is another matter. :confused:

Sounds good. Would that then just apply a particular style to the whole document or individual paragraphs?

Mmm. I suppose if I wanted to apply it to a single paragraph, I could somehow have that paragraph as a single document. Never thought of doing that before. Tricky if you need a lot of different styles on the compiled page, but doable.

Another update:
I guess the trick is to see Scriv as a sort of hierarchical LaTeX type of thing, rather than a hierarchical word processor.

You could use the floating styles palette to change the style of a particular paragraph within a document there and then, too. So if, say, one paragraph needed particular formatting, you could use the palette to change its style within the document, then use Scrivener 2.0’s new “Preserve Style” feature to tell Scrivener not to change the style of that particular paragraph during compile.

The problem with changing styles throughout the whole project isn’t just limited to how you cannot see all the documents at once - although I still think that’s a problem because it would be very difficult to make it undoable. There’s also the problem of how the OS X text system has nothing built-in for recognising styles, no way of tagging this or that paragraph as belonging to a certain style.

All the best,

Yes, it does seem that the only option for tagging paragraphs would be to use the binder for paragraph by paragraph document structure (which does not really seem to be what it’s designed for). A pity Apple’s text system is so lame - what I need is to be able to e.g. set a paragraph to be tagged as a blockquote and to ensure that it will stay a blockquote on compile (where whatever formatting could be applied to it). It appears that without MMD such an approach isn’t possible?



Mmm … it seems that you’re pretty close to cracking the problem. If you defer the styling to compile time, then you don’t really have to worry about changing them while you’re writing (LaTEX folk would say this isn’t the way to write anyway).

I dunno. Scrivener seems to support multi-level hierarchies. Is a paragraph level possible? Or perhaps some kind of meta command to include a document (and it’s associated compile style) from somewhere else in the hierarchy when the document is compiled.

2.0 does have a way of telling paragraphs to remain as block quotes, for instance - it’s called “Preserve Style”. This is like “Preserve Formatting”, only it works on a textual basis rather than a document basis. Here’s how it works:

  1. You apply some formatting to a paragraph or chunk of text - for instance, you make it a block quote.
  2. Realising that you aren’t going to want this paragraph to have its formatting completely overridden, you select the text and apply “Preserve Style” to it. Here’s how it looks then:

(Note that the nasty lilac colour has yet to be tweaked into a cooler, paler blue.)

Now, at the Compile stage, by default Compile Draft will not change the formatting of that paragraph at all. However, you do have a little more control even at the Compile Stage. You can choose exactly what Preserve Style preserves - you can choose for it only to preserve the alignment, font size and tabs and indents (or a combination thereof). So here is what the above chunk of text might look like when passed through Compile Draft in 2.0 using standard manuscript format, and with Preserve Style set to preserve only font size, alignment, tabs and indents:

Preserve Style thus allows you to mark up certain passages and requiring special formatting within a document.

All the best,

Well, that’s pretty great. It’s not as conceptually neat as paragraph styles, but given the constraints of the Apple text system I can see how this can be easily hacked into doing all sorts of structural document markup (without resorting to MMD which requires introducing new characters into the text). Bring on 2.0 beta!

Actually forget I said that, it’s a terrible idea.

Aside from looking completely alien to the way Scrivener works, if a writer did a circular include, then the whole compilation would collapse in a big heap.

If you have a way of marking a paragraph to be preserved on compilation, could that not be extended so that it you can tag blocks of text with some kind of named style (similar to the tagging for footnotes)? Then on compilation, that named style could be applied to the block (unfortunately, I don’t know what is involved in compiling the documents, so it may be impossible). That way, styles could be changed from the compilation window and affect the finished document on output.

Would be completely invisible while editing though.

The trouble with that - and it’s the sort of idea I’ve played with - is that it gets complicated for the user, maintaining lists of styles that aren’t actually applied anywhere until compile time. I still have two weeks dedicated to this in a couple of months, as I say, so more thoughts welcome as I’m still thinking about this too…

Yes, I see what you mean. There would be no way of actually seeing the effects of the style while you’re editing. I have a feeling you may be right; folk may find that very problematic. Seems like I’m trying to turn Scrivener into Visual LaTeX here … :frowning:

Okay, daft idea #2 - can you do a pop wysiwyg view on a block of text if they cursor into and press the space bar (kind of like a Quick look). Sounds hard while I’m thinking about.

daft idea #3 - hire someone to steal the Nisus rendering code from their office safe

Mollys Mum has asked me to ask a daft question for her. What exactly is meant by the word, [i]'Styles'[/i], in this particular context :confused: cyou very much

I don’t think that would complicate my use very much - after all, for people who have no need to apply formatting based on styles, they simply wouldn’t use them.

My ideal scenario would involve something a bit more structural than “styles” as we generally describe them. What I’d like are to be able to tag words, sentences or paragraphs of text with some kind of metadata (e.g quote, header, John, Jill, etc. - like the keywords?). At compile time, any kind of thing could be done with those tags, including applying e.g. one of the OS X text styles to pecifically tagged text. There might also be other applications for this kind of structured tagging of text?

Not sure if this is a realistic request or not, but at least it moves it away from having to render text in the document?

Text formating combination. This allows you to apply a predefined format too text simply by selecting the “style” instead of needing to select the individual format components.

Being that you and mum (I highly doubt it is really her question as she has yet to shy away from “silliness” in her questions) are involved (and pink is probably not far behind) I recommend the in your creation of styles you allow free vent to your creative-naming side. I can just see vi-k’s style list now. I am not sure it is safe to publish though.

Rather than format the look of a piece of text, a style more or less defines what it is, so the look can be applied later on.

Okay, you have a document with lots of chapter titles. You want the chapter titles to stand out. Now normally, you would through your document and make the headings bold, like this:

Chapter 1

So you’ve said what headings look like. Styles, in this context, says what the piece of text is.


Now in your list of styles is an entry stating what a should look like (font, size, centred etc.), when you change it, all the chapter headings will take on the new look, which saves having to hunt through all your chapter headings and changing them manually.

I like this idea a lot, but I still think everyone would need some sort of clue in the text window, otherwise how would they know which piece of text had the tag applied?

Hmm, off the top of my head… What about something like this:

  1. Ability to set up a list of “Compile Styles” somewhere.
  2. Ability to select some text and assign a “Compile Style”. This would highlight the text and put a dotted line around it, like in the “Preserve Style” screenshot I showed earlier:

(You could possibly assign a different colour to each style, maybe.)

  1. If you hover the cursor over such a block, a tooltip will appear telling you what style is assigned to it.
  2. In Compile Draft, you could choose the formatting for each “Compile Style”.

This is really just a more advanced version of the “Preserve Style” option. It’s still not true, auto-updating styles, but it would allow you to quickly mark-up a section of text as belonging to a particular style, knowing that you could worry about its proper formatting at the Compile Stage.

Combined with hierarchical formatting, this could offer a lot of flexibility, and it keeps the main formatting work at the Compile stage.


That would be a beautiful solution, to my mind.