This page is, by definition, always a work in progress. But hopefully you'll like what you see.
Before you look at screenshots of the UI, have a look at what Quill and Parchment produces.
Here's an example document, as rendered to PDF by Parchment and seen in Evince
(you can download
[5 pages, 487 kB] and look at it yourself if you're interested).
This is just some silly nonsense, but it does exercise the various semantics we support so far. Note that the fonts used here are printer fonts, or at least, are fonts that look really bloody good at 1200x1200 dpi on paper. They are not the fonts used for editing, and while they look ok zoomed-in inside Evince, that's not really the point.
Editing in Quill
Contrast the above final rendered output to what working in the Editor looks like.
Told you it was a nonsense
:). But it illustrates how the editor
presents an different user interface for different block types, and at the
inline level, how a number of different semantic markups appropriate to
technical documentation are supported (in the example, normal text, a filename,
class or type, a method or function name, some literal
code snippets, a command you can execute, and an
Application or project name in this example,
along with the standard rich text italic emphasis
and bold text, of course).
These are not the markups used when publishing; these are simply used to give a visual differentiation for different semantics that is smooth and not overly distracting to the eye.
Using the real estate
Quill is actually designed to be make use of all available screen estate, so the fullscreen screenshots are necessarily rather large images. They were taken on a 1366x768 laptop monitor. Click on the thumbnail to see the full image at native resolution.
The left hand side is the editor, of course; in this case, the right hand side is not the editor; it is a live preview of what a rendered page will look like on the right hand side. This preview is drawn with the same Cairo code that is used to render the PDFs, so you get an accurate representation of how your page is going to layout on paper.
Here's a close up of the preview:
The Preview comes up (or refreshes) when you press F5.
Here we can see the main help screen, showing the accelerators used for applying semantic markup:
Navigating via the Outline
Since figuring out where you are in a large document is often challenging, integral to Quill is an Outline function, giving you an overview of the document structure along with information about which file each chapter is stored in along with current word count.
You can see that the left hand side is still the Editor. You can also see an
image with a caption that has been added. And lots of spelling mistakes
highlighted; apparently artificially generated Latin isn't a language I have a
spelling dictionary for.
Pressing F6 will get you to the Outline.
Here's the Outline from a somewhat more complex document. You can see the underlying filenames, the component word counts, and a schematic representation of the content of each chapter:
The chapter and section headings are buttons; clicking on one of them will jump you to that location in the editor.
Configuring the render engine
All things considered this is pretty self-explanitory; you select the RenderEngine class that's going to handle rendering your document, tell it the output paper size and margins, and then specify a collection of complimentary fonts:
The fun part here is the font height display allowing you to quickly convege the x-heights of the sans-serif and monospaced fonts you've selected to the x-height of the serif font that will be used for the bulk of body text. This is pretty important; fonts rarely go together cleanly. Once selected, however, the renderer can use these typefaces smoothly together and you know they will be complimentary.
The Stylesheet editor is on the left-hand side (if you're changing things then you'll want the Preview up, and it's on the right) and is accessed via F2.
Specifying document metadata
Finally there's a small amount of global metadata for each document. Mostly that boils down to specifying the language that's being used for spell checking. The document author and title is also specified here; these are available for the renderer to use if it draws headers and footers.
F3 will present the document Metadata editor pane on the left-hand side:
There's not much too it, which is a good thing; yeay simplicity. The values from the Stylesheet editor and the Metadata editor end up directly in the .parchment manuscript file; see the File Format page for more details.
Notes and References
One of the most frustrating things about conventional WYSIWYG word processors is the difficulty of editing footnotes. You don't want to jump to the bottom of a page to then squint and something in a tiny font. Instead, Quill presents the notes for the current chapter you're editing on the left-hand side in a separate view on the right-hand side. This way you can see the context of what you're writing a note about.
You get your Endnotes up on the right-hand side by pressing F7. A close up of the notes from one of the chapters of a conference paper:
You're free to number your endnotes consecuitively through the document as a whole (common for essays, conference papers, and journal articles) or to restart numbering with each chapter (appropriate with book length works).
As you can see from that example, you can refer to references from endnotes, though its as common to have citations in the main body of the text. Speaking of references, here's the References editor, which you get the References up on the right-hand side by pressing F8:
Quill doesn't impose any scheme on the way you style your references; there are way too many variations out there, so the reference lables are just freeform text. You can use whatever style you need to, and since some people have to do really long ones — like (Eintsein, 1905b) or worse — so we left space for that in the UI.