TinyButStrong Documentation

A TBS object is created as a new instance of the clsTinyButStrong class. A TBS object enables you to work with one or several templates using the object's methods and properties.

Syntax to create a new TBS object as of version 3.8.0: $TBS = new clsTinyButStrong({array Options})

Examples:

$TBS1 = new clsTinyButStrong;                                             // default behavior
$TBS2 = new clsTinyButStrong( array('chr_open'=>'{', 'chr_close'=>'}') ); // TBS tags will be like {var.x} instead of [var.x]
$TBS3 = new clsTinyButStrong( array('var_prefix'=>'tbs_fct_') );          // TBS will display only PHP global variables beginning with 'tbs_var_'
$TBS4 = new clsTinyButStrong( array('fct_prefix'=>'tbs_fct_') );          // TBS will call only PHP function beginning with 'tbs_fct_'

Versioning:
Before TBS version 3.8.0, the syntax to create a new TBS object was:
   $TBS = new clsTinyButStrong({string chr_delim {, string var_prefix {, string fct_prefix}}});
where:
- chr_delim is the concatenation of (the option chr_open + the string ',' + the option chr_close). For example: '{,}'
- var_prefix is the value for the option var_prefix
- fct_prefix is the value for the option fct_prefix

Loads a template for the merging process. The complete contents of the file is immediately stored in the Source property of the TBS object, then [onload] fields and blocks are merged. If the file is not found, then it will also be searched in the folder of the last loaded template (since TBS version 3.2.0).

Syntax: $TBS->LoadTemplate(string File{, string Charset})

Scope of the file path:

If the file is nout found then its' also searched into the directory of the last loaded template, or the last loaded subtemplate.
Since TBS version 3.3.0, the file also searched into the include_path.

Adding the file at the end of the current template:

You can use the keyword '+' for the argument Charset to have the file defined by File added to the end of the current template. The current charset will not be modified.

Special actions using argument File:

Since TBS version 3.4.0.
If File is null, then all default actions (Plug-ins, [onload] tags, and Charset) are applied without loading any file.
If File is '' (empty string), then only the charset option is modified, without doing any other action. (deprecated since TBS version 3.8.0, use SetOption() instead)
In both cases, if Charset is '+', then it will be ignored and the current charset will not be modified.

Example:

$TBS->Source = $template; // load the template from a string
$TBS->LoadTemplate(null,'BIG5'); //  run plug-ins if any, and merges [onload] tags if any
...
$TBS->LoadTemplate('',false); // turn the charset to no-charset

Merges one or several TBS blocks with records coming from a data source. By default, this method returns the number of merged records (more exactly, it is the number of the last record), but it can also return the full merged record set (see argument BlockName).

TinyButStrong supports several data source types in native:

You can also add a new one: 'database plug-ins'.

Syntax: int $TBS->MergeBlock(string BlockName, mixed Source{, string Query}{, mixed QryPrms})

Link between the block and the records:

Merging several blocks with the same data:

Returning the full merged record set:

Counting the records:

Resource and Request arguments according to the data source type:

Php data sources:

$TBS->MergeBlock('b1','num',12);
$TBS->MergeBlock('b2','num',array('min'=>20,'max'=>30));
$TBS->MergeBlock('b3','num',array('min'=>10,'max'=>20,'step'=>2));

$TBS->MergeBlock('block1','array','days[mon]');

 $TBS->MergeBlock('block1','array','days');

['key1']=>value1
['key2']=>value2
 ...

[0] => (['column1']=>value1-0 ; ['column2']=>value2-0 ; ...)
[1] => (['column1']=>value1-1 ; ['column2']=>value2-1 ; ...)
[2] => (['column1']=>value1-2 ; ['column2']=>value2-2 ; ...)
...

Terminates the merge.

Syntax: $TBS->Show({int Render})

The Show() method performs the following actions:

1. Merge [onshow] fields and blocks,
2. Merge [var] fields (for compatibility with version prior to 3.2.0),
3. Display the result (this action can be cancelled by Render property/argument),
4. End the script (this action can be cancelled by Render property/argument).

The Render property/argument allows to adjust the behavior of the Show() method. See the Render property for more information.

Returns the source of a TBS Block from the template. If no block is found, the method returns false.

