Dataface/Record.php

Go to the documentation of this file.

<?php
/*-------------------------------------------------------------------------------
 * Xataface Web Application Framework
 * Copyright (C) 2005-2008 Web Lite Solutions Corp (shannah@sfu.ca)
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *-------------------------------------------------------------------------------
 */
 

import( 'Dataface/Table.php');
import( 'Dataface/RelatedRecord.php');
import('Dataface/LinkTool.php');


define('DATAFACE_RECORD_RELATED_RECORD_BLOCKSIZE', 30);


class Dataface_Record {

        var $secureDisplay = true;


        var $_id;
        
        static function _nextId(){
                static $id = 0;
                return $id++;
        }

        var $_parentRecord;
        
        
        var $propertyChangeListeners=array();
        
        var $_values;
        
        
        var $_table;
        
        
        var $_tablename;
        
        
        var $_relatedValues = array();
        
        var $_relatedValuesLoaded = array();
        
        var $_numRelatedRecords = array();
        var $_lastRelatedRecordStart = 0;
        
        var $_lastRelatedRecordLimit = 30;
        
        var $_relationshipRanges;
        
        
        var $_title;
        
        
        var $_oldValues;
        
        var $_transientValues=array();
        
        
        var $useMetaData = true;
        
        
        var $_dirtyFlags = array();
        
        var $_relatedDirtyFlags = array();
        
        var $_isLoaded = array();
        
        var $_metaDataValues=array();
        
        
        var $loadBlobs = false;
        
        var $_relatedMetaValues=array();
        
        
        var $_delegate = null;
        
        var $cache=array();
        
        var $vetoSecurity = false;
        
        var $vetoFields = array();
        
        
        var $pouch = array();
        
        
        var $lang = null;
        
        //--------------------------------------------------------------------------------
        // @{
        function Dataface_Record($tablename, $values=null){
                $app =& Dataface_Application::getInstance();
                $this->_id = Dataface_Record::_nextId();
                $this->_tablename = $tablename;
                $this->_table =& Dataface_Table::loadTable($tablename);
                $this->_delegate =& $this->_table->getDelegate();
                $this->lang = $app->_conf['lang'];
                
                if ( $values !== null ){
                        foreach ($values as $k=>$v){
                                $this->setValue($k, $v);
                        }
                        //$this->setValues($values);
                        $this->setSnapshot();
                }
        }
        
        // @}
        // END Initialization 
        //---------------------------------------------------------------------------------
        
        function __destruct(){
                unset($this->propertyChangeListeners);
                unset($this->cache);
                unset($this->pouch);
                unset($this->vetoFields);
                unset($this->_delegate);
                unset($this->_metaDataValues);
                unset($this->_transientValues);
                unset($this->_oldValues);
        
                if ( isset($this->_parentRecord) ){
                        $this->_parentRecord->__destruct();
                        unset($this->_parentRecord);
                }
                
                
        }
        
        //------------------------------------------------------------------------------------
        // @{
        function callDelegateFunction($function, $fallback=null){
                $del =& $this->_table->getDelegate();
                $parent =& $this->getParentRecord();
                if ( isset($del) && method_exists($del, $function) ){
                        return $del->$function($this);
                        //return call_user_func(array(&$del, $function), $this);
                } else if ( isset($parent) ){
                
                        return $parent->callDelegateFunction($function, $fallback);
                } else {
                        return $fallback;
                }
        
        }
        
        

        
        
        function getActions($params=array()){
                $params['record'] =& $this;
                $actions = $this->_table->getActions($params);
                
                $parent =& $this->getParentRecord();
                if ( isset($parent) ){
                        $actions = array_merge_recursive_unique($parent->getActions($params), $actions);
                }
                return $actions;
        }
        
        
        function &table(){
                return $this->_table;
        }
        
        
        function clearCache(){
                
                unset($this->cache);
                
                $this->cache=array();
                
                $this->_relatedValuesLoaded = array();
                
                $this->_relatedValues = array();
                $this->_relatedMetaValues = array();
                
                
        }
        
        
        
        
                
        function parseString( $str){
                if ( !is_string($str) ) return $str;
                $matches = array();
                $blackString = $str;
                while ( preg_match( '/(?<!\\\)\$([0-9a-zA-Z\._\-]+)/', $blackString, $matches ) ){
                        if ( $this->_table->hasField($matches[1]) ){
                                $replacement = $this->strval($matches[1]);
                                
                                
                        } else {
                                $replacement = $matches[1];
                        }
                        $str = preg_replace( '/(?<!\\\)\$'.$matches[1].'/', $replacement, $str);
                        $blackString = preg_replace( '/(?<!\\\)\$'.$matches[1].'/', "", $blackString);
                        
                }
                return $str;
        }
        
        // @}
        // END Utility Methods
        //-------------------------------------------------------------------------------
        
        
        //---------------------------------------------------------------------------------
        //{@
        
        function getRelationshipRange($relationshipName){
                if ( isset( $this->_relationshipRanges[$relationshipName] ) ){
                        return $this->_relationshipRanges[$relationshipName];
                } else {
                        return $this->_table->getRelationshipRange($relationshipName);
                }
        }
        
        function setRelationshipRange($relationshipName, $lower, $upper){
                if ( !isset( $this->_relationshipRanges ) ) $this->_relationshipRanges = array();
                $this->_relationshipRanges[$relationshipName] = array($lower, $upper);
                
        }

        
        
        
        
        
        
        
        function _relatedRecordLoaded($relname, $index, $where=0, $sort=0){
        
                $blockNumber = floor($index / DATAFACE_RECORD_RELATED_RECORD_BLOCKSIZE);
                return ( isset( $this->_relatedValuesLoaded[$relname][$where][$sort][$blockNumber] ) and $this->_relatedValuesLoaded[$relname][$where][$sort][$blockNumber] );
        }
        
        
        function _translateRangeToBlocks($lower, $upper){
        
                $lowerBlock = floor($lower / DATAFACE_RECORD_RELATED_RECORD_BLOCKSIZE);
                $upperBlock = floor($upper / DATAFACE_RECORD_RELATED_RECORD_BLOCKSIZE);
                return array(intval($lowerBlock), intval($upperBlock));
        }
        
        function _relatedRecordBlockLoaded($relname, $block, $where=0, $sort=0){
                return ( isset( $this->_relatedValuesLoaded[$relname][$where][$sort][$block] ) and $this->_relatedValuesLoaded[$relname][$where][$sort][$block] );
        }
        
        function _loadRelatedRecordBlock($relname, $block, $where=0, $sort=0){
                if ( $this->_relatedRecordBlockLoaded($relname, $block, $where, $sort) ) return true;

                $relationship =& $this->_table->getRelationship($relname);
                if ( !is_object($relationship) ){
                        throw new Exception(
                                df_translate(
                                        'scripts.Dataface.Record._loadRelatedRecordBlock.ERROR_GETTING_RELATIONSHIP',
                                        "Error getting relationship '$relname'.  The value returned by getRelationship() was '$relationship'.",
                                        array('relationship'=>$relname, 'retval'=>$relationship)
                                        ), E_USER_ERROR);
                }
                
                $start = $block * DATAFACE_RECORD_RELATED_RECORD_BLOCKSIZE;
                $limit = DATAFACE_RECORD_RELATED_RECORD_BLOCKSIZE;
                
                if ( $start >= $this->numRelatedRecords($relname, $where) ){


                        return false;
                }
                
                //$sql = $this->parseString($relationship->_schema['sql']);
                $sql = $this->parseString($relationship->getSQL($this->loadBlobs, $where, $sort));

                // TODO We need to change this so that it is compatible with relationships that already specify a limit.
                $sql .= " LIMIT ".addslashes($start).",".addslashes($limit);
                

                //$res = mysql_query($sql, $this->_table->db);
                $db =& Dataface_DB::getInstance();
                $res = $db->query($sql, $this->_table->db, null, true);
                if ( !$res and !is_array($res) ){
                        
                        throw new Exception( mysql_error($this->_table->db).
                                df_translate(
                                        'scripts.Dataface.Record._loadRelatedRecordBlock.ERROR_LOADING_RELATED_RECORDS',
                                        "Error loading related records for relationship '$relname' in table '".$this->_table->tablename."'.  There was a problem performing the sql query '$sql'. The Mysql error returned was '".mysql_error($this->_table->db),
                                        array('relationship'=>$relname,'table'=>$this->_table->tablename, 'mysql_error'=>mysql_error($this->_table->db), 'sql'=>$sql)
                                        )
                                ,E_USER_ERROR);
                }
                $index = $start;
                //while ( $row = mysql_fetch_assoc($res) ){
                foreach ($res as $row){
                        $record_row = array();
                        $meta_row = array();
                        foreach ($row as $key=>$value){
                                
                                if (  strpos($key, '__') === 0  ){
                                        $meta_row[$key] = $value;
                                } else {
                                        $record_row[$key] = $this->_table->parse($relname.'.'.$key, $value);
                                }
                                unset($value);
                        }
                        $this->_relatedValues[$relname][$where][$sort][$index++] =& $record_row;
                        $this->_relatedMetaValues[$relname][$where][$sort][$index-1] =& $meta_row;
                        unset($record_row);
                        unset($meta_row);
                        
                }

                $this->_relatedValuesLoaded[$relname][$where][$sort][$block] = true;
                
                return true;
        }
        
        
        function numRelatedRecords($relname, $where=0){
        
                if ( !isset( $this->_numRelatedRecords[$relname][$where]) ){
                        $relationship =& $this->_table->getRelationship($relname);
                        
                        //if ( $where !== 0 ){
                                $sql = $this->parseString($relationship->getSQL($this->loadBlobs, $where));
                        //} else {
                        //      $sql = $this->parseString($relationship->_schema['sql']);
                        //}
                        $sql = stristr($sql, ' FROM ');
                        $sql = "SELECT COUNT(*) as num".$sql;
                        //$dbObj = 
                        //$res = mysql_query($sql, $this->_table->db);
                        //$res = mysql_query($sql, $this->_table->db);
                        $db =& Dataface_DB::getInstance();
                        $res = $db->query($sql, $this->_table->db, null, true);
                        if ( !$res and !is_array($res) ){
                        //if ( !$res ){
                                throw new Exception(
                                        df_translate(
                                                'scripts.Dataface.Record.numRelatedRecords.ERROR_CALCULATING_NUM_RELATED_RECORDS',
                                                "Error calculating the number of related records there are for the relationship '$relname' in the table '".$this->_table->tablename."'.  There was a problem performing the sql query '$sql'.  The MYSQL error returned was '".mysql_error($this->_table->db)."'.\n<br>",
                                                array('relationship'=>$relname,'table'=>$this->_table->tablename,'mysql_error'=>mysql_error($this->_table->db),'sql'=>$sql)
                                                ), E_USER_ERROR);
                        }
                        
                        $this->_numRelatedRecords[$relname][$where] = $res[0]['num'];
                }
                return $this->_numRelatedRecords[$relname][$where];
                
        }
        
