Fargo Docs

What is Fargo?
  Fargo is a simple idea outliner, notepad, todo list, blogging tool, project organizer.
  It's an HTML 5 application, written in JavaScript, runs in any compatible browser, including Chrome, Safari, Firefox, Microsoft IE 10.
  Files are stored in Dropbox, using the Dropbox API. They are accessible anywhere Dropbox is. You can share files with other users, or publicly.
  #### How much does Fargo cost?
    There is no charge to use Fargo.
    We don't want any limits on the growth because we think outlining is vitally important to the growth of the net as a thinking person's platform.
    We will eventually offer for-pay services to Fargo users.
  #### Where can I try it?
    http://fargo.io/
  #### What outliners are used for
    Notetaking.
    Organizing projects.
    Course outlines.
    Content management.
    Bulleted lists.
    Programming.
    Blogging.
    Narrating your work.
    Thinking.
    Presentations.
    Brainstorming.
    Writing.
    Design.
    Specifications.
  #### What is an outliner?
    It's an editor that works with hierarchic structures. You can control the level of detail, and reorganize according to structure.
    For a full explanation of how outliners work, check out our new Outliner Howto.
  #### How does it relate to Little Outliner?
    Fargo is our full-featured outliner. Little Outliner is our entry-level product.
    Fargo can be used to edit a number of files at at the same time, where Little Outliner is limited to a single file.
    Little Outliner only stores files locally, and Fargo stores them where ever Dropbox files go.
  #### Screen shot
    Fargo screen shot with several tabs open.
  #### Competition
    There are desktop outliners, and those that run in browsers. Fargo is the only idea organizer that runs in the browser, cross-operating system with entirely cloud-based storage.
    Fargo is used for many of the same things as a notetaker app like Evernote. However Fargo is simpler, and the user's data is always fully available to them in an open format, OPML, at all times, in their Dropbox folder. No export needed.
  #### Roadmap
    Fargo is Small Picture's primary product.
    Little Outliner is a place for people who are new to outliners to get a feel for how they work. It will remain simple, general, easy and approachable. It's where we expect new users to start.
    We will strive to keep Fargo simple and approachable as well, and some people will find it easier than Little Outliner because they are already familiar with Dropbox.
    Fargo will get new features, connections to new platforms and other products and network services.
    We may offer other specialized products after Fargo and Little Outliner. All of our products will be built on outliners and communication.
    Concord is the open source outlining engine in all our products. It manages the data structures and basic user interaction. Concord's functionality is documented in our Outliner Howto.
    Fargo has a complete content management system which can be used to generate blogs and many other kinds of websites.
    All outlines are stored in OPML, one of the most popular formats on the net, openly specified at dev.opml.org. OPML allows our software to plug into other components developed by Small Picture and others. We believe OPML will become as important a format in this decade as RSS was in the last decade.
  #### Company
    Small Picture, Inc. is a Delaware corporation, founded on December 19, 2012.
    Its founder, Dave Winer, 58, has a long history in the tech industry. He started Living Videotext, founded in 1981, created the first personal computer outliners, ThinkTank, Ready and MORE. UserLand Software, founded in 1988, created Frontier, integrated development tools and web content management software for desktop computers. UserLand developed the first blogging software, Manila and Radio, and pioneered the development of RSS aggregator and interapplication protocols. Winer was the first blogger, and pioneered the development of podcasting, in 1994 and 2001 respectively. He has been a researcher at Harvard and NYU and has a MS in Computer Science from the University of Wisconsin, and a BA in Mathematics from Tulane University. He lives and works in New York City.
About Fargo 2 beta
  Welcome to the Fargo 2 beta.
  If you were a user of Fargo before this release, you should find everything is still where it was. At the surface level, there's not much difference between the two versions.
  #### The CMS is in Fargo
    The big change is this -- under the hood there's a content management system or CMS. This means that the Fargo running on your computer can do a lot of things that server software like WordPress or Tumblr does, without the server. This means that you have a lot more freedom about where you host your website, and it means there's no central server doing the rendering as there was with the first release of Fargo.
  #### Where to look
    The "Blogging with Fargo" section is a good place for writers to begin.
    If you're a designer, developer or web programmer, look at the "Content Management" section.
  #### Mail list, blog
    We've got a support mail list for the Fargo 2 beta.
    There's a blog and it has an RSS feed.
    Support is only available on the mail list, most definitely not on Twitter. It's impossible to fully describe a problem or a solution in 140 characters. We don't even try. Use the mail list. Thanks. ;-)
  #### It's a beta
    As long as there's a big red BETA in the right margin of the app, it's still provisional and you should expect breakage. Back up your work! ;-)
    When we go final, the version number will change to 2.00 and the BETA will be removed. If all goes well that should happen fairly soon.
  #### Where your work is hosted
    Rendered content for named outlines is stored at xyz.smallpict.com -- where xyz is the name of your outline.
    All the Fargo 1 names have been ported to Fargo 2. You should be able to continue to update those outlines, and when you update them you'll see the changes at the same smallpict.com address.
    As before, the Eye icon in the left margin will take you to the rendered version of the page.
    It takes a little longer now for the content to make it up to its web location, but once there, it should be fast and reliable and will scale because we're storing the pages in an Amazon S3 bucket. Your readers should find your site very responsive.
    I can't guarantee that I'll host your content forever and for free. I'm just one person, paying for this from my savings account. I do it because I love this stuff. But I also have to eat and pay the rent, like everyone else. So this is just how we get started.
    All rendered content for each outline is also stored in the html sub-folder of the Fargo app folder in Dropbox. We're going to be looking for services that can sync with the sub-folders of the html folder. We've already figured out how to do it with the Pages service on GitHub. I'm sure there will be more such connections in the future.
    Fargo connects to smallpict.com through a new protocol (that's still evolving as of Feb 2014) called fargoPublisher. It's documented by a node.js implementation which is open source. As it settles down I'll be writing separate docs.
    Bottom-line: Fargo2 technology is very simple on the back-end. The complex, expensive stuff runs in Fargo itself.
    You may see highly technical discussions take place on the Fargo2 mail list. As always if you don't understand something, don't worry. There are many levels to Fargo. ;-)
  #### What's new?
    Here's a list of things Fargo users should have a look at.
    There's a new CMS panel in the Outline Settings dialog in the File menu.
    There are two new commands in the Fargo File menu: Render Page and Render All Pages.
    Named outlines are back and they work. ;-)
    There's a new icon in the left margin that renders the page the bar cursor points to.
    Fargo 2 is built around Markdown. (The rules-based renderer was part of the old CMS and didn't make the transition.)
    There's a new way to upload images using Fargo.
    The docs are rewritten to reflect the changes in the software, and the links in the Docs menu work. ;-)
  #### Version numbers
    The numbers will advance quickly while we're in beta.
    When the new version is finalized, the Fargo version number will change to 2.00.
  #### Markdown
    As we embraced user scripting with JavaScript, Bootstrap and Font-Awesome in Fargo 1, the CMS in Fargo 2 is built around Markdown.
    Almost everything you read here flowed through the Markdown processor, for better or worse. (Two exceptions are presentations and automatically generated index pages.)
    We're going to learn how to make Markdown work really well with outlines.
    That's one of the big goals for Fargo 2.
  #### Who I am
    My name is Dave Winer.
    New York, NY
    January 29, 2014