Syntax: string $TBS->GetBlockSource(string BlockName {, boolean AsArray}{, boolean DefTags}{, mix ReplaceWith})

Replaces one or several TBS Fields with a fixed value or by calling a user function. Each TBS fields having the specified base name will be merged.

Since TBS version 3.0, it's also possible to indicate a method of a class (see OOP).

It is also possible to merge the special [onload], [onshow] and [var] (see below).

Syntax: $TBS->MergeField(string BaseName, mixed X {, boolean FunctionMode}{, array DefaultPrm})

Merging with a value:

X can be numeric, string, an array or an object. For an array or an object, names of TBS Fields must have suffixes like automatic fields ([onload] and [onshow]).

Example:

$TBS->MergeField('account',array('id'=>55,'name'=>'Bob'));

Merging with a user function:

TBS calls this function for each field found in the template.
This function must have the following syntax:

function fct_user($Subname [, $PrmLst]) {...}

When the function is called, its argument $Subname has for value the suffix of the field's name (example: for a field named 'ml.title', $Subname will have the value 'title'). And the optional argument $PrmLst contains an associative array with the field's parameters. The function must return the value to be merged.

Example:

$TBS->MergeField('ml','m_multilanguage',true);
...
function m_multilanguage($Subname) {
  global $lang_id; 
  $rs = mysql_query("SELECT text_$lang_id AS txt FROM t_language WHERE key='$Subname");
  $rec = mysql_fetch_array($rs);
  return $rec['txt'] ;
}

Merge automatic fields and blocks:

You can use the method MergeField() in order to force the merge of the automatic fields and blocks ([onload] and [onshow]). But in this case, only the first argument should be indicated.

Example: $TBS->MergeField('var');

Set one or several TBS options. See the list and desciptions of options below.
Some of the TBS options are a new way of setting old TBS features.

Versioning: methods SetOption() is supported since TBS version 3.8.0.

Syntax:

$TBS->SetOption(string $option_name, mixed $value)

Syntax for an array of options:

$TBS->SetOption(array $options)

Examples:

$TBS->SetOption('charset', false); // change the Charset option
$TBS->SetOption( array('chr_open'=>'{', 'chr_close'=>'}') ); // change several options

Syntaxes for options that are arrays:

Syntax 1: $TBS->SetOption(string $option_name, string $item, mixed $value)
Syntax 2: $TBS->SetOption(string $option_name, array $values)

Examples:

$TBS->SetOption('tpl_frms', 'curr', '0,000.0'); // add item 'curr' to the Template Formats
$TBS->SetOption('tpl_frms', 'curr', null); // delete item 'curr' from the Template Formats
$TBS->SetOption('tpl_frms', null); // delete all items from the Template Formats

$TBS->SetOption('include_path', 'tpl/english'); // add one path to the TBS include_path
$TBS->SetOption('include_path', 'tpl/english', null); // delete one path from the TBS include_path
$TBS->SetOption('include_path', null); // delete all pathes from the TBS include_path

Options

function f_StrToXml($Txt string,$ConvBr boolean) {
  // Convert a string into an XML text.
  $x = htmlspecialchars(utf8_encode($Txt));
  if ($ConvBr) {
    $x = nl2br($x); // Convert any type of line break
    $x = str_replace('<br />', '<text:line-break/>',$x);
  }
  return $x;
}

Compatibility with previous TBS versions:

Some TBS options are a new way of setting old TBS features.
The old features are still suported for compatibility, but they become deprecated. It is better to use the TBS options.

Return the value of a TBS option.

Syntax: mixed $TBS->GetOption(string $option_name)

For supported options names, see method SetOption().

Enables you to call a TBS plug-in's command, or to install a TBS plug-in.

Syntax: mixed $TBS->PlugIn(mixed arg1, mixed arg2, ...)

Remind: in order to have your TBS plug-in working, its PHP script must be included in your application before.

Example: include_once('tbs_plugin_xxx.php');
And aslo, every TBS plug-in should have a key as explained at Plug-ins.

Calling a plug-in's command:

Use the plug-in's key as the main argument. Next arguments are for the called plug-in's purpose.

Example:

$TBS->PlugIn(TBS_XXX, $arg1, arg2);    

Remark: when you call a plug-in's command for the first time this plug-in is automatically installed on the TBS instance ($TBS).