        function &getRelatedRecords( $relname, $multipleRows=true , $start = null, $limit=null, $where=0, $sort=0){
                if ( !is_bool($multipleRows) and intval($multipleRows) > 0  ){
                        /*
                         * Give caller the option of omitting the "MultipleRows" option.
                         */
                        $sort = $where;
                        $where = $limit;
                        $limit = $start;
                        $start = $multipleRows;
                        $multipleRows = true;
                } else if ( $multipleRows === 'all'){
                        // the second argument is the 'all' specifier - meaning that all records should be returned.
                        $where = ($start === null ? 0:$start);
                        $sort = $limit;
                        $start = 0;
                        $limit = $this->numRelatedRecords($relname, $where) + 1;
                        $multipleRows = true;

                
                
                } else if ( is_string($multipleRows) and intval($multipleRows) === 0 and $multipleRows !== "0"){

                        if ( is_string($start) and intval($start) === 0 and $start !== "0" ){
                                // $start actually contains the sort parameter
                                $sort = $start;
                                $start = $limit;
                                $limit = $where;
                        } else {
                                $sort = $where;
                        
                        }
                        $where = $multipleRows;
                        $multipleRows = 'all';
                        return $this->getRelatedRecords($relname, $multipleRows, $where, $sort);
                }
                        
                
                if ( $where === null ) $where = 0;
                if ( $sort === null ) $sort = 0;
                list($defaultStart, $defaultEnd) = $this->getRelationshipRange($relname);
                if ( $start === null){
                        //$start = $this->_lastRelatedRecordStart;
                        $start = $defaultStart;
                } else {
                        $this->_lastRelatedRecordStart = $start;
                }
                
                if ( $limit === null ){
                        //$limit = $this->_lastRelatedRecordLimit;
                        $limit = $defaultEnd-$defaultStart;
                } else {
                        $this->_lastRelatedRecordLimit = $limit;
                }
                
                
                $range = $this->_translateRangeToBlocks($start,$start+$limit-1);
                if ( $where === null ) $where = 0;
                if ( $sort === null ) $sort = 0;
                if ( !$sort ){
                        $relationship =& $this->_table->getRelationship($relname);
                        $order_column = $relationship->getOrderColumn();
                        if ( !PEAR::isError($order_column) and $order_column){
                                $sort = $order_column;
                        }
                }
                // [0]->startblock as int , [1]->endblock as int
                for ( $i=$range[0]; $i<=$range[1]; $i++){
                        $res = $this->_loadRelatedRecordBlock($relname, $i, $where, $sort);
                        
                        // If the above returned false, that means that we have reached the end of the result set.
                        if (!$res ) break;
                }
                
                
                if ( $multipleRows === true ){
                
                
                        $out = array();
                        for ( $i=$start; $i<$start+$limit; $i++){
                                if ( !isset( $this->_relatedValues[$relname][$where][$sort][$i] ) ) continue;
                                $out[$i] =& $this->_relatedValues[$relname][$where][$sort][$i];
                        }
                        //return $this->_relatedValues[$relname][$where][$sort];
                        return $out;
                } else if (is_array($multipleRows) ){
                        throw new Exception("Unsupported feature: using array query for multiple rows in getRelatedRecords", E_USER_ERROR);
                        // we are searching using a query
                        foreach ( array_keys($this->_relatedValues[$relname][$where][$sort]) as $rowIndex ){
                                $row =& $this->_relatedValues[$relname][$where][$sort][$rowIndex];
                                $match = true;
                                foreach ( $multipleRows as $key=>$value ){
                                        if ( strpos($key,'.')!== false ){
                                                // if the query specifies an absolute path, just parse it
                                                list($dummy, $key) = explode('.', $key);
                                                if ( trim($dummy) != trim($relname) ){
                                                        // make sure that this query is for this relationship
                                                        continue;
                                                }
                                        }
                                        $fullpath = $relname.'.'.$key;
                                        $nvalue = $this->_table->normalize($fullpath, $value);
                                        if ( $nvalue != $this->_table->normalize($fullpath, $rowIndex) ){
                                                // see if this column matches
                                                $match = false;
                                        }
                                }
                                if ( $match ) return $row;
                                unset($row);
                        }
                        
                
                } else {
                        if (count($this->_relatedValues[$relname][$where][$sort])>0){
                                if ( is_int( $start ) ){
                                        return $this->_relatedValues[$relname][$where][$sort][$start];
                                } else {
                                        return reset($this->_relatedValues[$relname][$where][$sort]);
                                }
                                //$first =& array_shift($this->_relatedValues[$relname]);
                                //array_unshift($this->_relatedValues[$relname], $first);
                                //return $first;
                        } else {
                                return null;
                        }
                }
                                
        }
        
        function getChildren($start=null, $limit=null){
                $delegate =& $this->_table->getDelegate();
                if ( isset($delegate) and method_exists($delegate, 'getChildren')){
                        $children =& $delegate->getChildren($this);
                        return $children;
                } else if ( ( $rel =& $this->_table->getChildrenRelationship() ) !== null ){
                        $it = $this->getRelationshipIterator($rel->getName(), $start, $limit);
                        $out = array();
                        while ( $it->hasNext() ){
                                $child = $it->next();
                                $out[] = $child->toRecord();
                        }
                        return $out;
                } else {
                        
                        return null;
                }
        }
        
        
        function getChild($index){
                $children =& $this->getChildren($index,1);
                if ( !isset($children) || count($children) == 0 ) return null;
                return $children[0];
        }
        
        function &getParent(){
                $delegate =& $this->_table->getDelegate();
                if ( isset($delegate) and method_exists($delegate, 'getParent')){
                        $parent =  $delegate->getParent($this);
                        return $parent;
                } else if ( ( $rel =& $this->_table->getParentRelationship() ) !== null ){
                        $it = $this->getRelationshipIterator($rel->getName());
                        
                        if ( $it->hasNext() ){
                                $parent = $it->next();
                                $out = $parent->toRecord();
                                return $out;
                        }
                        return null;
                } else {
                        return null;
                }
        }
        
        
        
        
        
        
        function getRelationshipIterator($relationshipName, $start=null, $limit=null,$where=0, $sort=0){
                if ( !$sort ){
                        $relationship =& $this->_table->getRelationship($relationshipName);
                        $order_column = $relationship->getOrderColumn();
                        if ( !PEAR::isError($order_column) and $order_column){
                                $sort = $order_column;
                        }
                }
                return new Dataface_RelationshipIterator($this, $relationshipName, $start, $limit, $where, $sort);
        }
        
