Themes

TinkerCell now uses "Themes" to categorize graphics object. Each Theme is defined by a set of Nodes, Arrows, and Decorators. Each theme rests in a folder. There are three themes as of today:

Fancy1, Bio1, Blocks1

These themes are located inside the Graphics folder. In TinkerCell Options->"Select Theme" is used to switch between themes. TinkerCell searches the home folder (i.e. Documents/TinkerCell) first, which means that users can make new Themes and place them in the home folder.

Here is how to make a new Theme:

1. Create a folder in the Documents/TinkerCell folder called "Graphics"

2. Inside Graphics, create a folder with any name. The folder name is the name of your theme

3. Make three folders inside your theme folder: Nodes, Arrows, Decorators (case sensitive, I think)

4. Use the NodeGraphics program to make nodes, arrows, and decorators xml and PNG files, and put those files in the appropriate folders. Note that the NodeGraphics program creates an xml file (the vector graphics) and a PNG file (used to draw buttons).

5. Make sure that the names are correct. Eg. the .xml and .PNG file for drawing "Protein" types should be names Protein.xml, and the arrow for EnzymeCatalysis reactions should be names EnzymeCatalysis.xml. The Decorators should also use process family names, e.g. EnzymeCatalysis. You may want to look at the existing TinkerCell/Graphics folder.

6. Once you are done with your Theme, create a drawing in TinkerCell using your theme. Take a screenshot and save the "screenshot.png" file in your Theme folder. The Options->"Select Theme" dialog will display this file.

More demo on modules

Modularity at work

New C/Python/Octave functions

tc_simulateODE

tc_simulateSSA

tc_scanSteadyState

tc_exportSBML

tc_screenshot

tc_screenWidth

tc_screenHeight

tc_savePlot

Name change in the C/Python/Octave API

Classes for embedding Python and Octave are now included inside the TinkerCellCore library.

Names of the base classes have changed to avoid confusion with the existing Octave classes. All data structures now have a tc_ prefix to avoid collisions. Here is the detailed documentation:

http://tinkercell.sourceforge.net/CAPI/index.html

All the function names available in the link above can be called from C, Python, or Octave.

Defining and creating new modules

The video shows how new modules can be defined and added. A "module" is an encapsulated biological process. So, in TinkerCell, this is treated like a "connection". The graphical representation will be modified to show something more than just a connection (not in this video).

How the autocompletion of reaction works

Each reaction is now defined by:

1. the family
2. the types, i.e. families, of nodes involved in the connection
3. the "role" of each node involved in the connection

ConnectionFamily::nodeFamilies and ConnectionFamily::nodeFunctions store this information (number 2 and 3 above)

For example, the family named "Enzyme Catalysis" would have:
participant families = Molecule, Molecule, Enzyme
participant roles = Reactant, Product, Catalyst

The roles MUST be unique. If there are multiple Reactants, the roles should define Reactant1, Reactant2, and so on.

The roles are used for:
1. Generating the stoichiometry (Stoichiometry and Rates plugin)
2. Identifying where to place the arrow-heads (Connection Insertion plugin)
3. Identifying how to merge components in a sub-model with the parent-model

The Connection Insertion inserts an arrow for any participant that has the role "Product" or "Target" (or contains those strings).
The Stoichiometry plugins assumes that any participant labeled "Reactant" will be consumed in the reaction and any participant labeled "Product" will be produced.

Abstract reactions with internal models

Big Plans Ahead...

1. TinkerCell will come with a folder full of modules, e.g. enzyme kinetics, gene regulation

2. Each reaction arc, such as a gene regulation arc, can be used to represent one of these modules. The interface will allow the user to double click on the gene regulation connector and load one of the modules to represent that process.

3. All modules will be encapsulated by default. Input/outputs will be represented using small input/output indicators on the items inside the module.

4. Users will be able to write Octave code for TinkerCell.

Big change to Core library

Qt has stopped supporting the drawItems(...) method that allowed multiple graphic v, each showing different items from the scene. As a result, I have adopted a different (possibly better) architecture:

A "NetworkHandle" class is used to represent a network.
Each NetworkHandle consists of one or more NetworkWindows, where each NetworkWindow can contain a scene or a text editor. So, a network is defined by using multiple scenes and/or text editors.