Installing a plug-in:

Although some plug-ins are automatically installed, it can be useful in some other cases to make a manual installation. For this, use the constant TBS_INSTALL with the plug-in's key.

Example:

$TBS->PlugIn(TBS_XXX, TBS_XXX);    

Remarks:

• A plug-in is installed relatively to a TBS instance (a variable $TBS for example). If you are using a second TBS instance (for example $TBS2) then you will also need to install the plug-in on this instance.
• A plug-in is installed automatically when you call one of its commands using the method PlugIn() (se above).

This property enables you to set the scope of variables availables for automatic fields ([onload], [onshow] and [var]).

By default, VarRef is a reference to the $GLOBALS PHP variable, which means all global PHP variables are available for automatic field.

Syntax: array $TBS->VarRef

Notes:

• Method ResetVarRef($ToGlobal) is a shorthand for reseting property VarRef to $GLOBALS or to an empty array.
• If property VarRef is changed by a sub-template, the change is available only for the sub-template.

Example for setting VarRef to global variables :

$TBS->VarRef = &$GLOBALS;

which is the same as:

$TBS->ResetVarRef(true);

Example for setting VarRef to a custome scope of variables:

$TBS->ResetVarRef(false); // VarRef is now a new empty array
$TBS->VarRef['x'] = 'This is value X';

Versioning: property VarRef is supported since TBS version 3.8. Before this version, the scope of automatic fields was PHP global variables.

Enables you to define information for a subsequent merging which can be automatic or manual.

Syntax: array $TBS->Assigned

Property Assigned is a PHP array defined by the user. Arguments for methods MergeBlock() and MergeField() can be saved there. Arguments have to be saved in a PHP array with numerical keys and ordered following the syntax of those methods. It is possible to use optional string keys in order to define specific behaviors:

Example of a manual merging:

$TBS->Assigned['b'] = array('b1,b2', &$cnt_id, 'SELECT id, name FROM table1');
... 
$TBS->MergeBlock('b'); // merge block b1 and b2 with the SQL query          

Example of an automatic merging:

$TBS->Assigned['b'] = array('b1,b2', &$cnt_id, 'SELECT id, name FROM table1', 'auto'=>'onload'); 

Example of merging fields:

$TBS->Assigned['f1'] = array('f1', $data, 'type'=>'mergefield');
... 
$TBS->MergeField('f1'); // merge field f1 witht the array $data

Notes:

• To merge an assigned block or field, you just have to call the corresponding method using only the name of the assigned key. You can add the argument Source = 'assigned', but this is optional because it is the default value. In other words, $TBS->MergeBlock('b') is equivalent to $TBS->MergeBlock('b', 'assigned').
• An assignment with 'auto'=>'onload' will be merged, of course, only if it is defined before calling the LoadTemplate() method.
• You can pass some arguments by reference for you assignments. This is particularly useful for PHP 4 which is passing object with a copy by default.

This property contains the source of the template currently merged. It is read/write. When TinyButStrong processes a merging (when using the MergeBlock() method for example), the Source property is modified immediately.

Syntax: string $TBS->Source

Notes:

• The LoadTemplate() method loads a file into the Source property and merges the [onload] tags automatically. Thus, Source may be different from the original template after LoadTemplate().
• The Show() method merges [onshow] tags automatically before to display the result.

In order to load a template stored into a Php variable, you can code:

$TBS->Source = $my_template;
$TBS->LoadTemplate(null); //  run plug-ins if any, and merges [onload] tags if any

In order to store the result at the end of the merging, you can code:

$TBS->Show(TBS_NOTHING); // terminate the merging without leaving the script nor to display the result
$result = $TBS->Source;

Contains the array of template variables corresponding to current template.

Syntax: array $TBS->TplVars

You can define template variables using one or several onload automatic fields with parameter tplvars. All parameters that follow parameter tplvars are added to the TplVars property when the LoadTemplate() method is called.

Remarks:

• Parameter tplvars works only with onload automatic fields.
• You can use parameter tplvars several times in the same template.

TinyButStrong integrate a technique to call methods or properties of objects that you've coded at the PHP side.

Calling methods of a class without created object:

Calling created objects:

A TBS field is a TBS tag which has to be replaced by a single data item. A TBS fields must have a name to identify it (which does not have to be unique) and can have parameters to modify the displayed value.