        function &getRelatedRecordObjects($relationshipName, $start=null, $end=null,$where=0, $sort=0){
                $out = array();
                        
                $it = $this->getRelationshipIterator($relationshipName, $start, $end,$where,$sort);
                while ($it->hasNext() ){
                        $out[] =& $it->next();
                }
                return $out;
        }
        
        
        function &getRelatedRecord($relationshipName, $index=0, $where=0, $sort=0){
                if ( isset($this->cache[__FUNCTION__][$relationshipName][$index][$where][$sort]) ){
                        return $this->cache[__FUNCTION__][$relationshipName][$index][$where][$sort];
                }
                $it = $this->getRelationshipIterator($relationshipName, $index, 1, $where, $sort);
                if ( $it->hasNext() ){
                        $rec =& $it->next();
                        $this->cache[__FUNCTION__][$relationshipName][$index][$where][$sort] =& $rec;
                        return $rec;
                } else {
                        $null = null;   // stupid hack because literal 'null' can't be returned by ref.
                        return $null;
                }
        }
        
        
        
        
        function moveUp($relationship, $index){
                
                $r =& $this->_table->getRelationship($relationship);
                $order_col = $r->getOrderColumn();
                if ( PEAR::isError($order_col) ) return $order_col;
                $order_table =& $r->getTable($order_col);
                if ( PEAR::isError($order_table) ) return $order_table;
                
                if ( $index == 0 ) return PEAR::raiseError("Cannot move up index 0");
                $it =& $this->getRelationshipIterator($relationship, $index-1, 2);
                if ( PEAR::isError($it) ) return $it;
                if ( $it->hasNext() ){
                        $prev_record =& $it->next();
                        if ( $it->hasNext() ){
                                $curr_record =& $it->next();
                        }
                }
                
                if ( !isset($prev_record) || !isset($curr_record) ){
                        return PEAR::raiseError('Attempt to move record up in "'.$relationship.'" but the index "'.$index.'" did not exist.');
                }
                
                if ( intval($prev_record->val($order_col)) == intval($curr_record->val($order_col)) ){
                        // The relationship's records are not ordered yet (consecutive records should have distinct order values.
                        $res = $this->sortRelationship($relationship);
                        if ( PEAR::isError($res) ) return $res;
                        return $this->moveUp($relationship, $index);
                }
                
                
                $prev = $prev_record->toRecord($order_table->tablename);
                $curr = $curr_record->toRecord($order_table->tablename);
                $temp = $prev->val($order_col);
                $res = $prev->setValue($order_col, $curr->val($order_col));
                if (PEAR::isError($res) ) return $res;
                $res = $prev->save();
                if ( PEAR::isError($res) ) return $res;
                $res = $curr->setValue($order_col, $temp);
                if ( PEAR::isError($res) ) return $res;
                $res = $curr->save();
                if ( PEAR::isError($res) ) return $res;
                
                return true;
                
                
        }
        
        function moveDown($relationship, $index){
                return $this->moveUp($relationship, $index+1);
        }
        
        
        
        function sortRelationship($relationship, $start=null, $subset=null){
                $r =& $this->_table->getRelationship($relationship);
                $order_col = $r->getOrderColumn();
                if ( PEAR::isError($order_col) ) return $order_col;
                $order_table =& $r->getTable($order_col);
                if ( PEAR::isError($order_table) ) return $order_table;
                
                // Our strategy for sorting only a subset.
                // Let R be the list of records in the relationship ordered
                // using the default order.
                //
                // Let A be the list of records in our subset of R using the 
                // default order.
                // 
                // Let b = A[0]
                // Let a be the predecessor of b.
                // Let c be the last record in A.
                // Let d be the successor of c.
                // Let B = A union {a,d}
                // For any record x in R, let ord(x) be the value of the order column
                // in x.
                //
                //
                //  The algorithm we will use to sort our subset is as follows:
                //      if ( !exists(a) or ord(a) < ord(b) )
                //              and 
                //      ( !exists(d) or ord(c) < ord(d) )
                //              and
                //      ( ord(c) - ord(b) >= count(A) ){
                //              sort(A)
                //  } else {
                //              sort(R)
                //      }
                
                
                if ( isset($start) ){
                        // We are dealing with a subset, so let's go through our algorithm
                        // to see if we can get away with only sorting the subset
                        //$countR = $this->numRelatedRecords($relationship);
                        $aExists = ($start > 0);
                        $countA = count($subset);
                        $B =& $this->getRelatedRecordObjects($relationship, max($start-1,0), $countA+2);
                        $countB = count($B);
                
                        
                        if ( $aExists ){
                                $dExists = ( $countB-$countA >=2 );
                        } else {
                                $dExists = ($countB-$countA >= 1);
                        }
                        
                        
                        $AOffset = 0;
                        if ( $aExists ) $AOffset++; 
                        
                        
                        if ( (!$aExists or $B[0 + $AOffset]->val($order_col) > $B[0]->val($order_col) )
                                        and
                                 (!$dExists or $B[$countA-1+$AOffset]->val($order_col) < $B[$countB-1]->val($order_col) )
                                        and
                                 ( ($B[$countA-1+$AOffset]->val($order_col) - $B[0+$AOffset]->val($order_col)) >= ($countA - 1) ) ){
                                 
                                
                                 $sortIndex = array();
                                 $i = $B[0+$AOffset]->val($order_col);
                                 foreach ($subset as $record){
                                        $sortIndex[$record->getId()] = $i++;
                                 }
                                 
                                 
                                 $i0 = $AOffset;
                                 $i1 = $countA+$AOffset;
                                 for ( $i = $i0; $i<$i1; $i++ ){
                                        $B[$i]->setValue($order_col, $sortIndex[ $B[$i]->getId() ] );
                                        $res = $B[$i]->save();
                                        if ( PEAR::isError($res) ) echo $res->getMessage();
                                 }
                                 $this->clearCache();
                                 return true;
                        }
                        
                        
                        
                }
                
                $it =& $this->getRelationshipIterator($relationship, 'all');
                $i = 1;
                
                while ( $it->hasNext() ){
                        $rec =& $it->next();
                        //$rec->setValue($order_col, $i++);
                        $orderRecord =& $rec->toRecord($order_table->tablename);
                        $orderRecord->setValue($order_col, $i++);
                        $res = $orderRecord->save();
                        if ( PEAR::isError($res) ) return $res;
                        unset($rec);
                        unset($orderRecord);
                        
                }
                $this->clearCache();
                
        }
        
        // @}
        // End Relationships
        //--------------------------------------------------------------------------------------
        
        // @{
        
        function setValue($key, $value, $index=0){
                
                $oldValue = $this->getValue($key, $index);
                
                
                if ( strpos($key, '.')!== false ){
                        throw new Exception("Unsupported operation: setting value on related record.", E_USER_ERROR);
                
                }
                        
                // This is a local field
                else {
                        if ( strpos($key, "__") === 0 && $this->useMetaData ){
                                /*
                                 * This is a meta value..
                                 */
                                return $this->setMetaDataValue($key, $value);
                        }
                        
                        $add=true;
                        
                         
                        if ( !array_key_exists($key, $this->_table->fields() ) ){
                                
                                if ( array_key_exists($key, $this->_table->transientFields()) ){
                                        
                                        $this->_transientValues[$key] = $value;
                                        $add=false;
                                        //return;
                                }
                        
                                else if ( !array_key_exists($key, $this->_table->graftedFields(false)) ){
                                        $parent =& $this->getParentRecord();
                                        
                                        if ( isset($parent) and $parent->_table->hasField($key) ){
                                                
                                                $parent->setValue($key, $value, $index);
                                
                                        }
                                        $add=false;
                                } else {
                                        
                                        
                                        
                                        $add=true;
                                }
                                
                        } 
                        if ( $add ){
                                $this->_values[$key] = $this->_table->parse($key, $value);
                                
                                $this->_isLoaded[$key] = true;
                        }
                }
                
                
                // now set the flag to indicate that the value has been changed.
                
                $this->clearCache();
                
                if ($oldValue != $this->getValue($key, $index) ){
                        
                        $this->setFlag($key, $index);
                        if ( $this->vetoSecurity ){
                                $this->vetoFields[$key] = true;
                        }
                        $this->clearCache();
                        
                        $this->firePropertyChangeEvent($key, $oldValue, $this->getValue($key,$index));
                        
                        // Now we should notify the parent record if this was a key field
                        if ( array_key_exists($key, $this->_table->keys() ) ){
                                if ( !isset($parent) ) $parent =& $this->getParentRecord();
                                if ( isset($parent) ){
                                        $keys = array_keys($this->_table->keys());
                                        $pkeys = array_keys($parent->_table->keys());
                                        $key_index = array_search($key, $keys);
                                        
                                        $parent->setValue($pkeys[$key_index], $this->getValue($key, $index));
                                }
                        }
                }
                
                
        }
        
        
        
        
        
