| Home | Libraries | People | FAQ | More |
A QuickBook document is composed of one or more blocks. An example of a block is the paragraph or a C++ code snippet. Some blocks have special mark-ups. Blocks, except code snippets which have their own grammar (C++ or Python), are composed of one or more phrases. A phrase can be a simple contiguous run of characters. Phrases can have special mark-ups. Marked up phrases can recursively contain other phrases, but cannot contain blocks. A terminal is a self contained block-level or phrase-level element that does not nest anything.
Blocks, in general, are delimited by two end-of-lines (the block terminator). Phrases in each block cannot contain a block terminator. This way, syntax errors such as un-matched closing brackets do not go haywire and corrupt anything past a single block.
Can be placed anywhere.
[/ comment (no output generated) ]
[/ comments can be nested [/ some more here] ]
[/ Quickbook blocks can nest inside comments. [*Comment this out too!] ]
['italic], [*bold], [_underline], [^teletype], [-strikethrough]
will generate:
italic, bold, underline, teletype
, strikethrough
Like all non-terminal phrase level elements, this can of course be nested:
[*['bold-italic]]
will generate:
bold-italic
When you want content that may or must be replaced by the user, use the syntax:
[~replacement]
This will generate:
replacement
["A question that sometimes drives me hazy: am I or are the others crazy?]--Einstein
will generate:
“A question that sometimes drives me hazy: am I or are the others crazy?”--Einstein
Note the proper left and right quote marks. Also, while you can simply use ordinary quote marks like "quoted", our quotation, above, will generate correct DocBook quotations (e.g. <quote>quoted</quote>).
Like all phrase elements, quotations may be nested. Example:
["Here's the rule for bargains: ["Do other men, for they would do you.] That's the true business precept.]
will generate:
“Here's the rule for bargains: ‘Do other men, for they would do you.’ That's the true business precept.”
Simple markup for formatting text, common in many applications, is now supported:
/italic/, *bold*, _underline_, =teletype=
will generate:
italic, bold, underline, teletype
Unlike QuickBook's standard formatting scheme, the rules for simpler alternatives are much stricter [6] .
Table 30.1. More Formatting Samples
|
Markup |
Result |
|---|---|
|
|
Bold |
|
|
Is bold |
|
|
* Not bold* *Not bold * * Not bold * |
|
|
This*Isn't*Bold (no bold) |
|
|
(Bold Inside) (parenthesis not bold) |
|
|
(Bold Outside) (parenthesis bold) |
|
|
3*4*5 = 60 (no bold) |
|
|
3 * 4 * 5 = 60 (no bold) |
|
|
3 4 5 = 60 (4 is bold) |
|
|
This is bold this is not but this is |
|
|
This is bold. |
|
|
B. (bold B) |
|
|
Bold-Italic |
|
|
side-by-side |
As mentioned, simple markups cannot go past a single block. The text from "have" to "full" in the following paragraph will be rendered as bold:
Baa baa black sheep, *have you any wool? Yes sir, yes sir, three bags full!* One for the master, one for the dame, And one for the little boy who lives down the lane.
Baa baa black sheep, have you any wool? Yes sir, yes sir, three bags full! One for the master, one for the dame, And one for the little boy who lives down the lane.
But in the following paragraph, bold is not applied:
Baa baa black sheep, *have you any wool? Yes sir, yes sir, three bags full! One for the master, one for the dame, And one for the little boy who lives down the lane.
Baa baa black sheep, *have you any wool? Yes sir, yes sir, three bags full! One for the master, one for the dame, And one for the little boy who lives down the lane.
Inlining code in paragraphs is quite common when writing C++ documentation. We provide a very simple markup for this. For example, this:
This text has inlined code `int main() { return 0; }` in it.
will generate:
This text has inlined code int main() { return 0; }
in it. The code will be syntax highlighted.
| Note | |
|---|---|
We simply enclose the code with the tick: |
Preformatted code simply starts with a space or a tab (See Code). However, such a simple syntax cannot be used as phrase elements in lists (See Ordered lists and Unordered lists), tables (See Tables), etc. Inline code (see above) can. The problem is, inline code does not allow formatting with newlines, spaces, and tabs. These are lost.
We provide a phrase level markup that is a mix between the two. By using the double-tick, instead of the single-tick, we are telling QuickBook to use preformatted blocks of code. Example:
`` #include <iostream> int main() { std::cout << "Hello, World!" << std::endl; return 0; } ``
will generate:
#include <iostream> int main() { std::cout << "Hello, World!" << std::endl; return 0; }
If a document contains more than one type of source code then the source mode may be changed dynamically as the document is processed. All QuickBook documents are initially in C++ mode by default, though an alternative initial value may be set in the Document section.
To change the source mode, use the [source-mode]
markup,
where source-mode
is one of the supported modes. For
example, this:
Python's [python] `import` is rather like C++'s [c++] `#include`. A C++ comment `// looks like this` whereas a Python comment [python] `# looks like this`.
will generate:
Python's import
is rather
like C++'s #include
.
A C++ comment // looks like this
whereas a Python comment #looks like this
.
Table 30.2. Supported Source Modes
|
Mode |
Source Mode Markup |
|---|---|
|
C++ |
|
|
Python |
|
|
Plain Text |
|
| Note | |
|---|---|
The source mode strings are lowercase. |
[br]
| Warning | |
|---|---|
|
[#named_anchor]
A named anchor is a hook that can be referenced by a link elsewhere in
the document. You can then reference an anchor with [link named_anchor
Some link text]
.
See Anchor links,
Section and Heading.
These anchors are global and can be accessed from anywhere in the quickbook documentation. Be careful to avoid clashes with anchors in other sections.
[@http://www.boost.org this is [*boost's] website....]
will generate:
URL links where the link text is the link itself is common. Example:
see http://spirit.sourceforge.net/
so, when the text is absent in a link markup, the URL is assumed. Example:
see [@http://spirit.sourceforge.net/]
will generate:
see http://spirit.sourceforge.net/
Boostbook also support a custom url schema for linking to files within the boost distribution:
[@boost:/libs/spirit/index.html the Boost.Spirit documentation]
will generate: the Boost.Spirit documentation
Note that this is only available when using BoostBook, and only for links - it can't be used for images.
You can link within a document using:
[link document_id.section_id.normalized_header_text The link text]
In addition, you can link internally to an XML refentry like:
[link xml.refentry The link text]
This gets converted into <link linkend="xml.refentry">The
link text</link>
.
Like URLs, the link text is optional. If this is not present, the link text will automatically be the refentry. Example:
[link xml.refentry]
This gets converted into <link linkend="xml.refentry">xml.refentry</link>
.
If you want to link to a function, class, member, enum, concept, global, or header in the reference section, you can use:
[funcref fully::qualified::function_name The link text] [classref fully::qualified::class_name The link text] [memberref fully::qualified::member_name The link text] [enumref fully::qualified::enum_name The link text] [macroref MACRO_NAME The link text] [conceptref ConceptName The link text] [headerref path/to/header.hpp The link text] [globalref fully::qualified::global The link text]
Again, the link text is optional. If this is not present, the link text will automatically be the function, class, member, enum, macro, concept, global, or header name. Example:
[classref boost::bar::baz]
would have "boost::bar::baz" as the link text.
The escape mark-up is used when we don't want to do any processing.
''' escape (no processing/formatting) '''
Escaping allows us to pass XML markup to BoostBook or DocBook. For example:
''' <emphasis role="bold">This is direct XML markup</emphasis> '''
This is direct XML markup
The backslash may be used to escape a single punctuation character. The
punctuation immediately after the backslash is passed without any processing.
This is useful when we need to escape QuickBook punctuations such as [
and ]
.
For example, how do you escape the triple quote? Simple: \'\'\'
\n
has a special meaning. It is used to generate line breaks.
| Warning | |
|---|---|
|
The escaped space: \
also
has a special meaning. The escaped space is removed from the output.
[$image.jpg]
From version 1.5, you can also use DocBook imagedata attributes:
[$image.jpg [width 200in] [height 200in]]
As of version 1.3, QuickBook supports footnotes. Just put the text of the
footnote in a [footnote]
block, and the text will be put at the
bottom of the current page. For example, this:
[footnote A sample footnote]
will generate this [7] .
Like C++ #ifdef
, you can generate
phrases depending on the presence of a macro. Example:
[? __to_be__ To be or not to be]
Here, the phrase "To be or not to be" will only be generated if the macro symbol __to_be__ has been previously defined. The phrase above will not do anything since we haven't defined __to_be__. Now, let's define the symbol:
[def __to_be__]
And try again:
To be or not to be
Yes! [8]
Every document must begin with a Document Info section, which should look like this:
[document-type The Document Title [quickbook 1.5] [version 1.0] [id the_document_name] [dirname the_document_dir] [copyright 2000 2002 2003 Joe Blow, Jane Doe] [purpose The document's reason for being] [category The document's category] [authors [Blow, Joe], [Doe, Jane]] [license The document's license] [source-mode source-type] ]
Where document-type is one of:
quickbook 1.5 declares the version of quickbook the document is written for. In its absence, version 1.1 is assumed.
version
, id
, dirname
,
copyright
, purpose
, category
,
authors
, license
, last-revision
and source-mode
are optional information.
source-type
is a lowercase string setting the initial
Source Mode.
If the source-mode
field is omitted, a default value
of c++
will be used.
Starting a new section is accomplished with:
[section:id The Section Title]
where id is optional. id will be the filename of the
generated section. If it is not present, "The Section Title"
will be normalized and become the id. Valid characters are a-Z
,
A-Z
, 0-9
and _
.
All non-valid characters are converted to underscore and all upper-case
are converted to lower case. Thus: "The Section Title" will be
normalized to "the_section_title".
End a section with:
[endsect]
Sections can nest, and that results in a hierarchy in the table of contents.
You can include another XML file with:
[xinclude file.xml]
This is useful when file.xml has been generated by Doxygen and contains your reference section.
Paragraphs start left-flushed and are terminated by two or more newlines. No markup is needed for paragraphs. QuickBook automatically detects paragraphs from the context. Block markups [section, endsect, h1, h2, h3, h4, h5, h6, blurb, (block-quote) ':', pre, def, table and include ] may also terminate a paragraph.
This is a new paragraph...
List hierarchies are supported. Example:
# One # Two # Three # Three.a # Three.b # Three.c # Four # Four.a # Four.a.i # Four.a.ii # Five
will generate:
Long lines will be wrapped appropriately. Example:
# A short item. # A very long item. A very long item. A very long item. A very long item. A very long item. A very long item. A very long item. A very long item. A very long item. A very long item. A very long item. A very long item. A very long item. A very long item. A very long item. # A short item.
Mixed lists (ordered and unordered) are supported. Example:
# One # Two # Three * Three.a * Three.b * Three.c # Four
will generate:
And...
# 1 * 1.a # 1.a.1 # 1.a.2 * 1.b # 2 * 2.a * 2.b # 2.b.1 # 2.b.2 * 2.b.2.a * 2.b.2.b
will generate:
Preformatted code starts with a space or a tab. The code will be syntax highlighted according to the current Source Mode:
#include <iostream> int main() { // Sample code std::cout << "Hello, World\n"; return 0; }
import cgi def cookForHtml(text): '''"Cooks" the input text for HTML.''' return cgi.escape(text)
Macros that are already defined are expanded in source code. Example:
[def __array__ [@http://www.boost.org/doc/html/array/reference.html array]] [def __boost__ [@http://www.boost.org/libs/libraries.htm boost]] using __boost__::__array__;
Generates:
using boost::array;
Inside code, code blocks and inline code, QuickBook does not allow any markup to avoid conflicts with the target syntax (e.g. c++). In case you need to switch back to QuickBook markup inside code, you can do so using a language specific escape-back delimiter. In C++ and Python, the delimiter is the double tick (back-quote): "``" and "``". Example:
void ``[@http://en.wikipedia.org/wiki/Foo#Foo.2C_Bar_and_Baz foo]``() { }
Will generate:
void foo() { }
When escaping from code to QuickBook, only phrase level markups are allowed. Block level markups like lists, tables etc. are not allowed.
Sometimes, you don't want some preformatted text to be parsed as C++. In
such cases, use the [pre ... ]
markup block.
[pre Some *preformatted* text Some *preformatted* text Some *preformatted* text Some *preformatted* text Some *preformatted* text Some *preformatted* text ]
Spaces, tabs and newlines are rendered as-is. Unlike all quickbook block level markup, pre (and Code) are the only ones that allow multiple newlines. The markup above will generate:
Some preformatted text Some preformatted text Some preformatted text Some preformatted text Some preformatted text Some preformatted text
Notice that unlike Code, phrase markup such as font style is still permitted
inside pre
blocks.
[note This is a note] [tip This is a tip] [important This is important] [caution This is a caution] [warning This is a warning]
generates DocBook admonitions:
| Note | |
|---|---|
This is a note |
| Tip | |
|---|---|
This is a tip |
| Important | |
|---|---|
This is important |
| Caution | |
|---|---|
This is a caution |
| Warning | |
|---|---|
This is a warning |
These are the only admonitions supported by DocBook.
So, for example [information This is some information]
is unlikely to produce the desired effect.
[h1 Heading 1] [h2 Heading 2] [h3 Heading 3] [h4 Heading 4] [h5 Heading 5] [h6 Heading 6]
Headings 1-3 [h1 h2 and h3] will automatically have anchors with normalized
names with name="document_id.section_id.normalized_header_text"
(i.e. valid characters are a-z
, A-Z
,
0-9
and _
. All non-valid characters
are converted to underscore and all upper-case are converted to lower-case.
For example: Heading 1 in section Section 2 will be normalized to section_2.heading_1
).
You can use:
[link document_id.section_id.normalized_header_text The link text]
to link to them. See Anchor links and Section for more info.
In cases when you don't want to care about the heading level (1 to 6), you can use the Generic Heading:
[heading Heading]
The Generic Heading assumes the level, plus one, of the innermost section where it is placed. For example, if it is placed in the outermost section, then, it assumes h2.
Headings are often used as an alternative to sections. It is used particularly if you do not want to start a new section. In many cases, however, headings in a particular section is just flat. Example:
[section A] [h2 X] [h2 Y] [h2 Z] [endsect]
Here we use h2 assuming that section A is the outermost level. If it is placed in an inner level, you'll have to use h3, h4, etc. depending on where the section is. In general, it is the section level plus one. It is rather tedious, however, to scan the section level everytime. If you rewrite the example above as shown below, this will be automatic:
[section A] [heading X] [heading Y] [heading Z] [endsect]
They work well regardless where you place them. You can rearrange sections at will without any extra work to ensure correct heading levels. In fact, with section and heading, you have all you need. h1..h6 becomes redundant. h1..h6 might be deprecated in the future.
[def macro_identifier some text]
When a macro is defined, the identifier replaces the text anywhere in the file, in paragraphs, in markups, etc. macro_identifier is a string of non- white space characters except ']'. A macro may not follow an alphabetic character or the underscore. The replacement text can be any phrase (even marked up). Example:
[def sf_logo [$http://sourceforge.net/sflogo.php?group_id=28447&type=1]] sf_logo
Now everywhere the sf_logo is placed, the picture will be inlined.
| Tip | |
|---|---|
It's a good idea to use macro identifiers that are distinguishable. For
instance, in this document, macro identifiers have two leading and trailing
underscores (e.g. |
Links (URLS) and images are good candidates for macros. 1)
They tend to change a lot. It is a good idea to place all links and images
in one place near the top to make it easy to make changes. 2)
The syntax is not pretty. It's easier to read and write, e.g. __spirit__
than [@http://spirit.sourceforge.net Spirit]
.
Some more examples:
[def :-) [$theme/smiley.png]] [def __spirit__ [@http://spirit.sourceforge.net Spirit]]
Invoking these macros:
Hi __spirit__ :-)
will generate this:
Hi Spirit
Quickbook has some predefined macros that you can already use.
Table 30.3. Predefined Macros
|
Macro |
Meaning |
Example |
|---|---|---|
|
__DATE__ |
Today's date |
2010-Feb-01 |
|
__TIME__ |
The current time |
10:24:06 AM |
|
__FILENAME__ |
Quickbook source filename |
/Users/daniel/boost/release/boost-release/tools/quickbook/doc/quickbook.qbk |
Templates provide a more versatile text substitution mechanism. Templates come in handy when you need to create parameterizable, multi-line, boilerplate text that you specify once and expand many times. Templates accept one or more arguments. These arguments act like place-holders for text replacement. Unlike simple macros, which are limited to phrase level markup, templates can contain block level markup (e.g. paragraphs, code blocks and tables).
Example template:
[template person[name age what] Hi, my name is [name]. I am [age] years old. I am a [what]. ]
Template identifiers can either consist of:
Template formal arguments are identifiers consisting of an initial alphabetic character or the underscore, followed by zero or more alphanumeric characters or the underscore. This is similar to your typical C/C++ identifier.
A template formal argument temporarily hides a template of the same name
at the point where the template
is expanded. Note that the body of the person
template above refers to name
age
and what
as [name]
[age]
and [what]
. name
age
and what
are actually templates that exist in the duration
of the template call.
The template body can be just about any QuickBook block or phrase. There are actually two forms. Templates may be phrase or block level. Phrase templates are of the form:
[template sample[arg1 arg2...argN] replacement text... ]
Block templates are of the form:
[template sample[arg1 arg2...argN] replacement text... ]
The basic rule is as follows: if a newline immediately follows the argument list, then it is a block template, otherwise, it is a phrase template. Phrase templates are typically expanded as part of phrases. Like macros, block level elements are not allowed in phrase templates.
You expand a template this way:
[template_identifier arg1..arg2..arg3]
At template expansion, you supply the actual arguments. The template will be expanded with your supplied arguments. Example:
[person James Bond..39..Spy] [person Santa Clause..87..Big Red Fatso]
Which will expand to:
Hi, my name is James Bond. I am 39 years old. I am a Spy.
Hi, my name is Santa Clause. I am 87 years old. I am a Big Red Fatso.
| Caution | |
|---|---|
A word of caution: Templates are recursive. A template can call another template or even itself, directly or indirectly. There are no control structures in QuickBook (yet) so this will always mean infinite recursion. QuickBook can detect this situation and report an error if recursion exceeds a certain limit. |
Each actual argument can be a word, a text fragment or just about any
QuickBook phrase. Arguments
are separated by the double dot ".."
and terminated
by the close parenthesis.
Nullary templates look and act like simple macros. Example:
[template alpha[]'''α'''] [template beta[]'''β''']
Expanding:
Some squigles...[*[alpha][beta]]
We have:
Some squiggles...αβ
The difference with macros are
The empty brackets after the template identifier (alpha[]
)
indicates no arguments. If the template body does not look like a template
argument list, we can elide the empty brackets. Example:
[template aristotle_quote Aristotle: [*['Education is the best provision for the journey to old age.]]]
Expanding:
Here's a quote from [aristotle_quote].
We have:
Here's a quote from Aristotle: Education is the best provision for the journey to old age..
The disadvantage is that you can't avoid the space between the template
identifier, aristotle_quote
,
and the template body "Aristotle...". This space will be part
of the template body. If that space is unwanted, use empty brackets or
use the space escape: "\
".
Example:
[template tag\ _tag]
Then expanding:
`struct` x[tag];
We have:
struct
x_tag;
You have a couple of ways to do it. I personally prefer the explicit empty brackets, though.
As mentioned, arguments are separated by the double dot ".."
.
Alternatively, if the double dot isn't used and more than one argument
is expected, QuickBook uses whitespace to separate the arguments, following
this logic:
'',
'\n', \t' or '\r'
).
For example:
[template simple[a b c d] [a][b][c][d]] [simple w x y z]
will produce:
wxyz
"w x y z" is initially treated as a single argument because we
didn't supply any ".."
separators. However,
since simple
expects 4 arguments, "w x y z"
is broken down iteratively (applying the logic above) until we have "w",
"x", "y" and "z".
QuickBook only tries to get the arguments it needs. For example:
[simple w x y z trail]
will produce:
wxyz trail
The arguments being: "w", "x", "y" and "z trail".
| Caution | |
|---|---|
The behavior described here is for QuickBook 1.5. In older versions you could use both the double dot and whitespace as separators in the same template call. If your document is marked up as an older version, it will use the old behavior, which is described in the QuickBook 1.4 documentation. |
With templates, one of our objectives is to allow us to rewrite QuickBook in QuickBook (as a qbk library). For that to happen, we need to accommodate single character punctuation templates which are fairly common in QuickBook. You might have noticed that single character punctuations are allowed as template identifiers. Example:
[template ![bar] <hey>[bar]</hey>]
Now, expanding this:
[!baz]
We will have:
<hey>baz</hey>
[blurb :-) [*An eye catching advertisement or note...] __spirit__ is an object-oriented recursive-descent parser generator framework implemented using template meta-programming techniques. Expression templates allow us to approximate the syntax of Extended Backus-Normal Form (EBNF) completely in C++. ]
will generate this:
| Note | |
|---|---|
Prefer admonitions wherever appropriate. |
[table:id A Simple Table [[Heading 1] [Heading 2] [Heading 3]] [[R0-C0] [R0-C1] [R0-C2]] [[R1-C0] [R1-C1] [R1-C2]] [[R2-C0] [R2-C1] [R2-C2]] ]
will generate:
Table 30.4. A Simple Table
|
Heading 1 |
Heading 2 |
Heading 3 |
|---|---|---|
|
R0-C0 |
R0-C1 |
R0-C2 |
|
R1-C0 |
R1-C1 |
R1-C2 |
|
R2-C0 |
R2-C1 |
R2-C2 |
The table title is optional. The first row of the table is automatically
treated as the table header; that is, it is wrapped in <thead>...</thead>
XML tags. Note that unlike the original QuickDoc, the columns are nested
in [cells... ].
Giving tables an id is a new feature for quickbook 1.5 onwards. As with sections, the id is optional. If the table has a title but no id, an id will be generated from the title. The table above can be linked to using:
[link quickbook.syntax.block.tables.id link to table]
which will generate:
The syntax is free-format and allows big cells to be formatted nicely.  We emphasize libraries that work well with the C++ Standard Library. Boost libraries are intended to be widely useful, and usable across a broad spectrum of applications. The Boost license encourages both commercial and non-commercial use. ] ] [ [Row 1, Col 0: a small cell] [Row 1, Col 1: a small cell] ] ]
and thus:
Table 30.5.  We emphasize libraries that work well with the C++ Standard Library. Boost libraries are intended to be widely useful, and usable across a broad spectrum of applications. The Boost license encourages both commercial and non-commercial use. |
|
Row 1, Col 0: a small cell |
Row 1, Col 1: a small cell |
Here's how to have preformatted blocks of code in a table cell:
[table Table with code [[Comment] [Code]] [ [My first program] [`` #include <iostream> int main() { std::cout << "Hello, World!" << std::endl; return 0; } ``] ] ]
Table 30.6. Table with code
|
Comment |
Code |
|---|---|
|
My first program |
#include <iostream> int main() { std::cout << "Hello, World!" << std::endl; return 0; }
|
[variablelist A Variable List [[term 1] [The definition of term 1]] [[term 2] [The definition of term 2]] [[term 3] [ The definition of term 3. Definitions may contain paragraphs. ]] ]
will generate:
A Variable List
The definition of term 1
The definition of term 2
The definition of term 3.
Definitions may contain paragraphs.
The rules for variable lists are the same as for tables, except that only 2 "columns" are allowed. The first column contains the terms, and the second column contains the definitions. Those familiar with HTML will recognize this as a "definition list".
You can include one QuickBook file from another. The syntax is simply:
[include someother.qbk]
The included file will be processed as if it had been cut and pasted into the current document, with the following exceptions:
The [include]
directive lets you specify a document
id to use for the included file. When this id is not explicitly specified,
the id defaults to the filename ("someother", in the example
above). You can specify the id like this:
[include:someid someother.qbk]
All auto-generated anchors will use the document id as a unique prefix.
So for instance, if there is a top section in someother.qbk named "Intro",
the named anchor for that section will be "someid.intro", and
you can link to it with [link someid.intro The Intro]
.
When documenting code, you'd surely need to present code from actual source files. While it is possible to copy some code and paste them in your QuickBook file, doing so is error prone and the extracted code in the documentation tends to get out of sync with the actual code as the code evolves. The problem, as always, is that once documentation is written, the tendency is for the docs to languish in the archives without maintenance.
QuickBook's import facility provides a nice solution.
You can effortlessly import code snippets from source code into your QuickBook. The following illustrates how this is done:
[import ../test/stub.cpp] [foo] [bar]
The first line:
[import ../test/stub.cpp]
collects specially marked-up code snippets from stub.cpp
and places them in your QuickBook file as virtual templates. Each of the
specially marked-up code snippets has a name (e.g. foo
and bar
in the example
above). This shall be the template identifier for that particular code
snippet. The second and third line above does the actual template expansion:
[foo] [bar]
And the result is:
This is the foo function.
This description can have paragraphs...
And any quickbook block markup.
std::string foo() { // return 'em, foo man! return "foo"; }
This is the bar function
std::string bar() { // return 'em, bar man! return "bar"; }
Some trailing text here
Note how the code snippets in stub.cpp get marked up. We use distinguishable comments following the form:
//[id some code here //]
The first comment line above initiates a named code-snippet. This prefix
will not be visible in quickbook. The entire code-snippet in between //[id
and //]
will be inserted as a template in quickbook with name id.
The comment //]
ends a code-snippet
This too will not be visible in quickbook.
Special comments of the form:
//` some [*quickbook] markup here
and:
/*` some [*quickbook] markup here */
will be parsed by QuickBook. This can contain quickbook blocks (e.g. sections, paragraphs, tables, etc). In the first case, the initial slash-slash, tick and white-space shall be ignored. In the second, the initial slash-star-tick and the final star-slash shall be ignored.
Special comments of the form:
/*<- this C++ comment will be ignored ->*/
or
/*<-*/ "this c++ code will be ignored" /*->*/
or
//<- private: int some_member; //->
can be used to inhibit code from passing through to quickbook. All text between the delimeters will simply be ignored.
Special comments of the form:
/*< some [*quickbook] markup here >*/
will be regarded as callouts. These will be collected, numbered and rendered as a "callout bug" (a small icon with a number). After the whole snippet is parsed, the callout list is generated. See Callouts for details. Example:
std::string foo_bar() { return "foo-bar"; }
The Mythical FooBar. See Foobar for details |
|
return 'em, foo-bar man! |
This is the actual code:
//[ foo_bar std::string foo_bar() /*< The /Mythical/ FooBar. See [@http://en.wikipedia.org/wiki/Foobar Foobar for details] >*/ { return "foo-bar"; /*< return 'em, foo-bar man! >*/ } //]
The callouts bugs are placed exactly where the special callout comment is situated. It can be anywhere in the code. The bugs can be rather obtrusive, however. They get in the way of the clarity of the code. Another special callout comment style is available:
/*<< some [*quickbook] markup here >>*/
This is the line-oriented version of the callout. With this, the "bug" is placed at the very left of the code block, away from the actual code. By placing it at the far left, the code is rendered un-obscured. Example:
class x { public: x() : n(0) { } ~x() { } int get() const { return n; } void set(int n_) { n = n_; } };
See the actual code here: boost:/tools/quickbook/test/stub.cpp
[6] Thanks to David Barrett, author of Qwiki, for sharing these samples and teaching me these obscure formatting rules. I wasn't sure at all if Spirit, being more or less a formal EBNF parser, can handle the context sensitivity and ambiguity.
[7] A sample footnote
[8] Conditional Generation makes quickbook turing complete.


Id = 21
Nombre Capitulo = Testicle Monster Dimension
Tipo = Dimension
Dimension = Testicle Monster Dimension
Personaje = ['https://rickandmortyapi.com/api/character/7', 'https://rickandmortyapi.com/api/character/436']
Numero Personaje = ['7', '436']
URL Locacion = https://rickandmortyapi.com/api/location/21


An appended fact is written by placing constraints in curly braces
immediately after a sig statement. They can make
a model clearer by logically grouping related constraints
together.
sig name {
// fields of the signature
}{
// appended fact constraints
}
Any field mentioned in the appended fact has an implied "all
this:name |" at its beginning, and an implied
"this." in front of it. Thus:
sig Person {
closeFriends: set Person,
friends: set Person
} {
closeFriends in friends
}
is really saying
sig Person {
closeFriends: set Person,
friends: set Person
}
fact {
all x:Person | x.closeFriends in x.friends
}
Consequently, appended fact can be more concise (and thus clearer) than the equivalent non-appended fact. However, there is also a danger in forgetting that every field mentioned in an appended fact is prepended with "this.".


The Premium Matrimonial Website
For the new age millenials
Premium Features
Find Match is a matchmaking website for the new age millenials. Our vision is to match people who have similar goals, and have a vision to change the world.Life becomes all the more exciting when your better half shares the same life mission


During quarantine, I finally got around to continuing a project that has been on my mind for some four years. For a more complete overview (including references), check out the NIME 2021 paper.
Le Bâton: A Digital Musical Instrument Based on the Chaotic Triple Pendulum
Long exposure photo of Le Bâton.
Introduction
Chaotic systems, a type of nonlinear dynamic system characterized by a strong sensitivity to initial conditions, have inspired many approaches to computer music composition. Though this research primarily occurred during the late 1980s and early 1990s, there has been continued interest in using chaotic data to generate music. Approaches generally involve mapping the output of a chaotic equation to audio synthesis parameters such as MIDI data (i.e. pitch), time domain-based models (i.e. digital waveguides), and frequency domain-based models (i.e. granular synthesis).
The research into the application of chaos to computer music has primarily been focused on iterating over chaotic attractors or maps with computer programs. Typically, a composer inputs some number of equations (usually differential or recursive in nature) with initial parameters into a program which are then iterated using various numerical or discrete-time methods. The output data is then mapped to a sound synthesis. This is known as Functional Iteration Synthesis.
Because the chaotic data is being generated entirely with a computer, it can be confusing to audiences why this compositional approach is unique when compared with other algorithmic composition approaches. Canadian composer Barry Truax writes “from a more philosophical or aesthetic point of view, it is not clear that an arbitrary mapping of a nonlinear function [onto the pitch of successive notes] is inherently more musical than, for instance, a random or stochastic function. The musicality may reside in the musical knowledge of the mapper more than in the source function”. In this project, we seek to continue research into the application of chaotic systems to computer music by building a chaotic digital musical instrument with a visual feedback mechanism, allowing for a coherent audiovisual experience.
Le Bâton.
Le Bâton (pictured above) is a novel interface for musical expression based on the triple pendulum, a simple physical system that can undergo visible chaotic motion. Le Bâton provides embedded visualization and remote sonification of motion data in real-time through embedded wireless inertial measurement units (IMUs) and allows for user interaction through remotely setting its initial conditions.
Le Bâton
This section presents the design and implementation of Le Bâton’s architecture and components: pendulum arms, the control mechanism, data acquisition processes, embedded visualization, and user interaction. All Le Bâton-related source code and documentation are available at https://github.com/IDMIL/le-baton.
Pendulum Arms
We modeled three custom pendulum arms in CAD-based software and 3D-printed them using selective laser sintering with Polyamide-12 filament. The interior of each arm was appropriately hollowed to fit the embedded electronics. The arms were connected with competition-grade skateboard bearings fitted on a small axle to permit independent rotation.
Based on prototyping results, we determined that the swivel point of arm should be located at half the length of that arm, which is connected to the end of arm . This configuration allowed for more favorable motion than simply attaching the end of arm at the end of arm . Additionally, we observed this favorable motion when the mass of the arm was concentrated at one end, as opposed to distributed evenly along its length. To achieve this, we embedded the battery compartment towards one end while hollowing the other end to achieve an asymmetric mass distribution, as shown in the image below.
Photo of electronics embedded inside each pendulum arm.
Control Mechanism
To allow a user to have control over the initial angle and angular velocity of the top pendulum arm, we designed a control mechanism based around the fixed swivel point of the top arm. The mechanism required the ability to “lock” a motor to this point, swing the top arm to some angle, then “unlock,” letting gravity take over.
Our control mechanism consists of a 150:1 12V brushed DC gearmotor coupled to a 24 V DC Ogura AMC 10-29 electromagnetic clutch as shown in the image below. Electromagnetic clutches are electromechanical devices that are commonly found in automated manufacturing machines. Their purpose is to transmit torque from an input shaft to an output hub. When an electromagnetic clutch is powered, electromagnets cause an armature plate to cross a tiny air gap, allowing the input shaft to lock to the output hub via a strong frictional force. Thus, when the input shaft is coupled to a rotating motor, the hub and top pendulum arm will rotate as well. When the clutch is unpowered, the hub is allowed to rotate freely on a bearing, meaning gravity will take over and the pendulum will begin its motion. The output hub of the Ogura clutch we used originally included a shaft that had to be removed to not get in the way of the pendulum.
Control mechanism for Le Bâton. A DC motor is coupled to an
electromagnetic clutch. Once users swing the primary pendulum arm to
some angle and release, gravity takes over.
The motor is controlled with a motor driver interfaced with an Arduino Uno and the electromagnetic clutch is controlled with a relay module interfaced with the same Arduino Uno. A custom enclosure was modeled and 3D-printed to fit all components.
Data Acquisition
We acquire and process motion data for all three pendulum arms in real-time via embedded wireless inertial measurement units (IMUs). An Adafruit BNO055 9DOF Absolute Orientation Sensor is interfaced with an Arduino Nano 33 IoT in each arm, which sends motion data over WiFi to a Macbook Pro laptop running Max/MSP. This data includes absolute orientation, angular velocity, acceleration, magnetic field strength, and gravitational acceleration measurements at around 15 Hz, whereas the fastest oscillations observed were around 6 Hz, thus satisfying the Nyquist criterion.
To achieve consistent data corresponding to the angle θ of each arm at any given moment, we compute a simple polar angle on the gravitational acceleration vectors:
where and are measurements of the acceleration due to gravity along the - and -axes, respectively. All data is readily accessible to users for mapping in a Max patch.
Embedded Visualization
To enhance the audiovisual feedback mechanism, 12 individually addressable RGBW WS2812 LEDs (NeoPixels) were attached to each arm. The goal of these LEDs is to highlight interesting aspects of the motion or sound in real-time while not taking away from the focus of the project. That is, we are not interested in creating unnecessarily complex color patterns that draw attention away from the motion and sound. Rather, they should complement each other. The LEDs are controlled using the Arduino Nano 33 IoT receiving WiFi messages from Max/MSP. Because NeoPixels operate at 5 V, a boost converter (Adafruit PowerBoost 1000C) and 3.3 V to 5 V logic level converter (SparkFun Bi-Directional Logic Level Converter) were embedded alongside the Arduino and IMU. The Adafruit PowerBoost 1000C also features a LiPo battery charging circuit along with constant 5V output. The entire hardware setup is shown below.
Block diagram of Le Bâton hardware platform.
User Interaction
DMIs built around mechanical systems with inherent behavior often focus the user interaction on the initial excitation of the system. Additionally, chaotic systems are very sensitive to their initial conditions. In the case of Le Bâton, this involves providing the pendulum with some potential energy (dropping it from rest), kinetic energy (pushing it into motion), or both. We implemented the aforementioned control mechanism allowing users to remotely interact with the direction and speed of its motor. The addition of the fine-tuned control over the initial angle and angular velocity was motivated by a desire for a more meaningful interaction experience, especially in a performance context. The high sensitivity of this system can be demonstrated as the motion differs even when dropped from the same initial angle.
Because of the variety and quality of its embedded inputs, we selected a Sony DualShock 4 wireless gaming controller as a control interface for prototyping with Le Bâton. The controller sends its data via Bluetooth to a computer running Max/MSP and for further filtering and mapping.
Depending on the context of interaction, some other controls, including but not limited to audio synthesis parameters and LED mappings, are also available to users, to help them gain a better understanding of the various aspects of the chaotic motion.
Long exposure photo of Le Bâton.
Example of angle data for Le Bâton to be processed and mapped to sound.
Rest position is defined as 180°. Note the transition from the chaotic
to non-chaotic regimes at around t = 80s.
Demos
To see Le Bâton in action, check out the NIME 2021 demo video or my presentation at the 3rd CIRMMT-OICRM-BRAMS Student Colloquium.
Acknowledgments
I would like to thank Sean Ferguson, Valérian Fraisse, Pia Baltazar, and Samuel Waranch for fruitful discussions and input. Thanks also to John Sullivan and Yves Méthot for assistance with early prototyping and to the Centre for Interdisciplinary Research in Music Media and Technology for funding this project.


I’m a web developer working in HTML, CSS, JS, React, MongoDB, Express, Socket.io and Ruby on Rails. Prior to web development I worked as a repair technician where I fixed cell phones and computers. I became a manager after a year where I was responsible for training employees. I am currently working on a time tracker for a tutoring business. I am using a combination of HTML, CSS, Javascript, and Ruby on Rails.
Email<EMAIL_ADDRESS>Phone:<PHONE_NUMBER>
Location: Los Angeles & Orance County


 Please start FreeOTP on your smartphone and scan the following QR Code with it:
I'm done, take me to the Login page!


My Title
Ed Campbell (@esc24)
Code:
#!/usr/bin/env python3 print('hello')
Here is a
Link to the code slide
Image can be loaded lazily using 'data-src' (oops on github, looks like you have to use 'src')


Brand
Toggle navigation
First Item
Second Item
Third Item
Log In
Sign Up
Sign In
×
Log in
Or
Forget password
Don't have an account?
Sign Up
Sign Up Now
×
Continue with Facebook
Continue with Google
I agree all the terms and conditions.
Sign Up
Already have an Account?
Log In


Welcome!
Shmetterling is where Spotify meets YouTube. Create your music video radio(!) station and enjoy watching it! It is a great tool for making your party unforgettable!
Shmetterling is where Spotify meets YouTube. Create your music video radio(!) station and enjoy watching it! It is a great tool for making your party unforgettable!


The much awaited "Designing the User Interface, 6th Edition is now available!
This is a new, revised edition of the highly successful textbook on Human Computer Interaction originally developed by Ben Shneiderman and Catherine Plaisant at the University of Maryland.
Part I: Introduction
Chapter 1: Usability of Interactive Systems
Chapter 2: Universal Usability
Chapter 3: Guidelines, Principles, and Theories
Part II: Design Processes
Chapter 4: Design
Chapter 5: Evaluation and the User Experience
Chapter 6: Design Case Studies
Part III: Interaction Styles
Chapter 7: Direct Manipulation and Immersive Environments
Chapter 8: Fluid Navigation
Chapter 9: Expressive Human and Command Languages
Chapter 10: Devices
Chapter 11: Communication and Collaboration
Part IV: Design Issues
Chapter 12: Advancing the User Experience (formerly Chapter 11)
Chapter 13: The Timely User Experience (formerly Chapter 10)
Chapter 14: Documentation and User Support (a.k.a Help)
Chapter 15: Information Search
Chapter 16: Data Visualization
Afterword: Societal and Individual Impact of User Interfaces
Afterword 1: Future Interfaces and Grand Challenges
Afterword 2 Ten Plagues of the Information Age
Authors: From left to right
As a Human-Computer Interaction University Associate Professor I was delighted with the new edition of Designing the User Interface: Strategies for Effective Human-Computer Interaction (5th Edition).
It was entirely renewed and fully updated.
I have shared this textbook with my HCI undergraduate and graduate HCI students this semester and they liked it a lot and found it touches well and thoroughly current HCI issues!
Ben Shneiderman and Catherine Plaisant present and discuss timely most key HCI theories, concepts, ideas and applications.
I strongly recommend this book for academic and professional HCI courses.
- Jaime Sánchez, HCI Professor at the University of Chile
The 5th edition thoroughly updates and improves this valuable resource for students, professionals, and researchers interested in human-computer interaction. The presentation's coherent depth and breadth clarify how the interface mediates our access to information, and the need to match its design to our cognitive and perceptual capabilities. I was especially pleased that my colleagues Shneiderman and Plaisant included a chapter on information visualization also providing a rich list of references on this and other related fields. They make a convincing case for development of new information visualization evaluation tools. The 5th symphony, I meant edition, made me better aware of how mobile devices are changing our world and of the increasing power of YouTube, flickr and other social media. This is a great book!
- Alfred Inselberg, Senior Fellow San Diego Supercomputing Center at the Department of Computer Science, Tel Aviv University


{% extends 'settings/base.html' %} {% load bootstrap3 %} {% block page_name %}Teller.io data import (beta){% endblock %} {% block page_description %}{% endblock %} {% block settings_form %}
Swiftwind can load you bank statement data in using the teller.io service. Once you setup an account you can enter the details below.
The teller token is the token teller providers you with once you signup. The account ID is the ID of your bank account as reported by their API. You will need to access their API in order to retrieve your account ID.
{{ block.super }} {% endblock %}


resume
blog
about
portfolio
My name is Anna Weddle, I am a designer specializing in
branding,
web,
and illustration
Illustration
Mural
Dope Sweater
Creative Crosswalks


{%- endif %}
{{ content }}
{% include nav.html -%}
{% include footer.html -%}
{%- comment -%}
Since it is the element that is scrolling, focus must be
moved from the overall document to the element for the
default spacebar scrolling to work. Obviously, Javascript must be
enabled for this to work since, sadly, there is no HTML/CSS way to
do it. It is a cosmetic level convenience so if it does not
enabled/work it is not fatal.
{%- endcomment %}


DEAR SIR. REQUEST FOR URGENT BUSINESS RELATIONSHIP First I must solicit your confidence in this transaction, this is by vitue of its’ nature as being very CONFIDENTIAL. I am a member of Board of Directors with UNION BANK OF NIGERIA PLC, LAGOS (UBN). I came to know of you in my private search for a reliable and reputable person to handle this confidential transaction, which involves the transfer of a huge sum of money to a foreign Bank Account requiring maximum confidence. THE PREPOSITION The late Engineer MARK JOHNSON a Foreigner and an oil merchant /contractor with the Federal Government of Nigeria until his death three years ago in a plane Nigeria Plc, Lagos and had a closing balance of usd 28,900,000.00 (Twnety -Eight Million Nine Hundred Thousand Dollars) The bank now unquestionably expect it to be claimed by Mark Johnson’s next of kin. Priceless efforts have been made by the Union BANK PLC to get in touch with any of the JOHNSON’S family but to no avail. It is becaue of the perceived possibility of not being unable to locate ENGR. MARK JOHNSON’S next of kin that the management under the influence of our chairman Board of Directors Major General Kalu Ike Kalu who has agreed that since the incident occured in 1997 and has left the fund dormant and devalued, we should transfer the fund overseas and ultilize it either on stock exchange or personal business interest. Your role is very important as the fund when concluded on tranfer would be justifiably presented as having been remited into the next of kin’s bank account. Your interest will be protected as unecessary documentation will be avoided and adequate percenta ge (%) sheduled for mutual benefit. 1. Account holder - 30% ( foreign partner) 2. Nigeria partner - 60% ( Nigeria partner) 3. 10% incidental expenses that might be incurred in the course of this transaction. You are required to contact me on my E-mail address to indicate your interest. All parties interest should be protected in terms of confidentiality. Note that all modalities necessary for this transfer of this fund have been perfected and the transaction is 100% risk free. Awaiting your prompt response. Regards, MARK AKPU.


public class HomeController
extends java.lang.Object
| Constructor and Description |
|---|
HomeController(App app,
Employee connectedEmployee) |
| Modifier and Type | Method and Description |
|---|---|
void |
displayReservations(Client currentClient)
This method creates a link between the reservations button in the clients submenu on the first tab and the reservations on the 2nd tab
|
void |
finish()
return to connection screen
|
ClientsController |
getClientsController() |
EmployeesController |
getEmployeesController() |
IncidentsController |
getIncidentsController() |
MapController |
getMapController() |
NotificationsController |
getNotificationsController() |
ProductController |
getProductController() |
ReservationsController |
getReservationsController() |
StatisticsController |
getStatiscticsController() |
SupplierController |
getSupplierController() |
javafx.scene.Scene |
getView() |
void |
OnWindowIsClosing() |
public javafx.scene.Scene getView()
public void displayReservations(Client currentClient)
currentClient
- is the client of who we want to see the reservationspublic void finish()
public NotificationsController getNotificationsController()
public StatisticsController getStatiscticsController()
public ClientsController getClientsController()
public IncidentsController getIncidentsController()
public MapController getMapController()
public EmployeesController getEmployeesController()
public SupplierController getSupplierController()
public ReservationsController getReservationsController()
public ProductController getProductController()
public void OnWindowIsClosing()