Prototypes

PROTOTYPES

Prototypes let you specify the default value for an entire class of notes. You specify one note as the prototype and tell Tinderbox to use the prototype for the other notes of that type. Then, whenever Tinderbox checks an attribute that you haven't specifically set, it will use the value from the prototype. Change an attribute in a prototype and you change it for the notes that use that prototype. A note inherits all attributes from its prototype except Created, Modified, Height, Width, XPos, and YPos.

Prototypes are an advanced feature -- you may not need to use them -- but they're powerful time-savers for complex projects.

To create a prototype,

• create a new note, however is convenient, or select and existing note to serve as a prototype
• in the dialog box to name the note, check the box can be a prototype

This new note can now be a prototype for other notes.

In outline view the note icon for notes which can serve as prototypes is surrounded by a light green circle.

To use a prototype,

• create a new note, or select a note and press Enter
• choose a prototype from the Prototype popup menu in the sidebar. This menu shows the names of all notes that have been designated "can be a prototype."

or

• select the note in the map view. A tab appears beneath the note showing the note's prototype, if any. Right-click the prototype tab to select a new prototype from the popup menu

or

• select the note in the outline view, and right-click on the rectangular note icon to select a new prototype from the popup menu.

Your note will now use the selected prototype: it will inherit the values for most of its attributes from the prototype note. When you change the value of any of those attributes in the prototype, the value of that attribute in all of the notes that use that prototype will change as well.

How Prototype Inheritance Works

Tinderbox notes inherit from their prototype; when you give a note a prototype, you’re telling Tinderbox, "this note is just like its prototype, except for the differences I tell you about."

Whenever Tinderbox looks up the value of an attribute, it reviews the following checklist:

• If the note has a value for that attribute, that’s the value.

Otherwise,

• If the note has a prototype, and if the prototype has a value, then we inherit the prototype’s value.

Otherwise,

• If the prototype itself has a prototype, we inherit that value.

Otherwise,

• We use the default value for that attribute.

Notice that a note’s own values always override inheritance. Suppose that PrototypicalTask is gray. We create a new note called TodaysMeeting that inherits from PrototypicalTask. Initially, TodaysMeeting inherits everything from its prototype, so it’s gray, too. But if we set the Color of TodaysMeeting to blue, it turns blue. Other tasks remain gray.

Now, we make yet another note, ConferenceCall, which also inherits from PrototypicalTask. It, too, is gray, because PrototypicalTask is gray. But perhaps we’d like all tasks to be green; we change the Color of PrototypicalTask to green. Now, ConferenceCall turns green, because it inherits its Color from the prototype. TodaysMeeting remains blue, because you gave it a specific color; a note’s own values always take precedence over inheritance.

Any Note can be a prototype

Any note can serve as a prototype for other notes. You don’t need to define prototypes in advance, and you should feel free to create new prototypes as your needs change.

Prototypes save typing. As you take notes, you may find that you sometimes repeat yourself, setting up a series of similar notes that describe similar sorts of things — people, or references, or issues you want to discuss with your staff. Prototypes can help you capture the common elements, making it easier and more pleasant to create notes.

A note can only have one prototype, but each prototype can be used by many different notes.

Prototype inheritance in Tinderbox is extremely efficient; don’t worry about memory or performance when using prototypes.

Prototypes and Children

If a prototype is a container, then notes that use the prototype will "inherit" copies of the prototype’s children. For example, if PrototypeArticle contains separate notes for AuthorInformation and Text, then making a note into an instance of PrototypeArticle will create new notes inside the article to hold the author information and the text of the article.

Note that these “inherited” notes are created at the time the prototype is assigned; adding or removing children to the prototype at some later time will not affect notes that already use the prototype.

Inheritance of prototype notes is controlled by the attribute, PrototypeBequeathsChildren. By setting this attribute to false for a specific prototype, passing of children to new instances of the prototype may be disabled. By setting the default value of PrototypeBequeathsChildren to false, the feature may be disabled throughout the document (unless specifically overridden by a prototype that wants to use it).