        function setValues($values){
                $fields = $this->_table->fields(false, true);
                foreach ($values as $key=>$value){
                        if ( isset( $fields[$key] ) ){
                                $this->setValue($key, $value);
                        } else if ( strpos($key,'__')===0){
                                $this->setMetaDataValue($key,$value);
                        }
                }
        }
        
        
        function &getValue($fieldname, $index=0, $where=0, $sort=0, $debug=false){
                static $callcount=0;
                $callcount++;
                if ( $debug ) echo "Num calls to getValue(): $callcount";
                if ( isset($this->cache[__FUNCTION__][$fieldname][$index][$where][$sort]) ){
                        return $this->cache[__FUNCTION__][$fieldname][$index][$where][$sort];
                }
                
                
                
                if ( is_array($index) ){
                        throw new Exception(
                                df_translate(
                                        'scripts.Dataface.Record.getValue.ERROR_PARAMETER_2',
                                        "In Dataface_Record.getValue() expected 2nd parameter to be integer but received array."
                                        ), E_USER_ERROR);
                }
                if ( is_array($where) ){
                        throw new Exception(
                                df_translate(
                                        'scripts.Dataface.Record.getValue.ERROR_PARAMETER_3',
                                        "In Dataface_Record.getValue() expected 3rd parameter to be a string, but received array."
                                        ), E_USER_ERROR);
                }
                if ( is_array($sort) ){
                        throw new Exception(
                                df_translate(
                                        'scripts.Dataface.Record.getValue.ERROR_PARAMETER_4',
                                        "In Dataface_Record.getValue() expected 4th parameter to be a string but received array."
                                        ), E_USER_ERROR);
                }
                
                $out = null;
                if ( strpos($fieldname,'.') === false ){
                        $delegate =& $this->_delegate;
                        
                        if ( !isset( $this->_values[$fieldname] ) ) {
                                // The field is not set... check if there is a calculated field we can use.
                                if ( $delegate !== null and method_exists($delegate, "field__$fieldname")){
                                        $methodname = "field__$fieldname";
                                        $out =& $delegate->$methodname($this,$index);
                                        //$out =& call_user_func( array(&$delegate, "field__$fieldname"), $this, $index);
                                //} else if ( array_key_exists($fieldname, $this->_transientValues) ){
                                } else if ( array_key_exists($fieldname, $this->_table->transientFields()) ){
                                        $transientFields =& $this->_table->transientFields();
                                        if ( array_key_exists( $fieldname, $this->_transientValues) ){
                                                $out = $this->_transientValues[$fieldname];
                                        } else if ( isset($transientFields[$fieldname]['relationship']) and $transientFields[$fieldname]['widget']['type'] == 'grid'){
                                                $out= array();
                                                $rrecords =& $this->getRelatedRecordObjects($transientFields[$fieldname]['relationship'], 'all');
                                                $currRelationship =& $this->_table->getRelationship($transientFields[$fieldname]['relationship']);
                                                $relKeys =& $currRelationship->keys();
                                                //print_r(array_keys($currRelationship->keys()));
                                                foreach ($rrecords as $rrecord){
                                                        $row = $rrecord->strvals();
                                                        
                                                        foreach ( array_keys($row) as $row_field ){
                                                                $ptable =& $rrecord->_relationship->getTable($row_field);
                                                                $precord =& $rrecord->toRecord($ptable->tablename);
                                                                if ( !$precord or PEAR::isError($precord) ) continue;
                                                                $row['__permissions__'][$row_field] = $precord->getPermissions(array('field'=>$row_field));
                                                                if ( isset($relKeys[$row_field]) ) unset($row['__permissions__'][$row_field]['edit']);
                                                                unset($precord);
                                                                unset($ptable);
                                                        }
                                                        $row['__id__'] = $rrecord->getId();
                                                        
                                                        $out[] = $row;
                                                        unset($rrecord);
                                                        unset($row);
                                                }
                                                unset($relKeys);
                                                unset($currRelationship);
                                                unset($rrecords);
                                                $this->_transientValues[$fieldname] = $out;
                                        } else if ( isset($transientFields[$fieldname]['relationship']) and $transientFields[$fieldname]['widget']['type'] == 'checkbox'){
                                                $out= array();
                                                $rrecords =& $this->getRelatedRecordObjects($transientFields[$fieldname]['relationship'], 'all');
                                                $currRelationship =& $this->_table->getRelationship($transientFields[$fieldname]['relationship']);
                                                foreach ($rrecords as $rrecord){
                                                        $row = $rrecord->strvals();
                                                        $domRec = $rrecord->toRecord();
                                                        
                                                        $rowstr = array();
                                                        foreach (array_keys($domRec->_table->keys()) as $relKey){
                                                                $rowStr[] = urlencode($relKey).'='.urlencode($row[$relKey]);
                                                        }
                                                        $out[] = implode('&',$rowStr);
                                                        
                                                        unset($rowStr, $domRec);
                                                        unset($rrecord);
                                                        unset($row);
                                                }
                                                unset($relKeys);
                                                unset($currRelationship);
                                                unset($rrecords);
                                                $this->_transientValues[$fieldname] = $out;
                                        } else {
                                                
                                                if ( isset($delegate) and  method_exists($delegate, $fieldname.'__init') ){
                                                        $methodname = $fieldname.'__init';
                                                        $out = $delegate->$methodname($this);
                                                        if ( isset($out) ){
                                                                $this->_transientValues[$fieldname] = $out;
                                                        }
                                                }
                                                
                                                if ( !isset($out) ){
                                                        $methodname = 'initTransientField';
                                                        $app = Dataface_Application::getInstance();
                                                        $appdel = $app->getDelegate();
                                                        if ( isset($appdel) and method_exists($appdel, $methodname) ){
                                                                $out = $appdel->$methodname($this, $transientFields[$fieldname]);
                                                                if ( isset($out) ){
                                                                        $this->_transientValues[$fieldname] = $out;
                                                                }
                                                        }
                                                        
                                                
                                                }
                                                
                                                if ( !isset($out) ){
                                                        $event = new StdClass;
                                                        $event->record = $this;
                                                        $event->field = $transientFields[$fieldname];
                                                        $out = null;
                                                        
                                                        
                                                        $app = Dataface_Application::getInstance();
                                                        $app->fireEvent('initTransientField', $event);
                                                        
                                                        
                                                        $out = $event->out;
                                                        if ( isset($out) ){
                                                                $this->_transientValues[$fieldname] = $out;
                                                        }
                                                }
                                                        
                                                
                                                
                                                $out = null;
                                        }
                                        
                                } else if ( ( $parent =& $this->getParentRecord() ) and $parent->_table->hasField($fieldname) ){
                                
                                        return $parent->getValue($fieldname,$index,$where,$sort,$debug);
                                } else {
                                        $this->_values[$fieldname] = null;
                                        $out = null;
                                }
                        } else {
                                $out = $this->_values[$fieldname];
                        }
                        if ( isset($out) ){
                                // We only store non-null values in cache.  We were having problems 
                                // with segfaulting in PHP5 when groups are used.
                                // This seems to fix the issue, but let's revisit it later.
                                $this->cache[strval(__FUNCTION__)][strval($fieldname)][$index][$where][$sort] = $out;
                        }
                        return $out;
                } else {
                        list($relationship, $fieldname) = explode('.', $fieldname);
                        
                        $rec =& $this->getRelatedRecords($relationship, false, $index, 1, $where, $sort);
                        $this->cache[__FUNCTION__][$relationship.'.'.$fieldname][$index][$where][$sort] =& $rec[$fieldname];
                        return $rec[$fieldname];
                        
                        
                }
        }
        
        
        
        
        function &value($fieldname, $index=0, $where=0, $sort=0){
                $val =& $this->getValue($fieldname, $index,$where, $sort);
                return $val;
        }
        
        function &val($fieldname, $index=0, $where=0, $sort=0){
                $val =& $this->getValue($fieldname, $index, $where, $sort);
                return $val;
        }
        
        function &getValues($fields = null, $index=0, $where=0, $sort=0){
                if ( !isset( $this->_values ) ) $this->_values = array();
                $values = array();
                $fields = ( $fields === null ) ? array_keys($this->_table->fields(false,true)) : $fields;
                foreach ($fields as $field){
                        $values[$field] =& $this->getValue($field, $index, $where, $sort);
                }
                        
                return $values;
        }
        
        function &values($fields = null, $index=0, $where=0, $sort=0){
                $vals =& $this->getValues($fields, $index, $where, $sort);
                return $vals;
        }
        
        function &vals($fields = null, $index=0, $where=0, $sort=0){
                $vals =& $this->getValues($fields, $index, $where, $sort);
                return $vals;
        }
        
        function getValueAsString($fieldname, $index=0, $where=0, $sort=0){
                //return $this->_table->getValueAsString($fieldname, $this->getValue($fieldname), $index);
                
                $value = $this->getValue($fieldname, $index, $where, $sort);
                
                
                $table =& $this->_table->getTableTableForField($fieldname);
                $delegate =& $table->getDelegate();
                $rel_fieldname = $table->relativeFieldName($fieldname);
                if ( $delegate !== null and method_exists( $delegate, $rel_fieldname.'__toString') ){
                        $methodname = $rel_fieldname.'__toString';
                        $value = $delegate->$methodname($value); //call_user_func( array(&$delegate, $rel_fieldname.'__toString'), $value);
                } else 
                
                
                if ( !is_scalar($value) ){
                        $methodname = $this->_table->getType($fieldname)."_to_string";
                        if ( method_exists( $this->_table, $methodname) ){
                                
                                $value = $this->_table->$methodname($value); //call_user_func( array( &$this->_table, $this->_table->getType($fieldname)."_to_string"), $value );
                        } else {
                                $value = $this->array2string($value);
                                
                        }
                }
                
                else if ( ( $parent =& $this->getParentRecord() ) and $parent->_table->hasField($fieldname) ){
                        return $parent->getValueAsString($fieldname, $index, $where, $sort);
                }
                
                $evt = new stdClass;
                $evt->table = $table;
                $evt->field =& $table->getField($rel_fieldname);
                $evt->value = $value;
                $evt->type = $table->getType($rel_fieldname);
                $table->app->fireEvent('after_getValueAsString', $evt);
                $value = $evt->value;
                
                return $value;
        }
        
        function array2string($value){
                if ( is_string($value) ) return $value;
                if ( is_array($value) ){
                        if ( count($value) > 0 and is_array($value[0]) ){
                                $delim = "\n";
                        } else {
                                $delim = ', ';
                        }
                        return implode($delim, array_map(array(&$this,'array2string'), $value));
                }
                return '';
        }
        
        
        function getValuesAsStrings($fields='', $index=0, $where=0, $sort=0){
                $keys = is_array($fields) ? $fields : array_keys($this->_table->fields(false,true));
                $values = array();
                foreach ($keys as $key){
                        $values[$key] = $this->getValueAsString($key, $index, $where, $sort);
                }
                return $values;
        }
        
