DCA stands for Dynaflex Configuration Array. It's very similar to the TCA. If you understood the scheme of the TCA, understanding the DCA shouldn't be a problem. :-)

When I'm talking about paths, I always mean a path inside of an array. In most cases this will be inside the TCA, but it also can be inside a FlexForm data structure (which is also an array after all).

If you specify a path, you do it the same way as you'll do it on *NIX systems. Every key inside the array is like a folder in a file system. There is only one difference to a file system, the path doesn't start with a slash! For example, if you have the following array:

If you want to edit the field “subsub1value1” the path to this field will be:

TCA/element1/subelement1/sub1sub1field1

Before the dynaflex extension will do anything, you have to configure it (section “Configuration”) and than you have to instantiate and call it at the right position of the TYPO3 TCA processing.

Since version 1.7.0 this has be improved dramatically!

Since that version, DynaFlex implements all needed hooks by itself. This has various advantages. On the one hand, you don't have to register the hooks by your own. And the second one is, that through the way of implementation, you don't have to think about how DynaFlex has to be called. And last but not least, with version 1.7.0 I introduced hooks for config loading. That means, that you can alter the DCA of another extension by using a hook that is called while the configuration is loaded.

The old way of calling will work as usual of course, but it is highly recommend to use the new way of calling DynaFlex!!!

$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_befunc.php']['getFlexFormDSClass'][] = 'EXT:dynaflex_tut/class.tx_dynaflextut_befunc_hooks.php:tx_dynaflextut_befunc_hooks';

class tx_dynaflextut_befunc_hooks{

function getFlexFormDS_postProcessDS(&$dataStructArray, $conf, $row, $table, $fieldName){

global $counter;

$counter++;

if ($table == 'tx_dynaflextut_test'&&

t3lib_extMgm::isLoaded('dynaflex') &&

$counter <= 1

){

// Load the configuration from a file

require_once(t3lib_extMgm::extPath('dynaflex_tut') .'df_config.php');

// And start the dynaflex processing

require_once(t3lib_extMgm::extPath('dynaflex') .'class.dynaflex.php');

$dynaflex = t3lib_div::makeInstance('dynaflex');

// debug($GLOBALS['TCA']['tx_dynaflextut_test']);

$dynaflex->init($GLOBALS['TCA'], $GLOBALS['T3_VAR']['dynaflex']['dca']);

// process DCA and read dataStructArray from index 0

$GLOBALS['TCA'] = $dynaflex->getDynamicTCA();

$dataStructArray = $dynaflex->dataStructArray[0];

// at last cleanup the XML structure in the database

$dynaflex->doCleanup('flexdata');

}

}

}

$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_tceforms.php']['getMainFieldsClass'][] = 'EXT:dynaflex_tut/class.tx_dynaflextut_tceforms_hooks.php:tx_dynaflextut_tceforms_hooks';

function getMainFields_preProcess($table, $row, $pObj){

if ($table == 'tx_dynaflextut_test'&&

t3lib_extMgm::isLoaded('dynaflex')

){

// Load the configuration from a file

require_once(t3lib_extMgm::extPath('dynaflex_tut') .'df_config.php');

// And start the dynaflex processing

require_once(t3lib_extMgm::extPath('dynaflex') .'class.dynaflex.php');

$dynaflex = t3lib_div::makeInstance('dynaflex');

$dynaflex->init($GLOBALS['TCA'], $GLOBALS['T3_VAR']['dynaflex']['dca']);

$GLOBALS['TCA'] = $dynaflex->getDynamicTCA();

$dynaflex->doCleanup('flexdata');

}

}

The configuration of dynaflex is processed in the same order as it's keys! That means that you have to keep track of the keys you give your configurations. This is good to know, because you can reference to field you have dynamically created in a modfication step before. I know that sounds a little bit coated but believe me, it can be useful. :-)