Syntax: TEMPLATE ... [FieldName{;param1}{;param2}{;param3}{...}] ... TEMPLATE

Field's parameters:

<html>
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
  <title>The main template</title>
  [onshow.store.default]
</head>
<body>
  Here is a component :
  <div>
    [onload;file=component1.htm;getpart=body;store=(script)+(style)]
  </div>
</body>
</html>

Order of processing parameters:

When you want to use several parameters in the same TBS field, then it can be interesting to understand in which order they are processed.
TBS changes the value to be merged, without changing the original value.

Order of processes:

1) -> Retreive the value of the field to be merged.
2) -> Change the value using parameters:
    2.1) -> onformat
    2.2) -> ope + plug-ins OnOperation
    2.3) -> frm or strconv or default char conversion
    2.4) -> if
    2.5) -> file
    2.6) -> script
    2.7) -> att
    2.8) -> . / ifempty / magnet
3) -> Insert the value in the template.

Automatic fields enable you to automatically merge PHP global variables when some events occur.

For example [onload.x] will be merged with the global variable $x when the LoadTemplate() method is called.

Automatic fields can only merge PHP variables when they are global. There is no way to merge a variable which is local to a function, unless you make a reference to it with a global variable, or if you merge it using MergeField().
Automatic fields can also merge TBS special information (see Special automatic fields), or data of the ObjectRef property (see Objet Oriented Programming).

There are three types of automatic fields:

• [onload] fields, which are automatically merged when the LoadTemplate() method is called.
• [onshow] fields, which are automatically merged when the Show() method is called.
• [var] fields, which are automatically merged when the field they are embedded in is also merged itself, but it works only if they are placed into a parameter file, script, if, then, else or when.

Versioning:
- Automatic fields [onload] and [onshow] are supported since TBS version 3.2.0. For compatibility with versions prior to 3.2.0, remaining [var] fields are still merged as if there were [onshow] fields but is it recommended to use real [onshow] fields instead.
- [var] are processed into parameter then and else since TBS version 2.02.

Automatic fields may or may not have a sub name, like x in [onload.x], [onshow.x] or [var.x]. An automatic field without sub name will be merged with an empty string value (''). Example: [onload;file=header.html] this field inserts a subtemplate when LoadTemplate() method is called.

An automatic field having a sub name will be merged with the corresponding global PHP variable.
If the global variable doesn't exist at this moment, then a TBS error is displayed, unless you add parameter noerr.

Examples:

You can also merge array's items, object's properties or object's methods using a dot (".") as separator. Resource variables are ignored.
For example (valid for both [onload], [onshow] and [var]):

Note: You can also force the merge of [var] fields or other types at anytime using the MergeField() method.

Embedded automatic fields

An embedded TBS field is never merged, unless :

• it is merged before the parent field,
• il is a [var] field placed into a paremeter file, script, if, then, else or when.

Examples:

[onload;if [onload.x]=1;then 'yes';else 'no']
This example will always display 'no', because the embedded [onload.x] fild will never be evaluated. It is better to use [onload;if [var.x]=1;then 'yes';else 'no'] instead, or better : [onload.x;if [val]=1;then 'yes';else 'no']

[b1.nom;block=tr;headergrp=[var.x]]
In this example, [var.x] will not be merged yet when you call $TBS->MergeBlock('b1',...)
The header will then be defined badly.
It needs one of those:
- using an onload field: [b1.name;block=tr;headergrp=[onload.x]]
- calling $TBS->MergeField('var') avant $TBS->MergeBlock('b1',...)
- using a customized field name: [b1.name;block=tr;headergrp=[zzz]] manually merged with $TBS->MergeField('zzz',$x)

Security: how to limit automatic fields usage in templates?

You can limit the automatic fields usage by defining a prefix for allowed PHP variables. For details, see create a new TBS object.

Prevent from processing automatic fields [onload] and [onshow]

Properties $TBS->OnLoad and $TBS->OnShow enable you to cancel the processing of [onload] and [onshow] fields. Those properties accept only true of false values. This can be very useful especially, but not only, for some TBS plug-ins. Note that [var] fields are automatically processed even if $TBS->OnShow = false.