        function strvals($fields='', $index=0, $where=0, $sort=0){
                return $this->getValuesAsStrings($fields, $index, $where, $sort);
        }
        
        
        function strval($fieldname, $index=0, $where=0, $sort=0){
                return $this->getValueAsString($fieldname, $index, $where, $sort);
        }
        
        
        function stringValue($fieldname, $index=0, $where=0, $sort=0){
                return $this->getValueAsString($fieldname, $index, $where, $sort);
        }
        
        
        function getSerializedValue($fieldname, $index=0, $where=0, $sort=0){
                $s = $this->_table->getSerializer();
                return $s->serialize($fieldname, $this->getValue($fieldname, 0, $where, $sort));
        
        }
        
        
        function display($fieldname, $index=0, $where=0, $sort=0, $urlencode=false){
                if ( isset($this->cache[__FUNCTION__][$fieldname][$index][$where][$sort]) ){
                        return $this->cache[__FUNCTION__][$fieldname][$index][$where][$sort];
                }
                if ( strpos($fieldname,'.') === false ){
                        // this is not a related field.
                        if ( $this->secureDisplay and !Dataface_PermissionsTool::view($this, array('field'=>$fieldname)) ){
                                $del =& $this->_table->getDelegate();
                                if ( $del and method_exists($del, 'no_access_text') ){
                                        return $del->no_access_text($this, array('field'=>$fieldname));
                                } else {
                                        return 'NO ACCESS';
                                }
                        }
                } else {
                        list($relationship,$fieldname) = explode('.',$fieldname);
                        $rrecord =& $this->getRelatedRecord($relationship,$index,$where,$sort);
                        if ( !$rrecord ) return null;
                        $out = $rrecord->display($fieldname);
                        $this->cache[__FUNCTION__][$fieldname][$index][$where][$sort] = $out;
                        return $out;
                }
                
                
        
                $table =&  $this->_table->getTableTableForField($fieldname);
                
                
                $delegate =& $this->_table->getDelegate();
                if ( $delegate !== null and method_exists( $delegate, $fieldname."__display") ){
                        $methodname = $fieldname."__display";
                        $out = $delegate->$methodname($this);
                        //$out = call_user_func(array(&$delegate, $fieldname."__display"), $this);
                        $this->cache[__FUNCTION__][$fieldname][$index][$where][$sort] = $out;
                        return $out;
                        
                }
                
                $field =& $this->_table->getField($fieldname);
                if ( $this->_table->isBlob($fieldname) or ($this->_table->isContainer($fieldname) and @$field['secure'])  ){
                        
                        unset($table);
                        $table =& Dataface_Table::loadTable($field['tablename']);
                        $keys = array_keys($table->keys());
                        $qstr = '';
                        foreach ($keys as $key){
                                $qstr .= "&$key"."=".$this->strval($key,$index,$where,$sort);
                        }
                        $out = DATAFACE_SITE_HREF."?-action=getBlob&-table=".$field['tablename']."&-field=$fieldname&-index=$index$qstr";
                        $this->cache[__FUNCTION__][$fieldname][$index][$where][$sort] = $out;
                        return $out;
                }
                
                else if ( $this->_table->isContainer($fieldname) ){
                        $field =& $this->_table->getField($fieldname);
                        $strvl=$this->strval($fieldname,$index,$where,$sort);
                        if ($urlencode)
                        {
                            $strvl=rawurlencode($strvl);
                        }
                        $out = $field['url'].'/'.$strvl;
                        if ( strlen($out) > 1 and $out{0} == '/' and $out{1} == '/' ){
                                $out = substr($out,1);
                        }
                        $this->cache[__FUNCTION__][$fieldname][$index][$where][$sort] = $out;
                        return $out;
                }
                
                else { //if ( !$this->_table->isBlob($fieldname) ){
                
                        $field =& $this->_table->getField($fieldname);
                        
                        
                        if ( PEAR::isError($field) ){
                                $field->addUserInfo("Failed to get field '$fieldname' while trying to display its value in Record::display()");
                                return $field;
                                
                                
                        }
                        $vocab = $field['vocabulary'];
                        if ( $vocab ){
                                $valuelist =& $table->getValuelist($vocab);
                        }
                        $value = $this->getValue($fieldname, $index, $where, $sort);
                        if ( PEAR::isError($value) ) return '';
                        if ( isset($valuelist) && !PEAR::isError($valuelist) ){
                                if ( $field['repeat'] and is_array($value) ){
                                        $out = "";
                                        foreach ($value as $value_item){
                                                if ( isset( $valuelist[$value_item] ) ){
                                                        $out .= $valuelist[$value_item].', ';
                                                } else {
                                                        $out .= $value_item.', ';
                                                }
                                        }
                                        if ( strlen($out) > 0 ) $out = substr($out, 0, strlen($out)-2);
                                        $this->cache[__FUNCTION__][$fieldname][$index][$where][$sort] = $out;
                                        return $out;
                                }
                                
                                //else if ( isset( $valuelist[$value]) ){
                                else {
                                        if ( is_array($value) ) $value = $this->strval($fieldname, $index, $where, $sort);
                                        if ( isset($valuelist[$value]) ){
                                                $out = $valuelist[$value];
                                                $this->cache[__FUNCTION__][$fieldname][$index][$where][$sort] = $out;
                                                return $out;
                                        } else {
                                                return $value;
                                        }
                                } 
                        } else {
                                $parent =& $this->getParentRecord();
                                
                                
                                
                                if ( isset($parent) and $parent->_table->hasField($fieldname) ){
                                        
                                        return $parent->display($fieldname, $index, $where, $sort);
                                }
                                $out = $this->getValueAsString($fieldname, $index, $where, $sort);
                                
                                
                                $out = $table->format($fieldname, $out);
                                
                                
                                // Let's pass the value through an event filter to give modules
                                // a crack at the final output.
                                $evt = new stdClass;
                                $evt->record = $this;
                                $evt->field =& $field;
                                $evt->value = $out;
                                $table->app->fireEvent('Record::display', $evt);
                                $out = $evt->value;
                                
                                
                                
                                $this->cache[__FUNCTION__][$fieldname][$index][$where][$sort] = $out;
                                return $out;
                        }
                
                
                        //return $this->_table->display($fieldname, $this->getValue($fieldname, $index));
                } 
                                
                                
        }
        
        
        
        
        function htmlValue($fieldname, $index=0, $where=0, $sort=0,$params=array()){
                $recid = $this->getId();
                $uri = $recid.'#'.$fieldname;
                $domid = $uri.'-'.rand();
                
                
                
                $delegate =& $this->_table->getDelegate();
                if ( isset($delegate) && method_exists($delegate, $fieldname.'__htmlValue') ){
                        $methodname = $fieldname.'__htmlValue';
                        $res = $delegate->$methodname($this);
                        //$res = call_user_func(array(&$delegate, $fieldname.'__htmlValue'), $this);
                        if ( is_string($res) and DATAFACE_USAGE_MODE == 'edit' and $this->checkPermission('edit', array('field'=>$fieldname)) and !$this->_table->isMetaField($fieldname) ){
                                $res = '<span id="'.$domid.'" df:id="'.$uri.'" class="df__editable">'.$res.'</span>';
                        }
                        return $res;
                }
                $parent =& $this->getParentRecord();
                if ( isset($parent) and $parent->_table->hasField($fieldname) ){
                        return $parent->htmlValue($fieldname, $index, $where, $sort, $params);
                }       
                $val = $this->display($fieldname, $index, $where, $sort);
                
                if ( $this->secureDisplay and !Dataface_PermissionsTool::view($this, array('field'=>$fieldname)) ){
                        $del =& $this->_table->getDelegate();
                        if ( $del and method_exists($del, 'no_access_link') ){
                                $link = $del->no_access_link($this, array('field'=>$fieldname));
                                return '<a href="'.htmlspecialchars($link).'">'.$val.'</a>';
                        }
                }
                
                $field = $this->_table->getField($fieldname);
                //if ( $field['widget']['type'] != 'htmlarea' ) $val = htmlentities($val,ENT_COMPAT, 'UTF-8');
                if ( $this->_table->isText($fieldname) and $field['widget']['type'] != 'htmlarea' and $field['contenttype'] != 'text/html' ) $val = nl2br($val);
                
                if ( $this->_table->isBlob($fieldname) or $this->_table->isContainer($fieldname) ){
                        if ( $this->getLength($fieldname, $index,$where,$sort) > 0 ){
                                if ( $this->isImage($fieldname, $index, $where, $sort) ){
                                        $val = '<img src="'.$val.'"';
                                        if ( !isset($params['width']) and isset($field['width']) ){
                                                $params['width'] = $field['width'];
                                        }
                                        foreach ($params as $pkey=>$pval){
                                                $val .= ' '.$pkey.'="'.$pval.'"';
                                        }
                                        $val .= '/>';
                                } else {
                                        $file_icon = df_translate(
                                                $this->getMimetype($fieldname,$index,$where,$sort).' file icon',
                                                df_absolute_url(DATAFACE_URL).'/images/document_icon.gif'
                                                );
                                        $val = '<img src="'.$file_icon.'"/><a href="'.$val.'" target="_blank"';
                                        foreach ($params as $pkey=>$pval){
                                                $val .= ' '.$pkey.'="'.$pval.'"';
                                        }
                                        $val .= '>View Field Content In New Window ('.$this->getMimetype($fieldname, $index,$where,$sort).')</a>';
                                }
                        } else {
                                $val = "(Empty)";
                        }
                }
                if ( is_string($val) and DATAFACE_USAGE_MODE == 'edit' and $this->checkPermission('edit', array('field'=>$fieldname))  and !$this->_table->isMetaField($fieldname)){
                        $val = '<span id="'.$domid.'" df:id="'.$uri.'" class="df__editable">'.$val.'</span>';
                }
                return $val;
                
        
        
        }
        
        
        function preview($fieldname, $index=0, $maxlength=255, $where=0, $sort=0){
        
                $strval = strip_tags($this->display($fieldname,$index, $where, $sort));
                $out = substr($strval, 0, $maxlength);
                if ( strlen($strval)>$maxlength) {
                        $out .= '...';
                }        
                return $out;
                
        }
        