In some cases you might register DynaFlex for general table like tt_content. This is the case if you want to modify the flexform of a frontend plugin. The problem is, that DynaFlex will execute the modification every time tt_content is loaded. This means for every content element!

Since version 1.9 you can define some restriction to make sure that DynaFlex will only start if the dataset we're working on accomplishes some rules. These rules or conditions can be defined in the configuration class in a variable called $rowChecks.

$rowChecks is an array of key value pairs where the keys are the fieldnames in the table we are working on and the values are the values the tablefield should have. If any of the tablefields does not have the value that is set in the $rowChecks array, the complete DCA won't be executed!

Here is an example. This checks if the CType of the tt_content element is 'list' (Insert Plugin) and that the selected plugin is 'dynaflex_tut_pi1':

var $rowChecks = array (

    'list_type' => 'dynaflex_tut_pi1',

    'CType' => 'list'

);

Since version 1.4.0 you can force a cleanup of your data in the database. The problem is, that the values of a flexform are stored in a XML structure which holds each field you have ever had in your flexform. That is not a problem if the flexforms are static. If you use DynaFlex, fields can disappear from a form and so the data in the database is holding data for a field that doesn't exist.

Since version 4.0 of TYPO there is a class called “flexformtools” which provides a method that removes all flexform fields from the datastructure that are not present in the TCA. In DynaFlex this method is used to provide a method that cleans up the database. This method also works for pre 4.0 version of TYPO3. DynaFlex ships with a copy of this flexformtools class.

All you have to do is, to call the method “doCleanup” after you have written back the TCA. The following code snippet shows this:

   1: $dynaflex->init($GLOBALS['TCA'], $dca);

   2: 

   3:     // write back the modified TCA

   4: $GLOBALS['TCA'] = $dynaflex->getDynamicTCA();

   5: 

   6: $dynaflex->doCleanup('flexdata');

The argument you pass to this method is the field of the content element that is used to store the data XML. In this case the field is called “flexdata”. This is also the field for which the flexform structure is defined in the TCA.

This is obsolete with version 1.7.0! The cleanup is done automatically by DynaFlex if you use the recommend way of calling it.

Since the new way of calling DynaFlex was introduced it's possible to register hooks that can alter the DCA of other extensions. The only condition is, that the author of the orginal extension has used the new way. If he has not, the hooks are normally not available.

The way of registering a hook is the same as you might know it from TYPO3 itself. Only the location is a different one. If you take a look at the section before (Where to instanciate – the recommend way) you'll find an example config class for DynaFlex. There you can see that the hooks are registered inside that config classes in the variable $hooks. Just enter the path to your hook class in such a config class as new array element and register the class for the targeted table.

Now everytime time, DynaFlex is processing this table, it will load the regsitered DCA and will look for all hooks that might be registered for it.

Keep in mind that it makes in which order the extensions are installed. The extension that provides the orginal DCA has to be installed before any extension that provides altering hooks!!!

Inside the hook class you have to define a methd called alterDCA_onLoad. This method will receive two arguments. The first one is the DCA with all modifications at the time the hook is called. This variable is called by reference! So you your method don't have to return anything. Just change the DCA.

The second parameter is the name of the table we are working on. This is not really needed because you should know for which table you have regsitered your hook but it makes it easier to change the tablename later on if you use it in the alter method. An example hook could look like this:

function alterDCA_onLoad($currentDCA, $table){

// store the last modification (the move)

$lastIndex = count($currentDCA[0]['modifications']) -1;

$lastModification = $currentDCA[0]['modifications'][$lastIndex];

// write the new one

$currentDCA[0]['modifications'][$lastIndex] = array (

'method' => 'add',

'path' => 'ROOT/el',

'type' => 'field',

'field_config' => array (

'name' => 'df_field_fromHook',

'label' => 'A field from a hook',

'config' => array (

'type' => 'input'

)

)

);

// and append the former last one at the end again

$currentDCA[0]['modifications'][] = $lastModification;

}