Example:   $TBS->OnShow = false;
Properties OnLoad and OnShow are supported since TBS version 3.6.0.

A Special automatic field is a TBS automatic field which has a special name and can display special data provided by the template engine.
The special names can work only with automatic fields. That is [onload], [onshow] and [var].
The scpecial names always have a double dot before the key instead of one.

Example: Date of the day : [onshow..now;frm='mm-dd-yyyy']

Available keys for special automatic fields:

Versioning:
- special var fields cst and tbs_info are supported since TBS version 3.2.0.
- error_msg is supported since TBS version 3.5.0.
- php_info and store are supported since TBS version 3.8.0

A TBS block enables you define a zone and to display data from a record source. You can define a TBS block using one or two TBS tags (see below).

Merging with data:

Merging a block with data is done using the MergeBlock() method. When a TBS block is merged with data, it is repeated as many times as there are records; and the associated TBS fields are replaced by the value of the columns stored in the current record.
A TBS field associated to a block is identified by its name which should be made of the name of the block followed by the name of the column to display and separated by a dot.

Examples:

Since TBS version 3.5.0 column names with spaces are accepted.

Remark: when two separated blocks have the same name, then they will be considered has two sections of the same block. All content placed between those two sections of a block will be ignored and deleted during the merging. See sections of blocks to know more about sections.

Block syntaxes:

There are three possible syntaxes to define a TBS block:

Explicit Syntax:

Relative Syntax:

Simplified Syntax:

Which syntax to use?

Synopsis of a block tag:

Block's parameters:

Different blocks having the same name will be regarded as sections of the same block.

Sections can be used to:

• alternate the display (normal sections),
• display something if there is no data (NoData section),
• display a header each time the value of a column changes (grouping sections).

Normal sections:

When you define several normal sections, they will be used alternatively for each record.

NoData section:

The NoData section is a section displayed only if the data source has no records. There can be only one NoData section in a block. The NoData section is defined by adding the parameter nodata.

Example:

Grouping sections:

Grouping sections are displayed every time a column's value in the record-set changes. You can define header, footer, splitter or parent sections using parameters headergrp, footergrp, splittergrp, and parentgrp. See block's parameters for more details.

Example:

Conditional sections:

Conditional sections are displayed only if their condition is verified. The condition for display is defined using parameter when. As soon as a section has this parameter, it becomes conditional. See Conditional display for more details.

Example:

The serial display enables you to display several records inside a block. For this, you have to use a main block and secondary blocks.

Syntax:

The main block and its secondary blocks are merged using only one call to the MergeBock() method. The main block must be defined using the parameter serial. The secondary blocks must be nested into the main block. The secondary block's names must be the name of the main block followed by "_" and a number indicating display order.

Empty secondary block:

You can specify a special secondary block that will be used to replace unused secondary blocks (without records). This "Empty" secondary block must have the index 0. It can either be placed inside the main block with the normal secondary block, or alone inside another serial block. The "empty" secondary block is optional.

Remark: The serial display also works with sections of block and dynamic queries.

Automatic subblock are supported since TBS version 3.5.0.

You can use automatic subblocks when the data of the parent block has a column which contains the ready-to-merge subdata for the subblock. Set parameter sub1=column in the parent block to define the column which contain the data for the subblock. If you have several subblocks to merge in the same parent block then use parameters sub2, sub3, ... The name of the subblock must be the same as the parent block followed by the suffix _sub1, (or _sub2, _sub3, ...)

The data of the parent block must have a column which contains the data of the subblock. Supported data types are:

• a PHP array
• an object supported by TBS (natively or with a plug-in)
• a text string of values separated by comas (,).

Have the column optional:

If you want no error message when the column is omitted in the parent data, then you can set it optional by using parenthesis. This is working only if the parent data is a PHP array. Optional column is supported since TBS version 3.6.0.

Direct subblocks (which are not saved under a column):

If you use parameter sub1 by omitting the column name, then TBS will assume that the data for the subblock are available directly on the current record instead of under a column of this record. Direct subblocks are supported since TBS version 3.6.1.

Example of data that can be merged with a direct subblock:

$data = array();
$data['group1'] = array();
$data['group1'][] = array('id'=>1, 'name'=>'peter');
$data['group1'][] = array('id'=>2, 'name'=>'paul');
$data['group2'] = array();
$data['group2'][] = array('id'=>3, 'name'=>'jules');
$data['group2'][] = array('id'=>4, 'name'=>'jim');