        function printValue($fieldname, $index=0, $where=0, $sort=0 ){
                return $this->display($fieldname, $index, $where, $sort);
        }
        
        function printval($fieldname, $index=0, $where=0, $sort=0){
                return $this->display($fieldname, $index, $where, $sort);
        }
        
        function q($fieldname, $index=0, $where=0, $sort=0){
                return $this->display($fieldname, $index, $where, $sort);
        }
        
        function qq($fieldname, $index=0, $where=0, $sort=0){
                return $this->htmlValue($fieldname, $index, $where, $sort);
        }
        
        function hasValue($fieldname){
                return (isset( $this->_values) and array_key_exists($fieldname, $this->_values) );
        }
        
        
        function getAbsoluteValues(){
                $values = $this->getValues();
                $absValues = array();
                foreach ( $values as $key=>$value){
                        $absValues[$this->_table->tablename.".".$key] = $value;
                }
                return $absValues;
        }
        
        
        
        function getContainerSource($fieldname){
                $filename =& $this->strval($fieldname);
                if ( strlen($filename)===0 ){
                        return null;
                }
                $field =& $this->_table->getField($fieldname);
                return $field['savepath'].'/'.$filename;
        
        }

        
        function setMetaDataValue($key, $value){
                if ( !isset( $this->_metaDataValues ) ) $this->_metaDataValues = array();
                $this->_metaDataValues[$key] = $value;
                $parent =& $this->getParentRecord();
                if ( isset($parent) ){
                        $parent->setMetaDataValue($key, $value);
                }
        }
        
        
        
        
        
        
        
        function clearValues(){
                $this->_values = array();
                $this->_relatedValues = array();
                $this->_valCache = array();
                
                $this->clearFlags();
                
                $parent =& $this->getParentRecord();
                if ( isset($parent) ){
                        $parent->clearValues();
                }
        
        }
        
        function clearValue($field){
                
                unset($this->_values[$field]);
                $this->clearFlag($field);
                
                $parent =& $this->getParentRecord();
                if ( isset($parent) ){
                        $parent->clearValue();
                }
        }
        
        
        
        // @}
        // End Field Values Methods
        //-------------------------------------------------------------------------------
        
        
        // @{
        function addPropertyChangeListener($key, &$listener){
                $this->propertyChangeListeners[$key][] = &$listener;
        }
        
        function removePropertyChangeListener($key, &$listener){
                if ( !isset($key) ) $key = '*';
                if ( !isset($callback) ) unset($this->propertyChangeListeners[$key]);
                else if ( isset($this->propertyChangeListeners[$key]) ){
                        if ( ($index = array_search($listener,$this->propertyChangeListeners[$key])) !== false){
                                unset($this->propertyChangeListeners[$key][$index]);
                        }
                }
        }
        
        function firePropertyChangeEvent($key, $oldValue, $newValue){
                $origKey = $key;
                $keys = array('*');
                if ( isset($key) ) $keys[] = $key;
                foreach ($keys as $key){
                        if ( !isset($this->propertyChangeListeners[$key] ) ) continue;
                        foreach ( array_keys($this->propertyChangeListeners[$key]) as $lkey){
                                $this->propertyChangeListeners[$key][$lkey]->propertyChanged($this,$origKey, $oldValue, $newValue);
                                
                        }
                }
                
                
        }
        
        function propertyChanged(&$source, $key, $oldValue, $newValue){
                $parentRecord =& $this->getParentRecord();
                if ( is_a($source, 'Dataface_Record') and is_a($parentRecord, 'Dataface_Record') and $source->_id === $parentRecord->_id ){
                        $pkeys = $source->_table->keys();
                        $pkey_names = array_keys($pkeys);
                        $okeys = $this->_table->keys();
                        $okey_names = array_keys($okeys);
                        
                        if ( !array_key_exists($key, $pkeys) ) return false;
                                // The field that was changed was not a key so we don't care
                                
                        $key_index = array_search($key, $pkey_names);
                        if ( $key_index === false ) throw new Exception("An error occurred trying to find the index of the parent's key.  This is a code error that should be fixded by the developer.", E_USER_ERROR);
                        
                        
                        if ( !isset($okey_names[$key_index]) )
                                throw new Exception("Attempt to keep the current record in sync with its parent but they seem to have a different number of primary keys.  To use Dataface inheritance, tables must have a corresponding primary key.", E_USER_ERROR);
                        
                        
                        $this->setValue( $okey_names[$key_index], $newValue);
                }
        }
        
        
        
        
        // @}
        // END Property Change Events
        //-------------------------------------------------------------------------------------
        
        // @{
        function getJoinRecord($tablename, $nullIfNotFound=false){
                $table =& Dataface_Table::loadTable($tablename);
                $query = $this->getJoinKeys($tablename);
                foreach ( $query as $key=>$val ){
                        $query[$key] = '='.$val;
                }
                
                $record = df_get_record($tablename, $query);
                if ( !$record ){
                        if ( $nullIfNotFound ) return null;
                        // No record was found, so we create a new one.
                        $record = new Dataface_Record($tablename, array());
                        foreach ( $query as $key=>$value){
                                $record->setValue($key, substr($value,1));
                        }
                }
                return $record;
                
        }
        
        
        function getJoinKeys($tablename){
                $table =& Dataface_Table::loadTable($tablename);
                $query = array();
                
                $pkeys1 = array_keys($this->_table->keys());
                $pkeys2 = array_keys($table->keys());
                
                if ( count($pkeys1) != count($pkeys2) ){
                        return PEAR::raiseError("Attempt to get join record [".$this->_table->tablename."] -> [".$table->tablename."] but they have a different number of columns as primary key.");
                }
                
                for ($i =0; $i<count($pkeys1); $i++ ){
                        $query[$pkeys2[$i]] = $this->strval($pkeys1[$i]);
                }
                
                return $query;
        
        }
        
        function tabs(){
                return $this->_table->tabs($this);
        }
        
        // @}
        // END TAB Management
        
        
        //---------------------------------------------------------------------------
        // @{
        function getRoles($params=array()){
                return $this->_table->getRoles($this, $params);
                
        }
        
        function getRolePermissions($params=array()){
                return $this->_table->getRolePermissions($this, $params);
        }
        
        
        function getPermissions($params=array()){
                $params['record'] =& $this;
                return $this->_table->getPermissions($params);
        }
        
        function checkPermission($perm, $params=array()){
                $perms = $this->getPermissions($params);
                return ( isset($perms[$perm]) and $perms[$perm] );
        }
        
        
        
        // @}
        // END Permissions
        //----------------------------------------------------------------------------------
        
        function validate( $fieldname, $value, &$params){
                //if ( func_num_args() > 2 ){
                //      $params =& func_get_arg(2);
                //}
                //else {
                //      $params = array();
                //}
                
                if ( !is_array($params) ){
                        $params = array('message'=> &$params);
                }
                $res = $this->_table->validate($fieldname, $value, $params);
                
                $field =& $this->_table->getField($fieldname);
                
                if ( $field['widget']['type'] == 'file' and @$field['validators']['required'] and is_array($value) and $this->getLength($fieldname) == 0 and !is_uploaded_file(@$value['tmp_name'])){
                                // This bit of validation operates on the upload values assuming the file was just uploaded as a form.  It assumes
                                // that $value is of the form
                                $params['message'] = "$fieldname is a required field.";
                                $params['message_i18n_id'] = "Field is a required field";
                                $params['message_i18n_params'] = array('field'=>$fieldname);
                                return false;
                }
                if ( $res ){
                        $delegate =& $this->_table->getDelegate();
                        if ( $delegate !== null and method_exists($delegate, $fieldname."__validate") ){
                                /*
                                 *
                                 * The delegate defines a custom validation method for this field.  Use it.
                                 *
                                 */
                                $methodname = $fieldname."__validate";
                                $res = $delegate->$methodname($this,$value,$params);
                                //$res = call_user_func(array(&$delegate, $fieldname."__validate"), $this, $value, $params);
                        }
                        
                        
                }
                
                if ($res){
                        $parent =& $this->getParentRecord();
                        if ( isset($parent) and $parent->_table->hasField($fieldname) ){
                                $res = $parent->validate($fieldname, $value, $params);
                        }
                }
                
                return $res;
                
                
        }
        

        function &getParentRecord(){
                if ( !isset($this->_parentRecord) ){
                        $parent =& $this->_table->getParent();
                        if ( isset($parent) ){
                                $this->_parentRecord = new Dataface_Record($parent->tablename, array());
                                foreach ( array_keys($parent->keys()) as $key ){
                                        $this->_parentRecord->addPropertyChangeListener( $key, $this);
                                }
                        }       
                }
                return $this->_parentRecord;
        
        }
        
        
        //------------------------------------------------------------------------------------
        // @{ 
        function setSnapshot(){
                 
                $this->clearFlags();
                if ( isset($this->_values) ){
                        // If there are no values, then we don't need to set the snapshot
                        $this->_oldValues = $this->getValues();
                }
                $parent =& $this->getParentRecord();
                if ( isset($parent) ){
                        $parent->setSnapshot();
                }
                
                return $this;
                
        }
        