Outliner howto
  #### What is an outliner?
    An outliner is a text editor that organizes information in a hierarchy, allowing users to control the level of detail and to reorganize according to structure. Your notes can have full detail, yet be organized so a casual reader can get a quick overview. Outlining is a great way for teams to organize work.
    Paul Ford, an early user of our software, said: "What Google Maps does for geography, outliners do for ideas." Map software lets you zoom in at any level of detail. Same with outliners.
  #### The bar cursor and text cursor
    In an outliner are two kinds of cursors, a bar cursor, which is black, and covers a whole headline, and a text cursor, which is a vertical line, also called a caret. The text cursor flashes slowly.
    Each headline has a wedge, displayed to the left of the text, a small triangle that's either gray or black. If it's black that means there's unexpanded text below the headline.
    There are two modes, structure mode and text mode. To go from text to structure mode, click once on a wedge. To go from structure to text mode, click on any character inside the headline.
    To expand a headline, double-click on the black wedge. To collapse, double-click on the wedge of an expanded headline.
    The headline the bar cursor points to is called the bar cursor headline. You'll see that term used in the docs below, because many commands apply to the bar cursor headline. In the screen shot at the top of this section, the bar cursor headline is the United States.
  #### What is an outline?
    An outline can contain many headlines that are organized in a hierarchy.
    A top level headline is called a summit. An outline can have many summits.
    Underneath a summit are more headlines, which in turn contain headlines, many levels deep.
    Headlines can also have attributes such as a creation date or a serial number. Headlines are often called nodes in this context.
    The whole thing, a hierarchy of headlines with attributes, is the outline.
  #### What does Cmd mean?
    If you're using a Macintosh, when we say Cmd-X that means hold down the Command key, the one with the ⌘ on it, and press X at the same time.
    If you use Windows or Linux, when you see Cmd-X, think Control-X. We use this short-hand rather than repeating this equivalence every time we talk about a Control key.
  #### How do you enter text into an outliner?
    To create a new headline, put the cursor on the headline above where you want the headline to appear and press Return.
    Type as you would into a text editor. When you want to create another headline, press Return.
    If you want to move the headline in by one level press Tab. To move it out by one level, press Shift-Tab.
    You can bolden the selected text with Cmd-B, and italicize with Cmd-I. To un-bolden or un-italicize, just repeat the Cmd key.
  #### How does expand and collapse work?
    If you want to expand a headline, to see what's underneath, double-click on its wedge.
    This only works if the wedge is black. If it's gray that means there's nothing underneath to expand. So you can see from a distance where there's hidden text.
    To the right is a screen shot that shows the Midwest headline expanded. The Michigan headline has a black wedge, that means there are unexpanded items below it, entries for the cities of Flint, Detroit, Ann Arbor.
    To collapse a level, double-click on the wedge next to its parent.
    You can expand and collapse using the keyboard with Cmd-, (comma). If the bar cursor headline is expanded it is collapsed. If it's collapsed it expands.
  #### Can you explain how the arrow keys work?
    When you're in structure mode...
      moves to the previous headline at the same level.
      moves to the next headline at the same level.
      moves flatdown -- to the next headline, regardless of level.
      moves flatup, to the previous headline, regardless of level.
    When you're in text mode...
      and move to the previous and next character.
      and move to the next and previous headline, regardless of level.
  #### How do you delete a headline?
    You can delete a headline and all its subs by placing the bar cursor on the headline, and press the Delete key.
  #### How does Undo work?
    If you do something that you want undone, press Cmd-Z to Undo.
  #### How do I reorganize an outline?
    Suppose we decide to reclassify Arizona as a Far West state (it's currently in the Southwest).
    To move it using the mouse, first expand Southwest by double-clicking on its wedge. Then click on the wedge, and hold the mouse button down, and move the mouse pointer to the wedge in front of Far West, and while continuing to hold the button down, nudge the mouse to the right until the arrow points down and to the right. Let up the mouse. Far West expands and Arizona becomes the first item under Far West.
    To move it using the keyboard, expand Southwest and click the wedge in front of Arizona. Press Cmd-L, then Cmd-U repeated until it's just below Far West. Then Cmd-R to move it under Far West.
    The keystrokes for moving are Cmd-U for up, Cmd-D for down, Cmd-L for left, and Cmd-R for right.
    Tab does the same thing as Cmd-R and Shift-tab is the same as Cmd-L.
    Either method works as well as the other, it's just a matter of preference or what's convenient.
  #### Shift-click and Cmd-A
    Reorganizing usually applies only to the bar cursor headline.
    But you can select a group of headlines using shift-click and then use dragging move or the Cmd keystrokes to reorganize.
    To select all the items at a level, Select All or Cmd-A.
  #### Selecting all the text in an outline
    A frequently asked question.
      Click on one of the top-level headlines in your outline.
      Click on the wedge to go into structure mode.
      Press Cmd-A to Select All.
    That's it, you've now selected all the text in the outline.
  #### Return vs Enter
    If you have a keyboard that distinguishes between Return and Enter (as the full Macintosh keyboard does), then the Return key will work as described above, and Enter toggles between text and structure mode.
  #### Promote and demote
    If you decide that a category is no longer necessary and want to move all of the former sub-heads out to the same level as their parent, that's when you need to promote the subs. To do so, put the cursor on the parent and press Cmd-[ to promote the subs.
    Suppose you have a list of items and want to move them all under a new parent. That's called demote and is a little more tricky.
    Create the new parent headline at the same level as the soon-to-be subs, and just before them in their list. Then press Cmd-] to demote.
  #### Cut, Copy, Paste
    The normal clipboard operations apply. To Cut, press Cmd-X, to Copy press Cmd-C and to paste press Cmd-V.
  #### Wedges and attributes
    Earlier in this document we talked about wedges, as gray or black triangles. But you'll see other wedges from time to time. They usually indicate that there are attributes attached to the headline. Attributes themselves are usually not visible.
    When you're moving headlines by dragging with the mouse, the wedges on the target headline will change to an arrow, to indicate where the headline being dragged will be deposited when you let up.
  #### Render mode
    Sometimes your outline text will be published on web pages. You can enter HTML markup in your text, and it will correctly flow out to the OPML file.
    A limited set of markup -- boldface text, italic text and links -- will be rendered if the outliner is in render mode.
    When the outliner starts up, it is in this mode. If you want to see the markup and possibly edit it, you can go into non-render mode by pressing Cmd-` and return to render mode by pressing it again. It's a toggle.
  #### One-line JavaScript code
    If you enter a snippet of JavaScript code into a headline in the outliner, you can run the code by pressing Cmd-/.
    The result is entered as a sub-head of the headline containing the script code.
    For example, if you enter 12 + 12 in a headline and press Cmd-/, its sub-head will contain 24.
    You can enter code as complex as you like, you can even call functions implemented by the outliner itself.
    It can be useful, if you're a programmer, to keep a library of one-liners in a section of your outline, ready for you to Cmd-/ them.
  #### Commenting
    In programming languages and some content management systems, you can "comment out" text, so that it isn't processed. This allows you to leave notes to yourself that don't get passed along, but are saved in the OPML file. The comments will still be there next time you open the file.
    To comment a branch of the outline, press Cmd-\\. To uncomment, repeat the keystroke.
    When you comment an item, its wedge changes to a chevron, as well as the wedge next to all the items below it.
Using Fargo
  Fargo and Dropbox
    Fargo is a multi-tab outliner that stores files in Dropbox.
    It's an HTML 5 app written in JavaScript that runs in web browsers.
    When you visit fargo.io the first time, on every device, you'll see a dialog confirming that you want to visit the Dropbox website to authorize Fargo, to read and write to a single sub-folder in your Dropbox folder at Apps/Small Picture. Fargo stores all your outlines, settings and status info in this folder.
    Any other instances of Fargo that you have running, on your tablet, for example, observe the changes in this folder. So you could set up your desktop to have certain files open, and then when you access them from your iPad, it will have the same tabs open and they will have the same items expanded.
    Note: The app folder that Dropbox creates is called Fargo for some users and Small Picture for others. In the docs we refer to it as the Small Picture folder.
    #### Dropbox backs up your outlines
    One of the benefits of using Dropbox to store Fargo outlines and data files is that Dropbox automatically manages a stream of backups as you modify your outlines.
    So, if you accidentally delete something, or decide you want to go back to an earlier version, for any reason, Dropbox very likely has a backup copy that you can revert to.
    For more information, see the howto on the Dropbox website.
  Fargo's menus
    #### The File menu
      The File menu contains commands that for the most part, create, open and close files.
      New, Open, Close and Save work as they do in desktop apps. They work on files in the Small Picture folder.
      Outline settings opens a dialog that allows you to change default values for the outline in the active tab. More info.
      Archive cursor creates an archive of the bar cursor outline.
      Import OPML asks for the URL of an OPML file and imports it into the outline in the active tab, down from the bar cursor headline.
      Name outline allows you to give the outline a public name.
      Render Page creates and HTML rendering of the page the bar cursor points to. Render All Pages renders everything in the outline in the active tab. These are content management commands.
      View In Reader opens the current outline in Small Picture Reader.
      Get Public Link gets you a link to the file in the current tab. All your Dropbox files are private, until you create a public link to one. Then whoever you give that link to has read-only access to the file.
      Open by URL asks for the URL of an OPML file and opens it in a new tab, in read-only mode. It notifies you when the outline has changed. You can remember these outlines using the Bookmarks menu.
    #### The Outliner menu
      Many of the commands in this menu are explained in the "Outliner Howto".
      Expand -- expands the bar cursor headline, showing the first-level subs.
      Expand All Subs -- expands all sub-heads at all levels under the bar cursor headline.
      Expand Everything -- expands everything in the outline in the active tab.
      Collapse -- collapses the bar cursor headline.
      Collapse Everything -- collapses everything in the outline in the active tab, showing only the top-level headlines, or summits.
      Show arrow pad -- opens a navigation and reorganization control allowing you to work with outlines on a device without a mouse or real keyboard, such as a tablet or a smartphone. More info.
      Edit Attributes -- opens a dialog that allows you to edit, add or remove attributes attached to the bar cursor headline. More info.
      Choose Icon... -- opens a dialog that allows you to attach a Font Awesome icon to the bar cursor headline. More info.
      Add Include... -- opens a dialog prompting you for the URL of an OPML file include, through the headline pointed to by the bar cursor. More info.
      Add Feed... -- opens a dialog prompting you for the URL of an RSS or Atom feed. The bar cursor headline will point to the feed. Useful for editing OPML subscription lists in Fargo.
      Find -- prompts you for a string to search the current outline for. When you click OK, the search begins and the search stops on the first headline that contains the string. More info.
      Find again -- repeats the previous find starting at the current bar cursor headline.
      Run Selection -- runs the text of the bar cursor headline through the browser's JavaScript interpreter, inserting the resulting value as a subhead of the bar cursor headline.
      Toggle Comment -- if the bar cursor headline is a comment, uncomment it. Or comment it if it's not commented.
      Non-render mode -- switch between render mode and non-render mode. In render mode HTML markup is applied to the text, in non-render mode you see the actual markup (making it easier to edit the markup).
    #### The Reorg menu
      As with the Outliner menu, many of these commands are explained in the "Outliner Howto".
      Move Up -- The bar cursor outline exchanges places with the outline above it.
      Move Down -- The bar cursor outline exchanges places with the outline below it.
      Move Left -- The bar cursor outline moves out one level, to become a sibling of its former parent.
      Move Right -- The bar cursor outline moves in one level, to become the last child of its former sibling.
      Promote -- All the subheads of the bar cursor headline move out one level.
      Demote -- All the siblings of the bar cursor headline that are down from it move to the end of the bar cursor's child list.
    #### The Bookmarks menu
      There are two kinds of outlines in Fargo. 1. Editable outlines. 2. Watched outlines.
      Editable outlines are in the Fargo sub-folder of your Dropbox Apps folder. Open them with the File/Open command. Watched outlines live elsewhere. You can open them in read-only mode via the Open By URL command, also in the File menu. When they update, your view of them updates.
      The Bookmarks menu is for watched outlines. It works more or less like the Bookmarks menu in a web browser. When you have opened an outline that you want to remember, choose Add Bookmark from the Bookmarks menu. A dialog appears asking what you want to call the bookmark. We suggest the title of the outline (or the long title if it has one).
      When you choose Edit Bookmarks, a new tab opens with the contents of the menu in an outline. You can edit the bookmarks there. The menu contains link nodes. You can change the text, or the URLs associated with the items, and reorganize the menu in any way you like.
      Only the top level headlines are included in the Bookmarks menu.
      See the Workgroups section for more on the Bookmarks menu.
    #### The System menu
      We call the menu at the right edge of the menubar the System menu. The name of this menu is the name you are logged-into Dropbox with, so on my system it says Dave Winer, and on your system it will have your name. Screen shot.
      About Fargo -- opens a window with an outline that provides an overview of Fargo.
      Settings -- opens a dialog with the global settings for Fargo.
      Sign Out -- disconnects from Dropbox. This will take you through the startup process again, and you can connect with another Dropbox account if you like, or just sign off to prevent local access to your folder.
  Icons in left margin
    The left margin in Fargo contains a column of icons for frequently used actions.
    The + icon adds a new item to a calendar-structured sub-outline in the current outline. It creates headlines as it needs to. The top-level headline of the calendar is the current year. Under that is the month, and below that is an entry for each day. When you click the + it creates a new item under the current day, ready for you to type into it. Try it and you'll immediately see what it does.
    The B, I and S icons bolden, italicize and strikethrough the selected text. If you're in structure mode, it does this to all the text in the bar cursor headline.
    The link icon creates an HTML link if you're in text mode, or if you're in structure mode, it turns the headline into a link node.
    The suitcase icon is a direct link to the Edit Attributes dialog.
    The share icon renders just the document pointed to by the bar cursor, none of its parents or sub-documents. It's useful when you have configured Fargo, via the Outline Settings dialog, to not automatically render after every change, or if you just want one page rendered, and not all of its subs and parents.
    The home icon, if present, allows you to visit the home page of the website the bar cursor headline is inside of.
    The eye icon, if present, allows you to view the contents of the bar cursor headline on the web. For example if it's pointing to a link node, you'll visit the page the link node points to.
  Find and Find again
    When you want to search your Fargo outline for a word or phrase, either choose Find from the Outliner menu, or press Cmd-F (Control-F on Windows or Unix).
    Enter the word or phrase, and click OK. If the string is found, the outline is expanded to reveal the headline, and the bar cursor moves to it.
    If you want to repeat the same search, choose Find again from the Outliner menu or press Cmd-G.
    The search is case-insensitive. For example, if you search for Minnesota, it will match minnesota or MiNnESoTa.
    The search begins at the bar cursor headline, and continues through all levels of the outline. When it reaches the end, it wraps around to the beginning.
    If it fails to find the string, it beeps and displays a dialog.
  The Arrow Pad
    The arrow pad is designed to make reorganizing and navigating in an outline easy on a tablet like the iPad.
    To access the arrow pad, choose the command from the Outliner menu.
    Screen shot.
    There are two buttons and four arrows.
    The leftmost button says either Navigate or Reorg.
      If it says Navigate, the arrows move the cursor.
      If it says Reorg, the arrows reorganize the outline.
    The arrows move in the indicated direction, when you click them.
      They are only enabled if movement in the indicated direction is possible. They are structural, so left moves to the parent when navigating, or moves the bar cursor outline out a level in
    The rightmost button says either Expand or Collapse.
      The setting depends on whether the cursor is on a headline that is expanded or collapsed, and it says what the button will do if you click on it.
    When you're in text mode in the outline, the arrow pad automatically goes into Reorg mode.
  Edit Attributes dialog
    You can open this dialog by choosing the command in the Outliner menu, or clicking on the Suitcase icon in the left margin.
    Each headline in an outline can have any number of attributes attached to it, invisibly. The attributes are saved with the outline, and move with the headline when you reorganize or copy and paste.
    Attributes serve as hints, often to the content management system, on how to interpret the outline and its subheads.
    For example, the type attribute tells the CMS how to render a page. The created attribute says when the headline was created.
    Screen shot.
    To add a new attribute, click on the + button in the lower left corner of the dialog. A new line will open. Enter the name of the attribute in the left column and its value in the right column.
    To delete an attribute, click on the trashcan icon to the right of the attribute.
    To edit an attribute, click on its name or value, and use the normal editing commands.
    Your changes aren't permanent until you click on the Save button.
  Includes, OPML format
    Headlines whose type is include are a special kind of pointer. They must have another attribute, url, that contains the address of another outline. When you're viewing the outline, it appears as if the outline being pointed to is part of the main outline.
    When you expand the headline, Fargo fetches the outline that's linked to, and adds it underneath the original headline, as if the linked-to outline were part of the outline doing the linking. When the included outline changes, there's no need to modify the outline that's doing the including, it adjusts automatically the next time you collapse and re-expand it.
    All outlines in Fargo are stored in an open format called OPML. Most outliners support this format, so you can include outlines created by those tools in Fargo, and vice versa.
  Named outlines
    Any of your outlines can have a name. The name is shorter and easier to remember than the URL assigned to it by Dropbox.
    You can name any outline anything you want, as long as:
      It hasn't already been named.
      The name you want to use is available.
      The name is 4 characters or more.
      It contains only alphabetic and numeric characters, or hyphens.
    To give an outline a name, click on its tab and choose Name outline in the File menu. A dialog appears. Screen shot. Enter a name. As you're typing, you're given an indication whether the name is available. When you're ready click OK. Be sure this is the name you want to use because it can't be changed or deleted.
    Right now there is no charge to create a name because these are early days, and you're helping us debug an important feature.
    You can name any outline, but only one outline is you. To say which one that is, choose Settings from the system menu (upper-right corner of the window). In the first panel, named You, there's a place to enter your Profile URL. Screen shot. This should be the address of your outline.
    If your name is "mitch" then your profile URL is: http://mitch.smallpict.com/.
    Note: This command is disabled as we transition to a new content management system.
  Icon Chooser
    The Choose Icon command in the Outliner menu brings up a dialog with several tabs. In each tab are 45 awesome icons. Screen shot.
    Click on one of the icons to set the icon of the bar cursor headline.
    Click Close to dismiss the dialog without setting an icon.
  Settings dialog
    The Settings dialog is organized into panels, one for each subject area.
    You -- asks for your name, email address, profile URL, Twitter and Facebook usernames. This information is included in the OPML files we generate.
    Font -- allows you to set the default font, size and line-height for outlines. You can override these choices for each outline in the Outline Settings dialog in the File menu.
    Auto-Save -- allows you to turn off auto-save (or turn it on if it was off). You can also control the minimum number of seconds between auto-saves. When you stop typing, Fargo will wait this long before saving, allowing you to pause briefly while typing without causing a save.
    Blog -- allows you to connect Fargo with a WordPress site. Enter the URL of the site, and your username and password. You can optionally have the blog post text pass through a Markdown processor on its way to WordPress.
    Insert -- controls the way the big + icon in the left margin works. You can set the type of newly created headlines, whether they automatically appear in the RSS 2.0 feed for the outline, and whether newly inserted headlines are initially commented.
    CMS -- allows you to configure the content management system built into Fargo 2.
    CSS -- allows you to include CSS style information that controls everything about the way Fargo displays. More info.
    Code -- allows you to provide JavaScript code that runs when Fargo starts up and when Fargo saves an outline with a public URL.
    Advanced -- you can provide an encryption password for all files that are encrypted, or hide the right sidebar, or display outline attributes in the right sidebar.
  Outline settings dialog
    The Outline settings dialog is organized into panels.
    Titles -- allows you to set the short and long titles for the outline, and provide a description. These values are available to templates in the CMS.
    Font -- allows you to set the font, font-size and line-height in pixels of text when you're editing the outline in Fargo.
    Encrypt -- has a single checkbox that says whether you want the content of this outline to be encrypted so that only you can read it.
    CMS -- has settings for the content management system as it applies to this outline.
    Overrides -- offers settings that are specific to this outline that override global settings.
  Encryption
    #### How it works
      Some files are encrypted, most probably aren't.
      You can't encrypt files that are published.
      There's a single encryption password used for all the outline documents you choose to encrypt in Fargo.
    #### To set the password
      Choose Settings from the system menu, the one with your name, in the right corner of the menu bar.
      Click on the Advanced tab. Screen shot.
      Enter the password and click OK.
    #### Pick a good password
      Once you've encrypted files, it's not easy to change the password, so pick a good one.
      It should be memorable, but not easy to guess.
      Do not store the password in your Dropbox folder.
    #### For each file you want to encrypt
      Activate its tab.
      Choose Outline Settings in the File menu.
      Click on the Encrypt tab. Screen shot.
      Click the checkbox and click OK.
      Make a change to the file to cause it to be saved or choose Save from the File menu.
    #### How to be sure it's encrypted
      In the file system open an OPML file you encrypted with Notepad or Text Edit. It should be a JSON file, not an OPML file. It contains the OPML, encrypted.
      Here's a screen shot of one of my test files after it's been encrypted.
    #### How to test
      Reload Fargo. It should open all the previously open tabs, including the one you encrypted. It should look exactly the same in Fargo, even though in Dropbox it's unreadable. That's the encryption working. ;-)
    #### To use it on other machines
      Enter the same password in the Settings dialog and open files as you would normally.
      You should get a dialog if you try to open an encrypted file with the wrong password saying there was an encryption error.
    #### If you need to change the password
      Open all of your encrypted files.
      Change the password in the Settings dialog.
      Make changes to each of the files to force them to be saved.
    #### The encryption we use
      We use the Stanford Javascript Crypto Library.
      Just plugged right in, couldn't be simpler. ;-)
    #### How secure is this encryption?
      I'm not an encryption expert, in any manner of speaking, so the honest answer is I don't know. If you spot any problems please let us know.
    #### Do we store the password on our server?
      No. We don't really have a server to store the password on.
      Fargo is a static JavaScript app that loads from an S3 bucket.
      All the processing takes place on your machine, including the encryption.
      The password is stored in HTML 5 local storage, on your machine. It is not transmitted.
    #### See also
      Scripting News: Encryption in Fargo 1.14.
      Scripting News: A light-hearted use-case for encryption.
    #### Video demo
  CSS settings
    The CSS panel mentioned in the Settings section can be used to style outline text by level. For example:
    .concord-level-1-text {
    font-family: Arial !important;
    font-weight: bold !important;
    }
    .concord-level-1 {
    margin-bottom: 8px !important;
    }
    Will make the top level heads bold and in Arial font and will add 8 pixels after every level.
    Another example, if you wanted to provide a background image to "skin" the Fargo app, you would add this bit to the CSS text.
    body {
    background-image:url('https://dl.dropbox.com/u/36518280/images/niagara.jpg');
    }
    To learn more about how this works, for styling experts, have a look at the generated HTML instructions in a good debugger.
  Using the Reader app
    You can share outlines with the Small Picture Reader app.
    ####To use it...
      Prepare an outline in Fargo that you want to share.
      When you're ready, choose View in Reader in the File menu.
      Reader should open, with your outline displayed.
      You can then send the URL of that page to friends or colleagues, or use the Tweet icon in the left margin to send it to your Twitter followers.
    #### Example
      Here's an example of an outline from Fargo being viewed in Reader.
    #### Automatic updates
      Reader is always checking to see if your outline has updated, and when it does, it automatically displays the updated outline.
      If this bothers you, click the lock icon in the left margin. Reader will hold on to any updates, and only show them when you unlock it.
      When there are changes the lock icon will change from gray to green.
    #### Rules are removed
      Rules are used in Trex to format outlines, but they are not interpreted in Reader.
      To make it possible for you to view outlines in either reading environment, in Reader 0.15 we remove any rules that may be present.
  Using Fargo with WordPress
    Starting with version 0.54, there is a connection between Fargo and WordPress.
    With this connection you can create new posts and edit them -- organizing your work in Fargo's outliner.
    You can also use the outline structure to format your blog posts. If you have the ability to edit CSS in your WordPress blog, you can style the text according to level.
    To set up the connection, choose Settings from the System menu in the upper right corner of the Fargo screen. Click on the Blog panel. Check the box to enable the connection. Enter the URL of your blog, your username and password. This information passes through our server but is not recorded.
    Screen shot of the Blog settings panel.
    To create a WordPress post, create a new headline, anywhere, and enter the title of your post. Underneath it, add the text of the post. Place the cursor on the title, and click the WordPress icon in the left sidebar. A dialog appears confirming that you want to post it to your WordPress blog. Click OK. Wait a few seconds. You should hear a beep. If you visit your blog you should see a new post.
    To edit the post, change the text or the title and click the WordPress icon again. You should hear a beep when it's saved. You can repeat this as many times as you like.
    If you don't see the WordPress icon that means that the prefs aren't set up correctly. Try doing it again.
    If you don't hear a beep that means something went wrong on the server. Try again. If after a few times you don't hear the beep or you don't see the updated text on your blog, post an item to the mail list. Include the URL to your blog and an idea of what happened.
    This feature is limited to a single WordPress blog for a single user.
  Archiving sections of large outlines
    If an outline is getting large, you may want to archive pieces of it.
    It works by converting a sub-outline into an include.
    #### An advanced feature
      This is an advanced feature and should only be used by people who understand includes, and have large outlines that are taking a long time to save. Most people don't need to archive sections of their outlines, at least not yet. :-)
    #### Archived material can't be edited
      Only archive sections that you don't need to edit, because you won't be able to edit them.
      For example, if you're keeping a blog in Fargo, you might want to archive July's posts at the beginning of August, only if you're sure you won't need to edit them.
    #### How to
      Put the cursor on the section of the outline you want to archive.
      Choose Archive outline from the File menu.
      Click OK to the confirmation prompt.
      Wait a few seconds.
      The bar cursor should change to an include node.
    #### Technical details
      The archives are stored in the archive sub-folder of your Fargo folder in Dropbox.
      They're stored in a calendar structure and given fairly cryptic names that are very unlikely to "collide" with each other.
  Using Fargo to upload images
    This feature allows you to set up a folder that we check periodically for new image files. If we find one, we upload it, and then open a dialog containing the URL of the image file, ready for you to insert into a blog post or other web-based document.
    #### How to...
      Choose the Settings command in the System menu at the right end of the menu bar.
      Click on the CMS tab. There's a new checkbox that allows you to enable the "watched" folder. Screen shot.
      In a few seconds a new folder is automatically created in your Small Picture folder called watched.
      Copy an image into the folder. Wait a few seconds (as many as 11 or 12).
      A dialog should appear with the URL of the image.
      You can use it anywhere you would use the URL of an image. It doesn't even have to be in Fargo.
      They don't have to be images. They could be MP3s, PDFs, whatever.
    #### Where do we store the images?
      In your Dropbox of course. ;-)
      Look in the new media sub-folder of the Small Picture folder.
Blogging with Fargo
  Your first post
    #### Video
      A video demo that shows how to write a blog post.
      The steps in the demo are summarized in the following sections.
      The video has saved some people quite a bit of time. ;-)
    #### Create a named outline
      To create a blog post so others can view it, you must have a public place to put it. In Fargo, these public places are called named outlines.
      Choose the New command from the File menu.
      Enter a title, something like My Public Outline. Click OK.
      Enter a little bit of text in the first headline, and click the Save button in the right margin if you don't have autosave turned on.
      Choose Name Outline from the File menu. Your name must be at least 4 characters long, and be unique. You'll get feedback from Fargo as you enter the name. Click OK when you're ready. A dialog will appear to confirm that the name has been assigned to your outline.
      The name that's assigned will be on smallpict.com, something like moose.smallpict.com. That domain will redirect to another location where your blog is stored.
      There's a full explanation of named outlines in the Fargo section of the docs site.
    #### Write a blog post
      Click on the big plus sign at the top of the left margin. Enter the title of your post, something like Welcome to my blog!
      Indent by pressing the tab key, and enter the body text of your post.
      Put the cursor on the top headline, click the Eye icon in the left margin.
      Here's a screen shot that illustrates. The red arrows point to the + icon and the Eye icon.
      When you click the Eye, a new tab should open in your browser, and with any luck you'll see your post.
      Copy the URL from the title bar of the browser and send it to your friends.
      When you make changes to the post they are automatically saved and stored on the server.
      Write more posts in exactly this way. ;-)
      That's all there is!
    #### The html folder
      After Fargo builds each page, it stores a copy of the HTML text in a sub-folder of the html folder in your Small Picture app folder in Dropbox.
      Here's a screen shot of the folder after writing the first post in the example above.
  Feeds in Fargo
    Every website managed by Fargo has an RSS feed.
    If the URL of your website is http://mysite.com/, the feed is at http://mysite.com/rss.xml.
    All items that are added via the + icon are automatically in the feed.
    If you want another item to be in the feed, add an isFeedItem attribute with the value true.
    Fargo also supports podcasts. If you have the URL to an MP3 (or any other type) create an enclosure attribute on the main headline of the post. Fargo will fill in the enclosureLength and enclosureType attributes automatically.
    Here's a screen shot of the attributes on my test podcast post.
  Using Markdown in Fargo
    The body of your blog post is passed through a Markdown processor as it's turned into a web page.
    You can use all the features of Markdown in Fargo.
    #### Outline structure and Markdown
    Fargo indents text according to outline structure as it's generating Markdown text.
    For each line we add a carriage return and linefeed character.
    A special case -- a line that begins with a # that is not a #directive. For those it adds two line endings.
    For each level we add a space at the beginning. If the level is greater than zero, we add a hyphen followed by a space.
  Categorizing feed items
    If an item that ends up in a feed has a category attribute, each comma-separated category is added to the feed.
    For example, if an item has a category attribute with the value: baseball, NYC, mets -- there would be three category elements on the feed item.
      <category>baseball</category>
      <category>NYC</category>
      <category>mets</category>
    Blanks are removed before and after the category names.
    New in Fargo 1.11.
  Setting up a Fargo noteblog
    Here's a set of step-by-step instructions for setting up a Fargo noteblog.
    1. Create a new file, say My Noteblog.
    2. The filename for the outline will be myNoteblog.opml. You might want to verify this in Dropbox. You'll need the name of the file in the next step.
    3. In the System menu (at the right end of the menubar in Fargo) choose Settings. Click on the Links tab. Enter the name of the file from step 2. Screen shot.
    4. Install the bookmarklet, per the instructions on this page.
    5. Test it by adding a link to the instructions page using the bookmarklet. (Or any other page you want.).
    6. If it worked, you'll see something like this. The date will be different of course.
    7. If you don't want to publish the outline, if the links are just for you, you're done. If you want to publish it, follow the instructions in the next section.
    #### Publishing the linkblog
    1. Give the outline a name. Choose Name outline in the File menu.
    2. Add a #type directive at the top level of the outline, with the value "stream". Screen shot.
    3. Choose Render All Pages in the File menu. This will cause the site to be built as a noteblog site.
    4. Click the Home icon in the left margin to view the home page of your linkblog site.
    #### Adding items without the bookmarklet
    You can add new items without using the bookmarklet.
    1. Click on the tab containing your linkblog outline.
    2. Choose Outline Settings in the File menu.
    3. Click on the Overrides panel.
    4. Enter idea in the text entry box and click OK. Screen shot.
    To enter a new idea into your noteblog, click the + icon in the left margin, exactly as you would to create a new blog post. Your item will have a light bulb as its icon. Enter your idea. You can add a whole outline structure beneath it and Fargo will automatically generate that structure in your noteblog.
    #### Examples
    My weblog "Scripting News" is a noteblog site.
    The OPML file is here.
    Have a look at the note page for March 15. It's got all the basic elements.
    #### Tips
    1. By default, Fargo will link up the whole text of the headline when rendering a linkblog item. You can override this by including text inside [square brackets]. If you use them, only that text will be linked. Here's a screen shot that shows what that looks like in practice.
    2. It's better not to put links in headlines with subs. It makes clicking on the headline have two meanings, and this can be confusing. If I find I want to add notes under something that's already linked, I add a new headline, and moved headline with the link under it.
    3. If you want something to be in the feed, you have to use the + icon to create it. Some people are apparently creating new items by pressing Return. I do it myself, without thinking. Those items will not be in the feed.
    4. We use the terms linkblog and noteblog almost interchangeably, but they are different ideas. You can use this style of blog for notetaking, to narrate your work for others to see. In that case it's not about linking. A linkblog entry is something you want to remember or share with users. Typically we use a bookmarklet to post items to a linkblog, but not with a noteblog. Sorry for the confusion, but they are two similar but different applications that are totally compatible (meaning one site can be both a linkblog and a noteblog).
  Linkblogging & the Bookmarklet
    You can run a linkblog in Fargo with a little configuration, using a bookmarklet, which we supply below. Here's how to get started.
    #### Set up
    1. You must designate an outline as the one to receive your links, and the outline must be open.
    2. In the System menu (in the right corner of the Fargo menubar) choose the Settings command.
    3. Click on the Links panel.
    4. Enter the name of the outline file you want to use. Screen shot.
    5. Install the bookmarklet by dragging the word Bookmarklet below into the chrome of your browser.
    Bookmarklet
    #### You can change the title
    You may want to change the title of the bookmarklet. In most browsers you do that by right-clicking on its name in the chrome of the browser.
    Here's what the menu looks like in Apple's Safari browser.
    #### Adding a link
    1. Be sure Fargo is open and the outline you've designated to receive links is open.
    2. Visit a page you want to add to your linkblog. Click the bookmarklet you installed above.
    3. Click on the Fargo tab. You should see the title of the page in the calendar structure in the designated outline. It will be of type idea, that's compatible with the new stream template.
    #### More info
    See the previous section about setting up a Fargo noteblog.
  Adding a custom menu to a Fargo blog
    Every new Fargo blog has a default menu at the top of each page.
    This menu may be all you ever need, but if you want to create your own menu, this document shows you how to do that.
    #### Grab a starter menu
      Instead of starting from scratch, I recommend grabbing the menu from the Kim Parker demo site and modify it for your purposes. It'll make it easier to guide you through the process in an error-free way.
      In Fargo choose Open by name in the File menu.
      Enter kim, and click OK.
      The outline should open in a new tab.
      Put the cursor on the #menus line and press Cmd-C to Copy (or Control-C on Windows or Unix).
      Click on the tab for your outline, and paste this sub-outline at the top level of your file.
      Now if you view your site you should see Kim's menu on your site.
      The next section shows you how to customize it.
    #### Tour of Kim's menu
      The top level item in Kim's #menus outline is called default. You can have more than one set of menus in a website, and you can say which menu you want with the #menuName directive, but if you just want one menu, name it default and keep it simple, as Kim does.
      Under the name of the menu is its title. Kim wants Fargo to figure it out for her, so the title is <%menutitle%>. The title of the menu will come from the title of the outline as set in the Set Titles dialog in the File menu in Fargo.
      Under the title are a series of items, some are links, and others are menus. To create a link, click on the link icon in the left margin in Fargo and enter a URL. You can read about that in the Fargo docs. If you want it to be a menu, add headlines under the heading. Each of these will be a menu item.
      The menu items can be links or there can be items under them as illustrated in the About Me! section of Kim's Personal menu. She included the text of her About page in the menu itself. Fargo figures this out, and automatically links to the page from the menu. It's incredibly easy to create these page in Fargo, which in other blogging systems require a number of steps. In Fargo just indent and start typing. The only thing you have to do to signal that the text is to be on its own page is to set its type attribute to outline.
      If you look under the About Me! headline, the first line is #text "All About Kim". That's a way of making the title on the blog page different from the text in the menu item. Kim wanted the title to be a little longer on the page because there's more room for a title there than there is in the menu item.
      Sometimes you want to group the menu items. The conventional way to do this in menus is with a thin gray line. You tell Fargo that you want a separator with a single hyphen on a line.
      If you look at the Archive item, you'll notice that there are no items under it in the editor, but in the actual menu there are items for each of the months that have blog posts. That's because this menu is generated automatically. To see how it works, put the cursor on the headline and click the suitcase icon in the left margin. You'll see that there's a type attribute with the value archive. This tells Fargo to generate the menu items automatically.
      The last few items are icons chosen from the "Font Awesome" collection which is baked into Fargo. They link to her Twitter and Facebook accounts and to the RSS feed that's automatically maintained by Fargo.
  Where to go for more
    All the blogging features of Fargo are made possible by a powerful "content management" system built into the Fargo app running on your computer. You can design templates, use a glossary to define macros, and much more.
Presentations in Fargo
  One of the many new things you can do with "Fargo" is create and view presentations in outlines.
  #### Example
    Here's an example of a presentation I created.
  #### Open a named outline
    To publish a presentation so others can view it you must have a public place to put it. In Fargo, those are called named outlines.
    If you have a named outline, please open it now. If not, here's how you can create one.
      Choose the New command from the File menu.
      Enter a title, something like My Public Outline. Click OK.
      Enter a little bit of text in the first headline, and click the Save button in the right margin if you don't have autosave turned on.
      Choose Name Outline from the File menu. Your name must be at least 4 characters long, and be unique. You'll get feedback from Fargo as you enter the name.
    With your named outline open, you're now ready to create a presentation!
  #### Entering your presentation
    Create a new headline by clicking on the big plus icon in the left margin. Enter the title of your presentation, something like My First Presentation.
    Under that headline, enter the titles of your slides. For your first experiment make it something easy like Slide 1, Slide 2, Slide 3.
    Under each slide, enter some text. This is what will appear on each slide.
    Now, put the cursor on the headline created in the first step. Click on the suitcase icon in the left margin. These are the attributes that are attached to the headline. You can edit them. There should be an item called type. Change its value to presentation and click OK. Screen shot.
    Again, with the cursor on the same headline, click the Eye icon in the left margin. A new tab should open in your browser, and with any luck you'll see your presentation.
    Click the left and right arrow keys to move through the presentation.
  #### That's it!
    You can make changes, and they will be immediately reflected in the public presentation. You can make as many as you like and share them with your colleagues.
Content management
  Introduction
    #### History
      As you may know, shortly after we released Fargo, we introduced a server-based CMS called Trex. A small community developed, we were off to a good start, then due to a programmer quitting, we lost the ability to scale the server.
      In September, the server finally couldn't handle the load, and we had to turn it off. Fargo went back to being an outliner, with a number of vestigial features that didn't work because its back-end was kaput.
      I had to quickly cobble together a Frontier-based solution so Scripting News could stay on the air, if I wanted to continue using Fargo, and I most certainly did. Then after a couple of weeks of using that system, it occurred to me that I could port this new code to JavaScript, and merge it with Fargo. This was a really exciting idea, and I couldn't see anything that stood in the way of it working. If you saw me in this period you could tell I had discovered something, I was pretty excited.
      As it turns out, for good cause -- there were no obstacles in the way. The software is ported. I'm using it to render this blog post, as I write it, in the background. All the software is running on my machine. There is no server.
      Yet there's a really powerful content management system that's rendering this content. I know about this stuff, I've been writing CMS's since 1994 when I first started working on the web. There's been a long sequence of them: AutoWeb, Clay Basket, Frontier's website framework, Manila, Radio UserLand. And not counting all the one-off blogging tools I've made for myself that ran Scripting News. Of all those, this is the only one I want to use. Because it's all in the outliner. I have the ability to control what I need to control, and when I'm writing, it all stays neatly out of the way.
      Now I want to walk you through the features of this new CMS, which is just called Fargo, it's just a feature of the outliner.
    #### How it works
      I'm editing this in my outline.
      To get it to render, I chose Outline Settings in the File menu in Fargo.
      I clicked on the CMS tab, and then turned on rendering, and background rendering for this outline.
      Then I started editing. The first time Fargo saved the outline, the Eye icon in the left margin appeared. When I click on the icon, it opens a new tab with the rendered view of the content.
      I can edit, review, edit, iterating over my writing until it's ready to present to the public.
      The rendered content appears in the html sub-folder of the Fargo app folder in Dropbox. Here's a screen shot of what my folder looks like.
      There's a sub-folder for each file that you've chosen to have rendered. Inside that folder there are pages with stories on them, and pages for each month and day. There's a sub-folder for the year, then one for each month, and one for each day, and finally a file with the rendered version of the post. It also automatically generates an index file for each level.
      The contents of each page can include Markdown features. You can use the outline structure to add structure to the rendered page. We generate a Markdown list for every level of indentation. It's pretty nice.
    #### Powerfully configurable
      Templates, the glossary, menus and # directives work exactly as they did in Trex with a few enhancements.
      You can have a #prefs outline anywhere that includes other directives.
      If there's a file called cmsPrefs.opml in your Fargo folder the templates, glossary items, macros in that file will be included in every rendering on your system. That means you can establish global defaults that apply to every outline.
      We also support includes in a lot more places than Trex did. We will support them everywhere practical. They're very very useful, and we missed this ability in Trex.
    #### What's not here
      There's only one major feature in Trex that is not present in the new CMS: rules-based outline rendering.
      Markdown is what the rest of the world is using. If we can make it work in the Fargo outliner, our work will be immediately relevant to a lot more people.
      We're going to study Markdown and make it work with outlines.
  Who are these docs for?
    These docs are for people who want to fully master the CMS in Fargo at a technical level. It will be possible to use content management without understanding most of what's here. But if you want to create templates or complex websites, this is for you
    Like most technical docs, you may have to read it two or three times before fully understanding it. However we try to include examples that cut through the difficult stuff, and show you the results before you have to master the theory.
    The first few sections are designed to be read in-order, and also serve as a technical reference.
  The "view source" of Fargo
    If you want to see how someone did something in their Fargo website, ask the person whose outline it is to do this:
      Open the outline in a tab in Fargo.
      Choose Get Public Link in the File menu.
      Copy the URL.
      Send it to you.
    To open the outline..
      Choose Open By URL in the File menu and paste the URL your friend sent you.
  Where to find examples/docs
    The global preferences are in this outline, which you can open in Fargo using the Open by URL command in the File menu. You can't edit it, but you can override any of the settings in this file in your cmsPrefs.opml file. Just copy and paste the bits you want to change from the global file into your cmsPrefs file, and edit.
    Here's the OPML source for the Fargo Docs website (the site you're reading now).
    I edit "Scripting News" in Fargo. Here's the OPML file.
    And the OPML file for the home page, or noteblog of Scripting News.
    Here's the OPML source of the Fargo blog.
    #### Kim Parker's website
    Finally, the Kim Parker website is, by design, a great starter site to be looking at for examples of how to do the basics. Here's the OPML source for the site. And below is the outline, viewable in an in-browser outline.
    <%reader ("https://dl.dropbox.com/s/ge8ql807di0rzkt/kimParker.opml")%>
  Content management user interface
    The user interface of the Content Management system isn't all in a single place.
    There are two commands in the File menu, Render Page and Render All Pages.
    The Eye icon and Home icon in the left margin take you to the cursor page and the home page of the site you're editing.
    Most of the prefs in the Outline Settings dialog in the File menu are used to configure the CMS.
    These panels in the Settings dialog in the System menu configure the CMS: You, Insert, CMS.
    There's a new readout in the right margin that shows how long the last rendering operation took, in seconds.
    And sometimes when debugging a process, it helps to go into Console in the browser's debugger, if you know how to get there. The CMS code in Fargo narrates the content building process in this hidden part of the user interface.
  A hello world page
    I always like to provide a Hello World example as soon as possible to help give you something to think about while reading the docs.
    So here's a very simple web page.
    Here's a screen shot of the HTML source for that page.
    All the examples are available, in OPML, in this file.
  Nodetypes
    The type attribute of a headline determines how it is rendered by the content management system. There's a template for each of the built-in types, but the type system is totally extensible. You can create your own templates, and thereby create your own types.
    There are five nodetypes implemented for content management: html, outline, blogHome, presentation and markdown.
    Use the Edit Attributes dialog to set the type of a headline. Click the + button to create a new attribute. Here's a screen shot that illustrates.
    When Fargo renders a page, it's because it has one of these types, or it's the parent of one of these pages. Those pages don't need to have a type. If they don't it's rendered as an index page, using the outline template, and it contains an indented list of pages that are underneath it.
    The outline and markdown types pass through the markdown processor. Custom types also flow through the markdown processor.
    Use the markdown type when the contents of the sub-outline is pure markdown. If it's a structured outline, and you want indentation to work properly, use outline type.
    Here are examples of the five nodetypes: html, outline, presentation, markdown, blogHome, index.
  The html nodetype
    The text underneath a node of type html is sent back as-is, with the following exceptions: macros and glossary refs are evaluated first.
  Macros
    Macros are delimited with percent signs inside angle brackets.
    Example: <%somevalue%>.
    Macros can have parameters, or just be JavaScript expressions.
    You can define your own macros.
    Example: <%includeHTTP ("http://abc.com/")%>.
    Here's an example page that uses several macros.
      <%slogan%> -- returns one of 15 slogans.
      <%now%> -- to say what time it is on the server.
      <%text%> -- uses the text of the parent node to give the page a title.
      <%pickleFlavor%> -- a custom attribute from the parent node.
    A blog post with some more examples of macros.
    You can also define your own macros.
  Built-in macros
    <%icon (name)%> -- name is the Font-Awesome name for the icon.
    <%includeHTTP (url)%> -- includes the contents of an HTTP request in the page.
    <%prevNextLinks ()%> -- generates links to the previous and next page.
    <%reader (opmlUrl, font, fontSize, lineHeight)%> -- embeds the outline in the page.
    <%useMenu (name)%> -- generates a Bootstrap navbar with the named menu.
    <%menu ()%> -- generates a Bootstrap navbar with the menu named by the menuname attribute.
    <%breadcrumbs ()%> -- generates a Bootstrap breadcrumb trail for the current page.
    <%byline ()%> -- generates a byline for the page.
    <%disqusComments ()%> -- generates the code for a Disqus comment section.
    <%rssLink ()%> -- generates an HTML <link> element to the site's RSS 2.0 feed.
    <%slogan ()%> -- generates a random sometimes-snarky slogan.
    <%googleAnalytics (account, domain)%> -- generates a Google Analyticis script, with the indicated account and domain.
    <%formatDate (d, dateformat, timezone)%> -- formats a JavaScript date value using the strftime convention. The timezone is an offset of GMT.
    <%socialMediaLinks ()%> -- generates a colorful standard set of icons for linking to the author's Twitter and Facebook accounts and the site's RSS feed.
    <%userStyles ()%> -- returns an HTML <style> element with the user's #style prefs.
    <%pagetableInJSON ()%> -- returns a JSON string with the scalar objects in the pagetable.
    <%now%> -- the time/date when the page was built.
    <%path%> -- the relative path to the page.
    <%opmlDateCreated%> -- the creation date of the OPML file.
    <%opmlDateModified%> -- the mod date of the OPML file.
    <%opmlDescription%> -- the desciption head element from the OPML file.
    <%opmlLink%> -- the link head element from the OPML file.
    <%opmlLongTitle%> -- the title head element from the OPML file.
    <%opmlOwnerEmail%> -- the ownerEmail head element from the OPML file.
    <%opmlOwnerId%> -- the opmlOwnerId head element from the OPML file.
    <%opmlOwnerName%> -- the opmlName head element from the OPML file.
    <%opmlTitle%> -- the title head element from the OPML file.
    <%opmlUrl%> -- the address of the OPML file.
    <%text%> -- the text of the headine for this page, usually used as the page's title.
    <%useBootstrap%> -- include the files necessary to use the Bootstrap Toolkit.
    <%useFontAwesome%> -- include the files necessary to use Font Awesome.
    <%useJQuery%> -- include the files necessary to use jQuery.
  The pagetable
    The pagetable is a central concept in Fargo content management. It's a JavaScript object that accumulates data about the page through the various steps of the rendering process.
    Here's a list of all the things that go into the pagetable.
      Default values put there by the CMS code at the beginning of the rendering process.
      All the # directives in a super-global object that I created (this is where the built-in templates come from).
      All the # directives in your global preference outline called cmsPrefs.opml.
      All the attributes from all the headlines on the path to the headline being rendered.
      All the # directives on the path to the headline being rendered.
    The order above is important because values in the pagetable can be overridden. So if you want to change a default that's the global object, just put a different value for it in your cmsPrefs.opml file.
    The pagetable is included in the rendered page in the default templates so it is available to JavaScript code running in the page.
  How Fargo builds a site
    With Fargo you're not just editing individual web pages, you're editing an entire website in a single outline file.
    Each headline with subs corresponds to a folder in the web hierarchy.
    The attributes are inherited in an object-oriented way. The attributes of a headline are accessible to all the pages it contains. But any one can override its parent's attributes by specifying different values.
    In other words, at each step of the site-building process, we add all the atts from the node to the pagetable. If we encounter two nodes with the same attribute, the inner one wins. You can refer to any of the atts in the page as a macro.
    The path is generated by taking the text of the headline and "normalizing" it, by removing spaces and innerCasing. So "Technical docs" becomes technicalDocs.
    We also look for a name attribute. You can use this feature to give a node a fixed name, allowing the text of the headline to change, without breaking URLs. So if you prefer "docs" to "technicalDocs" just set the name attribute of the node to "docs."
    The site-building process goes through include nodes transparently.
    The HTML text resulting from the rendering is stored in a sub-folder of the html folder in your Small Picture folder. There's one sub-folder for each outline.
  The site-building process and Fargo's eye
    When you're editing an outline in Fargo, the Eye icon may be available in the left margin. If it's a named outline, the Eye points into the named site. The eye knows how the site-building process works. If it's not a named outline, and you're syncing through the html folder for the outline, you can enter the URL of the home page in the CMS panel of the Outline Settings dialog.
    Fargo automatically generates a name attribute for every headline with a type. This allows you to change the text in the headline without breaking links. You can edit the name attribute manually using the Edit Attributes dialog.
  # directives
    Any line in an outline that begins with a # does not flow through to the page.
    \#hairColor "brown"
    Then the name becomes an attribute and can be referenced as a <%hairColor%>.
    Example 14 illustrates the use of a directive to change the title of the story, using:
    \#text "A question maybe no one has ever asked you"
    Without that directive, the title on the page would be Example 14.
    This feature is especially useful at the top level of an outline file to control the appearance of the home page of the site, because there's no containing headline to attach attributes to.
    It also makes it easy to group all your global values in one place, easily edited by the outliner,
  #prefs
    You can bundle a set of directives under a single #prefs, to keep the appearance of your outline neat.
    This screen shot illustrates.
  cmsPrefs.opml
    If there's a file named cmsPrefs.opml in the Fargo app folder it's loaded when Fargo starts.
    It can contain globals that are available to every website rendered by your copy of Fargo.
    It can contain #menus, #glossary, #templates, basically anything that could appear in any website outline.
    If you make a change to the file, it's automatically reloaded, so your changes are reflected immediately.
    Here's what's in my cmsPrefs.opml file:
    <%reader ("https://dl.dropbox.com/s/s880hyhlo5f9zf1/cmsprefs.opml")%>
    #flPgfPermaLinks "false"
  globalPrefs.opml
    Here's the contents of the global prefs outline. <%reader ("http://fargo.io/cms/globalPrefs.opml")%>
  The #glossary is for re-usable bits of text
    When you're working on websites, you find there are bits of text that appear all over the place. Rather than having to type them every time, we have a structure called the glossary, that allows you to define them once and use them in many places. And if you need to change something, you can change it where it's defined and it automatically changes in all the places its referenced.
    Let's say you want to define a re-usable bit that contains a link to your home page.
      Create a headline at the top level of your outline called #glossary.
      Indented under it enter a line that says "myhome" (include the quotes).
      Indented under that, enter a line containing the link. Example:
        <a href="http://scripting.com/">Home</a>
      Here's a screen shot to make it clear.
    There's a #glossary in the example file.
    Now to use it, enter the text into one of your pages: "myhome" (again include the quotes). I've done that in Example 6.
    Here are some facts about glossary entries:
      They can include macros.
      You can use them in markdown pages and html pages.
      They can contain Markdown text and it will be processed in Markdown pages.
      You don't have to use double quotes to delimit them. It's a straight string substitution. However it's probably a good idea to use some kind of delimiter so you don't get substitutions in random and unexpected places.
      They are case-insensitive, so "MyHome" is the same as "myhome".
  Put menus in #menus
    A lot of websites have menus at the top of the page with links to other pages and other sites. Fargo makes it easy to create and update menus, and share them among different pages.
    To use the feature create a #menus headline at the top level of your outline.
    One level under that enter the name of a menu. One level under that, provide the text you want to appear in the sitename section of the menu, and beneath that a series of link nodes. These are the items that will appear in your menu.
    Here's a screen shot of the menus table in the example.
    When you want to associate a menu with a page or a group of pages, set the menuName attribute to the name of the menu you want to use.
    There must be a <%menu%> macro in the template that the page is rendered with.
    An example is here.
    The menus we generate are compatible with the Bootstrap Toolkit navbar structure.
  Other compound # directives
    There are two kinds of # directives -- those that have subs and those that don't.
    glossary and menus are compound types. There are others #templates, #macros and #style.
    Each item under #templates is a type, and the text under the type is what's used to render a page of that type. Of course a template can contain macros and glossary items, as well as linking to menus through macros.
    Under each item in a #macros item are names of macros, and under each macro is the JavaScript code that's executed when the macro is invoked. Your macros can override the built-in macros.
    Under each item in a #style section are names, and under the names are CSS styles. The names are ignored, they can be used as comments so you can keep track of what they do. However a name can't be blank. The styles are cumulative, so that styles defined in sections of a website can override those defined in outer sections. CSS can contain macros, so you get the functionality of a lightweight LESS-like pre-processor.
  Templates
    A template is an outline that contains an HTML wrapper.
    The name of the template maps to a node type. So if you have a headline with type greenroom, Fargo will look for a template with that name. If it finds it, it replaces the contents of the special <%bodytext%> macro with the text below the headline.
    Your templates are in a top-level outline called #templates. Its sub-heads are names of templates, and underneath each name is the template definition, which is an HTML wrapper.
    Fargo has built-in templates for the following types: outline, markdown, presentation, html. You can override any built-in template by providing your own.
    Here's a screen shot of the default templates.
    Templates can contain macros, and can reference glossary elements.
  Template example
    The Fargo Docs outline has a #templates section at the top level. It contains a template called greenroom.
    This example uses that template. It has a type attribute of markdown, so the text passes through the markdown processor before being passed through the template.
  The #style directive
    Suppose you like the built-in outline template, but you don't like the font we've chosen for paragraphs in Markdown text. Rather than force you to copy the whole template to change one style feature, you can use CSS to override them.
    Create a directive called #style and underneath, put a headline with a name. It doesn't matter what you call it. Think of the title as a comment to yourself.
    Under the title, include CSS styles as you would in the <style> section of an HTML page.
    This style says make the Markdown text generated by Fargo a little larger and make it 1.5 spaced.
    You can override styles locally if there's an individual page or group of pages that you want to have larger or smaller type. In other words, #style directives "cascade" just like CSS, only within the hierarchy of your website.
    You can include macros in your styles.
    Styles are included in templates with the userStyles () macro.
    We add these styles to the page last, so they get to override all the defaults, as well as styles set by a <%customStylesScripts%> glossary entry.
  Includes
    All content comes from outlines, represented in OPML. Outlines do not have to be edited in Fargo because you can use the include nodetype to bring in content from anywhere on the web.
    In fact I am using the OPML Editor to manage the complex sections of the docs because it's easier to write about a product from outside the product, I've discovered. ;-)
  The markdown nodetype
    How to create a Markdown page in Fargo.
    1. Create a new headline and set its type attribute to markdown.
    2. Enter some Markdown text under the headline.
      Maybe *this is italic* or **this is bold**.
    3. Click the eye icon to view the rendered version of the page.
    If all went as planned, you should see the Markdown rendering of the text.
    Here's an example page with a standard Markdown demo document.
    We are using the Pagedown library.
  #finalFilter scripts
    If you want to fix something up at the end of the rendering process, it can be handy to have a script run that can access the rendered text, make changes, and put them back.
    The #finalFilter directive works much like #glossary. The names of the scripts are not important. But every script that's in scope when a page is rendered is run just before the text is saved into the html folder.
    Here's a screen shot of the #finalFilter sub-outline for my River Lab outline.
    The first script replaces a url in the rendered page. The second script echoes the rendered text to the console.
    You can access all the rendering parameters through pagetable. The text of the fully rendered page is in pagetable.htmltext.
    The name finalFilter comes from the Frontier website framework, which also had firstFilter and pageFilter scripts. We may at some point have those in this framework as well.
  Disqus comments
    We expect Fargo to be used to create blogging systems. Comments are an important part of blogging, so we've built a special connection through macros to the Disqus commenting system.
    You can include a comments section in a template through the <%comments%> macro.
    By default it uses our Disqus group, smallpict, but you can override that with the disqusGroupName attribute.
    \#disqusGroupName "yourgroupname"
    You can also call the disqusComments macro to generate a comments section.
    If you don't want comments to appear, you can use the #flDisqusComments directive, like this:
    #flDisqusComments "false"
  Google Analytics
    We like to use Google Analytics to track the usage of our sites, so we made it easy for you to do so as well.
    You must define two attributes in order for it to work, googleAnalyticsID and domain.
    \#googleAnalyticsID "UA-55555555-5"
    \#domain "bullmancuso.com"
    Then, put the &lt%googleAnalytics%> macro where you want the analytics code to appear, usually in the <head> section of your template. We included it in the default templates.
    The domain attribute is the domain where the content will be hosted, where people reading it will access it.
  Presentation nodetype
    To create a presentation, set the type attribute of the main headline to presentation.
    Each of the sub-heads contains the title of one of the slides. The second-level heads form the content of each slide.
    You can also change the theme and transition values for the presentation by adding attributes to the main headline. The possible values for theme are sky, beige, simple and default. And for transition: cube, page, concave, linear, default.
    Example 10 illustrates.
  Creating a custom index page
    You can create custom index pages that override the automatically generated ones.
    Here's how. Create a page at the same level as the index page, and give it a name attribute whose value is index. Put whatever you like in the page body. Fargo will notice that it's there before creating an automatic index page and will skip it.
    This site, the Fargo Docs site, uses a custom index page at the top level. You can find a link to the OPML source for this site on this page.
  Including a menu in an html page
    If you want to include a menu in a page whose type is html, you have to use the <%useMenu ()%> macro instead of <%menu%>. Otherwise any macros in the menu text will not be evaluated.
    There's a technical reason for this. Any macros in a template will be evaluated as the template is included. Since the menu inclusion is coming from the text of the page, any macros it contains will not be evaluated. That's what useMenu does for you.
  Defining your own macros
    You can define your own macros, with or without parameters.
    Create a #macros section, it can be in your cmsPrefs.opml file, at the top level of an outline, or anywhere within an outline. Under #macros put the name of the macro and under that, put the macro definition.
    Here's a screen shot of the macros section of the outline for the docs website.
    Because there's a hello macro defined there, I can call it this way <%hello ()%> and it will render as the string <%hello ()%>.
    There's also a macro defined called sumArgs, which returns the sum of its arguments. I can call it this way <%sumArgs (1, 2, 3)%> which renders as <%sumArgs (1, 2, 3)%>.
  "reader" macro for sharing code
    A macro lets you display the contents of an outline exactly as it would be displayed in Fargo.
    <%reader (opmlUrl, font, fontSize, lineHeight)%>
    Here's an example of the macro being used to display the source code of a Find command I've been working on for the menubar, one that finds the next occurrence of a string in the active outline. You can copy the text from the outline below straight into menubar.opml.
    <%reader ("https://dl.dropboxusercontent.com/u/36518280/misc/codeExample.opml")%>
    #### How to set it up
      Copy the outline text you want to share to the clipboard.
      Create a new outline, choosing New from the File menu.
      Paste the text into the outline. If there's an extra line, delete it.
      Chose Get Public Link from the File menu.
      Copy the URL to the clipboard.
      Paste it into a call to reader in this post, as shown below.
    #### The exact code
      <%reader ("https://dl.dropboxusercontent.com/u/36518280/misc/codeExample.opml")%>
    #### Notes
      It remembers how you have the outline expanded, so you can set it up so that it leads the reader to the parts you think they'll find most useful or interesting.
      It's very useful for code, but probably could be used for other applications.
      The last three parameters are optional. If they aren't specified, the values we use are: Arial, 16 and 24.
    #### Styles
      You can override the style choices I made by including CSS in your <%customStylesScripts%> glossary entry. I separated out the styles from the code so that your styles take precedence.
  Using GitHub to host your site
    Carefully follow the instructions on this page.
    When you set up the folder for your repo, make it a direct sub-folder of the Fargo app folder in Dropbox. This is important. It must have the same name as your repo.
    There's a new directive, #siteFolder, that allows you to tell Fargo where to store your files. This is how I set it up for the Kim Parker site: #siteFolder "scripting.github.io/kimParker/"
    When you're ready to try it out with Fargo content, render the whole site with the Render All Pages command in the File menu.
    Verify that the pages were rendered into the sub-folder of your GitHub folder.
    In the GitHub client, click on Commit & Sync button. Screen shot.
    View the updates on your website.
  Using "SuperSync" to upload your site
    #### What it is
      SuperSync is an OPML Editor tool that runs on any computer that has access to your Dropbox folder.
      You can run it on your desktop computer (I do). It keeps folders in sync with locations on Amazon S3. You can have as many sharepoints as you want.
      You set it up by editing the config.root object database. It's useful with Fargo 2, which stores static HTML pages in sub-folders of the Dropbox folder.
      It's how I keep the Fargo Docs site in sync with its location on S3.
    #### How to install
      Choose Tool Catalog from the Misc menu in the OPML Editor.
      Click on the Install link next to SuperSync. Click on OK to all confirmation prompts.
    #### How to set up
      At this time you have to create new tables for sync points by hand in the object database.
      Jump to config.superSync, and create a new sub-table of the points table. Wait till the top of the minute, and a background script will initialize the table for you.
      Open the table and open its prefs sub-table, and fill in the three parts like this.
      When you're ready to start syncing change config.superSync.prefs.enabled to true.
      When syncing happens you should see an outline window open showing you the files it's uploaded.
    #### Maintenence
      You should update the tool from time to time.
      The log outlines are automatically cleared every night.
  Running your own server
    Fargo's CMS defines a very simple protocol to get the rendered content from your local machine to a place where it can be viewed on the web. We've developed software, in node.js, that implements the server. It's open source and you can run it yourself. It's fairly easy and inexpensive.
    #### Preamble
      This howto is very bare-bones. We don't know where the traps are. There may be steps omitted, or the instructions may be wrong. When you report problems on the Fargo2 list, be sure to provide screen shots and a good narrative of what you did, what you expected and what actually happened.
      Even worse -- after writing this howto, the Nodejitsu connection to GitHub went down. They're working to fix it. As of this writing, 1/29/14, the connection is still down.
    #### Requirements
      An Amazon S3 bucket.
      A CNAME for the bucket. (Your equiv of beta.fargo.io.)
      A GitHub account.
      A Nodejitsu account. (It's free for the first 30 days, $9 a month thereafter.)
      A domain for your user's accounts. (Your equiv of smallpict.com.)
    #### How to
      Set up a bucket on Amazon S3 where you will store the rendered content and the user data.
      Map the CNAME to the bucket.
      On GitHub, fork the fargoPublisher repository.
      Edit the package.json file, and change the subdomain value to something like bullpub3. This will determine the domain name that Nodejitsu gives to your app, something like bullpub3.jit.su.
      On GitHub, in Settings, click on Service Hooks, scroll down to Nodejitsu, and enter your username and password. Also check the Active box. This will cause changes from the GitHub project to be automatically posted to your Nodejitsu account.
      If all went well, when you go to Nodejitsu, you'll have an app called FargoPublisher. With any luck this link will take you to it. ;-)
    #### Setting up your server
      Nodejitsu will try to run your server, and will fail because the environment variables haven't been set.
      Here's how I have my environment variables set on the server I'm running.
      I've obscured the AWS account info (this is private), and I'm pretty sure you don't have to set the AWS region. (You should try it without setting it. Otherwise it's the region your bucket is stored in.)
      Refer to the ReadMe for fargoPublisher for an explanation of what the other environment variables mean.
    #### Set up DNS
      One final step before restarting the server and going online -- you need to map the domain for your user's accounts to the Nodejitsu server. They have a howto for this on the Nodejitsu site. I've done it with smallpict.com and it appears to work.
    #### Restart the server
      Once you have all the variables set, click the Restart button on the Nodejitsu app page. If all goes well you should see a message like this in the log:
        [out] Sat, 25 Jan 2014 16:13:06 GMT Fargo Publisher server v0.63
    #### Configure Fargo
      Now you have to tell Fargo to use your server instead of mine.
      Choose Settings in the System menu in the upper right corner of the Fargo screen, and click on the CMS tab. In place of my server, pub.fargo.io -- enter the name of yours -- in the example above, bullpub3.jit.su (obviously yours will be different).
      Try publishing something. If it worked, you should see a stream of messages fly by in the Logs section of your Nodejitsu app page. If you do, you're done -- it worked!
      Either way, tell us about it on the list.
    #### Remaining loose-ends
      The "domain for your user's accounts" is confusing because at this time (Jan 25) it is not fully implemented in fargoPublisher. I have it jury-rigged so it works for smallpict.com. I want to get this up and running on a couple of users' systems first, so I can get a feel for how that works, before deciding how to implement this.
  Differences from Trex
    The method attribute is not supported
      Almost all types pass through the Markdown processor now, and there is no rules-based rendering.
      The exceptions are presentation type and untyped pages. In both cases the CMS generates the structural HTML, and it's not really great to pass it through Markdown.
    The <%menu%> macro is now a script macro
      Use <%menu ()%> instead of <%menu%>.
    Macros are supported everywhere they can reasonably be supported
      I took a much closer look at the rendering process and tested carefully.
      Glossary elements can now contain macros. This will prove useful.
    Includes everywhere
      I think you can have an include everywhere in the CMS. Not sure they work everywhere though. There are so many places to test. ;-)
    There are no http macros, httpHost, httpPath, httpUserAgent.
      There is no server, so these values are not available.
      However, there is a <%path%> macro that gives you the path to the current page.
    The RSS file is no longer stored in the RSS folder
      It may seem counterintuitive, but the RSS file is now stored in the HTML folder for the outline, along with the other files that make up its website. It needs to be processed in the same way as the HTML files.
    The #bootstrapTheme attribute changed
      It can no longer be a full URL, it has to be one of the names of the themes.
      So this no longer works:
        #bootstrapTheme "http://bootswatch.com/readable/bootstrap.min.css"
      Use this instead:
        #bootstrapTheme "readable"
      If you want to replace bootstrap.min.css with your own file, set the cssUrl attribute to point to it.
    The archive type in menus is not implemented
      However there is a new stories type that will give you a menu with the most recent stories in it, in reverse-chronological order. You can set the #maxStoryList attribute to determine the number of stories.
    Menu items that contain pages are not implemented
      In Trex you could put a type attribute on a menu item, and the text under it would be displayed as a page on the site. This is not implemented in the new CMS.
    cmsPrefs.opml lets you set global attributes
      So if you want to define glossary items, for example, that can be accessed in any of your websites, add them to this outline. Explained here.
Little Outliner
  What is Little Outliner?
    #### Overview
      Little Outliner is an easy to learn, entry-level outliner that runs in a web browser.
      It's written in JavaScript and runs in HTML 5.
      You do not have to register or create an account. Just visit the site, and start typing.
      It stores text in local storage on your own computer.
      The user's outline is not transmitted to our servers.
      There is no charge to use Little Outliner. Use it to become familiar with outliners. For some people the features of Little Outliner will be exactly what they need.
    #### Where can I try it?
      http://littleoutliner.com/
    #### What is an outliner?
      It's an editor that works with hierarchic structures.
      For a full explanation of how outliners work, check out our new Outliner Howto.
    #### What outliners are used for
      Notetaking.
      Organizing projects.
      Narrating your work.
      Presentations.
      Writing.
      Design.
      Programming.
      Specifications.
    #### How does Little Outliner compare to Fargo?
      It's built on the same outlining technology as "Fargo", but comes in a simpler-to-use package, with fewer features.
      There's a new version of Little Outliner that makes it even more compatible with Fargo.
    #### Screen shot and demo
      Screen shot.
      Video demo.
    #### HTML 5
      Because we depend on features that are only available in HTML 5, Little Outliner can only work with modern browsers. We've tested with the latest versions of Chrome, Safari, Firefox and Internet Explorer.
      We like this platform because it gets us to all the major operating systems, and because it runs in a communication-rich environment (the web) we can do new things with networking. To share an outline, something that was awkward in the past, you just have to exchange a URL. And networking inside outlines, including outlines within other outlines, has huge potential.
      Also, with the vendors of portable operating systems exerting more control over the kinds of apps they'll allow, we like the freedom this platform offers. Like writers and journalists, developers need freedom to be creative, without unnecessary interference from platform vendors.
    #### Limits
      It can edit a single outline.
      The outline is saved to local storage, an HTML 5 feature. You can refresh the page, and the outline is still there.
      The outline can only be accessed on the machine it was created on.
Fargo in a workgroup
  Fargo has powerful collaboration features which make it great for coordinating a workgroup. We use Fargo in exactly this way to manage the development of Fargo itself. This doc shows how you can do it for your group.
  #### Overview
    Every member of the team has their own outline, and their own Dropbox account since Fargo stores its outlines in Dropbox.
    As the day goes by they narrate their work, making notes in the outline.
    Every team member has all the others' outlines in their Bookmarks menu. The people they work most closely with are in their own tabs. When another team member updates, that's indicated by a lightning bolt icon appearing next to their name in their tab. Click on the tab to find out what's new.
    When you want to view the updates of another member, choose their name from the Bookmarks menu. Their outline opens in a new tab.
  #### Every team member has an outline
    Start at fargo.io, connect with Dropbox.
    Create a new outline with the New command in the File menu. The title should be your first name, something like Susan or Pablo. This is going to be the name that shows up in the tab when other workgroup members read the outline.
    When you want to explain something you're working on, click the + icon at the top of the left sidebar. Screen shot.
      It creates a new note, in a calendar structure.
      Enter the description of the event, using the tools of the outliner to expand and collapse and reorganize. See the Outliner Howto for basic instructions on using the outliner.
      Depending on your style, and the nature of the event, the note could be a single line like "Good morning, ready for a new day of work!" or could have a list of things you want to accomplish during the day. Or anything that's relevant to your work and the other people in your group.
      Tip: It's often a good idea to edit your note in a private outline, and copy/paste it into your status outline when it's ready, so there's a single update for each new note. Every group develops its own conventions over time.
    As the day goes on, as you accomplish things, or have questions for other team members, post them as notes in your outline, again using the big + icon.
  #### Preparing to share
    Before sharing your outline, you might want to give it a longer title and a description. Here's how to do that.
    Be sure the outline is open and in the active tab.
    Choose Set Titles from the File menu. Screen shot.
    Enter a long title and a description. You may want to edit the short title at this time.
    The long title will appear as a suggested name for the Bookmark in a later step when people follow your outline. The long title should at least contain your first name and last name, where the short title should probably only have your first name.
  #### Sharing your outline with team members
    Once you're rolling with your outline, you should share the outline with other members of your team.
    To do so, choose Get Public Link in the File menu. (If you have multiple outlines open be sure the tab of the outline you want to share is in the active tab.)
      The public link is only public if you share it publicly, so the title of this command, while consistent with Dropbox terminology, is actually a bit misleading.
    Confirm that you want to create a public link, then copy the URL that appears in the dialog.
    Send the URL to team members via email or chat.
  #### Watching a team member's outline
    In the previous section we explained how to get a sharable link to an outline. Now we show you how to follow one of those outlines.
    Copy the URL you received via email to the clipboard.
    In Fargo, choose Open By URL in the File menu.
    Paste the URL into the text area in the dialog, and click OK.
    The outline should open in a new tab.
    Choose Add Bookmark from the Bookmarks menu. You can edit the name of the bookmark with something more descriptive.
    When the team member's outline updates, the icon next to his or her name will change from a person to a lightning bolt. That's how you can tell they updated. Click on the tab to see what's new.
    If you want to close their tab, choose Close from the File menu. Any time you want to find out what's new, you can choose their entry in the Bookmarks menu.
  #### That's it!
    Setting up a workgroup is fairly easy, and so is outlining.
    However, communicating your work with others is an art. So, while you get benefits from organizing your work this way right from the start, it gets better as you go along, as you develop standard practices specific to your projects and team.
    If you have questions on how to use Fargo as a workgroup tool, please use the smallpicture-user mail list, or post a comment here.
    If you want to share what you've learned -- please do! This is a new art, and we can all benefit from each others' experience. Write blog posts, or give presentations at conferences. We're anxious to hear how you're using Fargo for workgroup collaboration.
Fargo scripting
  #### Why scripting in an outliner?
    Fargo is a rich product, but there are so many things people want to do with outlines, we can't possibly add commands for all of it. That's why we have created a simple scripting interface for the Fargo outliner. This document both explains how it works today, and gives an idea of how it will evolve.
  #### The language is JavaScript, of course
    We don't need to create a scripting language for Fargo, as we did for earlier outliners -- because it's already embedded in a powerful scripting environment -- JavaScript running in the browser. So all the scripts you write for Fargo will be in JavaScript.
    That's got its pluses and minuses. It's good because JavaScript is fast, and a lot of people know how to program in it. But JavaScript is more of a systems language than a scripting language. It can do a lot, but sometimes even simple things are a bit complicated.
  #### Verbs
    So JavaScript is the syntax of scripting in Fargo, what about the nouns and verbs -- the things it operates on and the things it can do.
    In Fargo, you're operating on the current outline, the one in the selected tab, and the item that the bar cursor points to. For example, a script can move the cursor relative to its current location, reorganize the outline, expand and collapse, get an OPML version of the outline.
    We also have hooks into the file system, which is of course Dropbox. You can write a file anywhere in the Fargo folder, and can get a public URL for that file.
    You can also call any built-in JavaScript function, but be careful, as explained in the next section.
  #### Is it a platform?
    Up till now we've said emphatically that Fargo is not a platform. This is because you could get in and script stuff in Fargo, if you're willing to do a lot of work. But we're not committing to the internal structure of the program. If you call code inside Fargo from your scripts, you should assume that your code will break in the next Fargo update.
    But now we're making an exception to the no-platform rule. We're going to slowly build a set of safe functions you can call, ones that should not change over time. Because we're making that commitment, evolution of this set of verbs will be done carefully and slowly with much consideration toward backward compatibility.
    A caveat: While no-breakage is an ideal, sometimes breakage happens anyway. These verbs are as safe as they can be. We've had good luck with this in the Frontier scripting platform. Scripts written in the early 90s in Frontier still run today. But you never know what can happen. So it's not a contractual no-breakage rule, rather it's a statement of principle.
    Today we have an initial set of verbs that you can try out the scripting interface with. We will take suggestions for new verbs, on the "smallpicture-script" mail list, preferably in the form of links to blog posts where the idea is explained, and discussion can take place.
  #### The verb list
    The safe verbs are in a file called fargoVerbs.js.
    When looking through that list, focus on the interfaces, not what's behind them.
    It's the interfaces that are safe.
    So if you want to make a beep sound on the speaker, call speaker.beep (), not the code inside it.
  #### Adding a menu with scripts
    Create a new file in your Fargo folder called menubar.opml.
    The top level headlines in this file are the names of the menus.
    The second level heads are the names of scripts.
    The text under the second level heads are the scripts themselves.
    When you make a change to the script, Fargo automatically rebuilds the menus.
  #### Video demo of Fargo scripting
  #### Samples
    Here's an OPML file that contains a few very simple example scripts.
    These are meant to get the ball rolling, more coming soon. ;-)
  #### Support
    It's important that discussion about scripting in Fargo be limited to the "smallpicture-script" mail list. You can talk about your work there, even point to software that people can download. Please do not discuss scripting on other smallpicture mail lists. Thanks.
Examples
  Example 1
        Hello World
        Hello World!
  Example 2
        <%text%>
          p {
            font-family: Georgia;
            font-size: 22px;
            line-height: 150%;
            }
          h1 {
            margin-bottom: 25px;
            }
          .divExample2Body {
            width: 700px;
            margin-top: 200px;
            margin-left: auto;
            margin-right: auto;
            }
          <%text%>
          Welcome to the wonderrrrrful world of Fargo web content.
          "<%slogan%>"
          The current date/time is <%now%>.
          Your pickle flavor is <%pickleFlavor%>.
  Example 3
        <%text%>
        <%useBootstrap%>
          p {
            font-family: Georgia;
            font-size: 22px;
            line-height: 180%;
            }
          h1 {
            margin-bottom: 30px;
            }
          .divExample3Body {
            margin-top: 100px;
            margin-bottom: 200px;
            }
                <%text%> <%icon ("smile")%>
                One of our fetishes at Small Picture is getting cool stuff working with no servers. For example -- Little Outliner. There's only one function it relies on a server for, the importing of OPML. And if you think about it, it's ridiculous that that function has to be done through a server. The code is running in a browser, which is perfectly suited to get a file over the Internet.
                Many of the limits of the 2013 web are accidents of history. Someone at some time thought an operation was too powerful, that it could be abused, so they made it illegal. But they didn't close off the ability to call a server to do it for us, so we effectively can do anything we need to do.
                A great example of that is the way Dropbox allows Fargo to save to the local file system. This is something we're not supposed to be able to do. But we're doing it anyway. And nothing is breaking as far as I can tell. We're inside a very simple easy to understand sandbox, a sub-folder of the Dropbox folder.
                And in addition to being able to write to the local file system, we get cross-device synchronization for free. That's a great deal.
                All this means things are shifting pretty radically. Who is the operating system vendor if my files are equally accessible on Windows, Mac, Android, Linux, IOS, etc? Dropbox is, that's who.
                Blogging tools like WordPress, or even Medium, could add a feature to their API that would allows apps to store a small XML file along with a blog post. Logically that would lead to the equivalent of Dropbox, along with content management. You'd be able to publish just by saving a file. You have to figure Dropbox sees this opportunity. And that they will, eventually, navigate to roughly where WordPress is. WordPress likely sees this too and will likely navigate to where Dropbox will be.
                The server is moving. A fair amount of what used to be "up there" is now in JavaScript, in the browser. The network services are doing what only they can do, provide global access to published information. And unfortunately due to history, they are also acting as pointless proxies for things a browser app should be able to do for itself.
  Example 4
        <%text%>
        <%useBootstrap%>
          p {
            font-family: Georgia;
            font-size: 22px;
            line-height: 180%;
            }
          h1 {
            margin-bottom: 30px;
            }
          li {
            line-height: 200%;
            }
          .spTrexSlogan {
            color: green;
            }
          .divDisqusComments {
            margin-top: 60px;
            margin-bottom: 60px;
            }
              Hello World
              Welcome to the wonderrrrrful world of Fargo web content.
              This is a slogan: "<%slogan%>"
                now = <%now%>
                text = <%text%>
                opmlUrl = <%opmlUrl%>
                opmlTitle = <%opmlTitle%>
                opmlLongTitle = <%opmlLongTitle%>
                opmlLink = <%opmlLink%>
                opmlDescription = <%opmlDescription%>
                opmlDateCreated = <%opmlDateCreated%>
                opmlDateModified = <%opmlDateModified%>
                opmlOwnerName = <%opmlOwnerName%>
                opmlOwnerEmail = <%opmlOwnerEmail%>
                opmlOwnerId = <%opmlOwnerId%>
                path = <%path%>
              <%comments%>
  Example 5
    Quick Markdown Syntax Guide
    ===========================
    * - Plain text
    * - Markdown applied
    This guide shows you how to use Markdown instead of HTML when writing posts or comments.
    Markdown is way easier to use than HTML. (But you can still use HTML at the same time if you really want to and you know how.)
    Just write in the comment box *the same way it's shown in this file*, it's really that simple.
    (See bottom for more info about Markdown itself.)
    Links
    -----
    For a URL or email, just write it like this:
    To use text for the link, write it [like this](http://someurl).
    You can add a *title* (which shows up under the cursor), [like this](http://someurl "this title shows up when you hover").
    Reference Links
    ---------------
    You can also put the [link URL][1] below the current paragraph like [this][2].
      [1]: http://url
      [2]: http://another.url "A funky title"
    Here the text "link URL" gets linked to "http://url", and the lines showing "[1]: http://url" won't show anything.
    Or you can use a [shortcut][] reference, which links the text "shortcut"
    to the link named "[shortcut]" on the next paragraph.
      [shortcut]: http://goes/with/the/link/name/text
    Text
    ----
    Use * or _ to emphasize things:
    *this is in italic* and _so is this_
    **this is in bold** and __so is this__
    ***this is bold and italic*** and ___so is this___
    Just write paragraphs like in a text file and they will display how you would expect. A blank line separates paragraphs.
    So this is a new paragraph. But any text on adjacent lines
    will all end up
    in the same paragraph.
    Blockquotes
    ----------
    > Use the > character in front of a line, *just like in email*.
    > Use it if you're quoting a person, a song or whatever.
    > You can use *italic* or lists inside them also.
    And just like with other paragraphs,
    all of these lines are still
    part of the blockquote, even without the > character in front.
    To end the blockquote, just put a blank line before the following paragraph.
    Preformatted Text
    ----------------
    If you want some text to show up exactly as you write it, without Markdown
    doing anything to it, just indent every line by at least 4 spaces (or 1 tab).
      This line won't *have any markdown* formatting applied.
      I can even write HTML and it will show up as text.
      This is great for showing program source code, or HTML or even Markdown.
      this won't show up as HTML but exactly as you see it in
      this text file.
    (In a normal paragraph, this will show up in bold just like normal HTML.)
      Remember, you have to indent by *at least 4 spaces* to do it. This paragraph
      won't be preformatted.
    And if you use [reference][] links, make sure the links are indented
    by *fewer than* 4 spaces.
      [reference]: http://example.com/blah
    (woops, that link didn't work, see? It just got displayed as preformatted text.)
    As a shortcut you can use backquotes to do the same thing while inside
    a normal pargraph. `This won't be *italic* or **bold** at all.`
    Lists
    --------
    * an asterisk starts an unordered list
    * and this is another item in the list
    + or you can also use the + character
    - or the - character
    To start an ordered list, write this:
    1. this starts a list *with* numbers
    + this will show as number "2"
    * this will show as number "3."
    9. any number, +, -, or * will keep the list going.
      * just indent by 4 spaces (or tab) to make a sub-list
        1. keep indenting for more sub lists
    * here i'm back to the second level
    Headers
    ---------
    This is a huge header
    ==================
    this is a smaller header
    ------------------
    Just put 1 or more dashes or equals signs (--- or ===) below the title.
    You might use the huge header at the very top of your text for a title or
    something (except weblog posts usually already have a title), and use the
    smaller header for subtitles or sections.
    Horizontal Rule
    ---------------
    just put three or more *'s or -'s on a line:
    ----------------
    or you can use single spaces between then, like this:
    * * *
    or
    - - - - - - -
    Make sure you have a blank line above the dashes, though, or else:
    you will get a header
    ---
    Images
    -----------
    To include an image, just put a "!" in front of a text link:
    ![alternate text](http://static.scripting.com/larryKing/images/2013/06/03/trex.gif)
    The "alternate text" will show up if the browser can't load the image.
    You can also use a title if you want, like this:
    ![tiny mao](https://dl.dropboxusercontent.com/u/36518280/misc/My%20Twitter%20icons/chairmanMao.gif "tiny mao")
    Escapes
    ---------
    What if you want to just show asterisks, not italics?
    * this shows up in italics: *a happy day*
    * this shows t he asterisks: \*a happy day\*
    The backslashes will disappear and leave the asterisks.
    You can do the same with any of the characters that have a special meaning
    for Markdown.
    More Headers
    ----------
    More ways of doing headers:
    # this is a huge header #
    ## this is a smaller header ##
    ### this is even smaller ###
    #### more small ####
    ##### even smaller #####

    ###### smallest still: `
    ` header

    You can use up to 6 `#` characters at the beginning of the line.
    (You can optionally put them on the end, too, and they will disappear.)
    HTML crap
    -------------
    Don't worry about special HTML characters. I can write an ampersand & a
    less-than sign, and they show up as I intend them to: 3 < 4.
    (You can still write `&` (& character) and `<` (<) or `>` (>) if you
    want. or ignore what I just said.)
    About
    ---------
    This text file shows you how to use [Markdown][] instead of crappy HTML when
    writing posts or comments.
      [Markdown]: http://daringfireball.net/projects/markdown/syntax
    Markdown is an easier way of making HTML pages from text, rather than having to
    know HTML.
    * See this file as it looks when [rendered with Markdown][].
    * See the [original text file][].
      [rendered with Markdown]: http://greg.vario.us/doc/markdown.text
      [original text file]: http://greg.vario.us/doc/markdown.txt
    Thanks
    ---------
    Thanks to John Gruber and Aaron Swartz for creating Markdown.
    Fin
    ---------
    No rights reserved, do with this what you like.
    Written by Greg Schueler,
  Example 6
    Here's a link to my home page: "myHome".
  Example 7
    ## Danny Boy
    Oh, Danny boy, the pipes, the pipes are calling
    From glen to glen and down the mountain side
    The summer's gone and all the roses falling
    It's you, it's you, must go and I must bide
    But come ye back when summer's in the meadow
    Or when the valley's hushed and white with snow
    It's I'll be here in sunshine or in shadow
    Oh, Danny boy, oh, Danny boy, I love you so
    But when ye come and all the flowers are dying
    If I am dead and dead I well may be
    You'll come and find the place where I am lying
    And kneel and say an 'Ave' there for me
    And I shall hear tho' soft you tread above me
    And all my grave will warmer, sweeter be
    For you will bend and tell me that you love me
    And I shall sleep in peace until you come to me
    Source: [Wikipedia](http://en.wikipedia.org/wiki/Danny_Boy).
  Example 8
    Todo list
      Read a book.
      Go for a walk.
        Park?
        River?
      Talk with a friend.
    Trip to San Francisco
      People to see
        Bill Jordan
        Elio Malatesta
        Rudy Kiesler
        Uncle Vava
        Big Dot
      Press visits
      Tourism
        Baseball game?
  Example 9
    Hello this is an example of a page with a menu.
  Example 10
    "Don't Be Evil"
      Is Google's commandment.
      Mine isn't yet as concise.
      But here it is...
    Apps must...
      Give instant gratification and
      Convey a sense of purpose, yet
      Be deep.
    We serve
      Designers
      Programmers
      Writers
    Starter apps
      In 1984 the Mac could never have made it without MacWrite and MacPaint.
      Gave developers something to emulate.
      Helped form the coral reef.
      This is a comment
        So you won't see it.
    This slide is totally invisible
      Hellllo!
    Where's the catch?
      My goal is to deliver an outline-based writing, design and coding platform, and have there be no catch.
      No hidden business model. Nothing I have to prove other than you can do all this at the same time.
      I may want to sell something, but you will always have choice to buy or not. Or buy from someone else.
  Example 12
    <%pagetable.type%>
    abc<%icon ("smile")%>def
    ghi<%12+24%>jkl
    <%includeHTTP ("https://dl.dropboxusercontent.com/u/36518280/messageOfTheDay/fargo.txt")%>
    mno<%icon ("rss")%>pqr
  Example 13
    The text below comes from an include.
  Example 14
    #text "A question maybe no one has ever asked you"
    Here's a question: At what point in your life did what you think become important?
    Why I ask: Many people seem to think that what a kid thinks isn't important. After all, you're just a kid. Do what you're told. Be seen and not heard. It's totally understandable that adults react this way to kids, because they can be irritating with all their questions, ideas, enthusiasm, energy and emotions. Kids are a handful. Adults like a little peace and quiet. Shut up! ;-)
    We have to give the adults some understanding and love. But eventually the kids grow up, and did we ever stop and say, okay now that you're not a kid anymore, what you think is important? No one ever said that to me. And I think that's a b ug, because the truth is this -- what you think matters as much as what anyone else thinks. If they matter, then so do you. If you don't matter, neither do they.
    Once you get this, really feel it -- the reason to argue melts away. I don't need to convince you of anything, I just need to believe it myself. Or not. In other words, I'll make up my own mind, thank you very much.
    Happy Thanksgiving! :-)
  Example 15
    "river3"
    <%12+99+45-12%>
    "groundswell"
  Example 16 -- A blogHome page
    United States
      Ohio
        The name "Ohio" originated from Iroquois word ohi-yo’, meaning "great river" or "large creek". The state, originally partitioned from theNorthwest Territory, was admitted to the Union as the 17th state (and the first under the Northwest Ordinance) on March 1, 1803.
        Although there are conflicting narratives regarding the origin of the nickname, Ohio is historically known as the "Buckeye State" (relating to the Ohio buckeye tree) and Ohioans are also known as "Buckeyes".
      Louisiana
        Much of the state's lands were formed from sediment washed down the Mississippi River, leaving enormous deltas and vast areas of coastal marsh and swamp. These contain a rich southern biota; typical examples include birds such as ibis and egrets.
        There are also many species of tree frogs, and fish such as sturgeon and paddlefish. In more elevated areas, fire is a natural process in the landscape, and has produced extensive areas of longleaf pine forest and wet savannas.
        These support an exceptionally large number of plant species, including many species of orchids and carnivorous plants.
    Portugal
      The land within the borders of the current Portuguese Republic has been continually fought over and settled since prehistoric times. After a period of Roman rule followed by Visigothic and Suebian domination, in the 8th century most of the Iberian Peninsula was conquered byMoorish invaders.
      During the Catholic Church oriented Reconquista, Portugal established itself as an independent kingdom from Galicia in 1139. In the 15th and 16th centuries, as the result of pioneering the Age of Discovery, Portugal expanded western influence and established the first global empire, becoming one of the world's major economic, political and military powers, and ultimately dividing the world with Spain.
Troubleshooting
  You may run into trouble if you keep more than one copy of Fargo open at a time on the same computer. You should get error dialogs warning you before you overwrite an existing file with an older version. But the best way to operate is to keep at most one tab with Fargo open at any time.
  If you open Fargo and find there are no tabs visible, try this. Go to the Fargo folder. Open the #prefs folder. Delete tabs.json. Back in the browser, reload the Fargo page.
  Reload often. It's the cure for a lot of problems. It also helps make sure you're running the latest version. ;-)
  Try signing out. The command is in the System menu (the rightmost one, labeled with your Dropbox username). When you choose the command you'll get a dialog directing you to give permission in Dropbox.
  When you choose the View in Reader command in Fargo, your browser may prevent it from opening, thinking we're opening a popup window (because that's what it may look like to the browser). Usually the browser offers you the option to open the window anyway, but you may have to look for the option (in Chrome for example, it's in the right edge of the address area at the top of the browser window).
Support
  #### Mail lists
    Please use the Fargo2 list for support questions.
    Before posting there, review the How To Ask For Help post. You'll get better results! ;-)
    smallpicture-user is our community mail list, for everyone who uses Fargo.
      We announce new releases and features on this list.
      If you have a bug to report, this is the best place to do it.
      Advanced topics about web features and scripting are off-topic on this list.
    smallpicture-web is for people who are using Fargo to write blogs and websites, and use the more extensive content management features of Fargo.
    smallpicture-script is for all levels of programmers customizing Fargo or developing applications with Fargo.
  #### Our blog & feed
    We have a blog just for Fargo docs.
    It of course has an RSS feed.
#style
  indent index page lists
    .divFargoIndex ul {
      padding-left: 40px;
      }
#glossary
  "Blogging with Fargo"
    Blogging with Fargo
  "Content Management"
    Content Management
  "myhome"
    Home
  "river3"
    River3
  "scripting news"
    Scripting News
  "small picture"
    Small Picture
  "font awesome"
    Font Awesome
  "fargo"
    Fargo
  "footerPageElements"
    Bless the lord and this house. Blah blah blah.
  "bootswatch"
    Bootswatch
  "smallpicture-script"
    smallpicture-script
  "groundswell"
    This is a macro: <%12 + 24%>.
  "trex"
    Trex
#menus
  scriptingNewsMenu
    Used in Example 9 in the docs.
    Scripting News
      Blog
      Fargo
      Little Outliner
      Linkblog
      Top-40
      River
      Dave
#templates
  greenroom
        <%text%>
          body {
            font-family: Georgia;
            font-size: 19px;
            background-color: honeydew;
            color: darkgreen;
            width: 500px;
            margin-left: auto;
            margin-right: auto;
            margin-top: 100px;
            }
          a {
            color: darkgreen;
            }
        <%bodytext%>
#macros
  hello
    return ("Hello there!")
  sumArgs
    var sum = 0;
    for (var i = 0; i < sumArgs.arguments.length; i++) {
      sum += sumArgs.arguments [i];
      }
    return (sum);
#domain "fargo.io"
#flStoryTextOnIndexPage "false"
#ctLevelsOnIndexPage "1"
#menuname "fargoDocs"
#opmlFeed "http://fargo.io/blog/rss.xml"
#authorTwitterAccount "smallpict"
#flHideByline "true"
#type "index"
#flHitCounter "true"
#counterGroup "scripting"
#counterServer "http://counter.fargo.io/counter"