Example of direct subblock that can be merged with those data:

Principles of the dynamic queries:

It is possible to use the MergeBlock() method with a dynamic query. In your template, you have to define a block by adding the parameters p1, p2, p3,... with their values. The query given to the MergeBlock() method has to contain marks such as %p1%, %p2%, %p3%, ... in order to welcome the values of the parameters p1, p2, p3,...

Each section of the block to be merged that contains a parameter p1 will be computed as a separate block for which the dynamic query is re-executed. The sections of the block that have no parameter p1 are combined with the previous section with a parameter p1.

Use with subblocks:

Dynamic queries enable you to easily build a system of a main-block with subblocks. Here is how you can do it:

1. Create a main block, and then a subblock inside the main block.
2. Link them by adding to the subblock a parameter p1 whose value is a field from the main block.
3. At the PHP side, merge the main block first, and then the subblock.

Remarks:

• The parameter strconv=esc enables you to pass protected string values to the query.
• The dynamic queries also work with sections of block and serial display.

Automatic blocks enable you to automatically merge conditional blocks when some events occur.

There are two types of automatic blocks:

• [onload] blocks which are merged automatically when the LoadTemplate() method is called.
• [onshow] blocks which are merged automatically when the Show() method is called.

Automatic blocks are not merged with data ; that's why they cannot have normal sections (non conditional sections) and linked fields. Automatic blocks can have only conditional sections. Conditions are evaluated only once, and they can be expressions containing [var] fields.

If you need to have a group of exclusive sections, with or without a default section, you can suffix the [onload] and [onshow] bloc's names with "_" followed by a sub name.

See Conditional sections for more details.

There are two ways to insert subtemplates in your main template.

Primary insertion using parameter file:

This is the best way to simply insert a part contained in another file, like usually done for headers and footers.

The value given to parameter file must be the name of a file existing on the server. You can use an expression with [var] Fields and the [val] keyword which represent the value of the field. If the value is an empty string, then no error message is displayed, it is like parameter file is ignored. This can be used to manage conditional insertion.

Examples:

[onload;file=header.htm]
[onload;file=[var.file_header]]
[onload.sub1;file=[val]]
[onload;file=[var.insert;if [val]=1;then 'header.html';else '']]

Contents of the file is inserted at the place of the field, without no char conversion and no TBS protection.
[onload] tags contained in the file are processed at the insertion. [onshow] tags will be merged on the Show() method because they became part of the main template.

The subtemplate can contain any TBS fields, including [var] fields and blocks to be merged. If you intend to merge data with a block defined into a subtemplate, then it's suggested to use parameter file in an [onload] field in order to ensure that the subtemplate is inserted before you call MergeBlock().

You can create a subtemplate in an independent XML/HTML/Text file, and ask TBS to include in the main template only the <body> part (or another part). This can be done by adding parameter getpart to parameter file in the TBS field of the main template. This technique enables you to work WYSIWYG with your subtemplates.

Insertion driven with Php code using parameter subtpl:

Parameter subtpl is useful to manage subtemplate insertion with Php code. Parameter subtpl is active only when used with a parameter script or onformat. It turns the current TBS instance in Subtemplate mode during the script or function execution and can act on a new template without deteriorating the main template.

The Subtemplate mode presents the following characteristics:

When the script or the function ends, the TBS instance returns in normal mode with the main TBS template.

Example with parameter script:

[onload.file;script=specialbox.php;subtpl]

<?php
  echo('* Here include a subtemplate *');
  $this->LoadTemplate($CurrVal);
  $this->MergeBlock('blk1',$GLOBALS['conn_id'],'SELECT * FROM table1');
  $this->Show(); 
?>

Example with parameter onformat:

[onload.user_mode;onformat=f_user_info;subtpl]

function f_user_info($FieldName,&$CurrVal,&$CurrPrm,&$TBS) {
  if ($CurrVal==1) { // User is logged in
    $TBS->LoadTemplate('user_info.htm');
    $TBS->MergeBlock('blk1',$GLOBALS['conn_id'],'SELECT * FROM table1');
    $TBS->Show();
  } else { // User not logged in
    echo('You are not logged in.');
  }
}