        function snapshotExists(){
                return (is_array($this->_oldValues) and count($this->_oldValues) > 0);
        }
        
        function clearSnapshot(){
                $this->_oldValues = null;
                $parent =& $this->getParentRecord();
                if ( isset($parent) ){
                        $parent->clearSnapshot();
                }
                return $this;
        }
        
        function &getSnapshot($fields=''){
                if ( is_array($fields) ){
                        $out = array();
                        foreach ($fields as $field){
                                if ( isset( $this->_oldValues[$field] ) ){
                                        $out[$field] = $this->_oldValues[$field];
                                }
                        }
                        
                        return $out;
                } else {
                        return $this->_oldValues;
                }
        }
        
        function snapshotKeys(){
                return $this->getSnapshot(array_keys($this->_table->keys()));
        }
        
        function valueChanged($fieldname, $index=0, $checkParent=false){
                if ( strpos($fieldname, '.') !== false ){
                        // This is a related field, so we have to check the relationship for dirty flags
                        $path = explode('.', $fieldname);
                        
                        if ( is_array($index) ){
                                $index = $this->getRelatedIndex($index);
                        }
                        
                        return (isset( $this->_relatedDirtyFlags[$path[0]]) and 
                                        isset( $this->_relatedDirtyFlags[$path[0]][$path[1]]) and 
                                        $this->_relatedDirtyFlags[$path[0]][$path[1]] === true );
                } else {
                        // this is a local related field... just check the local dirty flags array.
                        if ( $checkParent ){
                                $parent =& $this->getParentRecord();
                                if ( isset($parent) and $parent->_table->hasField($fieldname) ){
                                        return $parent->valueChanged($fieldname, $index);
                                }
                        }
                        return (@$this->_dirtyFlags[$fieldname]);
                }
        }
        
        
        function recordChanged($checkParent=false){
                if ($checkParent){
                        $parent =& $this->getParentRecord();
                        if ( isset($parent) ){
                                $res = $parent->recordChanged();
                                if ( $res ) return true;
                        }
                }
                
                $fields =& $this->_table->fields();
                foreach ( array_keys( $fields) as $fieldname){
                        if ( $this->valueChanged($fieldname) ) return true;
                }
                return false;
        }
        
        
        
        function clearFlags(){
                $keys = array_keys($this->_dirtyFlags);
                foreach ( $keys as $i) {
                        $this->_dirtyFlags[$i] = false;
                        $this->vetoFields[$i] = false;
                }
                foreach (array_keys($this->_relatedDirtyFlags) as $rel_name){
                        foreach ( array_keys($this->_relatedDirtyFlags[$rel_name]) as $field_name){
                                $this->_relatedDirtyFlags[$rel_name][$field_name] = false;
                        }
                }
                
                // Clear the snapshot of old values.
                $this->clearSnapshot();
                
                $parent =& $this->getParentRecord();
                if ( isset($parent) ){
                        $parent->clearFlags();
                }
                return $this;
                
        }
        
        function clearFlag($name){
                if ( strpos($name, '.') !== false ){
                        // This is a related field.  We store dirty flags in the relationship array.
                        $path = explode('.', $name);
                        
                        if ( !isset($this->_relatedDirtyFlags[$path[0]]) ){
                                return;
                        }
                        if ( !isset($this->_relatedDirtyFlags[$path[0]][$path[1]]) ){
                                return;
                        }
                        $this->_relatedDirtyFlags[$path[0]][$path[1]] = false;
                } else {
                        
                        $this->_dirtyFlags[$name] = false;
                        $this->vetoFields[$name] = false;
                        $parent =& $this->getParentRecord();
                        if ( isset($parent) and $parent->_table->hasField($name) ){
                                $parent->clearFlag($name);
                        }
                }
                
                return $this;
        }
                
        
        function setFlag($fieldname, $index=0){
                if ( strpos($fieldname, '.') !== false ){
                        // This is a related field.  We store dirty flags in the relationship array.
                        $path = explode('.', $fieldname);
                        
                        
                        if ( !isset($this->_relatedDirtyFlags[$path[0]]) ){
                                $this->_relatedDirtyFlags[$path[0]] = array();
                        }
                        $this->_relatedDirtyFlags[$path[0]][$path[1]] = true;
                } else {
                        // This is a local field
                        $this->_dirtyFlags[$fieldname] = true;
                        $parent =& $this->getParentRecord();
                        if ( isset($parent) and $parent->_table->hasField($fieldname)){
                                $parent->setFlag($fieldname, $index);
                        }
                }
        }
        
        
        function isLoaded($fieldname){
                $parent =& $this->getParentRecord();
                if ( isset($parent) and $parent->_table->hasField($fieldname) ){
                        return $parent->isLoaded($fieldname);
                }
                return ( isset( $this->_isLoaded[$fieldname] ) and $this->_isLoaded[$fieldname]);
        }
        
        
        // @}
        // END OF TRANSACTIONS 
        //-----------------------------------------------------------------------------------------
                
        function getLink($fieldname){
                
                $field =& $this->_table->getField($fieldname);
                if ( PEAR::isError($field) ){
                        return null;
                }
                $table =& Dataface_Table::loadTable($field['tablename']);
                $delegate =& $table->getDelegate();
                if ( !$table->hasField($fieldname) ) return null;
                
                
                
                // Case 1: Delegate is defined -- we use the delegate's link
                if ( method_exists($delegate, $fieldname."__link") ){
                        $methodname = $fieldname."__link";
                        $link = $delegate->$methodname($this);
                        //$link = call_user_func(array(&$delegate, $fieldname."__link"), $this);
                        
                
                // Case 2: The link was specified in an ini file.
                } else if ( isset($field['link']) ){
                        
                        $link = $field['link'];
                        
                // Case 3: The link was not specified
                } else {
                        
                        $link = null;
                }
                
                
                if ( is_array($link) ){
                        foreach ( array_keys($link) as $key){
                                $link[$key] = $this->parseString($link[$key]);
                        }
                        
                        
                        return $link;
                        
                } else if ( $link  ){
                        return $this->parseString($link);
                } else {
                        
                        return null;
                }
        
        }
        
        //-----------------------------------------------------------------------------------
        // @{
        function _getSubfield(&$fieldval, $path){
                if ( !is_array($fieldval) ){
                        return PEAR::raiseError("_getSubfield() expects its first parameter to be an array.");
                }
                $path = explode(":",$path);
                $temp1 =& $fieldval[array_shift($path)];
                $temp2 =& $temp1;
                while ( sizeof($path) > 0 ){
                        unset($temp1);
                        $temp1 =& $temp2[array_shift($path)];
                        unset($temp2);
                        $temp2 =& $temp1;
                }
                return $temp2;
        }
        
        function getTitle($dontGuess=false){
                if ( !isset($this->_title) ){
                        $delegate =& $this->_table->getDelegate();
                        $title = null;
                        if ( $delegate !== null and method_exists($delegate, 'getTitle') ){
                                
                                $title = $delegate->getTitle($this);
                        } else {
                        
                                $parent =& $this->getParentRecord();
                                if ( isset($parent) ){
                                        $title = $parent->getTitle(true);
                                }
                        }
                        
                        if ( $dontGuess ){
                                if ( isset($title) ) $this->_title = $title;
                                return $title;
                        }
                        
                        if ( !isset($title) ){  
                                $fields =& $this->_table->fields();
                                $found_title = false; // flag to specify that a specific title field has been found
                                                                          // declared by the 'title' flag in the fields.ini file.
                                                                          
                                foreach (array_keys($fields) as $field_name){
                                        if ( isset($fields[$field_name]['title']) ){
                                                $title = $this->display($field_name);
                                                $found_title = true;
                                        }
                                        else if ( !isset($title) and $this->_table->isChar($field_name) ){
                                                $title = $this->display($field_name );
                                        }
                                        if ( $found_title) break;
                                }
                                
                                if ( !isset( $title) ){
                                        $title = "Untitled ".$this->_table->getLabel()." Record";
                                }
                                
                        }
                        $this->_title = $title;
                }
                
                return $this->_title;
                
        
        }
        
        
        
        function getDescription(){
                if ( ($res = $this->callDelegateFunction('getDescription')) !== null ){
                        return $res;
                } else if ( $descriptionField = $this->_table->getDescriptionField() ){
                        return $this->htmlValue($descriptionField);
                } else {
                        return '';
                }
        
        }
        
        function getCreated(){
                if ( $res = $this->callDelegateFunction('getCreated') ){
                        return $res;
                } else if ( $createdField = $this->_table->getCreatedField() ){
                        if ( strcasecmp($this->_table->getType($createdField),'timestamp') === 0 ){
                                $date = $this->val($createdField);
                                return strtotime($date['year'].'-'.$date['month'].'-'.$date['day'].' '.$date['hours'].':'.$date['minutes'].':'.$date['seconds']);
                                
                        }
                        return strtotime($this->display($createdField));
                } else {
                        return '';
                }
        }
        
        function getCreator(){
                if ( ($res = $this->callDelegateFunction('getCreator',-1)) !== -1 ){
                        return $res;
                } else if ( $creatorField = $this->_table->getCreatorField() ){
                        return $this->display($creatorField);
                } else {
                        return '';
                }
        }
        
        
        function getLastModified(){
                if ( $res = $this->callDelegateFunction('getLastModified') ){
                        return $res;
                } else if ( $lastModifiedField = $this->_table->getLastUpdatedField() ){
                        if ( strcasecmp($this->_table->getType($lastModifiedField),'timestamp') === 0 ){
                                $date = $this->val($lastModifiedField);
                                return strtotime($date['year'].'-'.$date['month'].'-'.$date['day'].' '.$date['hours'].':'.$date['minutes'].':'.$date['seconds']);
                                
                        }
                        $strtime = $this->strval($lastModifiedField);
                        if ( $strtime){
                                return strtotime($strtime);
                        } else {
                                return 0;
                        }
                } else {
                        return 0;
                }
        }
        
        function getBody(){
                if ( $res = $this->callDelegateFunction('getBody') ){
                        return $res;
                } else if ( $bodyField = $this->_table->getBodyField() ){
                        return $this->htmlValue($bodyField);
                } else {
                        return '';
                }
        }
        
        function getPublicLink($params=null){
                if ( $res = $this->callDelegateFunction('getPublicLink') ){
                        return $res;
                } else {
                        return $this->getURL($params);
                }
        
        }
        
        
        function getBreadCrumbs(){
                $delegate =& $this->_table->getDelegate();
                if ( $delegate !== null and method_exists($delegate, 'getBreadCrumbs') ){
                        return $delegate->getBreadCrumbs($this);
                }
                
                
                if ( ( $parent = $this->getParent() ) !== null ){
                        $bc = $parent->getBreadCrumbs();
                        $bc[$this->getTitle()] = $this->getURL( array('-action'=>'browse'));
                        return $bc;
                }
                
                
                return array(
                        $this->_table->getLabel() => Dataface_LinkTool::buildLink(array('-action'=>'list', '-table'=>$this->_table->tablename)), 
                        $this->getTitle() => $this->getURL(array('-action'=>'browse'))
                        );
        }
        
        function getURL($params=array()){
                if ( is_string($params) ){
                        $pairs = explode('&',$params);
                        $params = array();
                        foreach ( $pairs as $pair ){
                                list($key,$value) = explode('=', $pair);
                                $params[$key] = $value;
                        }
                }
                if ( $this->secureDisplay and !$this->checkPermission('link') ){
                        $del =& $this->_table->getDelegate();
                        if ( $del and method_exists($del, 'no_access_link')){
                                return $del->no_access_link($this, $params);
                        } 
                }
                
                $params['-table'] = $this->_table->tablename;
                if ( !isset($params['-action']) ) $params['-action'] = 'browse';
                foreach (array_keys($this->_table->keys()) as $key){
                        $params[$key] = '='.$this->strval($key);
                }
                
                $delegate =& $this->_table->getDelegate();
                if ( isset($delegate) and method_exists($delegate, 'getURL') ){
                        $res = $delegate->getURL($this, $params);
                        if ( $res and is_string($res) ) return $res;
                }
                
                import('Dataface/LinkTool.php');
                //$linkTool =& Dataface_LinkTool::getInstance();
        
                return Dataface_LinkTool::buildLink($params ,false);
        }
        
        
        function getId(){
                $keys = array_keys($this->_table->keys());
                $params=array();
                foreach ($keys as $key){
                        $params[] = urlencode($key).'='.urlencode($this->strval($key));
                }
                return $this->_table->tablename.'?'.implode('&',$params);
        }
        
        
        // @}
        // END Record Metadata
        //--------------------------------------------------------------------------------------
        
        
        // @{
        function getMimetype($fieldname,$index=0,$where=0,$sort=0){
                $field =& $this->_table->getField($fieldname);
                if ( isset($field['mimetype'])  and strlen($field['mimetype']) > 0 ){
                        return $this->getValue($field['mimetype'], $index,$where,$sort);
                }
                
                if ( $this->_table->isContainer($fieldname) ){
                        $filename = $this->strval($fieldname,$index,$where,$sort);
                        if ( strlen($filename) > 0 ){
                                $path = $field['savepath'].'/'.$filename;
                                $mimetype='';
                                //if(!extension_loaded('fileinfo')) {
                                //      @dl('fileinfo.' . PHP_SHLIB_SUFFIX);
                                //}
                                if(extension_loaded('fileinfo')) {
                                        $res = finfo_open(FILEINFO_MIME); /* return mime type ala mimetype extension */
                                        $mimetype = finfo_file($res, $path);
                                } else if (function_exists('mime_content_type')) {
                                        
                                
                                        $mimetype = mime_content_type($path);
                                        
                                }
                                
                                
                                return $mimetype;
                        }
                }
                return '';
                
        }
         
        function isImage($fieldname, $index=0, $where=0, $sort=0){
                return preg_match('/^image/', $this->getMimetype($fieldname,$index,$where,$sort));
        
        }
         
         
        function getLength($fieldname, $index=0, $where=0, $sort=0){
                if ( strpos($fieldname, '.') !== false ){
                        
                        list($relname, $localfieldname) = explode('.',$fieldname);
                        $record =& $this->getRelatedRecords($relname, false, $index, null, $where, $sort);
                        $relatedRecord = new Dataface_RelatedRecord($this, $relname,$record);
                        $relatedRecord->setValues($this->_relatedMetaValues[$relname][0][0][$index]);
                        return $relatedRecord->getLength($localfieldname);
                        //$key = '__'.$localfieldname.'_length';
                        //if ( isset($record[$key]) ){
                        //      return $record[$key];
                        //} else {
                        //      return null;
                        //}
                } else {
                        $key = '__'.$fieldname.'_length';
                        if ( isset($this->_metaDataValues[$key] ) ){
                                return $this->_metaDataValues[$key];
                        } else {
                                return strlen($this->getValueAsString($fieldname));
                        }
                }
                
        }
         
         
         
         // @}
         // END Field Metadata
         //--------------------------------------------------------------------------------------
        
        
        
        
        //-------------------------------------------------------------------------------------
        // @{
        function save($lang=null, $secure=false){
                if ( !isset($lang) ) $lang = $this->lang;
                return df_save_record($this, $this->strvals(array_keys($this->_table->keys())), $lang, $secure);
        }
        
        function delete($secure=false){
                import('Dataface/IO.php');
                $io = new Dataface_IO($this->_table->tablename);
                return $io->delete($this, $secure);
                
        }
        
        
        // @}
        // END IO Methods
        //---------------------------------------------------------------------------------------
        
        function toJS($fields=null){
                $strvals = $this->strvals($fields);
                $out = array();
                foreach ( $strvals as $key=>$val){
                        if ( $this->checkPermission('view', array('field'=>$key)) ){
                                $out[$key] = $val;
                                
                        }
                }
                $out['__title__'] = $this->getTitle();
                //$out[] = "'__title__': '".addslashes($this->getTitle())."'";
                $out['__url__'] = $this->getURL();
                //$out[] = "'__url__': '".addslashes($this->getURL())."'";
                $out['__expandable'] = ($this->checkPermission('expandable')?1:0);
                //$out[] = "'__expandable__': ".($this->checkPermission('expandable')?1:0);
                
                return json_encode($out);
                //return '{'.implode(',',$out).'}';
                
        }

        
        
        
        
        
}

class Dataface_RecordIterator {

        var $_records;
        var $_keys;
        var $_tablename;
        function Dataface_RecordIterator($tablename, &$records){
                $this->_records =& $records;
                $this->_keys = array_keys($records);
                $this->_tablename = $tablename;
                $this->reset();
        }
        
        function &next(){
                $out = new Dataface_Record($this->_tablename, $this->_records[current($this->_keys)]);
                next($this->_keys);
                return $out;
        }
        
        function &current(){
                return new Dataface_Record($this->_tablename, $this->_records[current($this->_keys)]);
        }
        
        function reset(){
                return reset($this->_keys);
        }
        
        function hasNext(){
                
                return (current($this->_keys) !== false);
        }
        
}


class Dataface_RelationshipIterator{
        var $_record;
        var $_relationshipName;
        var $_records;
        var $_keys;
        var $_where;
        var $_sort;
        function Dataface_RelationshipIterator(&$record, $relationshipName, $start=null, $limit=null, $where=0, $sort=0){
                $this->_record =& $record;
                $this->_relationshipName = $relationshipName;
                $this->_where = $where;
                $this->_sort = $sort;
                if ( $start !== 'all' ){
                
                        $this->_records =& $record->getRelatedRecords($relationshipName, true, $start, $limit, $where, $sort);
                } else {
                        $this->_records =& $record->getRelatedRecords($relationshipName, 'all',$where, $sort);
                }
                if ( is_array($this->_records) ){
                        $this->_keys = array_keys($this->_records);
                } else {
                        $this->_keys = array();
                }
        }
        
        function &next(){
                $out =& $this->current();
                next($this->_keys);
                return $out;
        }
        
        function &current(){
                $rec = new Dataface_RelatedRecord($this->_record, $this->_relationshipName, $this->_records[current($this->_keys)]);
                $rec->setValues($this->_record->_relatedMetaValues[$this->_relationshipName][$this->_where][$this->_sort][current($this->_keys)]);
                return $rec;
        }
        
        function reset(){
                return reset($this->_keys);
        }
        
        function hasNext(){
                return (current($this->_keys) !== false);
        }
}