TinyButStrong offers several tools for conditional display for both fields and blocks.

Conditional fields

For any TBS fields you can use parameters for conditional display, recalled below.

Conditional sections

You can use conditional sections any TBS block (data block or automatic block). A conditional section is a section which has a parameter when defining a condition, or parameter default. At the block's merging, each when condition of conditional sections is evaluated until one is verified. As soon as one when condition is verified, its conditional section is kept and other conditional sections are deleted. If no when condition is verified, then the default section is displayed if it exists.

• The case of data blocks:

If it is a data block, it means a block merged with MergeBlock(), then the conditional sections are reassessed for each record. It is even possible to define a data block with only conditional sections, with no standard section.

• Defining the conditions:

The conditions defined into parameters when can be expressions that contain [var] fields et and linked fields (if it is a data block). See parameter when for more details about operators supported by TBS.

• Section exclusivity:

By default conditional sections are exclusive inside a block. It means only one conditional section of a block can be displayed. But if you want a block to have non-exclusive conditional sections, you can use parameter several on the first conditional section. With this parameter, all conditions are evaluated and each true condition makes its section to be displayed.

Example with a data block:

Example with an automatic block:

Extended methods are custom methods that you can add to a TinyButStrong instance. This can be usefull for a plug-in for example.

Versioning: Extended methods are supported since TBS version 3.8. The feature needs PHP 5.0 or higher.

Examples:

If you define:
$TBS->ExtendedMethods['newMethod1'] = array(&$myObject, 'myMethod');
then if you call:
$TBS->newMethod1($x);
it whill run :
$myObject->myMethod($x);

If you define:
$TBS->ExtendedMethods['newMethod2'] = 'myFunction';
then if you call:
$TBS->newMethod($x);
it whill run :
myFunction($x);

A block alias is a special name for a block definition, which will be replaced with another list of tags or which will call a custom function to find the block bounds.
Block alias really empower the way of defining blocks. It is useful for plug-ins or when you want to simplify the understanding of the template coder.

Versioning: Block alias are supported since TBS version 3.8.

Examples:

$TBS->SetOption('block_alias', 'row', 'tr'); // the alias replace one tag
$TBS->SetOption('block_alias', 'dblrow', 'tr+tr'); // the alias replace several tags
$TBS->SetOption('block_alias', 'my_alias', array($myObj, 'findBounds') ); // the alias call a custom function to find the bounds

Use in the template :

[blk1;block=row] or [blk1;block=row+row] or even [blk1;block=th+row]
[blk2;block=dblrow]
[blk3;block=my_alias]
  

Defining a block alias with a function:

Example :

class clsTest {
 /** 
  * Function findBound() will be call two times for finding the bounds of the block. Once with $Forward=true, and once with $Forward=false.
  * It is supposed to return the position of the inner bounds of the block. 
  * It can return false if an error occurs of if the template source is inconsistent for finding the block at the given position.
  *
  * @param string  $Tag The name of the block alias
  * @param string  $Txt The source of the template
  * @param integer $Pos The position of the TBS field in $Txt
  * @param boolean $Forward The direction of the search
  * @param integer $LevelStop 
  * @return integer
  */
	function findBound($Tag, $Txt, $Pos, $Forward, $LevelStop) {
		if ($Forward) {
			return strpos($Txt, '}', $Pos);
		} else {
			return strrpos(substr($Txt, 0, $Pos+1), '{');
		}
	}
}

Versioning: database plug-ins are supported since TBS version 1.8.

A database plug-in enables the method MergeBlock() to recognize a new type of database. When you have a call such as $TBS->MergeBlock($BlockName, $Source, $Query), the MergeBlock process is first examining $Source to see if its type is supported.

Database plug-in based un user functions:

When the MergeBlock process meet a type of value for $Source which is not supported in native, it determines the TBS Id corresponding to that type. Then it looks for the user functions corresponding to that TBS Id.

• How to determine the TBS Id:

The TBS Id is a string identifier determined by the argument $Source.
If $Source is a string => the TBS Id is that string.
If $Source is a PHP resource => the TBS Id is the name of the resource's type.
If $Source is an object => the TBS Id is the name of the class.
For some convenience, if the TBS Id contains spaces (' '), it is cut. If the TBS Id contains '-', they are replaced with '_'.
For example, a PHP variable for a Sybase connection is typed as Resource and its resource name is 'sybase-db link'. The corresponding TBS Id is 'sybase_db'.

• How to build the plug-in for a TBS Id:

The plug-in is made of 3 user functions which must have specific names. The following function names are made for a TBS Id which is 'tbsid'. For another TBS Id, you just have to rename the functions. You can found several examples of database plug-in at the TinyButStrong web site.

Synopsis:

function tbsdb_tbsid_open(&$Source, &$Query)

function tbsdb_tbsid_fetch(&$Rs [,$RecNum])

function tbsdb_tbsid_close(&$Rs)

Database plug-in based on object:

When the MergeBlock process meet of value for $Source which is an object, and if that object has a method named tbsdb_open(), then it assumes that the object is a database plug-in.
The object must have at least the 3 methods tbsdb_open(), tbsdb_fetch() and tbsdb_close(). There can be other methods and properties, but those 3 methods must have the same syntax and the same feature as the user functions described above.

Synopsis:

class clsTbsPlugin {
  function tbsdb_open(&$Source, &$Query)
  function tbsdb_fetch(&$Rs [,$RecNum])
  function tbsdb_close(&$Rs)
}

Database plug-in based on property ObjectRef:

When the MergeBlock process meet a value for $Source which is a string beginning with '~' then it assumes that property $TBS->ObjectRef is a database plug-in based on object (see OOP). The object must have the same requirements as a database plug-in based on objet described above, but the names of the methods can be different.

Example:

$TBS->MergeBlock($BlockName,'~dbkey',$Query);

class clsTbsPlugin {
  function dbkey_open(&$Source, &$Query)
  function dbkey_fetch(&$Rs [,$RecNum])
  function dbkey_close(&$Rs)
}    

Versioning: plug-ins are supported since TBS version 3.0.

Coding a plug-in using a PHP class:

• Plug-in's key:

Each plug-in has a plug-in key which is the name of its Php class. This key must be given to the method PlugIn() when you use it. Thus, it is recommended to define a PHP constant for the plug-in's key (see example below).

• Plug-in events:

A TBS plug-in must be a PHP class which contains one or several specific methods that will be recognized and plugged by TBS. Those specific methods are called plug-in events because they are executed automatically by TBS when the corresponding event occurs. A TBS plug-in can also have other methods and properties for internal purpose. A TBS plug-in must have at least the OnInstall event.

For example:

// TBS plug-in XXX 
define('TBS_XXX','clsTbsPlugIng_XXX'); // That is the plug-in's key 
class clsTbsPlugIng_XXX() {
  function OnInstall(...) {...} // That is the OnInstall event 
  ...
}

See the PHP file "tbs_plugin_syntaxes" to have all plug-in events, their usage and expected arguments. There is also a list of supported events at the bottom of this section.

The OnInstall event is special. It has to return an array with all activated events for the current plug-in (see the PHP file "tbs_plugin_syntaxes"). The OnInstall event is called when the plug-in is installed at the TBS instance.

This event can be called in three situations:

• When using method PlugIn() with the plug-in's key for the first time.
• When using method PlugIn() with the plug-in's key and the argument TBS_INSTALL.
• When a new TBS instance is created, if the plug-in's key has be added to the global array $_TBS_AutoInstallPlugIns[] (see file "tbs_plugin_syntaxes.php" for more details).

• Property ->TBS:

As soon as the plug-in is installed on the TBS instance, a property ->TBS is automatically added to the plug-in, its value is a reference to the parent TBS instance. Remember this because this property can be very useful inside the plug-in's code.

Coding a plug-in using PHP functions:

The plug-ins' key is a string that you choose and which will be used for naming the function. It is recommended to define a PHP constant for the plug-in's key (see example below).

The plug-in events are coded using functions, and they names must be the string 'tbspi_', followed by the plug-in's key, followed by '_' and the event's name.

Example:

define('TBS_XXX', 'xxx');
function tbspi_xxx_OnInstall(...) {...}
...

All the rest works like for plug-in coded with a class. You must have at least the event OnInstall created, and it works the same way.

Remark: PHP functions are often faster than methods, but they don't let you having a ->TBS property to reach the parent TBS instance.

• List of plug-in events: